/test/mjsunit/asm/embenchen/lua_binarytrees.js

http://v8.googlecode.com/ · JavaScript · 42714 lines · 40862 code · 841 blank · 1011 comment · 10734 complexity · 4bf4fb04b77a8edbd76184a5ed3432a9 MD5 · raw file 

    

  1. // Copyright 2014 the V8 project authors. All rights reserved.
    2. 

  2. // Use of this source code is governed by a BSD-style license that can be
    3. 

  3. // found in the LICENSE file.
    4. 

  4. 

  5. var EXPECTED_OUTPUT =
    6. 

  6.   'stretch tree of depth 10\t check: -1\n' +
    7. 

  7.   '1448\t trees of depth 4\t check: -1448\n' +
    8. 

  8.   '362\t trees of depth 6\t check: -362\n' +
    9. 

  9.   '90\t trees of depth 8\t check: -90\n' +
    10. 

  10.   'long lived tree of depth 9\t check: -1\n';
    11. 

  11. var Module = {
    12. 

  12.   arguments: [1],
    13. 

  13.   print: function(x) {Module.printBuffer += x + '\n';},
    14. 

  14.   preRun: [function() {Module.printBuffer = ''}],
    15. 

  15.   postRun: [function() {
    16. 

  16.     assertEquals(EXPECTED_OUTPUT, Module.printBuffer);
    17. 

  17.   }],
    18. 

  18. };
    19. 

  19. 

  20. var Module;
    21. 

  21. if (typeof Module === 'undefined') Module = eval('(function() { try { return Module || {} } catch(e) { return {} } })()');
    22. 

  22. if (!Module.expectedDataFileDownloads) {
    23. 

  23.   Module.expectedDataFileDownloads = 0;
    24. 

  24.   Module.finishedDataFileDownloads = 0;
    25. 

  25. }
    26. 

  26. Module.expectedDataFileDownloads++;
    27. 

  27. (function() {
    28. 

  28. 

  29.   function runWithFS() {
    30. 

  30. 

  31. function assert(check, msg) {
    32. 

  32.   if (!check) throw msg + new Error().stack;
    33. 

  33. }
    34. 

  34. Module['FS_createDataFile']('/', 'binarytrees.lua', [45, 45, 32, 84, 104, 101, 32, 67, 111, 109, 112, 117, 116, 101, 114, 32, 76, 97, 110, 103, 117, 97, 103, 101, 32, 66, 101, 110, 99, 104, 109, 97, 114, 107, 115, 32, 71, 97, 109, 101, 10, 45, 45, 32, 104, 116, 116, 112, 58, 47, 47, 98, 101, 110, 99, 104, 109, 97, 114, 107, 115, 103, 97, 109, 101, 46, 97, 108, 105, 111, 116, 104, 46, 100, 101, 98, 105, 97, 110, 46, 111, 114, 103, 47, 10, 45, 45, 32, 99, 111, 110, 116, 114, 105, 98, 117, 116, 101, 100, 32, 98, 121, 32, 77, 105, 107, 101, 32, 80, 97, 108, 108, 10, 10, 108, 111, 99, 97, 108, 32, 102, 117, 110, 99, 116, 105, 111, 110, 32, 66, 111, 116, 116, 111, 109, 85, 112, 84, 114, 101, 101, 40, 105, 116, 101, 109, 44, 32, 100, 101, 112, 116, 104, 41, 10, 32, 32, 105, 102, 32, 100, 101, 112, 116, 104, 32, 62, 32, 48, 32, 116, 104, 101, 110, 10, 32, 32, 32, 32, 108, 111, 99, 97, 108, 32, 105, 32, 61, 32, 105, 116, 101, 109, 32, 43, 32, 105, 116, 101, 109, 10, 32, 32, 32, 32, 100, 101, 112, 116, 104, 32, 61, 32, 100, 101, 112, 116, 104, 32, 45, 32, 49, 10, 32, 32, 32, 32, 108, 111, 99, 97, 108, 32, 108, 101, 102, 116, 44, 32, 114, 105, 103, 104, 116, 32, 61, 32, 66, 111, 116, 116, 111, 109, 85, 112, 84, 114, 101, 101, 40, 105, 45, 49, 44, 32, 100, 101, 112, 116, 104, 41, 44, 32, 66, 111, 116, 116, 111, 109, 85, 112, 84, 114, 101, 101, 40, 105, 44, 32, 100, 101, 112, 116, 104, 41, 10, 32, 32, 32, 32, 114, 101, 116, 117, 114, 110, 32, 123, 32, 105, 116, 101, 109, 44, 32, 108, 101, 102, 116, 44, 32, 114, 105, 103, 104, 116, 32, 125, 10, 32, 32, 101, 108, 115, 101, 10, 32, 32, 32, 32, 114, 101, 116, 117, 114, 110, 32, 123, 32, 105, 116, 101, 109, 32, 125, 10, 32, 32, 101, 110, 100, 10, 101, 110, 100, 10, 10, 108, 111, 99, 97, 108, 32, 102, 117, 110, 99, 116, 105, 111, 110, 32, 73, 116, 101, 109, 67, 104, 101, 99, 107, 40, 116, 114, 101, 101, 41, 10, 32, 32, 105, 102, 32, 116, 114, 101, 101, 91, 50, 93, 32, 116, 104, 101, 110, 10, 32, 32, 32, 32, 114, 101, 116, 117, 114, 110, 32, 116, 114, 101, 101, 91, 49, 93, 32, 43, 32, 73, 116, 101, 109, 67, 104, 101, 99, 107, 40, 116, 114, 101, 101, 91, 50, 93, 41, 32, 45, 32, 73, 116, 101, 109, 67, 104, 101, 99, 107, 40, 116, 114, 101, 101, 91, 51, 93, 41, 10, 32, 32, 101, 108, 115, 101, 10, 32, 32, 32, 32, 114, 101, 116, 117, 114, 110, 32, 116, 114, 101, 101, 91, 49, 93, 10, 32, 32, 101, 110, 100, 10, 101, 110, 100, 10, 10, 108, 111, 99, 97, 108, 32, 78, 32, 61, 32, 116, 111, 110, 117, 109, 98, 101, 114, 40, 97, 114, 103, 32, 97, 110, 100, 32, 97, 114, 103, 91, 49, 93, 41, 32, 111, 114, 32, 52, 10, 10, 105, 102, 32, 78, 32, 61, 61, 32, 48, 32, 116, 104, 101, 110, 10, 32, 32, 78, 32, 61, 32, 48, 10, 101, 108, 115, 101, 105, 102, 32, 78, 32, 61, 61, 32, 49, 32, 116, 104, 101, 110, 10, 32, 32, 78, 32, 61, 32, 57, 46, 53, 10, 101, 108, 115, 101, 105, 102, 32, 78, 32, 61, 61, 32, 50, 32, 116, 104, 101, 110, 10, 32, 32, 78, 32, 61, 32, 49, 49, 46, 57, 57, 10, 101, 108, 115, 101, 105, 102, 32, 78, 32, 61, 61, 32, 51, 32, 116, 104, 101, 110, 10, 32, 32, 78, 32, 61, 32, 49, 50, 46, 56, 53, 10, 101, 108, 115, 101, 105, 102, 32, 78, 32, 61, 61, 32, 52, 32, 116, 104, 101, 110, 10, 32, 32, 78, 32, 61, 32, 49, 52, 46, 55, 50, 10, 101, 108, 115, 101, 105, 102, 32, 78, 32, 61, 61, 32, 53, 32, 116, 104, 101, 110, 10, 32, 32, 78, 32, 61, 32, 49, 53, 46, 56, 50, 10, 101, 110, 100, 10, 10, 108, 111, 99, 97, 108, 32, 109, 105, 110, 100, 101, 112, 116, 104, 32, 61, 32, 52, 10, 108, 111, 99, 97, 108, 32, 109, 97, 120, 100, 101, 112, 116, 104, 32, 61, 32, 109, 105, 110, 100, 101, 112, 116, 104, 32, 43, 32, 50, 10, 105, 102, 32, 109, 97, 120, 100, 101, 112, 116, 104, 32, 60, 32, 78, 32, 116, 104, 101, 110, 32, 109, 97, 120, 100, 101, 112, 116, 104, 32, 61, 32, 78, 32, 101, 110, 100, 10, 10, 100, 111, 10, 32, 32, 108, 111, 99, 97, 108, 32, 115, 116, 114, 101, 116, 99, 104, 100, 101, 112, 116, 104, 32, 61, 32, 109, 97, 120, 100, 101, 112, 116, 104, 32, 43, 32, 49, 10, 32, 32, 108, 111, 99, 97, 108, 32, 115, 116, 114, 101, 116, 99, 104, 116, 114, 101, 101, 32, 61, 32, 66, 111, 116, 116, 111, 109, 85, 112, 84, 114, 101, 101, 40, 48, 44, 32, 115, 116, 114, 101, 116, 99, 104, 100, 101, 112, 116, 104, 41, 10, 32, 32, 105, 111, 46, 119, 114, 105, 116, 101, 40, 115, 116, 114, 105, 110, 103, 46, 102, 111, 114, 109, 97, 116, 40, 34, 115, 116, 114, 101, 116, 99, 104, 32, 116, 114, 101, 101, 32, 111, 102, 32, 100, 101, 112, 116, 104, 32, 37, 100, 92, 116, 32, 99, 104, 101, 99, 107, 58, 32, 37, 100, 92, 110, 34, 44, 10, 32, 32, 32, 32, 115, 116, 114, 101, 116, 99, 104, 100, 101, 112, 116, 104, 44, 32, 73, 116, 101, 109, 67, 104, 101, 99, 107, 40, 115, 116, 114, 101, 116, 99, 104, 116, 114, 101, 101, 41, 41, 41, 10, 101, 110, 100, 10, 10, 108, 111, 99, 97, 108, 32, 108, 111, 110, 103, 108, 105, 118, 101, 100, 116, 114, 101, 101, 32, 61, 32, 66, 111, 116, 116, 111, 109, 85, 112, 84, 114, 101, 101, 40, 48, 44, 32, 109, 97, 120, 100, 101, 112, 116, 104, 41, 10, 10, 102, 111, 114, 32, 100, 101, 112, 116, 104, 61, 109, 105, 110, 100, 101, 112, 116, 104, 44, 109, 97, 120, 100, 101, 112, 116, 104, 44, 50, 32, 100, 111, 10, 32, 32, 108, 111, 99, 97, 108, 32, 105, 116, 101, 114, 97, 116, 105, 111, 110, 115, 32, 61, 32, 50, 32, 94, 32, 40, 109, 97, 120, 100, 101, 112, 116, 104, 32, 45, 32, 100, 101, 112, 116, 104, 32, 43, 32, 109, 105, 110, 100, 101, 112, 116, 104, 41, 10, 32, 32, 108, 111, 99, 97, 108, 32, 99, 104, 101, 99, 107, 32, 61, 32, 48, 10, 32, 32, 102, 111, 114, 32, 105, 61, 49, 44, 105, 116, 101, 114, 97, 116, 105, 111, 110, 115, 32, 100, 111, 10, 32, 32, 32, 32, 99, 104, 101, 99, 107, 32, 61, 32, 99, 104, 101, 99, 107, 32, 43, 32, 73, 116, 101, 109, 67, 104, 101, 99, 107, 40, 66, 111, 116, 116, 111, 109, 85, 112, 84, 114, 101, 101, 40, 49, 44, 32, 100, 101, 112, 116, 104, 41, 41, 32, 43, 10, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 73, 116, 101, 109, 67, 104, 101, 99, 107, 40, 66, 111, 116, 116, 111, 109, 85, 112, 84, 114, 101, 101, 40, 45, 49, 44, 32, 100, 101, 112, 116, 104, 41, 41, 10, 32, 32, 101, 110, 100, 10, 32, 32, 105, 111, 46, 119, 114, 105, 116, 101, 40, 115, 116, 114, 105, 110, 103, 46, 102, 111, 114, 109, 97, 116, 40, 34, 37, 100, 92, 116, 32, 116, 114, 101, 101, 115, 32, 111, 102, 32, 100, 101, 112, 116, 104, 32, 37, 100, 92, 116, 32, 99, 104, 101, 99, 107, 58, 32, 37, 100, 92, 110, 34, 44, 10, 32, 32, 32, 32, 105, 116, 101, 114, 97, 116, 105, 111, 110, 115, 42, 50, 44, 32, 100, 101, 112, 116, 104, 44, 32, 99, 104, 101, 99, 107, 41, 41, 10, 101, 110, 100, 10, 10, 105, 111, 46, 119, 114, 105, 116, 101, 40, 115, 116, 114, 105, 110, 103, 46, 102, 111, 114, 109, 97, 116, 40, 34, 108, 111, 110, 103, 32, 108, 105, 118, 101, 100, 32, 116, 114, 101, 101, 32, 111, 102, 32, 100, 101, 112, 116, 104, 32, 37, 100, 92, 116, 32, 99, 104, 101, 99, 107, 58, 32, 37, 100, 92, 110, 34, 44, 10, 32, 32, 109, 97, 120, 100, 101, 112, 116, 104, 44, 32, 73, 116, 101, 109, 67, 104, 101, 99, 107, 40, 108, 111, 110, 103, 108, 105, 118, 101, 100, 116, 114, 101, 101, 41, 41, 41, 10], true, true);
    35. 

  35. 

  36.   }
    37. 

  37.   if (Module['calledRun']) {
    38. 

  38.     runWithFS();
    39. 

  39.   } else {
    40. 

  40.     if (!Module['preRun']) Module['preRun'] = [];
    41. 

  41.     Module["preRun"].push(runWithFS); // FS is not initialized yet, wait for it
    42. 

  42.   }
    43. 

  43. 

  44. })();
    45. 

  45. 

  46. // The Module object: Our interface to the outside world. We import
    47. 

  47. // and export values on it, and do the work to get that through
    48. 

  48. // closure compiler if necessary. There are various ways Module can be used:
    49. 

  49. // 1. Not defined. We create it here
    50. 

  50. // 2. A function parameter, function(Module) { ..generated code.. }
    51. 

  51. // 3. pre-run appended it, var Module = {}; ..generated code..
    52. 

  52. // 4. External script tag defines var Module.
    53. 

  53. // We need to do an eval in order to handle the closure compiler
    54. 

  54. // case, where this code here is minified but Module was defined
    55. 

  55. // elsewhere (e.g. case 4 above). We also need to check if Module
    56. 

  56. // already exists (e.g. case 3 above).
    57. 

  57. // Note that if you want to run closure, and also to use Module
    58. 

  58. // after the generated code, you will need to define   var Module = {};
    59. 

  59. // before the code. Then that object will be used in the code, and you
    60. 

  60. // can continue to use Module afterwards as well.
    61. 

  61. var Module;
    62. 

  62. if (!Module) Module = (typeof Module !== 'undefined' ? Module : null) || {};
    63. 

  63. 

  64. // Sometimes an existing Module object exists with properties
    65. 

  65. // meant to overwrite the default module functionality. Here
    66. 

  66. // we collect those properties and reapply _after_ we configure
    67. 

  67. // the current environment's defaults to avoid having to be so
    68. 

  68. // defensive during initialization.
    69. 

  69. var moduleOverrides = {};
    70. 

  70. for (var key in Module) {
    71. 

  71.   if (Module.hasOwnProperty(key)) {
    72. 

  72.     moduleOverrides[key] = Module[key];
    73. 

  73.   }
    74. 

  74. }
    75. 

  75. 

  76. // The environment setup code below is customized to use Module.
    77. 

  77. // *** Environment setup code ***
    78. 

  78. var ENVIRONMENT_IS_NODE = typeof process === 'object' && typeof require === 'function';
    79. 

  79. var ENVIRONMENT_IS_WEB = typeof window === 'object';
    80. 

  80. var ENVIRONMENT_IS_WORKER = typeof importScripts === 'function';
    81. 

  81. var ENVIRONMENT_IS_SHELL = !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_NODE && !ENVIRONMENT_IS_WORKER;
    82. 

  82. 

  83. if (ENVIRONMENT_IS_NODE) {
    84. 

  84.   // Expose functionality in the same simple way that the shells work
    85. 

  85.   // Note that we pollute the global namespace here, otherwise we break in node
    86. 

  86.   if (!Module['print']) Module['print'] = function print(x) {
    87. 

  87.     process['stdout'].write(x + '\n');
    88. 

  88.   };
    89. 

  89.   if (!Module['printErr']) Module['printErr'] = function printErr(x) {
    90. 

  90.     process['stderr'].write(x + '\n');
    91. 

  91.   };
    92. 

  92. 

  93.   var nodeFS = require('fs');
    94. 

  94.   var nodePath = require('path');
    95. 

  95. 

  96.   Module['read'] = function read(filename, binary) {
    97. 

  97.     filename = nodePath['normalize'](filename);
    98. 

  98.     var ret = nodeFS['readFileSync'](filename);
    99. 

  99.     // The path is absolute if the normalized version is the same as the resolved.
    100. 

  100.     if (!ret && filename != nodePath['resolve'](filename)) {
    101. 

  101.       filename = path.join(__dirname, '..', 'src', filename);
    102. 

  102.       ret = nodeFS['readFileSync'](filename);
    103. 

  103.     }
    104. 

  104.     if (ret && !binary) ret = ret.toString();
    105. 

  105.     return ret;
    106. 

  106.   };
    107. 

  107. 

  108.   Module['readBinary'] = function readBinary(filename) { return Module['read'](filename, true) };
    109. 

  109. 

  110.   Module['load'] = function load(f) {
    111. 

  111.     globalEval(read(f));
    112. 

  112.   };
    113. 

  113. 

  114.   Module['arguments'] = process['argv'].slice(2);
    115. 

  115. 

  116.   module['exports'] = Module;
    117. 

  117. }
    118. 

  118. else if (ENVIRONMENT_IS_SHELL) {
    119. 

  119.   if (!Module['print']) Module['print'] = print;
    120. 

  120.   if (typeof printErr != 'undefined') Module['printErr'] = printErr; // not present in v8 or older sm
    121. 

  121. 

  122.   if (typeof read != 'undefined') {
    123. 

  123.     Module['read'] = read;
    124. 

  124.   } else {
    125. 

  125.     Module['read'] = function read() { throw 'no read() available (jsc?)' };
    126. 

  126.   }
    127. 

  127. 

  128.   Module['readBinary'] = function readBinary(f) {
    129. 

  129.     return read(f, 'binary');
    130. 

  130.   };
    131. 

  131. 

  132.   if (typeof scriptArgs != 'undefined') {
    133. 

  133.     Module['arguments'] = scriptArgs;
    134. 

  134.   } else if (typeof arguments != 'undefined') {
    135. 

  135.     Module['arguments'] = arguments;
    136. 

  136.   }
    137. 

  137. 

  138.   this['Module'] = Module;
    139. 

  139. 

  140.   eval("if (typeof gc === 'function' && gc.toString().indexOf('[native code]') > 0) var gc = undefined"); // wipe out the SpiderMonkey shell 'gc' function, which can confuse closure (uses it as a minified name, and it is then initted to a non-falsey value unexpectedly)
    141. 

  141. }
    142. 

  142. else if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {
    143. 

  143.   Module['read'] = function read(url) {
    144. 

  144.     var xhr = new XMLHttpRequest();
    145. 

  145.     xhr.open('GET', url, false);
    146. 

  146.     xhr.send(null);
    147. 

  147.     return xhr.responseText;
    148. 

  148.   };
    149. 

  149. 

  150.   if (typeof arguments != 'undefined') {
    151. 

  151.     Module['arguments'] = arguments;
    152. 

  152.   }
    153. 

  153. 

  154.   if (typeof console !== 'undefined') {
    155. 

  155.     if (!Module['print']) Module['print'] = function print(x) {
    156. 

  156.       console.log(x);
    157. 

  157.     };
    158. 

  158.     if (!Module['printErr']) Module['printErr'] = function printErr(x) {
    159. 

  159.       console.log(x);
    160. 

  160.     };
    161. 

  161.   } else {
    162. 

  162.     // Probably a worker, and without console.log. We can do very little here...
    163. 

  163.     var TRY_USE_DUMP = false;
    164. 

  164.     if (!Module['print']) Module['print'] = (TRY_USE_DUMP && (typeof(dump) !== "undefined") ? (function(x) {
    165. 

  165.       dump(x);
    166. 

  166.     }) : (function(x) {
    167. 

  167.       // self.postMessage(x); // enable this if you want stdout to be sent as messages
    168. 

  168.     }));
    169. 

  169.   }
    170. 

  170. 

  171.   if (ENVIRONMENT_IS_WEB) {
    172. 

  172.     window['Module'] = Module;
    173. 

  173.   } else {
    174. 

  174.     Module['load'] = importScripts;
    175. 

  175.   }
    176. 

  176. }
    177. 

  177. else {
    178. 

  178.   // Unreachable because SHELL is dependant on the others
    179. 

  179.   throw 'Unknown runtime environment. Where are we?';
    180. 

  180. }
    181. 

  181. 

  182. function globalEval(x) {
    183. 

  183.   eval.call(null, x);
    184. 

  184. }
    185. 

  185. if (!Module['load'] == 'undefined' && Module['read']) {
    186. 

  186.   Module['load'] = function load(f) {
    187. 

  187.     globalEval(Module['read'](f));
    188. 

  188.   };
    189. 

  189. }
    190. 

  190. if (!Module['print']) {
    191. 

  191.   Module['print'] = function(){};
    192. 

  192. }
    193. 

  193. if (!Module['printErr']) {
    194. 

  194.   Module['printErr'] = Module['print'];
    195. 

  195. }
    196. 

  196. if (!Module['arguments']) {
    197. 

  197.   Module['arguments'] = [];
    198. 

  198. }
    199. 

  199. // *** Environment setup code ***
    200. 

  200. 

  201. // Closure helpers
    202. 

  202. Module.print = Module['print'];
    203. 

  203. Module.printErr = Module['printErr'];
    204. 

  204. 

  205. // Callbacks
    206. 

  206. Module['preRun'] = [];
    207. 

  207. Module['postRun'] = [];
    208. 

  208. 

  209. // Merge back in the overrides
    210. 

  210. for (var key in moduleOverrides) {
    211. 

  211.   if (moduleOverrides.hasOwnProperty(key)) {
    212. 

  212.     Module[key] = moduleOverrides[key];
    213. 

  213.   }
    214. 

  214. }
    215. 

  215. 

  216. 

  217. 

  218. // === Auto-generated preamble library stuff ===
    219. 

  219. 

  220. //========================================
    221. 

  221. // Runtime code shared with compiler
    222. 

  222. //========================================
    223. 

  223. 

  224. var Runtime = {
    225. 

  225.   stackSave: function () {
    226. 

  226.     return STACKTOP;
    227. 

  227.   },
    228. 

  228.   stackRestore: function (stackTop) {
    229. 

  229.     STACKTOP = stackTop;
    230. 

  230.   },
    231. 

  231.   forceAlign: function (target, quantum) {
    232. 

  232.     quantum = quantum || 4;
    233. 

  233.     if (quantum == 1) return target;
    234. 

  234.     if (isNumber(target) && isNumber(quantum)) {
    235. 

  235.       return Math.ceil(target/quantum)*quantum;
    236. 

  236.     } else if (isNumber(quantum) && isPowerOfTwo(quantum)) {
    237. 

  237.       return '(((' +target + ')+' + (quantum-1) + ')&' + -quantum + ')';
    238. 

  238.     }
    239. 

  239.     return 'Math.ceil((' + target + ')/' + quantum + ')*' + quantum;
    240. 

  240.   },
    241. 

  241.   isNumberType: function (type) {
    242. 

  242.     return type in Runtime.INT_TYPES || type in Runtime.FLOAT_TYPES;
    243. 

  243.   },
    244. 

  244.   isPointerType: function isPointerType(type) {
    245. 

  245.   return type[type.length-1] == '*';
    246. 

  246. },
    247. 

  247.   isStructType: function isStructType(type) {
    248. 

  248.   if (isPointerType(type)) return false;
    249. 

  249.   if (isArrayType(type)) return true;
    250. 

  250.   if (/<?\{ ?[^}]* ?\}>?/.test(type)) return true; // { i32, i8 } etc. - anonymous struct types
    251. 

  251.   // See comment in isStructPointerType()
    252. 

  252.   return type[0] == '%';
    253. 

  253. },
    254. 

  254.   INT_TYPES: {"i1":0,"i8":0,"i16":0,"i32":0,"i64":0},
    255. 

  255.   FLOAT_TYPES: {"float":0,"double":0},
    256. 

  256.   or64: function (x, y) {
    257. 

  257.     var l = (x | 0) | (y | 0);
    258. 

  258.     var h = (Math.round(x / 4294967296) | Math.round(y / 4294967296)) * 4294967296;
    259. 

  259.     return l + h;
    260. 

  260.   },
    261. 

  261.   and64: function (x, y) {
    262. 

  262.     var l = (x | 0) & (y | 0);
    263. 

  263.     var h = (Math.round(x / 4294967296) & Math.round(y / 4294967296)) * 4294967296;
    264. 

  264.     return l + h;
    265. 

  265.   },
    266. 

  266.   xor64: function (x, y) {
    267. 

  267.     var l = (x | 0) ^ (y | 0);
    268. 

  268.     var h = (Math.round(x / 4294967296) ^ Math.round(y / 4294967296)) * 4294967296;
    269. 

  269.     return l + h;
    270. 

  270.   },
    271. 

  271.   getNativeTypeSize: function (type) {
    272. 

  272.     switch (type) {
    273. 

  273.       case 'i1': case 'i8': return 1;
    274. 

  274.       case 'i16': return 2;
    275. 

  275.       case 'i32': return 4;
    276. 

  276.       case 'i64': return 8;
    277. 

  277.       case 'float': return 4;
    278. 

  278.       case 'double': return 8;
    279. 

  279.       default: {
    280. 

  280.         if (type[type.length-1] === '*') {
    281. 

  281.           return Runtime.QUANTUM_SIZE; // A pointer
    282. 

  282.         } else if (type[0] === 'i') {
    283. 

  283.           var bits = parseInt(type.substr(1));
    284. 

  284.           assert(bits % 8 === 0);
    285. 

  285.           return bits/8;
    286. 

  286.         } else {
    287. 

  287.           return 0;
    288. 

  288.         }
    289. 

  289.       }
    290. 

  290.     }
    291. 

  291.   },
    292. 

  292.   getNativeFieldSize: function (type) {
    293. 

  293.     return Math.max(Runtime.getNativeTypeSize(type), Runtime.QUANTUM_SIZE);
    294. 

  294.   },
    295. 

  295.   dedup: function dedup(items, ident) {
    296. 

  296.   var seen = {};
    297. 

  297.   if (ident) {
    298. 

  298.     return items.filter(function(item) {
    299. 

  299.       if (seen[item[ident]]) return false;
    300. 

  300.       seen[item[ident]] = true;
    301. 

  301.       return true;
    302. 

  302.     });
    303. 

  303.   } else {
    304. 

  304.     return items.filter(function(item) {
    305. 

  305.       if (seen[item]) return false;
    306. 

  306.       seen[item] = true;
    307. 

  307.       return true;
    308. 

  308.     });
    309. 

  309.   }
    310. 

  310. },
    311. 

  311.   set: function set() {
    312. 

  312.   var args = typeof arguments[0] === 'object' ? arguments[0] : arguments;
    313. 

  313.   var ret = {};
    314. 

  314.   for (var i = 0; i < args.length; i++) {
    315. 

  315.     ret[args[i]] = 0;
    316. 

  316.   }
    317. 

  317.   return ret;
    318. 

  318. },
    319. 

  319.   STACK_ALIGN: 8,
    320. 

  320.   getAlignSize: function (type, size, vararg) {
    321. 

  321.     // we align i64s and doubles on 64-bit boundaries, unlike x86
    322. 

  322.     if (!vararg && (type == 'i64' || type == 'double')) return 8;
    323. 

  323.     if (!type) return Math.min(size, 8); // align structures internally to 64 bits
    324. 

  324.     return Math.min(size || (type ? Runtime.getNativeFieldSize(type) : 0), Runtime.QUANTUM_SIZE);
    325. 

  325.   },
    326. 

  326.   calculateStructAlignment: function calculateStructAlignment(type) {
    327. 

  327.     type.flatSize = 0;
    328. 

  328.     type.alignSize = 0;
    329. 

  329.     var diffs = [];
    330. 

  330.     var prev = -1;
    331. 

  331.     var index = 0;
    332. 

  332.     type.flatIndexes = type.fields.map(function(field) {
    333. 

  333.       index++;
    334. 

  334.       var size, alignSize;
    335. 

  335.       if (Runtime.isNumberType(field) || Runtime.isPointerType(field)) {
    336. 

  336.         size = Runtime.getNativeTypeSize(field); // pack char; char; in structs, also char[X]s.
    337. 

  337.         alignSize = Runtime.getAlignSize(field, size);
    338. 

  338.       } else if (Runtime.isStructType(field)) {
    339. 

  339.         if (field[1] === '0') {
    340. 

  340.           // this is [0 x something]. When inside another structure like here, it must be at the end,
    341. 

  341.           // and it adds no size
    342. 

  342.           // XXX this happens in java-nbody for example... assert(index === type.fields.length, 'zero-length in the middle!');
    343. 

  343.           size = 0;
    344. 

  344.           if (Types.types[field]) {
    345. 

  345.             alignSize = Runtime.getAlignSize(null, Types.types[field].alignSize);
    346. 

  346.           } else {
    347. 

  347.             alignSize = type.alignSize || QUANTUM_SIZE;
    348. 

  348.           }
    349. 

  349.         } else {
    350. 

  350.           size = Types.types[field].flatSize;
    351. 

  351.           alignSize = Runtime.getAlignSize(null, Types.types[field].alignSize);
    352. 

  352.         }
    353. 

  353.       } else if (field[0] == 'b') {
    354. 

  354.         // bN, large number field, like a [N x i8]
    355. 

  355.         size = field.substr(1)|0;
    356. 

  356.         alignSize = 1;
    357. 

  357.       } else if (field[0] === '<') {
    358. 

  358.         // vector type
    359. 

  359.         size = alignSize = Types.types[field].flatSize; // fully aligned
    360. 

  360.       } else if (field[0] === 'i') {
    361. 

  361.         // illegal integer field, that could not be legalized because it is an internal structure field
    362. 

  362.         // it is ok to have such fields, if we just use them as markers of field size and nothing more complex
    363. 

  363.         size = alignSize = parseInt(field.substr(1))/8;
    364. 

  364.         assert(size % 1 === 0, 'cannot handle non-byte-size field ' + field);
    365. 

  365.       } else {
    366. 

  366.         assert(false, 'invalid type for calculateStructAlignment');
    367. 

  367.       }
    368. 

  368.       if (type.packed) alignSize = 1;
    369. 

  369.       type.alignSize = Math.max(type.alignSize, alignSize);
    370. 

  370.       var curr = Runtime.alignMemory(type.flatSize, alignSize); // if necessary, place this on aligned memory
    371. 

  371.       type.flatSize = curr + size;
    372. 

  372.       if (prev >= 0) {
    373. 

  373.         diffs.push(curr-prev);
    374. 

  374.       }
    375. 

  375.       prev = curr;
    376. 

  376.       return curr;
    377. 

  377.     });
    378. 

  378.     if (type.name_ && type.name_[0] === '[') {
    379. 

  379.       // arrays have 2 elements, so we get the proper difference. then we scale here. that way we avoid
    380. 

  380.       // allocating a potentially huge array for [999999 x i8] etc.
    381. 

  381.       type.flatSize = parseInt(type.name_.substr(1))*type.flatSize/2;
    382. 

  382.     }
    383. 

  383.     type.flatSize = Runtime.alignMemory(type.flatSize, type.alignSize);
    384. 

  384.     if (diffs.length == 0) {
    385. 

  385.       type.flatFactor = type.flatSize;
    386. 

  386.     } else if (Runtime.dedup(diffs).length == 1) {
    387. 

  387.       type.flatFactor = diffs[0];
    388. 

  388.     }
    389. 

  389.     type.needsFlattening = (type.flatFactor != 1);
    390. 

  390.     return type.flatIndexes;
    391. 

  391.   },
    392. 

  392.   generateStructInfo: function (struct, typeName, offset) {
    393. 

  393.     var type, alignment;
    394. 

  394.     if (typeName) {
    395. 

  395.       offset = offset || 0;
    396. 

  396.       type = (typeof Types === 'undefined' ? Runtime.typeInfo : Types.types)[typeName];
    397. 

  397.       if (!type) return null;
    398. 

  398.       if (type.fields.length != struct.length) {
    399. 

  399.         printErr('Number of named fields must match the type for ' + typeName + ': possibly duplicate struct names. Cannot return structInfo');
    400. 

  400.         return null;
    401. 

  401.       }
    402. 

  402.       alignment = type.flatIndexes;
    403. 

  403.     } else {
    404. 

  404.       var type = { fields: struct.map(function(item) { return item[0] }) };
    405. 

  405.       alignment = Runtime.calculateStructAlignment(type);
    406. 

  406.     }
    407. 

  407.     var ret = {
    408. 

  408.       __size__: type.flatSize
    409. 

  409.     };
    410. 

  410.     if (typeName) {
    411. 

  411.       struct.forEach(function(item, i) {
    412. 

  412.         if (typeof item === 'string') {
    413. 

  413.           ret[item] = alignment[i] + offset;
    414. 

  414.         } else {
    415. 

  415.           // embedded struct
    416. 

  416.           var key;
    417. 

  417.           for (var k in item) key = k;
    418. 

  418.           ret[key] = Runtime.generateStructInfo(item[key], type.fields[i], alignment[i]);
    419. 

  419.         }
    420. 

  420.       });
    421. 

  421.     } else {
    422. 

  422.       struct.forEach(function(item, i) {
    423. 

  423.         ret[item[1]] = alignment[i];
    424. 

  424.       });
    425. 

  425.     }
    426. 

  426.     return ret;
    427. 

  427.   },
    428. 

  428.   dynCall: function (sig, ptr, args) {
    429. 

  429.     if (args && args.length) {
    430. 

  430.       if (!args.splice) args = Array.prototype.slice.call(args);
    431. 

  431.       args.splice(0, 0, ptr);
    432. 

  432.       return Module['dynCall_' + sig].apply(null, args);
    433. 

  433.     } else {
    434. 

  434.       return Module['dynCall_' + sig].call(null, ptr);
    435. 

  435.     }
    436. 

  436.   },
    437. 

  437.   functionPointers: [],
    438. 

  438.   addFunction: function (func) {
    439. 

  439.     for (var i = 0; i < Runtime.functionPointers.length; i++) {
    440. 

  440.       if (!Runtime.functionPointers[i]) {
    441. 

  441.         Runtime.functionPointers[i] = func;
    442. 

  442.         return 2*(1 + i);
    443. 

  443.       }
    444. 

  444.     }
    445. 

  445.     throw 'Finished up all reserved function pointers. Use a higher value for RESERVED_FUNCTION_POINTERS.';
    446. 

  446.   },
    447. 

  447.   removeFunction: function (index) {
    448. 

  448.     Runtime.functionPointers[(index-2)/2] = null;
    449. 

  449.   },
    450. 

  450.   getAsmConst: function (code, numArgs) {
    451. 

  451.     // code is a constant string on the heap, so we can cache these
    452. 

  452.     if (!Runtime.asmConstCache) Runtime.asmConstCache = {};
    453. 

  453.     var func = Runtime.asmConstCache[code];
    454. 

  454.     if (func) return func;
    455. 

  455.     var args = [];
    456. 

  456.     for (var i = 0; i < numArgs; i++) {
    457. 

  457.       args.push(String.fromCharCode(36) + i); // $0, $1 etc
    458. 

  458.     }
    459. 

  459.     var source = Pointer_stringify(code);
    460. 

  460.     if (source[0] === '"') {
    461. 

  461.       // tolerate EM_ASM("..code..") even though EM_ASM(..code..) is correct
    462. 

  462.       if (source.indexOf('"', 1) === source.length-1) {
    463. 

  463.         source = source.substr(1, source.length-2);
    464. 

  464.       } else {
    465. 

  465.         // something invalid happened, e.g. EM_ASM("..code($0)..", input)
    466. 

  466.         abort('invalid EM_ASM input |' + source + '|. Please use EM_ASM(..code..) (no quotes) or EM_ASM({ ..code($0).. }, input) (to input values)');
    467. 

  467.       }
    468. 

  468.     }
    469. 

  469.     try {
    470. 

  470.       var evalled = eval('(function(' + args.join(',') + '){ ' + source + ' })'); // new Function does not allow upvars in node
    471. 

  471.     } catch(e) {
    472. 

  472.       Module.printErr('error in executing inline EM_ASM code: ' + e + ' on: \n\n' + source + '\n\nwith args |' + args + '| (make sure to use the right one out of EM_ASM, EM_ASM_ARGS, etc.)');
    473. 

  473.       throw e;
    474. 

  474.     }
    475. 

  475.     return Runtime.asmConstCache[code] = evalled;
    476. 

  476.   },
    477. 

  477.   warnOnce: function (text) {
    478. 

  478.     if (!Runtime.warnOnce.shown) Runtime.warnOnce.shown = {};
    479. 

  479.     if (!Runtime.warnOnce.shown[text]) {
    480. 

  480.       Runtime.warnOnce.shown[text] = 1;
    481. 

  481.       Module.printErr(text);
    482. 

  482.     }
    483. 

  483.   },
    484. 

  484.   funcWrappers: {},
    485. 

  485.   getFuncWrapper: function (func, sig) {
    486. 

  486.     assert(sig);
    487. 

  487.     if (!Runtime.funcWrappers[func]) {
    488. 

  488.       Runtime.funcWrappers[func] = function dynCall_wrapper() {
    489. 

  489.         return Runtime.dynCall(sig, func, arguments);
    490. 

  490.       };
    491. 

  491.     }
    492. 

  492.     return Runtime.funcWrappers[func];
    493. 

  493.   },
    494. 

  494.   UTF8Processor: function () {
    495. 

  495.     var buffer = [];
    496. 

  496.     var needed = 0;
    497. 

  497.     this.processCChar = function (code) {
    498. 

  498.       code = code & 0xFF;
    499. 

  499. 

  500.       if (buffer.length == 0) {
    501. 

  501.         if ((code & 0x80) == 0x00) {        // 0xxxxxxx
    502. 

  502.           return String.fromCharCode(code);
    503. 

  503.         }
    504. 

  504.         buffer.push(code);
    505. 

  505.         if ((code & 0xE0) == 0xC0) {        // 110xxxxx
    506. 

  506.           needed = 1;
    507. 

  507.         } else if ((code & 0xF0) == 0xE0) { // 1110xxxx
    508. 

  508.           needed = 2;
    509. 

  509.         } else {                            // 11110xxx
    510. 

  510.           needed = 3;
    511. 

  511.         }
    512. 

  512.         return '';
    513. 

  513.       }
    514. 

  514. 

  515.       if (needed) {
    516. 

  516.         buffer.push(code);
    517. 

  517.         needed--;
    518. 

  518.         if (needed > 0) return '';
    519. 

  519.       }
    520. 

  520. 

  521.       var c1 = buffer[0];
    522. 

  522.       var c2 = buffer[1];
    523. 

  523.       var c3 = buffer[2];
    524. 

  524.       var c4 = buffer[3];
    525. 

  525.       var ret;
    526. 

  526.       if (buffer.length == 2) {
    527. 

  527.         ret = String.fromCharCode(((c1 & 0x1F) << 6)  | (c2 & 0x3F));
    528. 

  528.       } else if (buffer.length == 3) {
    529. 

  529.         ret = String.fromCharCode(((c1 & 0x0F) << 12) | ((c2 & 0x3F) << 6)  | (c3 & 0x3F));
    530. 

  530.       } else {
    531. 

  531.         // http://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae
    532. 

  532.         var codePoint = ((c1 & 0x07) << 18) | ((c2 & 0x3F) << 12) |
    533. 

  533.                         ((c3 & 0x3F) << 6)  | (c4 & 0x3F);
    534. 

  534.         ret = String.fromCharCode(
    535. 

  535.           Math.floor((codePoint - 0x10000) / 0x400) + 0xD800,
    536. 

  536.           (codePoint - 0x10000) % 0x400 + 0xDC00);
    537. 

  537.       }
    538. 

  538.       buffer.length = 0;
    539. 

  539.       return ret;
    540. 

  540.     }
    541. 

  541.     this.processJSString = function processJSString(string) {
    542. 

  542.       /* TODO: use TextEncoder when present,
    543. 

  543.         var encoder = new TextEncoder();
    544. 

  544.         encoder['encoding'] = "utf-8";
    545. 

  545.         var utf8Array = encoder['encode'](aMsg.data);
    546. 

  546.       */
    547. 

  547.       string = unescape(encodeURIComponent(string));
    548. 

  548.       var ret = [];
    549. 

  549.       for (var i = 0; i < string.length; i++) {
    550. 

  550.         ret.push(string.charCodeAt(i));
    551. 

  551.       }
    552. 

  552.       return ret;
    553. 

  553.     }
    554. 

  554.   },
    555. 

  555.   getCompilerSetting: function (name) {
    556. 

  556.     throw 'You must build with -s RETAIN_COMPILER_SETTINGS=1 for Runtime.getCompilerSetting or emscripten_get_compiler_setting to work';
    557. 

  557.   },
    558. 

  558.   stackAlloc: function (size) { var ret = STACKTOP;STACKTOP = (STACKTOP + size)|0;STACKTOP = (((STACKTOP)+7)&-8); return ret; },
    559. 

  559.   staticAlloc: function (size) { var ret = STATICTOP;STATICTOP = (STATICTOP + size)|0;STATICTOP = (((STATICTOP)+7)&-8); return ret; },
    560. 

  560.   dynamicAlloc: function (size) { var ret = DYNAMICTOP;DYNAMICTOP = (DYNAMICTOP + size)|0;DYNAMICTOP = (((DYNAMICTOP)+7)&-8); if (DYNAMICTOP >= TOTAL_MEMORY) enlargeMemory();; return ret; },
    561. 

  561.   alignMemory: function (size,quantum) { var ret = size = Math.ceil((size)/(quantum ? quantum : 8))*(quantum ? quantum : 8); return ret; },
    562. 

  562.   makeBigInt: function (low,high,unsigned) { var ret = (unsigned ? ((+((low>>>0)))+((+((high>>>0)))*(+4294967296))) : ((+((low>>>0)))+((+((high|0)))*(+4294967296)))); return ret; },
    563. 

  563.   GLOBAL_BASE: 8,
    564. 

  564.   QUANTUM_SIZE: 4,
    565. 

  565.   __dummy__: 0
    566. 

  566. }
    567. 

  567. 

  568. 

  569. Module['Runtime'] = Runtime;
    570. 

  570. 

  571. 

  572. 

  573. 

  574. 

  575. 

  576. 

  577. 

  578. 

  579. //========================================
    580. 

  580. // Runtime essentials
    581. 

  581. //========================================
    582. 

  582. 

  583. var __THREW__ = 0; // Used in checking for thrown exceptions.
    584. 

  584. 

  585. var ABORT = false; // whether we are quitting the application. no code should run after this. set in exit() and abort()
    586. 

  586. var EXITSTATUS = 0;
    587. 

  587. 

  588. var undef = 0;
    589. 

  589. // tempInt is used for 32-bit signed values or smaller. tempBigInt is used
    590. 

  590. // for 32-bit unsigned values or more than 32 bits. TODO: audit all uses of tempInt
    591. 

  591. var tempValue, tempInt, tempBigInt, tempInt2, tempBigInt2, tempPair, tempBigIntI, tempBigIntR, tempBigIntS, tempBigIntP, tempBigIntD, tempDouble, tempFloat;
    592. 

  592. var tempI64, tempI64b;
    593. 

  593. var tempRet0, tempRet1, tempRet2, tempRet3, tempRet4, tempRet5, tempRet6, tempRet7, tempRet8, tempRet9;
    594. 

  594. 

  595. function assert(condition, text) {
    596. 

  596.   if (!condition) {
    597. 

  597.     abort('Assertion failed: ' + text);
    598. 

  598.   }
    599. 

  599. }
    600. 

  600. 

  601. var globalScope = this;
    602. 

  602. 

  603. // C calling interface. A convenient way to call C functions (in C files, or
    604. 

  604. // defined with extern "C").
    605. 

  605. //
    606. 

  606. // Note: LLVM optimizations can inline and remove functions, after which you will not be
    607. 

  607. //       able to call them. Closure can also do so. To avoid that, add your function to
    608. 

  608. //       the exports using something like
    609. 

  609. //
    610. 

  610. //         -s EXPORTED_FUNCTIONS='["_main", "_myfunc"]'
    611. 

  611. //
    612. 

  612. // @param ident      The name of the C function (note that C++ functions will be name-mangled - use extern "C")
    613. 

  613. // @param returnType The return type of the function, one of the JS types 'number', 'string' or 'array' (use 'number' for any C pointer, and
    614. 

  614. //                   'array' for JavaScript arrays and typed arrays; note that arrays are 8-bit).
    615. 

  615. // @param argTypes   An array of the types of arguments for the function (if there are no arguments, this can be ommitted). Types are as in returnType,
    616. 

  616. //                   except that 'array' is not possible (there is no way for us to know the length of the array)
    617. 

  617. // @param args       An array of the arguments to the function, as native JS values (as in returnType)
    618. 

  618. //                   Note that string arguments will be stored on the stack (the JS string will become a C string on the stack).
    619. 

  619. // @return           The return value, as a native JS value (as in returnType)
    620. 

  620. function ccall(ident, returnType, argTypes, args) {
    621. 

  621.   return ccallFunc(getCFunc(ident), returnType, argTypes, args);
    622. 

  622. }
    623. 

  623. Module["ccall"] = ccall;
    624. 

  624. 

  625. // Returns the C function with a specified identifier (for C++, you need to do manual name mangling)
    626. 

  626. function getCFunc(ident) {
    627. 

  627.   try {
    628. 

  628.     var func = Module['_' + ident]; // closure exported function
    629. 

  629.     if (!func) func = eval('_' + ident); // explicit lookup
    630. 

  630.   } catch(e) {
    631. 

  631.   }
    632. 

  632.   assert(func, 'Cannot call unknown function ' + ident + ' (perhaps LLVM optimizations or closure removed it?)');
    633. 

  633.   return func;
    634. 

  634. }
    635. 

  635. 

  636. // Internal function that does a C call using a function, not an identifier
    637. 

  637. function ccallFunc(func, returnType, argTypes, args) {
    638. 

  638.   var stack = 0;
    639. 

  639.   function toC(value, type) {
    640. 

  640.     if (type == 'string') {
    641. 

  641.       if (value === null || value === undefined || value === 0) return 0; // null string
    642. 

  642.       value = intArrayFromString(value);
    643. 

  643.       type = 'array';
    644. 

  644.     }
    645. 

  645.     if (type == 'array') {
    646. 

  646.       if (!stack) stack = Runtime.stackSave();
    647. 

  647.       var ret = Runtime.stackAlloc(value.length);
    648. 

  648.       writeArrayToMemory(value, ret);
    649. 

  649.       return ret;
    650. 

  650.     }
    651. 

  651.     return value;
    652. 

  652.   }
    653. 

  653.   function fromC(value, type) {
    654. 

  654.     if (type == 'string') {
    655. 

  655.       return Pointer_stringify(value);
    656. 

  656.     }
    657. 

  657.     assert(type != 'array');
    658. 

  658.     return value;
    659. 

  659.   }
    660. 

  660.   var i = 0;
    661. 

  661.   var cArgs = args ? args.map(function(arg) {
    662. 

  662.     return toC(arg, argTypes[i++]);
    663. 

  663.   }) : [];
    664. 

  664.   var ret = fromC(func.apply(null, cArgs), returnType);
    665. 

  665.   if (stack) Runtime.stackRestore(stack);
    666. 

  666.   return ret;
    667. 

  667. }
    668. 

  668. 

  669. // Returns a native JS wrapper for a C function. This is similar to ccall, but
    670. 

  670. // returns a function you can call repeatedly in a normal way. For example:
    671. 

  671. //
    672. 

  672. //   var my_function = cwrap('my_c_function', 'number', ['number', 'number']);
    673. 

  673. //   alert(my_function(5, 22));
    674. 

  674. //   alert(my_function(99, 12));
    675. 

  675. //
    676. 

  676. function cwrap(ident, returnType, argTypes) {
    677. 

  677.   var func = getCFunc(ident);
    678. 

  678.   return function() {
    679. 

  679.     return ccallFunc(func, returnType, argTypes, Array.prototype.slice.call(arguments));
    680. 

  680.   }
    681. 

  681. }
    682. 

  682. Module["cwrap"] = cwrap;
    683. 

  683. 

  684. // Sets a value in memory in a dynamic way at run-time. Uses the
    685. 

  685. // type data. This is the same as makeSetValue, except that
    686. 

  686. // makeSetValue is done at compile-time and generates the needed
    687. 

  687. // code then, whereas this function picks the right code at
    688. 

  688. // run-time.
    689. 

  689. // Note that setValue and getValue only do *aligned* writes and reads!
    690. 

  690. // Note that ccall uses JS types as for defining types, while setValue and
    691. 

  691. // getValue need LLVM types ('i8', 'i32') - this is a lower-level operation
    692. 

  692. function setValue(ptr, value, type, noSafe) {
    693. 

  693.   type = type || 'i8';
    694. 

  694.   if (type.charAt(type.length-1) === '*') type = 'i32'; // pointers are 32-bit
    695. 

  695.     switch(type) {
    696. 

  696.       case 'i1': HEAP8[(ptr)]=value; break;
    697. 

  697.       case 'i8': HEAP8[(ptr)]=value; break;
    698. 

  698.       case 'i16': HEAP16[((ptr)>>1)]=value; break;
    699. 

  699.       case 'i32': HEAP32[((ptr)>>2)]=value; break;
    700. 

  700.       case 'i64': (tempI64 = [value>>>0,(tempDouble=value,(+(Math_abs(tempDouble))) >= (+1) ? (tempDouble > (+0) ? ((Math_min((+(Math_floor((tempDouble)/(+4294967296)))), (+4294967295)))|0)>>>0 : (~~((+(Math_ceil((tempDouble - +(((~~(tempDouble)))>>>0))/(+4294967296))))))>>>0) : 0)],HEAP32[((ptr)>>2)]=tempI64[0],HEAP32[(((ptr)+(4))>>2)]=tempI64[1]); break;
    701. 

  701.       case 'float': HEAPF32[((ptr)>>2)]=value; break;
    702. 

  702.       case 'double': HEAPF64[((ptr)>>3)]=value; break;
    703. 

  703.       default: abort('invalid type for setValue: ' + type);
    704. 

  704.     }
    705. 

  705. }
    706. 

  706. Module['setValue'] = setValue;
    707. 

  707. 

  708. // Parallel to setValue.
    709. 

  709. function getValue(ptr, type, noSafe) {
    710. 

  710.   type = type || 'i8';
    711. 

  711.   if (type.charAt(type.length-1) === '*') type = 'i32'; // pointers are 32-bit
    712. 

  712.     switch(type) {
    713. 

  713.       case 'i1': return HEAP8[(ptr)];
    714. 

  714.       case 'i8': return HEAP8[(ptr)];
    715. 

  715.       case 'i16': return HEAP16[((ptr)>>1)];
    716. 

  716.       case 'i32': return HEAP32[((ptr)>>2)];
    717. 

  717.       case 'i64': return HEAP32[((ptr)>>2)];
    718. 

  718.       case 'float': return HEAPF32[((ptr)>>2)];
    719. 

  719.       case 'double': return HEAPF64[((ptr)>>3)];
    720. 

  720.       default: abort('invalid type for setValue: ' + type);
    721. 

  721.     }
    722. 

  722.   return null;
    723. 

  723. }
    724. 

  724. Module['getValue'] = getValue;
    725. 

  725. 

  726. var ALLOC_NORMAL = 0; // Tries to use _malloc()
    727. 

  727. var ALLOC_STACK = 1; // Lives for the duration of the current function call
    728. 

  728. var ALLOC_STATIC = 2; // Cannot be freed
    729. 

  729. var ALLOC_DYNAMIC = 3; // Cannot be freed except through sbrk
    730. 

  730. var ALLOC_NONE = 4; // Do not allocate
    731. 

  731. Module['ALLOC_NORMAL'] = ALLOC_NORMAL;
    732. 

  732. Module['ALLOC_STACK'] = ALLOC_STACK;
    733. 

  733. Module['ALLOC_STATIC'] = ALLOC_STATIC;
    734. 

  734. Module['ALLOC_DYNAMIC'] = ALLOC_DYNAMIC;
    735. 

  735. Module['ALLOC_NONE'] = ALLOC_NONE;
    736. 

  736. 

  737. // allocate(): This is for internal use. You can use it yourself as well, but the interface
    738. 

  738. //             is a little tricky (see docs right below). The reason is that it is optimized
    739. 

  739. //             for multiple syntaxes to save space in generated code. So you should
    740. 

  740. //             normally not use allocate(), and instead allocate memory using _malloc(),
    741. 

  741. //             initialize it with setValue(), and so forth.
    742. 

  742. // @slab: An array of data, or a number. If a number, then the size of the block to allocate,
    743. 

  743. //        in *bytes* (note that this is sometimes confusing: the next parameter does not
    744. 

  744. //        affect this!)
    745. 

  745. // @types: Either an array of types, one for each byte (or 0 if no type at that position),
    746. 

  746. //         or a single type which is used for the entire block. This only matters if there
    747. 

  747. //         is initial data - if @slab is a number, then this does not matter at all and is
    748. 

  748. //         ignored.
    749. 

  749. // @allocator: How to allocate memory, see ALLOC_*
    750. 

  750. function allocate(slab, types, allocator, ptr) {
    751. 

  751.   var zeroinit, size;
    752. 

  752.   if (typeof slab === 'number') {
    753. 

  753.     zeroinit = true;
    754. 

  754.     size = slab;
    755. 

  755.   } else {
    756. 

  756.     zeroinit = false;
    757. 

  757.     size = slab.length;
    758. 

  758.   }
    759. 

  759. 

  760.   var singleType = typeof types === 'string' ? types : null;
    761. 

  761. 

  762.   var ret;
    763. 

  763.   if (allocator == ALLOC_NONE) {
    764. 

  764.     ret = ptr;
    765. 

  765.   } else {
    766. 

  766.     ret = [_malloc, Runtime.stackAlloc, Runtime.staticAlloc, Runtime.dynamicAlloc][allocator === undefined ? ALLOC_STATIC : allocator](Math.max(size, singleType ? 1 : types.length));
    767. 

  767.   }
    768. 

  768. 

  769.   if (zeroinit) {
    770. 

  770.     var ptr = ret, stop;
    771. 

  771.     assert((ret & 3) == 0);
    772. 

  772.     stop = ret + (size & ~3);
    773. 

  773.     for (; ptr < stop; ptr += 4) {
    774. 

  774.       HEAP32[((ptr)>>2)]=0;
    775. 

  775.     }
    776. 

  776.     stop = ret + size;
    777. 

  777.     while (ptr < stop) {
    778. 

  778.       HEAP8[((ptr++)|0)]=0;
    779. 

  779.     }
    780. 

  780.     return ret;
    781. 

  781.   }
    782. 

  782. 

  783.   if (singleType === 'i8') {
    784. 

  784.     if (slab.subarray || slab.slice) {
    785. 

  785.       HEAPU8.set(slab, ret);
    786. 

  786.     } else {
    787. 

  787.       HEAPU8.set(new Uint8Array(slab), ret);
    788. 

  788.     }
    789. 

  789.     return ret;
    790. 

  790.   }
    791. 

  791. 

  792.   var i = 0, type, typeSize, previousType;
    793. 

  793.   while (i < size) {
    794. 

  794.     var curr = slab[i];
    795. 

  795. 

  796.     if (typeof curr === 'function') {
    797. 

  797.       curr = Runtime.getFunctionIndex(curr);
    798. 

  798.     }
    799. 

  799. 

  800.     type = singleType || types[i];
    801. 

  801.     if (type === 0) {
    802. 

  802.       i++;
    803. 

  803.       continue;
    804. 

  804.     }
    805. 

  805. 

  806.     if (type == 'i64') type = 'i32'; // special case: we have one i32 here, and one i32 later
    807. 

  807. 

  808.     setValue(ret+i, curr, type);
    809. 

  809. 

  810.     // no need to look up size unless type changes, so cache it
    811. 

  811.     if (previousType !== type) {
    812. 

  812.       typeSize = Runtime.getNativeTypeSize(type);
    813. 

  813.       previousType = type;
    814. 

  814.     }
    815. 

  815.     i += typeSize;
    816. 

  816.   }
    817. 

  817. 

  818.   return ret;
    819. 

  819. }
    820. 

  820. Module['allocate'] = allocate;
    821. 

  821. 

  822. function Pointer_stringify(ptr, /* optional */ length) {
    823. 

  823.   // TODO: use TextDecoder
    824. 

  824.   // Find the length, and check for UTF while doing so
    825. 

  825.   var hasUtf = false;
    826. 

  826.   var t;
    827. 

  827.   var i = 0;
    828. 

  828.   while (1) {
    829. 

  829.     t = HEAPU8[(((ptr)+(i))|0)];
    830. 

  830.     if (t >= 128) hasUtf = true;
    831. 

  831.     else if (t == 0 && !length) break;
    832. 

  832.     i++;
    833. 

  833.     if (length && i == length) break;
    834. 

  834.   }
    835. 

  835.   if (!length) length = i;
    836. 

  836. 

  837.   var ret = '';
    838. 

  838. 

  839.   if (!hasUtf) {
    840. 

  840.     var MAX_CHUNK = 1024; // split up into chunks, because .apply on a huge string can overflow the stack
    841. 

  841.     var curr;
    842. 

  842.     while (length > 0) {
    843. 

  843.       curr = String.fromCharCode.apply(String, HEAPU8.subarray(ptr, ptr + Math.min(length, MAX_CHUNK)));
    844. 

  844.       ret = ret ? ret + curr : curr;
    845. 

  845.       ptr += MAX_CHUNK;
    846. 

  846.       length -= MAX_CHUNK;
    847. 

  847.     }
    848. 

  848.     return ret;
    849. 

  849.   }
    850. 

  850. 

  851.   var utf8 = new Runtime.UTF8Processor();
    852. 

  852.   for (i = 0; i < length; i++) {
    853. 

  853.     t = HEAPU8[(((ptr)+(i))|0)];
    854. 

  854.     ret += utf8.processCChar(t);
    855. 

  855.   }
    856. 

  856.   return ret;
    857. 

  857. }
    858. 

  858. Module['Pointer_stringify'] = Pointer_stringify;
    859. 

  859. 

  860. // Given a pointer 'ptr' to a null-terminated UTF16LE-encoded string in the emscripten HEAP, returns
    861. 

  861. // a copy of that string as a Javascript String object.
    862. 

  862. function UTF16ToString(ptr) {
    863. 

  863.   var i = 0;
    864. 

  864. 

  865.   var str = '';
    866. 

  866.   while (1) {
    867. 

  867.     var codeUnit = HEAP16[(((ptr)+(i*2))>>1)];
    868. 

  868.     if (codeUnit == 0)
    869. 

  869.       return str;
    870. 

  870.     ++i;
    871. 

  871.     // fromCharCode constructs a character from a UTF-16 code unit, so we can pass the UTF16 string right through.
    872. 

  872.     str += String.fromCharCode(codeUnit);
    873. 

  873.   }
    874. 

  874. }
    875. 

  875. Module['UTF16ToString'] = UTF16ToString;
    876. 

  876. 

  877. // Copies the given Javascript String object 'str' to the emscripten HEAP at address 'outPtr',
    878. 

  878. // null-terminated and encoded in UTF16LE form. The copy will require at most (str.length*2+1)*2 bytes of space in the HEAP.
    879. 

  879. function stringToUTF16(str, outPtr) {
    880. 

  880.   for(var i = 0; i < str.length; ++i) {
    881. 

  881.     // charCodeAt returns a UTF-16 encoded code unit, so it can be directly written to the HEAP.
    882. 

  882.     var codeUnit = str.charCodeAt(i); // possibly a lead surrogate
    883. 

  883.     HEAP16[(((outPtr)+(i*2))>>1)]=codeUnit;
    884. 

  884.   }
    885. 

  885.   // Null-terminate the pointer to the HEAP.
    886. 

  886.   HEAP16[(((outPtr)+(str.length*2))>>1)]=0;
    887. 

  887. }
    888. 

  888. Module['stringToUTF16'] = stringToUTF16;
    889. 

  889. 

  890. // Given a pointer 'ptr' to a null-terminated UTF32LE-encoded string in the emscripten HEAP, returns
    891. 

  891. // a copy of that string as a Javascript String object.
    892. 

  892. function UTF32ToString(ptr) {
    893. 

  893.   var i = 0;
    894. 

  894. 

  895.   var str = '';
    896. 

  896.   while (1) {
    897. 

  897.     var utf32 = HEAP32[(((ptr)+(i*4))>>2)];
    898. 

  898.     if (utf32 == 0)
    899. 

  899.       return str;
    900. 

  900.     ++i;
    901. 

  901.     // 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.
    902. 

  902.     if (utf32 >= 0x10000) {
    903. 

  903.       var ch = utf32 - 0x10000;
    904. 

  904.       str += String.fromCharCode(0xD800 | (ch >> 10), 0xDC00 | (ch & 0x3FF));
    905. 

  905.     } else {
    906. 

  906.       str += String.fromCharCode(utf32);
    907. 

  907.     }
    908. 

  908.   }
    909. 

  909. }
    910. 

  910. Module['UTF32ToString'] = UTF32ToString;
    911. 

  911. 

  912. // Copies the given Javascript String object 'str' to the emscripten HEAP at address 'outPtr',
    913. 

  913. // null-terminated and encoded in UTF32LE form. The copy will require at most (str.length+1)*4 bytes of space in the HEAP,
    914. 

  914. // but can use less, since str.length does not return the number of characters in the string, but the number of UTF-16 code units in the string.
    915. 

  915. function stringToUTF32(str, outPtr) {
    916. 

  916.   var iChar = 0;
    917. 

  917.   for(var iCodeUnit = 0; iCodeUnit < str.length; ++iCodeUnit) {
    918. 

  918.     // 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.
    919. 

  919.     var codeUnit = str.charCodeAt(iCodeUnit); // possibly a lead surrogate
    920. 

  920.     if (codeUnit >= 0xD800 && codeUnit <= 0xDFFF) {
    921. 

  921.       var trailSurrogate = str.charCodeAt(++iCodeUnit);
    922. 

  922.       codeUnit = 0x10000 + ((codeUnit & 0x3FF) << 10) | (trailSurrogate & 0x3FF);
    923. 

  923.     }
    924. 

  924.     HEAP32[(((outPtr)+(iChar*4))>>2)]=codeUnit;
    925. 

  925.     ++iChar;
    926. 

  926.   }
    927. 

  927.   // Null-terminate the pointer to the HEAP.
    928. 

  928.   HEAP32[(((outPtr)+(iChar*4))>>2)]=0;
    929. 

  929. }
    930. 

  930. Module['stringToUTF32'] = stringToUTF32;
    931. 

  931. 

  932. function demangle(func) {
    933. 

  933.   var i = 3;
    934. 

  934.   // params, etc.
    935. 

  935.   var basicTypes = {
    936. 

  936.     'v': 'void',
    937. 

  937.     'b': 'bool',
    938. 

  938.     'c': 'char',
    939. 

  939.     's': 'short',
    940. 

  940.     'i': 'int',
    941. 

  941.     'l': 'long',
    942. 

  942.     'f': 'float',
    943. 

  943.     'd': 'double',
    944. 

  944.     'w': 'wchar_t',
    945. 

  945.     'a': 'signed char',
    946. 

  946.     'h': 'unsigned char',
    947. 

  947.     't': 'unsigned short',
    948. 

  948.     'j': 'unsigned int',
    949. 

  949.     'm': 'unsigned long',
    950. 

  950.     'x': 'long long',
    951. 

  951.     'y': 'unsigned long long',
    952. 

  952.     'z': '...'
    953. 

  953.   };
    954. 

  954.   var subs = [];
    955. 

  955.   var first = true;
    956. 

  956.   function dump(x) {
    957. 

  957.     //return;
    958. 

  958.     if (x) Module.print(x);
    959. 

  959.     Module.print(func);
    960. 

  960.     var pre = '';
    961. 

  961.     for (var a = 0; a < i; a++) pre += ' ';
    962. 

  962.     Module.print (pre + '^');
    963. 

  963.   }
    964. 

  964.   function parseNested() {
    965. 

  965.     i++;
    966. 

  966.     if (func[i] === 'K') i++; // ignore const
    967. 

  967.     var parts = [];
    968. 

  968.     while (func[i] !== 'E') {
    969. 

  969.       if (func[i] === 'S') { // substitution
    970. 

  970.         i++;
    971. 

  971.         var next = func.indexOf('_', i);
    972. 

  972.         var num = func.substring(i, next) || 0;
    973. 

  973.         parts.push(subs[num] || '?');
    974. 

  974.         i = next+1;
    975. 

  975.         continue;
    976. 

  976.       }
    977. 

  977.       if (func[i] === 'C') { // constructor
    978. 

  978.         parts.push(parts[parts.length-1]);
    979. 

  979.         i += 2;
    980. 

  980.         continue;
    981. 

  981.       }
    982. 

  982.       var size = parseInt(func.substr(i));
    983. 

  983.       var pre = size.toString().length;
    984. 

  984.       if (!size || !pre) { i--; break; } // counter i++ below us
    985. 

  985.       var curr = func.substr(i + pre, size);
    986. 

  986.       parts.push(curr);
    987. 

  987.       subs.push(curr);
    988. 

  988.       i += pre + size;
    989. 

  989.     }
    990. 

  990.     i++; // skip E
    991. 

  991.     return parts;
    992. 

  992.   }
    993. 

  993.   function parse(rawList, limit, allowVoid) { // main parser
    994. 

  994.     limit = limit || Infinity;
    995. 

  995.     var ret = '', list = [];
    996. 

  996.     function flushList() {
    997. 

  997.       return '(' + list.join(', ') + ')';
    998. 

  998.     }
    999. 

  999.     var name;
    1000. 

  1000.     if (func[i] === 'N') {
    1001. 

  1001.       // namespaced N-E
    1002. 

  1002.       name = parseNested().join('::');
    1003. 

  1003.       limit--;
    1004. 

  1004.       if (limit === 0) return rawList ? [name] : name;
    1005. 

  1005.     } else {
    1006. 

  1006.       // not namespaced
    1007. 

  1007.       if (func[i] === 'K' || (first && func[i] === 'L')) i++; // ignore const and first 'L'
    1008. 

  1008.       var size = parseInt(func.substr(i));
    1009. 

  1009.       if (size) {
    1010. 

  1010.         var pre = size.toString().length;
    1011. 

  1011.         name = func.substr(i + pre, size);
    1012. 

  1012.         i += pre + size;
    1013. 

  1013.       }
    1014. 

  1014.     }
    1015. 

  1015.     first = false;
    1016. 

  1016.     if (func[i] === 'I') {
    1017. 

  1017.       i++;
    1018. 

  1018.       var iList = parse(true);
    1019. 

  1019.       var iRet = parse(true, 1, true);
    1020. 

  1020.       ret += iRet[0] + ' ' + name + '<' + iList.join(', ') + '>';
    1021. 

  1021.     } else {
    1022. 

  1022.       ret = name;
    1023. 

  1023.     }
    1024. 

  1024.     paramLoop: while (i < func.length && limit-- > 0) {
    1025. 

  1025.       //dump('paramLoop');
    1026. 

  1026.       var c = func[i++];
    1027. 

  1027.       if (c in basicTypes) {
    1028. 

  1028.         list.push(basicTypes[c]);
    1029. 

  1029.       } else {
    1030. 

  1030.         switch (c) {
    1031. 

  1031.           case 'P': list.push(parse(true, 1, true)[0] + '*'); break; // pointer
    1032. 

  1032.           case 'R': list.push(parse(true, 1, true)[0] + '&'); break; // reference
    1033. 

  1033.           case 'L': { // literal
    1034. 

  1034.             i++; // skip basic type
    1035. 

  1035.             var end = func.indexOf('E', i);
    1036. 

  1036.             var size = end - i;
    1037. 

  1037.             list.push(func.substr(i, size));
    1038. 

  1038.             i += size + 2; // size + 'EE'
    1039. 

  1039.             break;
    1040. 

  1040.           }
    1041. 

  1041.           case 'A': { // array
    1042. 

  1042.             var size = parseInt(func.substr(i));
    1043. 

  1043.             i += size.toString().length;
    1044. 

  1044.             if (func[i] !== '_') throw '?';
    1045. 

  1045.             i++; // skip _
    1046. 

  1046.             list.push(parse(true, 1, true)[0] + ' [' + size + ']');
    1047. 

  1047.             break;
    1048. 

  1048.           }
    1049. 

  1049.           case 'E': break paramLoop;
    1050. 

  1050.           default: ret += '?' + c; break paramLoop;
    1051. 

  1051.         }
    1052. 

  1052.       }
    1053. 

  1053.     }
    1054. 

  1054.     if (!allowVoid && list.length === 1 && list[0] === 'void') list = []; // avoid (void)
    1055. 

  1055.     if (rawList) {
    1056. 

  1056.       if (ret) {
    1057. 

  1057.         list.push(ret + '?');
    1058. 

  1058.       }
    1059. 

  1059.       return list;
    1060. 

  1060.     } else {
    1061. 

  1061.       return ret + flushList();
    1062. 

  1062.     }
    1063. 

  1063.   }
    1064. 

  1064.   try {
    1065. 

  1065.     // Special-case the entry point, since its name differs from other name mangling.
    1066. 

  1066.     if (func == 'Object._main' || func == '_main') {
    1067. 

  1067.       return 'main()';
    1068. 

  1068.     }
    1069. 

  1069.     if (typeof func === 'number') func = Pointer_stringify(func);
    1070. 

  1070.     if (func[0] !== '_') return func;
    1071. 

  1071.     if (func[1] !== '_') return func; // C function
    1072. 

  1072.     if (func[2] !== 'Z') return func;
    1073. 

  1073.     switch (func[3]) {
    1074. 

  1074.       case 'n': return 'operator new()';
    1075. 

  1075.       case 'd': return 'operator delete()';
    1076. 

  1076.     }
    1077. 

  1077.     return parse();
    1078. 

  1078.   } catch(e) {
    1079. 

  1079.     return func;
    1080. 

  1080.   }
    1081. 

  1081. }
    1082. 

  1082. 

  1083. function demangleAll(text) {
    1084. 

  1084.   return text.replace(/__Z[\w\d_]+/g, function(x) { var y = demangle(x); return x === y ? x : (x + ' [' + y + ']') });
    1085. 

  1085. }
    1086. 

  1086. 

  1087. function stackTrace() {
    1088. 

  1088.   var stack = new Error().stack;
    1089. 

  1089.   return stack ? demangleAll(stack) : '(no stack trace available)'; // Stack trace is not available at least on IE10 and Safari 6.
    1090. 

  1090. }
    1091. 

  1091. 

  1092. // Memory management
    1093. 

  1093. 

  1094. var PAGE_SIZE = 4096;
    1095. 

  1095. function alignMemoryPage(x) {
    1096. 

  1096.   return (x+4095)&-4096;
    1097. 

  1097. }
    1098. 

  1098. 

  1099. var HEAP;
    1100. 

  1100. var HEAP8, HEAPU8, HEAP16, HEAPU16, HEAP32, HEAPU32, HEAPF32, HEAPF64;
    1101. 

  1101. 

  1102. var STATIC_BASE = 0, STATICTOP = 0, staticSealed = false; // static area
    1103. 

  1103. var STACK_BASE = 0, STACKTOP = 0, STACK_MAX = 0; // stack area
    1104. 

  1104. var DYNAMIC_BASE = 0, DYNAMICTOP = 0; // dynamic area handled by sbrk
    1105. 

  1105. 

  1106. function enlargeMemory() {
    1107. 

  1107.   abort('Cannot enlarge memory arrays. Either (1) compile with -s TOTAL_MEMORY=X with X higher than the current value ' + TOTAL_MEMORY + ', (2) compile with ALLOW_MEMORY_GROWTH which adjusts the size at runtime but prevents some optimizations, or (3) set Module.TOTAL_MEMORY before the program runs.');
    1108. 

  1108. }
    1109. 

  1109. 

  1110. var TOTAL_STACK = Module['TOTAL_STACK'] || 5242880;
    1111. 

  1111. var TOTAL_MEMORY = Module['TOTAL_MEMORY'] || 134217728;
    1112. 

  1112. var FAST_MEMORY = Module['FAST_MEMORY'] || 2097152;
    1113. 

  1113. 

  1114. var totalMemory = 4096;
    1115. 

  1115. while (totalMemory < TOTAL_MEMORY || totalMemory < 2*TOTAL_STACK) {
    1116. 

  1116.   if (totalMemory < 16*1024*1024) {
    1117. 

  1117.     totalMemory *= 2;
    1118. 

  1118.   } else {
    1119. 

  1119.     totalMemory += 16*1024*1024
    1120. 

  1120.   }
    1121. 

  1121. }
    1122. 

  1122. if (totalMemory !== TOTAL_MEMORY) {
    1123. 

  1123.   Module.printErr('increasing TOTAL_MEMORY to ' + totalMemory + ' to be more reasonable');
    1124. 

  1124.   TOTAL_MEMORY = totalMemory;
    1125. 

  1125. }
    1126. 

  1126. 

  1127. // Initialize the runtime's memory
    1128. 

  1128. // check for full engine support (use string 'subarray' to avoid closure compiler confusion)
    1129. 

  1129. assert(typeof Int32Array !== 'undefined' && typeof Float64Array !== 'undefined' && !!(new Int32Array(1)['subarray']) && !!(new Int32Array(1)['set']),
    1130. 

  1130.        'JS engine does not provide full typed array support');
    1131. 

  1131. 

  1132. var buffer = new ArrayBuffer(TOTAL_MEMORY);
    1133. 

  1133. HEAP8 = new Int8Array(buffer);
    1134. 

  1134. HEAP16 = new Int16Array(buffer);
    1135. 

  1135. HEAP32 = new Int32Array(buffer);
    1136. 

  1136. HEAPU8 = new Uint8Array(buffer);
    1137. 

  1137. HEAPU16 = new Uint16Array(buffer);
    1138. 

  1138. HEAPU32 = new Uint32Array(buffer);
    1139. 

  1139. HEAPF32 = new Float32Array(buffer);
    1140. 

  1140. HEAPF64 = new Float64Array(buffer);
    1141. 

  1141. 

  1142. // Endianness check (note: assumes compiler arch was little-endian)
    1143. 

  1143. HEAP32[0] = 255;
    1144. 

  1144. assert(HEAPU8[0] === 255 && HEAPU8[3] === 0, 'Typed arrays 2 must be run on a little-endian system');
    1145. 

  1145. 

  1146. Module['HEAP'] = HEAP;
    1147. 

  1147. Module['HEAP8'] = HEAP8;
    1148. 

  1148. Module['HEAP16'] = HEAP16;
    1149. 

  1149. Module['HEAP32'] = HEAP32;
    1150. 

  1150. Module['HEAPU8'] = HEAPU8;
    1151. 

  1151. Module['HEAPU16'] = HEAPU16;
    1152. 

  1152. Module['HEAPU32'] = HEAPU32;
    1153. 

  1153. Module['HEAPF32'] = HEAPF32;
    1154. 

  1154. Module['HEAPF64'] = HEAPF64;
    1155. 

  1155. 

  1156. function callRuntimeCallbacks(callbacks) {
    1157. 

  1157.   while(callbacks.length > 0) {
    1158. 

  1158.     var callback = callbacks.shift();
    1159. 

  1159.     if (typeof callback == 'function') {
    1160. 

  1160.       callback();
    1161. 

  1161.       continue;
    1162. 

  1162.     }
    1163. 

  1163.     var func = callback.func;
    1164. 

  1164.     if (typeof func === 'number') {
    1165. 

  1165.       if (callback.arg === undefined) {
    1166. 

  1166.         Runtime.dynCall('v', func);
    1167. 

  1167.       } else {
    1168. 

  1168.         Runtime.dynCall('vi', func, [callback.arg]);
    1169. 

  1169.       }
    1170. 

  1170.     } else {
    1171. 

  1171.       func(callback.arg === undefined ? null : callback.arg);
    1172. 

  1172.     }
    1173. 

  1173.   }
    1174. 

  1174. }
    1175. 

  1175. 

  1176. var __ATPRERUN__  = []; // functions called before the runtime is initialized
    1177. 

  1177. var __ATINIT__    = []; // functions called during startup
    1178. 

  1178. var __ATMAIN__    = []; // functions called when main() is to be run
    1179. 

  1179. var __ATEXIT__    = []; // functions called during shutdown
    1180. 

  1180. var __ATPOSTRUN__ = []; // functions called after the runtime has exited
    1181. 

  1181. 

  1182. var runtimeInitialized = false;
    1183. 

  1183. 

  1184. function preRun() {
    1185. 

  1185.   // compatibility - merge in anything from Module['preRun'] at this time
    1186. 

  1186.   if (Module['preRun']) {
    1187. 

  1187.     if (typeof Module['preRun'] == 'function') Module['preRun'] = [Module['preRun']];
    1188. 

  1188.     while (Module['preRun'].length) {
    1189. 

  1189.       addOnPreRun(Module['preRun'].shift());
    1190. 

  1190.     }
    1191. 

  1191.   }
    1192. 

  1192.   callRuntimeCallbacks(__ATPRERUN__);
    1193. 

  1193. }
    1194. 

  1194. 

  1195. function ensureInitRuntime() {
    1196. 

  1196.   if (runtimeInitialized) return;
    1197. 

  1197.   runtimeInitialized = true;
    1198. 

  1198.   callRuntimeCallbacks(__ATINIT__);
    1199. 

  1199. }
    1200. 

  1200. 

  1201. function preMain() {
    1202. 

  1202.   callRuntimeCallbacks(__ATMAIN__);
    1203. 

  1203. }
    1204. 

  1204. 

  1205. function exitRuntime() {
    1206. 

  1206.   callRuntimeCallbacks(__ATEXIT__);
    1207. 

  1207. }
    1208. 

  1208. 

  1209. function postRun() {
    1210. 

  1210.   // compatibility - merge in anything from Module['postRun'] at this time
    1211. 

  1211.   if (Module['postRun']) {
    1212. 

  1212.     if (typeof Module['postRun'] == 'function') Module['postRun'] = [Module['postRun']];
    1213. 

  1213.     while (Module['postRun'].length) {
    1214. 

  1214.       addOnPostRun(Module['postRun'].shift());
    1215. 

  1215.     }
    1216. 

  1216.   }
    1217. 

  1217.   callRuntimeCallbacks(__ATPOSTRUN__);
    1218. 

  1218. }
    1219. 

  1219. 

  1220. function addOnPreRun(cb) {
    1221. 

  1221.   __ATPRERUN__.unshift(cb);
    1222. 

  1222. }
    1223. 

  1223. Module['addOnPreRun'] = Module.addOnPreRun = addOnPreRun;
    1224. 

  1224. 

  1225. function addOnInit(cb) {
    1226. 

  1226.   __ATINIT__.unshift(cb);
    1227. 

  1227. }
    1228. 

  1228. Module['addOnInit'] = Module.addOnInit = addOnInit;
    1229. 

  1229. 

  1230. function addOnPreMain(cb) {
    1231. 

  1231.   __ATMAIN__.unshift(cb);
    1232. 

  1232. }
    1233. 

  1233. Module['addOnPreMain'] = Module.addOnPreMain = addOnPreMain;
    1234. 

  1234. 

  1235. function addOnExit(cb) {
    1236. 

  1236.   __ATEXIT__.unshift(cb);
    1237. 

  1237. }
    1238. 

  1238. Module['addOnExit'] = Module.addOnExit = addOnExit;
    1239. 

  1239. 

  1240. function addOnPostRun(cb) {
    1241. 

  1241.   __ATPOSTRUN__.unshift(cb);
    1242. 

  1242. }
    1243. 

  1243. Module['addOnPostRun'] = Module.addOnPostRun = addOnPostRun;
    1244. 

  1244. 

  1245. // Tools
    1246. 

  1246. 

  1247. // This processes a JS string into a C-line array of numbers, 0-terminated.
    1248. 

  1248. // For LLVM-originating strings, see parser.js:parseLLVMString function
    1249. 

  1249. function intArrayFromString(stringy, dontAddNull, length /* optional */) {
    1250. 

  1250.   var ret = (new Runtime.UTF8Processor()).processJSString(stringy);
    1251. 

  1251.   if (length) {
    1252. 

  1252.     ret.length = length;
    1253. 

  1253.   }
    1254. 

  1254.   if (!dontAddNull) {
    1255. 

  1255.     ret.push(0);
    1256. 

  1256.   }
    1257. 

  1257.   return ret;
    1258. 

  1258. }
    1259. 

  1259. Module['intArrayFromString'] = intArrayFromString;
    1260. 

  1260. 

  1261. function intArrayToString(array) {
    1262. 

  1262.   var ret = [];
    1263. 

  1263.   for (var i = 0; i < array.length; i++) {
    1264. 

  1264.     var chr = array[i];
    1265. 

  1265.     if (chr > 0xFF) {
    1266. 

  1266.       chr &= 0xFF;
    1267. 

  1267.     }
    1268. 

  1268.     ret.push(String.fromCharCode(chr));
    1269. 

  1269.   }
    1270. 

  1270.   return ret.join('');
    1271. 

  1271. }
    1272. 

  1272. Module['intArrayToString'] = intArrayToString;
    1273. 

  1273. 

  1274. // Write a Javascript array to somewhere in the heap
    1275. 

  1275. function writeStringToMemory(string, buffer, dontAddNull) {
    1276. 

  1276.   var array = intArrayFromString(string, dontAddNull);
    1277. 

  1277.   var i = 0;
    1278. 

  1278.   while (i < array.length) {
    1279. 

  1279.     var chr = array[i];
    1280. 

  1280.     HEAP8[(((buffer)+(i))|0)]=chr;
    1281. 

  1281.     i = i + 1;
    1282. 

  1282.   }
    1283. 

  1283. }
    1284. 

  1284. Module['writeStringToMemory'] = writeStringToMemory;
    1285. 

  1285. 

  1286. function writeArrayToMemory(array, buffer) {
    1287. 

  1287.   for (var i = 0; i < array.length; i++) {
    1288. 

  1288.     HEAP8[(((buffer)+(i))|0)]=array[i];
    1289. 

  1289.   }
    1290. 

  1290. }
    1291. 

  1291. Module['writeArrayToMemory'] = writeArrayToMemory;
    1292. 

  1292. 

  1293. function writeAsciiToMemory(str, buffer, dontAddNull) {
    1294. 

  1294.   for (var i = 0; i < str.length; i++) {
    1295. 

  1295.     HEAP8[(((buffer)+(i))|0)]=str.charCodeAt(i);
    1296. 

  1296.   }
    1297. 

  1297.   if (!dontAddNull) HEAP8[(((buffer)+(str.length))|0)]=0;
    1298. 

  1298. }
    1299. 

  1299. Module['writeAsciiToMemory'] = writeAsciiToMemory;
    1300. 

  1300. 

  1301. function unSign(value, bits, ignore) {
    1302. 

  1302.   if (value >= 0) {
    1303. 

  1303.     return value;
    1304. 

  1304.   }
    1305. 

  1305.   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
    1306. 

  1306.                     : Math.pow(2, bits)         + value;
    1307. 

  1307. }
    1308. 

  1308. function reSign(value, bits, ignore) {
    1309. 

  1309.   if (value <= 0) {
    1310. 

  1310.     return value;
    1311. 

  1311.   }
    1312. 

  1312.   var half = bits <= 32 ? Math.abs(1 << (bits-1)) // abs is needed if bits == 32
    1313. 

  1313.                         : Math.pow(2, bits-1);
    1314. 

  1314.   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
    1315. 

  1315.                                                        // but, in general there is no perfect solution here. With 64-bit ints, we get rounding and errors
    1316. 

  1316.                                                        // TODO: In i64 mode 1, resign the two parts separately and safely
    1317. 

  1317.     value = -2*half + value; // Cannot bitshift half, as it may be at the limit of the bits JS uses in bitshifts
    1318. 

  1318.   }
    1319. 

  1319.   return value;
    1320. 

  1320. }
    1321. 

  1321. 

  1322. // check for imul support, and also for correctness ( https://bugs.webkit.org/show_bug.cgi?id=126345 )
    1323. 

  1323. if (!Math['imul'] || Math['imul'](0xffffffff, 5) !== -5) Math['imul'] = function imul(a, b) {
    1324. 

  1324.   var ah  = a >>> 16;
    1325. 

  1325.   var al = a & 0xffff;
    1326. 

  1326.   var bh  = b >>> 16;
    1327. 

  1327.   var bl = b & 0xffff;
    1328. 

  1328.   return (al*bl + ((ah*bl + al*bh) << 16))|0;
    1329. 

  1329. };
    1330. 

  1330. Math.imul = Math['imul'];
    1331. 

  1331. 

  1332. 

  1333. var Math_abs = Math.abs;
    1334. 

  1334. var Math_cos = Math.cos;
    1335. 

  1335. var Math_sin = Math.sin;
    1336. 

  1336. var Math_tan = Math.tan;
    1337. 

  1337. var Math_acos = Math.acos;
    1338. 

  1338. var Math_asin = Math.asin;
    1339. 

  1339. var Math_atan = Math.atan;
    1340. 

  1340. var Math_atan2 = Math.atan2;
    1341. 

  1341. var Math_exp = Math.exp;
    1342. 

  1342. var Math_log = Math.log;
    1343. 

  1343. var Math_sqrt = Math.sqrt;
    1344. 

  1344. var Math_ceil = Math.ceil;
    1345. 

  1345. var Math_floor = Math.floor;
    1346. 

  1346. var Math_pow = Math.pow;
    1347. 

  1347. var Math_imul = Math.imul;
    1348. 

  1348. var Math_fround = Math.fround;
    1349. 

  1349. var Math_min = Math.min;
    1350. 

  1350. 

  1351. // A counter of dependencies for calling run(). If we need to
    1352. 

  1352. // do asynchronous work before running, increment this and
    1353. 

  1353. // decrement it. Incrementing must happen in a place like
    1354. 

  1354. // PRE_RUN_ADDITIONS (used by emcc to add file preloading).
    1355. 

  1355. // Note that you can add dependencies in preRun, even though
    1356. 

  1356. // it happens right before run - run will be postponed until
    1357. 

  1357. // the dependencies are met.
    1358. 

  1358. var runDependencies = 0;
    1359. 

  1359. var runDependencyWatcher = null;
    1360. 

  1360. var dependenciesFulfilled = null; // overridden to take different actions when all run dependencies are fulfilled
    1361. 

  1361. 

  1362. function addRunDependency(id) {
    1363. 

  1363.   runDependencies++;
    1364. 

  1364.   if (Module['monitorRunDependencies']) {
    1365. 

  1365.     Module['monitorRunDependencies'](runDependencies);
    1366. 

  1366.   }
    1367. 

  1367. }
    1368. 

  1368. Module['addRunDependency'] = addRunDependency;
    1369. 

  1369. function removeRunDependency(id) {
    1370. 

  1370.   runDependencies--;
    1371. 

  1371.   if (Module['monitorRunDependencies']) {
    1372. 

  1372.     Module['monitorRunDependencies'](runDependencies);
    1373. 

  1373.   }
    1374. 

  1374.   if (runDependencies == 0) {
    1375. 

  1375.     if (runDependencyWatcher !== null) {
    1376. 

  1376.       clearInterval(runDependencyWatcher);
    1377. 

  1377.       runDependencyWatcher = null;
    1378. 

  1378.     }
    1379. 

  1379.     if (dependenciesFulfilled) {
    1380. 

  1380.       var callback = dependenciesFulfilled;
    1381. 

  1381.       dependenciesFulfilled = null;
    1382. 

  1382.       callback(); // can add another dependenciesFulfilled
    1383. 

  1383.     }
    1384. 

  1384.   }
    1385. 

  1385. }
    1386. 

  1386. Module['removeRunDependency'] = removeRunDependency;
    1387. 

  1387. 

  1388. Module["preloadedImages"] = {}; // maps url to image data
    1389. 

  1389. Module["preloadedAudios"] = {}; // maps url to audio data
    1390. 

  1390. 

  1391. 

  1392. var memoryInitializer = null;
    1393. 

  1393. 

  1394. // === Body ===
    1395. 

  1395. 

  1396. 

  1397. 

  1398. 

  1399. 

  1400. STATIC_BASE = 8;
    1401. 

  1401. 

  1402. STATICTOP = STATIC_BASE + Runtime.alignMemory(13467);
    1403. 

  1403. /* global initializers */ __ATINIT__.push();
    1404. 

  1404. 

  1405. 

  1406. /* memory initializer */ allocate([99,97,110,110,111,116,32,99,114,101,97,116,101,32,115,116,97,116,101,58,32,110,111,116,32,101,110,111,117,103,104,32,109,101,109,111,114,121,0,0,40,101,114,114,111,114,32,111,98,106,101,99,116,32,105,115,32,110,111,116,32,97,32,115,116,114,105,110,103,41,0,0,88,0,0,0,0,0,0,0,108,117,97,0,0,0,0,0,76,85,65,95,78,79,69,78,86,0,0,0,0,0,0,0,116,111,111,32,109,97,110,121,32,114,101,115,117,108,116,115,32,116,111,32,112,114,105,110,116,0,0,0,0,0,0,0,112,114,105,110,116,0,0,0,101,114,114,111,114,32,99,97,108,108,105,110,103,32,39,112,114,105,110,116,39,32,40,37,115,41,0,0,0,0,0,0,10,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,105,110,116,101,114,114,117,112,116,101,100,33,0,0,0,0,95,95,116,111,115,116,114,105,110,103,0,0,0,0,0,0,40,110,111,32,101,114,114,111,114,32,109,101,115,115,97,103,101,41,0,0,0,0,0,0,61,115,116,100,105,110,0,0,60,101,111,102,62,0,0,0,114,101,116,117,114,110,32,37,115,0,0,0,0,0,0,0,95,80,82,79,77,80,84,0,95,80,82,79,77,80,84,50,0,0,0,0,0,0,0,0,62,32,0,0,0,0,0,0,62,62,32,0,0,0,0,0,97,114,103,0,0,0,0,0,45,0,0,0,0,0,0,0,45,45,0,0,0,0,0,0,116,111,111,32,109,97,110,121,32,97,114,103,117,109,101,110,116,115,32,116,111,32,115,99,114,105,112,116,0,0,0,0,61,40,99,111,109,109,97,110,100,32,108,105,110,101,41,0,114,101,113,117,105,114,101,0,61,76,85,65,95,73,78,73,84,95,53,95,50,0,0,0,61,76,85,65,95,73,78,73,84,0,0,0,0,0,0,0,76,117,97,32,53,46,50,46,50,32,32,67,111,112,121,114,105,103,104,116,32,40,67,41,32,49,57,57,52,45,50,48,49,51,32,76,117,97,46,111,114,103,44,32,80,85,67,45,82,105,111,0,0,0,0,0,37,115,58,32,0,0,0,0,39,37,115,39,32,110,101,101,100,115,32,97,114,103,117,109,101,110,116,10,0,0,0,0,117,110,114,101,99,111,103,110,105,122,101,100,32,111,112,116,105,111,110,32,39,37,115,39,10,0,0,0,0,0,0,0,117,115,97,103,101,58,32,37,115,32,91,111,112,116,105,111,110,115,93,32,91,115,99,114,105,112,116,32,91,97,114,103,115,93,93,10,65,118,97,105,108,97,98,108,101,32,111,112,116,105,111,110,115,32,97,114,101,58,10,32,32,45,101,32,115,116,97,116,32,32,101,120,101,99,117,116,101,32,115,116,114,105,110,103,32,39,115,116,97,116,39,10,32,32,45,105,32,32,32,32,32,32,32,101,110,116,101,114,32,105,110,116,101,114,97,99,116,105,118,101,32,109,111,100,101,32,97,102,116,101,114,32,101,120,101,99,117,116,105,110,103,32,39,115,99,114,105,112,116,39,10,32,32,45,108,32,110,97,109,101,32,32,114,101,113,117,105,114,101,32,108,105,98,114,97,114,121,32,39,110,97,109,101,39,10,32,32,45,118,32,32,32,32,32,32,32,115,104,111,119,32,118,101,114,115,105,111,110,32,105,110,102,111,114,109,97,116,105,111,110,10,32,32,45,69,32,32,32,32,32,32,32,105,103,110,111,114,101,32,101,110,118,105,114,111,110,109,101,110,116,32,118,97,114,105,97,98,108,101,115,10,32,32,45,45,32,32,32,32,32,32,32,115,116,111,112,32,104,97,110,100,108,105,110,103,32,111,112,116,105,111,110,115,10,32,32,45,32,32,32,32,32,32,32,32,115,116,111,112,32,104,97,110,100,108,105,110,103,32,111,112,116,105,111,110,115,32,97,110,100,32,101,120,101,99,117,116,101,32,115,116,100,105,110,10,0,0,0,0,0,0,0,37,115,10,0,0,0,0,0,0,0,0,0,0,96,127,64,63,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,37,115,10,0,0,0,0,0,115,116,97,99,107,32,116,114,97,99,101,98,97,99,107,58,0,0,0,0,0,0,0,0,10,9,46,46,46,0,0,0,83,108,110,116,0,0,0,0,10,9,37,115,58,0,0,0,37,100,58,0,0,0,0,0,32,105,110,32,0,0,0,0,10,9,40,46,46,46,116,97,105,108,32,99,97,108,108,115,46,46,46,41,0,0,0,0,98,97,100,32,97,114,103,117,109,101,110,116,32,35,37,100,32,40,37,115,41,0,0,0,110,0,0,0,0,0,0,0,109,101,116,104,111,100,0,0,99,97,108,108,105,110,103,32,39,37,115,39,32,111,110,32,98,97,100,32,115,101,108,102,32,40,37,115,41,0,0,0,63,0,0,0,0,0,0,0,98,97,100,32,97,114,103,117,109,101,110,116,32,35,37,100,32,116,111,32,39,37,115,39,32,40,37,115,41,0,0,0,83,108,0,0,0,0,0,0,37,115,58,37,100,58,32,0,0,0,0,0,0,0,0,0,37,115,58,32,37,115,0,0,101,120,105,116,0,0,0,0,105,110,118,97,108,105,100,32,111,112,116,105,111,110,32,39,37,115,39,0,0,0,0,0,115,116,97,99,107,32,111,118,101,114,102,108,111,119,32,40,37,115,41,0,0,0,0,0,115,116,97,99,107,32,111,118,101,114,102,108,111,119,0,0,118,97,108,117,101,32,101,120,112,101,99,116,101,100,0,0,98,117,102,102,101,114,32,116,111,111,32,108,97,114,103,101,0,0,0,0,0,0,0,0,61,115,116,100,105,110,0,0,64,37,115,0,0,0,0,0,114,0,0,0,0,0,0,0,111,112,101,110,0,0,0,0,114,98,0,0,0,0,0,0,114,101,111,112,101,110,0,0,114,101,97,100,0,0,0,0,111,98,106,101,99,116,32,108,101,110,103,116,104,32,105,115,32,110,111,116,32,97,32,110,117,109,98,101,114,0,0,0,95,95,116,111,115,116,114,105,110,103,0,0,0,0,0,0,116,114,117,101,0,0,0,0,102,97,108,115,101,0,0,0,110,105,108,0,0,0,0,0,37,115,58,32,37,112,0,0,95,76,79,65,68,69,68,0,110,97,109,101,32,99,111,110,102,108,105,99,116,32,102,111,114,32,109,111,100,117,108,101,32,39,37,115,39,0,0,0,116,111,111,32,109,97,110,121,32,117,112,118,97,108,117,101,115,0,0,0,0,0,0,0,109,117,108,116,105,112,108,101,32,76,117,97,32,86,77,115,32,100,101,116,101,99,116,101,100,0,0,0,0,0,0,0,118,101,114,115,105,111,110,32,109,105,115,109,97,116,99,104,58,32,97,112,112,46,32,110,101,101,100,115,32,37,102,44,32,76,117,97,32,99,111,114,101,32,112,114,111,118,105,100,101,115,32,37,102,0,0,0,98,97,100,32,99,111,110,118,101,114,115,105,111,110,32,110,117,109,98,101,114,45,62,105,110,116,59,32,109,117,115,116,32,114,101,99,111,109,112,105,108,101,32,76,117,97,32,119,105,116,104,32,112,114,111,112,101,114,32,115,101,116,116,105,110,103,115,0,0,0,0,0,80,65,78,73,67,58,32,117,110,112,114,111,116,101,99,116,101,100,32,101,114,114,111,114,32,105,110,32,99,97,108,108,32,116,111,32,76,117,97,32,65,80,73,32,40,37,115,41,10,0,0,0,0,0,0,0,239,187,191,0,0,0,0,0,99,97,110,110,111,116,32,37,115,32,37,115,58,32,37,115,0,0,0,0,0,0,0,0,37,115,32,101,120,112,101,99,116,101,100,44,32,103,111,116,32,37,115,0,0,0,0,0,102,0,0,0,0,0,0,0,46,0,0,0,0,0,0,0,102,117,110,99,116,105,111,110,32,39,37,115,39,0,0,0,109,97,105,110,32,99,104,117,110,107,0,0,0,0,0,0,102,117,110,99,116,105,111,110,32,60,37,115,58,37,100,62,0,0,0,0,0,0,0,0,97,116,116,101,109,112,116,32,116,111,32,37,115,32,37,115,32,39,37,115,39,32,40,97,32,37,115,32,118,97,108,117,101,41,0,0,0,0,0,0,97,116,116,101,109,112,116,32,116,111,32,37,115,32,97,32,37,115,32,118,97,108,117,101,0,0,0,0,0,0,0,0,99,111,110,99,97,116,101,110,97,116,101,0,0,0,0,0,112,101,114,102,111,114,109,32,97,114,105,116,104,109,101,116,105,99,32,111,110,0,0,0,97,116,116,101,109,112,116,32,116,111,32,99,111,109,112,97,114,101,32,116,119,111,32,37,115,32,118,97,108,117,101,115,0,0,0,0,0,0,0,0,97,116,116,101,109,112,116,32,116,111,32,99,111,109,112,97,114,101,32,37,115,32,119,105,116,104,32,37,115,0,0,0,37,115,58,37,100,58,32,37,115,0,0,0,0,0,0,0,108,111,99,97,108,0,0,0,95,69,78,86,0,0,0,0,103,108,111,98,97,108,0,0,102,105,101,108,100,0,0,0,117,112,118,97,108,117,101,0,99,111,110,115,116,97,110,116,0,0,0,0,0,0,0,0,109,101,116,104,111,100,0,0,63,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,102,111,114,32,105,116,101,114,97,116,111,114,0,0,0,0,109,101,116,97,109,101,116,104,111,100,0,0,0,0,0,0,61,91,67,93,0,0,0,0,67,0,0,0,0,0,0,0,61,63,0,0,0,0,0,0,109,97,105,110,0,0,0,0,76,117,97,0,0,0,0,0,40,42,116,101,109,112,111,114,97,114,121,41,0,0,0,0,40,42,118,97,114,97,114,103,41,0,0,0,0,0,0,0,115,116,97,99,107,32,111,118,101,114,102,108,111,119,0,0,67,32,115,116,97,99,107,32,111,118,101,114,102,108,111,119,0,0,0,0,0,0,0,0,97,116,116,101,109,112,116,32,116,111,32,121,105,101,108,100,32,97,99,114,111,115,115,32,97,32,67,45,99,97,108,108,32,98,111,117,110,100,97,114,121,0,0,0,0,0,0,0,97,116,116,101,109,112,116,32,116,111,32,121,105,101,108,100,32,102,114,111,109,32,111,117,116,115,105,100,101,32,97,32,99,111,114,111,117,116,105,110,101,0,0,0,0,0,0,0,98,105,110,97,114,121,0,0,116,101,120,116,0,0,0,0,97,116,116,101,109,112,116,32,116,111,32,108,111,97,100,32,97,32,37,115,32,99,104,117,110,107,32,40,109,111,100,101,32,105,115,32,39,37,115,39,41,0,0,0,0,0,0,0,101,114,114,111,114,32,105,110,32,101,114,114,111,114,32,104,97,110,100,108,105,110,103,0,99,97,110,110,111,116,32,114,101,115,117,109,101,32,110,111,110,45,115,117,115,112,101,110,100,101,100,32,99,111,114,111,117,116,105,110,101,0,0,0,99,97,110,110,111,116,32,114,101,115,117,109,101,32,100,101,97,100,32,99,111,114,111,117,116,105,110,101,0,0,0,0,99,97,108,108,0,0,0,0,110,111,32,109,101,115,115,97,103,101,0,0,0,0,0,0,101,114,114,111,114,32,105,110,32,95,95,103,99,32,109,101,116,97,109,101,116,104,111,100,32,40,37,115,41,0,0,0,95,80,82,69,76,79,65,68,0,0,0,0,0,0,0,0,95,71,0,0,0,0,0,0,112,97,99,107,97,103,101,0,99,111,114,111,117,116,105,110,101,0,0,0,0,0,0,0,116,97,98,108,101,0,0,0,105,111,0,0,0,0,0,0,111,115,0,0,0,0,0,0,115,116,114,105,110,103,0,0,98,105,116,51,50,0,0,0,109,97,116,104,0,0,0,0,100,101,98,117,103,0,0,0,144,11,0,0,1,0,0,0,152,11,0,0,2,0,0,0,48,13,0,0,3,0,0,0,160,11,0,0,4,0,0,0,56,13,0,0,5,0,0,0,64,13,0,0,6,0,0,0,72,13,0,0,7,0,0,0,168,11,0,0,8,0,0,0,80,13,0,0,9,0,0,0,88,13,0,0,10,0,0,0,192,11,0,0,11,0,0,0,0,0,0,0,0,0,0,0,95,73,79,95,105,110,112,117,116,0,0,0,0,0,0,0,115,116,100,105,110,0,0,0,95,73,79,95,111,117,116,112,117,116,0,0,0,0,0,0,115,116,100,111,117,116,0,0,115,116,100,101,114,114,0,0,70,73,76,69,42,0,0,0,99,97,110,110,111,116,32,99,108,111,115,101,32,115,116,97,110,100,97,114,100,32,102,105,108,101,0,0,0,0,0,0,95,95,105,110,100,101,120,0,144,11,0,0,1,0,0,0,152,11,0,0,12,0,0,0,160,11,0,0,13,0,0,0,168,11,0,0,14,0,0,0,176,11,0,0,15,0,0,0,184,11,0,0,16,0,0,0,192,11,0,0,17,0,0,0,200,11,0,0,18,0,0,0,208,11,0,0,19,0,0,0,0,0,0,0,0,0,0,0,99,108,111,115,101,0,0,0,102,108,117,115,104,0,0,0,108,105,110,101,115,0,0,0,114,101,97,100,0,0,0,0,115,101,101,107,0,0,0,0,115,101,116,118,98,117,102,0,119,114,105,116,101,0,0,0,95,95,103,99,0,0,0,0,95,95,116,111,115,116,114,105,110,103,0,0,0,0,0,0,102,105,108,101,32,40,99,108,111,115,101,100,41,0,0,0,102,105,108,101,32,40,37,112,41,0,0,0,0,0,0,0,37,46,49,52,103,0,0,0,97,116,116,101,109,112,116,32,116,111,32,117,115,101,32,97,32,99,108,111,115,101,100,32,102,105,108,101,0,0,0,0,2,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,72,12,0,0,80,12,0,0,88,12,0,0,0,0,0,0,110,111,0,0,0,0,0,0,102,117,108,108,0,0,0,0,108,105,110,101,0,0,0,0,0,0,0,0,1,0,0,0,2,0,0,0,0,0,0,0,128,12,0,0,136,12,0,0,144,12,0,0,0,0,0,0,115,101,116,0,0,0,0,0,99,117,114,0,0,0,0,0,101,110,100,0,0,0,0,0,110,111,116,32,97,110,32,105,110,116,101,103,101,114,32,105,110,32,112,114,111,112,101,114,32,114,97,110,103,101,0,0,116,111,111,32,109,97,110,121,32,97,114,103,117,109,101,110,116,115,0,0,0,0,0,0,105,110,118,97,108,105,100,32,111,112,116,105,111,110,0,0,105,110,118,97,108,105,100,32,102,111,114,109,97,116,0,0,37,108,102,0,0,0,0,0,116,111,111,32,109,97,110,121,32,111,112,116,105,111,110,115,0,0,0,0,0,0,0,0,102,105,108,101,32,105,115,32,97,108,114,101,97,100,121,32,99,108,111,115,101,100,0,0,37,115,0,0,0,0,0,0,105,110,112,117,116,0,0,0,111,112,101,110,0,0,0,0,111,117,116,112,117,116,0,0,112,111,112,101,110,0,0,0,116,109,112,102,105,108,101,0,116,121,112,101,0,0,0,0,115,116,97,110,100,97,114,100,32,37,115,32,102,105,108,101,32,105,115,32,99,108,111,115,101,100,0,0,0,0,0,0,99,108,111,115,101,100,32,102,105,108,101,0,0,0,0,0,102,105,108,101,0,0,0,0,114,0,0,0,0,0,0,0,39,112,111,112,101,110,39,32,110,111,116,32,115,117,112,112,111,114,116,101,100,0,0,0,119,0,0,0,0,0,0,0,99,97,110,110,111,116,32,111,112,101,110,32,102,105,108,101,32,39,37,115,39,32,40,37,115,41,0,0,0,0,0,0,114,119,97,0,0,0,0,0,105,110,118,97,108,105,100,32,109,111,100,101,0,0,0,0,240,14,0,0,20,0,0,0,248,14,0,0,21,0,0,0,0,15,0,0,22,0,0,0,8,15,0,0,23,0,0,0,16,15,0,0,24,0,0,0,24,15,0,0,25,0,0,0,32,15,0,0,26,0,0,0,40,15,0,0,27,0,0,0,48,15,0,0,28,0,0,0,56,15,0,0,29,0,0,0,64,15,0,0,30,0,0,0,72,15,0,0,31,0,0,0,80,15,0,0,32,0,0,0,88,15,0,0,33,0,0,0,96,15,0,0,34,0,0,0,104,15,0,0,35,0,0,0,112,15,0,0,36,0,0,0,120,15,0,0,37,0,0,0,128,15,0,0,38,0,0,0,136,15,0,0,39,0,0,0,144,15,0,0,40,0,0,0,152,15,0,0,41,0,0,0,160,15,0,0,42,0,0,0,176,15,0,0,43,0,0,0,184,15,0,0,44,0,0,0,192,15,0,0,45,0,0,0,200,15,0,0,46,0,0,0,208,15,0,0,47,0,0,0,0,0,0,0,0,0,0,0,112,105,0,0,0,0,0,0,104,117,103,101,0,0,0,0,97,98,115,0,0,0,0,0,97,99,111,115,0,0,0,0,97,115,105,110,0,0,0,0,97,116,97,110,50,0,0,0,97,116,97,110,0,0,0,0,99,101,105,108,0,0,0,0,99,111,115,104,0,0,0,0,99,111,115,0,0,0,0,0,100,101,103,0,0,0,0,0,101,120,112,0,0,0,0,0,102,108,111,111,114,0,0,0,102,109,111,100,0,0,0,0,102,114,101,120,112,0,0,0,108,100,101,120,112,0,0,0,108,111,103,49,48,0,0,0,108,111,103,0,0,0,0,0,109,97,120,0,0,0,0,0,109,105,110,0,0,0,0,0,109,111,100,102,0,0,0,0,112,111,119,0,0,0,0,0,114,97,100,0,0,0,0,0,114,97,110,100,111,109,0,0,114,97,110,100,111,109,115,101,101,100,0,0,0,0,0,0,115,105,110,104,0,0,0,0,115,105,110,0,0,0,0,0,115,113,114,116,0,0,0,0,116,97,110,104,0,0,0,0,116,97,110,0,0,0,0,0,105,110,116,101,114,118,97,108,32,105,115,32,101,109,112,116,121,0,0,0,0,0,0,0,119,114,111,110,103,32,110,117,109,98,101,114,32,111,102,32,97,114,103,117,109,101,110,116,115,0,0,0,0,0,0,0,116,111,111,32,109,97,110,121,32,37,115,32,40,108,105,109,105,116,32,105,115,32,37,100,41,0,0,0,0,0,0,0,109,101,109,111,114,121,32,97,108,108,111,99,97,116,105,111,110,32,101,114,114,111,114,58,32,98,108,111,99,107,32,116,111,111,32,98,105,103,0,0,95,67,76,73,66,83,0,0,95,95,103,99,0,0,0,0,16,20,0,0,48,0,0,0,24,20,0,0,49,0,0,0,40,20,0,0,50,0,0,0,0,0,0,0,0,0,0,0,108,111,97,100,101,114,115,0,115,101,97,114,99,104,101,114,115,0,0,0,0,0,0,0,112,97,116,104,0,0,0,0,76,85,65,95,80,65,84,72,95,53,95,50,0,0,0,0,76,85,65,95,80,65,84,72,0,0,0,0,0,0,0,0,47,117,115,114,47,108,111,99,97,108,47,115,104,97,114,101,47,108,117,97,47,53,46,50,47,63,46,108,117,97,59,47,117,115,114,47,108,111,99,97,108,47,115,104,97,114,101,47,108,117,97,47,53,46,50,47,63,47,105,110,105,116,46,108,117,97,59,47,117,115,114,47,108,111,99,97,108,47,108,105,98,47,108,117,97,47,53,46,50,47,63,46,108,117,97,59,47,117,115,114,47,108,111,99,97,108,47,108,105,98,47,108,117,97,47,53,46,50,47,63,47,105,110,105,116,46,108,117,97,59,46,47,63,46,108,117,97,0,0,0,0,0,0,0,99,112,97,116,104,0,0,0,76,85,65,95,67,80,65,84,72,95,53,95,50,0,0,0,76,85,65,95,67,80,65,84,72,0,0,0,0,0,0,0,47,117,115,114,47,108,111,99,97,108,47,108,105,98,47,108,117,97,47,53,46,50,47,63,46,115,111,59,47,117,115,114,47,108,111,99,97,108,47,108,105,98,47,108,117,97,47,53,46,50,47,108,111,97,100,97,108,108,46,115,111,59,46,47,63,46,115,111,0,0,0,0,47,10,59,10,63,10,33,10,45,10,0,0,0,0,0,0,99,111,110,102,105,103,0,0,95,76,79,65,68,69,68,0,108,111,97,100,101,100,0,0,95,80,82,69,76,79,65,68,0,0,0,0,0,0,0,0,112,114,101,108,111,97,100,0,32,18,0,0,51,0,0,0,40,18,0,0,52,0,0,0,0,0,0,0,0,0,0,0,109,111,100,117,108,101,0,0,114,101,113,117,105,114,101,0,39,112,97,99,107,97,103,101,46,115,101,97,114,99,104,101,114,115,39,32,109,117,115,116,32,98,101,32,97,32,116,97,98,108,101,0,0,0,0,0,109,111,100,117,108,101,32,39,37,115,39,32,110,111,116,32,102,111,117,110,100,58,37,115,0,0,0,0,0,0,0,0,95,78,65,77,69,0,0,0,102,0,0,0,0,0,0,0,39,109,111,100,117,108,101,39,32,110,111,116,32,99,97,108,108,101,100,32,102,114,111,109,32,97,32,76,117,97,32,102,117,110,99,116,105,111,110,0,95,77,0,0,0,0,0,0,95,80,65,67,75,65,71,69,0,0,0,0,0,0,0,0,59,59,0,0,0,0,0,0,59,1,59,0,0,0,0,0,1,0,0,0,0,0,0,0,76,85,65,95,78,79,69,78,86,0,0,0,0,0,0,0,47,0,0,0,0,0,0,0,10,9,110,111,32,109,111,100,117,108,101,32,39,37,115,39,32,105,110,32,102,105,108,101,32,39,37,115,39,0,0,0,101,114,114,111,114,32,108,111,97,100,105,110,103,32,109,111,100,117,108,101,32,39,37,115,39,32,102,114,111,109,32,102,105,108,101,32,39,37,115,39,58,10,9,37,115,0,0,0,46,0,0,0,0,0,0,0,95,0,0,0,0,0,0,0,108,117,97,111,112,101,110,95,37,115,0,0,0,0,0,0,100,121,110,97,109,105,99,32,108,105,98,114,97,114,105,101,115,32,110,111,116,32,101,110,97,98,108,101,100,59,32,99,104,101,99,107,32,121,111,117,114,32,76,117,97,32,105,110,115,116,97,108,108,97,116,105,111,110,0,0,0,0,0,0,39,112,97,99,107,97,103,101,46,37,115,39,32,109,117,115,116,32,98,101,32,97,32,115,116,114,105,110,103,0,0,0,63,0,0,0,0,0,0,0,10,9,110,111,32,102,105,108,101,32,39,37,115,39,0,0,114,0,0,0,0,0,0,0,10,9,110,111,32,102,105,101,108,100,32,112,97,99,107,97,103,101,46,112,114,101,108,111,97,100,91,39,37,115,39,93,0,0,0,0,0,0,0,0,108,111,97,100,108,105,98,0,115,101,97,114,99,104,112,97,116,104,0,0,0,0,0,0,115,101,101,97,108,108,0,0,95,95,105,110,100,101,120,0,97,98,115,101,110,116,0,0,105,110,105,116,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,2,2,3,3,3,3,4,4,4,4,4,4,4,4,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,110,78,0,0,0,0,0,0,120,88,0,0,0,0,0,0,40,110,117,108,108,41,0,0,37,112,0,0,0,0,0,0,37,0,0,0,0,0,0,0,105,110,118,97,108,105,100,32,111,112,116,105,111,110,32,39,37,37,37,99,39,32,116,111,32,39,108,117,97,95,112,117,115,104,102,115,116,114,105,110,103,39,0,0,0,0,0,0,46,46,46,0,0,0,0,0,91,115,116,114,105,110,103,32,34,0,0,0,0,0,0,0,34,93,0,0,0,0,0,0,96,113,65,84,80,80,92,108,60,16,60,84,108,124,124,124,124,124,124,96,96,96,104,34,188,188,188,132,228,84,84,16,98,98,4,98,20,81,80,23,88,22,0,0,53,0,0,0,96,22,0,0,54,0,0,0,104,22,0,0,55,0,0,0,120,22,0,0,56,0,0,0,128,22,0,0,57,0,0,0,136,22,0,0,58,0,0,0,144,22,0,0,59,0,0,0,152,22,0,0,60,0,0,0,160,22,0,0,61,0,0,0,176,22,0,0,62,0,0,0,184,22,0,0,63,0,0,0,0,0,0,0,0,0,0,0,99,108,111,99,107,0,0,0,100,97,116,101,0,0,0,0,100,105,102,102,116,105,109,101,0,0,0,0,0,0,0,0,101,120,101,99,117,116,101,0,101,120,105,116,0,0,0,0,103,101,116,101,110,118,0,0,114,101,109,111,118,101,0,0,114,101,110,97,109,101,0,0,115,101,116,108,111,99,97,108,101,0,0,0,0,0,0,0,116,105,109,101,0,0,0,0,116,109,112,110,97,109,101,0,117,110,97,98,108,101,32,116,111,32,103,101,110,101,114,97,116,101,32,97,32,117,110,105,113,117,101,32,102,105,108,101,110,97,109,101,0,0,0,0,115,101,99,0,0,0,0,0,109,105,110,0,0,0,0,0,104,111,117,114,0,0,0,0,100,97,121,0,0,0,0,0,109,111,110,116,104,0,0,0,121,101,97,114,0,0,0,0,105,115,100,115,116,0,0,0,102,105,101,108,100,32,39,37,115,39,32,109,105,115,115,105,110,103,32,105,110,32,100,97,116,101,32,116,97,98,108,101,0,0,0,0,0,0,0,0,6,0,0,0,3,0,0,0,0,0,0,0,4,0,0,0,1,0,0,0,2,0,0,0,128,23,0,0,136,23,0,0,144,23,0,0,152,23,0,0,168,23,0,0,176,22,0,0,0,0,0,0,0,0,0,0,97,108,108,0,0,0,0,0,99,111,108,108,97,116,101,0,99,116,121,112,101,0,0,0,109,111,110,101,116,97,114,121,0,0,0,0,0,0,0,0,110,117,109,101,114,105,99,0,37,99,0,0,0,0,0,0,42,116,0,0,0,0,0,0,119,100,97,121,0,0,0,0,121,100,97,121,0,0,0,0,97,65,98,66,99,100,72,73,106,109,77,112,83,85,119,87,120,88,121,89,122,37,0,0,105,110,118,97,108,105,100,32,99,111,110,118,101,114,115,105,111,110,32,115,112,101,99,105,102,105,101,114,32,39,37,37,37,115,39,0,0,0,0,0,60,37,115,62,32,97,116,32,108,105,110,101,32,37,100,32,110,111,116,32,105,110,115,105,100,101,32,97,32,108,111,111,112,0,0,0,0,0,0,0,110,111,32,118,105,115,105,98,108,101,32,108,97,98,101,108,32,39,37,115,39,32,102,111,114,32,60,103,111,116,111,62,32,97,116,32,108,105,110,101,32,37,100,0,0,0,0,0,60,103,111,116,111,32,37,115,62,32,97,116,32,108,105,110,101,32,37,100,32,106,117,109,112,115,32,105,110,116,111,32,116,104,101,32,115,99,111,112,101,32,111,102,32,108,111,99,97,108,32,39,37,115,39,0,98,114,101,97,107,0,0,0,108,97,98,101,108,115,47,103,111,116,111,115,0,0,0,0,37,115,32,101,120,112,101,99,116,101,100,0,0,0,0,0,115,121,110,116,97,120,32,101,114,114,111,114,0,0,0,0,67,32,108,101,118,101,108,115,0,0,0,0,0,0,0,0,6,6,6,6,7,7,7,7,7,7,10,9,5,4,3,3,3,3,3,3,3,3,3,3,3,3,2,2,1,1,0,0,99,97,110,110,111,116,32,117,115,101,32,39,46,46,46,39,32,111,117,116,115,105,100,101,32,97,32,118,97,114,97,114,103,32,102,117,110,99,116,105,111,110,0,0,0,0,0,0,115,101,108,102,0,0,0,0,60,110,97,109,101,62,32,111,114,32,39,46,46,46,39,32,101,120,112,101,99,116,101,100,0,0,0,0,0,0,0,0,108,111,99,97,108,32,118,97,114,105,97,98,108,101,115,0,102,117,110,99,116,105,111,110,115,0,0,0,0,0,0,0,105,116,101,109,115,32,105,110,32,97,32,99,111,110,115,116,114,117,99,116,111,114,0,0,109,97,105,110,32,102,117,110,99,116,105,111,110,0,0,0,102,117,110,99,116,105,111,110,32,97,116,32,108,105,110,101,32,37,100,0,0,0,0,0,116,111,111,32,109,97,110,121,32,37,115,32,40,108,105,109,105,116,32,105,115,32,37,100,41,32,105,110,32,37,115,0,102,117,110,99,116,105,111,110,32,97,114,103,117,109,101,110,116,115,32,101,120,112,101,99,116,101,100,0,0,0,0,0,117,110,101,120,112,101,99,116,101,100,32,115,121,109,98,111,108,0,0,0,0,0,0,0,108,97,98,101,108,32,39,37,115,39,32,97,108,114,101,97,100,121,32,100,101,102,105,110,101,100,32,111,110,32,108,105,110,101,32,37,100,0,0,0,39,61,39,32,111,114,32,39,105,110,39,32,101,120,112,101,99,116,101,100,0,0,0,0,40,102,111,114,32,103,101,110,101,114,97,116,111,114,41,0,40,102,111,114,32,115,116,97,116,101,41,0,0,0,0,0,40,102,111,114,32,99,111,110,116,114,111,108,41,0,0,0,40,102,111,114,32,105,110,100,101,120,41,0,0,0,0,0,40,102,111,114,32,108,105,109,105,116,41,0,0,0,0,0,40,102,111,114,32,115,116,101,112,41,0,0,0,0,0,0,37,115,32,101,120,112,101,99,116,101,100,32,40,116,111,32,99,108,111,115,101,32,37,115,32,97,116,32,108,105,110,101,32,37,100,41,0,0,0,0,117,112,118,97,108,117,101,115,0,0,0,0,0,0,0,0,110,111,116,32,101,110,111,117,103,104,32,109,101,109,111,114,121,0,0,0,0,0,0,0,144,27,0,0,64,0,0,0,152,27,0,0,65,0,0,0,160,27,0,0,66,0,0,0,168,27,0,0,67,0,0,0,176,27,0,0,68,0,0,0,184,27,0,0,69,0,0,0,192,27,0,0,70,0,0,0,200,27,0,0,71,0,0,0,208,27,0,0,72,0,0,0,216,27,0,0,73,0,0,0,224,27,0,0,74,0,0,0,232,27,0,0,75,0,0,0,240,27,0,0,76,0,0,0,248,27,0,0,77,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,95,95,105,110,100,101,120,0,98,121,116,101,0,0,0,0,99,104,97,114,0,0,0,0,100,117,109,112,0,0,0,0,102,105,110,100,0,0,0,0,102,111,114,109,97,116,0,0,103,109,97,116,99,104,0,0,103,115,117,98,0,0,0,0,108,101,110,0,0,0,0,0,108,111,119,101,114,0,0,0,109,97,116,99,104,0,0,0,114,101,112,0,0,0,0,0,114,101,118,101,114,115,101,0,115,117,98,0,0,0,0,0,117,112,112,101,114,0,0,0,114,101,115,117,108,116,105,110,103,32,115,116,114,105,110,103,32,116,111,111,32,108,97,114,103,101,0,0,0,0,0,0,116,111,111,32,109,97,110,121,32,99,97,112,116,117,114,101,115,0,0,0,0,0,0,0,105,110,118,97,108,105,100,32,99,97,112,116,117,114,101,32,105,110,100,101,120,0,0,0,117,110,102,105,110,105,115,104,101,100,32,99,97,112,116,117,114,101,0,0,0,0,0,0,112,97,116,116,101,114,110,32,116,111,111,32,99,111,109,112,108,101,120,0,0,0,0,0,109,105,115,115,105,110,103,32,39,91,39,32,97,102,116,101,114,32,39,37,37,102,39,32,105,110,32,112,97,116,116,101,114,110,0,0,0,0,0,0,105,110,118,97,108,105,100,32,99,97,112,116,117,114,101,32,105,110,100,101,120,32,37,37,37,100,0,0,0,0,0,0,109,97,108,102,111,114,109,101,100,32,112,97,116,116,101,114,110,32,40,101,110,100,115,32,119,105,116,104,32,39,37,37,39,41,0,0,0,0,0,0,109,97,108,102,111,114,109,101,100,32,112,97,116,116,101,114,110,32,40,109,105,115,115,105,110,103,32,39,93,39,41,0,109,97,108,102,111,114,109,101,100,32,112,97,116,116,101,114,110,32,40,109,105,115,115,105,110,103,32,97,114,103,117,109,101,110,116,115,32,116,111,32,39,37,37,98,39,41,0,0,105,110,118,97,108,105,100,32,112,97,116,116,101,114,110,32,99,97,112,116,117,114,101,0,94,36,42,43,63,46,40,91,37,45,0,0,0,0,0,0,115,116,114,105,110,103,47,102,117,110,99,116,105,111,110,47,116,97,98,108,101,32,101,120,112,101,99,116,101,100,0,0,105,110,118,97,108,105,100,32,114,101,112,108,97,99,101,109,101,110,116,32,118,97,108,117,101,32,40,97,32,37,115,41,0,0,0,0,0,0,0,0,105,110,118,97,108,105,100,32,117,115,101,32,111,102,32,39,37,99,39,32,105,110,32,114,101,112,108,97,99,101,109,101,110,116,32,115,116,114,105,110,103,0,0,0,0,0,0,0,110,111,32,118,97,108,117,101,0,0,0,0,0,0,0,0,110,111,116,32,97,32,110,117,109,98,101,114,32,105,110,32,112,114,111,112,101,114,32,114,97,110,103,101,0,0,0,0,110,111,116,32,97,32,110,111,110,45,110,101,103,97,116,105,118,101,32,110,117,109,98,101,114,32,105,110,32,112,114,111,112,101,114,32,114,97,110,103,101,0,0,0,0,0,0,0,105,110,118,97,108,105,100,32,111,112,116,105,111,110,32,39,37,37,37,99,39,32,116,111,32,39,102,111,114,109,97,116,39,0,0,0,0,0,0,0,92,37,100,0,0,0,0,0,92,37,48,51,100,0,0,0,45,43,32,35,48,0,0,0,105,110,118,97,108,105,100,32,102,111,114,109,97,116,32,40,114,101,112,101,97,116,101,100,32,102,108,97,103,115,41,0,105,110,118,97,108,105,100,32,102,111,114,109,97,116,32,40,119,105,100,116,104,32,111,114,32,112,114,101,99,105,115,105,111,110,32,116,111,111,32,108,111,110,103,41,0,0,0,0,117,110,97,98,108,101,32,116,111,32,100,117,109,112,32,103,105,118,101,110,32,102,117,110,99,116,105,111,110,0,0,0,118,97,108,117,101,32,111,117,116,32,111,102,32,114,97,110,103,101,0,0,0,0,0,0,115,116,114,105,110,103,32,115,108,105,99,101,32,116,111,111,32,108,111,110,103,0,0,0,116,97,98,108,101,32,105,110,100,101,120,32,105,115,32,110,105,108,0,0,0,0,0,0,116,97,98,108,101,32,105,110,100,101,120,32,105,115,32,78,97,78,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,116,97,98,108,101,32,111,118,101,114,102,108,111,119,0,0,105,110,118,97,108,105,100,32,107,101,121,32,116,111,32,39,110,101,120,116,39,0,0,0,224,31,0,0,78,0,0,0,232,31,0,0,79,0,0,0,240,31,0,0,80,0,0,0,248,31,0,0,81,0,0,0,216,31,0,0,82,0,0,0,0,32,0,0,83,0,0,0,8,32,0,0,84,0,0,0,0,0,0,0,0,0,0,0,117,110,112,97,99,107,0,0,99,111,110,99,97,116,0,0,109,97,120,110,0,0,0,0,105,110,115,101,114,116,0,0,112,97,99,107,0,0,0,0,114,101,109,111,118,101,0,0,115,111,114,116,0,0,0,0,0,0,0,0,0,0,0,0,105,110,118,97,108,105,100,32,111,114,100,101,114,32,102,117,110,99,116,105,111,110,32,102,111,114,32,115,111,114,116,105,110,103,0,0,0,0,0,0,112,111,115,105,116,105,111,110,32,111,117,116,32,111,102,32,98,111,117,110,100,115,0,0,116,111,111,32,109,97,110,121,32,114,101,115,117,108,116,115,32,116,111,32,117,110,112,97,99,107,0,0,0,0,0,0,110,0,0,0,0,0,0,0,119,114,111,110,103,32,110,117,109,98,101,114,32,111,102,32,97,114,103,117,109,101,110,116,115,32,116,111,32,39,105,110,115,101,114,116,39,0,0,0,105,110,118,97,108,105,100,32,118,97,108,117,101,32,40,37,115,41,32,97,116,32,105,110,100,101,120,32,37,100,32,105,110,32,116,97,98,108,101,32,102,111,114,32,39,99,111,110,99,97,116,39,0,0,0,0,110,111,32,118,97,108,117,101,0,0,0,0,0,0,0,0,110,105,108,0,0,0,0,0,98,111,111,108,101,97,110,0,117,115,101,114,100,97,116,97,0,0,0,0,0,0,0,0,110,117,109,98,101,114,0,0,115,116,114,105,110,103,0,0,116,97,98,108,101,0,0,0,102,117,110,99,116,105,111,110,0,0,0,0,0,0,0,0,116,104,114,101,97,100,0,0,112,114,111,116,111,0,0,0,117,112,118,97,108,0,0,0,224,32,0,0,240,32,0,0,248,32,0,0,0,33,0,0,16,33,0,0,24,33,0,0,32,33,0,0,40,33,0,0,0,33,0,0,56,33,0,0,64,33,0,0,72,33,0,0,200,33,0,0,208,33,0,0,224,33,0,0,232,33,0,0,240,33,0,0,248,33,0,0,0,34,0,0,8,34,0,0,16,34,0,0,24,34,0,0,32,34,0,0,40,34,0,0,48,34,0,0,56,34,0,0,64,34,0,0,72,34,0,0,88,34,0,0,0,0,0,0,95,95,105,110,100,101,120,0,95,95,110,101,119,105,110,100,101,120,0,0,0,0,0,0,95,95,103,99,0,0,0,0,95,95,109,111,100,101,0,0,95,95,108,101,110,0,0,0,95,95,101,113,0,0,0,0,95,95,97,100,100,0,0,0,95,95,115,117,98,0,0,0,95,95,109,117,108,0,0,0,95,95,100,105,118,0,0,0,95,95,109,111,100,0,0,0,95,95,112,111,119,0,0,0,95,95,117,110,109,0,0,0,95,95,108,116,0,0,0,0,95,95,108,101,0,0,0,0,95,95,99,111,110,99,97,116,0,0,0,0,0,0,0,0,95,95,99,97,108,108,0,0,98,105,110,97,114,121,32,115,116,114,105,110,103,0,0,0,25,147,13,10,26,10,0,0,116,114,117,110,99,97,116,101,100,0,0,0,0,0,0,0,37,115,58,32,37,115,32,112,114,101,99,111,109,112,105,108,101,100,32,99,104,117,110,107,0,0,0,0,0,0,0,0,99,111,114,114,117,112,116,101,100,0,0,0,0,0,0,0,110,111,116,32,97,0,0,0,118,101,114,115,105,111,110,32,109,105,115,109,97,116,99,104,32,105,110,0,0,0,0,0,105,110,99,111,109,112,97,116,105,98,108,101,0,0,0,0,37,46,49,52,103,0,0,0,105,110,100,101,120,0,0,0,108,111,111,112,32,105,110,32,103,101,116,116,97,98,108,101,0,0,0,0,0,0,0,0,108,111,111,112,32,105,110,32,115,101,116,116,97,98,108,101,0,0,0,0,0,0,0,0,115,116,114,105,110,103,32,108,101,110,103,116,104,32,111,118,101,114,102,108,111,119,0,0,103,101,116,32,108,101,110,103,116,104,32,111,102,0,0,0,39,102,111,114,39,32,105,110,105,116,105,97,108,32,118,97,108,117,101,32,109,117,115,116,32,98,101,32,97,32,110,117,109,98,101,114,0,0,0,0,39,102,111,114,39,32,108,105,109,105,116,32,109,117,115,116,32,98,101,32,97,32,110,117,109,98,101,114,0,0,0,0,39,102,111,114,39,32,115,116,101,112,32,109,117,115,116,32,98,101,32,97,32,110,117,109,98,101,114,0,0,0,0,0,95,71,0,0,0,0,0,0,152,36,0,0,85,0,0,0,160,36,0,0,86,0,0,0,176,36,0,0,87,0,0,0,184,36,0,0,88,0,0,0,192,36,0,0,89,0,0,0,208,36,0,0,90,0,0,0,216,36,0,0,91,0,0,0,232,36,0,0,92,0,0,0,240,36,0,0,92,0,0,0,0,37,0,0,93,0,0,0,8,37,0,0,94,0,0,0,16,37,0,0,95,0,0,0,24,37,0,0,96,0,0,0,32,37,0,0,97,0,0,0,48,37,0,0,98,0,0,0,56,37,0,0,99,0,0,0,64,37,0,0,100,0,0,0,72,37,0,0,101,0,0,0,80,37,0,0,102,0,0,0,96,37,0,0,103,0,0,0,112,37,0,0,104,0,0,0,128,37,0,0,105,0,0,0,136,37,0,0,106,0,0,0,0,0,0,0,0,0,0,0,76,117,97,32,53,46,50,0,95,86,69,82,83,73,79,78,0,0,0,0,0,0,0,0,97,115,115,101,114,116,0,0,99,111,108,108,101,99,116,103,97,114,98,97,103,101,0,0,100,111,102,105,108,101,0,0,101,114,114,111,114,0,0,0,103,101,116,109,101,116,97,116,97,98,108,101,0,0,0,0,105,112,97,105,114,115,0,0,108,111,97,100,102,105,108,101,0,0,0,0,0,0,0,0,108,111,97,100,0,0,0,0,108,111,97,100,115,116,114,105,110,103,0,0,0,0,0,0,110,101,120,116,0,0,0,0,112,97,105,114,115,0,0,0,112,99,97,108,108,0,0,0,112,114,105,110,116,0,0,0,114,97,119,101,113,117,97,108,0,0,0,0,0,0,0,0,114,97,119,108,101,110,0,0,114,97,119,103,101,116,0,0,114,97,119,115,101,116,0,0,115,101,108,101,99,116,0,0,115,101,116,109,101,116,97,116,97,98,108,101,0,0,0,0,116,111,110,117,109,98,101,114,0,0,0,0,0,0,0,0,116,111,115,116,114,105,110,103,0,0,0,0,0,0,0,0,116,121,112,101,0,0,0,0,120,112,99,97,108,108,0,0,118,97,108,117,101,32,101,120,112,101,99,116,101,100,0,0,115,116,97,99,107,32,111,118,101,114,102,108,111,119,0,0,98,97,115,101,32,111,117,116,32,111,102,32,114,97,110,103,101,0,0,0,0,0,0,0,32,12,10,13,9,11,0,0,110,105,108,32,111,114,32,116,97,98,108,101,32,101,120,112,101,99,116,101,100,0,0,0,95,95,109,101,116,97,116,97,98,108,101,0,0,0,0,0,99,97,110,110,111,116,32,99,104,97,110,103,101,32,97,32,112,114,111,116,101,99,116,101,100,32,109,101,116,97,116,97,98,108,101,0,0,0,0,0,105,110,100,101,120,32,111,117,116,32,111,102,32,114,97,110,103,101,0,0,0,0,0,0,116,97,98,108,101,32,111,114,32,115,116,114,105,110,103,32,101,120,112,101,99,116,101,100,0,0,0,0,0,0,0,0,39,116,111,115,116,114,105,110,103,39,32,109,117,115,116,32,114,101,116,117,114,110,32,97,32,115,116,114,105,110,103,32,116,111,32,39,112,114,105,110,116,39,0,0,0,0,0,0,95,95,112,97,105,114,115,0,98,116,0,0,0,0,0,0,61,40,108,111,97,100,41,0,116,111,111,32,109,97,110,121,32,110,101,115,116,101,100,32,102,117,110,99,116,105,111,110,115,0,0,0,0,0,0,0,114,101,97,100,101,114,32,102,117,110,99,116,105,111,110,32,109,117,115,116,32,114,101,116,117,114,110,32,97,32,115,116,114,105,110,103,0,0,0,0,95,95,105,112,97,105,114,115,0,0,0,0,0,0,0,0,40,39,0,0,48,39,0,0,56,39,0,0,64,39,0,0,72,39,0,0,80,39,0,0,96,39,0,0,112,39,0,0,128,39,0,0,144,39,0,0,160,39,0,0,0,0,0,0,115,116,111,112,0,0,0,0,114,101,115,116,97,114,116,0,99,111,108,108,101,99,116,0,99,111,117,110,116,0,0,0,115,116,101,112,0,0,0,0,115,101,116,112,97,117,115,101,0,0,0,0,0,0,0,0,115,101,116,115,116,101,112,109,117,108,0,0,0,0,0,0,115,101,116,109,97,106,111,114,105,110,99,0,0,0,0,0,105,115,114,117,110,110,105,110,103,0,0,0,0,0,0,0,103,101,110,101,114,97,116,105,111,110,97,108,0,0,0,0,105,110,99,114,101,109,101,110,116,97,108,0,0,0,0,0,0,0,0,0,1,0,0,0,2,0,0,0,3,0,0,0,5,0,0,0,6,0,0,0,7,0,0,0,8,0,0,0,9,0,0,0,10,0,0,0,11,0,0,0,0,0,0,0,37,115,0,0,0,0,0,0,97,115,115,101,114,116,105,111,110,32,102,97,105,108,101,100,33,0,0,0,0,0,0,0,104,40,0,0,107], "i8", ALLOC_NONE, Runtime.GLOBAL_BASE);
    1407. 

  1407. /* memory initializer */ allocate([112,40,0,0,108,0,0,0,120,40,0,0,109,0,0,0,128,40,0,0,110,0,0,0,136,40,0,0,111,0,0,0,144,40,0,0,112,0,0,0,152,40,0,0,113,0,0,0,160,40,0,0,114,0,0,0,168,40,0,0,115,0,0,0,176,40,0,0,116,0,0,0,184,40,0,0,117,0,0,0,192,40,0,0,118,0,0,0,0,0,0,0,0,0,0,0,97,114,115,104,105,102,116,0,98,97,110,100,0,0,0,0,98,110,111,116,0,0,0,0,98,111,114,0,0,0,0,0,98,120,111,114,0,0,0,0,98,116,101,115,116,0,0,0,101,120,116,114,97,99,116,0,108,114,111,116,97,116,101,0,108,115,104,105,102,116,0,0,114,101,112,108,97,99,101,0,114,114,111,116,97,116,101,0,114,115,104,105,102,116,0,0,102,105,101,108,100,32,99,97,110,110,111,116,32,98,101,32,110,101,103,97,116,105,118,101,0,0,0,0,0,0,0,0,119,105,100,116,104,32,109,117,115,116,32,98,101,32,112,111,115,105,116,105,118,101,0,0,116,114,121,105,110,103,32,116,111,32,97,99,99,101,115,115,32,110,111,110,45,101,120,105,115,116,101,110,116,32,98,105,116,115,0,0,0,0,0,0,102,117,110,99,116,105,111,110,32,111,114,32,101,120,112,114,101,115,115,105,111,110,32,116,111,111,32,99,111,109,112,108,101,120,0,0,0,0,0,0,99,111,110,115,116,114,117,99,116,111,114,32,116,111,111,32,108,111,110,103,0,0,0,0,99,111,110,115,116,97,110,116,115,0,0,0,0,0,0,0,111,112,99,111,100,101,115,0,99,111,110,116,114,111,108,32,115,116,114,117,99,116,117,114,101,32,116,111,111,32,108,111,110,103,0,0,0,0,0,0,216,41,0,0,119,0,0,0,224,41,0,0,120,0,0,0,232,41,0,0,121,0,0,0,240,41,0,0,122,0,0,0,248,41,0,0,123,0,0,0,0,42,0,0,124,0,0,0,0,0,0,0,0,0,0,0,99,114,101,97,116,101,0,0,114,101,115,117,109,101,0,0,114,117,110,110,105,110,103,0,115,116,97,116,117,115,0,0,119,114,97,112,0,0,0,0,121,105,101,108,100,0,0,0,116,111,111,32,109,97,110,121,32,97,114,103,117,109,101,110,116,115,32,116,111,32,114,101,115,117,109,101,0,0,0,0,99,97,110,110,111,116,32,114,101,115,117,109,101,32,100,101,97,100,32,99,111,114,111,117,116,105,110,101,0,0,0,0,116,111,111,32,109,97,110,121,32,114,101,115,117,108,116,115,32,116,111,32,114,101,115,117,109,101,0,0,0,0,0,0,99,111,114,111,117,116,105,110,101,32,101,120,112,101,99,116,101,100,0,0,0,0,0,0,115,117,115,112,101,110,100,101,100,0,0,0,0,0,0,0,110,111,114,109,97,108,0,0,100,101,97,100,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,8,8,8,8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,12,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,22,22,22,22,22,22,22,22,22,22,4,4,4,4,4,4,4,21,21,21,21,21,21,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,4,4,4,4,5,4,21,21,21,21,21,21,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,4,4,4,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,48,44,0,0,125,0,0,0,56,44,0,0,126,0,0,0,72,44,0,0,127,0,0,0,80,44,0,0,128,0,0,0,88,44,0,0,129,0,0,0,104,44,0,0,130,0,0,0,120,44,0,0,131,0,0,0,136,44,0,0,132,0,0,0,152,44,0,0,133,0,0,0,168,44,0,0,134,0,0,0,184,44,0,0,135,0,0,0,200,44,0,0,136,0,0,0,208,44,0,0,137,0,0,0,224,44,0,0,138,0,0,0,240,44,0,0,139,0,0,0,0,45,0,0,140,0,0,0,0,0,0,0,0,0,0,0,100,101,98,117,103,0,0,0,103,101,116,117,115,101,114,118,97,108,117,101,0,0,0,0,103,101,116,104,111,111,107,0,103,101,116,105,110,102,111,0,103,101,116,108,111,99,97,108,0,0,0,0,0,0,0,0,103,101,116,114,101,103,105,115,116,114,121,0,0,0,0,0,103,101,116,109,101,116,97,116,97,98,108,101,0,0,0,0,103,101,116,117,112,118,97,108,117,101,0,0,0,0,0,0,117,112,118,97,108,117,101,106,111,105,110,0,0,0,0,0,117,112,118,97,108,117,101,105,100,0,0,0,0,0,0,0,115,101,116,117,115,101,114,118,97,108,117,101,0,0,0,0,115,101,116,104,111,111,107,0,115,101,116,108,111,99,97,108,0,0,0,0,0,0,0,0,115,101,116,109,101,116,97,116,97,98,108,101,0,0,0,0,115,101,116,117,112,118,97,108,117,101,0,0,0,0,0,0,116,114,97,99,101,98,97,99,107,0,0,0,0,0,0,0,110,105,108,32,111,114,32,116,97,98,108,101,32,101,120,112,101,99,116,101,100,0,0,0,108,101,118,101,108,32,111,117,116,32,111,102,32,114,97,110,103,101,0,0,0,0,0,0,95,72,75,69,89,0,0,0,107,0,0,0,0,0,0,0,95,95,109,111,100,101,0,0,112,45,0,0,120,45,0,0,128,45,0,0,136,45,0,0,144,45,0,0,0,0,0,0,99,97,108,108,0,0,0,0,114,101,116,117,114,110,0,0,108,105,110,101,0,0,0,0,99,111,117,110,116,0,0,0,116,97,105,108,32,99,97,108,108,0,0,0,0,0,0,0,102,117,108,108,32,117,115,101,114,100,97,116,97,32,101,120,112,101,99,116,101,100,44,32,103,111,116,32,108,105,103,104,116,32,117,115,101,114,100,97,116,97,0,0,0,0,0,0,62,117,0,0,0,0,0,0,105,110,118,97,108,105,100,32,117,112,118,97,108,117,101,32,105,110,100,101,120,0,0,0,76,117,97,32,102,117,110,99,116,105,111,110,32,101,120,112,101,99,116,101,100,0,0,0,102,108,110,83,116,117,0,0,62,37,115,0,0,0,0,0,102,117,110,99,116,105,111,110,32,111,114,32,108,101,118,101,108,32,101,120,112,101,99,116,101,100,0,0,0,0,0,0,105,110,118,97,108,105,100,32,111,112,116,105,111,110,0,0,115,111,117,114,99,101,0,0,115,104,111,114,116,95,115,114,99,0,0,0,0,0,0,0,108,105,110,101,100,101,102,105,110,101,100,0,0,0,0,0,108,97,115,116,108,105,110,101,100,101,102,105,110,101,100,0,119,104,97,116,0,0,0,0,99,117,114,114,101,110,116,108,105,110,101,0,0,0,0,0,110,117,112,115,0,0,0,0,110,112,97,114,97,109,115,0,105,115,118,97,114,97,114,103,0,0,0,0,0,0,0,0,110,97,109,101,0,0,0,0,110,97,109,101,119,104,97,116,0,0,0,0,0,0,0,0,105,115,116,97,105,108,99,97,108,108,0,0,0,0,0,0,97,99,116,105,118,101,108,105,110,101,115,0,0,0,0,0,102,117,110,99,0,0,0,0,101,120,116,101,114,110,97,108,32,104,111,111,107,0,0,0,108,117,97,95,100,101,98,117,103,62,32,0,0,0,0,0,99,111,110,116,10,0,0,0,61,40,100,101,98,117,103,32,99,111,109,109,97,110,100,41,0,0,0,0,0,0,0,0,37,115,10,0,0,0,0,0,80,49,0,0,88,49,0,0,96,49,0,0,104,49,0,0,112,49,0,0,120,49,0,0,128,49,0,0,136,49,0,0,144,49,0,0,160,49,0,0,168,49,0,0,176,49,0,0,184,49,0,0,192,49,0,0,200,49,0,0,208,49,0,0,216,49,0,0,224,49,0,0,232,49,0,0,240,49,0,0,248,49,0,0,0,50,0,0,8,50,0,0,16,50,0,0,24,50,0,0,32,50,0,0,40,50,0,0,48,50,0,0,56,50,0,0,64,50,0,0,72,50,0,0,88,50,0,0,96,50,0,0,0,0,0,0,39,37,99,39,0,0,0,0,99,104,97,114,40,37,100,41,0,0,0,0,0,0,0,0,39,37,115,39,0,0,0,0,95,69,78,86,0,0,0,0,105,110,118,97,108,105,100,32,108,111,110,103,32,115,116,114,105,110,103,32,100,101,108,105,109,105,116,101,114,0,0,0,46,0,0,0,0,0,0,0,69,101,0,0,0,0,0,0,88,120,0,0,0,0,0,0,80,112,0,0,0,0,0,0,43,45,0,0,0,0,0,0,109,97,108,102,111,114,109,101,100,32,110,117,109,98,101,114,0,0,0,0,0,0,0,0,108,101,120,105,99,97,108,32,101,108,101,109,101,110,116,32,116,111,111,32,108,111,110,103,0,0,0,0,0,0,0,0,117,110,102,105,110,105,115,104,101,100,32,115,116,114,105,110,103,0,0,0,0,0,0,0,105,110,118,97,108,105,100,32,101,115,99,97,112,101,32,115,101,113,117,101,110,99,101,0,100,101,99,105,109,97,108,32,101,115,99,97,112,101,32,116,111,111,32,108,97,114,103,101,0,0,0,0,0,0,0,0,104,101,120,97,100,101,99,105,109,97,108,32,100,105,103,105,116,32,101,120,112,101,99,116,101,100,0,0,0,0,0,0,117,110,102,105,110,105,115,104,101,100,32,108,111,110,103,32,115,116,114,105,110,103,0,0,117,110,102,105,110,105,115,104,101,100,32,108,111,110,103,32,99,111,109,109,101,110,116,0,99,104,117,110,107,32,104,97,115,32,116,111,111,32,109,97,110,121,32,108,105,110,101,115,0,0,0,0,0,0,0,0,37,115,58,37,100,58,32,37,115,0,0,0,0,0,0,0,37,115,32,110,101,97,114,32,37,115,0,0,0,0,0,0,97,110,100,0,0,0,0,0,98,114,101,97,107,0,0,0,100,111,0,0,0,0,0,0,101,108,115,101,0,0,0,0,101,108,115,101,105,102,0,0,101,110,100,0,0,0,0,0,102,97,108,115,101,0,0,0,102,111,114,0,0,0,0,0,102,117,110,99,116,105,111,110,0,0,0,0,0,0,0,0,103,111,116,111,0,0,0,0,105,102,0,0,0,0,0,0,105,110,0,0,0,0,0,0,108,111,99,97,108,0,0,0,110,105,108,0,0,0,0,0,110,111,116,0,0,0,0,0,111,114,0,0,0,0,0,0,114,101,112,101,97,116,0,0,114,101,116,117,114,110,0,0,116,104,101,110,0,0,0,0,116,114,117,101,0,0,0,0,117,110,116,105,108,0,0,0,119,104,105,108,101,0,0,0,46,46,0,0,0,0,0,0,46,46,46,0,0,0,0,0,61,61,0,0,0,0,0,0,62,61,0,0,0,0,0,0,60,61,0,0,0,0,0,0,126,61,0,0,0,0,0,0,58,58,0,0,0,0,0,0,60,101,111,102,62,0,0,0,60,110,117,109,98,101,114,62,0,0,0,0,0,0,0,0,60,110,97,109,101,62,0,0,60,115,116,114,105,110,103,62,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,105,110,102,105,110,105,116,121,0,0,0,0,0,0,0,0,110,97,110,0,0,0,0,0,95,112,137,0,255,9,47,15,10,0,0,0,100,0,0,0,232,3,0,0,16,39,0,0,160,134,1,0,64,66,15,0,128,150,152,0,0,225,245,5], "i8", ALLOC_NONE, Runtime.GLOBAL_BASE+10240);
    1408. 

  1408. 

  1409. 

  1410. 

  1411. 

  1412. var tempDoublePtr = Runtime.alignMemory(allocate(12, "i8", ALLOC_STATIC), 8);
    1413. 

  1413. 

  1414. assert(tempDoublePtr % 8 == 0);
    1415. 

  1415. 

  1416. function copyTempFloat(ptr) { // functions, because inlining this code increases code size too much
    1417. 

  1417. 

  1418.   HEAP8[tempDoublePtr] = HEAP8[ptr];
    1419. 

  1419. 

  1420.   HEAP8[tempDoublePtr+1] = HEAP8[ptr+1];
    1421. 

  1421. 

  1422.   HEAP8[tempDoublePtr+2] = HEAP8[ptr+2];
    1423. 

  1423. 

  1424.   HEAP8[tempDoublePtr+3] = HEAP8[ptr+3];
    1425. 

  1425. 

  1426. }
    1427. 

  1427. 

  1428. function copyTempDouble(ptr) {
    1429. 

  1429. 

  1430.   HEAP8[tempDoublePtr] = HEAP8[ptr];
    1431. 

  1431. 

  1432.   HEAP8[tempDoublePtr+1] = HEAP8[ptr+1];
    1433. 

  1433. 

  1434.   HEAP8[tempDoublePtr+2] = HEAP8[ptr+2];
    1435. 

  1435. 

  1436.   HEAP8[tempDoublePtr+3] = HEAP8[ptr+3];
    1437. 

  1437. 

  1438.   HEAP8[tempDoublePtr+4] = HEAP8[ptr+4];
    1439. 

  1439. 

  1440.   HEAP8[tempDoublePtr+5] = HEAP8[ptr+5];
    1441. 

  1441. 

  1442.   HEAP8[tempDoublePtr+6] = HEAP8[ptr+6];
    1443. 

  1443. 

  1444.   HEAP8[tempDoublePtr+7] = HEAP8[ptr+7];
    1445. 

  1445. 

  1446. }
    1447. 

  1447. 

  1448. 

  1449. 

  1450. 

  1451.   Module["_rand_r"] = _rand_r;
    1452. 

  1452. 

  1453.   var ___rand_seed=allocate([0x0273459b, 0, 0, 0], "i32", ALLOC_STATIC);
    1454. 

  1454.   Module["_rand"] = _rand;
    1455. 

  1455. 

  1456. 

  1457. 

  1458.   var ERRNO_CODES={EPERM:1,ENOENT:2,ESRCH:3,EINTR:4,EIO:5,ENXIO:6,E2BIG:7,ENOEXEC:8,EBADF:9,ECHILD:10,EAGAIN:11,EWOULDBLOCK:11,ENOMEM:12,EACCES:13,EFAULT:14,ENOTBLK:15,EBUSY:16,EEXIST:17,EXDEV:18,ENODEV:19,ENOTDIR:20,EISDIR:21,EINVAL:22,ENFILE:23,EMFILE:24,ENOTTY:25,ETXTBSY:26,EFBIG:27,ENOSPC:28,ESPIPE:29,EROFS:30,EMLINK:31,EPIPE:32,EDOM:33,ERANGE:34,ENOMSG:42,EIDRM:43,ECHRNG:44,EL2NSYNC:45,EL3HLT:46,EL3RST:47,ELNRNG:48,EUNATCH:49,ENOCSI:50,EL2HLT:51,EDEADLK:35,ENOLCK:37,EBADE:52,EBADR:53,EXFULL:54,ENOANO:55,EBADRQC:56,EBADSLT:57,EDEADLOCK:35,EBFONT:59,ENOSTR:60,ENODATA:61,ETIME:62,ENOSR:63,ENONET:64,ENOPKG:65,EREMOTE:66,ENOLINK:67,EADV:68,ESRMNT:69,ECOMM:70,EPROTO:71,EMULTIHOP:72,EDOTDOT:73,EBADMSG:74,ENOTUNIQ:76,EBADFD:77,EREMCHG:78,ELIBACC:79,ELIBBAD:80,ELIBSCN:81,ELIBMAX:82,ELIBEXEC:83,ENOSYS:38,ENOTEMPTY:39,ENAMETOOLONG:36,ELOOP:40,EOPNOTSUPP:95,EPFNOSUPPORT:96,ECONNRESET:104,ENOBUFS:105,EAFNOSUPPORT:97,EPROTOTYPE:91,ENOTSOCK:88,ENOPROTOOPT:92,ESHUTDOWN:108,ECONNREFUSED:111,EADDRINUSE:98,ECONNABORTED:103,ENETUNREACH:101,ENETDOWN:100,ETIMEDOUT:110,EHOSTDOWN:112,EHOSTUNREACH:113,EINPROGRESS:115,EALREADY:114,EDESTADDRREQ:89,EMSGSIZE:90,EPROTONOSUPPORT:93,ESOCKTNOSUPPORT:94,EADDRNOTAVAIL:99,ENETRESET:102,EISCONN:106,ENOTCONN:107,ETOOMANYREFS:109,EUSERS:87,EDQUOT:122,ESTALE:116,ENOTSUP:95,ENOMEDIUM:123,EILSEQ:84,EOVERFLOW:75,ECANCELED:125,ENOTRECOVERABLE:131,EOWNERDEAD:130,ESTRPIPE:86};
    1459. 

  1459. 

  1460.   var ERRNO_MESSAGES={0:"Success",1:"Not super-user",2:"No such file or directory",3:"No such process",4:"Interrupted system call",5:"I/O error",6:"No such device or address",7:"Arg list too long",8:"Exec format error",9:"Bad file number",10:"No children",11:"No more processes",12:"Not enough core",13:"Permission denied",14:"Bad address",15:"Block device required",16:"Mount device busy",17:"File exists",18:"Cross-device link",19:"No such device",20:"Not a directory",21:"Is a directory",22:"Invalid argument",23:"Too many open files in system",24:"Too many open files",25:"Not a typewriter",26:"Text file busy",27:"File too large",28:"No space left on device",29:"Illegal seek",30:"Read only file system",31:"Too many links",32:"Broken pipe",33:"Math arg out of domain of func",34:"Math result not representable",35:"File locking deadlock error",36:"File or path name too long",37:"No record locks available",38:"Function not implemented",39:"Directory not empty",40:"Too many symbolic links",42:"No message of desired type",43:"Identifier removed",44:"Channel number out of range",45:"Level 2 not synchronized",46:"Level 3 halted",47:"Level 3 reset",48:"Link number out of range",49:"Protocol driver not attached",50:"No CSI structure available",51:"Level 2 halted",52:"Invalid exchange",53:"Invalid request descriptor",54:"Exchange full",55:"No anode",56:"Invalid request code",57:"Invalid slot",59:"Bad font file fmt",60:"Device not a stream",61:"No data (for no delay io)",62:"Timer expired",63:"Out of streams resources",64:"Machine is not on the network",65:"Package not installed",66:"The object is remote",67:"The link has been severed",68:"Advertise error",69:"Srmount error",70:"Communication error on send",71:"Protocol error",72:"Multihop attempted",73:"Cross mount point (not really error)",74:"Trying to read unreadable message",75:"Value too large for defined data type",76:"Given log. name not unique",77:"f.d. invalid for this operation",78:"Remote address changed",79:"Can   access a needed shared lib",80:"Accessing a corrupted shared lib",81:".lib section in a.out corrupted",82:"Attempting to link in too many libs",83:"Attempting to exec a shared library",84:"Illegal byte sequence",86:"Streams pipe error",87:"Too many users",88:"Socket operation on non-socket",89:"Destination address required",90:"Message too long",91:"Protocol wrong type for socket",92:"Protocol not available",93:"Unknown protocol",94:"Socket type not supported",95:"Not supported",96:"Protocol family not supported",97:"Address family not supported by protocol family",98:"Address already in use",99:"Address not available",100:"Network interface is not configured",101:"Network is unreachable",102:"Connection reset by network",103:"Connection aborted",104:"Connection reset by peer",105:"No buffer space available",106:"Socket is already connected",107:"Socket is not connected",108:"Can't send after socket shutdown",109:"Too many references",110:"Connection timed out",111:"Connection refused",112:"Host is down",113:"Host is unreachable",114:"Socket already connected",115:"Connection already in progress",116:"Stale file handle",122:"Quota exceeded",123:"No medium (in tape drive)",125:"Operation canceled",130:"Previous owner died",131:"State not recoverable"};
    1461. 

  1461. 

  1462. 

  1463.   var ___errno_state=0;function ___setErrNo(value) {
    1464. 

  1464.       // For convenient setting and returning of errno.
    1465. 

  1465.       HEAP32[((___errno_state)>>2)]=value;
    1466. 

  1466.       return value;
    1467. 

  1467.     }
    1468. 

  1468. 

  1469.   var PATH={splitPath:function (filename) {
    1470. 

  1470.         var splitPathRe = /^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/;
    1471. 

  1471.         return splitPathRe.exec(filename).slice(1);
    1472. 

  1472.       },normalizeArray:function (parts, allowAboveRoot) {
    1473. 

  1473.         // if the path tries to go above the root, `up` ends up > 0
    1474. 

  1474.         var up = 0;
    1475. 

  1475.         for (var i = parts.length - 1; i >= 0; i--) {
    1476. 

  1476.           var last = parts[i];
    1477. 

  1477.           if (last === '.') {
    1478. 

  1478.             parts.splice(i, 1);
    1479. 

  1479.           } else if (last === '..') {
    1480. 

  1480.             parts.splice(i, 1);
    1481. 

  1481.             up++;
    1482. 

  1482.           } else if (up) {
    1483. 

  1483.             parts.splice(i, 1);
    1484. 

  1484.             up--;
    1485. 

  1485.           }
    1486. 

  1486.         }
    1487. 

  1487.         // if the path is allowed to go above the root, restore leading ..s
    1488. 

  1488.         if (allowAboveRoot) {
    1489. 

  1489.           for (; up--; up) {
    1490. 

  1490.             parts.unshift('..');
    1491. 

  1491.           }
    1492. 

  1492.         }
    1493. 

  1493.         return parts;
    1494. 

  1494.       },normalize:function (path) {
    1495. 

  1495.         var isAbsolute = path.charAt(0) === '/',
    1496. 

  1496.             trailingSlash = path.substr(-1) === '/';
    1497. 

  1497.         // Normalize the path
    1498. 

  1498.         path = PATH.normalizeArray(path.split('/').filter(function(p) {
    1499. 

  1499.           return !!p;
    1500. 

  1500.         }), !isAbsolute).join('/');
    1501. 

  1501.         if (!path && !isAbsolute) {
    1502. 

  1502.           path = '.';
    1503. 

  1503.         }
    1504. 

  1504.         if (path && trailingSlash) {
    1505. 

  1505.           path += '/';
    1506. 

  1506.         }
    1507. 

  1507.         return (isAbsolute ? '/' : '') + path;
    1508. 

  1508.       },dirname:function (path) {
    1509. 

  1509.         var result = PATH.splitPath(path),
    1510. 

  1510.             root = result[0],
    1511. 

  1511.             dir = result[1];
    1512. 

  1512.         if (!root && !dir) {
    1513. 

  1513.           // No dirname whatsoever
    1514. 

  1514.           return '.';
    1515. 

  1515.         }
    1516. 

  1516.         if (dir) {
    1517. 

  1517.           // It has a dirname, strip trailing slash
    1518. 

  1518.           dir = dir.substr(0, dir.length - 1);
    1519. 

  1519.         }
    1520. 

  1520.         return root + dir;
    1521. 

  1521.       },basename:function (path) {
    1522. 

  1522.         // EMSCRIPTEN return '/'' for '/', not an empty string
    1523. 

  1523.         if (path === '/') return '/';
    1524. 

  1524.         var lastSlash = path.lastIndexOf('/');
    1525. 

  1525.         if (lastSlash === -1) return path;
    1526. 

  1526.         return path.substr(lastSlash+1);
    1527. 

  1527.       },extname:function (path) {
    1528. 

  1528.         return PATH.splitPath(path)[3];
    1529. 

  1529.       },join:function () {
    1530. 

  1530.         var paths = Array.prototype.slice.call(arguments, 0);
    1531. 

  1531.         return PATH.normalize(paths.join('/'));
    1532. 

  1532.       },join2:function (l, r) {
    1533. 

  1533.         return PATH.normalize(l + '/' + r);
    1534. 

  1534.       },resolve:function () {
    1535. 

  1535.         var resolvedPath = '',
    1536. 

  1536.           resolvedAbsolute = false;
    1537. 

  1537.         for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) {
    1538. 

  1538.           var path = (i >= 0) ? arguments[i] : FS.cwd();
    1539. 

  1539.           // Skip empty and invalid entries
    1540. 

  1540.           if (typeof path !== 'string') {
    1541. 

  1541.             throw new TypeError('Arguments to path.resolve must be strings');
    1542. 

  1542.           } else if (!path) {
    1543. 

  1543.             continue;
    1544. 

  1544.           }
    1545. 

  1545.           resolvedPath = path + '/' + resolvedPath;
    1546. 

  1546.           resolvedAbsolute = path.charAt(0) === '/';
    1547. 

  1547.         }
    1548. 

  1548.         // At this point the path should be resolved to a full absolute path, but
    1549. 

  1549.         // handle relative paths to be safe (might happen when process.cwd() fails)
    1550. 

  1550.         resolvedPath = PATH.normalizeArray(resolvedPath.split('/').filter(function(p) {
    1551. 

  1551.           return !!p;
    1552. 

  1552.         }), !resolvedAbsolute).join('/');
    1553. 

  1553.         return ((resolvedAbsolute ? '/' : '') + resolvedPath) || '.';
    1554. 

  1554.       },relative:function (from, to) {
    1555. 

  1555.         from = PATH.resolve(from).substr(1);
    1556. 

  1556.         to = PATH.resolve(to).substr(1);
    1557. 

  1557.         function trim(arr) {
    1558. 

  1558.           var start = 0;
    1559. 

  1559.           for (; start < arr.length; start++) {
    1560. 

  1560.             if (arr[start] !== '') break;
    1561. 

  1561.           }
    1562. 

  1562.           var end = arr.length - 1;
    1563. 

  1563.           for (; end >= 0; end--) {
    1564. 

  1564.             if (arr[end] !== '') break;
    1565. 

  1565.           }
    1566. 

  1566.           if (start > end) return [];
    1567. 

  1567.           return arr.slice(start, end - start + 1);
    1568. 

  1568.         }
    1569. 

  1569.         var fromParts = trim(from.split('/'));
    1570. 

  1570.         var toParts = trim(to.split('/'));
    1571. 

  1571.         var length = Math.min(fromParts.length, toParts.length);
    1572. 

  1572.         var samePartsLength = length;
    1573. 

  1573.         for (var i = 0; i < length; i++) {
    1574. 

  1574.           if (fromParts[i] !== toParts[i]) {
    1575. 

  1575.             samePartsLength = i;
    1576. 

  1576.             break;
    1577. 

  1577.           }
    1578. 

  1578.         }
    1579. 

  1579.         var outputParts = [];
    1580. 

  1580.         for (var i = samePartsLength; i < fromParts.length; i++) {
    1581. 

  1581.           outputParts.push('..');
    1582. 

  1582.         }
    1583. 

  1583.         outputParts = outputParts.concat(toParts.slice(samePartsLength));
    1584. 

  1584.         return outputParts.join('/');
    1585. 

  1585.       }};
    1586. 

  1586. 

  1587.   var TTY={ttys:[],init:function () {
    1588. 

  1588.         // https://github.com/kripken/emscripten/pull/1555
    1589. 

  1589.         // if (ENVIRONMENT_IS_NODE) {
    1590. 

  1590.         //   // currently, FS.init does not distinguish if process.stdin is a file or TTY
    1591. 

  1591.         //   // device, it always assumes it's a TTY device. because of this, we're forcing
    1592. 

  1592.         //   // process.stdin to UTF8 encoding to at least make stdin reading compatible
    1593. 

  1593.         //   // with text files until FS.init can be refactored.
    1594. 

  1594.         //   process['stdin']['setEncoding']('utf8');
    1595. 

  1595.         // }
    1596. 

  1596.       },shutdown:function () {
    1597. 

  1597.         // https://github.com/kripken/emscripten/pull/1555
    1598. 

  1598.         // if (ENVIRONMENT_IS_NODE) {
    1599. 

  1599.         //   // inolen: any idea as to why node -e 'process.stdin.read()' wouldn't exit immediately (with process.stdin being a tty)?
    1600. 

  1600.         //   // 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
    1601. 

  1601.         //   // inolen: I thought read() in that case was a synchronous operation that just grabbed some amount of buffered data if it exists?
    1602. 

  1602.         //   // isaacs: it is. but it also triggers a _read() call, which calls readStart() on the handle
    1603. 

  1603.         //   // isaacs: do process.stdin.pause() and i'd think it'd probably close the pending call
    1604. 

  1604.         //   process['stdin']['pause']();
    1605. 

  1605.         // }
    1606. 

  1606.       },register:function (dev, ops) {
    1607. 

  1607.         TTY.ttys[dev] = { input: [], output: [], ops: ops };
    1608. 

  1608.         FS.registerDevice(dev, TTY.stream_ops);
    1609. 

  1609.       },stream_ops:{open:function (stream) {
    1610. 

  1610.           var tty = TTY.ttys[stream.node.rdev];
    1611. 

  1611.           if (!tty) {
    1612. 

  1612.             throw new FS.ErrnoError(ERRNO_CODES.ENODEV);
    1613. 

  1613.           }
    1614. 

  1614.           stream.tty = tty;
    1615. 

  1615.           stream.seekable = false;
    1616. 

  1616.         },close:function (stream) {
    1617. 

  1617.           // flush any pending line data
    1618. 

  1618.           if (stream.tty.output.length) {
    1619. 

  1619.             stream.tty.ops.put_char(stream.tty, 10);
    1620. 

  1620.           }
    1621. 

  1621.         },read:function (stream, buffer, offset, length, pos /* ignored */) {
    1622. 

  1622.           if (!stream.tty || !stream.tty.ops.get_char) {
    1623. 

  1623.             throw new FS.ErrnoError(ERRNO_CODES.ENXIO);
    1624. 

  1624.           }
    1625. 

  1625.           var bytesRead = 0;
    1626. 

  1626.           for (var i = 0; i < length; i++) {
    1627. 

  1627.             var result;
    1628. 

  1628.             try {
    1629. 

  1629.               result = stream.tty.ops.get_char(stream.tty);
    1630. 

  1630.             } catch (e) {
    1631. 

  1631.               throw new FS.ErrnoError(ERRNO_CODES.EIO);
    1632. 

  1632.             }
    1633. 

  1633.             if (result === undefined && bytesRead === 0) {
    1634. 

  1634.               throw new FS.ErrnoError(ERRNO_CODES.EAGAIN);
    1635. 

  1635.             }
    1636. 

  1636.             if (result === null || result === undefined) break;
    1637. 

  1637.             bytesRead++;
    1638. 

  1638.             buffer[offset+i] = result;
    1639. 

  1639.           }
    1640. 

  1640.           if (bytesRead) {
    1641. 

  1641.             stream.node.timestamp = Date.now();
    1642. 

  1642.           }
    1643. 

  1643.           return bytesRead;
    1644. 

  1644.         },write:function (stream, buffer, offset, length, pos) {
    1645. 

  1645.           if (!stream.tty || !stream.tty.ops.put_char) {
    1646. 

  1646.             throw new FS.ErrnoError(ERRNO_CODES.ENXIO);
    1647. 

  1647.           }
    1648. 

  1648.           for (var i = 0; i < length; i++) {
    1649. 

  1649.             try {
    1650. 

  1650.               stream.tty.ops.put_char(stream.tty, buffer[offset+i]);
    1651. 

  1651.             } catch (e) {
    1652. 

  1652.               throw new FS.ErrnoError(ERRNO_CODES.EIO);
    1653. 

  1653.             }
    1654. 

  1654.           }
    1655. 

  1655.           if (length) {
    1656. 

  1656.             stream.node.timestamp = Date.now();
    1657. 

  1657.           }
    1658. 

  1658.           return i;
    1659. 

  1659.         }},default_tty_ops:{get_char:function (tty) {
    1660. 

  1660.           if (!tty.input.length) {
    1661. 

  1661.             var result = null;
    1662. 

  1662.             if (ENVIRONMENT_IS_NODE) {
    1663. 

  1663.               result = process['stdin']['read']();
    1664. 

  1664.               if (!result) {
    1665. 

  1665.                 if (process['stdin']['_readableState'] && process['stdin']['_readableState']['ended']) {
    1666. 

  1666.                   return null;  // EOF
    1667. 

  1667.                 }
    1668. 

  1668.                 return undefined;  // no data available
    1669. 

  1669.               }
    1670. 

  1670.             } else if (typeof window != 'undefined' &&
    1671. 

  1671.               typeof window.prompt == 'function') {
    1672. 

  1672.               // Browser.
    1673. 

  1673.               result = window.prompt('Input: ');  // returns null on cancel
    1674. 

  1674.               if (result !== null) {
    1675. 

  1675.                 result += '\n';
    1676. 

  1676.               }
    1677. 

  1677.             } else if (typeof readline == 'function') {
    1678. 

  1678.               // Command line.
    1679. 

  1679.               result = readline();
    1680. 

  1680.               if (result !== null) {
    1681. 

  1681.                 result += '\n';
    1682. 

  1682.               }
    1683. 

  1683.             }
    1684. 

  1684.             if (!result) {
    1685. 

  1685.               return null;
    1686. 

  1686.             }
    1687. 

  1687.             tty.input = intArrayFromString(result, true);
    1688. 

  1688.           }
    1689. 

  1689.           return tty.input.shift();
    1690. 

  1690.         },put_char:function (tty, val) {
    1691. 

  1691.           if (val === null || val === 10) {
    1692. 

  1692.             Module['print'](tty.output.join(''));
    1693. 

  1693.             tty.output = [];
    1694. 

  1694.           } else {
    1695. 

  1695.             tty.output.push(TTY.utf8.processCChar(val));
    1696. 

  1696.           }
    1697. 

  1697.         }},default_tty1_ops:{put_char:function (tty, val) {
    1698. 

  1698.           if (val === null || val === 10) {
    1699. 

  1699.             Module['printErr'](tty.output.join(''));
    1700. 

  1700.             tty.output = [];
    1701. 

  1701.           } else {
    1702. 

  1702.             tty.output.push(TTY.utf8.processCChar(val));
    1703. 

  1703.           }
    1704. 

  1704.         }}};
    1705. 

  1705. 

  1706.   var MEMFS={ops_table:null,CONTENT_OWNING:1,CONTENT_FLEXIBLE:2,CONTENT_FIXED:3,mount:function (mount) {
    1707. 

  1707.         return MEMFS.createNode(null, '/', 16384 | 511 /* 0777 */, 0);
    1708. 

  1708.       },createNode:function (parent, name, mode, dev) {
    1709. 

  1709.         if (FS.isBlkdev(mode) || FS.isFIFO(mode)) {
    1710. 

  1710.           // no supported
    1711. 

  1711.           throw new FS.ErrnoError(ERRNO_CODES.EPERM);
    1712. 

  1712.         }
    1713. 

  1713.         if (!MEMFS.ops_table) {
    1714. 

  1714.           MEMFS.ops_table = {
    1715. 

  1715.             dir: {
    1716. 

  1716.               node: {
    1717. 

  1717.                 getattr: MEMFS.node_ops.getattr,
    1718. 

  1718.                 setattr: MEMFS.node_ops.setattr,
    1719. 

  1719.                 lookup: MEMFS.node_ops.lookup,
    1720. 

  1720.                 mknod: MEMFS.node_ops.mknod,
    1721. 

  1721.                 rename: MEMFS.node_ops.rename,
    1722. 

  1722.                 unlink: MEMFS.node_ops.unlink,
    1723. 

  1723.                 rmdir: MEMFS.node_ops.rmdir,
    1724. 

  1724.                 readdir: MEMFS.node_ops.readdir,
    1725. 

  1725.                 symlink: MEMFS.node_ops.symlink
    1726. 

  1726.               },
    1727. 

  1727.               stream: {
    1728. 

  1728.                 llseek: MEMFS.stream_ops.llseek
    1729. 

  1729.               }
    1730. 

  1730.             },
    1731. 

  1731.             file: {
    1732. 

  1732.               node: {
    1733. 

  1733.                 getattr: MEMFS.node_ops.getattr,
    1734. 

  1734.                 setattr: MEMFS.node_ops.setattr
    1735. 

  1735.               },
    1736. 

  1736.               stream: {
    1737. 

  1737.                 llseek: MEMFS.stream_ops.llseek,
    1738. 

  1738.                 read: MEMFS.stream_ops.read,
    1739. 

  1739.                 write: MEMFS.stream_ops.write,
    1740. 

  1740.                 allocate: MEMFS.stream_ops.allocate,
    1741. 

  1741.                 mmap: MEMFS.stream_ops.mmap
    1742. 

  1742.               }
    1743. 

  1743.             },
    1744. 

  1744.             link: {
    1745. 

  1745.               node: {
    1746. 

  1746.                 getattr: MEMFS.node_ops.getattr,
    1747. 

  1747.                 setattr: MEMFS.node_ops.setattr,
    1748. 

  1748.                 readlink: MEMFS.node_ops.readlink
    1749. 

  1749.               },
    1750. 

  1750.               stream: {}
    1751. 

  1751.             },
    1752. 

  1752.             chrdev: {
    1753. 

  1753.               node: {
    1754. 

  1754.                 getattr: MEMFS.node_ops.getattr,
    1755. 

  1755.                 setattr: MEMFS.node_ops.setattr
    1756. 

  1756.               },
    1757. 

  1757.               stream: FS.chrdev_stream_ops
    1758. 

  1758.             },
    1759. 

  1759.           };
    1760. 

  1760.         }
    1761. 

  1761.         var node = FS.createNode(parent, name, mode, dev);
    1762. 

  1762.         if (FS.isDir(node.mode)) {
    1763. 

  1763.           node.node_ops = MEMFS.ops_table.dir.node;
    1764. 

  1764.           node.stream_ops = MEMFS.ops_table.dir.stream;
    1765. 

  1765.           node.contents = {};
    1766. 

  1766.         } else if (FS.isFile(node.mode)) {
    1767. 

  1767.           node.node_ops = MEMFS.ops_table.file.node;
    1768. 

  1768.           node.stream_ops = MEMFS.ops_table.file.stream;
    1769. 

  1769.           node.contents = [];
    1770. 

  1770.           node.contentMode = MEMFS.CONTENT_FLEXIBLE;
    1771. 

  1771.         } else if (FS.isLink(node.mode)) {
    1772. 

  1772.           node.node_ops = MEMFS.ops_table.link.node;
    1773. 

  1773.           node.stream_ops = MEMFS.ops_table.link.stream;
    1774. 

  1774.         } else if (FS.isChrdev(node.mode)) {
    1775. 

  1775.           node.node_ops = MEMFS.ops_table.chrdev.node;
    1776. 

  1776.           node.stream_ops = MEMFS.ops_table.chrdev.stream;
    1777. 

  1777.         }
    1778. 

  1778.         node.timestamp = Date.now();
    1779. 

  1779.         // add the new node to the parent
    1780. 

  1780.         if (parent) {
    1781. 

  1781.           parent.contents[name] = node;
    1782. 

  1782.         }
    1783. 

  1783.         return node;
    1784. 

  1784.       },ensureFlexible:function (node) {
    1785. 

  1785.         if (node.contentMode !== MEMFS.CONTENT_FLEXIBLE) {
    1786. 

  1786.           var contents = node.contents;
    1787. 

  1787.           node.contents = Array.prototype.slice.call(contents);
    1788. 

  1788.           node.contentMode = MEMFS.CONTENT_FLEXIBLE;
    1789. 

  1789.         }
    1790. 

  1790.       },node_ops:{getattr:function (node) {
    1791. 

  1791.           var attr = {};
    1792. 

  1792.           // device numbers reuse inode numbers.
    1793. 

  1793.           attr.dev = FS.isChrdev(node.mode) ? node.id : 1;
    1794. 

  1794.           attr.ino = node.id;
    1795. 

  1795.           attr.mode = node.mode;
    1796. 

  1796.           attr.nlink = 1;
    1797. 

  1797.           attr.uid = 0;
    1798. 

  1798.           attr.gid = 0;
    1799. 

  1799.           attr.rdev = node.rdev;
    1800. 

  1800.           if (FS.isDir(node.mode)) {
    1801. 

  1801.             attr.size = 4096;
    1802. 

  1802.           } else if (FS.isFile(node.mode)) {
    1803. 

  1803.             attr.size = node.contents.length;
    1804. 

  1804.           } else if (FS.isLink(node.mode)) {
    1805. 

  1805.             attr.size = node.link.length;
    1806. 

  1806.           } else {
    1807. 

  1807.             attr.size = 0;
    1808. 

  1808.           }
    1809. 

  1809.           attr.atime = new Date(node.timestamp);
    1810. 

  1810.           attr.mtime = new Date(node.timestamp);
    1811. 

  1811.           attr.ctime = new Date(node.timestamp);
    1812. 

  1812.           // NOTE: In our implementation, st_blocks = Math.ceil(st_size/st_blksize),
    1813. 

  1813.           //       but this is not required by the standard.
    1814. 

  1814.           attr.blksize = 4096;
    1815. 

  1815.           attr.blocks = Math.ceil(attr.size / attr.blksize);
    1816. 

  1816.           return attr;
    1817. 

  1817.         },setattr:function (node, attr) {
    1818. 

  1818.           if (attr.mode !== undefined) {
    1819. 

  1819.             node.mode = attr.mode;
    1820. 

  1820.           }
    1821. 

  1821.           if (attr.timestamp !== undefined) {
    1822. 

  1822.             node.timestamp = attr.timestamp;
    1823. 

  1823.           }
    1824. 

  1824.           if (attr.size !== undefined) {
    1825. 

  1825.             MEMFS.ensureFlexible(node);
    1826. 

  1826.             var contents = node.contents;
    1827. 

  1827.             if (attr.size < contents.length) contents.length = attr.size;
    1828. 

  1828.             else while (attr.size > contents.length) contents.push(0);
    1829. 

  1829.           }
    1830. 

  1830.         },lookup:function (parent, name) {
    1831. 

  1831.           throw FS.genericErrors[ERRNO_CODES.ENOENT];
    1832. 

  1832.         },mknod:function (parent, name, mode, dev) {
    1833. 

  1833.           return MEMFS.createNode(parent, name, mode, dev);
    1834. 

  1834.         },rename:function (old_node, new_dir, new_name) {
    1835. 

  1835.           // if we're overwriting a directory at new_name, make sure it's empty.
    1836. 

  1836.           if (FS.isDir(old_node.mode)) {
    1837. 

  1837.             var new_node;
    1838. 

  1838.             try {
    1839. 

  1839.               new_node = FS.lookupNode(new_dir, new_name);
    1840. 

  1840.             } catch (e) {
    1841. 

  1841.             }
    1842. 

  1842.             if (new_node) {
    1843. 

  1843.               for (var i in new_node.contents) {
    1844. 

  1844.                 throw new FS.ErrnoError(ERRNO_CODES.ENOTEMPTY);
    1845. 

  1845.               }
    1846. 

  1846.             }
    1847. 

  1847.           }
    1848. 

  1848.           // do the internal rewiring
    1849. 

  1849.           delete old_node.parent.contents[old_node.name];
    1850. 

  1850.           old_node.name = new_name;
    1851. 

  1851.           new_dir.contents[new_name] = old_node;
    1852. 

  1852.           old_node.parent = new_dir;
    1853. 

  1853.         },unlink:function (parent, name) {
    1854. 

  1854.           delete parent.contents[name];
    1855. 

  1855.         },rmdir:function (parent, name) {
    1856. 

  1856.           var node = FS.lookupNode(parent, name);
    1857. 

  1857.           for (var i in node.contents) {
    1858. 

  1858.             throw new FS.ErrnoError(ERRNO_CODES.ENOTEMPTY);
    1859. 

  1859.           }
    1860. 

  1860.           delete parent.contents[name];
    1861. 

  1861.         },readdir:function (node) {
    1862. 

  1862.           var entries = ['.', '..']
    1863. 

  1863.           for (var key in node.contents) {
    1864. 

  1864.             if (!node.contents.hasOwnProperty(key)) {
    1865. 

  1865.               continue;
    1866. 

  1866.             }
    1867. 

  1867.             entries.push(key);
    1868. 

  1868.           }
    1869. 

  1869.           return entries;
    1870. 

  1870.         },symlink:function (parent, newname, oldpath) {
    1871. 

  1871.           var node = MEMFS.createNode(parent, newname, 511 /* 0777 */ | 40960, 0);
    1872. 

  1872.           node.link = oldpath;
    1873. 

  1873.           return node;
    1874. 

  1874.         },readlink:function (node) {
    1875. 

  1875.           if (!FS.isLink(node.mode)) {
    1876. 

  1876.             throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
    1877. 

  1877.           }
    1878. 

  1878.           return node.link;
    1879. 

  1879.         }},stream_ops:{read:function (stream, buffer, offset, length, position) {
    1880. 

  1880.           var contents = stream.node.contents;
    1881. 

  1881.           if (position >= contents.length)
    1882. 

  1882.             return 0;
    1883. 

  1883.           var size = Math.min(contents.length - position, length);
    1884. 

  1884.           assert(size >= 0);
    1885. 

  1885.           if (size > 8 && contents.subarray) { // non-trivial, and typed array
    1886. 

  1886.             buffer.set(contents.subarray(position, position + size), offset);
    1887. 

  1887.           } else
    1888. 

  1888.           {
    1889. 

  1889.             for (var i = 0; i < size; i++) {
    1890. 

  1890.               buffer[offset + i] = contents[position + i];
    1891. 

  1891.             }
    1892. 

  1892.           }
    1893. 

  1893.           return size;
    1894. 

  1894.         },write:function (stream, buffer, offset, length, position, canOwn) {
    1895. 

  1895.           var node = stream.node;
    1896. 

  1896.           node.timestamp = Date.now();
    1897. 

  1897.           var contents = node.contents;
    1898. 

  1898.           if (length && contents.length === 0 && position === 0 && buffer.subarray) {
    1899. 

  1899.             // just replace it with the new data
    1900. 

  1900.             if (canOwn && offset === 0) {
    1901. 

  1901.               node.contents = buffer; // this could be a subarray of Emscripten HEAP, or allocated from some other source.
    1902. 

  1902.               node.contentMode = (buffer.buffer === HEAP8.buffer) ? MEMFS.CONTENT_OWNING : MEMFS.CONTENT_FIXED;
    1903. 

  1903.             } else {
    1904. 

  1904.               node.contents = new Uint8Array(buffer.subarray(offset, offset+length));
    1905. 

  1905.               node.contentMode = MEMFS.CONTENT_FIXED;
    1906. 

  1906.             }
    1907. 

  1907.             return length;
    1908. 

  1908.           }
    1909. 

  1909.           MEMFS.ensureFlexible(node);
    1910. 

  1910.           var contents = node.contents;
    1911. 

  1911.           while (contents.length < position) contents.push(0);
    1912. 

  1912.           for (var i = 0; i < length; i++) {
    1913. 

  1913.             contents[position + i] = buffer[offset + i];
    1914. 

  1914.           }
    1915. 

  1915.           return length;
    1916. 

  1916.         },llseek:function (stream, offset, whence) {
    1917. 

  1917.           var position = offset;
    1918. 

  1918.           if (whence === 1) {  // SEEK_CUR.
    1919. 

  1919.             position += stream.position;
    1920. 

  1920.           } else if (whence === 2) {  // SEEK_END.
    1921. 

  1921.             if (FS.isFile(stream.node.mode)) {
    1922. 

  1922.               position += stream.node.contents.length;
    1923. 

  1923.             }
    1924. 

  1924.           }
    1925. 

  1925.           if (position < 0) {
    1926. 

  1926.             throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
    1927. 

  1927.           }
    1928. 

  1928.           stream.ungotten = [];
    1929. 

  1929.           stream.position = position;
    1930. 

  1930.           return position;
    1931. 

  1931.         },allocate:function (stream, offset, length) {
    1932. 

  1932.           MEMFS.ensureFlexible(stream.node);
    1933. 

  1933.           var contents = stream.node.contents;
    1934. 

  1934.           var limit = offset + length;
    1935. 

  1935.           while (limit > contents.length) contents.push(0);
    1936. 

  1936.         },mmap:function (stream, buffer, offset, length, position, prot, flags) {
    1937. 

  1937.           if (!FS.isFile(stream.node.mode)) {
    1938. 

  1938.             throw new FS.ErrnoError(ERRNO_CODES.ENODEV);
    1939. 

  1939.           }
    1940. 

  1940.           var ptr;
    1941. 

  1941.           var allocated;
    1942. 

  1942.           var contents = stream.node.contents;
    1943. 

  1943.           // Only make a new copy when MAP_PRIVATE is specified.
    1944. 

  1944.           if ( !(flags & 2) &&
    1945. 

  1945.                 (contents.buffer === buffer || contents.buffer === buffer.buffer) ) {
    1946. 

  1946.             // We can't emulate MAP_SHARED when the file is not backed by the buffer
    1947. 

  1947.             // we're mapping to (e.g. the HEAP buffer).
    1948. 

  1948.             allocated = false;
    1949. 

  1949.             ptr = contents.byteOffset;
    1950. 

  1950.           } else {
    1951. 

  1951.             // Try to avoid unnecessary slices.
    1952. 

  1952.             if (position > 0 || position + length < contents.length) {
    1953. 

  1953.               if (contents.subarray) {
    1954. 

  1954.                 contents = contents.subarray(position, position + length);
    1955. 

  1955.               } else {
    1956. 

  1956.                 contents = Array.prototype.slice.call(contents, position, position + length);
    1957. 

  1957.               }
    1958. 

  1958.             }
    1959. 

  1959.             allocated = true;
    1960. 

  1960.             ptr = _malloc(length);
    1961. 

  1961.             if (!ptr) {
    1962. 

  1962.               throw new FS.ErrnoError(ERRNO_CODES.ENOMEM);
    1963. 

  1963.             }
    1964. 

  1964.             buffer.set(contents, ptr);
    1965. 

  1965.           }
    1966. 

  1966.           return { ptr: ptr, allocated: allocated };
    1967. 

  1967.         }}};
    1968. 

  1968. 

  1969.   var IDBFS={dbs:{},indexedDB:function () {
    1970. 

  1970.         return window.indexedDB || window.mozIndexedDB || window.webkitIndexedDB || window.msIndexedDB;
    1971. 

  1971.       },DB_VERSION:21,DB_STORE_NAME:"FILE_DATA",mount:function (mount) {
    1972. 

  1972.         // reuse all of the core MEMFS functionality
    1973. 

  1973.         return MEMFS.mount.apply(null, arguments);
    1974. 

  1974.       },syncfs:function (mount, populate, callback) {
    1975. 

  1975.         IDBFS.getLocalSet(mount, function(err, local) {
    1976. 

  1976.           if (err) return callback(err);
    1977. 

  1977. 

  1978.           IDBFS.getRemoteSet(mount, function(err, remote) {
    1979. 

  1979.             if (err) return callback(err);
    1980. 

  1980. 

  1981.             var src = populate ? remote : local;
    1982. 

  1982.             var dst = populate ? local : remote;
    1983. 

  1983. 

  1984.             IDBFS.reconcile(src, dst, callback);
    1985. 

  1985.           });
    1986. 

  1986.         });
    1987. 

  1987.       },getDB:function (name, callback) {
    1988. 

  1988.         // check the cache first
    1989. 

  1989.         var db = IDBFS.dbs[name];
    1990. 

  1990.         if (db) {
    1991. 

  1991.           return callback(null, db);
    1992. 

  1992.         }
    1993. 

  1993. 

  1994.         var req;
    1995. 

  1995.         try {
    1996. 

  1996.           req = IDBFS.indexedDB().open(name, IDBFS.DB_VERSION);
    1997. 

  1997.         } catch (e) {
    1998. 

  1998.           return callback(e);
    1999. 

  1999.         }
    2000. 

  2000.         req.onupgradeneeded = function(e) {
    2001. 

  2001.           var db = e.target.result;
    2002. 

  2002.           var transaction = e.target.transaction;
    2003. 

  2003. 

  2004.           var fileStore;
    2005. 

  2005. 

  2006.           if (db.objectStoreNames.contains(IDBFS.DB_STORE_NAME)) {
    2007. 

  2007.             fileStore = transaction.objectStore(IDBFS.DB_STORE_NAME);
    2008. 

  2008.           } else {
    2009. 

  2009.             fileStore = db.createObjectStore(IDBFS.DB_STORE_NAME);
    2010. 

  2010.           }
    2011. 

  2011. 

  2012.           fileStore.createIndex('timestamp', 'timestamp', { unique: false });
    2013. 

  2013.         };
    2014. 

  2014.         req.onsuccess = function() {
    2015. 

  2015.           db = req.result;
    2016. 

  2016. 

  2017.           // add to the cache
    2018. 

  2018.           IDBFS.dbs[name] = db;
    2019. 

  2019.           callback(null, db);
    2020. 

  2020.         };
    2021. 

  2021.         req.onerror = function() {
    2022. 

  2022.           callback(this.error);
    2023. 

  2023.         };
    2024. 

  2024.       },getLocalSet:function (mount, callback) {
    2025. 

  2025.         var entries = {};
    2026. 

  2026. 

  2027.         function isRealDir(p) {
    2028. 

  2028.           return p !== '.' && p !== '..';
    2029. 

  2029.         };
    2030. 

  2030.         function toAbsolute(root) {
    2031. 

  2031.           return function(p) {
    2032. 

  2032.             return PATH.join2(root, p);
    2033. 

  2033.           }
    2034. 

  2034.         };
    2035. 

  2035. 

  2036.         var check = FS.readdir(mount.mountpoint).filter(isRealDir).map(toAbsolute(mount.mountpoint));
    2037. 

  2037. 

  2038.         while (check.length) {
    2039. 

  2039.           var path = check.pop();
    2040. 

  2040.           var stat;
    2041. 

  2041. 

  2042.           try {
    2043. 

  2043.             stat = FS.stat(path);
    2044. 

  2044.           } catch (e) {
    2045. 

  2045.             return callback(e);
    2046. 

  2046.           }
    2047. 

  2047. 

  2048.           if (FS.isDir(stat.mode)) {
    2049. 

  2049.             check.push.apply(check, FS.readdir(path).filter(isRealDir).map(toAbsolute(path)));
    2050. 

  2050.           }
    2051. 

  2051. 

  2052.           entries[path] = { timestamp: stat.mtime };
    2053. 

  2053.         }
    2054. 

  2054. 

  2055.         return callback(null, { type: 'local', entries: entries });
    2056. 

  2056.       },getRemoteSet:function (mount, callback) {
    2057. 

  2057.         var entries = {};
    2058. 

  2058. 

  2059.         IDBFS.getDB(mount.mountpoint, function(err, db) {
    2060. 

  2060.           if (err) return callback(err);
    2061. 

  2061. 

  2062.           var transaction = db.transaction([IDBFS.DB_STORE_NAME], 'readonly');
    2063. 

  2063.           transaction.onerror = function() { callback(this.error); };
    2064. 

  2064. 

  2065.           var store = transaction.objectStore(IDBFS.DB_STORE_NAME);
    2066. 

  2066.           var index = store.index('timestamp');
    2067. 

  2067. 

  2068.           index.openKeyCursor().onsuccess = function(event) {
    2069. 

  2069.             var cursor = event.target.result;
    2070. 

  2070. 

  2071.             if (!cursor) {
    2072. 

  2072.               return callback(null, { type: 'remote', db: db, entries: entries });
    2073. 

  2073.             }
    2074. 

  2074. 

  2075.             entries[cursor.primaryKey] = { timestamp: cursor.key };
    2076. 

  2076. 

  2077.             cursor.continue();
    2078. 

  2078.           };
    2079. 

  2079.         });
    2080. 

  2080.       },loadLocalEntry:function (path, callback) {
    2081. 

  2081.         var stat, node;
    2082. 

  2082. 

  2083.         try {
    2084. 

  2084.           var lookup = FS.lookupPath(path);
    2085. 

  2085.           node = lookup.node;
    2086. 

  2086.           stat = FS.stat(path);
    2087. 

  2087.         } catch (e) {
    2088. 

  2088.           return callback(e);
    2089. 

  2089.         }
    2090. 

  2090. 

  2091.         if (FS.isDir(stat.mode)) {
    2092. 

  2092.           return callback(null, { timestamp: stat.mtime, mode: stat.mode });
    2093. 

  2093.         } else if (FS.isFile(stat.mode)) {
    2094. 

  2094.           return callback(null, { timestamp: stat.mtime, mode: stat.mode, contents: node.contents });
    2095. 

  2095.         } else {
    2096. 

  2096.           return callback(new Error('node type not supported'));
    2097. 

  2097.         }
    2098. 

  2098.       },storeLocalEntry:function (path, entry, callback) {
    2099. 

  2099.         try {
    2100. 

  2100.           if (FS.isDir(entry.mode)) {
    2101. 

  2101.             FS.mkdir(path, entry.mode);
    2102. 

  2102.           } else if (FS.isFile(entry.mode)) {
    2103. 

  2103.             FS.writeFile(path, entry.contents, { encoding: 'binary', canOwn: true });
    2104. 

  2104.           } else {
    2105. 

  2105.             return callback(new Error('node type not supported'));
    2106. 

  2106.           }
    2107. 

  2107. 

  2108.           FS.utime(path, entry.timestamp, entry.timestamp);
    2109. 

  2109.         } catch (e) {
    2110. 

  2110.           return callback(e);
    2111. 

  2111.         }
    2112. 

  2112. 

  2113.         callback(null);
    2114. 

  2114.       },removeLocalEntry:function (path, callback) {
    2115. 

  2115.         try {
    2116. 

  2116.           var lookup = FS.lookupPath(path);
    2117. 

  2117.           var stat = FS.stat(path);
    2118. 

  2118. 

  2119.           if (FS.isDir(stat.mode)) {
    2120. 

  2120.             FS.rmdir(path);
    2121. 

  2121.           } else if (FS.isFile(stat.mode)) {
    2122. 

  2122.             FS.unlink(path);
    2123. 

  2123.           }
    2124. 

  2124.         } catch (e) {
    2125. 

  2125.           return callback(e);
    2126. 

  2126.         }
    2127. 

  2127. 

  2128.         callback(null);
    2129. 

  2129.       },loadRemoteEntry:function (store, path, callback) {
    2130. 

  2130.         var req = store.get(path);
    2131. 

  2131.         req.onsuccess = function(event) { callback(null, event.target.result); };
    2132. 

  2132.         req.onerror = function() { callback(this.error); };
    2133. 

  2133.       },storeRemoteEntry:function (store, path, entry, callback) {
    2134. 

  2134.         var req = store.put(entry, path);
    2135. 

  2135.         req.onsuccess = function() { callback(null); };
    2136. 

  2136.         req.onerror = function() { callback(this.error); };
    2137. 

  2137.       },removeRemoteEntry:function (store, path, callback) {
    2138. 

  2138.         var req = store.delete(path);
    2139. 

  2139.         req.onsuccess = function() { callback(null); };
    2140. 

  2140.         req.onerror = function() { callback(this.error); };
    2141. 

  2141.       },reconcile:function (src, dst, callback) {
    2142. 

  2142.         var total = 0;
    2143. 

  2143. 

  2144.         var create = [];
    2145. 

  2145.         Object.keys(src.entries).forEach(function (key) {
    2146. 

  2146.           var e = src.entries[key];
    2147. 

  2147.           var e2 = dst.entries[key];
    2148. 

  2148.           if (!e2 || e.timestamp > e2.timestamp) {
    2149. 

  2149.             create.push(key);
    2150. 

  2150.             total++;
    2151. 

  2151.           }
    2152. 

  2152.         });
    2153. 

  2153. 

  2154.         var remove = [];
    2155. 

  2155.         Object.keys(dst.entries).forEach(function (key) {
    2156. 

  2156.           var e = dst.entries[key];
    2157. 

  2157.           var e2 = src.entries[key];
    2158. 

  2158.           if (!e2) {
    2159. 

  2159.             remove.push(key);
    2160. 

  2160.             total++;
    2161. 

  2161.           }
    2162. 

  2162.         });
    2163. 

  2163. 

  2164.         if (!total) {
    2165. 

  2165.           return callback(null);
    2166. 

  2166.         }
    2167. 

  2167. 

  2168.         var errored = false;
    2169. 

  2169.         var completed = 0;
    2170. 

  2170.         var db = src.type === 'remote' ? src.db : dst.db;
    2171. 

  2171.         var transaction = db.transaction([IDBFS.DB_STORE_NAME], 'readwrite');
    2172. 

  2172.         var store = transaction.objectStore(IDBFS.DB_STORE_NAME);
    2173. 

  2173. 

  2174.         function done(err) {
    2175. 

  2175.           if (err) {
    2176. 

  2176.             if (!done.errored) {
    2177. 

  2177.               done.errored = true;
    2178. 

  2178.               return callback(err);
    2179. 

  2179.             }
    2180. 

  2180.             return;
    2181. 

  2181.           }
    2182. 

  2182.           if (++completed >= total) {
    2183. 

  2183.             return callback(null);
    2184. 

  2184.           }
    2185. 

  2185.         };
    2186. 

  2186. 

  2187.         transaction.onerror = function() { done(this.error); };
    2188. 

  2188. 

  2189.         // sort paths in ascending order so directory entries are created
    2190. 

  2190.         // before the files inside them
    2191. 

  2191.         create.sort().forEach(function (path) {
    2192. 

  2192.           if (dst.type === 'local') {
    2193. 

  2193.             IDBFS.loadRemoteEntry(store, path, function (err, entry) {
    2194. 

  2194.               if (err) return done(err);
    2195. 

  2195.               IDBFS.storeLocalEntry(path, entry, done);
    2196. 

  2196.             });
    2197. 

  2197.           } else {
    2198. 

  2198.             IDBFS.loadLocalEntry(path, function (err, entry) {
    2199. 

  2199.               if (err) return done(err);
    2200. 

  2200.               IDBFS.storeRemoteEntry(store, path, entry, done);
    2201. 

  2201.             });
    2202. 

  2202.           }
    2203. 

  2203.         });
    2204. 

  2204. 

  2205.         // sort paths in descending order so files are deleted before their
    2206. 

  2206.         // parent directories
    2207. 

  2207.         remove.sort().reverse().forEach(function(path) {
    2208. 

  2208.           if (dst.type === 'local') {
    2209. 

  2209.             IDBFS.removeLocalEntry(path, done);
    2210. 

  2210.           } else {
    2211. 

  2211.             IDBFS.removeRemoteEntry(store, path, done);
    2212. 

  2212.           }
    2213. 

  2213.         });
    2214. 

  2214.       }};
    2215. 

  2215. 

  2216.   var NODEFS={isWindows:false,staticInit:function () {
    2217. 

  2217.         NODEFS.isWindows = !!process.platform.match(/^win/);
    2218. 

  2218.       },mount:function (mount) {
    2219. 

  2219.         assert(ENVIRONMENT_IS_NODE);
    2220. 

  2220.         return NODEFS.createNode(null, '/', NODEFS.getMode(mount.opts.root), 0);
    2221. 

  2221.       },createNode:function (parent, name, mode, dev) {
    2222. 

  2222.         if (!FS.isDir(mode) && !FS.isFile(mode) && !FS.isLink(mode)) {
    2223. 

  2223.           throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
    2224. 

  2224.         }
    2225. 

  2225.         var node = FS.createNode(parent, name, mode);
    2226. 

  2226.         node.node_ops = NODEFS.node_ops;
    2227. 

  2227.         node.stream_ops = NODEFS.stream_ops;
    2228. 

  2228.         return node;
    2229. 

  2229.       },getMode:function (path) {
    2230. 

  2230.         var stat;
    2231. 

  2231.         try {
    2232. 

  2232.           stat = fs.lstatSync(path);
    2233. 

  2233.           if (NODEFS.isWindows) {
    2234. 

  2234.             // On Windows, directories return permission bits 'rw-rw-rw-', even though they have 'rwxrwxrwx', so
    2235. 

  2235.             // propagate write bits to execute bits.
    2236. 

  2236.             stat.mode = stat.mode | ((stat.mode & 146) >> 1);
    2237. 

  2237.           }
    2238. 

  2238.         } catch (e) {
    2239. 

  2239.           if (!e.code) throw e;
    2240. 

  2240.           throw new FS.ErrnoError(ERRNO_CODES[e.code]);
    2241. 

  2241.         }
    2242. 

  2242.         return stat.mode;
    2243. 

  2243.       },realPath:function (node) {
    2244. 

  2244.         var parts = [];
    2245. 

  2245.         while (node.parent !== node) {
    2246. 

  2246.           parts.push(node.name);
    2247. 

  2247.           node = node.parent;
    2248. 

  2248.         }
    2249. 

  2249.         parts.push(node.mount.opts.root);
    2250. 

  2250.         parts.reverse();
    2251. 

  2251.         return PATH.join.apply(null, parts);
    2252. 

  2252.       },flagsToPermissionStringMap:{0:"r",1:"r+",2:"r+",64:"r",65:"r+",66:"r+",129:"rx+",193:"rx+",514:"w+",577:"w",578:"w+",705:"wx",706:"wx+",1024:"a",1025:"a",1026:"a+",1089:"a",1090:"a+",1153:"ax",1154:"ax+",1217:"ax",1218:"ax+",4096:"rs",4098:"rs+"},flagsToPermissionString:function (flags) {
    2253. 

  2253.         if (flags in NODEFS.flagsToPermissionStringMap) {
    2254. 

  2254.           return NODEFS.flagsToPermissionStringMap[flags];
    2255. 

  2255.         } else {
    2256. 

  2256.           return flags;
    2257. 

  2257.         }
    2258. 

  2258.       },node_ops:{getattr:function (node) {
    2259. 

  2259.           var path = NODEFS.realPath(node);
    2260. 

  2260.           var stat;
    2261. 

  2261.           try {
    2262. 

  2262.             stat = fs.lstatSync(path);
    2263. 

  2263.           } catch (e) {
    2264. 

  2264.             if (!e.code) throw e;
    2265. 

  2265.             throw new FS.ErrnoError(ERRNO_CODES[e.code]);
    2266. 

  2266.           }
    2267. 

  2267.           // node.js v0.10.20 doesn't report blksize and blocks on Windows. Fake them with default blksize of 4096.
    2268. 

  2268.           // See http://support.microsoft.com/kb/140365
    2269. 

  2269.           if (NODEFS.isWindows && !stat.blksize) {
    2270. 

  2270.             stat.blksize = 4096;
    2271. 

  2271.           }
    2272. 

  2272.           if (NODEFS.isWindows && !stat.blocks) {
    2273. 

  2273.             stat.blocks = (stat.size+stat.blksize-1)/stat.blksize|0;
    2274. 

  2274.           }
    2275. 

  2275.           return {
    2276. 

  2276.             dev: stat.dev,
    2277. 

  2277.             ino: stat.ino,
    2278. 

  2278.             mode: stat.mode,
    2279. 

  2279.             nlink: stat.nlink,
    2280. 

  2280.             uid: stat.uid,
    2281. 

  2281.             gid: stat.gid,
    2282. 

  2282.             rdev: stat.rdev,
    2283. 

  2283.             size: stat.size,
    2284. 

  2284.             atime: stat.atime,
    2285. 

  2285.             mtime: stat.mtime,
    2286. 

  2286.             ctime: stat.ctime,
    2287. 

  2287.             blksize: stat.blksize,
    2288. 

  2288.             blocks: stat.blocks
    2289. 

  2289.           };
    2290. 

  2290.         },setattr:function (node, attr) {
    2291. 

  2291.           var path = NODEFS.realPath(node);
    2292. 

  2292.           try {
    2293. 

  2293.             if (attr.mode !== undefined) {
    2294. 

  2294.               fs.chmodSync(path, attr.mode);
    2295. 

  2295.               // update the common node structure mode as well
    2296. 

  2296.               node.mode = attr.mode;
    2297. 

  2297.             }
    2298. 

  2298.             if (attr.timestamp !== undefined) {
    2299. 

  2299.               var date = new Date(attr.timestamp);
    2300. 

  2300.               fs.utimesSync(path, date, date);
    2301. 

  2301.             }
    2302. 

  2302.             if (attr.size !== undefined) {
    2303. 

  2303.               fs.truncateSync(path, attr.size);
    2304. 

  2304.             }
    2305. 

  2305.           } catch (e) {
    2306. 

  2306.             if (!e.code) throw e;
    2307. 

  2307.             throw new FS.ErrnoError(ERRNO_CODES[e.code]);
    2308. 

  2308.           }
    2309. 

  2309.         },lookup:function (parent, name) {
    2310. 

  2310.           var path = PATH.join2(NODEFS.realPath(parent), name);
    2311. 

  2311.           var mode = NODEFS.getMode(path);
    2312. 

  2312.           return NODEFS.createNode(parent, name, mode);
    2313. 

  2313.         },mknod:function (parent, name, mode, dev) {
    2314. 

  2314.           var node = NODEFS.createNode(parent, name, mode, dev);
    2315. 

  2315.           // create the backing node for this in the fs root as well
    2316. 

  2316.           var path = NODEFS.realPath(node);
    2317. 

  2317.           try {
    2318. 

  2318.             if (FS.isDir(node.mode)) {
    2319. 

  2319.               fs.mkdirSync(path, node.mode);
    2320. 

  2320.             } else {
    2321. 

  2321.               fs.writeFileSync(path, '', { mode: node.mode });
    2322. 

  2322.             }
    2323. 

  2323.           } catch (e) {
    2324. 

  2324.             if (!e.code) throw e;
    2325. 

  2325.             throw new FS.ErrnoError(ERRNO_CODES[e.code]);
    2326. 

  2326.           }
    2327. 

  2327.           return node;
    2328. 

  2328.         },rename:function (oldNode, newDir, newName) {
    2329. 

  2329.           var oldPath = NODEFS.realPath(oldNode);
    2330. 

  2330.           var newPath = PATH.join2(NODEFS.realPath(newDir), newName);
    2331. 

  2331.           try {
    2332. 

  2332.             fs.renameSync(oldPath, newPath);
    2333. 

  2333.           } catch (e) {
    2334. 

  2334.             if (!e.code) throw e;
    2335. 

  2335.             throw new FS.ErrnoError(ERRNO_CODES[e.code]);
    2336. 

  2336.           }
    2337. 

  2337.         },unlink:function (parent, name) {
    2338. 

  2338.           var path = PATH.join2(NODEFS.realPath(parent), name);
    2339. 

  2339.           try {
    2340. 

  2340.             fs.unlinkSync(path);
    2341. 

  2341.           } catch (e) {
    2342. 

  2342.             if (!e.code) throw e;
    2343. 

  2343.             throw new FS.ErrnoError(ERRNO_CODES[e.code]);
    2344. 

  2344.           }
    2345. 

  2345.         },rmdir:function (parent, name) {
    2346. 

  2346.           var path = PATH.join2(NODEFS.realPath(parent), name);
    2347. 

  2347.           try {
    2348. 

  2348.             fs.rmdirSync(path);
    2349. 

  2349.           } catch (e) {
    2350. 

  2350.             if (!e.code) throw e;
    2351. 

  2351.             throw new FS.ErrnoError(ERRNO_CODES[e.code]);
    2352. 

  2352.           }
    2353. 

  2353.         },readdir:function (node) {
    2354. 

  2354.           var path = NODEFS.realPath(node);
    2355. 

  2355.           try {
    2356. 

  2356.             return fs.readdirSync(path);
    2357. 

  2357.           } catch (e) {
    2358. 

  2358.             if (!e.code) throw e;
    2359. 

  2359.             throw new FS.ErrnoError(ERRNO_CODES[e.code]);
    2360. 

  2360.           }
    2361. 

  2361.         },symlink:function (parent, newName, oldPath) {
    2362. 

  2362.           var newPath = PATH.join2(NODEFS.realPath(parent), newName);
    2363. 

  2363.           try {
    2364. 

  2364.             fs.symlinkSync(oldPath, newPath);
    2365. 

  2365.           } catch (e) {
    2366. 

  2366.             if (!e.code) throw e;
    2367. 

  2367.             throw new FS.ErrnoError(ERRNO_CODES[e.code]);
    2368. 

  2368.           }
    2369. 

  2369.         },readlink:function (node) {
    2370. 

  2370.           var path = NODEFS.realPath(node);
    2371. 

  2371.           try {
    2372. 

  2372.             return fs.readlinkSync(path);
    2373. 

  2373.           } catch (e) {
    2374. 

  2374.             if (!e.code) throw e;
    2375. 

  2375.             throw new FS.ErrnoError(ERRNO_CODES[e.code]);
    2376. 

  2376.           }
    2377. 

  2377.         }},stream_ops:{open:function (stream) {
    2378. 

  2378.           var path = NODEFS.realPath(stream.node);
    2379. 

  2379.           try {
    2380. 

  2380.             if (FS.isFile(stream.node.mode)) {
    2381. 

  2381.               stream.nfd = fs.openSync(path, NODEFS.flagsToPermissionString(stream.flags));
    2382. 

  2382.             }
    2383. 

  2383.           } catch (e) {
    2384. 

  2384.             if (!e.code) throw e;
    2385. 

  2385.             throw new FS.ErrnoError(ERRNO_CODES[e.code]);
    2386. 

  2386.           }
    2387. 

  2387.         },close:function (stream) {
    2388. 

  2388.           try {
    2389. 

  2389.             if (FS.isFile(stream.node.mode) && stream.nfd) {
    2390. 

  2390.               fs.closeSync(stream.nfd);
    2391. 

  2391.             }
    2392. 

  2392.           } catch (e) {
    2393. 

  2393.             if (!e.code) throw e;
    2394. 

  2394.             throw new FS.ErrnoError(ERRNO_CODES[e.code]);
    2395. 

  2395.           }
    2396. 

  2396.         },read:function (stream, buffer, offset, length, position) {
    2397. 

  2397.           // FIXME this is terrible.
    2398. 

  2398.           var nbuffer = new Buffer(length);
    2399. 

  2399.           var res;
    2400. 

  2400.           try {
    2401. 

  2401.             res = fs.readSync(stream.nfd, nbuffer, 0, length, position);
    2402. 

  2402.           } catch (e) {
    2403. 

  2403.             throw new FS.ErrnoError(ERRNO_CODES[e.code]);
    2404. 

  2404.           }
    2405. 

  2405.           if (res > 0) {
    2406. 

  2406.             for (var i = 0; i < res; i++) {
    2407. 

  2407.               buffer[offset + i] = nbuffer[i];
    2408. 

  2408.             }
    2409. 

  2409.           }
    2410. 

  2410.           return res;
    2411. 

  2411.         },write:function (stream, buffer, offset, length, position) {
    2412. 

  2412.           // FIXME this is terrible.
    2413. 

  2413.           var nbuffer = new Buffer(buffer.subarray(offset, offset + length));
    2414. 

  2414.           var res;
    2415. 

  2415.           try {
    2416. 

  2416.             res = fs.writeSync(stream.nfd, nbuffer, 0, length, position);
    2417. 

  2417.           } catch (e) {
    2418. 

  2418.             throw new FS.ErrnoError(ERRNO_CODES[e.code]);
    2419. 

  2419.           }
    2420. 

  2420.           return res;
    2421. 

  2421.         },llseek:function (stream, offset, whence) {
    2422. 

  2422.           var position = offset;
    2423. 

  2423.           if (whence === 1) {  // SEEK_CUR.
    2424. 

  2424.             position += stream.position;
    2425. 

  2425.           } else if (whence === 2) {  // SEEK_END.
    2426. 

  2426.             if (FS.isFile(stream.node.mode)) {
    2427. 

  2427.               try {
    2428. 

  2428.                 var stat = fs.fstatSync(stream.nfd);
    2429. 

  2429.                 position += stat.size;
    2430. 

  2430.               } catch (e) {
    2431. 

  2431.                 throw new FS.ErrnoError(ERRNO_CODES[e.code]);
    2432. 

  2432.               }
    2433. 

  2433.             }
    2434. 

  2434.           }
    2435. 

  2435. 

  2436.           if (position < 0) {
    2437. 

  2437.             throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
    2438. 

  2438.           }
    2439. 

  2439. 

  2440.           stream.position = position;
    2441. 

  2441.           return position;
    2442. 

  2442.         }}};
    2443. 

  2443. 

  2444.   var _stdin=allocate(1, "i32*", ALLOC_STATIC);
    2445. 

  2445. 

  2446.   var _stdout=allocate(1, "i32*", ALLOC_STATIC);
    2447. 

  2447. 

  2448.   var _stderr=allocate(1, "i32*", ALLOC_STATIC);
    2449. 

  2449. 

  2450.   function _fflush(stream) {
    2451. 

  2451.       // int fflush(FILE *stream);
    2452. 

  2452.       // http://pubs.opengroup.org/onlinepubs/000095399/functions/fflush.html
    2453. 

  2453.       // we don't currently perform any user-space buffering of data
    2454. 

  2454.     }var FS={root:null,mounts:[],devices:[null],streams:[],nextInode:1,nameTable:null,currentPath:"/",initialized:false,ignorePermissions:true,ErrnoError:null,genericErrors:{},handleFSError:function (e) {
    2455. 

  2455.         if (!(e instanceof FS.ErrnoError)) throw e + ' : ' + stackTrace();
    2456. 

  2456.         return ___setErrNo(e.errno);
    2457. 

  2457.       },lookupPath:function (path, opts) {
    2458. 

  2458.         path = PATH.resolve(FS.cwd(), path);
    2459. 

  2459.         opts = opts || {};
    2460. 

  2460. 

  2461.         var defaults = {
    2462. 

  2462.           follow_mount: true,
    2463. 

  2463.           recurse_count: 0
    2464. 

  2464.         };
    2465. 

  2465.         for (var key in defaults) {
    2466. 

  2466.           if (opts[key] === undefined) {
    2467. 

  2467.             opts[key] = defaults[key];
    2468. 

  2468.           }
    2469. 

  2469.         }
    2470. 

  2470. 

  2471.         if (opts.recurse_count > 8) {  // max recursive lookup of 8
    2472. 

  2472.           throw new FS.ErrnoError(ERRNO_CODES.ELOOP);
    2473. 

  2473.         }
    2474. 

  2474. 

  2475.         // split the path
    2476. 

  2476.         var parts = PATH.normalizeArray(path.split('/').filter(function(p) {
    2477. 

  2477.           return !!p;
    2478. 

  2478.         }), false);
    2479. 

  2479. 

  2480.         // start at the root
    2481. 

  2481.         var current = FS.root;
    2482. 

  2482.         var current_path = '/';
    2483. 

  2483. 

  2484.         for (var i = 0; i < parts.length; i++) {
    2485. 

  2485.           var islast = (i === parts.length-1);
    2486. 

  2486.           if (islast && opts.parent) {
    2487. 

  2487.             // stop resolving
    2488. 

  2488.             break;
    2489. 

  2489.           }
    2490. 

  2490. 

  2491.           current = FS.lookupNode(current, parts[i]);
    2492. 

  2492.           current_path = PATH.join2(current_path, parts[i]);
    2493. 

  2493. 

  2494.           // jump to the mount's root node if this is a mountpoint
    2495. 

  2495.           if (FS.isMountpoint(current)) {
    2496. 

  2496.             if (!islast || (islast && opts.follow_mount)) {
    2497. 

  2497.               current = current.mounted.root;
    2498. 

  2498.             }
    2499. 

  2499.           }
    2500. 

  2500. 

  2501.           // by default, lookupPath will not follow a symlink if it is the final path component.
    2502. 

  2502.           // setting opts.follow = true will override this behavior.
    2503. 

  2503.           if (!islast || opts.follow) {
    2504. 

  2504.             var count = 0;
    2505. 

  2505.             while (FS.isLink(current.mode)) {
    2506. 

  2506.               var link = FS.readlink(current_path);
    2507. 

  2507.               current_path = PATH.resolve(PATH.dirname(current_path), link);
    2508. 

  2508. 

  2509.               var lookup = FS.lookupPath(current_path, { recurse_count: opts.recurse_count });
    2510. 

  2510.               current = lookup.node;
    2511. 

  2511. 

  2512.               if (count++ > 40) {  // limit max consecutive symlinks to 40 (SYMLOOP_MAX).
    2513. 

  2513.                 throw new FS.ErrnoError(ERRNO_CODES.ELOOP);
    2514. 

  2514.               }
    2515. 

  2515.             }
    2516. 

  2516.           }
    2517. 

  2517.         }
    2518. 

  2518. 

  2519.         return { path: current_path, node: current };
    2520. 

  2520.       },getPath:function (node) {
    2521. 

  2521.         var path;
    2522. 

  2522.         while (true) {
    2523. 

  2523.           if (FS.isRoot(node)) {
    2524. 

  2524.             var mount = node.mount.mountpoint;
    2525. 

  2525.             if (!path) return mount;
    2526. 

  2526.             return mount[mount.length-1] !== '/' ? mount + '/' + path : mount + path;
    2527. 

  2527.           }
    2528. 

  2528.           path = path ? node.name + '/' + path : node.name;
    2529. 

  2529.           node = node.parent;
    2530. 

  2530.         }
    2531. 

  2531.       },hashName:function (parentid, name) {
    2532. 

  2532.         var hash = 0;
    2533. 

  2533. 

  2534. 

  2535.         for (var i = 0; i < name.length; i++) {
    2536. 

  2536.           hash = ((hash << 5) - hash + name.charCodeAt(i)) | 0;
    2537. 

  2537.         }
    2538. 

  2538.         return ((parentid + hash) >>> 0) % FS.nameTable.length;
    2539. 

  2539.       },hashAddNode:function (node) {
    2540. 

  2540.         var hash = FS.hashName(node.parent.id, node.name);
    2541. 

  2541.         node.name_next = FS.nameTable[hash];
    2542. 

  2542.         FS.nameTable[hash] = node;
    2543. 

  2543.       },hashRemoveNode:function (node) {
    2544. 

  2544.         var hash = FS.hashName(node.parent.id, node.name);
    2545. 

  2545.         if (FS.nameTable[hash] === node) {
    2546. 

  2546.           FS.nameTable[hash] = node.name_next;
    2547. 

  2547.         } else {
    2548. 

  2548.           var current = FS.nameTable[hash];
    2549. 

  2549.           while (current) {
    2550. 

  2550.             if (current.name_next === node) {
    2551. 

  2551.               current.name_next = node.name_next;
    2552. 

  2552.               break;
    2553. 

  2553.             }
    2554. 

  2554.             current = current.name_next;
    2555. 

  2555.           }
    2556. 

  2556.         }
    2557. 

  2557.       },lookupNode:function (parent, name) {
    2558. 

  2558.         var err = FS.mayLookup(parent);
    2559. 

  2559.         if (err) {
    2560. 

  2560.           throw new FS.ErrnoError(err);
    2561. 

  2561.         }
    2562. 

  2562.         var hash = FS.hashName(parent.id, name);
    2563. 

  2563.         for (var node = FS.nameTable[hash]; node; node = node.name_next) {
    2564. 

  2564.           var nodeName = node.name;
    2565. 

  2565.           if (node.parent.id === parent.id && nodeName === name) {
    2566. 

  2566.             return node;
    2567. 

  2567.           }
    2568. 

  2568.         }
    2569. 

  2569.         // if we failed to find it in the cache, call into the VFS
    2570. 

  2570.         return FS.lookup(parent, name);
    2571. 

  2571.       },createNode:function (parent, name, mode, rdev) {
    2572. 

  2572.         if (!FS.FSNode) {
    2573. 

  2573.           FS.FSNode = function(parent, name, mode, rdev) {
    2574. 

  2574.             if (!parent) {
    2575. 

  2575.               parent = this;  // root node sets parent to itself
    2576. 

  2576.             }
    2577. 

  2577.             this.parent = parent;
    2578. 

  2578.             this.mount = parent.mount;
    2579. 

  2579.             this.mounted = null;
    2580. 

  2580.             this.id = FS.nextInode++;
    2581. 

  2581.             this.name = name;
    2582. 

  2582.             this.mode = mode;
    2583. 

  2583.             this.node_ops = {};
    2584. 

  2584.             this.stream_ops = {};
    2585. 

  2585.             this.rdev = rdev;
    2586. 

  2586.           };
    2587. 

  2587. 

  2588.           FS.FSNode.prototype = {};
    2589. 

  2589. 

  2590.           // compatibility
    2591. 

  2591.           var readMode = 292 | 73;
    2592. 

  2592.           var writeMode = 146;
    2593. 

  2593. 

  2594.           // NOTE we must use Object.defineProperties instead of individual calls to
    2595. 

  2595.           // Object.defineProperty in order to make closure compiler happy
    2596. 

  2596.           Object.defineProperties(FS.FSNode.prototype, {
    2597. 

  2597.             read: {
    2598. 

  2598.               get: function() { return (this.mode & readMode) === readMode; },
    2599. 

  2599.               set: function(val) { val ? this.mode |= readMode : this.mode &= ~readMode; }
    2600. 

  2600.             },
    2601. 

  2601.             write: {
    2602. 

  2602.               get: function() { return (this.mode & writeMode) === writeMode; },
    2603. 

  2603.               set: function(val) { val ? this.mode |= writeMode : this.mode &= ~writeMode; }
    2604. 

  2604.             },
    2605. 

  2605.             isFolder: {
    2606. 

  2606.               get: function() { return FS.isDir(this.mode); },
    2607. 

  2607.             },
    2608. 

  2608.             isDevice: {
    2609. 

  2609.               get: function() { return FS.isChrdev(this.mode); },
    2610. 

  2610.             },
    2611. 

  2611.           });
    2612. 

  2612.         }
    2613. 

  2613. 

  2614.         var node = new FS.FSNode(parent, name, mode, rdev);
    2615. 

  2615. 

  2616.         FS.hashAddNode(node);
    2617. 

  2617. 

  2618.         return node;
    2619. 

  2619.       },destroyNode:function (node) {
    2620. 

  2620.         FS.hashRemoveNode(node);
    2621. 

  2621.       },isRoot:function (node) {
    2622. 

  2622.         return node === node.parent;
    2623. 

  2623.       },isMountpoint:function (node) {
    2624. 

  2624.         return !!node.mounted;
    2625. 

  2625.       },isFile:function (mode) {
    2626. 

  2626.         return (mode & 61440) === 32768;
    2627. 

  2627.       },isDir:function (mode) {
    2628. 

  2628.         return (mode & 61440) === 16384;
    2629. 

  2629.       },isLink:function (mode) {
    2630. 

  2630.         return (mode & 61440) === 40960;
    2631. 

  2631.       },isChrdev:function (mode) {
    2632. 

  2632.         return (mode & 61440) === 8192;
    2633. 

  2633.       },isBlkdev:function (mode) {
    2634. 

  2634.         return (mode & 61440) === 24576;
    2635. 

  2635.       },isFIFO:function (mode) {
    2636. 

  2636.         return (mode & 61440) === 4096;
    2637. 

  2637.       },isSocket:function (mode) {
    2638. 

  2638.         return (mode & 49152) === 49152;
    2639. 

  2639.       },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) {
    2640. 

  2640.         var flags = FS.flagModes[str];
    2641. 

  2641.         if (typeof flags === 'undefined') {
    2642. 

  2642.           throw new Error('Unknown file open mode: ' + str);
    2643. 

  2643.         }
    2644. 

  2644.         return flags;
    2645. 

  2645.       },flagsToPermissionString:function (flag) {
    2646. 

  2646.         var accmode = flag & 2097155;
    2647. 

  2647.         var perms = ['r', 'w', 'rw'][accmode];
    2648. 

  2648.         if ((flag & 512)) {
    2649. 

  2649.           perms += 'w';
    2650. 

  2650.         }
    2651. 

  2651.         return perms;
    2652. 

  2652.       },nodePermissions:function (node, perms) {
    2653. 

  2653.         if (FS.ignorePermissions) {
    2654. 

  2654.           return 0;
    2655. 

  2655.         }
    2656. 

  2656.         // return 0 if any user, group or owner bits are set.
    2657. 

  2657.         if (perms.indexOf('r') !== -1 && !(node.mode & 292)) {
    2658. 

  2658.           return ERRNO_CODES.EACCES;
    2659. 

  2659.         } else if (perms.indexOf('w') !== -1 && !(node.mode & 146)) {
    2660. 

  2660.           return ERRNO_CODES.EACCES;
    2661. 

  2661.         } else if (perms.indexOf('x') !== -1 && !(node.mode & 73)) {
    2662. 

  2662.           return ERRNO_CODES.EACCES;
    2663. 

  2663.         }
    2664. 

  2664.         return 0;
    2665. 

  2665.       },mayLookup:function (dir) {
    2666. 

  2666.         return FS.nodePermissions(dir, 'x');
    2667. 

  2667.       },mayCreate:function (dir, name) {
    2668. 

  2668.         try {
    2669. 

  2669.           var node = FS.lookupNode(dir, name);
    2670. 

  2670.           return ERRNO_CODES.EEXIST;
    2671. 

  2671.         } catch (e) {
    2672. 

  2672.         }
    2673. 

  2673.         return FS.nodePermissions(dir, 'wx');
    2674. 

  2674.       },mayDelete:function (dir, name, isdir) {
    2675. 

  2675.         var node;
    2676. 

  2676.         try {
    2677. 

  2677.           node = FS.lookupNode(dir, name);
    2678. 

  2678.         } catch (e) {
    2679. 

  2679.           return e.errno;
    2680. 

  2680.         }
    2681. 

  2681.         var err = FS.nodePermissions(dir, 'wx');
    2682. 

  2682.         if (err) {
    2683. 

  2683.           return err;
    2684. 

  2684.         }
    2685. 

  2685.         if (isdir) {
    2686. 

  2686.           if (!FS.isDir(node.mode)) {
    2687. 

  2687.             return ERRNO_CODES.ENOTDIR;
    2688. 

  2688.           }
    2689. 

  2689.           if (FS.isRoot(node) || FS.getPath(node) === FS.cwd()) {
    2690. 

  2690.             return ERRNO_CODES.EBUSY;
    2691. 

  2691.           }
    2692. 

  2692.         } else {
    2693. 

  2693.           if (FS.isDir(node.mode)) {
    2694. 

  2694.             return ERRNO_CODES.EISDIR;
    2695. 

  2695.           }
    2696. 

  2696.         }
    2697. 

  2697.         return 0;
    2698. 

  2698.       },mayOpen:function (node, flags) {
    2699. 

  2699.         if (!node) {
    2700. 

  2700.           return ERRNO_CODES.ENOENT;
    2701. 

  2701.         }
    2702. 

  2702.         if (FS.isLink(node.mode)) {
    2703. 

  2703.           return ERRNO_CODES.ELOOP;
    2704. 

  2704.         } else if (FS.isDir(node.mode)) {
    2705. 

  2705.           if ((flags & 2097155) !== 0 ||  // opening for write
    2706. 

  2706.               (flags & 512)) {
    2707. 

  2707.             return ERRNO_CODES.EISDIR;
    2708. 

  2708.           }
    2709. 

  2709.         }
    2710. 

  2710.         return FS.nodePermissions(node, FS.flagsToPermissionString(flags));
    2711. 

  2711.       },MAX_OPEN_FDS:4096,nextfd:function (fd_start, fd_end) {
    2712. 

  2712.         fd_start = fd_start || 0;
    2713. 

  2713.         fd_end = fd_end || FS.MAX_OPEN_FDS;
    2714. 

  2714.         for (var fd = fd_start; fd <= fd_end; fd++) {
    2715. 

  2715.           if (!FS.streams[fd]) {
    2716. 

  2716.             return fd;
    2717. 

  2717.           }
    2718. 

  2718.         }
    2719. 

  2719.         throw new FS.ErrnoError(ERRNO_CODES.EMFILE);
    2720. 

  2720.       },getStream:function (fd) {
    2721. 

  2721.         return FS.streams[fd];
    2722. 

  2722.       },createStream:function (stream, fd_start, fd_end) {
    2723. 

  2723.         if (!FS.FSStream) {
    2724. 

  2724.           FS.FSStream = function(){};
    2725. 

  2725.           FS.FSStream.prototype = {};
    2726. 

  2726.           // compatibility
    2727. 

  2727.           Object.defineProperties(FS.FSStream.prototype, {
    2728. 

  2728.             object: {
    2729. 

  2729.               get: function() { return this.node; },
    2730. 

  2730.               set: function(val) { this.node = val; }
    2731. 

  2731.             },
    2732. 

  2732.             isRead: {
    2733. 

  2733.               get: function() { return (this.flags & 2097155) !== 1; }
    2734. 

  2734.             },
    2735. 

  2735.             isWrite: {
    2736. 

  2736.               get: function() { return (this.flags & 2097155) !== 0; }
    2737. 

  2737.             },
    2738. 

  2738.             isAppend: {
    2739. 

  2739.               get: function() { return (this.flags & 1024); }
    2740. 

  2740.             }
    2741. 

  2741.           });
    2742. 

  2742.         }
    2743. 

  2743.         if (0) {
    2744. 

  2744.           // reuse the object
    2745. 

  2745.           stream.__proto__ = FS.FSStream.prototype;
    2746. 

  2746.         } else {
    2747. 

  2747.           var newStream = new FS.FSStream();
    2748. 

  2748.           for (var p in stream) {
    2749. 

  2749.             newStream[p] = stream[p];
    2750. 

  2750.           }
    2751. 

  2751.           stream = newStream;
    2752. 

  2752.         }
    2753. 

  2753.         var fd = FS.nextfd(fd_start, fd_end);
    2754. 

  2754.         stream.fd = fd;
    2755. 

  2755.         FS.streams[fd] = stream;
    2756. 

  2756.         return stream;
    2757. 

  2757.       },closeStream:function (fd) {
    2758. 

  2758.         FS.streams[fd] = null;
    2759. 

  2759.       },getStreamFromPtr:function (ptr) {
    2760. 

  2760.         return FS.streams[ptr - 1];
    2761. 

  2761.       },getPtrForStream:function (stream) {
    2762. 

  2762.         return stream ? stream.fd + 1 : 0;
    2763. 

  2763.       },chrdev_stream_ops:{open:function (stream) {
    2764. 

  2764.           var device = FS.getDevice(stream.node.rdev);
    2765. 

  2765.           // override node's stream ops with the device's
    2766. 

  2766.           stream.stream_ops = device.stream_ops;
    2767. 

  2767.           // forward the open call
    2768. 

  2768.           if (stream.stream_ops.open) {
    2769. 

  2769.             stream.stream_ops.open(stream);
    2770. 

  2770.           }
    2771. 

  2771.         },llseek:function () {
    2772. 

  2772.           throw new FS.ErrnoError(ERRNO_CODES.ESPIPE);
    2773. 

  2773.         }},major:function (dev) {
    2774. 

  2774.         return ((dev) >> 8);
    2775. 

  2775.       },minor:function (dev) {
    2776. 

  2776.         return ((dev) & 0xff);
    2777. 

  2777.       },makedev:function (ma, mi) {
    2778. 

  2778.         return ((ma) << 8 | (mi));
    2779. 

  2779.       },registerDevice:function (dev, ops) {
    2780. 

  2780.         FS.devices[dev] = { stream_ops: ops };
    2781. 

  2781.       },getDevice:function (dev) {
    2782. 

  2782.         return FS.devices[dev];
    2783. 

  2783.       },getMounts:function (mount) {
    2784. 

  2784.         var mounts = [];
    2785. 

  2785.         var check = [mount];
    2786. 

  2786. 

  2787.         while (check.length) {
    2788. 

  2788.           var m = check.pop();
    2789. 

  2789. 

  2790.           mounts.push(m);
    2791. 

  2791. 

  2792.           check.push.apply(check, m.mounts);
    2793. 

  2793.         }
    2794. 

  2794. 

  2795.         return mounts;
    2796. 

  2796.       },syncfs:function (populate, callback) {
    2797. 

  2797.         if (typeof(populate) === 'function') {
    2798. 

  2798.           callback = populate;
    2799. 

  2799.           populate = false;
    2800. 

  2800.         }
    2801. 

  2801. 

  2802.         var mounts = FS.getMounts(FS.root.mount);
    2803. 

  2803.         var completed = 0;
    2804. 

  2804. 

  2805.         function done(err) {
    2806. 

  2806.           if (err) {
    2807. 

  2807.             if (!done.errored) {
    2808. 

  2808.               done.errored = true;
    2809. 

  2809.               return callback(err);
    2810. 

  2810.             }
    2811. 

  2811.             return;
    2812. 

  2812.           }
    2813. 

  2813.           if (++completed >= mounts.length) {
    2814. 

  2814.             callback(null);
    2815. 

  2815.           }
    2816. 

  2816.         };
    2817. 

  2817. 

  2818.         // sync all mounts
    2819. 

  2819.         mounts.forEach(function (mount) {
    2820. 

  2820.           if (!mount.type.syncfs) {
    2821. 

  2821.             return done(null);
    2822. 

  2822.           }
    2823. 

  2823.           mount.type.syncfs(mount, populate, done);
    2824. 

  2824.         });
    2825. 

  2825.       },mount:function (type, opts, mountpoint) {
    2826. 

  2826.         var root = mountpoint === '/';
    2827. 

  2827.         var pseudo = !mountpoint;
    2828. 

  2828.         var node;
    2829. 

  2829. 

  2830.         if (root && FS.root) {
    2831. 

  2831.           throw new FS.ErrnoError(ERRNO_CODES.EBUSY);
    2832. 

  2832.         } else if (!root && !pseudo) {
    2833. 

  2833.           var lookup = FS.lookupPath(mountpoint, { follow_mount: false });
    2834. 

  2834. 

  2835.           mountpoint = lookup.path;  // use the absolute path
    2836. 

  2836.           node = lookup.node;
    2837. 

  2837. 

  2838.           if (FS.isMountpoint(node)) {
    2839. 

  2839.             throw new FS.ErrnoError(ERRNO_CODES.EBUSY);
    2840. 

  2840.           }
    2841. 

  2841. 

  2842.           if (!FS.isDir(node.mode)) {
    2843. 

  2843.             throw new FS.ErrnoError(ERRNO_CODES.ENOTDIR);
    2844. 

  2844.           }
    2845. 

  2845.         }
    2846. 

  2846. 

  2847.         var mount = {
    2848. 

  2848.           type: type,
    2849. 

  2849.           opts: opts,
    2850. 

  2850.           mountpoint: mountpoint,
    2851. 

  2851.           mounts: []
    2852. 

  2852.         };
    2853. 

  2853. 

  2854.         // create a root node for the fs
    2855. 

  2855.         var mountRoot = type.mount(mount);
    2856. 

  2856.         mountRoot.mount = mount;
    2857. 

  2857.         mount.root = mountRoot;
    2858. 

  2858. 

  2859.         if (root) {
    2860. 

  2860.           FS.root = mountRoot;
    2861. 

  2861.         } else if (node) {
    2862. 

  2862.           // set as a mountpoint
    2863. 

  2863.           node.mounted = mount;
    2864. 

  2864. 

  2865.           // add the new mount to the current mount's children
    2866. 

  2866.           if (node.mount) {
    2867. 

  2867.             node.mount.mounts.push(mount);
    2868. 

  2868.           }
    2869. 

  2869.         }
    2870. 

  2870. 

  2871.         return mountRoot;
    2872. 

  2872.       },unmount:function (mountpoint) {
    2873. 

  2873.         var lookup = FS.lookupPath(mountpoint, { follow_mount: false });
    2874. 

  2874. 

  2875.         if (!FS.isMountpoint(lookup.node)) {
    2876. 

  2876.           throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
    2877. 

  2877.         }
    2878. 

  2878. 

  2879.         // destroy the nodes for this mount, and all its child mounts
    2880. 

  2880.         var node = lookup.node;
    2881. 

  2881.         var mount = node.mounted;
    2882. 

  2882.         var mounts = FS.getMounts(mount);
    2883. 

  2883. 

  2884.         Object.keys(FS.nameTable).forEach(function (hash) {
    2885. 

  2885.           var current = FS.nameTable[hash];
    2886. 

  2886. 

  2887.           while (current) {
    2888. 

  2888.             var next = current.name_next;
    2889. 

  2889. 

  2890.             if (mounts.indexOf(current.mount) !== -1) {
    2891. 

  2891.               FS.destroyNode(current);
    2892. 

  2892.             }
    2893. 

  2893. 

  2894.             current = next;
    2895. 

  2895.           }
    2896. 

  2896.         });
    2897. 

  2897. 

  2898.         // no longer a mountpoint
    2899. 

  2899.         node.mounted = null;
    2900. 

  2900. 

  2901.         // remove this mount from the child mounts
    2902. 

  2902.         var idx = node.mount.mounts.indexOf(mount);
    2903. 

  2903.         assert(idx !== -1);
    2904. 

  2904.         node.mount.mounts.splice(idx, 1);
    2905. 

  2905.       },lookup:function (parent, name) {
    2906. 

  2906.         return parent.node_ops.lookup(parent, name);
    2907. 

  2907.       },mknod:function (path, mode, dev) {
    2908. 

  2908.         var lookup = FS.lookupPath(path, { parent: true });
    2909. 

  2909.         var parent = lookup.node;
    2910. 

  2910.         var name = PATH.basename(path);
    2911. 

  2911.         var err = FS.mayCreate(parent, name);
    2912. 

  2912.         if (err) {
    2913. 

  2913.           throw new FS.ErrnoError(err);
    2914. 

  2914.         }
    2915. 

  2915.         if (!parent.node_ops.mknod) {
    2916. 

  2916.           throw new FS.ErrnoError(ERRNO_CODES.EPERM);
    2917. 

  2917.         }
    2918. 

  2918.         return parent.node_ops.mknod(parent, name, mode, dev);
    2919. 

  2919.       },create:function (path, mode) {
    2920. 

  2920.         mode = mode !== undefined ? mode : 438 /* 0666 */;
    2921. 

  2921.         mode &= 4095;
    2922. 

  2922.         mode |= 32768;
    2923. 

  2923.         return FS.mknod(path, mode, 0);
    2924. 

  2924.       },mkdir:function (path, mode) {
    2925. 

  2925.         mode = mode !== undefined ? mode : 511 /* 0777 */;
    2926. 

  2926.         mode &= 511 | 512;
    2927. 

  2927.         mode |= 16384;
    2928. 

  2928.         return FS.mknod(path, mode, 0);
    2929. 

  2929.       },mkdev:function (path, mode, dev) {
    2930. 

  2930.         if (typeof(dev) === 'undefined') {
    2931. 

  2931.           dev = mode;
    2932. 

  2932.           mode = 438 /* 0666 */;
    2933. 

  2933.         }
    2934. 

  2934.         mode |= 8192;
    2935. 

  2935.         return FS.mknod(path, mode, dev);
    2936. 

  2936.       },symlink:function (oldpath, newpath) {
    2937. 

  2937.         var lookup = FS.lookupPath(newpath, { parent: true });
    2938. 

  2938.         var parent = lookup.node;
    2939. 

  2939.         var newname = PATH.basename(newpath);
    2940. 

  2940.         var err = FS.mayCreate(parent, newname);
    2941. 

  2941.         if (err) {
    2942. 

  2942.           throw new FS.ErrnoError(err);
    2943. 

  2943.         }
    2944. 

  2944.         if (!parent.node_ops.symlink) {
    2945. 

  2945.           throw new FS.ErrnoError(ERRNO_CODES.EPERM);
    2946. 

  2946.         }
    2947. 

  2947.         return parent.node_ops.symlink(parent, newname, oldpath);
    2948. 

  2948.       },rename:function (old_path, new_path) {
    2949. 

  2949.         var old_dirname = PATH.dirname(old_path);
    2950. 

  2950.         var new_dirname = PATH.dirname(new_path);
    2951. 

  2951.         var old_name = PATH.basename(old_path);
    2952. 

  2952.         var new_name = PATH.basename(new_path);
    2953. 

  2953.         // parents must exist
    2954. 

  2954.         var lookup, old_dir, new_dir;
    2955. 

  2955.         try {
    2956. 

  2956.           lookup = FS.lookupPath(old_path, { parent: true });
    2957. 

  2957.           old_dir = lookup.node;
    2958. 

  2958.           lookup = FS.lookupPath(new_path, { parent: true });
    2959. 

  2959.           new_dir = lookup.node;
    2960. 

  2960.         } catch (e) {
    2961. 

  2961.           throw new FS.ErrnoError(ERRNO_CODES.EBUSY);
    2962. 

  2962.         }
    2963. 

  2963.         // need to be part of the same mount
    2964. 

  2964.         if (old_dir.mount !== new_dir.mount) {
    2965. 

  2965.           throw new FS.ErrnoError(ERRNO_CODES.EXDEV);
    2966. 

  2966.         }
    2967. 

  2967.         // source must exist
    2968. 

  2968.         var old_node = FS.lookupNode(old_dir, old_name);
    2969. 

  2969.         // old path should not be an ancestor of the new path
    2970. 

  2970.         var relative = PATH.relative(old_path, new_dirname);
    2971. 

  2971.         if (relative.charAt(0) !== '.') {
    2972. 

  2972.           throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
    2973. 

  2973.         }
    2974. 

  2974.         // new path should not be an ancestor of the old path
    2975. 

  2975.         relative = PATH.relative(new_path, old_dirname);
    2976. 

  2976.         if (relative.charAt(0) !== '.') {
    2977. 

  2977.           throw new FS.ErrnoError(ERRNO_CODES.ENOTEMPTY);
    2978. 

  2978.         }
    2979. 

  2979.         // see if the new path already exists
    2980. 

  2980.         var new_node;
    2981. 

  2981.         try {
    2982. 

  2982.           new_node = FS.lookupNode(new_dir, new_name);
    2983. 

  2983.         } catch (e) {
    2984. 

  2984.           // not fatal
    2985. 

  2985.         }
    2986. 

  2986.         // early out if nothing needs to change
    2987. 

  2987.         if (old_node === new_node) {
    2988. 

  2988.           return;
    2989. 

  2989.         }
    2990. 

  2990.         // we'll need to delete the old entry
    2991. 

  2991.         var isdir = FS.isDir(old_node.mode);
    2992. 

  2992.         var err = FS.mayDelete(old_dir, old_name, isdir);
    2993. 

  2993.         if (err) {
    2994. 

  2994.           throw new FS.ErrnoError(err);
    2995. 

  2995.         }
    2996. 

  2996.         // need delete permissions if we'll be overwriting.
    2997. 

  2997.         // need create permissions if new doesn't already exist.
    2998. 

  2998.         err = new_node ?
    2999. 

  2999.           FS.mayDelete(new_dir, new_name, isdir) :
    3000. 

  3000.           FS.mayCreate(new_dir, new_name);
    3001. 

  3001.         if (err) {
    3002. 

  3002.           throw new FS.ErrnoError(err);
    3003. 

  3003.         }
    3004. 

  3004.         if (!old_dir.node_ops.rename) {
    3005. 

  3005.           throw new FS.ErrnoError(ERRNO_CODES.EPERM);
    3006. 

  3006.         }
    3007. 

  3007.         if (FS.isMountpoint(old_node) || (new_node && FS.isMountpoint(new_node))) {
    3008. 

  3008.           throw new FS.ErrnoError(ERRNO_CODES.EBUSY);
    3009. 

  3009.         }
    3010. 

  3010.         // if we are going to change the parent, check write permissions
    3011. 

  3011.         if (new_dir !== old_dir) {
    3012. 

  3012.           err = FS.nodePermissions(old_dir, 'w');
    3013. 

  3013.           if (err) {
    3014. 

  3014.             throw new FS.ErrnoError(err);
    3015. 

  3015.           }
    3016. 

  3016.         }
    3017. 

  3017.         // remove the node from the lookup hash
    3018. 

  3018.         FS.hashRemoveNode(old_node);
    3019. 

  3019.         // do the underlying fs rename
    3020. 

  3020.         try {
    3021. 

  3021.           old_dir.node_ops.rename(old_node, new_dir, new_name);
    3022. 

  3022.         } catch (e) {
    3023. 

  3023.           throw e;
    3024. 

  3024.         } finally {
    3025. 

  3025.           // add the node back to the hash (in case node_ops.rename
    3026. 

  3026.           // changed its name)
    3027. 

  3027.           FS.hashAddNode(old_node);
    3028. 

  3028.         }
    3029. 

  3029.       },rmdir:function (path) {
    3030. 

  3030.         var lookup = FS.lookupPath(path, { parent: true });
    3031. 

  3031.         var parent = lookup.node;
    3032. 

  3032.         var name = PATH.basename(path);
    3033. 

  3033.         var node = FS.lookupNode(parent, name);
    3034. 

  3034.         var err = FS.mayDelete(parent, name, true);
    3035. 

  3035.         if (err) {
    3036. 

  3036.           throw new FS.ErrnoError(err);
    3037. 

  3037.         }
    3038. 

  3038.         if (!parent.node_ops.rmdir) {
    3039. 

  3039.           throw new FS.ErrnoError(ERRNO_CODES.EPERM);
    3040. 

  3040.         }
    3041. 

  3041.         if (FS.isMountpoint(node)) {
    3042. 

  3042.           throw new FS.ErrnoError(ERRNO_CODES.EBUSY);
    3043. 

  3043.         }
    3044. 

  3044.         parent.node_ops.rmdir(parent, name);
    3045. 

  3045.         FS.destroyNode(node);
    3046. 

  3046.       },readdir:function (path) {
    3047. 

  3047.         var lookup = FS.lookupPath(path, { follow: true });
    3048. 

  3048.         var node = lookup.node;
    3049. 

  3049.         if (!node.node_ops.readdir) {
    3050. 

  3050.           throw new FS.ErrnoError(ERRNO_CODES.ENOTDIR);
    3051. 

  3051.         }
    3052. 

  3052.         return node.node_ops.readdir(node);
    3053. 

  3053.       },unlink:function (path) {
    3054. 

  3054.         var lookup = FS.lookupPath(path, { parent: true });
    3055. 

  3055.         var parent = lookup.node;
    3056. 

  3056.         var name = PATH.basename(path);
    3057. 

  3057.         var node = FS.lookupNode(parent, name);
    3058. 

  3058.         var err = FS.mayDelete(parent, name, false);
    3059. 

  3059.         if (err) {
    3060. 

  3060.           // POSIX says unlink should set EPERM, not EISDIR
    3061. 

  3061.           if (err === ERRNO_CODES.EISDIR) err = ERRNO_CODES.EPERM;
    3062. 

  3062.           throw new FS.ErrnoError(err);
    3063. 

  3063.         }
    3064. 

  3064.         if (!parent.node_ops.unlink) {
    3065. 

  3065.           throw new FS.ErrnoError(ERRNO_CODES.EPERM);
    3066. 

  3066.         }
    3067. 

  3067.         if (FS.isMountpoint(node)) {
    3068. 

  3068.           throw new FS.ErrnoError(ERRNO_CODES.EBUSY);
    3069. 

  3069.         }
    3070. 

  3070.         parent.node_ops.unlink(parent, name);
    3071. 

  3071.         FS.destroyNode(node);
    3072. 

  3072.       },readlink:function (path) {
    3073. 

  3073.         var lookup = FS.lookupPath(path);
    3074. 

  3074.         var link = lookup.node;
    3075. 

  3075.         if (!link.node_ops.readlink) {
    3076. 

  3076.           throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
    3077. 

  3077.         }
    3078. 

  3078.         return link.node_ops.readlink(link);
    3079. 

  3079.       },stat:function (path, dontFollow) {
    3080. 

  3080.         var lookup = FS.lookupPath(path, { follow: !dontFollow });
    3081. 

  3081.         var node = lookup.node;
    3082. 

  3082.         if (!node.node_ops.getattr) {
    3083. 

  3083.           throw new FS.ErrnoError(ERRNO_CODES.EPERM);
    3084. 

  3084.         }
    3085. 

  3085.         return node.node_ops.getattr(node);
    3086. 

  3086.       },lstat:function (path) {
    3087. 

  3087.         return FS.stat(path, true);
    3088. 

  3088.       },chmod:function (path, mode, dontFollow) {
    3089. 

  3089.         var node;
    3090. 

  3090.         if (typeof path === 'string') {
    3091. 

  3091.           var lookup = FS.lookupPath(path, { follow: !dontFollow });
    3092. 

  3092.           node = lookup.node;
    3093. 

  3093.         } else {
    3094. 

  3094.           node = path;
    3095. 

  3095.         }
    3096. 

  3096.         if (!node.node_ops.setattr) {
    3097. 

  3097.           throw new FS.ErrnoError(ERRNO_CODES.EPERM);
    3098. 

  3098.         }
    3099. 

  3099.         node.node_ops.setattr(node, {
    3100. 

  3100.           mode: (mode & 4095) | (node.mode & ~4095),
    3101. 

  3101.           timestamp: Date.now()
    3102. 

  3102.         });
    3103. 

  3103.       },lchmod:function (path, mode) {
    3104. 

  3104.         FS.chmod(path, mode, true);
    3105. 

  3105.       },fchmod:function (fd, mode) {
    3106. 

  3106.         var stream = FS.getStream(fd);
    3107. 

  3107.         if (!stream) {
    3108. 

  3108.           throw new FS.ErrnoError(ERRNO_CODES.EBADF);
    3109. 

  3109.         }
    3110. 

  3110.         FS.chmod(stream.node, mode);
    3111. 

  3111.       },chown:function (path, uid, gid, dontFollow) {
    3112. 

  3112.         var node;
    3113. 

  3113.         if (typeof path === 'string') {
    3114. 

  3114.           var lookup = FS.lookupPath(path, { follow: !dontFollow });
    3115. 

  3115.           node = lookup.node;
    3116. 

  3116.         } else {
    3117. 

  3117.           node = path;
    3118. 

  3118.         }
    3119. 

  3119.         if (!node.node_ops.setattr) {
    3120. 

  3120.           throw new FS.ErrnoError(ERRNO_CODES.EPERM);
    3121. 

  3121.         }
    3122. 

  3122.         node.node_ops.setattr(node, {
    3123. 

  3123.           timestamp: Date.now()
    3124. 

  3124.           // we ignore the uid / gid for now
    3125. 

  3125.         });
    3126. 

  3126.       },lchown:function (path, uid, gid) {
    3127. 

  3127.         FS.chown(path, uid, gid, true);
    3128. 

  3128.       },fchown:function (fd, uid, gid) {
    3129. 

  3129.         var stream = FS.getStream(fd);
    3130. 

  3130.         if (!stream) {
    3131. 

  3131.           throw new FS.ErrnoError(ERRNO_CODES.EBADF);
    3132. 

  3132.         }
    3133. 

  3133.         FS.chown(stream.node, uid, gid);
    3134. 

  3134.       },truncate:function (path, len) {
    3135. 

  3135.         if (len < 0) {
    3136. 

  3136.           throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
    3137. 

  3137.         }
    3138. 

  3138.         var node;
    3139. 

  3139.         if (typeof path === 'string') {
    3140. 

  3140.           var lookup = FS.lookupPath(path, { follow: true });
    3141. 

  3141.           node = lookup.node;
    3142. 

  3142.         } else {
    3143. 

  3143.           node = path;
    3144. 

  3144.         }
    3145. 

  3145.         if (!node.node_ops.setattr) {
    3146. 

  3146.           throw new FS.ErrnoError(ERRNO_CODES.EPERM);
    3147. 

  3147.         }
    3148. 

  3148.         if (FS.isDir(node.mode)) {
    3149. 

  3149.           throw new FS.ErrnoError(ERRNO_CODES.EISDIR);
    3150. 

  3150.         }
    3151. 

  3151.         if (!FS.isFile(node.mode)) {
    3152. 

  3152.           throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
    3153. 

  3153.         }
    3154. 

  3154.         var err = FS.nodePermissions(node, 'w');
    3155. 

  3155.         if (err) {
    3156. 

  3156.           throw new FS.ErrnoError(err);
    3157. 

  3157.         }
    3158. 

  3158.         node.node_ops.setattr(node, {
    3159. 

  3159.           size: len,
    3160. 

  3160.           timestamp: Date.now()
    3161. 

  3161.         });
    3162. 

  3162.       },ftruncate:function (fd, len) {
    3163. 

  3163.         var stream = FS.getStream(fd);
    3164. 

  3164.         if (!stream) {
    3165. 

  3165.           throw new FS.ErrnoError(ERRNO_CODES.EBADF);
    3166. 

  3166.         }
    3167. 

  3167.         if ((stream.flags & 2097155) === 0) {
    3168. 

  3168.           throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
    3169. 

  3169.         }
    3170. 

  3170.         FS.truncate(stream.node, len);
    3171. 

  3171.       },utime:function (path, atime, mtime) {
    3172. 

  3172.         var lookup = FS.lookupPath(path, { follow: true });
    3173. 

  3173.         var node = lookup.node;
    3174. 

  3174.         node.node_ops.setattr(node, {
    3175. 

  3175.           timestamp: Math.max(atime, mtime)
    3176. 

  3176.         });
    3177. 

  3177.       },open:function (path, flags, mode, fd_start, fd_end) {
    3178. 

  3178.         flags = typeof flags === 'string' ? FS.modeStringToFlags(flags) : flags;
    3179. 

  3179.         mode = typeof mode === 'undefined' ? 438 /* 0666 */ : mode;
    3180. 

  3180.         if ((flags & 64)) {
    3181. 

  3181.           mode = (mode & 4095) | 32768;
    3182. 

  3182.         } else {
    3183. 

  3183.           mode = 0;
    3184. 

  3184.         }
    3185. 

  3185.         var node;
    3186. 

  3186.         if (typeof path === 'object') {
    3187. 

  3187.           node = path;
    3188. 

  3188.         } else {
    3189. 

  3189.           path = PATH.normalize(path);
    3190. 

  3190.           try {
    3191. 

  3191.             var lookup = FS.lookupPath(path, {
    3192. 

  3192.               follow: !(flags & 131072)
    3193. 

  3193.             });
    3194. 

  3194.             node = lookup.node;
    3195. 

  3195.           } catch (e) {
    3196. 

  3196.             // ignore
    3197. 

  3197.           }
    3198. 

  3198.         }
    3199. 

  3199.         // perhaps we need to create the node
    3200. 

  3200.         if ((flags & 64)) {
    3201. 

  3201.           if (node) {
    3202. 

  3202.             // if O_CREAT and O_EXCL are set, error out if the node already exists
    3203. 

  3203.             if ((flags & 128)) {
    3204. 

  3204.               throw new FS.ErrnoError(ERRNO_CODES.EEXIST);
    3205. 

  3205.             }
    3206. 

  3206.           } else {
    3207. 

  3207.             // node doesn't exist, try to create it
    3208. 

  3208.             node = FS.mknod(path, mode, 0);
    3209. 

  3209.           }
    3210. 

  3210.         }
    3211. 

  3211.         if (!node) {
    3212. 

  3212.           throw new FS.ErrnoError(ERRNO_CODES.ENOENT);
    3213. 

  3213.         }
    3214. 

  3214.         // can't truncate a device
    3215. 

  3215.         if (FS.isChrdev(node.mode)) {
    3216. 

  3216.           flags &= ~512;
    3217. 

  3217.         }
    3218. 

  3218.         // check permissions
    3219. 

  3219.         var err = FS.mayOpen(node, flags);
    3220. 

  3220.         if (err) {
    3221. 

  3221.           throw new FS.ErrnoError(err);
    3222. 

  3222.         }
    3223. 

  3223.         // do truncation if necessary
    3224. 

  3224.         if ((flags & 512)) {
    3225. 

  3225.           FS.truncate(node, 0);
    3226. 

  3226.         }
    3227. 

  3227.         // we've already handled these, don't pass down to the underlying vfs
    3228. 

  3228.         flags &= ~(128 | 512);
    3229. 

  3229. 

  3230.         // register the stream with the filesystem
    3231. 

  3231.         var stream = FS.createStream({
    3232. 

  3232.           node: node,
    3233. 

  3233.           path: FS.getPath(node),  // we want the absolute path to the node
    3234. 

  3234.           flags: flags,
    3235. 

  3235.           seekable: true,
    3236. 

  3236.           position: 0,
    3237. 

  3237.           stream_ops: node.stream_ops,
    3238. 

  3238.           // used by the file family libc calls (fopen, fwrite, ferror, etc.)
    3239. 

  3239.           ungotten: [],
    3240. 

  3240.           error: false
    3241. 

  3241.         }, fd_start, fd_end);
    3242. 

  3242.         // call the new stream's open function
    3243. 

  3243.         if (stream.stream_ops.open) {
    3244. 

  3244.           stream.stream_ops.open(stream);
    3245. 

  3245.         }
    3246. 

  3246.         if (Module['logReadFiles'] && !(flags & 1)) {
    3247. 

  3247.           if (!FS.readFiles) FS.readFiles = {};
    3248. 

  3248.           if (!(path in FS.readFiles)) {
    3249. 

  3249.             FS.readFiles[path] = 1;
    3250. 

  3250.             Module['printErr']('read file: ' + path);
    3251. 

  3251.           }
    3252. 

  3252.         }
    3253. 

  3253.         return stream;
    3254. 

  3254.       },close:function (stream) {
    3255. 

  3255.         try {
    3256. 

  3256.           if (stream.stream_ops.close) {
    3257. 

  3257.             stream.stream_ops.close(stream);
    3258. 

  3258.           }
    3259. 

  3259.         } catch (e) {
    3260. 

  3260.           throw e;
    3261. 

  3261.         } finally {
    3262. 

  3262.           FS.closeStream(stream.fd);
    3263. 

  3263.         }
    3264. 

  3264.       },llseek:function (stream, offset, whence) {
    3265. 

  3265.         if (!stream.seekable || !stream.stream_ops.llseek) {
    3266. 

  3266.           throw new FS.ErrnoError(ERRNO_CODES.ESPIPE);
    3267. 

  3267.         }
    3268. 

  3268.         return stream.stream_ops.llseek(stream, offset, whence);
    3269. 

  3269.       },read:function (stream, buffer, offset, length, position) {
    3270. 

  3270.         if (length < 0 || position < 0) {
    3271. 

  3271.           throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
    3272. 

  3272.         }
    3273. 

  3273.         if ((stream.flags & 2097155) === 1) {
    3274. 

  3274.           throw new FS.ErrnoError(ERRNO_CODES.EBADF);
    3275. 

  3275.         }
    3276. 

  3276.         if (FS.isDir(stream.node.mode)) {
    3277. 

  3277.           throw new FS.ErrnoError(ERRNO_CODES.EISDIR);
    3278. 

  3278.         }
    3279. 

  3279.         if (!stream.stream_ops.read) {
    3280. 

  3280.           throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
    3281. 

  3281.         }
    3282. 

  3282.         var seeking = true;
    3283. 

  3283.         if (typeof position === 'undefined') {
    3284. 

  3284.           position = stream.position;
    3285. 

  3285.           seeking = false;
    3286. 

  3286.         } else if (!stream.seekable) {
    3287. 

  3287.           throw new FS.ErrnoError(ERRNO_CODES.ESPIPE);
    3288. 

  3288.         }
    3289. 

  3289.         var bytesRead = stream.stream_ops.read(stream, buffer, offset, length, position);
    3290. 

  3290.         if (!seeking) stream.position += bytesRead;
    3291. 

  3291.         return bytesRead;
    3292. 

  3292.       },write:function (stream, buffer, offset, length, position, canOwn) {
    3293. 

  3293.         if (length < 0 || position < 0) {
    3294. 

  3294.           throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
    3295. 

  3295.         }
    3296. 

  3296.         if ((stream.flags & 2097155) === 0) {
    3297. 

  3297.           throw new FS.ErrnoError(ERRNO_CODES.EBADF);
    3298. 

  3298.         }
    3299. 

  3299.         if (FS.isDir(stream.node.mode)) {
    3300. 

  3300.           throw new FS.ErrnoError(ERRNO_CODES.EISDIR);
    3301. 

  3301.         }
    3302. 

  3302.         if (!stream.stream_ops.write) {
    3303. 

  3303.           throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
    3304. 

  3304.         }
    3305. 

  3305.         var seeking = true;
    3306. 

  3306.         if (typeof position === 'undefined') {
    3307. 

  3307.           position = stream.position;
    3308. 

  3308.           seeking = false;
    3309. 

  3309.         } else if (!stream.seekable) {
    3310. 

  3310.           throw new FS.ErrnoError(ERRNO_CODES.ESPIPE);
    3311. 

  3311.         }
    3312. 

  3312.         if (stream.flags & 1024) {
    3313. 

  3313.           // seek to the end before writing in append mode
    3314. 

  3314.           FS.llseek(stream, 0, 2);
    3315. 

  3315.         }
    3316. 

  3316.         var bytesWritten = stream.stream_ops.write(stream, buffer, offset, length, position, canOwn);
    3317. 

  3317.         if (!seeking) stream.position += bytesWritten;
    3318. 

  3318.         return bytesWritten;
    3319. 

  3319.       },allocate:function (stream, offset, length) {
    3320. 

  3320.         if (offset < 0 || length <= 0) {
    3321. 

  3321.           throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
    3322. 

  3322.         }
    3323. 

  3323.         if ((stream.flags & 2097155) === 0) {
    3324. 

  3324.           throw new FS.ErrnoError(ERRNO_CODES.EBADF);
    3325. 

  3325.         }
    3326. 

  3326.         if (!FS.isFile(stream.node.mode) && !FS.isDir(node.mode)) {
    3327. 

  3327.           throw new FS.ErrnoError(ERRNO_CODES.ENODEV);
    3328. 

  3328.         }
    3329. 

  3329.         if (!stream.stream_ops.allocate) {
    3330. 

  3330.           throw new FS.ErrnoError(ERRNO_CODES.EOPNOTSUPP);
    3331. 

  3331.         }
    3332. 

  3332.         stream.stream_ops.allocate(stream, offset, length);
    3333. 

  3333.       },mmap:function (stream, buffer, offset, length, position, prot, flags) {
    3334. 

  3334.         // TODO if PROT is PROT_WRITE, make sure we have write access
    3335. 

  3335.         if ((stream.flags & 2097155) === 1) {
    3336. 

  3336.           throw new FS.ErrnoError(ERRNO_CODES.EACCES);
    3337. 

  3337.         }
    3338. 

  3338.         if (!stream.stream_ops.mmap) {
    3339. 

  3339.           throw new FS.ErrnoError(ERRNO_CODES.ENODEV);
    3340. 

  3340.         }
    3341. 

  3341.         return stream.stream_ops.mmap(stream, buffer, offset, length, position, prot, flags);
    3342. 

  3342.       },ioctl:function (stream, cmd, arg) {
    3343. 

  3343.         if (!stream.stream_ops.ioctl) {
    3344. 

  3344.           throw new FS.ErrnoError(ERRNO_CODES.ENOTTY);
    3345. 

  3345.         }
    3346. 

  3346.         return stream.stream_ops.ioctl(stream, cmd, arg);
    3347. 

  3347.       },readFile:function (path, opts) {
    3348. 

  3348.         opts = opts || {};
    3349. 

  3349.         opts.flags = opts.flags || 'r';
    3350. 

  3350.         opts.encoding = opts.encoding || 'binary';
    3351. 

  3351.         if (opts.encoding !== 'utf8' && opts.encoding !== 'binary') {
    3352. 

  3352.           throw new Error('Invalid encoding type "' + opts.encoding + '"');
    3353. 

  3353.         }
    3354. 

  3354.         var ret;
    3355. 

  3355.         var stream = FS.open(path, opts.flags);
    3356. 

  3356.         var stat = FS.stat(path);
    3357. 

  3357.         var length = stat.size;
    3358. 

  3358.         var buf = new Uint8Array(length);
    3359. 

  3359.         FS.read(stream, buf, 0, length, 0);
    3360. 

  3360.         if (opts.encoding === 'utf8') {
    3361. 

  3361.           ret = '';
    3362. 

  3362.           var utf8 = new Runtime.UTF8Processor();
    3363. 

  3363.           for (var i = 0; i < length; i++) {
    3364. 

  3364.             ret += utf8.processCChar(buf[i]);
    3365. 

  3365.           }
    3366. 

  3366.         } else if (opts.encoding === 'binary') {
    3367. 

  3367.           ret = buf;
    3368. 

  3368.         }
    3369. 

  3369.         FS.close(stream);
    3370. 

  3370.         return ret;
    3371. 

  3371.       },writeFile:function (path, data, opts) {
    3372. 

  3372.         opts = opts || {};
    3373. 

  3373.         opts.flags = opts.flags || 'w';
    3374. 

  3374.         opts.encoding = opts.encoding || 'utf8';
    3375. 

  3375.         if (opts.encoding !== 'utf8' && opts.encoding !== 'binary') {
    3376. 

  3376.           throw new Error('Invalid encoding type "' + opts.encoding + '"');
    3377. 

  3377.         }
    3378. 

  3378.         var stream = FS.open(path, opts.flags, opts.mode);
    3379. 

  3379.         if (opts.encoding === 'utf8') {
    3380. 

  3380.           var utf8 = new Runtime.UTF8Processor();
    3381. 

  3381.           var buf = new Uint8Array(utf8.processJSString(data));
    3382. 

  3382.           FS.write(stream, buf, 0, buf.length, 0, opts.canOwn);
    3383. 

  3383.         } else if (opts.encoding === 'binary') {
    3384. 

  3384.           FS.write(stream, data, 0, data.length, 0, opts.canOwn);
    3385. 

  3385.         }
    3386. 

  3386.         FS.close(stream);
    3387. 

  3387.       },cwd:function () {
    3388. 

  3388.         return FS.currentPath;
    3389. 

  3389.       },chdir:function (path) {
    3390. 

  3390.         var lookup = FS.lookupPath(path, { follow: true });
    3391. 

  3391.         if (!FS.isDir(lookup.node.mode)) {
    3392. 

  3392.           throw new FS.ErrnoError(ERRNO_CODES.ENOTDIR);
    3393. 

  3393.         }
    3394. 

  3394.         var err = FS.nodePermissions(lookup.node, 'x');
    3395. 

  3395.         if (err) {
    3396. 

  3396.           throw new FS.ErrnoError(err);
    3397. 

  3397.         }
    3398. 

  3398.         FS.currentPath = lookup.path;
    3399. 

  3399.       },createDefaultDirectories:function () {
    3400. 

  3400.         FS.mkdir('/tmp');
    3401. 

  3401.       },createDefaultDevices:function () {
    3402. 

  3402.         // create /dev
    3403. 

  3403.         FS.mkdir('/dev');
    3404. 

  3404.         // setup /dev/null
    3405. 

  3405.         FS.registerDevice(FS.makedev(1, 3), {
    3406. 

  3406.           read: function() { return 0; },
    3407. 

  3407.           write: function() { return 0; }
    3408. 

  3408.         });
    3409. 

  3409.         FS.mkdev('/dev/null', FS.makedev(1, 3));
    3410. 

  3410.         // setup /dev/tty and /dev/tty1
    3411. 

  3411.         // stderr needs to print output using Module['printErr']
    3412. 

  3412.         // so we register a second tty just for it.
    3413. 

  3413.         TTY.register(FS.makedev(5, 0), TTY.default_tty_ops);
    3414. 

  3414.         TTY.register(FS.makedev(6, 0), TTY.default_tty1_ops);
    3415. 

  3415.         FS.mkdev('/dev/tty', FS.makedev(5, 0));
    3416. 

  3416.         FS.mkdev('/dev/tty1', FS.makedev(6, 0));
    3417. 

  3417.         // we're not going to emulate the actual shm device,
    3418. 

  3418.         // just create the tmp dirs that reside in it commonly
    3419. 

  3419.         FS.mkdir('/dev/shm');
    3420. 

  3420.         FS.mkdir('/dev/shm/tmp');
    3421. 

  3421.       },createStandardStreams:function () {
    3422. 

  3422.         // TODO deprecate the old functionality of a single
    3423. 

  3423.         // input / output callback and that utilizes FS.createDevice
    3424. 

  3424.         // and instead require a unique set of stream ops
    3425. 

  3425. 

  3426.         // by default, we symlink the standard streams to the
    3427. 

  3427.         // default tty devices. however, if the standard streams
    3428. 

  3428.         // have been overwritten we create a unique device for
    3429. 

  3429.         // them instead.
    3430. 

  3430.         if (Module['stdin']) {
    3431. 

  3431.           FS.createDevice('/dev', 'stdin', Module['stdin']);
    3432. 

  3432.         } else {
    3433. 

  3433.           FS.symlink('/dev/tty', '/dev/stdin');
    3434. 

  3434.         }
    3435. 

  3435.         if (Module['stdout']) {
    3436. 

  3436.           FS.createDevice('/dev', 'stdout', null, Module['stdout']);
    3437. 

  3437.         } else {
    3438. 

  3438.           FS.symlink('/dev/tty', '/dev/stdout');
    3439. 

  3439.         }
    3440. 

  3440.         if (Module['stderr']) {
    3441. 

  3441.           FS.createDevice('/dev', 'stderr', null, Module['stderr']);
    3442. 

  3442.         } else {
    3443. 

  3443.           FS.symlink('/dev/tty1', '/dev/stderr');
    3444. 

  3444.         }
    3445. 

  3445. 

  3446.         // open default streams for the stdin, stdout and stderr devices
    3447. 

  3447.         var stdin = FS.open('/dev/stdin', 'r');
    3448. 

  3448.         HEAP32[((_stdin)>>2)]=FS.getPtrForStream(stdin);
    3449. 

  3449.         assert(stdin.fd === 0, 'invalid handle for stdin (' + stdin.fd + ')');
    3450. 

  3450. 

  3451.         var stdout = FS.open('/dev/stdout', 'w');
    3452. 

  3452.         HEAP32[((_stdout)>>2)]=FS.getPtrForStream(stdout);
    3453. 

  3453.         assert(stdout.fd === 1, 'invalid handle for stdout (' + stdout.fd + ')');
    3454. 

  3454. 

  3455.         var stderr = FS.open('/dev/stderr', 'w');
    3456. 

  3456.         HEAP32[((_stderr)>>2)]=FS.getPtrForStream(stderr);
    3457. 

  3457.         assert(stderr.fd === 2, 'invalid handle for stderr (' + stderr.fd + ')');
    3458. 

  3458.       },ensureErrnoError:function () {
    3459. 

  3459.         if (FS.ErrnoError) return;
    3460. 

  3460.         FS.ErrnoError = function ErrnoError(errno) {
    3461. 

  3461.           this.errno = errno;
    3462. 

  3462.           for (var key in ERRNO_CODES) {
    3463. 

  3463.             if (ERRNO_CODES[key] === errno) {
    3464. 

  3464.               this.code = key;
    3465. 

  3465.               break;
    3466. 

  3466.             }
    3467. 

  3467.           }
    3468. 

  3468.           this.message = ERRNO_MESSAGES[errno];
    3469. 

  3469.         };
    3470. 

  3470.         FS.ErrnoError.prototype = new Error();
    3471. 

  3471.         FS.ErrnoError.prototype.constructor = FS.ErrnoError;
    3472. 

  3472.         // Some errors may happen quite a bit, to avoid overhead we reuse them (and suffer a lack of stack info)
    3473. 

  3473.         [ERRNO_CODES.ENOENT].forEach(function(code) {
    3474. 

  3474.           FS.genericErrors[code] = new FS.ErrnoError(code);
    3475. 

  3475.           FS.genericErrors[code].stack = '<generic error, no stack>';
    3476. 

  3476.         });
    3477. 

  3477.       },staticInit:function () {
    3478. 

  3478.         FS.ensureErrnoError();
    3479. 

  3479. 

  3480.         FS.nameTable = new Array(4096);
    3481. 

  3481. 

  3482.         FS.mount(MEMFS, {}, '/');
    3483. 

  3483. 

  3484.         FS.createDefaultDirectories();
    3485. 

  3485.         FS.createDefaultDevices();
    3486. 

  3486.       },init:function (input, output, error) {
    3487. 

  3487.         assert(!FS.init.initialized, 'FS.init was previously called. If you want to initialize later with custom parameters, remove any earlier calls (note that one is automatically added to the generated code)');
    3488. 

  3488.         FS.init.initialized = true;
    3489. 

  3489. 

  3490.         FS.ensureErrnoError();
    3491. 

  3491. 

  3492.         // Allow Module.stdin etc. to provide defaults, if none explicitly passed to us here
    3493. 

  3493.         Module['stdin'] = input || Module['stdin'];
    3494. 

  3494.         Module['stdout'] = output || Module['stdout'];
    3495. 

  3495.         Module['stderr'] = error || Module['stderr'];
    3496. 

  3496. 

  3497.         FS.createStandardStreams();
    3498. 

  3498.       },quit:function () {
    3499. 

  3499.         FS.init.initialized = false;
    3500. 

  3500.         for (var i = 0; i < FS.streams.length; i++) {
    3501. 

  3501.           var stream = FS.streams[i];
    3502. 

  3502.           if (!stream) {
    3503. 

  3503.             continue;
    3504. 

  3504.           }
    3505. 

  3505.           FS.close(stream);
    3506. 

  3506.         }
    3507. 

  3507.       },getMode:function (canRead, canWrite) {
    3508. 

  3508.         var mode = 0;
    3509. 

  3509.         if (canRead) mode |= 292 | 73;
    3510. 

  3510.         if (canWrite) mode |= 146;
    3511. 

  3511.         return mode;
    3512. 

  3512.       },joinPath:function (parts, forceRelative) {
    3513. 

  3513.         var path = PATH.join.apply(null, parts);
    3514. 

  3514.         if (forceRelative && path[0] == '/') path = path.substr(1);
    3515. 

  3515.         return path;
    3516. 

  3516.       },absolutePath:function (relative, base) {
    3517. 

  3517.         return PATH.resolve(base, relative);
    3518. 

  3518.       },standardizePath:function (path) {
    3519. 

  3519.         return PATH.normalize(path);
    3520. 

  3520.       },findObject:function (path, dontResolveLastLink) {
    3521. 

  3521.         var ret = FS.analyzePath(path, dontResolveLastLink);
    3522. 

  3522.         if (ret.exists) {
    3523. 

  3523.           return ret.object;
    3524. 

  3524.         } else {
    3525. 

  3525.           ___setErrNo(ret.error);
    3526. 

  3526.           return null;
    3527. 

  3527.         }
    3528. 

  3528.       },analyzePath:function (path, dontResolveLastLink) {
    3529. 

  3529.         // operate from within the context of the symlink's target
    3530. 

  3530.         try {
    3531. 

  3531.           var lookup = FS.lookupPath(path, { follow: !dontResolveLastLink });
    3532. 

  3532.           path = lookup.path;
    3533. 

  3533.         } catch (e) {
    3534. 

  3534.         }
    3535. 

  3535.         var ret = {
    3536. 

  3536.           isRoot: false, exists: false, error: 0, name: null, path: null, object: null,
    3537. 

  3537.           parentExists: false, parentPath: null, parentObject: null
    3538. 

  3538.         };
    3539. 

  3539.         try {
    3540. 

  3540.           var lookup = FS.lookupPath(path, { parent: true });
    3541. 

  3541.           ret.parentExists = true;
    3542. 

  3542.           ret.parentPath = lookup.path;
    3543. 

  3543.           ret.parentObject = lookup.node;
    3544. 

  3544.           ret.name = PATH.basename(path);
    3545. 

  3545.           lookup = FS.lookupPath(path, { follow: !dontResolveLastLink });
    3546. 

  3546.           ret.exists = true;
    3547. 

  3547.           ret.path = lookup.path;
    3548. 

  3548.           ret.object = lookup.node;
    3549. 

  3549.           ret.name = lookup.node.name;
    3550. 

  3550.           ret.isRoot = lookup.path === '/';
    3551. 

  3551.         } catch (e) {
    3552. 

  3552.           ret.error = e.errno;
    3553. 

  3553.         };
    3554. 

  3554.         return ret;
    3555. 

  3555.       },createFolder:function (parent, name, canRead, canWrite) {
    3556. 

  3556.         var path = PATH.join2(typeof parent === 'string' ? parent : FS.getPath(parent), name);
    3557. 

  3557.         var mode = FS.getMode(canRead, canWrite);
    3558. 

  3558.         return FS.mkdir(path, mode);
    3559. 

  3559.       },createPath:function (parent, path, canRead, canWrite) {
    3560. 

  3560.         parent = typeof parent === 'string' ? parent : FS.getPath(parent);
    3561. 

  3561.         var parts = path.split('/').reverse();
    3562. 

  3562.         while (parts.length) {
    3563. 

  3563.           var part = parts.pop();
    3564. 

  3564.           if (!part) continue;
    3565. 

  3565.           var current = PATH.join2(parent, part);
    3566. 

  3566.           try {
    3567. 

  3567.             FS.mkdir(current);
    3568. 

  3568.           } catch (e) {
    3569. 

  3569.             // ignore EEXIST
    3570. 

  3570.           }
    3571. 

  3571.           parent = current;
    3572. 

  3572.         }
    3573. 

  3573.         return current;
    3574. 

  3574.       },createFile:function (parent, name, properties, canRead, canWrite) {
    3575. 

  3575.         var path = PATH.join2(typeof parent === 'string' ? parent : FS.getPath(parent), name);
    3576. 

  3576.         var mode = FS.getMode(canRead, canWrite);
    3577. 

  3577.         return FS.create(path, mode);
    3578. 

  3578.       },createDataFile:function (parent, name, data, canRead, canWrite, canOwn) {
    3579. 

  3579.         var path = name ? PATH.join2(typeof parent === 'string' ? parent : FS.getPath(parent), name) : parent;
    3580. 

  3580.         var mode = FS.getMode(canRead, canWrite);
    3581. 

  3581.         var node = FS.create(path, mode);
    3582. 

  3582.         if (data) {
    3583. 

  3583.           if (typeof data === 'string') {
    3584. 

  3584.             var arr = new Array(data.length);
    3585. 

  3585.             for (var i = 0, len = data.length; i < len; ++i) arr[i] = data.charCodeAt(i);
    3586. 

  3586.             data = arr;
    3587. 

  3587.           }
    3588. 

  3588.           // make sure we can write to the file
    3589. 

  3589.           FS.chmod(node, mode | 146);
    3590. 

  3590.           var stream = FS.open(node, 'w');
    3591. 

  3591.           FS.write(stream, data, 0, data.length, 0, canOwn);
    3592. 

  3592.           FS.close(stream);
    3593. 

  3593.           FS.chmod(node, mode);
    3594. 

  3594.         }
    3595. 

  3595.         return node;
    3596. 

  3596.       },createDevice:function (parent, name, input, output) {
    3597. 

  3597.         var path = PATH.join2(typeof parent === 'string' ? parent : FS.getPath(parent), name);
    3598. 

  3598.         var mode = FS.getMode(!!input, !!output);
    3599. 

  3599.         if (!FS.createDevice.major) FS.createDevice.major = 64;
    3600. 

  3600.         var dev = FS.makedev(FS.createDevice.major++, 0);
    3601. 

  3601.         // Create a fake device that a set of stream ops to emulate
    3602. 

  3602.         // the old behavior.
    3603. 

  3603.         FS.registerDevice(dev, {
    3604. 

  3604.           open: function(stream) {
    3605. 

  3605.             stream.seekable = false;
    3606. 

  3606.           },
    3607. 

  3607.           close: function(stream) {
    3608. 

  3608.             // flush any pending line data
    3609. 

  3609.             if (output && output.buffer && output.buffer.length) {
    3610. 

  3610.               output(10);
    3611. 

  3611.             }
    3612. 

  3612.           },
    3613. 

  3613.           read: function(stream, buffer, offset, length, pos /* ignored */) {
    3614. 

  3614.             var bytesRead = 0;
    3615. 

  3615.             for (var i = 0; i < length; i++) {
    3616. 

  3616.               var result;
    3617. 

  3617.               try {
    3618. 

  3618.                 result = input();
    3619. 

  3619.               } catch (e) {
    3620. 

  3620.                 throw new FS.ErrnoError(ERRNO_CODES.EIO);
    3621. 

  3621.               }
    3622. 

  3622.               if (result === undefined && bytesRead === 0) {
    3623. 

  3623.                 throw new FS.ErrnoError(ERRNO_CODES.EAGAIN);
    3624. 

  3624.               }
    3625. 

  3625.               if (result === null || result === undefined) break;
    3626. 

  3626.               bytesRead++;
    3627. 

  3627.               buffer[offset+i] = result;
    3628. 

  3628.             }
    3629. 

  3629.             if (bytesRead) {
    3630. 

  3630.               stream.node.timestamp = Date.now();
    3631. 

  3631.             }
    3632. 

  3632.             return bytesRead;
    3633. 

  3633.           },
    3634. 

  3634.           write: function(stream, buffer, offset, length, pos) {
    3635. 

  3635.             for (var i = 0; i < length; i++) {
    3636. 

  3636.               try {
    3637. 

  3637.                 output(buffer[offset+i]);
    3638. 

  3638.               } catch (e) {
    3639. 

  3639.                 throw new FS.ErrnoError(ERRNO_CODES.EIO);
    3640. 

  3640.               }
    3641. 

  3641.             }
    3642. 

  3642.             if (length) {
    3643. 

  3643.               stream.node.timestamp = Date.now();
    3644. 

  3644.             }
    3645. 

  3645.             return i;
    3646. 

  3646.           }
    3647. 

  3647.         });
    3648. 

  3648.         return FS.mkdev(path, mode, dev);
    3649. 

  3649.       },createLink:function (parent, name, target, canRead, canWrite) {
    3650. 

  3650.         var path = PATH.join2(typeof parent === 'string' ? parent : FS.getPath(parent), name);
    3651. 

  3651.         return FS.symlink(target, path);
    3652. 

  3652.       },forceLoadFile:function (obj) {
    3653. 

  3653.         if (obj.isDevice || obj.isFolder || obj.link || obj.contents) return true;
    3654. 

  3654.         var success = true;
    3655. 

  3655.         if (typeof XMLHttpRequest !== 'undefined') {
    3656. 

  3656.           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.");
    3657. 

  3657.         } else if (Module['read']) {
    3658. 

  3658.           // Command-line.
    3659. 

  3659.           try {
    3660. 

  3660.             // WARNING: Can't read binary files in V8's d8 or tracemonkey's js, as
    3661. 

  3661.             //          read() will try to parse UTF8.
    3662. 

  3662.             obj.contents = intArrayFromString(Module['read'](obj.url), true);
    3663. 

  3663.           } catch (e) {
    3664. 

  3664.             success = false;
    3665. 

  3665.           }
    3666. 

  3666.         } else {
    3667. 

  3667.           throw new Error('Cannot load without read() or XMLHttpRequest.');
    3668. 

  3668.         }
    3669. 

  3669.         if (!success) ___setErrNo(ERRNO_CODES.EIO);
    3670. 

  3670.         return success;
    3671. 

  3671.       },createLazyFile:function (parent, name, url, canRead, canWrite) {
    3672. 

  3672.         // Lazy chunked Uint8Array (implements get and length from Uint8Array). Actual getting is abstracted away for eventual reuse.
    3673. 

  3673.         function LazyUint8Array() {
    3674. 

  3674.           this.lengthKnown = false;
    3675. 

  3675.           this.chunks = []; // Loaded chunks. Index is the chunk number
    3676. 

  3676.         }
    3677. 

  3677.         LazyUint8Array.prototype.get = function LazyUint8Array_get(idx) {
    3678. 

  3678.           if (idx > this.length-1 || idx < 0) {
    3679. 

  3679.             return undefined;
    3680. 

  3680.           }
    3681. 

  3681.           var chunkOffset = idx % this.chunkSize;
    3682. 

  3682.           var chunkNum = Math.floor(idx / this.chunkSize);
    3683. 

  3683.           return this.getter(chunkNum)[chunkOffset];
    3684. 

  3684.         }
    3685. 

  3685.         LazyUint8Array.prototype.setDataGetter = function LazyUint8Array_setDataGetter(getter) {
    3686. 

  3686.           this.getter = getter;
    3687. 

  3687.         }
    3688. 

  3688.         LazyUint8Array.prototype.cacheLength = function LazyUint8Array_cacheLength() {
    3689. 

  3689.             // Find length
    3690. 

  3690.             var xhr = new XMLHttpRequest();
    3691. 

  3691.             xhr.open('HEAD', url, false);
    3692. 

  3692.             xhr.send(null);
    3693. 

  3693.             if (!(xhr.status >= 200 && xhr.status < 300 || xhr.status === 304)) throw new Error("Couldn't load " + url + ". Status: " + xhr.status);
    3694. 

  3694.             var datalength = Number(xhr.getResponseHeader("Content-length"));
    3695. 

  3695.             var header;
    3696. 

  3696.             var hasByteServing = (header = xhr.getResponseHeader("Accept-Ranges")) && header === "bytes";
    3697. 

  3697.             var chunkSize = 1024*1024; // Chunk size in bytes
    3698. 

  3698. 

  3699.             if (!hasByteServing) chunkSize = datalength;
    3700. 

  3700. 

  3701.             // Function to get a range from the remote URL.
    3702. 

  3702.             var doXHR = (function(from, to) {
    3703. 

  3703.               if (from > to) throw new Error("invalid range (" + from + ", " + to + ") or no bytes requested!");
    3704. 

  3704.               if (to > datalength-1) throw new Error("only " + datalength + " bytes available! programmer error!");
    3705. 

  3705. 

  3706.               // TODO: Use mozResponseArrayBuffer, responseStream, etc. if available.
    3707. 

  3707.               var xhr = new XMLHttpRequest();
    3708. 

  3708.               xhr.open('GET', url, false);
    3709. 

  3709.               if (datalength !== chunkSize) xhr.setRequestHeader("Range", "bytes=" + from + "-" + to);
    3710. 

  3710. 

  3711.               // Some hints to the browser that we want binary data.
    3712. 

  3712.               if (typeof Uint8Array != 'undefined') xhr.responseType = 'arraybuffer';
    3713. 

  3713.               if (xhr.overrideMimeType) {
    3714. 

  3714.                 xhr.overrideMimeType('text/plain; charset=x-user-defined');
    3715. 

  3715.               }
    3716. 

  3716. 

  3717.               xhr.send(null);
    3718. 

  3718.               if (!(xhr.status >= 200 && xhr.status < 300 || xhr.status === 304)) throw new Error("Couldn't load " + url + ". Status: " + xhr.status);
    3719. 

  3719.               if (xhr.response !== undefined) {
    3720. 

  3720.                 return new Uint8Array(xhr.response || []);
    3721. 

  3721.               } else {
    3722. 

  3722.                 return intArrayFromString(xhr.responseText || '', true);
    3723. 

  3723.               }
    3724. 

  3724.             });
    3725. 

  3725.             var lazyArray = this;
    3726. 

  3726.             lazyArray.setDataGetter(function(chunkNum) {
    3727. 

  3727.               var start = chunkNum * chunkSize;
    3728. 

  3728.               var end = (chunkNum+1) * chunkSize - 1; // including this byte
    3729. 

  3729.               end = Math.min(end, datalength-1); // if datalength-1 is selected, this is the last block
    3730. 

  3730.               if (typeof(lazyArray.chunks[chunkNum]) === "undefined") {
    3731. 

  3731.                 lazyArray.chunks[chunkNum] = doXHR(start, end);
    3732. 

  3732.               }
    3733. 

  3733.               if (typeof(lazyArray.chunks[chunkNum]) === "undefined") throw new Error("doXHR failed!");
    3734. 

  3734.               return lazyArray.chunks[chunkNum];
    3735. 

  3735.             });
    3736. 

  3736. 

  3737.             this._length = datalength;
    3738. 

  3738.             this._chunkSize = chunkSize;
    3739. 

  3739.             this.lengthKnown = true;
    3740. 

  3740.         }
    3741. 

  3741.         if (typeof XMLHttpRequest !== 'undefined') {
    3742. 

  3742.           if (!ENVIRONMENT_IS_WORKER) throw 'Cannot do synchronous binary XHRs outside webworkers in modern browsers. Use --embed-file or --preload-file in emcc';
    3743. 

  3743.           var lazyArray = new LazyUint8Array();
    3744. 

  3744.           Object.defineProperty(lazyArray, "length", {
    3745. 

  3745.               get: function() {
    3746. 

  3746.                   if(!this.lengthKnown) {
    3747. 

  3747.                       this.cacheLength();
    3748. 

  3748.                   }
    3749. 

  3749.                   return this._length;
    3750. 

  3750.               }
    3751. 

  3751.           });
    3752. 

  3752.           Object.defineProperty(lazyArray, "chunkSize", {
    3753. 

  3753.               get: function() {
    3754. 

  3754.                   if(!this.lengthKnown) {
    3755. 

  3755.                       this.cacheLength();
    3756. 

  3756.                   }
    3757. 

  3757.                   return this._chunkSize;
    3758. 

  3758.               }
    3759. 

  3759.           });
    3760. 

  3760. 

  3761.           var properties = { isDevice: false, contents: lazyArray };
    3762. 

  3762.         } else {
    3763. 

  3763.           var properties = { isDevice: false, url: url };
    3764. 

  3764.         }
    3765. 

  3765. 

  3766.         var node = FS.createFile(parent, name, properties, canRead, canWrite);
    3767. 

  3767.         // This is a total hack, but I want to get this lazy file code out of the
    3768. 

  3768.         // core of MEMFS. If we want to keep this lazy file concept I feel it should
    3769. 

  3769.         // be its own thin LAZYFS proxying calls to MEMFS.
    3770. 

  3770.         if (properties.contents) {
    3771. 

  3771.           node.contents = properties.contents;
    3772. 

  3772.         } else if (properties.url) {
    3773. 

  3773.           node.contents = null;
    3774. 

  3774.           node.url = properties.url;
    3775. 

  3775.         }
    3776. 

  3776.         // override each stream op with one that tries to force load the lazy file first
    3777. 

  3777.         var stream_ops = {};
    3778. 

  3778.         var keys = Object.keys(node.stream_ops);
    3779. 

  3779.         keys.forEach(function(key) {
    3780. 

  3780.           var fn = node.stream_ops[key];
    3781. 

  3781.           stream_ops[key] = function forceLoadLazyFile() {
    3782. 

  3782.             if (!FS.forceLoadFile(node)) {
    3783. 

  3783.               throw new FS.ErrnoError(ERRNO_CODES.EIO);
    3784. 

  3784.             }
    3785. 

  3785.             return fn.apply(null, arguments);
    3786. 

  3786.           };
    3787. 

  3787.         });
    3788. 

  3788.         // use a custom read function
    3789. 

  3789.         stream_ops.read = function stream_ops_read(stream, buffer, offset, length, position) {
    3790. 

  3790.           if (!FS.forceLoadFile(node)) {
    3791. 

  3791.             throw new FS.ErrnoError(ERRNO_CODES.EIO);
    3792. 

  3792.           }
    3793. 

  3793.           var contents = stream.node.contents;
    3794. 

  3794.           if (position >= contents.length)
    3795. 

  3795.             return 0;
    3796. 

  3796.           var size = Math.min(contents.length - position, length);
    3797. 

  3797.           assert(size >= 0);
    3798. 

  3798.           if (contents.slice) { // normal array
    3799. 

  3799.             for (var i = 0; i < size; i++) {
    3800. 

  3800.               buffer[offset + i] = contents[position + i];
    3801. 

  3801.             }
    3802. 

  3802.           } else {
    3803. 

  3803.             for (var i = 0; i < size; i++) { // LazyUint8Array from sync binary XHR
    3804. 

  3804.               buffer[offset + i] = contents.get(position + i);
    3805. 

  3805.             }
    3806. 

  3806.           }
    3807. 

  3807.           return size;
    3808. 

  3808.         };
    3809. 

  3809.         node.stream_ops = stream_ops;
    3810. 

  3810.         return node;
    3811. 

  3811.       },createPreloadedFile:function (parent, name, url, canRead, canWrite, onload, onerror, dontCreateFile, canOwn) {
    3812. 

  3812.         Browser.init();
    3813. 

  3813.         // TODO we should allow people to just pass in a complete filename instead
    3814. 

  3814.         // of parent and name being that we just join them anyways
    3815. 

  3815.         var fullname = name ? PATH.resolve(PATH.join2(parent, name)) : parent;
    3816. 

  3816.         function processData(byteArray) {
    3817. 

  3817.           function finish(byteArray) {
    3818. 

  3818.             if (!dontCreateFile) {
    3819. 

  3819.               FS.createDataFile(parent, name, byteArray, canRead, canWrite, canOwn);
    3820. 

  3820.             }
    3821. 

  3821.             if (onload) onload();
    3822. 

  3822.             removeRunDependency('cp ' + fullname);
    3823. 

  3823.           }
    3824. 

  3824.           var handled = false;
    3825. 

  3825.           Module['preloadPlugins'].forEach(function(plugin) {
    3826. 

  3826.             if (handled) return;
    3827. 

  3827.             if (plugin['canHandle'](fullname)) {
    3828. 

  3828.               plugin['handle'](byteArray, fullname, finish, function() {
    3829. 

  3829.                 if (onerror) onerror();
    3830. 

  3830.                 removeRunDependency('cp ' + fullname);
    3831. 

  3831.               });
    3832. 

  3832.               handled = true;
    3833. 

  3833.             }
    3834. 

  3834.           });
    3835. 

  3835.           if (!handled) finish(byteArray);
    3836. 

  3836.         }
    3837. 

  3837.         addRunDependency('cp ' + fullname);
    3838. 

  3838.         if (typeof url == 'string') {
    3839. 

  3839.           Browser.asyncLoad(url, function(byteArray) {
    3840. 

  3840.             processData(byteArray);
    3841. 

  3841.           }, onerror);
    3842. 

  3842.         } else {
    3843. 

  3843.           processData(url);
    3844. 

  3844.         }
    3845. 

  3845.       },indexedDB:function () {
    3846. 

  3846.         return window.indexedDB || window.mozIndexedDB || window.webkitIndexedDB || window.msIndexedDB;
    3847. 

  3847.       },DB_NAME:function () {
    3848. 

  3848.         return 'EM_FS_' + window.location.pathname;
    3849. 

  3849.       },DB_VERSION:20,DB_STORE_NAME:"FILE_DATA",saveFilesToDB:function (paths, onload, onerror) {
    3850. 

  3850.         onload = onload || function(){};
    3851. 

  3851.         onerror = onerror || function(){};
    3852. 

  3852.         var indexedDB = FS.indexedDB();
    3853. 

  3853.         try {
    3854. 

  3854.           var openRequest = indexedDB.open(FS.DB_NAME(), FS.DB_VERSION);
    3855. 

  3855.         } catch (e) {
    3856. 

  3856.           return onerror(e);
    3857. 

  3857.         }
    3858. 

  3858.         openRequest.onupgradeneeded = function openRequest_onupgradeneeded() {
    3859. 

  3859.           console.log('creating db');
    3860. 

  3860.           var db = openRequest.result;
    3861. 

  3861.           db.createObjectStore(FS.DB_STORE_NAME);
    3862. 

  3862.         };
    3863. 

  3863.         openRequest.onsuccess = function openRequest_onsuccess() {
    3864. 

  3864.           var db = openRequest.result;
    3865. 

  3865.           var transaction = db.transaction([FS.DB_STORE_NAME], 'readwrite');
    3866. 

  3866.           var files = transaction.objectStore(FS.DB_STORE_NAME);
    3867. 

  3867.           var ok = 0, fail = 0, total = paths.length;
    3868. 

  3868.           function finish() {
    3869. 

  3869.             if (fail == 0) onload(); else onerror();
    3870. 

  3870.           }
    3871. 

  3871.           paths.forEach(function(path) {
    3872. 

  3872.             var putRequest = files.put(FS.analyzePath(path).object.contents, path);
    3873. 

  3873.             putRequest.onsuccess = function putRequest_onsuccess() { ok++; if (ok + fail == total) finish() };
    3874. 

  3874.             putRequest.onerror = function putRequest_onerror() { fail++; if (ok + fail == total) finish() };
    3875. 

  3875.           });
    3876. 

  3876.           transaction.onerror = onerror;
    3877. 

  3877.         };
    3878. 

  3878.         openRequest.onerror = onerror;
    3879. 

  3879.       },loadFilesFromDB:function (paths, onload, onerror) {
    3880. 

  3880.         onload = onload || function(){};
    3881. 

  3881.         onerror = onerror || function(){};
    3882. 

  3882.         var indexedDB = FS.indexedDB();
    3883. 

  3883.         try {
    3884. 

  3884.           var openRequest = indexedDB.open(FS.DB_NAME(), FS.DB_VERSION);
    3885. 

  3885.         } catch (e) {
    3886. 

  3886.           return onerror(e);
    3887. 

  3887.         }
    3888. 

  3888.         openRequest.onupgradeneeded = onerror; // no database to load from
    3889. 

  3889.         openRequest.onsuccess = function openRequest_onsuccess() {
    3890. 

  3890.           var db = openRequest.result;
    3891. 

  3891.           try {
    3892. 

  3892.             var transaction = db.transaction([FS.DB_STORE_NAME], 'readonly');
    3893. 

  3893.           } catch(e) {
    3894. 

  3894.             onerror(e);
    3895. 

  3895.             return;
    3896. 

  3896.           }
    3897. 

  3897.           var files = transaction.objectStore(FS.DB_STORE_NAME);
    3898. 

  3898.           var ok = 0, fail = 0, total = paths.length;
    3899. 

  3899.           function finish() {
    3900. 

  3900.             if (fail == 0) onload(); else onerror();
    3901. 

  3901.           }
    3902. 

  3902.           paths.forEach(function(path) {
    3903. 

  3903.             var getRequest = files.get(path);
    3904. 

  3904.             getRequest.onsuccess = function getRequest_onsuccess() {
    3905. 

  3905.               if (FS.analyzePath(path).exists) {
    3906. 

  3906.                 FS.unlink(path);
    3907. 

  3907.               }
    3908. 

  3908.               FS.createDataFile(PATH.dirname(path), PATH.basename(path), getRequest.result, true, true, true);
    3909. 

  3909.               ok++;
    3910. 

  3910.               if (ok + fail == total) finish();
    3911. 

  3911.             };
    3912. 

  3912.             getRequest.onerror = function getRequest_onerror() { fail++; if (ok + fail == total) finish() };
    3913. 

  3913.           });
    3914. 

  3914.           transaction.onerror = onerror;
    3915. 

  3915.         };
    3916. 

  3916.         openRequest.onerror = onerror;
    3917. 

  3917.       }};
    3918. 

  3918. 

  3919.   function _lseek(fildes, offset, whence) {
    3920. 

  3920.       // off_t lseek(int fildes, off_t offset, int whence);
    3921. 

  3921.       // http://pubs.opengroup.org/onlinepubs/000095399/functions/lseek.html
    3922. 

  3922.       var stream = FS.getStream(fildes);
    3923. 

  3923.       if (!stream) {
    3924. 

  3924.         ___setErrNo(ERRNO_CODES.EBADF);
    3925. 

  3925.         return -1;
    3926. 

  3926.       }
    3927. 

  3927.       try {
    3928. 

  3928.         return FS.llseek(stream, offset, whence);
    3929. 

  3929.       } catch (e) {
    3930. 

  3930.         FS.handleFSError(e);
    3931. 

  3931.         return -1;
    3932. 

  3932.       }
    3933. 

  3933.     }
    3934. 

  3934. 

  3935.   function _fileno(stream) {
    3936. 

  3936.       // int fileno(FILE *stream);
    3937. 

  3937.       // http://pubs.opengroup.org/onlinepubs/000095399/functions/fileno.html
    3938. 

  3938.       stream = FS.getStreamFromPtr(stream);
    3939. 

  3939.       if (!stream) return -1;
    3940. 

  3940.       return stream.fd;
    3941. 

  3941.     }function _fseek(stream, offset, whence) {
    3942. 

  3942.       // int fseek(FILE *stream, long offset, int whence);
    3943. 

  3943.       // http://pubs.opengroup.org/onlinepubs/000095399/functions/fseek.html
    3944. 

  3944.       var fd = _fileno(stream);
    3945. 

  3945.       var ret = _lseek(fd, offset, whence);
    3946. 

  3946.       if (ret == -1) {
    3947. 

  3947.         return -1;
    3948. 

  3948.       }
    3949. 

  3949.       stream = FS.getStreamFromPtr(stream);
    3950. 

  3950.       stream.eof = false;
    3951. 

  3951.       return 0;
    3952. 

  3952.     }
    3953. 

  3953. 

  3954. 

  3955.   Module["_i64Subtract"] = _i64Subtract;
    3956. 

  3956. 

  3957. 

  3958.   Module["_i64Add"] = _i64Add;
    3959. 

  3959. 

  3960.   function _setlocale(category, locale) {
    3961. 

  3961.       if (!_setlocale.ret) _setlocale.ret = allocate([0], 'i8', ALLOC_NORMAL);
    3962. 

  3962.       return _setlocale.ret;
    3963. 

  3963.     }
    3964. 

  3964. 

  3965. 

  3966.   function _close(fildes) {
    3967. 

  3967.       // int close(int fildes);
    3968. 

  3968.       // http://pubs.opengroup.org/onlinepubs/000095399/functions/close.html
    3969. 

  3969.       var stream = FS.getStream(fildes);
    3970. 

  3970.       if (!stream) {
    3971. 

  3971.         ___setErrNo(ERRNO_CODES.EBADF);
    3972. 

  3972.         return -1;
    3973. 

  3973.       }
    3974. 

  3974.       try {
    3975. 

  3975.         FS.close(stream);
    3976. 

  3976.         return 0;
    3977. 

  3977.       } catch (e) {
    3978. 

  3978.         FS.handleFSError(e);
    3979. 

  3979.         return -1;
    3980. 

  3980.       }
    3981. 

  3981.     }
    3982. 

  3982. 

  3983.   function _fsync(fildes) {
    3984. 

  3984.       // int fsync(int fildes);
    3985. 

  3985.       // http://pubs.opengroup.org/onlinepubs/000095399/functions/fsync.html
    3986. 

  3986.       var stream = FS.getStream(fildes);
    3987. 

  3987.       if (stream) {
    3988. 

  3988.         // We write directly to the file system, so there's nothing to do here.
    3989. 

  3989.         return 0;
    3990. 

  3990.       } else {
    3991. 

  3991.         ___setErrNo(ERRNO_CODES.EBADF);
    3992. 

  3992.         return -1;
    3993. 

  3993.       }
    3994. 

  3994.     }function _fclose(stream) {
    3995. 

  3995.       // int fclose(FILE *stream);
    3996. 

  3996.       // http://pubs.opengroup.org/onlinepubs/000095399/functions/fclose.html
    3997. 

  3997.       var fd = _fileno(stream);
    3998. 

  3998.       _fsync(fd);
    3999. 

  3999.       return _close(fd);
    4000. 

  4000.     }
    4001. 

  4001. 

  4002. 

  4003. 

  4004. 

  4005. 

  4006.   function _mkport() { throw 'TODO' }var SOCKFS={mount:function (mount) {
    4007. 

  4007.         return FS.createNode(null, '/', 16384 | 511 /* 0777 */, 0);
    4008. 

  4008.       },createSocket:function (family, type, protocol) {
    4009. 

  4009.         var streaming = type == 1;
    4010. 

  4010.         if (protocol) {
    4011. 

  4011.           assert(streaming == (protocol == 6)); // if SOCK_STREAM, must be tcp
    4012. 

  4012.         }
    4013. 

  4013. 

  4014.         // create our internal socket structure
    4015. 

  4015.         var sock = {
    4016. 

  4016.           family: family,
    4017. 

  4017.           type: type,
    4018. 

  4018.           protocol: protocol,
    4019. 

  4019.           server: null,
    4020. 

  4020.           peers: {},
    4021. 

  4021.           pending: [],
    4022. 

  4022.           recv_queue: [],
    4023. 

  4023.           sock_ops: SOCKFS.websocket_sock_ops
    4024. 

  4024.         };
    4025. 

  4025. 

  4026.         // create the filesystem node to store the socket structure
    4027. 

  4027.         var name = SOCKFS.nextname();
    4028. 

  4028.         var node = FS.createNode(SOCKFS.root, name, 49152, 0);
    4029. 

  4029.         node.sock = sock;
    4030. 

  4030. 

  4031.         // and the wrapping stream that enables library functions such
    4032. 

  4032.         // as read and write to indirectly interact with the socket
    4033. 

  4033.         var stream = FS.createStream({
    4034. 

  4034.           path: name,
    4035. 

  4035.           node: node,
    4036. 

  4036.           flags: FS.modeStringToFlags('r+'),
    4037. 

  4037.           seekable: false,
    4038. 

  4038.           stream_ops: SOCKFS.stream_ops
    4039. 

  4039.         });
    4040. 

  4040. 

  4041.         // map the new stream to the socket structure (sockets have a 1:1
    4042. 

  4042.         // relationship with a stream)
    4043. 

  4043.         sock.stream = stream;
    4044. 

  4044. 

  4045.         return sock;
    4046. 

  4046.       },getSocket:function (fd) {
    4047. 

  4047.         var stream = FS.getStream(fd);
    4048. 

  4048.         if (!stream || !FS.isSocket(stream.node.mode)) {
    4049. 

  4049.           return null;
    4050. 

  4050.         }
    4051. 

  4051.         return stream.node.sock;
    4052. 

  4052.       },stream_ops:{poll:function (stream) {
    4053. 

  4053.           var sock = stream.node.sock;
    4054. 

  4054.           return sock.sock_ops.poll(sock);
    4055. 

  4055.         },ioctl:function (stream, request, varargs) {
    4056. 

  4056.           var sock = stream.node.sock;
    4057. 

  4057.           return sock.sock_ops.ioctl(sock, request, varargs);
    4058. 

  4058.         },read:function (stream, buffer, offset, length, position /* ignored */) {
    4059. 

  4059.           var sock = stream.node.sock;
    4060. 

  4060.           var msg = sock.sock_ops.recvmsg(sock, length);
    4061. 

  4061.           if (!msg) {
    4062. 

  4062.             // socket is closed
    4063. 

  4063.             return 0;
    4064. 

  4064.           }
    4065. 

  4065.           buffer.set(msg.buffer, offset);
    4066. 

  4066.           return msg.buffer.length;
    4067. 

  4067.         },write:function (stream, buffer, offset, length, position /* ignored */) {
    4068. 

  4068.           var sock = stream.node.sock;
    4069. 

  4069.           return sock.sock_ops.sendmsg(sock, buffer, offset, length);
    4070. 

  4070.         },close:function (stream) {
    4071. 

  4071.           var sock = stream.node.sock;
    4072. 

  4072.           sock.sock_ops.close(sock);
    4073. 

  4073.         }},nextname:function () {
    4074. 

  4074.         if (!SOCKFS.nextname.current) {
    4075. 

  4075.           SOCKFS.nextname.current = 0;
    4076. 

  4076.         }
    4077. 

  4077.         return 'socket[' + (SOCKFS.nextname.current++) + ']';
    4078. 

  4078.       },websocket_sock_ops:{createPeer:function (sock, addr, port) {
    4079. 

  4079.           var ws;
    4080. 

  4080. 

  4081.           if (typeof addr === 'object') {
    4082. 

  4082.             ws = addr;
    4083. 

  4083.             addr = null;
    4084. 

  4084.             port = null;
    4085. 

  4085.           }
    4086. 

  4086. 

  4087.           if (ws) {
    4088. 

  4088.             // for sockets that've already connected (e.g. we're the server)
    4089. 

  4089.             // we can inspect the _socket property for the address
    4090. 

  4090.             if (ws._socket) {
    4091. 

  4091.               addr = ws._socket.remoteAddress;
    4092. 

  4092.               port = ws._socket.remotePort;
    4093. 

  4093.             }
    4094. 

  4094.             // if we're just now initializing a connection to the remote,
    4095. 

  4095.             // inspect the url property
    4096. 

  4096.             else {
    4097. 

  4097.               var result = /ws[s]?:\/\/([^:]+):(\d+)/.exec(ws.url);
    4098. 

  4098.               if (!result) {
    4099. 

  4099.                 throw new Error('WebSocket URL must be in the format ws(s)://address:port');
    4100. 

  4100.               }
    4101. 

  4101.               addr = result[1];
    4102. 

  4102.               port = parseInt(result[2], 10);
    4103. 

  4103.             }
    4104. 

  4104.           } else {
    4105. 

  4105.             // create the actual websocket object and connect
    4106. 

  4106.             try {
    4107. 

  4107.               // runtimeConfig gets set to true if WebSocket runtime configuration is available.
    4108. 

  4108.               var runtimeConfig = (Module['websocket'] && ('object' === typeof Module['websocket']));
    4109. 

  4109. 

  4110.               // The default value is 'ws://' the replace is needed because the compiler replaces "//" comments with '#'
    4111. 

  4111.               // comments without checking context, so we'd end up with ws:#, the replace swaps the "#" for "//" again.
    4112. 

  4112.               var url = 'ws:#'.replace('#', '//');
    4113. 

  4113. 

  4114.               if (runtimeConfig) {
    4115. 

  4115.                 if ('string' === typeof Module['websocket']['url']) {
    4116. 

  4116.                   url = Module['websocket']['url']; // Fetch runtime WebSocket URL config.
    4117. 

  4117.                 }
    4118. 

  4118.               }
    4119. 

  4119. 

  4120.               if (url === 'ws://' || url === 'wss://') { // Is the supplied URL config just a prefix, if so complete it.
    4121. 

  4121.                 url = url + addr + ':' + port;
    4122. 

  4122.               }
    4123. 

  4123. 

  4124.               // Make the WebSocket subprotocol (Sec-WebSocket-Protocol) default to binary if no configuration is set.
    4125. 

  4125.               var subProtocols = 'binary'; // The default value is 'binary'
    4126. 

  4126. 

  4127.               if (runtimeConfig) {
    4128. 

  4128.                 if ('string' === typeof Module['websocket']['subprotocol']) {
    4129. 

  4129.                   subProtocols = Module['websocket']['subprotocol']; // Fetch runtime WebSocket subprotocol config.
    4130. 

  4130.                 }
    4131. 

  4131.               }
    4132. 

  4132. 

  4133.               // The regex trims the string (removes spaces at the beginning and end, then splits the string by
    4134. 

  4134.               // <any space>,<any space> into an Array. Whitespace removal is important for Websockify and ws.
    4135. 

  4135.               subProtocols = subProtocols.replace(/^ +| +$/g,"").split(/ *, */);
    4136. 

  4136. 

  4137.               // The node ws library API for specifying optional subprotocol is slightly different than the browser's.
    4138. 

  4138.               var opts = ENVIRONMENT_IS_NODE ? {'protocol': subProtocols.toString()} : subProtocols;
    4139. 

  4139. 

  4140.               // If node we use the ws library.
    4141. 

  4141.               var WebSocket = ENVIRONMENT_IS_NODE ? require('ws') : window['WebSocket'];
    4142. 

  4142.               ws = new WebSocket(url, opts);
    4143. 

  4143.               ws.binaryType = 'arraybuffer';
    4144. 

  4144.             } catch (e) {
    4145. 

  4145.               throw new FS.ErrnoError(ERRNO_CODES.EHOSTUNREACH);
    4146. 

  4146.             }
    4147. 

  4147.           }
    4148. 

  4148. 

  4149. 

  4150.           var peer = {
    4151. 

  4151.             addr: addr,
    4152. 

  4152.             port: port,
    4153. 

  4153.             socket: ws,
    4154. 

  4154.             dgram_send_queue: []
    4155. 

  4155.           };
    4156. 

  4156. 

  4157.           SOCKFS.websocket_sock_ops.addPeer(sock, peer);
    4158. 

  4158.           SOCKFS.websocket_sock_ops.handlePeerEvents(sock, peer);
    4159. 

  4159. 

  4160.           // if this is a bound dgram socket, send the port number first to allow
    4161. 

  4161.           // us to override the ephemeral port reported to us by remotePort on the
    4162. 

  4162.           // remote end.
    4163. 

  4163.           if (sock.type === 2 && typeof sock.sport !== 'undefined') {
    4164. 

  4164.             peer.dgram_send_queue.push(new Uint8Array([
    4165. 

  4165.                 255, 255, 255, 255,
    4166. 

  4166.                 'p'.charCodeAt(0), 'o'.charCodeAt(0), 'r'.charCodeAt(0), 't'.charCodeAt(0),
    4167. 

  4167.                 ((sock.sport & 0xff00) >> 8) , (sock.sport & 0xff)
    4168. 

  4168.             ]));
    4169. 

  4169.           }
    4170. 

  4170. 

  4171.           return peer;
    4172. 

  4172.         },getPeer:function (sock, addr, port) {
    4173. 

  4173.           return sock.peers[addr + ':' + port];
    4174. 

  4174.         },addPeer:function (sock, peer) {
    4175. 

  4175.           sock.peers[peer.addr + ':' + peer.port] = peer;
    4176. 

  4176.         },removePeer:function (sock, peer) {
    4177. 

  4177.           delete sock.peers[peer.addr + ':' + peer.port];
    4178. 

  4178.         },handlePeerEvents:function (sock, peer) {
    4179. 

  4179.           var first = true;
    4180. 

  4180. 

  4181.           var handleOpen = function () {
    4182. 

  4182.             try {
    4183. 

  4183.               var queued = peer.dgram_send_queue.shift();
    4184. 

  4184.               while (queued) {
    4185. 

  4185.                 peer.socket.send(queued);
    4186. 

  4186.                 queued = peer.dgram_send_queue.shift();
    4187. 

  4187.               }
    4188. 

  4188.             } catch (e) {
    4189. 

  4189.               // not much we can do here in the way of proper error handling as we've already
    4190. 

  4190.               // lied and said this data was sent. shut it down.
    4191. 

  4191.               peer.socket.close();
    4192. 

  4192.             }
    4193. 

  4193.           };
    4194. 

  4194. 

  4195.           function handleMessage(data) {
    4196. 

  4196.             assert(typeof data !== 'string' && data.byteLength !== undefined);  // must receive an ArrayBuffer
    4197. 

  4197.             data = new Uint8Array(data);  // make a typed array view on the array buffer
    4198. 

  4198. 

  4199. 

  4200.             // if this is the port message, override the peer's port with it
    4201. 

  4201.             var wasfirst = first;
    4202. 

  4202.             first = false;
    4203. 

  4203.             if (wasfirst &&
    4204. 

  4204.                 data.length === 10 &&
    4205. 

  4205.                 data[0] === 255 && data[1] === 255 && data[2] === 255 && data[3] === 255 &&
    4206. 

  4206.                 data[4] === 'p'.charCodeAt(0) && data[5] === 'o'.charCodeAt(0) && data[6] === 'r'.charCodeAt(0) && data[7] === 't'.charCodeAt(0)) {
    4207. 

  4207.               // update the peer's port and it's key in the peer map
    4208. 

  4208.               var newport = ((data[8] << 8) | data[9]);
    4209. 

  4209.               SOCKFS.websocket_sock_ops.removePeer(sock, peer);
    4210. 

  4210.               peer.port = newport;
    4211. 

  4211.               SOCKFS.websocket_sock_ops.addPeer(sock, peer);
    4212. 

  4212.               return;
    4213. 

  4213.             }
    4214. 

  4214. 

  4215.             sock.recv_queue.push({ addr: peer.addr, port: peer.port, data: data });
    4216. 

  4216.           };
    4217. 

  4217. 

  4218.           if (ENVIRONMENT_IS_NODE) {
    4219. 

  4219.             peer.socket.on('open', handleOpen);
    4220. 

  4220.             peer.socket.on('message', function(data, flags) {
    4221. 

  4221.               if (!flags.binary) {
    4222. 

  4222.                 return;
    4223. 

  4223.               }
    4224. 

  4224.               handleMessage((new Uint8Array(data)).buffer);  // copy from node Buffer -> ArrayBuffer
    4225. 

  4225.             });
    4226. 

  4226.             peer.socket.on('error', function() {
    4227. 

  4227.               // don't throw
    4228. 

  4228.             });
    4229. 

  4229.           } else {
    4230. 

  4230.             peer.socket.onopen = handleOpen;
    4231. 

  4231.             peer.socket.onmessage = function peer_socket_onmessage(event) {
    4232. 

  4232.               handleMessage(event.data);
    4233. 

  4233.             };
    4234. 

  4234.           }
    4235. 

  4235.         },poll:function (sock) {
    4236. 

  4236.           if (sock.type === 1 && sock.server) {
    4237. 

  4237.             // listen sockets should only say they're available for reading
    4238. 

  4238.             // if there are pending clients.
    4239. 

  4239.             return sock.pending.length ? (64 | 1) : 0;
    4240. 

  4240.           }
    4241. 

  4241. 

  4242.           var mask = 0;
    4243. 

  4243.           var dest = sock.type === 1 ?  // we only care about the socket state for connection-based sockets
    4244. 

  4244.             SOCKFS.websocket_sock_ops.getPeer(sock, sock.daddr, sock.dport) :
    4245. 

  4245.             null;
    4246. 

  4246. 

  4247.           if (sock.recv_queue.length ||
    4248. 

  4248.               !dest ||  // connection-less sockets are always ready to read
    4249. 

  4249.               (dest && dest.socket.readyState === dest.socket.CLOSING) ||
    4250. 

  4250.               (dest && dest.socket.readyState === dest.socket.CLOSED)) {  // let recv return 0 once closed
    4251. 

  4251.             mask |= (64 | 1);
    4252. 

  4252.           }
    4253. 

  4253. 

  4254.           if (!dest ||  // connection-less sockets are always ready to write
    4255. 

  4255.               (dest && dest.socket.readyState === dest.socket.OPEN)) {
    4256. 

  4256.             mask |= 4;
    4257. 

  4257.           }
    4258. 

  4258. 

  4259.           if ((dest && dest.socket.readyState === dest.socket.CLOSING) ||
    4260. 

  4260.               (dest && dest.socket.readyState === dest.socket.CLOSED)) {
    4261. 

  4261.             mask |= 16;
    4262. 

  4262.           }
    4263. 

  4263. 

  4264.           return mask;
    4265. 

  4265.         },ioctl:function (sock, request, arg) {
    4266. 

  4266.           switch (request) {
    4267. 

  4267.             case 21531:
    4268. 

  4268.               var bytes = 0;
    4269. 

  4269.               if (sock.recv_queue.length) {
    4270. 

  4270.                 bytes = sock.recv_queue[0].data.length;
    4271. 

  4271.               }
    4272. 

  4272.               HEAP32[((arg)>>2)]=bytes;
    4273. 

  4273.               return 0;
    4274. 

  4274.             default:
    4275. 

  4275.               return ERRNO_CODES.EINVAL;
    4276. 

  4276.           }
    4277. 

  4277.         },close:function (sock) {
    4278. 

  4278.           // if we've spawned a listen server, close it
    4279. 

  4279.           if (sock.server) {
    4280. 

  4280.             try {
    4281. 

  4281.               sock.server.close();
    4282. 

  4282.             } catch (e) {
    4283. 

  4283.             }
    4284. 

  4284.             sock.server = null;
    4285. 

  4285.           }
    4286. 

  4286.           // close any peer connections
    4287. 

  4287.           var peers = Object.keys(sock.peers);
    4288. 

  4288.           for (var i = 0; i < peers.length; i++) {
    4289. 

  4289.             var peer = sock.peers[peers[i]];
    4290. 

  4290.             try {
    4291. 

  4291.               peer.socket.close();
    4292. 

  4292.             } catch (e) {
    4293. 

  4293.             }
    4294. 

  4294.             SOCKFS.websocket_sock_ops.removePeer(sock, peer);
    4295. 

  4295.           }
    4296. 

  4296.           return 0;
    4297. 

  4297.         },bind:function (sock, addr, port) {
    4298. 

  4298.           if (typeof sock.saddr !== 'undefined' || typeof sock.sport !== 'undefined') {
    4299. 

  4299.             throw new FS.ErrnoError(ERRNO_CODES.EINVAL);  // already bound
    4300. 

  4300.           }
    4301. 

  4301.           sock.saddr = addr;
    4302. 

  4302.           sock.sport = port || _mkport();
    4303. 

  4303.           // in order to emulate dgram sockets, we need to launch a listen server when
    4304. 

  4304.           // binding on a connection-less socket
    4305. 

  4305.           // note: this is only required on the server side
    4306. 

  4306.           if (sock.type === 2) {
    4307. 

  4307.             // close the existing server if it exists
    4308. 

  4308.             if (sock.server) {
    4309. 

  4309.               sock.server.close();
    4310. 

  4310.               sock.server = null;
    4311. 

  4311.             }
    4312. 

  4312.             // swallow error operation not supported error that occurs when binding in the
    4313. 

  4313.             // browser where this isn't supported
    4314. 

  4314.             try {
    4315. 

  4315.               sock.sock_ops.listen(sock, 0);
    4316. 

  4316.             } catch (e) {
    4317. 

  4317.               if (!(e instanceof FS.ErrnoError)) throw e;
    4318. 

  4318.               if (e.errno !== ERRNO_CODES.EOPNOTSUPP) throw e;
    4319. 

  4319.             }
    4320. 

  4320.           }
    4321. 

  4321.         },connect:function (sock, addr, port) {
    4322. 

  4322.           if (sock.server) {
    4323. 

  4323.             throw new FS.ErrnoError(ERRNO_CODS.EOPNOTSUPP);
    4324. 

  4324.           }
    4325. 

  4325. 

  4326.           // TODO autobind
    4327. 

  4327.           // if (!sock.addr && sock.type == 2) {
    4328. 

  4328.           // }
    4329. 

  4329. 

  4330.           // early out if we're already connected / in the middle of connecting
    4331. 

  4331.           if (typeof sock.daddr !== 'undefined' && typeof sock.dport !== 'undefined') {
    4332. 

  4332.             var dest = SOCKFS.websocket_sock_ops.getPeer(sock, sock.daddr, sock.dport);
    4333. 

  4333.             if (dest) {
    4334. 

  4334.               if (dest.socket.readyState === dest.socket.CONNECTING) {
    4335. 

  4335.                 throw new FS.ErrnoError(ERRNO_CODES.EALREADY);
    4336. 

  4336.               } else {
    4337. 

  4337.                 throw new FS.ErrnoError(ERRNO_CODES.EISCONN);
    4338. 

  4338.               }
    4339. 

  4339.             }
    4340. 

  4340.           }
    4341. 

  4341. 

  4342.           // add the socket to our peer list and set our
    4343. 

  4343.           // destination address / port to match
    4344. 

  4344.           var peer = SOCKFS.websocket_sock_ops.createPeer(sock, addr, port);
    4345. 

  4345.           sock.daddr = peer.addr;
    4346. 

  4346.           sock.dport = peer.port;
    4347. 

  4347. 

  4348.           // always "fail" in non-blocking mode
    4349. 

  4349.           throw new FS.ErrnoError(ERRNO_CODES.EINPROGRESS);
    4350. 

  4350.         },listen:function (sock, backlog) {
    4351. 

  4351.           if (!ENVIRONMENT_IS_NODE) {
    4352. 

  4352.             throw new FS.ErrnoError(ERRNO_CODES.EOPNOTSUPP);
    4353. 

  4353.           }
    4354. 

  4354.           if (sock.server) {
    4355. 

  4355.              throw new FS.ErrnoError(ERRNO_CODES.EINVAL);  // already listening
    4356. 

  4356.           }
    4357. 

  4357.           var WebSocketServer = require('ws').Server;
    4358. 

  4358.           var host = sock.saddr;
    4359. 

  4359.           sock.server = new WebSocketServer({
    4360. 

  4360.             host: host,
    4361. 

  4361.             port: sock.sport
    4362. 

  4362.             // TODO support backlog
    4363. 

  4363.           });
    4364. 

  4364. 

  4365.           sock.server.on('connection', function(ws) {
    4366. 

  4366.             if (sock.type === 1) {
    4367. 

  4367.               var newsock = SOCKFS.createSocket(sock.family, sock.type, sock.protocol);
    4368. 

  4368. 

  4369.               // create a peer on the new socket
    4370. 

  4370.               var peer = SOCKFS.websocket_sock_ops.createPeer(newsock, ws);
    4371. 

  4371.               newsock.daddr = peer.addr;
    4372. 

  4372.               newsock.dport = peer.port;
    4373. 

  4373. 

  4374.               // push to queue for accept to pick up
    4375. 

  4375.               sock.pending.push(newsock);
    4376. 

  4376.             } else {
    4377. 

  4377.               // create a peer on the listen socket so calling sendto
    4378. 

  4378.               // with the listen socket and an address will resolve
    4379. 

  4379.               // to the correct client
    4380. 

  4380.               SOCKFS.websocket_sock_ops.createPeer(sock, ws);
    4381. 

  4381.             }
    4382. 

  4382.           });
    4383. 

  4383.           sock.server.on('closed', function() {
    4384. 

  4384.             sock.server = null;
    4385. 

  4385.           });
    4386. 

  4386.           sock.server.on('error', function() {
    4387. 

  4387.             // don't throw
    4388. 

  4388.           });
    4389. 

  4389.         },accept:function (listensock) {
    4390. 

  4390.           if (!listensock.server) {
    4391. 

  4391.             throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
    4392. 

  4392.           }
    4393. 

  4393.           var newsock = listensock.pending.shift();
    4394. 

  4394.           newsock.stream.flags = listensock.stream.flags;
    4395. 

  4395.           return newsock;
    4396. 

  4396.         },getname:function (sock, peer) {
    4397. 

  4397.           var addr, port;
    4398. 

  4398.           if (peer) {
    4399. 

  4399.             if (sock.daddr === undefined || sock.dport === undefined) {
    4400. 

  4400.               throw new FS.ErrnoError(ERRNO_CODES.ENOTCONN);
    4401. 

  4401.             }
    4402. 

  4402.             addr = sock.daddr;
    4403. 

  4403.             port = sock.dport;
    4404. 

  4404.           } else {
    4405. 

  4405.             // TODO saddr and sport will be set for bind()'d UDP sockets, but what
    4406. 

  4406.             // should we be returning for TCP sockets that've been connect()'d?
    4407. 

  4407.             addr = sock.saddr || 0;
    4408. 

  4408.             port = sock.sport || 0;
    4409. 

  4409.           }
    4410. 

  4410.           return { addr: addr, port: port };
    4411. 

  4411.         },sendmsg:function (sock, buffer, offset, length, addr, port) {
    4412. 

  4412.           if (sock.type === 2) {
    4413. 

  4413.             // connection-less sockets will honor the message address,
    4414. 

  4414.             // and otherwise fall back to the bound destination address
    4415. 

  4415.             if (addr === undefined || port === undefined) {
    4416. 

  4416.               addr = sock.daddr;
    4417. 

  4417.               port = sock.dport;
    4418. 

  4418.             }
    4419. 

  4419.             // if there was no address to fall back to, error out
    4420. 

  4420.             if (addr === undefined || port === undefined) {
    4421. 

  4421.               throw new FS.ErrnoError(ERRNO_CODES.EDESTADDRREQ);
    4422. 

  4422.             }
    4423. 

  4423.           } else {
    4424. 

  4424.             // connection-based sockets will only use the bound
    4425. 

  4425.             addr = sock.daddr;
    4426. 

  4426.             port = sock.dport;
    4427. 

  4427.           }
    4428. 

  4428. 

  4429.           // find the peer for the destination address
    4430. 

  4430.           var dest = SOCKFS.websocket_sock_ops.getPeer(sock, addr, port);
    4431. 

  4431. 

  4432.           // early out if not connected with a connection-based socket
    4433. 

  4433.           if (sock.type === 1) {
    4434. 

  4434.             if (!dest || dest.socket.readyState === dest.socket.CLOSING || dest.socket.readyState === dest.socket.CLOSED) {
    4435. 

  4435.               throw new FS.ErrnoError(ERRNO_CODES.ENOTCONN);
    4436. 

  4436.             } else if (dest.socket.readyState === dest.socket.CONNECTING) {
    4437. 

  4437.               throw new FS.ErrnoError(ERRNO_CODES.EAGAIN);
    4438. 

  4438.             }
    4439. 

  4439.           }
    4440. 

  4440. 

  4441.           // create a copy of the incoming data to send, as the WebSocket API
    4442. 

  4442.           // doesn't work entirely with an ArrayBufferView, it'll just send
    4443. 

  4443.           // the entire underlying buffer
    4444. 

  4444.           var data;
    4445. 

  4445.           if (buffer instanceof Array || buffer instanceof ArrayBuffer) {
    4446. 

  4446.             data = buffer.slice(offset, offset + length);
    4447. 

  4447.           } else {  // ArrayBufferView
    4448. 

  4448.             data = buffer.buffer.slice(buffer.byteOffset + offset, buffer.byteOffset + offset + length);
    4449. 

  4449.           }
    4450. 

  4450. 

  4451.           // if we're emulating a connection-less dgram socket and don't have
    4452. 

  4452.           // a cached connection, queue the buffer to send upon connect and
    4453. 

  4453.           // lie, saying the data was sent now.
    4454. 

  4454.           if (sock.type === 2) {
    4455. 

  4455.             if (!dest || dest.socket.readyState !== dest.socket.OPEN) {
    4456. 

  4456.               // if we're not connected, open a new connection
    4457. 

  4457.               if (!dest || dest.socket.readyState === dest.socket.CLOSING || dest.socket.readyState === dest.socket.CLOSED) {
    4458. 

  4458.                 dest = SOCKFS.websocket_sock_ops.createPeer(sock, addr, port);
    4459. 

  4459.               }
    4460. 

  4460.               dest.dgram_send_queue.push(data);
    4461. 

  4461.               return length;
    4462. 

  4462.             }
    4463. 

  4463.           }
    4464. 

  4464. 

  4465.           try {
    4466. 

  4466.             // send the actual data
    4467. 

  4467.             dest.socket.send(data);
    4468. 

  4468.             return length;
    4469. 

  4469.           } catch (e) {
    4470. 

  4470.             throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
    4471. 

  4471.           }
    4472. 

  4472.         },recvmsg:function (sock, length) {
    4473. 

  4473.           // http://pubs.opengroup.org/onlinepubs/7908799/xns/recvmsg.html
    4474. 

  4474.           if (sock.type === 1 && sock.server) {
    4475. 

  4475.             // tcp servers should not be recv()'ing on the listen socket
    4476. 

  4476.             throw new FS.ErrnoError(ERRNO_CODES.ENOTCONN);
    4477. 

  4477.           }
    4478. 

  4478. 

  4479.           var queued = sock.recv_queue.shift();
    4480. 

  4480.           if (!queued) {
    4481. 

  4481.             if (sock.type === 1) {
    4482. 

  4482.               var dest = SOCKFS.websocket_sock_ops.getPeer(sock, sock.daddr, sock.dport);
    4483. 

  4483. 

  4484.               if (!dest) {
    4485. 

  4485.                 // if we have a destination address but are not connected, error out
    4486. 

  4486.                 throw new FS.ErrnoError(ERRNO_CODES.ENOTCONN);
    4487. 

  4487.               }
    4488. 

  4488.               else if (dest.socket.readyState === dest.socket.CLOSING || dest.socket.readyState === dest.socket.CLOSED) {
    4489. 

  4489.                 // return null if the socket has closed
    4490. 

  4490.                 return null;
    4491. 

  4491.               }
    4492. 

  4492.               else {
    4493. 

  4493.                 // else, our socket is in a valid state but truly has nothing available
    4494. 

  4494.                 throw new FS.ErrnoError(ERRNO_CODES.EAGAIN);
    4495. 

  4495.               }
    4496. 

  4496.             } else {
    4497. 

  4497.               throw new FS.ErrnoError(ERRNO_CODES.EAGAIN);
    4498. 

  4498.             }
    4499. 

  4499.           }
    4500. 

  4500. 

  4501.           // queued.data will be an ArrayBuffer if it's unadulterated, but if it's
    4502. 

  4502.           // requeued TCP data it'll be an ArrayBufferView
    4503. 

  4503.           var queuedLength = queued.data.byteLength || queued.data.length;
    4504. 

  4504.           var queuedOffset = queued.data.byteOffset || 0;
    4505. 

  4505.           var queuedBuffer = queued.data.buffer || queued.data;
    4506. 

  4506.           var bytesRead = Math.min(length, queuedLength);
    4507. 

  4507.           var res = {
    4508. 

  4508.             buffer: new Uint8Array(queuedBuffer, queuedOffset, bytesRead),
    4509. 

  4509.             addr: queued.addr,
    4510. 

  4510.             port: queued.port
    4511. 

  4511.           };
    4512. 

  4512. 

  4513. 

  4514.           // push back any unread data for TCP connections
    4515. 

  4515.           if (sock.type === 1 && bytesRead < queuedLength) {
    4516. 

  4516.             var bytesRemaining = queuedLength - bytesRead;
    4517. 

  4517.             queued.data = new Uint8Array(queuedBuffer, queuedOffset + bytesRead, bytesRemaining);
    4518. 

  4518.             sock.recv_queue.unshift(queued);
    4519. 

  4519.           }
    4520. 

  4520. 

  4521.           return res;
    4522. 

  4522.         }}};function _recv(fd, buf, len, flags) {
    4523. 

  4523.       var sock = SOCKFS.getSocket(fd);
    4524. 

  4524.       if (!sock) {
    4525. 

  4525.         ___setErrNo(ERRNO_CODES.EBADF);
    4526. 

  4526.         return -1;
    4527. 

  4527.       }
    4528. 

  4528.       // TODO honor flags
    4529. 

  4529.       return _read(fd, buf, len);
    4530. 

  4530.     }
    4531. 

  4531. 

  4532.   function _pread(fildes, buf, nbyte, offset) {
    4533. 

  4533.       // ssize_t pread(int fildes, void *buf, size_t nbyte, off_t offset);
    4534. 

  4534.       // http://pubs.opengroup.org/onlinepubs/000095399/functions/read.html
    4535. 

  4535.       var stream = FS.getStream(fildes);
    4536. 

  4536.       if (!stream) {
    4537. 

  4537.         ___setErrNo(ERRNO_CODES.EBADF);
    4538. 

  4538.         return -1;
    4539. 

  4539.       }
    4540. 

  4540.       try {
    4541. 

  4541.         var slab = HEAP8;
    4542. 

  4542.         return FS.read(stream, slab, buf, nbyte, offset);
    4543. 

  4543.       } catch (e) {
    4544. 

  4544.         FS.handleFSError(e);
    4545. 

  4545.         return -1;
    4546. 

  4546.       }
    4547. 

  4547.     }function _read(fildes, buf, nbyte) {
    4548. 

  4548.       // ssize_t read(int fildes, void *buf, size_t nbyte);
    4549. 

  4549.       // http://pubs.opengroup.org/onlinepubs/000095399/functions/read.html
    4550. 

  4550.       var stream = FS.getStream(fildes);
    4551. 

  4551.       if (!stream) {
    4552. 

  4552.         ___setErrNo(ERRNO_CODES.EBADF);
    4553. 

  4553.         return -1;
    4554. 

  4554.       }
    4555. 

  4555. 

  4556. 

  4557.       try {
    4558. 

  4558.         var slab = HEAP8;
    4559. 

  4559.         return FS.read(stream, slab, buf, nbyte);
    4560. 

  4560.       } catch (e) {
    4561. 

  4561.         FS.handleFSError(e);
    4562. 

  4562.         return -1;
    4563. 

  4563.       }
    4564. 

  4564.     }function _fread(ptr, size, nitems, stream) {
    4565. 

  4565.       // size_t fread(void *restrict ptr, size_t size, size_t nitems, FILE *restrict stream);
    4566. 

  4566.       // http://pubs.opengroup.org/onlinepubs/000095399/functions/fread.html
    4567. 

  4567.       var bytesToRead = nitems * size;
    4568. 

  4568.       if (bytesToRead == 0) {
    4569. 

  4569.         return 0;
    4570. 

  4570.       }
    4571. 

  4571.       var bytesRead = 0;
    4572. 

  4572.       var streamObj = FS.getStreamFromPtr(stream);
    4573. 

  4573.       if (!streamObj) {
    4574. 

  4574.         ___setErrNo(ERRNO_CODES.EBADF);
    4575. 

  4575.         return 0;
    4576. 

  4576.       }
    4577. 

  4577.       while (streamObj.ungotten.length && bytesToRead > 0) {
    4578. 

  4578.         HEAP8[((ptr++)|0)]=streamObj.ungotten.pop();
    4579. 

  4579.         bytesToRead--;
    4580. 

  4580.         bytesRead++;
    4581. 

  4581.       }
    4582. 

  4582.       var err = _read(streamObj.fd, ptr, bytesToRead);
    4583. 

  4583.       if (err == -1) {
    4584. 

  4584.         if (streamObj) streamObj.error = true;
    4585. 

  4585.         return 0;
    4586. 

  4586.       }
    4587. 

  4587.       bytesRead += err;
    4588. 

  4588.       if (bytesRead < bytesToRead) streamObj.eof = true;
    4589. 

  4589.       return Math.floor(bytesRead / size);
    4590. 

  4590.     }
    4591. 

  4591. 

  4592.   function _toupper(chr) {
    4593. 

  4593.       if (chr >= 97 && chr <= 122) {
    4594. 

  4594.         return chr - 97 + 65;
    4595. 

  4595.       } else {
    4596. 

  4596.         return chr;
    4597. 

  4597.       }
    4598. 

  4598.     }
    4599. 

  4599. 

  4600. 

  4601. 

  4602.   function _open(path, oflag, varargs) {
    4603. 

  4603.       // int open(const char *path, int oflag, ...);
    4604. 

  4604.       // http://pubs.opengroup.org/onlinepubs/009695399/functions/open.html
    4605. 

  4605.       var mode = HEAP32[((varargs)>>2)];
    4606. 

  4606.       path = Pointer_stringify(path);
    4607. 

  4607.       try {
    4608. 

  4608.         var stream = FS.open(path, oflag, mode);
    4609. 

  4609.         return stream.fd;
    4610. 

  4610.       } catch (e) {
    4611. 

  4611.         FS.handleFSError(e);
    4612. 

  4612.         return -1;
    4613. 

  4613.       }
    4614. 

  4614.     }function _fopen(filename, mode) {
    4615. 

  4615.       // FILE *fopen(const char *restrict filename, const char *restrict mode);
    4616. 

  4616.       // http://pubs.opengroup.org/onlinepubs/000095399/functions/fopen.html
    4617. 

  4617.       var flags;
    4618. 

  4618.       mode = Pointer_stringify(mode);
    4619. 

  4619.       if (mode[0] == 'r') {
    4620. 

  4620.         if (mode.indexOf('+') != -1) {
    4621. 

  4621.           flags = 2;
    4622. 

  4622.         } else {
    4623. 

  4623.           flags = 0;
    4624. 

  4624.         }
    4625. 

  4625.       } else if (mode[0] == 'w') {
    4626. 

  4626.         if (mode.indexOf('+') != -1) {
    4627. 

  4627.           flags = 2;
    4628. 

  4628.         } else {
    4629. 

  4629.           flags = 1;
    4630. 

  4630.         }
    4631. 

  4631.         flags |= 64;
    4632. 

  4632.         flags |= 512;
    4633. 

  4633.       } else if (mode[0] == 'a') {
    4634. 

  4634.         if (mode.indexOf('+') != -1) {
    4635. 

  4635.           flags = 2;
    4636. 

  4636.         } else {
    4637. 

  4637.           flags = 1;
    4638. 

  4638.         }
    4639. 

  4639.         flags |= 64;
    4640. 

  4640.         flags |= 1024;
    4641. 

  4641.       } else {
    4642. 

  4642.         ___setErrNo(ERRNO_CODES.EINVAL);
    4643. 

  4643.         return 0;
    4644. 

  4644.       }
    4645. 

  4645.       var fd = _open(filename, flags, allocate([0x1FF, 0, 0, 0], 'i32', ALLOC_STACK));  // All creation permissions.
    4646. 

  4646.       return fd === -1 ? 0 : FS.getPtrForStream(FS.getStream(fd));
    4647. 

  4647.     }
    4648. 

  4648. 

  4649.   var _emscripten_check_longjmp=true;
    4650. 

  4650. 

  4651. 

  4652. 

  4653.   function _send(fd, buf, len, flags) {
    4654. 

  4654.       var sock = SOCKFS.getSocket(fd);
    4655. 

  4655.       if (!sock) {
    4656. 

  4656.         ___setErrNo(ERRNO_CODES.EBADF);
    4657. 

  4657.         return -1;
    4658. 

  4658.       }
    4659. 

  4659.       // TODO honor flags
    4660. 

  4660.       return _write(fd, buf, len);
    4661. 

  4661.     }
    4662. 

  4662. 

  4663.   function _pwrite(fildes, buf, nbyte, offset) {
    4664. 

  4664.       // ssize_t pwrite(int fildes, const void *buf, size_t nbyte, off_t offset);
    4665. 

  4665.       // http://pubs.opengroup.org/onlinepubs/000095399/functions/write.html
    4666. 

  4666.       var stream = FS.getStream(fildes);
    4667. 

  4667.       if (!stream) {
    4668. 

  4668.         ___setErrNo(ERRNO_CODES.EBADF);
    4669. 

  4669.         return -1;
    4670. 

  4670.       }
    4671. 

  4671.       try {
    4672. 

  4672.         var slab = HEAP8;
    4673. 

  4673.         return FS.write(stream, slab, buf, nbyte, offset);
    4674. 

  4674.       } catch (e) {
    4675. 

  4675.         FS.handleFSError(e);
    4676. 

  4676.         return -1;
    4677. 

  4677.       }
    4678. 

  4678.     }function _write(fildes, buf, nbyte) {
    4679. 

  4679.       // ssize_t write(int fildes, const void *buf, size_t nbyte);
    4680. 

  4680.       // http://pubs.opengroup.org/onlinepubs/000095399/functions/write.html
    4681. 

  4681.       var stream = FS.getStream(fildes);
    4682. 

  4682.       if (!stream) {
    4683. 

  4683.         ___setErrNo(ERRNO_CODES.EBADF);
    4684. 

  4684.         return -1;
    4685. 

  4685.       }
    4686. 

  4686. 

  4687. 

  4688.       try {
    4689. 

  4689.         var slab = HEAP8;
    4690. 

  4690.         return FS.write(stream, slab, buf, nbyte);
    4691. 

  4691.       } catch (e) {
    4692. 

  4692.         FS.handleFSError(e);
    4693. 

  4693.         return -1;
    4694. 

  4694.       }
    4695. 

  4695.     }function _fputc(c, stream) {
    4696. 

  4696.       // int fputc(int c, FILE *stream);
    4697. 

  4697.       // http://pubs.opengroup.org/onlinepubs/000095399/functions/fputc.html
    4698. 

  4698.       var chr = unSign(c & 0xFF);
    4699. 

  4699.       HEAP8[((_fputc.ret)|0)]=chr;
    4700. 

  4700.       var fd = _fileno(stream);
    4701. 

  4701.       var ret = _write(fd, _fputc.ret, 1);
    4702. 

  4702.       if (ret == -1) {
    4703. 

  4703.         var streamObj = FS.getStreamFromPtr(stream);
    4704. 

  4704.         if (streamObj) streamObj.error = true;
    4705. 

  4705.         return -1;
    4706. 

  4706.       } else {
    4707. 

  4707.         return chr;
    4708. 

  4708.       }
    4709. 

  4709.     }
    4710. 

  4710. 

  4711.   var _log=Math_log;
    4712. 

  4712. 

  4713.   var _emscripten_postinvoke=true;
    4714. 

  4714. 

  4715. 

  4716.   function _putchar(c) {
    4717. 

  4717.       // int putchar(int c);
    4718. 

  4718.       // http://pubs.opengroup.org/onlinepubs/000095399/functions/putchar.html
    4719. 

  4719.       return _fputc(c, HEAP32[((_stdout)>>2)]);
    4720. 

  4720.     }
    4721. 

  4721.   Module["_saveSetjmp"] = _saveSetjmp;
    4722. 

  4722. 

  4723.   function _fwrite(ptr, size, nitems, stream) {
    4724. 

  4724.       // size_t fwrite(const void *restrict ptr, size_t size, size_t nitems, FILE *restrict stream);
    4725. 

  4725.       // http://pubs.opengroup.org/onlinepubs/000095399/functions/fwrite.html
    4726. 

  4726.       var bytesToWrite = nitems * size;
    4727. 

  4727.       if (bytesToWrite == 0) return 0;
    4728. 

  4728.       var fd = _fileno(stream);
    4729. 

  4729.       var bytesWritten = _write(fd, ptr, bytesToWrite);
    4730. 

  4730.       if (bytesWritten == -1) {
    4731. 

  4731.         var streamObj = FS.getStreamFromPtr(stream);
    4732. 

  4732.         if (streamObj) streamObj.error = true;
    4733. 

  4733.         return 0;
    4734. 

  4734.       } else {
    4735. 

  4735.         return Math.floor(bytesWritten / size);
    4736. 

  4736.       }
    4737. 

  4737.     }
    4738. 

  4738. 

  4739.   function _system(command) {
    4740. 

  4740.       // int system(const char *command);
    4741. 

  4741.       // http://pubs.opengroup.org/onlinepubs/000095399/functions/system.html
    4742. 

  4742.       // Can't call external programs.
    4743. 

  4743.       ___setErrNo(ERRNO_CODES.EAGAIN);
    4744. 

  4744.       return -1;
    4745. 

  4745.     }
    4746. 

  4746. 

  4747.   function _frexp(x, exp_addr) {
    4748. 

  4748.       var sig = 0, exp_ = 0;
    4749. 

  4749.       if (x !== 0) {
    4750. 

  4750.         var sign = 1;
    4751. 

  4751.         if (x < 0) {
    4752. 

  4752.           x = -x;
    4753. 

  4753.           sign = -1;
    4754. 

  4754.         }
    4755. 

  4755.         var raw_exp = Math.log(x)/Math.log(2);
    4756. 

  4756.         exp_ = Math.ceil(raw_exp);
    4757. 

  4757.         if (exp_ === raw_exp) exp_ += 1;
    4758. 

  4758.         sig = sign*x/Math.pow(2, exp_);
    4759. 

  4759.       }
    4760. 

  4760.       HEAP32[((exp_addr)>>2)]=exp_;
    4761. 

  4761.       return sig;
    4762. 

  4762.     }
    4763. 

  4763. 

  4764. 

  4765. 

  4766.   var _tzname=allocate(8, "i32*", ALLOC_STATIC);
    4767. 

  4767. 

  4768.   var _daylight=allocate(1, "i32*", ALLOC_STATIC);
    4769. 

  4769. 

  4770.   var _timezone=allocate(1, "i32*", ALLOC_STATIC);function _tzset() {
    4771. 

  4771.       // TODO: Use (malleable) environment variables instead of system settings.
    4772. 

  4772.       if (_tzset.called) return;
    4773. 

  4773.       _tzset.called = true;
    4774. 

  4774. 

  4775.       HEAP32[((_timezone)>>2)]=-(new Date()).getTimezoneOffset() * 60;
    4776. 

  4776. 

  4777.       var winter = new Date(2000, 0, 1);
    4778. 

  4778.       var summer = new Date(2000, 6, 1);
    4779. 

  4779.       HEAP32[((_daylight)>>2)]=Number(winter.getTimezoneOffset() != summer.getTimezoneOffset());
    4780. 

  4780. 

  4781.       var winterName = 'GMT'; // XXX do not rely on browser timezone info, it is very unpredictable | winter.toString().match(/\(([A-Z]+)\)/)[1];
    4782. 

  4782.       var summerName = 'GMT'; // XXX do not rely on browser timezone info, it is very unpredictable | summer.toString().match(/\(([A-Z]+)\)/)[1];
    4783. 

  4783.       var winterNamePtr = allocate(intArrayFromString(winterName), 'i8', ALLOC_NORMAL);
    4784. 

  4784.       var summerNamePtr = allocate(intArrayFromString(summerName), 'i8', ALLOC_NORMAL);
    4785. 

  4785.       HEAP32[((_tzname)>>2)]=winterNamePtr;
    4786. 

  4786.       HEAP32[(((_tzname)+(4))>>2)]=summerNamePtr;
    4787. 

  4787.     }function _mktime(tmPtr) {
    4788. 

  4788.       _tzset();
    4789. 

  4789.       var year = HEAP32[(((tmPtr)+(20))>>2)];
    4790. 

  4790.       var timestamp = new Date(year >= 1900 ? year : year + 1900,
    4791. 

  4791.                                HEAP32[(((tmPtr)+(16))>>2)],
    4792. 

  4792.                                HEAP32[(((tmPtr)+(12))>>2)],
    4793. 

  4793.                                HEAP32[(((tmPtr)+(8))>>2)],
    4794. 

  4794.                                HEAP32[(((tmPtr)+(4))>>2)],
    4795. 

  4795.                                HEAP32[((tmPtr)>>2)],
    4796. 

  4796.                                0).getTime() / 1000;
    4797. 

  4797.       HEAP32[(((tmPtr)+(24))>>2)]=new Date(timestamp).getDay();
    4798. 

  4798.       var yday = Math.round((timestamp - (new Date(year, 0, 1)).getTime()) / (1000 * 60 * 60 * 24));
    4799. 

  4799.       HEAP32[(((tmPtr)+(28))>>2)]=yday;
    4800. 

  4800.       return timestamp;
    4801. 

  4801.     }
    4802. 

  4802. 

  4803.   function _isalpha(chr) {
    4804. 

  4804.       return (chr >= 97 && chr <= 122) ||
    4805. 

  4805.              (chr >= 65 && chr <= 90);
    4806. 

  4806.     }
    4807. 

  4807. 

  4808. 

  4809.   function _malloc(bytes) {
    4810. 

  4810.       /* Over-allocate to make sure it is byte-aligned by 8.
    4811. 

  4811.        * This will leak memory, but this is only the dummy
    4812. 

  4812.        * implementation (replaced by dlmalloc normally) so
    4813. 

  4813.        * not an issue.
    4814. 

  4814.        */
    4815. 

  4815.       var ptr = Runtime.dynamicAlloc(bytes + 8);
    4816. 

  4816.       return (ptr+8) & 0xFFFFFFF8;
    4817. 

  4817.     }
    4818. 

  4818.   Module["_malloc"] = _malloc;function _tmpnam(s, dir, prefix) {
    4819. 

  4819.       // char *tmpnam(char *s);
    4820. 

  4820.       // http://pubs.opengroup.org/onlinepubs/000095399/functions/tmpnam.html
    4821. 

  4821.       // NOTE: The dir and prefix arguments are for internal use only.
    4822. 

  4822.       var folder = FS.findObject(dir || '/tmp');
    4823. 

  4823.       if (!folder || !folder.isFolder) {
    4824. 

  4824.         dir = '/tmp';
    4825. 

  4825.         folder = FS.findObject(dir);
    4826. 

  4826.         if (!folder || !folder.isFolder) return 0;
    4827. 

  4827.       }
    4828. 

  4828.       var name = prefix || 'file';
    4829. 

  4829.       do {
    4830. 

  4830.         name += String.fromCharCode(65 + Math.floor(Math.random() * 25));
    4831. 

  4831.       } while (name in folder.contents);
    4832. 

  4832.       var result = dir + '/' + name;
    4833. 

  4833.       if (!_tmpnam.buffer) _tmpnam.buffer = _malloc(256);
    4834. 

  4834.       if (!s) s = _tmpnam.buffer;
    4835. 

  4835.       writeAsciiToMemory(result, s);
    4836. 

  4836.       return s;
    4837. 

  4837.     }
    4838. 

  4838. 

  4839.   var Browser={mainLoop:{scheduler:null,method:"",shouldPause:false,paused:false,queue:[],pause:function () {
    4840. 

  4840.           Browser.mainLoop.shouldPause = true;
    4841. 

  4841.         },resume:function () {
    4842. 

  4842.           if (Browser.mainLoop.paused) {
    4843. 

  4843.             Browser.mainLoop.paused = false;
    4844. 

  4844.             Browser.mainLoop.scheduler();
    4845. 

  4845.           }
    4846. 

  4846.           Browser.mainLoop.shouldPause = false;
    4847. 

  4847.         },updateStatus:function () {
    4848. 

  4848.           if (Module['setStatus']) {
    4849. 

  4849.             var message = Module['statusMessage'] || 'Please wait...';
    4850. 

  4850.             var remaining = Browser.mainLoop.remainingBlockers;
    4851. 

  4851.             var expected = Browser.mainLoop.expectedBlockers;
    4852. 

  4852.             if (remaining) {
    4853. 

  4853.               if (remaining < expected) {
    4854. 

  4854.                 Module['setStatus'](message + ' (' + (expected - remaining) + '/' + expected + ')');
    4855. 

  4855.               } else {
    4856. 

  4856.                 Module['setStatus'](message);
    4857. 

  4857.               }
    4858. 

  4858.             } else {
    4859. 

  4859.               Module['setStatus']('');
    4860. 

  4860.             }
    4861. 

  4861.           }
    4862. 

  4862.         }},isFullScreen:false,pointerLock:false,moduleContextCreatedCallbacks:[],workers:[],init:function () {
    4863. 

  4863.         if (!Module["preloadPlugins"]) Module["preloadPlugins"] = []; // needs to exist even in workers
    4864. 

  4864. 

  4865.         if (Browser.initted || ENVIRONMENT_IS_WORKER) return;
    4866. 

  4866.         Browser.initted = true;
    4867. 

  4867. 

  4868.         try {
    4869. 

  4869.           new Blob();
    4870. 

  4870.           Browser.hasBlobConstructor = true;
    4871. 

  4871.         } catch(e) {
    4872. 

  4872.           Browser.hasBlobConstructor = false;
    4873. 

  4873.           console.log("warning: no blob constructor, cannot create blobs with mimetypes");
    4874. 

  4874.         }
    4875. 

  4875.         Browser.BlobBuilder = typeof MozBlobBuilder != "undefined" ? MozBlobBuilder : (typeof WebKitBlobBuilder != "undefined" ? WebKitBlobBuilder : (!Browser.hasBlobConstructor ? console.log("warning: no BlobBuilder") : null));
    4876. 

  4876.         Browser.URLObject = typeof window != "undefined" ? (window.URL ? window.URL : window.webkitURL) : undefined;
    4877. 

  4877.         if (!Module.noImageDecoding && typeof Browser.URLObject === 'undefined') {
    4878. 

  4878.           console.log("warning: Browser does not support creating object URLs. Built-in browser image decoding will not be available.");
    4879. 

  4879.           Module.noImageDecoding = true;
    4880. 

  4880.         }
    4881. 

  4881. 

  4882.         // Support for plugins that can process preloaded files. You can add more of these to
    4883. 

  4883.         // your app by creating and appending to Module.preloadPlugins.
    4884. 

  4884.         //
    4885. 

  4885.         // Each plugin is asked if it can handle a file based on the file's name. If it can,
    4886. 

  4886.         // it is given the file's raw data. When it is done, it calls a callback with the file's
    4887. 

  4887.         // (possibly modified) data. For example, a plugin might decompress a file, or it
    4888. 

  4888.         // might create some side data structure for use later (like an Image element, etc.).
    4889. 

  4889. 

  4890.         var imagePlugin = {};
    4891. 

  4891.         imagePlugin['canHandle'] = function imagePlugin_canHandle(name) {
    4892. 

  4892.           return !Module.noImageDecoding && /\.(jpg|jpeg|png|bmp)$/i.test(name);
    4893. 

  4893.         };
    4894. 

  4894.         imagePlugin['handle'] = function imagePlugin_handle(byteArray, name, onload, onerror) {
    4895. 

  4895.           var b = null;
    4896. 

  4896.           if (Browser.hasBlobConstructor) {
    4897. 

  4897.             try {
    4898. 

  4898.               b = new Blob([byteArray], { type: Browser.getMimetype(name) });
    4899. 

  4899.               if (b.size !== byteArray.length) { // Safari bug #118630
    4900. 

  4900.                 // Safari's Blob can only take an ArrayBuffer
    4901. 

  4901.                 b = new Blob([(new Uint8Array(byteArray)).buffer], { type: Browser.getMimetype(name) });
    4902. 

  4902.               }
    4903. 

  4903.             } catch(e) {
    4904. 

  4904.               Runtime.warnOnce('Blob constructor present but fails: ' + e + '; falling back to blob builder');
    4905. 

  4905.             }
    4906. 

  4906.           }
    4907. 

  4907.           if (!b) {
    4908. 

  4908.             var bb = new Browser.BlobBuilder();
    4909. 

  4909.             bb.append((new Uint8Array(byteArray)).buffer); // we need to pass a buffer, and must copy the array to get the right data range
    4910. 

  4910.             b = bb.getBlob();
    4911. 

  4911.           }
    4912. 

  4912.           var url = Browser.URLObject.createObjectURL(b);
    4913. 

  4913.           var img = new Image();
    4914. 

  4914.           img.onload = function img_onload() {
    4915. 

  4915.             assert(img.complete, 'Image ' + name + ' could not be decoded');
    4916. 

  4916.             var canvas = document.createElement('canvas');
    4917. 

  4917.             canvas.width = img.width;
    4918. 

  4918.             canvas.height = img.height;
    4919. 

  4919.             var ctx = canvas.getContext('2d');
    4920. 

  4920.             ctx.drawImage(img, 0, 0);
    4921. 

  4921.             Module["preloadedImages"][name] = canvas;
    4922. 

  4922.             Browser.URLObject.revokeObjectURL(url);
    4923. 

  4923.             if (onload) onload(byteArray);
    4924. 

  4924.           };
    4925. 

  4925.           img.onerror = function img_onerror(event) {
    4926. 

  4926.             console.log('Image ' + url + ' could not be decoded');
    4927. 

  4927.             if (onerror) onerror();
    4928. 

  4928.           };
    4929. 

  4929.           img.src = url;
    4930. 

  4930.         };
    4931. 

  4931.         Module['preloadPlugins'].push(imagePlugin);
    4932. 

  4932. 

  4933.         var audioPlugin = {};
    4934. 

  4934.         audioPlugin['canHandle'] = function audioPlugin_canHandle(name) {
    4935. 

  4935.           return !Module.noAudioDecoding && name.substr(-4) in { '.ogg': 1, '.wav': 1, '.mp3': 1 };
    4936. 

  4936.         };
    4937. 

  4937.         audioPlugin['handle'] = function audioPlugin_handle(byteArray, name, onload, onerror) {
    4938. 

  4938.           var done = false;
    4939. 

  4939.           function finish(audio) {
    4940. 

  4940.             if (done) return;
    4941. 

  4941.             done = true;
    4942. 

  4942.             Module["preloadedAudios"][name] = audio;
    4943. 

  4943.             if (onload) onload(byteArray);
    4944. 

  4944.           }
    4945. 

  4945.           function fail() {
    4946. 

  4946.             if (done) return;
    4947. 

  4947.             done = true;
    4948. 

  4948.             Module["preloadedAudios"][name] = new Audio(); // empty shim
    4949. 

  4949.             if (onerror) onerror();
    4950. 

  4950.           }
    4951. 

  4951.           if (Browser.hasBlobConstructor) {
    4952. 

  4952.             try {
    4953. 

  4953.               var b = new Blob([byteArray], { type: Browser.getMimetype(name) });
    4954. 

  4954.             } catch(e) {
    4955. 

  4955.               return fail();
    4956. 

  4956.             }
    4957. 

  4957.             var url = Browser.URLObject.createObjectURL(b); // XXX we never revoke this!
    4958. 

  4958.             var audio = new Audio();
    4959. 

  4959.             audio.addEventListener('canplaythrough', function() { finish(audio) }, false); // use addEventListener due to chromium bug 124926
    4960. 

  4960.             audio.onerror = function audio_onerror(event) {
    4961. 

  4961.               if (done) return;
    4962. 

  4962.               console.log('warning: browser could not fully decode audio ' + name + ', trying slower base64 approach');
    4963. 

  4963.               function encode64(data) {
    4964. 

  4964.                 var BASE = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
    4965. 

  4965.                 var PAD = '=';
    4966. 

  4966.                 var ret = '';
    4967. 

  4967.                 var leftchar = 0;
    4968. 

  4968.                 var leftbits = 0;
    4969. 

  4969.                 for (var i = 0; i < data.length; i++) {
    4970. 

  4970.                   leftchar = (leftchar << 8) | data[i];
    4971. 

  4971.                   leftbits += 8;
    4972. 

  4972.                   while (leftbits >= 6) {
    4973. 

  4973.                     var curr = (leftchar >> (leftbits-6)) & 0x3f;
    4974. 

  4974.                     leftbits -= 6;
    4975. 

  4975.                     ret += BASE[curr];
    4976. 

  4976.                   }
    4977. 

  4977.                 }
    4978. 

  4978.                 if (leftbits == 2) {
    4979. 

  4979.                   ret += BASE[(leftchar&3) << 4];
    4980. 

  4980.                   ret += PAD + PAD;
    4981. 

  4981.                 } else if (leftbits == 4) {
    4982. 

  4982.                   ret += BASE[(leftchar&0xf) << 2];
    4983. 

  4983.                   ret += PAD;
    4984. 

  4984.                 }
    4985. 

  4985.                 return ret;
    4986. 

  4986.               }
    4987. 

  4987.               audio.src = 'data:audio/x-' + name.substr(-3) + ';base64,' + encode64(byteArray);
    4988. 

  4988.               finish(audio); // we don't wait for confirmation this worked - but it's worth trying
    4989. 

  4989.             };
    4990. 

  4990.             audio.src = url;
    4991. 

  4991.             // workaround for chrome bug 124926 - we do not always get oncanplaythrough or onerror
    4992. 

  4992.             Browser.safeSetTimeout(function() {
    4993. 

  4993.               finish(audio); // try to use it even though it is not necessarily ready to play
    4994. 

  4994.             }, 10000);
    4995. 

  4995.           } else {
    4996. 

  4996.             return fail();
    4997. 

  4997.           }
    4998. 

  4998.         };
    4999. 

  4999.         Module['preloadPlugins'].push(audioPlugin);
    5000. 

  5000. 

  5001.         // Canvas event setup
    5002. 

  5002. 

  5003.         var canvas = Module['canvas'];
    5004. 

  5004. 

  5005.         // forced aspect ratio can be enabled by defining 'forcedAspectRatio' on Module
    5006. 

  5006.         // Module['forcedAspectRatio'] = 4 / 3;
    5007. 

  5007. 

  5008.         canvas.requestPointerLock = canvas['requestPointerLock'] ||
    5009. 

  5009.                                     canvas['mozRequestPointerLock'] ||
    5010. 

  5010.                                     canvas['webkitRequestPointerLock'] ||
    5011. 

  5011.                                     canvas['msRequestPointerLock'] ||
    5012. 

  5012.                                     function(){};
    5013. 

  5013.         canvas.exitPointerLock = document['exitPointerLock'] ||
    5014. 

  5014.                                  document['mozExitPointerLock'] ||
    5015. 

  5015.                                  document['webkitExitPointerLock'] ||
    5016. 

  5016.                                  document['msExitPointerLock'] ||
    5017. 

  5017.                                  function(){}; // no-op if function does not exist
    5018. 

  5018.         canvas.exitPointerLock = canvas.exitPointerLock.bind(document);
    5019. 

  5019. 

  5020.         function pointerLockChange() {
    5021. 

  5021.           Browser.pointerLock = document['pointerLockElement'] === canvas ||
    5022. 

  5022.                                 document['mozPointerLockElement'] === canvas ||
    5023. 

  5023.                                 document['webkitPointerLockElement'] === canvas ||
    5024. 

  5024.                                 document['msPointerLockElement'] === canvas;
    5025. 

  5025.         }
    5026. 

  5026. 

  5027.         document.addEventListener('pointerlockchange', pointerLockChange, false);
    5028. 

  5028.         document.addEventListener('mozpointerlockchange', pointerLockChange, false);
    5029. 

  5029.         document.addEventListener('webkitpointerlockchange', pointerLockChange, false);
    5030. 

  5030.         document.addEventListener('mspointerlockchange', pointerLockChange, false);
    5031. 

  5031. 

  5032.         if (Module['elementPointerLock']) {
    5033. 

  5033.           canvas.addEventListener("click", function(ev) {
    5034. 

  5034.             if (!Browser.pointerLock && canvas.requestPointerLock) {
    5035. 

  5035.               canvas.requestPointerLock();
    5036. 

  5036.               ev.preventDefault();
    5037. 

  5037.             }
    5038. 

  5038.           }, false);
    5039. 

  5039.         }
    5040. 

  5040.       },createContext:function (canvas, useWebGL, setInModule, webGLContextAttributes) {
    5041. 

  5041.         var ctx;
    5042. 

  5042.         var errorInfo = '?';
    5043. 

  5043.         function onContextCreationError(event) {
    5044. 

  5044.           errorInfo = event.statusMessage || errorInfo;
    5045. 

  5045.         }
    5046. 

  5046.         try {
    5047. 

  5047.           if (useWebGL) {
    5048. 

  5048.             var contextAttributes = {
    5049. 

  5049.               antialias: false,
    5050. 

  5050.               alpha: false
    5051. 

  5051.             };
    5052. 

  5052. 

  5053.             if (webGLContextAttributes) {
    5054. 

  5054.               for (var attribute in webGLContextAttributes) {
    5055. 

  5055.                 contextAttributes[attribute] = webGLContextAttributes[attribute];
    5056. 

  5056.               }
    5057. 

  5057.             }
    5058. 

  5058. 

  5059. 

  5060.             canvas.addEventListener('webglcontextcreationerror', onContextCreationError, false);
    5061. 

  5061.             try {
    5062. 

  5062.               ['experimental-webgl', 'webgl'].some(function(webglId) {
    5063. 

  5063.                 return ctx = canvas.getContext(webglId, contextAttributes);
    5064. 

  5064.               });
    5065. 

  5065.             } finally {
    5066. 

  5066.               canvas.removeEventListener('webglcontextcreationerror', onContextCreationError, false);
    5067. 

  5067.             }
    5068. 

  5068.           } else {
    5069. 

  5069.             ctx = canvas.getContext('2d');
    5070. 

  5070.           }
    5071. 

  5071.           if (!ctx) throw ':(';
    5072. 

  5072.         } catch (e) {
    5073. 

  5073.           Module.print('Could not create canvas: ' + [errorInfo, e]);
    5074. 

  5074.           return null;
    5075. 

  5075.         }
    5076. 

  5076.         if (useWebGL) {
    5077. 

  5077.           // Set the background of the WebGL canvas to black
    5078. 

  5078.           canvas.style.backgroundColor = "black";
    5079. 

  5079. 

  5080.           // Warn on context loss
    5081. 

  5081.           canvas.addEventListener('webglcontextlost', function(event) {
    5082. 

  5082.             alert('WebGL context lost. You will need to reload the page.');
    5083. 

  5083.           }, false);
    5084. 

  5084.         }
    5085. 

  5085.         if (setInModule) {
    5086. 

  5086.           GLctx = Module.ctx = ctx;
    5087. 

  5087.           Module.useWebGL = useWebGL;
    5088. 

  5088.           Browser.moduleContextCreatedCallbacks.forEach(function(callback) { callback() });
    5089. 

  5089.           Browser.init();
    5090. 

  5090.         }
    5091. 

  5091.         return ctx;
    5092. 

  5092.       },destroyContext:function (canvas, useWebGL, setInModule) {},fullScreenHandlersInstalled:false,lockPointer:undefined,resizeCanvas:undefined,requestFullScreen:function (lockPointer, resizeCanvas) {
    5093. 

  5093.         Browser.lockPointer = lockPointer;
    5094. 

  5094.         Browser.resizeCanvas = resizeCanvas;
    5095. 

  5095.         if (typeof Browser.lockPointer === 'undefined') Browser.lockPointer = true;
    5096. 

  5096.         if (typeof Browser.resizeCanvas === 'undefined') Browser.resizeCanvas = false;
    5097. 

  5097. 

  5098.         var canvas = Module['canvas'];
    5099. 

  5099.         function fullScreenChange() {
    5100. 

  5100.           Browser.isFullScreen = false;
    5101. 

  5101.           var canvasContainer = canvas.parentNode;
    5102. 

  5102.           if ((document['webkitFullScreenElement'] || document['webkitFullscreenElement'] ||
    5103. 

  5103.                document['mozFullScreenElement'] || document['mozFullscreenElement'] ||
    5104. 

  5104.                document['fullScreenElement'] || document['fullscreenElement'] ||
    5105. 

  5105.                document['msFullScreenElement'] || document['msFullscreenElement'] ||
    5106. 

  5106.                document['webkitCurrentFullScreenElement']) === canvasContainer) {
    5107. 

  5107.             canvas.cancelFullScreen = document['cancelFullScreen'] ||
    5108. 

  5108.                                       document['mozCancelFullScreen'] ||
    5109. 

  5109.                                       document['webkitCancelFullScreen'] ||
    5110. 

  5110.                                       document['msExitFullscreen'] ||
    5111. 

  5111.                                       document['exitFullscreen'] ||
    5112. 

  5112.                                       function() {};
    5113. 

  5113.             canvas.cancelFullScreen = canvas.cancelFullScreen.bind(document);
    5114. 

  5114.             if (Browser.lockPointer) canvas.requestPointerLock();
    5115. 

  5115.             Browser.isFullScreen = true;
    5116. 

  5116.             if (Browser.resizeCanvas) Browser.setFullScreenCanvasSize();
    5117. 

  5117.           } else {
    5118. 

  5118. 

  5119.             // remove the full screen specific parent of the canvas again to restore the HTML structure from before going full screen
    5120. 

  5120.             canvasContainer.parentNode.insertBefore(canvas, canvasContainer);
    5121. 

  5121.             canvasContainer.parentNode.removeChild(canvasContainer);
    5122. 

  5122. 

  5123.             if (Browser.resizeCanvas) Browser.setWindowedCanvasSize();
    5124. 

  5124.           }
    5125. 

  5125.           if (Module['onFullScreen']) Module['onFullScreen'](Browser.isFullScreen);
    5126. 

  5126.           Browser.updateCanvasDimensions(canvas);
    5127. 

  5127.         }
    5128. 

  5128. 

  5129.         if (!Browser.fullScreenHandlersInstalled) {
    5130. 

  5130.           Browser.fullScreenHandlersInstalled = true;
    5131. 

  5131.           document.addEventListener('fullscreenchange', fullScreenChange, false);
    5132. 

  5132.           document.addEventListener('mozfullscreenchange', fullScreenChange, false);
    5133. 

  5133.           document.addEventListener('webkitfullscreenchange', fullScreenChange, false);
    5134. 

  5134.           document.addEventListener('MSFullscreenChange', fullScreenChange, false);
    5135. 

  5135.         }
    5136. 

  5136. 

  5137.         // create a new parent to ensure the canvas has no siblings. this allows browsers to optimize full screen performance when its parent is the full screen root
    5138. 

  5138.         var canvasContainer = document.createElement("div");
    5139. 

  5139.         canvas.parentNode.insertBefore(canvasContainer, canvas);
    5140. 

  5140.         canvasContainer.appendChild(canvas);
    5141. 

  5141. 

  5142.         // use parent of canvas as full screen root to allow aspect ratio correction (Firefox stretches the root to screen size)
    5143. 

  5143.         canvasContainer.requestFullScreen = canvasContainer['requestFullScreen'] ||
    5144. 

  5144.                                             canvasContainer['mozRequestFullScreen'] ||
    5145. 

  5145.                                             canvasContainer['msRequestFullscreen'] ||
    5146. 

  5146.                                            (canvasContainer['webkitRequestFullScreen'] ? function() { canvasContainer['webkitRequestFullScreen'](Element['ALLOW_KEYBOARD_INPUT']) } : null);
    5147. 

  5147.         canvasContainer.requestFullScreen();
    5148. 

  5148.       },requestAnimationFrame:function requestAnimationFrame(func) {
    5149. 

  5149.         if (typeof window === 'undefined') { // Provide fallback to setTimeout if window is undefined (e.g. in Node.js)
    5150. 

  5150.           setTimeout(func, 1000/60);
    5151. 

  5151.         } else {
    5152. 

  5152.           if (!window.requestAnimationFrame) {
    5153. 

  5153.             window.requestAnimationFrame = window['requestAnimationFrame'] ||
    5154. 

  5154.                                            window['mozRequestAnimationFrame'] ||
    5155. 

  5155.                                            window['webkitRequestAnimationFrame'] ||
    5156. 

  5156.                                            window['msRequestAnimationFrame'] ||
    5157. 

  5157.                                            window['oRequestAnimationFrame'] ||
    5158. 

  5158.                                            window['setTimeout'];
    5159. 

  5159.           }
    5160. 

  5160.           window.requestAnimationFrame(func);
    5161. 

  5161.         }
    5162. 

  5162.       },safeCallback:function (func) {
    5163. 

  5163.         return function() {
    5164. 

  5164.           if (!ABORT) return func.apply(null, arguments);
    5165. 

  5165.         };
    5166. 

  5166.       },safeRequestAnimationFrame:function (func) {
    5167. 

  5167.         return Browser.requestAnimationFrame(function() {
    5168. 

  5168.           if (!ABORT) func();
    5169. 

  5169.         });
    5170. 

  5170.       },safeSetTimeout:function (func, timeout) {
    5171. 

  5171.         return setTimeout(function() {
    5172. 

  5172.           if (!ABORT) func();
    5173. 

  5173.         }, timeout);
    5174. 

  5174.       },safeSetInterval:function (func, timeout) {
    5175. 

  5175.         return setInterval(function() {
    5176. 

  5176.           if (!ABORT) func();
    5177. 

  5177.         }, timeout);
    5178. 

  5178.       },getMimetype:function (name) {
    5179. 

  5179.         return {
    5180. 

  5180.           'jpg': 'image/jpeg',
    5181. 

  5181.           'jpeg': 'image/jpeg',
    5182. 

  5182.           'png': 'image/png',
    5183. 

  5183.           'bmp': 'image/bmp',
    5184. 

  5184.           'ogg': 'audio/ogg',
    5185. 

  5185.           'wav': 'audio/wav',
    5186. 

  5186.           'mp3': 'audio/mpeg'
    5187. 

  5187.         }[name.substr(name.lastIndexOf('.')+1)];
    5188. 

  5188.       },getUserMedia:function (func) {
    5189. 

  5189.         if(!window.getUserMedia) {
    5190. 

  5190.           window.getUserMedia = navigator['getUserMedia'] ||
    5191. 

  5191.                                 navigator['mozGetUserMedia'];
    5192. 

  5192.         }
    5193. 

  5193.         window.getUserMedia(func);
    5194. 

  5194.       },getMovementX:function (event) {
    5195. 

  5195.         return event['movementX'] ||
    5196. 

  5196.                event['mozMovementX'] ||
    5197. 

  5197.                event['webkitMovementX'] ||
    5198. 

  5198.                0;
    5199. 

  5199.       },getMovementY:function (event) {
    5200. 

  5200.         return event['movementY'] ||
    5201. 

  5201.                event['mozMovementY'] ||
    5202. 

  5202.                event['webkitMovementY'] ||
    5203. 

  5203.                0;
    5204. 

  5204.       },getMouseWheelDelta:function (event) {
    5205. 

  5205.         return Math.max(-1, Math.min(1, event.type === 'DOMMouseScroll' ? event.detail : -event.wheelDelta));
    5206. 

  5206.       },mouseX:0,mouseY:0,mouseMovementX:0,mouseMovementY:0,calculateMouseEvent:function (event) { // event should be mousemove, mousedown or mouseup
    5207. 

  5207.         if (Browser.pointerLock) {
    5208. 

  5208.           // When the pointer is locked, calculate the coordinates
    5209. 

  5209.           // based on the movement of the mouse.
    5210. 

  5210.           // Workaround for Firefox bug 764498
    5211. 

  5211.           if (event.type != 'mousemove' &&
    5212. 

  5212.               ('mozMovementX' in event)) {
    5213. 

  5213.             Browser.mouseMovementX = Browser.mouseMovementY = 0;
    5214. 

  5214.           } else {
    5215. 

  5215.             Browser.mouseMovementX = Browser.getMovementX(event);
    5216. 

  5216.             Browser.mouseMovementY = Browser.getMovementY(event);
    5217. 

  5217.           }
    5218. 

  5218. 

  5219.           // check if SDL is available
    5220. 

  5220.           if (typeof SDL != "undefined") {
    5221. 

  5221.             Browser.mouseX = SDL.mouseX + Browser.mouseMovementX;
    5222. 

  5222.             Browser.mouseY = SDL.mouseY + Browser.mouseMovementY;
    5223. 

  5223.           } else {
    5224. 

  5224.             // just add the mouse delta to the current absolut mouse position
    5225. 

  5225.             // FIXME: ideally this should be clamped against the canvas size and zero
    5226. 

  5226.             Browser.mouseX += Browser.mouseMovementX;
    5227. 

  5227.             Browser.mouseY += Browser.mouseMovementY;
    5228. 

  5228.           }
    5229. 

  5229.         } else {
    5230. 

  5230.           // Otherwise, calculate the movement based on the changes
    5231. 

  5231.           // in the coordinates.
    5232. 

  5232.           var rect = Module["canvas"].getBoundingClientRect();
    5233. 

  5233.           var x, y;
    5234. 

  5234. 

  5235.           // Neither .scrollX or .pageXOffset are defined in a spec, but
    5236. 

  5236.           // we prefer .scrollX because it is currently in a spec draft.
    5237. 

  5237.           // (see: http://www.w3.org/TR/2013/WD-cssom-view-20131217/)
    5238. 

  5238.           var scrollX = ((typeof window.scrollX !== 'undefined') ? window.scrollX : window.pageXOffset);
    5239. 

  5239.           var scrollY = ((typeof window.scrollY !== 'undefined') ? window.scrollY : window.pageYOffset);
    5240. 

  5240.           if (event.type == 'touchstart' ||
    5241. 

  5241.               event.type == 'touchend' ||
    5242. 

  5242.               event.type == 'touchmove') {
    5243. 

  5243.             var t = event.touches.item(0);
    5244. 

  5244.             if (t) {
    5245. 

  5245.               x = t.pageX - (scrollX + rect.left);
    5246. 

  5246.               y = t.pageY - (scrollY + rect.top);
    5247. 

  5247.             } else {
    5248. 

  5248.               return;
    5249. 

  5249.             }
    5250. 

  5250.           } else {
    5251. 

  5251.             x = event.pageX - (scrollX + rect.left);
    5252. 

  5252.             y = event.pageY - (scrollY + rect.top);
    5253. 

  5253.           }
    5254. 

  5254. 

  5255.           // the canvas might be CSS-scaled compared to its backbuffer;
    5256. 

  5256.           // SDL-using content will want mouse coordinates in terms
    5257. 

  5257.           // of backbuffer units.
    5258. 

  5258.           var cw = Module["canvas"].width;
    5259. 

  5259.           var ch = Module["canvas"].height;
    5260. 

  5260.           x = x * (cw / rect.width);
    5261. 

  5261.           y = y * (ch / rect.height);
    5262. 

  5262. 

  5263.           Browser.mouseMovementX = x - Browser.mouseX;
    5264. 

  5264.           Browser.mouseMovementY = y - Browser.mouseY;
    5265. 

  5265.           Browser.mouseX = x;
    5266. 

  5266.           Browser.mouseY = y;
    5267. 

  5267.         }
    5268. 

  5268.       },xhrLoad:function (url, onload, onerror) {
    5269. 

  5269.         var xhr = new XMLHttpRequest();
    5270. 

  5270.         xhr.open('GET', url, true);
    5271. 

  5271.         xhr.responseType = 'arraybuffer';
    5272. 

  5272.         xhr.onload = function xhr_onload() {
    5273. 

  5273.           if (xhr.status == 200 || (xhr.status == 0 && xhr.response)) { // file URLs can return 0
    5274. 

  5274.             onload(xhr.response);
    5275. 

  5275.           } else {
    5276. 

  5276.             onerror();
    5277. 

  5277.           }
    5278. 

  5278.         };
    5279. 

  5279.         xhr.onerror = onerror;
    5280. 

  5280.         xhr.send(null);
    5281. 

  5281.       },asyncLoad:function (url, onload, onerror, noRunDep) {
    5282. 

  5282.         Browser.xhrLoad(url, function(arrayBuffer) {
    5283. 

  5283.           assert(arrayBuffer, 'Loading data file "' + url + '" failed (no arrayBuffer).');
    5284. 

  5284.           onload(new Uint8Array(arrayBuffer));
    5285. 

  5285.           if (!noRunDep) removeRunDependency('al ' + url);
    5286. 

  5286.         }, function(event) {
    5287. 

  5287.           if (onerror) {
    5288. 

  5288.             onerror();
    5289. 

  5289.           } else {
    5290. 

  5290.             throw 'Loading data file "' + url + '" failed.';
    5291. 

  5291.           }
    5292. 

  5292.         });
    5293. 

  5293.         if (!noRunDep) addRunDependency('al ' + url);
    5294. 

  5294.       },resizeListeners:[],updateResizeListeners:function () {
    5295. 

  5295.         var canvas = Module['canvas'];
    5296. 

  5296.         Browser.resizeListeners.forEach(function(listener) {
    5297. 

  5297.           listener(canvas.width, canvas.height);
    5298. 

  5298.         });
    5299. 

  5299.       },setCanvasSize:function (width, height, noUpdates) {
    5300. 

  5300.         var canvas = Module['canvas'];
    5301. 

  5301.         Browser.updateCanvasDimensions(canvas, width, height);
    5302. 

  5302.         if (!noUpdates) Browser.updateResizeListeners();
    5303. 

  5303.       },windowedWidth:0,windowedHeight:0,setFullScreenCanvasSize:function () {
    5304. 

  5304.         // check if SDL is available
    5305. 

  5305.         if (typeof SDL != "undefined") {
    5306. 

  5306.           var flags = HEAPU32[((SDL.screen+Runtime.QUANTUM_SIZE*0)>>2)];
    5307. 

  5307.           flags = flags | 0x00800000; // set SDL_FULLSCREEN flag
    5308. 

  5308.           HEAP32[((SDL.screen+Runtime.QUANTUM_SIZE*0)>>2)]=flags
    5309. 

  5309.         }
    5310. 

  5310.         Browser.updateResizeListeners();
    5311. 

  5311.       },setWindowedCanvasSize:function () {
    5312. 

  5312.         // check if SDL is available
    5313. 

  5313.         if (typeof SDL != "undefined") {
    5314. 

  5314.           var flags = HEAPU32[((SDL.screen+Runtime.QUANTUM_SIZE*0)>>2)];
    5315. 

  5315.           flags = flags & ~0x00800000; // clear SDL_FULLSCREEN flag
    5316. 

  5316.           HEAP32[((SDL.screen+Runtime.QUANTUM_SIZE*0)>>2)]=flags
    5317. 

  5317.         }
    5318. 

  5318.         Browser.updateResizeListeners();
    5319. 

  5319.       },updateCanvasDimensions:function (canvas, wNative, hNative) {
    5320. 

  5320.         if (wNative && hNative) {
    5321. 

  5321.           canvas.widthNative = wNative;
    5322. 

  5322.           canvas.heightNative = hNative;
    5323. 

  5323.         } else {
    5324. 

  5324.           wNative = canvas.widthNative;
    5325. 

  5325.           hNative = canvas.heightNative;
    5326. 

  5326.         }
    5327. 

  5327.         var w = wNative;
    5328. 

  5328.         var h = hNative;
    5329. 

  5329.         if (Module['forcedAspectRatio'] && Module['forcedAspectRatio'] > 0) {
    5330. 

  5330.           if (w/h < Module['forcedAspectRatio']) {
    5331. 

  5331.             w = Math.round(h * Module['forcedAspectRatio']);
    5332. 

  5332.           } else {
    5333. 

  5333.             h = Math.round(w / Module['forcedAspectRatio']);
    5334. 

  5334.           }
    5335. 

  5335.         }
    5336. 

  5336.         if (((document['webkitFullScreenElement'] || document['webkitFullscreenElement'] ||
    5337. 

  5337.              document['mozFullScreenElement'] || document['mozFullscreenElement'] ||
    5338. 

  5338.              document['fullScreenElement'] || document['fullscreenElement'] ||
    5339. 

  5339.              document['msFullScreenElement'] || document['msFullscreenElement'] ||
    5340. 

  5340.              document['webkitCurrentFullScreenElement']) === canvas.parentNode) && (typeof screen != 'undefined')) {
    5341. 

  5341.            var factor = Math.min(screen.width / w, screen.height / h);
    5342. 

  5342.            w = Math.round(w * factor);
    5343. 

  5343.            h = Math.round(h * factor);
    5344. 

  5344.         }
    5345. 

  5345.         if (Browser.resizeCanvas) {
    5346. 

  5346.           if (canvas.width  != w) canvas.width  = w;
    5347. 

  5347.           if (canvas.height != h) canvas.height = h;
    5348. 

  5348.           if (typeof canvas.style != 'undefined') {
    5349. 

  5349.             canvas.style.removeProperty( "width");
    5350. 

  5350.             canvas.style.removeProperty("height");
    5351. 

  5351.           }
    5352. 

  5352.         } else {
    5353. 

  5353.           if (canvas.width  != wNative) canvas.width  = wNative;
    5354. 

  5354.           if (canvas.height != hNative) canvas.height = hNative;
    5355. 

  5355.           if (typeof canvas.style != 'undefined') {
    5356. 

  5356.             if (w != wNative || h != hNative) {
    5357. 

  5357.               canvas.style.setProperty( "width", w + "px", "important");
    5358. 

  5358.               canvas.style.setProperty("height", h + "px", "important");
    5359. 

  5359.             } else {
    5360. 

  5360.               canvas.style.removeProperty( "width");
    5361. 

  5361.               canvas.style.removeProperty("height");
    5362. 

  5362.             }
    5363. 

  5363.           }
    5364. 

  5364.         }
    5365. 

  5365.       }};
    5366. 

  5366. 

  5367.   function _log10(x) {
    5368. 

  5368.       return Math.log(x) / Math.LN10;
    5369. 

  5369.     }
    5370. 

  5370. 

  5371.   function _isspace(chr) {
    5372. 

  5372.       return (chr == 32) || (chr >= 9 && chr <= 13);
    5373. 

  5373.     }
    5374. 

  5374. 

  5375. 

  5376.   var ___tm_current=allocate(44, "i8", ALLOC_STATIC);
    5377. 

  5377. 

  5378. 

  5379.   var ___tm_timezone=allocate(intArrayFromString("GMT"), "i8", ALLOC_STATIC);function _localtime_r(time, tmPtr) {
    5380. 

  5380.       _tzset();
    5381. 

  5381.       var date = new Date(HEAP32[((time)>>2)]*1000);
    5382. 

  5382.       HEAP32[((tmPtr)>>2)]=date.getSeconds();
    5383. 

  5383.       HEAP32[(((tmPtr)+(4))>>2)]=date.getMinutes();
    5384. 

  5384.       HEAP32[(((tmPtr)+(8))>>2)]=date.getHours();
    5385. 

  5385.       HEAP32[(((tmPtr)+(12))>>2)]=date.getDate();
    5386. 

  5386.       HEAP32[(((tmPtr)+(16))>>2)]=date.getMonth();
    5387. 

  5387.       HEAP32[(((tmPtr)+(20))>>2)]=date.getFullYear()-1900;
    5388. 

  5388.       HEAP32[(((tmPtr)+(24))>>2)]=date.getDay();
    5389. 

  5389. 

  5390.       var start = new Date(date.getFullYear(), 0, 1);
    5391. 

  5391.       var yday = Math.floor((date.getTime() - start.getTime()) / (1000 * 60 * 60 * 24));
    5392. 

  5392.       HEAP32[(((tmPtr)+(28))>>2)]=yday;
    5393. 

  5393.       HEAP32[(((tmPtr)+(36))>>2)]=start.getTimezoneOffset() * 60;
    5394. 

  5394. 

  5395.       var dst = Number(start.getTimezoneOffset() != date.getTimezoneOffset());
    5396. 

  5396.       HEAP32[(((tmPtr)+(32))>>2)]=dst;
    5397. 

  5397. 

  5398.       HEAP32[(((tmPtr)+(40))>>2)]=___tm_timezone;
    5399. 

  5399. 

  5400.       return tmPtr;
    5401. 

  5401.     }function _localtime(time) {
    5402. 

  5402.       return _localtime_r(time, ___tm_current);
    5403. 

  5403.     }
    5404. 

  5404. 

  5405.   function _srand(seed) {
    5406. 

  5406.       HEAP32[((___rand_seed)>>2)]=seed
    5407. 

  5407.     }
    5408. 

  5408. 

  5409.   var _emscripten_prep_setjmp=true;
    5410. 

  5410. 

  5411. 

  5412. 

  5413. 

  5414.   Module["_testSetjmp"] = _testSetjmp;function _longjmp(env, value) {
    5415. 

  5415.       asm['setThrew'](env, value || 1);
    5416. 

  5416.       throw 'longjmp';
    5417. 

  5417.     }function _emscripten_longjmp(env, value) {
    5418. 

  5418.       _longjmp(env, value);
    5419. 

  5419.     }
    5420. 

  5420. 

  5421.   var _ceil=Math_ceil;
    5422. 

  5422. 

  5423. 

  5424.   function _emscripten_memcpy_big(dest, src, num) {
    5425. 

  5425.       HEAPU8.set(HEAPU8.subarray(src, src+num), dest);
    5426. 

  5426.       return dest;
    5427. 

  5427.     }
    5428. 

  5428.   Module["_memcpy"] = _memcpy;
    5429. 

  5429. 

  5430.   var _llvm_pow_f64=Math_pow;
    5431. 

  5431. 

  5432. 

  5433. 

  5434.   Module["_strlen"] = _strlen;function _fputs(s, stream) {
    5435. 

  5435.       // int fputs(const char *restrict s, FILE *restrict stream);
    5436. 

  5436.       // http://pubs.opengroup.org/onlinepubs/000095399/functions/fputs.html
    5437. 

  5437.       var fd = _fileno(stream);
    5438. 

  5438.       return _write(fd, s, _strlen(s));
    5439. 

  5439.     }
    5440. 

  5440. 

  5441.   function _sbrk(bytes) {
    5442. 

  5442.       // Implement a Linux-like 'memory area' for our 'process'.
    5443. 

  5443.       // Changes the size of the memory area by |bytes|; returns the
    5444. 

  5444.       // address of the previous top ('break') of the memory area
    5445. 

  5445.       // We control the "dynamic" memory - DYNAMIC_BASE to DYNAMICTOP
    5446. 

  5446.       var self = _sbrk;
    5447. 

  5447.       if (!self.called) {
    5448. 

  5448.         DYNAMICTOP = alignMemoryPage(DYNAMICTOP); // make sure we start out aligned
    5449. 

  5449.         self.called = true;
    5450. 

  5450.         assert(Runtime.dynamicAlloc);
    5451. 

  5451.         self.alloc = Runtime.dynamicAlloc;
    5452. 

  5452.         Runtime.dynamicAlloc = function() { abort('cannot dynamically allocate, sbrk now has control') };
    5453. 

  5453.       }
    5454. 

  5454.       var ret = DYNAMICTOP;
    5455. 

  5455.       if (bytes != 0) self.alloc(bytes);
    5456. 

  5456.       return ret;  // Previous break location.
    5457. 

  5457.     }
    5458. 

  5458. 

  5459. 

  5460.   function _sinh(x) {
    5461. 

  5461.       var p = Math.pow(Math.E, x);
    5462. 

  5462.       return (p - (1 / p)) / 2;
    5463. 

  5463.     }
    5464. 

  5464. 

  5465.   function _cosh(x) {
    5466. 

  5466.       var p = Math.pow(Math.E, x);
    5467. 

  5467.       return (p + (1 / p)) / 2;
    5468. 

  5468.     }function _tanh(x) {
    5469. 

  5469.       return _sinh(x) / _cosh(x);
    5470. 

  5470.     }
    5471. 

  5471. 

  5472.   function _signal(sig, func) {
    5473. 

  5473.       // TODO
    5474. 

  5474.       return 0;
    5475. 

  5475.     }
    5476. 

  5476. 

  5477. 

  5478. 

  5479.   function __getFloat(text) {
    5480. 

  5480.       return /^[+-]?[0-9]*\.?[0-9]+([eE][+-]?[0-9]+)?/.exec(text);
    5481. 

  5481.     }function __scanString(format, get, unget, varargs) {
    5482. 

  5482.       if (!__scanString.whiteSpace) {
    5483. 

  5483.         __scanString.whiteSpace = {};
    5484. 

  5484.         __scanString.whiteSpace[32] = 1;
    5485. 

  5485.         __scanString.whiteSpace[9] = 1;
    5486. 

  5486.         __scanString.whiteSpace[10] = 1;
    5487. 

  5487.         __scanString.whiteSpace[11] = 1;
    5488. 

  5488.         __scanString.whiteSpace[12] = 1;
    5489. 

  5489.         __scanString.whiteSpace[13] = 1;
    5490. 

  5490.       }
    5491. 

  5491.       // Supports %x, %4x, %d.%d, %lld, %s, %f, %lf.
    5492. 

  5492.       // TODO: Support all format specifiers.
    5493. 

  5493.       format = Pointer_stringify(format);
    5494. 

  5494.       var soFar = 0;
    5495. 

  5495.       if (format.indexOf('%n') >= 0) {
    5496. 

  5496.         // need to track soFar
    5497. 

  5497.         var _get = get;
    5498. 

  5498.         get = function get() {
    5499. 

  5499.           soFar++;
    5500. 

  5500.           return _get();
    5501. 

  5501.         }
    5502. 

  5502.         var _unget = unget;
    5503. 

  5503.         unget = function unget() {
    5504. 

  5504.           soFar--;
    5505. 

  5505.           return _unget();
    5506. 

  5506.         }
    5507. 

  5507.       }
    5508. 

  5508.       var formatIndex = 0;
    5509. 

  5509.       var argsi = 0;
    5510. 

  5510.       var fields = 0;
    5511. 

  5511.       var argIndex = 0;
    5512. 

  5512.       var next;
    5513. 

  5513. 

  5514.       mainLoop:
    5515. 

  5515.       for (var formatIndex = 0; formatIndex < format.length;) {
    5516. 

  5516.         if (format[formatIndex] === '%' && format[formatIndex+1] == 'n') {
    5517. 

  5517.           var argPtr = HEAP32[(((varargs)+(argIndex))>>2)];
    5518. 

  5518.           argIndex += Runtime.getAlignSize('void*', null, true);
    5519. 

  5519.           HEAP32[((argPtr)>>2)]=soFar;
    5520. 

  5520.           formatIndex += 2;
    5521. 

  5521.           continue;
    5522. 

  5522.         }
    5523. 

  5523. 

  5524.         if (format[formatIndex] === '%') {
    5525. 

  5525.           var nextC = format.indexOf('c', formatIndex+1);
    5526. 

  5526.           if (nextC > 0) {
    5527. 

  5527.             var maxx = 1;
    5528. 

  5528.             if (nextC > formatIndex+1) {
    5529. 

  5529.               var sub = format.substring(formatIndex+1, nextC);
    5530. 

  5530.               maxx = parseInt(sub);
    5531. 

  5531.               if (maxx != sub) maxx = 0;
    5532. 

  5532.             }
    5533. 

  5533.             if (maxx) {
    5534. 

  5534.               var argPtr = HEAP32[(((varargs)+(argIndex))>>2)];
    5535. 

  5535.               argIndex += Runtime.getAlignSize('void*', null, true);
    5536. 

  5536.               fields++;
    5537. 

  5537.               for (var i = 0; i < maxx; i++) {
    5538. 

  5538.                 next = get();
    5539. 

  5539.                 HEAP8[((argPtr++)|0)]=next;
    5540. 

  5540.                 if (next === 0) return i > 0 ? fields : fields-1; // we failed to read the full length of this field
    5541. 

  5541.               }
    5542. 

  5542.               formatIndex += nextC - formatIndex + 1;
    5543. 

  5543.               continue;
    5544. 

  5544.             }
    5545. 

  5545.           }
    5546. 

  5546.         }
    5547. 

  5547. 

  5548.         // handle %[...]
    5549. 

  5549.         if (format[formatIndex] === '%' && format.indexOf('[', formatIndex+1) > 0) {
    5550. 

  5550.           var match = /\%([0-9]*)\[(\^)?(\]?[^\]]*)\]/.exec(format.substring(formatIndex));
    5551. 

  5551.           if (match) {
    5552. 

  5552.             var maxNumCharacters = parseInt(match[1]) || Infinity;
    5553. 

  5553.             var negateScanList = (match[2] === '^');
    5554. 

  5554.             var scanList = match[3];
    5555. 

  5555. 

  5556.             // expand "middle" dashs into character sets
    5557. 

  5557.             var middleDashMatch;
    5558. 

  5558.             while ((middleDashMatch = /([^\-])\-([^\-])/.exec(scanList))) {
    5559. 

  5559.               var rangeStartCharCode = middleDashMatch[1].charCodeAt(0);
    5560. 

  5560.               var rangeEndCharCode = middleDashMatch[2].charCodeAt(0);
    5561. 

  5561.               for (var expanded = ''; rangeStartCharCode <= rangeEndCharCode; expanded += String.fromCharCode(rangeStartCharCode++));
    5562. 

  5562.               scanList = scanList.replace(middleDashMatch[1] + '-' + middleDashMatch[2], expanded);
    5563. 

  5563.             }
    5564. 

  5564. 

  5565.             var argPtr = HEAP32[(((varargs)+(argIndex))>>2)];
    5566. 

  5566.             argIndex += Runtime.getAlignSize('void*', null, true);
    5567. 

  5567.             fields++;
    5568. 

  5568. 

  5569.             for (var i = 0; i < maxNumCharacters; i++) {
    5570. 

  5570.               next = get();
    5571. 

  5571.               if (negateScanList) {
    5572. 

  5572.                 if (scanList.indexOf(String.fromCharCode(next)) < 0) {
    5573. 

  5573.                   HEAP8[((argPtr++)|0)]=next;
    5574. 

  5574.                 } else {
    5575. 

  5575.                   unget();
    5576. 

  5576.                   break;
    5577. 

  5577.                 }
    5578. 

  5578.               } else {
    5579. 

  5579.                 if (scanList.indexOf(String.fromCharCode(next)) >= 0) {
    5580. 

  5580.                   HEAP8[((argPtr++)|0)]=next;
    5581. 

  5581.                 } else {
    5582. 

  5582.                   unget();
    5583. 

  5583.                   break;
    5584. 

  5584.                 }
    5585. 

  5585.               }
    5586. 

  5586.             }
    5587. 

  5587. 

  5588.             // write out null-terminating character
    5589. 

  5589.             HEAP8[((argPtr++)|0)]=0;
    5590. 

  5590.             formatIndex += match[0].length;
    5591. 

  5591. 

  5592.             continue;
    5593. 

  5593.           }
    5594. 

  5594.         }
    5595. 

  5595.         // remove whitespace
    5596. 

  5596.         while (1) {
    5597. 

  5597.           next = get();
    5598. 

  5598.           if (next == 0) return fields;
    5599. 

  5599.           if (!(next in __scanString.whiteSpace)) break;
    5600. 

  5600.         }
    5601. 

  5601.         unget();
    5602. 

  5602. 

  5603.         if (format[formatIndex] === '%') {
    5604. 

  5604.           formatIndex++;
    5605. 

  5605.           var suppressAssignment = false;
    5606. 

  5606.           if (format[formatIndex] == '*') {
    5607. 

  5607.             suppressAssignment = true;
    5608. 

  5608.             formatIndex++;
    5609. 

  5609.           }
    5610. 

  5610.           var maxSpecifierStart = formatIndex;
    5611. 

  5611.           while (format[formatIndex].charCodeAt(0) >= 48 &&
    5612. 

  5612.                  format[formatIndex].charCodeAt(0) <= 57) {
    5613. 

  5613.             formatIndex++;
    5614. 

  5614.           }
    5615. 

  5615.           var max_;
    5616. 

  5616.           if (formatIndex != maxSpecifierStart) {
    5617. 

  5617.             max_ = parseInt(format.slice(maxSpecifierStart, formatIndex), 10);
    5618. 

  5618.           }
    5619. 

  5619.           var long_ = false;
    5620. 

  5620.           var half = false;
    5621. 

  5621.           var longLong = false;
    5622. 

  5622.           if (format[formatIndex] == 'l') {
    5623. 

  5623.             long_ = true;
    5624. 

  5624.             formatIndex++;
    5625. 

  5625.             if (format[formatIndex] == 'l') {
    5626. 

  5626.               longLong = true;
    5627. 

  5627.               formatIndex++;
    5628. 

  5628.             }
    5629. 

  5629.           } else if (format[formatIndex] == 'h') {
    5630. 

  5630.             half = true;
    5631. 

  5631.             formatIndex++;
    5632. 

  5632.           }
    5633. 

  5633.           var type = format[formatIndex];
    5634. 

  5634.           formatIndex++;
    5635. 

  5635.           var curr = 0;
    5636. 

  5636.           var buffer = [];
    5637. 

  5637.           // Read characters according to the format. floats are trickier, they may be in an unfloat state in the middle, then be a valid float later
    5638. 

  5638.           if (type == 'f' || type == 'e' || type == 'g' ||
    5639. 

  5639.               type == 'F' || type == 'E' || type == 'G') {
    5640. 

  5640.             next = get();
    5641. 

  5641.             while (next > 0 && (!(next in __scanString.whiteSpace)))  {
    5642. 

  5642.               buffer.push(String.fromCharCode(next));
    5643. 

  5643.               next = get();
    5644. 

  5644.             }
    5645. 

  5645.             var m = __getFloat(buffer.join(''));
    5646. 

  5646.             var last = m ? m[0].length : 0;
    5647. 

  5647.             for (var i = 0; i < buffer.length - last + 1; i++) {
    5648. 

  5648.               unget();
    5649. 

  5649.             }
    5650. 

  5650.             buffer.length = last;
    5651. 

  5651.           } else {
    5652. 

  5652.             next = get();
    5653. 

  5653.             var first = true;
    5654. 

  5654. 

  5655.             // Strip the optional 0x prefix for %x.
    5656. 

  5656.             if ((type == 'x' || type == 'X') && (next == 48)) {
    5657. 

  5657.               var peek = get();
    5658. 

  5658.               if (peek == 120 || peek == 88) {
    5659. 

  5659.                 next = get();
    5660. 

  5660.               } else {
    5661. 

  5661.                 unget();
    5662. 

  5662.               }
    5663. 

  5663.             }
    5664. 

  5664. 

  5665.             while ((curr < max_ || isNaN(max_)) && next > 0) {
    5666. 

  5666.               if (!(next in __scanString.whiteSpace) && // stop on whitespace
    5667. 

  5667.                   (type == 's' ||
    5668. 

  5668.                    ((type === 'd' || type == 'u' || type == 'i') && ((next >= 48 && next <= 57) ||
    5669. 

  5669.                                                                      (first && next == 45))) ||
    5670. 

  5670.                    ((type === 'x' || type === 'X') && (next >= 48 && next <= 57 ||
    5671. 

  5671.                                      next >= 97 && next <= 102 ||
    5672. 

  5672.                                      next >= 65 && next <= 70))) &&
    5673. 

  5673.                   (formatIndex >= format.length || next !== format[formatIndex].charCodeAt(0))) { // Stop when we read something that is coming up
    5674. 

  5674.                 buffer.push(String.fromCharCode(next));
    5675. 

  5675.                 next = get();
    5676. 

  5676.                 curr++;
    5677. 

  5677.                 first = false;
    5678. 

  5678.               } else {
    5679. 

  5679.                 break;
    5680. 

  5680.               }
    5681. 

  5681.             }
    5682. 

  5682.             unget();
    5683. 

  5683.           }
    5684. 

  5684.           if (buffer.length === 0) return 0;  // Failure.
    5685. 

  5685.           if (suppressAssignment) continue;
    5686. 

  5686. 

  5687.           var text = buffer.join('');
    5688. 

  5688.           var argPtr = HEAP32[(((varargs)+(argIndex))>>2)];
    5689. 

  5689.           argIndex += Runtime.getAlignSize('void*', null, true);
    5690. 

  5690.           switch (type) {
    5691. 

  5691.             case 'd': case 'u': case 'i':
    5692. 

  5692.               if (half) {
    5693. 

  5693.                 HEAP16[((argPtr)>>1)]=parseInt(text, 10);
    5694. 

  5694.               } else if (longLong) {
    5695. 

  5695.                 (tempI64 = [parseInt(text, 10)>>>0,(tempDouble=parseInt(text, 10),(+(Math_abs(tempDouble))) >= (+1) ? (tempDouble > (+0) ? ((Math_min((+(Math_floor((tempDouble)/(+4294967296)))), (+4294967295)))|0)>>>0 : (~~((+(Math_ceil((tempDouble - +(((~~(tempDouble)))>>>0))/(+4294967296))))))>>>0) : 0)],HEAP32[((argPtr)>>2)]=tempI64[0],HEAP32[(((argPtr)+(4))>>2)]=tempI64[1]);
    5696. 

  5696.               } else {
    5697. 

  5697.                 HEAP32[((argPtr)>>2)]=parseInt(text, 10);
    5698. 

  5698.               }
    5699. 

  5699.               break;
    5700. 

  5700.             case 'X':
    5701. 

  5701.             case 'x':
    5702. 

  5702.               HEAP32[((argPtr)>>2)]=parseInt(text, 16);
    5703. 

  5703.               break;
    5704. 

  5704.             case 'F':
    5705. 

  5705.             case 'f':
    5706. 

  5706.             case 'E':
    5707. 

  5707.             case 'e':
    5708. 

  5708.             case 'G':
    5709. 

  5709.             case 'g':
    5710. 

  5710.             case 'E':
    5711. 

  5711.               // fallthrough intended
    5712. 

  5712.               if (long_) {
    5713. 

  5713.                 HEAPF64[((argPtr)>>3)]=parseFloat(text);
    5714. 

  5714.               } else {
    5715. 

  5715.                 HEAPF32[((argPtr)>>2)]=parseFloat(text);
    5716. 

  5716.               }
    5717. 

  5717.               break;
    5718. 

  5718.             case 's':
    5719. 

  5719.               var array = intArrayFromString(text);
    5720. 

  5720.               for (var j = 0; j < array.length; j++) {
    5721. 

  5721.                 HEAP8[(((argPtr)+(j))|0)]=array[j];
    5722. 

  5722.               }
    5723. 

  5723.               break;
    5724. 

  5724.           }
    5725. 

  5725.           fields++;
    5726. 

  5726.         } else if (format[formatIndex].charCodeAt(0) in __scanString.whiteSpace) {
    5727. 

  5727.           next = get();
    5728. 

  5728.           while (next in __scanString.whiteSpace) {
    5729. 

  5729.             if (next <= 0) break mainLoop;  // End of input.
    5730. 

  5730.             next = get();
    5731. 

  5731.           }
    5732. 

  5732.           unget(next);
    5733. 

  5733.           formatIndex++;
    5734. 

  5734.         } else {
    5735. 

  5735.           // Not a specifier.
    5736. 

  5736.           next = get();
    5737. 

  5737.           if (format[formatIndex].charCodeAt(0) !== next) {
    5738. 

  5738.             unget(next);
    5739. 

  5739.             break mainLoop;
    5740. 

  5740.           }
    5741. 

  5741.           formatIndex++;
    5742. 

  5742.         }
    5743. 

  5743.       }
    5744. 

  5744.       return fields;
    5745. 

  5745.     }
    5746. 

  5746. 

  5747.   function _fgetc(stream) {
    5748. 

  5748.       // int fgetc(FILE *stream);
    5749. 

  5749.       // http://pubs.opengroup.org/onlinepubs/000095399/functions/fgetc.html
    5750. 

  5750.       var streamObj = FS.getStreamFromPtr(stream);
    5751. 

  5751.       if (!streamObj) return -1;
    5752. 

  5752.       if (streamObj.eof || streamObj.error) return -1;
    5753. 

  5753.       var ret = _fread(_fgetc.ret, 1, 1, stream);
    5754. 

  5754.       if (ret == 0) {
    5755. 

  5755.         return -1;
    5756. 

  5756.       } else if (ret == -1) {
    5757. 

  5757.         streamObj.error = true;
    5758. 

  5758.         return -1;
    5759. 

  5759.       } else {
    5760. 

  5760.         return HEAPU8[((_fgetc.ret)|0)];
    5761. 

  5761.       }
    5762. 

  5762.     }
    5763. 

  5763. 

  5764.   function _ungetc(c, stream) {
    5765. 

  5765.       // int ungetc(int c, FILE *stream);
    5766. 

  5766.       // http://pubs.opengroup.org/onlinepubs/000095399/functions/ungetc.html
    5767. 

  5767.       stream = FS.getStreamFromPtr(stream);
    5768. 

  5768.       if (!stream) {
    5769. 

  5769.         return -1;
    5770. 

  5770.       }
    5771. 

  5771.       if (c === -1) {
    5772. 

  5772.         // do nothing for EOF character
    5773. 

  5773.         return c;
    5774. 

  5774.       }
    5775. 

  5775.       c = unSign(c & 0xFF);
    5776. 

  5776.       stream.ungotten.push(c);
    5777. 

  5777.       stream.eof = false;
    5778. 

  5778.       return c;
    5779. 

  5779.     }function _fscanf(stream, format, varargs) {
    5780. 

  5780.       // int fscanf(FILE *restrict stream, const char *restrict format, ... );
    5781. 

  5781.       // http://pubs.opengroup.org/onlinepubs/000095399/functions/scanf.html
    5782. 

  5782.       var streamObj = FS.getStreamFromPtr(stream);
    5783. 

  5783.       if (!streamObj) {
    5784. 

  5784.         return -1;
    5785. 

  5785.       }
    5786. 

  5786.       var buffer = [];
    5787. 

  5787.       function get() {
    5788. 

  5788.         var c = _fgetc(stream);
    5789. 

  5789.         buffer.push(c);
    5790. 

  5790.         return c;
    5791. 

  5791.       };
    5792. 

  5792.       function unget() {
    5793. 

  5793.         _ungetc(buffer.pop(), stream);
    5794. 

  5794.       };
    5795. 

  5795.       return __scanString(format, get, unget, varargs);
    5796. 

  5796.     }
    5797. 

  5797. 

  5798.   var _emscripten_preinvoke=true;
    5799. 

  5799. 

  5800.   function _localeconv() {
    5801. 

  5801.       // %struct.timeval = type { char* decimal point, other stuff... }
    5802. 

  5802.       // var indexes = Runtime.calculateStructAlignment({ fields: ['i32', 'i32'] });
    5803. 

  5803.       var me = _localeconv;
    5804. 

  5804.       if (!me.ret) {
    5805. 

  5805.       // These are defaults from the "C" locale
    5806. 

  5806.         me.ret = allocate([
    5807. 

  5807.           allocate(intArrayFromString('.'), 'i8', ALLOC_NORMAL),0,0,0, // decimal_point
    5808. 

  5808.           allocate(intArrayFromString(''), 'i8', ALLOC_NORMAL),0,0,0, // thousands_sep
    5809. 

  5809.           allocate(intArrayFromString(''), 'i8', ALLOC_NORMAL),0,0,0, // grouping
    5810. 

  5810.           allocate(intArrayFromString(''), 'i8', ALLOC_NORMAL),0,0,0, // int_curr_symbol
    5811. 

  5811.           allocate(intArrayFromString(''), 'i8', ALLOC_NORMAL),0,0,0, // currency_symbol
    5812. 

  5812.           allocate(intArrayFromString(''), 'i8', ALLOC_NORMAL),0,0,0, // mon_decimal_point
    5813. 

  5813.           allocate(intArrayFromString(''), 'i8', ALLOC_NORMAL),0,0,0, // mon_thousands_sep
    5814. 

  5814.           allocate(intArrayFromString(''), 'i8', ALLOC_NORMAL),0,0,0, // mon_grouping
    5815. 

  5815.           allocate(intArrayFromString(''), 'i8', ALLOC_NORMAL),0,0,0, // positive_sign
    5816. 

  5816.           allocate(intArrayFromString(''), 'i8', ALLOC_NORMAL),0,0,0 // negative_sign
    5817. 

  5817.         ], 'i8*', ALLOC_NORMAL); // Allocate strings in lconv, still don't allocate chars
    5818. 

  5818.       }
    5819. 

  5819.       return me.ret;
    5820. 

  5820.     }
    5821. 

  5821. 

  5822. 

  5823.   function _unlink(path) {
    5824. 

  5824.       // int unlink(const char *path);
    5825. 

  5825.       // http://pubs.opengroup.org/onlinepubs/000095399/functions/unlink.html
    5826. 

  5826.       path = Pointer_stringify(path);
    5827. 

  5827.       try {
    5828. 

  5828.         FS.unlink(path);
    5829. 

  5829.         return 0;
    5830. 

  5830.       } catch (e) {
    5831. 

  5831.         FS.handleFSError(e);
    5832. 

  5832.         return -1;
    5833. 

  5833.       }
    5834. 

  5834.     }
    5835. 

  5835. 

  5836.   function _rmdir(path) {
    5837. 

  5837.       // int rmdir(const char *path);
    5838. 

  5838.       // http://pubs.opengroup.org/onlinepubs/000095399/functions/rmdir.html
    5839. 

  5839.       path = Pointer_stringify(path);
    5840. 

  5840.       try {
    5841. 

  5841.         FS.rmdir(path);
    5842. 

  5842.         return 0;
    5843. 

  5843.       } catch (e) {
    5844. 

  5844.         FS.handleFSError(e);
    5845. 

  5845.         return -1;
    5846. 

  5846.       }
    5847. 

  5847.     }function _remove(path) {
    5848. 

  5848.       // int remove(const char *path);
    5849. 

  5849.       // http://pubs.opengroup.org/onlinepubs/000095399/functions/remove.html
    5850. 

  5850.       var ret = _unlink(path);
    5851. 

  5851.       if (ret == -1) ret = _rmdir(path);
    5852. 

  5852.       return ret;
    5853. 

  5853.     }
    5854. 

  5854. 

  5855.   function _freopen(filename, mode, stream) {
    5856. 

  5856.       // FILE *freopen(const char *restrict filename, const char *restrict mode, FILE *restrict stream);
    5857. 

  5857.       // http://pubs.opengroup.org/onlinepubs/000095399/functions/freopen.html
    5858. 

  5858.       if (!filename) {
    5859. 

  5859.         var streamObj = FS.getStreamFromPtr(stream);
    5860. 

  5860.         if (!streamObj) {
    5861. 

  5861.           ___setErrNo(ERRNO_CODES.EBADF);
    5862. 

  5862.           return 0;
    5863. 

  5863.         }
    5864. 

  5864.         if (_freopen.buffer) _free(_freopen.buffer);
    5865. 

  5865.         filename = intArrayFromString(streamObj.path);
    5866. 

  5866.         filename = allocate(filename, 'i8', ALLOC_NORMAL);
    5867. 

  5867.       }
    5868. 

  5868.       _fclose(stream);
    5869. 

  5869.       return _fopen(filename, mode);
    5870. 

  5870.     }
    5871. 

  5871. 

  5872. 

  5873.   function _rename(old_path, new_path) {
    5874. 

  5874.       // int rename(const char *old, const char *new);
    5875. 

  5875.       // http://pubs.opengroup.org/onlinepubs/000095399/functions/rename.html
    5876. 

  5876.       old_path = Pointer_stringify(old_path);
    5877. 

  5877.       new_path = Pointer_stringify(new_path);
    5878. 

  5878.       try {
    5879. 

  5879.         FS.rename(old_path, new_path);
    5880. 

  5880.         return 0;
    5881. 

  5881.       } catch (e) {
    5882. 

  5882.         FS.handleFSError(e);
    5883. 

  5883.         return -1;
    5884. 

  5884.       }
    5885. 

  5885.     }
    5886. 

  5886. 

  5887.   function _tmpfile() {
    5888. 

  5888.       // FILE *tmpfile(void);
    5889. 

  5889.       // http://pubs.opengroup.org/onlinepubs/000095399/functions/tmpfile.html
    5890. 

  5890.       // TODO: Delete the created file on closing.
    5891. 

  5891.       if (_tmpfile.mode) {
    5892. 

  5892.         _tmpfile.mode = allocate(intArrayFromString('w+'), 'i8', ALLOC_NORMAL);
    5893. 

  5893.       }
    5894. 

  5894.       return _fopen(_tmpnam(0), _tmpfile.mode);
    5895. 

  5895.     }
    5896. 

  5896. 

  5897.   function _sysconf(name) {
    5898. 

  5898.       // long sysconf(int name);
    5899. 

  5899.       // http://pubs.opengroup.org/onlinepubs/009695399/functions/sysconf.html
    5900. 

  5900.       switch(name) {
    5901. 

  5901.         case 30: return PAGE_SIZE;
    5902. 

  5902.         case 132:
    5903. 

  5903.         case 133:
    5904. 

  5904.         case 12:
    5905. 

  5905.         case 137:
    5906. 

  5906.         case 138:
    5907. 

  5907.         case 15:
    5908. 

  5908.         case 235:
    5909. 

  5909.         case 16:
    5910. 

  5910.         case 17:
    5911. 

  5911.         case 18:
    5912. 

  5912.         case 19:
    5913. 

  5913.         case 20:
    5914. 

  5914.         case 149:
    5915. 

  5915.         case 13:
    5916. 

  5916.         case 10:
    5917. 

  5917.         case 236:
    5918. 

  5918.         case 153:
    5919. 

  5919.         case 9:
    5920. 

  5920.         case 21:
    5921. 

  5921.         case 22:
    5922. 

  5922.         case 159:
    5923. 

  5923.         case 154:
    5924. 

  5924.         case 14:
    5925. 

  5925.         case 77:
    5926. 

  5926.         case 78:
    5927. 

  5927.         case 139:
    5928. 

  5928.         case 80:
    5929. 

  5929.         case 81:
    5930. 

  5930.         case 79:
    5931. 

  5931.         case 82:
    5932. 

  5932.         case 68:
    5933. 

  5933.         case 67:
    5934. 

  5934.         case 164:
    5935. 

  5935.         case 11:
    5936. 

  5936.         case 29:
    5937. 

  5937.         case 47:
    5938. 

  5938.         case 48:
    5939. 

  5939.         case 95:
    5940. 

  5940.         case 52:
    5941. 

  5941.         case 51:
    5942. 

  5942.         case 46:
    5943. 

  5943.           return 200809;
    5944. 

  5944.         case 27:
    5945. 

  5945.         case 246:
    5946. 

  5946.         case 127:
    5947. 

  5947.         case 128:
    5948. 

  5948.         case 23:
    5949. 

  5949.         case 24:
    5950. 

  5950.         case 160:
    5951. 

  5951.         case 161:
    5952. 

  5952.         case 181:
    5953. 

  5953.         case 182:
    5954. 

  5954.         case 242:
    5955. 

  5955.         case 183:
    5956. 

  5956.         case 184:
    5957. 

  5957.         case 243:
    5958. 

  5958.         case 244:
    5959. 

  5959.         case 245:
    5960. 

  5960.         case 165:
    5961. 

  5961.         case 178:
    5962. 

  5962.         case 179:
    5963. 

  5963.         case 49:
    5964. 

  5964.         case 50:
    5965. 

  5965.         case 168:
    5966. 

  5966.         case 169:
    5967. 

  5967.         case 175:
    5968. 

  5968.         case 170:
    5969. 

  5969.         case 171:
    5970. 

  5970.         case 172:
    5971. 

  5971.         case 97:
    5972. 

  5972.         case 76:
    5973. 

  5973.         case 32:
    5974. 

  5974.         case 173:
    5975. 

  5975.         case 35:
    5976. 

  5976.           return -1;
    5977. 

  5977.         case 176:
    5978. 

  5978.         case 177:
    5979. 

  5979.         case 7:
    5980. 

  5980.         case 155:
    5981. 

  5981.         case 8:
    5982. 

  5982.         case 157:
    5983. 

  5983.         case 125:
    5984. 

  5984.         case 126:
    5985. 

  5985.         case 92:
    5986. 

  5986.         case 93:
    5987. 

  5987.         case 129:
    5988. 

  5988.         case 130:
    5989. 

  5989.         case 131:
    5990. 

  5990.         case 94:
    5991. 

  5991.         case 91:
    5992. 

  5992.           return 1;
    5993. 

  5993.         case 74:
    5994. 

  5994.         case 60:
    5995. 

  5995.         case 69:
    5996. 

  5996.         case 70:
    5997. 

  5997.         case 4:
    5998. 

  5998.           return 1024;
    5999. 

  5999.         case 31:
    6000. 

  6000.         case 42:
    6001. 

  6001.         case 72:
    6002. 

  6002.           return 32;
    6003. 

  6003.         case 87:
    6004. 

  6004.         case 26:
    6005. 

  6005.         case 33:
    6006. 

  6006.           return 2147483647;
    6007. 

  6007.         case 34:
    6008. 

  6008.         case 1:
    6009. 

  6009.           return 47839;
    6010. 

  6010.         case 38:
    6011. 

  6011.         case 36:
    6012. 

  6012.           return 99;
    6013. 

  6013.         case 43:
    6014. 

  6014.         case 37:
    6015. 

  6015.           return 2048;
    6016. 

  6016.         case 0: return 2097152;
    6017. 

  6017.         case 3: return 65536;
    6018. 

  6018.         case 28: return 32768;
    6019. 

  6019.         case 44: return 32767;
    6020. 

  6020.         case 75: return 16384;
    6021. 

  6021.         case 39: return 1000;
    6022. 

  6022.         case 89: return 700;
    6023. 

  6023.         case 71: return 256;
    6024. 

  6024.         case 40: return 255;
    6025. 

  6025.         case 2: return 100;
    6026. 

  6026.         case 180: return 64;
    6027. 

  6027.         case 25: return 20;
    6028. 

  6028.         case 5: return 16;
    6029. 

  6029.         case 6: return 6;
    6030. 

  6030.         case 73: return 4;
    6031. 

  6031.         case 84: return 1;
    6032. 

  6032.       }
    6033. 

  6033.       ___setErrNo(ERRNO_CODES.EINVAL);
    6034. 

  6034.       return -1;
    6035. 

  6035.     }
    6036. 

  6036. 

  6037. 

  6038.   function ___errno_location() {
    6039. 

  6039.       return ___errno_state;
    6040. 

  6040.     }
    6041. 

  6041. 

  6042. 

  6043.   Module["_memset"] = _memset;
    6044. 

  6044. 

  6045. 

  6046. 

  6047.   Module["_bitshift64Shl"] = _bitshift64Shl;
    6048. 

  6048. 

  6049.   function _abort() {
    6050. 

  6050.       Module['abort']();
    6051. 

  6051.     }
    6052. 

  6052. 

  6053. 

  6054. 

  6055.   function __reallyNegative(x) {
    6056. 

  6056.       return x < 0 || (x === 0 && (1/x) === -Infinity);
    6057. 

  6057.     }function __formatString(format, varargs) {
    6058. 

  6058.       var textIndex = format;
    6059. 

  6059.       var argIndex = 0;
    6060. 

  6060.       function getNextArg(type) {
    6061. 

  6061.         // NOTE: Explicitly ignoring type safety. Otherwise this fails:
    6062. 

  6062.         //       int x = 4; printf("%c\n", (char)x);
    6063. 

  6063.         var ret;
    6064. 

  6064.         if (type === 'double') {
    6065. 

  6065.           ret = HEAPF64[(((varargs)+(argIndex))>>3)];
    6066. 

  6066.         } else if (type == 'i64') {
    6067. 

  6067.           ret = [HEAP32[(((varargs)+(argIndex))>>2)],
    6068. 

  6068.                  HEAP32[(((varargs)+(argIndex+4))>>2)]];
    6069. 

  6069. 

  6070.         } else {
    6071. 

  6071.           type = 'i32'; // varargs are always i32, i64, or double
    6072. 

  6072.           ret = HEAP32[(((varargs)+(argIndex))>>2)];
    6073. 

  6073.         }
    6074. 

  6074.         argIndex += Runtime.getNativeFieldSize(type);
    6075. 

  6075.         return ret;
    6076. 

  6076.       }
    6077. 

  6077. 

  6078.       var ret = [];
    6079. 

  6079.       var curr, next, currArg;
    6080. 

  6080.       while(1) {
    6081. 

  6081.         var startTextIndex = textIndex;
    6082. 

  6082.         curr = HEAP8[(textIndex)];
    6083. 

  6083.         if (curr === 0) break;
    6084. 

  6084.         next = HEAP8[((textIndex+1)|0)];
    6085. 

  6085.         if (curr == 37) {
    6086. 

  6086.           // Handle flags.
    6087. 

  6087.           var flagAlwaysSigned = false;
    6088. 

  6088.           var flagLeftAlign = false;
    6089. 

  6089.           var flagAlternative = false;
    6090. 

  6090.           var flagZeroPad = false;
    6091. 

  6091.           var flagPadSign = false;
    6092. 

  6092.           flagsLoop: while (1) {
    6093. 

  6093.             switch (next) {
    6094. 

  6094.               case 43:
    6095. 

  6095.                 flagAlwaysSigned = true;
    6096. 

  6096.                 break;
    6097. 

  6097.               case 45:
    6098. 

  6098.                 flagLeftAlign = true;
    6099. 

  6099.                 break;
    6100. 

  6100.               case 35:
    6101. 

  6101.                 flagAlternative = true;
    6102. 

  6102.                 break;
    6103. 

  6103.               case 48:
    6104. 

  6104.                 if (flagZeroPad) {
    6105. 

  6105.                   break flagsLoop;
    6106. 

  6106.                 } else {
    6107. 

  6107.                   flagZeroPad = true;
    6108. 

  6108.                   break;
    6109. 

  6109.                 }
    6110. 

  6110.               case 32:
    6111. 

  6111.                 flagPadSign = true;
    6112. 

  6112.                 break;
    6113. 

  6113.               default:
    6114. 

  6114.                 break flagsLoop;
    6115. 

  6115.             }
    6116. 

  6116.             textIndex++;
    6117. 

  6117.             next = HEAP8[((textIndex+1)|0)];
    6118. 

  6118.           }
    6119. 

  6119. 

  6120.           // Handle width.
    6121. 

  6121.           var width = 0;
    6122. 

  6122.           if (next == 42) {
    6123. 

  6123.             width = getNextArg('i32');
    6124. 

  6124.             textIndex++;
    6125. 

  6125.             next = HEAP8[((textIndex+1)|0)];
    6126. 

  6126.           } else {
    6127. 

  6127.             while (next >= 48 && next <= 57) {
    6128. 

  6128.               width = width * 10 + (next - 48);
    6129. 

  6129.               textIndex++;
    6130. 

  6130.               next = HEAP8[((textIndex+1)|0)];
    6131. 

  6131.             }
    6132. 

  6132.           }
    6133. 

  6133. 

  6134.           // Handle precision.
    6135. 

  6135.           var precisionSet = false, precision = -1;
    6136. 

  6136.           if (next == 46) {
    6137. 

  6137.             precision = 0;
    6138. 

  6138.             precisionSet = true;
    6139. 

  6139.             textIndex++;
    6140. 

  6140.             next = HEAP8[((textIndex+1)|0)];
    6141. 

  6141.             if (next == 42) {
    6142. 

  6142.               precision = getNextArg('i32');
    6143. 

  6143.               textIndex++;
    6144. 

  6144.             } else {
    6145. 

  6145.               while(1) {
    6146. 

  6146.                 var precisionChr = HEAP8[((textIndex+1)|0)];
    6147. 

  6147.                 if (precisionChr < 48 ||
    6148. 

  6148.                     precisionChr > 57) break;
    6149. 

  6149.                 precision = precision * 10 + (precisionChr - 48);
    6150. 

  6150.                 textIndex++;
    6151. 

  6151.               }
    6152. 

  6152.             }
    6153. 

  6153.             next = HEAP8[((textIndex+1)|0)];
    6154. 

  6154.           }
    6155. 

  6155.           if (precision < 0) {
    6156. 

  6156.             precision = 6; // Standard default.
    6157. 

  6157.             precisionSet = false;
    6158. 

  6158.           }
    6159. 

  6159. 

  6160.           // Handle integer sizes. WARNING: These assume a 32-bit architecture!
    6161. 

  6161.           var argSize;
    6162. 

  6162.           switch (String.fromCharCode(next)) {
    6163. 

  6163.             case 'h':
    6164. 

  6164.               var nextNext = HEAP8[((textIndex+2)|0)];
    6165. 

  6165.               if (nextNext == 104) {
    6166. 

  6166.                 textIndex++;
    6167. 

  6167.                 argSize = 1; // char (actually i32 in varargs)
    6168. 

  6168.               } else {
    6169. 

  6169.                 argSize = 2; // short (actually i32 in varargs)
    6170. 

  6170.               }
    6171. 

  6171.               break;
    6172. 

  6172.             case 'l':
    6173. 

  6173.               var nextNext = HEAP8[((textIndex+2)|0)];
    6174. 

  6174.               if (nextNext == 108) {
    6175. 

  6175.                 textIndex++;
    6176. 

  6176.                 argSize = 8; // long long
    6177. 

  6177.               } else {
    6178. 

  6178.                 argSize = 4; // long
    6179. 

  6179.               }
    6180. 

  6180.               break;
    6181. 

  6181.             case 'L': // long long
    6182. 

  6182.             case 'q': // int64_t
    6183. 

  6183.             case 'j': // intmax_t
    6184. 

  6184.               argSize = 8;
    6185. 

  6185.               break;
    6186. 

  6186.             case 'z': // size_t
    6187. 

  6187.             case 't': // ptrdiff_t
    6188. 

  6188.             case 'I': // signed ptrdiff_t or unsigned size_t
    6189. 

  6189.               argSize = 4;
    6190. 

  6190.               break;
    6191. 

  6191.             default:
    6192. 

  6192.               argSize = null;
    6193. 

  6193.           }
    6194. 

  6194.           if (argSize) textIndex++;
    6195. 

  6195.           next = HEAP8[((textIndex+1)|0)];
    6196. 

  6196. 

  6197.           // Handle type specifier.
    6198. 

  6198.           switch (String.fromCharCode(next)) {
    6199. 

  6199.             case 'd': case 'i': case 'u': case 'o': case 'x': case 'X': case 'p': {
    6200. 

  6200.               // Integer.
    6201. 

  6201.               var signed = next == 100 || next == 105;
    6202. 

  6202.               argSize = argSize || 4;
    6203. 

  6203.               var currArg = getNextArg('i' + (argSize * 8));
    6204. 

  6204.               var origArg = currArg;
    6205. 

  6205.               var argText;
    6206. 

  6206.               // Flatten i64-1 [low, high] into a (slightly rounded) double
    6207. 

  6207.               if (argSize == 8) {
    6208. 

  6208.                 currArg = Runtime.makeBigInt(currArg[0], currArg[1], next == 117);
    6209. 

  6209.               }
    6210. 

  6210.               // Truncate to requested size.
    6211. 

  6211.               if (argSize <= 4) {
    6212. 

  6212.                 var limit = Math.pow(256, argSize) - 1;
    6213. 

  6213.                 currArg = (signed ? reSign : unSign)(currArg & limit, argSize * 8);
    6214. 

  6214.               }
    6215. 

  6215.               // Format the number.
    6216. 

  6216.               var currAbsArg = Math.abs(currArg);
    6217. 

  6217.               var prefix = '';
    6218. 

  6218.               if (next == 100 || next == 105) {
    6219. 

  6219.                 if (argSize == 8 && i64Math) argText = i64Math.stringify(origArg[0], origArg[1], null); else
    6220. 

  6220.                 argText = reSign(currArg, 8 * argSize, 1).toString(10);
    6221. 

  6221.               } else if (next == 117) {
    6222. 

  6222.                 if (argSize == 8 && i64Math) argText = i64Math.stringify(origArg[0], origArg[1], true); else
    6223. 

  6223.                 argText = unSign(currArg, 8 * argSize, 1).toString(10);
    6224. 

  6224.                 currArg = Math.abs(currArg);
    6225. 

  6225.               } else if (next == 111) {
    6226. 

  6226.                 argText = (flagAlternative ? '0' : '') + currAbsArg.toString(8);
    6227. 

  6227.               } else if (next == 120 || next == 88) {
    6228. 

  6228.                 prefix = (flagAlternative && currArg != 0) ? '0x' : '';
    6229. 

  6229.                 if (argSize == 8 && i64Math) {
    6230. 

  6230.                   if (origArg[1]) {
    6231. 

  6231.                     argText = (origArg[1]>>>0).toString(16);
    6232. 

  6232.                     var lower = (origArg[0]>>>0).toString(16);
    6233. 

  6233.                     while (lower.length < 8) lower = '0' + lower;
    6234. 

  6234.                     argText += lower;
    6235. 

  6235.                   } else {
    6236. 

  6236.                     argText = (origArg[0]>>>0).toString(16);
    6237. 

  6237.                   }
    6238. 

  6238.                 } else
    6239. 

  6239.                 if (currArg < 0) {
    6240. 

  6240.                   // Represent negative numbers in hex as 2's complement.
    6241. 

  6241.                   currArg = -currArg;
    6242. 

  6242.                   argText = (currAbsArg - 1).toString(16);
    6243. 

  6243.                   var buffer = [];
    6244. 

  6244.                   for (var i = 0; i < argText.length; i++) {
    6245. 

  6245.                     buffer.push((0xF - parseInt(argText[i], 16)).toString(16));
    6246. 

  6246.                   }
    6247. 

  6247.                   argText = buffer.join('');
    6248. 

  6248.                   while (argText.length < argSize * 2) argText = 'f' + argText;
    6249. 

  6249.                 } else {
    6250. 

  6250.                   argText = currAbsArg.toString(16);
    6251. 

  6251.                 }
    6252. 

  6252.                 if (next == 88) {
    6253. 

  6253.                   prefix = prefix.toUpperCase();
    6254. 

  6254.                   argText = argText.toUpperCase();
    6255. 

  6255.                 }
    6256. 

  6256.               } else if (next == 112) {
    6257. 

  6257.                 if (currAbsArg === 0) {
    6258. 

  6258.                   argText = '(nil)';
    6259. 

  6259.                 } else {
    6260. 

  6260.                   prefix = '0x';
    6261. 

  6261.                   argText = currAbsArg.toString(16);
    6262. 

  6262.                 }
    6263. 

  6263.               }
    6264. 

  6264.               if (precisionSet) {
    6265. 

  6265.                 while (argText.length < precision) {
    6266. 

  6266.                   argText = '0' + argText;
    6267. 

  6267.                 }
    6268. 

  6268.               }
    6269. 

  6269. 

  6270.               // Add sign if needed
    6271. 

  6271.               if (currArg >= 0) {
    6272. 

  6272.                 if (flagAlwaysSigned) {
    6273. 

  6273.                   prefix = '+' + prefix;
    6274. 

  6274.                 } else if (flagPadSign) {
    6275. 

  6275.                   prefix = ' ' + prefix;
    6276. 

  6276.                 }
    6277. 

  6277.               }
    6278. 

  6278. 

  6279.               // Move sign to prefix so we zero-pad after the sign
    6280. 

  6280.               if (argText.charAt(0) == '-') {
    6281. 

  6281.                 prefix = '-' + prefix;
    6282. 

  6282.                 argText = argText.substr(1);
    6283. 

  6283.               }
    6284. 

  6284. 

  6285.               // Add padding.
    6286. 

  6286.               while (prefix.length + argText.length < width) {
    6287. 

  6287.                 if (flagLeftAlign) {
    6288. 

  6288.                   argText += ' ';
    6289. 

  6289.                 } else {
    6290. 

  6290.                   if (flagZeroPad) {
    6291. 

  6291.                     argText = '0' + argText;
    6292. 

  6292.                   } else {
    6293. 

  6293.                     prefix = ' ' + prefix;
    6294. 

  6294.                   }
    6295. 

  6295.                 }
    6296. 

  6296.               }
    6297. 

  6297. 

  6298.               // Insert the result into the buffer.
    6299. 

  6299.               argText = prefix + argText;
    6300. 

  6300.               argText.split('').forEach(function(chr) {
    6301. 

  6301.                 ret.push(chr.charCodeAt(0));
    6302. 

  6302.               });
    6303. 

  6303.               break;
    6304. 

  6304.             }
    6305. 

  6305.             case 'f': case 'F': case 'e': case 'E': case 'g': case 'G': {
    6306. 

  6306.               // Float.
    6307. 

  6307.               var currArg = getNextArg('double');
    6308. 

  6308.               var argText;
    6309. 

  6309.               if (isNaN(currArg)) {
    6310. 

  6310.                 argText = 'nan';
    6311. 

  6311.                 flagZeroPad = false;
    6312. 

  6312.               } else if (!isFinite(currArg)) {
    6313. 

  6313.                 argText = (currArg < 0 ? '-' : '') + 'inf';
    6314. 

  6314.                 flagZeroPad = false;
    6315. 

  6315.               } else {
    6316. 

  6316.                 var isGeneral = false;
    6317. 

  6317.                 var effectivePrecision = Math.min(precision, 20);
    6318. 

  6318. 

  6319.                 // Convert g/G to f/F or e/E, as per:
    6320. 

  6320.                 // http://pubs.opengroup.org/onlinepubs/9699919799/functions/printf.html
    6321. 

  6321.                 if (next == 103 || next == 71) {
    6322. 

  6322.                   isGeneral = true;
    6323. 

  6323.                   precision = precision || 1;
    6324. 

  6324.                   var exponent = parseInt(currArg.toExponential(effectivePrecision).split('e')[1], 10);
    6325. 

  6325.                   if (precision > exponent && exponent >= -4) {
    6326. 

  6326.                     next = ((next == 103) ? 'f' : 'F').charCodeAt(0);
    6327. 

  6327.                     precision -= exponent + 1;
    6328. 

  6328.                   } else {
    6329. 

  6329.                     next = ((next == 103) ? 'e' : 'E').charCodeAt(0);
    6330. 

  6330.                     precision--;
    6331. 

  6331.                   }
    6332. 

  6332.                   effectivePrecision = Math.min(precision, 20);
    6333. 

  6333.                 }
    6334. 

  6334. 

  6335.                 if (next == 101 || next == 69) {
    6336. 

  6336.                   argText = currArg.toExponential(effectivePrecision);
    6337. 

  6337.                   // Make sure the exponent has at least 2 digits.
    6338. 

  6338.                   if (/[eE][-+]\d$/.test(argText)) {
    6339. 

  6339.                     argText = argText.slice(0, -1) + '0' + argText.slice(-1);
    6340. 

  6340.                   }
    6341. 

  6341.                 } else if (next == 102 || next == 70) {
    6342. 

  6342.                   argText = currArg.toFixed(effectivePrecision);
    6343. 

  6343.                   if (currArg === 0 && __reallyNegative(currArg)) {
    6344. 

  6344.                     argText = '-' + argText;
    6345. 

  6345.                   }
    6346. 

  6346.                 }
    6347. 

  6347. 

  6348.                 var parts = argText.split('e');
    6349. 

  6349.                 if (isGeneral && !flagAlternative) {
    6350. 

  6350.                   // Discard trailing zeros and periods.
    6351. 

  6351.                   while (parts[0].length > 1 && parts[0].indexOf('.') != -1 &&
    6352. 

  6352.                          (parts[0].slice(-1) == '0' || parts[0].slice(-1) == '.')) {
    6353. 

  6353.                     parts[0] = parts[0].slice(0, -1);
    6354. 

  6354.                   }
    6355. 

  6355.                 } else {
    6356. 

  6356.                   // Make sure we have a period in alternative mode.
    6357. 

  6357.                   if (flagAlternative && argText.indexOf('.') == -1) parts[0] += '.';
    6358. 

  6358.                   // Zero pad until required precision.
    6359. 

  6359.                   while (precision > effectivePrecision++) parts[0] += '0';
    6360. 

  6360.                 }
    6361. 

  6361.                 argText = parts[0] + (parts.length > 1 ? 'e' + parts[1] : '');
    6362. 

  6362. 

  6363.                 // Capitalize 'E' if needed.
    6364. 

  6364.                 if (next == 69) argText = argText.toUpperCase();
    6365. 

  6365. 

  6366.                 // Add sign.
    6367. 

  6367.                 if (currArg >= 0) {
    6368. 

  6368.                   if (flagAlwaysSigned) {
    6369. 

  6369.                     argText = '+' + argText;
    6370. 

  6370.                   } else if (flagPadSign) {
    6371. 

  6371.                     argText = ' ' + argText;
    6372. 

  6372.                   }
    6373. 

  6373.                 }
    6374. 

  6374.               }
    6375. 

  6375. 

  6376.               // Add padding.
    6377. 

  6377.               while (argText.length < width) {
    6378. 

  6378.                 if (flagLeftAlign) {
    6379. 

  6379.                   argText += ' ';
    6380. 

  6380.                 } else {
    6381. 

  6381.                   if (flagZeroPad && (argText[0] == '-' || argText[0] == '+')) {
    6382. 

  6382.                     argText = argText[0] + '0' + argText.slice(1);
    6383. 

  6383.                   } else {
    6384. 

  6384.                     argText = (flagZeroPad ? '0' : ' ') + argText;
    6385. 

  6385.                   }
    6386. 

  6386.                 }
    6387. 

  6387.               }
    6388. 

  6388. 

  6389.               // Adjust case.
    6390. 

  6390.               if (next < 97) argText = argText.toUpperCase();
    6391. 

  6391. 

  6392.               // Insert the result into the buffer.
    6393. 

  6393.               argText.split('').forEach(function(chr) {
    6394. 

  6394.                 ret.push(chr.charCodeAt(0));
    6395. 

  6395.               });
    6396. 

  6396.               break;
    6397. 

  6397.             }
    6398. 

  6398.             case 's': {
    6399. 

  6399.               // String.
    6400. 

  6400.               var arg = getNextArg('i8*');
    6401. 

  6401.               var argLength = arg ? _strlen(arg) : '(null)'.length;
    6402. 

  6402.               if (precisionSet) argLength = Math.min(argLength, precision);
    6403. 

  6403.               if (!flagLeftAlign) {
    6404. 

  6404.                 while (argLength < width--) {
    6405. 

  6405.                   ret.push(32);
    6406. 

  6406.                 }
    6407. 

  6407.               }
    6408. 

  6408.               if (arg) {
    6409. 

  6409.                 for (var i = 0; i < argLength; i++) {
    6410. 

  6410.                   ret.push(HEAPU8[((arg++)|0)]);
    6411. 

  6411.                 }
    6412. 

  6412.               } else {
    6413. 

  6413.                 ret = ret.concat(intArrayFromString('(null)'.substr(0, argLength), true));
    6414. 

  6414.               }
    6415. 

  6415.               if (flagLeftAlign) {
    6416. 

  6416.                 while (argLength < width--) {
    6417. 

  6417.                   ret.push(32);
    6418. 

  6418.                 }
    6419. 

  6419.               }
    6420. 

  6420.               break;
    6421. 

  6421.             }
    6422. 

  6422.             case 'c': {
    6423. 

  6423.               // Character.
    6424. 

  6424.               if (flagLeftAlign) ret.push(getNextArg('i8'));
    6425. 

  6425.               while (--width > 0) {
    6426. 

  6426.                 ret.push(32);
    6427. 

  6427.               }
    6428. 

  6428.               if (!flagLeftAlign) ret.push(getNextArg('i8'));
    6429. 

  6429.               break;
    6430. 

  6430.             }
    6431. 

  6431.             case 'n': {
    6432. 

  6432.               // Write the length written so far to the next parameter.
    6433. 

  6433.               var ptr = getNextArg('i32*');
    6434. 

  6434.               HEAP32[((ptr)>>2)]=ret.length;
    6435. 

  6435.               break;
    6436. 

  6436.             }
    6437. 

  6437.             case '%': {
    6438. 

  6438.               // Literal percent sign.
    6439. 

  6439.               ret.push(curr);
    6440. 

  6440.               break;
    6441. 

  6441.             }
    6442. 

  6442.             default: {
    6443. 

  6443.               // Unknown specifiers remain untouched.
    6444. 

  6444.               for (var i = startTextIndex; i < textIndex + 2; i++) {
    6445. 

  6445.                 ret.push(HEAP8[(i)]);
    6446. 

  6446.               }
    6447. 

  6447.             }
    6448. 

  6448.           }
    6449. 

  6449.           textIndex += 2;
    6450. 

  6450.           // TODO: Support a/A (hex float) and m (last error) specifiers.
    6451. 

  6451.           // TODO: Support %1${specifier} for arg selection.
    6452. 

  6452.         } else {
    6453. 

  6453.           ret.push(curr);
    6454. 

  6454.           textIndex += 1;
    6455. 

  6455.         }
    6456. 

  6456.       }
    6457. 

  6457.       return ret;
    6458. 

  6458.     }function _fprintf(stream, format, varargs) {
    6459. 

  6459.       // int fprintf(FILE *restrict stream, const char *restrict format, ...);
    6460. 

  6460.       // http://pubs.opengroup.org/onlinepubs/000095399/functions/printf.html
    6461. 

  6461.       var result = __formatString(format, varargs);
    6462. 

  6462.       var stack = Runtime.stackSave();
    6463. 

  6463.       var ret = _fwrite(allocate(result, 'i8', ALLOC_STACK), 1, result.length, stream);
    6464. 

  6464.       Runtime.stackRestore(stack);
    6465. 

  6465.       return ret;
    6466. 

  6466.     }
    6467. 

  6467. 

  6468.   function _fgets(s, n, stream) {
    6469. 

  6469.       // char *fgets(char *restrict s, int n, FILE *restrict stream);
    6470. 

  6470.       // http://pubs.opengroup.org/onlinepubs/000095399/functions/fgets.html
    6471. 

  6471.       var streamObj = FS.getStreamFromPtr(stream);
    6472. 

  6472.       if (!streamObj) return 0;
    6473. 

  6473.       if (streamObj.error || streamObj.eof) return 0;
    6474. 

  6474.       var byte_;
    6475. 

  6475.       for (var i = 0; i < n - 1 && byte_ != 10; i++) {
    6476. 

  6476.         byte_ = _fgetc(stream);
    6477. 

  6477.         if (byte_ == -1) {
    6478. 

  6478.           if (streamObj.error || (streamObj.eof && i == 0)) return 0;
    6479. 

  6479.           else if (streamObj.eof) break;
    6480. 

  6480.         }
    6481. 

  6481.         HEAP8[(((s)+(i))|0)]=byte_;
    6482. 

  6482.       }
    6483. 

  6483.       HEAP8[(((s)+(i))|0)]=0;
    6484. 

  6484.       return s;
    6485. 

  6485.     }
    6486. 

  6486. 

  6487.   var _tan=Math_tan;
    6488. 

  6488. 

  6489.   function _ispunct(chr) {
    6490. 

  6490.       return (chr >= 33 && chr <= 47) ||
    6491. 

  6491.              (chr >= 58 && chr <= 64) ||
    6492. 

  6492.              (chr >= 91 && chr <= 96) ||
    6493. 

  6493.              (chr >= 123 && chr <= 126);
    6494. 

  6494.     }
    6495. 

  6495. 

  6496.   function _feof(stream) {
    6497. 

  6497.       // int feof(FILE *stream);
    6498. 

  6498.       // http://pubs.opengroup.org/onlinepubs/000095399/functions/feof.html
    6499. 

  6499.       stream = FS.getStreamFromPtr(stream);
    6500. 

  6500.       return Number(stream && stream.eof);
    6501. 

  6501.     }
    6502. 

  6502. 

  6503. 

  6504.   Module["_tolower"] = _tolower;
    6505. 

  6505. 

  6506.   var _asin=Math_asin;
    6507. 

  6507. 

  6508.   function _clearerr(stream) {
    6509. 

  6509.       // void clearerr(FILE *stream);
    6510. 

  6510.       // http://pubs.opengroup.org/onlinepubs/000095399/functions/clearerr.html
    6511. 

  6511.       stream = FS.getStreamFromPtr(stream);
    6512. 

  6512.       if (!stream) {
    6513. 

  6513.         return;
    6514. 

  6514.       }
    6515. 

  6515.       stream.eof = false;
    6516. 

  6516.       stream.error = false;
    6517. 

  6517.     }
    6518. 

  6518. 

  6519.   var _fabs=Math_abs;
    6520. 

  6520. 

  6521.   function _clock() {
    6522. 

  6522.       if (_clock.start === undefined) _clock.start = Date.now();
    6523. 

  6523.       return Math.floor((Date.now() - _clock.start) * (1000000/1000));
    6524. 

  6524.     }
    6525. 

  6525. 

  6526. 

  6527.   var _getc=_fgetc;
    6528. 

  6528. 

  6529.   function _modf(x, intpart) {
    6530. 

  6530.       HEAPF64[((intpart)>>3)]=Math.floor(x);
    6531. 

  6531.       return x - HEAPF64[((intpart)>>3)];
    6532. 

  6532.     }
    6533. 

  6533. 

  6534.   var _sqrt=Math_sqrt;
    6535. 

  6535. 

  6536.   function _isxdigit(chr) {
    6537. 

  6537.       return (chr >= 48 && chr <= 57) ||
    6538. 

  6538.              (chr >= 97 && chr <= 102) ||
    6539. 

  6539.              (chr >= 65 && chr <= 70);
    6540. 

  6540.     }
    6541. 

  6541. 

  6542.   function _ftell(stream) {
    6543. 

  6543.       // long ftell(FILE *stream);
    6544. 

  6544.       // http://pubs.opengroup.org/onlinepubs/000095399/functions/ftell.html
    6545. 

  6545.       stream = FS.getStreamFromPtr(stream);
    6546. 

  6546.       if (!stream) {
    6547. 

  6547.         ___setErrNo(ERRNO_CODES.EBADF);
    6548. 

  6548.         return -1;
    6549. 

  6549.       }
    6550. 

  6550.       if (FS.isChrdev(stream.node.mode)) {
    6551. 

  6551.         ___setErrNo(ERRNO_CODES.ESPIPE);
    6552. 

  6552.         return -1;
    6553. 

  6553.       } else {
    6554. 

  6554.         return stream.position;
    6555. 

  6555.       }
    6556. 

  6556.     }
    6557. 

  6557. 

  6558. 

  6559.   function __exit(status) {
    6560. 

  6560.       // void _exit(int status);
    6561. 

  6561.       // http://pubs.opengroup.org/onlinepubs/000095399/functions/exit.html
    6562. 

  6562.       Module['exit'](status);
    6563. 

  6563.     }function _exit(status) {
    6564. 

  6564.       __exit(status);
    6565. 

  6565.     }
    6566. 

  6566. 

  6567. 

  6568.   function _snprintf(s, n, format, varargs) {
    6569. 

  6569.       // int snprintf(char *restrict s, size_t n, const char *restrict format, ...);
    6570. 

  6570.       // http://pubs.opengroup.org/onlinepubs/000095399/functions/printf.html
    6571. 

  6571.       var result = __formatString(format, varargs);
    6572. 

  6572.       var limit = (n === undefined) ? result.length
    6573. 

  6573.                                     : Math.min(result.length, Math.max(n - 1, 0));
    6574. 

  6574.       if (s < 0) {
    6575. 

  6575.         s = -s;
    6576. 

  6576.         var buf = _malloc(limit+1);
    6577. 

  6577.         HEAP32[((s)>>2)]=buf;
    6578. 

  6578.         s = buf;
    6579. 

  6579.       }
    6580. 

  6580.       for (var i = 0; i < limit; i++) {
    6581. 

  6581.         HEAP8[(((s)+(i))|0)]=result[i];
    6582. 

  6582.       }
    6583. 

  6583.       if (limit < n || (n === undefined)) HEAP8[(((s)+(i))|0)]=0;
    6584. 

  6584.       return result.length;
    6585. 

  6585.     }function _sprintf(s, format, varargs) {
    6586. 

  6586.       // int sprintf(char *restrict s, const char *restrict format, ...);
    6587. 

  6587.       // http://pubs.opengroup.org/onlinepubs/000095399/functions/printf.html
    6588. 

  6588.       return _snprintf(s, undefined, format, varargs);
    6589. 

  6589.     }
    6590. 

  6590. 

  6591.   var _emscripten_get_longjmp_result=true;
    6592. 

  6592. 

  6593.   var _sin=Math_sin;
    6594. 

  6594. 

  6595. 

  6596.   function _fmod(x, y) {
    6597. 

  6597.       return x % y;
    6598. 

  6598.     }var _fmodl=_fmod;
    6599. 

  6599. 

  6600. 

  6601. 

  6602.   var _atan=Math_atan;
    6603. 

  6603. 

  6604.   function _ferror(stream) {
    6605. 

  6605.       // int ferror(FILE *stream);
    6606. 

  6606.       // http://pubs.opengroup.org/onlinepubs/000095399/functions/ferror.html
    6607. 

  6607.       stream = FS.getStreamFromPtr(stream);
    6608. 

  6608.       return Number(stream && stream.error);
    6609. 

  6609.     }
    6610. 

  6610. 

  6611.   function _time(ptr) {
    6612. 

  6612.       var ret = Math.floor(Date.now()/1000);
    6613. 

  6613.       if (ptr) {
    6614. 

  6614.         HEAP32[((ptr)>>2)]=ret;
    6615. 

  6615.       }
    6616. 

  6616.       return ret;
    6617. 

  6617.     }
    6618. 

  6618. 

  6619.   function _copysign(a, b) {
    6620. 

  6620.       return __reallyNegative(a) === __reallyNegative(b) ? a : -a;
    6621. 

  6621.     }
    6622. 

  6622. 

  6623. 

  6624.   function _gmtime_r(time, tmPtr) {
    6625. 

  6625.       var date = new Date(HEAP32[((time)>>2)]*1000);
    6626. 

  6626.       HEAP32[((tmPtr)>>2)]=date.getUTCSeconds();
    6627. 

  6627.       HEAP32[(((tmPtr)+(4))>>2)]=date.getUTCMinutes();
    6628. 

  6628.       HEAP32[(((tmPtr)+(8))>>2)]=date.getUTCHours();
    6629. 

  6629.       HEAP32[(((tmPtr)+(12))>>2)]=date.getUTCDate();
    6630. 

  6630.       HEAP32[(((tmPtr)+(16))>>2)]=date.getUTCMonth();
    6631. 

  6631.       HEAP32[(((tmPtr)+(20))>>2)]=date.getUTCFullYear()-1900;
    6632. 

  6632.       HEAP32[(((tmPtr)+(24))>>2)]=date.getUTCDay();
    6633. 

  6633.       HEAP32[(((tmPtr)+(36))>>2)]=0;
    6634. 

  6634.       HEAP32[(((tmPtr)+(32))>>2)]=0;
    6635. 

  6635.       var start = new Date(date); // define date using UTC, start from Jan 01 00:00:00 UTC
    6636. 

  6636.       start.setUTCDate(1);
    6637. 

  6637.       start.setUTCMonth(0);
    6638. 

  6638.       start.setUTCHours(0);
    6639. 

  6639.       start.setUTCMinutes(0);
    6640. 

  6640.       start.setUTCSeconds(0);
    6641. 

  6641.       start.setUTCMilliseconds(0);
    6642. 

  6642.       var yday = Math.floor((date.getTime() - start.getTime()) / (1000 * 60 * 60 * 24));
    6643. 

  6643.       HEAP32[(((tmPtr)+(28))>>2)]=yday;
    6644. 

  6644.       HEAP32[(((tmPtr)+(40))>>2)]=___tm_timezone;
    6645. 

  6645. 

  6646.       return tmPtr;
    6647. 

  6647.     }function _gmtime(time) {
    6648. 

  6648.       return _gmtime_r(time, ___tm_current);
    6649. 

  6649.     }
    6650. 

  6650. 

  6651.   function _isgraph(chr) {
    6652. 

  6652.       return 0x20 < chr && chr < 0x7F;
    6653. 

  6653.     }
    6654. 

  6654. 

  6655. 

  6656. 

  6657.   function _strerror_r(errnum, strerrbuf, buflen) {
    6658. 

  6658.       if (errnum in ERRNO_MESSAGES) {
    6659. 

  6659.         if (ERRNO_MESSAGES[errnum].length > buflen - 1) {
    6660. 

  6660.           return ___setErrNo(ERRNO_CODES.ERANGE);
    6661. 

  6661.         } else {
    6662. 

  6662.           var msg = ERRNO_MESSAGES[errnum];
    6663. 

  6663.           writeAsciiToMemory(msg, strerrbuf);
    6664. 

  6664.           return 0;
    6665. 

  6665.         }
    6666. 

  6666.       } else {
    6667. 

  6667.         return ___setErrNo(ERRNO_CODES.EINVAL);
    6668. 

  6668.       }
    6669. 

  6669.     }function _strerror(errnum) {
    6670. 

  6670.       if (!_strerror.buffer) _strerror.buffer = _malloc(256);
    6671. 

  6671.       _strerror_r(errnum, _strerror.buffer, 256);
    6672. 

  6672.       return _strerror.buffer;
    6673. 

  6673.     }
    6674. 

  6674. 

  6675. 

  6676. 

  6677. 

  6678. 

  6679.   var _environ=allocate(1, "i32*", ALLOC_STATIC);var ___environ=_environ;function ___buildEnvironment(env) {
    6680. 

  6680.       // WARNING: Arbitrary limit!
    6681. 

  6681.       var MAX_ENV_VALUES = 64;
    6682. 

  6682.       var TOTAL_ENV_SIZE = 1024;
    6683. 

  6683. 

  6684.       // Statically allocate memory for the environment.
    6685. 

  6685.       var poolPtr;
    6686. 

  6686.       var envPtr;
    6687. 

  6687.       if (!___buildEnvironment.called) {
    6688. 

  6688.         ___buildEnvironment.called = true;
    6689. 

  6689.         // Set default values. Use string keys for Closure Compiler compatibility.
    6690. 

  6690.         ENV['USER'] = 'root';
    6691. 

  6691.         ENV['PATH'] = '/';
    6692. 

  6692.         ENV['PWD'] = '/';
    6693. 

  6693.         ENV['HOME'] = '/home/emscripten';
    6694. 

  6694.         ENV['LANG'] = 'en_US.UTF-8';
    6695. 

  6695.         ENV['_'] = './this.program';
    6696. 

  6696.         // Allocate memory.
    6697. 

  6697.         poolPtr = allocate(TOTAL_ENV_SIZE, 'i8', ALLOC_STATIC);
    6698. 

  6698.         envPtr = allocate(MAX_ENV_VALUES * 4,
    6699. 

  6699.                           'i8*', ALLOC_STATIC);
    6700. 

  6700.         HEAP32[((envPtr)>>2)]=poolPtr;
    6701. 

  6701.         HEAP32[((_environ)>>2)]=envPtr;
    6702. 

  6702.       } else {
    6703. 

  6703.         envPtr = HEAP32[((_environ)>>2)];
    6704. 

  6704.         poolPtr = HEAP32[((envPtr)>>2)];
    6705. 

  6705.       }
    6706. 

  6706. 

  6707.       // Collect key=value lines.
    6708. 

  6708.       var strings = [];
    6709. 

  6709.       var totalSize = 0;
    6710. 

  6710.       for (var key in env) {
    6711. 

  6711.         if (typeof env[key] === 'string') {
    6712. 

  6712.           var line = key + '=' + env[key];
    6713. 

  6713.           strings.push(line);
    6714. 

  6714.           totalSize += line.length;
    6715. 

  6715.         }
    6716. 

  6716.       }
    6717. 

  6717.       if (totalSize > TOTAL_ENV_SIZE) {
    6718. 

  6718.         throw new Error('Environment size exceeded TOTAL_ENV_SIZE!');
    6719. 

  6719.       }
    6720. 

  6720. 

  6721.       // Make new.
    6722. 

  6722.       var ptrSize = 4;
    6723. 

  6723.       for (var i = 0; i < strings.length; i++) {
    6724. 

  6724.         var line = strings[i];
    6725. 

  6725.         writeAsciiToMemory(line, poolPtr);
    6726. 

  6726.         HEAP32[(((envPtr)+(i * ptrSize))>>2)]=poolPtr;
    6727. 

  6727.         poolPtr += line.length + 1;
    6728. 

  6728.       }
    6729. 

  6729.       HEAP32[(((envPtr)+(strings.length * ptrSize))>>2)]=0;
    6730. 

  6730.     }var ENV={};function _getenv(name) {
    6731. 

  6731.       // char *getenv(const char *name);
    6732. 

  6732.       // http://pubs.opengroup.org/onlinepubs/009695399/functions/getenv.html
    6733. 

  6733.       if (name === 0) return 0;
    6734. 

  6734.       name = Pointer_stringify(name);
    6735. 

  6735.       if (!ENV.hasOwnProperty(name)) return 0;
    6736. 

  6736. 

  6737.       if (_getenv.ret) _free(_getenv.ret);
    6738. 

  6738.       _getenv.ret = allocate(intArrayFromString(ENV[name]), 'i8', ALLOC_NORMAL);
    6739. 

  6739.       return _getenv.ret;
    6740. 

  6740.     }
    6741. 

  6741. 

  6742.   var _emscripten_setjmp=true;
    6743. 

  6743. 

  6744.   var _cos=Math_cos;
    6745. 

  6745. 

  6746.   function _isalnum(chr) {
    6747. 

  6747.       return (chr >= 48 && chr <= 57) ||
    6748. 

  6748.              (chr >= 97 && chr <= 122) ||
    6749. 

  6749.              (chr >= 65 && chr <= 90);
    6750. 

  6750.     }
    6751. 

  6751. 

  6752.   var _BItoD=true;
    6753. 

  6753. 

  6754.   function _difftime(time1, time0) {
    6755. 

  6755.       return time1 - time0;
    6756. 

  6756.     }
    6757. 

  6757. 

  6758.   var _floor=Math_floor;
    6759. 

  6759. 

  6760.   function _iscntrl(chr) {
    6761. 

  6761.       return (0 <= chr && chr <= 0x1F) || chr === 0x7F;
    6762. 

  6762.     }
    6763. 

  6763. 

  6764.   var _atan2=Math_atan2;
    6765. 

  6765. 

  6766.   function _setvbuf(stream, buf, type, size) {
    6767. 

  6767.       // int setvbuf(FILE *restrict stream, char *restrict buf, int type, size_t size);
    6768. 

  6768.       // http://pubs.opengroup.org/onlinepubs/000095399/functions/setvbuf.html
    6769. 

  6769.       // TODO: Implement custom buffering.
    6770. 

  6770.       return 0;
    6771. 

  6771.     }
    6772. 

  6772. 

  6773.   var _exp=Math_exp;
    6774. 

  6774. 

  6775.   var _copysignl=_copysign;
    6776. 

  6776. 

  6777.   function _islower(chr) {
    6778. 

  6778.       return chr >= 97 && chr <= 122;
    6779. 

  6779.     }
    6780. 

  6780. 

  6781.   var _acos=Math_acos;
    6782. 

  6782. 

  6783.   function _isupper(chr) {
    6784. 

  6784.       return chr >= 65 && chr <= 90;
    6785. 

  6785.     }
    6786. 

  6786. 

  6787. 

  6788.   function __isLeapYear(year) {
    6789. 

  6789.         return year%4 === 0 && (year%100 !== 0 || year%400 === 0);
    6790. 

  6790.     }
    6791. 

  6791. 

  6792.   function __arraySum(array, index) {
    6793. 

  6793.       var sum = 0;
    6794. 

  6794.       for (var i = 0; i <= index; sum += array[i++]);
    6795. 

  6795.       return sum;
    6796. 

  6796.     }
    6797. 

  6797. 

  6798. 

  6799.   var __MONTH_DAYS_LEAP=[31,29,31,30,31,30,31,31,30,31,30,31];
    6800. 

  6800. 

  6801.   var __MONTH_DAYS_REGULAR=[31,28,31,30,31,30,31,31,30,31,30,31];function __addDays(date, days) {
    6802. 

  6802.       var newDate = new Date(date.getTime());
    6803. 

  6803.       while(days > 0) {
    6804. 

  6804.         var leap = __isLeapYear(newDate.getFullYear());
    6805. 

  6805.         var currentMonth = newDate.getMonth();
    6806. 

  6806.         var daysInCurrentMonth = (leap ? __MONTH_DAYS_LEAP : __MONTH_DAYS_REGULAR)[currentMonth];
    6807. 

  6807. 

  6808.         if (days > daysInCurrentMonth-newDate.getDate()) {
    6809. 

  6809.           // we spill over to next month
    6810. 

  6810.           days -= (daysInCurrentMonth-newDate.getDate()+1);
    6811. 

  6811.           newDate.setDate(1);
    6812. 

  6812.           if (currentMonth < 11) {
    6813. 

  6813.             newDate.setMonth(currentMonth+1)
    6814. 

  6814.           } else {
    6815. 

  6815.             newDate.setMonth(0);
    6816. 

  6816.             newDate.setFullYear(newDate.getFullYear()+1);
    6817. 

  6817.           }
    6818. 

  6818.         } else {
    6819. 

  6819.           // we stay in current month
    6820. 

  6820.           newDate.setDate(newDate.getDate()+days);
    6821. 

  6821.           return newDate;
    6822. 

  6822.         }
    6823. 

  6823.       }
    6824. 

  6824. 

  6825.       return newDate;
    6826. 

  6826.     }function _strftime(s, maxsize, format, tm) {
    6827. 

  6827.       // size_t strftime(char *restrict s, size_t maxsize, const char *restrict format, const struct tm *restrict timeptr);
    6828. 

  6828.       // http://pubs.opengroup.org/onlinepubs/009695399/functions/strftime.html
    6829. 

  6829. 

  6830.       var date = {
    6831. 

  6831.         tm_sec: HEAP32[((tm)>>2)],
    6832. 

  6832.         tm_min: HEAP32[(((tm)+(4))>>2)],
    6833. 

  6833.         tm_hour: HEAP32[(((tm)+(8))>>2)],
    6834. 

  6834.         tm_mday: HEAP32[(((tm)+(12))>>2)],
    6835. 

  6835.         tm_mon: HEAP32[(((tm)+(16))>>2)],
    6836. 

  6836.         tm_year: HEAP32[(((tm)+(20))>>2)],
    6837. 

  6837.         tm_wday: HEAP32[(((tm)+(24))>>2)],
    6838. 

  6838.         tm_yday: HEAP32[(((tm)+(28))>>2)],
    6839. 

  6839.         tm_isdst: HEAP32[(((tm)+(32))>>2)]
    6840. 

  6840.       };
    6841. 

  6841. 

  6842.       var pattern = Pointer_stringify(format);
    6843. 

  6843. 

  6844.       // expand format
    6845. 

  6845.       var EXPANSION_RULES_1 = {
    6846. 

  6846.         '%c': '%a %b %d %H:%M:%S %Y',     // Replaced by the locale's appropriate date and time representation - e.g., Mon Aug  3 14:02:01 2013
    6847. 

  6847.         '%D': '%m/%d/%y',                 // Equivalent to %m / %d / %y
    6848. 

  6848.         '%F': '%Y-%m-%d',                 // Equivalent to %Y - %m - %d
    6849. 

  6849.         '%h': '%b',                       // Equivalent to %b
    6850. 

  6850.         '%r': '%I:%M:%S %p',              // Replaced by the time in a.m. and p.m. notation
    6851. 

  6851.         '%R': '%H:%M',                    // Replaced by the time in 24-hour notation
    6852. 

  6852.         '%T': '%H:%M:%S',                 // Replaced by the time
    6853. 

  6853.         '%x': '%m/%d/%y',                 // Replaced by the locale's appropriate date representation
    6854. 

  6854.         '%X': '%H:%M:%S',                 // Replaced by the locale's appropriate date representation
    6855. 

  6855.       };
    6856. 

  6856.       for (var rule in EXPANSION_RULES_1) {
    6857. 

  6857.         pattern = pattern.replace(new RegExp(rule, 'g'), EXPANSION_RULES_1[rule]);
    6858. 

  6858.       }
    6859. 

  6859. 

  6860.       var WEEKDAYS = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'];
    6861. 

  6861.       var MONTHS = ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December'];
    6862. 

  6862. 

  6863.       function leadingSomething(value, digits, character) {
    6864. 

  6864.         var str = typeof value === 'number' ? value.toString() : (value || '');
    6865. 

  6865.         while (str.length < digits) {
    6866. 

  6866.           str = character[0]+str;
    6867. 

  6867.         }
    6868. 

  6868.         return str;
    6869. 

  6869.       };
    6870. 

  6870. 

  6871.       function leadingNulls(value, digits) {
    6872. 

  6872.         return leadingSomething(value, digits, '0');
    6873. 

  6873.       };
    6874. 

  6874. 

  6875.       function compareByDay(date1, date2) {
    6876. 

  6876.         function sgn(value) {
    6877. 

  6877.           return value < 0 ? -1 : (value > 0 ? 1 : 0);
    6878. 

  6878.         };
    6879. 

  6879. 

  6880.         var compare;
    6881. 

  6881.         if ((compare = sgn(date1.getFullYear()-date2.getFullYear())) === 0) {
    6882. 

  6882.           if ((compare = sgn(date1.getMonth()-date2.getMonth())) === 0) {
    6883. 

  6883.             compare = sgn(date1.getDate()-date2.getDate());
    6884. 

  6884.           }
    6885. 

  6885.         }
    6886. 

  6886.         return compare;
    6887. 

  6887.       };
    6888. 

  6888. 

  6889.       function getFirstWeekStartDate(janFourth) {
    6890. 

  6890.           switch (janFourth.getDay()) {
    6891. 

  6891.             case 0: // Sunday
    6892. 

  6892.               return new Date(janFourth.getFullYear()-1, 11, 29);
    6893. 

  6893.             case 1: // Monday
    6894. 

  6894.               return janFourth;
    6895. 

  6895.             case 2: // Tuesday
    6896. 

  6896.               return new Date(janFourth.getFullYear(), 0, 3);
    6897. 

  6897.             case 3: // Wednesday
    6898. 

  6898.               return new Date(janFourth.getFullYear(), 0, 2);
    6899. 

  6899.             case 4: // Thursday
    6900. 

  6900.               return new Date(janFourth.getFullYear(), 0, 1);
    6901. 

  6901.             case 5: // Friday
    6902. 

  6902.               return new Date(janFourth.getFullYear()-1, 11, 31);
    6903. 

  6903.             case 6: // Saturday
    6904. 

  6904.               return new Date(janFourth.getFullYear()-1, 11, 30);
    6905. 

  6905.           }
    6906. 

  6906.       };
    6907. 

  6907. 

  6908.       function getWeekBasedYear(date) {
    6909. 

  6909.           var thisDate = __addDays(new Date(date.tm_year+1900, 0, 1), date.tm_yday);
    6910. 

  6910. 

  6911.           var janFourthThisYear = new Date(thisDate.getFullYear(), 0, 4);
    6912. 

  6912.           var janFourthNextYear = new Date(thisDate.getFullYear()+1, 0, 4);
    6913. 

  6913. 

  6914.           var firstWeekStartThisYear = getFirstWeekStartDate(janFourthThisYear);
    6915. 

  6915.           var firstWeekStartNextYear = getFirstWeekStartDate(janFourthNextYear);
    6916. 

  6916. 

  6917.           if (compareByDay(firstWeekStartThisYear, thisDate) <= 0) {
    6918. 

  6918.             // this date is after the start of the first week of this year
    6919. 

  6919.             if (compareByDay(firstWeekStartNextYear, thisDate) <= 0) {
    6920. 

  6920.               return thisDate.getFullYear()+1;
    6921. 

  6921.             } else {
    6922. 

  6922.               return thisDate.getFullYear();
    6923. 

  6923.             }
    6924. 

  6924.           } else {
    6925. 

  6925.             return thisDate.getFullYear()-1;
    6926. 

  6926.           }
    6927. 

  6927.       };
    6928. 

  6928. 

  6929.       var EXPANSION_RULES_2 = {
    6930. 

  6930.         '%a': function(date) {
    6931. 

  6931.           return WEEKDAYS[date.tm_wday].substring(0,3);
    6932. 

  6932.         },
    6933. 

  6933.         '%A': function(date) {
    6934. 

  6934.           return WEEKDAYS[date.tm_wday];
    6935. 

  6935.         },
    6936. 

  6936.         '%b': function(date) {
    6937. 

  6937.           return MONTHS[date.tm_mon].substring(0,3);
    6938. 

  6938.         },
    6939. 

  6939.         '%B': function(date) {
    6940. 

  6940.           return MONTHS[date.tm_mon];
    6941. 

  6941.         },
    6942. 

  6942.         '%C': function(date) {
    6943. 

  6943.           var year = date.tm_year+1900;
    6944. 

  6944.           return leadingNulls(Math.floor(year/100),2);
    6945. 

  6945.         },
    6946. 

  6946.         '%d': function(date) {
    6947. 

  6947.           return leadingNulls(date.tm_mday, 2);
    6948. 

  6948.         },
    6949. 

  6949.         '%e': function(date) {
    6950. 

  6950.           return leadingSomething(date.tm_mday, 2, ' ');
    6951. 

  6951.         },
    6952. 

  6952.         '%g': function(date) {
    6953. 

  6953.           // %g, %G, and %V give values according to the ISO 8601:2000 standard week-based year.
    6954. 

  6954.           // In this system, weeks begin on a Monday and week 1 of the year is the week that includes
    6955. 

  6955.           // January 4th, which is also the week that includes the first Thursday of the year, and
    6956. 

  6956.           // is also the first week that contains at least four days in the year.
    6957. 

  6957.           // If the first Monday of January is the 2nd, 3rd, or 4th, the preceding days are part of
    6958. 

  6958.           // the last week of the preceding year; thus, for Saturday 2nd January 1999,
    6959. 

  6959.           // %G is replaced by 1998 and %V is replaced by 53. If December 29th, 30th,
    6960. 

  6960.           // or 31st is a Monday, it and any following days are part of week 1 of the following year.
    6961. 

  6961.           // Thus, for Tuesday 30th December 1997, %G is replaced by 1998 and %V is replaced by 01.
    6962. 

  6962. 

  6963.           return getWeekBasedYear(date).toString().substring(2);
    6964. 

  6964.         },
    6965. 

  6965.         '%G': function(date) {
    6966. 

  6966.           return getWeekBasedYear(date);
    6967. 

  6967.         },
    6968. 

  6968.         '%H': function(date) {
    6969. 

  6969.           return leadingNulls(date.tm_hour, 2);
    6970. 

  6970.         },
    6971. 

  6971.         '%I': function(date) {
    6972. 

  6972.           return leadingNulls(date.tm_hour < 13 ? date.tm_hour : date.tm_hour-12, 2);
    6973. 

  6973.         },
    6974. 

  6974.         '%j': function(date) {
    6975. 

  6975.           // Day of the year (001-366)
    6976. 

  6976.           return leadingNulls(date.tm_mday+__arraySum(__isLeapYear(date.tm_year+1900) ? __MONTH_DAYS_LEAP : __MONTH_DAYS_REGULAR, date.tm_mon-1), 3);
    6977. 

  6977.         },
    6978. 

  6978.         '%m': function(date) {
    6979. 

  6979.           return leadingNulls(date.tm_mon+1, 2);
    6980. 

  6980.         },
    6981. 

  6981.         '%M': function(date) {
    6982. 

  6982.           return leadingNulls(date.tm_min, 2);
    6983. 

  6983.         },
    6984. 

  6984.         '%n': function() {
    6985. 

  6985.           return '\n';
    6986. 

  6986.         },
    6987. 

  6987.         '%p': function(date) {
    6988. 

  6988.           if (date.tm_hour > 0 && date.tm_hour < 13) {
    6989. 

  6989.             return 'AM';
    6990. 

  6990.           } else {
    6991. 

  6991.             return 'PM';
    6992. 

  6992.           }
    6993. 

  6993.         },
    6994. 

  6994.         '%S': function(date) {
    6995. 

  6995.           return leadingNulls(date.tm_sec, 2);
    6996. 

  6996.         },
    6997. 

  6997.         '%t': function() {
    6998. 

  6998.           return '\t';
    6999. 

  6999.         },
    7000. 

  7000.         '%u': function(date) {
    7001. 

  7001.           var day = new Date(date.tm_year+1900, date.tm_mon+1, date.tm_mday, 0, 0, 0, 0);
    7002. 

  7002.           return day.getDay() || 7;
    7003. 

  7003.         },
    7004. 

  7004.         '%U': function(date) {
    7005. 

  7005.           // Replaced by the week number of the year as a decimal number [00,53].
    7006. 

  7006.           // The first Sunday of January is the first day of week 1;
    7007. 

  7007.           // days in the new year before this are in week 0. [ tm_year, tm_wday, tm_yday]
    7008. 

  7008.           var janFirst = new Date(date.tm_year+1900, 0, 1);
    7009. 

  7009.           var firstSunday = janFirst.getDay() === 0 ? janFirst : __addDays(janFirst, 7-janFirst.getDay());
    7010. 

  7010.           var endDate = new Date(date.tm_year+1900, date.tm_mon, date.tm_mday);
    7011. 

  7011. 

  7012.           // is target date after the first Sunday?
    7013. 

  7013.           if (compareByDay(firstSunday, endDate) < 0) {
    7014. 

  7014.             // calculate difference in days between first Sunday and endDate
    7015. 

  7015.             var februaryFirstUntilEndMonth = __arraySum(__isLeapYear(endDate.getFullYear()) ? __MONTH_DAYS_LEAP : __MONTH_DAYS_REGULAR, endDate.getMonth()-1)-31;
    7016. 

  7016.             var firstSundayUntilEndJanuary = 31-firstSunday.getDate();
    7017. 

  7017.             var days = firstSundayUntilEndJanuary+februaryFirstUntilEndMonth+endDate.getDate();
    7018. 

  7018.             return leadingNulls(Math.ceil(days/7), 2);
    7019. 

  7019.           }
    7020. 

  7020. 

  7021.           return compareByDay(firstSunday, janFirst) === 0 ? '01': '00';
    7022. 

  7022.         },
    7023. 

  7023.         '%V': function(date) {
    7024. 

  7024.           // Replaced by the week number of the year (Monday as the first day of the week)
    7025. 

  7025.           // as a decimal number [01,53]. If the week containing 1 January has four
    7026. 

  7026.           // or more days in the new year, then it is considered week 1.
    7027. 

  7027.           // Otherwise, it is the last week of the previous year, and the next week is week 1.
    7028. 

  7028.           // Both January 4th and the first Thursday of January are always in week 1. [ tm_year, tm_wday, tm_yday]
    7029. 

  7029.           var janFourthThisYear = new Date(date.tm_year+1900, 0, 4);
    7030. 

  7030.           var janFourthNextYear = new Date(date.tm_year+1901, 0, 4);
    7031. 

  7031. 

  7032.           var firstWeekStartThisYear = getFirstWeekStartDate(janFourthThisYear);
    7033. 

  7033.           var firstWeekStartNextYear = getFirstWeekStartDate(janFourthNextYear);
    7034. 

  7034. 

  7035.           var endDate = __addDays(new Date(date.tm_year+1900, 0, 1), date.tm_yday);
    7036. 

  7036. 

  7037.           if (compareByDay(endDate, firstWeekStartThisYear) < 0) {
    7038. 

  7038.             // if given date is before this years first week, then it belongs to the 53rd week of last year
    7039. 

  7039.             return '53';
    7040. 

  7040.           }
    7041. 

  7041. 

  7042.           if (compareByDay(firstWeekStartNextYear, endDate) <= 0) {
    7043. 

  7043.             // if given date is after next years first week, then it belongs to the 01th week of next year
    7044. 

  7044.             return '01';
    7045. 

  7045.           }
    7046. 

  7046. 

  7047.           // given date is in between CW 01..53 of this calendar year
    7048. 

  7048.           var daysDifference;
    7049. 

  7049.           if (firstWeekStartThisYear.getFullYear() < date.tm_year+1900) {
    7050. 

  7050.             // first CW of this year starts last year
    7051. 

  7051.             daysDifference = date.tm_yday+32-firstWeekStartThisYear.getDate()
    7052. 

  7052.           } else {
    7053. 

  7053.             // first CW of this year starts this year
    7054. 

  7054.             daysDifference = date.tm_yday+1-firstWeekStartThisYear.getDate();
    7055. 

  7055.           }
    7056. 

  7056.           return leadingNulls(Math.ceil(daysDifference/7), 2);
    7057. 

  7057.         },
    7058. 

  7058.         '%w': function(date) {
    7059. 

  7059.           var day = new Date(date.tm_year+1900, date.tm_mon+1, date.tm_mday, 0, 0, 0, 0);
    7060. 

  7060.           return day.getDay();
    7061. 

  7061.         },
    7062. 

  7062.         '%W': function(date) {
    7063. 

  7063.           // Replaced by the week number of the year as a decimal number [00,53].
    7064. 

  7064.           // The first Monday of January is the first day of week 1;
    7065. 

  7065.           // days in the new year before this are in week 0. [ tm_year, tm_wday, tm_yday]
    7066. 

  7066.           var janFirst = new Date(date.tm_year, 0, 1);
    7067. 

  7067.           var firstMonday = janFirst.getDay() === 1 ? janFirst : __addDays(janFirst, janFirst.getDay() === 0 ? 1 : 7-janFirst.getDay()+1);
    7068. 

  7068.           var endDate = new Date(date.tm_year+1900, date.tm_mon, date.tm_mday);
    7069. 

  7069. 

  7070.           // is target date after the first Monday?
    7071. 

  7071.           if (compareByDay(firstMonday, endDate) < 0) {
    7072. 

  7072.             var februaryFirstUntilEndMonth = __arraySum(__isLeapYear(endDate.getFullYear()) ? __MONTH_DAYS_LEAP : __MONTH_DAYS_REGULAR, endDate.getMonth()-1)-31;
    7073. 

  7073.             var firstMondayUntilEndJanuary = 31-firstMonday.getDate();
    7074. 

  7074.             var days = firstMondayUntilEndJanuary+februaryFirstUntilEndMonth+endDate.getDate();
    7075. 

  7075.             return leadingNulls(Math.ceil(days/7), 2);
    7076. 

  7076.           }
    7077. 

  7077.           return compareByDay(firstMonday, janFirst) === 0 ? '01': '00';
    7078. 

  7078.         },
    7079. 

  7079.         '%y': function(date) {
    7080. 

  7080.           // Replaced by the last two digits of the year as a decimal number [00,99]. [ tm_year]
    7081. 

  7081.           return (date.tm_year+1900).toString().substring(2);
    7082. 

  7082.         },
    7083. 

  7083.         '%Y': function(date) {
    7084. 

  7084.           // Replaced by the year as a decimal number (for example, 1997). [ tm_year]
    7085. 

  7085.           return date.tm_year+1900;
    7086. 

  7086.         },
    7087. 

  7087.         '%z': function(date) {
    7088. 

  7088.           // Replaced by the offset from UTC in the ISO 8601:2000 standard format ( +hhmm or -hhmm ),
    7089. 

  7089.           // or by no characters if no timezone is determinable.
    7090. 

  7090.           // For example, "-0430" means 4 hours 30 minutes behind UTC (west of Greenwich).
    7091. 

  7091.           // If tm_isdst is zero, the standard time offset is used.
    7092. 

  7092.           // If tm_isdst is greater than zero, the daylight savings time offset is used.
    7093. 

  7093.           // If tm_isdst is negative, no characters are returned.
    7094. 

  7094.           // FIXME: we cannot determine time zone (or can we?)
    7095. 

  7095.           return '';
    7096. 

  7096.         },
    7097. 

  7097.         '%Z': function(date) {
    7098. 

  7098.           // Replaced by the timezone name or abbreviation, or by no bytes if no timezone information exists. [ tm_isdst]
    7099. 

  7099.           // FIXME: we cannot determine time zone (or can we?)
    7100. 

  7100.           return '';
    7101. 

  7101.         },
    7102. 

  7102.         '%%': function() {
    7103. 

  7103.           return '%';
    7104. 

  7104.         }
    7105. 

  7105.       };
    7106. 

  7106.       for (var rule in EXPANSION_RULES_2) {
    7107. 

  7107.         if (pattern.indexOf(rule) >= 0) {
    7108. 

  7108.           pattern = pattern.replace(new RegExp(rule, 'g'), EXPANSION_RULES_2[rule](date));
    7109. 

  7109.         }
    7110. 

  7110.       }
    7111. 

  7111. 

  7112.       var bytes = intArrayFromString(pattern, false);
    7113. 

  7113.       if (bytes.length > maxsize) {
    7114. 

  7114.         return 0;
    7115. 

  7115.       }
    7116. 

  7116. 

  7117.       writeArrayToMemory(bytes, s);
    7118. 

  7118.       return bytes.length-1;
    7119. 

  7119.     }
    7120. 

  7120. 

  7121. 

  7122. 

  7123. FS.staticInit();__ATINIT__.unshift({ func: function() { if (!Module["noFSInit"] && !FS.init.initialized) FS.init() } });__ATMAIN__.push({ func: function() { FS.ignorePermissions = false } });__ATEXIT__.push({ func: function() { FS.quit() } });Module["FS_createFolder"] = FS.createFolder;Module["FS_createPath"] = FS.createPath;Module["FS_createDataFile"] = FS.createDataFile;Module["FS_createPreloadedFile"] = FS.createPreloadedFile;Module["FS_createLazyFile"] = FS.createLazyFile;Module["FS_createLink"] = FS.createLink;Module["FS_createDevice"] = FS.createDevice;
    7124. 

  7124. ___errno_state = Runtime.staticAlloc(4); HEAP32[((___errno_state)>>2)]=0;
    7125. 

  7125. __ATINIT__.unshift({ func: function() { TTY.init() } });__ATEXIT__.push({ func: function() { TTY.shutdown() } });TTY.utf8 = new Runtime.UTF8Processor();
    7126. 

  7126. if (ENVIRONMENT_IS_NODE) { var fs = require("fs"); NODEFS.staticInit(); }
    7127. 

  7127. __ATINIT__.push({ func: function() { SOCKFS.root = FS.mount(SOCKFS, {}, null); } });
    7128. 

  7128. _fputc.ret = allocate([0], "i8", ALLOC_STATIC);
    7129. 

  7129. Module["requestFullScreen"] = function Module_requestFullScreen(lockPointer, resizeCanvas) { Browser.requestFullScreen(lockPointer, resizeCanvas) };
    7130. 

  7130.   Module["requestAnimationFrame"] = function Module_requestAnimationFrame(func) { Browser.requestAnimationFrame(func) };
    7131. 

  7131.   Module["setCanvasSize"] = function Module_setCanvasSize(width, height, noUpdates) { Browser.setCanvasSize(width, height, noUpdates) };
    7132. 

  7132.   Module["pauseMainLoop"] = function Module_pauseMainLoop() { Browser.mainLoop.pause() };
    7133. 

  7133.   Module["resumeMainLoop"] = function Module_resumeMainLoop() { Browser.mainLoop.resume() };
    7134. 

  7134.   Module["getUserMedia"] = function Module_getUserMedia() { Browser.getUserMedia() }
    7135. 

  7135. _fgetc.ret = allocate([0], "i8", ALLOC_STATIC);
    7136. 

  7136. ___buildEnvironment(ENV);
    7137. 

  7137. STACK_BASE = STACKTOP = Runtime.alignMemory(STATICTOP);
    7138. 

  7138. 

  7139. staticSealed = true; // seal the static portion of memory
    7140. 

  7140. 

  7141. STACK_MAX = STACK_BASE + 5242880;
    7142. 

  7142. 

  7143. DYNAMIC_BASE = DYNAMICTOP = Runtime.alignMemory(STACK_MAX);
    7144. 

  7144. 

  7145. assert(DYNAMIC_BASE < TOTAL_MEMORY, "TOTAL_MEMORY not big enough for stack");
    7146. 

  7146. 

  7147.  var ctlz_i8 = allocate([8,7,6,6,5,5,5,5,4,4,4,4,4,4,4,4,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], "i8", ALLOC_DYNAMIC);
    7148. 

  7148.  var cttz_i8 = allocate([8,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,5,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,6,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,5,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,7,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,5,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,6,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,5,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0], "i8", ALLOC_DYNAMIC);
    7149. 

  7149. 

  7150. var Math_min = Math.min;
    7151. 

  7151. function invoke_iiii(index,a1,a2,a3) {
    7152. 

  7152.   try {
    7153. 

  7153.     return Module["dynCall_iiii"](index,a1,a2,a3);
    7154. 

  7154.   } catch(e) {
    7155. 

  7155.     if (typeof e !== 'number' && e !== 'longjmp') throw e;
    7156. 

  7156.     asm["setThrew"](1, 0);
    7157. 

  7157.   }
    7158. 

  7158. }
    7159. 

  7159. 

  7160. function invoke_vi(index,a1) {
    7161. 

  7161.   try {
    7162. 

  7162.     Module["dynCall_vi"](index,a1);
    7163. 

  7163.   } catch(e) {
    7164. 

  7164.     if (typeof e !== 'number' && e !== 'longjmp') throw e;
    7165. 

  7165.     asm["setThrew"](1, 0);
    7166. 

  7166.   }
    7167. 

  7167. }
    7168. 

  7168. 

  7169. function invoke_vii(index,a1,a2) {
    7170. 

  7170.   try {
    7171. 

  7171.     Module["dynCall_vii"](index,a1,a2);
    7172. 

  7172.   } catch(e) {
    7173. 

  7173.     if (typeof e !== 'number' && e !== 'longjmp') throw e;
    7174. 

  7174.     asm["setThrew"](1, 0);
    7175. 

  7175.   }
    7176. 

  7176. }
    7177. 

  7177. 

  7178. function invoke_ii(index,a1) {
    7179. 

  7179.   try {
    7180. 

  7180.     return Module["dynCall_ii"](index,a1);
    7181. 

  7181.   } catch(e) {
    7182. 

  7182.     if (typeof e !== 'number' && e !== 'longjmp') throw e;
    7183. 

  7183.     asm["setThrew"](1, 0);
    7184. 

  7184.   }
    7185. 

  7185. }
    7186. 

  7186. 

  7187. function invoke_iiiii(index,a1,a2,a3,a4) {
    7188. 

  7188.   try {
    7189. 

  7189.     return Module["dynCall_iiiii"](index,a1,a2,a3,a4);
    7190. 

  7190.   } catch(e) {
    7191. 

  7191.     if (typeof e !== 'number' && e !== 'longjmp') throw e;
    7192. 

  7192.     asm["setThrew"](1, 0);
    7193. 

  7193.   }
    7194. 

  7194. }
    7195. 

  7195. 

  7196. function invoke_iii(index,a1,a2) {
    7197. 

  7197.   try {
    7198. 

  7198.     return Module["dynCall_iii"](index,a1,a2);
    7199. 

  7199.   } catch(e) {
    7200. 

  7200.     if (typeof e !== 'number' && e !== 'longjmp') throw e;
    7201. 

  7201.     asm["setThrew"](1, 0);
    7202. 

  7202.   }
    7203. 

  7203. }
    7204. 

  7204. 

  7205. function asmPrintInt(x, y) {
    7206. 

  7206.   Module.print('int ' + x + ',' + y);// + ' ' + new Error().stack);
    7207. 

  7207. }
    7208. 

  7208. function asmPrintFloat(x, y) {
    7209. 

  7209.   Module.print('float ' + x + ',' + y);// + ' ' + new Error().stack);
    7210. 

  7210. }
    7211. 

  7211. // EMSCRIPTEN_START_ASM
    7212. 

  7212. var asm = (function(global, env, buffer) {
    7213. 

  7213.   'use asm';
    7214. 

  7214.   var HEAP8 = new global.Int8Array(buffer);
    7215. 

  7215.   var HEAP16 = new global.Int16Array(buffer);
    7216. 

  7216.   var HEAP32 = new global.Int32Array(buffer);
    7217. 

  7217.   var HEAPU8 = new global.Uint8Array(buffer);
    7218. 

  7218.   var HEAPU16 = new global.Uint16Array(buffer);
    7219. 

  7219.   var HEAPU32 = new global.Uint32Array(buffer);
    7220. 

  7220.   var HEAPF32 = new global.Float32Array(buffer);
    7221. 

  7221.   var HEAPF64 = new global.Float64Array(buffer);
    7222. 

  7222. 

  7223.   var STACKTOP=env.STACKTOP|0;
    7224. 

  7224.   var STACK_MAX=env.STACK_MAX|0;
    7225. 

  7225.   var tempDoublePtr=env.tempDoublePtr|0;
    7226. 

  7226.   var ABORT=env.ABORT|0;
    7227. 

  7227.   var cttz_i8=env.cttz_i8|0;
    7228. 

  7228.   var ctlz_i8=env.ctlz_i8|0;
    7229. 

  7229.   var ___rand_seed=env.___rand_seed|0;
    7230. 

  7230.   var _stderr=env._stderr|0;
    7231. 

  7231.   var _stdin=env._stdin|0;
    7232. 

  7232.   var _stdout=env._stdout|0;
    7233. 

  7233. 

  7234.   var __THREW__ = 0;
    7235. 

  7235.   var threwValue = 0;
    7236. 

  7236.   var setjmpId = 0;
    7237. 

  7237.   var undef = 0;
    7238. 

  7238.   var nan = +env.NaN, inf = +env.Infinity;
    7239. 

  7239.   var tempInt = 0, tempBigInt = 0, tempBigIntP = 0, tempBigIntS = 0, tempBigIntR = 0.0, tempBigIntI = 0, tempBigIntD = 0, tempValue = 0, tempDouble = 0.0;
    7240. 

  7240. 

  7241.   var tempRet0 = 0;
    7242. 

  7242.   var tempRet1 = 0;
    7243. 

  7243.   var tempRet2 = 0;
    7244. 

  7244.   var tempRet3 = 0;
    7245. 

  7245.   var tempRet4 = 0;
    7246. 

  7246.   var tempRet5 = 0;
    7247. 

  7247.   var tempRet6 = 0;
    7248. 

  7248.   var tempRet7 = 0;
    7249. 

  7249.   var tempRet8 = 0;
    7250. 

  7250.   var tempRet9 = 0;
    7251. 

  7251.   var Math_floor=global.Math.floor;
    7252. 

  7252.   var Math_abs=global.Math.abs;
    7253. 

  7253.   var Math_sqrt=global.Math.sqrt;
    7254. 

  7254.   var Math_pow=global.Math.pow;
    7255. 

  7255.   var Math_cos=global.Math.cos;
    7256. 

  7256.   var Math_sin=global.Math.sin;
    7257. 

  7257.   var Math_tan=global.Math.tan;
    7258. 

  7258.   var Math_acos=global.Math.acos;
    7259. 

  7259.   var Math_asin=global.Math.asin;
    7260. 

  7260.   var Math_atan=global.Math.atan;
    7261. 

  7261.   var Math_atan2=global.Math.atan2;
    7262. 

  7262.   var Math_exp=global.Math.exp;
    7263. 

  7263.   var Math_log=global.Math.log;
    7264. 

  7264.   var Math_ceil=global.Math.ceil;
    7265. 

  7265.   var Math_imul=global.Math.imul;
    7266. 

  7266.   var abort=env.abort;
    7267. 

  7267.   var assert=env.assert;
    7268. 

  7268.   var asmPrintInt=env.asmPrintInt;
    7269. 

  7269.   var asmPrintFloat=env.asmPrintFloat;
    7270. 

  7270.   var Math_min=env.min;
    7271. 

  7271.   var invoke_iiii=env.invoke_iiii;
    7272. 

  7272.   var invoke_vi=env.invoke_vi;
    7273. 

  7273.   var invoke_vii=env.invoke_vii;
    7274. 

  7274.   var invoke_ii=env.invoke_ii;
    7275. 

  7275.   var invoke_iiiii=env.invoke_iiiii;
    7276. 

  7276.   var invoke_iii=env.invoke_iii;
    7277. 

  7277.   var _isalnum=env._isalnum;
    7278. 

  7278.   var _fabs=env._fabs;
    7279. 

  7279.   var _frexp=env._frexp;
    7280. 

  7280.   var _exp=env._exp;
    7281. 

  7281.   var _fread=env._fread;
    7282. 

  7282.   var __reallyNegative=env.__reallyNegative;
    7283. 

  7283.   var _longjmp=env._longjmp;
    7284. 

  7284.   var __addDays=env.__addDays;
    7285. 

  7285.   var _fsync=env._fsync;
    7286. 

  7286.   var _signal=env._signal;
    7287. 

  7287.   var _rename=env._rename;
    7288. 

  7288.   var _sbrk=env._sbrk;
    7289. 

  7289.   var _emscripten_memcpy_big=env._emscripten_memcpy_big;
    7290. 

  7290.   var _sinh=env._sinh;
    7291. 

  7291.   var _sysconf=env._sysconf;
    7292. 

  7292.   var _close=env._close;
    7293. 

  7293.   var _ferror=env._ferror;
    7294. 

  7294.   var _clock=env._clock;
    7295. 

  7295.   var _cos=env._cos;
    7296. 

  7296.   var _tanh=env._tanh;
    7297. 

  7297.   var _unlink=env._unlink;
    7298. 

  7298.   var _write=env._write;
    7299. 

  7299.   var __isLeapYear=env.__isLeapYear;
    7300. 

  7300.   var _ftell=env._ftell;
    7301. 

  7301.   var _isupper=env._isupper;
    7302. 

  7302.   var _gmtime_r=env._gmtime_r;
    7303. 

  7303.   var _islower=env._islower;
    7304. 

  7304.   var _tmpnam=env._tmpnam;
    7305. 

  7305.   var _tmpfile=env._tmpfile;
    7306. 

  7306.   var _send=env._send;
    7307. 

  7307.   var _abort=env._abort;
    7308. 

  7308.   var _setvbuf=env._setvbuf;
    7309. 

  7309.   var _atan2=env._atan2;
    7310. 

  7310.   var _setlocale=env._setlocale;
    7311. 

  7311.   var _isgraph=env._isgraph;
    7312. 

  7312.   var _modf=env._modf;
    7313. 

  7313.   var _strerror_r=env._strerror_r;
    7314. 

  7314.   var _fscanf=env._fscanf;
    7315. 

  7315.   var ___setErrNo=env.___setErrNo;
    7316. 

  7316.   var _isalpha=env._isalpha;
    7317. 

  7317.   var _srand=env._srand;
    7318. 

  7318.   var _mktime=env._mktime;
    7319. 

  7319.   var _putchar=env._putchar;
    7320. 

  7320.   var _gmtime=env._gmtime;
    7321. 

  7321.   var _localeconv=env._localeconv;
    7322. 

  7322.   var _sprintf=env._sprintf;
    7323. 

  7323.   var _localtime=env._localtime;
    7324. 

  7324.   var _read=env._read;
    7325. 

  7325.   var _fwrite=env._fwrite;
    7326. 

  7326.   var _time=env._time;
    7327. 

  7327.   var _fprintf=env._fprintf;
    7328. 

  7328.   var _exit=env._exit;
    7329. 

  7329.   var _freopen=env._freopen;
    7330. 

  7330.   var _llvm_pow_f64=env._llvm_pow_f64;
    7331. 

  7331.   var _fgetc=env._fgetc;
    7332. 

  7332.   var _fmod=env._fmod;
    7333. 

  7333.   var _lseek=env._lseek;
    7334. 

  7334.   var _rmdir=env._rmdir;
    7335. 

  7335.   var _asin=env._asin;
    7336. 

  7336.   var _floor=env._floor;
    7337. 

  7337.   var _pwrite=env._pwrite;
    7338. 

  7338.   var _localtime_r=env._localtime_r;
    7339. 

  7339.   var _tzset=env._tzset;
    7340. 

  7340.   var _open=env._open;
    7341. 

  7341.   var _remove=env._remove;
    7342. 

  7342.   var _snprintf=env._snprintf;
    7343. 

  7343.   var __scanString=env.__scanString;
    7344. 

  7344.   var _strftime=env._strftime;
    7345. 

  7345.   var _fseek=env._fseek;
    7346. 

  7346.   var _iscntrl=env._iscntrl;
    7347. 

  7347.   var _isxdigit=env._isxdigit;
    7348. 

  7348.   var _fclose=env._fclose;
    7349. 

  7349.   var _log=env._log;
    7350. 

  7350.   var _recv=env._recv;
    7351. 

  7351.   var _tan=env._tan;
    7352. 

  7352.   var _copysign=env._copysign;
    7353. 

  7353.   var __getFloat=env.__getFloat;
    7354. 

  7354.   var _fputc=env._fputc;
    7355. 

  7355.   var _ispunct=env._ispunct;
    7356. 

  7356.   var _ceil=env._ceil;
    7357. 

  7357.   var _isspace=env._isspace;
    7358. 

  7358.   var _fopen=env._fopen;
    7359. 

  7359.   var _sin=env._sin;
    7360. 

  7360.   var _acos=env._acos;
    7361. 

  7361.   var _cosh=env._cosh;
    7362. 

  7362.   var ___buildEnvironment=env.___buildEnvironment;
    7363. 

  7363.   var _difftime=env._difftime;
    7364. 

  7364.   var _ungetc=env._ungetc;
    7365. 

  7365.   var _system=env._system;
    7366. 

  7366.   var _fflush=env._fflush;
    7367. 

  7367.   var _log10=env._log10;
    7368. 

  7368.   var _fileno=env._fileno;
    7369. 

  7369.   var __exit=env.__exit;
    7370. 

  7370.   var __arraySum=env.__arraySum;
    7371. 

  7371.   var _fgets=env._fgets;
    7372. 

  7372.   var _atan=env._atan;
    7373. 

  7373.   var _pread=env._pread;
    7374. 

  7374.   var _mkport=env._mkport;
    7375. 

  7375.   var _toupper=env._toupper;
    7376. 

  7376.   var _feof=env._feof;
    7377. 

  7377.   var ___errno_location=env.___errno_location;
    7378. 

  7378.   var _clearerr=env._clearerr;
    7379. 

  7379.   var _getenv=env._getenv;
    7380. 

  7380.   var _strerror=env._strerror;
    7381. 

  7381.   var _emscripten_longjmp=env._emscripten_longjmp;
    7382. 

  7382.   var __formatString=env.__formatString;
    7383. 

  7383.   var _fputs=env._fputs;
    7384. 

  7384.   var _sqrt=env._sqrt;
    7385. 

  7385.   var tempFloat = 0.0;
    7386. 

  7386. 

  7387. // EMSCRIPTEN_START_FUNCS
    7388. 

  7388. function _malloc(i12) {
    7389. 

  7389.  i12 = i12 | 0;
    7390. 

  7390.  var i1 = 0, i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i13 = 0, i14 = 0, i15 = 0, i16 = 0, i17 = 0, i18 = 0, i19 = 0, i20 = 0, i21 = 0, i22 = 0, i23 = 0, i24 = 0, i25 = 0, i26 = 0, i27 = 0, i28 = 0, i29 = 0, i30 = 0, i31 = 0, i32 = 0;
    7391. 

  7391.  i1 = STACKTOP;
    7392. 

  7392.  do {
    7393. 

  7393.   if (i12 >>> 0 < 245) {
    7394. 

  7394.    if (i12 >>> 0 < 11) {
    7395. 

  7395.     i12 = 16;
    7396. 

  7396.    } else {
    7397. 

  7397.     i12 = i12 + 11 & -8;
    7398. 

  7398.    }
    7399. 

  7399.    i20 = i12 >>> 3;
    7400. 

  7400.    i18 = HEAP32[3228] | 0;
    7401. 

  7401.    i21 = i18 >>> i20;
    7402. 

  7402.    if ((i21 & 3 | 0) != 0) {
    7403. 

  7403.     i6 = (i21 & 1 ^ 1) + i20 | 0;
    7404. 

  7404.     i5 = i6 << 1;
    7405. 

  7405.     i3 = 12952 + (i5 << 2) | 0;
    7406. 

  7406.     i5 = 12952 + (i5 + 2 << 2) | 0;
    7407. 

  7407.     i7 = HEAP32[i5 >> 2] | 0;
    7408. 

  7408.     i2 = i7 + 8 | 0;
    7409. 

  7409.     i4 = HEAP32[i2 >> 2] | 0;
    7410. 

  7410.     do {
    7411. 

  7411.      if ((i3 | 0) != (i4 | 0)) {
    7412. 

  7412.       if (i4 >>> 0 < (HEAP32[12928 >> 2] | 0) >>> 0) {
    7413. 

  7413.        _abort();
    7414. 

  7414.       }
    7415. 

  7415.       i8 = i4 + 12 | 0;
    7416. 

  7416.       if ((HEAP32[i8 >> 2] | 0) == (i7 | 0)) {
    7417. 

  7417.        HEAP32[i8 >> 2] = i3;
    7418. 

  7418.        HEAP32[i5 >> 2] = i4;
    7419. 

  7419.        break;
    7420. 

  7420.       } else {
    7421. 

  7421.        _abort();
    7422. 

  7422.       }
    7423. 

  7423.      } else {
    7424. 

  7424.       HEAP32[3228] = i18 & ~(1 << i6);
    7425. 

  7425.      }
    7426. 

  7426.     } while (0);
    7427. 

  7427.     i32 = i6 << 3;
    7428. 

  7428.     HEAP32[i7 + 4 >> 2] = i32 | 3;
    7429. 

  7429.     i32 = i7 + (i32 | 4) | 0;
    7430. 

  7430.     HEAP32[i32 >> 2] = HEAP32[i32 >> 2] | 1;
    7431. 

  7431.     i32 = i2;
    7432. 

  7432.     STACKTOP = i1;
    7433. 

  7433.     return i32 | 0;
    7434. 

  7434.    }
    7435. 

  7435.    if (i12 >>> 0 > (HEAP32[12920 >> 2] | 0) >>> 0) {
    7436. 

  7436.     if ((i21 | 0) != 0) {
    7437. 

  7437.      i7 = 2 << i20;
    7438. 

  7438.      i7 = i21 << i20 & (i7 | 0 - i7);
    7439. 

  7439.      i7 = (i7 & 0 - i7) + -1 | 0;
    7440. 

  7440.      i2 = i7 >>> 12 & 16;
    7441. 

  7441.      i7 = i7 >>> i2;
    7442. 

  7442.      i6 = i7 >>> 5 & 8;
    7443. 

  7443.      i7 = i7 >>> i6;
    7444. 

  7444.      i5 = i7 >>> 2 & 4;
    7445. 

  7445.      i7 = i7 >>> i5;
    7446. 

  7446.      i4 = i7 >>> 1 & 2;
    7447. 

  7447.      i7 = i7 >>> i4;
    7448. 

  7448.      i3 = i7 >>> 1 & 1;
    7449. 

  7449.      i3 = (i6 | i2 | i5 | i4 | i3) + (i7 >>> i3) | 0;
    7450. 

  7450.      i7 = i3 << 1;
    7451. 

  7451.      i4 = 12952 + (i7 << 2) | 0;
    7452. 

  7452.      i7 = 12952 + (i7 + 2 << 2) | 0;
    7453. 

  7453.      i5 = HEAP32[i7 >> 2] | 0;
    7454. 

  7454.      i2 = i5 + 8 | 0;
    7455. 

  7455.      i6 = HEAP32[i2 >> 2] | 0;
    7456. 

  7456.      do {
    7457. 

  7457.       if ((i4 | 0) != (i6 | 0)) {
    7458. 

  7458.        if (i6 >>> 0 < (HEAP32[12928 >> 2] | 0) >>> 0) {
    7459. 

  7459.         _abort();
    7460. 

  7460.        }
    7461. 

  7461.        i8 = i6 + 12 | 0;
    7462. 

  7462.        if ((HEAP32[i8 >> 2] | 0) == (i5 | 0)) {
    7463. 

  7463.         HEAP32[i8 >> 2] = i4;
    7464. 

  7464.         HEAP32[i7 >> 2] = i6;
    7465. 

  7465.         break;
    7466. 

  7466.        } else {
    7467. 

  7467.         _abort();
    7468. 

  7468.        }
    7469. 

  7469.       } else {
    7470. 

  7470.        HEAP32[3228] = i18 & ~(1 << i3);
    7471. 

  7471.       }
    7472. 

  7472.      } while (0);
    7473. 

  7473.      i6 = i3 << 3;
    7474. 

  7474.      i4 = i6 - i12 | 0;
    7475. 

  7475.      HEAP32[i5 + 4 >> 2] = i12 | 3;
    7476. 

  7476.      i3 = i5 + i12 | 0;
    7477. 

  7477.      HEAP32[i5 + (i12 | 4) >> 2] = i4 | 1;
    7478. 

  7478.      HEAP32[i5 + i6 >> 2] = i4;
    7479. 

  7479.      i6 = HEAP32[12920 >> 2] | 0;
    7480. 

  7480.      if ((i6 | 0) != 0) {
    7481. 

  7481.       i5 = HEAP32[12932 >> 2] | 0;
    7482. 

  7482.       i8 = i6 >>> 3;
    7483. 

  7483.       i9 = i8 << 1;
    7484. 

  7484.       i6 = 12952 + (i9 << 2) | 0;
    7485. 

  7485.       i7 = HEAP32[3228] | 0;
    7486. 

  7486.       i8 = 1 << i8;
    7487. 

  7487.       if ((i7 & i8 | 0) != 0) {
    7488. 

  7488.        i7 = 12952 + (i9 + 2 << 2) | 0;
    7489. 

  7489.        i8 = HEAP32[i7 >> 2] | 0;
    7490. 

  7490.        if (i8 >>> 0 < (HEAP32[12928 >> 2] | 0) >>> 0) {
    7491. 

  7491.         _abort();
    7492. 

  7492.        } else {
    7493. 

  7493.         i28 = i7;
    7494. 

  7494.         i27 = i8;
    7495. 

  7495.        }
    7496. 

  7496.       } else {
    7497. 

  7497.        HEAP32[3228] = i7 | i8;
    7498. 

  7498.        i28 = 12952 + (i9 + 2 << 2) | 0;
    7499. 

  7499.        i27 = i6;
    7500. 

  7500.       }
    7501. 

  7501.       HEAP32[i28 >> 2] = i5;
    7502. 

  7502.       HEAP32[i27 + 12 >> 2] = i5;
    7503. 

  7503.       HEAP32[i5 + 8 >> 2] = i27;
    7504. 

  7504.       HEAP32[i5 + 12 >> 2] = i6;
    7505. 

  7505.      }
    7506. 

  7506.      HEAP32[12920 >> 2] = i4;
    7507. 

  7507.      HEAP32[12932 >> 2] = i3;
    7508. 

  7508.      i32 = i2;
    7509. 

  7509.      STACKTOP = i1;
    7510. 

  7510.      return i32 | 0;
    7511. 

  7511.     }
    7512. 

  7512.     i18 = HEAP32[12916 >> 2] | 0;
    7513. 

  7513.     if ((i18 | 0) != 0) {
    7514. 

  7514.      i2 = (i18 & 0 - i18) + -1 | 0;
    7515. 

  7515.      i31 = i2 >>> 12 & 16;
    7516. 

  7516.      i2 = i2 >>> i31;
    7517. 

  7517.      i30 = i2 >>> 5 & 8;
    7518. 

  7518.      i2 = i2 >>> i30;
    7519. 

  7519.      i32 = i2 >>> 2 & 4;
    7520. 

  7520.      i2 = i2 >>> i32;
    7521. 

  7521.      i6 = i2 >>> 1 & 2;
    7522. 

  7522.      i2 = i2 >>> i6;
    7523. 

  7523.      i3 = i2 >>> 1 & 1;
    7524. 

  7524.      i3 = HEAP32[13216 + ((i30 | i31 | i32 | i6 | i3) + (i2 >>> i3) << 2) >> 2] | 0;
    7525. 

  7525.      i2 = (HEAP32[i3 + 4 >> 2] & -8) - i12 | 0;
    7526. 

  7526.      i6 = i3;
    7527. 

  7527.      while (1) {
    7528. 

  7528.       i5 = HEAP32[i6 + 16 >> 2] | 0;
    7529. 

  7529.       if ((i5 | 0) == 0) {
    7530. 

  7530.        i5 = HEAP32[i6 + 20 >> 2] | 0;
    7531. 

  7531.        if ((i5 | 0) == 0) {
    7532. 

  7532.         break;
    7533. 

  7533.        }
    7534. 

  7534.       }
    7535. 

  7535.       i6 = (HEAP32[i5 + 4 >> 2] & -8) - i12 | 0;
    7536. 

  7536.       i4 = i6 >>> 0 < i2 >>> 0;
    7537. 

  7537.       i2 = i4 ? i6 : i2;
    7538. 

  7538.       i6 = i5;
    7539. 

  7539.       i3 = i4 ? i5 : i3;
    7540. 

  7540.      }
    7541. 

  7541.      i6 = HEAP32[12928 >> 2] | 0;
    7542. 

  7542.      if (i3 >>> 0 < i6 >>> 0) {
    7543. 

  7543.       _abort();
    7544. 

  7544.      }
    7545. 

  7545.      i4 = i3 + i12 | 0;
    7546. 

  7546.      if (!(i3 >>> 0 < i4 >>> 0)) {
    7547. 

  7547.       _abort();
    7548. 

  7548.      }
    7549. 

  7549.      i5 = HEAP32[i3 + 24 >> 2] | 0;
    7550. 

  7550.      i7 = HEAP32[i3 + 12 >> 2] | 0;
    7551. 

  7551.      do {
    7552. 

  7552.       if ((i7 | 0) == (i3 | 0)) {
    7553. 

  7553.        i8 = i3 + 20 | 0;
    7554. 

  7554.        i7 = HEAP32[i8 >> 2] | 0;
    7555. 

  7555.        if ((i7 | 0) == 0) {
    7556. 

  7556.         i8 = i3 + 16 | 0;
    7557. 

  7557.         i7 = HEAP32[i8 >> 2] | 0;
    7558. 

  7558.         if ((i7 | 0) == 0) {
    7559. 

  7559.          i26 = 0;
    7560. 

  7560.          break;
    7561. 

  7561.         }
    7562. 

  7562.        }
    7563. 

  7563.        while (1) {
    7564. 

  7564.         i10 = i7 + 20 | 0;
    7565. 

  7565.         i9 = HEAP32[i10 >> 2] | 0;
    7566. 

  7566.         if ((i9 | 0) != 0) {
    7567. 

  7567.          i7 = i9;
    7568. 

  7568.          i8 = i10;
    7569. 

  7569.          continue;
    7570. 

  7570.         }
    7571. 

  7571.         i10 = i7 + 16 | 0;
    7572. 

  7572.         i9 = HEAP32[i10 >> 2] | 0;
    7573. 

  7573.         if ((i9 | 0) == 0) {
    7574. 

  7574.          break;
    7575. 

  7575.         } else {
    7576. 

  7576.          i7 = i9;
    7577. 

  7577.          i8 = i10;
    7578. 

  7578.         }
    7579. 

  7579.        }
    7580. 

  7580.        if (i8 >>> 0 < i6 >>> 0) {
    7581. 

  7581.         _abort();
    7582. 

  7582.        } else {
    7583. 

  7583.         HEAP32[i8 >> 2] = 0;
    7584. 

  7584.         i26 = i7;
    7585. 

  7585.         break;
    7586. 

  7586.        }
    7587. 

  7587.       } else {
    7588. 

  7588.        i8 = HEAP32[i3 + 8 >> 2] | 0;
    7589. 

  7589.        if (i8 >>> 0 < i6 >>> 0) {
    7590. 

  7590.         _abort();
    7591. 

  7591.        }
    7592. 

  7592.        i6 = i8 + 12 | 0;
    7593. 

  7593.        if ((HEAP32[i6 >> 2] | 0) != (i3 | 0)) {
    7594. 

  7594.         _abort();
    7595. 

  7595.        }
    7596. 

  7596.        i9 = i7 + 8 | 0;
    7597. 

  7597.        if ((HEAP32[i9 >> 2] | 0) == (i3 | 0)) {
    7598. 

  7598.         HEAP32[i6 >> 2] = i7;
    7599. 

  7599.         HEAP32[i9 >> 2] = i8;
    7600. 

  7600.         i26 = i7;
    7601. 

  7601.         break;
    7602. 

  7602.        } else {
    7603. 

  7603.         _abort();
    7604. 

  7604.        }
    7605. 

  7605.       }
    7606. 

  7606.      } while (0);
    7607. 

  7607.      do {
    7608. 

  7608.       if ((i5 | 0) != 0) {
    7609. 

  7609.        i7 = HEAP32[i3 + 28 >> 2] | 0;
    7610. 

  7610.        i6 = 13216 + (i7 << 2) | 0;
    7611. 

  7611.        if ((i3 | 0) == (HEAP32[i6 >> 2] | 0)) {
    7612. 

  7612.         HEAP32[i6 >> 2] = i26;
    7613. 

  7613.         if ((i26 | 0) == 0) {
    7614. 

  7614.          HEAP32[12916 >> 2] = HEAP32[12916 >> 2] & ~(1 << i7);
    7615. 

  7615.          break;
    7616. 

  7616.         }
    7617. 

  7617.        } else {
    7618. 

  7618.         if (i5 >>> 0 < (HEAP32[12928 >> 2] | 0) >>> 0) {
    7619. 

  7619.          _abort();
    7620. 

  7620.         }
    7621. 

  7621.         i6 = i5 + 16 | 0;
    7622. 

  7622.         if ((HEAP32[i6 >> 2] | 0) == (i3 | 0)) {
    7623. 

  7623.          HEAP32[i6 >> 2] = i26;
    7624. 

  7624.         } else {
    7625. 

  7625.          HEAP32[i5 + 20 >> 2] = i26;
    7626. 

  7626.         }
    7627. 

  7627.         if ((i26 | 0) == 0) {
    7628. 

  7628.          break;
    7629. 

  7629.         }
    7630. 

  7630.        }
    7631. 

  7631.        if (i26 >>> 0 < (HEAP32[12928 >> 2] | 0) >>> 0) {
    7632. 

  7632.         _abort();
    7633. 

  7633.        }
    7634. 

  7634.        HEAP32[i26 + 24 >> 2] = i5;
    7635. 

  7635.        i5 = HEAP32[i3 + 16 >> 2] | 0;
    7636. 

  7636.        do {
    7637. 

  7637.         if ((i5 | 0) != 0) {
    7638. 

  7638.          if (i5 >>> 0 < (HEAP32[12928 >> 2] | 0) >>> 0) {
    7639. 

  7639.           _abort();
    7640. 

  7640.          } else {
    7641. 

  7641.           HEAP32[i26 + 16 >> 2] = i5;
    7642. 

  7642.           HEAP32[i5 + 24 >> 2] = i26;
    7643. 

  7643.           break;
    7644. 

  7644.          }
    7645. 

  7645.         }
    7646. 

  7646.        } while (0);
    7647. 

  7647.        i5 = HEAP32[i3 + 20 >> 2] | 0;
    7648. 

  7648.        if ((i5 | 0) != 0) {
    7649. 

  7649.         if (i5 >>> 0 < (HEAP32[12928 >> 2] | 0) >>> 0) {
    7650. 

  7650.          _abort();
    7651. 

  7651.         } else {
    7652. 

  7652.          HEAP32[i26 + 20 >> 2] = i5;
    7653. 

  7653.          HEAP32[i5 + 24 >> 2] = i26;
    7654. 

  7654.          break;
    7655. 

  7655.         }
    7656. 

  7656.        }
    7657. 

  7657.       }
    7658. 

  7658.      } while (0);
    7659. 

  7659.      if (i2 >>> 0 < 16) {
    7660. 

  7660.       i32 = i2 + i12 | 0;
    7661. 

  7661.       HEAP32[i3 + 4 >> 2] = i32 | 3;
    7662. 

  7662.       i32 = i3 + (i32 + 4) | 0;
    7663. 

  7663.       HEAP32[i32 >> 2] = HEAP32[i32 >> 2] | 1;
    7664. 

  7664.      } else {
    7665. 

  7665.       HEAP32[i3 + 4 >> 2] = i12 | 3;
    7666. 

  7666.       HEAP32[i3 + (i12 | 4) >> 2] = i2 | 1;
    7667. 

  7667.       HEAP32[i3 + (i2 + i12) >> 2] = i2;
    7668. 

  7668.       i6 = HEAP32[12920 >> 2] | 0;
    7669. 

  7669.       if ((i6 | 0) != 0) {
    7670. 

  7670.        i5 = HEAP32[12932 >> 2] | 0;
    7671. 

  7671.        i8 = i6 >>> 3;
    7672. 

  7672.        i9 = i8 << 1;
    7673. 

  7673.        i6 = 12952 + (i9 << 2) | 0;
    7674. 

  7674.        i7 = HEAP32[3228] | 0;
    7675. 

  7675.        i8 = 1 << i8;
    7676. 

  7676.        if ((i7 & i8 | 0) != 0) {
    7677. 

  7677.         i7 = 12952 + (i9 + 2 << 2) | 0;
    7678. 

  7678.         i8 = HEAP32[i7 >> 2] | 0;
    7679. 

  7679.         if (i8 >>> 0 < (HEAP32[12928 >> 2] | 0) >>> 0) {
    7680. 

  7680.          _abort();
    7681. 

  7681.         } else {
    7682. 

  7682.          i25 = i7;
    7683. 

  7683.          i24 = i8;
    7684. 

  7684.         }
    7685. 

  7685.        } else {
    7686. 

  7686.         HEAP32[3228] = i7 | i8;
    7687. 

  7687.         i25 = 12952 + (i9 + 2 << 2) | 0;
    7688. 

  7688.         i24 = i6;
    7689. 

  7689.        }
    7690. 

  7690.        HEAP32[i25 >> 2] = i5;
    7691. 

  7691.        HEAP32[i24 + 12 >> 2] = i5;
    7692. 

  7692.        HEAP32[i5 + 8 >> 2] = i24;
    7693. 

  7693.        HEAP32[i5 + 12 >> 2] = i6;
    7694. 

  7694.       }
    7695. 

  7695.       HEAP32[12920 >> 2] = i2;
    7696. 

  7696.       HEAP32[12932 >> 2] = i4;
    7697. 

  7697.      }
    7698. 

  7698.      i32 = i3 + 8 | 0;
    7699. 

  7699.      STACKTOP = i1;
    7700. 

  7700.      return i32 | 0;
    7701. 

  7701.     }
    7702. 

  7702.    }
    7703. 

  7703.   } else {
    7704. 

  7704.    if (!(i12 >>> 0 > 4294967231)) {
    7705. 

  7705.     i24 = i12 + 11 | 0;
    7706. 

  7706.     i12 = i24 & -8;
    7707. 

  7707.     i26 = HEAP32[12916 >> 2] | 0;
    7708. 

  7708.     if ((i26 | 0) != 0) {
    7709. 

  7709.      i25 = 0 - i12 | 0;
    7710. 

  7710.      i24 = i24 >>> 8;
    7711. 

  7711.      if ((i24 | 0) != 0) {
    7712. 

  7712.       if (i12 >>> 0 > 16777215) {
    7713. 

  7713.        i27 = 31;
    7714. 

  7714.       } else {
    7715. 

  7715.        i31 = (i24 + 1048320 | 0) >>> 16 & 8;
    7716. 

  7716.        i32 = i24 << i31;
    7717. 

  7717.        i30 = (i32 + 520192 | 0) >>> 16 & 4;
    7718. 

  7718.        i32 = i32 << i30;
    7719. 

  7719.        i27 = (i32 + 245760 | 0) >>> 16 & 2;
    7720. 

  7720.        i27 = 14 - (i30 | i31 | i27) + (i32 << i27 >>> 15) | 0;
    7721. 

  7721.        i27 = i12 >>> (i27 + 7 | 0) & 1 | i27 << 1;
    7722. 

  7722.       }
    7723. 

  7723.      } else {
    7724. 

  7724.       i27 = 0;
    7725. 

  7725.      }
    7726. 

  7726.      i30 = HEAP32[13216 + (i27 << 2) >> 2] | 0;
    7727. 

  7727.      L126 : do {
    7728. 

  7728.       if ((i30 | 0) == 0) {
    7729. 

  7729.        i29 = 0;
    7730. 

  7730.        i24 = 0;
    7731. 

  7731.       } else {
    7732. 

  7732.        if ((i27 | 0) == 31) {
    7733. 

  7733.         i24 = 0;
    7734. 

  7734.        } else {
    7735. 

  7735.         i24 = 25 - (i27 >>> 1) | 0;
    7736. 

  7736.        }
    7737. 

  7737.        i29 = 0;
    7738. 

  7738.        i28 = i12 << i24;
    7739. 

  7739.        i24 = 0;
    7740. 

  7740.        while (1) {
    7741. 

  7741.         i32 = HEAP32[i30 + 4 >> 2] & -8;
    7742. 

  7742.         i31 = i32 - i12 | 0;
    7743. 

  7743.         if (i31 >>> 0 < i25 >>> 0) {
    7744. 

  7744.          if ((i32 | 0) == (i12 | 0)) {
    7745. 

  7745.           i25 = i31;
    7746. 

  7746.           i29 = i30;
    7747. 

  7747.           i24 = i30;
    7748. 

  7748.           break L126;
    7749. 

  7749.          } else {
    7750. 

  7750.           i25 = i31;
    7751. 

  7751.           i24 = i30;
    7752. 

  7752.          }
    7753. 

  7753.         }
    7754. 

  7754.         i31 = HEAP32[i30 + 20 >> 2] | 0;
    7755. 

  7755.         i30 = HEAP32[i30 + (i28 >>> 31 << 2) + 16 >> 2] | 0;
    7756. 

  7756.         i29 = (i31 | 0) == 0 | (i31 | 0) == (i30 | 0) ? i29 : i31;
    7757. 

  7757.         if ((i30 | 0) == 0) {
    7758. 

  7758.          break;
    7759. 

  7759.         } else {
    7760. 

  7760.          i28 = i28 << 1;
    7761. 

  7761.         }
    7762. 

  7762.        }
    7763. 

  7763.       }
    7764. 

  7764.      } while (0);
    7765. 

  7765.      if ((i29 | 0) == 0 & (i24 | 0) == 0) {
    7766. 

  7766.       i32 = 2 << i27;
    7767. 

  7767.       i26 = i26 & (i32 | 0 - i32);
    7768. 

  7768.       if ((i26 | 0) == 0) {
    7769. 

  7769.        break;
    7770. 

  7770.       }
    7771. 

  7771.       i32 = (i26 & 0 - i26) + -1 | 0;
    7772. 

  7772.       i28 = i32 >>> 12 & 16;
    7773. 

  7773.       i32 = i32 >>> i28;
    7774. 

  7774.       i27 = i32 >>> 5 & 8;
    7775. 

  7775.       i32 = i32 >>> i27;
    7776. 

  7776.       i30 = i32 >>> 2 & 4;
    7777. 

  7777.       i32 = i32 >>> i30;
    7778. 

  7778.       i31 = i32 >>> 1 & 2;
    7779. 

  7779.       i32 = i32 >>> i31;
    7780. 

  7780.       i29 = i32 >>> 1 & 1;
    7781. 

  7781.       i29 = HEAP32[13216 + ((i27 | i28 | i30 | i31 | i29) + (i32 >>> i29) << 2) >> 2] | 0;
    7782. 

  7782.      }
    7783. 

  7783.      if ((i29 | 0) != 0) {
    7784. 

  7784.       while (1) {
    7785. 

  7785.        i27 = (HEAP32[i29 + 4 >> 2] & -8) - i12 | 0;
    7786. 

  7786.        i26 = i27 >>> 0 < i25 >>> 0;
    7787. 

  7787.        i25 = i26 ? i27 : i25;
    7788. 

  7788.        i24 = i26 ? i29 : i24;
    7789. 

  7789.        i26 = HEAP32[i29 + 16 >> 2] | 0;
    7790. 

  7790.        if ((i26 | 0) != 0) {
    7791. 

  7791.         i29 = i26;
    7792. 

  7792.         continue;
    7793. 

  7793.        }
    7794. 

  7794.        i29 = HEAP32[i29 + 20 >> 2] | 0;
    7795. 

  7795.        if ((i29 | 0) == 0) {
    7796. 

  7796.         break;
    7797. 

  7797.        }
    7798. 

  7798.       }
    7799. 

  7799.      }
    7800. 

  7800.      if ((i24 | 0) != 0 ? i25 >>> 0 < ((HEAP32[12920 >> 2] | 0) - i12 | 0) >>> 0 : 0) {
    7801. 

  7801.       i4 = HEAP32[12928 >> 2] | 0;
    7802. 

  7802.       if (i24 >>> 0 < i4 >>> 0) {
    7803. 

  7803.        _abort();
    7804. 

  7804.       }
    7805. 

  7805.       i2 = i24 + i12 | 0;
    7806. 

  7806.       if (!(i24 >>> 0 < i2 >>> 0)) {
    7807. 

  7807.        _abort();
    7808. 

  7808.       }
    7809. 

  7809.       i3 = HEAP32[i24 + 24 >> 2] | 0;
    7810. 

  7810.       i6 = HEAP32[i24 + 12 >> 2] | 0;
    7811. 

  7811.       do {
    7812. 

  7812.        if ((i6 | 0) == (i24 | 0)) {
    7813. 

  7813.         i6 = i24 + 20 | 0;
    7814. 

  7814.         i5 = HEAP32[i6 >> 2] | 0;
    7815. 

  7815.         if ((i5 | 0) == 0) {
    7816. 

  7816.          i6 = i24 + 16 | 0;
    7817. 

  7817.          i5 = HEAP32[i6 >> 2] | 0;
    7818. 

  7818.          if ((i5 | 0) == 0) {
    7819. 

  7819.           i22 = 0;
    7820. 

  7820.           break;
    7821. 

  7821.          }
    7822. 

  7822.         }
    7823. 

  7823.         while (1) {
    7824. 

  7824.          i8 = i5 + 20 | 0;
    7825. 

  7825.          i7 = HEAP32[i8 >> 2] | 0;
    7826. 

  7826.          if ((i7 | 0) != 0) {
    7827. 

  7827.           i5 = i7;
    7828. 

  7828.           i6 = i8;
    7829. 

  7829.           continue;
    7830. 

  7830.          }
    7831. 

  7831.          i7 = i5 + 16 | 0;
    7832. 

  7832.          i8 = HEAP32[i7 >> 2] | 0;
    7833. 

  7833.          if ((i8 | 0) == 0) {
    7834. 

  7834.           break;
    7835. 

  7835.          } else {
    7836. 

  7836.           i5 = i8;
    7837. 

  7837.           i6 = i7;
    7838. 

  7838.          }
    7839. 

  7839.         }
    7840. 

  7840.         if (i6 >>> 0 < i4 >>> 0) {
    7841. 

  7841.          _abort();
    7842. 

  7842.         } else {
    7843. 

  7843.          HEAP32[i6 >> 2] = 0;
    7844. 

  7844.          i22 = i5;
    7845. 

  7845.          break;
    7846. 

  7846.         }
    7847. 

  7847.        } else {
    7848. 

  7848.         i5 = HEAP32[i24 + 8 >> 2] | 0;
    7849. 

  7849.         if (i5 >>> 0 < i4 >>> 0) {
    7850. 

  7850.          _abort();
    7851. 

  7851.         }
    7852. 

  7852.         i7 = i5 + 12 | 0;
    7853. 

  7853.         if ((HEAP32[i7 >> 2] | 0) != (i24 | 0)) {
    7854. 

  7854.          _abort();
    7855. 

  7855.         }
    7856. 

  7856.         i4 = i6 + 8 | 0;
    7857. 

  7857.         if ((HEAP32[i4 >> 2] | 0) == (i24 | 0)) {
    7858. 

  7858.          HEAP32[i7 >> 2] = i6;
    7859. 

  7859.          HEAP32[i4 >> 2] = i5;
    7860. 

  7860.          i22 = i6;
    7861. 

  7861.          break;
    7862. 

  7862.         } else {
    7863. 

  7863.          _abort();
    7864. 

  7864.         }
    7865. 

  7865.        }
    7866. 

  7866.       } while (0);
    7867. 

  7867.       do {
    7868. 

  7868.        if ((i3 | 0) != 0) {
    7869. 

  7869.         i4 = HEAP32[i24 + 28 >> 2] | 0;
    7870. 

  7870.         i5 = 13216 + (i4 << 2) | 0;
    7871. 

  7871.         if ((i24 | 0) == (HEAP32[i5 >> 2] | 0)) {
    7872. 

  7872.          HEAP32[i5 >> 2] = i22;
    7873. 

  7873.          if ((i22 | 0) == 0) {
    7874. 

  7874.           HEAP32[12916 >> 2] = HEAP32[12916 >> 2] & ~(1 << i4);
    7875. 

  7875.           break;
    7876. 

  7876.          }
    7877. 

  7877.         } else {
    7878. 

  7878.          if (i3 >>> 0 < (HEAP32[12928 >> 2] | 0) >>> 0) {
    7879. 

  7879.           _abort();
    7880. 

  7880.          }
    7881. 

  7881.          i4 = i3 + 16 | 0;
    7882. 

  7882.          if ((HEAP32[i4 >> 2] | 0) == (i24 | 0)) {
    7883. 

  7883.           HEAP32[i4 >> 2] = i22;
    7884. 

  7884.          } else {
    7885. 

  7885.           HEAP32[i3 + 20 >> 2] = i22;
    7886. 

  7886.          }
    7887. 

  7887.          if ((i22 | 0) == 0) {
    7888. 

  7888.           break;
    7889. 

  7889.          }
    7890. 

  7890.         }
    7891. 

  7891.         if (i22 >>> 0 < (HEAP32[12928 >> 2] | 0) >>> 0) {
    7892. 

  7892.          _abort();
    7893. 

  7893.         }
    7894. 

  7894.         HEAP32[i22 + 24 >> 2] = i3;
    7895. 

  7895.         i3 = HEAP32[i24 + 16 >> 2] | 0;
    7896. 

  7896.         do {
    7897. 

  7897.          if ((i3 | 0) != 0) {
    7898. 

  7898.           if (i3 >>> 0 < (HEAP32[12928 >> 2] | 0) >>> 0) {
    7899. 

  7899.            _abort();
    7900. 

  7900.           } else {
    7901. 

  7901.            HEAP32[i22 + 16 >> 2] = i3;
    7902. 

  7902.            HEAP32[i3 + 24 >> 2] = i22;
    7903. 

  7903.            break;
    7904. 

  7904.           }
    7905. 

  7905.          }
    7906. 

  7906.         } while (0);
    7907. 

  7907.         i3 = HEAP32[i24 + 20 >> 2] | 0;
    7908. 

  7908.         if ((i3 | 0) != 0) {
    7909. 

  7909.          if (i3 >>> 0 < (HEAP32[12928 >> 2] | 0) >>> 0) {
    7910. 

  7910.           _abort();
    7911. 

  7911.          } else {
    7912. 

  7912.           HEAP32[i22 + 20 >> 2] = i3;
    7913. 

  7913.           HEAP32[i3 + 24 >> 2] = i22;
    7914. 

  7914.           break;
    7915. 

  7915.          }
    7916. 

  7916.         }
    7917. 

  7917.        }
    7918. 

  7918.       } while (0);
    7919. 

  7919.       L204 : do {
    7920. 

  7920.        if (!(i25 >>> 0 < 16)) {
    7921. 

  7921.         HEAP32[i24 + 4 >> 2] = i12 | 3;
    7922. 

  7922.         HEAP32[i24 + (i12 | 4) >> 2] = i25 | 1;
    7923. 

  7923.         HEAP32[i24 + (i25 + i12) >> 2] = i25;
    7924. 

  7924.         i4 = i25 >>> 3;
    7925. 

  7925.         if (i25 >>> 0 < 256) {
    7926. 

  7926.          i6 = i4 << 1;
    7927. 

  7927.          i3 = 12952 + (i6 << 2) | 0;
    7928. 

  7928.          i5 = HEAP32[3228] | 0;
    7929. 

  7929.          i4 = 1 << i4;
    7930. 

  7930.          if ((i5 & i4 | 0) != 0) {
    7931. 

  7931.           i5 = 12952 + (i6 + 2 << 2) | 0;
    7932. 

  7932.           i4 = HEAP32[i5 >> 2] | 0;
    7933. 

  7933.           if (i4 >>> 0 < (HEAP32[12928 >> 2] | 0) >>> 0) {
    7934. 

  7934.            _abort();
    7935. 

  7935.           } else {
    7936. 

  7936.            i21 = i5;
    7937. 

  7937.            i20 = i4;
    7938. 

  7938.           }
    7939. 

  7939.          } else {
    7940. 

  7940.           HEAP32[3228] = i5 | i4;
    7941. 

  7941.           i21 = 12952 + (i6 + 2 << 2) | 0;
    7942. 

  7942.           i20 = i3;
    7943. 

  7943.          }
    7944. 

  7944.          HEAP32[i21 >> 2] = i2;
    7945. 

  7945.          HEAP32[i20 + 12 >> 2] = i2;
    7946. 

  7946.          HEAP32[i24 + (i12 + 8) >> 2] = i20;
    7947. 

  7947.          HEAP32[i24 + (i12 + 12) >> 2] = i3;
    7948. 

  7948.          break;
    7949. 

  7949.         }
    7950. 

  7950.         i3 = i25 >>> 8;
    7951. 

  7951.         if ((i3 | 0) != 0) {
    7952. 

  7952.          if (i25 >>> 0 > 16777215) {
    7953. 

  7953.           i3 = 31;
    7954. 

  7954.          } else {
    7955. 

  7955.           i31 = (i3 + 1048320 | 0) >>> 16 & 8;
    7956. 

  7956.           i32 = i3 << i31;
    7957. 

  7957.           i30 = (i32 + 520192 | 0) >>> 16 & 4;
    7958. 

  7958.           i32 = i32 << i30;
    7959. 

  7959.           i3 = (i32 + 245760 | 0) >>> 16 & 2;
    7960. 

  7960.           i3 = 14 - (i30 | i31 | i3) + (i32 << i3 >>> 15) | 0;
    7961. 

  7961.           i3 = i25 >>> (i3 + 7 | 0) & 1 | i3 << 1;
    7962. 

  7962.          }
    7963. 

  7963.         } else {
    7964. 

  7964.          i3 = 0;
    7965. 

  7965.         }
    7966. 

  7966.         i6 = 13216 + (i3 << 2) | 0;
    7967. 

  7967.         HEAP32[i24 + (i12 + 28) >> 2] = i3;
    7968. 

  7968.         HEAP32[i24 + (i12 + 20) >> 2] = 0;
    7969. 

  7969.         HEAP32[i24 + (i12 + 16) >> 2] = 0;
    7970. 

  7970.         i4 = HEAP32[12916 >> 2] | 0;
    7971. 

  7971.         i5 = 1 << i3;
    7972. 

  7972.         if ((i4 & i5 | 0) == 0) {
    7973. 

  7973.          HEAP32[12916 >> 2] = i4 | i5;
    7974. 

  7974.          HEAP32[i6 >> 2] = i2;
    7975. 

  7975.          HEAP32[i24 + (i12 + 24) >> 2] = i6;
    7976. 

  7976.          HEAP32[i24 + (i12 + 12) >> 2] = i2;
    7977. 

  7977.          HEAP32[i24 + (i12 + 8) >> 2] = i2;
    7978. 

  7978.          break;
    7979. 

  7979.         }
    7980. 

  7980.         i4 = HEAP32[i6 >> 2] | 0;
    7981. 

  7981.         if ((i3 | 0) == 31) {
    7982. 

  7982.          i3 = 0;
    7983. 

  7983.         } else {
    7984. 

  7984.          i3 = 25 - (i3 >>> 1) | 0;
    7985. 

  7985.         }
    7986. 

  7986.         L225 : do {
    7987. 

  7987.          if ((HEAP32[i4 + 4 >> 2] & -8 | 0) != (i25 | 0)) {
    7988. 

  7988.           i3 = i25 << i3;
    7989. 

  7989.           while (1) {
    7990. 

  7990.            i6 = i4 + (i3 >>> 31 << 2) + 16 | 0;
    7991. 

  7991.            i5 = HEAP32[i6 >> 2] | 0;
    7992. 

  7992.            if ((i5 | 0) == 0) {
    7993. 

  7993.             break;
    7994. 

  7994.            }
    7995. 

  7995.            if ((HEAP32[i5 + 4 >> 2] & -8 | 0) == (i25 | 0)) {
    7996. 

  7996.             i18 = i5;
    7997. 

  7997.             break L225;
    7998. 

  7998.            } else {
    7999. 

  7999.             i3 = i3 << 1;
    8000. 

  8000.             i4 = i5;
    8001. 

  8001.            }
    8002. 

  8002.           }
    8003. 

  8003.           if (i6 >>> 0 < (HEAP32[12928 >> 2] | 0) >>> 0) {
    8004. 

  8004.            _abort();
    8005. 

  8005.           } else {
    8006. 

  8006.            HEAP32[i6 >> 2] = i2;
    8007. 

  8007.            HEAP32[i24 + (i12 + 24) >> 2] = i4;
    8008. 

  8008.            HEAP32[i24 + (i12 + 12) >> 2] = i2;
    8009. 

  8009.            HEAP32[i24 + (i12 + 8) >> 2] = i2;
    8010. 

  8010.            break L204;
    8011. 

  8011.           }
    8012. 

  8012.          } else {
    8013. 

  8013.           i18 = i4;
    8014. 

  8014.          }
    8015. 

  8015.         } while (0);
    8016. 

  8016.         i4 = i18 + 8 | 0;
    8017. 

  8017.         i3 = HEAP32[i4 >> 2] | 0;
    8018. 

  8018.         i5 = HEAP32[12928 >> 2] | 0;
    8019. 

  8019.         if (i18 >>> 0 < i5 >>> 0) {
    8020. 

  8020.          _abort();
    8021. 

  8021.         }
    8022. 

  8022.         if (i3 >>> 0 < i5 >>> 0) {
    8023. 

  8023.          _abort();
    8024. 

  8024.         } else {
    8025. 

  8025.          HEAP32[i3 + 12 >> 2] = i2;
    8026. 

  8026.          HEAP32[i4 >> 2] = i2;
    8027. 

  8027.          HEAP32[i24 + (i12 + 8) >> 2] = i3;
    8028. 

  8028.          HEAP32[i24 + (i12 + 12) >> 2] = i18;
    8029. 

  8029.          HEAP32[i24 + (i12 + 24) >> 2] = 0;
    8030. 

  8030.          break;
    8031. 

  8031.         }
    8032. 

  8032.        } else {
    8033. 

  8033.         i32 = i25 + i12 | 0;
    8034. 

  8034.         HEAP32[i24 + 4 >> 2] = i32 | 3;
    8035. 

  8035.         i32 = i24 + (i32 + 4) | 0;
    8036. 

  8036.         HEAP32[i32 >> 2] = HEAP32[i32 >> 2] | 1;
    8037. 

  8037.        }
    8038. 

  8038.       } while (0);
    8039. 

  8039.       i32 = i24 + 8 | 0;
    8040. 

  8040.       STACKTOP = i1;
    8041. 

  8041.       return i32 | 0;
    8042. 

  8042.      }
    8043. 

  8043.     }
    8044. 

  8044.    } else {
    8045. 

  8045.     i12 = -1;
    8046. 

  8046.    }
    8047. 

  8047.   }
    8048. 

  8048.  } while (0);
    8049. 

  8049.  i18 = HEAP32[12920 >> 2] | 0;
    8050. 

  8050.  if (!(i12 >>> 0 > i18 >>> 0)) {
    8051. 

  8051.   i3 = i18 - i12 | 0;
    8052. 

  8052.   i2 = HEAP32[12932 >> 2] | 0;
    8053. 

  8053.   if (i3 >>> 0 > 15) {
    8054. 

  8054.    HEAP32[12932 >> 2] = i2 + i12;
    8055. 

  8055.    HEAP32[12920 >> 2] = i3;
    8056. 

  8056.    HEAP32[i2 + (i12 + 4) >> 2] = i3 | 1;
    8057. 

  8057.    HEAP32[i2 + i18 >> 2] = i3;
    8058. 

  8058.    HEAP32[i2 + 4 >> 2] = i12 | 3;
    8059. 

  8059.   } else {
    8060. 

  8060.    HEAP32[12920 >> 2] = 0;
    8061. 

  8061.    HEAP32[12932 >> 2] = 0;
    8062. 

  8062.    HEAP32[i2 + 4 >> 2] = i18 | 3;
    8063. 

  8063.    i32 = i2 + (i18 + 4) | 0;
    8064. 

  8064.    HEAP32[i32 >> 2] = HEAP32[i32 >> 2] | 1;
    8065. 

  8065.   }
    8066. 

  8066.   i32 = i2 + 8 | 0;
    8067. 

  8067.   STACKTOP = i1;
    8068. 

  8068.   return i32 | 0;
    8069. 

  8069.  }
    8070. 

  8070.  i18 = HEAP32[12924 >> 2] | 0;
    8071. 

  8071.  if (i12 >>> 0 < i18 >>> 0) {
    8072. 

  8072.   i31 = i18 - i12 | 0;
    8073. 

  8073.   HEAP32[12924 >> 2] = i31;
    8074. 

  8074.   i32 = HEAP32[12936 >> 2] | 0;
    8075. 

  8075.   HEAP32[12936 >> 2] = i32 + i12;
    8076. 

  8076.   HEAP32[i32 + (i12 + 4) >> 2] = i31 | 1;
    8077. 

  8077.   HEAP32[i32 + 4 >> 2] = i12 | 3;
    8078. 

  8078.   i32 = i32 + 8 | 0;
    8079. 

  8079.   STACKTOP = i1;
    8080. 

  8080.   return i32 | 0;
    8081. 

  8081.  }
    8082. 

  8082.  do {
    8083. 

  8083.   if ((HEAP32[3346] | 0) == 0) {
    8084. 

  8084.    i18 = _sysconf(30) | 0;
    8085. 

  8085.    if ((i18 + -1 & i18 | 0) == 0) {
    8086. 

  8086.     HEAP32[13392 >> 2] = i18;
    8087. 

  8087.     HEAP32[13388 >> 2] = i18;
    8088. 

  8088.     HEAP32[13396 >> 2] = -1;
    8089. 

  8089.     HEAP32[13400 >> 2] = -1;
    8090. 

  8090.     HEAP32[13404 >> 2] = 0;
    8091. 

  8091.     HEAP32[13356 >> 2] = 0;
    8092. 

  8092.     HEAP32[3346] = (_time(0) | 0) & -16 ^ 1431655768;
    8093. 

  8093.     break;
    8094. 

  8094.    } else {
    8095. 

  8095.     _abort();
    8096. 

  8096.    }
    8097. 

  8097.   }
    8098. 

  8098.  } while (0);
    8099. 

  8099.  i20 = i12 + 48 | 0;
    8100. 

  8100.  i25 = HEAP32[13392 >> 2] | 0;
    8101. 

  8101.  i21 = i12 + 47 | 0;
    8102. 

  8102.  i22 = i25 + i21 | 0;
    8103. 

  8103.  i25 = 0 - i25 | 0;
    8104. 

  8104.  i18 = i22 & i25;
    8105. 

  8105.  if (!(i18 >>> 0 > i12 >>> 0)) {
    8106. 

  8106.   i32 = 0;
    8107. 

  8107.   STACKTOP = i1;
    8108. 

  8108.   return i32 | 0;
    8109. 

  8109.  }
    8110. 

  8110.  i24 = HEAP32[13352 >> 2] | 0;
    8111. 

  8111.  if ((i24 | 0) != 0 ? (i31 = HEAP32[13344 >> 2] | 0, i32 = i31 + i18 | 0, i32 >>> 0 <= i31 >>> 0 | i32 >>> 0 > i24 >>> 0) : 0) {
    8112. 

  8112.   i32 = 0;
    8113. 

  8113.   STACKTOP = i1;
    8114. 

  8114.   return i32 | 0;
    8115. 

  8115.  }
    8116. 

  8116.  L269 : do {
    8117. 

  8117.   if ((HEAP32[13356 >> 2] & 4 | 0) == 0) {
    8118. 

  8118.    i26 = HEAP32[12936 >> 2] | 0;
    8119. 

  8119.    L271 : do {
    8120. 

  8120.     if ((i26 | 0) != 0) {
    8121. 

  8121.      i24 = 13360 | 0;
    8122. 

  8122.      while (1) {
    8123. 

  8123.       i27 = HEAP32[i24 >> 2] | 0;
    8124. 

  8124.       if (!(i27 >>> 0 > i26 >>> 0) ? (i23 = i24 + 4 | 0, (i27 + (HEAP32[i23 >> 2] | 0) | 0) >>> 0 > i26 >>> 0) : 0) {
    8125. 

  8125.        break;
    8126. 

  8126.       }
    8127. 

  8127.       i24 = HEAP32[i24 + 8 >> 2] | 0;
    8128. 

  8128.       if ((i24 | 0) == 0) {
    8129. 

  8129.        i13 = 182;
    8130. 

  8130.        break L271;
    8131. 

  8131.       }
    8132. 

  8132.      }
    8133. 

  8133.      if ((i24 | 0) != 0) {
    8134. 

  8134.       i25 = i22 - (HEAP32[12924 >> 2] | 0) & i25;
    8135. 

  8135.       if (i25 >>> 0 < 2147483647) {
    8136. 

  8136.        i13 = _sbrk(i25 | 0) | 0;
    8137. 

  8137.        i26 = (i13 | 0) == ((HEAP32[i24 >> 2] | 0) + (HEAP32[i23 >> 2] | 0) | 0);
    8138. 

  8138.        i22 = i13;
    8139. 

  8139.        i24 = i25;
    8140. 

  8140.        i23 = i26 ? i13 : -1;
    8141. 

  8141.        i25 = i26 ? i25 : 0;
    8142. 

  8142.        i13 = 191;
    8143. 

  8143.       } else {
    8144. 

  8144.        i25 = 0;
    8145. 

  8145.       }
    8146. 

  8146.      } else {
    8147. 

  8147.       i13 = 182;
    8148. 

  8148.      }
    8149. 

  8149.     } else {
    8150. 

  8150.      i13 = 182;
    8151. 

  8151.     }
    8152. 

  8152.    } while (0);
    8153. 

  8153.    do {
    8154. 

  8154.     if ((i13 | 0) == 182) {
    8155. 

  8155.      i23 = _sbrk(0) | 0;
    8156. 

  8156.      if ((i23 | 0) != (-1 | 0)) {
    8157. 

  8157.       i24 = i23;
    8158. 

  8158.       i22 = HEAP32[13388 >> 2] | 0;
    8159. 

  8159.       i25 = i22 + -1 | 0;
    8160. 

  8160.       if ((i25 & i24 | 0) == 0) {
    8161. 

  8161.        i25 = i18;
    8162. 

  8162.       } else {
    8163. 

  8163.        i25 = i18 - i24 + (i25 + i24 & 0 - i22) | 0;
    8164. 

  8164.       }
    8165. 

  8165.       i24 = HEAP32[13344 >> 2] | 0;
    8166. 

  8166.       i26 = i24 + i25 | 0;
    8167. 

  8167.       if (i25 >>> 0 > i12 >>> 0 & i25 >>> 0 < 2147483647) {
    8168. 

  8168.        i22 = HEAP32[13352 >> 2] | 0;
    8169. 

  8169.        if ((i22 | 0) != 0 ? i26 >>> 0 <= i24 >>> 0 | i26 >>> 0 > i22 >>> 0 : 0) {
    8170. 

  8170.         i25 = 0;
    8171. 

  8171.         break;
    8172. 

  8172.        }
    8173. 

  8173.        i22 = _sbrk(i25 | 0) | 0;
    8174. 

  8174.        i13 = (i22 | 0) == (i23 | 0);
    8175. 

  8175.        i24 = i25;
    8176. 

  8176.        i23 = i13 ? i23 : -1;
    8177. 

  8177.        i25 = i13 ? i25 : 0;
    8178. 

  8178.        i13 = 191;
    8179. 

  8179.       } else {
    8180. 

  8180.        i25 = 0;
    8181. 

  8181.       }
    8182. 

  8182.      } else {
    8183. 

  8183.       i25 = 0;
    8184. 

  8184.      }
    8185. 

  8185.     }
    8186. 

  8186.    } while (0);
    8187. 

  8187.    L291 : do {
    8188. 

  8188.     if ((i13 | 0) == 191) {
    8189. 

  8189.      i13 = 0 - i24 | 0;
    8190. 

  8190.      if ((i23 | 0) != (-1 | 0)) {
    8191. 

  8191.       i17 = i23;
    8192. 

  8192.       i14 = i25;
    8193. 

  8193.       i13 = 202;
    8194. 

  8194.       break L269;
    8195. 

  8195.      }
    8196. 

  8196.      do {
    8197. 

  8197.       if ((i22 | 0) != (-1 | 0) & i24 >>> 0 < 2147483647 & i24 >>> 0 < i20 >>> 0 ? (i19 = HEAP32[13392 >> 2] | 0, i19 = i21 - i24 + i19 & 0 - i19, i19 >>> 0 < 2147483647) : 0) {
    8198. 

  8198.        if ((_sbrk(i19 | 0) | 0) == (-1 | 0)) {
    8199. 

  8199.         _sbrk(i13 | 0) | 0;
    8200. 

  8200.         break L291;
    8201. 

  8201.        } else {
    8202. 

  8202.         i24 = i19 + i24 | 0;
    8203. 

  8203.         break;
    8204. 

  8204.        }
    8205. 

  8205.       }
    8206. 

  8206.      } while (0);
    8207. 

  8207.      if ((i22 | 0) != (-1 | 0)) {
    8208. 

  8208.       i17 = i22;
    8209. 

  8209.       i14 = i24;
    8210. 

  8210.       i13 = 202;
    8211. 

  8211.       break L269;
    8212. 

  8212.      }
    8213. 

  8213.     }
    8214. 

  8214.    } while (0);
    8215. 

  8215.    HEAP32[13356 >> 2] = HEAP32[13356 >> 2] | 4;
    8216. 

  8216.    i13 = 199;
    8217. 

  8217.   } else {
    8218. 

  8218.    i25 = 0;
    8219. 

  8219.    i13 = 199;
    8220. 

  8220.   }
    8221. 

  8221.  } while (0);
    8222. 

  8222.  if ((((i13 | 0) == 199 ? i18 >>> 0 < 2147483647 : 0) ? (i17 = _sbrk(i18 | 0) | 0, i16 = _sbrk(0) | 0, (i16 | 0) != (-1 | 0) & (i17 | 0) != (-1 | 0) & i17 >>> 0 < i16 >>> 0) : 0) ? (i15 = i16 - i17 | 0, i14 = i15 >>> 0 > (i12 + 40 | 0) >>> 0, i14) : 0) {
    8223. 

  8223.   i14 = i14 ? i15 : i25;
    8224. 

  8224.   i13 = 202;
    8225. 

  8225.  }
    8226. 

  8226.  if ((i13 | 0) == 202) {
    8227. 

  8227.   i15 = (HEAP32[13344 >> 2] | 0) + i14 | 0;
    8228. 

  8228.   HEAP32[13344 >> 2] = i15;
    8229. 

  8229.   if (i15 >>> 0 > (HEAP32[13348 >> 2] | 0) >>> 0) {
    8230. 

  8230.    HEAP32[13348 >> 2] = i15;
    8231. 

  8231.   }
    8232. 

  8232.   i15 = HEAP32[12936 >> 2] | 0;
    8233. 

  8233.   L311 : do {
    8234. 

  8234.    if ((i15 | 0) != 0) {
    8235. 

  8235.     i21 = 13360 | 0;
    8236. 

  8236.     while (1) {
    8237. 

  8237.      i16 = HEAP32[i21 >> 2] | 0;
    8238. 

  8238.      i19 = i21 + 4 | 0;
    8239. 

  8239.      i20 = HEAP32[i19 >> 2] | 0;
    8240. 

  8240.      if ((i17 | 0) == (i16 + i20 | 0)) {
    8241. 

  8241.       i13 = 214;
    8242. 

  8242.       break;
    8243. 

  8243.      }
    8244. 

  8244.      i18 = HEAP32[i21 + 8 >> 2] | 0;
    8245. 

  8245.      if ((i18 | 0) == 0) {
    8246. 

  8246.       break;
    8247. 

  8247.      } else {
    8248. 

  8248.       i21 = i18;
    8249. 

  8249.      }
    8250. 

  8250.     }
    8251. 

  8251.     if (((i13 | 0) == 214 ? (HEAP32[i21 + 12 >> 2] & 8 | 0) == 0 : 0) ? i15 >>> 0 >= i16 >>> 0 & i15 >>> 0 < i17 >>> 0 : 0) {
    8252. 

  8252.      HEAP32[i19 >> 2] = i20 + i14;
    8253. 

  8253.      i2 = (HEAP32[12924 >> 2] | 0) + i14 | 0;
    8254. 

  8254.      i3 = i15 + 8 | 0;
    8255. 

  8255.      if ((i3 & 7 | 0) == 0) {
    8256. 

  8256.       i3 = 0;
    8257. 

  8257.      } else {
    8258. 

  8258.       i3 = 0 - i3 & 7;
    8259. 

  8259.      }
    8260. 

  8260.      i32 = i2 - i3 | 0;
    8261. 

  8261.      HEAP32[12936 >> 2] = i15 + i3;
    8262. 

  8262.      HEAP32[12924 >> 2] = i32;
    8263. 

  8263.      HEAP32[i15 + (i3 + 4) >> 2] = i32 | 1;
    8264. 

  8264.      HEAP32[i15 + (i2 + 4) >> 2] = 40;
    8265. 

  8265.      HEAP32[12940 >> 2] = HEAP32[13400 >> 2];
    8266. 

  8266.      break;
    8267. 

  8267.     }
    8268. 

  8268.     if (i17 >>> 0 < (HEAP32[12928 >> 2] | 0) >>> 0) {
    8269. 

  8269.      HEAP32[12928 >> 2] = i17;
    8270. 

  8270.     }
    8271. 

  8271.     i19 = i17 + i14 | 0;
    8272. 

  8272.     i16 = 13360 | 0;
    8273. 

  8273.     while (1) {
    8274. 

  8274.      if ((HEAP32[i16 >> 2] | 0) == (i19 | 0)) {
    8275. 

  8275.       i13 = 224;
    8276. 

  8276.       break;
    8277. 

  8277.      }
    8278. 

  8278.      i18 = HEAP32[i16 + 8 >> 2] | 0;
    8279. 

  8279.      if ((i18 | 0) == 0) {
    8280. 

  8280.       break;
    8281. 

  8281.      } else {
    8282. 

  8282.       i16 = i18;
    8283. 

  8283.      }
    8284. 

  8284.     }
    8285. 

  8285.     if ((i13 | 0) == 224 ? (HEAP32[i16 + 12 >> 2] & 8 | 0) == 0 : 0) {
    8286. 

  8286.      HEAP32[i16 >> 2] = i17;
    8287. 

  8287.      i6 = i16 + 4 | 0;
    8288. 

  8288.      HEAP32[i6 >> 2] = (HEAP32[i6 >> 2] | 0) + i14;
    8289. 

  8289.      i6 = i17 + 8 | 0;
    8290. 

  8290.      if ((i6 & 7 | 0) == 0) {
    8291. 

  8291.       i6 = 0;
    8292. 

  8292.      } else {
    8293. 

  8293.       i6 = 0 - i6 & 7;
    8294. 

  8294.      }
    8295. 

  8295.      i7 = i17 + (i14 + 8) | 0;
    8296. 

  8296.      if ((i7 & 7 | 0) == 0) {
    8297. 

  8297.       i13 = 0;
    8298. 

  8298.      } else {
    8299. 

  8299.       i13 = 0 - i7 & 7;
    8300. 

  8300.      }
    8301. 

  8301.      i15 = i17 + (i13 + i14) | 0;
    8302. 

  8302.      i8 = i6 + i12 | 0;
    8303. 

  8303.      i7 = i17 + i8 | 0;
    8304. 

  8304.      i10 = i15 - (i17 + i6) - i12 | 0;
    8305. 

  8305.      HEAP32[i17 + (i6 + 4) >> 2] = i12 | 3;
    8306. 

  8306.      L348 : do {
    8307. 

  8307.       if ((i15 | 0) != (HEAP32[12936 >> 2] | 0)) {
    8308. 

  8308.        if ((i15 | 0) == (HEAP32[12932 >> 2] | 0)) {
    8309. 

  8309.         i32 = (HEAP32[12920 >> 2] | 0) + i10 | 0;
    8310. 

  8310.         HEAP32[12920 >> 2] = i32;
    8311. 

  8311.         HEAP32[12932 >> 2] = i7;
    8312. 

  8312.         HEAP32[i17 + (i8 + 4) >> 2] = i32 | 1;
    8313. 

  8313.         HEAP32[i17 + (i32 + i8) >> 2] = i32;
    8314. 

  8314.         break;
    8315. 

  8315.        }
    8316. 

  8316.        i12 = i14 + 4 | 0;
    8317. 

  8317.        i18 = HEAP32[i17 + (i12 + i13) >> 2] | 0;
    8318. 

  8318.        if ((i18 & 3 | 0) == 1) {
    8319. 

  8319.         i11 = i18 & -8;
    8320. 

  8320.         i16 = i18 >>> 3;
    8321. 

  8321.         do {
    8322. 

  8322.          if (!(i18 >>> 0 < 256)) {
    8323. 

  8323.           i9 = HEAP32[i17 + ((i13 | 24) + i14) >> 2] | 0;
    8324. 

  8324.           i19 = HEAP32[i17 + (i14 + 12 + i13) >> 2] | 0;
    8325. 

  8325.           do {
    8326. 

  8326.            if ((i19 | 0) == (i15 | 0)) {
    8327. 

  8327.             i19 = i13 | 16;
    8328. 

  8328.             i18 = i17 + (i12 + i19) | 0;
    8329. 

  8329.             i16 = HEAP32[i18 >> 2] | 0;
    8330. 

  8330.             if ((i16 | 0) == 0) {
    8331. 

  8331.              i18 = i17 + (i19 + i14) | 0;
    8332. 

  8332.              i16 = HEAP32[i18 >> 2] | 0;
    8333. 

  8333.              if ((i16 | 0) == 0) {
    8334. 

  8334.               i5 = 0;
    8335. 

  8335.               break;
    8336. 

  8336.              }
    8337. 

  8337.             }
    8338. 

  8338.             while (1) {
    8339. 

  8339.              i20 = i16 + 20 | 0;
    8340. 

  8340.              i19 = HEAP32[i20 >> 2] | 0;
    8341. 

  8341.              if ((i19 | 0) != 0) {
    8342. 

  8342.               i16 = i19;
    8343. 

  8343.               i18 = i20;
    8344. 

  8344.               continue;
    8345. 

  8345.              }
    8346. 

  8346.              i19 = i16 + 16 | 0;
    8347. 

  8347.              i20 = HEAP32[i19 >> 2] | 0;
    8348. 

  8348.              if ((i20 | 0) == 0) {
    8349. 

  8349.               break;
    8350. 

  8350.              } else {
    8351. 

  8351.               i16 = i20;
    8352. 

  8352.               i18 = i19;
    8353. 

  8353.              }
    8354. 

  8354.             }
    8355. 

  8355.             if (i18 >>> 0 < (HEAP32[12928 >> 2] | 0) >>> 0) {
    8356. 

  8356.              _abort();
    8357. 

  8357.             } else {
    8358. 

  8358.              HEAP32[i18 >> 2] = 0;
    8359. 

  8359.              i5 = i16;
    8360. 

  8360.              break;
    8361. 

  8361.             }
    8362. 

  8362.            } else {
    8363. 

  8363.             i18 = HEAP32[i17 + ((i13 | 8) + i14) >> 2] | 0;
    8364. 

  8364.             if (i18 >>> 0 < (HEAP32[12928 >> 2] | 0) >>> 0) {
    8365. 

  8365.              _abort();
    8366. 

  8366.             }
    8367. 

  8367.             i16 = i18 + 12 | 0;
    8368. 

  8368.             if ((HEAP32[i16 >> 2] | 0) != (i15 | 0)) {
    8369. 

  8369.              _abort();
    8370. 

  8370.             }
    8371. 

  8371.             i20 = i19 + 8 | 0;
    8372. 

  8372.             if ((HEAP32[i20 >> 2] | 0) == (i15 | 0)) {
    8373. 

  8373.              HEAP32[i16 >> 2] = i19;
    8374. 

  8374.              HEAP32[i20 >> 2] = i18;
    8375. 

  8375.              i5 = i19;
    8376. 

  8376.              break;
    8377. 

  8377.             } else {
    8378. 

  8378.              _abort();
    8379. 

  8379.             }
    8380. 

  8380.            }
    8381. 

  8381.           } while (0);
    8382. 

  8382.           if ((i9 | 0) != 0) {
    8383. 

  8383.            i16 = HEAP32[i17 + (i14 + 28 + i13) >> 2] | 0;
    8384. 

  8384.            i18 = 13216 + (i16 << 2) | 0;
    8385. 

  8385.            if ((i15 | 0) == (HEAP32[i18 >> 2] | 0)) {
    8386. 

  8386.             HEAP32[i18 >> 2] = i5;
    8387. 

  8387.             if ((i5 | 0) == 0) {
    8388. 

  8388.              HEAP32[12916 >> 2] = HEAP32[12916 >> 2] & ~(1 << i16);
    8389. 

  8389.              break;
    8390. 

  8390.             }
    8391. 

  8391.            } else {
    8392. 

  8392.             if (i9 >>> 0 < (HEAP32[12928 >> 2] | 0) >>> 0) {
    8393. 

  8393.              _abort();
    8394. 

  8394.             }
    8395. 

  8395.             i16 = i9 + 16 | 0;
    8396. 

  8396.             if ((HEAP32[i16 >> 2] | 0) == (i15 | 0)) {
    8397. 

  8397.              HEAP32[i16 >> 2] = i5;
    8398. 

  8398.             } else {
    8399. 

  8399.              HEAP32[i9 + 20 >> 2] = i5;
    8400. 

  8400.             }
    8401. 

  8401.             if ((i5 | 0) == 0) {
    8402. 

  8402.              break;
    8403. 

  8403.             }
    8404. 

  8404.            }
    8405. 

  8405.            if (i5 >>> 0 < (HEAP32[12928 >> 2] | 0) >>> 0) {
    8406. 

  8406.             _abort();
    8407. 

  8407.            }
    8408. 

  8408.            HEAP32[i5 + 24 >> 2] = i9;
    8409. 

  8409.            i15 = i13 | 16;
    8410. 

  8410.            i9 = HEAP32[i17 + (i15 + i14) >> 2] | 0;
    8411. 

  8411.            do {
    8412. 

  8412.             if ((i9 | 0) != 0) {
    8413. 

  8413.              if (i9 >>> 0 < (HEAP32[12928 >> 2] | 0) >>> 0) {
    8414. 

  8414.               _abort();
    8415. 

  8415.              } else {
    8416. 

  8416.               HEAP32[i5 + 16 >> 2] = i9;
    8417. 

  8417.               HEAP32[i9 + 24 >> 2] = i5;
    8418. 

  8418.               break;
    8419. 

  8419.              }
    8420. 

  8420.             }
    8421. 

  8421.            } while (0);
    8422. 

  8422.            i9 = HEAP32[i17 + (i12 + i15) >> 2] | 0;
    8423. 

  8423.            if ((i9 | 0) != 0) {
    8424. 

  8424.             if (i9 >>> 0 < (HEAP32[12928 >> 2] | 0) >>> 0) {
    8425. 

  8425.              _abort();
    8426. 

  8426.             } else {
    8427. 

  8427.              HEAP32[i5 + 20 >> 2] = i9;
    8428. 

  8428.              HEAP32[i9 + 24 >> 2] = i5;
    8429. 

  8429.              break;
    8430. 

  8430.             }
    8431. 

  8431.            }
    8432. 

  8432.           }
    8433. 

  8433.          } else {
    8434. 

  8434.           i5 = HEAP32[i17 + ((i13 | 8) + i14) >> 2] | 0;
    8435. 

  8435.           i12 = HEAP32[i17 + (i14 + 12 + i13) >> 2] | 0;
    8436. 

  8436.           i18 = 12952 + (i16 << 1 << 2) | 0;
    8437. 

  8437.           if ((i5 | 0) != (i18 | 0)) {
    8438. 

  8438.            if (i5 >>> 0 < (HEAP32[12928 >> 2] | 0) >>> 0) {
    8439. 

  8439.             _abort();
    8440. 

  8440.            }
    8441. 

  8441.            if ((HEAP32[i5 + 12 >> 2] | 0) != (i15 | 0)) {
    8442. 

  8442.             _abort();
    8443. 

  8443.            }
    8444. 

  8444.           }
    8445. 

  8445.           if ((i12 | 0) == (i5 | 0)) {
    8446. 

  8446.            HEAP32[3228] = HEAP32[3228] & ~(1 << i16);
    8447. 

  8447.            break;
    8448. 

  8448.           }
    8449. 

  8449.           if ((i12 | 0) != (i18 | 0)) {
    8450. 

  8450.            if (i12 >>> 0 < (HEAP32[12928 >> 2] | 0) >>> 0) {
    8451. 

  8451.             _abort();
    8452. 

  8452.            }
    8453. 

  8453.            i16 = i12 + 8 | 0;
    8454. 

  8454.            if ((HEAP32[i16 >> 2] | 0) == (i15 | 0)) {
    8455. 

  8455.             i9 = i16;
    8456. 

  8456.            } else {
    8457. 

  8457.             _abort();
    8458. 

  8458.            }
    8459. 

  8459.           } else {
    8460. 

  8460.            i9 = i12 + 8 | 0;
    8461. 

  8461.           }
    8462. 

  8462.           HEAP32[i5 + 12 >> 2] = i12;
    8463. 

  8463.           HEAP32[i9 >> 2] = i5;
    8464. 

  8464.          }
    8465. 

  8465.         } while (0);
    8466. 

  8466.         i15 = i17 + ((i11 | i13) + i14) | 0;
    8467. 

  8467.         i10 = i11 + i10 | 0;
    8468. 

  8468.        }
    8469. 

  8469.        i5 = i15 + 4 | 0;
    8470. 

  8470.        HEAP32[i5 >> 2] = HEAP32[i5 >> 2] & -2;
    8471. 

  8471.        HEAP32[i17 + (i8 + 4) >> 2] = i10 | 1;
    8472. 

  8472.        HEAP32[i17 + (i10 + i8) >> 2] = i10;
    8473. 

  8473.        i5 = i10 >>> 3;
    8474. 

  8474.        if (i10 >>> 0 < 256) {
    8475. 

  8475.         i10 = i5 << 1;
    8476. 

  8476.         i2 = 12952 + (i10 << 2) | 0;
    8477. 

  8477.         i9 = HEAP32[3228] | 0;
    8478. 

  8478.         i5 = 1 << i5;
    8479. 

  8479.         if ((i9 & i5 | 0) != 0) {
    8480. 

  8480.          i9 = 12952 + (i10 + 2 << 2) | 0;
    8481. 

  8481.          i5 = HEAP32[i9 >> 2] | 0;
    8482. 

  8482.          if (i5 >>> 0 < (HEAP32[12928 >> 2] | 0) >>> 0) {
    8483. 

  8483.           _abort();
    8484. 

  8484.          } else {
    8485. 

  8485.           i3 = i9;
    8486. 

  8486.           i4 = i5;
    8487. 

  8487.          }
    8488. 

  8488.         } else {
    8489. 

  8489.          HEAP32[3228] = i9 | i5;
    8490. 

  8490.          i3 = 12952 + (i10 + 2 << 2) | 0;
    8491. 

  8491.          i4 = i2;
    8492. 

  8492.         }
    8493. 

  8493.         HEAP32[i3 >> 2] = i7;
    8494. 

  8494.         HEAP32[i4 + 12 >> 2] = i7;
    8495. 

  8495.         HEAP32[i17 + (i8 + 8) >> 2] = i4;
    8496. 

  8496.         HEAP32[i17 + (i8 + 12) >> 2] = i2;
    8497. 

  8497.         break;
    8498. 

  8498.        }
    8499. 

  8499.        i3 = i10 >>> 8;
    8500. 

  8500.        if ((i3 | 0) != 0) {
    8501. 

  8501.         if (i10 >>> 0 > 16777215) {
    8502. 

  8502.          i3 = 31;
    8503. 

  8503.         } else {
    8504. 

  8504.          i31 = (i3 + 1048320 | 0) >>> 16 & 8;
    8505. 

  8505.          i32 = i3 << i31;
    8506. 

  8506.          i30 = (i32 + 520192 | 0) >>> 16 & 4;
    8507. 

  8507.          i32 = i32 << i30;
    8508. 

  8508.          i3 = (i32 + 245760 | 0) >>> 16 & 2;
    8509. 

  8509.          i3 = 14 - (i30 | i31 | i3) + (i32 << i3 >>> 15) | 0;
    8510. 

  8510.          i3 = i10 >>> (i3 + 7 | 0) & 1 | i3 << 1;
    8511. 

  8511.         }
    8512. 

  8512.        } else {
    8513. 

  8513.         i3 = 0;
    8514. 

  8514.        }
    8515. 

  8515.        i4 = 13216 + (i3 << 2) | 0;
    8516. 

  8516.        HEAP32[i17 + (i8 + 28) >> 2] = i3;
    8517. 

  8517.        HEAP32[i17 + (i8 + 20) >> 2] = 0;
    8518. 

  8518.        HEAP32[i17 + (i8 + 16) >> 2] = 0;
    8519. 

  8519.        i9 = HEAP32[12916 >> 2] | 0;
    8520. 

  8520.        i5 = 1 << i3;
    8521. 

  8521.        if ((i9 & i5 | 0) == 0) {
    8522. 

  8522.         HEAP32[12916 >> 2] = i9 | i5;
    8523. 

  8523.         HEAP32[i4 >> 2] = i7;
    8524. 

  8524.         HEAP32[i17 + (i8 + 24) >> 2] = i4;
    8525. 

  8525.         HEAP32[i17 + (i8 + 12) >> 2] = i7;
    8526. 

  8526.         HEAP32[i17 + (i8 + 8) >> 2] = i7;
    8527. 

  8527.         break;
    8528. 

  8528.        }
    8529. 

  8529.        i4 = HEAP32[i4 >> 2] | 0;
    8530. 

  8530.        if ((i3 | 0) == 31) {
    8531. 

  8531.         i3 = 0;
    8532. 

  8532.        } else {
    8533. 

  8533.         i3 = 25 - (i3 >>> 1) | 0;
    8534. 

  8534.        }
    8535. 

  8535.        L445 : do {
    8536. 

  8536.         if ((HEAP32[i4 + 4 >> 2] & -8 | 0) != (i10 | 0)) {
    8537. 

  8537.          i3 = i10 << i3;
    8538. 

  8538.          while (1) {
    8539. 

  8539.           i5 = i4 + (i3 >>> 31 << 2) + 16 | 0;
    8540. 

  8540.           i9 = HEAP32[i5 >> 2] | 0;
    8541. 

  8541.           if ((i9 | 0) == 0) {
    8542. 

  8542.            break;
    8543. 

  8543.           }
    8544. 

  8544.           if ((HEAP32[i9 + 4 >> 2] & -8 | 0) == (i10 | 0)) {
    8545. 

  8545.            i2 = i9;
    8546. 

  8546.            break L445;
    8547. 

  8547.           } else {
    8548. 

  8548.            i3 = i3 << 1;
    8549. 

  8549.            i4 = i9;
    8550. 

  8550.           }
    8551. 

  8551.          }
    8552. 

  8552.          if (i5 >>> 0 < (HEAP32[12928 >> 2] | 0) >>> 0) {
    8553. 

  8553.           _abort();
    8554. 

  8554.          } else {
    8555. 

  8555.           HEAP32[i5 >> 2] = i7;
    8556. 

  8556.           HEAP32[i17 + (i8 + 24) >> 2] = i4;
    8557. 

  8557.           HEAP32[i17 + (i8 + 12) >> 2] = i7;
    8558. 

  8558.           HEAP32[i17 + (i8 + 8) >> 2] = i7;
    8559. 

  8559.           break L348;
    8560. 

  8560.          }
    8561. 

  8561.         } else {
    8562. 

  8562.          i2 = i4;
    8563. 

  8563.         }
    8564. 

  8564.        } while (0);
    8565. 

  8565.        i4 = i2 + 8 | 0;
    8566. 

  8566.        i3 = HEAP32[i4 >> 2] | 0;
    8567. 

  8567.        i5 = HEAP32[12928 >> 2] | 0;
    8568. 

  8568.        if (i2 >>> 0 < i5 >>> 0) {
    8569. 

  8569.         _abort();
    8570. 

  8570.        }
    8571. 

  8571.        if (i3 >>> 0 < i5 >>> 0) {
    8572. 

  8572.         _abort();
    8573. 

  8573.        } else {
    8574. 

  8574.         HEAP32[i3 + 12 >> 2] = i7;
    8575. 

  8575.         HEAP32[i4 >> 2] = i7;
    8576. 

  8576.         HEAP32[i17 + (i8 + 8) >> 2] = i3;
    8577. 

  8577.         HEAP32[i17 + (i8 + 12) >> 2] = i2;
    8578. 

  8578.         HEAP32[i17 + (i8 + 24) >> 2] = 0;
    8579. 

  8579.         break;
    8580. 

  8580.        }
    8581. 

  8581.       } else {
    8582. 

  8582.        i32 = (HEAP32[12924 >> 2] | 0) + i10 | 0;
    8583. 

  8583.        HEAP32[12924 >> 2] = i32;
    8584. 

  8584.        HEAP32[12936 >> 2] = i7;
    8585. 

  8585.        HEAP32[i17 + (i8 + 4) >> 2] = i32 | 1;
    8586. 

  8586.       }
    8587. 

  8587.      } while (0);
    8588. 

  8588.      i32 = i17 + (i6 | 8) | 0;
    8589. 

  8589.      STACKTOP = i1;
    8590. 

  8590.      return i32 | 0;
    8591. 

  8591.     }
    8592. 

  8592.     i3 = 13360 | 0;
    8593. 

  8593.     while (1) {
    8594. 

  8594.      i2 = HEAP32[i3 >> 2] | 0;
    8595. 

  8595.      if (!(i2 >>> 0 > i15 >>> 0) ? (i11 = HEAP32[i3 + 4 >> 2] | 0, i10 = i2 + i11 | 0, i10 >>> 0 > i15 >>> 0) : 0) {
    8596. 

  8596.       break;
    8597. 

  8597.      }
    8598. 

  8598.      i3 = HEAP32[i3 + 8 >> 2] | 0;
    8599. 

  8599.     }
    8600. 

  8600.     i3 = i2 + (i11 + -39) | 0;
    8601. 

  8601.     if ((i3 & 7 | 0) == 0) {
    8602. 

  8602.      i3 = 0;
    8603. 

  8603.     } else {
    8604. 

  8604.      i3 = 0 - i3 & 7;
    8605. 

  8605.     }
    8606. 

  8606.     i2 = i2 + (i11 + -47 + i3) | 0;
    8607. 

  8607.     i2 = i2 >>> 0 < (i15 + 16 | 0) >>> 0 ? i15 : i2;
    8608. 

  8608.     i3 = i2 + 8 | 0;
    8609. 

  8609.     i4 = i17 + 8 | 0;
    8610. 

  8610.     if ((i4 & 7 | 0) == 0) {
    8611. 

  8611.      i4 = 0;
    8612. 

  8612.     } else {
    8613. 

  8613.      i4 = 0 - i4 & 7;
    8614. 

  8614.     }
    8615. 

  8615.     i32 = i14 + -40 - i4 | 0;
    8616. 

  8616.     HEAP32[12936 >> 2] = i17 + i4;
    8617. 

  8617.     HEAP32[12924 >> 2] = i32;
    8618. 

  8618.     HEAP32[i17 + (i4 + 4) >> 2] = i32 | 1;
    8619. 

  8619.     HEAP32[i17 + (i14 + -36) >> 2] = 40;
    8620. 

  8620.     HEAP32[12940 >> 2] = HEAP32[13400 >> 2];
    8621. 

  8621.     HEAP32[i2 + 4 >> 2] = 27;
    8622. 

  8622.     HEAP32[i3 + 0 >> 2] = HEAP32[13360 >> 2];
    8623. 

  8623.     HEAP32[i3 + 4 >> 2] = HEAP32[13364 >> 2];
    8624. 

  8624.     HEAP32[i3 + 8 >> 2] = HEAP32[13368 >> 2];
    8625. 

  8625.     HEAP32[i3 + 12 >> 2] = HEAP32[13372 >> 2];
    8626. 

  8626.     HEAP32[13360 >> 2] = i17;
    8627. 

  8627.     HEAP32[13364 >> 2] = i14;
    8628. 

  8628.     HEAP32[13372 >> 2] = 0;
    8629. 

  8629.     HEAP32[13368 >> 2] = i3;
    8630. 

  8630.     i4 = i2 + 28 | 0;
    8631. 

  8631.     HEAP32[i4 >> 2] = 7;
    8632. 

  8632.     if ((i2 + 32 | 0) >>> 0 < i10 >>> 0) {
    8633. 

  8633.      while (1) {
    8634. 

  8634.       i3 = i4 + 4 | 0;
    8635. 

  8635.       HEAP32[i3 >> 2] = 7;
    8636. 

  8636.       if ((i4 + 8 | 0) >>> 0 < i10 >>> 0) {
    8637. 

  8637.        i4 = i3;
    8638. 

  8638.       } else {
    8639. 

  8639.        break;
    8640. 

  8640.       }
    8641. 

  8641.      }
    8642. 

  8642.     }
    8643. 

  8643.     if ((i2 | 0) != (i15 | 0)) {
    8644. 

  8644.      i2 = i2 - i15 | 0;
    8645. 

  8645.      i3 = i15 + (i2 + 4) | 0;
    8646. 

  8646.      HEAP32[i3 >> 2] = HEAP32[i3 >> 2] & -2;
    8647. 

  8647.      HEAP32[i15 + 4 >> 2] = i2 | 1;
    8648. 

  8648.      HEAP32[i15 + i2 >> 2] = i2;
    8649. 

  8649.      i3 = i2 >>> 3;
    8650. 

  8650.      if (i2 >>> 0 < 256) {
    8651. 

  8651.       i4 = i3 << 1;
    8652. 

  8652.       i2 = 12952 + (i4 << 2) | 0;
    8653. 

  8653.       i5 = HEAP32[3228] | 0;
    8654. 

  8654.       i3 = 1 << i3;
    8655. 

  8655.       if ((i5 & i3 | 0) != 0) {
    8656. 

  8656.        i4 = 12952 + (i4 + 2 << 2) | 0;
    8657. 

  8657.        i3 = HEAP32[i4 >> 2] | 0;
    8658. 

  8658.        if (i3 >>> 0 < (HEAP32[12928 >> 2] | 0) >>> 0) {
    8659. 

  8659.         _abort();
    8660. 

  8660.        } else {
    8661. 

  8661.         i7 = i4;
    8662. 

  8662.         i8 = i3;
    8663. 

  8663.        }
    8664. 

  8664.       } else {
    8665. 

  8665.        HEAP32[3228] = i5 | i3;
    8666. 

  8666.        i7 = 12952 + (i4 + 2 << 2) | 0;
    8667. 

  8667.        i8 = i2;
    8668. 

  8668.       }
    8669. 

  8669.       HEAP32[i7 >> 2] = i15;
    8670. 

  8670.       HEAP32[i8 + 12 >> 2] = i15;
    8671. 

  8671.       HEAP32[i15 + 8 >> 2] = i8;
    8672. 

  8672.       HEAP32[i15 + 12 >> 2] = i2;
    8673. 

  8673.       break;
    8674. 

  8674.      }
    8675. 

  8675.      i3 = i2 >>> 8;
    8676. 

  8676.      if ((i3 | 0) != 0) {
    8677. 

  8677.       if (i2 >>> 0 > 16777215) {
    8678. 

  8678.        i3 = 31;
    8679. 

  8679.       } else {
    8680. 

  8680.        i31 = (i3 + 1048320 | 0) >>> 16 & 8;
    8681. 

  8681.        i32 = i3 << i31;
    8682. 

  8682.        i30 = (i32 + 520192 | 0) >>> 16 & 4;
    8683. 

  8683.        i32 = i32 << i30;
    8684. 

  8684.        i3 = (i32 + 245760 | 0) >>> 16 & 2;
    8685. 

  8685.        i3 = 14 - (i30 | i31 | i3) + (i32 << i3 >>> 15) | 0;
    8686. 

  8686.        i3 = i2 >>> (i3 + 7 | 0) & 1 | i3 << 1;
    8687. 

  8687.       }
    8688. 

  8688.      } else {
    8689. 

  8689.       i3 = 0;
    8690. 

  8690.      }
    8691. 

  8691.      i7 = 13216 + (i3 << 2) | 0;
    8692. 

  8692.      HEAP32[i15 + 28 >> 2] = i3;
    8693. 

  8693.      HEAP32[i15 + 20 >> 2] = 0;
    8694. 

  8694.      HEAP32[i15 + 16 >> 2] = 0;
    8695. 

  8695.      i4 = HEAP32[12916 >> 2] | 0;
    8696. 

  8696.      i5 = 1 << i3;
    8697. 

  8697.      if ((i4 & i5 | 0) == 0) {
    8698. 

  8698.       HEAP32[12916 >> 2] = i4 | i5;
    8699. 

  8699.       HEAP32[i7 >> 2] = i15;
    8700. 

  8700.       HEAP32[i15 + 24 >> 2] = i7;
    8701. 

  8701.       HEAP32[i15 + 12 >> 2] = i15;
    8702. 

  8702.       HEAP32[i15 + 8 >> 2] = i15;
    8703. 

  8703.       break;
    8704. 

  8704.      }
    8705. 

  8705.      i4 = HEAP32[i7 >> 2] | 0;
    8706. 

  8706.      if ((i3 | 0) == 31) {
    8707. 

  8707.       i3 = 0;
    8708. 

  8708.      } else {
    8709. 

  8709.       i3 = 25 - (i3 >>> 1) | 0;
    8710. 

  8710.      }
    8711. 

  8711.      L499 : do {
    8712. 

  8712.       if ((HEAP32[i4 + 4 >> 2] & -8 | 0) != (i2 | 0)) {
    8713. 

  8713.        i3 = i2 << i3;
    8714. 

  8714.        while (1) {
    8715. 

  8715.         i7 = i4 + (i3 >>> 31 << 2) + 16 | 0;
    8716. 

  8716.         i5 = HEAP32[i7 >> 2] | 0;
    8717. 

  8717.         if ((i5 | 0) == 0) {
    8718. 

  8718.          break;
    8719. 

  8719.         }
    8720. 

  8720.         if ((HEAP32[i5 + 4 >> 2] & -8 | 0) == (i2 | 0)) {
    8721. 

  8721.          i6 = i5;
    8722. 

  8722.          break L499;
    8723. 

  8723.         } else {
    8724. 

  8724.          i3 = i3 << 1;
    8725. 

  8725.          i4 = i5;
    8726. 

  8726.         }
    8727. 

  8727.        }
    8728. 

  8728.        if (i7 >>> 0 < (HEAP32[12928 >> 2] | 0) >>> 0) {
    8729. 

  8729.         _abort();
    8730. 

  8730.        } else {
    8731. 

  8731.         HEAP32[i7 >> 2] = i15;
    8732. 

  8732.         HEAP32[i15 + 24 >> 2] = i4;
    8733. 

  8733.         HEAP32[i15 + 12 >> 2] = i15;
    8734. 

  8734.         HEAP32[i15 + 8 >> 2] = i15;
    8735. 

  8735.         break L311;
    8736. 

  8736.        }
    8737. 

  8737.       } else {
    8738. 

  8738.        i6 = i4;
    8739. 

  8739.       }
    8740. 

  8740.      } while (0);
    8741. 

  8741.      i4 = i6 + 8 | 0;
    8742. 

  8742.      i3 = HEAP32[i4 >> 2] | 0;
    8743. 

  8743.      i2 = HEAP32[12928 >> 2] | 0;
    8744. 

  8744.      if (i6 >>> 0 < i2 >>> 0) {
    8745. 

  8745.       _abort();
    8746. 

  8746.      }
    8747. 

  8747.      if (i3 >>> 0 < i2 >>> 0) {
    8748. 

  8748.       _abort();
    8749. 

  8749.      } else {
    8750. 

  8750.       HEAP32[i3 + 12 >> 2] = i15;
    8751. 

  8751.       HEAP32[i4 >> 2] = i15;
    8752. 

  8752.       HEAP32[i15 + 8 >> 2] = i3;
    8753. 

  8753.       HEAP32[i15 + 12 >> 2] = i6;
    8754. 

  8754.       HEAP32[i15 + 24 >> 2] = 0;
    8755. 

  8755.       break;
    8756. 

  8756.      }
    8757. 

  8757.     }
    8758. 

  8758.    } else {
    8759. 

  8759.     i32 = HEAP32[12928 >> 2] | 0;
    8760. 

  8760.     if ((i32 | 0) == 0 | i17 >>> 0 < i32 >>> 0) {
    8761. 

  8761.      HEAP32[12928 >> 2] = i17;
    8762. 

  8762.     }
    8763. 

  8763.     HEAP32[13360 >> 2] = i17;
    8764. 

  8764.     HEAP32[13364 >> 2] = i14;
    8765. 

  8765.     HEAP32[13372 >> 2] = 0;
    8766. 

  8766.     HEAP32[12948 >> 2] = HEAP32[3346];
    8767. 

  8767.     HEAP32[12944 >> 2] = -1;
    8768. 

  8768.     i2 = 0;
    8769. 

  8769.     do {
    8770. 

  8770.      i32 = i2 << 1;
    8771. 

  8771.      i31 = 12952 + (i32 << 2) | 0;
    8772. 

  8772.      HEAP32[12952 + (i32 + 3 << 2) >> 2] = i31;
    8773. 

  8773.      HEAP32[12952 + (i32 + 2 << 2) >> 2] = i31;
    8774. 

  8774.      i2 = i2 + 1 | 0;
    8775. 

  8775.     } while ((i2 | 0) != 32);
    8776. 

  8776.     i2 = i17 + 8 | 0;
    8777. 

  8777.     if ((i2 & 7 | 0) == 0) {
    8778. 

  8778.      i2 = 0;
    8779. 

  8779.     } else {
    8780. 

  8780.      i2 = 0 - i2 & 7;
    8781. 

  8781.     }
    8782. 

  8782.     i32 = i14 + -40 - i2 | 0;
    8783. 

  8783.     HEAP32[12936 >> 2] = i17 + i2;
    8784. 

  8784.     HEAP32[12924 >> 2] = i32;
    8785. 

  8785.     HEAP32[i17 + (i2 + 4) >> 2] = i32 | 1;
    8786. 

  8786.     HEAP32[i17 + (i14 + -36) >> 2] = 40;
    8787. 

  8787.     HEAP32[12940 >> 2] = HEAP32[13400 >> 2];
    8788. 

  8788.    }
    8789. 

  8789.   } while (0);
    8790. 

  8790.   i2 = HEAP32[12924 >> 2] | 0;
    8791. 

  8791.   if (i2 >>> 0 > i12 >>> 0) {
    8792. 

  8792.    i31 = i2 - i12 | 0;
    8793. 

  8793.    HEAP32[12924 >> 2] = i31;
    8794. 

  8794.    i32 = HEAP32[12936 >> 2] | 0;
    8795. 

  8795.    HEAP32[12936 >> 2] = i32 + i12;
    8796. 

  8796.    HEAP32[i32 + (i12 + 4) >> 2] = i31 | 1;
    8797. 

  8797.    HEAP32[i32 + 4 >> 2] = i12 | 3;
    8798. 

  8798.    i32 = i32 + 8 | 0;
    8799. 

  8799.    STACKTOP = i1;
    8800. 

  8800.    return i32 | 0;
    8801. 

  8801.   }
    8802. 

  8802.  }
    8803. 

  8803.  HEAP32[(___errno_location() | 0) >> 2] = 12;
    8804. 

  8804.  i32 = 0;
    8805. 

  8805.  STACKTOP = i1;
    8806. 

  8806.  return i32 | 0;
    8807. 

  8807. }
    8808. 

  8808. function _llex(i2, i3) {
    8809. 

  8809.  i2 = i2 | 0;
    8810. 

  8810.  i3 = i3 | 0;
    8811. 

  8811.  var i1 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0, i14 = 0, i15 = 0, i16 = 0, i17 = 0, i18 = 0, i19 = 0, i20 = 0, i21 = 0, i22 = 0, i23 = 0, i24 = 0, i25 = 0, i26 = 0, i27 = 0;
    8812. 

  8812.  i1 = STACKTOP;
    8813. 

  8813.  STACKTOP = STACKTOP + 16 | 0;
    8814. 

  8814.  i12 = i1;
    8815. 

  8815.  i4 = i2 + 60 | 0;
    8816. 

  8816.  HEAP32[(HEAP32[i4 >> 2] | 0) + 4 >> 2] = 0;
    8817. 

  8817.  i5 = i2 + 56 | 0;
    8818. 

  8818.  L1 : while (1) {
    8819. 

  8819.   i13 = HEAP32[i2 >> 2] | 0;
    8820. 

  8820.   L3 : while (1) {
    8821. 

  8821.    switch (i13 | 0) {
    8822. 

  8822.    case 11:
    8823. 

  8823.    case 9:
    8824. 

  8824.    case 12:
    8825. 

  8825.    case 32:
    8826. 

  8826.     {
    8827. 

  8827.      break;
    8828. 

  8828.     }
    8829. 

  8829.    case 91:
    8830. 

  8830.     {
    8831. 

  8831.      i9 = 25;
    8832. 

  8832.      break L1;
    8833. 

  8833.     }
    8834. 

  8834.    case 62:
    8835. 

  8835.     {
    8836. 

  8836.      i9 = 45;
    8837. 

  8837.      break L1;
    8838. 

  8838.     }
    8839. 

  8839.    case 46:
    8840. 

  8840.     {
    8841. 

  8841.      i9 = 161;
    8842. 

  8842.      break L1;
    8843. 

  8843.     }
    8844. 

  8844.    case 13:
    8845. 

  8845.    case 10:
    8846. 

  8846.     {
    8847. 

  8847.      i9 = 4;
    8848. 

  8848.      break L3;
    8849. 

  8849.     }
    8850. 

  8850.    case 45:
    8851. 

  8851.     {
    8852. 

  8852.      break L3;
    8853. 

  8853.     }
    8854. 

  8854.    case 61:
    8855. 

  8855.     {
    8856. 

  8856.      i9 = 29;
    8857. 

  8857.      break L1;
    8858. 

  8858.     }
    8859. 

  8859.    case 39:
    8860. 

  8860.    case 34:
    8861. 

  8861.     {
    8862. 

  8862.      i9 = 69;
    8863. 

  8863.      break L1;
    8864. 

  8864.     }
    8865. 

  8865.    case 126:
    8866. 

  8866.     {
    8867. 

  8867.      i9 = 53;
    8868. 

  8868.      break L1;
    8869. 

  8869.     }
    8870. 

  8870.    case 60:
    8871. 

  8871.     {
    8872. 

  8872.      i9 = 37;
    8873. 

  8873.      break L1;
    8874. 

  8874.     }
    8875. 

  8875.    case 58:
    8876. 

  8876.     {
    8877. 

  8877.      i9 = 61;
    8878. 

  8878.      break L1;
    8879. 

  8879.     }
    8880. 

  8880.    case 57:
    8881. 

  8881.    case 56:
    8882. 

  8882.    case 55:
    8883. 

  8883.    case 54:
    8884. 

  8884.    case 53:
    8885. 

  8885.    case 52:
    8886. 

  8886.    case 51:
    8887. 

  8887.    case 50:
    8888. 

  8888.    case 49:
    8889. 

  8889.    case 48:
    8890. 

  8890.     {
    8891. 

  8891.      i20 = i13;
    8892. 

  8892.      break L1;
    8893. 

  8893.     }
    8894. 

  8894.    case -1:
    8895. 

  8895.     {
    8896. 

  8896.      i2 = 286;
    8897. 

  8897.      i9 = 306;
    8898. 

  8898.      break L1;
    8899. 

  8899.     }
    8900. 

  8900.    default:
    8901. 

  8901.     {
    8902. 

  8902.      i9 = 283;
    8903. 

  8903.      break L1;
    8904. 

  8904.     }
    8905. 

  8905.    }
    8906. 

  8906.    i13 = HEAP32[i5 >> 2] | 0;
    8907. 

  8907.    i27 = HEAP32[i13 >> 2] | 0;
    8908. 

  8908.    HEAP32[i13 >> 2] = i27 + -1;
    8909. 

  8909.    if ((i27 | 0) == 0) {
    8910. 

  8910.     i13 = _luaZ_fill(i13) | 0;
    8911. 

  8911.    } else {
    8912. 

  8912.     i27 = i13 + 4 | 0;
    8913. 

  8913.     i13 = HEAP32[i27 >> 2] | 0;
    8914. 

  8914.     HEAP32[i27 >> 2] = i13 + 1;
    8915. 

  8915.     i13 = HEAPU8[i13] | 0;
    8916. 

  8916.    }
    8917. 

  8917.    HEAP32[i2 >> 2] = i13;
    8918. 

  8918.   }
    8919. 

  8919.   if ((i9 | 0) == 4) {
    8920. 

  8920.    i9 = 0;
    8921. 

  8921.    _inclinenumber(i2);
    8922. 

  8922.    continue;
    8923. 

  8923.   }
    8924. 

  8924.   i13 = HEAP32[i5 >> 2] | 0;
    8925. 

  8925.   i27 = HEAP32[i13 >> 2] | 0;
    8926. 

  8926.   HEAP32[i13 >> 2] = i27 + -1;
    8927. 

  8927.   if ((i27 | 0) == 0) {
    8928. 

  8928.    i13 = _luaZ_fill(i13) | 0;
    8929. 

  8929.   } else {
    8930. 

  8930.    i27 = i13 + 4 | 0;
    8931. 

  8931.    i13 = HEAP32[i27 >> 2] | 0;
    8932. 

  8932.    HEAP32[i27 >> 2] = i13 + 1;
    8933. 

  8933.    i13 = HEAPU8[i13] | 0;
    8934. 

  8934.   }
    8935. 

  8935.   HEAP32[i2 >> 2] = i13;
    8936. 

  8936.   if ((i13 | 0) != 45) {
    8937. 

  8937.    i2 = 45;
    8938. 

  8938.    i9 = 306;
    8939. 

  8939.    break;
    8940. 

  8940.   }
    8941. 

  8941.   i13 = HEAP32[i5 >> 2] | 0;
    8942. 

  8942.   i27 = HEAP32[i13 >> 2] | 0;
    8943. 

  8943.   HEAP32[i13 >> 2] = i27 + -1;
    8944. 

  8944.   if ((i27 | 0) == 0) {
    8945. 

  8945.    i13 = _luaZ_fill(i13) | 0;
    8946. 

  8946.   } else {
    8947. 

  8947.    i27 = i13 + 4 | 0;
    8948. 

  8948.    i13 = HEAP32[i27 >> 2] | 0;
    8949. 

  8949.    HEAP32[i27 >> 2] = i13 + 1;
    8950. 

  8950.    i13 = HEAPU8[i13] | 0;
    8951. 

  8951.   }
    8952. 

  8952.   HEAP32[i2 >> 2] = i13;
    8953. 

  8953.   do {
    8954. 

  8954.    if ((i13 | 0) == 91) {
    8955. 

  8955.     i13 = _skip_sep(i2) | 0;
    8956. 

  8956.     HEAP32[(HEAP32[i4 >> 2] | 0) + 4 >> 2] = 0;
    8957. 

  8957.     if ((i13 | 0) > -1) {
    8958. 

  8958.      _read_long_string(i2, 0, i13);
    8959. 

  8959.      HEAP32[(HEAP32[i4 >> 2] | 0) + 4 >> 2] = 0;
    8960. 

  8960.      continue L1;
    8961. 

  8961.     } else {
    8962. 

  8962.      i13 = HEAP32[i2 >> 2] | 0;
    8963. 

  8963.      break;
    8964. 

  8964.     }
    8965. 

  8965.    }
    8966. 

  8966.   } while (0);
    8967. 

  8967.   while (1) {
    8968. 

  8968.    if ((i13 | 0) == -1 | (i13 | 0) == 13 | (i13 | 0) == 10) {
    8969. 

  8969.     continue L1;
    8970. 

  8970.    }
    8971. 

  8971.    i13 = HEAP32[i5 >> 2] | 0;
    8972. 

  8972.    i27 = HEAP32[i13 >> 2] | 0;
    8973. 

  8973.    HEAP32[i13 >> 2] = i27 + -1;
    8974. 

  8974.    if ((i27 | 0) == 0) {
    8975. 

  8975.     i13 = _luaZ_fill(i13) | 0;
    8976. 

  8976.    } else {
    8977. 

  8977.     i27 = i13 + 4 | 0;
    8978. 

  8978.     i13 = HEAP32[i27 >> 2] | 0;
    8979. 

  8979.     HEAP32[i27 >> 2] = i13 + 1;
    8980. 

  8980.     i13 = HEAPU8[i13] | 0;
    8981. 

  8981.    }
    8982. 

  8982.    HEAP32[i2 >> 2] = i13;
    8983. 

  8983.   }
    8984. 

  8984.  }
    8985. 

  8985.  if ((i9 | 0) == 25) {
    8986. 

  8986.   i9 = _skip_sep(i2) | 0;
    8987. 

  8987.   if ((i9 | 0) > -1) {
    8988. 

  8988.    _read_long_string(i2, i3, i9);
    8989. 

  8989.    i27 = 289;
    8990. 

  8990.    STACKTOP = i1;
    8991. 

  8991.    return i27 | 0;
    8992. 

  8992.   }
    8993. 

  8993.   if ((i9 | 0) == -1) {
    8994. 

  8994.    i27 = 91;
    8995. 

  8995.    STACKTOP = i1;
    8996. 

  8996.    return i27 | 0;
    8997. 

  8997.   } else {
    8998. 

  8998.    _lexerror(i2, 12272, 289);
    8999. 

  8999.   }
    9000. 

  9000.  } else if ((i9 | 0) == 29) {
    9001. 

  9001.   i3 = HEAP32[i5 >> 2] | 0;
    9002. 

  9002.   i27 = HEAP32[i3 >> 2] | 0;
    9003. 

  9003.   HEAP32[i3 >> 2] = i27 + -1;
    9004. 

  9004.   if ((i27 | 0) == 0) {
    9005. 

  9005.    i3 = _luaZ_fill(i3) | 0;
    9006. 

  9006.   } else {
    9007. 

  9007.    i27 = i3 + 4 | 0;
    9008. 

  9008.    i3 = HEAP32[i27 >> 2] | 0;
    9009. 

  9009.    HEAP32[i27 >> 2] = i3 + 1;
    9010. 

  9010.    i3 = HEAPU8[i3] | 0;
    9011. 

  9011.   }
    9012. 

  9012.   HEAP32[i2 >> 2] = i3;
    9013. 

  9013.   if ((i3 | 0) != 61) {
    9014. 

  9014.    i27 = 61;
    9015. 

  9015.    STACKTOP = i1;
    9016. 

  9016.    return i27 | 0;
    9017. 

  9017.   }
    9018. 

  9018.   i3 = HEAP32[i5 >> 2] | 0;
    9019. 

  9019.   i27 = HEAP32[i3 >> 2] | 0;
    9020. 

  9020.   HEAP32[i3 >> 2] = i27 + -1;
    9021. 

  9021.   if ((i27 | 0) == 0) {
    9022. 

  9022.    i3 = _luaZ_fill(i3) | 0;
    9023. 

  9023.   } else {
    9024. 

  9024.    i27 = i3 + 4 | 0;
    9025. 

  9025.    i3 = HEAP32[i27 >> 2] | 0;
    9026. 

  9026.    HEAP32[i27 >> 2] = i3 + 1;
    9027. 

  9027.    i3 = HEAPU8[i3] | 0;
    9028. 

  9028.   }
    9029. 

  9029.   HEAP32[i2 >> 2] = i3;
    9030. 

  9030.   i27 = 281;
    9031. 

  9031.   STACKTOP = i1;
    9032. 

  9032.   return i27 | 0;
    9033. 

  9033.  } else if ((i9 | 0) == 37) {
    9034. 

  9034.   i3 = HEAP32[i5 >> 2] | 0;
    9035. 

  9035.   i27 = HEAP32[i3 >> 2] | 0;
    9036. 

  9036.   HEAP32[i3 >> 2] = i27 + -1;
    9037. 

  9037.   if ((i27 | 0) == 0) {
    9038. 

  9038.    i3 = _luaZ_fill(i3) | 0;
    9039. 

  9039.   } else {
    9040. 

  9040.    i27 = i3 + 4 | 0;
    9041. 

  9041.    i3 = HEAP32[i27 >> 2] | 0;
    9042. 

  9042.    HEAP32[i27 >> 2] = i3 + 1;
    9043. 

  9043.    i3 = HEAPU8[i3] | 0;
    9044. 

  9044.   }
    9045. 

  9045.   HEAP32[i2 >> 2] = i3;
    9046. 

  9046.   if ((i3 | 0) != 61) {
    9047. 

  9047.    i27 = 60;
    9048. 

  9048.    STACKTOP = i1;
    9049. 

  9049.    return i27 | 0;
    9050. 

  9050.   }
    9051. 

  9051.   i3 = HEAP32[i5 >> 2] | 0;
    9052. 

  9052.   i27 = HEAP32[i3 >> 2] | 0;
    9053. 

  9053.   HEAP32[i3 >> 2] = i27 + -1;
    9054. 

  9054.   if ((i27 | 0) == 0) {
    9055. 

  9055.    i3 = _luaZ_fill(i3) | 0;
    9056. 

  9056.   } else {
    9057. 

  9057.    i27 = i3 + 4 | 0;
    9058. 

  9058.    i3 = HEAP32[i27 >> 2] | 0;
    9059. 

  9059.    HEAP32[i27 >> 2] = i3 + 1;
    9060. 

  9060.    i3 = HEAPU8[i3] | 0;
    9061. 

  9061.   }
    9062. 

  9062.   HEAP32[i2 >> 2] = i3;
    9063. 

  9063.   i27 = 283;
    9064. 

  9064.   STACKTOP = i1;
    9065. 

  9065.   return i27 | 0;
    9066. 

  9066.  } else if ((i9 | 0) == 45) {
    9067. 

  9067.   i3 = HEAP32[i5 >> 2] | 0;
    9068. 

  9068.   i27 = HEAP32[i3 >> 2] | 0;
    9069. 

  9069.   HEAP32[i3 >> 2] = i27 + -1;
    9070. 

  9070.   if ((i27 | 0) == 0) {
    9071. 

  9071.    i3 = _luaZ_fill(i3) | 0;
    9072. 

  9072.   } else {
    9073. 

  9073.    i27 = i3 + 4 | 0;
    9074. 

  9074.    i3 = HEAP32[i27 >> 2] | 0;
    9075. 

  9075.    HEAP32[i27 >> 2] = i3 + 1;
    9076. 

  9076.    i3 = HEAPU8[i3] | 0;
    9077. 

  9077.   }
    9078. 

  9078.   HEAP32[i2 >> 2] = i3;
    9079. 

  9079.   if ((i3 | 0) != 61) {
    9080. 

  9080.    i27 = 62;
    9081. 

  9081.    STACKTOP = i1;
    9082. 

  9082.    return i27 | 0;
    9083. 

  9083.   }
    9084. 

  9084.   i3 = HEAP32[i5 >> 2] | 0;
    9085. 

  9085.   i27 = HEAP32[i3 >> 2] | 0;
    9086. 

  9086.   HEAP32[i3 >> 2] = i27 + -1;
    9087. 

  9087.   if ((i27 | 0) == 0) {
    9088. 

  9088.    i3 = _luaZ_fill(i3) | 0;
    9089. 

  9089.   } else {
    9090. 

  9090.    i27 = i3 + 4 | 0;
    9091. 

  9091.    i3 = HEAP32[i27 >> 2] | 0;
    9092. 

  9092.    HEAP32[i27 >> 2] = i3 + 1;
    9093. 

  9093.    i3 = HEAPU8[i3] | 0;
    9094. 

  9094.   }
    9095. 

  9095.   HEAP32[i2 >> 2] = i3;
    9096. 

  9096.   i27 = 282;
    9097. 

  9097.   STACKTOP = i1;
    9098. 

  9098.   return i27 | 0;
    9099. 

  9099.  } else if ((i9 | 0) == 53) {
    9100. 

  9100.   i3 = HEAP32[i5 >> 2] | 0;
    9101. 

  9101.   i27 = HEAP32[i3 >> 2] | 0;
    9102. 

  9102.   HEAP32[i3 >> 2] = i27 + -1;
    9103. 

  9103.   if ((i27 | 0) == 0) {
    9104. 

  9104.    i3 = _luaZ_fill(i3) | 0;
    9105. 

  9105.   } else {
    9106. 

  9106.    i27 = i3 + 4 | 0;
    9107. 

  9107.    i3 = HEAP32[i27 >> 2] | 0;
    9108. 

  9108.    HEAP32[i27 >> 2] = i3 + 1;
    9109. 

  9109.    i3 = HEAPU8[i3] | 0;
    9110. 

  9110.   }
    9111. 

  9111.   HEAP32[i2 >> 2] = i3;
    9112. 

  9112.   if ((i3 | 0) != 61) {
    9113. 

  9113.    i27 = 126;
    9114. 

  9114.    STACKTOP = i1;
    9115. 

  9115.    return i27 | 0;
    9116. 

  9116.   }
    9117. 

  9117.   i3 = HEAP32[i5 >> 2] | 0;
    9118. 

  9118.   i27 = HEAP32[i3 >> 2] | 0;
    9119. 

  9119.   HEAP32[i3 >> 2] = i27 + -1;
    9120. 

  9120.   if ((i27 | 0) == 0) {
    9121. 

  9121.    i3 = _luaZ_fill(i3) | 0;
    9122. 

  9122.   } else {
    9123. 

  9123.    i27 = i3 + 4 | 0;
    9124. 

  9124.    i3 = HEAP32[i27 >> 2] | 0;
    9125. 

  9125.    HEAP32[i27 >> 2] = i3 + 1;
    9126. 

  9126.    i3 = HEAPU8[i3] | 0;
    9127. 

  9127.   }
    9128. 

  9128.   HEAP32[i2 >> 2] = i3;
    9129. 

  9129.   i27 = 284;
    9130. 

  9130.   STACKTOP = i1;
    9131. 

  9131.   return i27 | 0;
    9132. 

  9132.  } else if ((i9 | 0) == 61) {
    9133. 

  9133.   i3 = HEAP32[i5 >> 2] | 0;
    9134. 

  9134.   i27 = HEAP32[i3 >> 2] | 0;
    9135. 

  9135.   HEAP32[i3 >> 2] = i27 + -1;
    9136. 

  9136.   if ((i27 | 0) == 0) {
    9137. 

  9137.    i3 = _luaZ_fill(i3) | 0;
    9138. 

  9138.   } else {
    9139. 

  9139.    i27 = i3 + 4 | 0;
    9140. 

  9140.    i3 = HEAP32[i27 >> 2] | 0;
    9141. 

  9141.    HEAP32[i27 >> 2] = i3 + 1;
    9142. 

  9142.    i3 = HEAPU8[i3] | 0;
    9143. 

  9143.   }
    9144. 

  9144.   HEAP32[i2 >> 2] = i3;
    9145. 

  9145.   if ((i3 | 0) != 58) {
    9146. 

  9146.    i27 = 58;
    9147. 

  9147.    STACKTOP = i1;
    9148. 

  9148.    return i27 | 0;
    9149. 

  9149.   }
    9150. 

  9150.   i3 = HEAP32[i5 >> 2] | 0;
    9151. 

  9151.   i27 = HEAP32[i3 >> 2] | 0;
    9152. 

  9152.   HEAP32[i3 >> 2] = i27 + -1;
    9153. 

  9153.   if ((i27 | 0) == 0) {
    9154. 

  9154.    i3 = _luaZ_fill(i3) | 0;
    9155. 

  9155.   } else {
    9156. 

  9156.    i27 = i3 + 4 | 0;
    9157. 

  9157.    i3 = HEAP32[i27 >> 2] | 0;
    9158. 

  9158.    HEAP32[i27 >> 2] = i3 + 1;
    9159. 

  9159.    i3 = HEAPU8[i3] | 0;
    9160. 

  9160.   }
    9161. 

  9161.   HEAP32[i2 >> 2] = i3;
    9162. 

  9162.   i27 = 285;
    9163. 

  9163.   STACKTOP = i1;
    9164. 

  9164.   return i27 | 0;
    9165. 

  9165.  } else if ((i9 | 0) == 69) {
    9166. 

  9166.   i14 = HEAP32[i4 >> 2] | 0;
    9167. 

  9167.   i7 = i14 + 4 | 0;
    9168. 

  9168.   i15 = HEAP32[i7 >> 2] | 0;
    9169. 

  9169.   i8 = i14 + 8 | 0;
    9170. 

  9170.   i6 = HEAP32[i8 >> 2] | 0;
    9171. 

  9171.   do {
    9172. 

  9172.    if ((i15 + 1 | 0) >>> 0 > i6 >>> 0) {
    9173. 

  9173.     if (i6 >>> 0 > 2147483645) {
    9174. 

  9174.      _lexerror(i2, 12368, 0);
    9175. 

  9175.     }
    9176. 

  9176.     i16 = i6 << 1;
    9177. 

  9177.     i15 = HEAP32[i2 + 52 >> 2] | 0;
    9178. 

  9178.     if ((i16 | 0) == -2) {
    9179. 

  9179.      _luaM_toobig(i15);
    9180. 

  9180.     } else {
    9181. 

  9181.      i24 = _luaM_realloc_(i15, HEAP32[i14 >> 2] | 0, i6, i16) | 0;
    9182. 

  9182.      HEAP32[i14 >> 2] = i24;
    9183. 

  9183.      HEAP32[i8 >> 2] = i16;
    9184. 

  9184.      i23 = HEAP32[i7 >> 2] | 0;
    9185. 

  9185.      break;
    9186. 

  9186.     }
    9187. 

  9187.    } else {
    9188. 

  9188.     i23 = i15;
    9189. 

  9189.     i24 = HEAP32[i14 >> 2] | 0;
    9190. 

  9190.    }
    9191. 

  9191.   } while (0);
    9192. 

  9192.   i6 = i13 & 255;
    9193. 

  9193.   HEAP32[i7 >> 2] = i23 + 1;
    9194. 

  9194.   HEAP8[i24 + i23 | 0] = i6;
    9195. 

  9195.   i7 = HEAP32[i5 >> 2] | 0;
    9196. 

  9196.   i27 = HEAP32[i7 >> 2] | 0;
    9197. 

  9197.   HEAP32[i7 >> 2] = i27 + -1;
    9198. 

  9198.   if ((i27 | 0) == 0) {
    9199. 

  9199.    i14 = _luaZ_fill(i7) | 0;
    9200. 

  9200.   } else {
    9201. 

  9201.    i27 = i7 + 4 | 0;
    9202. 

  9202.    i14 = HEAP32[i27 >> 2] | 0;
    9203. 

  9203.    HEAP32[i27 >> 2] = i14 + 1;
    9204. 

  9204.    i14 = HEAPU8[i14] | 0;
    9205. 

  9205.   }
    9206. 

  9206.   HEAP32[i2 >> 2] = i14;
    9207. 

  9207.   L139 : do {
    9208. 

  9208.    if ((i14 | 0) != (i13 | 0)) {
    9209. 

  9209.     i7 = i2 + 52 | 0;
    9210. 

  9210.     L141 : while (1) {
    9211. 

  9211.      L143 : do {
    9212. 

  9212.       if ((i14 | 0) == 92) {
    9213. 

  9213.        i8 = HEAP32[i5 >> 2] | 0;
    9214. 

  9214.        i27 = HEAP32[i8 >> 2] | 0;
    9215. 

  9215.        HEAP32[i8 >> 2] = i27 + -1;
    9216. 

  9216.        if ((i27 | 0) == 0) {
    9217. 

  9217.         i8 = _luaZ_fill(i8) | 0;
    9218. 

  9218.        } else {
    9219. 

  9219.         i27 = i8 + 4 | 0;
    9220. 

  9220.         i8 = HEAP32[i27 >> 2] | 0;
    9221. 

  9221.         HEAP32[i27 >> 2] = i8 + 1;
    9222. 

  9222.         i8 = HEAPU8[i8] | 0;
    9223. 

  9223.        }
    9224. 

  9224.        HEAP32[i2 >> 2] = i8;
    9225. 

  9225.        switch (i8 | 0) {
    9226. 

  9226.        case 13:
    9227. 

  9227.        case 10:
    9228. 

  9228.         {
    9229. 

  9229.          _inclinenumber(i2);
    9230. 

  9230.          i8 = 10;
    9231. 

  9231.          break;
    9232. 

  9232.         }
    9233. 

  9233.        case 39:
    9234. 

  9234.        case 34:
    9235. 

  9235.        case 92:
    9236. 

  9236.         {
    9237. 

  9237.          i9 = 124;
    9238. 

  9238.          break;
    9239. 

  9239.         }
    9240. 

  9240.        case 122:
    9241. 

  9241.         {
    9242. 

  9242.          i8 = HEAP32[i5 >> 2] | 0;
    9243. 

  9243.          i27 = HEAP32[i8 >> 2] | 0;
    9244. 

  9244.          HEAP32[i8 >> 2] = i27 + -1;
    9245. 

  9245.          if ((i27 | 0) == 0) {
    9246. 

  9246.           i14 = _luaZ_fill(i8) | 0;
    9247. 

  9247.          } else {
    9248. 

  9248.           i27 = i8 + 4 | 0;
    9249. 

  9249.           i14 = HEAP32[i27 >> 2] | 0;
    9250. 

  9250.           HEAP32[i27 >> 2] = i14 + 1;
    9251. 

  9251.           i14 = HEAPU8[i14] | 0;
    9252. 

  9252.          }
    9253. 

  9253.          HEAP32[i2 >> 2] = i14;
    9254. 

  9254.          if ((HEAP8[i14 + 10913 | 0] & 8) == 0) {
    9255. 

  9255.           break L143;
    9256. 

  9256.          }
    9257. 

  9257.          while (1) {
    9258. 

  9258.           if ((i14 | 0) == 13 | (i14 | 0) == 10) {
    9259. 

  9259.            _inclinenumber(i2);
    9260. 

  9260.            i14 = HEAP32[i2 >> 2] | 0;
    9261. 

  9261.           } else {
    9262. 

  9262.            i8 = HEAP32[i5 >> 2] | 0;
    9263. 

  9263.            i27 = HEAP32[i8 >> 2] | 0;
    9264. 

  9264.            HEAP32[i8 >> 2] = i27 + -1;
    9265. 

  9265.            if ((i27 | 0) == 0) {
    9266. 

  9266.             i14 = _luaZ_fill(i8) | 0;
    9267. 

  9267.            } else {
    9268. 

  9268.             i27 = i8 + 4 | 0;
    9269. 

  9269.             i14 = HEAP32[i27 >> 2] | 0;
    9270. 

  9270.             HEAP32[i27 >> 2] = i14 + 1;
    9271. 

  9271.             i14 = HEAPU8[i14] | 0;
    9272. 

  9272.            }
    9273. 

  9273.            HEAP32[i2 >> 2] = i14;
    9274. 

  9274.           }
    9275. 

  9275.           if ((HEAP8[i14 + 10913 | 0] & 8) == 0) {
    9276. 

  9276.            break L143;
    9277. 

  9277.           }
    9278. 

  9278.          }
    9279. 

  9279.         }
    9280. 

  9280.        case 118:
    9281. 

  9281.         {
    9282. 

  9282.          i8 = 11;
    9283. 

  9283.          i9 = 124;
    9284. 

  9284.          break;
    9285. 

  9285.         }
    9286. 

  9286.        case 120:
    9287. 

  9287.         {
    9288. 

  9288.          HEAP32[i12 >> 2] = 120;
    9289. 

  9289.          i14 = 1;
    9290. 

  9290.          i8 = 0;
    9291. 

  9291.          while (1) {
    9292. 

  9292.           i9 = HEAP32[i5 >> 2] | 0;
    9293. 

  9293.           i27 = HEAP32[i9 >> 2] | 0;
    9294. 

  9294.           HEAP32[i9 >> 2] = i27 + -1;
    9295. 

  9295.           if ((i27 | 0) == 0) {
    9296. 

  9296.            i9 = _luaZ_fill(i9) | 0;
    9297. 

  9297.           } else {
    9298. 

  9298.            i27 = i9 + 4 | 0;
    9299. 

  9299.            i9 = HEAP32[i27 >> 2] | 0;
    9300. 

  9300.            HEAP32[i27 >> 2] = i9 + 1;
    9301. 

  9301.            i9 = HEAPU8[i9] | 0;
    9302. 

  9302.           }
    9303. 

  9303.           HEAP32[i2 >> 2] = i9;
    9304. 

  9304.           HEAP32[i12 + (i14 << 2) >> 2] = i9;
    9305. 

  9305.           if ((HEAP8[i9 + 10913 | 0] & 16) == 0) {
    9306. 

  9306.            i9 = 100;
    9307. 

  9307.            break L141;
    9308. 

  9308.           }
    9309. 

  9309.           i8 = (_luaO_hexavalue(i9) | 0) + (i8 << 4) | 0;
    9310. 

  9310.           i14 = i14 + 1 | 0;
    9311. 

  9311.           if ((i14 | 0) >= 3) {
    9312. 

  9312.            i9 = 124;
    9313. 

  9313.            break;
    9314. 

  9314.           }
    9315. 

  9315.          }
    9316. 

  9316.          break;
    9317. 

  9317.         }
    9318. 

  9318.        case -1:
    9319. 

  9319.         {
    9320. 

  9320.          i14 = -1;
    9321. 

  9321.          break L143;
    9322. 

  9322.         }
    9323. 

  9323.        case 98:
    9324. 

  9324.         {
    9325. 

  9325.          i8 = 8;
    9326. 

  9326.          i9 = 124;
    9327. 

  9327.          break;
    9328. 

  9328.         }
    9329. 

  9329.        case 102:
    9330. 

  9330.         {
    9331. 

  9331.          i8 = 12;
    9332. 

  9332.          i9 = 124;
    9333. 

  9333.          break;
    9334. 

  9334.         }
    9335. 

  9335.        case 110:
    9336. 

  9336.         {
    9337. 

  9337.          i8 = 10;
    9338. 

  9338.          i9 = 124;
    9339. 

  9339.          break;
    9340. 

  9340.         }
    9341. 

  9341.        case 114:
    9342. 

  9342.         {
    9343. 

  9343.          i8 = 13;
    9344. 

  9344.          i9 = 124;
    9345. 

  9345.          break;
    9346. 

  9346.         }
    9347. 

  9347.        case 116:
    9348. 

  9348.         {
    9349. 

  9349.          i8 = 9;
    9350. 

  9350.          i9 = 124;
    9351. 

  9351.          break;
    9352. 

  9352.         }
    9353. 

  9353.        case 97:
    9354. 

  9354.         {
    9355. 

  9355.          i8 = 7;
    9356. 

  9356.          i9 = 124;
    9357. 

  9357.          break;
    9358. 

  9358.         }
    9359. 

  9359.        default:
    9360. 

  9360.         {
    9361. 

  9361.          if ((HEAP8[i8 + 10913 | 0] & 2) == 0) {
    9362. 

  9362.           i9 = 116;
    9363. 

  9363.           break L141;
    9364. 

  9364.          } else {
    9365. 

  9365.           i15 = i8;
    9366. 

  9366.           i14 = 0;
    9367. 

  9367.           i8 = 0;
    9368. 

  9368.          }
    9369. 

  9369.          do {
    9370. 

  9370.           if ((HEAP8[i15 + 10913 | 0] & 2) == 0) {
    9371. 

  9371.            break;
    9372. 

  9372.           }
    9373. 

  9373.           HEAP32[i12 + (i14 << 2) >> 2] = i15;
    9374. 

  9374.           i8 = i15 + -48 + (i8 * 10 | 0) | 0;
    9375. 

  9375.           i15 = HEAP32[i5 >> 2] | 0;
    9376. 

  9376.           i27 = HEAP32[i15 >> 2] | 0;
    9377. 

  9377.           HEAP32[i15 >> 2] = i27 + -1;
    9378. 

  9378.           if ((i27 | 0) == 0) {
    9379. 

  9379.            i15 = _luaZ_fill(i15) | 0;
    9380. 

  9380.           } else {
    9381. 

  9381.            i27 = i15 + 4 | 0;
    9382. 

  9382.            i15 = HEAP32[i27 >> 2] | 0;
    9383. 

  9383.            HEAP32[i27 >> 2] = i15 + 1;
    9384. 

  9384.            i15 = HEAPU8[i15] | 0;
    9385. 

  9385.           }
    9386. 

  9386.           HEAP32[i2 >> 2] = i15;
    9387. 

  9387.           i14 = i14 + 1 | 0;
    9388. 

  9388.          } while ((i14 | 0) < 3);
    9389. 

  9389.          if ((i8 | 0) > 255) {
    9390. 

  9390.           i9 = 123;
    9391. 

  9391.           break L141;
    9392. 

  9392.          }
    9393. 

  9393.         }
    9394. 

  9394.        }
    9395. 

  9395.        if ((i9 | 0) == 124) {
    9396. 

  9396.         i9 = 0;
    9397. 

  9397.         i14 = HEAP32[i5 >> 2] | 0;
    9398. 

  9398.         i27 = HEAP32[i14 >> 2] | 0;
    9399. 

  9399.         HEAP32[i14 >> 2] = i27 + -1;
    9400. 

  9400.         if ((i27 | 0) == 0) {
    9401. 

  9401.          i14 = _luaZ_fill(i14) | 0;
    9402. 

  9402.         } else {
    9403. 

  9403.          i27 = i14 + 4 | 0;
    9404. 

  9404.          i14 = HEAP32[i27 >> 2] | 0;
    9405. 

  9405.          HEAP32[i27 >> 2] = i14 + 1;
    9406. 

  9406.          i14 = HEAPU8[i14] | 0;
    9407. 

  9407.         }
    9408. 

  9408.         HEAP32[i2 >> 2] = i14;
    9409. 

  9409.        }
    9410. 

  9410.        i15 = HEAP32[i4 >> 2] | 0;
    9411. 

  9411.        i14 = i15 + 4 | 0;
    9412. 

  9412.        i18 = HEAP32[i14 >> 2] | 0;
    9413. 

  9413.        i16 = i15 + 8 | 0;
    9414. 

  9414.        i17 = HEAP32[i16 >> 2] | 0;
    9415. 

  9415.        if ((i18 + 1 | 0) >>> 0 > i17 >>> 0) {
    9416. 

  9416.         if (i17 >>> 0 > 2147483645) {
    9417. 

  9417.          i9 = 131;
    9418. 

  9418.          break L141;
    9419. 

  9419.         }
    9420. 

  9420.         i18 = i17 << 1;
    9421. 

  9421.         i19 = HEAP32[i7 >> 2] | 0;
    9422. 

  9422.         if ((i18 | 0) == -2) {
    9423. 

  9423.          i9 = 133;
    9424. 

  9424.          break L141;
    9425. 

  9425.         }
    9426. 

  9426.         i27 = _luaM_realloc_(i19, HEAP32[i15 >> 2] | 0, i17, i18) | 0;
    9427. 

  9427.         HEAP32[i15 >> 2] = i27;
    9428. 

  9428.         HEAP32[i16 >> 2] = i18;
    9429. 

  9429.         i18 = HEAP32[i14 >> 2] | 0;
    9430. 

  9430.         i15 = i27;
    9431. 

  9431.        } else {
    9432. 

  9432.         i15 = HEAP32[i15 >> 2] | 0;
    9433. 

  9433.        }
    9434. 

  9434.        HEAP32[i14 >> 2] = i18 + 1;
    9435. 

  9435.        HEAP8[i15 + i18 | 0] = i8;
    9436. 

  9436.        i14 = HEAP32[i2 >> 2] | 0;
    9437. 

  9437.       } else if ((i14 | 0) == -1) {
    9438. 

  9438.        i9 = 82;
    9439. 

  9439.        break L141;
    9440. 

  9440.       } else if ((i14 | 0) == 13 | (i14 | 0) == 10) {
    9441. 

  9441.        i9 = 83;
    9442. 

  9442.        break L141;
    9443. 

  9443.       } else {
    9444. 

  9444.        i15 = HEAP32[i4 >> 2] | 0;
    9445. 

  9445.        i8 = i15 + 4 | 0;
    9446. 

  9446.        i18 = HEAP32[i8 >> 2] | 0;
    9447. 

  9447.        i17 = i15 + 8 | 0;
    9448. 

  9448.        i16 = HEAP32[i17 >> 2] | 0;
    9449. 

  9449.        if ((i18 + 1 | 0) >>> 0 > i16 >>> 0) {
    9450. 

  9450.         if (i16 >>> 0 > 2147483645) {
    9451. 

  9451.          i9 = 139;
    9452. 

  9452.          break L141;
    9453. 

  9453.         }
    9454. 

  9454.         i19 = i16 << 1;
    9455. 

  9455.         i18 = HEAP32[i7 >> 2] | 0;
    9456. 

  9456.         if ((i19 | 0) == -2) {
    9457. 

  9457.          i9 = 141;
    9458. 

  9458.          break L141;
    9459. 

  9459.         }
    9460. 

  9460.         i27 = _luaM_realloc_(i18, HEAP32[i15 >> 2] | 0, i16, i19) | 0;
    9461. 

  9461.         HEAP32[i15 >> 2] = i27;
    9462. 

  9462.         HEAP32[i17 >> 2] = i19;
    9463. 

  9463.         i18 = HEAP32[i8 >> 2] | 0;
    9464. 

  9464.         i15 = i27;
    9465. 

  9465.        } else {
    9466. 

  9466.         i15 = HEAP32[i15 >> 2] | 0;
    9467. 

  9467.        }
    9468. 

  9468.        HEAP32[i8 >> 2] = i18 + 1;
    9469. 

  9469.        HEAP8[i15 + i18 | 0] = i14;
    9470. 

  9470.        i8 = HEAP32[i5 >> 2] | 0;
    9471. 

  9471.        i27 = HEAP32[i8 >> 2] | 0;
    9472. 

  9472.        HEAP32[i8 >> 2] = i27 + -1;
    9473. 

  9473.        if ((i27 | 0) == 0) {
    9474. 

  9474.         i14 = _luaZ_fill(i8) | 0;
    9475. 

  9475.        } else {
    9476. 

  9476.         i27 = i8 + 4 | 0;
    9477. 

  9477.         i14 = HEAP32[i27 >> 2] | 0;
    9478. 

  9478.         HEAP32[i27 >> 2] = i14 + 1;
    9479. 

  9479.         i14 = HEAPU8[i14] | 0;
    9480. 

  9480.        }
    9481. 

  9481.        HEAP32[i2 >> 2] = i14;
    9482. 

  9482.       }
    9483. 

  9483.      } while (0);
    9484. 

  9484.      if ((i14 | 0) == (i13 | 0)) {
    9485. 

  9485.       break L139;
    9486. 

  9486.      }
    9487. 

  9487.     }
    9488. 

  9488.     if ((i9 | 0) == 82) {
    9489. 

  9489.      _lexerror(i2, 12400, 286);
    9490. 

  9490.     } else if ((i9 | 0) == 83) {
    9491. 

  9491.      _lexerror(i2, 12400, 289);
    9492. 

  9492.     } else if ((i9 | 0) == 100) {
    9493. 

  9493.      _escerror(i2, i12, i14 + 1 | 0, 12480);
    9494. 

  9494.     } else if ((i9 | 0) == 116) {
    9495. 

  9495.      _escerror(i2, i2, 1, 12424);
    9496. 

  9496.     } else if ((i9 | 0) == 123) {
    9497. 

  9497.      _escerror(i2, i12, i14, 12448);
    9498. 

  9498.     } else if ((i9 | 0) == 131) {
    9499. 

  9499.      _lexerror(i2, 12368, 0);
    9500. 

  9500.     } else if ((i9 | 0) == 133) {
    9501. 

  9501.      _luaM_toobig(i19);
    9502. 

  9502.     } else if ((i9 | 0) == 139) {
    9503. 

  9503.      _lexerror(i2, 12368, 0);
    9504. 

  9504.     } else if ((i9 | 0) == 141) {
    9505. 

  9505.      _luaM_toobig(i18);
    9506. 

  9506.     }
    9507. 

  9507.    }
    9508. 

  9508.   } while (0);
    9509. 

  9509.   i7 = HEAP32[i4 >> 2] | 0;
    9510. 

  9510.   i8 = i7 + 4 | 0;
    9511. 

  9511.   i13 = HEAP32[i8 >> 2] | 0;
    9512. 

  9512.   i12 = i7 + 8 | 0;
    9513. 

  9513.   i9 = HEAP32[i12 >> 2] | 0;
    9514. 

  9514.   do {
    9515. 

  9515.    if ((i13 + 1 | 0) >>> 0 > i9 >>> 0) {
    9516. 

  9516.     if (i9 >>> 0 > 2147483645) {
    9517. 

  9517.      _lexerror(i2, 12368, 0);
    9518. 

  9518.     }
    9519. 

  9519.     i14 = i9 << 1;
    9520. 

  9520.     i13 = HEAP32[i2 + 52 >> 2] | 0;
    9521. 

  9521.     if ((i14 | 0) == -2) {
    9522. 

  9522.      _luaM_toobig(i13);
    9523. 

  9523.     } else {
    9524. 

  9524.      i11 = _luaM_realloc_(i13, HEAP32[i7 >> 2] | 0, i9, i14) | 0;
    9525. 

  9525.      HEAP32[i7 >> 2] = i11;
    9526. 

  9526.      HEAP32[i12 >> 2] = i14;
    9527. 

  9527.      i10 = HEAP32[i8 >> 2] | 0;
    9528. 

  9528.      break;
    9529. 

  9529.     }
    9530. 

  9530.    } else {
    9531. 

  9531.     i10 = i13;
    9532. 

  9532.     i11 = HEAP32[i7 >> 2] | 0;
    9533. 

  9533.    }
    9534. 

  9534.   } while (0);
    9535. 

  9535.   HEAP32[i8 >> 2] = i10 + 1;
    9536. 

  9536.   HEAP8[i11 + i10 | 0] = i6;
    9537. 

  9537.   i5 = HEAP32[i5 >> 2] | 0;
    9538. 

  9538.   i27 = HEAP32[i5 >> 2] | 0;
    9539. 

  9539.   HEAP32[i5 >> 2] = i27 + -1;
    9540. 

  9540.   if ((i27 | 0) == 0) {
    9541. 

  9541.    i5 = _luaZ_fill(i5) | 0;
    9542. 

  9542.   } else {
    9543. 

  9543.    i27 = i5 + 4 | 0;
    9544. 

  9544.    i5 = HEAP32[i27 >> 2] | 0;
    9545. 

  9545.    HEAP32[i27 >> 2] = i5 + 1;
    9546. 

  9546.    i5 = HEAPU8[i5] | 0;
    9547. 

  9547.   }
    9548. 

  9548.   HEAP32[i2 >> 2] = i5;
    9549. 

  9549.   i5 = HEAP32[i4 >> 2] | 0;
    9550. 

  9550.   i4 = HEAP32[i2 + 52 >> 2] | 0;
    9551. 

  9551.   i5 = _luaS_newlstr(i4, (HEAP32[i5 >> 2] | 0) + 1 | 0, (HEAP32[i5 + 4 >> 2] | 0) + -2 | 0) | 0;
    9552. 

  9552.   i6 = i4 + 8 | 0;
    9553. 

  9553.   i7 = HEAP32[i6 >> 2] | 0;
    9554. 

  9554.   HEAP32[i6 >> 2] = i7 + 16;
    9555. 

  9555.   HEAP32[i7 >> 2] = i5;
    9556. 

  9556.   HEAP32[i7 + 8 >> 2] = HEAPU8[i5 + 4 | 0] | 64;
    9557. 

  9557.   i7 = _luaH_set(i4, HEAP32[(HEAP32[i2 + 48 >> 2] | 0) + 4 >> 2] | 0, (HEAP32[i6 >> 2] | 0) + -16 | 0) | 0;
    9558. 

  9558.   i2 = i7 + 8 | 0;
    9559. 

  9559.   if ((HEAP32[i2 >> 2] | 0) == 0 ? (HEAP32[i7 >> 2] = 1, HEAP32[i2 >> 2] = 1, (HEAP32[(HEAP32[i4 + 12 >> 2] | 0) + 12 >> 2] | 0) > 0) : 0) {
    9560. 

  9560.    _luaC_step(i4);
    9561. 

  9561.   }
    9562. 

  9562.   HEAP32[i6 >> 2] = (HEAP32[i6 >> 2] | 0) + -16;
    9563. 

  9563.   HEAP32[i3 >> 2] = i5;
    9564. 

  9564.   i27 = 289;
    9565. 

  9565.   STACKTOP = i1;
    9566. 

  9566.   return i27 | 0;
    9567. 

  9567.  } else if ((i9 | 0) == 161) {
    9568. 

  9568.   i10 = HEAP32[i4 >> 2] | 0;
    9569. 

  9569.   i9 = i10 + 4 | 0;
    9570. 

  9570.   i13 = HEAP32[i9 >> 2] | 0;
    9571. 

  9571.   i12 = i10 + 8 | 0;
    9572. 

  9572.   i11 = HEAP32[i12 >> 2] | 0;
    9573. 

  9573.   do {
    9574. 

  9574.    if ((i13 + 1 | 0) >>> 0 > i11 >>> 0) {
    9575. 

  9575.     if (i11 >>> 0 > 2147483645) {
    9576. 

  9576.      _lexerror(i2, 12368, 0);
    9577. 

  9577.     }
    9578. 

  9578.     i13 = i11 << 1;
    9579. 

  9579.     i20 = HEAP32[i2 + 52 >> 2] | 0;
    9580. 

  9580.     if ((i13 | 0) == -2) {
    9581. 

  9581.      _luaM_toobig(i20);
    9582. 

  9582.     } else {
    9583. 

  9583.      i25 = _luaM_realloc_(i20, HEAP32[i10 >> 2] | 0, i11, i13) | 0;
    9584. 

  9584.      HEAP32[i10 >> 2] = i25;
    9585. 

  9585.      HEAP32[i12 >> 2] = i13;
    9586. 

  9586.      i26 = HEAP32[i9 >> 2] | 0;
    9587. 

  9587.      break;
    9588. 

  9588.     }
    9589. 

  9589.    } else {
    9590. 

  9590.     i26 = i13;
    9591. 

  9591.     i25 = HEAP32[i10 >> 2] | 0;
    9592. 

  9592.    }
    9593. 

  9593.   } while (0);
    9594. 

  9594.   HEAP32[i9 >> 2] = i26 + 1;
    9595. 

  9595.   HEAP8[i25 + i26 | 0] = 46;
    9596. 

  9596.   i9 = HEAP32[i5 >> 2] | 0;
    9597. 

  9597.   i27 = HEAP32[i9 >> 2] | 0;
    9598. 

  9598.   HEAP32[i9 >> 2] = i27 + -1;
    9599. 

  9599.   if ((i27 | 0) == 0) {
    9600. 

  9600.    i20 = _luaZ_fill(i9) | 0;
    9601. 

  9601.   } else {
    9602. 

  9602.    i27 = i9 + 4 | 0;
    9603. 

  9603.    i20 = HEAP32[i27 >> 2] | 0;
    9604. 

  9604.    HEAP32[i27 >> 2] = i20 + 1;
    9605. 

  9605.    i20 = HEAPU8[i20] | 0;
    9606. 

  9606.   }
    9607. 

  9607.   HEAP32[i2 >> 2] = i20;
    9608. 

  9608.   if ((i20 | 0) != 0 ? (_memchr(12304, i20, 2) | 0) != 0 : 0) {
    9609. 

  9609.    i6 = HEAP32[i4 >> 2] | 0;
    9610. 

  9610.    i3 = i6 + 4 | 0;
    9611. 

  9611.    i9 = HEAP32[i3 >> 2] | 0;
    9612. 

  9612.    i8 = i6 + 8 | 0;
    9613. 

  9613.    i7 = HEAP32[i8 >> 2] | 0;
    9614. 

  9614.    do {
    9615. 

  9615.     if ((i9 + 1 | 0) >>> 0 > i7 >>> 0) {
    9616. 

  9616.      if (i7 >>> 0 > 2147483645) {
    9617. 

  9617.       _lexerror(i2, 12368, 0);
    9618. 

  9618.      }
    9619. 

  9619.      i9 = i7 << 1;
    9620. 

  9620.      i10 = HEAP32[i2 + 52 >> 2] | 0;
    9621. 

  9621.      if ((i9 | 0) == -2) {
    9622. 

  9622.       _luaM_toobig(i10);
    9623. 

  9623.      } else {
    9624. 

  9624.       i21 = _luaM_realloc_(i10, HEAP32[i6 >> 2] | 0, i7, i9) | 0;
    9625. 

  9625.       HEAP32[i6 >> 2] = i21;
    9626. 

  9626.       HEAP32[i8 >> 2] = i9;
    9627. 

  9627.       i22 = HEAP32[i3 >> 2] | 0;
    9628. 

  9628.       break;
    9629. 

  9629.      }
    9630. 

  9630.     } else {
    9631. 

  9631.      i22 = i9;
    9632. 

  9632.      i21 = HEAP32[i6 >> 2] | 0;
    9633. 

  9633.     }
    9634. 

  9634.    } while (0);
    9635. 

  9635.    HEAP32[i3 >> 2] = i22 + 1;
    9636. 

  9636.    HEAP8[i21 + i22 | 0] = i20;
    9637. 

  9637.    i3 = HEAP32[i5 >> 2] | 0;
    9638. 

  9638.    i27 = HEAP32[i3 >> 2] | 0;
    9639. 

  9639.    HEAP32[i3 >> 2] = i27 + -1;
    9640. 

  9640.    if ((i27 | 0) == 0) {
    9641. 

  9641.     i3 = _luaZ_fill(i3) | 0;
    9642. 

  9642.    } else {
    9643. 

  9643.     i27 = i3 + 4 | 0;
    9644. 

  9644.     i3 = HEAP32[i27 >> 2] | 0;
    9645. 

  9645.     HEAP32[i27 >> 2] = i3 + 1;
    9646. 

  9646.     i3 = HEAPU8[i3] | 0;
    9647. 

  9647.    }
    9648. 

  9648.    HEAP32[i2 >> 2] = i3;
    9649. 

  9649.    if ((i3 | 0) == 0) {
    9650. 

  9650.     i27 = 279;
    9651. 

  9651.     STACKTOP = i1;
    9652. 

  9652.     return i27 | 0;
    9653. 

  9653.    }
    9654. 

  9654.    if ((_memchr(12304, i3, 2) | 0) == 0) {
    9655. 

  9655.     i27 = 279;
    9656. 

  9656.     STACKTOP = i1;
    9657. 

  9657.     return i27 | 0;
    9658. 

  9658.    }
    9659. 

  9659.    i6 = HEAP32[i4 >> 2] | 0;
    9660. 

  9660.    i7 = i6 + 4 | 0;
    9661. 

  9661.    i9 = HEAP32[i7 >> 2] | 0;
    9662. 

  9662.    i8 = i6 + 8 | 0;
    9663. 

  9663.    i4 = HEAP32[i8 >> 2] | 0;
    9664. 

  9664.    do {
    9665. 

  9665.     if ((i9 + 1 | 0) >>> 0 > i4 >>> 0) {
    9666. 

  9666.      if (i4 >>> 0 > 2147483645) {
    9667. 

  9667.       _lexerror(i2, 12368, 0);
    9668. 

  9668.      }
    9669. 

  9669.      i10 = i4 << 1;
    9670. 

  9670.      i9 = HEAP32[i2 + 52 >> 2] | 0;
    9671. 

  9671.      if ((i10 | 0) == -2) {
    9672. 

  9672.       _luaM_toobig(i9);
    9673. 

  9673.      } else {
    9674. 

  9674.       i18 = _luaM_realloc_(i9, HEAP32[i6 >> 2] | 0, i4, i10) | 0;
    9675. 

  9675.       HEAP32[i6 >> 2] = i18;
    9676. 

  9676.       HEAP32[i8 >> 2] = i10;
    9677. 

  9677.       i19 = HEAP32[i7 >> 2] | 0;
    9678. 

  9678.       break;
    9679. 

  9679.      }
    9680. 

  9680.     } else {
    9681. 

  9681.      i19 = i9;
    9682. 

  9682.      i18 = HEAP32[i6 >> 2] | 0;
    9683. 

  9683.     }
    9684. 

  9684.    } while (0);
    9685. 

  9685.    HEAP32[i7 >> 2] = i19 + 1;
    9686. 

  9686.    HEAP8[i18 + i19 | 0] = i3;
    9687. 

  9687.    i3 = HEAP32[i5 >> 2] | 0;
    9688. 

  9688.    i27 = HEAP32[i3 >> 2] | 0;
    9689. 

  9689.    HEAP32[i3 >> 2] = i27 + -1;
    9690. 

  9690.    if ((i27 | 0) == 0) {
    9691. 

  9691.     i3 = _luaZ_fill(i3) | 0;
    9692. 

  9692.    } else {
    9693. 

  9693.     i27 = i3 + 4 | 0;
    9694. 

  9694.     i3 = HEAP32[i27 >> 2] | 0;
    9695. 

  9695.     HEAP32[i27 >> 2] = i3 + 1;
    9696. 

  9696.     i3 = HEAPU8[i3] | 0;
    9697. 

  9697.    }
    9698. 

  9698.    HEAP32[i2 >> 2] = i3;
    9699. 

  9699.    i27 = 280;
    9700. 

  9700.    STACKTOP = i1;
    9701. 

  9701.    return i27 | 0;
    9702. 

  9702.   }
    9703. 

  9703.   if ((HEAP8[i20 + 10913 | 0] & 2) == 0) {
    9704. 

  9704.    i27 = 46;
    9705. 

  9705.    STACKTOP = i1;
    9706. 

  9706.    return i27 | 0;
    9707. 

  9707.   }
    9708. 

  9708.  } else if ((i9 | 0) == 283) {
    9709. 

  9709.   if ((HEAP8[i13 + 10913 | 0] & 1) == 0) {
    9710. 

  9710.    i3 = HEAP32[i5 >> 2] | 0;
    9711. 

  9711.    i27 = HEAP32[i3 >> 2] | 0;
    9712. 

  9712.    HEAP32[i3 >> 2] = i27 + -1;
    9713. 

  9713.    if ((i27 | 0) == 0) {
    9714. 

  9714.     i3 = _luaZ_fill(i3) | 0;
    9715. 

  9715.    } else {
    9716. 

  9716.     i27 = i3 + 4 | 0;
    9717. 

  9717.     i3 = HEAP32[i27 >> 2] | 0;
    9718. 

  9718.     HEAP32[i27 >> 2] = i3 + 1;
    9719. 

  9719.     i3 = HEAPU8[i3] | 0;
    9720. 

  9720.    }
    9721. 

  9721.    HEAP32[i2 >> 2] = i3;
    9722. 

  9722.    i27 = i13;
    9723. 

  9723.    STACKTOP = i1;
    9724. 

  9724.    return i27 | 0;
    9725. 

  9725.   }
    9726. 

  9726.   i10 = i2 + 52 | 0;
    9727. 

  9727.   while (1) {
    9728. 

  9728.    i11 = HEAP32[i4 >> 2] | 0;
    9729. 

  9729.    i9 = i11 + 4 | 0;
    9730. 

  9730.    i12 = HEAP32[i9 >> 2] | 0;
    9731. 

  9731.    i19 = i11 + 8 | 0;
    9732. 

  9732.    i18 = HEAP32[i19 >> 2] | 0;
    9733. 

  9733.    if ((i12 + 1 | 0) >>> 0 > i18 >>> 0) {
    9734. 

  9734.     if (i18 >>> 0 > 2147483645) {
    9735. 

  9735.      i9 = 288;
    9736. 

  9736.      break;
    9737. 

  9737.     }
    9738. 

  9738.     i21 = i18 << 1;
    9739. 

  9739.     i12 = HEAP32[i10 >> 2] | 0;
    9740. 

  9740.     if ((i21 | 0) == -2) {
    9741. 

  9741.      i9 = 290;
    9742. 

  9742.      break;
    9743. 

  9743.     }
    9744. 

  9744.     i27 = _luaM_realloc_(i12, HEAP32[i11 >> 2] | 0, i18, i21) | 0;
    9745. 

  9745.     HEAP32[i11 >> 2] = i27;
    9746. 

  9746.     HEAP32[i19 >> 2] = i21;
    9747. 

  9747.     i12 = HEAP32[i9 >> 2] | 0;
    9748. 

  9748.     i11 = i27;
    9749. 

  9749.    } else {
    9750. 

  9750.     i11 = HEAP32[i11 >> 2] | 0;
    9751. 

  9751.    }
    9752. 

  9752.    HEAP32[i9 >> 2] = i12 + 1;
    9753. 

  9753.    HEAP8[i11 + i12 | 0] = i13;
    9754. 

  9754.    i9 = HEAP32[i5 >> 2] | 0;
    9755. 

  9755.    i27 = HEAP32[i9 >> 2] | 0;
    9756. 

  9756.    HEAP32[i9 >> 2] = i27 + -1;
    9757. 

  9757.    if ((i27 | 0) == 0) {
    9758. 

  9758.     i13 = _luaZ_fill(i9) | 0;
    9759. 

  9759.    } else {
    9760. 

  9760.     i27 = i9 + 4 | 0;
    9761. 

  9761.     i13 = HEAP32[i27 >> 2] | 0;
    9762. 

  9762.     HEAP32[i27 >> 2] = i13 + 1;
    9763. 

  9763.     i13 = HEAPU8[i13] | 0;
    9764. 

  9764.    }
    9765. 

  9765.    HEAP32[i2 >> 2] = i13;
    9766. 

  9766.    if ((HEAP8[i13 + 10913 | 0] & 3) == 0) {
    9767. 

  9767.     i9 = 296;
    9768. 

  9768.     break;
    9769. 

  9769.    }
    9770. 

  9770.   }
    9771. 

  9771.   if ((i9 | 0) == 288) {
    9772. 

  9772.    _lexerror(i2, 12368, 0);
    9773. 

  9773.   } else if ((i9 | 0) == 290) {
    9774. 

  9774.    _luaM_toobig(i12);
    9775. 

  9775.   } else if ((i9 | 0) == 296) {
    9776. 

  9776.    i6 = HEAP32[i4 >> 2] | 0;
    9777. 

  9777.    i4 = HEAP32[i10 >> 2] | 0;
    9778. 

  9778.    i6 = _luaS_newlstr(i4, HEAP32[i6 >> 2] | 0, HEAP32[i6 + 4 >> 2] | 0) | 0;
    9779. 

  9779.    i7 = i4 + 8 | 0;
    9780. 

  9780.    i8 = HEAP32[i7 >> 2] | 0;
    9781. 

  9781.    HEAP32[i7 >> 2] = i8 + 16;
    9782. 

  9782.    HEAP32[i8 >> 2] = i6;
    9783. 

  9783.    i5 = i6 + 4 | 0;
    9784. 

  9784.    HEAP32[i8 + 8 >> 2] = HEAPU8[i5] | 64;
    9785. 

  9785.    i8 = _luaH_set(i4, HEAP32[(HEAP32[i2 + 48 >> 2] | 0) + 4 >> 2] | 0, (HEAP32[i7 >> 2] | 0) + -16 | 0) | 0;
    9786. 

  9786.    i2 = i8 + 8 | 0;
    9787. 

  9787.    if ((HEAP32[i2 >> 2] | 0) == 0 ? (HEAP32[i8 >> 2] = 1, HEAP32[i2 >> 2] = 1, (HEAP32[(HEAP32[i4 + 12 >> 2] | 0) + 12 >> 2] | 0) > 0) : 0) {
    9788. 

  9788.     _luaC_step(i4);
    9789. 

  9789.    }
    9790. 

  9790.    HEAP32[i7 >> 2] = (HEAP32[i7 >> 2] | 0) + -16;
    9791. 

  9791.    HEAP32[i3 >> 2] = i6;
    9792. 

  9792.    if ((HEAP8[i5] | 0) != 4) {
    9793. 

  9793.     i27 = 288;
    9794. 

  9794.     STACKTOP = i1;
    9795. 

  9795.     return i27 | 0;
    9796. 

  9796.    }
    9797. 

  9797.    i2 = HEAP8[i6 + 6 | 0] | 0;
    9798. 

  9798.    if (i2 << 24 >> 24 == 0) {
    9799. 

  9799.     i27 = 288;
    9800. 

  9800.     STACKTOP = i1;
    9801. 

  9801.     return i27 | 0;
    9802. 

  9802.    }
    9803. 

  9803.    i27 = i2 & 255 | 256;
    9804. 

  9804.    STACKTOP = i1;
    9805. 

  9805.    return i27 | 0;
    9806. 

  9806.   }
    9807. 

  9807.  } else if ((i9 | 0) == 306) {
    9808. 

  9808.   STACKTOP = i1;
    9809. 

  9809.   return i2 | 0;
    9810. 

  9810.  }
    9811. 

  9811.  i9 = HEAP32[i4 >> 2] | 0;
    9812. 

  9812.  i12 = i9 + 4 | 0;
    9813. 

  9813.  i13 = HEAP32[i12 >> 2] | 0;
    9814. 

  9814.  i11 = i9 + 8 | 0;
    9815. 

  9815.  i10 = HEAP32[i11 >> 2] | 0;
    9816. 

  9816.  do {
    9817. 

  9817.   if ((i13 + 1 | 0) >>> 0 > i10 >>> 0) {
    9818. 

  9818.    if (i10 >>> 0 > 2147483645) {
    9819. 

  9819.     _lexerror(i2, 12368, 0);
    9820. 

  9820.    }
    9821. 

  9821.    i18 = i10 << 1;
    9822. 

  9822.    i13 = HEAP32[i2 + 52 >> 2] | 0;
    9823. 

  9823.    if ((i18 | 0) == -2) {
    9824. 

  9824.     _luaM_toobig(i13);
    9825. 

  9825.    } else {
    9826. 

  9826.     i16 = _luaM_realloc_(i13, HEAP32[i9 >> 2] | 0, i10, i18) | 0;
    9827. 

  9827.     HEAP32[i9 >> 2] = i16;
    9828. 

  9828.     HEAP32[i11 >> 2] = i18;
    9829. 

  9829.     i17 = HEAP32[i12 >> 2] | 0;
    9830. 

  9830.     break;
    9831. 

  9831.    }
    9832. 

  9832.   } else {
    9833. 

  9833.    i17 = i13;
    9834. 

  9834.    i16 = HEAP32[i9 >> 2] | 0;
    9835. 

  9835.   }
    9836. 

  9836.  } while (0);
    9837. 

  9837.  HEAP32[i12 >> 2] = i17 + 1;
    9838. 

  9838.  HEAP8[i16 + i17 | 0] = i20;
    9839. 

  9839.  i9 = HEAP32[i5 >> 2] | 0;
    9840. 

  9840.  i27 = HEAP32[i9 >> 2] | 0;
    9841. 

  9841.  HEAP32[i9 >> 2] = i27 + -1;
    9842. 

  9842.  if ((i27 | 0) == 0) {
    9843. 

  9843.   i9 = _luaZ_fill(i9) | 0;
    9844. 

  9844.  } else {
    9845. 

  9845.   i27 = i9 + 4 | 0;
    9846. 

  9846.   i9 = HEAP32[i27 >> 2] | 0;
    9847. 

  9847.   HEAP32[i27 >> 2] = i9 + 1;
    9848. 

  9848.   i9 = HEAPU8[i9] | 0;
    9849. 

  9849.  }
    9850. 

  9850.  HEAP32[i2 >> 2] = i9;
    9851. 

  9851.  if ((i20 | 0) == 48) {
    9852. 

  9852.   if ((i9 | 0) != 0) {
    9853. 

  9853.    if ((_memchr(12320, i9, 3) | 0) == 0) {
    9854. 

  9854.     i15 = i9;
    9855. 

  9855.     i9 = 12312;
    9856. 

  9856.    } else {
    9857. 

  9857.     i10 = HEAP32[i4 >> 2] | 0;
    9858. 

  9858.     i13 = i10 + 4 | 0;
    9859. 

  9859.     i16 = HEAP32[i13 >> 2] | 0;
    9860. 

  9860.     i11 = i10 + 8 | 0;
    9861. 

  9861.     i12 = HEAP32[i11 >> 2] | 0;
    9862. 

  9862.     do {
    9863. 

  9863.      if ((i16 + 1 | 0) >>> 0 > i12 >>> 0) {
    9864. 

  9864.       if (i12 >>> 0 > 2147483645) {
    9865. 

  9865.        _lexerror(i2, 12368, 0);
    9866. 

  9866.       }
    9867. 

  9867.       i17 = i12 << 1;
    9868. 

  9868.       i16 = HEAP32[i2 + 52 >> 2] | 0;
    9869. 

  9869.       if ((i17 | 0) == -2) {
    9870. 

  9870.        _luaM_toobig(i16);
    9871. 

  9871.       } else {
    9872. 

  9872.        i15 = _luaM_realloc_(i16, HEAP32[i10 >> 2] | 0, i12, i17) | 0;
    9873. 

  9873.        HEAP32[i10 >> 2] = i15;
    9874. 

  9874.        HEAP32[i11 >> 2] = i17;
    9875. 

  9875.        i14 = HEAP32[i13 >> 2] | 0;
    9876. 

  9876.        break;
    9877. 

  9877.       }
    9878. 

  9878.      } else {
    9879. 

  9879.       i14 = i16;
    9880. 

  9880.       i15 = HEAP32[i10 >> 2] | 0;
    9881. 

  9881.      }
    9882. 

  9882.     } while (0);
    9883. 

  9883.     HEAP32[i13 >> 2] = i14 + 1;
    9884. 

  9884.     HEAP8[i15 + i14 | 0] = i9;
    9885. 

  9885.     i9 = HEAP32[i5 >> 2] | 0;
    9886. 

  9886.     i27 = HEAP32[i9 >> 2] | 0;
    9887. 

  9887.     HEAP32[i9 >> 2] = i27 + -1;
    9888. 

  9888.     if ((i27 | 0) == 0) {
    9889. 

  9889.      i15 = _luaZ_fill(i9) | 0;
    9890. 

  9890.     } else {
    9891. 

  9891.      i27 = i9 + 4 | 0;
    9892. 

  9892.      i15 = HEAP32[i27 >> 2] | 0;
    9893. 

  9893.      HEAP32[i27 >> 2] = i15 + 1;
    9894. 

  9894.      i15 = HEAPU8[i15] | 0;
    9895. 

  9895.     }
    9896. 

  9896.     HEAP32[i2 >> 2] = i15;
    9897. 

  9897.     i9 = 12328;
    9898. 

  9898.    }
    9899. 

  9899.   } else {
    9900. 

  9900.    i15 = 0;
    9901. 

  9901.    i9 = 12312;
    9902. 

  9902.   }
    9903. 

  9903.  } else {
    9904. 

  9904.   i15 = i9;
    9905. 

  9905.   i9 = 12312;
    9906. 

  9906.  }
    9907. 

  9907.  i10 = i2 + 52 | 0;
    9908. 

  9908.  while (1) {
    9909. 

  9909.   if ((i15 | 0) != 0) {
    9910. 

  9910.    if ((_memchr(i9, i15, 3) | 0) != 0) {
    9911. 

  9911.     i12 = HEAP32[i4 >> 2] | 0;
    9912. 

  9912.     i11 = i12 + 4 | 0;
    9913. 

  9913.     i16 = HEAP32[i11 >> 2] | 0;
    9914. 

  9914.     i14 = i12 + 8 | 0;
    9915. 

  9915.     i13 = HEAP32[i14 >> 2] | 0;
    9916. 

  9916.     if ((i16 + 1 | 0) >>> 0 > i13 >>> 0) {
    9917. 

  9917.      if (i13 >>> 0 > 2147483645) {
    9918. 

  9918.       i9 = 227;
    9919. 

  9919.       break;
    9920. 

  9920.      }
    9921. 

  9921.      i17 = i13 << 1;
    9922. 

  9922.      i16 = HEAP32[i10 >> 2] | 0;
    9923. 

  9923.      if ((i17 | 0) == -2) {
    9924. 

  9924.       i9 = 229;
    9925. 

  9925.       break;
    9926. 

  9926.      }
    9927. 

  9927.      i27 = _luaM_realloc_(i16, HEAP32[i12 >> 2] | 0, i13, i17) | 0;
    9928. 

  9928.      HEAP32[i12 >> 2] = i27;
    9929. 

  9929.      HEAP32[i14 >> 2] = i17;
    9930. 

  9930.      i16 = HEAP32[i11 >> 2] | 0;
    9931. 

  9931.      i12 = i27;
    9932. 

  9932.     } else {
    9933. 

  9933.      i12 = HEAP32[i12 >> 2] | 0;
    9934. 

  9934.     }
    9935. 

  9935.     HEAP32[i11 >> 2] = i16 + 1;
    9936. 

  9936.     HEAP8[i12 + i16 | 0] = i15;
    9937. 

  9937.     i11 = HEAP32[i5 >> 2] | 0;
    9938. 

  9938.     i27 = HEAP32[i11 >> 2] | 0;
    9939. 

  9939.     HEAP32[i11 >> 2] = i27 + -1;
    9940. 

  9940.     if ((i27 | 0) == 0) {
    9941. 

  9941.      i15 = _luaZ_fill(i11) | 0;
    9942. 

  9942.     } else {
    9943. 

  9943.      i27 = i11 + 4 | 0;
    9944. 

  9944.      i15 = HEAP32[i27 >> 2] | 0;
    9945. 

  9945.      HEAP32[i27 >> 2] = i15 + 1;
    9946. 

  9946.      i15 = HEAPU8[i15] | 0;
    9947. 

  9947.     }
    9948. 

  9948.     HEAP32[i2 >> 2] = i15;
    9949. 

  9949.     if ((i15 | 0) != 0) {
    9950. 

  9950.      if ((_memchr(12336, i15, 3) | 0) != 0) {
    9951. 

  9951.       i12 = HEAP32[i4 >> 2] | 0;
    9952. 

  9952.       i11 = i12 + 4 | 0;
    9953. 

  9953.       i16 = HEAP32[i11 >> 2] | 0;
    9954. 

  9954.       i14 = i12 + 8 | 0;
    9955. 

  9955.       i13 = HEAP32[i14 >> 2] | 0;
    9956. 

  9956.       if ((i16 + 1 | 0) >>> 0 > i13 >>> 0) {
    9957. 

  9957.        if (i13 >>> 0 > 2147483645) {
    9958. 

  9958.         i9 = 239;
    9959. 

  9959.         break;
    9960. 

  9960.        }
    9961. 

  9961.        i17 = i13 << 1;
    9962. 

  9962.        i16 = HEAP32[i10 >> 2] | 0;
    9963. 

  9963.        if ((i17 | 0) == -2) {
    9964. 

  9964.         i9 = 241;
    9965. 

  9965.         break;
    9966. 

  9966.        }
    9967. 

  9967.        i27 = _luaM_realloc_(i16, HEAP32[i12 >> 2] | 0, i13, i17) | 0;
    9968. 

  9968.        HEAP32[i12 >> 2] = i27;
    9969. 

  9969.        HEAP32[i14 >> 2] = i17;
    9970. 

  9970.        i16 = HEAP32[i11 >> 2] | 0;
    9971. 

  9971.        i12 = i27;
    9972. 

  9972.       } else {
    9973. 

  9973.        i12 = HEAP32[i12 >> 2] | 0;
    9974. 

  9974.       }
    9975. 

  9975.       HEAP32[i11 >> 2] = i16 + 1;
    9976. 

  9976.       HEAP8[i12 + i16 | 0] = i15;
    9977. 

  9977.       i11 = HEAP32[i5 >> 2] | 0;
    9978. 

  9978.       i27 = HEAP32[i11 >> 2] | 0;
    9979. 

  9979.       HEAP32[i11 >> 2] = i27 + -1;
    9980. 

  9980.       if ((i27 | 0) == 0) {
    9981. 

  9981.        i15 = _luaZ_fill(i11) | 0;
    9982. 

  9982.       } else {
    9983. 

  9983.        i27 = i11 + 4 | 0;
    9984. 

  9984.        i15 = HEAP32[i27 >> 2] | 0;
    9985. 

  9985.        HEAP32[i27 >> 2] = i15 + 1;
    9986. 

  9986.        i15 = HEAPU8[i15] | 0;
    9987. 

  9987.       }
    9988. 

  9988.       HEAP32[i2 >> 2] = i15;
    9989. 

  9989.      }
    9990. 

  9990.     } else {
    9991. 

  9991.      i15 = 0;
    9992. 

  9992.     }
    9993. 

  9993.    }
    9994. 

  9994.   } else {
    9995. 

  9995.    i15 = 0;
    9996. 

  9996.   }
    9997. 

  9997.   i12 = HEAP32[i4 >> 2] | 0;
    9998. 

  9998.   i11 = i12 + 4 | 0;
    9999. 

  9999.   i17 = HEAP32[i11 >> 2] | 0;
    10000. 

  10000.   i14 = i12 + 8 | 0;
    10001. 

  10001.   i13 = HEAP32[i14 >> 2] | 0;
    10002. 

  10002.   i16 = (i17 + 1 | 0) >>> 0 > i13 >>> 0;
    10003. 

  10003.   if (!((HEAP8[i15 + 10913 | 0] & 16) != 0 | (i15 | 0) == 46)) {
    10004. 

  10004.    i9 = 259;
    10005. 

  10005.    break;
    10006. 

  10006.   }
    10007. 

  10007.   if (i16) {
    10008. 

  10008.    if (i13 >>> 0 > 2147483645) {
    10009. 

  10009.     i9 = 251;
    10010. 

  10010.     break;
    10011. 

  10011.    }
    10012. 

  10012.    i17 = i13 << 1;
    10013. 

  10013.    i16 = HEAP32[i10 >> 2] | 0;
    10014. 

  10014.    if ((i17 | 0) == -2) {
    10015. 

  10015.     i9 = 253;
    10016. 

  10016.     break;
    10017. 

  10017.    }
    10018. 

  10018.    i27 = _luaM_realloc_(i16, HEAP32[i12 >> 2] | 0, i13, i17) | 0;
    10019. 

  10019.    HEAP32[i12 >> 2] = i27;
    10020. 

  10020.    HEAP32[i14 >> 2] = i17;
    10021. 

  10021.    i17 = HEAP32[i11 >> 2] | 0;
    10022. 

  10022.    i12 = i27;
    10023. 

  10023.   } else {
    10024. 

  10024.    i12 = HEAP32[i12 >> 2] | 0;
    10025. 

  10025.   }
    10026. 

  10026.   HEAP32[i11 >> 2] = i17 + 1;
    10027. 

  10027.   HEAP8[i12 + i17 | 0] = i15;
    10028. 

  10028.   i11 = HEAP32[i5 >> 2] | 0;
    10029. 

  10029.   i27 = HEAP32[i11 >> 2] | 0;
    10030. 

  10030.   HEAP32[i11 >> 2] = i27 + -1;
    10031. 

  10031.   if ((i27 | 0) == 0) {
    10032. 

  10032.    i15 = _luaZ_fill(i11) | 0;
    10033. 

  10033.   } else {
    10034. 

  10034.    i27 = i11 + 4 | 0;
    10035. 

  10035.    i15 = HEAP32[i27 >> 2] | 0;
    10036. 

  10036.    HEAP32[i27 >> 2] = i15 + 1;
    10037. 

  10037.    i15 = HEAPU8[i15] | 0;
    10038. 

  10038.   }
    10039. 

  10039.   HEAP32[i2 >> 2] = i15;
    10040. 

  10040.  }
    10041. 

  10041.  if ((i9 | 0) == 227) {
    10042. 

  10042.   _lexerror(i2, 12368, 0);
    10043. 

  10043.  } else if ((i9 | 0) == 229) {
    10044. 

  10044.   _luaM_toobig(i16);
    10045. 

  10045.  } else if ((i9 | 0) == 239) {
    10046. 

  10046.   _lexerror(i2, 12368, 0);
    10047. 

  10047.  } else if ((i9 | 0) == 241) {
    10048. 

  10048.   _luaM_toobig(i16);
    10049. 

  10049.  } else if ((i9 | 0) == 251) {
    10050. 

  10050.   _lexerror(i2, 12368, 0);
    10051. 

  10051.  } else if ((i9 | 0) == 253) {
    10052. 

  10052.   _luaM_toobig(i16);
    10053. 

  10053.  } else if ((i9 | 0) == 259) {
    10054. 

  10054.   do {
    10055. 

  10055.    if (i16) {
    10056. 

  10056.     if (i13 >>> 0 > 2147483645) {
    10057. 

  10057.      _lexerror(i2, 12368, 0);
    10058. 

  10058.     }
    10059. 

  10059.     i5 = i13 << 1;
    10060. 

  10060.     i9 = HEAP32[i10 >> 2] | 0;
    10061. 

  10061.     if ((i5 | 0) == -2) {
    10062. 

  10062.      _luaM_toobig(i9);
    10063. 

  10063.     } else {
    10064. 

  10064.      i7 = _luaM_realloc_(i9, HEAP32[i12 >> 2] | 0, i13, i5) | 0;
    10065. 

  10065.      HEAP32[i12 >> 2] = i7;
    10066. 

  10066.      HEAP32[i14 >> 2] = i5;
    10067. 

  10067.      i8 = HEAP32[i11 >> 2] | 0;
    10068. 

  10068.      break;
    10069. 

  10069.     }
    10070. 

  10070.    } else {
    10071. 

  10071.     i8 = i17;
    10072. 

  10072.     i7 = HEAP32[i12 >> 2] | 0;
    10073. 

  10073.    }
    10074. 

  10074.   } while (0);
    10075. 

  10075.   HEAP32[i11 >> 2] = i8 + 1;
    10076. 

  10076.   HEAP8[i7 + i8 | 0] = 0;
    10077. 

  10077.   i5 = i2 + 76 | 0;
    10078. 

  10078.   i7 = HEAP8[i5] | 0;
    10079. 

  10079.   i10 = HEAP32[i4 >> 2] | 0;
    10080. 

  10080.   i8 = HEAP32[i10 >> 2] | 0;
    10081. 

  10081.   i10 = HEAP32[i10 + 4 >> 2] | 0;
    10082. 

  10082.   if ((i10 | 0) == 0) {
    10083. 

  10083.    i7 = -1;
    10084. 

  10084.   } else {
    10085. 

  10085.    do {
    10086. 

  10086.     i10 = i10 + -1 | 0;
    10087. 

  10087.     i9 = i8 + i10 | 0;
    10088. 

  10088.     if ((HEAP8[i9] | 0) == 46) {
    10089. 

  10089.      HEAP8[i9] = i7;
    10090. 

  10090.     }
    10091. 

  10091.    } while ((i10 | 0) != 0);
    10092. 

  10092.    i7 = HEAP32[i4 >> 2] | 0;
    10093. 

  10093.    i8 = HEAP32[i7 >> 2] | 0;
    10094. 

  10094.    i7 = (HEAP32[i7 + 4 >> 2] | 0) + -1 | 0;
    10095. 

  10095.   }
    10096. 

  10096.   if ((_luaO_str2d(i8, i7, i3) | 0) != 0) {
    10097. 

  10097.    i27 = 287;
    10098. 

  10098.    STACKTOP = i1;
    10099. 

  10099.    return i27 | 0;
    10100. 

  10100.   }
    10101. 

  10101.   i9 = HEAP8[i5] | 0;
    10102. 

  10102.   i8 = HEAP8[HEAP32[(_localeconv() | 0) >> 2] | 0] | 0;
    10103. 

  10103.   HEAP8[i5] = i8;
    10104. 

  10104.   i10 = HEAP32[i4 >> 2] | 0;
    10105. 

  10105.   i7 = HEAP32[i10 >> 2] | 0;
    10106. 

  10106.   i10 = HEAP32[i10 + 4 >> 2] | 0;
    10107. 

  10107.   if ((i10 | 0) == 0) {
    10108. 

  10108.    i8 = -1;
    10109. 

  10109.   } else {
    10110. 

  10110.    do {
    10111. 

  10111.     i10 = i10 + -1 | 0;
    10112. 

  10112.     i11 = i7 + i10 | 0;
    10113. 

  10113.     if ((HEAP8[i11] | 0) == i9 << 24 >> 24) {
    10114. 

  10114.      HEAP8[i11] = i8;
    10115. 

  10115.     }
    10116. 

  10116.    } while ((i10 | 0) != 0);
    10117. 

  10117.    i8 = HEAP32[i4 >> 2] | 0;
    10118. 

  10118.    i7 = HEAP32[i8 >> 2] | 0;
    10119. 

  10119.    i8 = (HEAP32[i8 + 4 >> 2] | 0) + -1 | 0;
    10120. 

  10120.   }
    10121. 

  10121.   if ((_luaO_str2d(i7, i8, i3) | 0) != 0) {
    10122. 

  10122.    i27 = 287;
    10123. 

  10123.    STACKTOP = i1;
    10124. 

  10124.    return i27 | 0;
    10125. 

  10125.   }
    10126. 

  10126.   i1 = HEAP8[i5] | 0;
    10127. 

  10127.   i4 = HEAP32[i4 >> 2] | 0;
    10128. 

  10128.   i3 = HEAP32[i4 >> 2] | 0;
    10129. 

  10129.   i4 = HEAP32[i4 + 4 >> 2] | 0;
    10130. 

  10130.   if ((i4 | 0) == 0) {
    10131. 

  10131.    _lexerror(i2, 12344, 287);
    10132. 

  10132.   } else {
    10133. 

  10133.    i6 = i4;
    10134. 

  10134.   }
    10135. 

  10135.   do {
    10136. 

  10136.    i6 = i6 + -1 | 0;
    10137. 

  10137.    i4 = i3 + i6 | 0;
    10138. 

  10138.    if ((HEAP8[i4] | 0) == i1 << 24 >> 24) {
    10139. 

  10139.     HEAP8[i4] = 46;
    10140. 

  10140.    }
    10141. 

  10141.   } while ((i6 | 0) != 0);
    10142. 

  10142.   _lexerror(i2, 12344, 287);
    10143. 

  10143.  }
    10144. 

  10144.  return 0;
    10145. 

  10145. }
    10146. 

  10146. function _luaV_execute(i1) {
    10147. 

  10147.  i1 = i1 | 0;
    10148. 

  10148.  var i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0, i14 = 0, i15 = 0, i16 = 0, i17 = 0, i18 = 0, i19 = 0, i20 = 0, i21 = 0, i22 = 0, i23 = 0, i24 = 0, i25 = 0, i26 = 0, i27 = 0, i28 = 0, i29 = 0, i30 = 0, i31 = 0, i32 = 0, i33 = 0, i34 = 0, i35 = 0, i36 = 0, d37 = 0.0, d38 = 0.0, d39 = 0.0;
    10149. 

  10149.  i12 = STACKTOP;
    10150. 

  10150.  STACKTOP = STACKTOP + 32 | 0;
    10151. 

  10151.  i13 = i12 + 24 | 0;
    10152. 

  10152.  i10 = i12 + 16 | 0;
    10153. 

  10153.  i9 = i12 + 8 | 0;
    10154. 

  10154.  i8 = i12;
    10155. 

  10155.  i3 = i1 + 16 | 0;
    10156. 

  10156.  i4 = i1 + 40 | 0;
    10157. 

  10157.  i6 = i1 + 12 | 0;
    10158. 

  10158.  i5 = i1 + 8 | 0;
    10159. 

  10159.  i11 = i1 + 24 | 0;
    10160. 

  10160.  i17 = i1 + 48 | 0;
    10161. 

  10161.  i2 = i1 + 20 | 0;
    10162. 

  10162.  i16 = i1 + 6 | 0;
    10163. 

  10163.  i7 = i1 + 44 | 0;
    10164. 

  10164.  i19 = HEAP32[i3 >> 2] | 0;
    10165. 

  10165.  L1 : while (1) {
    10166. 

  10166.   i22 = HEAP32[HEAP32[i19 >> 2] >> 2] | 0;
    10167. 

  10167.   i18 = i22 + 12 | 0;
    10168. 

  10168.   i23 = HEAP32[(HEAP32[i18 >> 2] | 0) + 8 >> 2] | 0;
    10169. 

  10169.   i20 = i19 + 24 | 0;
    10170. 

  10170.   i21 = i19 + 28 | 0;
    10171. 

  10171.   i22 = i22 + 16 | 0;
    10172. 

  10172.   i24 = i19 + 4 | 0;
    10173. 

  10173.   i25 = HEAP32[i20 >> 2] | 0;
    10174. 

  10174.   L3 : while (1) {
    10175. 

  10175.    i28 = HEAP32[i21 >> 2] | 0;
    10176. 

  10176.    HEAP32[i21 >> 2] = i28 + 4;
    10177. 

  10177.    i28 = HEAP32[i28 >> 2] | 0;
    10178. 

  10178.    i27 = HEAP8[i4] | 0;
    10179. 

  10179.    do {
    10180. 

  10180.     if (!((i27 & 12) == 0)) {
    10181. 

  10181.      i26 = (HEAP32[i17 >> 2] | 0) + -1 | 0;
    10182. 

  10182.      HEAP32[i17 >> 2] = i26;
    10183. 

  10183.      i26 = (i26 | 0) == 0;
    10184. 

  10184.      if (!i26 ? (i27 & 4) == 0 : 0) {
    10185. 

  10185.       break;
    10186. 

  10186.      }
    10187. 

  10187.      i25 = HEAP32[i3 >> 2] | 0;
    10188. 

  10188.      i29 = i27 & 255;
    10189. 

  10189.      if ((i29 & 8 | 0) == 0 | i26 ^ 1) {
    10190. 

  10190.       i27 = 0;
    10191. 

  10191.      } else {
    10192. 

  10192.       HEAP32[i17 >> 2] = HEAP32[i7 >> 2];
    10193. 

  10193.       i27 = 1;
    10194. 

  10194.      }
    10195. 

  10195.      i26 = i25 + 18 | 0;
    10196. 

  10196.      i30 = HEAPU8[i26] | 0;
    10197. 

  10197.      if ((i30 & 128 | 0) == 0) {
    10198. 

  10198.       if (i27) {
    10199. 

  10199.        _luaD_hook(i1, 3, -1);
    10200. 

  10200.       }
    10201. 

  10201.       do {
    10202. 

  10202.        if ((i29 & 4 | 0) == 0) {
    10203. 

  10203.         i29 = i25 + 28 | 0;
    10204. 

  10204.        } else {
    10205. 

  10205.         i34 = HEAP32[(HEAP32[HEAP32[i25 >> 2] >> 2] | 0) + 12 >> 2] | 0;
    10206. 

  10206.         i29 = i25 + 28 | 0;
    10207. 

  10207.         i32 = HEAP32[i29 >> 2] | 0;
    10208. 

  10208.         i35 = HEAP32[i34 + 12 >> 2] | 0;
    10209. 

  10209.         i33 = (i32 - i35 >> 2) + -1 | 0;
    10210. 

  10210.         i34 = HEAP32[i34 + 20 >> 2] | 0;
    10211. 

  10211.         i31 = (i34 | 0) == 0;
    10212. 

  10212.         if (i31) {
    10213. 

  10213.          i30 = 0;
    10214. 

  10214.         } else {
    10215. 

  10215.          i30 = HEAP32[i34 + (i33 << 2) >> 2] | 0;
    10216. 

  10216.         }
    10217. 

  10217.         if ((i33 | 0) != 0 ? (i14 = HEAP32[i2 >> 2] | 0, i32 >>> 0 > i14 >>> 0) : 0) {
    10218. 

  10218.          if (i31) {
    10219. 

  10219.           i31 = 0;
    10220. 

  10220.          } else {
    10221. 

  10221.           i31 = HEAP32[i34 + ((i14 - i35 >> 2) + -1 << 2) >> 2] | 0;
    10222. 

  10222.          }
    10223. 

  10223.          if ((i30 | 0) == (i31 | 0)) {
    10224. 

  10224.           break;
    10225. 

  10225.          }
    10226. 

  10226.         }
    10227. 

  10227.         _luaD_hook(i1, 2, i30);
    10228. 

  10228.        }
    10229. 

  10229.       } while (0);
    10230. 

  10230.       HEAP32[i2 >> 2] = HEAP32[i29 >> 2];
    10231. 

  10231.       if ((HEAP8[i16] | 0) == 1) {
    10232. 

  10232.        i15 = 23;
    10233. 

  10233.        break L1;
    10234. 

  10234.       }
    10235. 

  10235.      } else {
    10236. 

  10236.       HEAP8[i26] = i30 & 127;
    10237. 

  10237.      }
    10238. 

  10238.      i25 = HEAP32[i20 >> 2] | 0;
    10239. 

  10239.     }
    10240. 

  10240.    } while (0);
    10241. 

  10241.    i26 = i28 >>> 6 & 255;
    10242. 

  10242.    i27 = i25 + (i26 << 4) | 0;
    10243. 

  10243.    switch (i28 & 63 | 0) {
    10244. 

  10244.    case 9:
    10245. 

  10245.     {
    10246. 

  10246.      i28 = HEAP32[i22 + (i28 >>> 23 << 2) >> 2] | 0;
    10247. 

  10247.      i35 = HEAP32[i28 + 8 >> 2] | 0;
    10248. 

  10248.      i33 = i27;
    10249. 

  10249.      i34 = HEAP32[i33 + 4 >> 2] | 0;
    10250. 

  10250.      i36 = i35;
    10251. 

  10251.      HEAP32[i36 >> 2] = HEAP32[i33 >> 2];
    10252. 

  10252.      HEAP32[i36 + 4 >> 2] = i34;
    10253. 

  10253.      i36 = i25 + (i26 << 4) + 8 | 0;
    10254. 

  10254.      HEAP32[i35 + 8 >> 2] = HEAP32[i36 >> 2];
    10255. 

  10255.      if ((HEAP32[i36 >> 2] & 64 | 0) == 0) {
    10256. 

  10256.       continue L3;
    10257. 

  10257.      }
    10258. 

  10258.      i26 = HEAP32[i27 >> 2] | 0;
    10259. 

  10259.      if ((HEAP8[i26 + 5 | 0] & 3) == 0) {
    10260. 

  10260.       continue L3;
    10261. 

  10261.      }
    10262. 

  10262.      if ((HEAP8[i28 + 5 | 0] & 4) == 0) {
    10263. 

  10263.       continue L3;
    10264. 

  10264.      }
    10265. 

  10265.      _luaC_barrier_(i1, i28, i26);
    10266. 

  10266.      continue L3;
    10267. 

  10267.     }
    10268. 

  10268.    case 10:
    10269. 

  10269.     {
    10270. 

  10270.      i26 = i28 >>> 23;
    10271. 

  10271.      if ((i26 & 256 | 0) == 0) {
    10272. 

  10272.       i26 = i25 + (i26 << 4) | 0;
    10273. 

  10273.      } else {
    10274. 

  10274.       i26 = i23 + ((i26 & 255) << 4) | 0;
    10275. 

  10275.      }
    10276. 

  10276.      i28 = i28 >>> 14;
    10277. 

  10277.      if ((i28 & 256 | 0) == 0) {
    10278. 

  10278.       i25 = i25 + ((i28 & 511) << 4) | 0;
    10279. 

  10279.      } else {
    10280. 

  10280.       i25 = i23 + ((i28 & 255) << 4) | 0;
    10281. 

  10281.      }
    10282. 

  10282.      _luaV_settable(i1, i27, i26, i25);
    10283. 

  10283.      i25 = HEAP32[i20 >> 2] | 0;
    10284. 

  10284.      continue L3;
    10285. 

  10285.     }
    10286. 

  10286.    case 17:
    10287. 

  10287.     {
    10288. 

  10288.      i29 = i28 >>> 23;
    10289. 

  10289.      if ((i29 & 256 | 0) == 0) {
    10290. 

  10290.       i29 = i25 + (i29 << 4) | 0;
    10291. 

  10291.      } else {
    10292. 

  10292.       i29 = i23 + ((i29 & 255) << 4) | 0;
    10293. 

  10293.      }
    10294. 

  10294.      i28 = i28 >>> 14;
    10295. 

  10295.      if ((i28 & 256 | 0) == 0) {
    10296. 

  10296.       i28 = i25 + ((i28 & 511) << 4) | 0;
    10297. 

  10297.      } else {
    10298. 

  10298.       i28 = i23 + ((i28 & 255) << 4) | 0;
    10299. 

  10299.      }
    10300. 

  10300.      if ((HEAP32[i29 + 8 >> 2] | 0) == 3 ? (HEAP32[i28 + 8 >> 2] | 0) == 3 : 0) {
    10301. 

  10301.       d37 = +HEAPF64[i29 >> 3];
    10302. 

  10302.       d38 = +HEAPF64[i28 >> 3];
    10303. 

  10303.       HEAPF64[i27 >> 3] = d37 - d38 * +Math_floor(+(d37 / d38));
    10304. 

  10304.       HEAP32[i25 + (i26 << 4) + 8 >> 2] = 3;
    10305. 

  10305.       continue L3;
    10306. 

  10306.      }
    10307. 

  10307.      _luaV_arith(i1, i27, i29, i28, 10);
    10308. 

  10308.      i25 = HEAP32[i20 >> 2] | 0;
    10309. 

  10309.      continue L3;
    10310. 

  10310.     }
    10311. 

  10311.    case 23:
    10312. 

  10312.     {
    10313. 

  10313.      if ((i26 | 0) != 0) {
    10314. 

  10314.       _luaF_close(i1, (HEAP32[i20 >> 2] | 0) + (i26 + -1 << 4) | 0);
    10315. 

  10315.      }
    10316. 

  10316.      HEAP32[i21 >> 2] = (HEAP32[i21 >> 2] | 0) + ((i28 >>> 14) + -131071 << 2);
    10317. 

  10317.      continue L3;
    10318. 

  10318.     }
    10319. 

  10319.    case 24:
    10320. 

  10320.     {
    10321. 

  10321.      i27 = i28 >>> 23;
    10322. 

  10322.      if ((i27 & 256 | 0) == 0) {
    10323. 

  10323.       i27 = i25 + (i27 << 4) | 0;
    10324. 

  10324.      } else {
    10325. 

  10325.       i27 = i23 + ((i27 & 255) << 4) | 0;
    10326. 

  10326.      }
    10327. 

  10327.      i28 = i28 >>> 14;
    10328. 

  10328.      if ((i28 & 256 | 0) == 0) {
    10329. 

  10329.       i25 = i25 + ((i28 & 511) << 4) | 0;
    10330. 

  10330.      } else {
    10331. 

  10331.       i25 = i23 + ((i28 & 255) << 4) | 0;
    10332. 

  10332.      }
    10333. 

  10333.      if ((HEAP32[i27 + 8 >> 2] | 0) == (HEAP32[i25 + 8 >> 2] | 0)) {
    10334. 

  10334.       i27 = (_luaV_equalobj_(i1, i27, i25) | 0) != 0;
    10335. 

  10335.      } else {
    10336. 

  10336.       i27 = 0;
    10337. 

  10337.      }
    10338. 

  10338.      i25 = HEAP32[i21 >> 2] | 0;
    10339. 

  10339.      if ((i27 & 1 | 0) == (i26 | 0)) {
    10340. 

  10340.       i26 = HEAP32[i25 >> 2] | 0;
    10341. 

  10341.       i27 = i26 >>> 6 & 255;
    10342. 

  10342.       if ((i27 | 0) != 0) {
    10343. 

  10343.        _luaF_close(i1, (HEAP32[i20 >> 2] | 0) + (i27 + -1 << 4) | 0);
    10344. 

  10344.        i25 = HEAP32[i21 >> 2] | 0;
    10345. 

  10345.       }
    10346. 

  10346.       i25 = i25 + ((i26 >>> 14) + -131070 << 2) | 0;
    10347. 

  10347.      } else {
    10348. 

  10348.       i25 = i25 + 4 | 0;
    10349. 

  10349.      }
    10350. 

  10350.      HEAP32[i21 >> 2] = i25;
    10351. 

  10351.      i25 = HEAP32[i20 >> 2] | 0;
    10352. 

  10352.      continue L3;
    10353. 

  10353.     }
    10354. 

  10354.    case 18:
    10355. 

  10355.     {
    10356. 

  10356.      i29 = i28 >>> 23;
    10357. 

  10357.      if ((i29 & 256 | 0) == 0) {
    10358. 

  10358.       i29 = i25 + (i29 << 4) | 0;
    10359. 

  10359.      } else {
    10360. 

  10360.       i29 = i23 + ((i29 & 255) << 4) | 0;
    10361. 

  10361.      }
    10362. 

  10362.      i28 = i28 >>> 14;
    10363. 

  10363.      if ((i28 & 256 | 0) == 0) {
    10364. 

  10364.       i28 = i25 + ((i28 & 511) << 4) | 0;
    10365. 

  10365.      } else {
    10366. 

  10366.       i28 = i23 + ((i28 & 255) << 4) | 0;
    10367. 

  10367.      }
    10368. 

  10368.      if ((HEAP32[i29 + 8 >> 2] | 0) == 3 ? (HEAP32[i28 + 8 >> 2] | 0) == 3 : 0) {
    10369. 

  10369.       HEAPF64[i27 >> 3] = +Math_pow(+(+HEAPF64[i29 >> 3]), +(+HEAPF64[i28 >> 3]));
    10370. 

  10370.       HEAP32[i25 + (i26 << 4) + 8 >> 2] = 3;
    10371. 

  10371.       continue L3;
    10372. 

  10372.      }
    10373. 

  10373.      _luaV_arith(i1, i27, i29, i28, 11);
    10374. 

  10374.      i25 = HEAP32[i20 >> 2] | 0;
    10375. 

  10375.      continue L3;
    10376. 

  10376.     }
    10377. 

  10377.    case 1:
    10378. 

  10378.     {
    10379. 

  10379.      i36 = i28 >>> 14;
    10380. 

  10380.      i33 = i23 + (i36 << 4) | 0;
    10381. 

  10381.      i34 = HEAP32[i33 + 4 >> 2] | 0;
    10382. 

  10382.      i35 = i27;
    10383. 

  10383.      HEAP32[i35 >> 2] = HEAP32[i33 >> 2];
    10384. 

  10384.      HEAP32[i35 + 4 >> 2] = i34;
    10385. 

  10385.      HEAP32[i25 + (i26 << 4) + 8 >> 2] = HEAP32[i23 + (i36 << 4) + 8 >> 2];
    10386. 

  10386.      continue L3;
    10387. 

  10387.     }
    10388. 

  10388.    case 0:
    10389. 

  10389.     {
    10390. 

  10390.      i36 = i28 >>> 23;
    10391. 

  10391.      i33 = i25 + (i36 << 4) | 0;
    10392. 

  10392.      i34 = HEAP32[i33 + 4 >> 2] | 0;
    10393. 

  10393.      i35 = i27;
    10394. 

  10394.      HEAP32[i35 >> 2] = HEAP32[i33 >> 2];
    10395. 

  10395.      HEAP32[i35 + 4 >> 2] = i34;
    10396. 

  10396.      HEAP32[i25 + (i26 << 4) + 8 >> 2] = HEAP32[i25 + (i36 << 4) + 8 >> 2];
    10397. 

  10397.      continue L3;
    10398. 

  10398.     }
    10399. 

  10399.    case 2:
    10400. 

  10400.     {
    10401. 

  10401.      i36 = HEAP32[i21 >> 2] | 0;
    10402. 

  10402.      HEAP32[i21 >> 2] = i36 + 4;
    10403. 

  10403.      i36 = (HEAP32[i36 >> 2] | 0) >>> 6;
    10404. 

  10404.      i33 = i23 + (i36 << 4) | 0;
    10405. 

  10405.      i34 = HEAP32[i33 + 4 >> 2] | 0;
    10406. 

  10406.      i35 = i27;
    10407. 

  10407.      HEAP32[i35 >> 2] = HEAP32[i33 >> 2];
    10408. 

  10408.      HEAP32[i35 + 4 >> 2] = i34;
    10409. 

  10409.      HEAP32[i25 + (i26 << 4) + 8 >> 2] = HEAP32[i23 + (i36 << 4) + 8 >> 2];
    10410. 

  10410.      continue L3;
    10411. 

  10411.     }
    10412. 

  10412.    case 5:
    10413. 

  10413.     {
    10414. 

  10414.      i36 = HEAP32[(HEAP32[i22 + (i28 >>> 23 << 2) >> 2] | 0) + 8 >> 2] | 0;
    10415. 

  10415.      i33 = i36;
    10416. 

  10416.      i34 = HEAP32[i33 + 4 >> 2] | 0;
    10417. 

  10417.      i35 = i27;
    10418. 

  10418.      HEAP32[i35 >> 2] = HEAP32[i33 >> 2];
    10419. 

  10419.      HEAP32[i35 + 4 >> 2] = i34;
    10420. 

  10420.      HEAP32[i25 + (i26 << 4) + 8 >> 2] = HEAP32[i36 + 8 >> 2];
    10421. 

  10421.      continue L3;
    10422. 

  10422.     }
    10423. 

  10423.    case 3:
    10424. 

  10424.     {
    10425. 

  10425.      HEAP32[i27 >> 2] = i28 >>> 23;
    10426. 

  10426.      HEAP32[i25 + (i26 << 4) + 8 >> 2] = 1;
    10427. 

  10427.      if ((i28 & 8372224 | 0) == 0) {
    10428. 

  10428.       continue L3;
    10429. 

  10429.      }
    10430. 

  10430.      HEAP32[i21 >> 2] = (HEAP32[i21 >> 2] | 0) + 4;
    10431. 

  10431.      continue L3;
    10432. 

  10432.     }
    10433. 

  10433.    case 7:
    10434. 

  10434.     {
    10435. 

  10435.      i26 = i28 >>> 14;
    10436. 

  10436.      if ((i26 & 256 | 0) == 0) {
    10437. 

  10437.       i26 = i25 + ((i26 & 511) << 4) | 0;
    10438. 

  10438.      } else {
    10439. 

  10439.       i26 = i23 + ((i26 & 255) << 4) | 0;
    10440. 

  10440.      }
    10441. 

  10441.      _luaV_gettable(i1, i25 + (i28 >>> 23 << 4) | 0, i26, i27);
    10442. 

  10442.      i25 = HEAP32[i20 >> 2] | 0;
    10443. 

  10443.      continue L3;
    10444. 

  10444.     }
    10445. 

  10445.    case 12:
    10446. 

  10446.     {
    10447. 

  10447.      i36 = i28 >>> 23;
    10448. 

  10448.      i29 = i25 + (i36 << 4) | 0;
    10449. 

  10449.      i26 = i26 + 1 | 0;
    10450. 

  10450.      i33 = i29;
    10451. 

  10451.      i34 = HEAP32[i33 + 4 >> 2] | 0;
    10452. 

  10452.      i35 = i25 + (i26 << 4) | 0;
    10453. 

  10453.      HEAP32[i35 >> 2] = HEAP32[i33 >> 2];
    10454. 

  10454.      HEAP32[i35 + 4 >> 2] = i34;
    10455. 

  10455.      HEAP32[i25 + (i26 << 4) + 8 >> 2] = HEAP32[i25 + (i36 << 4) + 8 >> 2];
    10456. 

  10456.      i26 = i28 >>> 14;
    10457. 

  10457.      if ((i26 & 256 | 0) == 0) {
    10458. 

  10458.       i25 = i25 + ((i26 & 511) << 4) | 0;
    10459. 

  10459.      } else {
    10460. 

  10460.       i25 = i23 + ((i26 & 255) << 4) | 0;
    10461. 

  10461.      }
    10462. 

  10462.      _luaV_gettable(i1, i29, i25, i27);
    10463. 

  10463.      i25 = HEAP32[i20 >> 2] | 0;
    10464. 

  10464.      continue L3;
    10465. 

  10465.     }
    10466. 

  10466.    case 13:
    10467. 

  10467.     {
    10468. 

  10468.      i29 = i28 >>> 23;
    10469. 

  10469.      if ((i29 & 256 | 0) == 0) {
    10470. 

  10470.       i29 = i25 + (i29 << 4) | 0;
    10471. 

  10471.      } else {
    10472. 

  10472.       i29 = i23 + ((i29 & 255) << 4) | 0;
    10473. 

  10473.      }
    10474. 

  10474.      i28 = i28 >>> 14;
    10475. 

  10475.      if ((i28 & 256 | 0) == 0) {
    10476. 

  10476.       i28 = i25 + ((i28 & 511) << 4) | 0;
    10477. 

  10477.      } else {
    10478. 

  10478.       i28 = i23 + ((i28 & 255) << 4) | 0;
    10479. 

  10479.      }
    10480. 

  10480.      if ((HEAP32[i29 + 8 >> 2] | 0) == 3 ? (HEAP32[i28 + 8 >> 2] | 0) == 3 : 0) {
    10481. 

  10481.       HEAPF64[i27 >> 3] = +HEAPF64[i29 >> 3] + +HEAPF64[i28 >> 3];
    10482. 

  10482.       HEAP32[i25 + (i26 << 4) + 8 >> 2] = 3;
    10483. 

  10483.       continue L3;
    10484. 

  10484.      }
    10485. 

  10485.      _luaV_arith(i1, i27, i29, i28, 6);
    10486. 

  10486.      i25 = HEAP32[i20 >> 2] | 0;
    10487. 

  10487.      continue L3;
    10488. 

  10488.     }
    10489. 

  10489.    case 14:
    10490. 

  10490.     {
    10491. 

  10491.      i29 = i28 >>> 23;
    10492. 

  10492.      if ((i29 & 256 | 0) == 0) {
    10493. 

  10493.       i29 = i25 + (i29 << 4) | 0;
    10494. 

  10494.      } else {
    10495. 

  10495.       i29 = i23 + ((i29 & 255) << 4) | 0;
    10496. 

  10496.      }
    10497. 

  10497.      i28 = i28 >>> 14;
    10498. 

  10498.      if ((i28 & 256 | 0) == 0) {
    10499. 

  10499.       i28 = i25 + ((i28 & 511) << 4) | 0;
    10500. 

  10500.      } else {
    10501. 

  10501.       i28 = i23 + ((i28 & 255) << 4) | 0;
    10502. 

  10502.      }
    10503. 

  10503.      if ((HEAP32[i29 + 8 >> 2] | 0) == 3 ? (HEAP32[i28 + 8 >> 2] | 0) == 3 : 0) {
    10504. 

  10504.       HEAPF64[i27 >> 3] = +HEAPF64[i29 >> 3] - +HEAPF64[i28 >> 3];
    10505. 

  10505.       HEAP32[i25 + (i26 << 4) + 8 >> 2] = 3;
    10506. 

  10506.       continue L3;
    10507. 

  10507.      }
    10508. 

  10508.      _luaV_arith(i1, i27, i29, i28, 7);
    10509. 

  10509.      i25 = HEAP32[i20 >> 2] | 0;
    10510. 

  10510.      continue L3;
    10511. 

  10511.     }
    10512. 

  10512.    case 6:
    10513. 

  10513.     {
    10514. 

  10514.      i26 = i28 >>> 14;
    10515. 

  10515.      if ((i26 & 256 | 0) == 0) {
    10516. 

  10516.       i25 = i25 + ((i26 & 511) << 4) | 0;
    10517. 

  10517.      } else {
    10518. 

  10518.       i25 = i23 + ((i26 & 255) << 4) | 0;
    10519. 

  10519.      }
    10520. 

  10520.      _luaV_gettable(i1, HEAP32[(HEAP32[i22 + (i28 >>> 23 << 2) >> 2] | 0) + 8 >> 2] | 0, i25, i27);
    10521. 

  10521.      i25 = HEAP32[i20 >> 2] | 0;
    10522. 

  10522.      continue L3;
    10523. 

  10523.     }
    10524. 

  10524.    case 4:
    10525. 

  10525.     {
    10526. 

  10526.      i26 = i28 >>> 23;
    10527. 

  10527.      while (1) {
    10528. 

  10528.       HEAP32[i27 + 8 >> 2] = 0;
    10529. 

  10529.       if ((i26 | 0) == 0) {
    10530. 

  10530.        continue L3;
    10531. 

  10531.       } else {
    10532. 

  10532.        i26 = i26 + -1 | 0;
    10533. 

  10533.        i27 = i27 + 16 | 0;
    10534. 

  10534.       }
    10535. 

  10535.      }
    10536. 

  10536.     }
    10537. 

  10537.    case 8:
    10538. 

  10538.     {
    10539. 

  10539.      i27 = i28 >>> 23;
    10540. 

  10540.      if ((i27 & 256 | 0) == 0) {
    10541. 

  10541.       i27 = i25 + (i27 << 4) | 0;
    10542. 

  10542.      } else {
    10543. 

  10543.       i27 = i23 + ((i27 & 255) << 4) | 0;
    10544. 

  10544.      }
    10545. 

  10545.      i28 = i28 >>> 14;
    10546. 

  10546.      if ((i28 & 256 | 0) == 0) {
    10547. 

  10547.       i25 = i25 + ((i28 & 511) << 4) | 0;
    10548. 

  10548.      } else {
    10549. 

  10549.       i25 = i23 + ((i28 & 255) << 4) | 0;
    10550. 

  10550.      }
    10551. 

  10551.      _luaV_settable(i1, HEAP32[(HEAP32[i22 + (i26 << 2) >> 2] | 0) + 8 >> 2] | 0, i27, i25);
    10552. 

  10552.      i25 = HEAP32[i20 >> 2] | 0;
    10553. 

  10553.      continue L3;
    10554. 

  10554.     }
    10555. 

  10555.    case 11:
    10556. 

  10556.     {
    10557. 

  10557.      i29 = i28 >>> 23;
    10558. 

  10558.      i28 = i28 >>> 14 & 511;
    10559. 

  10559.      i30 = _luaH_new(i1) | 0;
    10560. 

  10560.      HEAP32[i27 >> 2] = i30;
    10561. 

  10561.      HEAP32[i25 + (i26 << 4) + 8 >> 2] = 69;
    10562. 

  10562.      if ((i28 | i29 | 0) != 0) {
    10563. 

  10563.       i36 = _luaO_fb2int(i29) | 0;
    10564. 

  10564.       _luaH_resize(i1, i30, i36, _luaO_fb2int(i28) | 0);
    10565. 

  10565.      }
    10566. 

  10566.      if ((HEAP32[(HEAP32[i6 >> 2] | 0) + 12 >> 2] | 0) > 0) {
    10567. 

  10567.       HEAP32[i5 >> 2] = i25 + (i26 + 1 << 4);
    10568. 

  10568.       _luaC_step(i1);
    10569. 

  10569.       HEAP32[i5 >> 2] = HEAP32[i24 >> 2];
    10570. 

  10570.      }
    10571. 

  10571.      i25 = HEAP32[i20 >> 2] | 0;
    10572. 

  10572.      continue L3;
    10573. 

  10573.     }
    10574. 

  10574.    case 19:
    10575. 

  10575.     {
    10576. 

  10576.      i36 = i28 >>> 23;
    10577. 

  10577.      i28 = i25 + (i36 << 4) | 0;
    10578. 

  10578.      if ((HEAP32[i25 + (i36 << 4) + 8 >> 2] | 0) == 3) {
    10579. 

  10579.       HEAPF64[i27 >> 3] = -+HEAPF64[i28 >> 3];
    10580. 

  10580.       HEAP32[i25 + (i26 << 4) + 8 >> 2] = 3;
    10581. 

  10581.       continue L3;
    10582. 

  10582.      } else {
    10583. 

  10583.       _luaV_arith(i1, i27, i28, i28, 12);
    10584. 

  10584.       i25 = HEAP32[i20 >> 2] | 0;
    10585. 

  10585.       continue L3;
    10586. 

  10586.      }
    10587. 

  10587.     }
    10588. 

  10588.    case 15:
    10589. 

  10589.     {
    10590. 

  10590.      i29 = i28 >>> 23;
    10591. 

  10591.      if ((i29 & 256 | 0) == 0) {
    10592. 

  10592.       i29 = i25 + (i29 << 4) | 0;
    10593. 

  10593.      } else {
    10594. 

  10594.       i29 = i23 + ((i29 & 255) << 4) | 0;
    10595. 

  10595.      }
    10596. 

  10596.      i28 = i28 >>> 14;
    10597. 

  10597.      if ((i28 & 256 | 0) == 0) {
    10598. 

  10598.       i28 = i25 + ((i28 & 511) << 4) | 0;
    10599. 

  10599.      } else {
    10600. 

  10600.       i28 = i23 + ((i28 & 255) << 4) | 0;
    10601. 

  10601.      }
    10602. 

  10602.      if ((HEAP32[i29 + 8 >> 2] | 0) == 3 ? (HEAP32[i28 + 8 >> 2] | 0) == 3 : 0) {
    10603. 

  10603.       HEAPF64[i27 >> 3] = +HEAPF64[i29 >> 3] * +HEAPF64[i28 >> 3];
    10604. 

  10604.       HEAP32[i25 + (i26 << 4) + 8 >> 2] = 3;
    10605. 

  10605.       continue L3;
    10606. 

  10606.      }
    10607. 

  10607.      _luaV_arith(i1, i27, i29, i28, 8);
    10608. 

  10608.      i25 = HEAP32[i20 >> 2] | 0;
    10609. 

  10609.      continue L3;
    10610. 

  10610.     }
    10611. 

  10611.    case 16:
    10612. 

  10612.     {
    10613. 

  10613.      i29 = i28 >>> 23;
    10614. 

  10614.      if ((i29 & 256 | 0) == 0) {
    10615. 

  10615.       i29 = i25 + (i29 << 4) | 0;
    10616. 

  10616.      } else {
    10617. 

  10617.       i29 = i23 + ((i29 & 255) << 4) | 0;
    10618. 

  10618.      }
    10619. 

  10619.      i28 = i28 >>> 14;
    10620. 

  10620.      if ((i28 & 256 | 0) == 0) {
    10621. 

  10621.       i28 = i25 + ((i28 & 511) << 4) | 0;
    10622. 

  10622.      } else {
    10623. 

  10623.       i28 = i23 + ((i28 & 255) << 4) | 0;
    10624. 

  10624.      }
    10625. 

  10625.      if ((HEAP32[i29 + 8 >> 2] | 0) == 3 ? (HEAP32[i28 + 8 >> 2] | 0) == 3 : 0) {
    10626. 

  10626.       HEAPF64[i27 >> 3] = +HEAPF64[i29 >> 3] / +HEAPF64[i28 >> 3];
    10627. 

  10627.       HEAP32[i25 + (i26 << 4) + 8 >> 2] = 3;
    10628. 

  10628.       continue L3;
    10629. 

  10629.      }
    10630. 

  10630.      _luaV_arith(i1, i27, i29, i28, 9);
    10631. 

  10631.      i25 = HEAP32[i20 >> 2] | 0;
    10632. 

  10632.      continue L3;
    10633. 

  10633.     }
    10634. 

  10634.    case 20:
    10635. 

  10635.     {
    10636. 

  10636.      i29 = i28 >>> 23;
    10637. 

  10637.      i28 = HEAP32[i25 + (i29 << 4) + 8 >> 2] | 0;
    10638. 

  10638.      if ((i28 | 0) != 0) {
    10639. 

  10639.       if ((i28 | 0) == 1) {
    10640. 

  10640.        i28 = (HEAP32[i25 + (i29 << 4) >> 2] | 0) == 0;
    10641. 

  10641.       } else {
    10642. 

  10642.        i28 = 0;
    10643. 

  10643.       }
    10644. 

  10644.      } else {
    10645. 

  10645.       i28 = 1;
    10646. 

  10646.      }
    10647. 

  10647.      HEAP32[i27 >> 2] = i28 & 1;
    10648. 

  10648.      HEAP32[i25 + (i26 << 4) + 8 >> 2] = 1;
    10649. 

  10649.      continue L3;
    10650. 

  10650.     }
    10651. 

  10651.    case 21:
    10652. 

  10652.     {
    10653. 

  10653.      _luaV_objlen(i1, i27, i25 + (i28 >>> 23 << 4) | 0);
    10654. 

  10654.      i25 = HEAP32[i20 >> 2] | 0;
    10655. 

  10655.      continue L3;
    10656. 

  10656.     }
    10657. 

  10657.    case 22:
    10658. 

  10658.     {
    10659. 

  10659.      i27 = i28 >>> 23;
    10660. 

  10660.      i28 = i28 >>> 14 & 511;
    10661. 

  10661.      HEAP32[i5 >> 2] = i25 + (i28 + 1 << 4);
    10662. 

  10662.      _luaV_concat(i1, 1 - i27 + i28 | 0);
    10663. 

  10663.      i25 = HEAP32[i20 >> 2] | 0;
    10664. 

  10664.      i28 = i25 + (i27 << 4) | 0;
    10665. 

  10665.      i34 = i28;
    10666. 

  10666.      i35 = HEAP32[i34 + 4 >> 2] | 0;
    10667. 

  10667.      i36 = i25 + (i26 << 4) | 0;
    10668. 

  10668.      HEAP32[i36 >> 2] = HEAP32[i34 >> 2];
    10669. 

  10669.      HEAP32[i36 + 4 >> 2] = i35;
    10670. 

  10670.      HEAP32[i25 + (i26 << 4) + 8 >> 2] = HEAP32[i25 + (i27 << 4) + 8 >> 2];
    10671. 

  10671.      if ((HEAP32[(HEAP32[i6 >> 2] | 0) + 12 >> 2] | 0) > 0) {
    10672. 

  10672.       if (!(i26 >>> 0 < i27 >>> 0)) {
    10673. 

  10673.        i28 = i25 + (i26 + 1 << 4) | 0;
    10674. 

  10674.       }
    10675. 

  10675.       HEAP32[i5 >> 2] = i28;
    10676. 

  10676.       _luaC_step(i1);
    10677. 

  10677.       HEAP32[i5 >> 2] = HEAP32[i24 >> 2];
    10678. 

  10678.      }
    10679. 

  10679.      i25 = HEAP32[i20 >> 2] | 0;
    10680. 

  10680.      HEAP32[i5 >> 2] = HEAP32[i24 >> 2];
    10681. 

  10681.      continue L3;
    10682. 

  10682.     }
    10683. 

  10683.    case 25:
    10684. 

  10684.     {
    10685. 

  10685.      i27 = i28 >>> 23;
    10686. 

  10686.      if ((i27 & 256 | 0) == 0) {
    10687. 

  10687.       i27 = i25 + (i27 << 4) | 0;
    10688. 

  10688.      } else {
    10689. 

  10689.       i27 = i23 + ((i27 & 255) << 4) | 0;
    10690. 

  10690.      }
    10691. 

  10691.      i28 = i28 >>> 14;
    10692. 

  10692.      if ((i28 & 256 | 0) == 0) {
    10693. 

  10693.       i25 = i25 + ((i28 & 511) << 4) | 0;
    10694. 

  10694.      } else {
    10695. 

  10695.       i25 = i23 + ((i28 & 255) << 4) | 0;
    10696. 

  10696.      }
    10697. 

  10697.      i36 = (_luaV_lessthan(i1, i27, i25) | 0) == (i26 | 0);
    10698. 

  10698.      i26 = HEAP32[i21 >> 2] | 0;
    10699. 

  10699.      if (i36) {
    10700. 

  10700.       i25 = HEAP32[i26 >> 2] | 0;
    10701. 

  10701.       i27 = i25 >>> 6 & 255;
    10702. 

  10702.       if ((i27 | 0) != 0) {
    10703. 

  10703.        _luaF_close(i1, (HEAP32[i20 >> 2] | 0) + (i27 + -1 << 4) | 0);
    10704. 

  10704.        i26 = HEAP32[i21 >> 2] | 0;
    10705. 

  10705.       }
    10706. 

  10706.       i25 = i26 + ((i25 >>> 14) + -131070 << 2) | 0;
    10707. 

  10707.      } else {
    10708. 

  10708.       i25 = i26 + 4 | 0;
    10709. 

  10709.      }
    10710. 

  10710.      HEAP32[i21 >> 2] = i25;
    10711. 

  10711.      i25 = HEAP32[i20 >> 2] | 0;
    10712. 

  10712.      continue L3;
    10713. 

  10713.     }
    10714. 

  10714.    case 27:
    10715. 

  10715.     {
    10716. 

  10716.      i29 = HEAP32[i25 + (i26 << 4) + 8 >> 2] | 0;
    10717. 

  10717.      i26 = (i29 | 0) == 0;
    10718. 

  10718.      if ((i28 & 8372224 | 0) == 0) {
    10719. 

  10719.       if (!i26) {
    10720. 

  10720.        if (!((i29 | 0) == 1 ? (HEAP32[i27 >> 2] | 0) == 0 : 0)) {
    10721. 

  10721.         i15 = 192;
    10722. 

  10722.        }
    10723. 

  10723.       }
    10724. 

  10724.      } else {
    10725. 

  10725.       if (!i26) {
    10726. 

  10726.        if ((i29 | 0) == 1 ? (HEAP32[i27 >> 2] | 0) == 0 : 0) {
    10727. 

  10727.         i15 = 192;
    10728. 

  10728.        }
    10729. 

  10729.       } else {
    10730. 

  10730.        i15 = 192;
    10731. 

  10731.       }
    10732. 

  10732.      }
    10733. 

  10733.      if ((i15 | 0) == 192) {
    10734. 

  10734.       i15 = 0;
    10735. 

  10735.       HEAP32[i21 >> 2] = (HEAP32[i21 >> 2] | 0) + 4;
    10736. 

  10736.       continue L3;
    10737. 

  10737.      }
    10738. 

  10738.      i27 = HEAP32[i21 >> 2] | 0;
    10739. 

  10739.      i26 = HEAP32[i27 >> 2] | 0;
    10740. 

  10740.      i28 = i26 >>> 6 & 255;
    10741. 

  10741.      if ((i28 | 0) != 0) {
    10742. 

  10742.       _luaF_close(i1, (HEAP32[i20 >> 2] | 0) + (i28 + -1 << 4) | 0);
    10743. 

  10743.       i27 = HEAP32[i21 >> 2] | 0;
    10744. 

  10744.      }
    10745. 

  10745.      HEAP32[i21 >> 2] = i27 + ((i26 >>> 14) + -131070 << 2);
    10746. 

  10746.      continue L3;
    10747. 

  10747.     }
    10748. 

  10748.    case 26:
    10749. 

  10749.     {
    10750. 

  10750.      i27 = i28 >>> 23;
    10751. 

  10751.      if ((i27 & 256 | 0) == 0) {
    10752. 

  10752.       i27 = i25 + (i27 << 4) | 0;
    10753. 

  10753.      } else {
    10754. 

  10754.       i27 = i23 + ((i27 & 255) << 4) | 0;
    10755. 

  10755.      }
    10756. 

  10756.      i28 = i28 >>> 14;
    10757. 

  10757.      if ((i28 & 256 | 0) == 0) {
    10758. 

  10758.       i25 = i25 + ((i28 & 511) << 4) | 0;
    10759. 

  10759.      } else {
    10760. 

  10760.       i25 = i23 + ((i28 & 255) << 4) | 0;
    10761. 

  10761.      }
    10762. 

  10762.      i36 = (_luaV_lessequal(i1, i27, i25) | 0) == (i26 | 0);
    10763. 

  10763.      i26 = HEAP32[i21 >> 2] | 0;
    10764. 

  10764.      if (i36) {
    10765. 

  10765.       i25 = HEAP32[i26 >> 2] | 0;
    10766. 

  10766.       i27 = i25 >>> 6 & 255;
    10767. 

  10767.       if ((i27 | 0) != 0) {
    10768. 

  10768.        _luaF_close(i1, (HEAP32[i20 >> 2] | 0) + (i27 + -1 << 4) | 0);
    10769. 

  10769.        i26 = HEAP32[i21 >> 2] | 0;
    10770. 

  10770.       }
    10771. 

  10771.       i25 = i26 + ((i25 >>> 14) + -131070 << 2) | 0;
    10772. 

  10772.      } else {
    10773. 

  10773.       i25 = i26 + 4 | 0;
    10774. 

  10774.      }
    10775. 

  10775.      HEAP32[i21 >> 2] = i25;
    10776. 

  10776.      i25 = HEAP32[i20 >> 2] | 0;
    10777. 

  10777.      continue L3;
    10778. 

  10778.     }
    10779. 

  10779.    case 28:
    10780. 

  10780.     {
    10781. 

  10781.      i30 = i28 >>> 23;
    10782. 

  10782.      i29 = i25 + (i30 << 4) | 0;
    10783. 

  10783.      i30 = HEAP32[i25 + (i30 << 4) + 8 >> 2] | 0;
    10784. 

  10784.      i31 = (i30 | 0) == 0;
    10785. 

  10785.      if ((i28 & 8372224 | 0) == 0) {
    10786. 

  10786.       if (!i31) {
    10787. 

  10787.        if (!((i30 | 0) == 1 ? (HEAP32[i29 >> 2] | 0) == 0 : 0)) {
    10788. 

  10788.         i15 = 203;
    10789. 

  10789.        }
    10790. 

  10790.       }
    10791. 

  10791.      } else {
    10792. 

  10792.       if (!i31) {
    10793. 

  10793.        if ((i30 | 0) == 1 ? (HEAP32[i29 >> 2] | 0) == 0 : 0) {
    10794. 

  10794.         i15 = 203;
    10795. 

  10795.        }
    10796. 

  10796.       } else {
    10797. 

  10797.        i15 = 203;
    10798. 

  10798.       }
    10799. 

  10799.      }
    10800. 

  10800.      if ((i15 | 0) == 203) {
    10801. 

  10801.       i15 = 0;
    10802. 

  10802.       HEAP32[i21 >> 2] = (HEAP32[i21 >> 2] | 0) + 4;
    10803. 

  10803.       continue L3;
    10804. 

  10804.      }
    10805. 

  10805.      i36 = i29;
    10806. 

  10806.      i28 = HEAP32[i36 + 4 >> 2] | 0;
    10807. 

  10807.      HEAP32[i27 >> 2] = HEAP32[i36 >> 2];
    10808. 

  10808.      HEAP32[i27 + 4 >> 2] = i28;
    10809. 

  10809.      HEAP32[i25 + (i26 << 4) + 8 >> 2] = i30;
    10810. 

  10810.      i27 = HEAP32[i21 >> 2] | 0;
    10811. 

  10811.      i26 = HEAP32[i27 >> 2] | 0;
    10812. 

  10812.      i28 = i26 >>> 6 & 255;
    10813. 

  10813.      if ((i28 | 0) != 0) {
    10814. 

  10814.       _luaF_close(i1, (HEAP32[i20 >> 2] | 0) + (i28 + -1 << 4) | 0);
    10815. 

  10815.       i27 = HEAP32[i21 >> 2] | 0;
    10816. 

  10816.      }
    10817. 

  10817.      HEAP32[i21 >> 2] = i27 + ((i26 >>> 14) + -131070 << 2);
    10818. 

  10818.      continue L3;
    10819. 

  10819.     }
    10820. 

  10820.    case 30:
    10821. 

  10821.     {
    10822. 

  10822.      i28 = i28 >>> 23;
    10823. 

  10823.      if ((i28 | 0) != 0) {
    10824. 

  10824.       HEAP32[i5 >> 2] = i25 + (i26 + i28 << 4);
    10825. 

  10825.      }
    10826. 

  10826.      if ((_luaD_precall(i1, i27, -1) | 0) == 0) {
    10827. 

  10827.       i15 = 218;
    10828. 

  10828.       break L3;
    10829. 

  10829.      }
    10830. 

  10830.      i25 = HEAP32[i20 >> 2] | 0;
    10831. 

  10831.      continue L3;
    10832. 

  10832.     }
    10833. 

  10833.    case 29:
    10834. 

  10834.     {
    10835. 

  10835.      i29 = i28 >>> 23;
    10836. 

  10836.      i28 = i28 >>> 14 & 511;
    10837. 

  10837.      if ((i29 | 0) != 0) {
    10838. 

  10838.       HEAP32[i5 >> 2] = i25 + (i26 + i29 << 4);
    10839. 

  10839.      }
    10840. 

  10840.      if ((_luaD_precall(i1, i27, i28 + -1 | 0) | 0) == 0) {
    10841. 

  10841.       i15 = 213;
    10842. 

  10842.       break L3;
    10843. 

  10843.      }
    10844. 

  10844.      if ((i28 | 0) != 0) {
    10845. 

  10845.       HEAP32[i5 >> 2] = HEAP32[i24 >> 2];
    10846. 

  10846.      }
    10847. 

  10847.      i25 = HEAP32[i20 >> 2] | 0;
    10848. 

  10848.      continue L3;
    10849. 

  10849.     }
    10850. 

  10850.    case 32:
    10851. 

  10851.     {
    10852. 

  10852.      d39 = +HEAPF64[i25 + (i26 + 2 << 4) >> 3];
    10853. 

  10853.      d38 = d39 + +HEAPF64[i27 >> 3];
    10854. 

  10854.      d37 = +HEAPF64[i25 + (i26 + 1 << 4) >> 3];
    10855. 

  10855.      if (d39 > 0.0) {
    10856. 

  10856.       if (!(d38 <= d37)) {
    10857. 

  10857.        continue L3;
    10858. 

  10858.       }
    10859. 

  10859.      } else {
    10860. 

  10860.       if (!(d37 <= d38)) {
    10861. 

  10861.        continue L3;
    10862. 

  10862.       }
    10863. 

  10863.      }
    10864. 

  10864.      HEAP32[i21 >> 2] = (HEAP32[i21 >> 2] | 0) + ((i28 >>> 14) + -131071 << 2);
    10865. 

  10865.      HEAPF64[i27 >> 3] = d38;
    10866. 

  10866.      HEAP32[i25 + (i26 << 4) + 8 >> 2] = 3;
    10867. 

  10867.      i36 = i26 + 3 | 0;
    10868. 

  10868.      HEAPF64[i25 + (i36 << 4) >> 3] = d38;
    10869. 

  10869.      HEAP32[i25 + (i36 << 4) + 8 >> 2] = 3;
    10870. 

  10870.      continue L3;
    10871. 

  10871.     }
    10872. 

  10872.    case 33:
    10873. 

  10873.     {
    10874. 

  10874.      i32 = i26 + 1 | 0;
    10875. 

  10875.      i30 = i25 + (i32 << 4) | 0;
    10876. 

  10876.      i31 = i26 + 2 | 0;
    10877. 

  10877.      i29 = i25 + (i31 << 4) | 0;
    10878. 

  10878.      i26 = i25 + (i26 << 4) + 8 | 0;
    10879. 

  10879.      i33 = HEAP32[i26 >> 2] | 0;
    10880. 

  10880.      if ((i33 | 0) != 3) {
    10881. 

  10881.       if ((i33 & 15 | 0) != 4) {
    10882. 

  10882.        i15 = 239;
    10883. 

  10883.        break L1;
    10884. 

  10884.       }
    10885. 

  10885.       i36 = HEAP32[i27 >> 2] | 0;
    10886. 

  10886.       if ((_luaO_str2d(i36 + 16 | 0, HEAP32[i36 + 12 >> 2] | 0, i8) | 0) == 0) {
    10887. 

  10887.        i15 = 239;
    10888. 

  10888.        break L1;
    10889. 

  10889.       }
    10890. 

  10890.       HEAPF64[i27 >> 3] = +HEAPF64[i8 >> 3];
    10891. 

  10891.       HEAP32[i26 >> 2] = 3;
    10892. 

  10892.       if ((i27 | 0) == 0) {
    10893. 

  10893.        i15 = 239;
    10894. 

  10894.        break L1;
    10895. 

  10895.       }
    10896. 

  10896.      }
    10897. 

  10897.      i33 = i25 + (i32 << 4) + 8 | 0;
    10898. 

  10898.      i32 = HEAP32[i33 >> 2] | 0;
    10899. 

  10899.      if ((i32 | 0) != 3) {
    10900. 

  10900.       if ((i32 & 15 | 0) != 4) {
    10901. 

  10901.        i15 = 244;
    10902. 

  10902.        break L1;
    10903. 

  10903.       }
    10904. 

  10904.       i36 = HEAP32[i30 >> 2] | 0;
    10905. 

  10905.       if ((_luaO_str2d(i36 + 16 | 0, HEAP32[i36 + 12 >> 2] | 0, i9) | 0) == 0) {
    10906. 

  10906.        i15 = 244;
    10907. 

  10907.        break L1;
    10908. 

  10908.       }
    10909. 

  10909.       HEAPF64[i30 >> 3] = +HEAPF64[i9 >> 3];
    10910. 

  10910.       HEAP32[i33 >> 2] = 3;
    10911. 

  10911.      }
    10912. 

  10912.      i31 = i25 + (i31 << 4) + 8 | 0;
    10913. 

  10913.      i30 = HEAP32[i31 >> 2] | 0;
    10914. 

  10914.      if ((i30 | 0) != 3) {
    10915. 

  10915.       if ((i30 & 15 | 0) != 4) {
    10916. 

  10916.        i15 = 249;
    10917. 

  10917.        break L1;
    10918. 

  10918.       }
    10919. 

  10919.       i36 = HEAP32[i29 >> 2] | 0;
    10920. 

  10920.       if ((_luaO_str2d(i36 + 16 | 0, HEAP32[i36 + 12 >> 2] | 0, i10) | 0) == 0) {
    10921. 

  10921.        i15 = 249;
    10922. 

  10922.        break L1;
    10923. 

  10923.       }
    10924. 

  10924.       HEAPF64[i29 >> 3] = +HEAPF64[i10 >> 3];
    10925. 

  10925.       HEAP32[i31 >> 2] = 3;
    10926. 

  10926.      }
    10927. 

  10927.      HEAPF64[i27 >> 3] = +HEAPF64[i27 >> 3] - +HEAPF64[i29 >> 3];
    10928. 

  10928.      HEAP32[i26 >> 2] = 3;
    10929. 

  10929.      HEAP32[i21 >> 2] = (HEAP32[i21 >> 2] | 0) + ((i28 >>> 14) + -131071 << 2);
    10930. 

  10930.      continue L3;
    10931. 

  10931.     }
    10932. 

  10932.    case 31:
    10933. 

  10933.     {
    10934. 

  10934.      i15 = 223;
    10935. 

  10935.      break L3;
    10936. 

  10936.     }
    10937. 

  10937.    case 34:
    10938. 

  10938.     {
    10939. 

  10939.      i35 = i26 + 3 | 0;
    10940. 

  10940.      i36 = i25 + (i35 << 4) | 0;
    10941. 

  10941.      i33 = i26 + 2 | 0;
    10942. 

  10942.      i34 = i26 + 5 | 0;
    10943. 

  10943.      i32 = i25 + (i33 << 4) | 0;
    10944. 

  10944.      i31 = HEAP32[i32 + 4 >> 2] | 0;
    10945. 

  10945.      i30 = i25 + (i34 << 4) | 0;
    10946. 

  10946.      HEAP32[i30 >> 2] = HEAP32[i32 >> 2];
    10947. 

  10947.      HEAP32[i30 + 4 >> 2] = i31;
    10948. 

  10948.      HEAP32[i25 + (i34 << 4) + 8 >> 2] = HEAP32[i25 + (i33 << 4) + 8 >> 2];
    10949. 

  10949.      i34 = i26 + 1 | 0;
    10950. 

  10950.      i33 = i26 + 4 | 0;
    10951. 

  10951.      i30 = i25 + (i34 << 4) | 0;
    10952. 

  10952.      i31 = HEAP32[i30 + 4 >> 2] | 0;
    10953. 

  10953.      i32 = i25 + (i33 << 4) | 0;
    10954. 

  10954.      HEAP32[i32 >> 2] = HEAP32[i30 >> 2];
    10955. 

  10955.      HEAP32[i32 + 4 >> 2] = i31;
    10956. 

  10956.      HEAP32[i25 + (i33 << 4) + 8 >> 2] = HEAP32[i25 + (i34 << 4) + 8 >> 2];
    10957. 

  10957.      i33 = i27;
    10958. 

  10958.      i34 = HEAP32[i33 + 4 >> 2] | 0;
    10959. 

  10959.      i27 = i36;
    10960. 

  10960.      HEAP32[i27 >> 2] = HEAP32[i33 >> 2];
    10961. 

  10961.      HEAP32[i27 + 4 >> 2] = i34;
    10962. 

  10962.      HEAP32[i25 + (i35 << 4) + 8 >> 2] = HEAP32[i25 + (i26 << 4) + 8 >> 2];
    10963. 

  10963.      HEAP32[i5 >> 2] = i25 + (i26 + 6 << 4);
    10964. 

  10964.      _luaD_call(i1, i36, i28 >>> 14 & 511, 1);
    10965. 

  10965.      i36 = HEAP32[i20 >> 2] | 0;
    10966. 

  10966.      HEAP32[i5 >> 2] = HEAP32[i24 >> 2];
    10967. 

  10967.      i27 = HEAP32[i21 >> 2] | 0;
    10968. 

  10968.      HEAP32[i21 >> 2] = i27 + 4;
    10969. 

  10969.      i27 = HEAP32[i27 >> 2] | 0;
    10970. 

  10970.      i25 = i36;
    10971. 

  10971.      i28 = i27;
    10972. 

  10972.      i27 = i36 + ((i27 >>> 6 & 255) << 4) | 0;
    10973. 

  10973.      break;
    10974. 

  10974.     }
    10975. 

  10975.    case 35:
    10976. 

  10976.     {
    10977. 

  10977.      break;
    10978. 

  10978.     }
    10979. 

  10979.    case 36:
    10980. 

  10980.     {
    10981. 

  10981.      i29 = i28 >>> 23;
    10982. 

  10982.      i28 = i28 >>> 14 & 511;
    10983. 

  10983.      if ((i29 | 0) == 0) {
    10984. 

  10984.       i29 = ((HEAP32[i5 >> 2] | 0) - i27 >> 4) + -1 | 0;
    10985. 

  10985.      }
    10986. 

  10986.      if ((i28 | 0) == 0) {
    10987. 

  10987.       i28 = HEAP32[i21 >> 2] | 0;
    10988. 

  10988.       HEAP32[i21 >> 2] = i28 + 4;
    10989. 

  10989.       i28 = (HEAP32[i28 >> 2] | 0) >>> 6;
    10990. 

  10990.      }
    10991. 

  10991.      i27 = HEAP32[i27 >> 2] | 0;
    10992. 

  10992.      i30 = i29 + -50 + (i28 * 50 | 0) | 0;
    10993. 

  10993.      if ((i30 | 0) > (HEAP32[i27 + 28 >> 2] | 0)) {
    10994. 

  10994.       _luaH_resizearray(i1, i27, i30);
    10995. 

  10995.      }
    10996. 

  10996.      if ((i29 | 0) > 0) {
    10997. 

  10997.       i28 = i27 + 5 | 0;
    10998. 

  10998.       while (1) {
    10999. 

  10999.        i36 = i29 + i26 | 0;
    11000. 

  11000.        i32 = i25 + (i36 << 4) | 0;
    11001. 

  11001.        i31 = i30 + -1 | 0;
    11002. 

  11002.        _luaH_setint(i1, i27, i30, i32);
    11003. 

  11003.        if (((HEAP32[i25 + (i36 << 4) + 8 >> 2] & 64 | 0) != 0 ? !((HEAP8[(HEAP32[i32 >> 2] | 0) + 5 | 0] & 3) == 0) : 0) ? !((HEAP8[i28] & 4) == 0) : 0) {
    11004. 

  11004.         _luaC_barrierback_(i1, i27);
    11005. 

  11005.        }
    11006. 

  11006.        i29 = i29 + -1 | 0;
    11007. 

  11007.        if ((i29 | 0) > 0) {
    11008. 

  11008.         i30 = i31;
    11009. 

  11009.        } else {
    11010. 

  11010.         break;
    11011. 

  11011.        }
    11012. 

  11012.       }
    11013. 

  11013.      }
    11014. 

  11014.      HEAP32[i5 >> 2] = HEAP32[i24 >> 2];
    11015. 

  11015.      continue L3;
    11016. 

  11016.     }
    11017. 

  11017.    case 37:
    11018. 

  11018.     {
    11019. 

  11019.      i29 = HEAP32[(HEAP32[(HEAP32[i18 >> 2] | 0) + 16 >> 2] | 0) + (i28 >>> 14 << 2) >> 2] | 0;
    11020. 

  11020.      i28 = i29 + 32 | 0;
    11021. 

  11021.      i33 = HEAP32[i28 >> 2] | 0;
    11022. 

  11022.      i30 = HEAP32[i29 + 40 >> 2] | 0;
    11023. 

  11023.      i31 = HEAP32[i29 + 28 >> 2] | 0;
    11024. 

  11024.      L323 : do {
    11025. 

  11025.       if ((i33 | 0) == 0) {
    11026. 

  11026.        i15 = 276;
    11027. 

  11027.       } else {
    11028. 

  11028.        if ((i30 | 0) > 0) {
    11029. 

  11029.         i34 = i33 + 16 | 0;
    11030. 

  11030.         i32 = 0;
    11031. 

  11031.         while (1) {
    11032. 

  11032.          i35 = HEAPU8[i31 + (i32 << 3) + 5 | 0] | 0;
    11033. 

  11033.          if ((HEAP8[i31 + (i32 << 3) + 4 | 0] | 0) == 0) {
    11034. 

  11034.           i36 = HEAP32[(HEAP32[i22 + (i35 << 2) >> 2] | 0) + 8 >> 2] | 0;
    11035. 

  11035.          } else {
    11036. 

  11036.           i36 = i25 + (i35 << 4) | 0;
    11037. 

  11037.          }
    11038. 

  11038.          i35 = i32 + 1 | 0;
    11039. 

  11039.          if ((HEAP32[(HEAP32[i34 + (i32 << 2) >> 2] | 0) + 8 >> 2] | 0) != (i36 | 0)) {
    11040. 

  11040.           i15 = 276;
    11041. 

  11041.           break L323;
    11042. 

  11042.          }
    11043. 

  11043.          if ((i35 | 0) < (i30 | 0)) {
    11044. 

  11044.           i32 = i35;
    11045. 

  11045.          } else {
    11046. 

  11046.           break;
    11047. 

  11047.          }
    11048. 

  11048.         }
    11049. 

  11049.        }
    11050. 

  11050.        HEAP32[i27 >> 2] = i33;
    11051. 

  11051.        HEAP32[i25 + (i26 << 4) + 8 >> 2] = 70;
    11052. 

  11052.       }
    11053. 

  11053.      } while (0);
    11054. 

  11054.      if ((i15 | 0) == 276) {
    11055. 

  11055.       i15 = 0;
    11056. 

  11056.       i32 = _luaF_newLclosure(i1, i30) | 0;
    11057. 

  11057.       HEAP32[i32 + 12 >> 2] = i29;
    11058. 

  11058.       HEAP32[i27 >> 2] = i32;
    11059. 

  11059.       HEAP32[i25 + (i26 << 4) + 8 >> 2] = 70;
    11060. 

  11060.       if ((i30 | 0) > 0) {
    11061. 

  11061.        i27 = i32 + 16 | 0;
    11062. 

  11062.        i34 = 0;
    11063. 

  11063.        do {
    11064. 

  11064.         i33 = HEAPU8[i31 + (i34 << 3) + 5 | 0] | 0;
    11065. 

  11065.         if ((HEAP8[i31 + (i34 << 3) + 4 | 0] | 0) == 0) {
    11066. 

  11066.          HEAP32[i27 + (i34 << 2) >> 2] = HEAP32[i22 + (i33 << 2) >> 2];
    11067. 

  11067.         } else {
    11068. 

  11068.          HEAP32[i27 + (i34 << 2) >> 2] = _luaF_findupval(i1, i25 + (i33 << 4) | 0) | 0;
    11069. 

  11069.         }
    11070. 

  11070.         i34 = i34 + 1 | 0;
    11071. 

  11071.        } while ((i34 | 0) != (i30 | 0));
    11072. 

  11072.       }
    11073. 

  11073.       if (!((HEAP8[i29 + 5 | 0] & 4) == 0)) {
    11074. 

  11074.        _luaC_barrierproto_(i1, i29, i32);
    11075. 

  11075.       }
    11076. 

  11076.       HEAP32[i28 >> 2] = i32;
    11077. 

  11077.      }
    11078. 

  11078.      if ((HEAP32[(HEAP32[i6 >> 2] | 0) + 12 >> 2] | 0) > 0) {
    11079. 

  11079.       HEAP32[i5 >> 2] = i25 + (i26 + 1 << 4);
    11080. 

  11080.       _luaC_step(i1);
    11081. 

  11081.       HEAP32[i5 >> 2] = HEAP32[i24 >> 2];
    11082. 

  11082.      }
    11083. 

  11083.      i25 = HEAP32[i20 >> 2] | 0;
    11084. 

  11084.      continue L3;
    11085. 

  11085.     }
    11086. 

  11086.    case 38:
    11087. 

  11087.     {
    11088. 

  11088.      i36 = i28 >>> 23;
    11089. 

  11089.      i29 = i36 + -1 | 0;
    11090. 

  11090.      i30 = (i25 - (HEAP32[i19 >> 2] | 0) >> 4) - (HEAPU8[(HEAP32[i18 >> 2] | 0) + 76 | 0] | 0) | 0;
    11091. 

  11091.      i28 = i30 + -1 | 0;
    11092. 

  11092.      if ((i36 | 0) == 0) {
    11093. 

  11093.       if (((HEAP32[i11 >> 2] | 0) - (HEAP32[i5 >> 2] | 0) >> 4 | 0) <= (i28 | 0)) {
    11094. 

  11094.        _luaD_growstack(i1, i28);
    11095. 

  11095.       }
    11096. 

  11096.       i27 = HEAP32[i20 >> 2] | 0;
    11097. 

  11097.       HEAP32[i5 >> 2] = i27 + (i28 + i26 << 4);
    11098. 

  11098.       i29 = i28;
    11099. 

  11099.       i25 = i27;
    11100. 

  11100.       i27 = i27 + (i26 << 4) | 0;
    11101. 

  11101.      }
    11102. 

  11102.      if ((i29 | 0) <= 0) {
    11103. 

  11103.       continue L3;
    11104. 

  11104.      }
    11105. 

  11105.      i26 = 1 - i30 | 0;
    11106. 

  11106.      i30 = 0;
    11107. 

  11107.      while (1) {
    11108. 

  11108.       if ((i30 | 0) < (i28 | 0)) {
    11109. 

  11109.        i36 = i30 + i26 | 0;
    11110. 

  11110.        i33 = i25 + (i36 << 4) | 0;
    11111. 

  11111.        i34 = HEAP32[i33 + 4 >> 2] | 0;
    11112. 

  11112.        i35 = i27 + (i30 << 4) | 0;
    11113. 

  11113.        HEAP32[i35 >> 2] = HEAP32[i33 >> 2];
    11114. 

  11114.        HEAP32[i35 + 4 >> 2] = i34;
    11115. 

  11115.        HEAP32[i27 + (i30 << 4) + 8 >> 2] = HEAP32[i25 + (i36 << 4) + 8 >> 2];
    11116. 

  11116.       } else {
    11117. 

  11117.        HEAP32[i27 + (i30 << 4) + 8 >> 2] = 0;
    11118. 

  11118.       }
    11119. 

  11119.       i30 = i30 + 1 | 0;
    11120. 

  11120.       if ((i30 | 0) == (i29 | 0)) {
    11121. 

  11121.        continue L3;
    11122. 

  11122.       }
    11123. 

  11123.      }
    11124. 

  11124.     }
    11125. 

  11125.    default:
    11126. 

  11126.     {
    11127. 

  11127.      continue L3;
    11128. 

  11128.     }
    11129. 

  11129.    }
    11130. 

  11130.    i26 = HEAP32[i27 + 24 >> 2] | 0;
    11131. 

  11131.    if ((i26 | 0) == 0) {
    11132. 

  11132.     continue;
    11133. 

  11133.    }
    11134. 

  11134.    i34 = i27 + 16 | 0;
    11135. 

  11135.    i35 = HEAP32[i34 + 4 >> 2] | 0;
    11136. 

  11136.    i36 = i27;
    11137. 

  11137.    HEAP32[i36 >> 2] = HEAP32[i34 >> 2];
    11138. 

  11138.    HEAP32[i36 + 4 >> 2] = i35;
    11139. 

  11139.    HEAP32[i27 + 8 >> 2] = i26;
    11140. 

  11140.    HEAP32[i21 >> 2] = (HEAP32[i21 >> 2] | 0) + ((i28 >>> 14) + -131071 << 2);
    11141. 

  11141.   }
    11142. 

  11142.   if ((i15 | 0) == 213) {
    11143. 

  11143.    i15 = 0;
    11144. 

  11144.    i19 = HEAP32[i3 >> 2] | 0;
    11145. 

  11145.    i36 = i19 + 18 | 0;
    11146. 

  11146.    HEAP8[i36] = HEAPU8[i36] | 4;
    11147. 

  11147.    continue;
    11148. 

  11148.   } else if ((i15 | 0) == 218) {
    11149. 

  11149.    i15 = 0;
    11150. 

  11150.    i22 = HEAP32[i3 >> 2] | 0;
    11151. 

  11151.    i19 = HEAP32[i22 + 8 >> 2] | 0;
    11152. 

  11152.    i23 = HEAP32[i22 >> 2] | 0;
    11153. 

  11153.    i24 = HEAP32[i19 >> 2] | 0;
    11154. 

  11154.    i20 = i22 + 24 | 0;
    11155. 

  11155.    i21 = (HEAP32[i20 >> 2] | 0) + (HEAPU8[(HEAP32[(HEAP32[i23 >> 2] | 0) + 12 >> 2] | 0) + 76 | 0] << 4) | 0;
    11156. 

  11156.    if ((HEAP32[(HEAP32[i18 >> 2] | 0) + 56 >> 2] | 0) > 0) {
    11157. 

  11157.     _luaF_close(i1, HEAP32[i19 + 24 >> 2] | 0);
    11158. 

  11158.    }
    11159. 

  11159.    if (i23 >>> 0 < i21 >>> 0) {
    11160. 

  11160.     i25 = i23;
    11161. 

  11161.     i18 = 0;
    11162. 

  11162.     do {
    11163. 

  11163.      i34 = i25;
    11164. 

  11164.      i35 = HEAP32[i34 + 4 >> 2] | 0;
    11165. 

  11165.      i36 = i24 + (i18 << 4) | 0;
    11166. 

  11166.      HEAP32[i36 >> 2] = HEAP32[i34 >> 2];
    11167. 

  11167.      HEAP32[i36 + 4 >> 2] = i35;
    11168. 

  11168.      HEAP32[i24 + (i18 << 4) + 8 >> 2] = HEAP32[i23 + (i18 << 4) + 8 >> 2];
    11169. 

  11169.      i18 = i18 + 1 | 0;
    11170. 

  11170.      i25 = i23 + (i18 << 4) | 0;
    11171. 

  11171.     } while (i25 >>> 0 < i21 >>> 0);
    11172. 

  11172.    }
    11173. 

  11173.    i36 = i23;
    11174. 

  11174.    HEAP32[i19 + 24 >> 2] = i24 + ((HEAP32[i20 >> 2] | 0) - i36 >> 4 << 4);
    11175. 

  11175.    i36 = i24 + ((HEAP32[i5 >> 2] | 0) - i36 >> 4 << 4) | 0;
    11176. 

  11176.    HEAP32[i5 >> 2] = i36;
    11177. 

  11177.    HEAP32[i19 + 4 >> 2] = i36;
    11178. 

  11178.    HEAP32[i19 + 28 >> 2] = HEAP32[i22 + 28 >> 2];
    11179. 

  11179.    i36 = i19 + 18 | 0;
    11180. 

  11180.    HEAP8[i36] = HEAPU8[i36] | 64;
    11181. 

  11181.    HEAP32[i3 >> 2] = i19;
    11182. 

  11182.    continue;
    11183. 

  11183.   } else if ((i15 | 0) == 223) {
    11184. 

  11184.    i15 = 0;
    11185. 

  11185.    i20 = i28 >>> 23;
    11186. 

  11186.    if ((i20 | 0) != 0) {
    11187. 

  11187.     HEAP32[i5 >> 2] = i25 + (i20 + -1 + i26 << 4);
    11188. 

  11188.    }
    11189. 

  11189.    if ((HEAP32[(HEAP32[i18 >> 2] | 0) + 56 >> 2] | 0) > 0) {
    11190. 

  11190.     _luaF_close(i1, i25);
    11191. 

  11191.    }
    11192. 

  11192.    i18 = _luaD_poscall(i1, i27) | 0;
    11193. 

  11193.    if ((HEAP8[i19 + 18 | 0] & 4) == 0) {
    11194. 

  11194.     i15 = 228;
    11195. 

  11195.     break;
    11196. 

  11196.    }
    11197. 

  11197.    i19 = HEAP32[i3 >> 2] | 0;
    11198. 

  11198.    if ((i18 | 0) == 0) {
    11199. 

  11199.     continue;
    11200. 

  11200.    }
    11201. 

  11201.    HEAP32[i5 >> 2] = HEAP32[i19 + 4 >> 2];
    11202. 

  11202.    continue;
    11203. 

  11203.   }
    11204. 

  11204.  }
    11205. 

  11205.  if ((i15 | 0) == 23) {
    11206. 

  11206.   if (!i27) {
    11207. 

  11207.    i36 = HEAP32[i29 >> 2] | 0;
    11208. 

  11208.    i36 = i36 + -4 | 0;
    11209. 

  11209.    HEAP32[i29 >> 2] = i36;
    11210. 

  11210.    i36 = HEAP8[i26] | 0;
    11211. 

  11211.    i36 = i36 & 255;
    11212. 

  11212.    i36 = i36 | 128;
    11213. 

  11213.    i36 = i36 & 255;
    11214. 

  11214.    HEAP8[i26] = i36;
    11215. 

  11215.    i36 = HEAP32[i5 >> 2] | 0;
    11216. 

  11216.    i36 = i36 + -16 | 0;
    11217. 

  11217.    HEAP32[i25 >> 2] = i36;
    11218. 

  11218.    _luaD_throw(i1, 1);
    11219. 

  11219.   }
    11220. 

  11220.   HEAP32[i17 >> 2] = 1;
    11221. 

  11221.   i36 = HEAP32[i29 >> 2] | 0;
    11222. 

  11222.   i36 = i36 + -4 | 0;
    11223. 

  11223.   HEAP32[i29 >> 2] = i36;
    11224. 

  11224.   i36 = HEAP8[i26] | 0;
    11225. 

  11225.   i36 = i36 & 255;
    11226. 

  11226.   i36 = i36 | 128;
    11227. 

  11227.   i36 = i36 & 255;
    11228. 

  11228.   HEAP8[i26] = i36;
    11229. 

  11229.   i36 = HEAP32[i5 >> 2] | 0;
    11230. 

  11230.   i36 = i36 + -16 | 0;
    11231. 

  11231.   HEAP32[i25 >> 2] = i36;
    11232. 

  11232.   _luaD_throw(i1, 1);
    11233. 

  11233.  } else if ((i15 | 0) == 228) {
    11234. 

  11234.   STACKTOP = i12;
    11235. 

  11235.   return;
    11236. 

  11236.  } else if ((i15 | 0) == 239) {
    11237. 

  11237.   _luaG_runerror(i1, 9040, i13);
    11238. 

  11238.  } else if ((i15 | 0) == 244) {
    11239. 

  11239.   _luaG_runerror(i1, 9080, i13);
    11240. 

  11240.  } else if ((i15 | 0) == 249) {
    11241. 

  11241.   _luaG_runerror(i1, 9112, i13);
    11242. 

  11242.  }
    11243. 

  11243. }
    11244. 

  11244. function ___floatscan(i8, i2, i11) {
    11245. 

  11245.  i8 = i8 | 0;
    11246. 

  11246.  i2 = i2 | 0;
    11247. 

  11247.  i11 = i11 | 0;
    11248. 

  11248.  var i1 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i9 = 0, i10 = 0, i12 = 0, i13 = 0, d14 = 0.0, i15 = 0, i16 = 0, i17 = 0, i18 = 0, i19 = 0, i20 = 0, i21 = 0, i22 = 0, i23 = 0, i24 = 0, i25 = 0, i26 = 0, i27 = 0, d28 = 0.0, i29 = 0, d30 = 0.0, d31 = 0.0, d32 = 0.0, d33 = 0.0;
    11249. 

  11249.  i1 = STACKTOP;
    11250. 

  11250.  STACKTOP = STACKTOP + 512 | 0;
    11251. 

  11251.  i5 = i1;
    11252. 

  11252.  if ((i2 | 0) == 1) {
    11253. 

  11253.   i2 = 53;
    11254. 

  11254.   i3 = -1074;
    11255. 

  11255.  } else if ((i2 | 0) == 2) {
    11256. 

  11256.   i2 = 53;
    11257. 

  11257.   i3 = -1074;
    11258. 

  11258.  } else if ((i2 | 0) == 0) {
    11259. 

  11259.   i2 = 24;
    11260. 

  11260.   i3 = -149;
    11261. 

  11261.  } else {
    11262. 

  11262.   d31 = 0.0;
    11263. 

  11263.   STACKTOP = i1;
    11264. 

  11264.   return +d31;
    11265. 

  11265.  }
    11266. 

  11266.  i9 = i8 + 4 | 0;
    11267. 

  11267.  i10 = i8 + 100 | 0;
    11268. 

  11268.  do {
    11269. 

  11269.   i4 = HEAP32[i9 >> 2] | 0;
    11270. 

  11270.   if (i4 >>> 0 < (HEAP32[i10 >> 2] | 0) >>> 0) {
    11271. 

  11271.    HEAP32[i9 >> 2] = i4 + 1;
    11272. 

  11272.    i21 = HEAPU8[i4] | 0;
    11273. 

  11273.   } else {
    11274. 

  11274.    i21 = ___shgetc(i8) | 0;
    11275. 

  11275.   }
    11276. 

  11276.  } while ((_isspace(i21 | 0) | 0) != 0);
    11277. 

  11277.  do {
    11278. 

  11278.   if ((i21 | 0) == 43 | (i21 | 0) == 45) {
    11279. 

  11279.    i4 = 1 - (((i21 | 0) == 45) << 1) | 0;
    11280. 

  11280.    i7 = HEAP32[i9 >> 2] | 0;
    11281. 

  11281.    if (i7 >>> 0 < (HEAP32[i10 >> 2] | 0) >>> 0) {
    11282. 

  11282.     HEAP32[i9 >> 2] = i7 + 1;
    11283. 

  11283.     i21 = HEAPU8[i7] | 0;
    11284. 

  11284.     break;
    11285. 

  11285.    } else {
    11286. 

  11286.     i21 = ___shgetc(i8) | 0;
    11287. 

  11287.     break;
    11288. 

  11288.    }
    11289. 

  11289.   } else {
    11290. 

  11290.    i4 = 1;
    11291. 

  11291.   }
    11292. 

  11292.  } while (0);
    11293. 

  11293.  i7 = 0;
    11294. 

  11294.  do {
    11295. 

  11295.   if ((i21 | 32 | 0) != (HEAP8[13408 + i7 | 0] | 0)) {
    11296. 

  11296.    break;
    11297. 

  11297.   }
    11298. 

  11298.   do {
    11299. 

  11299.    if (i7 >>> 0 < 7) {
    11300. 

  11300.     i12 = HEAP32[i9 >> 2] | 0;
    11301. 

  11301.     if (i12 >>> 0 < (HEAP32[i10 >> 2] | 0) >>> 0) {
    11302. 

  11302.      HEAP32[i9 >> 2] = i12 + 1;
    11303. 

  11303.      i21 = HEAPU8[i12] | 0;
    11304. 

  11304.      break;
    11305. 

  11305.     } else {
    11306. 

  11306.      i21 = ___shgetc(i8) | 0;
    11307. 

  11307.      break;
    11308. 

  11308.     }
    11309. 

  11309.    }
    11310. 

  11310.   } while (0);
    11311. 

  11311.   i7 = i7 + 1 | 0;
    11312. 

  11312.  } while (i7 >>> 0 < 8);
    11313. 

  11313.  do {
    11314. 

  11314.   if ((i7 | 0) == 3) {
    11315. 

  11315.    i13 = 23;
    11316. 

  11316.   } else if ((i7 | 0) != 8) {
    11317. 

  11317.    i12 = (i11 | 0) == 0;
    11318. 

  11318.    if (!(i7 >>> 0 < 4 | i12)) {
    11319. 

  11319.     if ((i7 | 0) == 8) {
    11320. 

  11320.      break;
    11321. 

  11321.     } else {
    11322. 

  11322.      i13 = 23;
    11323. 

  11323.      break;
    11324. 

  11324.     }
    11325. 

  11325.    }
    11326. 

  11326.    L34 : do {
    11327. 

  11327.     if ((i7 | 0) == 0) {
    11328. 

  11328.      i7 = 0;
    11329. 

  11329.      do {
    11330. 

  11330.       if ((i21 | 32 | 0) != (HEAP8[13424 + i7 | 0] | 0)) {
    11331. 

  11331.        break L34;
    11332. 

  11332.       }
    11333. 

  11333.       do {
    11334. 

  11334.        if (i7 >>> 0 < 2) {
    11335. 

  11335.         i15 = HEAP32[i9 >> 2] | 0;
    11336. 

  11336.         if (i15 >>> 0 < (HEAP32[i10 >> 2] | 0) >>> 0) {
    11337. 

  11337.          HEAP32[i9 >> 2] = i15 + 1;
    11338. 

  11338.          i21 = HEAPU8[i15] | 0;
    11339. 

  11339.          break;
    11340. 

  11340.         } else {
    11341. 

  11341.          i21 = ___shgetc(i8) | 0;
    11342. 

  11342.          break;
    11343. 

  11343.         }
    11344. 

  11344.        }
    11345. 

  11345.       } while (0);
    11346. 

  11346.       i7 = i7 + 1 | 0;
    11347. 

  11347.      } while (i7 >>> 0 < 3);
    11348. 

  11348.     }
    11349. 

  11349.    } while (0);
    11350. 

  11350.    if ((i7 | 0) == 0) {
    11351. 

  11351.     do {
    11352. 

  11352.      if ((i21 | 0) == 48) {
    11353. 

  11353.       i7 = HEAP32[i9 >> 2] | 0;
    11354. 

  11354.       if (i7 >>> 0 < (HEAP32[i10 >> 2] | 0) >>> 0) {
    11355. 

  11355.        HEAP32[i9 >> 2] = i7 + 1;
    11356. 

  11356.        i7 = HEAPU8[i7] | 0;
    11357. 

  11357.       } else {
    11358. 

  11358.        i7 = ___shgetc(i8) | 0;
    11359. 

  11359.       }
    11360. 

  11360.       if ((i7 | 32 | 0) != 120) {
    11361. 

  11361.        if ((HEAP32[i10 >> 2] | 0) == 0) {
    11362. 

  11362.         i21 = 48;
    11363. 

  11363.         break;
    11364. 

  11364.        }
    11365. 

  11365.        HEAP32[i9 >> 2] = (HEAP32[i9 >> 2] | 0) + -1;
    11366. 

  11366.        i21 = 48;
    11367. 

  11367.        break;
    11368. 

  11368.       }
    11369. 

  11369.       i5 = HEAP32[i9 >> 2] | 0;
    11370. 

  11370.       if (i5 >>> 0 < (HEAP32[i10 >> 2] | 0) >>> 0) {
    11371. 

  11371.        HEAP32[i9 >> 2] = i5 + 1;
    11372. 

  11372.        i21 = HEAPU8[i5] | 0;
    11373. 

  11373.        i19 = 0;
    11374. 

  11374.       } else {
    11375. 

  11375.        i21 = ___shgetc(i8) | 0;
    11376. 

  11376.        i19 = 0;
    11377. 

  11377.       }
    11378. 

  11378.       while (1) {
    11379. 

  11379.        if ((i21 | 0) == 46) {
    11380. 

  11380.         i13 = 70;
    11381. 

  11381.         break;
    11382. 

  11382.        } else if ((i21 | 0) != 48) {
    11383. 

  11383.         i5 = 0;
    11384. 

  11384.         i7 = 0;
    11385. 

  11385.         i15 = 0;
    11386. 

  11386.         i16 = 0;
    11387. 

  11387.         i18 = 0;
    11388. 

  11388.         i20 = 0;
    11389. 

  11389.         d28 = 1.0;
    11390. 

  11390.         i17 = 0;
    11391. 

  11391.         d14 = 0.0;
    11392. 

  11392.         break;
    11393. 

  11393.        }
    11394. 

  11394.        i5 = HEAP32[i9 >> 2] | 0;
    11395. 

  11395.        if (i5 >>> 0 < (HEAP32[i10 >> 2] | 0) >>> 0) {
    11396. 

  11396.         HEAP32[i9 >> 2] = i5 + 1;
    11397. 

  11397.         i21 = HEAPU8[i5] | 0;
    11398. 

  11398.         i19 = 1;
    11399. 

  11399.         continue;
    11400. 

  11400.        } else {
    11401. 

  11401.         i21 = ___shgetc(i8) | 0;
    11402. 

  11402.         i19 = 1;
    11403. 

  11403.         continue;
    11404. 

  11404.        }
    11405. 

  11405.       }
    11406. 

  11406.       L66 : do {
    11407. 

  11407.        if ((i13 | 0) == 70) {
    11408. 

  11408.         i5 = HEAP32[i9 >> 2] | 0;
    11409. 

  11409.         if (i5 >>> 0 < (HEAP32[i10 >> 2] | 0) >>> 0) {
    11410. 

  11410.          HEAP32[i9 >> 2] = i5 + 1;
    11411. 

  11411.          i21 = HEAPU8[i5] | 0;
    11412. 

  11412.         } else {
    11413. 

  11413.          i21 = ___shgetc(i8) | 0;
    11414. 

  11414.         }
    11415. 

  11415.         if ((i21 | 0) == 48) {
    11416. 

  11416.          i15 = -1;
    11417. 

  11417.          i16 = -1;
    11418. 

  11418.          while (1) {
    11419. 

  11419.           i5 = HEAP32[i9 >> 2] | 0;
    11420. 

  11420.           if (i5 >>> 0 < (HEAP32[i10 >> 2] | 0) >>> 0) {
    11421. 

  11421.            HEAP32[i9 >> 2] = i5 + 1;
    11422. 

  11422.            i21 = HEAPU8[i5] | 0;
    11423. 

  11423.           } else {
    11424. 

  11424.            i21 = ___shgetc(i8) | 0;
    11425. 

  11425.           }
    11426. 

  11426.           if ((i21 | 0) != 48) {
    11427. 

  11427.            i5 = 0;
    11428. 

  11428.            i7 = 0;
    11429. 

  11429.            i19 = 1;
    11430. 

  11430.            i18 = 1;
    11431. 

  11431.            i20 = 0;
    11432. 

  11432.            d28 = 1.0;
    11433. 

  11433.            i17 = 0;
    11434. 

  11434.            d14 = 0.0;
    11435. 

  11435.            break L66;
    11436. 

  11436.           }
    11437. 

  11437.           i29 = _i64Add(i15 | 0, i16 | 0, -1, -1) | 0;
    11438. 

  11438.           i15 = i29;
    11439. 

  11439.           i16 = tempRet0;
    11440. 

  11440.          }
    11441. 

  11441.         } else {
    11442. 

  11442.          i5 = 0;
    11443. 

  11443.          i7 = 0;
    11444. 

  11444.          i15 = 0;
    11445. 

  11445.          i16 = 0;
    11446. 

  11446.          i18 = 1;
    11447. 

  11447.          i20 = 0;
    11448. 

  11448.          d28 = 1.0;
    11449. 

  11449.          i17 = 0;
    11450. 

  11450.          d14 = 0.0;
    11451. 

  11451.         }
    11452. 

  11452.        }
    11453. 

  11453.       } while (0);
    11454. 

  11454.       L79 : while (1) {
    11455. 

  11455.        i24 = i21 + -48 | 0;
    11456. 

  11456.        do {
    11457. 

  11457.         if (!(i24 >>> 0 < 10)) {
    11458. 

  11458.          i23 = i21 | 32;
    11459. 

  11459.          i22 = (i21 | 0) == 46;
    11460. 

  11460.          if (!((i23 + -97 | 0) >>> 0 < 6 | i22)) {
    11461. 

  11461.           break L79;
    11462. 

  11462.          }
    11463. 

  11463.          if (i22) {
    11464. 

  11464.           if ((i18 | 0) == 0) {
    11465. 

  11465.            i15 = i7;
    11466. 

  11466.            i16 = i5;
    11467. 

  11467.            i18 = 1;
    11468. 

  11468.            break;
    11469. 

  11469.           } else {
    11470. 

  11470.            i21 = 46;
    11471. 

  11471.            break L79;
    11472. 

  11472.           }
    11473. 

  11473.          } else {
    11474. 

  11474.           i24 = (i21 | 0) > 57 ? i23 + -87 | 0 : i24;
    11475. 

  11475.           i13 = 84;
    11476. 

  11476.           break;
    11477. 

  11477.          }
    11478. 

  11478.         } else {
    11479. 

  11479.          i13 = 84;
    11480. 

  11480.         }
    11481. 

  11481.        } while (0);
    11482. 

  11482.        if ((i13 | 0) == 84) {
    11483. 

  11483.         i13 = 0;
    11484. 

  11484.         do {
    11485. 

  11485.          if (!((i5 | 0) < 0 | (i5 | 0) == 0 & i7 >>> 0 < 8)) {
    11486. 

  11486.           if ((i5 | 0) < 0 | (i5 | 0) == 0 & i7 >>> 0 < 14) {
    11487. 

  11487.            d31 = d28 * .0625;
    11488. 

  11488.            d30 = d31;
    11489. 

  11489.            d14 = d14 + d31 * +(i24 | 0);
    11490. 

  11490.            break;
    11491. 

  11491.           }
    11492. 

  11492.           if ((i24 | 0) != 0 & (i20 | 0) == 0) {
    11493. 

  11493.            i20 = 1;
    11494. 

  11494.            d30 = d28;
    11495. 

  11495.            d14 = d14 + d28 * .5;
    11496. 

  11496.           } else {
    11497. 

  11497.            d30 = d28;
    11498. 

  11498.           }
    11499. 

  11499.          } else {
    11500. 

  11500.           d30 = d28;
    11501. 

  11501.           i17 = i24 + (i17 << 4) | 0;
    11502. 

  11502.          }
    11503. 

  11503.         } while (0);
    11504. 

  11504.         i7 = _i64Add(i7 | 0, i5 | 0, 1, 0) | 0;
    11505. 

  11505.         i5 = tempRet0;
    11506. 

  11506.         i19 = 1;
    11507. 

  11507.         d28 = d30;
    11508. 

  11508.        }
    11509. 

  11509.        i21 = HEAP32[i9 >> 2] | 0;
    11510. 

  11510.        if (i21 >>> 0 < (HEAP32[i10 >> 2] | 0) >>> 0) {
    11511. 

  11511.         HEAP32[i9 >> 2] = i21 + 1;
    11512. 

  11512.         i21 = HEAPU8[i21] | 0;
    11513. 

  11513.         continue;
    11514. 

  11514.        } else {
    11515. 

  11515.         i21 = ___shgetc(i8) | 0;
    11516. 

  11516.         continue;
    11517. 

  11517.        }
    11518. 

  11518.       }
    11519. 

  11519.       if ((i19 | 0) == 0) {
    11520. 

  11520.        i2 = (HEAP32[i10 >> 2] | 0) == 0;
    11521. 

  11521.        if (!i2) {
    11522. 

  11522.         HEAP32[i9 >> 2] = (HEAP32[i9 >> 2] | 0) + -1;
    11523. 

  11523.        }
    11524. 

  11524.        if (!i12) {
    11525. 

  11525.         if (!i2 ? (i6 = HEAP32[i9 >> 2] | 0, HEAP32[i9 >> 2] = i6 + -1, (i18 | 0) != 0) : 0) {
    11526. 

  11526.          HEAP32[i9 >> 2] = i6 + -2;
    11527. 

  11527.         }
    11528. 

  11528.        } else {
    11529. 

  11529.         ___shlim(i8, 0);
    11530. 

  11530.        }
    11531. 

  11531.        d31 = +(i4 | 0) * 0.0;
    11532. 

  11532.        STACKTOP = i1;
    11533. 

  11533.        return +d31;
    11534. 

  11534.       }
    11535. 

  11535.       i13 = (i18 | 0) == 0;
    11536. 

  11536.       i6 = i13 ? i7 : i15;
    11537. 

  11537.       i13 = i13 ? i5 : i16;
    11538. 

  11538.       if ((i5 | 0) < 0 | (i5 | 0) == 0 & i7 >>> 0 < 8) {
    11539. 

  11539.        do {
    11540. 

  11540.         i17 = i17 << 4;
    11541. 

  11541.         i7 = _i64Add(i7 | 0, i5 | 0, 1, 0) | 0;
    11542. 

  11542.         i5 = tempRet0;
    11543. 

  11543.        } while ((i5 | 0) < 0 | (i5 | 0) == 0 & i7 >>> 0 < 8);
    11544. 

  11544.       }
    11545. 

  11545.       do {
    11546. 

  11546.        if ((i21 | 32 | 0) == 112) {
    11547. 

  11547.         i7 = _scanexp(i8, i11) | 0;
    11548. 

  11548.         i5 = tempRet0;
    11549. 

  11549.         if ((i7 | 0) == 0 & (i5 | 0) == -2147483648) {
    11550. 

  11550.          if (i12) {
    11551. 

  11551.           ___shlim(i8, 0);
    11552. 

  11552.           d31 = 0.0;
    11553. 

  11553.           STACKTOP = i1;
    11554. 

  11554.           return +d31;
    11555. 

  11555.          } else {
    11556. 

  11556.           if ((HEAP32[i10 >> 2] | 0) == 0) {
    11557. 

  11557.            i7 = 0;
    11558. 

  11558.            i5 = 0;
    11559. 

  11559.            break;
    11560. 

  11560.           }
    11561. 

  11561.           HEAP32[i9 >> 2] = (HEAP32[i9 >> 2] | 0) + -1;
    11562. 

  11562.           i7 = 0;
    11563. 

  11563.           i5 = 0;
    11564. 

  11564.           break;
    11565. 

  11565.          }
    11566. 

  11566.         }
    11567. 

  11567.        } else {
    11568. 

  11568.         if ((HEAP32[i10 >> 2] | 0) == 0) {
    11569. 

  11569.          i7 = 0;
    11570. 

  11570.          i5 = 0;
    11571. 

  11571.         } else {
    11572. 

  11572.          HEAP32[i9 >> 2] = (HEAP32[i9 >> 2] | 0) + -1;
    11573. 

  11573.          i7 = 0;
    11574. 

  11574.          i5 = 0;
    11575. 

  11575.         }
    11576. 

  11576.        }
    11577. 

  11577.       } while (0);
    11578. 

  11578.       i6 = _bitshift64Shl(i6 | 0, i13 | 0, 2) | 0;
    11579. 

  11579.       i6 = _i64Add(i6 | 0, tempRet0 | 0, -32, -1) | 0;
    11580. 

  11580.       i5 = _i64Add(i6 | 0, tempRet0 | 0, i7 | 0, i5 | 0) | 0;
    11581. 

  11581.       i6 = tempRet0;
    11582. 

  11582.       if ((i17 | 0) == 0) {
    11583. 

  11583.        d31 = +(i4 | 0) * 0.0;
    11584. 

  11584.        STACKTOP = i1;
    11585. 

  11585.        return +d31;
    11586. 

  11586.       }
    11587. 

  11587.       if ((i6 | 0) > 0 | (i6 | 0) == 0 & i5 >>> 0 > (0 - i3 | 0) >>> 0) {
    11588. 

  11588.        HEAP32[(___errno_location() | 0) >> 2] = 34;
    11589. 

  11589.        d31 = +(i4 | 0) * 1.7976931348623157e+308 * 1.7976931348623157e+308;
    11590. 

  11590.        STACKTOP = i1;
    11591. 

  11591.        return +d31;
    11592. 

  11592.       }
    11593. 

  11593.       i29 = i3 + -106 | 0;
    11594. 

  11594.       i27 = ((i29 | 0) < 0) << 31 >> 31;
    11595. 

  11595.       if ((i6 | 0) < (i27 | 0) | (i6 | 0) == (i27 | 0) & i5 >>> 0 < i29 >>> 0) {
    11596. 

  11596.        HEAP32[(___errno_location() | 0) >> 2] = 34;
    11597. 

  11597.        d31 = +(i4 | 0) * 2.2250738585072014e-308 * 2.2250738585072014e-308;
    11598. 

  11598.        STACKTOP = i1;
    11599. 

  11599.        return +d31;
    11600. 

  11600.       }
    11601. 

  11601.       if ((i17 | 0) > -1) {
    11602. 

  11602.        do {
    11603. 

  11603.         i17 = i17 << 1;
    11604. 

  11604.         if (!(d14 >= .5)) {
    11605. 

  11605.          d28 = d14;
    11606. 

  11606.         } else {
    11607. 

  11607.          d28 = d14 + -1.0;
    11608. 

  11608.          i17 = i17 | 1;
    11609. 

  11609.         }
    11610. 

  11610.         d14 = d14 + d28;
    11611. 

  11611.         i5 = _i64Add(i5 | 0, i6 | 0, -1, -1) | 0;
    11612. 

  11612.         i6 = tempRet0;
    11613. 

  11613.        } while ((i17 | 0) > -1);
    11614. 

  11614.       }
    11615. 

  11615.       i3 = _i64Subtract(32, 0, i3 | 0, ((i3 | 0) < 0) << 31 >> 31 | 0) | 0;
    11616. 

  11616.       i3 = _i64Add(i5 | 0, i6 | 0, i3 | 0, tempRet0 | 0) | 0;
    11617. 

  11617.       i29 = tempRet0;
    11618. 

  11618.       if (0 > (i29 | 0) | 0 == (i29 | 0) & i2 >>> 0 > i3 >>> 0) {
    11619. 

  11619.        i2 = (i3 | 0) < 0 ? 0 : i3;
    11620. 

  11620.       }
    11621. 

  11621.       if ((i2 | 0) < 53) {
    11622. 

  11622.        d28 = +(i4 | 0);
    11623. 

  11623.        d30 = +_copysign(+(+_scalbn(1.0, 84 - i2 | 0)), +d28);
    11624. 

  11624.        if ((i2 | 0) < 32 & d14 != 0.0) {
    11625. 

  11625.         i29 = i17 & 1;
    11626. 

  11626.         i17 = (i29 ^ 1) + i17 | 0;
    11627. 

  11627.         d14 = (i29 | 0) == 0 ? 0.0 : d14;
    11628. 

  11628.        }
    11629. 

  11629.       } else {
    11630. 

  11630.        d28 = +(i4 | 0);
    11631. 

  11631.        d30 = 0.0;
    11632. 

  11632.       }
    11633. 

  11633.       d14 = d28 * d14 + (d30 + d28 * +(i17 >>> 0)) - d30;
    11634. 

  11634.       if (!(d14 != 0.0)) {
    11635. 

  11635.        HEAP32[(___errno_location() | 0) >> 2] = 34;
    11636. 

  11636.       }
    11637. 

  11637.       d31 = +_scalbnl(d14, i5);
    11638. 

  11638.       STACKTOP = i1;
    11639. 

  11639.       return +d31;
    11640. 

  11640.      }
    11641. 

  11641.     } while (0);
    11642. 

  11642.     i7 = i3 + i2 | 0;
    11643. 

  11643.     i6 = 0 - i7 | 0;
    11644. 

  11644.     i20 = 0;
    11645. 

  11645.     while (1) {
    11646. 

  11646.      if ((i21 | 0) == 46) {
    11647. 

  11647.       i13 = 139;
    11648. 

  11648.       break;
    11649. 

  11649.      } else if ((i21 | 0) != 48) {
    11650. 

  11650.       i25 = 0;
    11651. 

  11651.       i22 = 0;
    11652. 

  11652.       i19 = 0;
    11653. 

  11653.       break;
    11654. 

  11654.      }
    11655. 

  11655.      i15 = HEAP32[i9 >> 2] | 0;
    11656. 

  11656.      if (i15 >>> 0 < (HEAP32[i10 >> 2] | 0) >>> 0) {
    11657. 

  11657.       HEAP32[i9 >> 2] = i15 + 1;
    11658. 

  11658.       i21 = HEAPU8[i15] | 0;
    11659. 

  11659.       i20 = 1;
    11660. 

  11660.       continue;
    11661. 

  11661.      } else {
    11662. 

  11662.       i21 = ___shgetc(i8) | 0;
    11663. 

  11663.       i20 = 1;
    11664. 

  11664.       continue;
    11665. 

  11665.      }
    11666. 

  11666.     }
    11667. 

  11667.     L168 : do {
    11668. 

  11668.      if ((i13 | 0) == 139) {
    11669. 

  11669.       i15 = HEAP32[i9 >> 2] | 0;
    11670. 

  11670.       if (i15 >>> 0 < (HEAP32[i10 >> 2] | 0) >>> 0) {
    11671. 

  11671.        HEAP32[i9 >> 2] = i15 + 1;
    11672. 

  11672.        i21 = HEAPU8[i15] | 0;
    11673. 

  11673.       } else {
    11674. 

  11674.        i21 = ___shgetc(i8) | 0;
    11675. 

  11675.       }
    11676. 

  11676.       if ((i21 | 0) == 48) {
    11677. 

  11677.        i25 = -1;
    11678. 

  11678.        i22 = -1;
    11679. 

  11679.        while (1) {
    11680. 

  11680.         i15 = HEAP32[i9 >> 2] | 0;
    11681. 

  11681.         if (i15 >>> 0 < (HEAP32[i10 >> 2] | 0) >>> 0) {
    11682. 

  11682.          HEAP32[i9 >> 2] = i15 + 1;
    11683. 

  11683.          i21 = HEAPU8[i15] | 0;
    11684. 

  11684.         } else {
    11685. 

  11685.          i21 = ___shgetc(i8) | 0;
    11686. 

  11686.         }
    11687. 

  11687.         if ((i21 | 0) != 48) {
    11688. 

  11688.          i20 = 1;
    11689. 

  11689.          i19 = 1;
    11690. 

  11690.          break L168;
    11691. 

  11691.         }
    11692. 

  11692.         i29 = _i64Add(i25 | 0, i22 | 0, -1, -1) | 0;
    11693. 

  11693.         i25 = i29;
    11694. 

  11694.         i22 = tempRet0;
    11695. 

  11695.        }
    11696. 

  11696.       } else {
    11697. 

  11697.        i25 = 0;
    11698. 

  11698.        i22 = 0;
    11699. 

  11699.        i19 = 1;
    11700. 

  11700.       }
    11701. 

  11701.      }
    11702. 

  11702.     } while (0);
    11703. 

  11703.     HEAP32[i5 >> 2] = 0;
    11704. 

  11704.     i26 = i21 + -48 | 0;
    11705. 

  11705.     i27 = (i21 | 0) == 46;
    11706. 

  11706.     L182 : do {
    11707. 

  11707.      if (i26 >>> 0 < 10 | i27) {
    11708. 

  11708.       i15 = i5 + 496 | 0;
    11709. 

  11709.       i24 = 0;
    11710. 

  11710.       i23 = 0;
    11711. 

  11711.       i18 = 0;
    11712. 

  11712.       i17 = 0;
    11713. 

  11713.       i16 = 0;
    11714. 

  11714.       while (1) {
    11715. 

  11715.        do {
    11716. 

  11716.         if (i27) {
    11717. 

  11717.          if ((i19 | 0) == 0) {
    11718. 

  11718.           i25 = i24;
    11719. 

  11719.           i22 = i23;
    11720. 

  11720.           i19 = 1;
    11721. 

  11721.          } else {
    11722. 

  11722.           break L182;
    11723. 

  11723.          }
    11724. 

  11724.         } else {
    11725. 

  11725.          i27 = _i64Add(i24 | 0, i23 | 0, 1, 0) | 0;
    11726. 

  11726.          i23 = tempRet0;
    11727. 

  11727.          i29 = (i21 | 0) != 48;
    11728. 

  11728.          if ((i17 | 0) >= 125) {
    11729. 

  11729.           if (!i29) {
    11730. 

  11730.            i24 = i27;
    11731. 

  11731.            break;
    11732. 

  11732.           }
    11733. 

  11733.           HEAP32[i15 >> 2] = HEAP32[i15 >> 2] | 1;
    11734. 

  11734.           i24 = i27;
    11735. 

  11735.           break;
    11736. 

  11736.          }
    11737. 

  11737.          i20 = i5 + (i17 << 2) | 0;
    11738. 

  11738.          if ((i18 | 0) != 0) {
    11739. 

  11739.           i26 = i21 + -48 + ((HEAP32[i20 >> 2] | 0) * 10 | 0) | 0;
    11740. 

  11740.          }
    11741. 

  11741.          HEAP32[i20 >> 2] = i26;
    11742. 

  11742.          i18 = i18 + 1 | 0;
    11743. 

  11743.          i21 = (i18 | 0) == 9;
    11744. 

  11744.          i24 = i27;
    11745. 

  11745.          i20 = 1;
    11746. 

  11746.          i18 = i21 ? 0 : i18;
    11747. 

  11747.          i17 = (i21 & 1) + i17 | 0;
    11748. 

  11748.          i16 = i29 ? i27 : i16;
    11749. 

  11749.         }
    11750. 

  11750.        } while (0);
    11751. 

  11751.        i21 = HEAP32[i9 >> 2] | 0;
    11752. 

  11752.        if (i21 >>> 0 < (HEAP32[i10 >> 2] | 0) >>> 0) {
    11753. 

  11753.         HEAP32[i9 >> 2] = i21 + 1;
    11754. 

  11754.         i21 = HEAPU8[i21] | 0;
    11755. 

  11755.        } else {
    11756. 

  11756.         i21 = ___shgetc(i8) | 0;
    11757. 

  11757.        }
    11758. 

  11758.        i26 = i21 + -48 | 0;
    11759. 

  11759.        i27 = (i21 | 0) == 46;
    11760. 

  11760.        if (!(i26 >>> 0 < 10 | i27)) {
    11761. 

  11761.         i13 = 162;
    11762. 

  11762.         break;
    11763. 

  11763.        }
    11764. 

  11764.       }
    11765. 

  11765.      } else {
    11766. 

  11766.       i24 = 0;
    11767. 

  11767.       i23 = 0;
    11768. 

  11768.       i18 = 0;
    11769. 

  11769.       i17 = 0;
    11770. 

  11770.       i16 = 0;
    11771. 

  11771.       i13 = 162;
    11772. 

  11772.      }
    11773. 

  11773.     } while (0);
    11774. 

  11774.     if ((i13 | 0) == 162) {
    11775. 

  11775.      i13 = (i19 | 0) == 0;
    11776. 

  11776.      i25 = i13 ? i24 : i25;
    11777. 

  11777.      i22 = i13 ? i23 : i22;
    11778. 

  11778.     }
    11779. 

  11779.     i13 = (i20 | 0) != 0;
    11780. 

  11780.     if (i13 ? (i21 | 32 | 0) == 101 : 0) {
    11781. 

  11781.      i15 = _scanexp(i8, i11) | 0;
    11782. 

  11782.      i11 = tempRet0;
    11783. 

  11783.      do {
    11784. 

  11784.       if ((i15 | 0) == 0 & (i11 | 0) == -2147483648) {
    11785. 

  11785.        if (i12) {
    11786. 

  11786.         ___shlim(i8, 0);
    11787. 

  11787.         d31 = 0.0;
    11788. 

  11788.         STACKTOP = i1;
    11789. 

  11789.         return +d31;
    11790. 

  11790.        } else {
    11791. 

  11791.         if ((HEAP32[i10 >> 2] | 0) == 0) {
    11792. 

  11792.          i15 = 0;
    11793. 

  11793.          i11 = 0;
    11794. 

  11794.          break;
    11795. 

  11795.         }
    11796. 

  11796.         HEAP32[i9 >> 2] = (HEAP32[i9 >> 2] | 0) + -1;
    11797. 

  11797.         i15 = 0;
    11798. 

  11798.         i11 = 0;
    11799. 

  11799.         break;
    11800. 

  11800.        }
    11801. 

  11801.       }
    11802. 

  11802.      } while (0);
    11803. 

  11803.      i9 = _i64Add(i15 | 0, i11 | 0, i25 | 0, i22 | 0) | 0;
    11804. 

  11804.      i22 = tempRet0;
    11805. 

  11805.     } else {
    11806. 

  11806.      if ((i21 | 0) > -1 ? (HEAP32[i10 >> 2] | 0) != 0 : 0) {
    11807. 

  11807.       HEAP32[i9 >> 2] = (HEAP32[i9 >> 2] | 0) + -1;
    11808. 

  11808.       i9 = i25;
    11809. 

  11809.      } else {
    11810. 

  11810.       i9 = i25;
    11811. 

  11811.      }
    11812. 

  11812.     }
    11813. 

  11813.     if (!i13) {
    11814. 

  11814.      HEAP32[(___errno_location() | 0) >> 2] = 22;
    11815. 

  11815.      ___shlim(i8, 0);
    11816. 

  11816.      d31 = 0.0;
    11817. 

  11817.      STACKTOP = i1;
    11818. 

  11818.      return +d31;
    11819. 

  11819.     }
    11820. 

  11820.     i8 = HEAP32[i5 >> 2] | 0;
    11821. 

  11821.     if ((i8 | 0) == 0) {
    11822. 

  11822.      d31 = +(i4 | 0) * 0.0;
    11823. 

  11823.      STACKTOP = i1;
    11824. 

  11824.      return +d31;
    11825. 

  11825.     }
    11826. 

  11826.     do {
    11827. 

  11827.      if ((i9 | 0) == (i24 | 0) & (i22 | 0) == (i23 | 0) & ((i23 | 0) < 0 | (i23 | 0) == 0 & i24 >>> 0 < 10)) {
    11828. 

  11828.       if (!(i2 >>> 0 > 30) ? (i8 >>> i2 | 0) != 0 : 0) {
    11829. 

  11829.        break;
    11830. 

  11830.       }
    11831. 

  11831.       d31 = +(i4 | 0) * +(i8 >>> 0);
    11832. 

  11832.       STACKTOP = i1;
    11833. 

  11833.       return +d31;
    11834. 

  11834.      }
    11835. 

  11835.     } while (0);
    11836. 

  11836.     i29 = (i3 | 0) / -2 | 0;
    11837. 

  11837.     i27 = ((i29 | 0) < 0) << 31 >> 31;
    11838. 

  11838.     if ((i22 | 0) > (i27 | 0) | (i22 | 0) == (i27 | 0) & i9 >>> 0 > i29 >>> 0) {
    11839. 

  11839.      HEAP32[(___errno_location() | 0) >> 2] = 34;
    11840. 

  11840.      d31 = +(i4 | 0) * 1.7976931348623157e+308 * 1.7976931348623157e+308;
    11841. 

  11841.      STACKTOP = i1;
    11842. 

  11842.      return +d31;
    11843. 

  11843.     }
    11844. 

  11844.     i29 = i3 + -106 | 0;
    11845. 

  11845.     i27 = ((i29 | 0) < 0) << 31 >> 31;
    11846. 

  11846.     if ((i22 | 0) < (i27 | 0) | (i22 | 0) == (i27 | 0) & i9 >>> 0 < i29 >>> 0) {
    11847. 

  11847.      HEAP32[(___errno_location() | 0) >> 2] = 34;
    11848. 

  11848.      d31 = +(i4 | 0) * 2.2250738585072014e-308 * 2.2250738585072014e-308;
    11849. 

  11849.      STACKTOP = i1;
    11850. 

  11850.      return +d31;
    11851. 

  11851.     }
    11852. 

  11852.     if ((i18 | 0) != 0) {
    11853. 

  11853.      if ((i18 | 0) < 9) {
    11854. 

  11854.       i8 = i5 + (i17 << 2) | 0;
    11855. 

  11855.       i10 = HEAP32[i8 >> 2] | 0;
    11856. 

  11856.       do {
    11857. 

  11857.        i10 = i10 * 10 | 0;
    11858. 

  11858.        i18 = i18 + 1 | 0;
    11859. 

  11859.       } while ((i18 | 0) != 9);
    11860. 

  11860.       HEAP32[i8 >> 2] = i10;
    11861. 

  11861.      }
    11862. 

  11862.      i17 = i17 + 1 | 0;
    11863. 

  11863.     }
    11864. 

  11864.     do {
    11865. 

  11865.      if ((i16 | 0) < 9 ? (i16 | 0) <= (i9 | 0) & (i9 | 0) < 18 : 0) {
    11866. 

  11866.       if ((i9 | 0) == 9) {
    11867. 

  11867.        d31 = +(i4 | 0) * +((HEAP32[i5 >> 2] | 0) >>> 0);
    11868. 

  11868.        STACKTOP = i1;
    11869. 

  11869.        return +d31;
    11870. 

  11870.       }
    11871. 

  11871.       if ((i9 | 0) < 9) {
    11872. 

  11872.        d31 = +(i4 | 0) * +((HEAP32[i5 >> 2] | 0) >>> 0) / +(HEAP32[13440 + (8 - i9 << 2) >> 2] | 0);
    11873. 

  11873.        STACKTOP = i1;
    11874. 

  11874.        return +d31;
    11875. 

  11875.       }
    11876. 

  11876.       i10 = i2 + 27 + (Math_imul(i9, -3) | 0) | 0;
    11877. 

  11877.       i8 = HEAP32[i5 >> 2] | 0;
    11878. 

  11878.       if ((i10 | 0) <= 30 ? (i8 >>> i10 | 0) != 0 : 0) {
    11879. 

  11879.        break;
    11880. 

  11880.       }
    11881. 

  11881.       d31 = +(i4 | 0) * +(i8 >>> 0) * +(HEAP32[13440 + (i9 + -10 << 2) >> 2] | 0);
    11882. 

  11882.       STACKTOP = i1;
    11883. 

  11883.       return +d31;
    11884. 

  11884.      }
    11885. 

  11885.     } while (0);
    11886. 

  11886.     i8 = (i9 | 0) % 9 | 0;
    11887. 

  11887.     if ((i8 | 0) == 0) {
    11888. 

  11888.      i8 = 0;
    11889. 

  11889.      i10 = 0;
    11890. 

  11890.     } else {
    11891. 

  11891.      i11 = (i9 | 0) > -1 ? i8 : i8 + 9 | 0;
    11892. 

  11892.      i12 = HEAP32[13440 + (8 - i11 << 2) >> 2] | 0;
    11893. 

  11893.      if ((i17 | 0) != 0) {
    11894. 

  11894.       i10 = 1e9 / (i12 | 0) | 0;
    11895. 

  11895.       i8 = 0;
    11896. 

  11896.       i16 = 0;
    11897. 

  11897.       i15 = 0;
    11898. 

  11898.       while (1) {
    11899. 

  11899.        i27 = i5 + (i15 << 2) | 0;
    11900. 

  11900.        i13 = HEAP32[i27 >> 2] | 0;
    11901. 

  11901.        i29 = ((i13 >>> 0) / (i12 >>> 0) | 0) + i16 | 0;
    11902. 

  11902.        HEAP32[i27 >> 2] = i29;
    11903. 

  11903.        i16 = Math_imul((i13 >>> 0) % (i12 >>> 0) | 0, i10) | 0;
    11904. 

  11904.        i13 = i15 + 1 | 0;
    11905. 

  11905.        if ((i15 | 0) == (i8 | 0) & (i29 | 0) == 0) {
    11906. 

  11906.         i8 = i13 & 127;
    11907. 

  11907.         i9 = i9 + -9 | 0;
    11908. 

  11908.        }
    11909. 

  11909.        if ((i13 | 0) == (i17 | 0)) {
    11910. 

  11910.         break;
    11911. 

  11911.        } else {
    11912. 

  11912.         i15 = i13;
    11913. 

  11913.        }
    11914. 

  11914.       }
    11915. 

  11915.       if ((i16 | 0) != 0) {
    11916. 

  11916.        HEAP32[i5 + (i17 << 2) >> 2] = i16;
    11917. 

  11917.        i17 = i17 + 1 | 0;
    11918. 

  11918.       }
    11919. 

  11919.      } else {
    11920. 

  11920.       i8 = 0;
    11921. 

  11921.       i17 = 0;
    11922. 

  11922.      }
    11923. 

  11923.      i10 = 0;
    11924. 

  11924.      i9 = 9 - i11 + i9 | 0;
    11925. 

  11925.     }
    11926. 

  11926.     L280 : while (1) {
    11927. 

  11927.      i11 = i5 + (i8 << 2) | 0;
    11928. 

  11928.      if ((i9 | 0) < 18) {
    11929. 

  11929.       do {
    11930. 

  11930.        i13 = 0;
    11931. 

  11931.        i11 = i17 + 127 | 0;
    11932. 

  11932.        while (1) {
    11933. 

  11933.         i11 = i11 & 127;
    11934. 

  11934.         i12 = i5 + (i11 << 2) | 0;
    11935. 

  11935.         i15 = _bitshift64Shl(HEAP32[i12 >> 2] | 0, 0, 29) | 0;
    11936. 

  11936.         i15 = _i64Add(i15 | 0, tempRet0 | 0, i13 | 0, 0) | 0;
    11937. 

  11937.         i13 = tempRet0;
    11938. 

  11938.         if (i13 >>> 0 > 0 | (i13 | 0) == 0 & i15 >>> 0 > 1e9) {
    11939. 

  11939.          i29 = ___udivdi3(i15 | 0, i13 | 0, 1e9, 0) | 0;
    11940. 

  11940.          i15 = ___uremdi3(i15 | 0, i13 | 0, 1e9, 0) | 0;
    11941. 

  11941.          i13 = i29;
    11942. 

  11942.         } else {
    11943. 

  11943.          i13 = 0;
    11944. 

  11944.         }
    11945. 

  11945.         HEAP32[i12 >> 2] = i15;
    11946. 

  11946.         i12 = (i11 | 0) == (i8 | 0);
    11947. 

  11947.         if (!((i11 | 0) != (i17 + 127 & 127 | 0) | i12)) {
    11948. 

  11948.          i17 = (i15 | 0) == 0 ? i11 : i17;
    11949. 

  11949.         }
    11950. 

  11950.         if (i12) {
    11951. 

  11951.          break;
    11952. 

  11952.         } else {
    11953. 

  11953.          i11 = i11 + -1 | 0;
    11954. 

  11954.         }
    11955. 

  11955.        }
    11956. 

  11956.        i10 = i10 + -29 | 0;
    11957. 

  11957.       } while ((i13 | 0) == 0);
    11958. 

  11958.      } else {
    11959. 

  11959.       if ((i9 | 0) != 18) {
    11960. 

  11960.        break;
    11961. 

  11961.       }
    11962. 

  11962.       do {
    11963. 

  11963.        if (!((HEAP32[i11 >> 2] | 0) >>> 0 < 9007199)) {
    11964. 

  11964.         i9 = 18;
    11965. 

  11965.         break L280;
    11966. 

  11966.        }
    11967. 

  11967.        i13 = 0;
    11968. 

  11968.        i12 = i17 + 127 | 0;
    11969. 

  11969.        while (1) {
    11970. 

  11970.         i12 = i12 & 127;
    11971. 

  11971.         i15 = i5 + (i12 << 2) | 0;
    11972. 

  11972.         i16 = _bitshift64Shl(HEAP32[i15 >> 2] | 0, 0, 29) | 0;
    11973. 

  11973.         i16 = _i64Add(i16 | 0, tempRet0 | 0, i13 | 0, 0) | 0;
    11974. 

  11974.         i13 = tempRet0;
    11975. 

  11975.         if (i13 >>> 0 > 0 | (i13 | 0) == 0 & i16 >>> 0 > 1e9) {
    11976. 

  11976.          i29 = ___udivdi3(i16 | 0, i13 | 0, 1e9, 0) | 0;
    11977. 

  11977.          i16 = ___uremdi3(i16 | 0, i13 | 0, 1e9, 0) | 0;
    11978. 

  11978.          i13 = i29;
    11979. 

  11979.         } else {
    11980. 

  11980.          i13 = 0;
    11981. 

  11981.         }
    11982. 

  11982.         HEAP32[i15 >> 2] = i16;
    11983. 

  11983.         i15 = (i12 | 0) == (i8 | 0);
    11984. 

  11984.         if (!((i12 | 0) != (i17 + 127 & 127 | 0) | i15)) {
    11985. 

  11985.          i17 = (i16 | 0) == 0 ? i12 : i17;
    11986. 

  11986.         }
    11987. 

  11987.         if (i15) {
    11988. 

  11988.          break;
    11989. 

  11989.         } else {
    11990. 

  11990.          i12 = i12 + -1 | 0;
    11991. 

  11991.         }
    11992. 

  11992.        }
    11993. 

  11993.        i10 = i10 + -29 | 0;
    11994. 

  11994.       } while ((i13 | 0) == 0);
    11995. 

  11995.      }
    11996. 

  11996.      i8 = i8 + 127 & 127;
    11997. 

  11997.      if ((i8 | 0) == (i17 | 0)) {
    11998. 

  11998.       i29 = i17 + 127 & 127;
    11999. 

  11999.       i17 = i5 + ((i17 + 126 & 127) << 2) | 0;
    12000. 

  12000.       HEAP32[i17 >> 2] = HEAP32[i17 >> 2] | HEAP32[i5 + (i29 << 2) >> 2];
    12001. 

  12001.       i17 = i29;
    12002. 

  12002.      }
    12003. 

  12003.      HEAP32[i5 + (i8 << 2) >> 2] = i13;
    12004. 

  12004.      i9 = i9 + 9 | 0;
    12005. 

  12005.     }
    12006. 

  12006.     L311 : while (1) {
    12007. 

  12007.      i11 = i17 + 1 & 127;
    12008. 

  12008.      i12 = i5 + ((i17 + 127 & 127) << 2) | 0;
    12009. 

  12009.      while (1) {
    12010. 

  12010.       i15 = (i9 | 0) == 18;
    12011. 

  12011.       i13 = (i9 | 0) > 27 ? 9 : 1;
    12012. 

  12012.       while (1) {
    12013. 

  12013.        i16 = 0;
    12014. 

  12014.        while (1) {
    12015. 

  12015.         i18 = i16 + i8 & 127;
    12016. 

  12016.         if ((i18 | 0) == (i17 | 0)) {
    12017. 

  12017.          i16 = 2;
    12018. 

  12018.          break;
    12019. 

  12019.         }
    12020. 

  12020.         i18 = HEAP32[i5 + (i18 << 2) >> 2] | 0;
    12021. 

  12021.         i19 = HEAP32[13432 + (i16 << 2) >> 2] | 0;
    12022. 

  12022.         if (i18 >>> 0 < i19 >>> 0) {
    12023. 

  12023.          i16 = 2;
    12024. 

  12024.          break;
    12025. 

  12025.         }
    12026. 

  12026.         i20 = i16 + 1 | 0;
    12027. 

  12027.         if (i18 >>> 0 > i19 >>> 0) {
    12028. 

  12028.          break;
    12029. 

  12029.         }
    12030. 

  12030.         if ((i20 | 0) < 2) {
    12031. 

  12031.          i16 = i20;
    12032. 

  12032.         } else {
    12033. 

  12033.          i16 = i20;
    12034. 

  12034.          break;
    12035. 

  12035.         }
    12036. 

  12036.        }
    12037. 

  12037.        if ((i16 | 0) == 2 & i15) {
    12038. 

  12038.         break L311;
    12039. 

  12039.        }
    12040. 

  12040.        i10 = i13 + i10 | 0;
    12041. 

  12041.        if ((i8 | 0) == (i17 | 0)) {
    12042. 

  12042.         i8 = i17;
    12043. 

  12043.        } else {
    12044. 

  12044.         break;
    12045. 

  12045.        }
    12046. 

  12046.       }
    12047. 

  12047.       i15 = (1 << i13) + -1 | 0;
    12048. 

  12048.       i19 = 1e9 >>> i13;
    12049. 

  12049.       i18 = i8;
    12050. 

  12050.       i16 = 0;
    12051. 

  12051.       do {
    12052. 

  12052.        i27 = i5 + (i8 << 2) | 0;
    12053. 

  12053.        i29 = HEAP32[i27 >> 2] | 0;
    12054. 

  12054.        i20 = (i29 >>> i13) + i16 | 0;
    12055. 

  12055.        HEAP32[i27 >> 2] = i20;
    12056. 

  12056.        i16 = Math_imul(i29 & i15, i19) | 0;
    12057. 

  12057.        i20 = (i8 | 0) == (i18 | 0) & (i20 | 0) == 0;
    12058. 

  12058.        i8 = i8 + 1 & 127;
    12059. 

  12059.        i9 = i20 ? i9 + -9 | 0 : i9;
    12060. 

  12060.        i18 = i20 ? i8 : i18;
    12061. 

  12061.       } while ((i8 | 0) != (i17 | 0));
    12062. 

  12062.       if ((i16 | 0) == 0) {
    12063. 

  12063.        i8 = i18;
    12064. 

  12064.        continue;
    12065. 

  12065.       }
    12066. 

  12066.       if ((i11 | 0) != (i18 | 0)) {
    12067. 

  12067.        break;
    12068. 

  12068.       }
    12069. 

  12069.       HEAP32[i12 >> 2] = HEAP32[i12 >> 2] | 1;
    12070. 

  12070.       i8 = i18;
    12071. 

  12071.      }
    12072. 

  12072.      HEAP32[i5 + (i17 << 2) >> 2] = i16;
    12073. 

  12073.      i8 = i18;
    12074. 

  12074.      i17 = i11;
    12075. 

  12075.     }
    12076. 

  12076.     i9 = i8 & 127;
    12077. 

  12077.     if ((i9 | 0) == (i17 | 0)) {
    12078. 

  12078.      HEAP32[i5 + (i11 + -1 << 2) >> 2] = 0;
    12079. 

  12079.      i17 = i11;
    12080. 

  12080.     }
    12081. 

  12081.     d28 = +((HEAP32[i5 + (i9 << 2) >> 2] | 0) >>> 0);
    12082. 

  12082.     i9 = i8 + 1 & 127;
    12083. 

  12083.     if ((i9 | 0) == (i17 | 0)) {
    12084. 

  12084.      i17 = i17 + 1 & 127;
    12085. 

  12085.      HEAP32[i5 + (i17 + -1 << 2) >> 2] = 0;
    12086. 

  12086.     }
    12087. 

  12087.     d14 = +(i4 | 0);
    12088. 

  12088.     d30 = d14 * (d28 * 1.0e9 + +((HEAP32[i5 + (i9 << 2) >> 2] | 0) >>> 0));
    12089. 

  12089.     i4 = i10 + 53 | 0;
    12090. 

  12090.     i3 = i4 - i3 | 0;
    12091. 

  12091.     if ((i3 | 0) < (i2 | 0)) {
    12092. 

  12092.      i2 = (i3 | 0) < 0 ? 0 : i3;
    12093. 

  12093.      i9 = 1;
    12094. 

  12094.     } else {
    12095. 

  12095.      i9 = 0;
    12096. 

  12096.     }
    12097. 

  12097.     if ((i2 | 0) < 53) {
    12098. 

  12098.      d33 = +_copysign(+(+_scalbn(1.0, 105 - i2 | 0)), +d30);
    12099. 

  12099.      d32 = +_fmod(+d30, +(+_scalbn(1.0, 53 - i2 | 0)));
    12100. 

  12100.      d28 = d33;
    12101. 

  12101.      d31 = d32;
    12102. 

  12102.      d30 = d33 + (d30 - d32);
    12103. 

  12103.     } else {
    12104. 

  12104.      d28 = 0.0;
    12105. 

  12105.      d31 = 0.0;
    12106. 

  12106.     }
    12107. 

  12107.     i11 = i8 + 2 & 127;
    12108. 

  12108.     if ((i11 | 0) != (i17 | 0)) {
    12109. 

  12109.      i5 = HEAP32[i5 + (i11 << 2) >> 2] | 0;
    12110. 

  12110.      do {
    12111. 

  12111.       if (!(i5 >>> 0 < 5e8)) {
    12112. 

  12112.        if (i5 >>> 0 > 5e8) {
    12113. 

  12113.         d31 = d14 * .75 + d31;
    12114. 

  12114.         break;
    12115. 

  12115.        }
    12116. 

  12116.        if ((i8 + 3 & 127 | 0) == (i17 | 0)) {
    12117. 

  12117.         d31 = d14 * .5 + d31;
    12118. 

  12118.         break;
    12119. 

  12119.        } else {
    12120. 

  12120.         d31 = d14 * .75 + d31;
    12121. 

  12121.         break;
    12122. 

  12122.        }
    12123. 

  12123.       } else {
    12124. 

  12124.        if ((i5 | 0) == 0 ? (i8 + 3 & 127 | 0) == (i17 | 0) : 0) {
    12125. 

  12125.         break;
    12126. 

  12126.        }
    12127. 

  12127.        d31 = d14 * .25 + d31;
    12128. 

  12128.       }
    12129. 

  12129.      } while (0);
    12130. 

  12130.      if ((53 - i2 | 0) > 1 ? !(+_fmod(+d31, 1.0) != 0.0) : 0) {
    12131. 

  12131.       d31 = d31 + 1.0;
    12132. 

  12132.      }
    12133. 

  12133.     }
    12134. 

  12134.     d14 = d30 + d31 - d28;
    12135. 

  12135.     do {
    12136. 

  12136.      if ((i4 & 2147483647 | 0) > (-2 - i7 | 0)) {
    12137. 

  12137.       if (+Math_abs(+d14) >= 9007199254740992.0) {
    12138. 

  12138.        i9 = (i9 | 0) != 0 & (i2 | 0) == (i3 | 0) ? 0 : i9;
    12139. 

  12139.        i10 = i10 + 1 | 0;
    12140. 

  12140.        d14 = d14 * .5;
    12141. 

  12141.       }
    12142. 

  12142.       if ((i10 + 50 | 0) <= (i6 | 0) ? !((i9 | 0) != 0 & d31 != 0.0) : 0) {
    12143. 

  12143.        break;
    12144. 

  12144.       }
    12145. 

  12145.       HEAP32[(___errno_location() | 0) >> 2] = 34;
    12146. 

  12146.      }
    12147. 

  12147.     } while (0);
    12148. 

  12148.     d33 = +_scalbnl(d14, i10);
    12149. 

  12149.     STACKTOP = i1;
    12150. 

  12150.     return +d33;
    12151. 

  12151.    } else if ((i7 | 0) == 3) {
    12152. 

  12152.     i2 = HEAP32[i9 >> 2] | 0;
    12153. 

  12153.     if (i2 >>> 0 < (HEAP32[i10 >> 2] | 0) >>> 0) {
    12154. 

  12154.      HEAP32[i9 >> 2] = i2 + 1;
    12155. 

  12155.      i2 = HEAPU8[i2] | 0;
    12156. 

  12156.     } else {
    12157. 

  12157.      i2 = ___shgetc(i8) | 0;
    12158. 

  12158.     }
    12159. 

  12159.     if ((i2 | 0) == 40) {
    12160. 

  12160.      i2 = 1;
    12161. 

  12161.     } else {
    12162. 

  12162.      if ((HEAP32[i10 >> 2] | 0) == 0) {
    12163. 

  12163.       d33 = nan;
    12164. 

  12164.       STACKTOP = i1;
    12165. 

  12165.       return +d33;
    12166. 

  12166.      }
    12167. 

  12167.      HEAP32[i9 >> 2] = (HEAP32[i9 >> 2] | 0) + -1;
    12168. 

  12168.      d33 = nan;
    12169. 

  12169.      STACKTOP = i1;
    12170. 

  12170.      return +d33;
    12171. 

  12171.     }
    12172. 

  12172.     while (1) {
    12173. 

  12173.      i3 = HEAP32[i9 >> 2] | 0;
    12174. 

  12174.      if (i3 >>> 0 < (HEAP32[i10 >> 2] | 0) >>> 0) {
    12175. 

  12175.       HEAP32[i9 >> 2] = i3 + 1;
    12176. 

  12176.       i3 = HEAPU8[i3] | 0;
    12177. 

  12177.      } else {
    12178. 

  12178.       i3 = ___shgetc(i8) | 0;
    12179. 

  12179.      }
    12180. 

  12180.      if (!((i3 + -48 | 0) >>> 0 < 10 | (i3 + -65 | 0) >>> 0 < 26) ? !((i3 + -97 | 0) >>> 0 < 26 | (i3 | 0) == 95) : 0) {
    12181. 

  12181.       break;
    12182. 

  12182.      }
    12183. 

  12183.      i2 = i2 + 1 | 0;
    12184. 

  12184.     }
    12185. 

  12185.     if ((i3 | 0) == 41) {
    12186. 

  12186.      d33 = nan;
    12187. 

  12187.      STACKTOP = i1;
    12188. 

  12188.      return +d33;
    12189. 

  12189.     }
    12190. 

  12190.     i3 = (HEAP32[i10 >> 2] | 0) == 0;
    12191. 

  12191.     if (!i3) {
    12192. 

  12192.      HEAP32[i9 >> 2] = (HEAP32[i9 >> 2] | 0) + -1;
    12193. 

  12193.     }
    12194. 

  12194.     if (i12) {
    12195. 

  12195.      HEAP32[(___errno_location() | 0) >> 2] = 22;
    12196. 

  12196.      ___shlim(i8, 0);
    12197. 

  12197.      d33 = 0.0;
    12198. 

  12198.      STACKTOP = i1;
    12199. 

  12199.      return +d33;
    12200. 

  12200.     }
    12201. 

  12201.     if ((i2 | 0) == 0 | i3) {
    12202. 

  12202.      d33 = nan;
    12203. 

  12203.      STACKTOP = i1;
    12204. 

  12204.      return +d33;
    12205. 

  12205.     }
    12206. 

  12206.     while (1) {
    12207. 

  12207.      i2 = i2 + -1 | 0;
    12208. 

  12208.      HEAP32[i9 >> 2] = (HEAP32[i9 >> 2] | 0) + -1;
    12209. 

  12209.      if ((i2 | 0) == 0) {
    12210. 

  12210.       d14 = nan;
    12211. 

  12211.       break;
    12212. 

  12212.      }
    12213. 

  12213.     }
    12214. 

  12214.     STACKTOP = i1;
    12215. 

  12215.     return +d14;
    12216. 

  12216.    } else {
    12217. 

  12217.     if ((HEAP32[i10 >> 2] | 0) != 0) {
    12218. 

  12218.      HEAP32[i9 >> 2] = (HEAP32[i9 >> 2] | 0) + -1;
    12219. 

  12219.     }
    12220. 

  12220.     HEAP32[(___errno_location() | 0) >> 2] = 22;
    12221. 

  12221.     ___shlim(i8, 0);
    12222. 

  12222.     d33 = 0.0;
    12223. 

  12223.     STACKTOP = i1;
    12224. 

  12224.     return +d33;
    12225. 

  12225.    }
    12226. 

  12226.   }
    12227. 

  12227.  } while (0);
    12228. 

  12228.  if ((i13 | 0) == 23) {
    12229. 

  12229.   i2 = (HEAP32[i10 >> 2] | 0) == 0;
    12230. 

  12230.   if (!i2) {
    12231. 

  12231.    HEAP32[i9 >> 2] = (HEAP32[i9 >> 2] | 0) + -1;
    12232. 

  12232.   }
    12233. 

  12233.   if (!(i7 >>> 0 < 4 | (i11 | 0) == 0 | i2)) {
    12234. 

  12234.    do {
    12235. 

  12235.     HEAP32[i9 >> 2] = (HEAP32[i9 >> 2] | 0) + -1;
    12236. 

  12236.     i7 = i7 + -1 | 0;
    12237. 

  12237.    } while (i7 >>> 0 > 3);
    12238. 

  12238.   }
    12239. 

  12239.  }
    12240. 

  12240.  d33 = +(i4 | 0) * inf;
    12241. 

  12241.  STACKTOP = i1;
    12242. 

  12242.  return +d33;
    12243. 

  12243. }
    12244. 

  12244. function _statement(i4) {
    12245. 

  12245.  i4 = i4 | 0;
    12246. 

  12246.  var i1 = 0, i2 = 0, i3 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0, i14 = 0, i15 = 0, i16 = 0, i17 = 0, i18 = 0, i19 = 0, i20 = 0, i21 = 0, i22 = 0, i23 = 0, i24 = 0, i25 = 0, i26 = 0, i27 = 0, i28 = 0, i29 = 0;
    12247. 

  12247.  i2 = STACKTOP;
    12248. 

  12248.  STACKTOP = STACKTOP + 160 | 0;
    12249. 

  12249.  i8 = i2 + 120 | 0;
    12250. 

  12250.  i24 = i2 + 96 | 0;
    12251. 

  12251.  i15 = i2 + 72 | 0;
    12252. 

  12252.  i25 = i2 + 48 | 0;
    12253. 

  12253.  i20 = i2 + 24 | 0;
    12254. 

  12254.  i21 = i2;
    12255. 

  12255.  i19 = i4 + 4 | 0;
    12256. 

  12256.  i6 = HEAP32[i19 >> 2] | 0;
    12257. 

  12257.  i3 = i4 + 48 | 0;
    12258. 

  12258.  i9 = HEAP32[i3 >> 2] | 0;
    12259. 

  12259.  i1 = i4 + 52 | 0;
    12260. 

  12260.  i26 = (HEAP32[i1 >> 2] | 0) + 38 | 0;
    12261. 

  12261.  i27 = (HEAP16[i26 >> 1] | 0) + 1 << 16 >> 16;
    12262. 

  12262.  HEAP16[i26 >> 1] = i27;
    12263. 

  12263.  if ((i27 & 65535) > 200) {
    12264. 

  12264.   i27 = i9 + 12 | 0;
    12265. 

  12265.   i26 = HEAP32[(HEAP32[i27 >> 2] | 0) + 52 >> 2] | 0;
    12266. 

  12266.   i5 = HEAP32[(HEAP32[i9 >> 2] | 0) + 64 >> 2] | 0;
    12267. 

  12267.   if ((i5 | 0) == 0) {
    12268. 

  12268.    i29 = 6552;
    12269. 

  12269.    HEAP32[i8 >> 2] = 6360;
    12270. 

  12270.    i28 = i8 + 4 | 0;
    12271. 

  12271.    HEAP32[i28 >> 2] = 200;
    12272. 

  12272.    i28 = i8 + 8 | 0;
    12273. 

  12273.    HEAP32[i28 >> 2] = i29;
    12274. 

  12274.    i28 = _luaO_pushfstring(i26, 6592, i8) | 0;
    12275. 

  12275.    i29 = HEAP32[i27 >> 2] | 0;
    12276. 

  12276.    _luaX_syntaxerror(i29, i28);
    12277. 

  12277.   }
    12278. 

  12278.   HEAP32[i8 >> 2] = i5;
    12279. 

  12279.   i28 = _luaO_pushfstring(i26, 6568, i8) | 0;
    12280. 

  12280.   HEAP32[i8 >> 2] = 6360;
    12281. 

  12281.   i29 = i8 + 4 | 0;
    12282. 

  12282.   HEAP32[i29 >> 2] = 200;
    12283. 

  12283.   i29 = i8 + 8 | 0;
    12284. 

  12284.   HEAP32[i29 >> 2] = i28;
    12285. 

  12285.   i29 = _luaO_pushfstring(i26, 6592, i8) | 0;
    12286. 

  12286.   i28 = HEAP32[i27 >> 2] | 0;
    12287. 

  12287.   _luaX_syntaxerror(i28, i29);
    12288. 

  12288.  }
    12289. 

  12289.  i5 = i4 + 16 | 0;
    12290. 

  12290.  L8 : do {
    12291. 

  12291.   switch (HEAP32[i5 >> 2] | 0) {
    12292. 

  12292.   case 59:
    12293. 

  12293.    {
    12294. 

  12294.     _luaX_next(i4);
    12295. 

  12295.     break;
    12296. 

  12296.    }
    12297. 

  12297.   case 267:
    12298. 

  12298.    {
    12299. 

  12299.     HEAP32[i21 >> 2] = -1;
    12300. 

  12300.     _test_then_block(i4, i21);
    12301. 

  12301.     while (1) {
    12302. 

  12302.      i8 = HEAP32[i5 >> 2] | 0;
    12303. 

  12303.      if ((i8 | 0) == 260) {
    12304. 

  12304.       i7 = 10;
    12305. 

  12305.       break;
    12306. 

  12306.      } else if ((i8 | 0) != 261) {
    12307. 

  12307.       break;
    12308. 

  12308.      }
    12309. 

  12309.      _test_then_block(i4, i21);
    12310. 

  12310.     }
    12311. 

  12311.     if ((i7 | 0) == 10) {
    12312. 

  12312.      _luaX_next(i4);
    12313. 

  12313.      i7 = HEAP32[i3 >> 2] | 0;
    12314. 

  12314.      HEAP8[i20 + 10 | 0] = 0;
    12315. 

  12315.      HEAP8[i20 + 8 | 0] = HEAP8[i7 + 46 | 0] | 0;
    12316. 

  12316.      i29 = HEAP32[(HEAP32[i7 + 12 >> 2] | 0) + 64 >> 2] | 0;
    12317. 

  12317.      HEAP16[i20 + 4 >> 1] = HEAP32[i29 + 28 >> 2];
    12318. 

  12318.      HEAP16[i20 + 6 >> 1] = HEAP32[i29 + 16 >> 2];
    12319. 

  12319.      HEAP8[i20 + 9 | 0] = 0;
    12320. 

  12320.      i29 = i7 + 16 | 0;
    12321. 

  12321.      HEAP32[i20 >> 2] = HEAP32[i29 >> 2];
    12322. 

  12322.      HEAP32[i29 >> 2] = i20;
    12323. 

  12323.      L16 : do {
    12324. 

  12324.       i8 = HEAP32[i5 >> 2] | 0;
    12325. 

  12325.       switch (i8 | 0) {
    12326. 

  12326.       case 277:
    12327. 

  12327.       case 286:
    12328. 

  12328.       case 262:
    12329. 

  12329.       case 261:
    12330. 

  12330.       case 260:
    12331. 

  12331.        {
    12332. 

  12332.         break L16;
    12333. 

  12333.        }
    12334. 

  12334.       default:
    12335. 

  12335.        {}
    12336. 

  12336.       }
    12337. 

  12337.       _statement(i4);
    12338. 

  12338.      } while ((i8 | 0) != 274);
    12339. 

  12339.      _leaveblock(i7);
    12340. 

  12340.     }
    12341. 

  12341.     _check_match(i4, 262, 267, i6);
    12342. 

  12342.     _luaK_patchtohere(i9, HEAP32[i21 >> 2] | 0);
    12343. 

  12343.     break;
    12344. 

  12344.    }
    12345. 

  12345.   case 259:
    12346. 

  12346.    {
    12347. 

  12347.     _luaX_next(i4);
    12348. 

  12348.     i7 = HEAP32[i3 >> 2] | 0;
    12349. 

  12349.     HEAP8[i20 + 10 | 0] = 0;
    12350. 

  12350.     HEAP8[i20 + 8 | 0] = HEAP8[i7 + 46 | 0] | 0;
    12351. 

  12351.     i29 = HEAP32[(HEAP32[i7 + 12 >> 2] | 0) + 64 >> 2] | 0;
    12352. 

  12352.     HEAP16[i20 + 4 >> 1] = HEAP32[i29 + 28 >> 2];
    12353. 

  12353.     HEAP16[i20 + 6 >> 1] = HEAP32[i29 + 16 >> 2];
    12354. 

  12354.     HEAP8[i20 + 9 | 0] = 0;
    12355. 

  12355.     i29 = i7 + 16 | 0;
    12356. 

  12356.     HEAP32[i20 >> 2] = HEAP32[i29 >> 2];
    12357. 

  12357.     HEAP32[i29 >> 2] = i20;
    12358. 

  12358.     L22 : do {
    12359. 

  12359.      i8 = HEAP32[i5 >> 2] | 0;
    12360. 

  12360.      switch (i8 | 0) {
    12361. 

  12361.      case 277:
    12362. 

  12362.      case 286:
    12363. 

  12363.      case 262:
    12364. 

  12364.      case 261:
    12365. 

  12365.      case 260:
    12366. 

  12366.       {
    12367. 

  12367.        break L22;
    12368. 

  12368.       }
    12369. 

  12369.      default:
    12370. 

  12370.       {}
    12371. 

  12371.      }
    12372. 

  12372.      _statement(i4);
    12373. 

  12373.     } while ((i8 | 0) != 274);
    12374. 

  12374.     _leaveblock(i7);
    12375. 

  12375.     _check_match(i4, 262, 259, i6);
    12376. 

  12376.     break;
    12377. 

  12377.    }
    12378. 

  12378.   case 269:
    12379. 

  12379.    {
    12380. 

  12380.     _luaX_next(i4);
    12381. 

  12381.     i6 = HEAP32[i5 >> 2] | 0;
    12382. 

  12382.     if ((i6 | 0) == 265) {
    12383. 

  12383.      _luaX_next(i4);
    12384. 

  12384.      i7 = HEAP32[i3 >> 2] | 0;
    12385. 

  12385.      if ((HEAP32[i5 >> 2] | 0) == 288) {
    12386. 

  12386.       i29 = HEAP32[i4 + 24 >> 2] | 0;
    12387. 

  12387.       _luaX_next(i4);
    12388. 

  12388.       _new_localvar(i4, i29);
    12389. 

  12389.       i29 = HEAP32[i3 >> 2] | 0;
    12390. 

  12390.       i27 = i29 + 46 | 0;
    12391. 

  12391.       i28 = (HEAPU8[i27] | 0) + 1 | 0;
    12392. 

  12392.       HEAP8[i27] = i28;
    12393. 

  12393.       HEAP32[(HEAP32[(HEAP32[i29 >> 2] | 0) + 24 >> 2] | 0) + ((HEAP16[(HEAP32[HEAP32[(HEAP32[i29 + 12 >> 2] | 0) + 64 >> 2] >> 2] | 0) + ((i28 & 255) + -1 + (HEAP32[i29 + 40 >> 2] | 0) << 1) >> 1] | 0) * 12 | 0) + 4 >> 2] = HEAP32[i29 + 20 >> 2];
    12394. 

  12394.       _body(i4, i25, 0, HEAP32[i19 >> 2] | 0);
    12395. 

  12395.       HEAP32[(HEAP32[(HEAP32[i7 >> 2] | 0) + 24 >> 2] | 0) + ((HEAP16[(HEAP32[HEAP32[(HEAP32[i7 + 12 >> 2] | 0) + 64 >> 2] >> 2] | 0) + ((HEAP32[i7 + 40 >> 2] | 0) + (HEAP32[i25 + 8 >> 2] | 0) << 1) >> 1] | 0) * 12 | 0) + 4 >> 2] = HEAP32[i7 + 20 >> 2];
    12396. 

  12396.       break L8;
    12397. 

  12397.      } else {
    12398. 

  12398.       _error_expected(i4, 288);
    12399. 

  12399.      }
    12400. 

  12400.     }
    12401. 

  12401.     if ((i6 | 0) != 288) {
    12402. 

  12402.      _error_expected(i4, 288);
    12403. 

  12403.     }
    12404. 

  12404.     i7 = i4 + 24 | 0;
    12405. 

  12405.     i6 = 1;
    12406. 

  12406.     while (1) {
    12407. 

  12407.      i8 = HEAP32[i7 >> 2] | 0;
    12408. 

  12408.      _luaX_next(i4);
    12409. 

  12409.      _new_localvar(i4, i8);
    12410. 

  12410.      i8 = HEAP32[i5 >> 2] | 0;
    12411. 

  12411.      if ((i8 | 0) == 61) {
    12412. 

  12412.       i7 = 81;
    12413. 

  12413.       break;
    12414. 

  12414.      } else if ((i8 | 0) != 44) {
    12415. 

  12415.       i7 = 83;
    12416. 

  12416.       break;
    12417. 

  12417.      }
    12418. 

  12418.      _luaX_next(i4);
    12419. 

  12419.      if ((HEAP32[i5 >> 2] | 0) == 288) {
    12420. 

  12420.       i6 = i6 + 1 | 0;
    12421. 

  12421.      } else {
    12422. 

  12422.       i7 = 78;
    12423. 

  12423.       break;
    12424. 

  12424.      }
    12425. 

  12425.     }
    12426. 

  12426.     do {
    12427. 

  12427.      if ((i7 | 0) == 78) {
    12428. 

  12428.       _error_expected(i4, 288);
    12429. 

  12429.      } else if ((i7 | 0) == 81) {
    12430. 

  12430.       _luaX_next(i4);
    12431. 

  12431.       _subexpr(i4, i15, 0) | 0;
    12432. 

  12432.       if ((HEAP32[i5 >> 2] | 0) == 44) {
    12433. 

  12433.        i8 = 1;
    12434. 

  12434.        do {
    12435. 

  12435.         _luaX_next(i4);
    12436. 

  12436.         _luaK_exp2nextreg(HEAP32[i3 >> 2] | 0, i15);
    12437. 

  12437.         _subexpr(i4, i15, 0) | 0;
    12438. 

  12438.         i8 = i8 + 1 | 0;
    12439. 

  12439.        } while ((HEAP32[i5 >> 2] | 0) == 44);
    12440. 

  12440.       } else {
    12441. 

  12441.        i8 = 1;
    12442. 

  12442.       }
    12443. 

  12443.       i5 = HEAP32[i15 >> 2] | 0;
    12444. 

  12444.       i4 = HEAP32[i3 >> 2] | 0;
    12445. 

  12445.       i8 = i6 - i8 | 0;
    12446. 

  12446.       if ((i5 | 0) == 0) {
    12447. 

  12447.        i17 = i8;
    12448. 

  12448.        i18 = i4;
    12449. 

  12449.        i7 = 88;
    12450. 

  12450.        break;
    12451. 

  12451.       } else if (!((i5 | 0) == 13 | (i5 | 0) == 12)) {
    12452. 

  12452.        _luaK_exp2nextreg(i4, i15);
    12453. 

  12453.        i17 = i8;
    12454. 

  12454.        i18 = i4;
    12455. 

  12455.        i7 = 88;
    12456. 

  12456.        break;
    12457. 

  12457.       }
    12458. 

  12458.       i5 = i8 + 1 | 0;
    12459. 

  12459.       i5 = (i5 | 0) < 0 ? 0 : i5;
    12460. 

  12460.       _luaK_setreturns(i4, i15, i5);
    12461. 

  12461.       if ((i5 | 0) > 1) {
    12462. 

  12462.        _luaK_reserveregs(i4, i5 + -1 | 0);
    12463. 

  12463.       }
    12464. 

  12464.      } else if ((i7 | 0) == 83) {
    12465. 

  12465.       HEAP32[i15 >> 2] = 0;
    12466. 

  12466.       i17 = i6;
    12467. 

  12467.       i18 = HEAP32[i3 >> 2] | 0;
    12468. 

  12468.       i7 = 88;
    12469. 

  12469.      }
    12470. 

  12470.     } while (0);
    12471. 

  12471.     if ((i7 | 0) == 88 ? (i17 | 0) > 0 : 0) {
    12472. 

  12472.      i29 = HEAPU8[i18 + 48 | 0] | 0;
    12473. 

  12473.      _luaK_reserveregs(i18, i17);
    12474. 

  12474.      _luaK_nil(i18, i29, i17);
    12475. 

  12475.     }
    12476. 

  12476.     i5 = HEAP32[i3 >> 2] | 0;
    12477. 

  12477.     i4 = i5 + 46 | 0;
    12478. 

  12478.     i7 = (HEAPU8[i4] | 0) + i6 | 0;
    12479. 

  12479.     HEAP8[i4] = i7;
    12480. 

  12480.     if ((i6 | 0) != 0 ? (i11 = i5 + 20 | 0, i14 = i5 + 40 | 0, i12 = HEAP32[(HEAP32[i5 >> 2] | 0) + 24 >> 2] | 0, i13 = HEAP32[HEAP32[(HEAP32[i5 + 12 >> 2] | 0) + 64 >> 2] >> 2] | 0, HEAP32[i12 + ((HEAP16[i13 + ((i7 & 255) - i6 + (HEAP32[i14 >> 2] | 0) << 1) >> 1] | 0) * 12 | 0) + 4 >> 2] = HEAP32[i11 >> 2], i16 = i6 + -1 | 0, (i16 | 0) != 0) : 0) {
    12481. 

  12481.      do {
    12482. 

  12482.       HEAP32[i12 + ((HEAP16[i13 + ((HEAPU8[i4] | 0) - i16 + (HEAP32[i14 >> 2] | 0) << 1) >> 1] | 0) * 12 | 0) + 4 >> 2] = HEAP32[i11 >> 2];
    12483. 

  12483.       i16 = i16 + -1 | 0;
    12484. 

  12484.      } while ((i16 | 0) != 0);
    12485. 

  12485.     }
    12486. 

  12486.     break;
    12487. 

  12487.    }
    12488. 

  12488.   case 264:
    12489. 

  12489.    {
    12490. 

  12490.     HEAP8[i24 + 10 | 0] = 1;
    12491. 

  12491.     HEAP8[i24 + 8 | 0] = HEAP8[i9 + 46 | 0] | 0;
    12492. 

  12492.     i29 = HEAP32[(HEAP32[i9 + 12 >> 2] | 0) + 64 >> 2] | 0;
    12493. 

  12493.     HEAP16[i24 + 4 >> 1] = HEAP32[i29 + 28 >> 2];
    12494. 

  12494.     HEAP16[i24 + 6 >> 1] = HEAP32[i29 + 16 >> 2];
    12495. 

  12495.     HEAP8[i24 + 9 | 0] = 0;
    12496. 

  12496.     i29 = i9 + 16 | 0;
    12497. 

  12497.     HEAP32[i24 >> 2] = HEAP32[i29 >> 2];
    12498. 

  12498.     HEAP32[i29 >> 2] = i24;
    12499. 

  12499.     _luaX_next(i4);
    12500. 

  12500.     if ((HEAP32[i5 >> 2] | 0) != 288) {
    12501. 

  12501.      _error_expected(i4, 288);
    12502. 

  12502.     }
    12503. 

  12503.     i14 = i4 + 24 | 0;
    12504. 

  12504.     i13 = HEAP32[i14 >> 2] | 0;
    12505. 

  12505.     _luaX_next(i4);
    12506. 

  12506.     i11 = HEAP32[i5 >> 2] | 0;
    12507. 

  12507.     if ((i11 | 0) == 268 | (i11 | 0) == 44) {
    12508. 

  12508.      i12 = HEAP32[i3 >> 2] | 0;
    12509. 

  12509.      i11 = HEAPU8[i12 + 48 | 0] | 0;
    12510. 

  12510.      _new_localvar(i4, _luaX_newstring(i4, 6744, 15) | 0);
    12511. 

  12511.      _new_localvar(i4, _luaX_newstring(i4, 6760, 11) | 0);
    12512. 

  12512.      _new_localvar(i4, _luaX_newstring(i4, 6776, 13) | 0);
    12513. 

  12513.      _new_localvar(i4, i13);
    12514. 

  12514.      i13 = HEAP32[i5 >> 2] | 0;
    12515. 

  12515.      do {
    12516. 

  12516.       if ((i13 | 0) == 44) {
    12517. 

  12517.        i15 = 4;
    12518. 

  12518.        while (1) {
    12519. 

  12519.         _luaX_next(i4);
    12520. 

  12520.         if ((HEAP32[i5 >> 2] | 0) != 288) {
    12521. 

  12521.          i7 = 40;
    12522. 

  12522.          break;
    12523. 

  12523.         }
    12524. 

  12524.         i13 = HEAP32[i14 >> 2] | 0;
    12525. 

  12525.         _luaX_next(i4);
    12526. 

  12526.         _new_localvar(i4, i13);
    12527. 

  12527.         i13 = HEAP32[i5 >> 2] | 0;
    12528. 

  12528.         if ((i13 | 0) == 44) {
    12529. 

  12529.          i15 = i15 + 1 | 0;
    12530. 

  12530.         } else {
    12531. 

  12531.          i7 = 42;
    12532. 

  12532.          break;
    12533. 

  12533.         }
    12534. 

  12534.        }
    12535. 

  12535.        if ((i7 | 0) == 40) {
    12536. 

  12536.         _error_expected(i4, 288);
    12537. 

  12537.        } else if ((i7 | 0) == 42) {
    12538. 

  12538.         i22 = i13;
    12539. 

  12539.         i10 = i15 + -2 | 0;
    12540. 

  12540.         break;
    12541. 

  12541.        }
    12542. 

  12542.       } else {
    12543. 

  12543.        i22 = i13;
    12544. 

  12544.        i10 = 1;
    12545. 

  12545.       }
    12546. 

  12546.      } while (0);
    12547. 

  12547.      if ((i22 | 0) != 268) {
    12548. 

  12548.       _error_expected(i4, 268);
    12549. 

  12549.      }
    12550. 

  12550.      _luaX_next(i4);
    12551. 

  12551.      i13 = HEAP32[i19 >> 2] | 0;
    12552. 

  12552.      _subexpr(i4, i8, 0) | 0;
    12553. 

  12553.      if ((HEAP32[i5 >> 2] | 0) == 44) {
    12554. 

  12554.       i14 = 1;
    12555. 

  12555.       do {
    12556. 

  12556.        _luaX_next(i4);
    12557. 

  12557.        _luaK_exp2nextreg(HEAP32[i3 >> 2] | 0, i8);
    12558. 

  12558.        _subexpr(i4, i8, 0) | 0;
    12559. 

  12559.        i14 = i14 + 1 | 0;
    12560. 

  12560.       } while ((HEAP32[i5 >> 2] | 0) == 44);
    12561. 

  12561.      } else {
    12562. 

  12562.       i14 = 1;
    12563. 

  12563.      }
    12564. 

  12564.      i5 = HEAP32[i3 >> 2] | 0;
    12565. 

  12565.      i14 = 3 - i14 | 0;
    12566. 

  12566.      i15 = HEAP32[i8 >> 2] | 0;
    12567. 

  12567.      if ((i15 | 0) == 0) {
    12568. 

  12568.       i7 = 51;
    12569. 

  12569.      } else if ((i15 | 0) == 13 | (i15 | 0) == 12) {
    12570. 

  12570.       i15 = i14 + 1 | 0;
    12571. 

  12571.       i15 = (i15 | 0) < 0 ? 0 : i15;
    12572. 

  12572.       _luaK_setreturns(i5, i8, i15);
    12573. 

  12573.       if ((i15 | 0) > 1) {
    12574. 

  12574.        _luaK_reserveregs(i5, i15 + -1 | 0);
    12575. 

  12575.       }
    12576. 

  12576.      } else {
    12577. 

  12577.       _luaK_exp2nextreg(i5, i8);
    12578. 

  12578.       i7 = 51;
    12579. 

  12579.      }
    12580. 

  12580.      if ((i7 | 0) == 51 ? (i14 | 0) > 0 : 0) {
    12581. 

  12581.       i29 = HEAPU8[i5 + 48 | 0] | 0;
    12582. 

  12582.       _luaK_reserveregs(i5, i14);
    12583. 

  12583.       _luaK_nil(i5, i29, i14);
    12584. 

  12584.      }
    12585. 

  12585.      _luaK_checkstack(i12, 3);
    12586. 

  12586.      _forbody(i4, i11, i13, i10, 0);
    12587. 

  12587.     } else if ((i11 | 0) == 61) {
    12588. 

  12588.      i11 = HEAP32[i3 >> 2] | 0;
    12589. 

  12589.      i7 = i11 + 48 | 0;
    12590. 

  12590.      i10 = HEAPU8[i7] | 0;
    12591. 

  12591.      _new_localvar(i4, _luaX_newstring(i4, 6792, 11) | 0);
    12592. 

  12592.      _new_localvar(i4, _luaX_newstring(i4, 6808, 11) | 0);
    12593. 

  12593.      _new_localvar(i4, _luaX_newstring(i4, 6824, 10) | 0);
    12594. 

  12594.      _new_localvar(i4, i13);
    12595. 

  12595.      if ((HEAP32[i5 >> 2] | 0) != 61) {
    12596. 

  12596.       _error_expected(i4, 61);
    12597. 

  12597.      }
    12598. 

  12598.      _luaX_next(i4);
    12599. 

  12599.      _subexpr(i4, i8, 0) | 0;
    12600. 

  12600.      _luaK_exp2nextreg(HEAP32[i3 >> 2] | 0, i8);
    12601. 

  12601.      if ((HEAP32[i5 >> 2] | 0) != 44) {
    12602. 

  12602.       _error_expected(i4, 44);
    12603. 

  12603.      }
    12604. 

  12604.      _luaX_next(i4);
    12605. 

  12605.      _subexpr(i4, i8, 0) | 0;
    12606. 

  12606.      _luaK_exp2nextreg(HEAP32[i3 >> 2] | 0, i8);
    12607. 

  12607.      if ((HEAP32[i5 >> 2] | 0) == 44) {
    12608. 

  12608.       _luaX_next(i4);
    12609. 

  12609.       _subexpr(i4, i8, 0) | 0;
    12610. 

  12610.       _luaK_exp2nextreg(HEAP32[i3 >> 2] | 0, i8);
    12611. 

  12611.      } else {
    12612. 

  12612.       i29 = HEAPU8[i7] | 0;
    12613. 

  12613.       _luaK_codek(i11, i29, _luaK_numberK(i11, 1.0) | 0) | 0;
    12614. 

  12614.       _luaK_reserveregs(i11, 1);
    12615. 

  12615.      }
    12616. 

  12616.      _forbody(i4, i10, i6, 1, 1);
    12617. 

  12617.     } else {
    12618. 

  12618.      _luaX_syntaxerror(i4, 6720);
    12619. 

  12619.     }
    12620. 

  12620.     _check_match(i4, 262, 264, i6);
    12621. 

  12621.     _leaveblock(i9);
    12622. 

  12622.     break;
    12623. 

  12623.    }
    12624. 

  12624.   case 265:
    12625. 

  12625.    {
    12626. 

  12626.     _luaX_next(i4);
    12627. 

  12627.     if ((HEAP32[i5 >> 2] | 0) != 288) {
    12628. 

  12628.      _error_expected(i4, 288);
    12629. 

  12629.     }
    12630. 

  12630.     i8 = HEAP32[i4 + 24 >> 2] | 0;
    12631. 

  12631.     _luaX_next(i4);
    12632. 

  12632.     i9 = HEAP32[i3 >> 2] | 0;
    12633. 

  12633.     if ((_singlevaraux(i9, i8, i20, 1) | 0) == 0) {
    12634. 

  12634.      _singlevaraux(i9, HEAP32[i4 + 72 >> 2] | 0, i20, 1) | 0;
    12635. 

  12635.      i29 = _luaK_stringK(HEAP32[i3 >> 2] | 0, i8) | 0;
    12636. 

  12636.      HEAP32[i25 + 16 >> 2] = -1;
    12637. 

  12637.      HEAP32[i25 + 20 >> 2] = -1;
    12638. 

  12638.      HEAP32[i25 >> 2] = 4;
    12639. 

  12639.      HEAP32[i25 + 8 >> 2] = i29;
    12640. 

  12640.      _luaK_indexed(i9, i20, i25);
    12641. 

  12641.     }
    12642. 

  12642.     while (1) {
    12643. 

  12643.      i8 = HEAP32[i5 >> 2] | 0;
    12644. 

  12644.      if ((i8 | 0) == 58) {
    12645. 

  12645.       i7 = 70;
    12646. 

  12646.       break;
    12647. 

  12647.      } else if ((i8 | 0) != 46) {
    12648. 

  12648.       i5 = 0;
    12649. 

  12649.       break;
    12650. 

  12650.      }
    12651. 

  12651.      _fieldsel(i4, i20);
    12652. 

  12652.     }
    12653. 

  12653.     if ((i7 | 0) == 70) {
    12654. 

  12654.      _fieldsel(i4, i20);
    12655. 

  12655.      i5 = 1;
    12656. 

  12656.     }
    12657. 

  12657.     _body(i4, i21, i5, i6);
    12658. 

  12658.     _luaK_storevar(HEAP32[i3 >> 2] | 0, i20, i21);
    12659. 

  12659.     _luaK_fixline(HEAP32[i3 >> 2] | 0, i6);
    12660. 

  12660.     break;
    12661. 

  12661.    }
    12662. 

  12662.   case 278:
    12663. 

  12663.    {
    12664. 

  12664.     _luaX_next(i4);
    12665. 

  12665.     i7 = _luaK_getlabel(i9) | 0;
    12666. 

  12666.     _subexpr(i4, i20, 0) | 0;
    12667. 

  12667.     if ((HEAP32[i20 >> 2] | 0) == 1) {
    12668. 

  12668.      HEAP32[i20 >> 2] = 3;
    12669. 

  12669.     }
    12670. 

  12670.     _luaK_goiftrue(HEAP32[i3 >> 2] | 0, i20);
    12671. 

  12671.     i8 = HEAP32[i20 + 20 >> 2] | 0;
    12672. 

  12672.     HEAP8[i21 + 10 | 0] = 1;
    12673. 

  12673.     HEAP8[i21 + 8 | 0] = HEAP8[i9 + 46 | 0] | 0;
    12674. 

  12674.     i29 = HEAP32[(HEAP32[i9 + 12 >> 2] | 0) + 64 >> 2] | 0;
    12675. 

  12675.     HEAP16[i21 + 4 >> 1] = HEAP32[i29 + 28 >> 2];
    12676. 

  12676.     HEAP16[i21 + 6 >> 1] = HEAP32[i29 + 16 >> 2];
    12677. 

  12677.     HEAP8[i21 + 9 | 0] = 0;
    12678. 

  12678.     i29 = i9 + 16 | 0;
    12679. 

  12679.     HEAP32[i21 >> 2] = HEAP32[i29 >> 2];
    12680. 

  12680.     HEAP32[i29 >> 2] = i21;
    12681. 

  12681.     if ((HEAP32[i5 >> 2] | 0) != 259) {
    12682. 

  12682.      _error_expected(i4, 259);
    12683. 

  12683.     }
    12684. 

  12684.     _luaX_next(i4);
    12685. 

  12685.     i10 = HEAP32[i3 >> 2] | 0;
    12686. 

  12686.     HEAP8[i20 + 10 | 0] = 0;
    12687. 

  12687.     HEAP8[i20 + 8 | 0] = HEAP8[i10 + 46 | 0] | 0;
    12688. 

  12688.     i29 = HEAP32[(HEAP32[i10 + 12 >> 2] | 0) + 64 >> 2] | 0;
    12689. 

  12689.     HEAP16[i20 + 4 >> 1] = HEAP32[i29 + 28 >> 2];
    12690. 

  12690.     HEAP16[i20 + 6 >> 1] = HEAP32[i29 + 16 >> 2];
    12691. 

  12691.     HEAP8[i20 + 9 | 0] = 0;
    12692. 

  12692.     i29 = i10 + 16 | 0;
    12693. 

  12693.     HEAP32[i20 >> 2] = HEAP32[i29 >> 2];
    12694. 

  12694.     HEAP32[i29 >> 2] = i20;
    12695. 

  12695.     L119 : do {
    12696. 

  12696.      i11 = HEAP32[i5 >> 2] | 0;
    12697. 

  12697.      switch (i11 | 0) {
    12698. 

  12698.      case 277:
    12699. 

  12699.      case 286:
    12700. 

  12700.      case 262:
    12701. 

  12701.      case 261:
    12702. 

  12702.      case 260:
    12703. 

  12703.       {
    12704. 

  12704.        break L119;
    12705. 

  12705.       }
    12706. 

  12706.      default:
    12707. 

  12707.       {}
    12708. 

  12708.      }
    12709. 

  12709.      _statement(i4);
    12710. 

  12710.     } while ((i11 | 0) != 274);
    12711. 

  12711.     _leaveblock(i10);
    12712. 

  12712.     _luaK_patchlist(i9, _luaK_jump(i9) | 0, i7);
    12713. 

  12713.     _check_match(i4, 262, 278, i6);
    12714. 

  12714.     _leaveblock(i9);
    12715. 

  12715.     _luaK_patchtohere(i9, i8);
    12716. 

  12716.     break;
    12717. 

  12717.    }
    12718. 

  12718.   case 273:
    12719. 

  12719.    {
    12720. 

  12720.     i7 = _luaK_getlabel(i9) | 0;
    12721. 

  12721.     HEAP8[i24 + 10 | 0] = 1;
    12722. 

  12722.     i28 = i9 + 46 | 0;
    12723. 

  12723.     HEAP8[i24 + 8 | 0] = HEAP8[i28] | 0;
    12724. 

  12724.     i11 = i9 + 12 | 0;
    12725. 

  12725.     i29 = HEAP32[(HEAP32[i11 >> 2] | 0) + 64 >> 2] | 0;
    12726. 

  12726.     HEAP16[i24 + 4 >> 1] = HEAP32[i29 + 28 >> 2];
    12727. 

  12727.     HEAP16[i24 + 6 >> 1] = HEAP32[i29 + 16 >> 2];
    12728. 

  12728.     HEAP8[i24 + 9 | 0] = 0;
    12729. 

  12729.     i29 = i9 + 16 | 0;
    12730. 

  12730.     HEAP32[i24 >> 2] = HEAP32[i29 >> 2];
    12731. 

  12731.     HEAP32[i29 >> 2] = i24;
    12732. 

  12732.     HEAP8[i15 + 10 | 0] = 0;
    12733. 

  12733.     i10 = i15 + 8 | 0;
    12734. 

  12734.     HEAP8[i10] = HEAP8[i28] | 0;
    12735. 

  12735.     i11 = HEAP32[(HEAP32[i11 >> 2] | 0) + 64 >> 2] | 0;
    12736. 

  12736.     HEAP16[i15 + 4 >> 1] = HEAP32[i11 + 28 >> 2];
    12737. 

  12737.     HEAP16[i15 + 6 >> 1] = HEAP32[i11 + 16 >> 2];
    12738. 

  12738.     i11 = i15 + 9 | 0;
    12739. 

  12739.     HEAP8[i11] = 0;
    12740. 

  12740.     HEAP32[i15 >> 2] = HEAP32[i29 >> 2];
    12741. 

  12741.     HEAP32[i29 >> 2] = i15;
    12742. 

  12742.     _luaX_next(i4);
    12743. 

  12743.     L124 : do {
    12744. 

  12744.      i12 = HEAP32[i5 >> 2] | 0;
    12745. 

  12745.      switch (i12 | 0) {
    12746. 

  12746.      case 277:
    12747. 

  12747.      case 286:
    12748. 

  12748.      case 262:
    12749. 

  12749.      case 261:
    12750. 

  12750.      case 260:
    12751. 

  12751.       {
    12752. 

  12752.        break L124;
    12753. 

  12753.       }
    12754. 

  12754.      default:
    12755. 

  12755.       {}
    12756. 

  12756.      }
    12757. 

  12757.      _statement(i4);
    12758. 

  12758.     } while ((i12 | 0) != 274);
    12759. 

  12759.     _check_match(i4, 277, 273, i6);
    12760. 

  12760.     _subexpr(i4, i8, 0) | 0;
    12761. 

  12761.     if ((HEAP32[i8 >> 2] | 0) == 1) {
    12762. 

  12762.      HEAP32[i8 >> 2] = 3;
    12763. 

  12763.     }
    12764. 

  12764.     _luaK_goiftrue(HEAP32[i3 >> 2] | 0, i8);
    12765. 

  12765.     i4 = HEAP32[i8 + 20 >> 2] | 0;
    12766. 

  12766.     if ((HEAP8[i11] | 0) != 0) {
    12767. 

  12767.      _luaK_patchclose(i9, i4, HEAPU8[i10] | 0);
    12768. 

  12768.     }
    12769. 

  12769.     _leaveblock(i9);
    12770. 

  12770.     _luaK_patchlist(i9, i4, i7);
    12771. 

  12771.     _leaveblock(i9);
    12772. 

  12772.     break;
    12773. 

  12773.    }
    12774. 

  12774.   case 285:
    12775. 

  12775.    {
    12776. 

  12776.     _luaX_next(i4);
    12777. 

  12777.     if ((HEAP32[i5 >> 2] | 0) != 288) {
    12778. 

  12778.      _error_expected(i4, 288);
    12779. 

  12779.     }
    12780. 

  12780.     i10 = HEAP32[i4 + 24 >> 2] | 0;
    12781. 

  12781.     _luaX_next(i4);
    12782. 

  12782.     i15 = HEAP32[i3 >> 2] | 0;
    12783. 

  12783.     i9 = i4 + 64 | 0;
    12784. 

  12784.     i14 = HEAP32[i9 >> 2] | 0;
    12785. 

  12785.     i12 = i14 + 24 | 0;
    12786. 

  12786.     i11 = i15 + 16 | 0;
    12787. 

  12787.     i16 = HEAP16[(HEAP32[i11 >> 2] | 0) + 4 >> 1] | 0;
    12788. 

  12788.     i13 = i14 + 28 | 0;
    12789. 

  12789.     L138 : do {
    12790. 

  12790.      if ((i16 | 0) < (HEAP32[i13 >> 2] | 0)) {
    12791. 

  12791.       while (1) {
    12792. 

  12792.        i17 = i16 + 1 | 0;
    12793. 

  12793.        if ((_luaS_eqstr(i10, HEAP32[(HEAP32[i12 >> 2] | 0) + (i16 << 4) >> 2] | 0) | 0) != 0) {
    12794. 

  12794.         break;
    12795. 

  12795.        }
    12796. 

  12796.        if ((i17 | 0) < (HEAP32[i13 >> 2] | 0)) {
    12797. 

  12797.         i16 = i17;
    12798. 

  12798.        } else {
    12799. 

  12799.         break L138;
    12800. 

  12800.        }
    12801. 

  12801.       }
    12802. 

  12802.       i28 = i15 + 12 | 0;
    12803. 

  12803.       i29 = HEAP32[(HEAP32[i28 >> 2] | 0) + 52 >> 2] | 0;
    12804. 

  12804.       i27 = HEAP32[(HEAP32[i12 >> 2] | 0) + (i16 << 4) + 8 >> 2] | 0;
    12805. 

  12805.       HEAP32[i8 >> 2] = i10 + 16;
    12806. 

  12806.       HEAP32[i8 + 4 >> 2] = i27;
    12807. 

  12807.       i29 = _luaO_pushfstring(i29, 6680, i8) | 0;
    12808. 

  12808.       _semerror(HEAP32[i28 >> 2] | 0, i29);
    12809. 

  12809.      }
    12810. 

  12810.     } while (0);
    12811. 

  12811.     if ((HEAP32[i5 >> 2] | 0) != 285) {
    12812. 

  12812.      _error_expected(i4, 285);
    12813. 

  12813.     }
    12814. 

  12814.     _luaX_next(i4);
    12815. 

  12815.     i8 = HEAP32[i15 + 20 >> 2] | 0;
    12816. 

  12816.     i15 = HEAP32[i13 >> 2] | 0;
    12817. 

  12817.     i14 = i14 + 32 | 0;
    12818. 

  12818.     if ((i15 | 0) < (HEAP32[i14 >> 2] | 0)) {
    12819. 

  12819.      i14 = HEAP32[i12 >> 2] | 0;
    12820. 

  12820.     } else {
    12821. 

  12821.      i14 = _luaM_growaux_(HEAP32[i1 >> 2] | 0, HEAP32[i12 >> 2] | 0, i14, 16, 32767, 6312) | 0;
    12822. 

  12822.      HEAP32[i12 >> 2] = i14;
    12823. 

  12823.     }
    12824. 

  12824.     HEAP32[i14 + (i15 << 4) >> 2] = i10;
    12825. 

  12825.     i29 = HEAP32[i12 >> 2] | 0;
    12826. 

  12826.     HEAP32[i29 + (i15 << 4) + 8 >> 2] = i6;
    12827. 

  12827.     HEAP8[i29 + (i15 << 4) + 12 | 0] = HEAP8[(HEAP32[i3 >> 2] | 0) + 46 | 0] | 0;
    12828. 

  12828.     HEAP32[(HEAP32[i12 >> 2] | 0) + (i15 << 4) + 4 >> 2] = i8;
    12829. 

  12829.     HEAP32[i13 >> 2] = (HEAP32[i13 >> 2] | 0) + 1;
    12830. 

  12830.     L152 : while (1) {
    12831. 

  12831.      switch (HEAP32[i5 >> 2] | 0) {
    12832. 

  12832.      case 285:
    12833. 

  12833.      case 59:
    12834. 

  12834.       {
    12835. 

  12835.        break;
    12836. 

  12836.       }
    12837. 

  12837.      case 286:
    12838. 

  12838.      case 262:
    12839. 

  12839.      case 261:
    12840. 

  12840.      case 260:
    12841. 

  12841.       {
    12842. 

  12842.        i7 = 108;
    12843. 

  12843.        break L152;
    12844. 

  12844.       }
    12845. 

  12845.      default:
    12846. 

  12846.       {
    12847. 

  12847.        break L152;
    12848. 

  12848.       }
    12849. 

  12849.      }
    12850. 

  12850.      _statement(i4);
    12851. 

  12851.     }
    12852. 

  12852.     if ((i7 | 0) == 108) {
    12853. 

  12853.      HEAP8[(HEAP32[i12 >> 2] | 0) + (i15 << 4) + 12 | 0] = HEAP8[(HEAP32[i11 >> 2] | 0) + 8 | 0] | 0;
    12854. 

  12854.     }
    12855. 

  12855.     i5 = (HEAP32[i12 >> 2] | 0) + (i15 << 4) | 0;
    12856. 

  12856.     i8 = HEAP32[i9 >> 2] | 0;
    12857. 

  12857.     i7 = HEAP16[(HEAP32[(HEAP32[i3 >> 2] | 0) + 16 >> 2] | 0) + 6 >> 1] | 0;
    12858. 

  12858.     i6 = i8 + 16 | 0;
    12859. 

  12859.     if ((i7 | 0) < (HEAP32[i6 >> 2] | 0)) {
    12860. 

  12860.      i8 = i8 + 12 | 0;
    12861. 

  12861.      do {
    12862. 

  12862.       while (1) {
    12863. 

  12863.        if ((_luaS_eqstr(HEAP32[(HEAP32[i8 >> 2] | 0) + (i7 << 4) >> 2] | 0, HEAP32[i5 >> 2] | 0) | 0) == 0) {
    12864. 

  12864.         break;
    12865. 

  12865.        }
    12866. 

  12866.        _closegoto(i4, i7, i5);
    12867. 

  12867.        if ((i7 | 0) >= (HEAP32[i6 >> 2] | 0)) {
    12868. 

  12868.         break L8;
    12869. 

  12869.        }
    12870. 

  12870.       }
    12871. 

  12871.       i7 = i7 + 1 | 0;
    12872. 

  12872.      } while ((i7 | 0) < (HEAP32[i6 >> 2] | 0));
    12873. 

  12873.     }
    12874. 

  12874.     break;
    12875. 

  12875.    }
    12876. 

  12876.   case 274:
    12877. 

  12877.    {
    12878. 

  12878.     _luaX_next(i4);
    12879. 

  12879.     i6 = HEAP32[i3 >> 2] | 0;
    12880. 

  12880.     L166 : do {
    12881. 

  12881.      switch (HEAP32[i5 >> 2] | 0) {
    12882. 

  12882.      case 59:
    12883. 

  12883.      case 277:
    12884. 

  12884.      case 286:
    12885. 

  12885.      case 262:
    12886. 

  12886.      case 261:
    12887. 

  12887.      case 260:
    12888. 

  12888.       {
    12889. 

  12889.        i8 = 0;
    12890. 

  12890.        i7 = 0;
    12891. 

  12891.        break;
    12892. 

  12892.       }
    12893. 

  12893.      default:
    12894. 

  12894.       {
    12895. 

  12895.        _subexpr(i4, i24, 0) | 0;
    12896. 

  12896.        if ((HEAP32[i5 >> 2] | 0) == 44) {
    12897. 

  12897.         i7 = 1;
    12898. 

  12898.         do {
    12899. 

  12899.          _luaX_next(i4);
    12900. 

  12900.          _luaK_exp2nextreg(HEAP32[i3 >> 2] | 0, i24);
    12901. 

  12901.          _subexpr(i4, i24, 0) | 0;
    12902. 

  12902.          i7 = i7 + 1 | 0;
    12903. 

  12903.         } while ((HEAP32[i5 >> 2] | 0) == 44);
    12904. 

  12904.        } else {
    12905. 

  12905.         i7 = 1;
    12906. 

  12906.        }
    12907. 

  12907.        if (!(((HEAP32[i24 >> 2] | 0) + -12 | 0) >>> 0 < 2)) {
    12908. 

  12908.         if ((i7 | 0) == 1) {
    12909. 

  12909.          i8 = _luaK_exp2anyreg(i6, i24) | 0;
    12910. 

  12910.          i7 = 1;
    12911. 

  12911.          break L166;
    12912. 

  12912.         } else {
    12913. 

  12913.          _luaK_exp2nextreg(i6, i24);
    12914. 

  12914.          i8 = HEAPU8[i6 + 46 | 0] | 0;
    12915. 

  12915.          break L166;
    12916. 

  12916.         }
    12917. 

  12917.        } else {
    12918. 

  12918.         _luaK_setreturns(i6, i24, -1);
    12919. 

  12919.         if ((HEAP32[i24 >> 2] | 0) == 12 & (i7 | 0) == 1) {
    12920. 

  12920.          i29 = (HEAP32[(HEAP32[i6 >> 2] | 0) + 12 >> 2] | 0) + (HEAP32[i24 + 8 >> 2] << 2) | 0;
    12921. 

  12921.          HEAP32[i29 >> 2] = HEAP32[i29 >> 2] & -64 | 30;
    12922. 

  12922.         }
    12923. 

  12923.         i8 = HEAPU8[i6 + 46 | 0] | 0;
    12924. 

  12924.         i7 = -1;
    12925. 

  12925.         break L166;
    12926. 

  12926.        }
    12927. 

  12927.       }
    12928. 

  12928.      }
    12929. 

  12929.     } while (0);
    12930. 

  12930.     _luaK_ret(i6, i8, i7);
    12931. 

  12931.     if ((HEAP32[i5 >> 2] | 0) == 59) {
    12932. 

  12932.      _luaX_next(i4);
    12933. 

  12933.     }
    12934. 

  12934.     break;
    12935. 

  12935.    }
    12936. 

  12936.   case 266:
    12937. 

  12937.   case 258:
    12938. 

  12938.    {
    12939. 

  12939.     i6 = _luaK_jump(i9) | 0;
    12940. 

  12940.     i7 = HEAP32[i19 >> 2] | 0;
    12941. 

  12941.     i29 = (HEAP32[i5 >> 2] | 0) == 266;
    12942. 

  12942.     _luaX_next(i4);
    12943. 

  12943.     do {
    12944. 

  12944.      if (i29) {
    12945. 

  12945.       if ((HEAP32[i5 >> 2] | 0) == 288) {
    12946. 

  12946.        i23 = HEAP32[i4 + 24 >> 2] | 0;
    12947. 

  12947.        _luaX_next(i4);
    12948. 

  12948.        break;
    12949. 

  12949.       } else {
    12950. 

  12950.        _error_expected(i4, 288);
    12951. 

  12951.       }
    12952. 

  12952.      } else {
    12953. 

  12953.       i23 = _luaS_new(HEAP32[i1 >> 2] | 0, 6304) | 0;
    12954. 

  12954.      }
    12955. 

  12955.     } while (0);
    12956. 

  12956.     i10 = HEAP32[i4 + 64 >> 2] | 0;
    12957. 

  12957.     i9 = i10 + 12 | 0;
    12958. 

  12958.     i5 = i10 + 16 | 0;
    12959. 

  12959.     i8 = HEAP32[i5 >> 2] | 0;
    12960. 

  12960.     i10 = i10 + 20 | 0;
    12961. 

  12961.     if ((i8 | 0) < (HEAP32[i10 >> 2] | 0)) {
    12962. 

  12962.      i10 = HEAP32[i9 >> 2] | 0;
    12963. 

  12963.     } else {
    12964. 

  12964.      i10 = _luaM_growaux_(HEAP32[i1 >> 2] | 0, HEAP32[i9 >> 2] | 0, i10, 16, 32767, 6312) | 0;
    12965. 

  12965.      HEAP32[i9 >> 2] = i10;
    12966. 

  12966.     }
    12967. 

  12967.     HEAP32[i10 + (i8 << 4) >> 2] = i23;
    12968. 

  12968.     i29 = HEAP32[i9 >> 2] | 0;
    12969. 

  12969.     HEAP32[i29 + (i8 << 4) + 8 >> 2] = i7;
    12970. 

  12970.     HEAP8[i29 + (i8 << 4) + 12 | 0] = HEAP8[(HEAP32[i3 >> 2] | 0) + 46 | 0] | 0;
    12971. 

  12971.     HEAP32[(HEAP32[i9 >> 2] | 0) + (i8 << 4) + 4 >> 2] = i6;
    12972. 

  12972.     HEAP32[i5 >> 2] = (HEAP32[i5 >> 2] | 0) + 1;
    12973. 

  12973.     _findlabel(i4, i8) | 0;
    12974. 

  12974.     break;
    12975. 

  12975.    }
    12976. 

  12976.   default:
    12977. 

  12977.    {
    12978. 

  12978.     i6 = i8 + 8 | 0;
    12979. 

  12979.     _suffixedexp(i4, i6);
    12980. 

  12980.     i29 = HEAP32[i5 >> 2] | 0;
    12981. 

  12981.     if ((i29 | 0) == 44 | (i29 | 0) == 61) {
    12982. 

  12982.      HEAP32[i8 >> 2] = 0;
    12983. 

  12983.      _assignment(i4, i8, 1);
    12984. 

  12984.      break L8;
    12985. 

  12985.     }
    12986. 

  12986.     if ((HEAP32[i6 >> 2] | 0) == 12) {
    12987. 

  12987.      i29 = (HEAP32[(HEAP32[i9 >> 2] | 0) + 12 >> 2] | 0) + (HEAP32[i8 + 16 >> 2] << 2) | 0;
    12988. 

  12988.      HEAP32[i29 >> 2] = HEAP32[i29 >> 2] & -8372225 | 16384;
    12989. 

  12989.      break L8;
    12990. 

  12990.     } else {
    12991. 

  12991.      _luaX_syntaxerror(i4, 6344);
    12992. 

  12992.     }
    12993. 

  12993.    }
    12994. 

  12994.   }
    12995. 

  12995.  } while (0);
    12996. 

  12996.  i29 = HEAP32[i3 >> 2] | 0;
    12997. 

  12997.  HEAP8[i29 + 48 | 0] = HEAP8[i29 + 46 | 0] | 0;
    12998. 

  12998.  i29 = (HEAP32[i1 >> 2] | 0) + 38 | 0;
    12999. 

  12999.  HEAP16[i29 >> 1] = (HEAP16[i29 >> 1] | 0) + -1 << 16 >> 16;
    13000. 

  13000.  STACKTOP = i2;
    13001. 

  13001.  return;
    13002. 

  13002. }
    13003. 

  13003. function _match(i1, i12, i11) {
    13004. 

  13004.  i1 = i1 | 0;
    13005. 

  13005.  i12 = i12 | 0;
    13006. 

  13006.  i11 = i11 | 0;
    13007. 

  13007.  var i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i13 = 0, i14 = 0, i15 = 0, i16 = 0, i17 = 0, i18 = 0, i19 = 0, i20 = 0, i21 = 0, i22 = 0, i23 = 0, i24 = 0, i25 = 0, i26 = 0, i27 = 0, i28 = 0, i29 = 0, i30 = 0, i31 = 0, i32 = 0;
    13008. 

  13008.  i2 = STACKTOP;
    13009. 

  13009.  STACKTOP = STACKTOP + 16 | 0;
    13010. 

  13010.  i8 = i2;
    13011. 

  13011.  i32 = HEAP32[i1 >> 2] | 0;
    13012. 

  13012.  HEAP32[i1 >> 2] = i32 + -1;
    13013. 

  13013.  if ((i32 | 0) == 0) {
    13014. 

  13014.   _luaL_error(HEAP32[i1 + 16 >> 2] | 0, 7272, i8) | 0;
    13015. 

  13015.  }
    13016. 

  13016.  i14 = i1 + 12 | 0;
    13017. 

  13017.  i22 = HEAP32[i14 >> 2] | 0;
    13018. 

  13018.  L4 : do {
    13019. 

  13019.   if ((i22 | 0) != (i11 | 0)) {
    13020. 

  13020.    i3 = i1 + 8 | 0;
    13021. 

  13021.    i9 = i1 + 16 | 0;
    13022. 

  13022.    i16 = i1 + 4 | 0;
    13023. 

  13023.    i10 = i1 + 20 | 0;
    13024. 

  13024.    L6 : while (1) {
    13025. 

  13025.     i19 = i12 + 1 | 0;
    13026. 

  13026.     i20 = i12 + -1 | 0;
    13027. 

  13027.     L8 : while (1) {
    13028. 

  13028.      i23 = HEAP8[i11] | 0;
    13029. 

  13029.      i21 = i23 << 24 >> 24;
    13030. 

  13030.      L10 : do {
    13031. 

  13031.       if ((i21 | 0) == 36) {
    13032. 

  13032.        i7 = i11 + 1 | 0;
    13033. 

  13033.        if ((i7 | 0) == (i22 | 0)) {
    13034. 

  13034.         i7 = 23;
    13035. 

  13035.         break L6;
    13036. 

  13036.        } else {
    13037. 

  13037.         i22 = i7;
    13038. 

  13038.         i21 = i7;
    13039. 

  13039.         i7 = 89;
    13040. 

  13040.        }
    13041. 

  13041.       } else if ((i21 | 0) == 37) {
    13042. 

  13042.        i21 = i11 + 1 | 0;
    13043. 

  13043.        i23 = HEAP8[i21] | 0;
    13044. 

  13044.        switch (i23 << 24 >> 24 | 0) {
    13045. 

  13045.        case 57:
    13046. 

  13046.        case 56:
    13047. 

  13047.        case 55:
    13048. 

  13048.        case 54:
    13049. 

  13049.        case 53:
    13050. 

  13050.        case 52:
    13051. 

  13051.        case 51:
    13052. 

  13052.        case 50:
    13053. 

  13053.        case 49:
    13054. 

  13054.        case 48:
    13055. 

  13055.         {
    13056. 

  13056.          i7 = 69;
    13057. 

  13057.          break L8;
    13058. 

  13058.         }
    13059. 

  13059.        case 98:
    13060. 

  13060.         {
    13061. 

  13061.          i7 = 25;
    13062. 

  13062.          break L8;
    13063. 

  13063.         }
    13064. 

  13064.        case 102:
    13065. 

  13065.         {
    13066. 

  13066.          break;
    13067. 

  13067.         }
    13068. 

  13068.        default:
    13069. 

  13069.         {
    13070. 

  13070.          if ((i21 | 0) == (i22 | 0)) {
    13071. 

  13071.           _luaL_error(HEAP32[i9 >> 2] | 0, 7368, i8) | 0;
    13072. 

  13072.          }
    13073. 

  13073.          i22 = i11 + 2 | 0;
    13074. 

  13074.          i7 = 89;
    13075. 

  13075.          break L10;
    13076. 

  13076.         }
    13077. 

  13077.        }
    13078. 

  13078.        i22 = i11 + 2 | 0;
    13079. 

  13079.        if ((HEAP8[i22] | 0) == 91) {
    13080. 

  13080.         i21 = 91;
    13081. 

  13081.        } else {
    13082. 

  13082.         _luaL_error(HEAP32[i9 >> 2] | 0, 7296, i8) | 0;
    13083. 

  13083.         i21 = HEAP8[i22] | 0;
    13084. 

  13084.        }
    13085. 

  13085.        i23 = i11 + 3 | 0;
    13086. 

  13086.        i21 = i21 << 24 >> 24;
    13087. 

  13087.        if ((i21 | 0) == 91) {
    13088. 

  13088.         i21 = (HEAP8[i23] | 0) == 94 ? i11 + 4 | 0 : i23;
    13089. 

  13089.         while (1) {
    13090. 

  13090.          if ((i21 | 0) == (HEAP32[i14 >> 2] | 0)) {
    13091. 

  13091.           _luaL_error(HEAP32[i9 >> 2] | 0, 7408, i8) | 0;
    13092. 

  13092.          }
    13093. 

  13093.          i11 = i21 + 1 | 0;
    13094. 

  13094.          if ((HEAP8[i21] | 0) == 37) {
    13095. 

  13095.           i11 = i11 >>> 0 < (HEAP32[i14 >> 2] | 0) >>> 0 ? i21 + 2 | 0 : i11;
    13096. 

  13096.          }
    13097. 

  13097.          if ((HEAP8[i11] | 0) == 93) {
    13098. 

  13098.           break;
    13099. 

  13099.          } else {
    13100. 

  13100.           i21 = i11;
    13101. 

  13101.          }
    13102. 

  13102.         }
    13103. 

  13103.         i11 = i11 + 1 | 0;
    13104. 

  13104.        } else if ((i21 | 0) == 37) {
    13105. 

  13105.         if ((i23 | 0) == (HEAP32[i14 >> 2] | 0)) {
    13106. 

  13106.          _luaL_error(HEAP32[i9 >> 2] | 0, 7368, i8) | 0;
    13107. 

  13107.         }
    13108. 

  13108.         i11 = i11 + 4 | 0;
    13109. 

  13109.        } else {
    13110. 

  13110.         i11 = i23;
    13111. 

  13111.        }
    13112. 

  13112.        if ((i12 | 0) == (HEAP32[i16 >> 2] | 0)) {
    13113. 

  13113.         i25 = 0;
    13114. 

  13114.        } else {
    13115. 

  13115.         i25 = HEAP8[i20] | 0;
    13116. 

  13116.        }
    13117. 

  13117.        i24 = i25 & 255;
    13118. 

  13118.        i21 = i11 + -1 | 0;
    13119. 

  13119.        i26 = (HEAP8[i23] | 0) == 94;
    13120. 

  13120.        i28 = i26 ? i23 : i22;
    13121. 

  13121.        i27 = i26 & 1;
    13122. 

  13122.        i26 = i27 ^ 1;
    13123. 

  13123.        i30 = i28 + 1 | 0;
    13124. 

  13124.        L41 : do {
    13125. 

  13125.         if (i30 >>> 0 < i21 >>> 0) {
    13126. 

  13126.          while (1) {
    13127. 

  13127.           i32 = HEAP8[i30] | 0;
    13128. 

  13128.           i29 = i28 + 2 | 0;
    13129. 

  13129.           i31 = HEAP8[i29] | 0;
    13130. 

  13130.           do {
    13131. 

  13131.            if (i32 << 24 >> 24 == 37) {
    13132. 

  13132.             if ((_match_class(i24, i31 & 255) | 0) == 0) {
    13133. 

  13133.              i28 = i29;
    13134. 

  13134.             } else {
    13135. 

  13135.              break L41;
    13136. 

  13136.             }
    13137. 

  13137.            } else {
    13138. 

  13138.             if (i31 << 24 >> 24 == 45 ? (i18 = i28 + 3 | 0, i18 >>> 0 < i21 >>> 0) : 0) {
    13139. 

  13139.              if ((i32 & 255) > (i25 & 255)) {
    13140. 

  13140.               i28 = i18;
    13141. 

  13141.               break;
    13142. 

  13142.              }
    13143. 

  13143.              if ((HEAPU8[i18] | 0) < (i25 & 255)) {
    13144. 

  13144.               i28 = i18;
    13145. 

  13145.               break;
    13146. 

  13146.              } else {
    13147. 

  13147.               break L41;
    13148. 

  13148.              }
    13149. 

  13149.             }
    13150. 

  13150.             if (i32 << 24 >> 24 == i25 << 24 >> 24) {
    13151. 

  13151.              break L41;
    13152. 

  13152.             } else {
    13153. 

  13153.              i28 = i30;
    13154. 

  13154.             }
    13155. 

  13155.            }
    13156. 

  13156.           } while (0);
    13157. 

  13157.           i30 = i28 + 1 | 0;
    13158. 

  13158.           if (!(i30 >>> 0 < i21 >>> 0)) {
    13159. 

  13159.            i26 = i27;
    13160. 

  13160.            break;
    13161. 

  13161.           }
    13162. 

  13162.          }
    13163. 

  13163.         } else {
    13164. 

  13164.          i26 = i27;
    13165. 

  13165.         }
    13166. 

  13166.        } while (0);
    13167. 

  13167.        if ((i26 | 0) != 0) {
    13168. 

  13168.         i12 = 0;
    13169. 

  13169.         break L4;
    13170. 

  13170.        }
    13171. 

  13171.        i24 = HEAP8[i12] | 0;
    13172. 

  13172.        i25 = i24 & 255;
    13173. 

  13173.        i27 = (HEAP8[i23] | 0) == 94;
    13174. 

  13174.        i26 = i27 ? i23 : i22;
    13175. 

  13175.        i22 = i27 & 1;
    13176. 

  13176.        i23 = i22 ^ 1;
    13177. 

  13177.        i30 = i26 + 1 | 0;
    13178. 

  13178.        L55 : do {
    13179. 

  13179.         if (i30 >>> 0 < i21 >>> 0) {
    13180. 

  13180.          do {
    13181. 

  13181.           i29 = HEAP8[i30] | 0;
    13182. 

  13182.           i28 = i26 + 2 | 0;
    13183. 

  13183.           i27 = HEAP8[i28] | 0;
    13184. 

  13184.           do {
    13185. 

  13185.            if (i29 << 24 >> 24 == 37) {
    13186. 

  13186.             if ((_match_class(i25, i27 & 255) | 0) == 0) {
    13187. 

  13187.              i26 = i28;
    13188. 

  13188.             } else {
    13189. 

  13189.              i22 = i23;
    13190. 

  13190.              break L55;
    13191. 

  13191.             }
    13192. 

  13192.            } else {
    13193. 

  13193.             if (i27 << 24 >> 24 == 45 ? (i17 = i26 + 3 | 0, i17 >>> 0 < i21 >>> 0) : 0) {
    13194. 

  13194.              if ((i29 & 255) > (i24 & 255)) {
    13195. 

  13195.               i26 = i17;
    13196. 

  13196.               break;
    13197. 

  13197.              }
    13198. 

  13198.              if ((HEAPU8[i17] | 0) < (i24 & 255)) {
    13199. 

  13199.               i26 = i17;
    13200. 

  13200.               break;
    13201. 

  13201.              } else {
    13202. 

  13202.               i22 = i23;
    13203. 

  13203.               break L55;
    13204. 

  13204.              }
    13205. 

  13205.             }
    13206. 

  13206.             if (i29 << 24 >> 24 == i24 << 24 >> 24) {
    13207. 

  13207.              i22 = i23;
    13208. 

  13208.              break L55;
    13209. 

  13209.             } else {
    13210. 

  13210.              i26 = i30;
    13211. 

  13211.             }
    13212. 

  13212.            }
    13213. 

  13213.           } while (0);
    13214. 

  13214.           i30 = i26 + 1 | 0;
    13215. 

  13215.          } while (i30 >>> 0 < i21 >>> 0);
    13216. 

  13216.         }
    13217. 

  13217.        } while (0);
    13218. 

  13218.        if ((i22 | 0) == 0) {
    13219. 

  13219.         i12 = 0;
    13220. 

  13220.         break L4;
    13221. 

  13221.        }
    13222. 

  13222.       } else if ((i21 | 0) == 40) {
    13223. 

  13223.        i7 = 7;
    13224. 

  13224.        break L6;
    13225. 

  13225.       } else if ((i21 | 0) != 41) {
    13226. 

  13226.        i21 = i11 + 1 | 0;
    13227. 

  13227.        if (i23 << 24 >> 24 == 91) {
    13228. 

  13228.         i7 = (HEAP8[i21] | 0) == 94 ? i11 + 2 | 0 : i21;
    13229. 

  13229.         while (1) {
    13230. 

  13230.          if ((i7 | 0) == (i22 | 0)) {
    13231. 

  13231.           _luaL_error(HEAP32[i9 >> 2] | 0, 7408, i8) | 0;
    13232. 

  13232.          }
    13233. 

  13233.          i22 = i7 + 1 | 0;
    13234. 

  13234.          if ((HEAP8[i7] | 0) == 37) {
    13235. 

  13235.           i7 = i22 >>> 0 < (HEAP32[i14 >> 2] | 0) >>> 0 ? i7 + 2 | 0 : i22;
    13236. 

  13236.          } else {
    13237. 

  13237.           i7 = i22;
    13238. 

  13238.          }
    13239. 

  13239.          if ((HEAP8[i7] | 0) == 93) {
    13240. 

  13240.           break;
    13241. 

  13241.          }
    13242. 

  13242.          i22 = HEAP32[i14 >> 2] | 0;
    13243. 

  13243.         }
    13244. 

  13244.         i22 = i7 + 1 | 0;
    13245. 

  13245.         i7 = 89;
    13246. 

  13246.        } else {
    13247. 

  13247.         i22 = i21;
    13248. 

  13248.         i7 = 89;
    13249. 

  13249.        }
    13250. 

  13250.       } else {
    13251. 

  13251.        i7 = 16;
    13252. 

  13252.        break L6;
    13253. 

  13253.       }
    13254. 

  13254.      } while (0);
    13255. 

  13255.      L80 : do {
    13256. 

  13256.       if ((i7 | 0) == 89) {
    13257. 

  13257.        i7 = 0;
    13258. 

  13258.        do {
    13259. 

  13259.         if ((HEAP32[i3 >> 2] | 0) >>> 0 > i12 >>> 0) {
    13260. 

  13260.          i23 = HEAP8[i12] | 0;
    13261. 

  13261.          i24 = i23 & 255;
    13262. 

  13262.          i26 = HEAP8[i11] | 0;
    13263. 

  13263.          i25 = i26 << 24 >> 24;
    13264. 

  13264.          L85 : do {
    13265. 

  13265.           if ((i25 | 0) == 46) {
    13266. 

  13266.            i23 = HEAP8[i22] | 0;
    13267. 

  13267.           } else if ((i25 | 0) == 37) {
    13268. 

  13268.            i25 = _match_class(i24, HEAPU8[i21] | 0) | 0;
    13269. 

  13269.            i7 = 104;
    13270. 

  13270.           } else if ((i25 | 0) == 91) {
    13271. 

  13271.            i7 = i22 + -1 | 0;
    13272. 

  13272.            i25 = (HEAP8[i21] | 0) == 94;
    13273. 

  13273.            i27 = i25 ? i21 : i11;
    13274. 

  13274.            i26 = i25 & 1;
    13275. 

  13275.            i25 = i26 ^ 1;
    13276. 

  13276.            i30 = i27 + 1 | 0;
    13277. 

  13277.            if (i30 >>> 0 < i7 >>> 0) {
    13278. 

  13278.             while (1) {
    13279. 

  13279.              i31 = HEAP8[i30] | 0;
    13280. 

  13280.              i29 = i27 + 2 | 0;
    13281. 

  13281.              i28 = HEAP8[i29] | 0;
    13282. 

  13282.              do {
    13283. 

  13283.               if (i31 << 24 >> 24 == 37) {
    13284. 

  13284.                if ((_match_class(i24, i28 & 255) | 0) == 0) {
    13285. 

  13285.                 i27 = i29;
    13286. 

  13286.                } else {
    13287. 

  13287.                 i7 = 104;
    13288. 

  13288.                 break L85;
    13289. 

  13289.                }
    13290. 

  13290.               } else {
    13291. 

  13291.                if (i28 << 24 >> 24 == 45 ? (i13 = i27 + 3 | 0, i13 >>> 0 < i7 >>> 0) : 0) {
    13292. 

  13292.                 if ((i31 & 255) > (i23 & 255)) {
    13293. 

  13293.                  i27 = i13;
    13294. 

  13294.                  break;
    13295. 

  13295.                 }
    13296. 

  13296.                 if ((HEAPU8[i13] | 0) < (i23 & 255)) {
    13297. 

  13297.                  i27 = i13;
    13298. 

  13298.                  break;
    13299. 

  13299.                 } else {
    13300. 

  13300.                  i7 = 104;
    13301. 

  13301.                  break L85;
    13302. 

  13302.                 }
    13303. 

  13303.                }
    13304. 

  13304.                if (i31 << 24 >> 24 == i23 << 24 >> 24) {
    13305. 

  13305.                 i7 = 104;
    13306. 

  13306.                 break L85;
    13307. 

  13307.                } else {
    13308. 

  13308.                 i27 = i30;
    13309. 

  13309.                }
    13310. 

  13310.               }
    13311. 

  13311.              } while (0);
    13312. 

  13312.              i30 = i27 + 1 | 0;
    13313. 

  13313.              if (!(i30 >>> 0 < i7 >>> 0)) {
    13314. 

  13314.               i25 = i26;
    13315. 

  13315.               i7 = 104;
    13316. 

  13316.               break;
    13317. 

  13317.              }
    13318. 

  13318.             }
    13319. 

  13319.            } else {
    13320. 

  13320.             i25 = i26;
    13321. 

  13321.             i7 = 104;
    13322. 

  13322.            }
    13323. 

  13323.           } else {
    13324. 

  13324.            i25 = i26 << 24 >> 24 == i23 << 24 >> 24 | 0;
    13325. 

  13325.            i7 = 104;
    13326. 

  13326.           }
    13327. 

  13327.          } while (0);
    13328. 

  13328.          if ((i7 | 0) == 104) {
    13329. 

  13329.           i7 = 0;
    13330. 

  13330.           i23 = HEAP8[i22] | 0;
    13331. 

  13331.           if ((i25 | 0) == 0) {
    13332. 

  13332.            break;
    13333. 

  13333.           }
    13334. 

  13334.          }
    13335. 

  13335.          i23 = i23 << 24 >> 24;
    13336. 

  13336.          if ((i23 | 0) == 45) {
    13337. 

  13337.           i7 = 109;
    13338. 

  13338.           break L6;
    13339. 

  13339.          } else if ((i23 | 0) == 42) {
    13340. 

  13340.           i7 = 112;
    13341. 

  13341.           break L6;
    13342. 

  13342.          } else if ((i23 | 0) == 43) {
    13343. 

  13343.           break L6;
    13344. 

  13344.          } else if ((i23 | 0) != 63) {
    13345. 

  13345.           i12 = i19;
    13346. 

  13346.           i11 = i22;
    13347. 

  13347.           break L8;
    13348. 

  13348.          }
    13349. 

  13349.          i11 = i22 + 1 | 0;
    13350. 

  13350.          i21 = _match(i1, i19, i11) | 0;
    13351. 

  13351.          if ((i21 | 0) == 0) {
    13352. 

  13352.           break L80;
    13353. 

  13353.          } else {
    13354. 

  13354.           i12 = i21;
    13355. 

  13355.           break L4;
    13356. 

  13356.          }
    13357. 

  13357.         } else {
    13358. 

  13358.          i23 = HEAP8[i22] | 0;
    13359. 

  13359.         }
    13360. 

  13360.        } while (0);
    13361. 

  13361.        if (!(i23 << 24 >> 24 == 45 | i23 << 24 >> 24 == 63 | i23 << 24 >> 24 == 42)) {
    13362. 

  13362.         i12 = 0;
    13363. 

  13363.         break L4;
    13364. 

  13364.        }
    13365. 

  13365.        i11 = i22 + 1 | 0;
    13366. 

  13366.       }
    13367. 

  13367.      } while (0);
    13368. 

  13368.      i22 = HEAP32[i14 >> 2] | 0;
    13369. 

  13369.      if ((i11 | 0) == (i22 | 0)) {
    13370. 

  13370.       break L4;
    13371. 

  13371.      }
    13372. 

  13372.     }
    13373. 

  13373.     if ((i7 | 0) == 25) {
    13374. 

  13374.      i7 = 0;
    13375. 

  13375.      i21 = i11 + 2 | 0;
    13376. 

  13376.      if (!((i22 + -1 | 0) >>> 0 > i21 >>> 0)) {
    13377. 

  13377.       _luaL_error(HEAP32[i9 >> 2] | 0, 7440, i8) | 0;
    13378. 

  13378.      }
    13379. 

  13379.      i20 = HEAP8[i12] | 0;
    13380. 

  13380.      if (!(i20 << 24 >> 24 == (HEAP8[i21] | 0))) {
    13381. 

  13381.       i12 = 0;
    13382. 

  13382.       break L4;
    13383. 

  13383.      }
    13384. 

  13384.      i21 = HEAP8[i11 + 3 | 0] | 0;
    13385. 

  13385.      i22 = HEAP32[i3 >> 2] | 0;
    13386. 

  13386.      if (i19 >>> 0 < i22 >>> 0) {
    13387. 

  13387.       i24 = 1;
    13388. 

  13388.      } else {
    13389. 

  13389.       i12 = 0;
    13390. 

  13390.       break L4;
    13391. 

  13391.      }
    13392. 

  13392.      while (1) {
    13393. 

  13393.       i23 = HEAP8[i19] | 0;
    13394. 

  13394.       if (i23 << 24 >> 24 == i21 << 24 >> 24) {
    13395. 

  13395.        i24 = i24 + -1 | 0;
    13396. 

  13396.        if ((i24 | 0) == 0) {
    13397. 

  13397.         break;
    13398. 

  13398.        }
    13399. 

  13399.       } else {
    13400. 

  13400.        i24 = (i23 << 24 >> 24 == i20 << 24 >> 24) + i24 | 0;
    13401. 

  13401.       }
    13402. 

  13402.       i12 = i19 + 1 | 0;
    13403. 

  13403.       if (i12 >>> 0 < i22 >>> 0) {
    13404. 

  13404.        i32 = i19;
    13405. 

  13405.        i19 = i12;
    13406. 

  13406.        i12 = i32;
    13407. 

  13407.       } else {
    13408. 

  13408.        i12 = 0;
    13409. 

  13409.        break L4;
    13410. 

  13410.       }
    13411. 

  13411.      }
    13412. 

  13412.      i12 = i12 + 2 | 0;
    13413. 

  13413.      i11 = i11 + 4 | 0;
    13414. 

  13414.     } else if ((i7 | 0) == 69) {
    13415. 

  13415.      i7 = 0;
    13416. 

  13416.      i20 = i23 & 255;
    13417. 

  13417.      i19 = i20 + -49 | 0;
    13418. 

  13418.      if (((i19 | 0) >= 0 ? (i19 | 0) < (HEAP32[i10 >> 2] | 0) : 0) ? (i15 = HEAP32[i1 + (i19 << 3) + 28 >> 2] | 0, !((i15 | 0) == -1)) : 0) {
    13419. 

  13419.       i20 = i15;
    13420. 

  13420.      } else {
    13421. 

  13421.       i19 = HEAP32[i9 >> 2] | 0;
    13422. 

  13422.       HEAP32[i8 >> 2] = i20 + -48;
    13423. 

  13423.       i20 = _luaL_error(i19, 7336, i8) | 0;
    13424. 

  13424.       i19 = i20;
    13425. 

  13425.       i20 = HEAP32[i1 + (i20 << 3) + 28 >> 2] | 0;
    13426. 

  13426.      }
    13427. 

  13427.      if (((HEAP32[i3 >> 2] | 0) - i12 | 0) >>> 0 < i20 >>> 0) {
    13428. 

  13428.       i12 = 0;
    13429. 

  13429.       break L4;
    13430. 

  13430.      }
    13431. 

  13431.      if ((_memcmp(HEAP32[i1 + (i19 << 3) + 24 >> 2] | 0, i12, i20) | 0) != 0) {
    13432. 

  13432.       i12 = 0;
    13433. 

  13433.       break L4;
    13434. 

  13434.      }
    13435. 

  13435.      i12 = i12 + i20 | 0;
    13436. 

  13436.      if ((i12 | 0) == 0) {
    13437. 

  13437.       i12 = 0;
    13438. 

  13438.       break L4;
    13439. 

  13439.      }
    13440. 

  13440.      i11 = i11 + 2 | 0;
    13441. 

  13441.     }
    13442. 

  13442.     i22 = HEAP32[i14 >> 2] | 0;
    13443. 

  13443.     if ((i11 | 0) == (i22 | 0)) {
    13444. 

  13444.      break L4;
    13445. 

  13445.     }
    13446. 

  13446.    }
    13447. 

  13447.    if ((i7 | 0) == 7) {
    13448. 

  13448.     i3 = i11 + 1 | 0;
    13449. 

  13449.     if ((HEAP8[i3] | 0) == 41) {
    13450. 

  13450.      i3 = HEAP32[i10 >> 2] | 0;
    13451. 

  13451.      if ((i3 | 0) > 31) {
    13452. 

  13452.       _luaL_error(HEAP32[i9 >> 2] | 0, 7200, i8) | 0;
    13453. 

  13453.      }
    13454. 

  13454.      HEAP32[i1 + (i3 << 3) + 24 >> 2] = i12;
    13455. 

  13455.      HEAP32[i1 + (i3 << 3) + 28 >> 2] = -2;
    13456. 

  13456.      HEAP32[i10 >> 2] = i3 + 1;
    13457. 

  13457.      i12 = _match(i1, i12, i11 + 2 | 0) | 0;
    13458. 

  13458.      if ((i12 | 0) != 0) {
    13459. 

  13459.       break;
    13460. 

  13460.      }
    13461. 

  13461.      HEAP32[i10 >> 2] = (HEAP32[i10 >> 2] | 0) + -1;
    13462. 

  13462.      i12 = 0;
    13463. 

  13463.      break;
    13464. 

  13464.     } else {
    13465. 

  13465.      i4 = HEAP32[i10 >> 2] | 0;
    13466. 

  13466.      if ((i4 | 0) > 31) {
    13467. 

  13467.       _luaL_error(HEAP32[i9 >> 2] | 0, 7200, i8) | 0;
    13468. 

  13468.      }
    13469. 

  13469.      HEAP32[i1 + (i4 << 3) + 24 >> 2] = i12;
    13470. 

  13470.      HEAP32[i1 + (i4 << 3) + 28 >> 2] = -1;
    13471. 

  13471.      HEAP32[i10 >> 2] = i4 + 1;
    13472. 

  13472.      i12 = _match(i1, i12, i3) | 0;
    13473. 

  13473.      if ((i12 | 0) != 0) {
    13474. 

  13474.       break;
    13475. 

  13475.      }
    13476. 

  13476.      HEAP32[i10 >> 2] = (HEAP32[i10 >> 2] | 0) + -1;
    13477. 

  13477.      i12 = 0;
    13478. 

  13478.      break;
    13479. 

  13479.     }
    13480. 

  13480.    } else if ((i7 | 0) == 16) {
    13481. 

  13481.     i3 = i11 + 1 | 0;
    13482. 

  13482.     i5 = HEAP32[i10 >> 2] | 0;
    13483. 

  13483.     while (1) {
    13484. 

  13484.      i4 = i5 + -1 | 0;
    13485. 

  13485.      if ((i5 | 0) <= 0) {
    13486. 

  13486.       i7 = 19;
    13487. 

  13487.       break;
    13488. 

  13488.      }
    13489. 

  13489.      if ((HEAP32[i1 + (i4 << 3) + 28 >> 2] | 0) == -1) {
    13490. 

  13490.       break;
    13491. 

  13491.      } else {
    13492. 

  13492.       i5 = i4;
    13493. 

  13493.      }
    13494. 

  13494.     }
    13495. 

  13495.     if ((i7 | 0) == 19) {
    13496. 

  13496.      i4 = _luaL_error(HEAP32[i9 >> 2] | 0, 7488, i8) | 0;
    13497. 

  13497.     }
    13498. 

  13498.     i5 = i1 + (i4 << 3) + 28 | 0;
    13499. 

  13499.     HEAP32[i5 >> 2] = i12 - (HEAP32[i1 + (i4 << 3) + 24 >> 2] | 0);
    13500. 

  13500.     i12 = _match(i1, i12, i3) | 0;
    13501. 

  13501.     if ((i12 | 0) != 0) {
    13502. 

  13502.      break;
    13503. 

  13503.     }
    13504. 

  13504.     HEAP32[i5 >> 2] = -1;
    13505. 

  13505.     i12 = 0;
    13506. 

  13506.     break;
    13507. 

  13507.    } else if ((i7 | 0) == 23) {
    13508. 

  13508.     i12 = (i12 | 0) == (HEAP32[i3 >> 2] | 0) ? i12 : 0;
    13509. 

  13509.     break;
    13510. 

  13510.    } else if ((i7 | 0) == 109) {
    13511. 

  13511.     i4 = i22 + 1 | 0;
    13512. 

  13512.     i8 = _match(i1, i12, i4) | 0;
    13513. 

  13513.     if ((i8 | 0) != 0) {
    13514. 

  13514.      i12 = i8;
    13515. 

  13515.      break;
    13516. 

  13516.     }
    13517. 

  13517.     i8 = i22 + -1 | 0;
    13518. 

  13518.     while (1) {
    13519. 

  13519.      if (!((HEAP32[i3 >> 2] | 0) >>> 0 > i12 >>> 0)) {
    13520. 

  13520.       i12 = 0;
    13521. 

  13521.       break L4;
    13522. 

  13522.      }
    13523. 

  13523.      i9 = HEAP8[i12] | 0;
    13524. 

  13524.      i10 = i9 & 255;
    13525. 

  13525.      i14 = HEAP8[i11] | 0;
    13526. 

  13526.      i13 = i14 << 24 >> 24;
    13527. 

  13527.      L139 : do {
    13528. 

  13528.       if ((i13 | 0) == 91) {
    13529. 

  13529.        i6 = (HEAP8[i21] | 0) == 94;
    13530. 

  13530.        i13 = i6 ? i21 : i11;
    13531. 

  13531.        i6 = i6 & 1;
    13532. 

  13532.        i7 = i6 ^ 1;
    13533. 

  13533.        i14 = i13 + 1 | 0;
    13534. 

  13534.        if (i14 >>> 0 < i8 >>> 0) {
    13535. 

  13535.         while (1) {
    13536. 

  13536.          i17 = HEAP8[i14] | 0;
    13537. 

  13537.          i15 = i13 + 2 | 0;
    13538. 

  13538.          i16 = HEAP8[i15] | 0;
    13539. 

  13539.          do {
    13540. 

  13540.           if (i17 << 24 >> 24 == 37) {
    13541. 

  13541.            if ((_match_class(i10, i16 & 255) | 0) == 0) {
    13542. 

  13542.             i13 = i15;
    13543. 

  13543.            } else {
    13544. 

  13544.             i6 = i7;
    13545. 

  13545.             i7 = 147;
    13546. 

  13546.             break L139;
    13547. 

  13547.            }
    13548. 

  13548.           } else {
    13549. 

  13549.            if (i16 << 24 >> 24 == 45 ? (i5 = i13 + 3 | 0, i5 >>> 0 < i8 >>> 0) : 0) {
    13550. 

  13550.             if ((i17 & 255) > (i9 & 255)) {
    13551. 

  13551.              i13 = i5;
    13552. 

  13552.              break;
    13553. 

  13553.             }
    13554. 

  13554.             if ((HEAPU8[i5] | 0) < (i9 & 255)) {
    13555. 

  13555.              i13 = i5;
    13556. 

  13556.              break;
    13557. 

  13557.             } else {
    13558. 

  13558.              i6 = i7;
    13559. 

  13559.              i7 = 147;
    13560. 

  13560.              break L139;
    13561. 

  13561.             }
    13562. 

  13562.            }
    13563. 

  13563.            if (i17 << 24 >> 24 == i9 << 24 >> 24) {
    13564. 

  13564.             i6 = i7;
    13565. 

  13565.             i7 = 147;
    13566. 

  13566.             break L139;
    13567. 

  13567.            } else {
    13568. 

  13568.             i13 = i14;
    13569. 

  13569.            }
    13570. 

  13570.           }
    13571. 

  13571.          } while (0);
    13572. 

  13572.          i14 = i13 + 1 | 0;
    13573. 

  13573.          if (!(i14 >>> 0 < i8 >>> 0)) {
    13574. 

  13574.           i7 = 147;
    13575. 

  13575.           break;
    13576. 

  13576.          }
    13577. 

  13577.         }
    13578. 

  13578.        } else {
    13579. 

  13579.         i7 = 147;
    13580. 

  13580.        }
    13581. 

  13581.       } else if ((i13 | 0) == 37) {
    13582. 

  13582.        i6 = _match_class(i10, HEAPU8[i21] | 0) | 0;
    13583. 

  13583.        i7 = 147;
    13584. 

  13584.       } else if ((i13 | 0) != 46) {
    13585. 

  13585.        i6 = i14 << 24 >> 24 == i9 << 24 >> 24 | 0;
    13586. 

  13586.        i7 = 147;
    13587. 

  13587.       }
    13588. 

  13588.      } while (0);
    13589. 

  13589.      if ((i7 | 0) == 147 ? (i7 = 0, (i6 | 0) == 0) : 0) {
    13590. 

  13590.       i12 = 0;
    13591. 

  13591.       break L4;
    13592. 

  13592.      }
    13593. 

  13593.      i9 = i12 + 1 | 0;
    13594. 

  13594.      i12 = _match(i1, i9, i4) | 0;
    13595. 

  13595.      if ((i12 | 0) == 0) {
    13596. 

  13596.       i12 = i9;
    13597. 

  13597.      } else {
    13598. 

  13598.       break L4;
    13599. 

  13599.      }
    13600. 

  13600.     }
    13601. 

  13601.    } else if ((i7 | 0) == 112) {
    13602. 

  13602.     i19 = i12;
    13603. 

  13603.    }
    13604. 

  13604.    i10 = HEAP32[i3 >> 2] | 0;
    13605. 

  13605.    if (i10 >>> 0 > i19 >>> 0) {
    13606. 

  13606.     i5 = i22 + -1 | 0;
    13607. 

  13607.     i8 = i19;
    13608. 

  13608.     i6 = 0;
    13609. 

  13609.     do {
    13610. 

  13610.      i8 = HEAP8[i8] | 0;
    13611. 

  13611.      i9 = i8 & 255;
    13612. 

  13612.      i13 = HEAP8[i11] | 0;
    13613. 

  13613.      i12 = i13 << 24 >> 24;
    13614. 

  13614.      L183 : do {
    13615. 

  13615.       if ((i12 | 0) == 37) {
    13616. 

  13616.        i10 = _match_class(i9, HEAPU8[i21] | 0) | 0;
    13617. 

  13617.        i7 = 129;
    13618. 

  13618.       } else if ((i12 | 0) == 91) {
    13619. 

  13619.        i7 = (HEAP8[i21] | 0) == 94;
    13620. 

  13620.        i12 = i7 ? i21 : i11;
    13621. 

  13621.        i10 = i7 & 1;
    13622. 

  13622.        i7 = i10 ^ 1;
    13623. 

  13623.        i13 = i12 + 1 | 0;
    13624. 

  13624.        if (i13 >>> 0 < i5 >>> 0) {
    13625. 

  13625.         while (1) {
    13626. 

  13626.          i14 = HEAP8[i13] | 0;
    13627. 

  13627.          i16 = i12 + 2 | 0;
    13628. 

  13628.          i15 = HEAP8[i16] | 0;
    13629. 

  13629.          do {
    13630. 

  13630.           if (i14 << 24 >> 24 == 37) {
    13631. 

  13631.            if ((_match_class(i9, i15 & 255) | 0) == 0) {
    13632. 

  13632.             i12 = i16;
    13633. 

  13633.            } else {
    13634. 

  13634.             i10 = i7;
    13635. 

  13635.             i7 = 129;
    13636. 

  13636.             break L183;
    13637. 

  13637.            }
    13638. 

  13638.           } else {
    13639. 

  13639.            if (i15 << 24 >> 24 == 45 ? (i4 = i12 + 3 | 0, i4 >>> 0 < i5 >>> 0) : 0) {
    13640. 

  13640.             if ((i14 & 255) > (i8 & 255)) {
    13641. 

  13641.              i12 = i4;
    13642. 

  13642.              break;
    13643. 

  13643.             }
    13644. 

  13644.             if ((HEAPU8[i4] | 0) < (i8 & 255)) {
    13645. 

  13645.              i12 = i4;
    13646. 

  13646.              break;
    13647. 

  13647.             } else {
    13648. 

  13648.              i10 = i7;
    13649. 

  13649.              i7 = 129;
    13650. 

  13650.              break L183;
    13651. 

  13651.             }
    13652. 

  13652.            }
    13653. 

  13653.            if (i14 << 24 >> 24 == i8 << 24 >> 24) {
    13654. 

  13654.             i10 = i7;
    13655. 

  13655.             i7 = 129;
    13656. 

  13656.             break L183;
    13657. 

  13657.            } else {
    13658. 

  13658.             i12 = i13;
    13659. 

  13659.            }
    13660. 

  13660.           }
    13661. 

  13661.          } while (0);
    13662. 

  13662.          i13 = i12 + 1 | 0;
    13663. 

  13663.          if (!(i13 >>> 0 < i5 >>> 0)) {
    13664. 

  13664.           i7 = 129;
    13665. 

  13665.           break;
    13666. 

  13666.          }
    13667. 

  13667.         }
    13668. 

  13668.        } else {
    13669. 

  13669.         i7 = 129;
    13670. 

  13670.        }
    13671. 

  13671.       } else if ((i12 | 0) != 46) {
    13672. 

  13672.        i10 = i13 << 24 >> 24 == i8 << 24 >> 24 | 0;
    13673. 

  13673.        i7 = 129;
    13674. 

  13674.       }
    13675. 

  13675.      } while (0);
    13676. 

  13676.      if ((i7 | 0) == 129) {
    13677. 

  13677.       i7 = 0;
    13678. 

  13678.       if ((i10 | 0) == 0) {
    13679. 

  13679.        break;
    13680. 

  13680.       }
    13681. 

  13681.       i10 = HEAP32[i3 >> 2] | 0;
    13682. 

  13682.      }
    13683. 

  13683.      i6 = i6 + 1 | 0;
    13684. 

  13684.      i8 = i19 + i6 | 0;
    13685. 

  13685.     } while (i10 >>> 0 > i8 >>> 0);
    13686. 

  13686.     if (!((i6 | 0) > -1)) {
    13687. 

  13687.      i12 = 0;
    13688. 

  13688.      break;
    13689. 

  13689.     }
    13690. 

  13690.    } else {
    13691. 

  13691.     i6 = 0;
    13692. 

  13692.    }
    13693. 

  13693.    i3 = i22 + 1 | 0;
    13694. 

  13694.    while (1) {
    13695. 

  13695.     i12 = _match(i1, i19 + i6 | 0, i3) | 0;
    13696. 

  13696.     if ((i12 | 0) != 0) {
    13697. 

  13697.      break L4;
    13698. 

  13698.     }
    13699. 

  13699.     if ((i6 | 0) > 0) {
    13700. 

  13700.      i6 = i6 + -1 | 0;
    13701. 

  13701.     } else {
    13702. 

  13702.      i12 = 0;
    13703. 

  13703.      break;
    13704. 

  13704.     }
    13705. 

  13705.    }
    13706. 

  13706.   }
    13707. 

  13707.  } while (0);
    13708. 

  13708.  HEAP32[i1 >> 2] = (HEAP32[i1 >> 2] | 0) + 1;
    13709. 

  13709.  STACKTOP = i2;
    13710. 

  13710.  return i12 | 0;
    13711. 

  13711. }
    13712. 

  13712. function _free(i7) {
    13713. 

  13713.  i7 = i7 | 0;
    13714. 

  13714.  var i1 = 0, i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0, i14 = 0, i15 = 0, i16 = 0, i17 = 0, i18 = 0, i19 = 0, i20 = 0, i21 = 0;
    13715. 

  13715.  i1 = STACKTOP;
    13716. 

  13716.  if ((i7 | 0) == 0) {
    13717. 

  13717.   STACKTOP = i1;
    13718. 

  13718.   return;
    13719. 

  13719.  }
    13720. 

  13720.  i15 = i7 + -8 | 0;
    13721. 

  13721.  i16 = HEAP32[12928 >> 2] | 0;
    13722. 

  13722.  if (i15 >>> 0 < i16 >>> 0) {
    13723. 

  13723.   _abort();
    13724. 

  13724.  }
    13725. 

  13725.  i13 = HEAP32[i7 + -4 >> 2] | 0;
    13726. 

  13726.  i12 = i13 & 3;
    13727. 

  13727.  if ((i12 | 0) == 1) {
    13728. 

  13728.   _abort();
    13729. 

  13729.  }
    13730. 

  13730.  i8 = i13 & -8;
    13731. 

  13731.  i6 = i7 + (i8 + -8) | 0;
    13732. 

  13732.  do {
    13733. 

  13733.   if ((i13 & 1 | 0) == 0) {
    13734. 

  13734.    i19 = HEAP32[i15 >> 2] | 0;
    13735. 

  13735.    if ((i12 | 0) == 0) {
    13736. 

  13736.     STACKTOP = i1;
    13737. 

  13737.     return;
    13738. 

  13738.    }
    13739. 

  13739.    i15 = -8 - i19 | 0;
    13740. 

  13740.    i13 = i7 + i15 | 0;
    13741. 

  13741.    i12 = i19 + i8 | 0;
    13742. 

  13742.    if (i13 >>> 0 < i16 >>> 0) {
    13743. 

  13743.     _abort();
    13744. 

  13744.    }
    13745. 

  13745.    if ((i13 | 0) == (HEAP32[12932 >> 2] | 0)) {
    13746. 

  13746.     i2 = i7 + (i8 + -4) | 0;
    13747. 

  13747.     if ((HEAP32[i2 >> 2] & 3 | 0) != 3) {
    13748. 

  13748.      i2 = i13;
    13749. 

  13749.      i11 = i12;
    13750. 

  13750.      break;
    13751. 

  13751.     }
    13752. 

  13752.     HEAP32[12920 >> 2] = i12;
    13753. 

  13753.     HEAP32[i2 >> 2] = HEAP32[i2 >> 2] & -2;
    13754. 

  13754.     HEAP32[i7 + (i15 + 4) >> 2] = i12 | 1;
    13755. 

  13755.     HEAP32[i6 >> 2] = i12;
    13756. 

  13756.     STACKTOP = i1;
    13757. 

  13757.     return;
    13758. 

  13758.    }
    13759. 

  13759.    i18 = i19 >>> 3;
    13760. 

  13760.    if (i19 >>> 0 < 256) {
    13761. 

  13761.     i2 = HEAP32[i7 + (i15 + 8) >> 2] | 0;
    13762. 

  13762.     i11 = HEAP32[i7 + (i15 + 12) >> 2] | 0;
    13763. 

  13763.     i14 = 12952 + (i18 << 1 << 2) | 0;
    13764. 

  13764.     if ((i2 | 0) != (i14 | 0)) {
    13765. 

  13765.      if (i2 >>> 0 < i16 >>> 0) {
    13766. 

  13766.       _abort();
    13767. 

  13767.      }
    13768. 

  13768.      if ((HEAP32[i2 + 12 >> 2] | 0) != (i13 | 0)) {
    13769. 

  13769.       _abort();
    13770. 

  13770.      }
    13771. 

  13771.     }
    13772. 

  13772.     if ((i11 | 0) == (i2 | 0)) {
    13773. 

  13773.      HEAP32[3228] = HEAP32[3228] & ~(1 << i18);
    13774. 

  13774.      i2 = i13;
    13775. 

  13775.      i11 = i12;
    13776. 

  13776.      break;
    13777. 

  13777.     }
    13778. 

  13778.     if ((i11 | 0) != (i14 | 0)) {
    13779. 

  13779.      if (i11 >>> 0 < i16 >>> 0) {
    13780. 

  13780.       _abort();
    13781. 

  13781.      }
    13782. 

  13782.      i14 = i11 + 8 | 0;
    13783. 

  13783.      if ((HEAP32[i14 >> 2] | 0) == (i13 | 0)) {
    13784. 

  13784.       i17 = i14;
    13785. 

  13785.      } else {
    13786. 

  13786.       _abort();
    13787. 

  13787.      }
    13788. 

  13788.     } else {
    13789. 

  13789.      i17 = i11 + 8 | 0;
    13790. 

  13790.     }
    13791. 

  13791.     HEAP32[i2 + 12 >> 2] = i11;
    13792. 

  13792.     HEAP32[i17 >> 2] = i2;
    13793. 

  13793.     i2 = i13;
    13794. 

  13794.     i11 = i12;
    13795. 

  13795.     break;
    13796. 

  13796.    }
    13797. 

  13797.    i17 = HEAP32[i7 + (i15 + 24) >> 2] | 0;
    13798. 

  13798.    i18 = HEAP32[i7 + (i15 + 12) >> 2] | 0;
    13799. 

  13799.    do {
    13800. 

  13800.     if ((i18 | 0) == (i13 | 0)) {
    13801. 

  13801.      i19 = i7 + (i15 + 20) | 0;
    13802. 

  13802.      i18 = HEAP32[i19 >> 2] | 0;
    13803. 

  13803.      if ((i18 | 0) == 0) {
    13804. 

  13804.       i19 = i7 + (i15 + 16) | 0;
    13805. 

  13805.       i18 = HEAP32[i19 >> 2] | 0;
    13806. 

  13806.       if ((i18 | 0) == 0) {
    13807. 

  13807.        i14 = 0;
    13808. 

  13808.        break;
    13809. 

  13809.       }
    13810. 

  13810.      }
    13811. 

  13811.      while (1) {
    13812. 

  13812.       i21 = i18 + 20 | 0;
    13813. 

  13813.       i20 = HEAP32[i21 >> 2] | 0;
    13814. 

  13814.       if ((i20 | 0) != 0) {
    13815. 

  13815.        i18 = i20;
    13816. 

  13816.        i19 = i21;
    13817. 

  13817.        continue;
    13818. 

  13818.       }
    13819. 

  13819.       i20 = i18 + 16 | 0;
    13820. 

  13820.       i21 = HEAP32[i20 >> 2] | 0;
    13821. 

  13821.       if ((i21 | 0) == 0) {
    13822. 

  13822.        break;
    13823. 

  13823.       } else {
    13824. 

  13824.        i18 = i21;
    13825. 

  13825.        i19 = i20;
    13826. 

  13826.       }
    13827. 

  13827.      }
    13828. 

  13828.      if (i19 >>> 0 < i16 >>> 0) {
    13829. 

  13829.       _abort();
    13830. 

  13830.      } else {
    13831. 

  13831.       HEAP32[i19 >> 2] = 0;
    13832. 

  13832.       i14 = i18;
    13833. 

  13833.       break;
    13834. 

  13834.      }
    13835. 

  13835.     } else {
    13836. 

  13836.      i19 = HEAP32[i7 + (i15 + 8) >> 2] | 0;
    13837. 

  13837.      if (i19 >>> 0 < i16 >>> 0) {
    13838. 

  13838.       _abort();
    13839. 

  13839.      }
    13840. 

  13840.      i16 = i19 + 12 | 0;
    13841. 

  13841.      if ((HEAP32[i16 >> 2] | 0) != (i13 | 0)) {
    13842. 

  13842.       _abort();
    13843. 

  13843.      }
    13844. 

  13844.      i20 = i18 + 8 | 0;
    13845. 

  13845.      if ((HEAP32[i20 >> 2] | 0) == (i13 | 0)) {
    13846. 

  13846.       HEAP32[i16 >> 2] = i18;
    13847. 

  13847.       HEAP32[i20 >> 2] = i19;
    13848. 

  13848.       i14 = i18;
    13849. 

  13849.       break;
    13850. 

  13850.      } else {
    13851. 

  13851.       _abort();
    13852. 

  13852.      }
    13853. 

  13853.     }
    13854. 

  13854.    } while (0);
    13855. 

  13855.    if ((i17 | 0) != 0) {
    13856. 

  13856.     i18 = HEAP32[i7 + (i15 + 28) >> 2] | 0;
    13857. 

  13857.     i16 = 13216 + (i18 << 2) | 0;
    13858. 

  13858.     if ((i13 | 0) == (HEAP32[i16 >> 2] | 0)) {
    13859. 

  13859.      HEAP32[i16 >> 2] = i14;
    13860. 

  13860.      if ((i14 | 0) == 0) {
    13861. 

  13861.       HEAP32[12916 >> 2] = HEAP32[12916 >> 2] & ~(1 << i18);
    13862. 

  13862.       i2 = i13;
    13863. 

  13863.       i11 = i12;
    13864. 

  13864.       break;
    13865. 

  13865.      }
    13866. 

  13866.     } else {
    13867. 

  13867.      if (i17 >>> 0 < (HEAP32[12928 >> 2] | 0) >>> 0) {
    13868. 

  13868.       _abort();
    13869. 

  13869.      }
    13870. 

  13870.      i16 = i17 + 16 | 0;
    13871. 

  13871.      if ((HEAP32[i16 >> 2] | 0) == (i13 | 0)) {
    13872. 

  13872.       HEAP32[i16 >> 2] = i14;
    13873. 

  13873.      } else {
    13874. 

  13874.       HEAP32[i17 + 20 >> 2] = i14;
    13875. 

  13875.      }
    13876. 

  13876.      if ((i14 | 0) == 0) {
    13877. 

  13877.       i2 = i13;
    13878. 

  13878.       i11 = i12;
    13879. 

  13879.       break;
    13880. 

  13880.      }
    13881. 

  13881.     }
    13882. 

  13882.     if (i14 >>> 0 < (HEAP32[12928 >> 2] | 0) >>> 0) {
    13883. 

  13883.      _abort();
    13884. 

  13884.     }
    13885. 

  13885.     HEAP32[i14 + 24 >> 2] = i17;
    13886. 

  13886.     i16 = HEAP32[i7 + (i15 + 16) >> 2] | 0;
    13887. 

  13887.     do {
    13888. 

  13888.      if ((i16 | 0) != 0) {
    13889. 

  13889.       if (i16 >>> 0 < (HEAP32[12928 >> 2] | 0) >>> 0) {
    13890. 

  13890.        _abort();
    13891. 

  13891.       } else {
    13892. 

  13892.        HEAP32[i14 + 16 >> 2] = i16;
    13893. 

  13893.        HEAP32[i16 + 24 >> 2] = i14;
    13894. 

  13894.        break;
    13895. 

  13895.       }
    13896. 

  13896.      }
    13897. 

  13897.     } while (0);
    13898. 

  13898.     i15 = HEAP32[i7 + (i15 + 20) >> 2] | 0;
    13899. 

  13899.     if ((i15 | 0) != 0) {
    13900. 

  13900.      if (i15 >>> 0 < (HEAP32[12928 >> 2] | 0) >>> 0) {
    13901. 

  13901.       _abort();
    13902. 

  13902.      } else {
    13903. 

  13903.       HEAP32[i14 + 20 >> 2] = i15;
    13904. 

  13904.       HEAP32[i15 + 24 >> 2] = i14;
    13905. 

  13905.       i2 = i13;
    13906. 

  13906.       i11 = i12;
    13907. 

  13907.       break;
    13908. 

  13908.      }
    13909. 

  13909.     } else {
    13910. 

  13910.      i2 = i13;
    13911. 

  13911.      i11 = i12;
    13912. 

  13912.     }
    13913. 

  13913.    } else {
    13914. 

  13914.     i2 = i13;
    13915. 

  13915.     i11 = i12;
    13916. 

  13916.    }
    13917. 

  13917.   } else {
    13918. 

  13918.    i2 = i15;
    13919. 

  13919.    i11 = i8;
    13920. 

  13920.   }
    13921. 

  13921.  } while (0);
    13922. 

  13922.  if (!(i2 >>> 0 < i6 >>> 0)) {
    13923. 

  13923.   _abort();
    13924. 

  13924.  }
    13925. 

  13925.  i12 = i7 + (i8 + -4) | 0;
    13926. 

  13926.  i13 = HEAP32[i12 >> 2] | 0;
    13927. 

  13927.  if ((i13 & 1 | 0) == 0) {
    13928. 

  13928.   _abort();
    13929. 

  13929.  }
    13930. 

  13930.  if ((i13 & 2 | 0) == 0) {
    13931. 

  13931.   if ((i6 | 0) == (HEAP32[12936 >> 2] | 0)) {
    13932. 

  13932.    i21 = (HEAP32[12924 >> 2] | 0) + i11 | 0;
    13933. 

  13933.    HEAP32[12924 >> 2] = i21;
    13934. 

  13934.    HEAP32[12936 >> 2] = i2;
    13935. 

  13935.    HEAP32[i2 + 4 >> 2] = i21 | 1;
    13936. 

  13936.    if ((i2 | 0) != (HEAP32[12932 >> 2] | 0)) {
    13937. 

  13937.     STACKTOP = i1;
    13938. 

  13938.     return;
    13939. 

  13939.    }
    13940. 

  13940.    HEAP32[12932 >> 2] = 0;
    13941. 

  13941.    HEAP32[12920 >> 2] = 0;
    13942. 

  13942.    STACKTOP = i1;
    13943. 

  13943.    return;
    13944. 

  13944.   }
    13945. 

  13945.   if ((i6 | 0) == (HEAP32[12932 >> 2] | 0)) {
    13946. 

  13946.    i21 = (HEAP32[12920 >> 2] | 0) + i11 | 0;
    13947. 

  13947.    HEAP32[12920 >> 2] = i21;
    13948. 

  13948.    HEAP32[12932 >> 2] = i2;
    13949. 

  13949.    HEAP32[i2 + 4 >> 2] = i21 | 1;
    13950. 

  13950.    HEAP32[i2 + i21 >> 2] = i21;
    13951. 

  13951.    STACKTOP = i1;
    13952. 

  13952.    return;
    13953. 

  13953.   }
    13954. 

  13954.   i11 = (i13 & -8) + i11 | 0;
    13955. 

  13955.   i12 = i13 >>> 3;
    13956. 

  13956.   do {
    13957. 

  13957.    if (!(i13 >>> 0 < 256)) {
    13958. 

  13958.     i10 = HEAP32[i7 + (i8 + 16) >> 2] | 0;
    13959. 

  13959.     i15 = HEAP32[i7 + (i8 | 4) >> 2] | 0;
    13960. 

  13960.     do {
    13961. 

  13961.      if ((i15 | 0) == (i6 | 0)) {
    13962. 

  13962.       i13 = i7 + (i8 + 12) | 0;
    13963. 

  13963.       i12 = HEAP32[i13 >> 2] | 0;
    13964. 

  13964.       if ((i12 | 0) == 0) {
    13965. 

  13965.        i13 = i7 + (i8 + 8) | 0;
    13966. 

  13966.        i12 = HEAP32[i13 >> 2] | 0;
    13967. 

  13967.        if ((i12 | 0) == 0) {
    13968. 

  13968.         i9 = 0;
    13969. 

  13969.         break;
    13970. 

  13970.        }
    13971. 

  13971.       }
    13972. 

  13972.       while (1) {
    13973. 

  13973.        i14 = i12 + 20 | 0;
    13974. 

  13974.        i15 = HEAP32[i14 >> 2] | 0;
    13975. 

  13975.        if ((i15 | 0) != 0) {
    13976. 

  13976.         i12 = i15;
    13977. 

  13977.         i13 = i14;
    13978. 

  13978.         continue;
    13979. 

  13979.        }
    13980. 

  13980.        i14 = i12 + 16 | 0;
    13981. 

  13981.        i15 = HEAP32[i14 >> 2] | 0;
    13982. 

  13982.        if ((i15 | 0) == 0) {
    13983. 

  13983.         break;
    13984. 

  13984.        } else {
    13985. 

  13985.         i12 = i15;
    13986. 

  13986.         i13 = i14;
    13987. 

  13987.        }
    13988. 

  13988.       }
    13989. 

  13989.       if (i13 >>> 0 < (HEAP32[12928 >> 2] | 0) >>> 0) {
    13990. 

  13990.        _abort();
    13991. 

  13991.       } else {
    13992. 

  13992.        HEAP32[i13 >> 2] = 0;
    13993. 

  13993.        i9 = i12;
    13994. 

  13994.        break;
    13995. 

  13995.       }
    13996. 

  13996.      } else {
    13997. 

  13997.       i13 = HEAP32[i7 + i8 >> 2] | 0;
    13998. 

  13998.       if (i13 >>> 0 < (HEAP32[12928 >> 2] | 0) >>> 0) {
    13999. 

  13999.        _abort();
    14000. 

  14000.       }
    14001. 

  14001.       i14 = i13 + 12 | 0;
    14002. 

  14002.       if ((HEAP32[i14 >> 2] | 0) != (i6 | 0)) {
    14003. 

  14003.        _abort();
    14004. 

  14004.       }
    14005. 

  14005.       i12 = i15 + 8 | 0;
    14006. 

  14006.       if ((HEAP32[i12 >> 2] | 0) == (i6 | 0)) {
    14007. 

  14007.        HEAP32[i14 >> 2] = i15;
    14008. 

  14008.        HEAP32[i12 >> 2] = i13;
    14009. 

  14009.        i9 = i15;
    14010. 

  14010.        break;
    14011. 

  14011.       } else {
    14012. 

  14012.        _abort();
    14013. 

  14013.       }
    14014. 

  14014.      }
    14015. 

  14015.     } while (0);
    14016. 

  14016.     if ((i10 | 0) != 0) {
    14017. 

  14017.      i12 = HEAP32[i7 + (i8 + 20) >> 2] | 0;
    14018. 

  14018.      i13 = 13216 + (i12 << 2) | 0;
    14019. 

  14019.      if ((i6 | 0) == (HEAP32[i13 >> 2] | 0)) {
    14020. 

  14020.       HEAP32[i13 >> 2] = i9;
    14021. 

  14021.       if ((i9 | 0) == 0) {
    14022. 

  14022.        HEAP32[12916 >> 2] = HEAP32[12916 >> 2] & ~(1 << i12);
    14023. 

  14023.        break;
    14024. 

  14024.       }
    14025. 

  14025.      } else {
    14026. 

  14026.       if (i10 >>> 0 < (HEAP32[12928 >> 2] | 0) >>> 0) {
    14027. 

  14027.        _abort();
    14028. 

  14028.       }
    14029. 

  14029.       i12 = i10 + 16 | 0;
    14030. 

  14030.       if ((HEAP32[i12 >> 2] | 0) == (i6 | 0)) {
    14031. 

  14031.        HEAP32[i12 >> 2] = i9;
    14032. 

  14032.       } else {
    14033. 

  14033.        HEAP32[i10 + 20 >> 2] = i9;
    14034. 

  14034.       }
    14035. 

  14035.       if ((i9 | 0) == 0) {
    14036. 

  14036.        break;
    14037. 

  14037.       }
    14038. 

  14038.      }
    14039. 

  14039.      if (i9 >>> 0 < (HEAP32[12928 >> 2] | 0) >>> 0) {
    14040. 

  14040.       _abort();
    14041. 

  14041.      }
    14042. 

  14042.      HEAP32[i9 + 24 >> 2] = i10;
    14043. 

  14043.      i6 = HEAP32[i7 + (i8 + 8) >> 2] | 0;
    14044. 

  14044.      do {
    14045. 

  14045.       if ((i6 | 0) != 0) {
    14046. 

  14046.        if (i6 >>> 0 < (HEAP32[12928 >> 2] | 0) >>> 0) {
    14047. 

  14047.         _abort();
    14048. 

  14048.        } else {
    14049. 

  14049.         HEAP32[i9 + 16 >> 2] = i6;
    14050. 

  14050.         HEAP32[i6 + 24 >> 2] = i9;
    14051. 

  14051.         break;
    14052. 

  14052.        }
    14053. 

  14053.       }
    14054. 

  14054.      } while (0);
    14055. 

  14055.      i6 = HEAP32[i7 + (i8 + 12) >> 2] | 0;
    14056. 

  14056.      if ((i6 | 0) != 0) {
    14057. 

  14057.       if (i6 >>> 0 < (HEAP32[12928 >> 2] | 0) >>> 0) {
    14058. 

  14058.        _abort();
    14059. 

  14059.       } else {
    14060. 

  14060.        HEAP32[i9 + 20 >> 2] = i6;
    14061. 

  14061.        HEAP32[i6 + 24 >> 2] = i9;
    14062. 

  14062.        break;
    14063. 

  14063.       }
    14064. 

  14064.      }
    14065. 

  14065.     }
    14066. 

  14066.    } else {
    14067. 

  14067.     i9 = HEAP32[i7 + i8 >> 2] | 0;
    14068. 

  14068.     i7 = HEAP32[i7 + (i8 | 4) >> 2] | 0;
    14069. 

  14069.     i8 = 12952 + (i12 << 1 << 2) | 0;
    14070. 

  14070.     if ((i9 | 0) != (i8 | 0)) {
    14071. 

  14071.      if (i9 >>> 0 < (HEAP32[12928 >> 2] | 0) >>> 0) {
    14072. 

  14072.       _abort();
    14073. 

  14073.      }
    14074. 

  14074.      if ((HEAP32[i9 + 12 >> 2] | 0) != (i6 | 0)) {
    14075. 

  14075.       _abort();
    14076. 

  14076.      }
    14077. 

  14077.     }
    14078. 

  14078.     if ((i7 | 0) == (i9 | 0)) {
    14079. 

  14079.      HEAP32[3228] = HEAP32[3228] & ~(1 << i12);
    14080. 

  14080.      break;
    14081. 

  14081.     }
    14082. 

  14082.     if ((i7 | 0) != (i8 | 0)) {
    14083. 

  14083.      if (i7 >>> 0 < (HEAP32[12928 >> 2] | 0) >>> 0) {
    14084. 

  14084.       _abort();
    14085. 

  14085.      }
    14086. 

  14086.      i8 = i7 + 8 | 0;
    14087. 

  14087.      if ((HEAP32[i8 >> 2] | 0) == (i6 | 0)) {
    14088. 

  14088.       i10 = i8;
    14089. 

  14089.      } else {
    14090. 

  14090.       _abort();
    14091. 

  14091.      }
    14092. 

  14092.     } else {
    14093. 

  14093.      i10 = i7 + 8 | 0;
    14094. 

  14094.     }
    14095. 

  14095.     HEAP32[i9 + 12 >> 2] = i7;
    14096. 

  14096.     HEAP32[i10 >> 2] = i9;
    14097. 

  14097.    }
    14098. 

  14098.   } while (0);
    14099. 

  14099.   HEAP32[i2 + 4 >> 2] = i11 | 1;
    14100. 

  14100.   HEAP32[i2 + i11 >> 2] = i11;
    14101. 

  14101.   if ((i2 | 0) == (HEAP32[12932 >> 2] | 0)) {
    14102. 

  14102.    HEAP32[12920 >> 2] = i11;
    14103. 

  14103.    STACKTOP = i1;
    14104. 

  14104.    return;
    14105. 

  14105.   }
    14106. 

  14106.  } else {
    14107. 

  14107.   HEAP32[i12 >> 2] = i13 & -2;
    14108. 

  14108.   HEAP32[i2 + 4 >> 2] = i11 | 1;
    14109. 

  14109.   HEAP32[i2 + i11 >> 2] = i11;
    14110. 

  14110.  }
    14111. 

  14111.  i6 = i11 >>> 3;
    14112. 

  14112.  if (i11 >>> 0 < 256) {
    14113. 

  14113.   i7 = i6 << 1;
    14114. 

  14114.   i3 = 12952 + (i7 << 2) | 0;
    14115. 

  14115.   i8 = HEAP32[3228] | 0;
    14116. 

  14116.   i6 = 1 << i6;
    14117. 

  14117.   if ((i8 & i6 | 0) != 0) {
    14118. 

  14118.    i6 = 12952 + (i7 + 2 << 2) | 0;
    14119. 

  14119.    i7 = HEAP32[i6 >> 2] | 0;
    14120. 

  14120.    if (i7 >>> 0 < (HEAP32[12928 >> 2] | 0) >>> 0) {
    14121. 

  14121.     _abort();
    14122. 

  14122.    } else {
    14123. 

  14123.     i4 = i6;
    14124. 

  14124.     i5 = i7;
    14125. 

  14125.    }
    14126. 

  14126.   } else {
    14127. 

  14127.    HEAP32[3228] = i8 | i6;
    14128. 

  14128.    i4 = 12952 + (i7 + 2 << 2) | 0;
    14129. 

  14129.    i5 = i3;
    14130. 

  14130.   }
    14131. 

  14131.   HEAP32[i4 >> 2] = i2;
    14132. 

  14132.   HEAP32[i5 + 12 >> 2] = i2;
    14133. 

  14133.   HEAP32[i2 + 8 >> 2] = i5;
    14134. 

  14134.   HEAP32[i2 + 12 >> 2] = i3;
    14135. 

  14135.   STACKTOP = i1;
    14136. 

  14136.   return;
    14137. 

  14137.  }
    14138. 

  14138.  i4 = i11 >>> 8;
    14139. 

  14139.  if ((i4 | 0) != 0) {
    14140. 

  14140.   if (i11 >>> 0 > 16777215) {
    14141. 

  14141.    i4 = 31;
    14142. 

  14142.   } else {
    14143. 

  14143.    i20 = (i4 + 1048320 | 0) >>> 16 & 8;
    14144. 

  14144.    i21 = i4 << i20;
    14145. 

  14145.    i19 = (i21 + 520192 | 0) >>> 16 & 4;
    14146. 

  14146.    i21 = i21 << i19;
    14147. 

  14147.    i4 = (i21 + 245760 | 0) >>> 16 & 2;
    14148. 

  14148.    i4 = 14 - (i19 | i20 | i4) + (i21 << i4 >>> 15) | 0;
    14149. 

  14149.    i4 = i11 >>> (i4 + 7 | 0) & 1 | i4 << 1;
    14150. 

  14150.   }
    14151. 

  14151.  } else {
    14152. 

  14152.   i4 = 0;
    14153. 

  14153.  }
    14154. 

  14154.  i5 = 13216 + (i4 << 2) | 0;
    14155. 

  14155.  HEAP32[i2 + 28 >> 2] = i4;
    14156. 

  14156.  HEAP32[i2 + 20 >> 2] = 0;
    14157. 

  14157.  HEAP32[i2 + 16 >> 2] = 0;
    14158. 

  14158.  i7 = HEAP32[12916 >> 2] | 0;
    14159. 

  14159.  i6 = 1 << i4;
    14160. 

  14160.  L199 : do {
    14161. 

  14161.   if ((i7 & i6 | 0) != 0) {
    14162. 

  14162.    i5 = HEAP32[i5 >> 2] | 0;
    14163. 

  14163.    if ((i4 | 0) == 31) {
    14164. 

  14164.     i4 = 0;
    14165. 

  14165.    } else {
    14166. 

  14166.     i4 = 25 - (i4 >>> 1) | 0;
    14167. 

  14167.    }
    14168. 

  14168.    L204 : do {
    14169. 

  14169.     if ((HEAP32[i5 + 4 >> 2] & -8 | 0) != (i11 | 0)) {
    14170. 

  14170.      i4 = i11 << i4;
    14171. 

  14171.      i7 = i5;
    14172. 

  14172.      while (1) {
    14173. 

  14173.       i6 = i7 + (i4 >>> 31 << 2) + 16 | 0;
    14174. 

  14174.       i5 = HEAP32[i6 >> 2] | 0;
    14175. 

  14175.       if ((i5 | 0) == 0) {
    14176. 

  14176.        break;
    14177. 

  14177.       }
    14178. 

  14178.       if ((HEAP32[i5 + 4 >> 2] & -8 | 0) == (i11 | 0)) {
    14179. 

  14179.        i3 = i5;
    14180. 

  14180.        break L204;
    14181. 

  14181.       } else {
    14182. 

  14182.        i4 = i4 << 1;
    14183. 

  14183.        i7 = i5;
    14184. 

  14184.       }
    14185. 

  14185.      }
    14186. 

  14186.      if (i6 >>> 0 < (HEAP32[12928 >> 2] | 0) >>> 0) {
    14187. 

  14187.       _abort();
    14188. 

  14188.      } else {
    14189. 

  14189.       HEAP32[i6 >> 2] = i2;
    14190. 

  14190.       HEAP32[i2 + 24 >> 2] = i7;
    14191. 

  14191.       HEAP32[i2 + 12 >> 2] = i2;
    14192. 

  14192.       HEAP32[i2 + 8 >> 2] = i2;
    14193. 

  14193.       break L199;
    14194. 

  14194.      }
    14195. 

  14195.     } else {
    14196. 

  14196.      i3 = i5;
    14197. 

  14197.     }
    14198. 

  14198.    } while (0);
    14199. 

  14199.    i5 = i3 + 8 | 0;
    14200. 

  14200.    i4 = HEAP32[i5 >> 2] | 0;
    14201. 

  14201.    i6 = HEAP32[12928 >> 2] | 0;
    14202. 

  14202.    if (i3 >>> 0 < i6 >>> 0) {
    14203. 

  14203.     _abort();
    14204. 

  14204.    }
    14205. 

  14205.    if (i4 >>> 0 < i6 >>> 0) {
    14206. 

  14206.     _abort();
    14207. 

  14207.    } else {
    14208. 

  14208.     HEAP32[i4 + 12 >> 2] = i2;
    14209. 

  14209.     HEAP32[i5 >> 2] = i2;
    14210. 

  14210.     HEAP32[i2 + 8 >> 2] = i4;
    14211. 

  14211.     HEAP32[i2 + 12 >> 2] = i3;
    14212. 

  14212.     HEAP32[i2 + 24 >> 2] = 0;
    14213. 

  14213.     break;
    14214. 

  14214.    }
    14215. 

  14215.   } else {
    14216. 

  14216.    HEAP32[12916 >> 2] = i7 | i6;
    14217. 

  14217.    HEAP32[i5 >> 2] = i2;
    14218. 

  14218.    HEAP32[i2 + 24 >> 2] = i5;
    14219. 

  14219.    HEAP32[i2 + 12 >> 2] = i2;
    14220. 

  14220.    HEAP32[i2 + 8 >> 2] = i2;
    14221. 

  14221.   }
    14222. 

  14222.  } while (0);
    14223. 

  14223.  i21 = (HEAP32[12944 >> 2] | 0) + -1 | 0;
    14224. 

  14224.  HEAP32[12944 >> 2] = i21;
    14225. 

  14225.  if ((i21 | 0) == 0) {
    14226. 

  14226.   i2 = 13368 | 0;
    14227. 

  14227.  } else {
    14228. 

  14228.   STACKTOP = i1;
    14229. 

  14229.   return;
    14230. 

  14230.  }
    14231. 

  14231.  while (1) {
    14232. 

  14232.   i2 = HEAP32[i2 >> 2] | 0;
    14233. 

  14233.   if ((i2 | 0) == 0) {
    14234. 

  14234.    break;
    14235. 

  14235.   } else {
    14236. 

  14236.    i2 = i2 + 8 | 0;
    14237. 

  14237.   }
    14238. 

  14238.  }
    14239. 

  14239.  HEAP32[12944 >> 2] = -1;
    14240. 

  14240.  STACKTOP = i1;
    14241. 

  14241.  return;
    14242. 

  14242. }
    14243. 

  14243. function _dispose_chunk(i6, i7) {
    14244. 

  14244.  i6 = i6 | 0;
    14245. 

  14245.  i7 = i7 | 0;
    14246. 

  14246.  var i1 = 0, i2 = 0, i3 = 0, i4 = 0, i5 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0, i14 = 0, i15 = 0, i16 = 0, i17 = 0, i18 = 0, i19 = 0, i20 = 0;
    14247. 

  14247.  i1 = STACKTOP;
    14248. 

  14248.  i5 = i6 + i7 | 0;
    14249. 

  14249.  i10 = HEAP32[i6 + 4 >> 2] | 0;
    14250. 

  14250.  do {
    14251. 

  14251.   if ((i10 & 1 | 0) == 0) {
    14252. 

  14252.    i14 = HEAP32[i6 >> 2] | 0;
    14253. 

  14253.    if ((i10 & 3 | 0) == 0) {
    14254. 

  14254.     STACKTOP = i1;
    14255. 

  14255.     return;
    14256. 

  14256.    }
    14257. 

  14257.    i10 = i6 + (0 - i14) | 0;
    14258. 

  14258.    i11 = i14 + i7 | 0;
    14259. 

  14259.    i15 = HEAP32[12928 >> 2] | 0;
    14260. 

  14260.    if (i10 >>> 0 < i15 >>> 0) {
    14261. 

  14261.     _abort();
    14262. 

  14262.    }
    14263. 

  14263.    if ((i10 | 0) == (HEAP32[12932 >> 2] | 0)) {
    14264. 

  14264.     i2 = i6 + (i7 + 4) | 0;
    14265. 

  14265.     if ((HEAP32[i2 >> 2] & 3 | 0) != 3) {
    14266. 

  14266.      i2 = i10;
    14267. 

  14267.      i12 = i11;
    14268. 

  14268.      break;
    14269. 

  14269.     }
    14270. 

  14270.     HEAP32[12920 >> 2] = i11;
    14271. 

  14271.     HEAP32[i2 >> 2] = HEAP32[i2 >> 2] & -2;
    14272. 

  14272.     HEAP32[i6 + (4 - i14) >> 2] = i11 | 1;
    14273. 

  14273.     HEAP32[i5 >> 2] = i11;
    14274. 

  14274.     STACKTOP = i1;
    14275. 

  14275.     return;
    14276. 

  14276.    }
    14277. 

  14277.    i17 = i14 >>> 3;
    14278. 

  14278.    if (i14 >>> 0 < 256) {
    14279. 

  14279.     i2 = HEAP32[i6 + (8 - i14) >> 2] | 0;
    14280. 

  14280.     i12 = HEAP32[i6 + (12 - i14) >> 2] | 0;
    14281. 

  14281.     i13 = 12952 + (i17 << 1 << 2) | 0;
    14282. 

  14282.     if ((i2 | 0) != (i13 | 0)) {
    14283. 

  14283.      if (i2 >>> 0 < i15 >>> 0) {
    14284. 

  14284.       _abort();
    14285. 

  14285.      }
    14286. 

  14286.      if ((HEAP32[i2 + 12 >> 2] | 0) != (i10 | 0)) {
    14287. 

  14287.       _abort();
    14288. 

  14288.      }
    14289. 

  14289.     }
    14290. 

  14290.     if ((i12 | 0) == (i2 | 0)) {
    14291. 

  14291.      HEAP32[3228] = HEAP32[3228] & ~(1 << i17);
    14292. 

  14292.      i2 = i10;
    14293. 

  14293.      i12 = i11;
    14294. 

  14294.      break;
    14295. 

  14295.     }
    14296. 

  14296.     if ((i12 | 0) != (i13 | 0)) {
    14297. 

  14297.      if (i12 >>> 0 < i15 >>> 0) {
    14298. 

  14298.       _abort();
    14299. 

  14299.      }
    14300. 

  14300.      i13 = i12 + 8 | 0;
    14301. 

  14301.      if ((HEAP32[i13 >> 2] | 0) == (i10 | 0)) {
    14302. 

  14302.       i16 = i13;
    14303. 

  14303.      } else {
    14304. 

  14304.       _abort();
    14305. 

  14305.      }
    14306. 

  14306.     } else {
    14307. 

  14307.      i16 = i12 + 8 | 0;
    14308. 

  14308.     }
    14309. 

  14309.     HEAP32[i2 + 12 >> 2] = i12;
    14310. 

  14310.     HEAP32[i16 >> 2] = i2;
    14311. 

  14311.     i2 = i10;
    14312. 

  14312.     i12 = i11;
    14313. 

  14313.     break;
    14314. 

  14314.    }
    14315. 

  14315.    i16 = HEAP32[i6 + (24 - i14) >> 2] | 0;
    14316. 

  14316.    i18 = HEAP32[i6 + (12 - i14) >> 2] | 0;
    14317. 

  14317.    do {
    14318. 

  14318.     if ((i18 | 0) == (i10 | 0)) {
    14319. 

  14319.      i19 = 16 - i14 | 0;
    14320. 

  14320.      i18 = i6 + (i19 + 4) | 0;
    14321. 

  14321.      i17 = HEAP32[i18 >> 2] | 0;
    14322. 

  14322.      if ((i17 | 0) == 0) {
    14323. 

  14323.       i18 = i6 + i19 | 0;
    14324. 

  14324.       i17 = HEAP32[i18 >> 2] | 0;
    14325. 

  14325.       if ((i17 | 0) == 0) {
    14326. 

  14326.        i13 = 0;
    14327. 

  14327.        break;
    14328. 

  14328.       }
    14329. 

  14329.      }
    14330. 

  14330.      while (1) {
    14331. 

  14331.       i19 = i17 + 20 | 0;
    14332. 

  14332.       i20 = HEAP32[i19 >> 2] | 0;
    14333. 

  14333.       if ((i20 | 0) != 0) {
    14334. 

  14334.        i17 = i20;
    14335. 

  14335.        i18 = i19;
    14336. 

  14336.        continue;
    14337. 

  14337.       }
    14338. 

  14338.       i20 = i17 + 16 | 0;
    14339. 

  14339.       i19 = HEAP32[i20 >> 2] | 0;
    14340. 

  14340.       if ((i19 | 0) == 0) {
    14341. 

  14341.        break;
    14342. 

  14342.       } else {
    14343. 

  14343.        i17 = i19;
    14344. 

  14344.        i18 = i20;
    14345. 

  14345.       }
    14346. 

  14346.      }
    14347. 

  14347.      if (i18 >>> 0 < i15 >>> 0) {
    14348. 

  14348.       _abort();
    14349. 

  14349.      } else {
    14350. 

  14350.       HEAP32[i18 >> 2] = 0;
    14351. 

  14351.       i13 = i17;
    14352. 

  14352.       break;
    14353. 

  14353.      }
    14354. 

  14354.     } else {
    14355. 

  14355.      i17 = HEAP32[i6 + (8 - i14) >> 2] | 0;
    14356. 

  14356.      if (i17 >>> 0 < i15 >>> 0) {
    14357. 

  14357.       _abort();
    14358. 

  14358.      }
    14359. 

  14359.      i19 = i17 + 12 | 0;
    14360. 

  14360.      if ((HEAP32[i19 >> 2] | 0) != (i10 | 0)) {
    14361. 

  14361.       _abort();
    14362. 

  14362.      }
    14363. 

  14363.      i15 = i18 + 8 | 0;
    14364. 

  14364.      if ((HEAP32[i15 >> 2] | 0) == (i10 | 0)) {
    14365. 

  14365.       HEAP32[i19 >> 2] = i18;
    14366. 

  14366.       HEAP32[i15 >> 2] = i17;
    14367. 

  14367.       i13 = i18;
    14368. 

  14368.       break;
    14369. 

  14369.      } else {
    14370. 

  14370.       _abort();
    14371. 

  14371.      }
    14372. 

  14372.     }
    14373. 

  14373.    } while (0);
    14374. 

  14374.    if ((i16 | 0) != 0) {
    14375. 

  14375.     i15 = HEAP32[i6 + (28 - i14) >> 2] | 0;
    14376. 

  14376.     i17 = 13216 + (i15 << 2) | 0;
    14377. 

  14377.     if ((i10 | 0) == (HEAP32[i17 >> 2] | 0)) {
    14378. 

  14378.      HEAP32[i17 >> 2] = i13;
    14379. 

  14379.      if ((i13 | 0) == 0) {
    14380. 

  14380.       HEAP32[12916 >> 2] = HEAP32[12916 >> 2] & ~(1 << i15);
    14381. 

  14381.       i2 = i10;
    14382. 

  14382.       i12 = i11;
    14383. 

  14383.       break;
    14384. 

  14384.      }
    14385. 

  14385.     } else {
    14386. 

  14386.      if (i16 >>> 0 < (HEAP32[12928 >> 2] | 0) >>> 0) {
    14387. 

  14387.       _abort();
    14388. 

  14388.      }
    14389. 

  14389.      i15 = i16 + 16 | 0;
    14390. 

  14390.      if ((HEAP32[i15 >> 2] | 0) == (i10 | 0)) {
    14391. 

  14391.       HEAP32[i15 >> 2] = i13;
    14392. 

  14392.      } else {
    14393. 

  14393.       HEAP32[i16 + 20 >> 2] = i13;
    14394. 

  14394.      }
    14395. 

  14395.      if ((i13 | 0) == 0) {
    14396. 

  14396.       i2 = i10;
    14397. 

  14397.       i12 = i11;
    14398. 

  14398.       break;
    14399. 

  14399.      }
    14400. 

  14400.     }
    14401. 

  14401.     if (i13 >>> 0 < (HEAP32[12928 >> 2] | 0) >>> 0) {
    14402. 

  14402.      _abort();
    14403. 

  14403.     }
    14404. 

  14404.     HEAP32[i13 + 24 >> 2] = i16;
    14405. 

  14405.     i14 = 16 - i14 | 0;
    14406. 

  14406.     i15 = HEAP32[i6 + i14 >> 2] | 0;
    14407. 

  14407.     do {
    14408. 

  14408.      if ((i15 | 0) != 0) {
    14409. 

  14409.       if (i15 >>> 0 < (HEAP32[12928 >> 2] | 0) >>> 0) {
    14410. 

  14410.        _abort();
    14411. 

  14411.       } else {
    14412. 

  14412.        HEAP32[i13 + 16 >> 2] = i15;
    14413. 

  14413.        HEAP32[i15 + 24 >> 2] = i13;
    14414. 

  14414.        break;
    14415. 

  14415.       }
    14416. 

  14416.      }
    14417. 

  14417.     } while (0);
    14418. 

  14418.     i14 = HEAP32[i6 + (i14 + 4) >> 2] | 0;
    14419. 

  14419.     if ((i14 | 0) != 0) {
    14420. 

  14420.      if (i14 >>> 0 < (HEAP32[12928 >> 2] | 0) >>> 0) {
    14421. 

  14421.       _abort();
    14422. 

  14422.      } else {
    14423. 

  14423.       HEAP32[i13 + 20 >> 2] = i14;
    14424. 

  14424.       HEAP32[i14 + 24 >> 2] = i13;
    14425. 

  14425.       i2 = i10;
    14426. 

  14426.       i12 = i11;
    14427. 

  14427.       break;
    14428. 

  14428.      }
    14429. 

  14429.     } else {
    14430. 

  14430.      i2 = i10;
    14431. 

  14431.      i12 = i11;
    14432. 

  14432.     }
    14433. 

  14433.    } else {
    14434. 

  14434.     i2 = i10;
    14435. 

  14435.     i12 = i11;
    14436. 

  14436.    }
    14437. 

  14437.   } else {
    14438. 

  14438.    i2 = i6;
    14439. 

  14439.    i12 = i7;
    14440. 

  14440.   }
    14441. 

  14441.  } while (0);
    14442. 

  14442.  i10 = HEAP32[12928 >> 2] | 0;
    14443. 

  14443.  if (i5 >>> 0 < i10 >>> 0) {
    14444. 

  14444.   _abort();
    14445. 

  14445.  }
    14446. 

  14446.  i11 = i6 + (i7 + 4) | 0;
    14447. 

  14447.  i13 = HEAP32[i11 >> 2] | 0;
    14448. 

  14448.  if ((i13 & 2 | 0) == 0) {
    14449. 

  14449.   if ((i5 | 0) == (HEAP32[12936 >> 2] | 0)) {
    14450. 

  14450.    i20 = (HEAP32[12924 >> 2] | 0) + i12 | 0;
    14451. 

  14451.    HEAP32[12924 >> 2] = i20;
    14452. 

  14452.    HEAP32[12936 >> 2] = i2;
    14453. 

  14453.    HEAP32[i2 + 4 >> 2] = i20 | 1;
    14454. 

  14454.    if ((i2 | 0) != (HEAP32[12932 >> 2] | 0)) {
    14455. 

  14455.     STACKTOP = i1;
    14456. 

  14456.     return;
    14457. 

  14457.    }
    14458. 

  14458.    HEAP32[12932 >> 2] = 0;
    14459. 

  14459.    HEAP32[12920 >> 2] = 0;
    14460. 

  14460.    STACKTOP = i1;
    14461. 

  14461.    return;
    14462. 

  14462.   }
    14463. 

  14463.   if ((i5 | 0) == (HEAP32[12932 >> 2] | 0)) {
    14464. 

  14464.    i20 = (HEAP32[12920 >> 2] | 0) + i12 | 0;
    14465. 

  14465.    HEAP32[12920 >> 2] = i20;
    14466. 

  14466.    HEAP32[12932 >> 2] = i2;
    14467. 

  14467.    HEAP32[i2 + 4 >> 2] = i20 | 1;
    14468. 

  14468.    HEAP32[i2 + i20 >> 2] = i20;
    14469. 

  14469.    STACKTOP = i1;
    14470. 

  14470.    return;
    14471. 

  14471.   }
    14472. 

  14472.   i12 = (i13 & -8) + i12 | 0;
    14473. 

  14473.   i11 = i13 >>> 3;
    14474. 

  14474.   do {
    14475. 

  14475.    if (!(i13 >>> 0 < 256)) {
    14476. 

  14476.     i9 = HEAP32[i6 + (i7 + 24) >> 2] | 0;
    14477. 

  14477.     i11 = HEAP32[i6 + (i7 + 12) >> 2] | 0;
    14478. 

  14478.     do {
    14479. 

  14479.      if ((i11 | 0) == (i5 | 0)) {
    14480. 

  14480.       i13 = i6 + (i7 + 20) | 0;
    14481. 

  14481.       i11 = HEAP32[i13 >> 2] | 0;
    14482. 

  14482.       if ((i11 | 0) == 0) {
    14483. 

  14483.        i13 = i6 + (i7 + 16) | 0;
    14484. 

  14484.        i11 = HEAP32[i13 >> 2] | 0;
    14485. 

  14485.        if ((i11 | 0) == 0) {
    14486. 

  14486.         i8 = 0;
    14487. 

  14487.         break;
    14488. 

  14488.        }
    14489. 

  14489.       }
    14490. 

  14490.       while (1) {
    14491. 

  14491.        i15 = i11 + 20 | 0;
    14492. 

  14492.        i14 = HEAP32[i15 >> 2] | 0;
    14493. 

  14493.        if ((i14 | 0) != 0) {
    14494. 

  14494.         i11 = i14;
    14495. 

  14495.         i13 = i15;
    14496. 

  14496.         continue;
    14497. 

  14497.        }
    14498. 

  14498.        i14 = i11 + 16 | 0;
    14499. 

  14499.        i15 = HEAP32[i14 >> 2] | 0;
    14500. 

  14500.        if ((i15 | 0) == 0) {
    14501. 

  14501.         break;
    14502. 

  14502.        } else {
    14503. 

  14503.         i11 = i15;
    14504. 

  14504.         i13 = i14;
    14505. 

  14505.        }
    14506. 

  14506.       }
    14507. 

  14507.       if (i13 >>> 0 < i10 >>> 0) {
    14508. 

  14508.        _abort();
    14509. 

  14509.       } else {
    14510. 

  14510.        HEAP32[i13 >> 2] = 0;
    14511. 

  14511.        i8 = i11;
    14512. 

  14512.        break;
    14513. 

  14513.       }
    14514. 

  14514.      } else {
    14515. 

  14515.       i13 = HEAP32[i6 + (i7 + 8) >> 2] | 0;
    14516. 

  14516.       if (i13 >>> 0 < i10 >>> 0) {
    14517. 

  14517.        _abort();
    14518. 

  14518.       }
    14519. 

  14519.       i10 = i13 + 12 | 0;
    14520. 

  14520.       if ((HEAP32[i10 >> 2] | 0) != (i5 | 0)) {
    14521. 

  14521.        _abort();
    14522. 

  14522.       }
    14523. 

  14523.       i14 = i11 + 8 | 0;
    14524. 

  14524.       if ((HEAP32[i14 >> 2] | 0) == (i5 | 0)) {
    14525. 

  14525.        HEAP32[i10 >> 2] = i11;
    14526. 

  14526.        HEAP32[i14 >> 2] = i13;
    14527. 

  14527.        i8 = i11;
    14528. 

  14528.        break;
    14529. 

  14529.       } else {
    14530. 

  14530.        _abort();
    14531. 

  14531.       }
    14532. 

  14532.      }
    14533. 

  14533.     } while (0);
    14534. 

  14534.     if ((i9 | 0) != 0) {
    14535. 

  14535.      i10 = HEAP32[i6 + (i7 + 28) >> 2] | 0;
    14536. 

  14536.      i11 = 13216 + (i10 << 2) | 0;
    14537. 

  14537.      if ((i5 | 0) == (HEAP32[i11 >> 2] | 0)) {
    14538. 

  14538.       HEAP32[i11 >> 2] = i8;
    14539. 

  14539.       if ((i8 | 0) == 0) {
    14540. 

  14540.        HEAP32[12916 >> 2] = HEAP32[12916 >> 2] & ~(1 << i10);
    14541. 

  14541.        break;
    14542. 

  14542.       }
    14543. 

  14543.      } else {
    14544. 

  14544.       if (i9 >>> 0 < (HEAP32[12928 >> 2] | 0) >>> 0) {
    14545. 

  14545.        _abort();
    14546. 

  14546.       }
    14547. 

  14547.       i10 = i9 + 16 | 0;
    14548. 

  14548.       if ((HEAP32[i10 >> 2] | 0) == (i5 | 0)) {
    14549. 

  14549.        HEAP32[i10 >> 2] = i8;
    14550. 

  14550.       } else {
    14551. 

  14551.        HEAP32[i9 + 20 >> 2] = i8;
    14552. 

  14552.       }
    14553. 

  14553.       if ((i8 | 0) == 0) {
    14554. 

  14554.        break;
    14555. 

  14555.       }
    14556. 

  14556.      }
    14557. 

  14557.      if (i8 >>> 0 < (HEAP32[12928 >> 2] | 0) >>> 0) {
    14558. 

  14558.       _abort();
    14559. 

  14559.      }
    14560. 

  14560.      HEAP32[i8 + 24 >> 2] = i9;
    14561. 

  14561.      i5 = HEAP32[i6 + (i7 + 16) >> 2] | 0;
    14562. 

  14562.      do {
    14563. 

  14563.       if ((i5 | 0) != 0) {
    14564. 

  14564.        if (i5 >>> 0 < (HEAP32[12928 >> 2] | 0) >>> 0) {
    14565. 

  14565.         _abort();
    14566. 

  14566.        } else {
    14567. 

  14567.         HEAP32[i8 + 16 >> 2] = i5;
    14568. 

  14568.         HEAP32[i5 + 24 >> 2] = i8;
    14569. 

  14569.         break;
    14570. 

  14570.        }
    14571. 

  14571.       }
    14572. 

  14572.      } while (0);
    14573. 

  14573.      i5 = HEAP32[i6 + (i7 + 20) >> 2] | 0;
    14574. 

  14574.      if ((i5 | 0) != 0) {
    14575. 

  14575.       if (i5 >>> 0 < (HEAP32[12928 >> 2] | 0) >>> 0) {
    14576. 

  14576.        _abort();
    14577. 

  14577.       } else {
    14578. 

  14578.        HEAP32[i8 + 20 >> 2] = i5;
    14579. 

  14579.        HEAP32[i5 + 24 >> 2] = i8;
    14580. 

  14580.        break;
    14581. 

  14581.       }
    14582. 

  14582.      }
    14583. 

  14583.     }
    14584. 

  14584.    } else {
    14585. 

  14585.     i8 = HEAP32[i6 + (i7 + 8) >> 2] | 0;
    14586. 

  14586.     i6 = HEAP32[i6 + (i7 + 12) >> 2] | 0;
    14587. 

  14587.     i7 = 12952 + (i11 << 1 << 2) | 0;
    14588. 

  14588.     if ((i8 | 0) != (i7 | 0)) {
    14589. 

  14589.      if (i8 >>> 0 < i10 >>> 0) {
    14590. 

  14590.       _abort();
    14591. 

  14591.      }
    14592. 

  14592.      if ((HEAP32[i8 + 12 >> 2] | 0) != (i5 | 0)) {
    14593. 

  14593.       _abort();
    14594. 

  14594.      }
    14595. 

  14595.     }
    14596. 

  14596.     if ((i6 | 0) == (i8 | 0)) {
    14597. 

  14597.      HEAP32[3228] = HEAP32[3228] & ~(1 << i11);
    14598. 

  14598.      break;
    14599. 

  14599.     }
    14600. 

  14600.     if ((i6 | 0) != (i7 | 0)) {
    14601. 

  14601.      if (i6 >>> 0 < i10 >>> 0) {
    14602. 

  14602.       _abort();
    14603. 

  14603.      }
    14604. 

  14604.      i7 = i6 + 8 | 0;
    14605. 

  14605.      if ((HEAP32[i7 >> 2] | 0) == (i5 | 0)) {
    14606. 

  14606.       i9 = i7;
    14607. 

  14607.      } else {
    14608. 

  14608.       _abort();
    14609. 

  14609.      }
    14610. 

  14610.     } else {
    14611. 

  14611.      i9 = i6 + 8 | 0;
    14612. 

  14612.     }
    14613. 

  14613.     HEAP32[i8 + 12 >> 2] = i6;
    14614. 

  14614.     HEAP32[i9 >> 2] = i8;
    14615. 

  14615.    }
    14616. 

  14616.   } while (0);
    14617. 

  14617.   HEAP32[i2 + 4 >> 2] = i12 | 1;
    14618. 

  14618.   HEAP32[i2 + i12 >> 2] = i12;
    14619. 

  14619.   if ((i2 | 0) == (HEAP32[12932 >> 2] | 0)) {
    14620. 

  14620.    HEAP32[12920 >> 2] = i12;
    14621. 

  14621.    STACKTOP = i1;
    14622. 

  14622.    return;
    14623. 

  14623.   }
    14624. 

  14624.  } else {
    14625. 

  14625.   HEAP32[i11 >> 2] = i13 & -2;
    14626. 

  14626.   HEAP32[i2 + 4 >> 2] = i12 | 1;
    14627. 

  14627.   HEAP32[i2 + i12 >> 2] = i12;
    14628. 

  14628.  }
    14629. 

  14629.  i6 = i12 >>> 3;
    14630. 

  14630.  if (i12 >>> 0 < 256) {
    14631. 

  14631.   i7 = i6 << 1;
    14632. 

  14632.   i5 = 12952 + (i7 << 2) | 0;
    14633. 

  14633.   i8 = HEAP32[3228] | 0;
    14634. 

  14634.   i6 = 1 << i6;
    14635. 

  14635.   if ((i8 & i6 | 0) != 0) {
    14636. 

  14636.    i7 = 12952 + (i7 + 2 << 2) | 0;
    14637. 

  14637.    i6 = HEAP32[i7 >> 2] | 0;
    14638. 

  14638.    if (i6 >>> 0 < (HEAP32[12928 >> 2] | 0) >>> 0) {
    14639. 

  14639.     _abort();
    14640. 

  14640.    } else {
    14641. 

  14641.     i4 = i7;
    14642. 

  14642.     i3 = i6;
    14643. 

  14643.    }
    14644. 

  14644.   } else {
    14645. 

  14645.    HEAP32[3228] = i8 | i6;
    14646. 

  14646.    i4 = 12952 + (i7 + 2 << 2) | 0;
    14647. 

  14647.    i3 = i5;
    14648. 

  14648.   }
    14649. 

  14649.   HEAP32[i4 >> 2] = i2;
    14650. 

  14650.   HEAP32[i3 + 12 >> 2] = i2;
    14651. 

  14651.   HEAP32[i2 + 8 >> 2] = i3;
    14652. 

  14652.   HEAP32[i2 + 12 >> 2] = i5;
    14653. 

  14653.   STACKTOP = i1;
    14654. 

  14654.   return;
    14655. 

  14655.  }
    14656. 

  14656.  i3 = i12 >>> 8;
    14657. 

  14657.  if ((i3 | 0) != 0) {
    14658. 

  14658.   if (i12 >>> 0 > 16777215) {
    14659. 

  14659.    i3 = 31;
    14660. 

  14660.   } else {
    14661. 

  14661.    i19 = (i3 + 1048320 | 0) >>> 16 & 8;
    14662. 

  14662.    i20 = i3 << i19;
    14663. 

  14663.    i18 = (i20 + 520192 | 0) >>> 16 & 4;
    14664. 

  14664.    i20 = i20 << i18;
    14665. 

  14665.    i3 = (i20 + 245760 | 0) >>> 16 & 2;
    14666. 

  14666.    i3 = 14 - (i18 | i19 | i3) + (i20 << i3 >>> 15) | 0;
    14667. 

  14667.    i3 = i12 >>> (i3 + 7 | 0) & 1 | i3 << 1;
    14668. 

  14668.   }
    14669. 

  14669.  } else {
    14670. 

  14670.   i3 = 0;
    14671. 

  14671.  }
    14672. 

  14672.  i6 = 13216 + (i3 << 2) | 0;
    14673. 

  14673.  HEAP32[i2 + 28 >> 2] = i3;
    14674. 

  14674.  HEAP32[i2 + 20 >> 2] = 0;
    14675. 

  14675.  HEAP32[i2 + 16 >> 2] = 0;
    14676. 

  14676.  i5 = HEAP32[12916 >> 2] | 0;
    14677. 

  14677.  i4 = 1 << i3;
    14678. 

  14678.  if ((i5 & i4 | 0) == 0) {
    14679. 

  14679.   HEAP32[12916 >> 2] = i5 | i4;
    14680. 

  14680.   HEAP32[i6 >> 2] = i2;
    14681. 

  14681.   HEAP32[i2 + 24 >> 2] = i6;
    14682. 

  14682.   HEAP32[i2 + 12 >> 2] = i2;
    14683. 

  14683.   HEAP32[i2 + 8 >> 2] = i2;
    14684. 

  14684.   STACKTOP = i1;
    14685. 

  14685.   return;
    14686. 

  14686.  }
    14687. 

  14687.  i4 = HEAP32[i6 >> 2] | 0;
    14688. 

  14688.  if ((i3 | 0) == 31) {
    14689. 

  14689.   i3 = 0;
    14690. 

  14690.  } else {
    14691. 

  14691.   i3 = 25 - (i3 >>> 1) | 0;
    14692. 

  14692.  }
    14693. 

  14693.  L194 : do {
    14694. 

  14694.   if ((HEAP32[i4 + 4 >> 2] & -8 | 0) != (i12 | 0)) {
    14695. 

  14695.    i3 = i12 << i3;
    14696. 

  14696.    i6 = i4;
    14697. 

  14697.    while (1) {
    14698. 

  14698.     i5 = i6 + (i3 >>> 31 << 2) + 16 | 0;
    14699. 

  14699.     i4 = HEAP32[i5 >> 2] | 0;
    14700. 

  14700.     if ((i4 | 0) == 0) {
    14701. 

  14701.      break;
    14702. 

  14702.     }
    14703. 

  14703.     if ((HEAP32[i4 + 4 >> 2] & -8 | 0) == (i12 | 0)) {
    14704. 

  14704.      break L194;
    14705. 

  14705.     } else {
    14706. 

  14706.      i3 = i3 << 1;
    14707. 

  14707.      i6 = i4;
    14708. 

  14708.     }
    14709. 

  14709.    }
    14710. 

  14710.    if (i5 >>> 0 < (HEAP32[12928 >> 2] | 0) >>> 0) {
    14711. 

  14711.     _abort();
    14712. 

  14712.    }
    14713. 

  14713.    HEAP32[i5 >> 2] = i2;
    14714. 

  14714.    HEAP32[i2 + 24 >> 2] = i6;
    14715. 

  14715.    HEAP32[i2 + 12 >> 2] = i2;
    14716. 

  14716.    HEAP32[i2 + 8 >> 2] = i2;
    14717. 

  14717.    STACKTOP = i1;
    14718. 

  14718.    return;
    14719. 

  14719.   }
    14720. 

  14720.  } while (0);
    14721. 

  14721.  i3 = i4 + 8 | 0;
    14722. 

  14722.  i6 = HEAP32[i3 >> 2] | 0;
    14723. 

  14723.  i5 = HEAP32[12928 >> 2] | 0;
    14724. 

  14724.  if (i4 >>> 0 < i5 >>> 0) {
    14725. 

  14725.   _abort();
    14726. 

  14726.  }
    14727. 

  14727.  if (i6 >>> 0 < i5 >>> 0) {
    14728. 

  14728.   _abort();
    14729. 

  14729.  }
    14730. 

  14730.  HEAP32[i6 + 12 >> 2] = i2;
    14731. 

  14731.  HEAP32[i3 >> 2] = i2;
    14732. 

  14732.  HEAP32[i2 + 8 >> 2] = i6;
    14733. 

  14733.  HEAP32[i2 + 12 >> 2] = i4;
    14734. 

  14734.  HEAP32[i2 + 24 >> 2] = 0;
    14735. 

  14735.  STACKTOP = i1;
    14736. 

  14736.  return;
    14737. 

  14737. }
    14738. 

  14738. function _singlestep(i2) {
    14739. 

  14739.  i2 = i2 | 0;
    14740. 

  14740.  var i1 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0, i14 = 0, i15 = 0, i16 = 0, i17 = 0, i18 = 0, i19 = 0, i20 = 0, i21 = 0, i22 = 0;
    14741. 

  14741.  i1 = STACKTOP;
    14742. 

  14742.  STACKTOP = STACKTOP + 16 | 0;
    14743. 

  14743.  i14 = i1;
    14744. 

  14744.  i3 = i2 + 12 | 0;
    14745. 

  14745.  i8 = HEAP32[i3 >> 2] | 0;
    14746. 

  14746.  i6 = i8 + 61 | 0;
    14747. 

  14747.  switch (HEAPU8[i6] | 0) {
    14748. 

  14748.  case 0:
    14749. 

  14749.   {
    14750. 

  14750.    if ((HEAP32[i8 + 84 >> 2] | 0) != 0) {
    14751. 

  14751.     i21 = i8 + 16 | 0;
    14752. 

  14752.     i22 = HEAP32[i21 >> 2] | 0;
    14753. 

  14753.     _propagatemark(i8);
    14754. 

  14754.     i22 = (HEAP32[i21 >> 2] | 0) - i22 | 0;
    14755. 

  14755.     STACKTOP = i1;
    14756. 

  14756.     return i22 | 0;
    14757. 

  14757.    }
    14758. 

  14758.    HEAP8[i6] = 1;
    14759. 

  14759.    i6 = i8 + 20 | 0;
    14760. 

  14760.    HEAP32[i6 >> 2] = HEAP32[i8 + 16 >> 2];
    14761. 

  14761.    i8 = HEAP32[i3 >> 2] | 0;
    14762. 

  14762.    i7 = i8 + 16 | 0;
    14763. 

  14763.    i14 = HEAP32[i7 >> 2] | 0;
    14764. 

  14764.    if ((i2 | 0) != 0 ? !((HEAP8[i2 + 5 | 0] & 3) == 0) : 0) {
    14765. 

  14765.     _reallymarkobject(i8, i2);
    14766. 

  14766.    }
    14767. 

  14767.    if ((HEAP32[i8 + 48 >> 2] & 64 | 0) != 0 ? (i13 = HEAP32[i8 + 40 >> 2] | 0, !((HEAP8[i13 + 5 | 0] & 3) == 0)) : 0) {
    14768. 

  14768.     _reallymarkobject(i8, i13);
    14769. 

  14769.    }
    14770. 

  14770.    _markmt(i8);
    14771. 

  14771.    i13 = i8 + 112 | 0;
    14772. 

  14772.    i15 = HEAP32[i8 + 132 >> 2] | 0;
    14773. 

  14773.    if ((i15 | 0) != (i13 | 0)) {
    14774. 

  14774.     do {
    14775. 

  14775.      if (((HEAP8[i15 + 5 | 0] & 7) == 0 ? (i12 = HEAP32[i15 + 8 >> 2] | 0, (HEAP32[i12 + 8 >> 2] & 64 | 0) != 0) : 0) ? (i11 = HEAP32[i12 >> 2] | 0, !((HEAP8[i11 + 5 | 0] & 3) == 0)) : 0) {
    14776. 

  14776.       _reallymarkobject(i8, i11);
    14777. 

  14777.      }
    14778. 

  14778.      i15 = HEAP32[i15 + 20 >> 2] | 0;
    14779. 

  14779.     } while ((i15 | 0) != (i13 | 0));
    14780. 

  14780.    }
    14781. 

  14781.    i16 = i8 + 84 | 0;
    14782. 

  14782.    if ((HEAP32[i16 >> 2] | 0) != 0) {
    14783. 

  14783.     do {
    14784. 

  14784.      _propagatemark(i8);
    14785. 

  14785.     } while ((HEAP32[i16 >> 2] | 0) != 0);
    14786. 

  14786.    }
    14787. 

  14787.    i17 = (HEAP32[i7 >> 2] | 0) - i14 | 0;
    14788. 

  14788.    i11 = i8 + 92 | 0;
    14789. 

  14789.    i12 = HEAP32[i11 >> 2] | 0;
    14790. 

  14790.    i21 = i8 + 88 | 0;
    14791. 

  14791.    i22 = HEAP32[i21 >> 2] | 0;
    14792. 

  14792.    i15 = i8 + 96 | 0;
    14793. 

  14793.    i13 = HEAP32[i15 >> 2] | 0;
    14794. 

  14794.    HEAP32[i15 >> 2] = 0;
    14795. 

  14795.    HEAP32[i21 >> 2] = 0;
    14796. 

  14796.    HEAP32[i11 >> 2] = 0;
    14797. 

  14797.    HEAP32[i16 >> 2] = i22;
    14798. 

  14798.    if ((i22 | 0) != 0) {
    14799. 

  14799.     do {
    14800. 

  14800.      _propagatemark(i8);
    14801. 

  14801.     } while ((HEAP32[i16 >> 2] | 0) != 0);
    14802. 

  14802.    }
    14803. 

  14803.    HEAP32[i16 >> 2] = i12;
    14804. 

  14804.    if ((i12 | 0) != 0) {
    14805. 

  14805.     do {
    14806. 

  14806.      _propagatemark(i8);
    14807. 

  14807.     } while ((HEAP32[i16 >> 2] | 0) != 0);
    14808. 

  14808.    }
    14809. 

  14809.    HEAP32[i16 >> 2] = i13;
    14810. 

  14810.    if ((i13 | 0) != 0) {
    14811. 

  14811.     do {
    14812. 

  14812.      _propagatemark(i8);
    14813. 

  14813.     } while ((HEAP32[i16 >> 2] | 0) != 0);
    14814. 

  14814.    }
    14815. 

  14815.    i18 = HEAP32[i7 >> 2] | 0;
    14816. 

  14816.    while (1) {
    14817. 

  14817.     i13 = HEAP32[i15 >> 2] | 0;
    14818. 

  14818.     HEAP32[i15 >> 2] = 0;
    14819. 

  14819.     i12 = 0;
    14820. 

  14820.     L42 : while (1) {
    14821. 

  14821.      i14 = i13;
    14822. 

  14822.      while (1) {
    14823. 

  14823.       if ((i14 | 0) == 0) {
    14824. 

  14824.        break L42;
    14825. 

  14825.       }
    14826. 

  14826.       i13 = HEAP32[i14 + 24 >> 2] | 0;
    14827. 

  14827.       if ((_traverseephemeron(i8, i14) | 0) == 0) {
    14828. 

  14828.        i14 = i13;
    14829. 

  14829.       } else {
    14830. 

  14830.        break;
    14831. 

  14831.       }
    14832. 

  14832.      }
    14833. 

  14833.      if ((HEAP32[i16 >> 2] | 0) == 0) {
    14834. 

  14834.       i12 = 1;
    14835. 

  14835.       continue;
    14836. 

  14836.      }
    14837. 

  14837.      while (1) {
    14838. 

  14838.       _propagatemark(i8);
    14839. 

  14839.       if ((HEAP32[i16 >> 2] | 0) == 0) {
    14840. 

  14840.        i12 = 1;
    14841. 

  14841.        continue L42;
    14842. 

  14842.       }
    14843. 

  14843.      }
    14844. 

  14844.     }
    14845. 

  14845.     if ((i12 | 0) == 0) {
    14846. 

  14846.      break;
    14847. 

  14847.     }
    14848. 

  14848.    }
    14849. 

  14849.    _clearvalues(i8, HEAP32[i11 >> 2] | 0, 0);
    14850. 

  14850.    i14 = i8 + 100 | 0;
    14851. 

  14851.    _clearvalues(i8, HEAP32[i14 >> 2] | 0, 0);
    14852. 

  14852.    i13 = HEAP32[i11 >> 2] | 0;
    14853. 

  14853.    i12 = HEAP32[i14 >> 2] | 0;
    14854. 

  14854.    i21 = HEAP32[i7 >> 2] | 0;
    14855. 

  14855.    i20 = HEAP32[i3 >> 2] | 0;
    14856. 

  14856.    i19 = i20 + 104 | 0;
    14857. 

  14857.    while (1) {
    14858. 

  14858.     i22 = HEAP32[i19 >> 2] | 0;
    14859. 

  14859.     if ((i22 | 0) == 0) {
    14860. 

  14860.      break;
    14861. 

  14861.     } else {
    14862. 

  14862.      i19 = i22;
    14863. 

  14863.     }
    14864. 

  14864.    }
    14865. 

  14865.    i17 = i17 - i18 + i21 | 0;
    14866. 

  14866.    i20 = i20 + 72 | 0;
    14867. 

  14867.    i21 = HEAP32[i20 >> 2] | 0;
    14868. 

  14868.    L55 : do {
    14869. 

  14869.     if ((i21 | 0) != 0) {
    14870. 

  14870.      while (1) {
    14871. 

  14871.       i18 = i21;
    14872. 

  14872.       while (1) {
    14873. 

  14873.        i22 = i18 + 5 | 0;
    14874. 

  14874.        i21 = HEAP8[i22] | 0;
    14875. 

  14875.        if ((i21 & 3) == 0) {
    14876. 

  14876.         break;
    14877. 

  14877.        }
    14878. 

  14878.        HEAP8[i22] = i21 & 255 | 8;
    14879. 

  14879.        HEAP32[i20 >> 2] = HEAP32[i18 >> 2];
    14880. 

  14880.        HEAP32[i18 >> 2] = HEAP32[i19 >> 2];
    14881. 

  14881.        HEAP32[i19 >> 2] = i18;
    14882. 

  14882.        i19 = HEAP32[i20 >> 2] | 0;
    14883. 

  14883.        if ((i19 | 0) == 0) {
    14884. 

  14884.         break L55;
    14885. 

  14885.        } else {
    14886. 

  14886.         i22 = i18;
    14887. 

  14887.         i18 = i19;
    14888. 

  14888.         i19 = i22;
    14889. 

  14889.        }
    14890. 

  14890.       }
    14891. 

  14891.       i21 = HEAP32[i18 >> 2] | 0;
    14892. 

  14892.       if ((i21 | 0) == 0) {
    14893. 

  14893.        break;
    14894. 

  14894.       } else {
    14895. 

  14895.        i20 = i18;
    14896. 

  14896.       }
    14897. 

  14897.      }
    14898. 

  14898.     }
    14899. 

  14899.    } while (0);
    14900. 

  14900.    i19 = HEAP32[i8 + 104 >> 2] | 0;
    14901. 

  14901.    if ((i19 | 0) != 0) {
    14902. 

  14902.     i18 = i8 + 60 | 0;
    14903. 

  14903.     do {
    14904. 

  14904.      i22 = i19 + 5 | 0;
    14905. 

  14905.      HEAP8[i22] = HEAP8[i18] & 3 | HEAP8[i22] & 184;
    14906. 

  14906.      _reallymarkobject(i8, i19);
    14907. 

  14907.      i19 = HEAP32[i19 >> 2] | 0;
    14908. 

  14908.     } while ((i19 | 0) != 0);
    14909. 

  14909.    }
    14910. 

  14910.    if ((HEAP32[i16 >> 2] | 0) != 0) {
    14911. 

  14911.     do {
    14912. 

  14912.      _propagatemark(i8);
    14913. 

  14913.     } while ((HEAP32[i16 >> 2] | 0) != 0);
    14914. 

  14914.    }
    14915. 

  14915.    i18 = HEAP32[i7 >> 2] | 0;
    14916. 

  14916.    while (1) {
    14917. 

  14917.     i20 = HEAP32[i15 >> 2] | 0;
    14918. 

  14918.     HEAP32[i15 >> 2] = 0;
    14919. 

  14919.     i19 = 0;
    14920. 

  14920.     L74 : while (1) {
    14921. 

  14921.      i21 = i20;
    14922. 

  14922.      while (1) {
    14923. 

  14923.       if ((i21 | 0) == 0) {
    14924. 

  14924.        break L74;
    14925. 

  14925.       }
    14926. 

  14926.       i20 = HEAP32[i21 + 24 >> 2] | 0;
    14927. 

  14927.       if ((_traverseephemeron(i8, i21) | 0) == 0) {
    14928. 

  14928.        i21 = i20;
    14929. 

  14929.       } else {
    14930. 

  14930.        break;
    14931. 

  14931.       }
    14932. 

  14932.      }
    14933. 

  14933.      if ((HEAP32[i16 >> 2] | 0) == 0) {
    14934. 

  14934.       i19 = 1;
    14935. 

  14935.       continue;
    14936. 

  14936.      }
    14937. 

  14937.      while (1) {
    14938. 

  14938.       _propagatemark(i8);
    14939. 

  14939.       if ((HEAP32[i16 >> 2] | 0) == 0) {
    14940. 

  14940.        i19 = 1;
    14941. 

  14941.        continue L74;
    14942. 

  14942.       }
    14943. 

  14943.      }
    14944. 

  14944.     }
    14945. 

  14945.     if ((i19 | 0) == 0) {
    14946. 

  14946.      break;
    14947. 

  14947.     }
    14948. 

  14948.    }
    14949. 

  14949.    i16 = i17 - i18 | 0;
    14950. 

  14950.    i15 = HEAP32[i15 >> 2] | 0;
    14951. 

  14951.    if ((i15 | 0) != 0) {
    14952. 

  14952.     do {
    14953. 

  14953.      i22 = 1 << HEAPU8[i15 + 7 | 0];
    14954. 

  14954.      i19 = HEAP32[i15 + 16 >> 2] | 0;
    14955. 

  14955.      i17 = i19 + (i22 << 5) | 0;
    14956. 

  14956.      if ((i22 | 0) > 0) {
    14957. 

  14957.       do {
    14958. 

  14958.        i18 = i19 + 8 | 0;
    14959. 

  14959.        do {
    14960. 

  14960.         if ((HEAP32[i18 >> 2] | 0) != 0 ? (i9 = i19 + 24 | 0, i10 = HEAP32[i9 >> 2] | 0, (i10 & 64 | 0) != 0) : 0) {
    14961. 

  14961.          i20 = HEAP32[i19 + 16 >> 2] | 0;
    14962. 

  14962.          if ((i10 & 15 | 0) == 4) {
    14963. 

  14963.           if ((i20 | 0) == 0) {
    14964. 

  14964.            break;
    14965. 

  14965.           }
    14966. 

  14966.           if ((HEAP8[i20 + 5 | 0] & 3) == 0) {
    14967. 

  14967.            break;
    14968. 

  14968.           }
    14969. 

  14969.           _reallymarkobject(i8, i20);
    14970. 

  14970.           break;
    14971. 

  14971.          } else {
    14972. 

  14972.           i20 = i20 + 5 | 0;
    14973. 

  14973.           if ((HEAP8[i20] & 3) == 0) {
    14974. 

  14974.            break;
    14975. 

  14975.           }
    14976. 

  14976.           HEAP32[i18 >> 2] = 0;
    14977. 

  14977.           if ((HEAP8[i20] & 3) == 0) {
    14978. 

  14978.            break;
    14979. 

  14979.           }
    14980. 

  14980.           HEAP32[i9 >> 2] = 11;
    14981. 

  14981.           break;
    14982. 

  14982.          }
    14983. 

  14983.         }
    14984. 

  14984.        } while (0);
    14985. 

  14985.        i19 = i19 + 32 | 0;
    14986. 

  14986.       } while (i19 >>> 0 < i17 >>> 0);
    14987. 

  14987.      }
    14988. 

  14988.      i15 = HEAP32[i15 + 24 >> 2] | 0;
    14989. 

  14989.     } while ((i15 | 0) != 0);
    14990. 

  14990.    }
    14991. 

  14991.    i10 = HEAP32[i14 >> 2] | 0;
    14992. 

  14992.    if ((i10 | 0) != 0) {
    14993. 

  14993.     do {
    14994. 

  14994.      i22 = 1 << HEAPU8[i10 + 7 | 0];
    14995. 

  14995.      i17 = HEAP32[i10 + 16 >> 2] | 0;
    14996. 

  14996.      i9 = i17 + (i22 << 5) | 0;
    14997. 

  14997.      if ((i22 | 0) > 0) {
    14998. 

  14998.       do {
    14999. 

  14999.        i15 = i17 + 8 | 0;
    15000. 

  15000.        do {
    15001. 

  15001.         if ((HEAP32[i15 >> 2] | 0) != 0 ? (i5 = i17 + 24 | 0, i4 = HEAP32[i5 >> 2] | 0, (i4 & 64 | 0) != 0) : 0) {
    15002. 

  15002.          i18 = HEAP32[i17 + 16 >> 2] | 0;
    15003. 

  15003.          if ((i4 & 15 | 0) == 4) {
    15004. 

  15004.           if ((i18 | 0) == 0) {
    15005. 

  15005.            break;
    15006. 

  15006.           }
    15007. 

  15007.           if ((HEAP8[i18 + 5 | 0] & 3) == 0) {
    15008. 

  15008.            break;
    15009. 

  15009.           }
    15010. 

  15010.           _reallymarkobject(i8, i18);
    15011. 

  15011.           break;
    15012. 

  15012.          } else {
    15013. 

  15013.           i18 = i18 + 5 | 0;
    15014. 

  15014.           if ((HEAP8[i18] & 3) == 0) {
    15015. 

  15015.            break;
    15016. 

  15016.           }
    15017. 

  15017.           HEAP32[i15 >> 2] = 0;
    15018. 

  15018.           if ((HEAP8[i18] & 3) == 0) {
    15019. 

  15019.            break;
    15020. 

  15020.           }
    15021. 

  15021.           HEAP32[i5 >> 2] = 11;
    15022. 

  15022.           break;
    15023. 

  15023.          }
    15024. 

  15024.         }
    15025. 

  15025.        } while (0);
    15026. 

  15026.        i17 = i17 + 32 | 0;
    15027. 

  15027.       } while (i17 >>> 0 < i9 >>> 0);
    15028. 

  15028.      }
    15029. 

  15029.      i10 = HEAP32[i10 + 24 >> 2] | 0;
    15030. 

  15030.     } while ((i10 | 0) != 0);
    15031. 

  15031.    }
    15032. 

  15032.    _clearvalues(i8, HEAP32[i11 >> 2] | 0, i13);
    15033. 

  15033.    _clearvalues(i8, HEAP32[i14 >> 2] | 0, i12);
    15034. 

  15034.    i4 = i8 + 60 | 0;
    15035. 

  15035.    HEAP8[i4] = HEAPU8[i4] ^ 3;
    15036. 

  15036.    i4 = i16 + (HEAP32[i7 >> 2] | 0) | 0;
    15037. 

  15037.    HEAP32[i6 >> 2] = (HEAP32[i6 >> 2] | 0) + i4;
    15038. 

  15038.    i3 = HEAP32[i3 >> 2] | 0;
    15039. 

  15039.    HEAP8[i3 + 61 | 0] = 2;
    15040. 

  15040.    HEAP32[i3 + 64 >> 2] = 0;
    15041. 

  15041.    i7 = i3 + 72 | 0;
    15042. 

  15042.    i5 = 0;
    15043. 

  15043.    do {
    15044. 

  15044.     i5 = i5 + 1 | 0;
    15045. 

  15045.     i6 = _sweeplist(i2, i7, 1) | 0;
    15046. 

  15046.    } while ((i6 | 0) == (i7 | 0));
    15047. 

  15047.    HEAP32[i3 + 80 >> 2] = i6;
    15048. 

  15048.    i6 = i3 + 68 | 0;
    15049. 

  15049.    i7 = 0;
    15050. 

  15050.    do {
    15051. 

  15051.     i7 = i7 + 1 | 0;
    15052. 

  15052.     i8 = _sweeplist(i2, i6, 1) | 0;
    15053. 

  15053.    } while ((i8 | 0) == (i6 | 0));
    15054. 

  15054.    HEAP32[i3 + 76 >> 2] = i8;
    15055. 

  15055.    i22 = ((i7 + i5 | 0) * 5 | 0) + i4 | 0;
    15056. 

  15056.    STACKTOP = i1;
    15057. 

  15057.    return i22 | 0;
    15058. 

  15058.   }
    15059. 

  15059.  case 2:
    15060. 

  15060.   {
    15061. 

  15061.    i3 = i8 + 64 | 0;
    15062. 

  15062.    i4 = i8 + 32 | 0;
    15063. 

  15063.    i8 = i8 + 24 | 0;
    15064. 

  15064.    i5 = 0;
    15065. 

  15065.    while (1) {
    15066. 

  15066.     i10 = HEAP32[i3 >> 2] | 0;
    15067. 

  15067.     i11 = i10 + i5 | 0;
    15068. 

  15068.     i9 = HEAP32[i4 >> 2] | 0;
    15069. 

  15069.     if ((i11 | 0) >= (i9 | 0)) {
    15070. 

  15070.      i2 = i10;
    15071. 

  15071.      break;
    15072. 

  15072.     }
    15073. 

  15073.     _sweeplist(i2, (HEAP32[i8 >> 2] | 0) + (i11 << 2) | 0, -3) | 0;
    15074. 

  15074.     i5 = i5 + 1 | 0;
    15075. 

  15075.     if ((i5 | 0) >= 80) {
    15076. 

  15076.      i7 = 96;
    15077. 

  15077.      break;
    15078. 

  15078.     }
    15079. 

  15079.    }
    15080. 

  15080.    if ((i7 | 0) == 96) {
    15081. 

  15081.     i2 = HEAP32[i3 >> 2] | 0;
    15082. 

  15082.     i9 = HEAP32[i4 >> 2] | 0;
    15083. 

  15083.    }
    15084. 

  15084.    i22 = i2 + i5 | 0;
    15085. 

  15085.    HEAP32[i3 >> 2] = i22;
    15086. 

  15086.    if ((i22 | 0) >= (i9 | 0)) {
    15087. 

  15087.     HEAP8[i6] = 3;
    15088. 

  15088.    }
    15089. 

  15089.    i22 = i5 * 5 | 0;
    15090. 

  15090.    STACKTOP = i1;
    15091. 

  15091.    return i22 | 0;
    15092. 

  15092.   }
    15093. 

  15093.  case 5:
    15094. 

  15094.   {
    15095. 

  15095.    i2 = i8 + 16 | 0;
    15096. 

  15096.    HEAP32[i2 >> 2] = HEAP32[i8 + 32 >> 2] << 2;
    15097. 

  15097.    i22 = i8 + 84 | 0;
    15098. 

  15098.    i3 = i8 + 172 | 0;
    15099. 

  15099.    HEAP32[i22 + 0 >> 2] = 0;
    15100. 

  15100.    HEAP32[i22 + 4 >> 2] = 0;
    15101. 

  15101.    HEAP32[i22 + 8 >> 2] = 0;
    15102. 

  15102.    HEAP32[i22 + 12 >> 2] = 0;
    15103. 

  15103.    HEAP32[i22 + 16 >> 2] = 0;
    15104. 

  15104.    i3 = HEAP32[i3 >> 2] | 0;
    15105. 

  15105.    if ((i3 | 0) != 0 ? !((HEAP8[i3 + 5 | 0] & 3) == 0) : 0) {
    15106. 

  15106.     _reallymarkobject(i8, i3);
    15107. 

  15107.    }
    15108. 

  15108.    if ((HEAP32[i8 + 48 >> 2] & 64 | 0) != 0 ? (i15 = HEAP32[i8 + 40 >> 2] | 0, !((HEAP8[i15 + 5 | 0] & 3) == 0)) : 0) {
    15109. 

  15109.     _reallymarkobject(i8, i15);
    15110. 

  15110.    }
    15111. 

  15111.    _markmt(i8);
    15112. 

  15112.    i4 = HEAP32[i8 + 104 >> 2] | 0;
    15113. 

  15113.    if ((i4 | 0) != 0) {
    15114. 

  15114.     i3 = i8 + 60 | 0;
    15115. 

  15115.     do {
    15116. 

  15116.      i22 = i4 + 5 | 0;
    15117. 

  15117.      HEAP8[i22] = HEAP8[i3] & 3 | HEAP8[i22] & 184;
    15118. 

  15118.      _reallymarkobject(i8, i4);
    15119. 

  15119.      i4 = HEAP32[i4 >> 2] | 0;
    15120. 

  15120.     } while ((i4 | 0) != 0);
    15121. 

  15121.    }
    15122. 

  15122.    HEAP8[i6] = 0;
    15123. 

  15123.    i22 = HEAP32[i2 >> 2] | 0;
    15124. 

  15124.    STACKTOP = i1;
    15125. 

  15125.    return i22 | 0;
    15126. 

  15126.   }
    15127. 

  15127.  case 3:
    15128. 

  15128.   {
    15129. 

  15129.    i3 = i8 + 80 | 0;
    15130. 

  15130.    i4 = HEAP32[i3 >> 2] | 0;
    15131. 

  15131.    if ((i4 | 0) == 0) {
    15132. 

  15132.     HEAP8[i6] = 4;
    15133. 

  15133.     i22 = 0;
    15134. 

  15134.     STACKTOP = i1;
    15135. 

  15135.     return i22 | 0;
    15136. 

  15136.    } else {
    15137. 

  15137.     HEAP32[i3 >> 2] = _sweeplist(i2, i4, 80) | 0;
    15138. 

  15138.     i22 = 400;
    15139. 

  15139.     STACKTOP = i1;
    15140. 

  15140.     return i22 | 0;
    15141. 

  15141.    }
    15142. 

  15142.   }
    15143. 

  15143.  case 4:
    15144. 

  15144.   {
    15145. 

  15145.    i4 = i8 + 76 | 0;
    15146. 

  15146.    i5 = HEAP32[i4 >> 2] | 0;
    15147. 

  15147.    if ((i5 | 0) != 0) {
    15148. 

  15148.     HEAP32[i4 >> 2] = _sweeplist(i2, i5, 80) | 0;
    15149. 

  15149.     i22 = 400;
    15150. 

  15150.     STACKTOP = i1;
    15151. 

  15151.     return i22 | 0;
    15152. 

  15152.    }
    15153. 

  15153.    HEAP32[i14 >> 2] = HEAP32[i8 + 172 >> 2];
    15154. 

  15154.    _sweeplist(i2, i14, 1) | 0;
    15155. 

  15155.    i3 = HEAP32[i3 >> 2] | 0;
    15156. 

  15156.    if ((HEAP8[i3 + 62 | 0] | 0) != 1) {
    15157. 

  15157.     i4 = (HEAP32[i3 + 32 >> 2] | 0) / 2 | 0;
    15158. 

  15158.     if ((HEAP32[i3 + 28 >> 2] | 0) >>> 0 < i4 >>> 0) {
    15159. 

  15159.      _luaS_resize(i2, i4);
    15160. 

  15160.     }
    15161. 

  15161.     i21 = i3 + 144 | 0;
    15162. 

  15162.     i22 = i3 + 152 | 0;
    15163. 

  15163.     HEAP32[i21 >> 2] = _luaM_realloc_(i2, HEAP32[i21 >> 2] | 0, HEAP32[i22 >> 2] | 0, 0) | 0;
    15164. 

  15164.     HEAP32[i22 >> 2] = 0;
    15165. 

  15165.    }
    15166. 

  15166.    HEAP8[i6] = 5;
    15167. 

  15167.    i22 = 5;
    15168. 

  15168.    STACKTOP = i1;
    15169. 

  15169.    return i22 | 0;
    15170. 

  15170.   }
    15171. 

  15171.  default:
    15172. 

  15172.   {
    15173. 

  15173.    i22 = 0;
    15174. 

  15174.    STACKTOP = i1;
    15175. 

  15175.    return i22 | 0;
    15176. 

  15176.   }
    15177. 

  15177.  }
    15178. 

  15178.  return 0;
    15179. 

  15179. }
    15180. 

  15180. function _pmain(i3) {
    15181. 

  15181.  i3 = i3 | 0;
    15182. 

  15182.  var i1 = 0, i2 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0;
    15183. 

  15183.  i1 = STACKTOP;
    15184. 

  15184.  STACKTOP = STACKTOP + 16 | 0;
    15185. 

  15185.  i2 = i1;
    15186. 

  15186.  i7 = _lua_tointegerx(i3, 1, 0) | 0;
    15187. 

  15187.  i4 = _lua_touserdata(i3, 2) | 0;
    15188. 

  15188.  i5 = HEAP32[i4 >> 2] | 0;
    15189. 

  15189.  if ((i5 | 0) != 0 ? (HEAP8[i5] | 0) != 0 : 0) {
    15190. 

  15190.   HEAP32[20] = i5;
    15191. 

  15191.  }
    15192. 

  15192.  i12 = HEAP32[i4 + 4 >> 2] | 0;
    15193. 

  15193.  do {
    15194. 

  15194.   if ((i12 | 0) == 0) {
    15195. 

  15195.    i5 = 0;
    15196. 

  15196.    i6 = 0;
    15197. 

  15197.    i8 = 0;
    15198. 

  15198.    i9 = 1;
    15199. 

  15199.    i10 = 1;
    15200. 

  15200.   } else {
    15201. 

  15201.    i9 = 0;
    15202. 

  15202.    i8 = 0;
    15203. 

  15203.    i11 = 0;
    15204. 

  15204.    i6 = 0;
    15205. 

  15205.    i5 = 1;
    15206. 

  15206.    L6 : while (1) {
    15207. 

  15207.     if ((HEAP8[i12] | 0) != 45) {
    15208. 

  15208.      i10 = 18;
    15209. 

  15209.      break;
    15210. 

  15210.     }
    15211. 

  15211.     switch (HEAP8[i12 + 1 | 0] | 0) {
    15212. 

  15212.     case 108:
    15213. 

  15213.      {
    15214. 

  15214.       i10 = 12;
    15215. 

  15215.       break;
    15216. 

  15216.      }
    15217. 

  15217.     case 69:
    15218. 

  15218.      {
    15219. 

  15219.       i9 = 1;
    15220. 

  15220.       break;
    15221. 

  15221.      }
    15222. 

  15222.     case 45:
    15223. 

  15223.      {
    15224. 

  15224.       i10 = 7;
    15225. 

  15225.       break L6;
    15226. 

  15226.      }
    15227. 

  15227.     case 105:
    15228. 

  15228.      {
    15229. 

  15229.       if ((HEAP8[i12 + 2 | 0] | 0) == 0) {
    15230. 

  15230.        i11 = 1;
    15231. 

  15231.        i6 = 1;
    15232. 

  15232.       } else {
    15233. 

  15233.        i5 = -1;
    15234. 

  15234.        break L6;
    15235. 

  15235.       }
    15236. 

  15236.       break;
    15237. 

  15237.      }
    15238. 

  15238.     case 101:
    15239. 

  15239.      {
    15240. 

  15240.       i8 = 1;
    15241. 

  15241.       i10 = 12;
    15242. 

  15242.       break;
    15243. 

  15243.      }
    15244. 

  15244.     case 118:
    15245. 

  15245.      {
    15246. 

  15246.       if ((HEAP8[i12 + 2 | 0] | 0) == 0) {
    15247. 

  15247.        i11 = 1;
    15248. 

  15248.       } else {
    15249. 

  15249.        i5 = -1;
    15250. 

  15250.        break L6;
    15251. 

  15251.       }
    15252. 

  15252.       break;
    15253. 

  15253.      }
    15254. 

  15254.     case 0:
    15255. 

  15255.      {
    15256. 

  15256.       i10 = 18;
    15257. 

  15257.       break L6;
    15258. 

  15258.      }
    15259. 

  15259.     default:
    15260. 

  15260.      {
    15261. 

  15261.       i10 = 16;
    15262. 

  15262.       break L6;
    15263. 

  15263.      }
    15264. 

  15264.     }
    15265. 

  15265.     if ((i10 | 0) == 12) {
    15266. 

  15266.      i10 = 0;
    15267. 

  15267.      if ((HEAP8[i12 + 2 | 0] | 0) == 0) {
    15268. 

  15268.       i12 = i5 + 1 | 0;
    15269. 

  15269.       i13 = HEAP32[i4 + (i12 << 2) >> 2] | 0;
    15270. 

  15270.       if ((i13 | 0) == 0) {
    15271. 

  15271.        i10 = 15;
    15272. 

  15272.        break;
    15273. 

  15273.       }
    15274. 

  15274.       if ((HEAP8[i13] | 0) == 45) {
    15275. 

  15275.        i10 = 15;
    15276. 

  15276.        break;
    15277. 

  15277.       } else {
    15278. 

  15278.        i5 = i12;
    15279. 

  15279.       }
    15280. 

  15280.      }
    15281. 

  15281.     }
    15282. 

  15282.     i5 = i5 + 1 | 0;
    15283. 

  15283.     i12 = HEAP32[i4 + (i5 << 2) >> 2] | 0;
    15284. 

  15284.     if ((i12 | 0) == 0) {
    15285. 

  15285.      i5 = 0;
    15286. 

  15286.      i12 = i9;
    15287. 

  15287.      i10 = 23;
    15288. 

  15288.      break;
    15289. 

  15289.     }
    15290. 

  15290.    }
    15291. 

  15291.    if ((i10 | 0) == 7) {
    15292. 

  15292.     if ((HEAP8[i12 + 2 | 0] | 0) == 0) {
    15293. 

  15293.      i5 = i5 + 1 | 0;
    15294. 

  15294.      i5 = (HEAP32[i4 + (i5 << 2) >> 2] | 0) == 0 ? 0 : i5;
    15295. 

  15295.      i10 = 18;
    15296. 

  15296.     } else {
    15297. 

  15297.      i5 = -1;
    15298. 

  15298.     }
    15299. 

  15299.    } else if ((i10 | 0) == 15) {
    15300. 

  15300.     i5 = 0 - i5 | 0;
    15301. 

  15301.     i10 = 18;
    15302. 

  15302.    } else if ((i10 | 0) == 16) {
    15303. 

  15303.     i5 = 0 - i5 | 0;
    15304. 

  15304.     i10 = 18;
    15305. 

  15305.    }
    15306. 

  15306.    if ((i10 | 0) == 18) {
    15307. 

  15307.     if ((i5 | 0) >= 0) {
    15308. 

  15308.      i12 = i9;
    15309. 

  15309.      i10 = 23;
    15310. 

  15310.     }
    15311. 

  15311.    }
    15312. 

  15312.    if ((i10 | 0) == 23) {
    15313. 

  15313.     if ((i11 | 0) == 0) {
    15314. 

  15314.      i9 = 1;
    15315. 

  15315.     } else {
    15316. 

  15316.      i9 = HEAP32[_stdout >> 2] | 0;
    15317. 

  15317.      _fwrite(440, 1, 51, i9 | 0) | 0;
    15318. 

  15318.      _fputc(10, i9 | 0) | 0;
    15319. 

  15319.      _fflush(i9 | 0) | 0;
    15320. 

  15320.      i9 = 0;
    15321. 

  15321.     }
    15322. 

  15322.     if ((i12 | 0) == 0) {
    15323. 

  15323.      i10 = 1;
    15324. 

  15324.      break;
    15325. 

  15325.     }
    15326. 

  15326.     _lua_pushboolean(i3, 1);
    15327. 

  15327.     _lua_setfield(i3, -1001e3, 96);
    15328. 

  15328.     i10 = 0;
    15329. 

  15329.     break;
    15330. 

  15330.    }
    15331. 

  15331.    i3 = HEAP32[i4 + (0 - i5 << 2) >> 2] | 0;
    15332. 

  15332.    i4 = HEAP32[_stderr >> 2] | 0;
    15333. 

  15333.    HEAP32[i2 >> 2] = HEAP32[20];
    15334. 

  15334.    _fprintf(i4 | 0, 496, i2 | 0) | 0;
    15335. 

  15335.    _fflush(i4 | 0) | 0;
    15336. 

  15336.    i13 = HEAP8[i3 + 1 | 0] | 0;
    15337. 

  15337.    if (i13 << 24 >> 24 == 108 | i13 << 24 >> 24 == 101) {
    15338. 

  15338.     HEAP32[i2 >> 2] = i3;
    15339. 

  15339.     _fprintf(i4 | 0, 504, i2 | 0) | 0;
    15340. 

  15340.     _fflush(i4 | 0) | 0;
    15341. 

  15341.    } else {
    15342. 

  15342.     HEAP32[i2 >> 2] = i3;
    15343. 

  15343.     _fprintf(i4 | 0, 528, i2 | 0) | 0;
    15344. 

  15344.     _fflush(i4 | 0) | 0;
    15345. 

  15345.    }
    15346. 

  15346.    HEAP32[i2 >> 2] = HEAP32[20];
    15347. 

  15347.    _fprintf(i4 | 0, 560, i2 | 0) | 0;
    15348. 

  15348.    _fflush(i4 | 0) | 0;
    15349. 

  15349.    i13 = 0;
    15350. 

  15350.    STACKTOP = i1;
    15351. 

  15351.    return i13 | 0;
    15352. 

  15352.   }
    15353. 

  15353.  } while (0);
    15354. 

  15354.  _luaL_checkversion_(i3, 502.0);
    15355. 

  15355.  _lua_gc(i3, 0, 0) | 0;
    15356. 

  15356.  _luaL_openlibs(i3);
    15357. 

  15357.  _lua_gc(i3, 1, 0) | 0;
    15358. 

  15358.  do {
    15359. 

  15359.   if (i10) {
    15360. 

  15360.    i10 = _getenv(409 | 0) | 0;
    15361. 

  15361.    if ((i10 | 0) == 0) {
    15362. 

  15362.     i10 = _getenv(425 | 0) | 0;
    15363. 

  15363.     if ((i10 | 0) == 0) {
    15364. 

  15364.      break;
    15365. 

  15365.     } else {
    15366. 

  15366.      i11 = 424;
    15367. 

  15367.     }
    15368. 

  15368.    } else {
    15369. 

  15369.     i11 = 408;
    15370. 

  15370.    }
    15371. 

  15371.    if ((HEAP8[i10] | 0) == 64) {
    15372. 

  15372.     i13 = _luaL_loadfilex(i3, i10 + 1 | 0, 0) | 0;
    15373. 

  15373.     if ((i13 | 0) == 0) {
    15374. 

  15374.      i12 = _lua_gettop(i3) | 0;
    15375. 

  15375.      _lua_pushcclosure(i3, 142, 0);
    15376. 

  15376.      _lua_insert(i3, i12);
    15377. 

  15377.      HEAP32[48] = i3;
    15378. 

  15378.      _signal(2, 1) | 0;
    15379. 

  15379.      i13 = _lua_pcallk(i3, 0, 0, i12, 0, 0) | 0;
    15380. 

  15380.      _signal(2, 0) | 0;
    15381. 

  15381.      _lua_remove(i3, i12);
    15382. 

  15382.      if ((i13 | 0) == 0) {
    15383. 

  15383.       break;
    15384. 

  15384.      }
    15385. 

  15385.     }
    15386. 

  15386.     if ((_lua_type(i3, -1) | 0) == 0) {
    15387. 

  15387.      i13 = 0;
    15388. 

  15388.      STACKTOP = i1;
    15389. 

  15389.      return i13 | 0;
    15390. 

  15390.     }
    15391. 

  15391.     i11 = _lua_tolstring(i3, -1, 0) | 0;
    15392. 

  15392.     i12 = HEAP32[20] | 0;
    15393. 

  15393.     i10 = HEAP32[_stderr >> 2] | 0;
    15394. 

  15394.     if ((i12 | 0) != 0) {
    15395. 

  15395.      HEAP32[i2 >> 2] = i12;
    15396. 

  15396.      _fprintf(i10 | 0, 496, i2 | 0) | 0;
    15397. 

  15397.      _fflush(i10 | 0) | 0;
    15398. 

  15398.     }
    15399. 

  15399.     HEAP32[i2 >> 2] = (i11 | 0) == 0 ? 48 : i11;
    15400. 

  15400.     _fprintf(i10 | 0, 912, i2 | 0) | 0;
    15401. 

  15401.     _fflush(i10 | 0) | 0;
    15402. 

  15402.     _lua_settop(i3, -2);
    15403. 

  15403.     _lua_gc(i3, 2, 0) | 0;
    15404. 

  15404.    } else {
    15405. 

  15405.     i13 = _luaL_loadbufferx(i3, i10, _strlen(i10 | 0) | 0, i11, 0) | 0;
    15406. 

  15406.     if ((i13 | 0) == 0) {
    15407. 

  15407.      i12 = _lua_gettop(i3) | 0;
    15408. 

  15408.      _lua_pushcclosure(i3, 142, 0);
    15409. 

  15409.      _lua_insert(i3, i12);
    15410. 

  15410.      HEAP32[48] = i3;
    15411. 

  15411.      _signal(2, 1) | 0;
    15412. 

  15412.      i13 = _lua_pcallk(i3, 0, 0, i12, 0, 0) | 0;
    15413. 

  15413.      _signal(2, 0) | 0;
    15414. 

  15414.      _lua_remove(i3, i12);
    15415. 

  15415.      if ((i13 | 0) == 0) {
    15416. 

  15416.       break;
    15417. 

  15417.      }
    15418. 

  15418.     }
    15419. 

  15419.     if ((_lua_type(i3, -1) | 0) == 0) {
    15420. 

  15420.      i13 = 0;
    15421. 

  15421.      STACKTOP = i1;
    15422. 

  15422.      return i13 | 0;
    15423. 

  15423.     }
    15424. 

  15424.     i11 = _lua_tolstring(i3, -1, 0) | 0;
    15425. 

  15425.     i10 = HEAP32[20] | 0;
    15426. 

  15426.     i12 = HEAP32[_stderr >> 2] | 0;
    15427. 

  15427.     if ((i10 | 0) != 0) {
    15428. 

  15428.      HEAP32[i2 >> 2] = i10;
    15429. 

  15429.      _fprintf(i12 | 0, 496, i2 | 0) | 0;
    15430. 

  15430.      _fflush(i12 | 0) | 0;
    15431. 

  15431.     }
    15432. 

  15432.     HEAP32[i2 >> 2] = (i11 | 0) == 0 ? 48 : i11;
    15433. 

  15433.     _fprintf(i12 | 0, 912, i2 | 0) | 0;
    15434. 

  15434.     _fflush(i12 | 0) | 0;
    15435. 

  15435.     _lua_settop(i3, -2);
    15436. 

  15436.     _lua_gc(i3, 2, 0) | 0;
    15437. 

  15437.    }
    15438. 

  15438.    if ((i13 | 0) != 0) {
    15439. 

  15439.     i13 = 0;
    15440. 

  15440.     STACKTOP = i1;
    15441. 

  15441.     return i13 | 0;
    15442. 

  15442.    }
    15443. 

  15443.   }
    15444. 

  15444.  } while (0);
    15445. 

  15445.  i7 = (i5 | 0) > 0 ? i5 : i7;
    15446. 

  15446.  L67 : do {
    15447. 

  15447.   if ((i7 | 0) > 1) {
    15448. 

  15448.    i10 = 1;
    15449. 

  15449.    while (1) {
    15450. 

  15450.     i11 = HEAP32[i4 + (i10 << 2) >> 2] | 0;
    15451. 

  15451.     i12 = HEAP8[i11 + 1 | 0] | 0;
    15452. 

  15452.     if ((i12 | 0) == 108) {
    15453. 

  15453.      i11 = i11 + 2 | 0;
    15454. 

  15454.      if ((HEAP8[i11] | 0) == 0) {
    15455. 

  15455.       i10 = i10 + 1 | 0;
    15456. 

  15456.       i11 = HEAP32[i4 + (i10 << 2) >> 2] | 0;
    15457. 

  15457.      }
    15458. 

  15458.      _lua_getglobal(i3, 400);
    15459. 

  15459.      _lua_pushstring(i3, i11) | 0;
    15460. 

  15460.      i12 = (_lua_gettop(i3) | 0) + -1 | 0;
    15461. 

  15461.      _lua_pushcclosure(i3, 142, 0);
    15462. 

  15462.      _lua_insert(i3, i12);
    15463. 

  15463.      HEAP32[48] = i3;
    15464. 

  15464.      _signal(2, 1) | 0;
    15465. 

  15465.      i13 = _lua_pcallk(i3, 1, 1, i12, 0, 0) | 0;
    15466. 

  15466.      _signal(2, 0) | 0;
    15467. 

  15467.      _lua_remove(i3, i12);
    15468. 

  15468.      if ((i13 | 0) != 0) {
    15469. 

  15469.       i10 = 58;
    15470. 

  15470.       break;
    15471. 

  15471.      }
    15472. 

  15472.      _lua_setglobal(i3, i11);
    15473. 

  15473.     } else if ((i12 | 0) == 101) {
    15474. 

  15474.      i11 = i11 + 2 | 0;
    15475. 

  15475.      if ((HEAP8[i11] | 0) == 0) {
    15476. 

  15476.       i10 = i10 + 1 | 0;
    15477. 

  15477.       i11 = HEAP32[i4 + (i10 << 2) >> 2] | 0;
    15478. 

  15478.      }
    15479. 

  15479.      if ((_luaL_loadbufferx(i3, i11, _strlen(i11 | 0) | 0, 384, 0) | 0) != 0) {
    15480. 

  15480.       i10 = 50;
    15481. 

  15481.       break;
    15482. 

  15482.      }
    15483. 

  15483.      i12 = _lua_gettop(i3) | 0;
    15484. 

  15484.      _lua_pushcclosure(i3, 142, 0);
    15485. 

  15485.      _lua_insert(i3, i12);
    15486. 

  15486.      HEAP32[48] = i3;
    15487. 

  15487.      _signal(2, 1) | 0;
    15488. 

  15488.      i13 = _lua_pcallk(i3, 0, 0, i12, 0, 0) | 0;
    15489. 

  15489.      _signal(2, 0) | 0;
    15490. 

  15490.      _lua_remove(i3, i12);
    15491. 

  15491.      if ((i13 | 0) != 0) {
    15492. 

  15492.       i10 = 50;
    15493. 

  15493.       break;
    15494. 

  15494.      }
    15495. 

  15495.     }
    15496. 

  15496.     i10 = i10 + 1 | 0;
    15497. 

  15497.     if ((i10 | 0) >= (i7 | 0)) {
    15498. 

  15498.      break L67;
    15499. 

  15499.     }
    15500. 

  15500.    }
    15501. 

  15501.    if ((i10 | 0) == 50) {
    15502. 

  15502.     if ((_lua_type(i3, -1) | 0) == 0) {
    15503. 

  15503.      i13 = 0;
    15504. 

  15504.      STACKTOP = i1;
    15505. 

  15505.      return i13 | 0;
    15506. 

  15506.     }
    15507. 

  15507.     i5 = _lua_tolstring(i3, -1, 0) | 0;
    15508. 

  15508.     i6 = HEAP32[20] | 0;
    15509. 

  15509.     i4 = HEAP32[_stderr >> 2] | 0;
    15510. 

  15510.     if ((i6 | 0) != 0) {
    15511. 

  15511.      HEAP32[i2 >> 2] = i6;
    15512. 

  15512.      _fprintf(i4 | 0, 496, i2 | 0) | 0;
    15513. 

  15513.      _fflush(i4 | 0) | 0;
    15514. 

  15514.     }
    15515. 

  15515.     HEAP32[i2 >> 2] = (i5 | 0) == 0 ? 48 : i5;
    15516. 

  15516.     _fprintf(i4 | 0, 912, i2 | 0) | 0;
    15517. 

  15517.     _fflush(i4 | 0) | 0;
    15518. 

  15518.     _lua_settop(i3, -2);
    15519. 

  15519.     _lua_gc(i3, 2, 0) | 0;
    15520. 

  15520.     i13 = 0;
    15521. 

  15521.     STACKTOP = i1;
    15522. 

  15522.     return i13 | 0;
    15523. 

  15523.    } else if ((i10 | 0) == 58) {
    15524. 

  15524.     if ((_lua_type(i3, -1) | 0) == 0) {
    15525. 

  15525.      i13 = 0;
    15526. 

  15526.      STACKTOP = i1;
    15527. 

  15527.      return i13 | 0;
    15528. 

  15528.     }
    15529. 

  15529.     i5 = _lua_tolstring(i3, -1, 0) | 0;
    15530. 

  15530.     i6 = HEAP32[20] | 0;
    15531. 

  15531.     i4 = HEAP32[_stderr >> 2] | 0;
    15532. 

  15532.     if ((i6 | 0) != 0) {
    15533. 

  15533.      HEAP32[i2 >> 2] = i6;
    15534. 

  15534.      _fprintf(i4 | 0, 496, i2 | 0) | 0;
    15535. 

  15535.      _fflush(i4 | 0) | 0;
    15536. 

  15536.     }
    15537. 

  15537.     HEAP32[i2 >> 2] = (i5 | 0) == 0 ? 48 : i5;
    15538. 

  15538.     _fprintf(i4 | 0, 912, i2 | 0) | 0;
    15539. 

  15539.     _fflush(i4 | 0) | 0;
    15540. 

  15540.     _lua_settop(i3, -2);
    15541. 

  15541.     _lua_gc(i3, 2, 0) | 0;
    15542. 

  15542.     i13 = 0;
    15543. 

  15543.     STACKTOP = i1;
    15544. 

  15544.     return i13 | 0;
    15545. 

  15545.    }
    15546. 

  15546.   }
    15547. 

  15547.  } while (0);
    15548. 

  15548.  do {
    15549. 

  15549.   if ((i5 | 0) != 0) {
    15550. 

  15550.    i10 = 0;
    15551. 

  15551.    while (1) {
    15552. 

  15552.     if ((HEAP32[i4 + (i10 << 2) >> 2] | 0) == 0) {
    15553. 

  15553.      break;
    15554. 

  15554.     } else {
    15555. 

  15555.      i10 = i10 + 1 | 0;
    15556. 

  15556.     }
    15557. 

  15557.    }
    15558. 

  15558.    i11 = i5 + 1 | 0;
    15559. 

  15559.    i7 = i10 - i11 | 0;
    15560. 

  15560.    _luaL_checkstack(i3, i7 + 3 | 0, 352);
    15561. 

  15561.    if ((i11 | 0) < (i10 | 0)) {
    15562. 

  15562.     i12 = i11;
    15563. 

  15563.     do {
    15564. 

  15564.      _lua_pushstring(i3, HEAP32[i4 + (i12 << 2) >> 2] | 0) | 0;
    15565. 

  15565.      i12 = i12 + 1 | 0;
    15566. 

  15566.     } while ((i12 | 0) != (i10 | 0));
    15567. 

  15567.    }
    15568. 

  15568.    _lua_createtable(i3, i7, i11);
    15569. 

  15569.    if ((i10 | 0) > 0) {
    15570. 

  15570.     i11 = 0;
    15571. 

  15571.     do {
    15572. 

  15572.      _lua_pushstring(i3, HEAP32[i4 + (i11 << 2) >> 2] | 0) | 0;
    15573. 

  15573.      _lua_rawseti(i3, -2, i11 - i5 | 0);
    15574. 

  15574.      i11 = i11 + 1 | 0;
    15575. 

  15575.     } while ((i11 | 0) != (i10 | 0));
    15576. 

  15576.    }
    15577. 

  15577.    _lua_setglobal(i3, 328);
    15578. 

  15578.    i10 = HEAP32[i4 + (i5 << 2) >> 2] | 0;
    15579. 

  15579.    if ((_strcmp(i10, 336) | 0) == 0) {
    15580. 

  15580.     i13 = (_strcmp(HEAP32[i4 + (i5 + -1 << 2) >> 2] | 0, 344) | 0) == 0;
    15581. 

  15581.     i10 = i13 ? i10 : 0;
    15582. 

  15582.    }
    15583. 

  15583.    i10 = _luaL_loadfilex(i3, i10, 0) | 0;
    15584. 

  15584.    i4 = ~i7;
    15585. 

  15585.    _lua_insert(i3, i4);
    15586. 

  15586.    if ((i10 | 0) == 0) {
    15587. 

  15587.     i13 = (_lua_gettop(i3) | 0) - i7 | 0;
    15588. 

  15588.     _lua_pushcclosure(i3, 142, 0);
    15589. 

  15589.     _lua_insert(i3, i13);
    15590. 

  15590.     HEAP32[48] = i3;
    15591. 

  15591.     _signal(2, 1) | 0;
    15592. 

  15592.     i10 = _lua_pcallk(i3, i7, -1, i13, 0, 0) | 0;
    15593. 

  15593.     _signal(2, 0) | 0;
    15594. 

  15594.     _lua_remove(i3, i13);
    15595. 

  15595.     if ((i10 | 0) == 0) {
    15596. 

  15596.      break;
    15597. 

  15597.     }
    15598. 

  15598.    } else {
    15599. 

  15599.     _lua_settop(i3, i4);
    15600. 

  15600.    }
    15601. 

  15601.    if ((_lua_type(i3, -1) | 0) != 0) {
    15602. 

  15602.     i7 = _lua_tolstring(i3, -1, 0) | 0;
    15603. 

  15603.     i11 = HEAP32[20] | 0;
    15604. 

  15604.     i4 = HEAP32[_stderr >> 2] | 0;
    15605. 

  15605.     if ((i11 | 0) != 0) {
    15606. 

  15606.      HEAP32[i2 >> 2] = i11;
    15607. 

  15607.      _fprintf(i4 | 0, 496, i2 | 0) | 0;
    15608. 

  15608.      _fflush(i4 | 0) | 0;
    15609. 

  15609.     }
    15610. 

  15610.     HEAP32[i2 >> 2] = (i7 | 0) == 0 ? 48 : i7;
    15611. 

  15611.     _fprintf(i4 | 0, 912, i2 | 0) | 0;
    15612. 

  15612.     _fflush(i4 | 0) | 0;
    15613. 

  15613.     _lua_settop(i3, -2);
    15614. 

  15614.     _lua_gc(i3, 2, 0) | 0;
    15615. 

  15615.    }
    15616. 

  15616.    if ((i10 | 0) != 0) {
    15617. 

  15617.     i13 = 0;
    15618. 

  15618.     STACKTOP = i1;
    15619. 

  15619.     return i13 | 0;
    15620. 

  15620.    }
    15621. 

  15621.   }
    15622. 

  15622.  } while (0);
    15623. 

  15623.  if ((i6 | 0) == 0) {
    15624. 

  15624.   if (!((i8 | i5 | 0) != 0 | i9 ^ 1)) {
    15625. 

  15625.    i13 = HEAP32[_stdout >> 2] | 0;
    15626. 

  15626.    _fwrite(440, 1, 51, i13 | 0) | 0;
    15627. 

  15627.    _fputc(10, i13 | 0) | 0;
    15628. 

  15628.    _fflush(i13 | 0) | 0;
    15629. 

  15629.    _dotty(i3);
    15630. 

  15630.   }
    15631. 

  15631.  } else {
    15632. 

  15632.   _dotty(i3);
    15633. 

  15633.  }
    15634. 

  15634.  _lua_pushboolean(i3, 1);
    15635. 

  15635.  i13 = 1;
    15636. 

  15636.  STACKTOP = i1;
    15637. 

  15637.  return i13 | 0;
    15638. 

  15638. }
    15639. 

  15639. function _DumpFunction(i6, i2) {
    15640. 

  15640.  i6 = i6 | 0;
    15641. 

  15641.  i2 = i2 | 0;
    15642. 

  15642.  var i1 = 0, i3 = 0, i4 = 0, i5 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0, i14 = 0, i15 = 0, i16 = 0, i17 = 0, i18 = 0, i19 = 0, i20 = 0, i21 = 0, i22 = 0, i23 = 0, i24 = 0, i25 = 0, i26 = 0, i27 = 0, i28 = 0, i29 = 0, i30 = 0;
    15643. 

  15643.  i5 = STACKTOP;
    15644. 

  15644.  STACKTOP = STACKTOP + 64 | 0;
    15645. 

  15645.  i17 = i5 + 56 | 0;
    15646. 

  15646.  i19 = i5 + 52 | 0;
    15647. 

  15647.  i20 = i5 + 48 | 0;
    15648. 

  15648.  i18 = i5;
    15649. 

  15649.  i21 = i5 + 60 | 0;
    15650. 

  15650.  i22 = i5 + 44 | 0;
    15651. 

  15651.  i1 = i5 + 40 | 0;
    15652. 

  15652.  i16 = i5 + 36 | 0;
    15653. 

  15653.  i23 = i5 + 32 | 0;
    15654. 

  15654.  i3 = i5 + 28 | 0;
    15655. 

  15655.  i7 = i5 + 24 | 0;
    15656. 

  15656.  i8 = i5 + 20 | 0;
    15657. 

  15657.  i9 = i5 + 16 | 0;
    15658. 

  15658.  i10 = i5 + 12 | 0;
    15659. 

  15659.  i12 = i5 + 8 | 0;
    15660. 

  15660.  HEAP32[i17 >> 2] = HEAP32[i6 + 64 >> 2];
    15661. 

  15661.  i4 = i2 + 16 | 0;
    15662. 

  15662.  i28 = HEAP32[i4 >> 2] | 0;
    15663. 

  15663.  if ((i28 | 0) == 0) {
    15664. 

  15664.   i28 = FUNCTION_TABLE_iiiii[HEAP32[i2 + 4 >> 2] & 3](HEAP32[i2 >> 2] | 0, i17, 4, HEAP32[i2 + 8 >> 2] | 0) | 0;
    15665. 

  15665.   HEAP32[i4 >> 2] = i28;
    15666. 

  15666.  }
    15667. 

  15667.  HEAP32[i17 >> 2] = HEAP32[i6 + 68 >> 2];
    15668. 

  15668.  if ((i28 | 0) == 0) {
    15669. 

  15669.   i28 = FUNCTION_TABLE_iiiii[HEAP32[i2 + 4 >> 2] & 3](HEAP32[i2 >> 2] | 0, i17, 4, HEAP32[i2 + 8 >> 2] | 0) | 0;
    15670. 

  15670.   HEAP32[i4 >> 2] = i28;
    15671. 

  15671.  }
    15672. 

  15672.  HEAP8[i17] = HEAP8[i6 + 76 | 0] | 0;
    15673. 

  15673.  if ((i28 | 0) == 0) {
    15674. 

  15674.   i28 = FUNCTION_TABLE_iiiii[HEAP32[i2 + 4 >> 2] & 3](HEAP32[i2 >> 2] | 0, i17, 1, HEAP32[i2 + 8 >> 2] | 0) | 0;
    15675. 

  15675.   HEAP32[i4 >> 2] = i28;
    15676. 

  15676.  }
    15677. 

  15677.  HEAP8[i17] = HEAP8[i6 + 77 | 0] | 0;
    15678. 

  15678.  if ((i28 | 0) == 0) {
    15679. 

  15679.   i28 = FUNCTION_TABLE_iiiii[HEAP32[i2 + 4 >> 2] & 3](HEAP32[i2 >> 2] | 0, i17, 1, HEAP32[i2 + 8 >> 2] | 0) | 0;
    15680. 

  15680.   HEAP32[i4 >> 2] = i28;
    15681. 

  15681.  }
    15682. 

  15682.  HEAP8[i17] = HEAP8[i6 + 78 | 0] | 0;
    15683. 

  15683.  if ((i28 | 0) == 0) {
    15684. 

  15684.   i28 = FUNCTION_TABLE_iiiii[HEAP32[i2 + 4 >> 2] & 3](HEAP32[i2 >> 2] | 0, i17, 1, HEAP32[i2 + 8 >> 2] | 0) | 0;
    15685. 

  15685.   HEAP32[i4 >> 2] = i28;
    15686. 

  15686.  }
    15687. 

  15687.  i25 = HEAP32[i6 + 12 >> 2] | 0;
    15688. 

  15688.  i24 = HEAP32[i6 + 48 >> 2] | 0;
    15689. 

  15689.  HEAP32[i23 >> 2] = i24;
    15690. 

  15690.  if ((i28 | 0) == 0) {
    15691. 

  15691.   i26 = i2 + 4 | 0;
    15692. 

  15692.   i27 = i2 + 8 | 0;
    15693. 

  15693.   i28 = FUNCTION_TABLE_iiiii[HEAP32[i26 >> 2] & 3](HEAP32[i2 >> 2] | 0, i23, 4, HEAP32[i27 >> 2] | 0) | 0;
    15694. 

  15694.   HEAP32[i4 >> 2] = i28;
    15695. 

  15695.   if ((i28 | 0) == 0) {
    15696. 

  15696.    i28 = FUNCTION_TABLE_iiiii[HEAP32[i26 >> 2] & 3](HEAP32[i2 >> 2] | 0, i25, i24 << 2, HEAP32[i27 >> 2] | 0) | 0;
    15697. 

  15697.    HEAP32[i4 >> 2] = i28;
    15698. 

  15698.    i25 = HEAP32[i6 + 44 >> 2] | 0;
    15699. 

  15699.    HEAP32[i22 >> 2] = i25;
    15700. 

  15700.    if ((i28 | 0) == 0) {
    15701. 

  15701.     i28 = FUNCTION_TABLE_iiiii[HEAP32[i2 + 4 >> 2] & 3](HEAP32[i2 >> 2] | 0, i22, 4, HEAP32[i2 + 8 >> 2] | 0) | 0;
    15702. 

  15702.     HEAP32[i4 >> 2] = i28;
    15703. 

  15703.    }
    15704. 

  15704.   } else {
    15705. 

  15705.    i11 = 13;
    15706. 

  15706.   }
    15707. 

  15707.  } else {
    15708. 

  15708.   i11 = 13;
    15709. 

  15709.  }
    15710. 

  15710.  if ((i11 | 0) == 13) {
    15711. 

  15711.   i25 = HEAP32[i6 + 44 >> 2] | 0;
    15712. 

  15712.   HEAP32[i22 >> 2] = i25;
    15713. 

  15713.  }
    15714. 

  15714.  if ((i25 | 0) > 0) {
    15715. 

  15715.   i24 = i6 + 8 | 0;
    15716. 

  15716.   i23 = i2 + 4 | 0;
    15717. 

  15717.   i22 = i2 + 8 | 0;
    15718. 

  15718.   i26 = 0;
    15719. 

  15719.   do {
    15720. 

  15720.    i30 = HEAP32[i24 >> 2] | 0;
    15721. 

  15721.    i27 = i30 + (i26 << 4) | 0;
    15722. 

  15722.    i30 = i30 + (i26 << 4) + 8 | 0;
    15723. 

  15723.    i29 = HEAP32[i30 >> 2] | 0;
    15724. 

  15724.    HEAP8[i17] = i29 & 15;
    15725. 

  15725.    if ((i28 | 0) == 0) {
    15726. 

  15726.     i28 = FUNCTION_TABLE_iiiii[HEAP32[i23 >> 2] & 3](HEAP32[i2 >> 2] | 0, i17, 1, HEAP32[i22 >> 2] | 0) | 0;
    15727. 

  15727.     HEAP32[i4 >> 2] = i28;
    15728. 

  15728.     i29 = HEAP32[i30 >> 2] | 0;
    15729. 

  15729.    }
    15730. 

  15730.    i29 = i29 & 15;
    15731. 

  15731.    do {
    15732. 

  15732.     if ((i29 | 0) == 3) {
    15733. 

  15733.      HEAPF64[i18 >> 3] = +HEAPF64[i27 >> 3];
    15734. 

  15734.      if ((i28 | 0) == 0) {
    15735. 

  15735.       i28 = FUNCTION_TABLE_iiiii[HEAP32[i23 >> 2] & 3](HEAP32[i2 >> 2] | 0, i18, 8, HEAP32[i22 >> 2] | 0) | 0;
    15736. 

  15736.       HEAP32[i4 >> 2] = i28;
    15737. 

  15737.      }
    15738. 

  15738.     } else if ((i29 | 0) == 1) {
    15739. 

  15739.      HEAP8[i21] = HEAP32[i27 >> 2];
    15740. 

  15740.      if ((i28 | 0) == 0) {
    15741. 

  15741.       i28 = FUNCTION_TABLE_iiiii[HEAP32[i23 >> 2] & 3](HEAP32[i2 >> 2] | 0, i21, 1, HEAP32[i22 >> 2] | 0) | 0;
    15742. 

  15742.       HEAP32[i4 >> 2] = i28;
    15743. 

  15743.      }
    15744. 

  15744.     } else if ((i29 | 0) == 4) {
    15745. 

  15745.      i27 = HEAP32[i27 >> 2] | 0;
    15746. 

  15746.      if ((i27 | 0) == 0) {
    15747. 

  15747.       HEAP32[i19 >> 2] = 0;
    15748. 

  15748.       if ((i28 | 0) != 0) {
    15749. 

  15749.        break;
    15750. 

  15750.       }
    15751. 

  15751.       i28 = FUNCTION_TABLE_iiiii[HEAP32[i23 >> 2] & 3](HEAP32[i2 >> 2] | 0, i19, 4, HEAP32[i22 >> 2] | 0) | 0;
    15752. 

  15752.       HEAP32[i4 >> 2] = i28;
    15753. 

  15753.       break;
    15754. 

  15754.      }
    15755. 

  15755.      HEAP32[i20 >> 2] = (HEAP32[i27 + 12 >> 2] | 0) + 1;
    15756. 

  15756.      if ((i28 | 0) == 0) {
    15757. 

  15757.       i28 = FUNCTION_TABLE_iiiii[HEAP32[i23 >> 2] & 3](HEAP32[i2 >> 2] | 0, i20, 4, HEAP32[i22 >> 2] | 0) | 0;
    15758. 

  15758.       HEAP32[i4 >> 2] = i28;
    15759. 

  15759.       if ((i28 | 0) == 0) {
    15760. 

  15760.        i28 = FUNCTION_TABLE_iiiii[HEAP32[i23 >> 2] & 3](HEAP32[i2 >> 2] | 0, i27 + 16 | 0, HEAP32[i20 >> 2] | 0, HEAP32[i22 >> 2] | 0) | 0;
    15761. 

  15761.        HEAP32[i4 >> 2] = i28;
    15762. 

  15762.       }
    15763. 

  15763.      }
    15764. 

  15764.     }
    15765. 

  15765.    } while (0);
    15766. 

  15766.    i26 = i26 + 1 | 0;
    15767. 

  15767.   } while ((i26 | 0) != (i25 | 0));
    15768. 

  15768.  }
    15769. 

  15769.  i18 = HEAP32[i6 + 56 >> 2] | 0;
    15770. 

  15770.  HEAP32[i17 >> 2] = i18;
    15771. 

  15771.  if ((i28 | 0) == 0) {
    15772. 

  15772.   i28 = FUNCTION_TABLE_iiiii[HEAP32[i2 + 4 >> 2] & 3](HEAP32[i2 >> 2] | 0, i17, 4, HEAP32[i2 + 8 >> 2] | 0) | 0;
    15773. 

  15773.   HEAP32[i4 >> 2] = i28;
    15774. 

  15774.  }
    15775. 

  15775.  if ((i18 | 0) > 0) {
    15776. 

  15776.   i17 = i6 + 16 | 0;
    15777. 

  15777.   i19 = 0;
    15778. 

  15778.   do {
    15779. 

  15779.    _DumpFunction(HEAP32[(HEAP32[i17 >> 2] | 0) + (i19 << 2) >> 2] | 0, i2);
    15780. 

  15780.    i19 = i19 + 1 | 0;
    15781. 

  15781.   } while ((i19 | 0) != (i18 | 0));
    15782. 

  15782.   i28 = HEAP32[i4 >> 2] | 0;
    15783. 

  15783.  }
    15784. 

  15784.  i17 = i6 + 40 | 0;
    15785. 

  15785.  i18 = HEAP32[i17 >> 2] | 0;
    15786. 

  15786.  HEAP32[i16 >> 2] = i18;
    15787. 

  15787.  if ((i28 | 0) == 0) {
    15788. 

  15788.   i28 = FUNCTION_TABLE_iiiii[HEAP32[i2 + 4 >> 2] & 3](HEAP32[i2 >> 2] | 0, i16, 4, HEAP32[i2 + 8 >> 2] | 0) | 0;
    15789. 

  15789.   HEAP32[i4 >> 2] = i28;
    15790. 

  15790.  }
    15791. 

  15791.  if ((i18 | 0) > 0) {
    15792. 

  15792.   i19 = i6 + 28 | 0;
    15793. 

  15793.   i16 = i2 + 4 | 0;
    15794. 

  15794.   i20 = i2 + 8 | 0;
    15795. 

  15795.   i21 = 0;
    15796. 

  15796.   do {
    15797. 

  15797.    i22 = HEAP32[i19 >> 2] | 0;
    15798. 

  15798.    HEAP8[i1] = HEAP8[i22 + (i21 << 3) + 4 | 0] | 0;
    15799. 

  15799.    if ((i28 | 0) == 0) {
    15800. 

  15800.     i28 = FUNCTION_TABLE_iiiii[HEAP32[i16 >> 2] & 3](HEAP32[i2 >> 2] | 0, i1, 1, HEAP32[i20 >> 2] | 0) | 0;
    15801. 

  15801.     HEAP32[i4 >> 2] = i28;
    15802. 

  15802.     i22 = HEAP32[i19 >> 2] | 0;
    15803. 

  15803.    }
    15804. 

  15804.    HEAP8[i1] = HEAP8[i22 + (i21 << 3) + 5 | 0] | 0;
    15805. 

  15805.    if ((i28 | 0) == 0) {
    15806. 

  15806.     i28 = FUNCTION_TABLE_iiiii[HEAP32[i16 >> 2] & 3](HEAP32[i2 >> 2] | 0, i1, 1, HEAP32[i20 >> 2] | 0) | 0;
    15807. 

  15807.     HEAP32[i4 >> 2] = i28;
    15808. 

  15808.    }
    15809. 

  15809.    i21 = i21 + 1 | 0;
    15810. 

  15810.   } while ((i21 | 0) != (i18 | 0));
    15811. 

  15811.  }
    15812. 

  15812.  i16 = i2 + 12 | 0;
    15813. 

  15813.  if ((HEAP32[i16 >> 2] | 0) == 0 ? (i13 = HEAP32[i6 + 36 >> 2] | 0, (i13 | 0) != 0) : 0) {
    15814. 

  15814.   HEAP32[i12 >> 2] = (HEAP32[i13 + 12 >> 2] | 0) + 1;
    15815. 

  15815.   if ((i28 | 0) == 0 ? (i14 = i2 + 4 | 0, i15 = i2 + 8 | 0, i30 = FUNCTION_TABLE_iiiii[HEAP32[i14 >> 2] & 3](HEAP32[i2 >> 2] | 0, i12, 4, HEAP32[i15 >> 2] | 0) | 0, HEAP32[i4 >> 2] = i30, (i30 | 0) == 0) : 0) {
    15816. 

  15816.    HEAP32[i4 >> 2] = FUNCTION_TABLE_iiiii[HEAP32[i14 >> 2] & 3](HEAP32[i2 >> 2] | 0, i13 + 16 | 0, HEAP32[i12 >> 2] | 0, HEAP32[i15 >> 2] | 0) | 0;
    15817. 

  15817.   }
    15818. 

  15818.  } else {
    15819. 

  15819.   i12 = i10;
    15820. 

  15820.   i11 = 50;
    15821. 

  15821.  }
    15822. 

  15822.  if ((i11 | 0) == 50) {
    15823. 

  15823.   HEAP32[i10 >> 2] = 0;
    15824. 

  15824.   if ((i28 | 0) == 0) {
    15825. 

  15825.    HEAP32[i4 >> 2] = FUNCTION_TABLE_iiiii[HEAP32[i2 + 4 >> 2] & 3](HEAP32[i2 >> 2] | 0, i12, 4, HEAP32[i2 + 8 >> 2] | 0) | 0;
    15826. 

  15826.   }
    15827. 

  15827.  }
    15828. 

  15828.  if ((HEAP32[i16 >> 2] | 0) == 0) {
    15829. 

  15829.   i11 = HEAP32[i6 + 52 >> 2] | 0;
    15830. 

  15830.  } else {
    15831. 

  15831.   i11 = 0;
    15832. 

  15832.  }
    15833. 

  15833.  i10 = HEAP32[i6 + 20 >> 2] | 0;
    15834. 

  15834.  HEAP32[i9 >> 2] = i11;
    15835. 

  15835.  i14 = HEAP32[i4 >> 2] | 0;
    15836. 

  15836.  if ((i14 | 0) == 0) {
    15837. 

  15837.   i12 = i2 + 4 | 0;
    15838. 

  15838.   i13 = i2 + 8 | 0;
    15839. 

  15839.   i14 = FUNCTION_TABLE_iiiii[HEAP32[i12 >> 2] & 3](HEAP32[i2 >> 2] | 0, i9, 4, HEAP32[i13 >> 2] | 0) | 0;
    15840. 

  15840.   HEAP32[i4 >> 2] = i14;
    15841. 

  15841.   if ((i14 | 0) == 0) {
    15842. 

  15842.    i14 = FUNCTION_TABLE_iiiii[HEAP32[i12 >> 2] & 3](HEAP32[i2 >> 2] | 0, i10, i11 << 2, HEAP32[i13 >> 2] | 0) | 0;
    15843. 

  15843.    HEAP32[i4 >> 2] = i14;
    15844. 

  15844.   }
    15845. 

  15845.  }
    15846. 

  15846.  if ((HEAP32[i16 >> 2] | 0) == 0) {
    15847. 

  15847.   i9 = HEAP32[i6 + 60 >> 2] | 0;
    15848. 

  15848.  } else {
    15849. 

  15849.   i9 = 0;
    15850. 

  15850.  }
    15851. 

  15851.  HEAP32[i8 >> 2] = i9;
    15852. 

  15852.  if ((i14 | 0) == 0) {
    15853. 

  15853.   i14 = FUNCTION_TABLE_iiiii[HEAP32[i2 + 4 >> 2] & 3](HEAP32[i2 >> 2] | 0, i8, 4, HEAP32[i2 + 8 >> 2] | 0) | 0;
    15854. 

  15854.   HEAP32[i4 >> 2] = i14;
    15855. 

  15855.  }
    15856. 

  15856.  if ((i9 | 0) > 0) {
    15857. 

  15857.   i10 = i6 + 24 | 0;
    15858. 

  15858.   i11 = i2 + 4 | 0;
    15859. 

  15859.   i8 = i2 + 8 | 0;
    15860. 

  15860.   i12 = 0;
    15861. 

  15861.   do {
    15862. 

  15862.    i13 = HEAP32[(HEAP32[i10 >> 2] | 0) + (i12 * 12 | 0) >> 2] | 0;
    15863. 

  15863.    if ((i13 | 0) == 0) {
    15864. 

  15864.     HEAP32[i1 >> 2] = 0;
    15865. 

  15865.     if ((i14 | 0) == 0) {
    15866. 

  15866.      i14 = FUNCTION_TABLE_iiiii[HEAP32[i11 >> 2] & 3](HEAP32[i2 >> 2] | 0, i1, 4, HEAP32[i8 >> 2] | 0) | 0;
    15867. 

  15867.      HEAP32[i4 >> 2] = i14;
    15868. 

  15868.     }
    15869. 

  15869.    } else {
    15870. 

  15870.     HEAP32[i3 >> 2] = (HEAP32[i13 + 12 >> 2] | 0) + 1;
    15871. 

  15871.     if ((i14 | 0) == 0) {
    15872. 

  15872.      i14 = FUNCTION_TABLE_iiiii[HEAP32[i11 >> 2] & 3](HEAP32[i2 >> 2] | 0, i3, 4, HEAP32[i8 >> 2] | 0) | 0;
    15873. 

  15873.      HEAP32[i4 >> 2] = i14;
    15874. 

  15874.      if ((i14 | 0) == 0) {
    15875. 

  15875.       i14 = FUNCTION_TABLE_iiiii[HEAP32[i11 >> 2] & 3](HEAP32[i2 >> 2] | 0, i13 + 16 | 0, HEAP32[i3 >> 2] | 0, HEAP32[i8 >> 2] | 0) | 0;
    15876. 

  15876.       HEAP32[i4 >> 2] = i14;
    15877. 

  15877.      }
    15878. 

  15878.     }
    15879. 

  15879.    }
    15880. 

  15880.    i13 = HEAP32[i10 >> 2] | 0;
    15881. 

  15881.    HEAP32[i1 >> 2] = HEAP32[i13 + (i12 * 12 | 0) + 4 >> 2];
    15882. 

  15882.    if ((i14 | 0) == 0) {
    15883. 

  15883.     i14 = FUNCTION_TABLE_iiiii[HEAP32[i11 >> 2] & 3](HEAP32[i2 >> 2] | 0, i1, 4, HEAP32[i8 >> 2] | 0) | 0;
    15884. 

  15884.     HEAP32[i4 >> 2] = i14;
    15885. 

  15885.     i13 = HEAP32[i10 >> 2] | 0;
    15886. 

  15886.    }
    15887. 

  15887.    HEAP32[i1 >> 2] = HEAP32[i13 + (i12 * 12 | 0) + 8 >> 2];
    15888. 

  15888.    if ((i14 | 0) == 0) {
    15889. 

  15889.     i14 = FUNCTION_TABLE_iiiii[HEAP32[i11 >> 2] & 3](HEAP32[i2 >> 2] | 0, i1, 4, HEAP32[i8 >> 2] | 0) | 0;
    15890. 

  15890.     HEAP32[i4 >> 2] = i14;
    15891. 

  15891.    }
    15892. 

  15892.    i12 = i12 + 1 | 0;
    15893. 

  15893.   } while ((i12 | 0) != (i9 | 0));
    15894. 

  15894.  }
    15895. 

  15895.  if ((HEAP32[i16 >> 2] | 0) == 0) {
    15896. 

  15896.   i8 = HEAP32[i17 >> 2] | 0;
    15897. 

  15897.  } else {
    15898. 

  15898.   i8 = 0;
    15899. 

  15899.  }
    15900. 

  15900.  HEAP32[i7 >> 2] = i8;
    15901. 

  15901.  if ((i14 | 0) == 0) {
    15902. 

  15902.   i14 = FUNCTION_TABLE_iiiii[HEAP32[i2 + 4 >> 2] & 3](HEAP32[i2 >> 2] | 0, i7, 4, HEAP32[i2 + 8 >> 2] | 0) | 0;
    15903. 

  15903.   HEAP32[i4 >> 2] = i14;
    15904. 

  15904.  }
    15905. 

  15905.  if ((i8 | 0) <= 0) {
    15906. 

  15906.   STACKTOP = i5;
    15907. 

  15907.   return;
    15908. 

  15908.  }
    15909. 

  15909.  i7 = i6 + 28 | 0;
    15910. 

  15910.  i6 = i2 + 4 | 0;
    15911. 

  15911.  i9 = i2 + 8 | 0;
    15912. 

  15912.  i10 = 0;
    15913. 

  15913.  do {
    15914. 

  15914.   i11 = HEAP32[(HEAP32[i7 >> 2] | 0) + (i10 << 3) >> 2] | 0;
    15915. 

  15915.   if ((i11 | 0) == 0) {
    15916. 

  15916.    HEAP32[i1 >> 2] = 0;
    15917. 

  15917.    if ((i14 | 0) == 0) {
    15918. 

  15918.     i14 = FUNCTION_TABLE_iiiii[HEAP32[i6 >> 2] & 3](HEAP32[i2 >> 2] | 0, i1, 4, HEAP32[i9 >> 2] | 0) | 0;
    15919. 

  15919.     HEAP32[i4 >> 2] = i14;
    15920. 

  15920.    }
    15921. 

  15921.   } else {
    15922. 

  15922.    HEAP32[i3 >> 2] = (HEAP32[i11 + 12 >> 2] | 0) + 1;
    15923. 

  15923.    if ((i14 | 0) == 0) {
    15924. 

  15924.     i14 = FUNCTION_TABLE_iiiii[HEAP32[i6 >> 2] & 3](HEAP32[i2 >> 2] | 0, i3, 4, HEAP32[i9 >> 2] | 0) | 0;
    15925. 

  15925.     HEAP32[i4 >> 2] = i14;
    15926. 

  15926.     if ((i14 | 0) == 0) {
    15927. 

  15927.      i14 = FUNCTION_TABLE_iiiii[HEAP32[i6 >> 2] & 3](HEAP32[i2 >> 2] | 0, i11 + 16 | 0, HEAP32[i3 >> 2] | 0, HEAP32[i9 >> 2] | 0) | 0;
    15928. 

  15928.      HEAP32[i4 >> 2] = i14;
    15929. 

  15929.     }
    15930. 

  15930.    }
    15931. 

  15931.   }
    15932. 

  15932.   i10 = i10 + 1 | 0;
    15933. 

  15933.  } while ((i10 | 0) != (i8 | 0));
    15934. 

  15934.  STACKTOP = i5;
    15935. 

  15935.  return;
    15936. 

  15936. }
    15937. 

  15937. function _LoadFunction(i2, i6) {
    15938. 

  15938.  i2 = i2 | 0;
    15939. 

  15939.  i6 = i6 | 0;
    15940. 

  15940.  var i1 = 0, i3 = 0, i4 = 0, i5 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0, i14 = 0;
    15941. 

  15941.  i1 = STACKTOP;
    15942. 

  15942.  STACKTOP = STACKTOP + 16 | 0;
    15943. 

  15943.  i3 = i1;
    15944. 

  15944.  i5 = i1 + 8 | 0;
    15945. 

  15945.  i4 = i2 + 4 | 0;
    15946. 

  15946.  if ((_luaZ_read(HEAP32[i4 >> 2] | 0, i3, 4) | 0) != 0) {
    15947. 

  15947.   _error(i2, 8824);
    15948. 

  15948.  }
    15949. 

  15949.  i8 = HEAP32[i3 >> 2] | 0;
    15950. 

  15950.  if ((i8 | 0) < 0) {
    15951. 

  15951.   _error(i2, 8872);
    15952. 

  15952.  }
    15953. 

  15953.  HEAP32[i6 + 64 >> 2] = i8;
    15954. 

  15954.  if ((_luaZ_read(HEAP32[i4 >> 2] | 0, i3, 4) | 0) != 0) {
    15955. 

  15955.   _error(i2, 8824);
    15956. 

  15956.  }
    15957. 

  15957.  i8 = HEAP32[i3 >> 2] | 0;
    15958. 

  15958.  if ((i8 | 0) < 0) {
    15959. 

  15959.   _error(i2, 8872);
    15960. 

  15960.  }
    15961. 

  15961.  HEAP32[i6 + 68 >> 2] = i8;
    15962. 

  15962.  if ((_luaZ_read(HEAP32[i4 >> 2] | 0, i3, 1) | 0) != 0) {
    15963. 

  15963.   _error(i2, 8824);
    15964. 

  15964.  }
    15965. 

  15965.  HEAP8[i6 + 76 | 0] = HEAP8[i3] | 0;
    15966. 

  15966.  if ((_luaZ_read(HEAP32[i4 >> 2] | 0, i3, 1) | 0) != 0) {
    15967. 

  15967.   _error(i2, 8824);
    15968. 

  15968.  }
    15969. 

  15969.  HEAP8[i6 + 77 | 0] = HEAP8[i3] | 0;
    15970. 

  15970.  if ((_luaZ_read(HEAP32[i4 >> 2] | 0, i3, 1) | 0) != 0) {
    15971. 

  15971.   _error(i2, 8824);
    15972. 

  15972.  }
    15973. 

  15973.  HEAP8[i6 + 78 | 0] = HEAP8[i3] | 0;
    15974. 

  15974.  if ((_luaZ_read(HEAP32[i4 >> 2] | 0, i3, 4) | 0) != 0) {
    15975. 

  15975.   _error(i2, 8824);
    15976. 

  15976.  }
    15977. 

  15977.  i9 = HEAP32[i3 >> 2] | 0;
    15978. 

  15978.  if ((i9 | 0) < 0) {
    15979. 

  15979.   _error(i2, 8872);
    15980. 

  15980.  }
    15981. 

  15981.  i8 = HEAP32[i2 >> 2] | 0;
    15982. 

  15982.  if ((i9 + 1 | 0) >>> 0 > 1073741823) {
    15983. 

  15983.   _luaM_toobig(i8);
    15984. 

  15984.  }
    15985. 

  15985.  i14 = i9 << 2;
    15986. 

  15986.  i13 = _luaM_realloc_(i8, 0, 0, i14) | 0;
    15987. 

  15987.  HEAP32[i6 + 12 >> 2] = i13;
    15988. 

  15988.  HEAP32[i6 + 48 >> 2] = i9;
    15989. 

  15989.  if ((_luaZ_read(HEAP32[i4 >> 2] | 0, i13, i14) | 0) != 0) {
    15990. 

  15990.   _error(i2, 8824);
    15991. 

  15991.  }
    15992. 

  15992.  if ((_luaZ_read(HEAP32[i4 >> 2] | 0, i3, 4) | 0) != 0) {
    15993. 

  15993.   _error(i2, 8824);
    15994. 

  15994.  }
    15995. 

  15995.  i8 = HEAP32[i3 >> 2] | 0;
    15996. 

  15996.  if ((i8 | 0) < 0) {
    15997. 

  15997.   _error(i2, 8872);
    15998. 

  15998.  }
    15999. 

  15999.  i9 = HEAP32[i2 >> 2] | 0;
    16000. 

  16000.  if ((i8 + 1 | 0) >>> 0 > 268435455) {
    16001. 

  16001.   _luaM_toobig(i9);
    16002. 

  16002.  }
    16003. 

  16003.  i11 = _luaM_realloc_(i9, 0, 0, i8 << 4) | 0;
    16004. 

  16004.  i9 = i6 + 8 | 0;
    16005. 

  16005.  HEAP32[i9 >> 2] = i11;
    16006. 

  16006.  HEAP32[i6 + 44 >> 2] = i8;
    16007. 

  16007.  i12 = (i8 | 0) > 0;
    16008. 

  16008.  L43 : do {
    16009. 

  16009.   if (i12) {
    16010. 

  16010.    i10 = 0;
    16011. 

  16011.    do {
    16012. 

  16012.     HEAP32[i11 + (i10 << 4) + 8 >> 2] = 0;
    16013. 

  16013.     i10 = i10 + 1 | 0;
    16014. 

  16014.    } while ((i10 | 0) != (i8 | 0));
    16015. 

  16015.    if (i12) {
    16016. 

  16016.     i10 = i2 + 8 | 0;
    16017. 

  16017.     i13 = 0;
    16018. 

  16018.     while (1) {
    16019. 

  16019.      i12 = i11 + (i13 << 4) | 0;
    16020. 

  16020.      if ((_luaZ_read(HEAP32[i4 >> 2] | 0, i3, 1) | 0) != 0) {
    16021. 

  16021.       i9 = 34;
    16022. 

  16022.       break;
    16023. 

  16023.      }
    16024. 

  16024.      i14 = HEAP8[i3] | 0;
    16025. 

  16025.      if ((i14 | 0) == 4) {
    16026. 

  16026.       if ((_luaZ_read(HEAP32[i4 >> 2] | 0, i3, 4) | 0) != 0) {
    16027. 

  16027.        i9 = 44;
    16028. 

  16028.        break;
    16029. 

  16029.       }
    16030. 

  16030.       i14 = HEAP32[i3 >> 2] | 0;
    16031. 

  16031.       if ((i14 | 0) == 0) {
    16032. 

  16032.        i14 = 0;
    16033. 

  16033.       } else {
    16034. 

  16034.        i14 = _luaZ_openspace(HEAP32[i2 >> 2] | 0, HEAP32[i10 >> 2] | 0, i14) | 0;
    16035. 

  16035.        if ((_luaZ_read(HEAP32[i4 >> 2] | 0, i14, HEAP32[i3 >> 2] | 0) | 0) != 0) {
    16036. 

  16036.         i9 = 47;
    16037. 

  16037.         break;
    16038. 

  16038.        }
    16039. 

  16039.        i14 = _luaS_newlstr(HEAP32[i2 >> 2] | 0, i14, (HEAP32[i3 >> 2] | 0) + -1 | 0) | 0;
    16040. 

  16040.       }
    16041. 

  16041.       HEAP32[i12 >> 2] = i14;
    16042. 

  16042.       HEAP32[i11 + (i13 << 4) + 8 >> 2] = HEAPU8[i14 + 4 | 0] | 64;
    16043. 

  16043.      } else if ((i14 | 0) == 1) {
    16044. 

  16044.       if ((_luaZ_read(HEAP32[i4 >> 2] | 0, i3, 1) | 0) != 0) {
    16045. 

  16045.        i9 = 38;
    16046. 

  16046.        break;
    16047. 

  16047.       }
    16048. 

  16048.       HEAP32[i12 >> 2] = HEAP8[i3] | 0;
    16049. 

  16049.       HEAP32[i11 + (i13 << 4) + 8 >> 2] = 1;
    16050. 

  16050.      } else if ((i14 | 0) == 3) {
    16051. 

  16051.       if ((_luaZ_read(HEAP32[i4 >> 2] | 0, i3, 8) | 0) != 0) {
    16052. 

  16052.        i9 = 41;
    16053. 

  16053.        break;
    16054. 

  16054.       }
    16055. 

  16055.       HEAPF64[i12 >> 3] = +HEAPF64[i3 >> 3];
    16056. 

  16056.       HEAP32[i11 + (i13 << 4) + 8 >> 2] = 3;
    16057. 

  16057.      } else if ((i14 | 0) == 0) {
    16058. 

  16058.       HEAP32[i11 + (i13 << 4) + 8 >> 2] = 0;
    16059. 

  16059.      }
    16060. 

  16060.      i13 = i13 + 1 | 0;
    16061. 

  16061.      if ((i13 | 0) >= (i8 | 0)) {
    16062. 

  16062.       break L43;
    16063. 

  16063.      }
    16064. 

  16064.      i11 = HEAP32[i9 >> 2] | 0;
    16065. 

  16065.     }
    16066. 

  16066.     if ((i9 | 0) == 34) {
    16067. 

  16067.      _error(i2, 8824);
    16068. 

  16068.     } else if ((i9 | 0) == 38) {
    16069. 

  16069.      _error(i2, 8824);
    16070. 

  16070.     } else if ((i9 | 0) == 41) {
    16071. 

  16071.      _error(i2, 8824);
    16072. 

  16072.     } else if ((i9 | 0) == 44) {
    16073. 

  16073.      _error(i2, 8824);
    16074. 

  16074.     } else if ((i9 | 0) == 47) {
    16075. 

  16075.      _error(i2, 8824);
    16076. 

  16076.     }
    16077. 

  16077.    }
    16078. 

  16078.   }
    16079. 

  16079.  } while (0);
    16080. 

  16080.  if ((_luaZ_read(HEAP32[i4 >> 2] | 0, i3, 4) | 0) != 0) {
    16081. 

  16081.   _error(i2, 8824);
    16082. 

  16082.  }
    16083. 

  16083.  i8 = HEAP32[i3 >> 2] | 0;
    16084. 

  16084.  if ((i8 | 0) < 0) {
    16085. 

  16085.   _error(i2, 8872);
    16086. 

  16086.  }
    16087. 

  16087.  i9 = HEAP32[i2 >> 2] | 0;
    16088. 

  16088.  if ((i8 + 1 | 0) >>> 0 > 1073741823) {
    16089. 

  16089.   _luaM_toobig(i9);
    16090. 

  16090.  }
    16091. 

  16091.  i11 = _luaM_realloc_(i9, 0, 0, i8 << 2) | 0;
    16092. 

  16092.  i9 = i6 + 16 | 0;
    16093. 

  16093.  HEAP32[i9 >> 2] = i11;
    16094. 

  16094.  HEAP32[i6 + 56 >> 2] = i8;
    16095. 

  16095.  i10 = (i8 | 0) > 0;
    16096. 

  16096.  if (i10) {
    16097. 

  16097.   i12 = 0;
    16098. 

  16098.   while (1) {
    16099. 

  16099.    HEAP32[i11 + (i12 << 2) >> 2] = 0;
    16100. 

  16100.    i12 = i12 + 1 | 0;
    16101. 

  16101.    if ((i12 | 0) == (i8 | 0)) {
    16102. 

  16102.     break;
    16103. 

  16103.    }
    16104. 

  16104.    i11 = HEAP32[i9 >> 2] | 0;
    16105. 

  16105.   }
    16106. 

  16106.   if (i10) {
    16107. 

  16107.    i10 = 0;
    16108. 

  16108.    do {
    16109. 

  16109.     i14 = _luaF_newproto(HEAP32[i2 >> 2] | 0) | 0;
    16110. 

  16110.     HEAP32[(HEAP32[i9 >> 2] | 0) + (i10 << 2) >> 2] = i14;
    16111. 

  16111.     _LoadFunction(i2, HEAP32[(HEAP32[i9 >> 2] | 0) + (i10 << 2) >> 2] | 0);
    16112. 

  16112.     i10 = i10 + 1 | 0;
    16113. 

  16113.    } while ((i10 | 0) != (i8 | 0));
    16114. 

  16114.   }
    16115. 

  16115.  }
    16116. 

  16116.  if ((_luaZ_read(HEAP32[i4 >> 2] | 0, i3, 4) | 0) != 0) {
    16117. 

  16117.   _error(i2, 8824);
    16118. 

  16118.  }
    16119. 

  16119.  i9 = HEAP32[i3 >> 2] | 0;
    16120. 

  16120.  if ((i9 | 0) < 0) {
    16121. 

  16121.   _error(i2, 8872);
    16122. 

  16122.  }
    16123. 

  16123.  i8 = HEAP32[i2 >> 2] | 0;
    16124. 

  16124.  if ((i9 + 1 | 0) >>> 0 > 536870911) {
    16125. 

  16125.   _luaM_toobig(i8);
    16126. 

  16126.  }
    16127. 

  16127.  i10 = _luaM_realloc_(i8, 0, 0, i9 << 3) | 0;
    16128. 

  16128.  i8 = i6 + 28 | 0;
    16129. 

  16129.  HEAP32[i8 >> 2] = i10;
    16130. 

  16130.  HEAP32[i6 + 40 >> 2] = i9;
    16131. 

  16131.  L98 : do {
    16132. 

  16132.   if ((i9 | 0) > 0) {
    16133. 

  16133.    HEAP32[i10 >> 2] = 0;
    16134. 

  16134.    if ((i9 | 0) == 1) {
    16135. 

  16135.     i10 = 0;
    16136. 

  16136.    } else {
    16137. 

  16137.     i10 = 1;
    16138. 

  16138.     while (1) {
    16139. 

  16139.      HEAP32[(HEAP32[i8 >> 2] | 0) + (i10 << 3) >> 2] = 0;
    16140. 

  16140.      i10 = i10 + 1 | 0;
    16141. 

  16141.      if ((i10 | 0) == (i9 | 0)) {
    16142. 

  16142.       i10 = 0;
    16143. 

  16143.       break;
    16144. 

  16144.      }
    16145. 

  16145.     }
    16146. 

  16146.    }
    16147. 

  16147.    while (1) {
    16148. 

  16148.     if ((_luaZ_read(HEAP32[i4 >> 2] | 0, i3, 1) | 0) != 0) {
    16149. 

  16149.      i9 = 73;
    16150. 

  16150.      break;
    16151. 

  16151.     }
    16152. 

  16152.     HEAP8[(HEAP32[i8 >> 2] | 0) + (i10 << 3) + 4 | 0] = HEAP8[i3] | 0;
    16153. 

  16153.     if ((_luaZ_read(HEAP32[i4 >> 2] | 0, i3, 1) | 0) != 0) {
    16154. 

  16154.      i9 = 75;
    16155. 

  16155.      break;
    16156. 

  16156.     }
    16157. 

  16157.     HEAP8[(HEAP32[i8 >> 2] | 0) + (i10 << 3) + 5 | 0] = HEAP8[i3] | 0;
    16158. 

  16158.     i10 = i10 + 1 | 0;
    16159. 

  16159.     if ((i10 | 0) >= (i9 | 0)) {
    16160. 

  16160.      break L98;
    16161. 

  16161.     }
    16162. 

  16162.    }
    16163. 

  16163.    if ((i9 | 0) == 73) {
    16164. 

  16164.     _error(i2, 8824);
    16165. 

  16165.    } else if ((i9 | 0) == 75) {
    16166. 

  16166.     _error(i2, 8824);
    16167. 

  16167.    }
    16168. 

  16168.   }
    16169. 

  16169.  } while (0);
    16170. 

  16170.  if ((_luaZ_read(HEAP32[i4 >> 2] | 0, i3, 4) | 0) != 0) {
    16171. 

  16171.   _error(i2, 8824);
    16172. 

  16172.  }
    16173. 

  16173.  i9 = HEAP32[i3 >> 2] | 0;
    16174. 

  16174.  do {
    16175. 

  16175.   if ((i9 | 0) != 0) {
    16176. 

  16176.    i9 = _luaZ_openspace(HEAP32[i2 >> 2] | 0, HEAP32[i2 + 8 >> 2] | 0, i9) | 0;
    16177. 

  16177.    if ((_luaZ_read(HEAP32[i4 >> 2] | 0, i9, HEAP32[i3 >> 2] | 0) | 0) == 0) {
    16178. 

  16178.     i7 = _luaS_newlstr(HEAP32[i2 >> 2] | 0, i9, (HEAP32[i3 >> 2] | 0) + -1 | 0) | 0;
    16179. 

  16179.     break;
    16180. 

  16180.    } else {
    16181. 

  16181.     _error(i2, 8824);
    16182. 

  16182.    }
    16183. 

  16183.   } else {
    16184. 

  16184.    i7 = 0;
    16185. 

  16185.   }
    16186. 

  16186.  } while (0);
    16187. 

  16187.  HEAP32[i6 + 36 >> 2] = i7;
    16188. 

  16188.  if ((_luaZ_read(HEAP32[i4 >> 2] | 0, i3, 4) | 0) != 0) {
    16189. 

  16189.   _error(i2, 8824);
    16190. 

  16190.  }
    16191. 

  16191.  i7 = HEAP32[i3 >> 2] | 0;
    16192. 

  16192.  if ((i7 | 0) < 0) {
    16193. 

  16193.   _error(i2, 8872);
    16194. 

  16194.  }
    16195. 

  16195.  i9 = HEAP32[i2 >> 2] | 0;
    16196. 

  16196.  if ((i7 + 1 | 0) >>> 0 > 1073741823) {
    16197. 

  16197.   _luaM_toobig(i9);
    16198. 

  16198.  }
    16199. 

  16199.  i14 = i7 << 2;
    16200. 

  16200.  i13 = _luaM_realloc_(i9, 0, 0, i14) | 0;
    16201. 

  16201.  HEAP32[i6 + 20 >> 2] = i13;
    16202. 

  16202.  HEAP32[i6 + 52 >> 2] = i7;
    16203. 

  16203.  if ((_luaZ_read(HEAP32[i4 >> 2] | 0, i13, i14) | 0) != 0) {
    16204. 

  16204.   _error(i2, 8824);
    16205. 

  16205.  }
    16206. 

  16206.  if ((_luaZ_read(HEAP32[i4 >> 2] | 0, i3, 4) | 0) != 0) {
    16207. 

  16207.   _error(i2, 8824);
    16208. 

  16208.  }
    16209. 

  16209.  i7 = HEAP32[i3 >> 2] | 0;
    16210. 

  16210.  if ((i7 | 0) < 0) {
    16211. 

  16211.   _error(i2, 8872);
    16212. 

  16212.  }
    16213. 

  16213.  i9 = HEAP32[i2 >> 2] | 0;
    16214. 

  16214.  if ((i7 + 1 | 0) >>> 0 > 357913941) {
    16215. 

  16215.   _luaM_toobig(i9);
    16216. 

  16216.  }
    16217. 

  16217.  i10 = _luaM_realloc_(i9, 0, 0, i7 * 12 | 0) | 0;
    16218. 

  16218.  i9 = i6 + 24 | 0;
    16219. 

  16219.  HEAP32[i9 >> 2] = i10;
    16220. 

  16220.  HEAP32[i6 + 60 >> 2] = i7;
    16221. 

  16221.  L141 : do {
    16222. 

  16222.   if ((i7 | 0) > 0) {
    16223. 

  16223.    HEAP32[i10 >> 2] = 0;
    16224. 

  16224.    if ((i7 | 0) != 1) {
    16225. 

  16225.     i6 = 1;
    16226. 

  16226.     do {
    16227. 

  16227.      HEAP32[(HEAP32[i9 >> 2] | 0) + (i6 * 12 | 0) >> 2] = 0;
    16228. 

  16228.      i6 = i6 + 1 | 0;
    16229. 

  16229.     } while ((i6 | 0) != (i7 | 0));
    16230. 

  16230.    }
    16231. 

  16231.    i6 = i2 + 8 | 0;
    16232. 

  16232.    i10 = 0;
    16233. 

  16233.    while (1) {
    16234. 

  16234.     if ((_luaZ_read(HEAP32[i4 >> 2] | 0, i3, 4) | 0) != 0) {
    16235. 

  16235.      i9 = 102;
    16236. 

  16236.      break;
    16237. 

  16237.     }
    16238. 

  16238.     i11 = HEAP32[i3 >> 2] | 0;
    16239. 

  16239.     if ((i11 | 0) == 0) {
    16240. 

  16240.      i11 = 0;
    16241. 

  16241.     } else {
    16242. 

  16242.      i11 = _luaZ_openspace(HEAP32[i2 >> 2] | 0, HEAP32[i6 >> 2] | 0, i11) | 0;
    16243. 

  16243.      if ((_luaZ_read(HEAP32[i4 >> 2] | 0, i11, HEAP32[i3 >> 2] | 0) | 0) != 0) {
    16244. 

  16244.       i9 = 105;
    16245. 

  16245.       break;
    16246. 

  16246.      }
    16247. 

  16247.      i11 = _luaS_newlstr(HEAP32[i2 >> 2] | 0, i11, (HEAP32[i3 >> 2] | 0) + -1 | 0) | 0;
    16248. 

  16248.     }
    16249. 

  16249.     HEAP32[(HEAP32[i9 >> 2] | 0) + (i10 * 12 | 0) >> 2] = i11;
    16250. 

  16250.     if ((_luaZ_read(HEAP32[i4 >> 2] | 0, i3, 4) | 0) != 0) {
    16251. 

  16251.      i9 = 108;
    16252. 

  16252.      break;
    16253. 

  16253.     }
    16254. 

  16254.     i11 = HEAP32[i3 >> 2] | 0;
    16255. 

  16255.     if ((i11 | 0) < 0) {
    16256. 

  16256.      i9 = 110;
    16257. 

  16257.      break;
    16258. 

  16258.     }
    16259. 

  16259.     HEAP32[(HEAP32[i9 >> 2] | 0) + (i10 * 12 | 0) + 4 >> 2] = i11;
    16260. 

  16260.     if ((_luaZ_read(HEAP32[i4 >> 2] | 0, i3, 4) | 0) != 0) {
    16261. 

  16261.      i9 = 112;
    16262. 

  16262.      break;
    16263. 

  16263.     }
    16264. 

  16264.     i11 = HEAP32[i3 >> 2] | 0;
    16265. 

  16265.     if ((i11 | 0) < 0) {
    16266. 

  16266.      i9 = 114;
    16267. 

  16267.      break;
    16268. 

  16268.     }
    16269. 

  16269.     HEAP32[(HEAP32[i9 >> 2] | 0) + (i10 * 12 | 0) + 8 >> 2] = i11;
    16270. 

  16270.     i10 = i10 + 1 | 0;
    16271. 

  16271.     if ((i10 | 0) >= (i7 | 0)) {
    16272. 

  16272.      break L141;
    16273. 

  16273.     }
    16274. 

  16274.    }
    16275. 

  16275.    if ((i9 | 0) == 102) {
    16276. 

  16276.     _error(i2, 8824);
    16277. 

  16277.    } else if ((i9 | 0) == 105) {
    16278. 

  16278.     _error(i2, 8824);
    16279. 

  16279.    } else if ((i9 | 0) == 108) {
    16280. 

  16280.     _error(i2, 8824);
    16281. 

  16281.    } else if ((i9 | 0) == 110) {
    16282. 

  16282.     _error(i2, 8872);
    16283. 

  16283.    } else if ((i9 | 0) == 112) {
    16284. 

  16284.     _error(i2, 8824);
    16285. 

  16285.    } else if ((i9 | 0) == 114) {
    16286. 

  16286.     _error(i2, 8872);
    16287. 

  16287.    }
    16288. 

  16288.   }
    16289. 

  16289.  } while (0);
    16290. 

  16290.  if ((_luaZ_read(HEAP32[i4 >> 2] | 0, i5, 4) | 0) != 0) {
    16291. 

  16291.   _error(i2, 8824);
    16292. 

  16292.  }
    16293. 

  16293.  i6 = HEAP32[i5 >> 2] | 0;
    16294. 

  16294.  if ((i6 | 0) < 0) {
    16295. 

  16295.   _error(i2, 8872);
    16296. 

  16296.  }
    16297. 

  16297.  if ((i6 | 0) <= 0) {
    16298. 

  16298.   STACKTOP = i1;
    16299. 

  16299.   return;
    16300. 

  16300.  }
    16301. 

  16301.  i5 = i2 + 8 | 0;
    16302. 

  16302.  i7 = 0;
    16303. 

  16303.  while (1) {
    16304. 

  16304.   if ((_luaZ_read(HEAP32[i4 >> 2] | 0, i3, 4) | 0) != 0) {
    16305. 

  16305.    i9 = 123;
    16306. 

  16306.    break;
    16307. 

  16307.   }
    16308. 

  16308.   i9 = HEAP32[i3 >> 2] | 0;
    16309. 

  16309.   if ((i9 | 0) == 0) {
    16310. 

  16310.    i9 = 0;
    16311. 

  16311.   } else {
    16312. 

  16312.    i9 = _luaZ_openspace(HEAP32[i2 >> 2] | 0, HEAP32[i5 >> 2] | 0, i9) | 0;
    16313. 

  16313.    if ((_luaZ_read(HEAP32[i4 >> 2] | 0, i9, HEAP32[i3 >> 2] | 0) | 0) != 0) {
    16314. 

  16314.     i9 = 126;
    16315. 

  16315.     break;
    16316. 

  16316.    }
    16317. 

  16317.    i9 = _luaS_newlstr(HEAP32[i2 >> 2] | 0, i9, (HEAP32[i3 >> 2] | 0) + -1 | 0) | 0;
    16318. 

  16318.   }
    16319. 

  16319.   HEAP32[(HEAP32[i8 >> 2] | 0) + (i7 << 3) >> 2] = i9;
    16320. 

  16320.   i7 = i7 + 1 | 0;
    16321. 

  16321.   if ((i7 | 0) >= (i6 | 0)) {
    16322. 

  16322.    i9 = 129;
    16323. 

  16323.    break;
    16324. 

  16324.   }
    16325. 

  16325.  }
    16326. 

  16326.  if ((i9 | 0) == 123) {
    16327. 

  16327.   _error(i2, 8824);
    16328. 

  16328.  } else if ((i9 | 0) == 126) {
    16329. 

  16329.   _error(i2, 8824);
    16330. 

  16330.  } else if ((i9 | 0) == 129) {
    16331. 

  16331.   STACKTOP = i1;
    16332. 

  16332.   return;
    16333. 

  16333.  }
    16334. 

  16334. }
    16335. 

  16335. function _exp2reg(i4, i1, i7) {
    16336. 

  16336.  i4 = i4 | 0;
    16337. 

  16337.  i1 = i1 | 0;
    16338. 

  16338.  i7 = i7 | 0;
    16339. 

  16339.  var i2 = 0, i3 = 0, i5 = 0, i6 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0, i14 = 0, i15 = 0, i16 = 0, i17 = 0, i18 = 0, i19 = 0, i20 = 0, i21 = 0, i22 = 0, i23 = 0, i24 = 0, i25 = 0;
    16340. 

  16340.  i5 = STACKTOP;
    16341. 

  16341.  _discharge2reg(i4, i1, i7);
    16342. 

  16342.  i6 = i1 + 16 | 0;
    16343. 

  16343.  do {
    16344. 

  16344.   if ((HEAP32[i1 >> 2] | 0) == 10 ? (i10 = HEAP32[i1 + 8 >> 2] | 0, !((i10 | 0) == -1)) : 0) {
    16345. 

  16345.    i22 = HEAP32[i6 >> 2] | 0;
    16346. 

  16346.    if ((i22 | 0) == -1) {
    16347. 

  16347.     HEAP32[i6 >> 2] = i10;
    16348. 

  16348.     break;
    16349. 

  16349.    }
    16350. 

  16350.    i20 = HEAP32[(HEAP32[i4 >> 2] | 0) + 12 >> 2] | 0;
    16351. 

  16351.    while (1) {
    16352. 

  16352.     i19 = i20 + (i22 << 2) | 0;
    16353. 

  16353.     i21 = HEAP32[i19 >> 2] | 0;
    16354. 

  16354.     i23 = (i21 >>> 14) + -131071 | 0;
    16355. 

  16355.     if ((i23 | 0) == -1) {
    16356. 

  16356.      break;
    16357. 

  16357.     }
    16358. 

  16358.     i23 = i22 + 1 + i23 | 0;
    16359. 

  16359.     if ((i23 | 0) == -1) {
    16360. 

  16360.      break;
    16361. 

  16361.     } else {
    16362. 

  16362.      i22 = i23;
    16363. 

  16363.     }
    16364. 

  16364.    }
    16365. 

  16365.    i10 = i10 + ~i22 | 0;
    16366. 

  16366.    if ((((i10 | 0) > -1 ? i10 : 0 - i10 | 0) | 0) > 131071) {
    16367. 

  16367.     _luaX_syntaxerror(HEAP32[i4 + 12 >> 2] | 0, 10624);
    16368. 

  16368.    } else {
    16369. 

  16369.     HEAP32[i19 >> 2] = (i10 << 14) + 2147467264 | i21 & 16383;
    16370. 

  16370.     break;
    16371. 

  16371.    }
    16372. 

  16372.   }
    16373. 

  16373.  } while (0);
    16374. 

  16374.  i21 = HEAP32[i6 >> 2] | 0;
    16375. 

  16375.  i10 = i1 + 20 | 0;
    16376. 

  16376.  i19 = HEAP32[i10 >> 2] | 0;
    16377. 

  16377.  if ((i21 | 0) == (i19 | 0)) {
    16378. 

  16378.   HEAP32[i6 >> 2] = -1;
    16379. 

  16379.   HEAP32[i10 >> 2] = -1;
    16380. 

  16380.   i25 = i1 + 8 | 0;
    16381. 

  16381.   HEAP32[i25 >> 2] = i7;
    16382. 

  16382.   HEAP32[i1 >> 2] = 6;
    16383. 

  16383.   STACKTOP = i5;
    16384. 

  16384.   return;
    16385. 

  16385.  }
    16386. 

  16386.  L18 : do {
    16387. 

  16387.   if ((i21 | 0) == -1) {
    16388. 

  16388.    i18 = 20;
    16389. 

  16389.   } else {
    16390. 

  16390.    i20 = HEAP32[(HEAP32[i4 >> 2] | 0) + 12 >> 2] | 0;
    16391. 

  16391.    while (1) {
    16392. 

  16392.     i23 = i20 + (i21 << 2) | 0;
    16393. 

  16393.     if ((i21 | 0) > 0 ? (i18 = HEAP32[i20 + (i21 + -1 << 2) >> 2] | 0, (HEAP8[5584 + (i18 & 63) | 0] | 0) < 0) : 0) {
    16394. 

  16394.      i22 = i18;
    16395. 

  16395.     } else {
    16396. 

  16396.      i22 = HEAP32[i23 >> 2] | 0;
    16397. 

  16397.     }
    16398. 

  16398.     if ((i22 & 63 | 0) != 28) {
    16399. 

  16399.      i18 = 28;
    16400. 

  16400.      break L18;
    16401. 

  16401.     }
    16402. 

  16402.     i22 = ((HEAP32[i23 >> 2] | 0) >>> 14) + -131071 | 0;
    16403. 

  16403.     if ((i22 | 0) == -1) {
    16404. 

  16404.      i18 = 20;
    16405. 

  16405.      break L18;
    16406. 

  16406.     }
    16407. 

  16407.     i21 = i21 + 1 + i22 | 0;
    16408. 

  16408.     if ((i21 | 0) == -1) {
    16409. 

  16409.      i18 = 20;
    16410. 

  16410.      break;
    16411. 

  16411.     }
    16412. 

  16412.    }
    16413. 

  16413.   }
    16414. 

  16414.  } while (0);
    16415. 

  16415.  L29 : do {
    16416. 

  16416.   if ((i18 | 0) == 20) {
    16417. 

  16417.    if ((i19 | 0) == -1) {
    16418. 

  16418.     i15 = -1;
    16419. 

  16419.     i8 = -1;
    16420. 

  16420.    } else {
    16421. 

  16421.     i20 = HEAP32[(HEAP32[i4 >> 2] | 0) + 12 >> 2] | 0;
    16422. 

  16422.     while (1) {
    16423. 

  16423.      i21 = i20 + (i19 << 2) | 0;
    16424. 

  16424.      if ((i19 | 0) > 0 ? (i17 = HEAP32[i20 + (i19 + -1 << 2) >> 2] | 0, (HEAP8[5584 + (i17 & 63) | 0] | 0) < 0) : 0) {
    16425. 

  16425.       i22 = i17;
    16426. 

  16426.      } else {
    16427. 

  16427.       i22 = HEAP32[i21 >> 2] | 0;
    16428. 

  16428.      }
    16429. 

  16429.      if ((i22 & 63 | 0) != 28) {
    16430. 

  16430.       i18 = 28;
    16431. 

  16431.       break L29;
    16432. 

  16432.      }
    16433. 

  16433.      i21 = ((HEAP32[i21 >> 2] | 0) >>> 14) + -131071 | 0;
    16434. 

  16434.      if ((i21 | 0) == -1) {
    16435. 

  16435.       i15 = -1;
    16436. 

  16436.       i8 = -1;
    16437. 

  16437.       break L29;
    16438. 

  16438.      }
    16439. 

  16439.      i19 = i19 + 1 + i21 | 0;
    16440. 

  16440.      if ((i19 | 0) == -1) {
    16441. 

  16441.       i15 = -1;
    16442. 

  16442.       i8 = -1;
    16443. 

  16443.       break;
    16444. 

  16444.      }
    16445. 

  16445.     }
    16446. 

  16446.    }
    16447. 

  16447.   }
    16448. 

  16448.  } while (0);
    16449. 

  16449.  do {
    16450. 

  16450.   if ((i18 | 0) == 28) {
    16451. 

  16451.    i17 = i4 + 28 | 0;
    16452. 

  16452.    do {
    16453. 

  16453.     if ((HEAP32[i1 >> 2] | 0) != 10) {
    16454. 

  16454.      i21 = HEAP32[i17 >> 2] | 0;
    16455. 

  16455.      HEAP32[i17 >> 2] = -1;
    16456. 

  16456.      i18 = _luaK_code(i4, 2147450903) | 0;
    16457. 

  16457.      if (!((i21 | 0) == -1)) {
    16458. 

  16458.       if (!((i18 | 0) == -1)) {
    16459. 

  16459.        i23 = HEAP32[(HEAP32[i4 >> 2] | 0) + 12 >> 2] | 0;
    16460. 

  16460.        i22 = i18;
    16461. 

  16461.        while (1) {
    16462. 

  16462.         i20 = i23 + (i22 << 2) | 0;
    16463. 

  16463.         i19 = HEAP32[i20 >> 2] | 0;
    16464. 

  16464.         i24 = (i19 >>> 14) + -131071 | 0;
    16465. 

  16465.         if ((i24 | 0) == -1) {
    16466. 

  16466.          break;
    16467. 

  16467.         }
    16468. 

  16468.         i24 = i22 + 1 + i24 | 0;
    16469. 

  16469.         if ((i24 | 0) == -1) {
    16470. 

  16470.          break;
    16471. 

  16471.         } else {
    16472. 

  16472.          i22 = i24;
    16473. 

  16473.         }
    16474. 

  16474.        }
    16475. 

  16475.        i21 = i21 + ~i22 | 0;
    16476. 

  16476.        if ((((i21 | 0) > -1 ? i21 : 0 - i21 | 0) | 0) > 131071) {
    16477. 

  16477.         _luaX_syntaxerror(HEAP32[i4 + 12 >> 2] | 0, 10624);
    16478. 

  16478.        } else {
    16479. 

  16479.         HEAP32[i20 >> 2] = (i21 << 14) + 2147467264 | i19 & 16383;
    16480. 

  16480.         i16 = i18;
    16481. 

  16481.         break;
    16482. 

  16482.        }
    16483. 

  16483.       } else {
    16484. 

  16484.        i16 = i21;
    16485. 

  16485.       }
    16486. 

  16486.      } else {
    16487. 

  16487.       i16 = i18;
    16488. 

  16488.      }
    16489. 

  16489.     } else {
    16490. 

  16490.      i16 = -1;
    16491. 

  16491.     }
    16492. 

  16492.    } while (0);
    16493. 

  16493.    i24 = i4 + 20 | 0;
    16494. 

  16494.    i25 = i4 + 24 | 0;
    16495. 

  16495.    HEAP32[i25 >> 2] = HEAP32[i24 >> 2];
    16496. 

  16496.    i19 = i7 << 6;
    16497. 

  16497.    i18 = _luaK_code(i4, i19 | 16387) | 0;
    16498. 

  16498.    HEAP32[i25 >> 2] = HEAP32[i24 >> 2];
    16499. 

  16499.    i19 = _luaK_code(i4, i19 | 8388611) | 0;
    16500. 

  16500.    HEAP32[i25 >> 2] = HEAP32[i24 >> 2];
    16501. 

  16501.    if (!((i16 | 0) == -1)) {
    16502. 

  16502.     i22 = HEAP32[i17 >> 2] | 0;
    16503. 

  16503.     if ((i22 | 0) == -1) {
    16504. 

  16504.      HEAP32[i17 >> 2] = i16;
    16505. 

  16505.      i15 = i18;
    16506. 

  16506.      i8 = i19;
    16507. 

  16507.      break;
    16508. 

  16508.     }
    16509. 

  16509.     i17 = HEAP32[(HEAP32[i4 >> 2] | 0) + 12 >> 2] | 0;
    16510. 

  16510.     while (1) {
    16511. 

  16511.      i21 = i17 + (i22 << 2) | 0;
    16512. 

  16512.      i20 = HEAP32[i21 >> 2] | 0;
    16513. 

  16513.      i23 = (i20 >>> 14) + -131071 | 0;
    16514. 

  16514.      if ((i23 | 0) == -1) {
    16515. 

  16515.       break;
    16516. 

  16516.      }
    16517. 

  16517.      i23 = i22 + 1 + i23 | 0;
    16518. 

  16518.      if ((i23 | 0) == -1) {
    16519. 

  16519.       break;
    16520. 

  16520.      } else {
    16521. 

  16521.       i22 = i23;
    16522. 

  16522.      }
    16523. 

  16523.     }
    16524. 

  16524.     i16 = i16 + ~i22 | 0;
    16525. 

  16525.     if ((((i16 | 0) > -1 ? i16 : 0 - i16 | 0) | 0) > 131071) {
    16526. 

  16526.      _luaX_syntaxerror(HEAP32[i4 + 12 >> 2] | 0, 10624);
    16527. 

  16527.     } else {
    16528. 

  16528.      HEAP32[i21 >> 2] = (i16 << 14) + 2147467264 | i20 & 16383;
    16529. 

  16529.      i15 = i18;
    16530. 

  16530.      i8 = i19;
    16531. 

  16531.      break;
    16532. 

  16532.     }
    16533. 

  16533.    } else {
    16534. 

  16534.     i15 = i18;
    16535. 

  16535.     i8 = i19;
    16536. 

  16536.    }
    16537. 

  16537.   }
    16538. 

  16538.  } while (0);
    16539. 

  16539.  i16 = HEAP32[i4 + 20 >> 2] | 0;
    16540. 

  16540.  HEAP32[i4 + 24 >> 2] = i16;
    16541. 

  16541.  i22 = HEAP32[i10 >> 2] | 0;
    16542. 

  16542.  L67 : do {
    16543. 

  16543.   if (!((i22 | 0) == -1)) {
    16544. 

  16544.    i19 = (i7 | 0) == 255;
    16545. 

  16545.    i17 = i7 << 6 & 16320;
    16546. 

  16546.    i18 = HEAP32[(HEAP32[i4 >> 2] | 0) + 12 >> 2] | 0;
    16547. 

  16547.    while (1) {
    16548. 

  16548.     i20 = i18 + (i22 << 2) | 0;
    16549. 

  16549.     i23 = HEAP32[i20 >> 2] | 0;
    16550. 

  16550.     i21 = (i23 >>> 14) + -131071 | 0;
    16551. 

  16551.     if ((i21 | 0) == -1) {
    16552. 

  16552.      i21 = -1;
    16553. 

  16553.     } else {
    16554. 

  16554.      i21 = i22 + 1 + i21 | 0;
    16555. 

  16555.     }
    16556. 

  16556.     if ((i22 | 0) > 0 ? (i14 = i18 + (i22 + -1 << 2) | 0, i13 = HEAP32[i14 >> 2] | 0, (HEAP8[5584 + (i13 & 63) | 0] | 0) < 0) : 0) {
    16557. 

  16557.      i24 = i14;
    16558. 

  16558.      i25 = i13;
    16559. 

  16559.     } else {
    16560. 

  16560.      i24 = i20;
    16561. 

  16561.      i25 = i23;
    16562. 

  16562.     }
    16563. 

  16563.     if ((i25 & 63 | 0) == 28) {
    16564. 

  16564.      i23 = i25 >>> 23;
    16565. 

  16565.      if (i19 | (i23 | 0) == (i7 | 0)) {
    16566. 

  16566.       i23 = i25 & 8372224 | i23 << 6 | 27;
    16567. 

  16567.      } else {
    16568. 

  16568.       i23 = i25 & -16321 | i17;
    16569. 

  16569.      }
    16570. 

  16570.      HEAP32[i24 >> 2] = i23;
    16571. 

  16571.      i22 = i16 + ~i22 | 0;
    16572. 

  16572.      if ((((i22 | 0) > -1 ? i22 : 0 - i22 | 0) | 0) > 131071) {
    16573. 

  16573.       i18 = 58;
    16574. 

  16574.       break;
    16575. 

  16575.      }
    16576. 

  16576.      i22 = HEAP32[i20 >> 2] & 16383 | (i22 << 14) + 2147467264;
    16577. 

  16577.     } else {
    16578. 

  16578.      i22 = i15 + ~i22 | 0;
    16579. 

  16579.      if ((((i22 | 0) > -1 ? i22 : 0 - i22 | 0) | 0) > 131071) {
    16580. 

  16580.       i18 = 61;
    16581. 

  16581.       break;
    16582. 

  16582.      }
    16583. 

  16583.      i22 = i23 & 16383 | (i22 << 14) + 2147467264;
    16584. 

  16584.     }
    16585. 

  16585.     HEAP32[i20 >> 2] = i22;
    16586. 

  16586.     if ((i21 | 0) == -1) {
    16587. 

  16587.      break L67;
    16588. 

  16588.     } else {
    16589. 

  16589.      i22 = i21;
    16590. 

  16590.     }
    16591. 

  16591.    }
    16592. 

  16592.    if ((i18 | 0) == 58) {
    16593. 

  16593.     _luaX_syntaxerror(HEAP32[i4 + 12 >> 2] | 0, 10624);
    16594. 

  16594.    } else if ((i18 | 0) == 61) {
    16595. 

  16595.     _luaX_syntaxerror(HEAP32[i4 + 12 >> 2] | 0, 10624);
    16596. 

  16596.    }
    16597. 

  16597.   }
    16598. 

  16598.  } while (0);
    16599. 

  16599.  i20 = HEAP32[i6 >> 2] | 0;
    16600. 

  16600.  if ((i20 | 0) == -1) {
    16601. 

  16601.   HEAP32[i6 >> 2] = -1;
    16602. 

  16602.   HEAP32[i10 >> 2] = -1;
    16603. 

  16603.   i25 = i1 + 8 | 0;
    16604. 

  16604.   HEAP32[i25 >> 2] = i7;
    16605. 

  16605.   HEAP32[i1 >> 2] = 6;
    16606. 

  16606.   STACKTOP = i5;
    16607. 

  16607.   return;
    16608. 

  16608.  }
    16609. 

  16609.  i13 = i7 << 6;
    16610. 

  16610.  i15 = i13 & 16320;
    16611. 

  16611.  i14 = HEAP32[(HEAP32[i4 >> 2] | 0) + 12 >> 2] | 0;
    16612. 

  16612.  if ((i7 | 0) == 255) {
    16613. 

  16613.   while (1) {
    16614. 

  16614.    i17 = i14 + (i20 << 2) | 0;
    16615. 

  16615.    i19 = HEAP32[i17 >> 2] | 0;
    16616. 

  16616.    i18 = (i19 >>> 14) + -131071 | 0;
    16617. 

  16617.    if ((i18 | 0) == -1) {
    16618. 

  16618.     i18 = -1;
    16619. 

  16619.    } else {
    16620. 

  16620.     i18 = i20 + 1 + i18 | 0;
    16621. 

  16621.    }
    16622. 

  16622.    if ((i20 | 0) > 0 ? (i12 = i14 + (i20 + -1 << 2) | 0, i11 = HEAP32[i12 >> 2] | 0, (HEAP8[5584 + (i11 & 63) | 0] | 0) < 0) : 0) {
    16623. 

  16623.     i22 = i12;
    16624. 

  16624.     i21 = i11;
    16625. 

  16625.    } else {
    16626. 

  16626.     i22 = i17;
    16627. 

  16627.     i21 = i19;
    16628. 

  16628.    }
    16629. 

  16629.    if ((i21 & 63 | 0) == 28) {
    16630. 

  16630.     HEAP32[i22 >> 2] = i21 & 8372224 | i21 >>> 23 << 6 | 27;
    16631. 

  16631.     i19 = i16 + ~i20 | 0;
    16632. 

  16632.     if ((((i19 | 0) > -1 ? i19 : 0 - i19 | 0) | 0) > 131071) {
    16633. 

  16633.      i18 = 87;
    16634. 

  16634.      break;
    16635. 

  16635.     }
    16636. 

  16636.     i19 = HEAP32[i17 >> 2] & 16383 | (i19 << 14) + 2147467264;
    16637. 

  16637.    } else {
    16638. 

  16638.     i20 = i8 + ~i20 | 0;
    16639. 

  16639.     if ((((i20 | 0) > -1 ? i20 : 0 - i20 | 0) | 0) > 131071) {
    16640. 

  16640.      i18 = 90;
    16641. 

  16641.      break;
    16642. 

  16642.     }
    16643. 

  16643.     i19 = i19 & 16383 | (i20 << 14) + 2147467264;
    16644. 

  16644.    }
    16645. 

  16645.    HEAP32[i17 >> 2] = i19;
    16646. 

  16646.    if ((i18 | 0) == -1) {
    16647. 

  16647.     i18 = 93;
    16648. 

  16648.     break;
    16649. 

  16649.    } else {
    16650. 

  16650.     i20 = i18;
    16651. 

  16651.    }
    16652. 

  16652.   }
    16653. 

  16653.   if ((i18 | 0) == 87) {
    16654. 

  16654.    i25 = i4 + 12 | 0;
    16655. 

  16655.    i25 = HEAP32[i25 >> 2] | 0;
    16656. 

  16656.    _luaX_syntaxerror(i25, 10624);
    16657. 

  16657.   } else if ((i18 | 0) == 90) {
    16658. 

  16658.    i25 = i4 + 12 | 0;
    16659. 

  16659.    i25 = HEAP32[i25 >> 2] | 0;
    16660. 

  16660.    _luaX_syntaxerror(i25, 10624);
    16661. 

  16661.   } else if ((i18 | 0) == 93) {
    16662. 

  16662.    HEAP32[i6 >> 2] = -1;
    16663. 

  16663.    HEAP32[i10 >> 2] = -1;
    16664. 

  16664.    i25 = i1 + 8 | 0;
    16665. 

  16665.    HEAP32[i25 >> 2] = i7;
    16666. 

  16666.    HEAP32[i1 >> 2] = 6;
    16667. 

  16667.    STACKTOP = i5;
    16668. 

  16668.    return;
    16669. 

  16669.   }
    16670. 

  16670.  } else {
    16671. 

  16671.   i9 = i20;
    16672. 

  16672.  }
    16673. 

  16673.  while (1) {
    16674. 

  16674.   i11 = i14 + (i9 << 2) | 0;
    16675. 

  16675.   i17 = HEAP32[i11 >> 2] | 0;
    16676. 

  16676.   i12 = (i17 >>> 14) + -131071 | 0;
    16677. 

  16677.   if ((i12 | 0) == -1) {
    16678. 

  16678.    i12 = -1;
    16679. 

  16679.   } else {
    16680. 

  16680.    i12 = i9 + 1 + i12 | 0;
    16681. 

  16681.   }
    16682. 

  16682.   if ((i9 | 0) > 0 ? (i3 = i14 + (i9 + -1 << 2) | 0, i2 = HEAP32[i3 >> 2] | 0, (HEAP8[5584 + (i2 & 63) | 0] | 0) < 0) : 0) {
    16683. 

  16683.    i18 = i3;
    16684. 

  16684.    i19 = i2;
    16685. 

  16685.   } else {
    16686. 

  16686.    i18 = i11;
    16687. 

  16687.    i19 = i17;
    16688. 

  16688.   }
    16689. 

  16689.   if ((i19 & 63 | 0) == 28) {
    16690. 

  16690.    if ((i19 >>> 23 | 0) == (i7 | 0)) {
    16691. 

  16691.     i17 = i19 & 8372224 | i13 | 27;
    16692. 

  16692.    } else {
    16693. 

  16693.     i17 = i19 & -16321 | i15;
    16694. 

  16694.    }
    16695. 

  16695.    HEAP32[i18 >> 2] = i17;
    16696. 

  16696.    i9 = i16 + ~i9 | 0;
    16697. 

  16697.    if ((((i9 | 0) > -1 ? i9 : 0 - i9 | 0) | 0) > 131071) {
    16698. 

  16698.     i18 = 87;
    16699. 

  16699.     break;
    16700. 

  16700.    }
    16701. 

  16701.    i9 = HEAP32[i11 >> 2] & 16383 | (i9 << 14) + 2147467264;
    16702. 

  16702.   } else {
    16703. 

  16703.    i9 = i8 + ~i9 | 0;
    16704. 

  16704.    if ((((i9 | 0) > -1 ? i9 : 0 - i9 | 0) | 0) > 131071) {
    16705. 

  16705.     i18 = 90;
    16706. 

  16706.     break;
    16707. 

  16707.    }
    16708. 

  16708.    i9 = i17 & 16383 | (i9 << 14) + 2147467264;
    16709. 

  16709.   }
    16710. 

  16710.   HEAP32[i11 >> 2] = i9;
    16711. 

  16711.   if ((i12 | 0) == -1) {
    16712. 

  16712.    i18 = 93;
    16713. 

  16713.    break;
    16714. 

  16714.   } else {
    16715. 

  16715.    i9 = i12;
    16716. 

  16716.   }
    16717. 

  16717.  }
    16718. 

  16718.  if ((i18 | 0) == 87) {
    16719. 

  16719.   i25 = i4 + 12 | 0;
    16720. 

  16720.   i25 = HEAP32[i25 >> 2] | 0;
    16721. 

  16721.   _luaX_syntaxerror(i25, 10624);
    16722. 

  16722.  } else if ((i18 | 0) == 90) {
    16723. 

  16723.   i25 = i4 + 12 | 0;
    16724. 

  16724.   i25 = HEAP32[i25 >> 2] | 0;
    16725. 

  16725.   _luaX_syntaxerror(i25, 10624);
    16726. 

  16726.  } else if ((i18 | 0) == 93) {
    16727. 

  16727.   HEAP32[i6 >> 2] = -1;
    16728. 

  16728.   HEAP32[i10 >> 2] = -1;
    16729. 

  16729.   i25 = i1 + 8 | 0;
    16730. 

  16730.   HEAP32[i25 >> 2] = i7;
    16731. 

  16731.   HEAP32[i1 >> 2] = 6;
    16732. 

  16732.   STACKTOP = i5;
    16733. 

  16733.   return;
    16734. 

  16734.  }
    16735. 

  16735. }
    16736. 

  16736. function _propagatemark(i2) {
    16737. 

  16737.  i2 = i2 | 0;
    16738. 

  16738.  var i1 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0, i14 = 0, i15 = 0;
    16739. 

  16739.  i1 = STACKTOP;
    16740. 

  16740.  i15 = i2 + 84 | 0;
    16741. 

  16741.  i3 = HEAP32[i15 >> 2] | 0;
    16742. 

  16742.  i10 = i3 + 5 | 0;
    16743. 

  16743.  HEAP8[i10] = HEAPU8[i10] | 4;
    16744. 

  16744.  switch (HEAPU8[i3 + 4 | 0] | 0) {
    16745. 

  16745.  case 5:
    16746. 

  16746.   {
    16747. 

  16747.    i9 = i3 + 24 | 0;
    16748. 

  16748.    HEAP32[i15 >> 2] = HEAP32[i9 >> 2];
    16749. 

  16749.    i15 = i3 + 8 | 0;
    16750. 

  16750.    i14 = HEAP32[i15 >> 2] | 0;
    16751. 

  16751.    do {
    16752. 

  16752.     if ((i14 | 0) != 0) {
    16753. 

  16753.      if ((HEAP8[i14 + 6 | 0] & 8) == 0) {
    16754. 

  16754.       i11 = _luaT_gettm(i14, 3, HEAP32[i2 + 196 >> 2] | 0) | 0;
    16755. 

  16755.       i14 = HEAP32[i15 >> 2] | 0;
    16756. 

  16756.       if ((i14 | 0) != 0) {
    16757. 

  16757.        i6 = 5;
    16758. 

  16758.       }
    16759. 

  16759.      } else {
    16760. 

  16760.       i11 = 0;
    16761. 

  16761.       i6 = 5;
    16762. 

  16762.      }
    16763. 

  16763.      if ((i6 | 0) == 5) {
    16764. 

  16764.       if (!((HEAP8[i14 + 5 | 0] & 3) == 0)) {
    16765. 

  16765.        _reallymarkobject(i2, i14);
    16766. 

  16766.       }
    16767. 

  16767.      }
    16768. 

  16768.      if (((i11 | 0) != 0 ? (HEAP32[i11 + 8 >> 2] & 15 | 0) == 4 : 0) ? (i13 = (HEAP32[i11 >> 2] | 0) + 16 | 0, i12 = _strchr(i13, 107) | 0, i12 = (i12 | 0) != 0, i13 = (_strchr(i13, 118) | 0) == 0, !(i13 & (i12 ^ 1))) : 0) {
    16769. 

  16769.       HEAP8[i10] = HEAP8[i10] & 251;
    16770. 

  16770.       if (i12) {
    16771. 

  16771.        if (i13) {
    16772. 

  16772.         _traverseephemeron(i2, i3) | 0;
    16773. 

  16773.         break;
    16774. 

  16774.        } else {
    16775. 

  16775.         i15 = i2 + 100 | 0;
    16776. 

  16776.         HEAP32[i9 >> 2] = HEAP32[i15 >> 2];
    16777. 

  16777.         HEAP32[i15 >> 2] = i3;
    16778. 

  16778.         break;
    16779. 

  16779.        }
    16780. 

  16780.       }
    16781. 

  16781.       i15 = 1 << HEAPU8[i3 + 7 | 0];
    16782. 

  16782.       i5 = HEAP32[i3 + 16 >> 2] | 0;
    16783. 

  16783.       i4 = i5 + (i15 << 5) | 0;
    16784. 

  16784.       i8 = (HEAP32[i3 + 28 >> 2] | 0) > 0 | 0;
    16785. 

  16785.       if ((i15 | 0) > 0) {
    16786. 

  16786.        do {
    16787. 

  16787.         i12 = i5 + 8 | 0;
    16788. 

  16788.         i10 = i5 + 24 | 0;
    16789. 

  16789.         i11 = (HEAP32[i10 >> 2] & 64 | 0) == 0;
    16790. 

  16790.         do {
    16791. 

  16791.          if ((HEAP32[i12 >> 2] | 0) == 0) {
    16792. 

  16792.           if (!i11 ? !((HEAP8[(HEAP32[i5 + 16 >> 2] | 0) + 5 | 0] & 3) == 0) : 0) {
    16793. 

  16793.            HEAP32[i10 >> 2] = 11;
    16794. 

  16794.           }
    16795. 

  16795.          } else {
    16796. 

  16796.           if (!i11 ? (i7 = HEAP32[i5 + 16 >> 2] | 0, !((HEAP8[i7 + 5 | 0] & 3) == 0)) : 0) {
    16797. 

  16797.            _reallymarkobject(i2, i7);
    16798. 

  16798.           }
    16799. 

  16799.           if ((i8 | 0) == 0) {
    16800. 

  16800.            i10 = HEAP32[i12 >> 2] | 0;
    16801. 

  16801.            if ((i10 & 64 | 0) != 0) {
    16802. 

  16802.             i8 = HEAP32[i5 >> 2] | 0;
    16803. 

  16803.             if ((i10 & 15 | 0) != 4) {
    16804. 

  16804.              i8 = (HEAP8[i8 + 5 | 0] & 3) != 0 | 0;
    16805. 

  16805.              break;
    16806. 

  16806.             }
    16807. 

  16807.             if ((i8 | 0) != 0 ? !((HEAP8[i8 + 5 | 0] & 3) == 0) : 0) {
    16808. 

  16808.              _reallymarkobject(i2, i8);
    16809. 

  16809.              i8 = 0;
    16810. 

  16810.             } else {
    16811. 

  16811.              i8 = 0;
    16812. 

  16812.             }
    16813. 

  16813.            } else {
    16814. 

  16814.             i8 = 0;
    16815. 

  16815.            }
    16816. 

  16816.           }
    16817. 

  16817.          }
    16818. 

  16818.         } while (0);
    16819. 

  16819.         i5 = i5 + 32 | 0;
    16820. 

  16820.        } while (i5 >>> 0 < i4 >>> 0);
    16821. 

  16821.       }
    16822. 

  16822.       if ((i8 | 0) == 0) {
    16823. 

  16823.        i15 = i2 + 88 | 0;
    16824. 

  16824.        HEAP32[i9 >> 2] = HEAP32[i15 >> 2];
    16825. 

  16825.        HEAP32[i15 >> 2] = i3;
    16826. 

  16826.        break;
    16827. 

  16827.       } else {
    16828. 

  16828.        i15 = i2 + 92 | 0;
    16829. 

  16829.        HEAP32[i9 >> 2] = HEAP32[i15 >> 2];
    16830. 

  16830.        HEAP32[i15 >> 2] = i3;
    16831. 

  16831.        break;
    16832. 

  16832.       }
    16833. 

  16833.      } else {
    16834. 

  16834.       i6 = 33;
    16835. 

  16835.      }
    16836. 

  16836.     } else {
    16837. 

  16837.      i6 = 33;
    16838. 

  16838.     }
    16839. 

  16839.    } while (0);
    16840. 

  16840.    if ((i6 | 0) == 33) {
    16841. 

  16841.     i7 = i3 + 16 | 0;
    16842. 

  16842.     i10 = HEAP32[i7 >> 2] | 0;
    16843. 

  16843.     i6 = i10 + (1 << HEAPU8[i3 + 7 | 0] << 5) | 0;
    16844. 

  16844.     i9 = i3 + 28 | 0;
    16845. 

  16845.     i13 = HEAP32[i9 >> 2] | 0;
    16846. 

  16846.     if ((i13 | 0) > 0) {
    16847. 

  16847.      i10 = i3 + 12 | 0;
    16848. 

  16848.      i11 = 0;
    16849. 

  16849.      do {
    16850. 

  16850.       i12 = HEAP32[i10 >> 2] | 0;
    16851. 

  16851.       if ((HEAP32[i12 + (i11 << 4) + 8 >> 2] & 64 | 0) != 0 ? (i8 = HEAP32[i12 + (i11 << 4) >> 2] | 0, !((HEAP8[i8 + 5 | 0] & 3) == 0)) : 0) {
    16852. 

  16852.        _reallymarkobject(i2, i8);
    16853. 

  16853.        i13 = HEAP32[i9 >> 2] | 0;
    16854. 

  16854.       }
    16855. 

  16855.       i11 = i11 + 1 | 0;
    16856. 

  16856.      } while ((i11 | 0) < (i13 | 0));
    16857. 

  16857.      i7 = HEAP32[i7 >> 2] | 0;
    16858. 

  16858.     } else {
    16859. 

  16859.      i7 = i10;
    16860. 

  16860.     }
    16861. 

  16861.     if (i7 >>> 0 < i6 >>> 0) {
    16862. 

  16862.      do {
    16863. 

  16863.       i10 = i7 + 8 | 0;
    16864. 

  16864.       i11 = HEAP32[i10 >> 2] | 0;
    16865. 

  16865.       i9 = i7 + 24 | 0;
    16866. 

  16866.       i8 = (HEAP32[i9 >> 2] & 64 | 0) == 0;
    16867. 

  16867.       if ((i11 | 0) == 0) {
    16868. 

  16868.        if (!i8 ? !((HEAP8[(HEAP32[i7 + 16 >> 2] | 0) + 5 | 0] & 3) == 0) : 0) {
    16869. 

  16869.         HEAP32[i9 >> 2] = 11;
    16870. 

  16870.        }
    16871. 

  16871.       } else {
    16872. 

  16872.        if (!i8 ? (i5 = HEAP32[i7 + 16 >> 2] | 0, !((HEAP8[i5 + 5 | 0] & 3) == 0)) : 0) {
    16873. 

  16873.         _reallymarkobject(i2, i5);
    16874. 

  16874.         i11 = HEAP32[i10 >> 2] | 0;
    16875. 

  16875.        }
    16876. 

  16876.        if ((i11 & 64 | 0) != 0 ? (i4 = HEAP32[i7 >> 2] | 0, !((HEAP8[i4 + 5 | 0] & 3) == 0)) : 0) {
    16877. 

  16877.         _reallymarkobject(i2, i4);
    16878. 

  16878.        }
    16879. 

  16879.       }
    16880. 

  16880.       i7 = i7 + 32 | 0;
    16881. 

  16881.      } while (i7 >>> 0 < i6 >>> 0);
    16882. 

  16882.     }
    16883. 

  16883.    }
    16884. 

  16884.    i3 = (HEAP32[i3 + 28 >> 2] << 4) + 32 + (32 << HEAPU8[i3 + 7 | 0]) | 0;
    16885. 

  16885.    break;
    16886. 

  16886.   }
    16887. 

  16887.  case 8:
    16888. 

  16888.   {
    16889. 

  16889.    i7 = i3 + 60 | 0;
    16890. 

  16890.    HEAP32[i15 >> 2] = HEAP32[i7 >> 2];
    16891. 

  16891.    i4 = i2 + 88 | 0;
    16892. 

  16892.    HEAP32[i7 >> 2] = HEAP32[i4 >> 2];
    16893. 

  16893.    HEAP32[i4 >> 2] = i3;
    16894. 

  16894.    HEAP8[i10] = HEAP8[i10] & 251;
    16895. 

  16895.    i4 = i3 + 28 | 0;
    16896. 

  16896.    i7 = HEAP32[i4 >> 2] | 0;
    16897. 

  16897.    if ((i7 | 0) == 0) {
    16898. 

  16898.     i3 = 1;
    16899. 

  16899.    } else {
    16900. 

  16900.     i5 = i3 + 8 | 0;
    16901. 

  16901.     i6 = HEAP32[i5 >> 2] | 0;
    16902. 

  16902.     if (i7 >>> 0 < i6 >>> 0) {
    16903. 

  16903.      do {
    16904. 

  16904.       if ((HEAP32[i7 + 8 >> 2] & 64 | 0) != 0 ? (i11 = HEAP32[i7 >> 2] | 0, !((HEAP8[i11 + 5 | 0] & 3) == 0)) : 0) {
    16905. 

  16905.        _reallymarkobject(i2, i11);
    16906. 

  16906.        i6 = HEAP32[i5 >> 2] | 0;
    16907. 

  16907.       }
    16908. 

  16908.       i7 = i7 + 16 | 0;
    16909. 

  16909.      } while (i7 >>> 0 < i6 >>> 0);
    16910. 

  16910.     }
    16911. 

  16911.     if ((HEAP8[i2 + 61 | 0] | 0) == 1) {
    16912. 

  16912.      i3 = i3 + 32 | 0;
    16913. 

  16913.      i4 = (HEAP32[i4 >> 2] | 0) + (HEAP32[i3 >> 2] << 4) | 0;
    16914. 

  16914.      if (i7 >>> 0 < i4 >>> 0) {
    16915. 

  16915.       do {
    16916. 

  16916.        HEAP32[i7 + 8 >> 2] = 0;
    16917. 

  16917.        i7 = i7 + 16 | 0;
    16918. 

  16918.       } while (i7 >>> 0 < i4 >>> 0);
    16919. 

  16919.      }
    16920. 

  16920.     } else {
    16921. 

  16921.      i3 = i3 + 32 | 0;
    16922. 

  16922.     }
    16923. 

  16923.     i3 = (HEAP32[i3 >> 2] << 4) + 112 | 0;
    16924. 

  16924.    }
    16925. 

  16925.    break;
    16926. 

  16926.   }
    16927. 

  16927.  case 9:
    16928. 

  16928.   {
    16929. 

  16929.    HEAP32[i15 >> 2] = HEAP32[i3 + 72 >> 2];
    16930. 

  16930.    i5 = i3 + 32 | 0;
    16931. 

  16931.    i4 = HEAP32[i5 >> 2] | 0;
    16932. 

  16932.    if ((i4 | 0) != 0 ? !((HEAP8[i4 + 5 | 0] & 3) == 0) : 0) {
    16933. 

  16933.     HEAP32[i5 >> 2] = 0;
    16934. 

  16934.    }
    16935. 

  16935.    i4 = HEAP32[i3 + 36 >> 2] | 0;
    16936. 

  16936.    if ((i4 | 0) != 0 ? !((HEAP8[i4 + 5 | 0] & 3) == 0) : 0) {
    16937. 

  16937.     _reallymarkobject(i2, i4);
    16938. 

  16938.    }
    16939. 

  16939.    i4 = i3 + 44 | 0;
    16940. 

  16940.    i8 = HEAP32[i4 >> 2] | 0;
    16941. 

  16941.    if ((i8 | 0) > 0) {
    16942. 

  16942.     i5 = i3 + 8 | 0;
    16943. 

  16943.     i6 = 0;
    16944. 

  16944.     do {
    16945. 

  16945.      i7 = HEAP32[i5 >> 2] | 0;
    16946. 

  16946.      if ((HEAP32[i7 + (i6 << 4) + 8 >> 2] & 64 | 0) != 0 ? (i9 = HEAP32[i7 + (i6 << 4) >> 2] | 0, !((HEAP8[i9 + 5 | 0] & 3) == 0)) : 0) {
    16947. 

  16947.       _reallymarkobject(i2, i9);
    16948. 

  16948.       i8 = HEAP32[i4 >> 2] | 0;
    16949. 

  16949.      }
    16950. 

  16950.      i6 = i6 + 1 | 0;
    16951. 

  16951.     } while ((i6 | 0) < (i8 | 0));
    16952. 

  16952.    }
    16953. 

  16953.    i5 = i3 + 40 | 0;
    16954. 

  16954.    i8 = HEAP32[i5 >> 2] | 0;
    16955. 

  16955.    if ((i8 | 0) > 0) {
    16956. 

  16956.     i6 = i3 + 28 | 0;
    16957. 

  16957.     i7 = 0;
    16958. 

  16958.     do {
    16959. 

  16959.      i9 = HEAP32[(HEAP32[i6 >> 2] | 0) + (i7 << 3) >> 2] | 0;
    16960. 

  16960.      if ((i9 | 0) != 0 ? !((HEAP8[i9 + 5 | 0] & 3) == 0) : 0) {
    16961. 

  16961.       _reallymarkobject(i2, i9);
    16962. 

  16962.       i8 = HEAP32[i5 >> 2] | 0;
    16963. 

  16963.      }
    16964. 

  16964.      i7 = i7 + 1 | 0;
    16965. 

  16965.     } while ((i7 | 0) < (i8 | 0));
    16966. 

  16966.    }
    16967. 

  16967.    i6 = i3 + 56 | 0;
    16968. 

  16968.    i8 = HEAP32[i6 >> 2] | 0;
    16969. 

  16969.    if ((i8 | 0) > 0) {
    16970. 

  16970.     i7 = i3 + 16 | 0;
    16971. 

  16971.     i9 = 0;
    16972. 

  16972.     do {
    16973. 

  16973.      i10 = HEAP32[(HEAP32[i7 >> 2] | 0) + (i9 << 2) >> 2] | 0;
    16974. 

  16974.      if ((i10 | 0) != 0 ? !((HEAP8[i10 + 5 | 0] & 3) == 0) : 0) {
    16975. 

  16975.       _reallymarkobject(i2, i10);
    16976. 

  16976.       i8 = HEAP32[i6 >> 2] | 0;
    16977. 

  16977.      }
    16978. 

  16978.      i9 = i9 + 1 | 0;
    16979. 

  16979.     } while ((i9 | 0) < (i8 | 0));
    16980. 

  16980.    }
    16981. 

  16981.    i7 = i3 + 60 | 0;
    16982. 

  16982.    i11 = HEAP32[i7 >> 2] | 0;
    16983. 

  16983.    if ((i11 | 0) > 0) {
    16984. 

  16984.     i8 = i3 + 24 | 0;
    16985. 

  16985.     i9 = 0;
    16986. 

  16986.     do {
    16987. 

  16987.      i10 = HEAP32[(HEAP32[i8 >> 2] | 0) + (i9 * 12 | 0) >> 2] | 0;
    16988. 

  16988.      if ((i10 | 0) != 0 ? !((HEAP8[i10 + 5 | 0] & 3) == 0) : 0) {
    16989. 

  16989.       _reallymarkobject(i2, i10);
    16990. 

  16990.       i11 = HEAP32[i7 >> 2] | 0;
    16991. 

  16991.      }
    16992. 

  16992.      i9 = i9 + 1 | 0;
    16993. 

  16993.     } while ((i9 | 0) < (i11 | 0));
    16994. 

  16994.     i8 = HEAP32[i6 >> 2] | 0;
    16995. 

  16995.    }
    16996. 

  16996.    i3 = (i11 * 12 | 0) + 80 + (HEAP32[i4 >> 2] << 4) + (HEAP32[i5 >> 2] << 3) + ((HEAP32[i3 + 48 >> 2] | 0) + i8 + (HEAP32[i3 + 52 >> 2] | 0) << 2) | 0;
    16997. 

  16997.    break;
    16998. 

  16998.   }
    16999. 

  16999.  case 38:
    17000. 

  17000.   {
    17001. 

  17001.    HEAP32[i15 >> 2] = HEAP32[i3 + 8 >> 2];
    17002. 

  17002.    i4 = i3 + 6 | 0;
    17003. 

  17003.    i5 = HEAP8[i4] | 0;
    17004. 

  17004.    if (i5 << 24 >> 24 == 0) {
    17005. 

  17005.     i7 = i5 & 255;
    17006. 

  17006.    } else {
    17007. 

  17007.     i6 = 0;
    17008. 

  17008.     do {
    17009. 

  17009.      if ((HEAP32[i3 + (i6 << 4) + 24 >> 2] & 64 | 0) != 0 ? (i14 = HEAP32[i3 + (i6 << 4) + 16 >> 2] | 0, !((HEAP8[i14 + 5 | 0] & 3) == 0)) : 0) {
    17010. 

  17010.       _reallymarkobject(i2, i14);
    17011. 

  17011.       i5 = HEAP8[i4] | 0;
    17012. 

  17012.      }
    17013. 

  17013.      i6 = i6 + 1 | 0;
    17014. 

  17014.      i7 = i5 & 255;
    17015. 

  17015.     } while ((i6 | 0) < (i7 | 0));
    17016. 

  17016.    }
    17017. 

  17017.    i3 = (i7 << 4) + 16 | 0;
    17018. 

  17018.    break;
    17019. 

  17019.   }
    17020. 

  17020.  case 6:
    17021. 

  17021.   {
    17022. 

  17022.    HEAP32[i15 >> 2] = HEAP32[i3 + 8 >> 2];
    17023. 

  17023.    i4 = HEAP32[i3 + 12 >> 2] | 0;
    17024. 

  17024.    if ((i4 | 0) != 0 ? !((HEAP8[i4 + 5 | 0] & 3) == 0) : 0) {
    17025. 

  17025.     _reallymarkobject(i2, i4);
    17026. 

  17026.    }
    17027. 

  17027.    i4 = i3 + 6 | 0;
    17028. 

  17028.    i6 = HEAP8[i4] | 0;
    17029. 

  17029.    if (i6 << 24 >> 24 == 0) {
    17030. 

  17030.     i7 = i6 & 255;
    17031. 

  17031.    } else {
    17032. 

  17032.     i5 = 0;
    17033. 

  17033.     do {
    17034. 

  17034.      i7 = HEAP32[i3 + (i5 << 2) + 16 >> 2] | 0;
    17035. 

  17035.      if ((i7 | 0) != 0 ? !((HEAP8[i7 + 5 | 0] & 3) == 0) : 0) {
    17036. 

  17036.       _reallymarkobject(i2, i7);
    17037. 

  17037.       i6 = HEAP8[i4] | 0;
    17038. 

  17038.      }
    17039. 

  17039.      i5 = i5 + 1 | 0;
    17040. 

  17040.      i7 = i6 & 255;
    17041. 

  17041.     } while ((i5 | 0) < (i7 | 0));
    17042. 

  17042.    }
    17043. 

  17043.    i3 = (i7 << 2) + 16 | 0;
    17044. 

  17044.    break;
    17045. 

  17045.   }
    17046. 

  17046.  default:
    17047. 

  17047.   {
    17048. 

  17048.    STACKTOP = i1;
    17049. 

  17049.    return;
    17050. 

  17050.   }
    17051. 

  17051.  }
    17052. 

  17052.  i15 = i2 + 16 | 0;
    17053. 

  17053.  HEAP32[i15 >> 2] = (HEAP32[i15 >> 2] | 0) + i3;
    17054. 

  17054.  STACKTOP = i1;
    17055. 

  17055.  return;
    17056. 

  17056. }
    17057. 

  17057. function _strstr(i8, i4) {
    17058. 

  17058.  i8 = i8 | 0;
    17059. 

  17059.  i4 = i4 | 0;
    17060. 

  17060.  var i1 = 0, i2 = 0, i3 = 0, i5 = 0, i6 = 0, i7 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0, i14 = 0, i15 = 0, i16 = 0, i17 = 0, i18 = 0, i19 = 0, i20 = 0;
    17061. 

  17061.  i1 = STACKTOP;
    17062. 

  17062.  STACKTOP = STACKTOP + 1056 | 0;
    17063. 

  17063.  i6 = i1 + 1024 | 0;
    17064. 

  17064.  i2 = i1;
    17065. 

  17065.  i10 = HEAP8[i4] | 0;
    17066. 

  17066.  if (i10 << 24 >> 24 == 0) {
    17067. 

  17067.   i20 = i8;
    17068. 

  17068.   STACKTOP = i1;
    17069. 

  17069.   return i20 | 0;
    17070. 

  17070.  }
    17071. 

  17071.  i8 = _strchr(i8, i10 << 24 >> 24) | 0;
    17072. 

  17072.  if ((i8 | 0) == 0) {
    17073. 

  17073.   i20 = 0;
    17074. 

  17074.   STACKTOP = i1;
    17075. 

  17075.   return i20 | 0;
    17076. 

  17076.  }
    17077. 

  17077.  i13 = HEAP8[i4 + 1 | 0] | 0;
    17078. 

  17078.  if (i13 << 24 >> 24 == 0) {
    17079. 

  17079.   i20 = i8;
    17080. 

  17080.   STACKTOP = i1;
    17081. 

  17081.   return i20 | 0;
    17082. 

  17082.  }
    17083. 

  17083.  i11 = i8 + 1 | 0;
    17084. 

  17084.  i9 = HEAP8[i11] | 0;
    17085. 

  17085.  if (i9 << 24 >> 24 == 0) {
    17086. 

  17086.   i20 = 0;
    17087. 

  17087.   STACKTOP = i1;
    17088. 

  17088.   return i20 | 0;
    17089. 

  17089.  }
    17090. 

  17090.  i15 = HEAP8[i4 + 2 | 0] | 0;
    17091. 

  17091.  if (i15 << 24 >> 24 == 0) {
    17092. 

  17092.   i2 = i13 & 255 | (i10 & 255) << 8;
    17093. 

  17093.   i3 = i9;
    17094. 

  17094.   i4 = HEAPU8[i8] << 8 | i9 & 255;
    17095. 

  17095.   while (1) {
    17096. 

  17096.    i5 = i4 & 65535;
    17097. 

  17097.    if ((i5 | 0) == (i2 | 0)) {
    17098. 

  17098.     break;
    17099. 

  17099.    }
    17100. 

  17100.    i11 = i11 + 1 | 0;
    17101. 

  17101.    i4 = HEAP8[i11] | 0;
    17102. 

  17102.    if (i4 << 24 >> 24 == 0) {
    17103. 

  17103.     i3 = 0;
    17104. 

  17104.     break;
    17105. 

  17105.    } else {
    17106. 

  17106.     i3 = i4;
    17107. 

  17107.     i4 = i4 & 255 | i5 << 8;
    17108. 

  17108.    }
    17109. 

  17109.   }
    17110. 

  17110.   i20 = i3 << 24 >> 24 == 0 ? 0 : i11 + -1 | 0;
    17111. 

  17111.   STACKTOP = i1;
    17112. 

  17112.   return i20 | 0;
    17113. 

  17113.  }
    17114. 

  17114.  i16 = i8 + 2 | 0;
    17115. 

  17115.  i11 = HEAP8[i16] | 0;
    17116. 

  17116.  if (i11 << 24 >> 24 == 0) {
    17117. 

  17117.   i20 = 0;
    17118. 

  17118.   STACKTOP = i1;
    17119. 

  17119.   return i20 | 0;
    17120. 

  17120.  }
    17121. 

  17121.  i18 = HEAP8[i4 + 3 | 0] | 0;
    17122. 

  17122.  if (i18 << 24 >> 24 == 0) {
    17123. 

  17123.   i2 = (i13 & 255) << 16 | (i10 & 255) << 24 | (i15 & 255) << 8;
    17124. 

  17124.   i4 = (i11 & 255) << 8 | (i9 & 255) << 16 | HEAPU8[i8] << 24;
    17125. 

  17125.   if ((i4 | 0) == (i2 | 0)) {
    17126. 

  17126.    i3 = 0;
    17127. 

  17127.   } else {
    17128. 

  17128.    do {
    17129. 

  17129.     i16 = i16 + 1 | 0;
    17130. 

  17130.     i3 = HEAP8[i16] | 0;
    17131. 

  17131.     i4 = (i3 & 255 | i4) << 8;
    17132. 

  17132.     i3 = i3 << 24 >> 24 == 0;
    17133. 

  17133.    } while (!(i3 | (i4 | 0) == (i2 | 0)));
    17134. 

  17134.   }
    17135. 

  17135.   i20 = i3 ? 0 : i16 + -2 | 0;
    17136. 

  17136.   STACKTOP = i1;
    17137. 

  17137.   return i20 | 0;
    17138. 

  17138.  }
    17139. 

  17139.  i16 = i8 + 3 | 0;
    17140. 

  17140.  i17 = HEAP8[i16] | 0;
    17141. 

  17141.  if (i17 << 24 >> 24 == 0) {
    17142. 

  17142.   i20 = 0;
    17143. 

  17143.   STACKTOP = i1;
    17144. 

  17144.   return i20 | 0;
    17145. 

  17145.  }
    17146. 

  17146.  if ((HEAP8[i4 + 4 | 0] | 0) == 0) {
    17147. 

  17147.   i2 = (i13 & 255) << 16 | (i10 & 255) << 24 | (i15 & 255) << 8 | i18 & 255;
    17148. 

  17148.   i3 = (i11 & 255) << 8 | (i9 & 255) << 16 | i17 & 255 | HEAPU8[i8] << 24;
    17149. 

  17149.   if ((i3 | 0) == (i2 | 0)) {
    17150. 

  17150.    i4 = 0;
    17151. 

  17151.   } else {
    17152. 

  17152.    do {
    17153. 

  17153.     i16 = i16 + 1 | 0;
    17154. 

  17154.     i4 = HEAP8[i16] | 0;
    17155. 

  17155.     i3 = i4 & 255 | i3 << 8;
    17156. 

  17156.     i4 = i4 << 24 >> 24 == 0;
    17157. 

  17157.    } while (!(i4 | (i3 | 0) == (i2 | 0)));
    17158. 

  17158.   }
    17159. 

  17159.   i20 = i4 ? 0 : i16 + -3 | 0;
    17160. 

  17160.   STACKTOP = i1;
    17161. 

  17161.   return i20 | 0;
    17162. 

  17162.  }
    17163. 

  17163.  HEAP32[i6 + 0 >> 2] = 0;
    17164. 

  17164.  HEAP32[i6 + 4 >> 2] = 0;
    17165. 

  17165.  HEAP32[i6 + 8 >> 2] = 0;
    17166. 

  17166.  HEAP32[i6 + 12 >> 2] = 0;
    17167. 

  17167.  HEAP32[i6 + 16 >> 2] = 0;
    17168. 

  17168.  HEAP32[i6 + 20 >> 2] = 0;
    17169. 

  17169.  HEAP32[i6 + 24 >> 2] = 0;
    17170. 

  17170.  HEAP32[i6 + 28 >> 2] = 0;
    17171. 

  17171.  i9 = 0;
    17172. 

  17172.  while (1) {
    17173. 

  17173.   if ((HEAP8[i8 + i9 | 0] | 0) == 0) {
    17174. 

  17174.    i14 = 0;
    17175. 

  17175.    i12 = 80;
    17176. 

  17176.    break;
    17177. 

  17177.   }
    17178. 

  17178.   i20 = i10 & 255;
    17179. 

  17179.   i3 = i6 + (i20 >>> 5 << 2) | 0;
    17180. 

  17180.   HEAP32[i3 >> 2] = HEAP32[i3 >> 2] | 1 << (i20 & 31);
    17181. 

  17181.   i3 = i9 + 1 | 0;
    17182. 

  17182.   HEAP32[i2 + (i20 << 2) >> 2] = i3;
    17183. 

  17183.   i10 = HEAP8[i4 + i3 | 0] | 0;
    17184. 

  17184.   if (i10 << 24 >> 24 == 0) {
    17185. 

  17185.    break;
    17186. 

  17186.   } else {
    17187. 

  17187.    i9 = i3;
    17188. 

  17188.   }
    17189. 

  17189.  }
    17190. 

  17190.  if ((i12 | 0) == 80) {
    17191. 

  17191.   STACKTOP = i1;
    17192. 

  17192.   return i14 | 0;
    17193. 

  17193.  }
    17194. 

  17194.  L49 : do {
    17195. 

  17195.   if (i3 >>> 0 > 1) {
    17196. 

  17196.    i14 = 1;
    17197. 

  17197.    i11 = -1;
    17198. 

  17198.    i12 = 0;
    17199. 

  17199.    L50 : while (1) {
    17200. 

  17200.     i10 = 1;
    17201. 

  17201.     while (1) {
    17202. 

  17202.      i13 = i14;
    17203. 

  17203.      L54 : while (1) {
    17204. 

  17204.       i14 = 1;
    17205. 

  17205.       while (1) {
    17206. 

  17206.        i15 = HEAP8[i4 + (i14 + i11) | 0] | 0;
    17207. 

  17207.        i16 = HEAP8[i4 + i13 | 0] | 0;
    17208. 

  17208.        if (!(i15 << 24 >> 24 == i16 << 24 >> 24)) {
    17209. 

  17209.         break L54;
    17210. 

  17210.        }
    17211. 

  17211.        i15 = i14 + 1 | 0;
    17212. 

  17212.        if ((i14 | 0) == (i10 | 0)) {
    17213. 

  17213.         break;
    17214. 

  17214.        }
    17215. 

  17215.        i13 = i15 + i12 | 0;
    17216. 

  17216.        if (i13 >>> 0 < i3 >>> 0) {
    17217. 

  17217.         i14 = i15;
    17218. 

  17218.        } else {
    17219. 

  17219.         break L50;
    17220. 

  17220.        }
    17221. 

  17221.       }
    17222. 

  17222.       i12 = i12 + i10 | 0;
    17223. 

  17223.       i13 = i12 + 1 | 0;
    17224. 

  17224.       if (!(i13 >>> 0 < i3 >>> 0)) {
    17225. 

  17225.        break L50;
    17226. 

  17226.       }
    17227. 

  17227.      }
    17228. 

  17228.      i10 = i13 - i11 | 0;
    17229. 

  17229.      if (!((i15 & 255) > (i16 & 255))) {
    17230. 

  17230.       break;
    17231. 

  17231.      }
    17232. 

  17232.      i14 = i13 + 1 | 0;
    17233. 

  17233.      if (i14 >>> 0 < i3 >>> 0) {
    17234. 

  17234.       i12 = i13;
    17235. 

  17235.      } else {
    17236. 

  17236.       break L50;
    17237. 

  17237.      }
    17238. 

  17238.     }
    17239. 

  17239.     i14 = i12 + 2 | 0;
    17240. 

  17240.     if (i14 >>> 0 < i3 >>> 0) {
    17241. 

  17241.      i11 = i12;
    17242. 

  17242.      i12 = i12 + 1 | 0;
    17243. 

  17243.     } else {
    17244. 

  17244.      i11 = i12;
    17245. 

  17245.      i10 = 1;
    17246. 

  17246.      break;
    17247. 

  17247.     }
    17248. 

  17248.    }
    17249. 

  17249.    i16 = 1;
    17250. 

  17250.    i12 = -1;
    17251. 

  17251.    i14 = 0;
    17252. 

  17252.    while (1) {
    17253. 

  17253.     i13 = 1;
    17254. 

  17254.     while (1) {
    17255. 

  17255.      i15 = i16;
    17256. 

  17256.      L69 : while (1) {
    17257. 

  17257.       i18 = 1;
    17258. 

  17258.       while (1) {
    17259. 

  17259.        i17 = HEAP8[i4 + (i18 + i12) | 0] | 0;
    17260. 

  17260.        i16 = HEAP8[i4 + i15 | 0] | 0;
    17261. 

  17261.        if (!(i17 << 24 >> 24 == i16 << 24 >> 24)) {
    17262. 

  17262.         break L69;
    17263. 

  17263.        }
    17264. 

  17264.        i16 = i18 + 1 | 0;
    17265. 

  17265.        if ((i18 | 0) == (i13 | 0)) {
    17266. 

  17266.         break;
    17267. 

  17267.        }
    17268. 

  17268.        i15 = i16 + i14 | 0;
    17269. 

  17269.        if (i15 >>> 0 < i3 >>> 0) {
    17270. 

  17270.         i18 = i16;
    17271. 

  17271.        } else {
    17272. 

  17272.         i14 = i12;
    17273. 

  17273.         break L49;
    17274. 

  17274.        }
    17275. 

  17275.       }
    17276. 

  17276.       i14 = i14 + i13 | 0;
    17277. 

  17277.       i15 = i14 + 1 | 0;
    17278. 

  17278.       if (!(i15 >>> 0 < i3 >>> 0)) {
    17279. 

  17279.        i14 = i12;
    17280. 

  17280.        break L49;
    17281. 

  17281.       }
    17282. 

  17282.      }
    17283. 

  17283.      i13 = i15 - i12 | 0;
    17284. 

  17284.      if (!((i17 & 255) < (i16 & 255))) {
    17285. 

  17285.       break;
    17286. 

  17286.      }
    17287. 

  17287.      i16 = i15 + 1 | 0;
    17288. 

  17288.      if (i16 >>> 0 < i3 >>> 0) {
    17289. 

  17289.       i14 = i15;
    17290. 

  17290.      } else {
    17291. 

  17291.       i14 = i12;
    17292. 

  17292.       break L49;
    17293. 

  17293.      }
    17294. 

  17294.     }
    17295. 

  17295.     i16 = i14 + 2 | 0;
    17296. 

  17296.     if (i16 >>> 0 < i3 >>> 0) {
    17297. 

  17297.      i12 = i14;
    17298. 

  17298.      i14 = i14 + 1 | 0;
    17299. 

  17299.     } else {
    17300. 

  17300.      i13 = 1;
    17301. 

  17301.      break;
    17302. 

  17302.     }
    17303. 

  17303.    }
    17304. 

  17304.   } else {
    17305. 

  17305.    i11 = -1;
    17306. 

  17306.    i14 = -1;
    17307. 

  17307.    i10 = 1;
    17308. 

  17308.    i13 = 1;
    17309. 

  17309.   }
    17310. 

  17310.  } while (0);
    17311. 

  17311.  i15 = (i14 + 1 | 0) >>> 0 > (i11 + 1 | 0) >>> 0;
    17312. 

  17312.  i12 = i15 ? i13 : i10;
    17313. 

  17313.  i11 = i15 ? i14 : i11;
    17314. 

  17314.  i10 = i11 + 1 | 0;
    17315. 

  17315.  if ((_memcmp(i4, i4 + i12 | 0, i10) | 0) == 0) {
    17316. 

  17316.   i15 = i3 - i12 | 0;
    17317. 

  17317.   i16 = i3 | 63;
    17318. 

  17318.   if ((i3 | 0) != (i12 | 0)) {
    17319. 

  17319.    i14 = i8;
    17320. 

  17320.    i13 = 0;
    17321. 

  17321.    i17 = i8;
    17322. 

  17322.    L82 : while (1) {
    17323. 

  17323.     i18 = i14;
    17324. 

  17324.     do {
    17325. 

  17325.      if ((i17 - i18 | 0) >>> 0 < i3 >>> 0) {
    17326. 

  17326.       i19 = _memchr(i17, 0, i16) | 0;
    17327. 

  17327.       if ((i19 | 0) != 0) {
    17328. 

  17328.        if ((i19 - i18 | 0) >>> 0 < i3 >>> 0) {
    17329. 

  17329.         i14 = 0;
    17330. 

  17330.         i12 = 80;
    17331. 

  17331.         break L82;
    17332. 

  17332.        } else {
    17333. 

  17333.         i17 = i19;
    17334. 

  17334.         break;
    17335. 

  17335.        }
    17336. 

  17336.       } else {
    17337. 

  17337.        i17 = i17 + i16 | 0;
    17338. 

  17338.        break;
    17339. 

  17339.       }
    17340. 

  17340.      }
    17341. 

  17341.     } while (0);
    17342. 

  17342.     i18 = HEAPU8[i14 + i9 | 0] | 0;
    17343. 

  17343.     if ((1 << (i18 & 31) & HEAP32[i6 + (i18 >>> 5 << 2) >> 2] | 0) == 0) {
    17344. 

  17344.      i14 = i14 + i3 | 0;
    17345. 

  17345.      i13 = 0;
    17346. 

  17346.      continue;
    17347. 

  17347.     }
    17348. 

  17348.     i20 = HEAP32[i2 + (i18 << 2) >> 2] | 0;
    17349. 

  17349.     i18 = i3 - i20 | 0;
    17350. 

  17350.     if ((i3 | 0) != (i20 | 0)) {
    17351. 

  17351.      i14 = i14 + ((i13 | 0) != 0 & i18 >>> 0 < i12 >>> 0 ? i15 : i18) | 0;
    17352. 

  17352.      i13 = 0;
    17353. 

  17353.      continue;
    17354. 

  17354.     }
    17355. 

  17355.     i20 = i10 >>> 0 > i13 >>> 0 ? i10 : i13;
    17356. 

  17356.     i18 = HEAP8[i4 + i20 | 0] | 0;
    17357. 

  17357.     L96 : do {
    17358. 

  17358.      if (i18 << 24 >> 24 == 0) {
    17359. 

  17359.       i19 = i10;
    17360. 

  17360.      } else {
    17361. 

  17361.       while (1) {
    17362. 

  17362.        i19 = i20 + 1 | 0;
    17363. 

  17363.        if (!(i18 << 24 >> 24 == (HEAP8[i14 + i20 | 0] | 0))) {
    17364. 

  17364.         break;
    17365. 

  17365.        }
    17366. 

  17366.        i18 = HEAP8[i4 + i19 | 0] | 0;
    17367. 

  17367.        if (i18 << 24 >> 24 == 0) {
    17368. 

  17368.         i19 = i10;
    17369. 

  17369.         break L96;
    17370. 

  17370.        } else {
    17371. 

  17371.         i20 = i19;
    17372. 

  17372.        }
    17373. 

  17373.       }
    17374. 

  17374.       i14 = i14 + (i20 - i11) | 0;
    17375. 

  17375.       i13 = 0;
    17376. 

  17376.       continue L82;
    17377. 

  17377.      }
    17378. 

  17378.     } while (0);
    17379. 

  17379.     while (1) {
    17380. 

  17380.      if (!(i19 >>> 0 > i13 >>> 0)) {
    17381. 

  17381.       break;
    17382. 

  17382.      }
    17383. 

  17383.      i18 = i19 + -1 | 0;
    17384. 

  17384.      if ((HEAP8[i4 + i18 | 0] | 0) == (HEAP8[i14 + i18 | 0] | 0)) {
    17385. 

  17385.       i19 = i18;
    17386. 

  17386.      } else {
    17387. 

  17387.       break;
    17388. 

  17388.      }
    17389. 

  17389.     }
    17390. 

  17390.     if ((i19 | 0) == (i13 | 0)) {
    17391. 

  17391.      i12 = 80;
    17392. 

  17392.      break;
    17393. 

  17393.     }
    17394. 

  17394.     i14 = i14 + i12 | 0;
    17395. 

  17395.     i13 = i15;
    17396. 

  17396.    }
    17397. 

  17397.    if ((i12 | 0) == 80) {
    17398. 

  17398.     STACKTOP = i1;
    17399. 

  17399.     return i14 | 0;
    17400. 

  17400.    }
    17401. 

  17401.   } else {
    17402. 

  17402.    i5 = i16;
    17403. 

  17403.    i7 = i3;
    17404. 

  17404.   }
    17405. 

  17405.  } else {
    17406. 

  17406.   i7 = i3 - i11 + -1 | 0;
    17407. 

  17407.   i5 = i3 | 63;
    17408. 

  17408.   i7 = (i11 >>> 0 > i7 >>> 0 ? i11 : i7) + 1 | 0;
    17409. 

  17409.  }
    17410. 

  17410.  i12 = i4 + i10 | 0;
    17411. 

  17411.  i14 = i8;
    17412. 

  17412.  L111 : while (1) {
    17413. 

  17413.   i13 = i14;
    17414. 

  17414.   do {
    17415. 

  17415.    if ((i8 - i13 | 0) >>> 0 < i3 >>> 0) {
    17416. 

  17416.     i15 = _memchr(i8, 0, i5) | 0;
    17417. 

  17417.     if ((i15 | 0) != 0) {
    17418. 

  17418.      if ((i15 - i13 | 0) >>> 0 < i3 >>> 0) {
    17419. 

  17419.       i14 = 0;
    17420. 

  17420.       i12 = 80;
    17421. 

  17421.       break L111;
    17422. 

  17422.      } else {
    17423. 

  17423.       i8 = i15;
    17424. 

  17424.       break;
    17425. 

  17425.      }
    17426. 

  17426.     } else {
    17427. 

  17427.      i8 = i8 + i5 | 0;
    17428. 

  17428.      break;
    17429. 

  17429.     }
    17430. 

  17430.    }
    17431. 

  17431.   } while (0);
    17432. 

  17432.   i13 = HEAPU8[i14 + i9 | 0] | 0;
    17433. 

  17433.   if ((1 << (i13 & 31) & HEAP32[i6 + (i13 >>> 5 << 2) >> 2] | 0) == 0) {
    17434. 

  17434.    i14 = i14 + i3 | 0;
    17435. 

  17435.    continue;
    17436. 

  17436.   }
    17437. 

  17437.   i13 = HEAP32[i2 + (i13 << 2) >> 2] | 0;
    17438. 

  17438.   if ((i3 | 0) != (i13 | 0)) {
    17439. 

  17439.    i14 = i14 + (i3 - i13) | 0;
    17440. 

  17440.    continue;
    17441. 

  17441.   }
    17442. 

  17442.   i15 = HEAP8[i12] | 0;
    17443. 

  17443.   L125 : do {
    17444. 

  17444.    if (i15 << 24 >> 24 == 0) {
    17445. 

  17445.     i13 = i10;
    17446. 

  17446.    } else {
    17447. 

  17447.     i16 = i10;
    17448. 

  17448.     while (1) {
    17449. 

  17449.      i13 = i16 + 1 | 0;
    17450. 

  17450.      if (!(i15 << 24 >> 24 == (HEAP8[i14 + i16 | 0] | 0))) {
    17451. 

  17451.       break;
    17452. 

  17452.      }
    17453. 

  17453.      i15 = HEAP8[i4 + i13 | 0] | 0;
    17454. 

  17454.      if (i15 << 24 >> 24 == 0) {
    17455. 

  17455.       i13 = i10;
    17456. 

  17456.       break L125;
    17457. 

  17457.      } else {
    17458. 

  17458.       i16 = i13;
    17459. 

  17459.      }
    17460. 

  17460.     }
    17461. 

  17461.     i14 = i14 + (i16 - i11) | 0;
    17462. 

  17462.     continue L111;
    17463. 

  17463.    }
    17464. 

  17464.   } while (0);
    17465. 

  17465.   do {
    17466. 

  17466.    if ((i13 | 0) == 0) {
    17467. 

  17467.     i12 = 80;
    17468. 

  17468.     break L111;
    17469. 

  17469.    }
    17470. 

  17470.    i13 = i13 + -1 | 0;
    17471. 

  17471.   } while ((HEAP8[i4 + i13 | 0] | 0) == (HEAP8[i14 + i13 | 0] | 0));
    17472. 

  17472.   i14 = i14 + i7 | 0;
    17473. 

  17473.  }
    17474. 

  17474.  if ((i12 | 0) == 80) {
    17475. 

  17475.   STACKTOP = i1;
    17476. 

  17476.   return i14 | 0;
    17477. 

  17477.  }
    17478. 

  17478.  return 0;
    17479. 

  17479. }
    17480. 

  17480. function _str_format(i2) {
    17481. 

  17481.  i2 = i2 | 0;
    17482. 

  17482.  var i1 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0, i14 = 0, i15 = 0, i16 = 0, i17 = 0, i18 = 0, i19 = 0, i20 = 0, d21 = 0.0, i22 = 0;
    17483. 

  17483.  i12 = STACKTOP;
    17484. 

  17484.  STACKTOP = STACKTOP + 1104 | 0;
    17485. 

  17485.  i4 = i12;
    17486. 

  17486.  i7 = i12 + 1060 | 0;
    17487. 

  17487.  i9 = i12 + 1082 | 0;
    17488. 

  17488.  i20 = i12 + 1056 | 0;
    17489. 

  17489.  i10 = i12 + 16 | 0;
    17490. 

  17490.  i5 = i12 + 1064 | 0;
    17491. 

  17491.  i6 = i12 + 8 | 0;
    17492. 

  17492.  i8 = _lua_gettop(i2) | 0;
    17493. 

  17493.  i16 = _luaL_checklstring(i2, 1, i20) | 0;
    17494. 

  17494.  i20 = HEAP32[i20 >> 2] | 0;
    17495. 

  17495.  i3 = i16 + i20 | 0;
    17496. 

  17496.  _luaL_buffinit(i2, i10);
    17497. 

  17497.  L1 : do {
    17498. 

  17498.   if ((i20 | 0) > 0) {
    17499. 

  17499.    i1 = i10 + 8 | 0;
    17500. 

  17500.    i13 = i10 + 4 | 0;
    17501. 

  17501.    i14 = i5 + 1 | 0;
    17502. 

  17502.    i19 = 1;
    17503. 

  17503.    L3 : while (1) {
    17504. 

  17504.     while (1) {
    17505. 

  17505.      i15 = HEAP8[i16] | 0;
    17506. 

  17506.      if (i15 << 24 >> 24 == 37) {
    17507. 

  17507.       i18 = i16 + 1 | 0;
    17508. 

  17508.       if ((HEAP8[i18] | 0) != 37) {
    17509. 

  17509.        break;
    17510. 

  17510.       }
    17511. 

  17511.       i15 = HEAP32[i1 >> 2] | 0;
    17512. 

  17512.       if (i15 >>> 0 < (HEAP32[i13 >> 2] | 0) >>> 0) {
    17513. 

  17513.        i17 = 37;
    17514. 

  17514.       } else {
    17515. 

  17515.        _luaL_prepbuffsize(i10, 1) | 0;
    17516. 

  17516.        i15 = HEAP32[i1 >> 2] | 0;
    17517. 

  17517.        i17 = HEAP8[i18] | 0;
    17518. 

  17518.       }
    17519. 

  17519.       HEAP32[i1 >> 2] = i15 + 1;
    17520. 

  17520.       HEAP8[(HEAP32[i10 >> 2] | 0) + i15 | 0] = i17;
    17521. 

  17521.       i16 = i16 + 2 | 0;
    17522. 

  17522.      } else {
    17523. 

  17523.       i17 = HEAP32[i1 >> 2] | 0;
    17524. 

  17524.       if (!(i17 >>> 0 < (HEAP32[i13 >> 2] | 0) >>> 0)) {
    17525. 

  17525.        _luaL_prepbuffsize(i10, 1) | 0;
    17526. 

  17526.        i17 = HEAP32[i1 >> 2] | 0;
    17527. 

  17527.        i15 = HEAP8[i16] | 0;
    17528. 

  17528.       }
    17529. 

  17529.       HEAP32[i1 >> 2] = i17 + 1;
    17530. 

  17530.       HEAP8[(HEAP32[i10 >> 2] | 0) + i17 | 0] = i15;
    17531. 

  17531.       i16 = i16 + 1 | 0;
    17532. 

  17532.      }
    17533. 

  17533.      if (!(i16 >>> 0 < i3 >>> 0)) {
    17534. 

  17534.       break L1;
    17535. 

  17535.      }
    17536. 

  17536.     }
    17537. 

  17537.     i17 = _luaL_prepbuffsize(i10, 512) | 0;
    17538. 

  17538.     i15 = i19 + 1 | 0;
    17539. 

  17539.     if ((i19 | 0) >= (i8 | 0)) {
    17540. 

  17540.      _luaL_argerror(i2, i15, 7648) | 0;
    17541. 

  17541.     }
    17542. 

  17542.     i19 = HEAP8[i18] | 0;
    17543. 

  17543.     L22 : do {
    17544. 

  17544.      if (i19 << 24 >> 24 == 0) {
    17545. 

  17545.       i19 = 0;
    17546. 

  17546.       i20 = i18;
    17547. 

  17547.      } else {
    17548. 

  17548.       i20 = i18;
    17549. 

  17549.       while (1) {
    17550. 

  17550.        i16 = i20 + 1 | 0;
    17551. 

  17551.        if ((_memchr(7800, i19 << 24 >> 24, 6) | 0) == 0) {
    17552. 

  17552.         break L22;
    17553. 

  17553.        }
    17554. 

  17554.        i19 = HEAP8[i16] | 0;
    17555. 

  17555.        if (i19 << 24 >> 24 == 0) {
    17556. 

  17556.         i19 = 0;
    17557. 

  17557.         i20 = i16;
    17558. 

  17558.         break;
    17559. 

  17559.        } else {
    17560. 

  17560.         i20 = i16;
    17561. 

  17561.        }
    17562. 

  17562.       }
    17563. 

  17563.      }
    17564. 

  17564.     } while (0);
    17565. 

  17565.     i16 = i18;
    17566. 

  17566.     if ((i20 - i16 | 0) >>> 0 > 5) {
    17567. 

  17567.      _luaL_error(i2, 7808, i4) | 0;
    17568. 

  17568.      i19 = HEAP8[i20] | 0;
    17569. 

  17569.     }
    17570. 

  17570.     i19 = ((i19 & 255) + -48 | 0) >>> 0 < 10 ? i20 + 1 | 0 : i20;
    17571. 

  17571.     i19 = ((HEAPU8[i19] | 0) + -48 | 0) >>> 0 < 10 ? i19 + 1 | 0 : i19;
    17572. 

  17572.     i20 = HEAP8[i19] | 0;
    17573. 

  17573.     if (i20 << 24 >> 24 == 46) {
    17574. 

  17574.      i20 = i19 + 1 | 0;
    17575. 

  17575.      i19 = ((HEAPU8[i20] | 0) + -48 | 0) >>> 0 < 10 ? i19 + 2 | 0 : i20;
    17576. 

  17576.      i19 = ((HEAPU8[i19] | 0) + -48 | 0) >>> 0 < 10 ? i19 + 1 | 0 : i19;
    17577. 

  17577.      i20 = HEAP8[i19] | 0;
    17578. 

  17578.     }
    17579. 

  17579.     if (((i20 & 255) + -48 | 0) >>> 0 < 10) {
    17580. 

  17580.      _luaL_error(i2, 7840, i4) | 0;
    17581. 

  17581.     }
    17582. 

  17582.     HEAP8[i5] = 37;
    17583. 

  17583.     i16 = i19 - i16 | 0;
    17584. 

  17584.     _memcpy(i14 | 0, i18 | 0, i16 + 1 | 0) | 0;
    17585. 

  17585.     HEAP8[i5 + (i16 + 2) | 0] = 0;
    17586. 

  17586.     i16 = i19 + 1 | 0;
    17587. 

  17587.     i18 = HEAP8[i19] | 0;
    17588. 

  17588.     L36 : do {
    17589. 

  17589.      switch (i18 | 0) {
    17590. 

  17590.      case 115:
    17591. 

  17591.       {
    17592. 

  17592.        i18 = _luaL_tolstring(i2, i15, i6) | 0;
    17593. 

  17593.        if ((_strchr(i5, 46) | 0) == 0 ? (HEAP32[i6 >> 2] | 0) >>> 0 > 99 : 0) {
    17594. 

  17594.         _luaL_addvalue(i10);
    17595. 

  17595.         i17 = 0;
    17596. 

  17596.         break L36;
    17597. 

  17597.        }
    17598. 

  17598.        HEAP32[i4 >> 2] = i18;
    17599. 

  17599.        i17 = _sprintf(i17 | 0, i5 | 0, i4 | 0) | 0;
    17600. 

  17600.        _lua_settop(i2, -2);
    17601. 

  17601.        break;
    17602. 

  17602.       }
    17603. 

  17603.      case 88:
    17604. 

  17604.      case 120:
    17605. 

  17605.      case 117:
    17606. 

  17606.      case 111:
    17607. 

  17607.       {
    17608. 

  17608.        d21 = +_luaL_checknumber(i2, i15);
    17609. 

  17609.        i18 = ~~d21 >>> 0;
    17610. 

  17610.        d21 = d21 - +(i18 >>> 0);
    17611. 

  17611.        if (!(d21 > -1.0 & d21 < 1.0)) {
    17612. 

  17612.         _luaL_argerror(i2, i15, 7696) | 0;
    17613. 

  17613.        }
    17614. 

  17614.        i20 = _strlen(i5 | 0) | 0;
    17615. 

  17615.        i22 = i5 + (i20 + -1) | 0;
    17616. 

  17616.        i19 = HEAP8[i22] | 0;
    17617. 

  17617.        HEAP8[i22] = 108;
    17618. 

  17618.        HEAP8[i22 + 1 | 0] = 0;
    17619. 

  17619.        HEAP8[i5 + i20 | 0] = i19;
    17620. 

  17620.        HEAP8[i5 + (i20 + 1) | 0] = 0;
    17621. 

  17621.        HEAP32[i4 >> 2] = i18;
    17622. 

  17622.        i17 = _sprintf(i17 | 0, i5 | 0, i4 | 0) | 0;
    17623. 

  17623.        break;
    17624. 

  17624.       }
    17625. 

  17625.      case 99:
    17626. 

  17626.       {
    17627. 

  17627.        HEAP32[i4 >> 2] = _luaL_checkinteger(i2, i15) | 0;
    17628. 

  17628.        i17 = _sprintf(i17 | 0, i5 | 0, i4 | 0) | 0;
    17629. 

  17629.        break;
    17630. 

  17630.       }
    17631. 

  17631.      case 113:
    17632. 

  17632.       {
    17633. 

  17633.        i17 = _luaL_checklstring(i2, i15, i7) | 0;
    17634. 

  17634.        i18 = HEAP32[i1 >> 2] | 0;
    17635. 

  17635.        if (!(i18 >>> 0 < (HEAP32[i13 >> 2] | 0) >>> 0)) {
    17636. 

  17636.         _luaL_prepbuffsize(i10, 1) | 0;
    17637. 

  17637.         i18 = HEAP32[i1 >> 2] | 0;
    17638. 

  17638.        }
    17639. 

  17639.        HEAP32[i1 >> 2] = i18 + 1;
    17640. 

  17640.        HEAP8[(HEAP32[i10 >> 2] | 0) + i18 | 0] = 34;
    17641. 

  17641.        i22 = HEAP32[i7 >> 2] | 0;
    17642. 

  17642.        HEAP32[i7 >> 2] = i22 + -1;
    17643. 

  17643.        if ((i22 | 0) != 0) {
    17644. 

  17644.         while (1) {
    17645. 

  17645.          i18 = HEAP8[i17] | 0;
    17646. 

  17646.          do {
    17647. 

  17647.           if (i18 << 24 >> 24 == 10 | i18 << 24 >> 24 == 92 | i18 << 24 >> 24 == 34) {
    17648. 

  17648.            i18 = HEAP32[i1 >> 2] | 0;
    17649. 

  17649.            if (!(i18 >>> 0 < (HEAP32[i13 >> 2] | 0) >>> 0)) {
    17650. 

  17650.             _luaL_prepbuffsize(i10, 1) | 0;
    17651. 

  17651.             i18 = HEAP32[i1 >> 2] | 0;
    17652. 

  17652.            }
    17653. 

  17653.            HEAP32[i1 >> 2] = i18 + 1;
    17654. 

  17654.            HEAP8[(HEAP32[i10 >> 2] | 0) + i18 | 0] = 92;
    17655. 

  17655.            i18 = HEAP32[i1 >> 2] | 0;
    17656. 

  17656.            if (!(i18 >>> 0 < (HEAP32[i13 >> 2] | 0) >>> 0)) {
    17657. 

  17657.             _luaL_prepbuffsize(i10, 1) | 0;
    17658. 

  17658.             i18 = HEAP32[i1 >> 2] | 0;
    17659. 

  17659.            }
    17660. 

  17660.            i22 = HEAP8[i17] | 0;
    17661. 

  17661.            HEAP32[i1 >> 2] = i18 + 1;
    17662. 

  17662.            HEAP8[(HEAP32[i10 >> 2] | 0) + i18 | 0] = i22;
    17663. 

  17663.           } else if (i18 << 24 >> 24 == 0) {
    17664. 

  17664.            i18 = 0;
    17665. 

  17665.            i11 = 44;
    17666. 

  17666.           } else {
    17667. 

  17667.            if ((_iscntrl(i18 & 255 | 0) | 0) != 0) {
    17668. 

  17668.             i18 = HEAP8[i17] | 0;
    17669. 

  17669.             i11 = 44;
    17670. 

  17670.             break;
    17671. 

  17671.            }
    17672. 

  17672.            i18 = HEAP32[i1 >> 2] | 0;
    17673. 

  17673.            if (!(i18 >>> 0 < (HEAP32[i13 >> 2] | 0) >>> 0)) {
    17674. 

  17674.             _luaL_prepbuffsize(i10, 1) | 0;
    17675. 

  17675.             i18 = HEAP32[i1 >> 2] | 0;
    17676. 

  17676.            }
    17677. 

  17677.            i22 = HEAP8[i17] | 0;
    17678. 

  17678.            HEAP32[i1 >> 2] = i18 + 1;
    17679. 

  17679.            HEAP8[(HEAP32[i10 >> 2] | 0) + i18 | 0] = i22;
    17680. 

  17680.           }
    17681. 

  17681.          } while (0);
    17682. 

  17682.          if ((i11 | 0) == 44) {
    17683. 

  17683.           i11 = 0;
    17684. 

  17684.           i18 = i18 & 255;
    17685. 

  17685.           if (((HEAPU8[i17 + 1 | 0] | 0) + -48 | 0) >>> 0 < 10) {
    17686. 

  17686.            HEAP32[i4 >> 2] = i18;
    17687. 

  17687.            _sprintf(i9 | 0, 7792, i4 | 0) | 0;
    17688. 

  17688.           } else {
    17689. 

  17689.            HEAP32[i4 >> 2] = i18;
    17690. 

  17690.            _sprintf(i9 | 0, 7784, i4 | 0) | 0;
    17691. 

  17691.           }
    17692. 

  17692.           _luaL_addstring(i10, i9);
    17693. 

  17693.          }
    17694. 

  17694.          i22 = HEAP32[i7 >> 2] | 0;
    17695. 

  17695.          HEAP32[i7 >> 2] = i22 + -1;
    17696. 

  17696.          if ((i22 | 0) == 0) {
    17697. 

  17697.           break;
    17698. 

  17698.          } else {
    17699. 

  17699.           i17 = i17 + 1 | 0;
    17700. 

  17700.          }
    17701. 

  17701.         }
    17702. 

  17702.        }
    17703. 

  17703.        i17 = HEAP32[i1 >> 2] | 0;
    17704. 

  17704.        if (!(i17 >>> 0 < (HEAP32[i13 >> 2] | 0) >>> 0)) {
    17705. 

  17705.         _luaL_prepbuffsize(i10, 1) | 0;
    17706. 

  17706.         i17 = HEAP32[i1 >> 2] | 0;
    17707. 

  17707.        }
    17708. 

  17708.        HEAP32[i1 >> 2] = i17 + 1;
    17709. 

  17709.        HEAP8[(HEAP32[i10 >> 2] | 0) + i17 | 0] = 34;
    17710. 

  17710.        i17 = 0;
    17711. 

  17711.        break;
    17712. 

  17712.       }
    17713. 

  17713.      case 71:
    17714. 

  17714.      case 103:
    17715. 

  17715.      case 102:
    17716. 

  17716.      case 69:
    17717. 

  17717.      case 101:
    17718. 

  17718.       {
    17719. 

  17719.        HEAP8[i5 + (_strlen(i5 | 0) | 0) | 0] = 0;
    17720. 

  17720.        d21 = +_luaL_checknumber(i2, i15);
    17721. 

  17721.        HEAPF64[tempDoublePtr >> 3] = d21;
    17722. 

  17722.        HEAP32[i4 >> 2] = HEAP32[tempDoublePtr >> 2];
    17723. 

  17723.        HEAP32[i4 + 4 >> 2] = HEAP32[tempDoublePtr + 4 >> 2];
    17724. 

  17724.        i17 = _sprintf(i17 | 0, i5 | 0, i4 | 0) | 0;
    17725. 

  17725.        break;
    17726. 

  17726.       }
    17727. 

  17727.      case 105:
    17728. 

  17728.      case 100:
    17729. 

  17729.       {
    17730. 

  17730.        d21 = +_luaL_checknumber(i2, i15);
    17731. 

  17731.        i18 = ~~d21;
    17732. 

  17732.        d21 = d21 - +(i18 | 0);
    17733. 

  17733.        if (!(d21 > -1.0 & d21 < 1.0)) {
    17734. 

  17734.         _luaL_argerror(i2, i15, 7664) | 0;
    17735. 

  17735.        }
    17736. 

  17736.        i22 = _strlen(i5 | 0) | 0;
    17737. 

  17737.        i19 = i5 + (i22 + -1) | 0;
    17738. 

  17738.        i20 = HEAP8[i19] | 0;
    17739. 

  17739.        HEAP8[i19] = 108;
    17740. 

  17740.        HEAP8[i19 + 1 | 0] = 0;
    17741. 

  17741.        HEAP8[i5 + i22 | 0] = i20;
    17742. 

  17742.        HEAP8[i5 + (i22 + 1) | 0] = 0;
    17743. 

  17743.        HEAP32[i4 >> 2] = i18;
    17744. 

  17744.        i17 = _sprintf(i17 | 0, i5 | 0, i4 | 0) | 0;
    17745. 

  17745.        break;
    17746. 

  17746.       }
    17747. 

  17747.      default:
    17748. 

  17748.       {
    17749. 

  17749.        break L3;
    17750. 

  17750.       }
    17751. 

  17751.      }
    17752. 

  17752.     } while (0);
    17753. 

  17753.     HEAP32[i1 >> 2] = (HEAP32[i1 >> 2] | 0) + i17;
    17754. 

  17754.     if (i16 >>> 0 < i3 >>> 0) {
    17755. 

  17755.      i19 = i15;
    17756. 

  17756.     } else {
    17757. 

  17757.      break L1;
    17758. 

  17758.     }
    17759. 

  17759.    }
    17760. 

  17760.    HEAP32[i4 >> 2] = i18;
    17761. 

  17761.    i22 = _luaL_error(i2, 7744, i4) | 0;
    17762. 

  17762.    STACKTOP = i12;
    17763. 

  17763.    return i22 | 0;
    17764. 

  17764.   }
    17765. 

  17765.  } while (0);
    17766. 

  17766.  _luaL_pushresult(i10);
    17767. 

  17767.  i22 = 1;
    17768. 

  17768.  STACKTOP = i12;
    17769. 

  17769.  return i22 | 0;
    17770. 

  17770. }
    17771. 

  17771. function _luaD_precall(i3, i17, i4) {
    17772. 

  17772.  i3 = i3 | 0;
    17773. 

  17773.  i17 = i17 | 0;
    17774. 

  17774.  i4 = i4 | 0;
    17775. 

  17775.  var i1 = 0, i2 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0, i14 = 0, i15 = 0, i16 = 0, i18 = 0, i19 = 0, i20 = 0, i21 = 0, i22 = 0;
    17776. 

  17776.  i1 = STACKTOP;
    17777. 

  17777.  STACKTOP = STACKTOP + 16 | 0;
    17778. 

  17778.  i8 = i1;
    17779. 

  17779.  i6 = i3 + 28 | 0;
    17780. 

  17780.  i2 = i3 + 8 | 0;
    17781. 

  17781.  i13 = i3 + 24 | 0;
    17782. 

  17782.  i14 = i3 + 32 | 0;
    17783. 

  17783.  while (1) {
    17784. 

  17784.   i15 = HEAP32[i6 >> 2] | 0;
    17785. 

  17785.   i16 = i17;
    17786. 

  17786.   i12 = i15;
    17787. 

  17787.   i5 = i16 - i12 | 0;
    17788. 

  17788.   i11 = HEAP32[i17 + 8 >> 2] & 63;
    17789. 

  17789.   if ((i11 | 0) == 38) {
    17790. 

  17790.    i11 = 4;
    17791. 

  17791.    break;
    17792. 

  17792.   } else if ((i11 | 0) == 22) {
    17793. 

  17793.    i11 = 3;
    17794. 

  17794.    break;
    17795. 

  17795.   } else if ((i11 | 0) == 6) {
    17796. 

  17796.    i11 = 31;
    17797. 

  17797.    break;
    17798. 

  17798.   }
    17799. 

  17799.   i11 = _luaT_gettmbyobj(i3, i17, 16) | 0;
    17800. 

  17800.   i15 = i16 - (HEAP32[i6 >> 2] | 0) | 0;
    17801. 

  17801.   i16 = i11 + 8 | 0;
    17802. 

  17802.   if ((HEAP32[i16 >> 2] & 15 | 0) != 6) {
    17803. 

  17803.    i11 = 54;
    17804. 

  17804.    break;
    17805. 

  17805.   }
    17806. 

  17806.   i19 = HEAP32[i2 >> 2] | 0;
    17807. 

  17807.   if (i19 >>> 0 > i17 >>> 0) {
    17808. 

  17808.    while (1) {
    17809. 

  17809.     i18 = i19 + -16 | 0;
    17810. 

  17810.     i22 = i18;
    17811. 

  17811.     i21 = HEAP32[i22 + 4 >> 2] | 0;
    17812. 

  17812.     i20 = i19;
    17813. 

  17813.     HEAP32[i20 >> 2] = HEAP32[i22 >> 2];
    17814. 

  17814.     HEAP32[i20 + 4 >> 2] = i21;
    17815. 

  17815.     HEAP32[i19 + 8 >> 2] = HEAP32[i19 + -8 >> 2];
    17816. 

  17816.     if (i18 >>> 0 > i17 >>> 0) {
    17817. 

  17817.      i19 = i18;
    17818. 

  17818.     } else {
    17819. 

  17819.      break;
    17820. 

  17820.     }
    17821. 

  17821.    }
    17822. 

  17822.    i19 = HEAP32[i2 >> 2] | 0;
    17823. 

  17823.   }
    17824. 

  17824.   i17 = i19 + 16 | 0;
    17825. 

  17825.   HEAP32[i2 >> 2] = i17;
    17826. 

  17826.   if (((HEAP32[i13 >> 2] | 0) - i17 | 0) < 16) {
    17827. 

  17827.    i18 = HEAP32[i14 >> 2] | 0;
    17828. 

  17828.    if ((i18 | 0) > 1e6) {
    17829. 

  17829.     i11 = 60;
    17830. 

  17830.     break;
    17831. 

  17831.    }
    17832. 

  17832.    i17 = (i17 - (HEAP32[i6 >> 2] | 0) >> 4) + 5 | 0;
    17833. 

  17833.    i18 = i18 << 1;
    17834. 

  17834.    i18 = (i18 | 0) > 1e6 ? 1e6 : i18;
    17835. 

  17835.    i17 = (i18 | 0) < (i17 | 0) ? i17 : i18;
    17836. 

  17836.    if ((i17 | 0) > 1e6) {
    17837. 

  17837.     i11 = 62;
    17838. 

  17838.     break;
    17839. 

  17839.    }
    17840. 

  17840.    _luaD_reallocstack(i3, i17);
    17841. 

  17841.   }
    17842. 

  17842.   i22 = HEAP32[i6 >> 2] | 0;
    17843. 

  17843.   i17 = i22 + i15 | 0;
    17844. 

  17844.   i19 = i11;
    17845. 

  17845.   i20 = HEAP32[i19 + 4 >> 2] | 0;
    17846. 

  17846.   i21 = i17;
    17847. 

  17847.   HEAP32[i21 >> 2] = HEAP32[i19 >> 2];
    17848. 

  17848.   HEAP32[i21 + 4 >> 2] = i20;
    17849. 

  17849.   HEAP32[i22 + (i15 + 8) >> 2] = HEAP32[i16 >> 2];
    17850. 

  17850.  }
    17851. 

  17851.  if ((i11 | 0) == 3) {
    17852. 

  17852.   i10 = i17;
    17853. 

  17853.  } else if ((i11 | 0) == 4) {
    17854. 

  17854.   i10 = (HEAP32[i17 >> 2] | 0) + 12 | 0;
    17855. 

  17855.  } else if ((i11 | 0) == 31) {
    17856. 

  17856.   i10 = HEAP32[(HEAP32[i17 >> 2] | 0) + 12 >> 2] | 0;
    17857. 

  17857.   i18 = HEAP32[i2 >> 2] | 0;
    17858. 

  17858.   i16 = i18;
    17859. 

  17859.   i11 = i10 + 78 | 0;
    17860. 

  17860.   i17 = HEAPU8[i11] | 0;
    17861. 

  17861.   do {
    17862. 

  17862.    if (((HEAP32[i13 >> 2] | 0) - i16 >> 4 | 0) <= (i17 | 0)) {
    17863. 

  17863.     i13 = HEAP32[i14 >> 2] | 0;
    17864. 

  17864.     if ((i13 | 0) > 1e6) {
    17865. 

  17865.      _luaD_throw(i3, 6);
    17866. 

  17866.     }
    17867. 

  17867.     i12 = i17 + 5 + (i16 - i12 >> 4) | 0;
    17868. 

  17868.     i13 = i13 << 1;
    17869. 

  17869.     i13 = (i13 | 0) > 1e6 ? 1e6 : i13;
    17870. 

  17870.     i12 = (i13 | 0) < (i12 | 0) ? i12 : i13;
    17871. 

  17871.     if ((i12 | 0) > 1e6) {
    17872. 

  17872.      _luaD_reallocstack(i3, 1000200);
    17873. 

  17873.      _luaG_runerror(i3, 2224, i8);
    17874. 

  17874.     } else {
    17875. 

  17875.      _luaD_reallocstack(i3, i12);
    17876. 

  17876.      i7 = HEAP32[i6 >> 2] | 0;
    17877. 

  17877.      i9 = HEAP32[i2 >> 2] | 0;
    17878. 

  17878.      break;
    17879. 

  17879.     }
    17880. 

  17880.    } else {
    17881. 

  17881.     i7 = i15;
    17882. 

  17882.     i9 = i18;
    17883. 

  17883.    }
    17884. 

  17884.   } while (0);
    17885. 

  17885.   i6 = i7 + i5 | 0;
    17886. 

  17886.   i22 = i9 - i6 >> 4;
    17887. 

  17887.   i12 = i22 + -1 | 0;
    17888. 

  17888.   i8 = i10 + 76 | 0;
    17889. 

  17889.   i13 = HEAP8[i8] | 0;
    17890. 

  17890.   if ((i22 | 0) > (i13 & 255 | 0)) {
    17891. 

  17891.    i8 = i13;
    17892. 

  17892.   } else {
    17893. 

  17893.    i13 = i9;
    17894. 

  17894.    while (1) {
    17895. 

  17895.     i9 = i13 + 16 | 0;
    17896. 

  17896.     HEAP32[i2 >> 2] = i9;
    17897. 

  17897.     HEAP32[i13 + 8 >> 2] = 0;
    17898. 

  17898.     i12 = i12 + 1 | 0;
    17899. 

  17899.     i13 = HEAP8[i8] | 0;
    17900. 

  17900.     if ((i12 | 0) < (i13 & 255 | 0)) {
    17901. 

  17901.      i13 = i9;
    17902. 

  17902.     } else {
    17903. 

  17903.      i8 = i13;
    17904. 

  17904.      break;
    17905. 

  17905.     }
    17906. 

  17906.    }
    17907. 

  17907.   }
    17908. 

  17908.   if ((HEAP8[i10 + 77 | 0] | 0) != 0) {
    17909. 

  17909.    i5 = i8 & 255;
    17910. 

  17910.    if (!(i8 << 24 >> 24 == 0) ? (i22 = 0 - i12 | 0, HEAP32[i2 >> 2] = i9 + 16, i19 = i9 + (i22 << 4) | 0, i20 = HEAP32[i19 + 4 >> 2] | 0, i21 = i9, HEAP32[i21 >> 2] = HEAP32[i19 >> 2], HEAP32[i21 + 4 >> 2] = i20, i22 = i9 + (i22 << 4) + 8 | 0, HEAP32[i9 + 8 >> 2] = HEAP32[i22 >> 2], HEAP32[i22 >> 2] = 0, (i8 & 255) > 1) : 0) {
    17911. 

  17911.     i7 = 1;
    17912. 

  17912.     do {
    17913. 

  17913.      i21 = HEAP32[i2 >> 2] | 0;
    17914. 

  17914.      i22 = i7 - i12 | 0;
    17915. 

  17915.      HEAP32[i2 >> 2] = i21 + 16;
    17916. 

  17916.      i18 = i9 + (i22 << 4) | 0;
    17917. 

  17917.      i19 = HEAP32[i18 + 4 >> 2] | 0;
    17918. 

  17918.      i20 = i21;
    17919. 

  17919.      HEAP32[i20 >> 2] = HEAP32[i18 >> 2];
    17920. 

  17920.      HEAP32[i20 + 4 >> 2] = i19;
    17921. 

  17921.      i22 = i9 + (i22 << 4) + 8 | 0;
    17922. 

  17922.      HEAP32[i21 + 8 >> 2] = HEAP32[i22 >> 2];
    17923. 

  17923.      HEAP32[i22 >> 2] = 0;
    17924. 

  17924.      i7 = i7 + 1 | 0;
    17925. 

  17925.     } while ((i7 | 0) < (i5 | 0));
    17926. 

  17926.    }
    17927. 

  17927.   } else {
    17928. 

  17928.    i9 = i7 + (i5 + 16) | 0;
    17929. 

  17929.   }
    17930. 

  17930.   i7 = i3 + 16 | 0;
    17931. 

  17931.   i5 = HEAP32[(HEAP32[i7 >> 2] | 0) + 12 >> 2] | 0;
    17932. 

  17932.   if ((i5 | 0) == 0) {
    17933. 

  17933.    i5 = _luaE_extendCI(i3) | 0;
    17934. 

  17934.   }
    17935. 

  17935.   HEAP32[i7 >> 2] = i5;
    17936. 

  17936.   HEAP16[i5 + 16 >> 1] = i4;
    17937. 

  17937.   HEAP32[i5 >> 2] = i6;
    17938. 

  17938.   HEAP32[i5 + 24 >> 2] = i9;
    17939. 

  17939.   i22 = i9 + (HEAPU8[i11] << 4) | 0;
    17940. 

  17940.   HEAP32[i5 + 4 >> 2] = i22;
    17941. 

  17941.   i4 = i5 + 28 | 0;
    17942. 

  17942.   HEAP32[i4 >> 2] = HEAP32[i10 + 12 >> 2];
    17943. 

  17943.   i6 = i5 + 18 | 0;
    17944. 

  17944.   HEAP8[i6] = 1;
    17945. 

  17945.   HEAP32[i2 >> 2] = i22;
    17946. 

  17946.   if ((HEAP32[(HEAP32[i3 + 12 >> 2] | 0) + 12 >> 2] | 0) > 0) {
    17947. 

  17947.    _luaC_step(i3);
    17948. 

  17948.   }
    17949. 

  17949.   if ((HEAP8[i3 + 40 | 0] & 1) == 0) {
    17950. 

  17950.    i22 = 0;
    17951. 

  17951.    STACKTOP = i1;
    17952. 

  17952.    return i22 | 0;
    17953. 

  17953.   }
    17954. 

  17954.   HEAP32[i4 >> 2] = (HEAP32[i4 >> 2] | 0) + 4;
    17955. 

  17955.   i2 = HEAP32[i5 + 8 >> 2] | 0;
    17956. 

  17956.   if (!((HEAP8[i2 + 18 | 0] & 1) == 0) ? (HEAP32[(HEAP32[i2 + 28 >> 2] | 0) + -4 >> 2] & 63 | 0) == 30 : 0) {
    17957. 

  17957.    HEAP8[i6] = HEAPU8[i6] | 64;
    17958. 

  17958.    i2 = 4;
    17959. 

  17959.   } else {
    17960. 

  17960.    i2 = 0;
    17961. 

  17961.   }
    17962. 

  17962.   _luaD_hook(i3, i2, -1);
    17963. 

  17963.   HEAP32[i4 >> 2] = (HEAP32[i4 >> 2] | 0) + -4;
    17964. 

  17964.   i22 = 0;
    17965. 

  17965.   STACKTOP = i1;
    17966. 

  17966.   return i22 | 0;
    17967. 

  17967.  } else if ((i11 | 0) == 54) {
    17968. 

  17968.   _luaG_typeerror(i3, i17, 2520);
    17969. 

  17969.  } else if ((i11 | 0) == 60) {
    17970. 

  17970.   _luaD_throw(i3, 6);
    17971. 

  17971.  } else if ((i11 | 0) == 62) {
    17972. 

  17972.   _luaD_reallocstack(i3, 1000200);
    17973. 

  17973.   _luaG_runerror(i3, 2224, i8);
    17974. 

  17974.  }
    17975. 

  17975.  i7 = HEAP32[i10 >> 2] | 0;
    17976. 

  17976.  i9 = HEAP32[i2 >> 2] | 0;
    17977. 

  17977.  do {
    17978. 

  17978.   if (((HEAP32[i13 >> 2] | 0) - i9 | 0) < 336) {
    17979. 

  17979.    i10 = HEAP32[i14 >> 2] | 0;
    17980. 

  17980.    if ((i10 | 0) > 1e6) {
    17981. 

  17981.     _luaD_throw(i3, 6);
    17982. 

  17982.    }
    17983. 

  17983.    i9 = (i9 - i12 >> 4) + 25 | 0;
    17984. 

  17984.    i10 = i10 << 1;
    17985. 

  17985.    i10 = (i10 | 0) > 1e6 ? 1e6 : i10;
    17986. 

  17986.    i9 = (i10 | 0) < (i9 | 0) ? i9 : i10;
    17987. 

  17987.    if ((i9 | 0) > 1e6) {
    17988. 

  17988.     _luaD_reallocstack(i3, 1000200);
    17989. 

  17989.     _luaG_runerror(i3, 2224, i8);
    17990. 

  17990.    } else {
    17991. 

  17991.     _luaD_reallocstack(i3, i9);
    17992. 

  17992.     break;
    17993. 

  17993.    }
    17994. 

  17994.   }
    17995. 

  17995.  } while (0);
    17996. 

  17996.  i8 = i3 + 16 | 0;
    17997. 

  17997.  i9 = HEAP32[(HEAP32[i8 >> 2] | 0) + 12 >> 2] | 0;
    17998. 

  17998.  if ((i9 | 0) == 0) {
    17999. 

  17999.   i9 = _luaE_extendCI(i3) | 0;
    18000. 

  18000.  }
    18001. 

  18001.  HEAP32[i8 >> 2] = i9;
    18002. 

  18002.  HEAP16[i9 + 16 >> 1] = i4;
    18003. 

  18003.  HEAP32[i9 >> 2] = (HEAP32[i6 >> 2] | 0) + i5;
    18004. 

  18004.  HEAP32[i9 + 4 >> 2] = (HEAP32[i2 >> 2] | 0) + 320;
    18005. 

  18005.  HEAP8[i9 + 18 | 0] = 0;
    18006. 

  18006.  if ((HEAP32[(HEAP32[i3 + 12 >> 2] | 0) + 12 >> 2] | 0) > 0) {
    18007. 

  18007.   _luaC_step(i3);
    18008. 

  18008.  }
    18009. 

  18009.  i5 = i3 + 40 | 0;
    18010. 

  18010.  if (!((HEAP8[i5] & 1) == 0)) {
    18011. 

  18011.   _luaD_hook(i3, 0, -1);
    18012. 

  18012.  }
    18013. 

  18013.  i7 = FUNCTION_TABLE_ii[i7 & 255](i3) | 0;
    18014. 

  18014.  i7 = (HEAP32[i2 >> 2] | 0) + (0 - i7 << 4) | 0;
    18015. 

  18015.  i4 = HEAP32[i8 >> 2] | 0;
    18016. 

  18016.  i5 = HEAPU8[i5] | 0;
    18017. 

  18017.  if ((i5 & 6 | 0) == 0) {
    18018. 

  18018.   i5 = i7;
    18019. 

  18019.   i6 = i4 + 8 | 0;
    18020. 

  18020.  } else {
    18021. 

  18021.   if ((i5 & 2 | 0) == 0) {
    18022. 

  18022.    i5 = i7;
    18023. 

  18023.   } else {
    18024. 

  18024.    i5 = i7 - (HEAP32[i6 >> 2] | 0) | 0;
    18025. 

  18025.    _luaD_hook(i3, 1, -1);
    18026. 

  18026.    i5 = (HEAP32[i6 >> 2] | 0) + i5 | 0;
    18027. 

  18027.   }
    18028. 

  18028.   i6 = i4 + 8 | 0;
    18029. 

  18029.   HEAP32[i3 + 20 >> 2] = HEAP32[(HEAP32[i6 >> 2] | 0) + 28 >> 2];
    18030. 

  18030.  }
    18031. 

  18031.  i3 = HEAP32[i4 >> 2] | 0;
    18032. 

  18032.  i4 = HEAP16[i4 + 16 >> 1] | 0;
    18033. 

  18033.  HEAP32[i8 >> 2] = HEAP32[i6 >> 2];
    18034. 

  18034.  L82 : do {
    18035. 

  18035.   if (!(i4 << 16 >> 16 == 0)) {
    18036. 

  18036.    i4 = i4 << 16 >> 16;
    18037. 

  18037.    while (1) {
    18038. 

  18038.     if (!(i5 >>> 0 < (HEAP32[i2 >> 2] | 0) >>> 0)) {
    18039. 

  18039.      break;
    18040. 

  18040.     }
    18041. 

  18041.     i6 = i3 + 16 | 0;
    18042. 

  18042.     i20 = i5;
    18043. 

  18043.     i21 = HEAP32[i20 + 4 >> 2] | 0;
    18044. 

  18044.     i22 = i3;
    18045. 

  18045.     HEAP32[i22 >> 2] = HEAP32[i20 >> 2];
    18046. 

  18046.     HEAP32[i22 + 4 >> 2] = i21;
    18047. 

  18047.     HEAP32[i3 + 8 >> 2] = HEAP32[i5 + 8 >> 2];
    18048. 

  18048.     i4 = i4 + -1 | 0;
    18049. 

  18049.     if ((i4 | 0) == 0) {
    18050. 

  18050.      i3 = i6;
    18051. 

  18051.      break L82;
    18052. 

  18052.     }
    18053. 

  18053.     i5 = i5 + 16 | 0;
    18054. 

  18054.     i3 = i6;
    18055. 

  18055.    }
    18056. 

  18056.    if ((i4 | 0) > 0) {
    18057. 

  18057.     i5 = i4;
    18058. 

  18058.     i6 = i3;
    18059. 

  18059.     while (1) {
    18060. 

  18060.      i5 = i5 + -1 | 0;
    18061. 

  18061.      HEAP32[i6 + 8 >> 2] = 0;
    18062. 

  18062.      if ((i5 | 0) <= 0) {
    18063. 

  18063.       break;
    18064. 

  18064.      } else {
    18065. 

  18065.       i6 = i6 + 16 | 0;
    18066. 

  18066.      }
    18067. 

  18067.     }
    18068. 

  18068.     i3 = i3 + (i4 << 4) | 0;
    18069. 

  18069.    }
    18070. 

  18070.   }
    18071. 

  18071.  } while (0);
    18072. 

  18072.  HEAP32[i2 >> 2] = i3;
    18073. 

  18073.  i22 = 1;
    18074. 

  18074.  STACKTOP = i1;
    18075. 

  18075.  return i22 | 0;
    18076. 

  18076. }
    18077. 

  18077. function _lua_getinfo(i1, i6, i29) {
    18078. 

  18078.  i1 = i1 | 0;
    18079. 

  18079.  i6 = i6 | 0;
    18080. 

  18080.  i29 = i29 | 0;
    18081. 

  18081.  var i2 = 0, i3 = 0, i4 = 0, i5 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0, i14 = 0, i15 = 0, i16 = 0, i17 = 0, i18 = 0, i19 = 0, i20 = 0, i21 = 0, i22 = 0, i23 = 0, i24 = 0, i25 = 0, i26 = 0, i27 = 0, i28 = 0, i30 = 0, i31 = 0, i32 = 0, i33 = 0, i34 = 0, i35 = 0, i36 = 0;
    18082. 

  18082.  i3 = STACKTOP;
    18083. 

  18083.  STACKTOP = STACKTOP + 16 | 0;
    18084. 

  18084.  i2 = i3;
    18085. 

  18085.  if ((HEAP8[i6] | 0) == 62) {
    18086. 

  18086.   i10 = i1 + 8 | 0;
    18087. 

  18087.   i7 = (HEAP32[i10 >> 2] | 0) + -16 | 0;
    18088. 

  18088.   HEAP32[i10 >> 2] = i7;
    18089. 

  18089.   i6 = i6 + 1 | 0;
    18090. 

  18090.   i10 = 0;
    18091. 

  18091.  } else {
    18092. 

  18092.   i7 = HEAP32[i29 + 96 >> 2] | 0;
    18093. 

  18093.   i10 = i7;
    18094. 

  18094.   i7 = HEAP32[i7 >> 2] | 0;
    18095. 

  18095.  }
    18096. 

  18096.  i8 = i7 + 8 | 0;
    18097. 

  18097.  if ((HEAP32[i8 >> 2] & 31 | 0) == 6) {
    18098. 

  18098.   i9 = HEAP32[i7 >> 2] | 0;
    18099. 

  18099.  } else {
    18100. 

  18100.   i9 = 0;
    18101. 

  18101.  }
    18102. 

  18102.  i34 = HEAP8[i6] | 0;
    18103. 

  18103.  L8 : do {
    18104. 

  18104.   if (i34 << 24 >> 24 == 0) {
    18105. 

  18105.    i33 = 1;
    18106. 

  18106.   } else {
    18107. 

  18107.    i12 = (i9 | 0) == 0;
    18108. 

  18108.    i27 = i29 + 16 | 0;
    18109. 

  18109.    i28 = i29 + 24 | 0;
    18110. 

  18110.    i21 = i29 + 28 | 0;
    18111. 

  18111.    i25 = i29 + 12 | 0;
    18112. 

  18112.    i26 = i29 + 36 | 0;
    18113. 

  18113.    i19 = i9 + 4 | 0;
    18114. 

  18114.    i24 = i9 + 12 | 0;
    18115. 

  18115.    i18 = (i10 | 0) == 0;
    18116. 

  18116.    i23 = i29 + 20 | 0;
    18117. 

  18117.    i17 = i10 + 18 | 0;
    18118. 

  18118.    i22 = i10 + 28 | 0;
    18119. 

  18119.    i15 = i29 + 32 | 0;
    18120. 

  18120.    i14 = i29 + 34 | 0;
    18121. 

  18121.    i13 = i29 + 33 | 0;
    18122. 

  18122.    i11 = i9 + 6 | 0;
    18123. 

  18123.    i16 = i29 + 35 | 0;
    18124. 

  18124.    i20 = i29 + 8 | 0;
    18125. 

  18125.    i30 = i29 + 4 | 0;
    18126. 

  18126.    i29 = i10 + 8 | 0;
    18127. 

  18127.    i31 = i1 + 12 | 0;
    18128. 

  18128.    i32 = i6;
    18129. 

  18129.    i33 = 1;
    18130. 

  18130.    while (1) {
    18131. 

  18131.     L12 : do {
    18132. 

  18132.      switch (i34 << 24 >> 24 | 0) {
    18133. 

  18133.      case 116:
    18134. 

  18134.       {
    18135. 

  18135.        if (i18) {
    18136. 

  18136.         i34 = 0;
    18137. 

  18137.        } else {
    18138. 

  18138.         i34 = HEAPU8[i17] & 64;
    18139. 

  18139.        }
    18140. 

  18140.        HEAP8[i16] = i34;
    18141. 

  18141.        break;
    18142. 

  18142.       }
    18143. 

  18143.      case 110:
    18144. 

  18144.       {
    18145. 

  18145.        L18 : do {
    18146. 

  18146.         if ((!i18 ? (HEAP8[i17] & 64) == 0 : 0) ? (i5 = HEAP32[i29 >> 2] | 0, !((HEAP8[i5 + 18 | 0] & 1) == 0)) : 0) {
    18147. 

  18147.          i36 = HEAP32[(HEAP32[HEAP32[i5 >> 2] >> 2] | 0) + 12 >> 2] | 0;
    18148. 

  18148.          i35 = HEAP32[i36 + 12 >> 2] | 0;
    18149. 

  18149.          i34 = ((HEAP32[i5 + 28 >> 2] | 0) - i35 >> 2) + -1 | 0;
    18150. 

  18150.          i35 = HEAP32[i35 + (i34 << 2) >> 2] | 0;
    18151. 

  18151.          switch (i35 & 63 | 0) {
    18152. 

  18152.          case 10:
    18153. 

  18153.          case 8:
    18154. 

  18154.           {
    18155. 

  18155.            i34 = 1;
    18156. 

  18156.            i4 = 46;
    18157. 

  18157.            break;
    18158. 

  18158.           }
    18159. 

  18159.          case 24:
    18160. 

  18160.           {
    18161. 

  18161.            i34 = 5;
    18162. 

  18162.            i4 = 46;
    18163. 

  18163.            break;
    18164. 

  18164.           }
    18165. 

  18165.          case 13:
    18166. 

  18166.           {
    18167. 

  18167.            i34 = 6;
    18168. 

  18168.            i4 = 46;
    18169. 

  18169.            break;
    18170. 

  18170.           }
    18171. 

  18171.          case 14:
    18172. 

  18172.           {
    18173. 

  18173.            i34 = 7;
    18174. 

  18174.            i4 = 46;
    18175. 

  18175.            break;
    18176. 

  18176.           }
    18177. 

  18177.          case 15:
    18178. 

  18178.           {
    18179. 

  18179.            i34 = 8;
    18180. 

  18180.            i4 = 46;
    18181. 

  18181.            break;
    18182. 

  18182.           }
    18183. 

  18183.          case 16:
    18184. 

  18184.           {
    18185. 

  18185.            i34 = 9;
    18186. 

  18186.            i4 = 46;
    18187. 

  18187.            break;
    18188. 

  18188.           }
    18189. 

  18189.          case 17:
    18190. 

  18190.           {
    18191. 

  18191.            i34 = 10;
    18192. 

  18192.            i4 = 46;
    18193. 

  18193.            break;
    18194. 

  18194.           }
    18195. 

  18195.          case 18:
    18196. 

  18196.           {
    18197. 

  18197.            i34 = 11;
    18198. 

  18198.            i4 = 46;
    18199. 

  18199.            break;
    18200. 

  18200.           }
    18201. 

  18201.          case 19:
    18202. 

  18202.           {
    18203. 

  18203.            i34 = 12;
    18204. 

  18204.            i4 = 46;
    18205. 

  18205.            break;
    18206. 

  18206.           }
    18207. 

  18207.          case 21:
    18208. 

  18208.           {
    18209. 

  18209.            i34 = 4;
    18210. 

  18210.            i4 = 46;
    18211. 

  18211.            break;
    18212. 

  18212.           }
    18213. 

  18213.          case 25:
    18214. 

  18214.           {
    18215. 

  18215.            i34 = 13;
    18216. 

  18216.            i4 = 46;
    18217. 

  18217.            break;
    18218. 

  18218.           }
    18219. 

  18219.          case 26:
    18220. 

  18220.           {
    18221. 

  18221.            i34 = 14;
    18222. 

  18222.            i4 = 46;
    18223. 

  18223.            break;
    18224. 

  18224.           }
    18225. 

  18225.          case 22:
    18226. 

  18226.           {
    18227. 

  18227.            i34 = 15;
    18228. 

  18228.            i4 = 46;
    18229. 

  18229.            break;
    18230. 

  18230.           }
    18231. 

  18231.          case 7:
    18232. 

  18232.          case 6:
    18233. 

  18233.          case 12:
    18234. 

  18234.           {
    18235. 

  18235.            i34 = 0;
    18236. 

  18236.            i4 = 46;
    18237. 

  18237.            break;
    18238. 

  18238.           }
    18239. 

  18239.          case 34:
    18240. 

  18240.           {
    18241. 

  18241.            i34 = 2120;
    18242. 

  18242.            i35 = 2120;
    18243. 

  18243.            break;
    18244. 

  18244.           }
    18245. 

  18245.          case 30:
    18246. 

  18246.          case 29:
    18247. 

  18247.           {
    18248. 

  18248.            i36 = _getobjname(i36, i34, i35 >>> 6 & 255, i30) | 0;
    18249. 

  18249.            HEAP32[i20 >> 2] = i36;
    18250. 

  18250.            if ((i36 | 0) == 0) {
    18251. 

  18251.             break L18;
    18252. 

  18252.            } else {
    18253. 

  18253.             break L12;
    18254. 

  18254.            }
    18255. 

  18255.           }
    18256. 

  18256.          default:
    18257. 

  18257.           {
    18258. 

  18258.            i4 = 47;
    18259. 

  18259.            break L18;
    18260. 

  18260.           }
    18261. 

  18261.          }
    18262. 

  18262.          if ((i4 | 0) == 46) {
    18263. 

  18263.           i4 = 0;
    18264. 

  18264.           i34 = (HEAP32[(HEAP32[i31 >> 2] | 0) + (i34 << 2) + 184 >> 2] | 0) + 16 | 0;
    18265. 

  18265.           i35 = 2136;
    18266. 

  18266.          }
    18267. 

  18267.          HEAP32[i30 >> 2] = i34;
    18268. 

  18268.          HEAP32[i20 >> 2] = i35;
    18269. 

  18269.          break L12;
    18270. 

  18270.         } else {
    18271. 

  18271.          i4 = 47;
    18272. 

  18272.         }
    18273. 

  18273.        } while (0);
    18274. 

  18274.        if ((i4 | 0) == 47) {
    18275. 

  18275.         i4 = 0;
    18276. 

  18276.         HEAP32[i20 >> 2] = 0;
    18277. 

  18277.        }
    18278. 

  18278.        HEAP32[i20 >> 2] = 2112;
    18279. 

  18279.        HEAP32[i30 >> 2] = 0;
    18280. 

  18280.        break;
    18281. 

  18281.       }
    18282. 

  18282.      case 108:
    18283. 

  18283.       {
    18284. 

  18284.        if (!i18 ? !((HEAP8[i17] & 1) == 0) : 0) {
    18285. 

  18285.         i35 = HEAP32[(HEAP32[HEAP32[i10 >> 2] >> 2] | 0) + 12 >> 2] | 0;
    18286. 

  18286.         i34 = HEAP32[i35 + 20 >> 2] | 0;
    18287. 

  18287.         if ((i34 | 0) == 0) {
    18288. 

  18288.          i34 = 0;
    18289. 

  18289.         } else {
    18290. 

  18290.          i34 = HEAP32[i34 + (((HEAP32[i22 >> 2] | 0) - (HEAP32[i35 + 12 >> 2] | 0) >> 2) + -1 << 2) >> 2] | 0;
    18291. 

  18291.         }
    18292. 

  18292.        } else {
    18293. 

  18293.         i34 = -1;
    18294. 

  18294.        }
    18295. 

  18295.        HEAP32[i23 >> 2] = i34;
    18296. 

  18296.        break;
    18297. 

  18297.       }
    18298. 

  18298.      case 83:
    18299. 

  18299.       {
    18300. 

  18300.        if (!i12 ? (HEAP8[i19] | 0) != 38 : 0) {
    18301. 

  18301.         i34 = HEAP32[i24 >> 2] | 0;
    18302. 

  18302.         i35 = HEAP32[i34 + 36 >> 2] | 0;
    18303. 

  18303.         if ((i35 | 0) == 0) {
    18304. 

  18304.          i35 = 2168;
    18305. 

  18305.         } else {
    18306. 

  18306.          i35 = i35 + 16 | 0;
    18307. 

  18307.         }
    18308. 

  18308.         HEAP32[i27 >> 2] = i35;
    18309. 

  18309.         i36 = HEAP32[i34 + 64 >> 2] | 0;
    18310. 

  18310.         HEAP32[i28 >> 2] = i36;
    18311. 

  18311.         HEAP32[i21 >> 2] = HEAP32[i34 + 68 >> 2];
    18312. 

  18312.         i34 = (i36 | 0) == 0 ? 2176 : 2184;
    18313. 

  18313.        } else {
    18314. 

  18314.         HEAP32[i27 >> 2] = 2152;
    18315. 

  18315.         HEAP32[i28 >> 2] = -1;
    18316. 

  18316.         HEAP32[i21 >> 2] = -1;
    18317. 

  18317.         i35 = 2152;
    18318. 

  18318.         i34 = 2160;
    18319. 

  18319.        }
    18320. 

  18320.        HEAP32[i25 >> 2] = i34;
    18321. 

  18321.        _luaO_chunkid(i26, i35, 60);
    18322. 

  18322.        break;
    18323. 

  18323.       }
    18324. 

  18324.      case 117:
    18325. 

  18325.       {
    18326. 

  18326.        if (!i12) {
    18327. 

  18327.         HEAP8[i15] = HEAP8[i11] | 0;
    18328. 

  18328.         if ((HEAP8[i19] | 0) != 38) {
    18329. 

  18329.          HEAP8[i14] = HEAP8[(HEAP32[i24 >> 2] | 0) + 77 | 0] | 0;
    18330. 

  18330.          HEAP8[i13] = HEAP8[(HEAP32[i24 >> 2] | 0) + 76 | 0] | 0;
    18331. 

  18331.          break L12;
    18332. 

  18332.         }
    18333. 

  18333.        } else {
    18334. 

  18334.         HEAP8[i15] = 0;
    18335. 

  18335.        }
    18336. 

  18336.        HEAP8[i14] = 1;
    18337. 

  18337.        HEAP8[i13] = 0;
    18338. 

  18338.        break;
    18339. 

  18339.       }
    18340. 

  18340.      case 102:
    18341. 

  18341.      case 76:
    18342. 

  18342.       {
    18343. 

  18343.        break;
    18344. 

  18344.       }
    18345. 

  18345.      default:
    18346. 

  18346.       {
    18347. 

  18347.        i33 = 0;
    18348. 

  18348.       }
    18349. 

  18349.      }
    18350. 

  18350.     } while (0);
    18351. 

  18351.     i32 = i32 + 1 | 0;
    18352. 

  18352.     i34 = HEAP8[i32] | 0;
    18353. 

  18353.     if (i34 << 24 >> 24 == 0) {
    18354. 

  18354.      break L8;
    18355. 

  18355.     }
    18356. 

  18356.    }
    18357. 

  18357.   }
    18358. 

  18358.  } while (0);
    18359. 

  18359.  if ((_strchr(i6, 102) | 0) != 0) {
    18360. 

  18360.   i36 = i1 + 8 | 0;
    18361. 

  18361.   i35 = HEAP32[i36 >> 2] | 0;
    18362. 

  18362.   i31 = i7;
    18363. 

  18363.   i32 = HEAP32[i31 + 4 >> 2] | 0;
    18364. 

  18364.   i34 = i35;
    18365. 

  18365.   HEAP32[i34 >> 2] = HEAP32[i31 >> 2];
    18366. 

  18366.   HEAP32[i34 + 4 >> 2] = i32;
    18367. 

  18367.   HEAP32[i35 + 8 >> 2] = HEAP32[i8 >> 2];
    18368. 

  18368.   HEAP32[i36 >> 2] = (HEAP32[i36 >> 2] | 0) + 16;
    18369. 

  18369.  }
    18370. 

  18370.  if ((_strchr(i6, 76) | 0) == 0) {
    18371. 

  18371.   STACKTOP = i3;
    18372. 

  18372.   return i33 | 0;
    18373. 

  18373.  }
    18374. 

  18374.  if ((i9 | 0) != 0 ? (HEAP8[i9 + 4 | 0] | 0) != 38 : 0) {
    18375. 

  18375.   i6 = i9 + 12 | 0;
    18376. 

  18376.   i5 = HEAP32[(HEAP32[i6 >> 2] | 0) + 20 >> 2] | 0;
    18377. 

  18377.   i4 = _luaH_new(i1) | 0;
    18378. 

  18378.   i36 = i1 + 8 | 0;
    18379. 

  18379.   i35 = HEAP32[i36 >> 2] | 0;
    18380. 

  18380.   HEAP32[i35 >> 2] = i4;
    18381. 

  18381.   HEAP32[i35 + 8 >> 2] = 69;
    18382. 

  18382.   HEAP32[i36 >> 2] = (HEAP32[i36 >> 2] | 0) + 16;
    18383. 

  18383.   HEAP32[i2 >> 2] = 1;
    18384. 

  18384.   HEAP32[i2 + 8 >> 2] = 1;
    18385. 

  18385.   if ((HEAP32[(HEAP32[i6 >> 2] | 0) + 52 >> 2] | 0) > 0) {
    18386. 

  18386.    i7 = 0;
    18387. 

  18387.   } else {
    18388. 

  18388.    STACKTOP = i3;
    18389. 

  18389.    return i33 | 0;
    18390. 

  18390.   }
    18391. 

  18391.   do {
    18392. 

  18392.    _luaH_setint(i1, i4, HEAP32[i5 + (i7 << 2) >> 2] | 0, i2);
    18393. 

  18393.    i7 = i7 + 1 | 0;
    18394. 

  18394.   } while ((i7 | 0) < (HEAP32[(HEAP32[i6 >> 2] | 0) + 52 >> 2] | 0));
    18395. 

  18395.   STACKTOP = i3;
    18396. 

  18396.   return i33 | 0;
    18397. 

  18397.  }
    18398. 

  18398.  i36 = i1 + 8 | 0;
    18399. 

  18399.  i35 = HEAP32[i36 >> 2] | 0;
    18400. 

  18400.  HEAP32[i35 + 8 >> 2] = 0;
    18401. 

  18401.  HEAP32[i36 >> 2] = i35 + 16;
    18402. 

  18402.  STACKTOP = i3;
    18403. 

  18403.  return i33 | 0;
    18404. 

  18404. }
    18405. 

  18405. function _read_long_string(i3, i1, i5) {
    18406. 

  18406.  i3 = i3 | 0;
    18407. 

  18407.  i1 = i1 | 0;
    18408. 

  18408.  i5 = i5 | 0;
    18409. 

  18409.  var i2 = 0, i4 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0, i14 = 0, i15 = 0, i16 = 0, i17 = 0, i18 = 0;
    18410. 

  18410.  i2 = STACKTOP;
    18411. 

  18411.  i14 = HEAP32[i3 >> 2] | 0;
    18412. 

  18412.  i4 = i3 + 60 | 0;
    18413. 

  18413.  i13 = HEAP32[i4 >> 2] | 0;
    18414. 

  18414.  i15 = i13 + 4 | 0;
    18415. 

  18415.  i16 = HEAP32[i15 >> 2] | 0;
    18416. 

  18416.  i10 = i13 + 8 | 0;
    18417. 

  18417.  i12 = HEAP32[i10 >> 2] | 0;
    18418. 

  18418.  do {
    18419. 

  18419.   if ((i16 + 1 | 0) >>> 0 > i12 >>> 0) {
    18420. 

  18420.    if (i12 >>> 0 > 2147483645) {
    18421. 

  18421.     _lexerror(i3, 12368, 0);
    18422. 

  18422.    }
    18423. 

  18423.    i16 = i12 << 1;
    18424. 

  18424.    i17 = HEAP32[i3 + 52 >> 2] | 0;
    18425. 

  18425.    if ((i16 | 0) == -2) {
    18426. 

  18426.     _luaM_toobig(i17);
    18427. 

  18427.    } else {
    18428. 

  18428.     i8 = _luaM_realloc_(i17, HEAP32[i13 >> 2] | 0, i12, i16) | 0;
    18429. 

  18429.     HEAP32[i13 >> 2] = i8;
    18430. 

  18430.     HEAP32[i10 >> 2] = i16;
    18431. 

  18431.     i9 = HEAP32[i15 >> 2] | 0;
    18432. 

  18432.     break;
    18433. 

  18433.    }
    18434. 

  18434.   } else {
    18435. 

  18435.    i9 = i16;
    18436. 

  18436.    i8 = HEAP32[i13 >> 2] | 0;
    18437. 

  18437.   }
    18438. 

  18438.  } while (0);
    18439. 

  18439.  HEAP32[i15 >> 2] = i9 + 1;
    18440. 

  18440.  HEAP8[i8 + i9 | 0] = i14;
    18441. 

  18441.  i9 = i3 + 56 | 0;
    18442. 

  18442.  i8 = HEAP32[i9 >> 2] | 0;
    18443. 

  18443.  i18 = HEAP32[i8 >> 2] | 0;
    18444. 

  18444.  HEAP32[i8 >> 2] = i18 + -1;
    18445. 

  18445.  if ((i18 | 0) == 0) {
    18446. 

  18446.   i12 = _luaZ_fill(i8) | 0;
    18447. 

  18447.  } else {
    18448. 

  18448.   i18 = i8 + 4 | 0;
    18449. 

  18449.   i12 = HEAP32[i18 >> 2] | 0;
    18450. 

  18450.   HEAP32[i18 >> 2] = i12 + 1;
    18451. 

  18451.   i12 = HEAPU8[i12] | 0;
    18452. 

  18452.  }
    18453. 

  18453.  HEAP32[i3 >> 2] = i12;
    18454. 

  18454.  if ((i12 | 0) == 13 | (i12 | 0) == 10) {
    18455. 

  18455.   _inclinenumber(i3);
    18456. 

  18456.   i11 = 13;
    18457. 

  18457.  }
    18458. 

  18458.  L17 : while (1) {
    18459. 

  18459.   if ((i11 | 0) == 13) {
    18460. 

  18460.    i11 = 0;
    18461. 

  18461.    i12 = HEAP32[i3 >> 2] | 0;
    18462. 

  18462.   }
    18463. 

  18463.   i8 = (i1 | 0) == 0;
    18464. 

  18464.   i10 = i3 + 52 | 0;
    18465. 

  18465.   L21 : do {
    18466. 

  18466.    if (i8) {
    18467. 

  18467.     while (1) {
    18468. 

  18468.      if ((i12 | 0) == 13 | (i12 | 0) == 10) {
    18469. 

  18469.       break L21;
    18470. 

  18470.      } else if ((i12 | 0) == 93) {
    18471. 

  18471.       i11 = 22;
    18472. 

  18472.       break L21;
    18473. 

  18473.      } else if ((i12 | 0) == -1) {
    18474. 

  18474.       i11 = 21;
    18475. 

  18475.       break L17;
    18476. 

  18476.      }
    18477. 

  18477.      i12 = HEAP32[i9 >> 2] | 0;
    18478. 

  18478.      i18 = HEAP32[i12 >> 2] | 0;
    18479. 

  18479.      HEAP32[i12 >> 2] = i18 + -1;
    18480. 

  18480.      if ((i18 | 0) == 0) {
    18481. 

  18481.       i12 = _luaZ_fill(i12) | 0;
    18482. 

  18482.      } else {
    18483. 

  18483.       i18 = i12 + 4 | 0;
    18484. 

  18484.       i12 = HEAP32[i18 >> 2] | 0;
    18485. 

  18485.       HEAP32[i18 >> 2] = i12 + 1;
    18486. 

  18486.       i12 = HEAPU8[i12] | 0;
    18487. 

  18487.      }
    18488. 

  18488.      HEAP32[i3 >> 2] = i12;
    18489. 

  18489.     }
    18490. 

  18490.    } else {
    18491. 

  18491.     while (1) {
    18492. 

  18492.      if ((i12 | 0) == 13 | (i12 | 0) == 10) {
    18493. 

  18493.       break L21;
    18494. 

  18494.      } else if ((i12 | 0) == 93) {
    18495. 

  18495.       i11 = 22;
    18496. 

  18496.       break L21;
    18497. 

  18497.      } else if ((i12 | 0) == -1) {
    18498. 

  18498.       i11 = 21;
    18499. 

  18499.       break L17;
    18500. 

  18500.      }
    18501. 

  18501.      i14 = HEAP32[i4 >> 2] | 0;
    18502. 

  18502.      i13 = i14 + 4 | 0;
    18503. 

  18503.      i17 = HEAP32[i13 >> 2] | 0;
    18504. 

  18504.      i16 = i14 + 8 | 0;
    18505. 

  18505.      i15 = HEAP32[i16 >> 2] | 0;
    18506. 

  18506.      if ((i17 + 1 | 0) >>> 0 > i15 >>> 0) {
    18507. 

  18507.       if (i15 >>> 0 > 2147483645) {
    18508. 

  18508.        i11 = 46;
    18509. 

  18509.        break L17;
    18510. 

  18510.       }
    18511. 

  18511.       i17 = i15 << 1;
    18512. 

  18512.       i18 = HEAP32[i10 >> 2] | 0;
    18513. 

  18513.       if ((i17 | 0) == -2) {
    18514. 

  18514.        i11 = 48;
    18515. 

  18515.        break L17;
    18516. 

  18516.       }
    18517. 

  18517.       i18 = _luaM_realloc_(i18, HEAP32[i14 >> 2] | 0, i15, i17) | 0;
    18518. 

  18518.       HEAP32[i14 >> 2] = i18;
    18519. 

  18519.       HEAP32[i16 >> 2] = i17;
    18520. 

  18520.       i17 = HEAP32[i13 >> 2] | 0;
    18521. 

  18521.       i14 = i18;
    18522. 

  18522.      } else {
    18523. 

  18523.       i14 = HEAP32[i14 >> 2] | 0;
    18524. 

  18524.      }
    18525. 

  18525.      HEAP32[i13 >> 2] = i17 + 1;
    18526. 

  18526.      HEAP8[i14 + i17 | 0] = i12;
    18527. 

  18527.      i12 = HEAP32[i9 >> 2] | 0;
    18528. 

  18528.      i18 = HEAP32[i12 >> 2] | 0;
    18529. 

  18529.      HEAP32[i12 >> 2] = i18 + -1;
    18530. 

  18530.      if ((i18 | 0) == 0) {
    18531. 

  18531.       i12 = _luaZ_fill(i12) | 0;
    18532. 

  18532.      } else {
    18533. 

  18533.       i18 = i12 + 4 | 0;
    18534. 

  18534.       i12 = HEAP32[i18 >> 2] | 0;
    18535. 

  18535.       HEAP32[i18 >> 2] = i12 + 1;
    18536. 

  18536.       i12 = HEAPU8[i12] | 0;
    18537. 

  18537.      }
    18538. 

  18538.      HEAP32[i3 >> 2] = i12;
    18539. 

  18539.     }
    18540. 

  18540.    }
    18541. 

  18541.   } while (0);
    18542. 

  18542.   if ((i11 | 0) == 22) {
    18543. 

  18543.    if ((_skip_sep(i3) | 0) == (i5 | 0)) {
    18544. 

  18544.     i11 = 23;
    18545. 

  18545.     break;
    18546. 

  18546.    } else {
    18547. 

  18547.     i11 = 13;
    18548. 

  18548.     continue;
    18549. 

  18549.    }
    18550. 

  18550.   }
    18551. 

  18551.   i12 = HEAP32[i4 >> 2] | 0;
    18552. 

  18552.   i11 = i12 + 4 | 0;
    18553. 

  18553.   i15 = HEAP32[i11 >> 2] | 0;
    18554. 

  18554.   i14 = i12 + 8 | 0;
    18555. 

  18555.   i13 = HEAP32[i14 >> 2] | 0;
    18556. 

  18556.   if ((i15 + 1 | 0) >>> 0 > i13 >>> 0) {
    18557. 

  18557.    if (i13 >>> 0 > 2147483645) {
    18558. 

  18558.     i11 = 37;
    18559. 

  18559.     break;
    18560. 

  18560.    }
    18561. 

  18561.    i15 = i13 << 1;
    18562. 

  18562.    i10 = HEAP32[i10 >> 2] | 0;
    18563. 

  18563.    if ((i15 | 0) == -2) {
    18564. 

  18564.     i11 = 39;
    18565. 

  18565.     break;
    18566. 

  18566.    }
    18567. 

  18567.    i10 = _luaM_realloc_(i10, HEAP32[i12 >> 2] | 0, i13, i15) | 0;
    18568. 

  18568.    HEAP32[i12 >> 2] = i10;
    18569. 

  18569.    HEAP32[i14 >> 2] = i15;
    18570. 

  18570.    i15 = HEAP32[i11 >> 2] | 0;
    18571. 

  18571.   } else {
    18572. 

  18572.    i10 = HEAP32[i12 >> 2] | 0;
    18573. 

  18573.   }
    18574. 

  18574.   HEAP32[i11 >> 2] = i15 + 1;
    18575. 

  18575.   HEAP8[i10 + i15 | 0] = 10;
    18576. 

  18576.   _inclinenumber(i3);
    18577. 

  18577.   if (!i8) {
    18578. 

  18578.    i11 = 13;
    18579. 

  18579.    continue;
    18580. 

  18580.   }
    18581. 

  18581.   HEAP32[(HEAP32[i4 >> 2] | 0) + 4 >> 2] = 0;
    18582. 

  18582.   i11 = 13;
    18583. 

  18583.  }
    18584. 

  18584.  if ((i11 | 0) == 21) {
    18585. 

  18585.   _lexerror(i3, (i1 | 0) != 0 ? 12512 : 12536, 286);
    18586. 

  18586.  } else if ((i11 | 0) == 23) {
    18587. 

  18587.   i15 = HEAP32[i3 >> 2] | 0;
    18588. 

  18588.   i13 = HEAP32[i4 >> 2] | 0;
    18589. 

  18589.   i14 = i13 + 4 | 0;
    18590. 

  18590.   i16 = HEAP32[i14 >> 2] | 0;
    18591. 

  18591.   i11 = i13 + 8 | 0;
    18592. 

  18592.   i12 = HEAP32[i11 >> 2] | 0;
    18593. 

  18593.   do {
    18594. 

  18594.    if ((i16 + 1 | 0) >>> 0 > i12 >>> 0) {
    18595. 

  18595.     if (i12 >>> 0 > 2147483645) {
    18596. 

  18596.      _lexerror(i3, 12368, 0);
    18597. 

  18597.     }
    18598. 

  18598.     i17 = i12 << 1;
    18599. 

  18599.     i16 = HEAP32[i10 >> 2] | 0;
    18600. 

  18600.     if ((i17 | 0) == -2) {
    18601. 

  18601.      _luaM_toobig(i16);
    18602. 

  18602.     } else {
    18603. 

  18603.      i6 = _luaM_realloc_(i16, HEAP32[i13 >> 2] | 0, i12, i17) | 0;
    18604. 

  18604.      HEAP32[i13 >> 2] = i6;
    18605. 

  18605.      HEAP32[i11 >> 2] = i17;
    18606. 

  18606.      i7 = HEAP32[i14 >> 2] | 0;
    18607. 

  18607.      break;
    18608. 

  18608.     }
    18609. 

  18609.    } else {
    18610. 

  18610.     i7 = i16;
    18611. 

  18611.     i6 = HEAP32[i13 >> 2] | 0;
    18612. 

  18612.    }
    18613. 

  18613.   } while (0);
    18614. 

  18614.   HEAP32[i14 >> 2] = i7 + 1;
    18615. 

  18615.   HEAP8[i6 + i7 | 0] = i15;
    18616. 

  18616.   i6 = HEAP32[i9 >> 2] | 0;
    18617. 

  18617.   i18 = HEAP32[i6 >> 2] | 0;
    18618. 

  18618.   HEAP32[i6 >> 2] = i18 + -1;
    18619. 

  18619.   if ((i18 | 0) == 0) {
    18620. 

  18620.    i6 = _luaZ_fill(i6) | 0;
    18621. 

  18621.   } else {
    18622. 

  18622.    i18 = i6 + 4 | 0;
    18623. 

  18623.    i6 = HEAP32[i18 >> 2] | 0;
    18624. 

  18624.    HEAP32[i18 >> 2] = i6 + 1;
    18625. 

  18625.    i6 = HEAPU8[i6] | 0;
    18626. 

  18626.   }
    18627. 

  18627.   HEAP32[i3 >> 2] = i6;
    18628. 

  18628.   if (i8) {
    18629. 

  18629.    STACKTOP = i2;
    18630. 

  18630.    return;
    18631. 

  18631.   }
    18632. 

  18632.   i4 = HEAP32[i4 >> 2] | 0;
    18633. 

  18633.   i5 = i5 + 2 | 0;
    18634. 

  18634.   i6 = HEAP32[i10 >> 2] | 0;
    18635. 

  18635.   i5 = _luaS_newlstr(i6, (HEAP32[i4 >> 2] | 0) + i5 | 0, (HEAP32[i4 + 4 >> 2] | 0) - (i5 << 1) | 0) | 0;
    18636. 

  18636.   i4 = i6 + 8 | 0;
    18637. 

  18637.   i7 = HEAP32[i4 >> 2] | 0;
    18638. 

  18638.   HEAP32[i4 >> 2] = i7 + 16;
    18639. 

  18639.   HEAP32[i7 >> 2] = i5;
    18640. 

  18640.   HEAP32[i7 + 8 >> 2] = HEAPU8[i5 + 4 | 0] | 0 | 64;
    18641. 

  18641.   i7 = _luaH_set(i6, HEAP32[(HEAP32[i3 + 48 >> 2] | 0) + 4 >> 2] | 0, (HEAP32[i4 >> 2] | 0) + -16 | 0) | 0;
    18642. 

  18642.   i3 = i7 + 8 | 0;
    18643. 

  18643.   if ((HEAP32[i3 >> 2] | 0) == 0 ? (HEAP32[i7 >> 2] = 1, HEAP32[i3 >> 2] = 1, (HEAP32[(HEAP32[i6 + 12 >> 2] | 0) + 12 >> 2] | 0) > 0) : 0) {
    18644. 

  18644.    _luaC_step(i6);
    18645. 

  18645.   }
    18646. 

  18646.   HEAP32[i4 >> 2] = (HEAP32[i4 >> 2] | 0) + -16;
    18647. 

  18647.   HEAP32[i1 >> 2] = i5;
    18648. 

  18648.   STACKTOP = i2;
    18649. 

  18649.   return;
    18650. 

  18650.  } else if ((i11 | 0) == 37) {
    18651. 

  18651.   _lexerror(i3, 12368, 0);
    18652. 

  18652.  } else if ((i11 | 0) == 39) {
    18653. 

  18653.   _luaM_toobig(i10);
    18654. 

  18654.  } else if ((i11 | 0) == 46) {
    18655. 

  18655.   _lexerror(i3, 12368, 0);
    18656. 

  18656.  } else if ((i11 | 0) == 48) {
    18657. 

  18657.   _luaM_toobig(i18);
    18658. 

  18658.  }
    18659. 

  18659. }
    18660. 

  18660. function _try_realloc_chunk(i1, i3) {
    18661. 

  18661.  i1 = i1 | 0;
    18662. 

  18662.  i3 = i3 | 0;
    18663. 

  18663.  var i2 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0, i14 = 0, i15 = 0;
    18664. 

  18664.  i2 = STACKTOP;
    18665. 

  18665.  i4 = i1 + 4 | 0;
    18666. 

  18666.  i6 = HEAP32[i4 >> 2] | 0;
    18667. 

  18667.  i8 = i6 & -8;
    18668. 

  18668.  i5 = i1 + i8 | 0;
    18669. 

  18669.  i10 = HEAP32[12928 >> 2] | 0;
    18670. 

  18670.  if (i1 >>> 0 < i10 >>> 0) {
    18671. 

  18671.   _abort();
    18672. 

  18672.  }
    18673. 

  18673.  i12 = i6 & 3;
    18674. 

  18674.  if (!((i12 | 0) != 1 & i1 >>> 0 < i5 >>> 0)) {
    18675. 

  18675.   _abort();
    18676. 

  18676.  }
    18677. 

  18677.  i7 = i1 + (i8 | 4) | 0;
    18678. 

  18678.  i13 = HEAP32[i7 >> 2] | 0;
    18679. 

  18679.  if ((i13 & 1 | 0) == 0) {
    18680. 

  18680.   _abort();
    18681. 

  18681.  }
    18682. 

  18682.  if ((i12 | 0) == 0) {
    18683. 

  18683.   if (i3 >>> 0 < 256) {
    18684. 

  18684.    i15 = 0;
    18685. 

  18685.    STACKTOP = i2;
    18686. 

  18686.    return i15 | 0;
    18687. 

  18687.   }
    18688. 

  18688.   if (!(i8 >>> 0 < (i3 + 4 | 0) >>> 0) ? !((i8 - i3 | 0) >>> 0 > HEAP32[13392 >> 2] << 1 >>> 0) : 0) {
    18689. 

  18689.    i15 = i1;
    18690. 

  18690.    STACKTOP = i2;
    18691. 

  18691.    return i15 | 0;
    18692. 

  18692.   }
    18693. 

  18693.   i15 = 0;
    18694. 

  18694.   STACKTOP = i2;
    18695. 

  18695.   return i15 | 0;
    18696. 

  18696.  }
    18697. 

  18697.  if (!(i8 >>> 0 < i3 >>> 0)) {
    18698. 

  18698.   i5 = i8 - i3 | 0;
    18699. 

  18699.   if (!(i5 >>> 0 > 15)) {
    18700. 

  18700.    i15 = i1;
    18701. 

  18701.    STACKTOP = i2;
    18702. 

  18702.    return i15 | 0;
    18703. 

  18703.   }
    18704. 

  18704.   HEAP32[i4 >> 2] = i6 & 1 | i3 | 2;
    18705. 

  18705.   HEAP32[i1 + (i3 + 4) >> 2] = i5 | 3;
    18706. 

  18706.   HEAP32[i7 >> 2] = HEAP32[i7 >> 2] | 1;
    18707. 

  18707.   _dispose_chunk(i1 + i3 | 0, i5);
    18708. 

  18708.   i15 = i1;
    18709. 

  18709.   STACKTOP = i2;
    18710. 

  18710.   return i15 | 0;
    18711. 

  18711.  }
    18712. 

  18712.  if ((i5 | 0) == (HEAP32[12936 >> 2] | 0)) {
    18713. 

  18713.   i5 = (HEAP32[12924 >> 2] | 0) + i8 | 0;
    18714. 

  18714.   if (!(i5 >>> 0 > i3 >>> 0)) {
    18715. 

  18715.    i15 = 0;
    18716. 

  18716.    STACKTOP = i2;
    18717. 

  18717.    return i15 | 0;
    18718. 

  18718.   }
    18719. 

  18719.   i15 = i5 - i3 | 0;
    18720. 

  18720.   HEAP32[i4 >> 2] = i6 & 1 | i3 | 2;
    18721. 

  18721.   HEAP32[i1 + (i3 + 4) >> 2] = i15 | 1;
    18722. 

  18722.   HEAP32[12936 >> 2] = i1 + i3;
    18723. 

  18723.   HEAP32[12924 >> 2] = i15;
    18724. 

  18724.   i15 = i1;
    18725. 

  18725.   STACKTOP = i2;
    18726. 

  18726.   return i15 | 0;
    18727. 

  18727.  }
    18728. 

  18728.  if ((i5 | 0) == (HEAP32[12932 >> 2] | 0)) {
    18729. 

  18729.   i7 = (HEAP32[12920 >> 2] | 0) + i8 | 0;
    18730. 

  18730.   if (i7 >>> 0 < i3 >>> 0) {
    18731. 

  18731.    i15 = 0;
    18732. 

  18732.    STACKTOP = i2;
    18733. 

  18733.    return i15 | 0;
    18734. 

  18734.   }
    18735. 

  18735.   i5 = i7 - i3 | 0;
    18736. 

  18736.   if (i5 >>> 0 > 15) {
    18737. 

  18737.    HEAP32[i4 >> 2] = i6 & 1 | i3 | 2;
    18738. 

  18738.    HEAP32[i1 + (i3 + 4) >> 2] = i5 | 1;
    18739. 

  18739.    HEAP32[i1 + i7 >> 2] = i5;
    18740. 

  18740.    i15 = i1 + (i7 + 4) | 0;
    18741. 

  18741.    HEAP32[i15 >> 2] = HEAP32[i15 >> 2] & -2;
    18742. 

  18742.    i3 = i1 + i3 | 0;
    18743. 

  18743.   } else {
    18744. 

  18744.    HEAP32[i4 >> 2] = i6 & 1 | i7 | 2;
    18745. 

  18745.    i3 = i1 + (i7 + 4) | 0;
    18746. 

  18746.    HEAP32[i3 >> 2] = HEAP32[i3 >> 2] | 1;
    18747. 

  18747.    i3 = 0;
    18748. 

  18748.    i5 = 0;
    18749. 

  18749.   }
    18750. 

  18750.   HEAP32[12920 >> 2] = i5;
    18751. 

  18751.   HEAP32[12932 >> 2] = i3;
    18752. 

  18752.   i15 = i1;
    18753. 

  18753.   STACKTOP = i2;
    18754. 

  18754.   return i15 | 0;
    18755. 

  18755.  }
    18756. 

  18756.  if ((i13 & 2 | 0) != 0) {
    18757. 

  18757.   i15 = 0;
    18758. 

  18758.   STACKTOP = i2;
    18759. 

  18759.   return i15 | 0;
    18760. 

  18760.  }
    18761. 

  18761.  i7 = (i13 & -8) + i8 | 0;
    18762. 

  18762.  if (i7 >>> 0 < i3 >>> 0) {
    18763. 

  18763.   i15 = 0;
    18764. 

  18764.   STACKTOP = i2;
    18765. 

  18765.   return i15 | 0;
    18766. 

  18766.  }
    18767. 

  18767.  i6 = i7 - i3 | 0;
    18768. 

  18768.  i12 = i13 >>> 3;
    18769. 

  18769.  do {
    18770. 

  18770.   if (!(i13 >>> 0 < 256)) {
    18771. 

  18771.    i11 = HEAP32[i1 + (i8 + 24) >> 2] | 0;
    18772. 

  18772.    i13 = HEAP32[i1 + (i8 + 12) >> 2] | 0;
    18773. 

  18773.    do {
    18774. 

  18774.     if ((i13 | 0) == (i5 | 0)) {
    18775. 

  18775.      i13 = i1 + (i8 + 20) | 0;
    18776. 

  18776.      i12 = HEAP32[i13 >> 2] | 0;
    18777. 

  18777.      if ((i12 | 0) == 0) {
    18778. 

  18778.       i13 = i1 + (i8 + 16) | 0;
    18779. 

  18779.       i12 = HEAP32[i13 >> 2] | 0;
    18780. 

  18780.       if ((i12 | 0) == 0) {
    18781. 

  18781.        i9 = 0;
    18782. 

  18782.        break;
    18783. 

  18783.       }
    18784. 

  18784.      }
    18785. 

  18785.      while (1) {
    18786. 

  18786.       i15 = i12 + 20 | 0;
    18787. 

  18787.       i14 = HEAP32[i15 >> 2] | 0;
    18788. 

  18788.       if ((i14 | 0) != 0) {
    18789. 

  18789.        i12 = i14;
    18790. 

  18790.        i13 = i15;
    18791. 

  18791.        continue;
    18792. 

  18792.       }
    18793. 

  18793.       i15 = i12 + 16 | 0;
    18794. 

  18794.       i14 = HEAP32[i15 >> 2] | 0;
    18795. 

  18795.       if ((i14 | 0) == 0) {
    18796. 

  18796.        break;
    18797. 

  18797.       } else {
    18798. 

  18798.        i12 = i14;
    18799. 

  18799.        i13 = i15;
    18800. 

  18800.       }
    18801. 

  18801.      }
    18802. 

  18802.      if (i13 >>> 0 < i10 >>> 0) {
    18803. 

  18803.       _abort();
    18804. 

  18804.      } else {
    18805. 

  18805.       HEAP32[i13 >> 2] = 0;
    18806. 

  18806.       i9 = i12;
    18807. 

  18807.       break;
    18808. 

  18808.      }
    18809. 

  18809.     } else {
    18810. 

  18810.      i12 = HEAP32[i1 + (i8 + 8) >> 2] | 0;
    18811. 

  18811.      if (i12 >>> 0 < i10 >>> 0) {
    18812. 

  18812.       _abort();
    18813. 

  18813.      }
    18814. 

  18814.      i14 = i12 + 12 | 0;
    18815. 

  18815.      if ((HEAP32[i14 >> 2] | 0) != (i5 | 0)) {
    18816. 

  18816.       _abort();
    18817. 

  18817.      }
    18818. 

  18818.      i10 = i13 + 8 | 0;
    18819. 

  18819.      if ((HEAP32[i10 >> 2] | 0) == (i5 | 0)) {
    18820. 

  18820.       HEAP32[i14 >> 2] = i13;
    18821. 

  18821.       HEAP32[i10 >> 2] = i12;
    18822. 

  18822.       i9 = i13;
    18823. 

  18823.       break;
    18824. 

  18824.      } else {
    18825. 

  18825.       _abort();
    18826. 

  18826.      }
    18827. 

  18827.     }
    18828. 

  18828.    } while (0);
    18829. 

  18829.    if ((i11 | 0) != 0) {
    18830. 

  18830.     i10 = HEAP32[i1 + (i8 + 28) >> 2] | 0;
    18831. 

  18831.     i12 = 13216 + (i10 << 2) | 0;
    18832. 

  18832.     if ((i5 | 0) == (HEAP32[i12 >> 2] | 0)) {
    18833. 

  18833.      HEAP32[i12 >> 2] = i9;
    18834. 

  18834.      if ((i9 | 0) == 0) {
    18835. 

  18835.       HEAP32[12916 >> 2] = HEAP32[12916 >> 2] & ~(1 << i10);
    18836. 

  18836.       break;
    18837. 

  18837.      }
    18838. 

  18838.     } else {
    18839. 

  18839.      if (i11 >>> 0 < (HEAP32[12928 >> 2] | 0) >>> 0) {
    18840. 

  18840.       _abort();
    18841. 

  18841.      }
    18842. 

  18842.      i10 = i11 + 16 | 0;
    18843. 

  18843.      if ((HEAP32[i10 >> 2] | 0) == (i5 | 0)) {
    18844. 

  18844.       HEAP32[i10 >> 2] = i9;
    18845. 

  18845.      } else {
    18846. 

  18846.       HEAP32[i11 + 20 >> 2] = i9;
    18847. 

  18847.      }
    18848. 

  18848.      if ((i9 | 0) == 0) {
    18849. 

  18849.       break;
    18850. 

  18850.      }
    18851. 

  18851.     }
    18852. 

  18852.     if (i9 >>> 0 < (HEAP32[12928 >> 2] | 0) >>> 0) {
    18853. 

  18853.      _abort();
    18854. 

  18854.     }
    18855. 

  18855.     HEAP32[i9 + 24 >> 2] = i11;
    18856. 

  18856.     i5 = HEAP32[i1 + (i8 + 16) >> 2] | 0;
    18857. 

  18857.     do {
    18858. 

  18858.      if ((i5 | 0) != 0) {
    18859. 

  18859.       if (i5 >>> 0 < (HEAP32[12928 >> 2] | 0) >>> 0) {
    18860. 

  18860.        _abort();
    18861. 

  18861.       } else {
    18862. 

  18862.        HEAP32[i9 + 16 >> 2] = i5;
    18863. 

  18863.        HEAP32[i5 + 24 >> 2] = i9;
    18864. 

  18864.        break;
    18865. 

  18865.       }
    18866. 

  18866.      }
    18867. 

  18867.     } while (0);
    18868. 

  18868.     i5 = HEAP32[i1 + (i8 + 20) >> 2] | 0;
    18869. 

  18869.     if ((i5 | 0) != 0) {
    18870. 

  18870.      if (i5 >>> 0 < (HEAP32[12928 >> 2] | 0) >>> 0) {
    18871. 

  18871.       _abort();
    18872. 

  18872.      } else {
    18873. 

  18873.       HEAP32[i9 + 20 >> 2] = i5;
    18874. 

  18874.       HEAP32[i5 + 24 >> 2] = i9;
    18875. 

  18875.       break;
    18876. 

  18876.      }
    18877. 

  18877.     }
    18878. 

  18878.    }
    18879. 

  18879.   } else {
    18880. 

  18880.    i9 = HEAP32[i1 + (i8 + 8) >> 2] | 0;
    18881. 

  18881.    i8 = HEAP32[i1 + (i8 + 12) >> 2] | 0;
    18882. 

  18882.    i13 = 12952 + (i12 << 1 << 2) | 0;
    18883. 

  18883.    if ((i9 | 0) != (i13 | 0)) {
    18884. 

  18884.     if (i9 >>> 0 < i10 >>> 0) {
    18885. 

  18885.      _abort();
    18886. 

  18886.     }
    18887. 

  18887.     if ((HEAP32[i9 + 12 >> 2] | 0) != (i5 | 0)) {
    18888. 

  18888.      _abort();
    18889. 

  18889.     }
    18890. 

  18890.    }
    18891. 

  18891.    if ((i8 | 0) == (i9 | 0)) {
    18892. 

  18892.     HEAP32[3228] = HEAP32[3228] & ~(1 << i12);
    18893. 

  18893.     break;
    18894. 

  18894.    }
    18895. 

  18895.    if ((i8 | 0) != (i13 | 0)) {
    18896. 

  18896.     if (i8 >>> 0 < i10 >>> 0) {
    18897. 

  18897.      _abort();
    18898. 

  18898.     }
    18899. 

  18899.     i10 = i8 + 8 | 0;
    18900. 

  18900.     if ((HEAP32[i10 >> 2] | 0) == (i5 | 0)) {
    18901. 

  18901.      i11 = i10;
    18902. 

  18902.     } else {
    18903. 

  18903.      _abort();
    18904. 

  18904.     }
    18905. 

  18905.    } else {
    18906. 

  18906.     i11 = i8 + 8 | 0;
    18907. 

  18907.    }
    18908. 

  18908.    HEAP32[i9 + 12 >> 2] = i8;
    18909. 

  18909.    HEAP32[i11 >> 2] = i9;
    18910. 

  18910.   }
    18911. 

  18911.  } while (0);
    18912. 

  18912.  if (i6 >>> 0 < 16) {
    18913. 

  18913.   HEAP32[i4 >> 2] = i7 | HEAP32[i4 >> 2] & 1 | 2;
    18914. 

  18914.   i15 = i1 + (i7 | 4) | 0;
    18915. 

  18915.   HEAP32[i15 >> 2] = HEAP32[i15 >> 2] | 1;
    18916. 

  18916.   i15 = i1;
    18917. 

  18917.   STACKTOP = i2;
    18918. 

  18918.   return i15 | 0;
    18919. 

  18919.  } else {
    18920. 

  18920.   HEAP32[i4 >> 2] = HEAP32[i4 >> 2] & 1 | i3 | 2;
    18921. 

  18921.   HEAP32[i1 + (i3 + 4) >> 2] = i6 | 3;
    18922. 

  18922.   i15 = i1 + (i7 | 4) | 0;
    18923. 

  18923.   HEAP32[i15 >> 2] = HEAP32[i15 >> 2] | 1;
    18924. 

  18924.   _dispose_chunk(i1 + i3 | 0, i6);
    18925. 

  18925.   i15 = i1;
    18926. 

  18926.   STACKTOP = i2;
    18927. 

  18927.   return i15 | 0;
    18928. 

  18928.  }
    18929. 

  18929.  return 0;
    18930. 

  18930. }
    18931. 

  18931. function _luaK_posfix(i3, i16, i1, i4, i14) {
    18932. 

  18932.  i3 = i3 | 0;
    18933. 

  18933.  i16 = i16 | 0;
    18934. 

  18934.  i1 = i1 | 0;
    18935. 

  18935.  i4 = i4 | 0;
    18936. 

  18936.  i14 = i14 | 0;
    18937. 

  18937.  var i2 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0, i15 = 0;
    18938. 

  18938.  i2 = STACKTOP;
    18939. 

  18939.  switch (i16 | 0) {
    18940. 

  18940.  case 14:
    18941. 

  18941.   {
    18942. 

  18942.    _luaK_dischargevars(i3, i4);
    18943. 

  18943.    i6 = i4 + 16 | 0;
    18944. 

  18944.    i5 = HEAP32[i1 + 16 >> 2] | 0;
    18945. 

  18945.    do {
    18946. 

  18946.     if (!((i5 | 0) == -1)) {
    18947. 

  18947.      i9 = HEAP32[i6 >> 2] | 0;
    18948. 

  18948.      if ((i9 | 0) == -1) {
    18949. 

  18949.       HEAP32[i6 >> 2] = i5;
    18950. 

  18950.       break;
    18951. 

  18951.      }
    18952. 

  18952.      i7 = HEAP32[(HEAP32[i3 >> 2] | 0) + 12 >> 2] | 0;
    18953. 

  18953.      while (1) {
    18954. 

  18954.       i6 = i7 + (i9 << 2) | 0;
    18955. 

  18955.       i8 = HEAP32[i6 >> 2] | 0;
    18956. 

  18956.       i10 = (i8 >>> 14) + -131071 | 0;
    18957. 

  18957.       if ((i10 | 0) == -1) {
    18958. 

  18958.        break;
    18959. 

  18959.       }
    18960. 

  18960.       i10 = i9 + 1 + i10 | 0;
    18961. 

  18961.       if ((i10 | 0) == -1) {
    18962. 

  18962.        break;
    18963. 

  18963.       } else {
    18964. 

  18964.        i9 = i10;
    18965. 

  18965.       }
    18966. 

  18966.      }
    18967. 

  18967.      i5 = i5 + ~i9 | 0;
    18968. 

  18968.      if ((((i5 | 0) > -1 ? i5 : 0 - i5 | 0) | 0) > 131071) {
    18969. 

  18969.       _luaX_syntaxerror(HEAP32[i3 + 12 >> 2] | 0, 10624);
    18970. 

  18970.      } else {
    18971. 

  18971.       HEAP32[i6 >> 2] = (i5 << 14) + 2147467264 | i8 & 16383;
    18972. 

  18972.       break;
    18973. 

  18973.      }
    18974. 

  18974.     }
    18975. 

  18975.    } while (0);
    18976. 

  18976.    HEAP32[i1 + 0 >> 2] = HEAP32[i4 + 0 >> 2];
    18977. 

  18977.    HEAP32[i1 + 4 >> 2] = HEAP32[i4 + 4 >> 2];
    18978. 

  18978.    HEAP32[i1 + 8 >> 2] = HEAP32[i4 + 8 >> 2];
    18979. 

  18979.    HEAP32[i1 + 12 >> 2] = HEAP32[i4 + 12 >> 2];
    18980. 

  18980.    HEAP32[i1 + 16 >> 2] = HEAP32[i4 + 16 >> 2];
    18981. 

  18981.    HEAP32[i1 + 20 >> 2] = HEAP32[i4 + 20 >> 2];
    18982. 

  18982.    STACKTOP = i2;
    18983. 

  18983.    return;
    18984. 

  18984.   }
    18985. 

  18985.  case 13:
    18986. 

  18986.   {
    18987. 

  18987.    _luaK_dischargevars(i3, i4);
    18988. 

  18988.    i6 = i4 + 20 | 0;
    18989. 

  18989.    i5 = HEAP32[i1 + 20 >> 2] | 0;
    18990. 

  18990.    do {
    18991. 

  18991.     if (!((i5 | 0) == -1)) {
    18992. 

  18992.      i9 = HEAP32[i6 >> 2] | 0;
    18993. 

  18993.      if ((i9 | 0) == -1) {
    18994. 

  18994.       HEAP32[i6 >> 2] = i5;
    18995. 

  18995.       break;
    18996. 

  18996.      }
    18997. 

  18997.      i7 = HEAP32[(HEAP32[i3 >> 2] | 0) + 12 >> 2] | 0;
    18998. 

  18998.      while (1) {
    18999. 

  18999.       i8 = i7 + (i9 << 2) | 0;
    19000. 

  19000.       i6 = HEAP32[i8 >> 2] | 0;
    19001. 

  19001.       i10 = (i6 >>> 14) + -131071 | 0;
    19002. 

  19002.       if ((i10 | 0) == -1) {
    19003. 

  19003.        break;
    19004. 

  19004.       }
    19005. 

  19005.       i10 = i9 + 1 + i10 | 0;
    19006. 

  19006.       if ((i10 | 0) == -1) {
    19007. 

  19007.        break;
    19008. 

  19008.       } else {
    19009. 

  19009.        i9 = i10;
    19010. 

  19010.       }
    19011. 

  19011.      }
    19012. 

  19012.      i5 = i5 + ~i9 | 0;
    19013. 

  19013.      if ((((i5 | 0) > -1 ? i5 : 0 - i5 | 0) | 0) > 131071) {
    19014. 

  19014.       _luaX_syntaxerror(HEAP32[i3 + 12 >> 2] | 0, 10624);
    19015. 

  19015.      } else {
    19016. 

  19016.       HEAP32[i8 >> 2] = (i5 << 14) + 2147467264 | i6 & 16383;
    19017. 

  19017.       break;
    19018. 

  19018.      }
    19019. 

  19019.     }
    19020. 

  19020.    } while (0);
    19021. 

  19021.    HEAP32[i1 + 0 >> 2] = HEAP32[i4 + 0 >> 2];
    19022. 

  19022.    HEAP32[i1 + 4 >> 2] = HEAP32[i4 + 4 >> 2];
    19023. 

  19023.    HEAP32[i1 + 8 >> 2] = HEAP32[i4 + 8 >> 2];
    19024. 

  19024.    HEAP32[i1 + 12 >> 2] = HEAP32[i4 + 12 >> 2];
    19025. 

  19025.    HEAP32[i1 + 16 >> 2] = HEAP32[i4 + 16 >> 2];
    19026. 

  19026.    HEAP32[i1 + 20 >> 2] = HEAP32[i4 + 20 >> 2];
    19027. 

  19027.    STACKTOP = i2;
    19028. 

  19028.    return;
    19029. 

  19029.   }
    19030. 

  19030.  case 6:
    19031. 

  19031.   {
    19032. 

  19032.    i12 = i4 + 16 | 0;
    19033. 

  19033.    i13 = i4 + 20 | 0;
    19034. 

  19034.    i16 = (HEAP32[i12 >> 2] | 0) == (HEAP32[i13 >> 2] | 0);
    19035. 

  19035.    _luaK_dischargevars(i3, i4);
    19036. 

  19036.    do {
    19037. 

  19037.     if (!i16) {
    19038. 

  19038.      if ((HEAP32[i4 >> 2] | 0) == 6) {
    19039. 

  19039.       i10 = HEAP32[i4 + 8 >> 2] | 0;
    19040. 

  19040.       if ((HEAP32[i12 >> 2] | 0) == (HEAP32[i13 >> 2] | 0)) {
    19041. 

  19041.        break;
    19042. 

  19042.       }
    19043. 

  19043.       if ((i10 | 0) >= (HEAPU8[i3 + 46 | 0] | 0 | 0)) {
    19044. 

  19044.        _exp2reg(i3, i4, i10);
    19045. 

  19045.        break;
    19046. 

  19046.       }
    19047. 

  19047.      }
    19048. 

  19048.      _luaK_exp2nextreg(i3, i4);
    19049. 

  19049.     }
    19050. 

  19050.    } while (0);
    19051. 

  19051.    if ((HEAP32[i4 >> 2] | 0) == 11 ? (i5 = i4 + 8 | 0, i7 = HEAP32[i5 >> 2] | 0, i8 = (HEAP32[i3 >> 2] | 0) + 12 | 0, i9 = HEAP32[i8 >> 2] | 0, i6 = HEAP32[i9 + (i7 << 2) >> 2] | 0, (i6 & 63 | 0) == 22) : 0) {
    19052. 

  19052.     i4 = i1 + 8 | 0;
    19053. 

  19053.     if (((HEAP32[i1 >> 2] | 0) == 6 ? (i11 = HEAP32[i4 >> 2] | 0, (i11 & 256 | 0) == 0) : 0) ? (HEAPU8[i3 + 46 | 0] | 0 | 0) <= (i11 | 0) : 0) {
    19054. 

  19054.      i6 = i3 + 48 | 0;
    19055. 

  19055.      HEAP8[i6] = (HEAP8[i6] | 0) + -1 << 24 >> 24;
    19056. 

  19056.      i6 = HEAP32[i5 >> 2] | 0;
    19057. 

  19057.      i16 = HEAP32[i8 >> 2] | 0;
    19058. 

  19058.      i9 = i16;
    19059. 

  19059.      i7 = i6;
    19060. 

  19060.      i6 = HEAP32[i16 + (i6 << 2) >> 2] | 0;
    19061. 

  19061.     }
    19062. 

  19062.     HEAP32[i9 + (i7 << 2) >> 2] = HEAP32[i4 >> 2] << 23 | i6 & 8388607;
    19063. 

  19063.     HEAP32[i1 >> 2] = 11;
    19064. 

  19064.     HEAP32[i4 >> 2] = HEAP32[i5 >> 2];
    19065. 

  19065.     STACKTOP = i2;
    19066. 

  19066.     return;
    19067. 

  19067.    }
    19068. 

  19068.    _luaK_exp2nextreg(i3, i4);
    19069. 

  19069.    _codearith(i3, 22, i1, i4, i14);
    19070. 

  19070.    STACKTOP = i2;
    19071. 

  19071.    return;
    19072. 

  19072.   }
    19073. 

  19073.  case 9:
    19074. 

  19074.  case 8:
    19075. 

  19075.  case 7:
    19076. 

  19076.   {
    19077. 

  19077.    i7 = i16 + 17 | 0;
    19078. 

  19078.    i6 = _luaK_exp2RK(i3, i1) | 0;
    19079. 

  19079.    i5 = _luaK_exp2RK(i3, i4) | 0;
    19080. 

  19080.    if (((HEAP32[i4 >> 2] | 0) == 6 ? (i15 = HEAP32[i4 + 8 >> 2] | 0, (i15 & 256 | 0) == 0) : 0) ? (HEAPU8[i3 + 46 | 0] | 0 | 0) <= (i15 | 0) : 0) {
    19081. 

  19081.     i16 = i3 + 48 | 0;
    19082. 

  19082.     HEAP8[i16] = (HEAP8[i16] | 0) + -1 << 24 >> 24;
    19083. 

  19083.    }
    19084. 

  19084.    i4 = i1 + 8 | 0;
    19085. 

  19085.    if (((HEAP32[i1 >> 2] | 0) == 6 ? (i10 = HEAP32[i4 >> 2] | 0, (i10 & 256 | 0) == 0) : 0) ? (HEAPU8[i3 + 46 | 0] | 0 | 0) <= (i10 | 0) : 0) {
    19086. 

  19086.     i16 = i3 + 48 | 0;
    19087. 

  19087.     HEAP8[i16] = (HEAP8[i16] | 0) + -1 << 24 >> 24;
    19088. 

  19088.    }
    19089. 

  19089.    HEAP32[i4 >> 2] = _condjump(i3, i7, 1, i6, i5) | 0;
    19090. 

  19090.    HEAP32[i1 >> 2] = 10;
    19091. 

  19091.    STACKTOP = i2;
    19092. 

  19092.    return;
    19093. 

  19093.   }
    19094. 

  19094.  case 12:
    19095. 

  19095.  case 11:
    19096. 

  19096.  case 10:
    19097. 

  19097.   {
    19098. 

  19098.    i7 = i16 + 14 | 0;
    19099. 

  19099.    i6 = _luaK_exp2RK(i3, i1) | 0;
    19100. 

  19100.    i5 = _luaK_exp2RK(i3, i4) | 0;
    19101. 

  19101.    if (((HEAP32[i4 >> 2] | 0) == 6 ? (i13 = HEAP32[i4 + 8 >> 2] | 0, (i13 & 256 | 0) == 0) : 0) ? (HEAPU8[i3 + 46 | 0] | 0 | 0) <= (i13 | 0) : 0) {
    19102. 

  19102.     i16 = i3 + 48 | 0;
    19103. 

  19103.     HEAP8[i16] = (HEAP8[i16] | 0) + -1 << 24 >> 24;
    19104. 

  19104.    }
    19105. 

  19105.    i4 = i1 + 8 | 0;
    19106. 

  19106.    if (((HEAP32[i1 >> 2] | 0) == 6 ? (i12 = HEAP32[i4 >> 2] | 0, (i12 & 256 | 0) == 0) : 0) ? (HEAPU8[i3 + 46 | 0] | 0 | 0) <= (i12 | 0) : 0) {
    19107. 

  19107.     i16 = i3 + 48 | 0;
    19108. 

  19108.     HEAP8[i16] = (HEAP8[i16] | 0) + -1 << 24 >> 24;
    19109. 

  19109.    }
    19110. 

  19110.    i8 = (i7 | 0) == 24;
    19111. 

  19111.    HEAP32[i4 >> 2] = _condjump(i3, i7, i8 & 1 ^ 1, i8 ? i6 : i5, i8 ? i5 : i6) | 0;
    19112. 

  19112.    HEAP32[i1 >> 2] = 10;
    19113. 

  19113.    STACKTOP = i2;
    19114. 

  19114.    return;
    19115. 

  19115.   }
    19116. 

  19116.  case 5:
    19117. 

  19117.  case 4:
    19118. 

  19118.  case 3:
    19119. 

  19119.  case 2:
    19120. 

  19120.  case 1:
    19121. 

  19121.  case 0:
    19122. 

  19122.   {
    19123. 

  19123.    _codearith(i3, i16 + 13 | 0, i1, i4, i14);
    19124. 

  19124.    STACKTOP = i2;
    19125. 

  19125.    return;
    19126. 

  19126.   }
    19127. 

  19127.  default:
    19128. 

  19128.   {
    19129. 

  19129.    STACKTOP = i2;
    19130. 

  19130.    return;
    19131. 

  19131.   }
    19132. 

  19132.  }
    19133. 

  19133. }
    19134. 

  19134. function _body(i1, i4, i13, i5) {
    19135. 

  19135.  i1 = i1 | 0;
    19136. 

  19136.  i4 = i4 | 0;
    19137. 

  19137.  i13 = i13 | 0;
    19138. 

  19138.  i5 = i5 | 0;
    19139. 

  19139.  var i2 = 0, i3 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i14 = 0, i15 = 0, i16 = 0, i17 = 0, i18 = 0, i19 = 0, i20 = 0, i21 = 0, i22 = 0, i23 = 0, i24 = 0;
    19140. 

  19140.  i6 = STACKTOP;
    19141. 

  19141.  STACKTOP = STACKTOP + 64 | 0;
    19142. 

  19142.  i3 = i6 + 12 | 0;
    19143. 

  19143.  i14 = i6;
    19144. 

  19144.  i2 = i1 + 48 | 0;
    19145. 

  19145.  i19 = HEAP32[i2 >> 2] | 0;
    19146. 

  19146.  i18 = i1 + 52 | 0;
    19147. 

  19147.  i17 = HEAP32[i18 >> 2] | 0;
    19148. 

  19148.  i16 = HEAP32[i19 >> 2] | 0;
    19149. 

  19149.  i19 = i19 + 36 | 0;
    19150. 

  19150.  i23 = i16 + 56 | 0;
    19151. 

  19151.  i24 = HEAP32[i23 >> 2] | 0;
    19152. 

  19152.  i15 = i16 + 16 | 0;
    19153. 

  19153.  if (((HEAP32[i19 >> 2] | 0) >= (i24 | 0) ? (i21 = _luaM_growaux_(i17, HEAP32[i15 >> 2] | 0, i23, 4, 262143, 6512) | 0, HEAP32[i15 >> 2] = i21, i20 = HEAP32[i23 >> 2] | 0, (i24 | 0) < (i20 | 0)) : 0) ? (i22 = i24 + 1 | 0, HEAP32[i21 + (i24 << 2) >> 2] = 0, (i22 | 0) < (i20 | 0)) : 0) {
    19154. 

  19154.   while (1) {
    19155. 

  19155.    i21 = i22 + 1 | 0;
    19156. 

  19156.    HEAP32[(HEAP32[i15 >> 2] | 0) + (i22 << 2) >> 2] = 0;
    19157. 

  19157.    if ((i21 | 0) == (i20 | 0)) {
    19158. 

  19158.     break;
    19159. 

  19159.    } else {
    19160. 

  19160.     i22 = i21;
    19161. 

  19161.    }
    19162. 

  19162.   }
    19163. 

  19163.  }
    19164. 

  19164.  i20 = _luaF_newproto(i17) | 0;
    19165. 

  19165.  i24 = HEAP32[i19 >> 2] | 0;
    19166. 

  19166.  HEAP32[i19 >> 2] = i24 + 1;
    19167. 

  19167.  HEAP32[(HEAP32[i15 >> 2] | 0) + (i24 << 2) >> 2] = i20;
    19168. 

  19168.  if (!((HEAP8[i20 + 5 | 0] & 3) == 0) ? !((HEAP8[i16 + 5 | 0] & 4) == 0) : 0) {
    19169. 

  19169.   _luaC_barrier_(i17, i16, i20);
    19170. 

  19170.  }
    19171. 

  19171.  HEAP32[i3 >> 2] = i20;
    19172. 

  19172.  HEAP32[i20 + 64 >> 2] = i5;
    19173. 

  19173.  i16 = HEAP32[i18 >> 2] | 0;
    19174. 

  19174.  HEAP32[i3 + 8 >> 2] = HEAP32[i2 >> 2];
    19175. 

  19175.  i17 = i3 + 12 | 0;
    19176. 

  19176.  HEAP32[i17 >> 2] = i1;
    19177. 

  19177.  HEAP32[i2 >> 2] = i3;
    19178. 

  19178.  HEAP32[i3 + 20 >> 2] = 0;
    19179. 

  19179.  HEAP32[i3 + 24 >> 2] = 0;
    19180. 

  19180.  HEAP32[i3 + 28 >> 2] = -1;
    19181. 

  19181.  HEAP32[i3 + 32 >> 2] = 0;
    19182. 

  19182.  HEAP32[i3 + 36 >> 2] = 0;
    19183. 

  19183.  i22 = i3 + 44 | 0;
    19184. 

  19184.  i15 = i1 + 64 | 0;
    19185. 

  19185.  HEAP32[i22 + 0 >> 2] = 0;
    19186. 

  19186.  HEAP8[i22 + 4 | 0] = 0;
    19187. 

  19187.  HEAP32[i3 + 40 >> 2] = HEAP32[(HEAP32[i15 >> 2] | 0) + 4 >> 2];
    19188. 

  19188.  i15 = i3 + 16 | 0;
    19189. 

  19189.  HEAP32[i15 >> 2] = 0;
    19190. 

  19190.  HEAP32[i20 + 36 >> 2] = HEAP32[i1 + 68 >> 2];
    19191. 

  19191.  HEAP8[i20 + 78 | 0] = 2;
    19192. 

  19192.  i22 = _luaH_new(i16) | 0;
    19193. 

  19193.  HEAP32[i3 + 4 >> 2] = i22;
    19194. 

  19194.  i23 = i16 + 8 | 0;
    19195. 

  19195.  i24 = HEAP32[i23 >> 2] | 0;
    19196. 

  19196.  HEAP32[i24 >> 2] = i22;
    19197. 

  19197.  HEAP32[i24 + 8 >> 2] = 69;
    19198. 

  19198.  i24 = (HEAP32[i23 >> 2] | 0) + 16 | 0;
    19199. 

  19199.  HEAP32[i23 >> 2] = i24;
    19200. 

  19200.  if (((HEAP32[i16 + 24 >> 2] | 0) - i24 | 0) < 16) {
    19201. 

  19201.   _luaD_growstack(i16, 0);
    19202. 

  19202.  }
    19203. 

  19203.  HEAP8[i14 + 10 | 0] = 0;
    19204. 

  19204.  HEAP8[i14 + 8 | 0] = HEAP8[i3 + 46 | 0] | 0;
    19205. 

  19205.  i24 = HEAP32[(HEAP32[i17 >> 2] | 0) + 64 >> 2] | 0;
    19206. 

  19206.  HEAP16[i14 + 4 >> 1] = HEAP32[i24 + 28 >> 2];
    19207. 

  19207.  HEAP16[i14 + 6 >> 1] = HEAP32[i24 + 16 >> 2];
    19208. 

  19208.  HEAP8[i14 + 9 | 0] = 0;
    19209. 

  19209.  HEAP32[i14 >> 2] = HEAP32[i15 >> 2];
    19210. 

  19210.  HEAP32[i15 >> 2] = i14;
    19211. 

  19211.  i14 = i1 + 16 | 0;
    19212. 

  19212.  if ((HEAP32[i14 >> 2] | 0) != 40) {
    19213. 

  19213.   _error_expected(i1, 40);
    19214. 

  19214.  }
    19215. 

  19215.  _luaX_next(i1);
    19216. 

  19216.  if ((i13 | 0) != 0) {
    19217. 

  19217.   _new_localvar(i1, _luaX_newstring(i1, 6456, 4) | 0);
    19218. 

  19218.   i24 = HEAP32[i2 >> 2] | 0;
    19219. 

  19219.   i22 = i24 + 46 | 0;
    19220. 

  19220.   i23 = (HEAPU8[i22] | 0) + 1 | 0;
    19221. 

  19221.   HEAP8[i22] = i23;
    19222. 

  19222.   HEAP32[(HEAP32[(HEAP32[i24 >> 2] | 0) + 24 >> 2] | 0) + ((HEAP16[(HEAP32[HEAP32[(HEAP32[i24 + 12 >> 2] | 0) + 64 >> 2] >> 2] | 0) + ((i23 & 255) + -1 + (HEAP32[i24 + 40 >> 2] | 0) << 1) >> 1] | 0) * 12 | 0) + 4 >> 2] = HEAP32[i24 + 20 >> 2];
    19223. 

  19223.  }
    19224. 

  19224.  i13 = HEAP32[i2 >> 2] | 0;
    19225. 

  19225.  i15 = HEAP32[i13 >> 2] | 0;
    19226. 

  19226.  i16 = i15 + 77 | 0;
    19227. 

  19227.  HEAP8[i16] = 0;
    19228. 

  19228.  i19 = HEAP32[i14 >> 2] | 0;
    19229. 

  19229.  L20 : do {
    19230. 

  19230.   if ((i19 | 0) != 41) {
    19231. 

  19231.    i17 = i1 + 24 | 0;
    19232. 

  19232.    i18 = 0;
    19233. 

  19233.    while (1) {
    19234. 

  19234.     if ((i19 | 0) == 280) {
    19235. 

  19235.      i17 = 18;
    19236. 

  19236.      break;
    19237. 

  19237.     } else if ((i19 | 0) != 288) {
    19238. 

  19238.      i17 = 19;
    19239. 

  19239.      break;
    19240. 

  19240.     }
    19241. 

  19241.     i24 = HEAP32[i17 >> 2] | 0;
    19242. 

  19242.     _luaX_next(i1);
    19243. 

  19243.     _new_localvar(i1, i24);
    19244. 

  19244.     i18 = i18 + 1 | 0;
    19245. 

  19245.     if ((HEAP8[i16] | 0) != 0) {
    19246. 

  19246.      i11 = i18;
    19247. 

  19247.      break L20;
    19248. 

  19248.     }
    19249. 

  19249.     if ((HEAP32[i14 >> 2] | 0) != 44) {
    19250. 

  19250.      i11 = i18;
    19251. 

  19251.      break L20;
    19252. 

  19252.     }
    19253. 

  19253.     _luaX_next(i1);
    19254. 

  19254.     i19 = HEAP32[i14 >> 2] | 0;
    19255. 

  19255.    }
    19256. 

  19256.    if ((i17 | 0) == 18) {
    19257. 

  19257.     _luaX_next(i1);
    19258. 

  19258.     HEAP8[i16] = 1;
    19259. 

  19259.     i11 = i18;
    19260. 

  19260.     break;
    19261. 

  19261.    } else if ((i17 | 0) == 19) {
    19262. 

  19262.     _luaX_syntaxerror(i1, 6464);
    19263. 

  19263.    }
    19264. 

  19264.   } else {
    19265. 

  19265.    i11 = 0;
    19266. 

  19266.   }
    19267. 

  19267.  } while (0);
    19268. 

  19268.  i18 = HEAP32[i2 >> 2] | 0;
    19269. 

  19269.  i16 = i18 + 46 | 0;
    19270. 

  19270.  i17 = (HEAPU8[i16] | 0) + i11 | 0;
    19271. 

  19271.  HEAP8[i16] = i17;
    19272. 

  19272.  if ((i11 | 0) != 0 ? (i8 = i18 + 20 | 0, i9 = i18 + 40 | 0, i7 = HEAP32[(HEAP32[i18 >> 2] | 0) + 24 >> 2] | 0, i10 = HEAP32[HEAP32[(HEAP32[i18 + 12 >> 2] | 0) + 64 >> 2] >> 2] | 0, HEAP32[i7 + ((HEAP16[i10 + ((i17 & 255) - i11 + (HEAP32[i9 >> 2] | 0) << 1) >> 1] | 0) * 12 | 0) + 4 >> 2] = HEAP32[i8 >> 2], i12 = i11 + -1 | 0, (i12 | 0) != 0) : 0) {
    19273. 

  19273.   do {
    19274. 

  19274.    HEAP32[i7 + ((HEAP16[i10 + ((HEAPU8[i16] | 0) - i12 + (HEAP32[i9 >> 2] | 0) << 1) >> 1] | 0) * 12 | 0) + 4 >> 2] = HEAP32[i8 >> 2];
    19275. 

  19275.    i12 = i12 + -1 | 0;
    19276. 

  19276.   } while ((i12 | 0) != 0);
    19277. 

  19277.  }
    19278. 

  19278.  i24 = i13 + 46 | 0;
    19279. 

  19279.  HEAP8[i15 + 76 | 0] = HEAP8[i24] | 0;
    19280. 

  19280.  _luaK_reserveregs(i13, HEAPU8[i24] | 0);
    19281. 

  19281.  if ((HEAP32[i14 >> 2] | 0) != 41) {
    19282. 

  19282.   _error_expected(i1, 41);
    19283. 

  19283.  }
    19284. 

  19284.  _luaX_next(i1);
    19285. 

  19285.  L39 : while (1) {
    19286. 

  19286.   i7 = HEAP32[i14 >> 2] | 0;
    19287. 

  19287.   switch (i7 | 0) {
    19288. 

  19288.   case 277:
    19289. 

  19289.   case 286:
    19290. 

  19290.   case 262:
    19291. 

  19291.   case 261:
    19292. 

  19292.   case 260:
    19293. 

  19293.    {
    19294. 

  19294.     i17 = 30;
    19295. 

  19295.     break L39;
    19296. 

  19296.    }
    19297. 

  19297.   default:
    19298. 

  19298.    {}
    19299. 

  19299.   }
    19300. 

  19300.   _statement(i1);
    19301. 

  19301.   if ((i7 | 0) == 274) {
    19302. 

  19302.    i17 = 30;
    19303. 

  19303.    break;
    19304. 

  19304.   }
    19305. 

  19305.  }
    19306. 

  19306.  if ((i17 | 0) == 30) {
    19307. 

  19307.   HEAP32[(HEAP32[i3 >> 2] | 0) + 68 >> 2] = HEAP32[i1 + 4 >> 2];
    19308. 

  19308.   _check_match(i1, 262, 265, i5);
    19309. 

  19309.   i24 = HEAP32[(HEAP32[i2 >> 2] | 0) + 8 >> 2] | 0;
    19310. 

  19310.   i23 = _luaK_codeABx(i24, 37, 0, (HEAP32[i24 + 36 >> 2] | 0) + -1 | 0) | 0;
    19311. 

  19311.   HEAP32[i4 + 16 >> 2] = -1;
    19312. 

  19312.   HEAP32[i4 + 20 >> 2] = -1;
    19313. 

  19313.   HEAP32[i4 >> 2] = 11;
    19314. 

  19314.   HEAP32[i4 + 8 >> 2] = i23;
    19315. 

  19315.   _luaK_exp2nextreg(i24, i4);
    19316. 

  19316.   _close_func(i1);
    19317. 

  19317.   STACKTOP = i6;
    19318. 

  19318.   return;
    19319. 

  19319.  }
    19320. 

  19320. }
    19321. 

  19321. function _luaH_newkey(i3, i2, i1) {
    19322. 

  19322.  i3 = i3 | 0;
    19323. 

  19323.  i2 = i2 | 0;
    19324. 

  19324.  i1 = i1 | 0;
    19325. 

  19325.  var i4 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0, i14 = 0, i15 = 0, i16 = 0, i17 = 0, i18 = 0, i19 = 0, i20 = 0, d21 = 0.0;
    19326. 

  19326.  i4 = STACKTOP;
    19327. 

  19327.  STACKTOP = STACKTOP + 144 | 0;
    19328. 

  19328.  i8 = i4 + 8 | 0;
    19329. 

  19329.  i10 = i4;
    19330. 

  19330.  i5 = i4 + 16 | 0;
    19331. 

  19331.  i6 = i1 + 8 | 0;
    19332. 

  19332.  i11 = HEAP32[i6 >> 2] | 0;
    19333. 

  19333.  if ((i11 | 0) == 0) {
    19334. 

  19334.   _luaG_runerror(i3, 7968, i8);
    19335. 

  19335.  } else if ((i11 | 0) == 3) {
    19336. 

  19336.   i15 = 3;
    19337. 

  19337.  }
    19338. 

  19338.  if ((i15 | 0) == 3 ? (d21 = +HEAPF64[i1 >> 3], !(d21 == d21 & 0.0 == 0.0)) : 0) {
    19339. 

  19339.   _luaG_runerror(i3, 7992, i8);
    19340. 

  19340.  }
    19341. 

  19341.  i13 = _mainposition(i2, i1) | 0;
    19342. 

  19342.  i14 = i13 + 8 | 0;
    19343. 

  19343.  do {
    19344. 

  19344.   if ((HEAP32[i14 >> 2] | 0) != 0 | (i13 | 0) == 8016) {
    19345. 

  19345.    i18 = i2 + 20 | 0;
    19346. 

  19346.    i11 = i2 + 16 | 0;
    19347. 

  19347.    i17 = HEAP32[i11 >> 2] | 0;
    19348. 

  19348.    i16 = HEAP32[i18 >> 2] | 0;
    19349. 

  19349.    while (1) {
    19350. 

  19350.     if (!(i16 >>> 0 > i17 >>> 0)) {
    19351. 

  19351.      break;
    19352. 

  19352.     }
    19353. 

  19353.     i12 = i16 + -32 | 0;
    19354. 

  19354.     HEAP32[i18 >> 2] = i12;
    19355. 

  19355.     if ((HEAP32[i16 + -8 >> 2] | 0) == 0) {
    19356. 

  19356.      i15 = 37;
    19357. 

  19357.      break;
    19358. 

  19358.     } else {
    19359. 

  19359.      i16 = i12;
    19360. 

  19360.     }
    19361. 

  19361.    }
    19362. 

  19362.    if ((i15 | 0) == 37) {
    19363. 

  19363.     i5 = _mainposition(i2, i13 + 16 | 0) | 0;
    19364. 

  19364.     if ((i5 | 0) == (i13 | 0)) {
    19365. 

  19365.      i20 = i13 + 28 | 0;
    19366. 

  19366.      HEAP32[i16 + -4 >> 2] = HEAP32[i20 >> 2];
    19367. 

  19367.      HEAP32[i20 >> 2] = i12;
    19368. 

  19368.      break;
    19369. 

  19369.     } else {
    19370. 

  19370.      i7 = i5;
    19371. 

  19371.     }
    19372. 

  19372.     do {
    19373. 

  19373.      i5 = i7 + 28 | 0;
    19374. 

  19374.      i7 = HEAP32[i5 >> 2] | 0;
    19375. 

  19375.     } while ((i7 | 0) != (i13 | 0));
    19376. 

  19376.     HEAP32[i5 >> 2] = i12;
    19377. 

  19377.     HEAP32[i12 + 0 >> 2] = HEAP32[i13 + 0 >> 2];
    19378. 

  19378.     HEAP32[i12 + 4 >> 2] = HEAP32[i13 + 4 >> 2];
    19379. 

  19379.     HEAP32[i12 + 8 >> 2] = HEAP32[i13 + 8 >> 2];
    19380. 

  19380.     HEAP32[i12 + 12 >> 2] = HEAP32[i13 + 12 >> 2];
    19381. 

  19381.     HEAP32[i12 + 16 >> 2] = HEAP32[i13 + 16 >> 2];
    19382. 

  19382.     HEAP32[i12 + 20 >> 2] = HEAP32[i13 + 20 >> 2];
    19383. 

  19383.     HEAP32[i12 + 24 >> 2] = HEAP32[i13 + 24 >> 2];
    19384. 

  19384.     HEAP32[i12 + 28 >> 2] = HEAP32[i13 + 28 >> 2];
    19385. 

  19385.     HEAP32[i13 + 28 >> 2] = 0;
    19386. 

  19386.     HEAP32[i14 >> 2] = 0;
    19387. 

  19387.     i12 = i13;
    19388. 

  19388.     break;
    19389. 

  19389.    }
    19390. 

  19390.    i13 = i5 + 0 | 0;
    19391. 

  19391.    i12 = i13 + 124 | 0;
    19392. 

  19392.    do {
    19393. 

  19393.     HEAP32[i13 >> 2] = 0;
    19394. 

  19394.     i13 = i13 + 4 | 0;
    19395. 

  19395.    } while ((i13 | 0) < (i12 | 0));
    19396. 

  19396.    i15 = i2 + 12 | 0;
    19397. 

  19397.    i13 = HEAP32[i2 + 28 >> 2] | 0;
    19398. 

  19398.    i12 = 0;
    19399. 

  19399.    i20 = 1;
    19400. 

  19400.    i16 = 0;
    19401. 

  19401.    i14 = 1;
    19402. 

  19402.    while (1) {
    19403. 

  19403.     if ((i14 | 0) > (i13 | 0)) {
    19404. 

  19404.      if ((i20 | 0) > (i13 | 0)) {
    19405. 

  19405.       break;
    19406. 

  19406.      } else {
    19407. 

  19407.       i19 = i13;
    19408. 

  19408.      }
    19409. 

  19409.     } else {
    19410. 

  19410.      i19 = i14;
    19411. 

  19411.     }
    19412. 

  19412.     if ((i20 | 0) > (i19 | 0)) {
    19413. 

  19413.      i18 = i20;
    19414. 

  19414.      i17 = 0;
    19415. 

  19415.     } else {
    19416. 

  19416.      i18 = HEAP32[i15 >> 2] | 0;
    19417. 

  19417.      i17 = 0;
    19418. 

  19418.      while (1) {
    19419. 

  19419.       i17 = ((HEAP32[i18 + (i20 + -1 << 4) + 8 >> 2] | 0) != 0) + i17 | 0;
    19420. 

  19420.       if ((i20 | 0) >= (i19 | 0)) {
    19421. 

  19421.        break;
    19422. 

  19422.       } else {
    19423. 

  19423.        i20 = i20 + 1 | 0;
    19424. 

  19424.       }
    19425. 

  19425.      }
    19426. 

  19426.      i18 = i19 + 1 | 0;
    19427. 

  19427.     }
    19428. 

  19428.     i20 = i5 + (i16 << 2) | 0;
    19429. 

  19429.     HEAP32[i20 >> 2] = (HEAP32[i20 >> 2] | 0) + i17;
    19430. 

  19430.     i12 = i17 + i12 | 0;
    19431. 

  19431.     i16 = i16 + 1 | 0;
    19432. 

  19432.     if ((i16 | 0) < 31) {
    19433. 

  19433.      i20 = i18;
    19434. 

  19434.      i14 = i14 << 1;
    19435. 

  19435.     } else {
    19436. 

  19436.      break;
    19437. 

  19437.     }
    19438. 

  19438.    }
    19439. 

  19439.    i14 = 0;
    19440. 

  19440.    i15 = 1 << (HEAPU8[i2 + 7 | 0] | 0);
    19441. 

  19441.    i13 = 0;
    19442. 

  19442.    L32 : while (1) {
    19443. 

  19443.     i16 = i15;
    19444. 

  19444.     while (1) {
    19445. 

  19445.      i15 = i16 + -1 | 0;
    19446. 

  19446.      if ((i16 | 0) == 0) {
    19447. 

  19447.       break L32;
    19448. 

  19448.      }
    19449. 

  19449.      i16 = HEAP32[i11 >> 2] | 0;
    19450. 

  19450.      if ((HEAP32[i16 + (i15 << 5) + 8 >> 2] | 0) == 0) {
    19451. 

  19451.       i16 = i15;
    19452. 

  19452.      } else {
    19453. 

  19453.       break;
    19454. 

  19454.      }
    19455. 

  19455.     }
    19456. 

  19456.     if (((HEAP32[i16 + (i15 << 5) + 24 >> 2] | 0) == 3 ? (d21 = +HEAPF64[i16 + (i15 << 5) + 16 >> 3], HEAPF64[i10 >> 3] = d21 + 6755399441055744.0, i9 = HEAP32[i10 >> 2] | 0, +(i9 | 0) == d21) : 0) ? (i9 + -1 | 0) >>> 0 < 1073741824 : 0) {
    19457. 

  19457.      i16 = i5 + ((_luaO_ceillog2(i9) | 0) << 2) | 0;
    19458. 

  19458.      HEAP32[i16 >> 2] = (HEAP32[i16 >> 2] | 0) + 1;
    19459. 

  19459.      i16 = 1;
    19460. 

  19460.     } else {
    19461. 

  19461.      i16 = 0;
    19462. 

  19462.     }
    19463. 

  19463.     i14 = i16 + i14 | 0;
    19464. 

  19464.     i13 = i13 + 1 | 0;
    19465. 

  19465.    }
    19466. 

  19466.    i9 = i14 + i12 | 0;
    19467. 

  19467.    if (((HEAP32[i6 >> 2] | 0) == 3 ? (d21 = +HEAPF64[i1 >> 3], HEAPF64[i8 >> 3] = d21 + 6755399441055744.0, i7 = HEAP32[i8 >> 2] | 0, +(i7 | 0) == d21) : 0) ? (i7 + -1 | 0) >>> 0 < 1073741824 : 0) {
    19468. 

  19468.     i6 = i5 + ((_luaO_ceillog2(i7) | 0) << 2) | 0;
    19469. 

  19469.     HEAP32[i6 >> 2] = (HEAP32[i6 >> 2] | 0) + 1;
    19470. 

  19470.     i6 = 1;
    19471. 

  19471.    } else {
    19472. 

  19472.     i6 = 0;
    19473. 

  19473.    }
    19474. 

  19474.    i7 = i9 + i6 | 0;
    19475. 

  19475.    L49 : do {
    19476. 

  19476.     if ((i7 | 0) > 0) {
    19477. 

  19477.      i14 = 0;
    19478. 

  19478.      i10 = 0;
    19479. 

  19479.      i6 = 0;
    19480. 

  19480.      i8 = 0;
    19481. 

  19481.      i11 = 0;
    19482. 

  19482.      i9 = 1;
    19483. 

  19483.      while (1) {
    19484. 

  19484.       i15 = HEAP32[i5 + (i6 << 2) >> 2] | 0;
    19485. 

  19485.       if ((i15 | 0) > 0) {
    19486. 

  19486.        i15 = i15 + i10 | 0;
    19487. 

  19487.        i14 = (i15 | 0) > (i14 | 0);
    19488. 

  19488.        i10 = i15;
    19489. 

  19489.        i8 = i14 ? i9 : i8;
    19490. 

  19490.        i11 = i14 ? i15 : i11;
    19491. 

  19491.       }
    19492. 

  19492.       if ((i10 | 0) == (i7 | 0)) {
    19493. 

  19493.        break L49;
    19494. 

  19494.       }
    19495. 

  19495.       i9 = i9 << 1;
    19496. 

  19496.       i14 = (i9 | 0) / 2 | 0;
    19497. 

  19497.       if ((i14 | 0) < (i7 | 0)) {
    19498. 

  19498.        i6 = i6 + 1 | 0;
    19499. 

  19499.       } else {
    19500. 

  19500.        break;
    19501. 

  19501.       }
    19502. 

  19502.      }
    19503. 

  19503.     } else {
    19504. 

  19504.      i8 = 0;
    19505. 

  19505.      i11 = 0;
    19506. 

  19506.     }
    19507. 

  19507.    } while (0);
    19508. 

  19508.    _luaH_resize(i3, i2, i8, i12 + 1 + i13 - i11 | 0);
    19509. 

  19509.    i5 = _luaH_get(i2, i1) | 0;
    19510. 

  19510.    if ((i5 | 0) != 5192) {
    19511. 

  19511.     i20 = i5;
    19512. 

  19512.     STACKTOP = i4;
    19513. 

  19513.     return i20 | 0;
    19514. 

  19514.    }
    19515. 

  19515.    i20 = _luaH_newkey(i3, i2, i1) | 0;
    19516. 

  19516.    STACKTOP = i4;
    19517. 

  19517.    return i20 | 0;
    19518. 

  19518.   } else {
    19519. 

  19519.    i12 = i13;
    19520. 

  19520.   }
    19521. 

  19521.  } while (0);
    19522. 

  19522.  i18 = i1;
    19523. 

  19523.  i19 = HEAP32[i18 + 4 >> 2] | 0;
    19524. 

  19524.  i20 = i12 + 16 | 0;
    19525. 

  19525.  HEAP32[i20 >> 2] = HEAP32[i18 >> 2];
    19526. 

  19526.  HEAP32[i20 + 4 >> 2] = i19;
    19527. 

  19527.  HEAP32[i12 + 24 >> 2] = HEAP32[i6 >> 2];
    19528. 

  19528.  if (((HEAP32[i6 >> 2] & 64 | 0) != 0 ? !((HEAP8[(HEAP32[i1 >> 2] | 0) + 5 | 0] & 3) == 0) : 0) ? !((HEAP8[i2 + 5 | 0] & 4) == 0) : 0) {
    19529. 

  19529.   _luaC_barrierback_(i3, i2);
    19530. 

  19530.  }
    19531. 

  19531.  i20 = i12;
    19532. 

  19532.  STACKTOP = i4;
    19533. 

  19533.  return i20 | 0;
    19534. 

  19534. }
    19535. 

  19535. function _luaV_concat(i7, i10) {
    19536. 

  19536.  i7 = i7 | 0;
    19537. 

  19537.  i10 = i10 | 0;
    19538. 

  19538.  var i1 = 0, i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i8 = 0, i9 = 0, i11 = 0, i12 = 0, i13 = 0, i14 = 0, i15 = 0, i16 = 0, i17 = 0, i18 = 0, i19 = 0, i20 = 0;
    19539. 

  19539.  i5 = STACKTOP;
    19540. 

  19540.  STACKTOP = STACKTOP + 48 | 0;
    19541. 

  19541.  i9 = i5;
    19542. 

  19542.  i8 = i5 + 8 | 0;
    19543. 

  19543.  i6 = i7 + 8 | 0;
    19544. 

  19544.  i2 = i7 + 12 | 0;
    19545. 

  19545.  i3 = i7 + 28 | 0;
    19546. 

  19546.  i4 = i7 + 16 | 0;
    19547. 

  19547.  i11 = HEAP32[i6 >> 2] | 0;
    19548. 

  19548.  L1 : while (1) {
    19549. 

  19549.   i14 = i11 + -32 | 0;
    19550. 

  19550.   i12 = i11 + -24 | 0;
    19551. 

  19551.   i17 = HEAP32[i12 >> 2] | 0;
    19552. 

  19552.   i13 = i11 + -16 | 0;
    19553. 

  19553.   do {
    19554. 

  19554.    if ((i17 & 15 | 0) == 4 | (i17 | 0) == 3) {
    19555. 

  19555.     i15 = i11 + -8 | 0;
    19556. 

  19556.     i16 = HEAP32[i15 >> 2] | 0;
    19557. 

  19557.     if ((i16 & 15 | 0) == 4) {
    19558. 

  19558.      i16 = i13;
    19559. 

  19559.     } else {
    19560. 

  19560.      if ((i16 | 0) != 3) {
    19561. 

  19561.       i1 = 7;
    19562. 

  19562.       break;
    19563. 

  19563.      }
    19564. 

  19564.      HEAPF64[tempDoublePtr >> 3] = +HEAPF64[i13 >> 3];
    19565. 

  19565.      HEAP32[i9 >> 2] = HEAP32[tempDoublePtr >> 2];
    19566. 

  19566.      HEAP32[i9 + 4 >> 2] = HEAP32[tempDoublePtr + 4 >> 2];
    19567. 

  19567.      i16 = _luaS_newlstr(i7, i8, _sprintf(i8 | 0, 8936, i9 | 0) | 0) | 0;
    19568. 

  19568.      HEAP32[i13 >> 2] = i16;
    19569. 

  19569.      HEAP32[i15 >> 2] = HEAPU8[i16 + 4 | 0] | 0 | 64;
    19570. 

  19570.      i16 = i13;
    19571. 

  19571.      i17 = HEAP32[i12 >> 2] | 0;
    19572. 

  19572.     }
    19573. 

  19573.     i16 = HEAP32[(HEAP32[i16 >> 2] | 0) + 12 >> 2] | 0;
    19574. 

  19574.     i18 = (i17 & 15 | 0) == 4;
    19575. 

  19575.     if ((i16 | 0) == 0) {
    19576. 

  19576.      if (i18) {
    19577. 

  19577.       i12 = 2;
    19578. 

  19578.       break;
    19579. 

  19579.      }
    19580. 

  19580.      if ((i17 | 0) != 3) {
    19581. 

  19581.       i12 = 2;
    19582. 

  19582.       break;
    19583. 

  19583.      }
    19584. 

  19584.      HEAPF64[tempDoublePtr >> 3] = +HEAPF64[i14 >> 3];
    19585. 

  19585.      HEAP32[i9 >> 2] = HEAP32[tempDoublePtr >> 2];
    19586. 

  19586.      HEAP32[i9 + 4 >> 2] = HEAP32[tempDoublePtr + 4 >> 2];
    19587. 

  19587.      i18 = _luaS_newlstr(i7, i8, _sprintf(i8 | 0, 8936, i9 | 0) | 0) | 0;
    19588. 

  19588.      HEAP32[i14 >> 2] = i18;
    19589. 

  19589.      HEAP32[i12 >> 2] = HEAPU8[i18 + 4 | 0] | 0 | 64;
    19590. 

  19590.      i12 = 2;
    19591. 

  19591.      break;
    19592. 

  19592.     }
    19593. 

  19593.     if (i18 ? (HEAP32[(HEAP32[i14 >> 2] | 0) + 12 >> 2] | 0) == 0 : 0) {
    19594. 

  19594.      i16 = i13;
    19595. 

  19595.      i17 = HEAP32[i16 + 4 >> 2] | 0;
    19596. 

  19596.      i18 = i14;
    19597. 

  19597.      HEAP32[i18 >> 2] = HEAP32[i16 >> 2];
    19598. 

  19598.      HEAP32[i18 + 4 >> 2] = i17;
    19599. 

  19599.      HEAP32[i12 >> 2] = HEAP32[i15 >> 2];
    19600. 

  19600.      i12 = 2;
    19601. 

  19601.      break;
    19602. 

  19602.     }
    19603. 

  19603.     L19 : do {
    19604. 

  19604.      if ((i10 | 0) > 1) {
    19605. 

  19605.       i12 = 1;
    19606. 

  19606.       do {
    19607. 

  19607.        i15 = ~i12;
    19608. 

  19608.        i14 = i11 + (i15 << 4) | 0;
    19609. 

  19609.        i15 = i11 + (i15 << 4) + 8 | 0;
    19610. 

  19610.        i13 = HEAP32[i15 >> 2] | 0;
    19611. 

  19611.        if ((i13 & 15 | 0) != 4) {
    19612. 

  19612.         if ((i13 | 0) != 3) {
    19613. 

  19613.          break L19;
    19614. 

  19614.         }
    19615. 

  19615.         HEAPF64[tempDoublePtr >> 3] = +HEAPF64[i14 >> 3];
    19616. 

  19616.         HEAP32[i9 >> 2] = HEAP32[tempDoublePtr >> 2];
    19617. 

  19617.         HEAP32[i9 + 4 >> 2] = HEAP32[tempDoublePtr + 4 >> 2];
    19618. 

  19618.         i18 = _luaS_newlstr(i7, i8, _sprintf(i8 | 0, 8936, i9 | 0) | 0) | 0;
    19619. 

  19619.         HEAP32[i14 >> 2] = i18;
    19620. 

  19620.         HEAP32[i15 >> 2] = HEAPU8[i18 + 4 | 0] | 0 | 64;
    19621. 

  19621.        }
    19622. 

  19622.        i13 = HEAP32[(HEAP32[i14 >> 2] | 0) + 12 >> 2] | 0;
    19623. 

  19623.        if (!(i13 >>> 0 < (-3 - i16 | 0) >>> 0)) {
    19624. 

  19624.         i1 = 24;
    19625. 

  19625.         break L1;
    19626. 

  19626.        }
    19627. 

  19627.        i16 = i13 + i16 | 0;
    19628. 

  19628.        i12 = i12 + 1 | 0;
    19629. 

  19629.       } while ((i12 | 0) < (i10 | 0));
    19630. 

  19630.      } else {
    19631. 

  19631.       i12 = 1;
    19632. 

  19632.      }
    19633. 

  19633.     } while (0);
    19634. 

  19634.     i14 = _luaZ_openspace(i7, (HEAP32[i2 >> 2] | 0) + 144 | 0, i16) | 0;
    19635. 

  19635.     i15 = i12;
    19636. 

  19636.     i13 = 0;
    19637. 

  19637.     do {
    19638. 

  19638.      i17 = HEAP32[i11 + (0 - i15 << 4) >> 2] | 0;
    19639. 

  19639.      i18 = HEAP32[i17 + 12 >> 2] | 0;
    19640. 

  19640.      _memcpy(i14 + i13 | 0, i17 + 16 | 0, i18 | 0) | 0;
    19641. 

  19641.      i13 = i18 + i13 | 0;
    19642. 

  19642.      i15 = i15 + -1 | 0;
    19643. 

  19643.     } while ((i15 | 0) > 0);
    19644. 

  19644.     i18 = 0 - i12 | 0;
    19645. 

  19645.     i17 = _luaS_newlstr(i7, i14, i13) | 0;
    19646. 

  19646.     HEAP32[i11 + (i18 << 4) >> 2] = i17;
    19647. 

  19647.     HEAP32[i11 + (i18 << 4) + 8 >> 2] = HEAPU8[i17 + 4 | 0] | 0 | 64;
    19648. 

  19648.    } else {
    19649. 

  19649.     i1 = 7;
    19650. 

  19650.    }
    19651. 

  19651.   } while (0);
    19652. 

  19652.   if ((i1 | 0) == 7) {
    19653. 

  19653.    i1 = 0;
    19654. 

  19654.    i15 = _luaT_gettmbyobj(i7, i14, 15) | 0;
    19655. 

  19655.    if ((HEAP32[i15 + 8 >> 2] | 0) == 0) {
    19656. 

  19656.     i15 = _luaT_gettmbyobj(i7, i13, 15) | 0;
    19657. 

  19657.     if ((HEAP32[i15 + 8 >> 2] | 0) == 0) {
    19658. 

  19658.      i1 = 10;
    19659. 

  19659.      break;
    19660. 

  19660.     }
    19661. 

  19661.    }
    19662. 

  19662.    i18 = i14 - (HEAP32[i3 >> 2] | 0) | 0;
    19663. 

  19663.    i16 = HEAP32[i6 >> 2] | 0;
    19664. 

  19664.    HEAP32[i6 >> 2] = i16 + 16;
    19665. 

  19665.    i20 = i15;
    19666. 

  19666.    i19 = HEAP32[i20 + 4 >> 2] | 0;
    19667. 

  19667.    i17 = i16;
    19668. 

  19668.    HEAP32[i17 >> 2] = HEAP32[i20 >> 2];
    19669. 

  19669.    HEAP32[i17 + 4 >> 2] = i19;
    19670. 

  19670.    HEAP32[i16 + 8 >> 2] = HEAP32[i15 + 8 >> 2];
    19671. 

  19671.    i15 = HEAP32[i6 >> 2] | 0;
    19672. 

  19672.    HEAP32[i6 >> 2] = i15 + 16;
    19673. 

  19673.    i16 = i14;
    19674. 

  19674.    i17 = HEAP32[i16 + 4 >> 2] | 0;
    19675. 

  19675.    i14 = i15;
    19676. 

  19676.    HEAP32[i14 >> 2] = HEAP32[i16 >> 2];
    19677. 

  19677.    HEAP32[i14 + 4 >> 2] = i17;
    19678. 

  19678.    HEAP32[i15 + 8 >> 2] = HEAP32[i12 >> 2];
    19679. 

  19679.    i12 = HEAP32[i6 >> 2] | 0;
    19680. 

  19680.    HEAP32[i6 >> 2] = i12 + 16;
    19681. 

  19681.    i15 = i13;
    19682. 

  19682.    i14 = HEAP32[i15 + 4 >> 2] | 0;
    19683. 

  19683.    i17 = i12;
    19684. 

  19684.    HEAP32[i17 >> 2] = HEAP32[i15 >> 2];
    19685. 

  19685.    HEAP32[i17 + 4 >> 2] = i14;
    19686. 

  19686.    HEAP32[i12 + 8 >> 2] = HEAP32[i11 + -8 >> 2];
    19687. 

  19687.    _luaD_call(i7, (HEAP32[i6 >> 2] | 0) + -48 | 0, 1, HEAP8[(HEAP32[i4 >> 2] | 0) + 18 | 0] & 1);
    19688. 

  19688.    i12 = HEAP32[i3 >> 2] | 0;
    19689. 

  19689.    i17 = HEAP32[i6 >> 2] | 0;
    19690. 

  19690.    i14 = i17 + -16 | 0;
    19691. 

  19691.    HEAP32[i6 >> 2] = i14;
    19692. 

  19692.    i15 = HEAP32[i14 + 4 >> 2] | 0;
    19693. 

  19693.    i16 = i12 + i18 | 0;
    19694. 

  19694.    HEAP32[i16 >> 2] = HEAP32[i14 >> 2];
    19695. 

  19695.    HEAP32[i16 + 4 >> 2] = i15;
    19696. 

  19696.    HEAP32[i12 + (i18 + 8) >> 2] = HEAP32[i17 + -8 >> 2];
    19697. 

  19697.    i12 = 2;
    19698. 

  19698.   }
    19699. 

  19699.   i10 = i10 + 1 - i12 | 0;
    19700. 

  19700.   i11 = (HEAP32[i6 >> 2] | 0) + (1 - i12 << 4) | 0;
    19701. 

  19701.   HEAP32[i6 >> 2] = i11;
    19702. 

  19702.   if ((i10 | 0) <= 1) {
    19703. 

  19703.    i1 = 30;
    19704. 

  19704.    break;
    19705. 

  19705.   }
    19706. 

  19706.  }
    19707. 

  19707.  if ((i1 | 0) == 10) {
    19708. 

  19708.   _luaG_concaterror(i7, i14, i13);
    19709. 

  19709.  } else if ((i1 | 0) == 24) {
    19710. 

  19710.   _luaG_runerror(i7, 9e3, i9);
    19711. 

  19711.  } else if ((i1 | 0) == 30) {
    19712. 

  19712.   STACKTOP = i5;
    19713. 

  19713.   return;
    19714. 

  19714.  }
    19715. 

  19715. }
    19716. 

  19716. function _str_gsub(i1) {
    19717. 

  19717.  i1 = i1 | 0;
    19718. 

  19718.  var i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0, i14 = 0, i15 = 0, i16 = 0, i17 = 0, i18 = 0, i19 = 0, i20 = 0, i21 = 0, i22 = 0, i23 = 0, i24 = 0, i25 = 0, i26 = 0, i27 = 0, i28 = 0;
    19719. 

  19719.  i3 = STACKTOP;
    19720. 

  19720.  STACKTOP = STACKTOP + 1344 | 0;
    19721. 

  19721.  i4 = i3;
    19722. 

  19722.  i5 = i3 + 1336 | 0;
    19723. 

  19723.  i14 = i3 + 1332 | 0;
    19724. 

  19724.  i10 = i3 + 1328 | 0;
    19725. 

  19725.  i6 = i3 + 1048 | 0;
    19726. 

  19726.  i2 = i3 + 8 | 0;
    19727. 

  19727.  i20 = _luaL_checklstring(i1, 1, i14) | 0;
    19728. 

  19728.  i13 = _luaL_checklstring(i1, 2, i10) | 0;
    19729. 

  19729.  i8 = _lua_type(i1, 3) | 0;
    19730. 

  19730.  i9 = _luaL_optinteger(i1, 4, (HEAP32[i14 >> 2] | 0) + 1 | 0) | 0;
    19731. 

  19731.  i7 = (HEAP8[i13] | 0) == 94;
    19732. 

  19732.  if (!((i8 + -3 | 0) >>> 0 < 2 | (i8 | 0) == 6 | (i8 | 0) == 5)) {
    19733. 

  19733.   _luaL_argerror(i1, 3, 7528) | 0;
    19734. 

  19734.  }
    19735. 

  19735.  _luaL_buffinit(i1, i2);
    19736. 

  19736.  if (i7) {
    19737. 

  19737.   i15 = (HEAP32[i10 >> 2] | 0) + -1 | 0;
    19738. 

  19738.   HEAP32[i10 >> 2] = i15;
    19739. 

  19739.   i13 = i13 + 1 | 0;
    19740. 

  19740.  } else {
    19741. 

  19741.   i15 = HEAP32[i10 >> 2] | 0;
    19742. 

  19742.  }
    19743. 

  19743.  i11 = i6 + 16 | 0;
    19744. 

  19744.  HEAP32[i11 >> 2] = i1;
    19745. 

  19745.  HEAP32[i6 >> 2] = 200;
    19746. 

  19746.  i12 = i6 + 4 | 0;
    19747. 

  19747.  HEAP32[i12 >> 2] = i20;
    19748. 

  19748.  i10 = i6 + 8 | 0;
    19749. 

  19749.  HEAP32[i10 >> 2] = i20 + (HEAP32[i14 >> 2] | 0);
    19750. 

  19750.  HEAP32[i6 + 12 >> 2] = i13 + i15;
    19751. 

  19751.  i14 = i6 + 20 | 0;
    19752. 

  19752.  i15 = i2 + 8 | 0;
    19753. 

  19753.  i18 = i2 + 4 | 0;
    19754. 

  19754.  i16 = i6 + 28 | 0;
    19755. 

  19755.  i17 = i6 + 24 | 0;
    19756. 

  19756.  i22 = 0;
    19757. 

  19757.  while (1) {
    19758. 

  19758.   if (!(i22 >>> 0 < i9 >>> 0)) {
    19759. 

  19759.    i19 = 48;
    19760. 

  19760.    break;
    19761. 

  19761.   }
    19762. 

  19762.   HEAP32[i14 >> 2] = 0;
    19763. 

  19763.   i21 = _match(i6, i20, i13) | 0;
    19764. 

  19764.   if ((i21 | 0) != 0) {
    19765. 

  19765.    i22 = i22 + 1 | 0;
    19766. 

  19766.    i23 = HEAP32[i11 >> 2] | 0;
    19767. 

  19767.    if ((i8 | 0) == 5) {
    19768. 

  19768.     do {
    19769. 

  19769.      if ((HEAP32[i14 >> 2] | 0) > 0) {
    19770. 

  19770.       i24 = HEAP32[i16 >> 2] | 0;
    19771. 

  19771.       if (!((i24 | 0) == -1)) {
    19772. 

  19772.        i25 = HEAP32[i17 >> 2] | 0;
    19773. 

  19773.        if ((i24 | 0) == -2) {
    19774. 

  19774.         _lua_pushinteger(i23, i25 + 1 - (HEAP32[i12 >> 2] | 0) | 0);
    19775. 

  19775.         break;
    19776. 

  19776.        } else {
    19777. 

  19777.         i19 = i23;
    19778. 

  19778.        }
    19779. 

  19779.       } else {
    19780. 

  19780.        _luaL_error(i23, 7248, i4) | 0;
    19781. 

  19781.        i19 = HEAP32[i11 >> 2] | 0;
    19782. 

  19782.        i25 = HEAP32[i17 >> 2] | 0;
    19783. 

  19783.       }
    19784. 

  19784.       _lua_pushlstring(i19, i25, i24) | 0;
    19785. 

  19785.      } else {
    19786. 

  19786.       _lua_pushlstring(i23, i20, i21 - i20 | 0) | 0;
    19787. 

  19787.      }
    19788. 

  19788.     } while (0);
    19789. 

  19789.     _lua_gettable(i23, 3);
    19790. 

  19790.     i19 = 37;
    19791. 

  19791.    } else if ((i8 | 0) != 6) {
    19792. 

  19792.     i24 = _lua_tolstring(i23, 3, i5) | 0;
    19793. 

  19793.     if ((HEAP32[i5 >> 2] | 0) != 0) {
    19794. 

  19794.      i23 = i21 - i20 | 0;
    19795. 

  19795.      i25 = 0;
    19796. 

  19796.      do {
    19797. 

  19797.       i26 = i24 + i25 | 0;
    19798. 

  19798.       i27 = HEAP8[i26] | 0;
    19799. 

  19799.       do {
    19800. 

  19800.        if (i27 << 24 >> 24 == 37) {
    19801. 

  19801.         i25 = i25 + 1 | 0;
    19802. 

  19802.         i26 = i24 + i25 | 0;
    19803. 

  19803.         i28 = HEAP8[i26] | 0;
    19804. 

  19804.         i27 = i28 << 24 >> 24;
    19805. 

  19805.         if (((i28 & 255) + -48 | 0) >>> 0 < 10) {
    19806. 

  19806.          if (i28 << 24 >> 24 == 48) {
    19807. 

  19807.           _luaL_addlstring(i2, i20, i23);
    19808. 

  19808.           break;
    19809. 

  19809.          } else {
    19810. 

  19810.           _push_onecapture(i6, i27 + -49 | 0, i20, i21);
    19811. 

  19811.           _luaL_addvalue(i2);
    19812. 

  19812.           break;
    19813. 

  19813.          }
    19814. 

  19814.         }
    19815. 

  19815.         if (!(i28 << 24 >> 24 == 37)) {
    19816. 

  19816.          i28 = HEAP32[i11 >> 2] | 0;
    19817. 

  19817.          HEAP32[i4 >> 2] = 37;
    19818. 

  19818.          _luaL_error(i28, 7600, i4) | 0;
    19819. 

  19819.         }
    19820. 

  19820.         i27 = HEAP32[i15 >> 2] | 0;
    19821. 

  19821.         if (!(i27 >>> 0 < (HEAP32[i18 >> 2] | 0) >>> 0)) {
    19822. 

  19822.          _luaL_prepbuffsize(i2, 1) | 0;
    19823. 

  19823.          i27 = HEAP32[i15 >> 2] | 0;
    19824. 

  19824.         }
    19825. 

  19825.         i28 = HEAP8[i26] | 0;
    19826. 

  19826.         HEAP32[i15 >> 2] = i27 + 1;
    19827. 

  19827.         HEAP8[(HEAP32[i2 >> 2] | 0) + i27 | 0] = i28;
    19828. 

  19828.        } else {
    19829. 

  19829.         i28 = HEAP32[i15 >> 2] | 0;
    19830. 

  19830.         if (!(i28 >>> 0 < (HEAP32[i18 >> 2] | 0) >>> 0)) {
    19831. 

  19831.          _luaL_prepbuffsize(i2, 1) | 0;
    19832. 

  19832.          i28 = HEAP32[i15 >> 2] | 0;
    19833. 

  19833.          i27 = HEAP8[i26] | 0;
    19834. 

  19834.         }
    19835. 

  19835.         HEAP32[i15 >> 2] = i28 + 1;
    19836. 

  19836.         HEAP8[(HEAP32[i2 >> 2] | 0) + i28 | 0] = i27;
    19837. 

  19837.        }
    19838. 

  19838.       } while (0);
    19839. 

  19839.       i25 = i25 + 1 | 0;
    19840. 

  19840.      } while (i25 >>> 0 < (HEAP32[i5 >> 2] | 0) >>> 0);
    19841. 

  19841.     }
    19842. 

  19842.    } else {
    19843. 

  19843.     _lua_pushvalue(i23, 3);
    19844. 

  19844.     i19 = HEAP32[i14 >> 2] | 0;
    19845. 

  19845.     i19 = (i19 | 0) != 0 | (i20 | 0) == 0 ? i19 : 1;
    19846. 

  19846.     _luaL_checkstack(HEAP32[i11 >> 2] | 0, i19, 7200);
    19847. 

  19847.     if ((i19 | 0) > 0) {
    19848. 

  19848.      i24 = 0;
    19849. 

  19849.      do {
    19850. 

  19850.       _push_onecapture(i6, i24, i20, i21);
    19851. 

  19851.       i24 = i24 + 1 | 0;
    19852. 

  19852.      } while ((i24 | 0) != (i19 | 0));
    19853. 

  19853.     }
    19854. 

  19854.     _lua_callk(i23, i19, 1, 0, 0);
    19855. 

  19855.     i19 = 37;
    19856. 

  19856.    }
    19857. 

  19857.    if ((i19 | 0) == 37) {
    19858. 

  19858.     i19 = 0;
    19859. 

  19859.     if ((_lua_toboolean(i23, -1) | 0) != 0) {
    19860. 

  19860.      if ((_lua_isstring(i23, -1) | 0) == 0) {
    19861. 

  19861.       HEAP32[i4 >> 2] = _lua_typename(i23, _lua_type(i23, -1) | 0) | 0;
    19862. 

  19862.       _luaL_error(i23, 7560, i4) | 0;
    19863. 

  19863.      }
    19864. 

  19864.     } else {
    19865. 

  19865.      _lua_settop(i23, -2);
    19866. 

  19866.      _lua_pushlstring(i23, i20, i21 - i20 | 0) | 0;
    19867. 

  19867.     }
    19868. 

  19868.     _luaL_addvalue(i2);
    19869. 

  19869.    }
    19870. 

  19870.    if (i21 >>> 0 > i20 >>> 0) {
    19871. 

  19871.     i20 = i21;
    19872. 

  19872.    } else {
    19873. 

  19873.     i19 = 43;
    19874. 

  19874.    }
    19875. 

  19875.   } else {
    19876. 

  19876.    i19 = 43;
    19877. 

  19877.   }
    19878. 

  19878.   if ((i19 | 0) == 43) {
    19879. 

  19879.    i19 = 0;
    19880. 

  19880.    if (!(i20 >>> 0 < (HEAP32[i10 >> 2] | 0) >>> 0)) {
    19881. 

  19881.     i19 = 48;
    19882. 

  19882.     break;
    19883. 

  19883.    }
    19884. 

  19884.    i21 = HEAP32[i15 >> 2] | 0;
    19885. 

  19885.    if (!(i21 >>> 0 < (HEAP32[i18 >> 2] | 0) >>> 0)) {
    19886. 

  19886.     _luaL_prepbuffsize(i2, 1) | 0;
    19887. 

  19887.     i21 = HEAP32[i15 >> 2] | 0;
    19888. 

  19888.    }
    19889. 

  19889.    i28 = HEAP8[i20] | 0;
    19890. 

  19890.    HEAP32[i15 >> 2] = i21 + 1;
    19891. 

  19891.    HEAP8[(HEAP32[i2 >> 2] | 0) + i21 | 0] = i28;
    19892. 

  19892.    i20 = i20 + 1 | 0;
    19893. 

  19893.   }
    19894. 

  19894.   if (i7) {
    19895. 

  19895.    i19 = 48;
    19896. 

  19896.    break;
    19897. 

  19897.   }
    19898. 

  19898.  }
    19899. 

  19899.  if ((i19 | 0) == 48) {
    19900. 

  19900.   _luaL_addlstring(i2, i20, (HEAP32[i10 >> 2] | 0) - i20 | 0);
    19901. 

  19901.   _luaL_pushresult(i2);
    19902. 

  19902.   _lua_pushinteger(i1, i22);
    19903. 

  19903.   STACKTOP = i3;
    19904. 

  19904.   return 2;
    19905. 

  19905.  }
    19906. 

  19906.  return 0;
    19907. 

  19907. }
    19908. 

  19908. function _constructor(i11, i13) {
    19909. 

  19909.  i11 = i11 | 0;
    19910. 

  19910.  i13 = i13 | 0;
    19911. 

  19911.  var i1 = 0, i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i12 = 0, i14 = 0, i15 = 0, i16 = 0;
    19912. 

  19912.  i5 = STACKTOP;
    19913. 

  19913.  STACKTOP = STACKTOP + 64 | 0;
    19914. 

  19914.  i10 = i5 + 40 | 0;
    19915. 

  19915.  i8 = i5;
    19916. 

  19916.  i12 = i11 + 48 | 0;
    19917. 

  19917.  i6 = HEAP32[i12 >> 2] | 0;
    19918. 

  19918.  i9 = HEAP32[i11 + 4 >> 2] | 0;
    19919. 

  19919.  i2 = _luaK_codeABC(i6, 11, 0, 0, 0) | 0;
    19920. 

  19920.  i7 = i8 + 36 | 0;
    19921. 

  19921.  HEAP32[i7 >> 2] = 0;
    19922. 

  19922.  i4 = i8 + 28 | 0;
    19923. 

  19923.  HEAP32[i4 >> 2] = 0;
    19924. 

  19924.  i3 = i8 + 32 | 0;
    19925. 

  19925.  HEAP32[i3 >> 2] = 0;
    19926. 

  19926.  i1 = i8 + 24 | 0;
    19927. 

  19927.  HEAP32[i1 >> 2] = i13;
    19928. 

  19928.  HEAP32[i13 + 16 >> 2] = -1;
    19929. 

  19929.  HEAP32[i13 + 20 >> 2] = -1;
    19930. 

  19930.  HEAP32[i13 >> 2] = 11;
    19931. 

  19931.  HEAP32[i13 + 8 >> 2] = i2;
    19932. 

  19932.  HEAP32[i8 + 16 >> 2] = -1;
    19933. 

  19933.  HEAP32[i8 + 20 >> 2] = -1;
    19934. 

  19934.  HEAP32[i8 >> 2] = 0;
    19935. 

  19935.  HEAP32[i8 + 8 >> 2] = 0;
    19936. 

  19936.  _luaK_exp2nextreg(HEAP32[i12 >> 2] | 0, i13);
    19937. 

  19937.  i13 = i11 + 16 | 0;
    19938. 

  19938.  if ((HEAP32[i13 >> 2] | 0) != 123) {
    19939. 

  19939.   _error_expected(i11, 123);
    19940. 

  19940.  }
    19941. 

  19941.  _luaX_next(i11);
    19942. 

  19942.  L4 : do {
    19943. 

  19943.   if ((HEAP32[i13 >> 2] | 0) != 125) {
    19944. 

  19944.    L5 : while (1) {
    19945. 

  19945.     if ((HEAP32[i8 >> 2] | 0) != 0 ? (_luaK_exp2nextreg(i6, i8), HEAP32[i8 >> 2] = 0, (HEAP32[i7 >> 2] | 0) == 50) : 0) {
    19946. 

  19946.      _luaK_setlist(i6, HEAP32[(HEAP32[i1 >> 2] | 0) + 8 >> 2] | 0, HEAP32[i3 >> 2] | 0, 50);
    19947. 

  19947.      HEAP32[i7 >> 2] = 0;
    19948. 

  19948.     }
    19949. 

  19949.     i14 = HEAP32[i13 >> 2] | 0;
    19950. 

  19950.     do {
    19951. 

  19951.      if ((i14 | 0) == 288) {
    19952. 

  19952.       if ((_luaX_lookahead(i11) | 0) == 61) {
    19953. 

  19953.        _recfield(i11, i8);
    19954. 

  19954.        break;
    19955. 

  19955.       }
    19956. 

  19956.       _subexpr(i11, i8, 0) | 0;
    19957. 

  19957.       i14 = HEAP32[i12 >> 2] | 0;
    19958. 

  19958.       i15 = HEAP32[i3 >> 2] | 0;
    19959. 

  19959.       if ((i15 | 0) > 2147483645) {
    19960. 

  19960.        i12 = 10;
    19961. 

  19961.        break L5;
    19962. 

  19962.       }
    19963. 

  19963.       HEAP32[i3 >> 2] = i15 + 1;
    19964. 

  19964.       HEAP32[i7 >> 2] = (HEAP32[i7 >> 2] | 0) + 1;
    19965. 

  19965.      } else if ((i14 | 0) == 91) {
    19966. 

  19966.       _recfield(i11, i8);
    19967. 

  19967.      } else {
    19968. 

  19968.       _subexpr(i11, i8, 0) | 0;
    19969. 

  19969.       i14 = HEAP32[i12 >> 2] | 0;
    19970. 

  19970.       i15 = HEAP32[i3 >> 2] | 0;
    19971. 

  19971.       if ((i15 | 0) > 2147483645) {
    19972. 

  19972.        i12 = 17;
    19973. 

  19973.        break L5;
    19974. 

  19974.       }
    19975. 

  19975.       HEAP32[i3 >> 2] = i15 + 1;
    19976. 

  19976.       HEAP32[i7 >> 2] = (HEAP32[i7 >> 2] | 0) + 1;
    19977. 

  19977.      }
    19978. 

  19978.     } while (0);
    19979. 

  19979.     i14 = HEAP32[i13 >> 2] | 0;
    19980. 

  19980.     if ((i14 | 0) == 44) {
    19981. 

  19981.      _luaX_next(i11);
    19982. 

  19982.     } else if ((i14 | 0) == 59) {
    19983. 

  19983.      _luaX_next(i11);
    19984. 

  19984.     } else {
    19985. 

  19985.      break L4;
    19986. 

  19986.     }
    19987. 

  19987.     if ((HEAP32[i13 >> 2] | 0) == 125) {
    19988. 

  19988.      break L4;
    19989. 

  19989.     }
    19990. 

  19990.    }
    19991. 

  19991.    if ((i12 | 0) == 10) {
    19992. 

  19992.     i12 = i14 + 12 | 0;
    19993. 

  19993.     i13 = HEAP32[(HEAP32[i12 >> 2] | 0) + 52 >> 2] | 0;
    19994. 

  19994.     i14 = HEAP32[(HEAP32[i14 >> 2] | 0) + 64 >> 2] | 0;
    19995. 

  19995.     if ((i14 | 0) == 0) {
    19996. 

  19996.      i16 = 6552;
    19997. 

  19997.      HEAP32[i10 >> 2] = 6528;
    19998. 

  19998.      i15 = i10 + 4 | 0;
    19999. 

  19999.      HEAP32[i15 >> 2] = 2147483645;
    20000. 

  20000.      i15 = i10 + 8 | 0;
    20001. 

  20001.      HEAP32[i15 >> 2] = i16;
    20002. 

  20002.      i15 = _luaO_pushfstring(i13, 6592, i10) | 0;
    20003. 

  20003.      i16 = HEAP32[i12 >> 2] | 0;
    20004. 

  20004.      _luaX_syntaxerror(i16, i15);
    20005. 

  20005.     }
    20006. 

  20006.     HEAP32[i10 >> 2] = i14;
    20007. 

  20007.     i15 = _luaO_pushfstring(i13, 6568, i10) | 0;
    20008. 

  20008.     HEAP32[i10 >> 2] = 6528;
    20009. 

  20009.     i16 = i10 + 4 | 0;
    20010. 

  20010.     HEAP32[i16 >> 2] = 2147483645;
    20011. 

  20011.     i16 = i10 + 8 | 0;
    20012. 

  20012.     HEAP32[i16 >> 2] = i15;
    20013. 

  20013.     i16 = _luaO_pushfstring(i13, 6592, i10) | 0;
    20014. 

  20014.     i15 = HEAP32[i12 >> 2] | 0;
    20015. 

  20015.     _luaX_syntaxerror(i15, i16);
    20016. 

  20016.    } else if ((i12 | 0) == 17) {
    20017. 

  20017.     i13 = i14 + 12 | 0;
    20018. 

  20018.     i12 = HEAP32[(HEAP32[i13 >> 2] | 0) + 52 >> 2] | 0;
    20019. 

  20019.     i14 = HEAP32[(HEAP32[i14 >> 2] | 0) + 64 >> 2] | 0;
    20020. 

  20020.     if ((i14 | 0) == 0) {
    20021. 

  20021.      i15 = 6552;
    20022. 

  20022.      HEAP32[i10 >> 2] = 6528;
    20023. 

  20023.      i16 = i10 + 4 | 0;
    20024. 

  20024.      HEAP32[i16 >> 2] = 2147483645;
    20025. 

  20025.      i16 = i10 + 8 | 0;
    20026. 

  20026.      HEAP32[i16 >> 2] = i15;
    20027. 

  20027.      i16 = _luaO_pushfstring(i12, 6592, i10) | 0;
    20028. 

  20028.      i15 = HEAP32[i13 >> 2] | 0;
    20029. 

  20029.      _luaX_syntaxerror(i15, i16);
    20030. 

  20030.     }
    20031. 

  20031.     HEAP32[i10 >> 2] = i14;
    20032. 

  20032.     i15 = _luaO_pushfstring(i12, 6568, i10) | 0;
    20033. 

  20033.     HEAP32[i10 >> 2] = 6528;
    20034. 

  20034.     i16 = i10 + 4 | 0;
    20035. 

  20035.     HEAP32[i16 >> 2] = 2147483645;
    20036. 

  20036.     i16 = i10 + 8 | 0;
    20037. 

  20037.     HEAP32[i16 >> 2] = i15;
    20038. 

  20038.     i16 = _luaO_pushfstring(i12, 6592, i10) | 0;
    20039. 

  20039.     i15 = HEAP32[i13 >> 2] | 0;
    20040. 

  20040.     _luaX_syntaxerror(i15, i16);
    20041. 

  20041.    }
    20042. 

  20042.   }
    20043. 

  20043.  } while (0);
    20044. 

  20044.  _check_match(i11, 125, 123, i9);
    20045. 

  20045.  i9 = HEAP32[i7 >> 2] | 0;
    20046. 

  20046.  do {
    20047. 

  20047.   if ((i9 | 0) != 0) {
    20048. 

  20048.    i10 = HEAP32[i8 >> 2] | 0;
    20049. 

  20049.    if ((i10 | 0) != 0) if ((i10 | 0) == 13 | (i10 | 0) == 12) {
    20050. 

  20050.     _luaK_setreturns(i6, i8, -1);
    20051. 

  20051.     _luaK_setlist(i6, HEAP32[(HEAP32[i1 >> 2] | 0) + 8 >> 2] | 0, HEAP32[i3 >> 2] | 0, -1);
    20052. 

  20052.     HEAP32[i3 >> 2] = (HEAP32[i3 >> 2] | 0) + -1;
    20053. 

  20053.     break;
    20054. 

  20054.    } else {
    20055. 

  20055.     _luaK_exp2nextreg(i6, i8);
    20056. 

  20056.     i9 = HEAP32[i7 >> 2] | 0;
    20057. 

  20057.    }
    20058. 

  20058.    _luaK_setlist(i6, HEAP32[(HEAP32[i1 >> 2] | 0) + 8 >> 2] | 0, HEAP32[i3 >> 2] | 0, i9);
    20059. 

  20059.   }
    20060. 

  20060.  } while (0);
    20061. 

  20061.  i16 = HEAP32[(HEAP32[(HEAP32[i6 >> 2] | 0) + 12 >> 2] | 0) + (i2 << 2) >> 2] & 8388607;
    20062. 

  20062.  i16 = (_luaO_int2fb(HEAP32[i3 >> 2] | 0) | 0) << 23 | i16;
    20063. 

  20063.  HEAP32[(HEAP32[(HEAP32[i6 >> 2] | 0) + 12 >> 2] | 0) + (i2 << 2) >> 2] = i16;
    20064. 

  20064.  i16 = (_luaO_int2fb(HEAP32[i4 >> 2] | 0) | 0) << 14 & 8372224 | i16 & -8372225;
    20065. 

  20065.  HEAP32[(HEAP32[(HEAP32[i6 >> 2] | 0) + 12 >> 2] | 0) + (i2 << 2) >> 2] = i16;
    20066. 

  20066.  STACKTOP = i5;
    20067. 

  20067.  return;
    20068. 

  20068. }
    20069. 

  20069. function _luaK_prefix(i4, i14, i7, i13) {
    20070. 

  20070.  i4 = i4 | 0;
    20071. 

  20071.  i14 = i14 | 0;
    20072. 

  20072.  i7 = i7 | 0;
    20073. 

  20073.  i13 = i13 | 0;
    20074. 

  20074.  var i1 = 0, i2 = 0, i3 = 0, i5 = 0, i6 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0;
    20075. 

  20075.  i1 = STACKTOP;
    20076. 

  20076.  STACKTOP = STACKTOP + 32 | 0;
    20077. 

  20077.  i12 = i1;
    20078. 

  20078.  HEAP32[i12 + 20 >> 2] = -1;
    20079. 

  20079.  HEAP32[i12 + 16 >> 2] = -1;
    20080. 

  20080.  HEAP32[i12 >> 2] = 5;
    20081. 

  20081.  HEAPF64[i12 + 8 >> 3] = 0.0;
    20082. 

  20082.  if ((i14 | 0) == 1) {
    20083. 

  20083.   _luaK_dischargevars(i4, i7);
    20084. 

  20084.   switch (HEAP32[i7 >> 2] | 0) {
    20085. 

  20085.   case 2:
    20086. 

  20086.   case 5:
    20087. 

  20087.   case 4:
    20088. 

  20088.    {
    20089. 

  20089.     HEAP32[i7 >> 2] = 3;
    20090. 

  20090.     break;
    20091. 

  20091.    }
    20092. 

  20092.   case 10:
    20093. 

  20093.    {
    20094. 

  20094.     i13 = HEAP32[(HEAP32[i4 >> 2] | 0) + 12 >> 2] | 0;
    20095. 

  20095.     i12 = HEAP32[i7 + 8 >> 2] | 0;
    20096. 

  20096.     i10 = i13 + (i12 << 2) | 0;
    20097. 

  20097.     if (!((i12 | 0) > 0 ? (i11 = i13 + (i12 + -1 << 2) | 0, i9 = HEAP32[i11 >> 2] | 0, (HEAP8[5584 + (i9 & 63) | 0] | 0) < 0) : 0)) {
    20098. 

  20098.      i11 = i10;
    20099. 

  20099.      i9 = HEAP32[i10 >> 2] | 0;
    20100. 

  20100.     }
    20101. 

  20101.     HEAP32[i11 >> 2] = ((i9 & 16320 | 0) == 0) << 6 | i9 & -16321;
    20102. 

  20102.     break;
    20103. 

  20103.    }
    20104. 

  20104.   case 6:
    20105. 

  20105.    {
    20106. 

  20106.     i8 = 25;
    20107. 

  20107.     break;
    20108. 

  20108.    }
    20109. 

  20109.   case 3:
    20110. 

  20110.   case 1:
    20111. 

  20111.    {
    20112. 

  20112.     HEAP32[i7 >> 2] = 2;
    20113. 

  20113.     break;
    20114. 

  20114.    }
    20115. 

  20115.   case 11:
    20116. 

  20116.    {
    20117. 

  20117.     i12 = i4 + 48 | 0;
    20118. 

  20118.     i8 = HEAP8[i12] | 0;
    20119. 

  20119.     i11 = (i8 & 255) + 1 | 0;
    20120. 

  20120.     i9 = (HEAP32[i4 >> 2] | 0) + 78 | 0;
    20121. 

  20121.     do {
    20122. 

  20122.      if (i11 >>> 0 > (HEAPU8[i9] | 0) >>> 0) {
    20123. 

  20123.       if (i11 >>> 0 > 249) {
    20124. 

  20124.        _luaX_syntaxerror(HEAP32[i4 + 12 >> 2] | 0, 10536);
    20125. 

  20125.       } else {
    20126. 

  20126.        HEAP8[i9] = i11;
    20127. 

  20127.        i10 = HEAP8[i12] | 0;
    20128. 

  20128.        break;
    20129. 

  20129.       }
    20130. 

  20130.      } else {
    20131. 

  20131.       i10 = i8;
    20132. 

  20132.      }
    20133. 

  20133.     } while (0);
    20134. 

  20134.     i14 = (i10 & 255) + 1 | 0;
    20135. 

  20135.     HEAP8[i12] = i14;
    20136. 

  20136.     _discharge2reg(i4, i7, (i14 & 255) + -1 | 0);
    20137. 

  20137.     if ((HEAP32[i7 >> 2] | 0) == 6) {
    20138. 

  20138.      i8 = 25;
    20139. 

  20139.     } else {
    20140. 

  20140.      i9 = i7 + 8 | 0;
    20141. 

  20141.      i8 = 28;
    20142. 

  20142.     }
    20143. 

  20143.     break;
    20144. 

  20144.    }
    20145. 

  20145.   default:
    20146. 

  20146.    {}
    20147. 

  20147.   }
    20148. 

  20148.   if ((i8 | 0) == 25) {
    20149. 

  20149.    i8 = i7 + 8 | 0;
    20150. 

  20150.    i9 = HEAP32[i8 >> 2] | 0;
    20151. 

  20151.    if ((i9 & 256 | 0) == 0 ? (HEAPU8[i4 + 46 | 0] | 0) <= (i9 | 0) : 0) {
    20152. 

  20152.     i9 = i4 + 48 | 0;
    20153. 

  20153.     HEAP8[i9] = (HEAP8[i9] | 0) + -1 << 24 >> 24;
    20154. 

  20154.     i9 = i8;
    20155. 

  20155.     i8 = 28;
    20156. 

  20156.    } else {
    20157. 

  20157.     i9 = i8;
    20158. 

  20158.     i8 = 28;
    20159. 

  20159.    }
    20160. 

  20160.   }
    20161. 

  20161.   if ((i8 | 0) == 28) {
    20162. 

  20162.    HEAP32[i9 >> 2] = _luaK_code(i4, HEAP32[i9 >> 2] << 23 | 20) | 0;
    20163. 

  20163.    HEAP32[i7 >> 2] = 11;
    20164. 

  20164.   }
    20165. 

  20165.   i14 = i7 + 20 | 0;
    20166. 

  20166.   i8 = HEAP32[i14 >> 2] | 0;
    20167. 

  20167.   i7 = i7 + 16 | 0;
    20168. 

  20168.   i9 = HEAP32[i7 >> 2] | 0;
    20169. 

  20169.   HEAP32[i14 >> 2] = i9;
    20170. 

  20170.   HEAP32[i7 >> 2] = i8;
    20171. 

  20171.   if (!((i9 | 0) == -1)) {
    20172. 

  20172.    i8 = HEAP32[(HEAP32[i4 >> 2] | 0) + 12 >> 2] | 0;
    20173. 

  20173.    do {
    20174. 

  20174.     i12 = i8 + (i9 << 2) | 0;
    20175. 

  20175.     if ((i9 | 0) > 0 ? (i5 = i8 + (i9 + -1 << 2) | 0, i6 = HEAP32[i5 >> 2] | 0, (HEAP8[5584 + (i6 & 63) | 0] | 0) < 0) : 0) {
    20176. 

  20176.      i10 = i5;
    20177. 

  20177.      i11 = i6;
    20178. 

  20178.     } else {
    20179. 

  20179.      i10 = i12;
    20180. 

  20180.      i11 = HEAP32[i12 >> 2] | 0;
    20181. 

  20181.     }
    20182. 

  20182.     if ((i11 & 63 | 0) == 28) {
    20183. 

  20183.      HEAP32[i10 >> 2] = i11 & 8372224 | i11 >>> 23 << 6 | 27;
    20184. 

  20184.     }
    20185. 

  20185.     i10 = ((HEAP32[i12 >> 2] | 0) >>> 14) + -131071 | 0;
    20186. 

  20186.     if ((i10 | 0) == -1) {
    20187. 

  20187.      break;
    20188. 

  20188.     }
    20189. 

  20189.     i9 = i9 + 1 + i10 | 0;
    20190. 

  20190.    } while (!((i9 | 0) == -1));
    20191. 

  20191.    i8 = HEAP32[i7 >> 2] | 0;
    20192. 

  20192.   }
    20193. 

  20193.   if ((i8 | 0) == -1) {
    20194. 

  20194.    STACKTOP = i1;
    20195. 

  20195.    return;
    20196. 

  20196.   }
    20197. 

  20197.   i4 = HEAP32[(HEAP32[i4 >> 2] | 0) + 12 >> 2] | 0;
    20198. 

  20198.   while (1) {
    20199. 

  20199.    i6 = i4 + (i8 << 2) | 0;
    20200. 

  20200.    if ((i8 | 0) > 0 ? (i2 = i4 + (i8 + -1 << 2) | 0, i3 = HEAP32[i2 >> 2] | 0, (HEAP8[5584 + (i3 & 63) | 0] | 0) < 0) : 0) {
    20201. 

  20201.     i7 = i2;
    20202. 

  20202.     i5 = i3;
    20203. 

  20203.    } else {
    20204. 

  20204.     i7 = i6;
    20205. 

  20205.     i5 = HEAP32[i6 >> 2] | 0;
    20206. 

  20206.    }
    20207. 

  20207.    if ((i5 & 63 | 0) == 28) {
    20208. 

  20208.     HEAP32[i7 >> 2] = i5 & 8372224 | i5 >>> 23 << 6 | 27;
    20209. 

  20209.    }
    20210. 

  20210.    i5 = ((HEAP32[i6 >> 2] | 0) >>> 14) + -131071 | 0;
    20211. 

  20211.    if ((i5 | 0) == -1) {
    20212. 

  20212.     i8 = 54;
    20213. 

  20213.     break;
    20214. 

  20214.    }
    20215. 

  20215.    i8 = i8 + 1 + i5 | 0;
    20216. 

  20216.    if ((i8 | 0) == -1) {
    20217. 

  20217.     i8 = 54;
    20218. 

  20218.     break;
    20219. 

  20219.    }
    20220. 

  20220.   }
    20221. 

  20221.   if ((i8 | 0) == 54) {
    20222. 

  20222.    STACKTOP = i1;
    20223. 

  20223.    return;
    20224. 

  20224.   }
    20225. 

  20225.  } else if ((i14 | 0) == 0) {
    20226. 

  20226.   if (((HEAP32[i7 >> 2] | 0) == 5 ? (HEAP32[i7 + 16 >> 2] | 0) == -1 : 0) ? (HEAP32[i7 + 20 >> 2] | 0) == -1 : 0) {
    20227. 

  20227.    i14 = i7 + 8 | 0;
    20228. 

  20228.    HEAPF64[i14 >> 3] = -+HEAPF64[i14 >> 3];
    20229. 

  20229.    STACKTOP = i1;
    20230. 

  20230.    return;
    20231. 

  20231.   }
    20232. 

  20232.   _luaK_dischargevars(i4, i7);
    20233. 

  20233.   if ((HEAP32[i7 >> 2] | 0) == 6) {
    20234. 

  20234.    i2 = HEAP32[i7 + 8 >> 2] | 0;
    20235. 

  20235.    if ((HEAP32[i7 + 16 >> 2] | 0) != (HEAP32[i7 + 20 >> 2] | 0)) {
    20236. 

  20236.     if ((i2 | 0) < (HEAPU8[i4 + 46 | 0] | 0)) {
    20237. 

  20237.      i8 = 10;
    20238. 

  20238.     } else {
    20239. 

  20239.      _exp2reg(i4, i7, i2);
    20240. 

  20240.     }
    20241. 

  20241.    }
    20242. 

  20242.   } else {
    20243. 

  20243.    i8 = 10;
    20244. 

  20244.   }
    20245. 

  20245.   if ((i8 | 0) == 10) {
    20246. 

  20246.    _luaK_exp2nextreg(i4, i7);
    20247. 

  20247.   }
    20248. 

  20248.   _codearith(i4, 19, i7, i12, i13);
    20249. 

  20249.   STACKTOP = i1;
    20250. 

  20250.   return;
    20251. 

  20251.  } else if ((i14 | 0) == 2) {
    20252. 

  20252.   _luaK_dischargevars(i4, i7);
    20253. 

  20253.   if ((HEAP32[i7 >> 2] | 0) == 6) {
    20254. 

  20254.    i2 = HEAP32[i7 + 8 >> 2] | 0;
    20255. 

  20255.    if ((HEAP32[i7 + 16 >> 2] | 0) != (HEAP32[i7 + 20 >> 2] | 0)) {
    20256. 

  20256.     if ((i2 | 0) < (HEAPU8[i4 + 46 | 0] | 0)) {
    20257. 

  20257.      i8 = 52;
    20258. 

  20258.     } else {
    20259. 

  20259.      _exp2reg(i4, i7, i2);
    20260. 

  20260.     }
    20261. 

  20261.    }
    20262. 

  20262.   } else {
    20263. 

  20263.    i8 = 52;
    20264. 

  20264.   }
    20265. 

  20265.   if ((i8 | 0) == 52) {
    20266. 

  20266.    _luaK_exp2nextreg(i4, i7);
    20267. 

  20267.   }
    20268. 

  20268.   _codearith(i4, 21, i7, i12, i13);
    20269. 

  20269.   STACKTOP = i1;
    20270. 

  20270.   return;
    20271. 

  20271.  } else {
    20272. 

  20272.   STACKTOP = i1;
    20273. 

  20273.   return;
    20274. 

  20274.  }
    20275. 

  20275. }
    20276. 

  20276. function _subexpr(i6, i3, i7) {
    20277. 

  20277.  i6 = i6 | 0;
    20278. 

  20278.  i3 = i3 | 0;
    20279. 

  20279.  i7 = i7 | 0;
    20280. 

  20280.  var i1 = 0, i2 = 0, i4 = 0, i5 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0, i14 = 0, i15 = 0;
    20281. 

  20281.  i2 = STACKTOP;
    20282. 

  20282.  STACKTOP = STACKTOP + 48 | 0;
    20283. 

  20283.  i11 = i2 + 24 | 0;
    20284. 

  20284.  i5 = i2;
    20285. 

  20285.  i4 = i6 + 48 | 0;
    20286. 

  20286.  i9 = HEAP32[i4 >> 2] | 0;
    20287. 

  20287.  i1 = i6 + 52 | 0;
    20288. 

  20288.  i12 = (HEAP32[i1 >> 2] | 0) + 38 | 0;
    20289. 

  20289.  i13 = (HEAP16[i12 >> 1] | 0) + 1 << 16 >> 16;
    20290. 

  20290.  HEAP16[i12 >> 1] = i13;
    20291. 

  20291.  if ((i13 & 65535) > 200) {
    20292. 

  20292.   i10 = i9 + 12 | 0;
    20293. 

  20293.   i12 = HEAP32[(HEAP32[i10 >> 2] | 0) + 52 >> 2] | 0;
    20294. 

  20294.   i13 = HEAP32[(HEAP32[i9 >> 2] | 0) + 64 >> 2] | 0;
    20295. 

  20295.   if ((i13 | 0) == 0) {
    20296. 

  20296.    i15 = 6552;
    20297. 

  20297.    HEAP32[i11 >> 2] = 6360;
    20298. 

  20298.    i14 = i11 + 4 | 0;
    20299. 

  20299.    HEAP32[i14 >> 2] = 200;
    20300. 

  20300.    i14 = i11 + 8 | 0;
    20301. 

  20301.    HEAP32[i14 >> 2] = i15;
    20302. 

  20302.    i14 = _luaO_pushfstring(i12, 6592, i11) | 0;
    20303. 

  20303.    i15 = HEAP32[i10 >> 2] | 0;
    20304. 

  20304.    _luaX_syntaxerror(i15, i14);
    20305. 

  20305.   }
    20306. 

  20306.   HEAP32[i11 >> 2] = i13;
    20307. 

  20307.   i14 = _luaO_pushfstring(i12, 6568, i11) | 0;
    20308. 

  20308.   HEAP32[i11 >> 2] = 6360;
    20309. 

  20309.   i15 = i11 + 4 | 0;
    20310. 

  20310.   HEAP32[i15 >> 2] = 200;
    20311. 

  20311.   i15 = i11 + 8 | 0;
    20312. 

  20312.   HEAP32[i15 >> 2] = i14;
    20313. 

  20313.   i15 = _luaO_pushfstring(i12, 6592, i11) | 0;
    20314. 

  20314.   i14 = HEAP32[i10 >> 2] | 0;
    20315. 

  20315.   _luaX_syntaxerror(i14, i15);
    20316. 

  20316.  }
    20317. 

  20317.  i10 = i6 + 16 | 0;
    20318. 

  20318.  L8 : do {
    20319. 

  20319.   switch (HEAP32[i10 >> 2] | 0) {
    20320. 

  20320.   case 287:
    20321. 

  20321.    {
    20322. 

  20322.     HEAP32[i3 + 16 >> 2] = -1;
    20323. 

  20323.     HEAP32[i3 + 20 >> 2] = -1;
    20324. 

  20324.     HEAP32[i3 >> 2] = 5;
    20325. 

  20325.     HEAP32[i3 + 8 >> 2] = 0;
    20326. 

  20326.     HEAPF64[i3 + 8 >> 3] = +HEAPF64[i6 + 24 >> 3];
    20327. 

  20327.     i8 = 20;
    20328. 

  20328.     break;
    20329. 

  20329.    }
    20330. 

  20330.   case 271:
    20331. 

  20331.    {
    20332. 

  20332.     i9 = 1;
    20333. 

  20333.     i8 = 8;
    20334. 

  20334.     break;
    20335. 

  20335.    }
    20336. 

  20336.   case 289:
    20337. 

  20337.    {
    20338. 

  20338.     i8 = _luaK_stringK(i9, HEAP32[i6 + 24 >> 2] | 0) | 0;
    20339. 

  20339.     HEAP32[i3 + 16 >> 2] = -1;
    20340. 

  20340.     HEAP32[i3 + 20 >> 2] = -1;
    20341. 

  20341.     HEAP32[i3 >> 2] = 4;
    20342. 

  20342.     HEAP32[i3 + 8 >> 2] = i8;
    20343. 

  20343.     i8 = 20;
    20344. 

  20344.     break;
    20345. 

  20345.    }
    20346. 

  20346.   case 265:
    20347. 

  20347.    {
    20348. 

  20348.     _luaX_next(i6);
    20349. 

  20349.     _body(i6, i3, 0, HEAP32[i6 + 4 >> 2] | 0);
    20350. 

  20350.     break;
    20351. 

  20351.    }
    20352. 

  20352.   case 276:
    20353. 

  20353.    {
    20354. 

  20354.     HEAP32[i3 + 16 >> 2] = -1;
    20355. 

  20355.     HEAP32[i3 + 20 >> 2] = -1;
    20356. 

  20356.     HEAP32[i3 >> 2] = 2;
    20357. 

  20357.     HEAP32[i3 + 8 >> 2] = 0;
    20358. 

  20358.     i8 = 20;
    20359. 

  20359.     break;
    20360. 

  20360.    }
    20361. 

  20361.   case 45:
    20362. 

  20362.    {
    20363. 

  20363.     i9 = 0;
    20364. 

  20364.     i8 = 8;
    20365. 

  20365.     break;
    20366. 

  20366.    }
    20367. 

  20367.   case 35:
    20368. 

  20368.    {
    20369. 

  20369.     i9 = 2;
    20370. 

  20370.     i8 = 8;
    20371. 

  20371.     break;
    20372. 

  20372.    }
    20373. 

  20373.   case 123:
    20374. 

  20374.    {
    20375. 

  20375.     _constructor(i6, i3);
    20376. 

  20376.     break;
    20377. 

  20377.    }
    20378. 

  20378.   case 263:
    20379. 

  20379.    {
    20380. 

  20380.     HEAP32[i3 + 16 >> 2] = -1;
    20381. 

  20381.     HEAP32[i3 + 20 >> 2] = -1;
    20382. 

  20382.     HEAP32[i3 >> 2] = 3;
    20383. 

  20383.     HEAP32[i3 + 8 >> 2] = 0;
    20384. 

  20384.     i8 = 20;
    20385. 

  20385.     break;
    20386. 

  20386.    }
    20387. 

  20387.   case 280:
    20388. 

  20388.    {
    20389. 

  20389.     if ((HEAP8[(HEAP32[i9 >> 2] | 0) + 77 | 0] | 0) == 0) {
    20390. 

  20390.      _luaX_syntaxerror(i6, 6408);
    20391. 

  20391.     } else {
    20392. 

  20392.      i8 = _luaK_codeABC(i9, 38, 0, 1, 0) | 0;
    20393. 

  20393.      HEAP32[i3 + 16 >> 2] = -1;
    20394. 

  20394.      HEAP32[i3 + 20 >> 2] = -1;
    20395. 

  20395.      HEAP32[i3 >> 2] = 13;
    20396. 

  20396.      HEAP32[i3 + 8 >> 2] = i8;
    20397. 

  20397.      i8 = 20;
    20398. 

  20398.      break L8;
    20399. 

  20399.     }
    20400. 

  20400.     break;
    20401. 

  20401.    }
    20402. 

  20402.   case 270:
    20403. 

  20403.    {
    20404. 

  20404.     HEAP32[i3 + 16 >> 2] = -1;
    20405. 

  20405.     HEAP32[i3 + 20 >> 2] = -1;
    20406. 

  20406.     HEAP32[i3 >> 2] = 1;
    20407. 

  20407.     HEAP32[i3 + 8 >> 2] = 0;
    20408. 

  20408.     i8 = 20;
    20409. 

  20409.     break;
    20410. 

  20410.    }
    20411. 

  20411.   default:
    20412. 

  20412.    {
    20413. 

  20413.     _suffixedexp(i6, i3);
    20414. 

  20414.    }
    20415. 

  20415.   }
    20416. 

  20416.  } while (0);
    20417. 

  20417.  if ((i8 | 0) == 8) {
    20418. 

  20418.   i15 = HEAP32[i6 + 4 >> 2] | 0;
    20419. 

  20419.   _luaX_next(i6);
    20420. 

  20420.   _subexpr(i6, i3, 8) | 0;
    20421. 

  20421.   _luaK_prefix(HEAP32[i4 >> 2] | 0, i9, i3, i15);
    20422. 

  20422.  } else if ((i8 | 0) == 20) {
    20423. 

  20423.   _luaX_next(i6);
    20424. 

  20424.  }
    20425. 

  20425.  switch (HEAP32[i10 >> 2] | 0) {
    20426. 

  20426.  case 257:
    20427. 

  20427.   {
    20428. 

  20428.    i9 = 13;
    20429. 

  20429.    break;
    20430. 

  20430.   }
    20431. 

  20431.  case 272:
    20432. 

  20432.   {
    20433. 

  20433.    i9 = 14;
    20434. 

  20434.    break;
    20435. 

  20435.   }
    20436. 

  20436.  case 47:
    20437. 

  20437.   {
    20438. 

  20438.    i9 = 3;
    20439. 

  20439.    break;
    20440. 

  20440.   }
    20441. 

  20441.  case 37:
    20442. 

  20442.   {
    20443. 

  20443.    i9 = 4;
    20444. 

  20444.    break;
    20445. 

  20445.   }
    20446. 

  20446.  case 43:
    20447. 

  20447.   {
    20448. 

  20448.    i9 = 0;
    20449. 

  20449.    break;
    20450. 

  20450.   }
    20451. 

  20451.  case 284:
    20452. 

  20452.   {
    20453. 

  20453.    i9 = 10;
    20454. 

  20454.    break;
    20455. 

  20455.   }
    20456. 

  20456.  case 281:
    20457. 

  20457.   {
    20458. 

  20458.    i9 = 7;
    20459. 

  20459.    break;
    20460. 

  20460.   }
    20461. 

  20461.  case 62:
    20462. 

  20462.   {
    20463. 

  20463.    i9 = 11;
    20464. 

  20464.    break;
    20465. 

  20465.   }
    20466. 

  20466.  case 282:
    20467. 

  20467.   {
    20468. 

  20468.    i9 = 12;
    20469. 

  20469.    break;
    20470. 

  20470.   }
    20471. 

  20471.  case 45:
    20472. 

  20472.   {
    20473. 

  20473.    i9 = 1;
    20474. 

  20474.    break;
    20475. 

  20475.   }
    20476. 

  20476.  case 42:
    20477. 

  20477.   {
    20478. 

  20478.    i9 = 2;
    20479. 

  20479.    break;
    20480. 

  20480.   }
    20481. 

  20481.  case 60:
    20482. 

  20482.   {
    20483. 

  20483.    i9 = 8;
    20484. 

  20484.    break;
    20485. 

  20485.   }
    20486. 

  20486.  case 283:
    20487. 

  20487.   {
    20488. 

  20488.    i9 = 9;
    20489. 

  20489.    break;
    20490. 

  20490.   }
    20491. 

  20491.  case 94:
    20492. 

  20492.   {
    20493. 

  20493.    i9 = 5;
    20494. 

  20494.    break;
    20495. 

  20495.   }
    20496. 

  20496.  case 279:
    20497. 

  20497.   {
    20498. 

  20498.    i9 = 6;
    20499. 

  20499.    break;
    20500. 

  20500.   }
    20501. 

  20501.  default:
    20502. 

  20502.   {
    20503. 

  20503.    i15 = 15;
    20504. 

  20504.    i14 = HEAP32[i1 >> 2] | 0;
    20505. 

  20505.    i14 = i14 + 38 | 0;
    20506. 

  20506.    i13 = HEAP16[i14 >> 1] | 0;
    20507. 

  20507.    i13 = i13 + -1 << 16 >> 16;
    20508. 

  20508.    HEAP16[i14 >> 1] = i13;
    20509. 

  20509.    STACKTOP = i2;
    20510. 

  20510.    return i15 | 0;
    20511. 

  20511.   }
    20512. 

  20512.  }
    20513. 

  20513.  i8 = i6 + 4 | 0;
    20514. 

  20514.  while (1) {
    20515. 

  20515.   if ((HEAPU8[6376 + (i9 << 1) | 0] | 0) <= (i7 | 0)) {
    20516. 

  20516.    i8 = 39;
    20517. 

  20517.    break;
    20518. 

  20518.   }
    20519. 

  20519.   i15 = HEAP32[i8 >> 2] | 0;
    20520. 

  20520.   _luaX_next(i6);
    20521. 

  20521.   _luaK_infix(HEAP32[i4 >> 2] | 0, i9, i3);
    20522. 

  20522.   i10 = _subexpr(i6, i5, HEAPU8[6377 + (i9 << 1) | 0] | 0) | 0;
    20523. 

  20523.   _luaK_posfix(HEAP32[i4 >> 2] | 0, i9, i3, i5, i15);
    20524. 

  20524.   if ((i10 | 0) == 15) {
    20525. 

  20525.    i9 = 15;
    20526. 

  20526.    i8 = 39;
    20527. 

  20527.    break;
    20528. 

  20528.   } else {
    20529. 

  20529.    i9 = i10;
    20530. 

  20530.   }
    20531. 

  20531.  }
    20532. 

  20532.  if ((i8 | 0) == 39) {
    20533. 

  20533.   i15 = HEAP32[i1 >> 2] | 0;
    20534. 

  20534.   i15 = i15 + 38 | 0;
    20535. 

  20535.   i14 = HEAP16[i15 >> 1] | 0;
    20536. 

  20536.   i14 = i14 + -1 << 16 >> 16;
    20537. 

  20537.   HEAP16[i15 >> 1] = i14;
    20538. 

  20538.   STACKTOP = i2;
    20539. 

  20539.   return i9 | 0;
    20540. 

  20540.  }
    20541. 

  20541.  return 0;
    20542. 

  20542. }
    20543. 

  20543. function _luaV_lessequal(i5, i3, i2) {
    20544. 

  20544.  i5 = i5 | 0;
    20545. 

  20545.  i3 = i3 | 0;
    20546. 

  20546.  i2 = i2 | 0;
    20547. 

  20547.  var i1 = 0, i4 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0;
    20548. 

  20548.  i1 = STACKTOP;
    20549. 

  20549.  i4 = i3 + 8 | 0;
    20550. 

  20550.  i7 = HEAP32[i4 >> 2] | 0;
    20551. 

  20551.  if ((i7 | 0) == 3) {
    20552. 

  20552.   if ((HEAP32[i2 + 8 >> 2] | 0) == 3) {
    20553. 

  20553.    i9 = +HEAPF64[i3 >> 3] <= +HEAPF64[i2 >> 3] | 0;
    20554. 

  20554.    STACKTOP = i1;
    20555. 

  20555.    return i9 | 0;
    20556. 

  20556.   }
    20557. 

  20557.  } else {
    20558. 

  20558.   if ((i7 & 15 | 0) == 4 ? (HEAP32[i2 + 8 >> 2] & 15 | 0) == 4 : 0) {
    20559. 

  20559.    i3 = HEAP32[i3 >> 2] | 0;
    20560. 

  20560.    i6 = HEAP32[i2 >> 2] | 0;
    20561. 

  20561.    i4 = i3 + 16 | 0;
    20562. 

  20562.    i5 = i6 + 16 | 0;
    20563. 

  20563.    i7 = _strcmp(i4, i5) | 0;
    20564. 

  20564.    L8 : do {
    20565. 

  20565.     if ((i7 | 0) == 0) {
    20566. 

  20566.      i2 = HEAP32[i3 + 12 >> 2] | 0;
    20567. 

  20567.      i3 = HEAP32[i6 + 12 >> 2] | 0;
    20568. 

  20568.      i6 = i5;
    20569. 

  20569.      while (1) {
    20570. 

  20570.       i5 = _strlen(i4 | 0) | 0;
    20571. 

  20571.       i7 = (i5 | 0) == (i2 | 0);
    20572. 

  20572.       if ((i5 | 0) == (i3 | 0)) {
    20573. 

  20573.        break;
    20574. 

  20574.       }
    20575. 

  20575.       if (i7) {
    20576. 

  20576.        i7 = -1;
    20577. 

  20577.        break L8;
    20578. 

  20578.       }
    20579. 

  20579.       i5 = i5 + 1 | 0;
    20580. 

  20580.       i4 = i4 + i5 | 0;
    20581. 

  20581.       i6 = i6 + i5 | 0;
    20582. 

  20582.       i7 = _strcmp(i4, i6) | 0;
    20583. 

  20583.       if ((i7 | 0) == 0) {
    20584. 

  20584.        i2 = i2 - i5 | 0;
    20585. 

  20585.        i3 = i3 - i5 | 0;
    20586. 

  20586.       } else {
    20587. 

  20587.        break L8;
    20588. 

  20588.       }
    20589. 

  20589.      }
    20590. 

  20590.      i7 = i7 & 1 ^ 1;
    20591. 

  20591.     }
    20592. 

  20592.    } while (0);
    20593. 

  20593.    i9 = (i7 | 0) < 1 | 0;
    20594. 

  20594.    STACKTOP = i1;
    20595. 

  20595.    return i9 | 0;
    20596. 

  20596.   }
    20597. 

  20597.  }
    20598. 

  20598.  i7 = i5 + 8 | 0;
    20599. 

  20599.  i8 = HEAP32[i7 >> 2] | 0;
    20600. 

  20600.  i9 = _luaT_gettmbyobj(i5, i3, 14) | 0;
    20601. 

  20601.  if ((HEAP32[i9 + 8 >> 2] | 0) == 0) {
    20602. 

  20602.   i9 = _luaT_gettmbyobj(i5, i2, 14) | 0;
    20603. 

  20603.   if ((HEAP32[i9 + 8 >> 2] | 0) == 0) {
    20604. 

  20604.    i8 = HEAP32[i7 >> 2] | 0;
    20605. 

  20605.    i9 = _luaT_gettmbyobj(i5, i2, 13) | 0;
    20606. 

  20606.    if ((HEAP32[i9 + 8 >> 2] | 0) == 0) {
    20607. 

  20607.     i9 = _luaT_gettmbyobj(i5, i3, 13) | 0;
    20608. 

  20608.     if ((HEAP32[i9 + 8 >> 2] | 0) == 0) {
    20609. 

  20609.      _luaG_ordererror(i5, i3, i2);
    20610. 

  20610.     } else {
    20611. 

  20611.      i6 = i9;
    20612. 

  20612.     }
    20613. 

  20613.    } else {
    20614. 

  20614.     i6 = i9;
    20615. 

  20615.    }
    20616. 

  20616.    i10 = i5 + 28 | 0;
    20617. 

  20617.    i9 = i8 - (HEAP32[i10 >> 2] | 0) | 0;
    20618. 

  20618.    i8 = HEAP32[i7 >> 2] | 0;
    20619. 

  20619.    HEAP32[i7 >> 2] = i8 + 16;
    20620. 

  20620.    i13 = i6;
    20621. 

  20621.    i11 = HEAP32[i13 + 4 >> 2] | 0;
    20622. 

  20622.    i12 = i8;
    20623. 

  20623.    HEAP32[i12 >> 2] = HEAP32[i13 >> 2];
    20624. 

  20624.    HEAP32[i12 + 4 >> 2] = i11;
    20625. 

  20625.    HEAP32[i8 + 8 >> 2] = HEAP32[i6 + 8 >> 2];
    20626. 

  20626.    i8 = HEAP32[i7 >> 2] | 0;
    20627. 

  20627.    HEAP32[i7 >> 2] = i8 + 16;
    20628. 

  20628.    i12 = i2;
    20629. 

  20629.    i11 = HEAP32[i12 + 4 >> 2] | 0;
    20630. 

  20630.    i6 = i8;
    20631. 

  20631.    HEAP32[i6 >> 2] = HEAP32[i12 >> 2];
    20632. 

  20632.    HEAP32[i6 + 4 >> 2] = i11;
    20633. 

  20633.    HEAP32[i8 + 8 >> 2] = HEAP32[i2 + 8 >> 2];
    20634. 

  20634.    i2 = HEAP32[i7 >> 2] | 0;
    20635. 

  20635.    HEAP32[i7 >> 2] = i2 + 16;
    20636. 

  20636.    i8 = i3;
    20637. 

  20637.    i6 = HEAP32[i8 + 4 >> 2] | 0;
    20638. 

  20638.    i3 = i2;
    20639. 

  20639.    HEAP32[i3 >> 2] = HEAP32[i8 >> 2];
    20640. 

  20640.    HEAP32[i3 + 4 >> 2] = i6;
    20641. 

  20641.    HEAP32[i2 + 8 >> 2] = HEAP32[i4 >> 2];
    20642. 

  20642.    _luaD_call(i5, (HEAP32[i7 >> 2] | 0) + -48 | 0, 1, HEAP8[(HEAP32[i5 + 16 >> 2] | 0) + 18 | 0] & 1);
    20643. 

  20643.    i3 = HEAP32[i10 >> 2] | 0;
    20644. 

  20644.    i2 = HEAP32[i7 >> 2] | 0;
    20645. 

  20645.    i5 = i2 + -16 | 0;
    20646. 

  20646.    HEAP32[i7 >> 2] = i5;
    20647. 

  20647.    i6 = HEAP32[i5 + 4 >> 2] | 0;
    20648. 

  20648.    i8 = i3 + i9 | 0;
    20649. 

  20649.    HEAP32[i8 >> 2] = HEAP32[i5 >> 2];
    20650. 

  20650.    HEAP32[i8 + 4 >> 2] = i6;
    20651. 

  20651.    HEAP32[i3 + (i9 + 8) >> 2] = HEAP32[i2 + -8 >> 2];
    20652. 

  20652.    i3 = HEAP32[i7 >> 2] | 0;
    20653. 

  20653.    i2 = HEAP32[i3 + 8 >> 2] | 0;
    20654. 

  20654.    if ((i2 | 0) != 0) {
    20655. 

  20655.     if ((i2 | 0) == 1) {
    20656. 

  20656.      i2 = (HEAP32[i3 >> 2] | 0) != 0;
    20657. 

  20657.     } else {
    20658. 

  20658.      i2 = 1;
    20659. 

  20659.     }
    20660. 

  20660.    } else {
    20661. 

  20661.     i2 = 0;
    20662. 

  20662.    }
    20663. 

  20663.    i13 = i2 & 1 ^ 1;
    20664. 

  20664.    STACKTOP = i1;
    20665. 

  20665.    return i13 | 0;
    20666. 

  20666.   }
    20667. 

  20667.  }
    20668. 

  20668.  i10 = i5 + 28 | 0;
    20669. 

  20669.  i13 = i8 - (HEAP32[i10 >> 2] | 0) | 0;
    20670. 

  20670.  i11 = HEAP32[i7 >> 2] | 0;
    20671. 

  20671.  HEAP32[i7 >> 2] = i11 + 16;
    20672. 

  20672.  i6 = i9;
    20673. 

  20673.  i8 = HEAP32[i6 + 4 >> 2] | 0;
    20674. 

  20674.  i12 = i11;
    20675. 

  20675.  HEAP32[i12 >> 2] = HEAP32[i6 >> 2];
    20676. 

  20676.  HEAP32[i12 + 4 >> 2] = i8;
    20677. 

  20677.  HEAP32[i11 + 8 >> 2] = HEAP32[i9 + 8 >> 2];
    20678. 

  20678.  i9 = HEAP32[i7 >> 2] | 0;
    20679. 

  20679.  HEAP32[i7 >> 2] = i9 + 16;
    20680. 

  20680.  i11 = i3;
    20681. 

  20681.  i12 = HEAP32[i11 + 4 >> 2] | 0;
    20682. 

  20682.  i3 = i9;
    20683. 

  20683.  HEAP32[i3 >> 2] = HEAP32[i11 >> 2];
    20684. 

  20684.  HEAP32[i3 + 4 >> 2] = i12;
    20685. 

  20685.  HEAP32[i9 + 8 >> 2] = HEAP32[i4 >> 2];
    20686. 

  20686.  i3 = HEAP32[i7 >> 2] | 0;
    20687. 

  20687.  HEAP32[i7 >> 2] = i3 + 16;
    20688. 

  20688.  i9 = i2;
    20689. 

  20689.  i12 = HEAP32[i9 + 4 >> 2] | 0;
    20690. 

  20690.  i11 = i3;
    20691. 

  20691.  HEAP32[i11 >> 2] = HEAP32[i9 >> 2];
    20692. 

  20692.  HEAP32[i11 + 4 >> 2] = i12;
    20693. 

  20693.  HEAP32[i3 + 8 >> 2] = HEAP32[i2 + 8 >> 2];
    20694. 

  20694.  _luaD_call(i5, (HEAP32[i7 >> 2] | 0) + -48 | 0, 1, HEAP8[(HEAP32[i5 + 16 >> 2] | 0) + 18 | 0] & 1);
    20695. 

  20695.  i2 = HEAP32[i10 >> 2] | 0;
    20696. 

  20696.  i3 = HEAP32[i7 >> 2] | 0;
    20697. 

  20697.  i10 = i3 + -16 | 0;
    20698. 

  20698.  HEAP32[i7 >> 2] = i10;
    20699. 

  20699.  i11 = HEAP32[i10 + 4 >> 2] | 0;
    20700. 

  20700.  i12 = i2 + i13 | 0;
    20701. 

  20701.  HEAP32[i12 >> 2] = HEAP32[i10 >> 2];
    20702. 

  20702.  HEAP32[i12 + 4 >> 2] = i11;
    20703. 

  20703.  HEAP32[i2 + (i13 + 8) >> 2] = HEAP32[i3 + -8 >> 2];
    20704. 

  20704.  i2 = HEAP32[i7 >> 2] | 0;
    20705. 

  20705.  i3 = HEAP32[i2 + 8 >> 2] | 0;
    20706. 

  20706.  if ((i3 | 0) != 0) {
    20707. 

  20707.   if ((i3 | 0) == 1) {
    20708. 

  20708.    i2 = (HEAP32[i2 >> 2] | 0) != 0;
    20709. 

  20709.   } else {
    20710. 

  20710.    i2 = 1;
    20711. 

  20711.   }
    20712. 

  20712.  } else {
    20713. 

  20713.   i2 = 0;
    20714. 

  20714.  }
    20715. 

  20715.  i13 = i2 & 1;
    20716. 

  20716.  STACKTOP = i1;
    20717. 

  20717.  return i13 | 0;
    20718. 

  20718. }
    20719. 

  20719. function ___udivmoddi4(i6, i8, i2, i4, i1) {
    20720. 

  20720.  i6 = i6 | 0;
    20721. 

  20721.  i8 = i8 | 0;
    20722. 

  20722.  i2 = i2 | 0;
    20723. 

  20723.  i4 = i4 | 0;
    20724. 

  20724.  i1 = i1 | 0;
    20725. 

  20725.  var i3 = 0, i5 = 0, i7 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0, i14 = 0, i15 = 0;
    20726. 

  20726.  i5 = i6;
    20727. 

  20727.  i9 = i8;
    20728. 

  20728.  i7 = i9;
    20729. 

  20729.  i10 = i2;
    20730. 

  20730.  i3 = i4;
    20731. 

  20731.  i11 = i3;
    20732. 

  20732.  if ((i7 | 0) == 0) {
    20733. 

  20733.   i2 = (i1 | 0) != 0;
    20734. 

  20734.   if ((i11 | 0) == 0) {
    20735. 

  20735.    if (i2) {
    20736. 

  20736.     HEAP32[i1 >> 2] = (i5 >>> 0) % (i10 >>> 0);
    20737. 

  20737.     HEAP32[i1 + 4 >> 2] = 0;
    20738. 

  20738.    }
    20739. 

  20739.    i11 = 0;
    20740. 

  20740.    i12 = (i5 >>> 0) / (i10 >>> 0) >>> 0;
    20741. 

  20741.    return (tempRet0 = i11, i12) | 0;
    20742. 

  20742.   } else {
    20743. 

  20743.    if (!i2) {
    20744. 

  20744.     i11 = 0;
    20745. 

  20745.     i12 = 0;
    20746. 

  20746.     return (tempRet0 = i11, i12) | 0;
    20747. 

  20747.    }
    20748. 

  20748.    HEAP32[i1 >> 2] = i6 | 0;
    20749. 

  20749.    HEAP32[i1 + 4 >> 2] = i8 & 0;
    20750. 

  20750.    i11 = 0;
    20751. 

  20751.    i12 = 0;
    20752. 

  20752.    return (tempRet0 = i11, i12) | 0;
    20753. 

  20753.   }
    20754. 

  20754.  }
    20755. 

  20755.  i12 = (i11 | 0) == 0;
    20756. 

  20756.  do {
    20757. 

  20757.   if ((i10 | 0) != 0) {
    20758. 

  20758.    if (!i12) {
    20759. 

  20759.     i10 = (_llvm_ctlz_i32(i11 | 0) | 0) - (_llvm_ctlz_i32(i7 | 0) | 0) | 0;
    20760. 

  20760.     if (i10 >>> 0 <= 31) {
    20761. 

  20761.      i11 = i10 + 1 | 0;
    20762. 

  20762.      i12 = 31 - i10 | 0;
    20763. 

  20763.      i8 = i10 - 31 >> 31;
    20764. 

  20764.      i9 = i11;
    20765. 

  20765.      i6 = i5 >>> (i11 >>> 0) & i8 | i7 << i12;
    20766. 

  20766.      i8 = i7 >>> (i11 >>> 0) & i8;
    20767. 

  20767.      i11 = 0;
    20768. 

  20768.      i7 = i5 << i12;
    20769. 

  20769.      break;
    20770. 

  20770.     }
    20771. 

  20771.     if ((i1 | 0) == 0) {
    20772. 

  20772.      i11 = 0;
    20773. 

  20773.      i12 = 0;
    20774. 

  20774.      return (tempRet0 = i11, i12) | 0;
    20775. 

  20775.     }
    20776. 

  20776.     HEAP32[i1 >> 2] = i6 | 0;
    20777. 

  20777.     HEAP32[i1 + 4 >> 2] = i9 | i8 & 0;
    20778. 

  20778.     i11 = 0;
    20779. 

  20779.     i12 = 0;
    20780. 

  20780.     return (tempRet0 = i11, i12) | 0;
    20781. 

  20781.    }
    20782. 

  20782.    i11 = i10 - 1 | 0;
    20783. 

  20783.    if ((i11 & i10 | 0) != 0) {
    20784. 

  20784.     i12 = (_llvm_ctlz_i32(i10 | 0) | 0) + 33 - (_llvm_ctlz_i32(i7 | 0) | 0) | 0;
    20785. 

  20785.     i15 = 64 - i12 | 0;
    20786. 

  20786.     i10 = 32 - i12 | 0;
    20787. 

  20787.     i13 = i10 >> 31;
    20788. 

  20788.     i14 = i12 - 32 | 0;
    20789. 

  20789.     i8 = i14 >> 31;
    20790. 

  20790.     i9 = i12;
    20791. 

  20791.     i6 = i10 - 1 >> 31 & i7 >>> (i14 >>> 0) | (i7 << i10 | i5 >>> (i12 >>> 0)) & i8;
    20792. 

  20792.     i8 = i8 & i7 >>> (i12 >>> 0);
    20793. 

  20793.     i11 = i5 << i15 & i13;
    20794. 

  20794.     i7 = (i7 << i15 | i5 >>> (i14 >>> 0)) & i13 | i5 << i10 & i12 - 33 >> 31;
    20795. 

  20795.     break;
    20796. 

  20796.    }
    20797. 

  20797.    if ((i1 | 0) != 0) {
    20798. 

  20798.     HEAP32[i1 >> 2] = i11 & i5;
    20799. 

  20799.     HEAP32[i1 + 4 >> 2] = 0;
    20800. 

  20800.    }
    20801. 

  20801.    if ((i10 | 0) == 1) {
    20802. 

  20802.     i14 = i9 | i8 & 0;
    20803. 

  20803.     i15 = i6 | 0 | 0;
    20804. 

  20804.     return (tempRet0 = i14, i15) | 0;
    20805. 

  20805.    } else {
    20806. 

  20806.     i15 = _llvm_cttz_i32(i10 | 0) | 0;
    20807. 

  20807.     i14 = i7 >>> (i15 >>> 0) | 0;
    20808. 

  20808.     i15 = i7 << 32 - i15 | i5 >>> (i15 >>> 0) | 0;
    20809. 

  20809.     return (tempRet0 = i14, i15) | 0;
    20810. 

  20810.    }
    20811. 

  20811.   } else {
    20812. 

  20812.    if (i12) {
    20813. 

  20813.     if ((i1 | 0) != 0) {
    20814. 

  20814.      HEAP32[i1 >> 2] = (i7 >>> 0) % (i10 >>> 0);
    20815. 

  20815.      HEAP32[i1 + 4 >> 2] = 0;
    20816. 

  20816.     }
    20817. 

  20817.     i14 = 0;
    20818. 

  20818.     i15 = (i7 >>> 0) / (i10 >>> 0) >>> 0;
    20819. 

  20819.     return (tempRet0 = i14, i15) | 0;
    20820. 

  20820.    }
    20821. 

  20821.    if ((i5 | 0) == 0) {
    20822. 

  20822.     if ((i1 | 0) != 0) {
    20823. 

  20823.      HEAP32[i1 >> 2] = 0;
    20824. 

  20824.      HEAP32[i1 + 4 >> 2] = (i7 >>> 0) % (i11 >>> 0);
    20825. 

  20825.     }
    20826. 

  20826.     i14 = 0;
    20827. 

  20827.     i15 = (i7 >>> 0) / (i11 >>> 0) >>> 0;
    20828. 

  20828.     return (tempRet0 = i14, i15) | 0;
    20829. 

  20829.    }
    20830. 

  20830.    i10 = i11 - 1 | 0;
    20831. 

  20831.    if ((i10 & i11 | 0) == 0) {
    20832. 

  20832.     if ((i1 | 0) != 0) {
    20833. 

  20833.      HEAP32[i1 >> 2] = i6 | 0;
    20834. 

  20834.      HEAP32[i1 + 4 >> 2] = i10 & i7 | i8 & 0;
    20835. 

  20835.     }
    20836. 

  20836.     i14 = 0;
    20837. 

  20837.     i15 = i7 >>> ((_llvm_cttz_i32(i11 | 0) | 0) >>> 0);
    20838. 

  20838.     return (tempRet0 = i14, i15) | 0;
    20839. 

  20839.    }
    20840. 

  20840.    i10 = (_llvm_ctlz_i32(i11 | 0) | 0) - (_llvm_ctlz_i32(i7 | 0) | 0) | 0;
    20841. 

  20841.    if (i10 >>> 0 <= 30) {
    20842. 

  20842.     i8 = i10 + 1 | 0;
    20843. 

  20843.     i15 = 31 - i10 | 0;
    20844. 

  20844.     i9 = i8;
    20845. 

  20845.     i6 = i7 << i15 | i5 >>> (i8 >>> 0);
    20846. 

  20846.     i8 = i7 >>> (i8 >>> 0);
    20847. 

  20847.     i11 = 0;
    20848. 

  20848.     i7 = i5 << i15;
    20849. 

  20849.     break;
    20850. 

  20850.    }
    20851. 

  20851.    if ((i1 | 0) == 0) {
    20852. 

  20852.     i14 = 0;
    20853. 

  20853.     i15 = 0;
    20854. 

  20854.     return (tempRet0 = i14, i15) | 0;
    20855. 

  20855.    }
    20856. 

  20856.    HEAP32[i1 >> 2] = i6 | 0;
    20857. 

  20857.    HEAP32[i1 + 4 >> 2] = i9 | i8 & 0;
    20858. 

  20858.    i14 = 0;
    20859. 

  20859.    i15 = 0;
    20860. 

  20860.    return (tempRet0 = i14, i15) | 0;
    20861. 

  20861.   }
    20862. 

  20862.  } while (0);
    20863. 

  20863.  if ((i9 | 0) == 0) {
    20864. 

  20864.   i12 = i6;
    20865. 

  20865.   i2 = 0;
    20866. 

  20866.   i6 = 0;
    20867. 

  20867.  } else {
    20868. 

  20868.   i2 = i2 | 0 | 0;
    20869. 

  20869.   i3 = i3 | i4 & 0;
    20870. 

  20870.   i4 = _i64Add(i2, i3, -1, -1) | 0;
    20871. 

  20871.   i5 = tempRet0;
    20872. 

  20872.   i10 = i8;
    20873. 

  20873.   i12 = i6;
    20874. 

  20874.   i6 = 0;
    20875. 

  20875.   while (1) {
    20876. 

  20876.    i8 = i11 >>> 31 | i7 << 1;
    20877. 

  20877.    i11 = i6 | i11 << 1;
    20878. 

  20878.    i7 = i12 << 1 | i7 >>> 31 | 0;
    20879. 

  20879.    i10 = i12 >>> 31 | i10 << 1 | 0;
    20880. 

  20880.    _i64Subtract(i4, i5, i7, i10) | 0;
    20881. 

  20881.    i12 = tempRet0;
    20882. 

  20882.    i15 = i12 >> 31 | ((i12 | 0) < 0 ? -1 : 0) << 1;
    20883. 

  20883.    i6 = i15 & 1;
    20884. 

  20884.    i12 = _i64Subtract(i7, i10, i15 & i2, (((i12 | 0) < 0 ? -1 : 0) >> 31 | ((i12 | 0) < 0 ? -1 : 0) << 1) & i3) | 0;
    20885. 

  20885.    i10 = tempRet0;
    20886. 

  20886.    i9 = i9 - 1 | 0;
    20887. 

  20887.    if ((i9 | 0) == 0) {
    20888. 

  20888.     break;
    20889. 

  20889.    } else {
    20890. 

  20890.     i7 = i8;
    20891. 

  20891.    }
    20892. 

  20892.   }
    20893. 

  20893.   i7 = i8;
    20894. 

  20894.   i8 = i10;
    20895. 

  20895.   i2 = 0;
    20896. 

  20896.  }
    20897. 

  20897.  i3 = 0;
    20898. 

  20898.  if ((i1 | 0) != 0) {
    20899. 

  20899.   HEAP32[i1 >> 2] = i12;
    20900. 

  20900.   HEAP32[i1 + 4 >> 2] = i8;
    20901. 

  20901.  }
    20902. 

  20902.  i14 = (i11 | 0) >>> 31 | (i7 | i3) << 1 | (i3 << 1 | i11 >>> 31) & 0 | i2;
    20903. 

  20903.  i15 = (i11 << 1 | 0 >>> 31) & -2 | i6;
    20904. 

  20904.  return (tempRet0 = i14, i15) | 0;
    20905. 

  20905. }
    20906. 

  20906. function _leaveblock(i1) {
    20907. 

  20907.  i1 = i1 | 0;
    20908. 

  20908.  var i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0, i14 = 0, i15 = 0, i16 = 0;
    20909. 

  20909.  i3 = STACKTOP;
    20910. 

  20910.  STACKTOP = STACKTOP + 16 | 0;
    20911. 

  20911.  i5 = i3;
    20912. 

  20912.  i7 = i1 + 16 | 0;
    20913. 

  20913.  i4 = HEAP32[i7 >> 2] | 0;
    20914. 

  20914.  i2 = i1 + 12 | 0;
    20915. 

  20915.  i6 = HEAP32[i2 >> 2] | 0;
    20916. 

  20916.  if ((HEAP32[i4 >> 2] | 0) != 0 ? (HEAP8[i4 + 9 | 0] | 0) != 0 : 0) {
    20917. 

  20917.   i16 = _luaK_jump(i1) | 0;
    20918. 

  20918.   _luaK_patchclose(i1, i16, HEAPU8[i4 + 8 | 0] | 0);
    20919. 

  20919.   _luaK_patchtohere(i1, i16);
    20920. 

  20920.  }
    20921. 

  20921.  L5 : do {
    20922. 

  20922.   if ((HEAP8[i4 + 10 | 0] | 0) != 0) {
    20923. 

  20923.    i15 = i6 + 52 | 0;
    20924. 

  20924.    i14 = _luaS_new(HEAP32[i15 >> 2] | 0, 6304) | 0;
    20925. 

  20925.    i13 = i6 + 64 | 0;
    20926. 

  20926.    i16 = HEAP32[i13 >> 2] | 0;
    20927. 

  20927.    i10 = i16 + 24 | 0;
    20928. 

  20928.    i8 = i6 + 48 | 0;
    20929. 

  20929.    i11 = HEAP32[(HEAP32[i8 >> 2] | 0) + 20 >> 2] | 0;
    20930. 

  20930.    i12 = i16 + 28 | 0;
    20931. 

  20931.    i9 = HEAP32[i12 >> 2] | 0;
    20932. 

  20932.    i16 = i16 + 32 | 0;
    20933. 

  20933.    if ((i9 | 0) < (HEAP32[i16 >> 2] | 0)) {
    20934. 

  20934.     i15 = HEAP32[i10 >> 2] | 0;
    20935. 

  20935.    } else {
    20936. 

  20936.     i15 = _luaM_growaux_(HEAP32[i15 >> 2] | 0, HEAP32[i10 >> 2] | 0, i16, 16, 32767, 6312) | 0;
    20937. 

  20937.     HEAP32[i10 >> 2] = i15;
    20938. 

  20938.    }
    20939. 

  20939.    HEAP32[i15 + (i9 << 4) >> 2] = i14;
    20940. 

  20940.    i16 = HEAP32[i10 >> 2] | 0;
    20941. 

  20941.    HEAP32[i16 + (i9 << 4) + 8 >> 2] = 0;
    20942. 

  20942.    HEAP8[i16 + (i9 << 4) + 12 | 0] = HEAP8[(HEAP32[i8 >> 2] | 0) + 46 | 0] | 0;
    20943. 

  20943.    HEAP32[(HEAP32[i10 >> 2] | 0) + (i9 << 4) + 4 >> 2] = i11;
    20944. 

  20944.    HEAP32[i12 >> 2] = (HEAP32[i12 >> 2] | 0) + 1;
    20945. 

  20945.    i10 = HEAP32[i13 >> 2] | 0;
    20946. 

  20946.    i9 = (HEAP32[i10 + 24 >> 2] | 0) + (i9 << 4) | 0;
    20947. 

  20947.    i11 = HEAP16[(HEAP32[(HEAP32[i8 >> 2] | 0) + 16 >> 2] | 0) + 6 >> 1] | 0;
    20948. 

  20948.    i8 = i10 + 16 | 0;
    20949. 

  20949.    if ((i11 | 0) < (HEAP32[i8 >> 2] | 0)) {
    20950. 

  20950.     i10 = i10 + 12 | 0;
    20951. 

  20951.     do {
    20952. 

  20952.      while (1) {
    20953. 

  20953.       if ((_luaS_eqstr(HEAP32[(HEAP32[i10 >> 2] | 0) + (i11 << 4) >> 2] | 0, HEAP32[i9 >> 2] | 0) | 0) == 0) {
    20954. 

  20954.        break;
    20955. 

  20955.       }
    20956. 

  20956.       _closegoto(i6, i11, i9);
    20957. 

  20957.       if ((i11 | 0) >= (HEAP32[i8 >> 2] | 0)) {
    20958. 

  20958.        break L5;
    20959. 

  20959.       }
    20960. 

  20960.      }
    20961. 

  20961.      i11 = i11 + 1 | 0;
    20962. 

  20962.     } while ((i11 | 0) < (HEAP32[i8 >> 2] | 0));
    20963. 

  20963.    }
    20964. 

  20964.   }
    20965. 

  20965.  } while (0);
    20966. 

  20966.  HEAP32[i7 >> 2] = HEAP32[i4 >> 2];
    20967. 

  20967.  i7 = i4 + 8 | 0;
    20968. 

  20968.  i9 = HEAP8[i7] | 0;
    20969. 

  20969.  i10 = i1 + 46 | 0;
    20970. 

  20970.  i8 = (HEAP32[i2 >> 2] | 0) + 64 | 0;
    20971. 

  20971.  i14 = (HEAP32[i8 >> 2] | 0) + 4 | 0;
    20972. 

  20972.  HEAP32[i14 >> 2] = (i9 & 255) - (HEAPU8[i10] | 0) + (HEAP32[i14 >> 2] | 0);
    20973. 

  20973.  i14 = HEAP8[i10] | 0;
    20974. 

  20974.  if ((i14 & 255) > (i9 & 255)) {
    20975. 

  20975.   i13 = i1 + 20 | 0;
    20976. 

  20976.   i11 = i1 + 40 | 0;
    20977. 

  20977.   i12 = (HEAP32[i1 >> 2] | 0) + 24 | 0;
    20978. 

  20978.   do {
    20979. 

  20979.    i16 = HEAP32[i13 >> 2] | 0;
    20980. 

  20980.    i14 = i14 + -1 << 24 >> 24;
    20981. 

  20981.    HEAP8[i10] = i14;
    20982. 

  20982.    HEAP32[(HEAP32[i12 >> 2] | 0) + ((HEAP16[(HEAP32[HEAP32[i8 >> 2] >> 2] | 0) + ((HEAP32[i11 >> 2] | 0) + (i14 & 255) << 1) >> 1] | 0) * 12 | 0) + 8 >> 2] = i16;
    20983. 

  20983.    i14 = HEAP8[i10] | 0;
    20984. 

  20984.   } while ((i14 & 255) > (i9 & 255));
    20985. 

  20985.  }
    20986. 

  20986.  HEAP8[i1 + 48 | 0] = i14;
    20987. 

  20987.  i10 = HEAP32[i6 + 64 >> 2] | 0;
    20988. 

  20988.  HEAP32[i10 + 28 >> 2] = HEAP16[i4 + 4 >> 1] | 0;
    20989. 

  20989.  i9 = HEAP16[i4 + 6 >> 1] | 0;
    20990. 

  20990.  if ((HEAP32[i4 >> 2] | 0) == 0) {
    20991. 

  20991.   if ((i9 | 0) >= (HEAP32[i10 + 16 >> 2] | 0)) {
    20992. 

  20992.    STACKTOP = i3;
    20993. 

  20993.    return;
    20994. 

  20994.   }
    20995. 

  20995.   i10 = HEAP32[i10 + 12 >> 2] | 0;
    20996. 

  20996.   i11 = HEAP32[i10 + (i9 << 4) >> 2] | 0;
    20997. 

  20997.   if ((HEAP8[i11 + 4 | 0] | 0) != 4) {
    20998. 

  20998.    i16 = 6200;
    20999. 

  20999.    i15 = i6 + 52 | 0;
    21000. 

  21000.    i15 = HEAP32[i15 >> 2] | 0;
    21001. 

  21001.    i14 = i11 + 16 | 0;
    21002. 

  21002.    i13 = i10 + (i9 << 4) + 8 | 0;
    21003. 

  21003.    i13 = HEAP32[i13 >> 2] | 0;
    21004. 

  21004.    HEAP32[i5 >> 2] = i14;
    21005. 

  21005.    i14 = i5 + 4 | 0;
    21006. 

  21006.    HEAP32[i14 >> 2] = i13;
    21007. 

  21007.    i16 = _luaO_pushfstring(i15, i16, i5) | 0;
    21008. 

  21008.    _semerror(i6, i16);
    21009. 

  21009.   }
    21010. 

  21010.   i16 = (HEAP8[i11 + 6 | 0] | 0) != 0 ? 6160 : 6200;
    21011. 

  21011.   i15 = i6 + 52 | 0;
    21012. 

  21012.   i15 = HEAP32[i15 >> 2] | 0;
    21013. 

  21013.   i14 = i11 + 16 | 0;
    21014. 

  21014.   i13 = i10 + (i9 << 4) + 8 | 0;
    21015. 

  21015.   i13 = HEAP32[i13 >> 2] | 0;
    21016. 

  21016.   HEAP32[i5 >> 2] = i14;
    21017. 

  21017.   i14 = i5 + 4 | 0;
    21018. 

  21018.   HEAP32[i14 >> 2] = i13;
    21019. 

  21019.   i16 = _luaO_pushfstring(i15, i16, i5) | 0;
    21020. 

  21020.   _semerror(i6, i16);
    21021. 

  21021.  }
    21022. 

  21022.  i6 = HEAP32[i8 >> 2] | 0;
    21023. 

  21023.  i5 = i6 + 16 | 0;
    21024. 

  21024.  if ((i9 | 0) >= (HEAP32[i5 >> 2] | 0)) {
    21025. 

  21025.   STACKTOP = i3;
    21026. 

  21026.   return;
    21027. 

  21027.  }
    21028. 

  21028.  i6 = i6 + 12 | 0;
    21029. 

  21029.  i4 = i4 + 9 | 0;
    21030. 

  21030.  do {
    21031. 

  21031.   i10 = HEAP32[i6 >> 2] | 0;
    21032. 

  21032.   i8 = i10 + (i9 << 4) + 12 | 0;
    21033. 

  21033.   i11 = HEAP8[i7] | 0;
    21034. 

  21034.   i12 = i11 & 255;
    21035. 

  21035.   if ((HEAPU8[i8] | 0) > (i11 & 255)) {
    21036. 

  21036.    if ((HEAP8[i4] | 0) != 0) {
    21037. 

  21037.     _luaK_patchclose(i1, HEAP32[i10 + (i9 << 4) + 4 >> 2] | 0, i12);
    21038. 

  21038.     i11 = HEAP8[i7] | 0;
    21039. 

  21039.    }
    21040. 

  21040.    HEAP8[i8] = i11;
    21041. 

  21041.   }
    21042. 

  21042.   i9 = ((_findlabel(HEAP32[i2 >> 2] | 0, i9) | 0) == 0) + i9 | 0;
    21043. 

  21043.  } while ((i9 | 0) < (HEAP32[i5 >> 2] | 0));
    21044. 

  21044.  STACKTOP = i3;
    21045. 

  21045.  return;
    21046. 

  21046. }
    21047. 

  21047. function _getobjname(i3, i7, i9, i2) {
    21048. 

  21048.  i3 = i3 | 0;
    21049. 

  21049.  i7 = i7 | 0;
    21050. 

  21050.  i9 = i9 | 0;
    21051. 

  21051.  i2 = i2 | 0;
    21052. 

  21052.  var i1 = 0, i4 = 0, i5 = 0, i6 = 0, i8 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0;
    21053. 

  21053.  i1 = STACKTOP;
    21054. 

  21054.  i4 = i3 + 12 | 0;
    21055. 

  21055.  L1 : while (1) {
    21056. 

  21056.   i13 = _luaF_getlocalname(i3, i9 + 1 | 0, i7) | 0;
    21057. 

  21057.   HEAP32[i2 >> 2] = i13;
    21058. 

  21058.   if ((i13 | 0) != 0) {
    21059. 

  21059.    i2 = 2040;
    21060. 

  21060.    i4 = 42;
    21061. 

  21061.    break;
    21062. 

  21062.   }
    21063. 

  21063.   if ((i7 | 0) <= 0) {
    21064. 

  21064.    i2 = 0;
    21065. 

  21065.    i4 = 42;
    21066. 

  21066.    break;
    21067. 

  21067.   }
    21068. 

  21068.   i6 = HEAP32[i4 >> 2] | 0;
    21069. 

  21069.   i8 = 0;
    21070. 

  21070.   i5 = -1;
    21071. 

  21071.   do {
    21072. 

  21072.    i12 = HEAP32[i6 + (i8 << 2) >> 2] | 0;
    21073. 

  21073.    i13 = i12 & 63;
    21074. 

  21074.    i11 = i12 >>> 6 & 255;
    21075. 

  21075.    switch (i13 | 0) {
    21076. 

  21076.    case 27:
    21077. 

  21077.     {
    21078. 

  21078.      i10 = i8;
    21079. 

  21079.      i5 = (i11 | 0) == (i9 | 0) ? i8 : i5;
    21080. 

  21080.      break;
    21081. 

  21081.     }
    21082. 

  21082.    case 30:
    21083. 

  21083.    case 29:
    21084. 

  21084.     {
    21085. 

  21085.      i10 = i8;
    21086. 

  21086.      i5 = (i11 | 0) > (i9 | 0) ? i5 : i8;
    21087. 

  21087.      break;
    21088. 

  21088.     }
    21089. 

  21089.    case 23:
    21090. 

  21090.     {
    21091. 

  21091.      i10 = (i12 >>> 14) + -131071 | 0;
    21092. 

  21092.      i13 = i8 + 1 + i10 | 0;
    21093. 

  21093.      i10 = ((i8 | 0) >= (i13 | 0) | (i13 | 0) > (i7 | 0) ? 0 : i10) + i8 | 0;
    21094. 

  21094.      break;
    21095. 

  21095.     }
    21096. 

  21096.    case 4:
    21097. 

  21097.     {
    21098. 

  21098.      if ((i11 | 0) > (i9 | 0)) {
    21099. 

  21099.       i10 = i8;
    21100. 

  21100.      } else {
    21101. 

  21101.       i10 = i8;
    21102. 

  21102.       i5 = (i11 + (i12 >>> 23) | 0) < (i9 | 0) ? i5 : i8;
    21103. 

  21103.      }
    21104. 

  21104.      break;
    21105. 

  21105.     }
    21106. 

  21106.    case 34:
    21107. 

  21107.     {
    21108. 

  21108.      i10 = i8;
    21109. 

  21109.      i5 = (i11 + 2 | 0) > (i9 | 0) ? i5 : i8;
    21110. 

  21110.      break;
    21111. 

  21111.     }
    21112. 

  21112.    default:
    21113. 

  21113.     {
    21114. 

  21114.      i10 = i8;
    21115. 

  21115.      i5 = (HEAP8[5584 + i13 | 0] & 64) != 0 & (i11 | 0) == (i9 | 0) ? i8 : i5;
    21116. 

  21116.     }
    21117. 

  21117.    }
    21118. 

  21118.    i8 = i10 + 1 | 0;
    21119. 

  21119.   } while ((i8 | 0) < (i7 | 0));
    21120. 

  21120.   if ((i5 | 0) == -1) {
    21121. 

  21121.    i2 = 0;
    21122. 

  21122.    i4 = 42;
    21123. 

  21123.    break;
    21124. 

  21124.   }
    21125. 

  21125.   i7 = HEAP32[i6 + (i5 << 2) >> 2] | 0;
    21126. 

  21126.   i9 = i7 & 63;
    21127. 

  21127.   switch (i9 | 0) {
    21128. 

  21128.   case 0:
    21129. 

  21129.    {
    21130. 

  21130.     break;
    21131. 

  21131.    }
    21132. 

  21132.   case 7:
    21133. 

  21133.   case 6:
    21134. 

  21134.    {
    21135. 

  21135.     i4 = 17;
    21136. 

  21136.     break L1;
    21137. 

  21137.    }
    21138. 

  21138.   case 5:
    21139. 

  21139.    {
    21140. 

  21140.     i4 = 29;
    21141. 

  21141.     break L1;
    21142. 

  21142.    }
    21143. 

  21143.   case 1:
    21144. 

  21144.    {
    21145. 

  21145.     i4 = 32;
    21146. 

  21146.     break L1;
    21147. 

  21147.    }
    21148. 

  21148.   case 2:
    21149. 

  21149.    {
    21150. 

  21150.     i4 = 33;
    21151. 

  21151.     break L1;
    21152. 

  21152.    }
    21153. 

  21153.   case 12:
    21154. 

  21154.    {
    21155. 

  21155.     i4 = 36;
    21156. 

  21156.     break L1;
    21157. 

  21157.    }
    21158. 

  21158.   default:
    21159. 

  21159.    {
    21160. 

  21160.     i2 = 0;
    21161. 

  21161.     i4 = 42;
    21162. 

  21162.     break L1;
    21163. 

  21163.    }
    21164. 

  21164.   }
    21165. 

  21165.   i9 = i7 >>> 23;
    21166. 

  21166.   if (i9 >>> 0 < (i7 >>> 6 & 255) >>> 0) {
    21167. 

  21167.    i7 = i5;
    21168. 

  21168.   } else {
    21169. 

  21169.    i2 = 0;
    21170. 

  21170.    i4 = 42;
    21171. 

  21171.    break;
    21172. 

  21172.   }
    21173. 

  21173.  }
    21174. 

  21174.  if ((i4 | 0) == 17) {
    21175. 

  21175.   i6 = i7 >>> 14;
    21176. 

  21176.   i8 = i6 & 511;
    21177. 

  21177.   i7 = i7 >>> 23;
    21178. 

  21178.   if ((i9 | 0) != 7) {
    21179. 

  21179.    i7 = HEAP32[(HEAP32[i3 + 28 >> 2] | 0) + (i7 << 3) >> 2] | 0;
    21180. 

  21180.    if ((i7 | 0) == 0) {
    21181. 

  21181.     i7 = 2104;
    21182. 

  21182.    } else {
    21183. 

  21183.     i7 = i7 + 16 | 0;
    21184. 

  21184.    }
    21185. 

  21185.   } else {
    21186. 

  21186.    i7 = _luaF_getlocalname(i3, i7 + 1 | 0, i5) | 0;
    21187. 

  21187.   }
    21188. 

  21188.   if ((i6 & 256 | 0) == 0) {
    21189. 

  21189.    i3 = _getobjname(i3, i5, i8, i2) | 0;
    21190. 

  21190.    if (!((i3 | 0) != 0 ? (HEAP8[i3] | 0) == 99 : 0)) {
    21191. 

  21191.     i4 = 26;
    21192. 

  21192.    }
    21193. 

  21193.   } else {
    21194. 

  21194.    i5 = i6 & 255;
    21195. 

  21195.    i3 = HEAP32[i3 + 8 >> 2] | 0;
    21196. 

  21196.    if ((HEAP32[i3 + (i5 << 4) + 8 >> 2] & 15 | 0) == 4) {
    21197. 

  21197.     HEAP32[i2 >> 2] = (HEAP32[i3 + (i5 << 4) >> 2] | 0) + 16;
    21198. 

  21198.    } else {
    21199. 

  21199.     i4 = 26;
    21200. 

  21200.    }
    21201. 

  21201.   }
    21202. 

  21202.   if ((i4 | 0) == 26) {
    21203. 

  21203.    HEAP32[i2 >> 2] = 2104;
    21204. 

  21204.   }
    21205. 

  21205.   if ((i7 | 0) == 0) {
    21206. 

  21206.    i13 = 2064;
    21207. 

  21207.    STACKTOP = i1;
    21208. 

  21208.    return i13 | 0;
    21209. 

  21209.   }
    21210. 

  21210.   i13 = (_strcmp(i7, 2048) | 0) == 0;
    21211. 

  21211.   i13 = i13 ? 2056 : 2064;
    21212. 

  21212.   STACKTOP = i1;
    21213. 

  21213.   return i13 | 0;
    21214. 

  21214.  } else if ((i4 | 0) == 29) {
    21215. 

  21215.   i3 = HEAP32[(HEAP32[i3 + 28 >> 2] | 0) + (i7 >>> 23 << 3) >> 2] | 0;
    21216. 

  21216.   if ((i3 | 0) == 0) {
    21217. 

  21217.    i3 = 2104;
    21218. 

  21218.   } else {
    21219. 

  21219.    i3 = i3 + 16 | 0;
    21220. 

  21220.   }
    21221. 

  21221.   HEAP32[i2 >> 2] = i3;
    21222. 

  21222.   i13 = 2072;
    21223. 

  21223.   STACKTOP = i1;
    21224. 

  21224.   return i13 | 0;
    21225. 

  21225.  } else if ((i4 | 0) == 32) {
    21226. 

  21226.   i5 = i7 >>> 14;
    21227. 

  21227.  } else if ((i4 | 0) == 33) {
    21228. 

  21228.   i5 = (HEAP32[i6 + (i5 + 1 << 2) >> 2] | 0) >>> 6;
    21229. 

  21229.  } else if ((i4 | 0) == 36) {
    21230. 

  21230.   i4 = i7 >>> 14;
    21231. 

  21231.   if ((i4 & 256 | 0) == 0) {
    21232. 

  21232.    i3 = _getobjname(i3, i5, i4 & 511, i2) | 0;
    21233. 

  21233.    if ((i3 | 0) != 0 ? (HEAP8[i3] | 0) == 99 : 0) {
    21234. 

  21234.     i13 = 2096;
    21235. 

  21235.     STACKTOP = i1;
    21236. 

  21236.     return i13 | 0;
    21237. 

  21237.    }
    21238. 

  21238.   } else {
    21239. 

  21239.    i4 = i4 & 255;
    21240. 

  21240.    i3 = HEAP32[i3 + 8 >> 2] | 0;
    21241. 

  21241.    if ((HEAP32[i3 + (i4 << 4) + 8 >> 2] & 15 | 0) == 4) {
    21242. 

  21242.     HEAP32[i2 >> 2] = (HEAP32[i3 + (i4 << 4) >> 2] | 0) + 16;
    21243. 

  21243.     i13 = 2096;
    21244. 

  21244.     STACKTOP = i1;
    21245. 

  21245.     return i13 | 0;
    21246. 

  21246.    }
    21247. 

  21247.   }
    21248. 

  21248.   HEAP32[i2 >> 2] = 2104;
    21249. 

  21249.   i13 = 2096;
    21250. 

  21250.   STACKTOP = i1;
    21251. 

  21251.   return i13 | 0;
    21252. 

  21252.  } else if ((i4 | 0) == 42) {
    21253. 

  21253.   STACKTOP = i1;
    21254. 

  21254.   return i2 | 0;
    21255. 

  21255.  }
    21256. 

  21256.  i3 = HEAP32[i3 + 8 >> 2] | 0;
    21257. 

  21257.  if ((HEAP32[i3 + (i5 << 4) + 8 >> 2] & 15 | 0) != 4) {
    21258. 

  21258.   i13 = 0;
    21259. 

  21259.   STACKTOP = i1;
    21260. 

  21260.   return i13 | 0;
    21261. 

  21261.  }
    21262. 

  21262.  HEAP32[i2 >> 2] = (HEAP32[i3 + (i5 << 4) >> 2] | 0) + 16;
    21263. 

  21263.  i13 = 2080;
    21264. 

  21264.  STACKTOP = i1;
    21265. 

  21265.  return i13 | 0;
    21266. 

  21266. }
    21267. 

  21267. function _assignment(i2, i16, i5) {
    21268. 

  21268.  i2 = i2 | 0;
    21269. 

  21269.  i16 = i16 | 0;
    21270. 

  21270.  i5 = i5 | 0;
    21271. 

  21271.  var i1 = 0, i3 = 0, i4 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0, i14 = 0, i15 = 0, i17 = 0, i18 = 0, i19 = 0, i20 = 0, i21 = 0;
    21272. 

  21272.  i3 = STACKTOP;
    21273. 

  21273.  STACKTOP = STACKTOP + 80 | 0;
    21274. 

  21274.  i6 = i3 + 56 | 0;
    21275. 

  21275.  i1 = i3 + 32 | 0;
    21276. 

  21276.  i8 = i3;
    21277. 

  21277.  i4 = i16 + 8 | 0;
    21278. 

  21278.  if (!(((HEAP32[i4 >> 2] | 0) + -7 | 0) >>> 0 < 3)) {
    21279. 

  21279.   _luaX_syntaxerror(i2, 6344);
    21280. 

  21280.  }
    21281. 

  21281.  i13 = i2 + 16 | 0;
    21282. 

  21282.  i14 = HEAP32[i13 >> 2] | 0;
    21283. 

  21283.  do {
    21284. 

  21284.   if ((i14 | 0) == 44) {
    21285. 

  21285.    _luaX_next(i2);
    21286. 

  21286.    HEAP32[i8 >> 2] = i16;
    21287. 

  21287.    i14 = i8 + 8 | 0;
    21288. 

  21288.    _suffixedexp(i2, i14);
    21289. 

  21289.    i15 = i2 + 48 | 0;
    21290. 

  21290.    if ((HEAP32[i14 >> 2] | 0) != 9 ? (i10 = HEAP32[i15 >> 2] | 0, i11 = HEAP8[i10 + 48 | 0] | 0, i9 = i11 & 255, (i16 | 0) != 0) : 0) {
    21291. 

  21291.     i13 = i8 + 16 | 0;
    21292. 

  21292.     i12 = i11 & 255;
    21293. 

  21293.     i18 = 0;
    21294. 

  21294.     do {
    21295. 

  21295.      if ((HEAP32[i16 + 8 >> 2] | 0) == 9) {
    21296. 

  21296.       i17 = i16 + 16 | 0;
    21297. 

  21297.       i19 = i17 + 3 | 0;
    21298. 

  21298.       i20 = HEAPU8[i19] | 0;
    21299. 

  21299.       i21 = HEAP32[i14 >> 2] | 0;
    21300. 

  21300.       if ((i20 | 0) == (i21 | 0)) {
    21301. 

  21301.        i21 = i17 + 2 | 0;
    21302. 

  21302.        if ((HEAPU8[i21] | 0) == (HEAP32[i13 >> 2] | 0)) {
    21303. 

  21303.         HEAP8[i19] = 7;
    21304. 

  21304.         HEAP8[i21] = i11;
    21305. 

  21305.         i20 = HEAP32[i14 >> 2] | 0;
    21306. 

  21306.         i18 = 1;
    21307. 

  21307.        }
    21308. 

  21308.       } else {
    21309. 

  21309.        i20 = i21;
    21310. 

  21310.       }
    21311. 

  21311.       if ((i20 | 0) == 7 ? (HEAP16[i17 >> 1] | 0) == (HEAP32[i13 >> 2] | 0) : 0) {
    21312. 

  21312.        HEAP16[i17 >> 1] = i12;
    21313. 

  21313.        i18 = 1;
    21314. 

  21314.       }
    21315. 

  21315.      }
    21316. 

  21316.      i16 = HEAP32[i16 >> 2] | 0;
    21317. 

  21317.     } while ((i16 | 0) != 0);
    21318. 

  21318.     if ((i18 | 0) != 0) {
    21319. 

  21319.      _luaK_codeABC(i10, (HEAP32[i14 >> 2] | 0) == 7 ? 0 : 5, i9, HEAP32[i13 >> 2] | 0, 0) | 0;
    21320. 

  21320.      _luaK_reserveregs(i10, 1);
    21321. 

  21321.     }
    21322. 

  21322.    }
    21323. 

  21323.    i9 = HEAP32[i15 >> 2] | 0;
    21324. 

  21324.    if (((HEAPU16[(HEAP32[i2 + 52 >> 2] | 0) + 38 >> 1] | 0) + i5 | 0) <= 200) {
    21325. 

  21325.     _assignment(i2, i8, i5 + 1 | 0);
    21326. 

  21326.     i7 = i1;
    21327. 

  21327.     break;
    21328. 

  21328.    }
    21329. 

  21329.    i8 = i9 + 12 | 0;
    21330. 

  21330.    i5 = HEAP32[(HEAP32[i8 >> 2] | 0) + 52 >> 2] | 0;
    21331. 

  21331.    i9 = HEAP32[(HEAP32[i9 >> 2] | 0) + 64 >> 2] | 0;
    21332. 

  21332.    if ((i9 | 0) == 0) {
    21333. 

  21333.     i20 = 6552;
    21334. 

  21334.     HEAP32[i6 >> 2] = 6360;
    21335. 

  21335.     i21 = i6 + 4 | 0;
    21336. 

  21336.     HEAP32[i21 >> 2] = 200;
    21337. 

  21337.     i21 = i6 + 8 | 0;
    21338. 

  21338.     HEAP32[i21 >> 2] = i20;
    21339. 

  21339.     i21 = _luaO_pushfstring(i5, 6592, i6) | 0;
    21340. 

  21340.     i20 = HEAP32[i8 >> 2] | 0;
    21341. 

  21341.     _luaX_syntaxerror(i20, i21);
    21342. 

  21342.    }
    21343. 

  21343.    HEAP32[i6 >> 2] = i9;
    21344. 

  21344.    i20 = _luaO_pushfstring(i5, 6568, i6) | 0;
    21345. 

  21345.    HEAP32[i6 >> 2] = 6360;
    21346. 

  21346.    i21 = i6 + 4 | 0;
    21347. 

  21347.    HEAP32[i21 >> 2] = 200;
    21348. 

  21348.    i21 = i6 + 8 | 0;
    21349. 

  21349.    HEAP32[i21 >> 2] = i20;
    21350. 

  21350.    i21 = _luaO_pushfstring(i5, 6592, i6) | 0;
    21351. 

  21351.    i20 = HEAP32[i8 >> 2] | 0;
    21352. 

  21352.    _luaX_syntaxerror(i20, i21);
    21353. 

  21353.   } else if ((i14 | 0) == 61) {
    21354. 

  21354.    _luaX_next(i2);
    21355. 

  21355.    _subexpr(i2, i1, 0) | 0;
    21356. 

  21356.    i6 = i2 + 48 | 0;
    21357. 

  21357.    if ((HEAP32[i13 >> 2] | 0) == 44) {
    21358. 

  21358.     i9 = 1;
    21359. 

  21359.     do {
    21360. 

  21360.      _luaX_next(i2);
    21361. 

  21361.      _luaK_exp2nextreg(HEAP32[i6 >> 2] | 0, i1);
    21362. 

  21362.      _subexpr(i2, i1, 0) | 0;
    21363. 

  21363.      i9 = i9 + 1 | 0;
    21364. 

  21364.     } while ((HEAP32[i13 >> 2] | 0) == 44);
    21365. 

  21365.    } else {
    21366. 

  21366.     i9 = 1;
    21367. 

  21367.    }
    21368. 

  21368.    i8 = HEAP32[i6 >> 2] | 0;
    21369. 

  21369.    if ((i9 | 0) == (i5 | 0)) {
    21370. 

  21370.     _luaK_setoneret(i8, i1);
    21371. 

  21371.     _luaK_storevar(HEAP32[i6 >> 2] | 0, i4, i1);
    21372. 

  21372.     STACKTOP = i3;
    21373. 

  21373.     return;
    21374. 

  21374.    }
    21375. 

  21375.    i7 = i5 - i9 | 0;
    21376. 

  21376.    i10 = HEAP32[i1 >> 2] | 0;
    21377. 

  21377.    if ((i10 | 0) == 13 | (i10 | 0) == 12) {
    21378. 

  21378.     i10 = i7 + 1 | 0;
    21379. 

  21379.     i10 = (i10 | 0) < 0 ? 0 : i10;
    21380. 

  21380.     _luaK_setreturns(i8, i1, i10);
    21381. 

  21381.     if ((i10 | 0) > 1) {
    21382. 

  21382.      _luaK_reserveregs(i8, i10 + -1 | 0);
    21383. 

  21383.     }
    21384. 

  21384.    } else if ((i10 | 0) == 0) {
    21385. 

  21385.     i12 = 30;
    21386. 

  21386.    } else {
    21387. 

  21387.     _luaK_exp2nextreg(i8, i1);
    21388. 

  21388.     i12 = 30;
    21389. 

  21389.    }
    21390. 

  21390.    if ((i12 | 0) == 30 ? (i7 | 0) > 0 : 0) {
    21391. 

  21391.     i21 = HEAPU8[i8 + 48 | 0] | 0;
    21392. 

  21392.     _luaK_reserveregs(i8, i7);
    21393. 

  21393.     _luaK_nil(i8, i21, i7);
    21394. 

  21394.    }
    21395. 

  21395.    if ((i9 | 0) > (i5 | 0)) {
    21396. 

  21396.     i21 = (HEAP32[i6 >> 2] | 0) + 48 | 0;
    21397. 

  21397.     HEAP8[i21] = i7 + (HEAPU8[i21] | 0);
    21398. 

  21398.     i7 = i1;
    21399. 

  21399.    } else {
    21400. 

  21400.     i7 = i1;
    21401. 

  21401.    }
    21402. 

  21402.   } else {
    21403. 

  21403.    _error_expected(i2, 61);
    21404. 

  21404.   }
    21405. 

  21405.  } while (0);
    21406. 

  21406.  i21 = HEAP32[i2 + 48 >> 2] | 0;
    21407. 

  21407.  i20 = (HEAPU8[i21 + 48 | 0] | 0) + -1 | 0;
    21408. 

  21408.  HEAP32[i1 + 16 >> 2] = -1;
    21409. 

  21409.  HEAP32[i1 + 20 >> 2] = -1;
    21410. 

  21410.  HEAP32[i7 >> 2] = 6;
    21411. 

  21411.  HEAP32[i1 + 8 >> 2] = i20;
    21412. 

  21412.  _luaK_storevar(i21, i4, i1);
    21413. 

  21413.  STACKTOP = i3;
    21414. 

  21414.  return;
    21415. 

  21415. }
    21416. 

  21416. function _str_find_aux(i3, i7) {
    21417. 

  21417.  i3 = i3 | 0;
    21418. 

  21418.  i7 = i7 | 0;
    21419. 

  21419.  var i1 = 0, i2 = 0, i4 = 0, i5 = 0, i6 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0;
    21420. 

  21420.  i1 = STACKTOP;
    21421. 

  21421.  STACKTOP = STACKTOP + 288 | 0;
    21422. 

  21422.  i9 = i1 + 284 | 0;
    21423. 

  21423.  i5 = i1 + 280 | 0;
    21424. 

  21424.  i4 = i1;
    21425. 

  21425.  i2 = _luaL_checklstring(i3, 1, i9) | 0;
    21426. 

  21426.  i8 = _luaL_checklstring(i3, 2, i5) | 0;
    21427. 

  21427.  i12 = _luaL_optinteger(i3, 3, 1) | 0;
    21428. 

  21428.  i10 = HEAP32[i9 >> 2] | 0;
    21429. 

  21429.  if (!((i12 | 0) > -1)) {
    21430. 

  21430.   if (i10 >>> 0 < (0 - i12 | 0) >>> 0) {
    21431. 

  21431.    i12 = 1;
    21432. 

  21432.   } else {
    21433. 

  21433.    i12 = i12 + 1 + i10 | 0;
    21434. 

  21434.    i6 = 4;
    21435. 

  21435.   }
    21436. 

  21436.  } else {
    21437. 

  21437.   i6 = 4;
    21438. 

  21438.  }
    21439. 

  21439.  if ((i6 | 0) == 4) {
    21440. 

  21440.   if ((i12 | 0) != 0) {
    21441. 

  21441.    if (i12 >>> 0 > (i10 + 1 | 0) >>> 0) {
    21442. 

  21442.     _lua_pushnil(i3);
    21443. 

  21443.     i13 = 1;
    21444. 

  21444.     STACKTOP = i1;
    21445. 

  21445.     return i13 | 0;
    21446. 

  21446.    }
    21447. 

  21447.   } else {
    21448. 

  21448.    i12 = 1;
    21449. 

  21449.   }
    21450. 

  21450.  }
    21451. 

  21451.  i7 = (i7 | 0) != 0;
    21452. 

  21452.  L10 : do {
    21453. 

  21453.   if (i7) {
    21454. 

  21454.    i13 = (_lua_toboolean(i3, 4) | 0) == 0;
    21455. 

  21455.    i10 = HEAP32[i5 >> 2] | 0;
    21456. 

  21456.    if (i13) {
    21457. 

  21457.     i11 = 0;
    21458. 

  21458.     do {
    21459. 

  21459.      i13 = i8 + i11 | 0;
    21460. 

  21460.      if ((_strpbrk(i13, 7512) | 0) != 0) {
    21461. 

  21461.       i6 = 20;
    21462. 

  21462.       break L10;
    21463. 

  21463.      }
    21464. 

  21464.      i11 = i11 + 1 + (_strlen(i13 | 0) | 0) | 0;
    21465. 

  21465.     } while (!(i11 >>> 0 > i10 >>> 0));
    21466. 

  21466.    }
    21467. 

  21467.    i11 = i2 + (i12 + -1) | 0;
    21468. 

  21468.    i9 = (HEAP32[i9 >> 2] | 0) - i12 + 1 | 0;
    21469. 

  21469.    L17 : do {
    21470. 

  21470.     if ((i10 | 0) == 0) {
    21471. 

  21471.      if ((i11 | 0) == 0) {
    21472. 

  21472.       break L10;
    21473. 

  21473.      }
    21474. 

  21474.     } else {
    21475. 

  21475.      if (i10 >>> 0 > i9 >>> 0) {
    21476. 

  21476.       break L10;
    21477. 

  21477.      }
    21478. 

  21478.      i4 = i10 + -1 | 0;
    21479. 

  21479.      if ((i4 | 0) == (i9 | 0)) {
    21480. 

  21480.       break L10;
    21481. 

  21481.      }
    21482. 

  21482.      i7 = HEAP8[i8] | 0;
    21483. 

  21483.      i8 = i8 + 1 | 0;
    21484. 

  21484.      i9 = i9 - i4 | 0;
    21485. 

  21485.      i12 = i11;
    21486. 

  21486.      while (1) {
    21487. 

  21487.       i11 = _memchr(i12, i7, i9) | 0;
    21488. 

  21488.       if ((i11 | 0) == 0) {
    21489. 

  21489.        break L10;
    21490. 

  21490.       }
    21491. 

  21491.       i10 = i11 + 1 | 0;
    21492. 

  21492.       if ((_memcmp(i10, i8, i4) | 0) == 0) {
    21493. 

  21493.        break L17;
    21494. 

  21494.       }
    21495. 

  21495.       i11 = i10;
    21496. 

  21496.       i9 = i12 + i9 | 0;
    21497. 

  21497.       if ((i9 | 0) == (i11 | 0)) {
    21498. 

  21498.        break L10;
    21499. 

  21499.       } else {
    21500. 

  21500.        i9 = i9 - i11 | 0;
    21501. 

  21501.        i12 = i10;
    21502. 

  21502.       }
    21503. 

  21503.      }
    21504. 

  21504.     }
    21505. 

  21505.    } while (0);
    21506. 

  21506.    i13 = i11 - i2 | 0;
    21507. 

  21507.    _lua_pushinteger(i3, i13 + 1 | 0);
    21508. 

  21508.    _lua_pushinteger(i3, i13 + (HEAP32[i5 >> 2] | 0) | 0);
    21509. 

  21509.    i13 = 2;
    21510. 

  21510.    STACKTOP = i1;
    21511. 

  21511.    return i13 | 0;
    21512. 

  21512.   } else {
    21513. 

  21513.    i6 = 20;
    21514. 

  21514.   }
    21515. 

  21515.  } while (0);
    21516. 

  21516.  L28 : do {
    21517. 

  21517.   if ((i6 | 0) == 20) {
    21518. 

  21518.    i6 = i2 + (i12 + -1) | 0;
    21519. 

  21519.    i10 = (HEAP8[i8] | 0) == 94;
    21520. 

  21520.    if (i10) {
    21521. 

  21521.     i12 = (HEAP32[i5 >> 2] | 0) + -1 | 0;
    21522. 

  21522.     HEAP32[i5 >> 2] = i12;
    21523. 

  21523.     i8 = i8 + 1 | 0;
    21524. 

  21524.    } else {
    21525. 

  21525.     i12 = HEAP32[i5 >> 2] | 0;
    21526. 

  21526.    }
    21527. 

  21527.    i5 = i4 + 16 | 0;
    21528. 

  21528.    HEAP32[i5 >> 2] = i3;
    21529. 

  21529.    HEAP32[i4 >> 2] = 200;
    21530. 

  21530.    HEAP32[i4 + 4 >> 2] = i2;
    21531. 

  21531.    i11 = i4 + 8 | 0;
    21532. 

  21532.    HEAP32[i11 >> 2] = i2 + (HEAP32[i9 >> 2] | 0);
    21533. 

  21533.    HEAP32[i4 + 12 >> 2] = i8 + i12;
    21534. 

  21534.    i9 = i4 + 20 | 0;
    21535. 

  21535.    L34 : do {
    21536. 

  21536.     if (i10) {
    21537. 

  21537.      HEAP32[i9 >> 2] = 0;
    21538. 

  21538.      i8 = _match(i4, i6, i8) | 0;
    21539. 

  21539.      if ((i8 | 0) == 0) {
    21540. 

  21540.       break L28;
    21541. 

  21541.      }
    21542. 

  21542.     } else {
    21543. 

  21543.      while (1) {
    21544. 

  21544.       HEAP32[i9 >> 2] = 0;
    21545. 

  21545.       i10 = _match(i4, i6, i8) | 0;
    21546. 

  21546.       if ((i10 | 0) != 0) {
    21547. 

  21547.        i8 = i10;
    21548. 

  21548.        break L34;
    21549. 

  21549.       }
    21550. 

  21550.       if (!(i6 >>> 0 < (HEAP32[i11 >> 2] | 0) >>> 0)) {
    21551. 

  21551.        break L28;
    21552. 

  21552.       }
    21553. 

  21553.       i6 = i6 + 1 | 0;
    21554. 

  21554.      }
    21555. 

  21555.     }
    21556. 

  21556.    } while (0);
    21557. 

  21557.    if (i7) {
    21558. 

  21558.     _lua_pushinteger(i3, 1 - i2 + i6 | 0);
    21559. 

  21559.     _lua_pushinteger(i3, i8 - i2 | 0);
    21560. 

  21560.     i2 = HEAP32[i9 >> 2] | 0;
    21561. 

  21561.     _luaL_checkstack(HEAP32[i5 >> 2] | 0, i2, 7200);
    21562. 

  21562.     if ((i2 | 0) > 0) {
    21563. 

  21563.      i3 = 0;
    21564. 

  21564.      do {
    21565. 

  21565.       _push_onecapture(i4, i3, 0, 0);
    21566. 

  21566.       i3 = i3 + 1 | 0;
    21567. 

  21567.      } while ((i3 | 0) != (i2 | 0));
    21568. 

  21568.     }
    21569. 

  21569.     i13 = i2 + 2 | 0;
    21570. 

  21570.     STACKTOP = i1;
    21571. 

  21571.     return i13 | 0;
    21572. 

  21572.    } else {
    21573. 

  21573.     i3 = HEAP32[i9 >> 2] | 0;
    21574. 

  21574.     i2 = (i3 | 0) != 0 | (i6 | 0) == 0 ? i3 : 1;
    21575. 

  21575.     _luaL_checkstack(HEAP32[i5 >> 2] | 0, i2, 7200);
    21576. 

  21576.     if ((i2 | 0) > 0) {
    21577. 

  21577.      i3 = 0;
    21578. 

  21578.     } else {
    21579. 

  21579.      i13 = i3;
    21580. 

  21580.      STACKTOP = i1;
    21581. 

  21581.      return i13 | 0;
    21582. 

  21582.     }
    21583. 

  21583.     do {
    21584. 

  21584.      _push_onecapture(i4, i3, i6, i8);
    21585. 

  21585.      i3 = i3 + 1 | 0;
    21586. 

  21586.     } while ((i3 | 0) != (i2 | 0));
    21587. 

  21587.     STACKTOP = i1;
    21588. 

  21588.     return i2 | 0;
    21589. 

  21589.    }
    21590. 

  21590.   }
    21591. 

  21591.  } while (0);
    21592. 

  21592.  _lua_pushnil(i3);
    21593. 

  21593.  i13 = 1;
    21594. 

  21594.  STACKTOP = i1;
    21595. 

  21595.  return i13 | 0;
    21596. 

  21596. }
    21597. 

  21597. function _luaO_pushvfstring(i2, i13, i10) {
    21598. 

  21598.  i2 = i2 | 0;
    21599. 

  21599.  i13 = i13 | 0;
    21600. 

  21600.  i10 = i10 | 0;
    21601. 

  21601.  var i1 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i11 = 0, i12 = 0, i14 = 0, i15 = 0, i16 = 0, i17 = 0, d18 = 0.0;
    21602. 

  21602.  i3 = STACKTOP;
    21603. 

  21603.  STACKTOP = STACKTOP + 48 | 0;
    21604. 

  21604.  i7 = i3;
    21605. 

  21605.  i9 = i3 + 32 | 0;
    21606. 

  21606.  i8 = i3 + 8 | 0;
    21607. 

  21607.  i14 = _strchr(i13, 37) | 0;
    21608. 

  21608.  i6 = i2 + 24 | 0;
    21609. 

  21609.  i4 = i2 + 8 | 0;
    21610. 

  21610.  i15 = HEAP32[i4 >> 2] | 0;
    21611. 

  21611.  i17 = (HEAP32[i6 >> 2] | 0) - i15 | 0;
    21612. 

  21612.  L1 : do {
    21613. 

  21613.   if ((i14 | 0) == 0) {
    21614. 

  21614.    i5 = i13;
    21615. 

  21615.    i11 = i17;
    21616. 

  21616.    i12 = i15;
    21617. 

  21617.    i1 = 0;
    21618. 

  21618.   } else {
    21619. 

  21619.    i16 = 0;
    21620. 

  21620.    L3 : while (1) {
    21621. 

  21621.     if ((i17 | 0) < 48) {
    21622. 

  21622.      _luaD_growstack(i2, 2);
    21623. 

  21623.      i15 = HEAP32[i4 >> 2] | 0;
    21624. 

  21624.     }
    21625. 

  21625.     HEAP32[i4 >> 2] = i15 + 16;
    21626. 

  21626.     i13 = _luaS_newlstr(i2, i13, i14 - i13 | 0) | 0;
    21627. 

  21627.     HEAP32[i15 >> 2] = i13;
    21628. 

  21628.     HEAP32[i15 + 8 >> 2] = HEAPU8[i13 + 4 | 0] | 64;
    21629. 

  21629.     i13 = HEAP8[i14 + 1 | 0] | 0;
    21630. 

  21630.     switch (i13 | 0) {
    21631. 

  21631.     case 115:
    21632. 

  21632.      {
    21633. 

  21633.       i17 = HEAP32[i10 >> 2] | 0;
    21634. 

  21634.       i13 = HEAP32[i17 >> 2] | 0;
    21635. 

  21635.       HEAP32[i10 >> 2] = i17 + 4;
    21636. 

  21636.       i13 = (i13 | 0) == 0 ? 5480 : i13;
    21637. 

  21637.       i15 = _strlen(i13 | 0) | 0;
    21638. 

  21638.       i17 = HEAP32[i4 >> 2] | 0;
    21639. 

  21639.       HEAP32[i4 >> 2] = i17 + 16;
    21640. 

  21640.       i15 = _luaS_newlstr(i2, i13, i15) | 0;
    21641. 

  21641.       HEAP32[i17 >> 2] = i15;
    21642. 

  21642.       HEAP32[i17 + 8 >> 2] = HEAPU8[i15 + 4 | 0] | 64;
    21643. 

  21643.       break;
    21644. 

  21644.      }
    21645. 

  21645.     case 100:
    21646. 

  21646.      {
    21647. 

  21647.       i17 = HEAP32[i4 >> 2] | 0;
    21648. 

  21648.       HEAP32[i4 >> 2] = i17 + 16;
    21649. 

  21649.       i13 = HEAP32[i10 >> 2] | 0;
    21650. 

  21650.       i15 = HEAP32[i13 >> 2] | 0;
    21651. 

  21651.       HEAP32[i10 >> 2] = i13 + 4;
    21652. 

  21652.       HEAPF64[i17 >> 3] = +(i15 | 0);
    21653. 

  21653.       HEAP32[i17 + 8 >> 2] = 3;
    21654. 

  21654.       break;
    21655. 

  21655.      }
    21656. 

  21656.     case 37:
    21657. 

  21657.      {
    21658. 

  21658.       i17 = HEAP32[i4 >> 2] | 0;
    21659. 

  21659.       HEAP32[i4 >> 2] = i17 + 16;
    21660. 

  21660.       i15 = _luaS_newlstr(i2, 5496, 1) | 0;
    21661. 

  21661.       HEAP32[i17 >> 2] = i15;
    21662. 

  21662.       HEAP32[i17 + 8 >> 2] = HEAPU8[i15 + 4 | 0] | 64;
    21663. 

  21663.       break;
    21664. 

  21664.      }
    21665. 

  21665.     case 99:
    21666. 

  21666.      {
    21667. 

  21667.       i15 = HEAP32[i10 >> 2] | 0;
    21668. 

  21668.       i17 = HEAP32[i15 >> 2] | 0;
    21669. 

  21669.       HEAP32[i10 >> 2] = i15 + 4;
    21670. 

  21670.       HEAP8[i9] = i17;
    21671. 

  21671.       i17 = HEAP32[i4 >> 2] | 0;
    21672. 

  21672.       HEAP32[i4 >> 2] = i17 + 16;
    21673. 

  21673.       i15 = _luaS_newlstr(i2, i9, 1) | 0;
    21674. 

  21674.       HEAP32[i17 >> 2] = i15;
    21675. 

  21675.       HEAP32[i17 + 8 >> 2] = HEAPU8[i15 + 4 | 0] | 64;
    21676. 

  21676.       break;
    21677. 

  21677.      }
    21678. 

  21678.     case 102:
    21679. 

  21679.      {
    21680. 

  21680.       i17 = HEAP32[i4 >> 2] | 0;
    21681. 

  21681.       HEAP32[i4 >> 2] = i17 + 16;
    21682. 

  21682.       i15 = HEAP32[i10 >> 2] | 0;
    21683. 

  21683.       d18 = +HEAPF64[i15 >> 3];
    21684. 

  21684.       HEAP32[i10 >> 2] = i15 + 8;
    21685. 

  21685.       HEAPF64[i17 >> 3] = d18;
    21686. 

  21686.       HEAP32[i17 + 8 >> 2] = 3;
    21687. 

  21687.       break;
    21688. 

  21688.      }
    21689. 

  21689.     case 112:
    21690. 

  21690.      {
    21691. 

  21691.       i17 = HEAP32[i10 >> 2] | 0;
    21692. 

  21692.       i15 = HEAP32[i17 >> 2] | 0;
    21693. 

  21693.       HEAP32[i10 >> 2] = i17 + 4;
    21694. 

  21694.       HEAP32[i7 >> 2] = i15;
    21695. 

  21695.       i15 = _sprintf(i8 | 0, 5488, i7 | 0) | 0;
    21696. 

  21696.       i17 = HEAP32[i4 >> 2] | 0;
    21697. 

  21697.       HEAP32[i4 >> 2] = i17 + 16;
    21698. 

  21698.       i15 = _luaS_newlstr(i2, i8, i15) | 0;
    21699. 

  21699.       HEAP32[i17 >> 2] = i15;
    21700. 

  21700.       HEAP32[i17 + 8 >> 2] = HEAPU8[i15 + 4 | 0] | 64;
    21701. 

  21701.       break;
    21702. 

  21702.      }
    21703. 

  21703.     default:
    21704. 

  21704.      {
    21705. 

  21705.       break L3;
    21706. 

  21706.      }
    21707. 

  21707.     }
    21708. 

  21708.     i16 = i16 + 2 | 0;
    21709. 

  21709.     i13 = i14 + 2 | 0;
    21710. 

  21710.     i14 = _strchr(i13, 37) | 0;
    21711. 

  21711.     i15 = HEAP32[i4 >> 2] | 0;
    21712. 

  21712.     i17 = (HEAP32[i6 >> 2] | 0) - i15 | 0;
    21713. 

  21713.     if ((i14 | 0) == 0) {
    21714. 

  21714.      i5 = i13;
    21715. 

  21715.      i11 = i17;
    21716. 

  21716.      i12 = i15;
    21717. 

  21717.      i1 = i16;
    21718. 

  21718.      break L1;
    21719. 

  21719.     }
    21720. 

  21720.    }
    21721. 

  21721.    HEAP32[i7 >> 2] = i13;
    21722. 

  21722.    _luaG_runerror(i2, 5504, i7);
    21723. 

  21723.   }
    21724. 

  21724.  } while (0);
    21725. 

  21725.  if ((i11 | 0) < 32) {
    21726. 

  21726.   _luaD_growstack(i2, 1);
    21727. 

  21727.   i12 = HEAP32[i4 >> 2] | 0;
    21728. 

  21728.  }
    21729. 

  21729.  i17 = _strlen(i5 | 0) | 0;
    21730. 

  21730.  HEAP32[i4 >> 2] = i12 + 16;
    21731. 

  21731.  i17 = _luaS_newlstr(i2, i5, i17) | 0;
    21732. 

  21732.  HEAP32[i12 >> 2] = i17;
    21733. 

  21733.  HEAP32[i12 + 8 >> 2] = HEAPU8[i17 + 4 | 0] | 64;
    21734. 

  21734.  if ((i1 | 0) <= 0) {
    21735. 

  21735.   i17 = HEAP32[i4 >> 2] | 0;
    21736. 

  21736.   i17 = i17 + -16 | 0;
    21737. 

  21737.   i17 = HEAP32[i17 >> 2] | 0;
    21738. 

  21738.   i17 = i17 + 16 | 0;
    21739. 

  21739.   STACKTOP = i3;
    21740. 

  21740.   return i17 | 0;
    21741. 

  21741.  }
    21742. 

  21742.  _luaV_concat(i2, i1 | 1);
    21743. 

  21743.  i17 = HEAP32[i4 >> 2] | 0;
    21744. 

  21744.  i17 = i17 + -16 | 0;
    21745. 

  21745.  i17 = HEAP32[i17 >> 2] | 0;
    21746. 

  21746.  i17 = i17 + 16 | 0;
    21747. 

  21747.  STACKTOP = i3;
    21748. 

  21748.  return i17 | 0;
    21749. 

  21749. }
    21750. 

  21750. function _luaH_getn(i6) {
    21751. 

  21751.  i6 = i6 | 0;
    21752. 

  21752.  var i1 = 0, i2 = 0, i3 = 0, i4 = 0, i5 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, d11 = 0.0, i12 = 0, i13 = 0;
    21753. 

  21753.  i1 = STACKTOP;
    21754. 

  21754.  STACKTOP = STACKTOP + 16 | 0;
    21755. 

  21755.  i2 = i1;
    21756. 

  21756.  i3 = i6 + 28 | 0;
    21757. 

  21757.  i12 = HEAP32[i3 >> 2] | 0;
    21758. 

  21758.  if ((i12 | 0) != 0 ? (i4 = HEAP32[i6 + 12 >> 2] | 0, (HEAP32[i4 + (i12 + -1 << 4) + 8 >> 2] | 0) == 0) : 0) {
    21759. 

  21759.   if (i12 >>> 0 > 1) {
    21760. 

  21760.    i10 = 0;
    21761. 

  21761.   } else {
    21762. 

  21762.    i13 = 0;
    21763. 

  21763.    STACKTOP = i1;
    21764. 

  21764.    return i13 | 0;
    21765. 

  21765.   }
    21766. 

  21766.   do {
    21767. 

  21767.    i2 = (i10 + i12 | 0) >>> 1;
    21768. 

  21768.    i3 = (HEAP32[i4 + (i2 + -1 << 4) + 8 >> 2] | 0) == 0;
    21769. 

  21769.    i12 = i3 ? i2 : i12;
    21770. 

  21770.    i10 = i3 ? i10 : i2;
    21771. 

  21771.   } while ((i12 - i10 | 0) >>> 0 > 1);
    21772. 

  21772.   STACKTOP = i1;
    21773. 

  21773.   return i10 | 0;
    21774. 

  21774.  }
    21775. 

  21775.  i4 = i6 + 16 | 0;
    21776. 

  21776.  if ((HEAP32[i4 >> 2] | 0) == 8016) {
    21777. 

  21777.   i13 = i12;
    21778. 

  21778.   STACKTOP = i1;
    21779. 

  21779.   return i13 | 0;
    21780. 

  21780.  }
    21781. 

  21781.  i5 = i6 + 12 | 0;
    21782. 

  21782.  i6 = i6 + 7 | 0;
    21783. 

  21783.  i9 = i2 + 4 | 0;
    21784. 

  21784.  i8 = i12 + 1 | 0;
    21785. 

  21785.  i13 = i12;
    21786. 

  21786.  i10 = i12;
    21787. 

  21787.  while (1) {
    21788. 

  21788.   i12 = i8 + -1 | 0;
    21789. 

  21789.   L15 : do {
    21790. 

  21790.    if (i12 >>> 0 < i13 >>> 0) {
    21791. 

  21791.     i12 = (HEAP32[i5 >> 2] | 0) + (i12 << 4) | 0;
    21792. 

  21792.    } else {
    21793. 

  21793.     d11 = +(i8 | 0);
    21794. 

  21794.     HEAPF64[i2 >> 3] = d11 + 1.0;
    21795. 

  21795.     i13 = (HEAP32[i9 >> 2] | 0) + (HEAP32[i2 >> 2] | 0) | 0;
    21796. 

  21796.     if ((i13 | 0) < 0) {
    21797. 

  21797.      i12 = 0 - i13 | 0;
    21798. 

  21798.      i13 = (i13 | 0) == (i12 | 0) ? 0 : i12;
    21799. 

  21799.     }
    21800. 

  21800.     i12 = (HEAP32[i4 >> 2] | 0) + (((i13 | 0) % ((1 << (HEAPU8[i6] | 0)) + -1 | 1 | 0) | 0) << 5) | 0;
    21801. 

  21801.     while (1) {
    21802. 

  21802.      if ((HEAP32[i12 + 24 >> 2] | 0) == 3 ? +HEAPF64[i12 + 16 >> 3] == d11 : 0) {
    21803. 

  21803.       break;
    21804. 

  21804.      }
    21805. 

  21805.      i12 = HEAP32[i12 + 28 >> 2] | 0;
    21806. 

  21806.      if ((i12 | 0) == 0) {
    21807. 

  21807.       i12 = 5192;
    21808. 

  21808.       break L15;
    21809. 

  21809.      }
    21810. 

  21810.     }
    21811. 

  21811.    }
    21812. 

  21812.   } while (0);
    21813. 

  21813.   if ((HEAP32[i12 + 8 >> 2] | 0) == 0) {
    21814. 

  21814.    break;
    21815. 

  21815.   }
    21816. 

  21816.   i10 = i8 << 1;
    21817. 

  21817.   if (i10 >>> 0 > 2147483645) {
    21818. 

  21818.    i7 = 21;
    21819. 

  21819.    break;
    21820. 

  21820.   }
    21821. 

  21821.   i12 = i8;
    21822. 

  21822.   i8 = i10;
    21823. 

  21823.   i13 = HEAP32[i3 >> 2] | 0;
    21824. 

  21824.   i10 = i12;
    21825. 

  21825.  }
    21826. 

  21826.  if ((i7 | 0) == 21) {
    21827. 

  21827.   i8 = i2 + 4 | 0;
    21828. 

  21828.   i7 = 1;
    21829. 

  21829.   while (1) {
    21830. 

  21830.    i10 = i7 + -1 | 0;
    21831. 

  21831.    L34 : do {
    21832. 

  21832.     if (i10 >>> 0 < (HEAP32[i3 >> 2] | 0) >>> 0) {
    21833. 

  21833.      i9 = (HEAP32[i5 >> 2] | 0) + (i10 << 4) | 0;
    21834. 

  21834.     } else {
    21835. 

  21835.      d11 = +(i7 | 0);
    21836. 

  21836.      HEAPF64[i2 >> 3] = d11 + 1.0;
    21837. 

  21837.      i9 = (HEAP32[i8 >> 2] | 0) + (HEAP32[i2 >> 2] | 0) | 0;
    21838. 

  21838.      if ((i9 | 0) < 0) {
    21839. 

  21839.       i12 = 0 - i9 | 0;
    21840. 

  21840.       i9 = (i9 | 0) == (i12 | 0) ? 0 : i12;
    21841. 

  21841.      }
    21842. 

  21842.      i9 = (HEAP32[i4 >> 2] | 0) + (((i9 | 0) % ((1 << (HEAPU8[i6] | 0)) + -1 | 1 | 0) | 0) << 5) | 0;
    21843. 

  21843.      while (1) {
    21844. 

  21844.       if ((HEAP32[i9 + 24 >> 2] | 0) == 3 ? +HEAPF64[i9 + 16 >> 3] == d11 : 0) {
    21845. 

  21845.        break;
    21846. 

  21846.       }
    21847. 

  21847.       i9 = HEAP32[i9 + 28 >> 2] | 0;
    21848. 

  21848.       if ((i9 | 0) == 0) {
    21849. 

  21849.        i9 = 5192;
    21850. 

  21850.        break L34;
    21851. 

  21851.       }
    21852. 

  21852.      }
    21853. 

  21853.     }
    21854. 

  21854.    } while (0);
    21855. 

  21855.    if ((HEAP32[i9 + 8 >> 2] | 0) == 0) {
    21856. 

  21856.     break;
    21857. 

  21857.    }
    21858. 

  21858.    i7 = i7 + 1 | 0;
    21859. 

  21859.   }
    21860. 

  21860.   STACKTOP = i1;
    21861. 

  21861.   return i10 | 0;
    21862. 

  21862.  }
    21863. 

  21863.  if (!((i8 - i10 | 0) >>> 0 > 1)) {
    21864. 

  21864.   i13 = i10;
    21865. 

  21865.   STACKTOP = i1;
    21866. 

  21866.   return i13 | 0;
    21867. 

  21867.  }
    21868. 

  21868.  i7 = i2 + 4 | 0;
    21869. 

  21869.  do {
    21870. 

  21870.   i9 = (i8 + i10 | 0) >>> 1;
    21871. 

  21871.   i12 = i9 + -1 | 0;
    21872. 

  21872.   L55 : do {
    21873. 

  21873.    if (i12 >>> 0 < (HEAP32[i3 >> 2] | 0) >>> 0) {
    21874. 

  21874.     i12 = (HEAP32[i5 >> 2] | 0) + (i12 << 4) | 0;
    21875. 

  21875.    } else {
    21876. 

  21876.     d11 = +(i9 | 0);
    21877. 

  21877.     HEAPF64[i2 >> 3] = d11 + 1.0;
    21878. 

  21878.     i13 = (HEAP32[i7 >> 2] | 0) + (HEAP32[i2 >> 2] | 0) | 0;
    21879. 

  21879.     if ((i13 | 0) < 0) {
    21880. 

  21880.      i12 = 0 - i13 | 0;
    21881. 

  21881.      i13 = (i13 | 0) == (i12 | 0) ? 0 : i12;
    21882. 

  21882.     }
    21883. 

  21883.     i12 = (HEAP32[i4 >> 2] | 0) + (((i13 | 0) % ((1 << (HEAPU8[i6] | 0)) + -1 | 1 | 0) | 0) << 5) | 0;
    21884. 

  21884.     while (1) {
    21885. 

  21885.      if ((HEAP32[i12 + 24 >> 2] | 0) == 3 ? +HEAPF64[i12 + 16 >> 3] == d11 : 0) {
    21886. 

  21886.       break;
    21887. 

  21887.      }
    21888. 

  21888.      i12 = HEAP32[i12 + 28 >> 2] | 0;
    21889. 

  21889.      if ((i12 | 0) == 0) {
    21890. 

  21890.       i12 = 5192;
    21891. 

  21891.       break L55;
    21892. 

  21892.      }
    21893. 

  21893.     }
    21894. 

  21894.    }
    21895. 

  21895.   } while (0);
    21896. 

  21896.   i12 = (HEAP32[i12 + 8 >> 2] | 0) == 0;
    21897. 

  21897.   i8 = i12 ? i9 : i8;
    21898. 

  21898.   i10 = i12 ? i10 : i9;
    21899. 

  21899.  } while ((i8 - i10 | 0) >>> 0 > 1);
    21900. 

  21900.  STACKTOP = i1;
    21901. 

  21901.  return i10 | 0;
    21902. 

  21902. }
    21903. 

  21903. function _lua_resume(i4, i3, i7) {
    21904. 

  21904.  i4 = i4 | 0;
    21905. 

  21905.  i3 = i3 | 0;
    21906. 

  21906.  i7 = i7 | 0;
    21907. 

  21907.  var i1 = 0, i2 = 0, i5 = 0, i6 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0, i14 = 0, i15 = 0, i16 = 0, i17 = 0, i18 = 0, i19 = 0, i20 = 0, i21 = 0;
    21908. 

  21908.  i1 = STACKTOP;
    21909. 

  21909.  if ((i3 | 0) == 0) {
    21910. 

  21910.   i5 = 1;
    21911. 

  21911.  } else {
    21912. 

  21912.   i5 = (HEAPU16[i3 + 38 >> 1] | 0) + 1 & 65535;
    21913. 

  21913.  }
    21914. 

  21914.  i3 = i4 + 38 | 0;
    21915. 

  21915.  HEAP16[i3 >> 1] = i5;
    21916. 

  21916.  i5 = i4 + 36 | 0;
    21917. 

  21917.  HEAP16[i5 >> 1] = 0;
    21918. 

  21918.  i6 = i4 + 8 | 0;
    21919. 

  21919.  i13 = _luaD_rawrunprotected(i4, 4, (HEAP32[i6 >> 2] | 0) + (0 - i7 << 4) | 0) | 0;
    21920. 

  21920.  if ((i13 | 0) == -1) {
    21921. 

  21921.   i18 = 2;
    21922. 

  21922.   HEAP16[i5 >> 1] = 1;
    21923. 

  21923.   i17 = HEAP16[i3 >> 1] | 0;
    21924. 

  21924.   i17 = i17 + -1 << 16 >> 16;
    21925. 

  21925.   HEAP16[i3 >> 1] = i17;
    21926. 

  21926.   STACKTOP = i1;
    21927. 

  21927.   return i18 | 0;
    21928. 

  21928.  }
    21929. 

  21929.  if (!(i13 >>> 0 > 1)) {
    21930. 

  21930.   i18 = i13;
    21931. 

  21931.   HEAP16[i5 >> 1] = 1;
    21932. 

  21932.   i17 = HEAP16[i3 >> 1] | 0;
    21933. 

  21933.   i17 = i17 + -1 << 16 >> 16;
    21934. 

  21934.   HEAP16[i3 >> 1] = i17;
    21935. 

  21935.   STACKTOP = i1;
    21936. 

  21936.   return i18 | 0;
    21937. 

  21937.  }
    21938. 

  21938.  i7 = i4 + 16 | 0;
    21939. 

  21939.  i12 = i4 + 28 | 0;
    21940. 

  21940.  i11 = i4 + 41 | 0;
    21941. 

  21941.  i10 = i4 + 68 | 0;
    21942. 

  21942.  i9 = i4 + 32 | 0;
    21943. 

  21943.  i8 = i4 + 12 | 0;
    21944. 

  21944.  L10 : while (1) {
    21945. 

  21945.   i15 = HEAP32[i7 >> 2] | 0;
    21946. 

  21946.   if ((i15 | 0) == 0) {
    21947. 

  21947.    break;
    21948. 

  21948.   }
    21949. 

  21949.   while (1) {
    21950. 

  21950.    i14 = i15 + 18 | 0;
    21951. 

  21951.    if (!((HEAP8[i14] & 16) == 0)) {
    21952. 

  21952.     break;
    21953. 

  21953.    }
    21954. 

  21954.    i15 = HEAP32[i15 + 8 >> 2] | 0;
    21955. 

  21955.    if ((i15 | 0) == 0) {
    21956. 

  21956.     break L10;
    21957. 

  21957.    }
    21958. 

  21958.   }
    21959. 

  21959.   i16 = HEAP32[i12 >> 2] | 0;
    21960. 

  21960.   i17 = HEAP32[i15 + 20 >> 2] | 0;
    21961. 

  21961.   i18 = i16 + i17 | 0;
    21962. 

  21962.   _luaF_close(i4, i18);
    21963. 

  21963.   if ((i13 | 0) == 4) {
    21964. 

  21964.    i19 = HEAP32[(HEAP32[i8 >> 2] | 0) + 180 >> 2] | 0;
    21965. 

  21965.    HEAP32[i18 >> 2] = i19;
    21966. 

  21966.    HEAP32[i16 + (i17 + 8) >> 2] = HEAPU8[i19 + 4 | 0] | 0 | 64;
    21967. 

  21967.   } else if ((i13 | 0) == 6) {
    21968. 

  21968.    i19 = _luaS_newlstr(i4, 2424, 23) | 0;
    21969. 

  21969.    HEAP32[i18 >> 2] = i19;
    21970. 

  21970.    HEAP32[i16 + (i17 + 8) >> 2] = HEAPU8[i19 + 4 | 0] | 0 | 64;
    21971. 

  21971.   } else {
    21972. 

  21972.    i19 = HEAP32[i6 >> 2] | 0;
    21973. 

  21973.    i21 = i19 + -16 | 0;
    21974. 

  21974.    i20 = HEAP32[i21 + 4 >> 2] | 0;
    21975. 

  21975.    HEAP32[i18 >> 2] = HEAP32[i21 >> 2];
    21976. 

  21976.    HEAP32[i18 + 4 >> 2] = i20;
    21977. 

  21977.    HEAP32[i16 + (i17 + 8) >> 2] = HEAP32[i19 + -8 >> 2];
    21978. 

  21978.   }
    21979. 

  21979.   i17 = i16 + (i17 + 16) | 0;
    21980. 

  21980.   HEAP32[i6 >> 2] = i17;
    21981. 

  21981.   HEAP32[i7 >> 2] = i15;
    21982. 

  21982.   HEAP8[i11] = HEAP8[i15 + 36 | 0] | 0;
    21983. 

  21983.   HEAP16[i5 >> 1] = 0;
    21984. 

  21984.   if ((i15 | 0) != 0) {
    21985. 

  21985.    i16 = i15;
    21986. 

  21986.    do {
    21987. 

  21987.     i18 = HEAP32[i16 + 4 >> 2] | 0;
    21988. 

  21988.     i17 = i17 >>> 0 < i18 >>> 0 ? i18 : i17;
    21989. 

  21989.     i16 = HEAP32[i16 + 8 >> 2] | 0;
    21990. 

  21990.    } while ((i16 | 0) != 0);
    21991. 

  21991.   }
    21992. 

  21992.   i16 = i17 - (HEAP32[i12 >> 2] | 0) | 0;
    21993. 

  21993.   i17 = (i16 >> 4) + 1 | 0;
    21994. 

  21994.   i17 = ((i17 | 0) / 8 | 0) + 10 + i17 | 0;
    21995. 

  21995.   i17 = (i17 | 0) > 1e6 ? 1e6 : i17;
    21996. 

  21996.   if ((i16 | 0) <= 15999984 ? (i17 | 0) < (HEAP32[i9 >> 2] | 0) : 0) {
    21997. 

  21997.    _luaD_reallocstack(i4, i17);
    21998. 

  21998.   }
    21999. 

  21999.   HEAP32[i10 >> 2] = HEAP32[i15 + 32 >> 2];
    22000. 

  22000.   HEAP8[i14] = HEAPU8[i14] | 0 | 32;
    22001. 

  22001.   HEAP8[i15 + 37 | 0] = i13;
    22002. 

  22002.   i13 = _luaD_rawrunprotected(i4, 5, 0) | 0;
    22003. 

  22003.   if (!(i13 >>> 0 > 1)) {
    22004. 

  22004.    i2 = 24;
    22005. 

  22005.    break;
    22006. 

  22006.   }
    22007. 

  22007.  }
    22008. 

  22008.  if ((i2 | 0) == 24) {
    22009. 

  22009.   HEAP16[i5 >> 1] = 1;
    22010. 

  22010.   i21 = HEAP16[i3 >> 1] | 0;
    22011. 

  22011.   i21 = i21 + -1 << 16 >> 16;
    22012. 

  22012.   HEAP16[i3 >> 1] = i21;
    22013. 

  22013.   STACKTOP = i1;
    22014. 

  22014.   return i13 | 0;
    22015. 

  22015.  }
    22016. 

  22016.  HEAP8[i4 + 6 | 0] = i13;
    22017. 

  22017.  i2 = HEAP32[i6 >> 2] | 0;
    22018. 

  22018.  if ((i13 | 0) == 4) {
    22019. 

  22019.   i21 = HEAP32[(HEAP32[i8 >> 2] | 0) + 180 >> 2] | 0;
    22020. 

  22020.   HEAP32[i2 >> 2] = i21;
    22021. 

  22021.   HEAP32[i2 + 8 >> 2] = HEAPU8[i21 + 4 | 0] | 0 | 64;
    22022. 

  22022.  } else if ((i13 | 0) == 6) {
    22023. 

  22023.   i21 = _luaS_newlstr(i4, 2424, 23) | 0;
    22024. 

  22024.   HEAP32[i2 >> 2] = i21;
    22025. 

  22025.   HEAP32[i2 + 8 >> 2] = HEAPU8[i21 + 4 | 0] | 0 | 64;
    22026. 

  22026.  } else {
    22027. 

  22027.   i19 = i2 + -16 | 0;
    22028. 

  22028.   i20 = HEAP32[i19 + 4 >> 2] | 0;
    22029. 

  22029.   i21 = i2;
    22030. 

  22030.   HEAP32[i21 >> 2] = HEAP32[i19 >> 2];
    22031. 

  22031.   HEAP32[i21 + 4 >> 2] = i20;
    22032. 

  22032.   HEAP32[i2 + 8 >> 2] = HEAP32[i2 + -8 >> 2];
    22033. 

  22033.  }
    22034. 

  22034.  i21 = i2 + 16 | 0;
    22035. 

  22035.  HEAP32[i6 >> 2] = i21;
    22036. 

  22036.  HEAP32[(HEAP32[i7 >> 2] | 0) + 4 >> 2] = i21;
    22037. 

  22037.  i21 = i13;
    22038. 

  22038.  HEAP16[i5 >> 1] = 1;
    22039. 

  22039.  i20 = HEAP16[i3 >> 1] | 0;
    22040. 

  22040.  i20 = i20 + -1 << 16 >> 16;
    22041. 

  22041.  HEAP16[i3 >> 1] = i20;
    22042. 

  22042.  STACKTOP = i1;
    22043. 

  22043.  return i21 | 0;
    22044. 

  22044. }
    22045. 

  22045. function _luaK_goiftrue(i1, i3) {
    22046. 

  22046.  i1 = i1 | 0;
    22047. 

  22047.  i3 = i3 | 0;
    22048. 

  22048.  var i2 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0;
    22049. 

  22049.  i2 = STACKTOP;
    22050. 

  22050.  _luaK_dischargevars(i1, i3);
    22051. 

  22051.  i12 = HEAP32[i3 >> 2] | 0;
    22052. 

  22052.  do {
    22053. 

  22053.   if ((i12 | 0) == 10) {
    22054. 

  22054.    i9 = HEAP32[(HEAP32[i1 >> 2] | 0) + 12 >> 2] | 0;
    22055. 

  22055.    i5 = i3 + 8 | 0;
    22056. 

  22056.    i8 = HEAP32[i5 >> 2] | 0;
    22057. 

  22057.    i7 = i9 + (i8 << 2) | 0;
    22058. 

  22058.    if (!((i8 | 0) > 0 ? (i10 = i9 + (i8 + -1 << 2) | 0, i6 = HEAP32[i10 >> 2] | 0, (HEAP8[5584 + (i6 & 63) | 0] | 0) < 0) : 0)) {
    22059. 

  22059.     i10 = i7;
    22060. 

  22060.     i6 = HEAP32[i7 >> 2] | 0;
    22061. 

  22061.    }
    22062. 

  22062.    HEAP32[i10 >> 2] = ((i6 & 16320 | 0) == 0) << 6 | i6 & -16321;
    22063. 

  22063.    i5 = HEAP32[i5 >> 2] | 0;
    22064. 

  22064.    i8 = 18;
    22065. 

  22065.   } else if (!((i12 | 0) == 2 | (i12 | 0) == 5 | (i12 | 0) == 4)) {
    22066. 

  22066.    i5 = i3 + 8 | 0;
    22067. 

  22067.    if ((i12 | 0) == 6) {
    22068. 

  22068.     i8 = 14;
    22069. 

  22069.    } else if ((i12 | 0) == 11 ? (i11 = HEAP32[(HEAP32[(HEAP32[i1 >> 2] | 0) + 12 >> 2] | 0) + (HEAP32[i5 >> 2] << 2) >> 2] | 0, (i11 & 63 | 0) == 20) : 0) {
    22070. 

  22070.     i5 = i1 + 20 | 0;
    22071. 

  22071.     HEAP32[i5 >> 2] = (HEAP32[i5 >> 2] | 0) + -1;
    22072. 

  22072.     i5 = _condjump(i1, 27, i11 >>> 23, 0, 1) | 0;
    22073. 

  22073.     i8 = 18;
    22074. 

  22074.     break;
    22075. 

  22075.    } else {
    22076. 

  22076.     i8 = 9;
    22077. 

  22077.    }
    22078. 

  22078.    if ((i8 | 0) == 9) {
    22079. 

  22079.     i12 = i1 + 48 | 0;
    22080. 

  22080.     i10 = HEAP8[i12] | 0;
    22081. 

  22081.     i11 = (i10 & 255) + 1 | 0;
    22082. 

  22082.     i6 = (HEAP32[i1 >> 2] | 0) + 78 | 0;
    22083. 

  22083.     do {
    22084. 

  22084.      if (i11 >>> 0 > (HEAPU8[i6] | 0) >>> 0) {
    22085. 

  22085.       if (i11 >>> 0 > 249) {
    22086. 

  22086.        _luaX_syntaxerror(HEAP32[i1 + 12 >> 2] | 0, 10536);
    22087. 

  22087.       } else {
    22088. 

  22088.        HEAP8[i6] = i11;
    22089. 

  22089.        i9 = HEAP8[i12] | 0;
    22090. 

  22090.        break;
    22091. 

  22091.       }
    22092. 

  22092.      } else {
    22093. 

  22093.       i9 = i10;
    22094. 

  22094.      }
    22095. 

  22095.     } while (0);
    22096. 

  22096.     i11 = (i9 & 255) + 1 | 0;
    22097. 

  22097.     HEAP8[i12] = i11;
    22098. 

  22098.     _discharge2reg(i1, i3, (i11 & 255) + -1 | 0);
    22099. 

  22099.     if ((HEAP32[i3 >> 2] | 0) == 6) {
    22100. 

  22100.      i8 = 14;
    22101. 

  22101.     }
    22102. 

  22102.    }
    22103. 

  22103.    if (((i8 | 0) == 14 ? (i7 = HEAP32[i5 >> 2] | 0, (i7 & 256 | 0) == 0) : 0) ? (HEAPU8[i1 + 46 | 0] | 0) <= (i7 | 0) : 0) {
    22104. 

  22104.     i12 = i1 + 48 | 0;
    22105. 

  22105.     HEAP8[i12] = (HEAP8[i12] | 0) + -1 << 24 >> 24;
    22106. 

  22106.    }
    22107. 

  22107.    i5 = _condjump(i1, 28, 255, HEAP32[i5 >> 2] | 0, 0) | 0;
    22108. 

  22108.    i8 = 18;
    22109. 

  22109.   }
    22110. 

  22110.  } while (0);
    22111. 

  22111.  do {
    22112. 

  22112.   if ((i8 | 0) == 18 ? (i4 = i3 + 20 | 0, !((i5 | 0) == -1)) : 0) {
    22113. 

  22113.    i8 = HEAP32[i4 >> 2] | 0;
    22114. 

  22114.    if ((i8 | 0) == -1) {
    22115. 

  22115.     HEAP32[i4 >> 2] = i5;
    22116. 

  22116.     break;
    22117. 

  22117.    }
    22118. 

  22118.    i4 = HEAP32[(HEAP32[i1 >> 2] | 0) + 12 >> 2] | 0;
    22119. 

  22119.    while (1) {
    22120. 

  22120.     i7 = i4 + (i8 << 2) | 0;
    22121. 

  22121.     i6 = HEAP32[i7 >> 2] | 0;
    22122. 

  22122.     i9 = (i6 >>> 14) + -131071 | 0;
    22123. 

  22123.     if ((i9 | 0) == -1) {
    22124. 

  22124.      break;
    22125. 

  22125.     }
    22126. 

  22126.     i9 = i8 + 1 + i9 | 0;
    22127. 

  22127.     if ((i9 | 0) == -1) {
    22128. 

  22128.      break;
    22129. 

  22129.     } else {
    22130. 

  22130.      i8 = i9;
    22131. 

  22131.     }
    22132. 

  22132.    }
    22133. 

  22133.    i4 = i5 + ~i8 | 0;
    22134. 

  22134.    if ((((i4 | 0) > -1 ? i4 : 0 - i4 | 0) | 0) > 131071) {
    22135. 

  22135.     _luaX_syntaxerror(HEAP32[i1 + 12 >> 2] | 0, 10624);
    22136. 

  22136.    } else {
    22137. 

  22137.     HEAP32[i7 >> 2] = (i4 << 14) + 2147467264 | i6 & 16383;
    22138. 

  22138.     break;
    22139. 

  22139.    }
    22140. 

  22140.   }
    22141. 

  22141.  } while (0);
    22142. 

  22142.  i3 = i3 + 16 | 0;
    22143. 

  22143.  i4 = HEAP32[i3 >> 2] | 0;
    22144. 

  22144.  HEAP32[i1 + 24 >> 2] = HEAP32[i1 + 20 >> 2];
    22145. 

  22145.  i5 = i1 + 28 | 0;
    22146. 

  22146.  if ((i4 | 0) == -1) {
    22147. 

  22147.   HEAP32[i3 >> 2] = -1;
    22148. 

  22148.   STACKTOP = i2;
    22149. 

  22149.   return;
    22150. 

  22150.  }
    22151. 

  22151.  i8 = HEAP32[i5 >> 2] | 0;
    22152. 

  22152.  if ((i8 | 0) == -1) {
    22153. 

  22153.   HEAP32[i5 >> 2] = i4;
    22154. 

  22154.   HEAP32[i3 >> 2] = -1;
    22155. 

  22155.   STACKTOP = i2;
    22156. 

  22156.   return;
    22157. 

  22157.  }
    22158. 

  22158.  i7 = HEAP32[(HEAP32[i1 >> 2] | 0) + 12 >> 2] | 0;
    22159. 

  22159.  while (1) {
    22160. 

  22160.   i5 = i7 + (i8 << 2) | 0;
    22161. 

  22161.   i6 = HEAP32[i5 >> 2] | 0;
    22162. 

  22162.   i9 = (i6 >>> 14) + -131071 | 0;
    22163. 

  22163.   if ((i9 | 0) == -1) {
    22164. 

  22164.    break;
    22165. 

  22165.   }
    22166. 

  22166.   i9 = i8 + 1 + i9 | 0;
    22167. 

  22167.   if ((i9 | 0) == -1) {
    22168. 

  22168.    break;
    22169. 

  22169.   } else {
    22170. 

  22170.    i8 = i9;
    22171. 

  22171.   }
    22172. 

  22172.  }
    22173. 

  22173.  i4 = i4 + ~i8 | 0;
    22174. 

  22174.  if ((((i4 | 0) > -1 ? i4 : 0 - i4 | 0) | 0) > 131071) {
    22175. 

  22175.   _luaX_syntaxerror(HEAP32[i1 + 12 >> 2] | 0, 10624);
    22176. 

  22176.  }
    22177. 

  22177.  HEAP32[i5 >> 2] = (i4 << 14) + 2147467264 | i6 & 16383;
    22178. 

  22178.  HEAP32[i3 >> 2] = -1;
    22179. 

  22179.  STACKTOP = i2;
    22180. 

  22180.  return;
    22181. 

  22181. }
    22182. 

  22182. function _luaO_str2d(i1, i3, i5) {
    22183. 

  22183.  i1 = i1 | 0;
    22184. 

  22184.  i3 = i3 | 0;
    22185. 

  22185.  i5 = i5 | 0;
    22186. 

  22186.  var i2 = 0, i4 = 0, i6 = 0, i7 = 0, i8 = 0, d9 = 0.0, i10 = 0, i11 = 0, i12 = 0, i13 = 0;
    22187. 

  22187.  i2 = STACKTOP;
    22188. 

  22188.  STACKTOP = STACKTOP + 16 | 0;
    22189. 

  22189.  i4 = i2;
    22190. 

  22190.  if ((_strpbrk(i1, 5464) | 0) != 0) {
    22191. 

  22191.   i13 = 0;
    22192. 

  22192.   STACKTOP = i2;
    22193. 

  22193.   return i13 | 0;
    22194. 

  22194.  }
    22195. 

  22195.  do {
    22196. 

  22196.   if ((_strpbrk(i1, 5472) | 0) == 0) {
    22197. 

  22197.    d9 = +_strtod(i1, i4);
    22198. 

  22198.    i10 = HEAP32[i4 >> 2] | 0;
    22199. 

  22199.   } else {
    22200. 

  22200.    HEAP32[i4 >> 2] = i1;
    22201. 

  22201.    i8 = i1;
    22202. 

  22202.    while (1) {
    22203. 

  22203.     i6 = HEAP8[i8] | 0;
    22204. 

  22204.     i10 = i8 + 1 | 0;
    22205. 

  22205.     if ((HEAP8[(i6 & 255) + 10913 | 0] & 8) == 0) {
    22206. 

  22206.      break;
    22207. 

  22207.     } else {
    22208. 

  22208.      i8 = i10;
    22209. 

  22209.     }
    22210. 

  22210.    }
    22211. 

  22211.    if (i6 << 24 >> 24 == 43) {
    22212. 

  22212.     i6 = 0;
    22213. 

  22213.     i8 = i10;
    22214. 

  22214.    } else if (i6 << 24 >> 24 == 45) {
    22215. 

  22215.     i6 = 1;
    22216. 

  22216.     i8 = i10;
    22217. 

  22217.    } else {
    22218. 

  22218.     i6 = 0;
    22219. 

  22219.    }
    22220. 

  22220.    if ((HEAP8[i8] | 0) == 48 ? (i13 = HEAP8[i8 + 1 | 0] | 0, i13 << 24 >> 24 == 88 | i13 << 24 >> 24 == 120) : 0) {
    22221. 

  22221.     i10 = i8 + 2 | 0;
    22222. 

  22222.     i8 = HEAP8[i10] | 0;
    22223. 

  22223.     i12 = i8 & 255;
    22224. 

  22224.     i11 = HEAP8[i12 + 10913 | 0] | 0;
    22225. 

  22225.     if ((i11 & 16) == 0) {
    22226. 

  22226.      d9 = 0.0;
    22227. 

  22227.      i11 = i8;
    22228. 

  22228.      i8 = 0;
    22229. 

  22229.     } else {
    22230. 

  22230.      d9 = 0.0;
    22231. 

  22231.      i8 = 0;
    22232. 

  22232.      while (1) {
    22233. 

  22233.       if ((i11 & 2) == 0) {
    22234. 

  22234.        i11 = (i12 | 32) + -87 | 0;
    22235. 

  22235.       } else {
    22236. 

  22236.        i11 = i12 + -48 | 0;
    22237. 

  22237.       }
    22238. 

  22238.       d9 = d9 * 16.0 + +(i11 | 0);
    22239. 

  22239.       i8 = i8 + 1 | 0;
    22240. 

  22240.       i10 = i10 + 1 | 0;
    22241. 

  22241.       i13 = HEAP8[i10] | 0;
    22242. 

  22242.       i12 = i13 & 255;
    22243. 

  22243.       i11 = HEAP8[i12 + 10913 | 0] | 0;
    22244. 

  22244.       if ((i11 & 16) == 0) {
    22245. 

  22245.        i11 = i13;
    22246. 

  22246.        break;
    22247. 

  22247.       }
    22248. 

  22248.      }
    22249. 

  22249.     }
    22250. 

  22250.     if (i11 << 24 >> 24 == 46) {
    22251. 

  22251.      i10 = i10 + 1 | 0;
    22252. 

  22252.      i13 = HEAPU8[i10] | 0;
    22253. 

  22253.      i11 = HEAP8[i13 + 10913 | 0] | 0;
    22254. 

  22254.      if ((i11 & 16) == 0) {
    22255. 

  22255.       i12 = 0;
    22256. 

  22256.      } else {
    22257. 

  22257.       i12 = 0;
    22258. 

  22258.       do {
    22259. 

  22259.        if ((i11 & 2) == 0) {
    22260. 

  22260.         i11 = (i13 | 32) + -87 | 0;
    22261. 

  22261.        } else {
    22262. 

  22262.         i11 = i13 + -48 | 0;
    22263. 

  22263.        }
    22264. 

  22264.        d9 = d9 * 16.0 + +(i11 | 0);
    22265. 

  22265.        i12 = i12 + 1 | 0;
    22266. 

  22266.        i10 = i10 + 1 | 0;
    22267. 

  22267.        i13 = HEAPU8[i10] | 0;
    22268. 

  22268.        i11 = HEAP8[i13 + 10913 | 0] | 0;
    22269. 

  22269.       } while (!((i11 & 16) == 0));
    22270. 

  22270.      }
    22271. 

  22271.     } else {
    22272. 

  22272.      i12 = 0;
    22273. 

  22273.     }
    22274. 

  22274.     if ((i12 | i8 | 0) != 0) {
    22275. 

  22275.      i8 = Math_imul(i12, -4) | 0;
    22276. 

  22276.      HEAP32[i4 >> 2] = i10;
    22277. 

  22277.      i13 = HEAP8[i10] | 0;
    22278. 

  22278.      if (i13 << 24 >> 24 == 80 | i13 << 24 >> 24 == 112) {
    22279. 

  22279.       i13 = i10 + 1 | 0;
    22280. 

  22280.       i11 = HEAP8[i13] | 0;
    22281. 

  22281.       if (i11 << 24 >> 24 == 45) {
    22282. 

  22282.        i11 = 1;
    22283. 

  22283.        i13 = i10 + 2 | 0;
    22284. 

  22284.       } else if (i11 << 24 >> 24 == 43) {
    22285. 

  22285.        i11 = 0;
    22286. 

  22286.        i13 = i10 + 2 | 0;
    22287. 

  22287.       } else {
    22288. 

  22288.        i11 = 0;
    22289. 

  22289.       }
    22290. 

  22290.       i12 = HEAP8[i13] | 0;
    22291. 

  22291.       if (!((HEAP8[(i12 & 255) + 10913 | 0] & 2) == 0)) {
    22292. 

  22292.        i10 = i13;
    22293. 

  22293.        i7 = 0;
    22294. 

  22294.        do {
    22295. 

  22295.         i10 = i10 + 1 | 0;
    22296. 

  22296.         i7 = (i12 << 24 >> 24) + -48 + (i7 * 10 | 0) | 0;
    22297. 

  22297.         i12 = HEAP8[i10] | 0;
    22298. 

  22298.        } while (!((HEAP8[(i12 & 255) + 10913 | 0] & 2) == 0));
    22299. 

  22299.        i8 = ((i11 | 0) == 0 ? i7 : 0 - i7 | 0) + i8 | 0;
    22300. 

  22300.        i7 = 29;
    22301. 

  22301.       }
    22302. 

  22302.      } else {
    22303. 

  22303.       i7 = 29;
    22304. 

  22304.      }
    22305. 

  22305.      if ((i7 | 0) == 29) {
    22306. 

  22306.       HEAP32[i4 >> 2] = i10;
    22307. 

  22307.      }
    22308. 

  22308.      if ((i6 | 0) != 0) {
    22309. 

  22309.       d9 = -d9;
    22310. 

  22310.      }
    22311. 

  22311.      d9 = +_ldexp(d9, i8);
    22312. 

  22312.      break;
    22313. 

  22313.     }
    22314. 

  22314.    }
    22315. 

  22315.    HEAPF64[i5 >> 3] = 0.0;
    22316. 

  22316.    i13 = 0;
    22317. 

  22317.    STACKTOP = i2;
    22318. 

  22318.    return i13 | 0;
    22319. 

  22319.   }
    22320. 

  22320.  } while (0);
    22321. 

  22321.  HEAPF64[i5 >> 3] = d9;
    22322. 

  22322.  if ((i10 | 0) == (i1 | 0)) {
    22323. 

  22323.   i13 = 0;
    22324. 

  22324.   STACKTOP = i2;
    22325. 

  22325.   return i13 | 0;
    22326. 

  22326.  }
    22327. 

  22327.  if (!((HEAP8[(HEAPU8[i10] | 0) + 10913 | 0] & 8) == 0)) {
    22328. 

  22328.   do {
    22329. 

  22329.    i10 = i10 + 1 | 0;
    22330. 

  22330.   } while (!((HEAP8[(HEAPU8[i10] | 0) + 10913 | 0] & 8) == 0));
    22331. 

  22331.   HEAP32[i4 >> 2] = i10;
    22332. 

  22332.  }
    22333. 

  22333.  i13 = (i10 | 0) == (i1 + i3 | 0) | 0;
    22334. 

  22334.  STACKTOP = i2;
    22335. 

  22335.  return i13 | 0;
    22336. 

  22336. }
    22337. 

  22337. function _luaV_equalobj_(i2, i4, i5) {
    22338. 

  22338.  i2 = i2 | 0;
    22339. 

  22339.  i4 = i4 | 0;
    22340. 

  22340.  i5 = i5 | 0;
    22341. 

  22341.  var i1 = 0, i3 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0;
    22342. 

  22342.  i1 = STACKTOP;
    22343. 

  22343.  i3 = i4 + 8 | 0;
    22344. 

  22344.  L1 : do {
    22345. 

  22345.   switch (HEAP32[i3 >> 2] & 63 | 0) {
    22346. 

  22346.   case 7:
    22347. 

  22347.    {
    22348. 

  22348.     i6 = HEAP32[i4 >> 2] | 0;
    22349. 

  22349.     i7 = HEAP32[i5 >> 2] | 0;
    22350. 

  22350.     if ((i6 | 0) == (i7 | 0)) {
    22351. 

  22351.      i7 = 1;
    22352. 

  22352.      STACKTOP = i1;
    22353. 

  22353.      return i7 | 0;
    22354. 

  22354.     }
    22355. 

  22355.     if ((i2 | 0) == 0) {
    22356. 

  22356.      i7 = 0;
    22357. 

  22357.      STACKTOP = i1;
    22358. 

  22358.      return i7 | 0;
    22359. 

  22359.     } else {
    22360. 

  22360.      i6 = _get_equalTM(i2, HEAP32[i6 + 8 >> 2] | 0, HEAP32[i7 + 8 >> 2] | 0) | 0;
    22361. 

  22361.      break L1;
    22362. 

  22362.     }
    22363. 

  22363.    }
    22364. 

  22364.   case 5:
    22365. 

  22365.    {
    22366. 

  22366.     i7 = HEAP32[i4 >> 2] | 0;
    22367. 

  22367.     i6 = HEAP32[i5 >> 2] | 0;
    22368. 

  22368.     if ((i7 | 0) == (i6 | 0)) {
    22369. 

  22369.      i7 = 1;
    22370. 

  22370.      STACKTOP = i1;
    22371. 

  22371.      return i7 | 0;
    22372. 

  22372.     }
    22373. 

  22373.     if ((i2 | 0) == 0) {
    22374. 

  22374.      i7 = 0;
    22375. 

  22375.      STACKTOP = i1;
    22376. 

  22376.      return i7 | 0;
    22377. 

  22377.     } else {
    22378. 

  22378.      i6 = _get_equalTM(i2, HEAP32[i7 + 8 >> 2] | 0, HEAP32[i6 + 8 >> 2] | 0) | 0;
    22379. 

  22379.      break L1;
    22380. 

  22380.     }
    22381. 

  22381.    }
    22382. 

  22382.   case 4:
    22383. 

  22383.    {
    22384. 

  22384.     i7 = (HEAP32[i4 >> 2] | 0) == (HEAP32[i5 >> 2] | 0) | 0;
    22385. 

  22385.     STACKTOP = i1;
    22386. 

  22386.     return i7 | 0;
    22387. 

  22387.    }
    22388. 

  22388.   case 20:
    22389. 

  22389.    {
    22390. 

  22390.     i7 = _luaS_eqlngstr(HEAP32[i4 >> 2] | 0, HEAP32[i5 >> 2] | 0) | 0;
    22391. 

  22391.     STACKTOP = i1;
    22392. 

  22392.     return i7 | 0;
    22393. 

  22393.    }
    22394. 

  22394.   case 3:
    22395. 

  22395.    {
    22396. 

  22396.     i7 = +HEAPF64[i4 >> 3] == +HEAPF64[i5 >> 3] | 0;
    22397. 

  22397.     STACKTOP = i1;
    22398. 

  22398.     return i7 | 0;
    22399. 

  22399.    }
    22400. 

  22400.   case 1:
    22401. 

  22401.    {
    22402. 

  22402.     i7 = (HEAP32[i4 >> 2] | 0) == (HEAP32[i5 >> 2] | 0) | 0;
    22403. 

  22403.     STACKTOP = i1;
    22404. 

  22404.     return i7 | 0;
    22405. 

  22405.    }
    22406. 

  22406.   case 22:
    22407. 

  22407.    {
    22408. 

  22408.     i7 = (HEAP32[i4 >> 2] | 0) == (HEAP32[i5 >> 2] | 0) | 0;
    22409. 

  22409.     STACKTOP = i1;
    22410. 

  22410.     return i7 | 0;
    22411. 

  22411.    }
    22412. 

  22412.   case 2:
    22413. 

  22413.    {
    22414. 

  22414.     i7 = (HEAP32[i4 >> 2] | 0) == (HEAP32[i5 >> 2] | 0) | 0;
    22415. 

  22415.     STACKTOP = i1;
    22416. 

  22416.     return i7 | 0;
    22417. 

  22417.    }
    22418. 

  22418.   case 0:
    22419. 

  22419.    {
    22420. 

  22420.     i7 = 1;
    22421. 

  22421.     STACKTOP = i1;
    22422. 

  22422.     return i7 | 0;
    22423. 

  22423.    }
    22424. 

  22424.   default:
    22425. 

  22425.    {
    22426. 

  22426.     i7 = (HEAP32[i4 >> 2] | 0) == (HEAP32[i5 >> 2] | 0) | 0;
    22427. 

  22427.     STACKTOP = i1;
    22428. 

  22428.     return i7 | 0;
    22429. 

  22429.    }
    22430. 

  22430.   }
    22431. 

  22431.  } while (0);
    22432. 

  22432.  if ((i6 | 0) == 0) {
    22433. 

  22433.   i7 = 0;
    22434. 

  22434.   STACKTOP = i1;
    22435. 

  22435.   return i7 | 0;
    22436. 

  22436.  }
    22437. 

  22437.  i7 = i2 + 8 | 0;
    22438. 

  22438.  i10 = HEAP32[i7 >> 2] | 0;
    22439. 

  22439.  i9 = i2 + 28 | 0;
    22440. 

  22440.  i8 = i10 - (HEAP32[i9 >> 2] | 0) | 0;
    22441. 

  22441.  HEAP32[i7 >> 2] = i10 + 16;
    22442. 

  22442.  i13 = i6;
    22443. 

  22443.  i12 = HEAP32[i13 + 4 >> 2] | 0;
    22444. 

  22444.  i11 = i10;
    22445. 

  22445.  HEAP32[i11 >> 2] = HEAP32[i13 >> 2];
    22446. 

  22446.  HEAP32[i11 + 4 >> 2] = i12;
    22447. 

  22447.  HEAP32[i10 + 8 >> 2] = HEAP32[i6 + 8 >> 2];
    22448. 

  22448.  i10 = HEAP32[i7 >> 2] | 0;
    22449. 

  22449.  HEAP32[i7 >> 2] = i10 + 16;
    22450. 

  22450.  i11 = i4;
    22451. 

  22451.  i4 = HEAP32[i11 + 4 >> 2] | 0;
    22452. 

  22452.  i6 = i10;
    22453. 

  22453.  HEAP32[i6 >> 2] = HEAP32[i11 >> 2];
    22454. 

  22454.  HEAP32[i6 + 4 >> 2] = i4;
    22455. 

  22455.  HEAP32[i10 + 8 >> 2] = HEAP32[i3 >> 2];
    22456. 

  22456.  i3 = HEAP32[i7 >> 2] | 0;
    22457. 

  22457.  HEAP32[i7 >> 2] = i3 + 16;
    22458. 

  22458.  i10 = i5;
    22459. 

  22459.  i6 = HEAP32[i10 + 4 >> 2] | 0;
    22460. 

  22460.  i4 = i3;
    22461. 

  22461.  HEAP32[i4 >> 2] = HEAP32[i10 >> 2];
    22462. 

  22462.  HEAP32[i4 + 4 >> 2] = i6;
    22463. 

  22463.  HEAP32[i3 + 8 >> 2] = HEAP32[i5 + 8 >> 2];
    22464. 

  22464.  _luaD_call(i2, (HEAP32[i7 >> 2] | 0) + -48 | 0, 1, HEAP8[(HEAP32[i2 + 16 >> 2] | 0) + 18 | 0] & 1);
    22465. 

  22465.  i2 = HEAP32[i9 >> 2] | 0;
    22466. 

  22466.  i3 = HEAP32[i7 >> 2] | 0;
    22467. 

  22467.  i4 = i3 + -16 | 0;
    22468. 

  22468.  HEAP32[i7 >> 2] = i4;
    22469. 

  22469.  i5 = HEAP32[i4 + 4 >> 2] | 0;
    22470. 

  22470.  i6 = i2 + i8 | 0;
    22471. 

  22471.  HEAP32[i6 >> 2] = HEAP32[i4 >> 2];
    22472. 

  22472.  HEAP32[i6 + 4 >> 2] = i5;
    22473. 

  22473.  HEAP32[i2 + (i8 + 8) >> 2] = HEAP32[i3 + -8 >> 2];
    22474. 

  22474.  i2 = HEAP32[i7 >> 2] | 0;
    22475. 

  22475.  i3 = HEAP32[i2 + 8 >> 2] | 0;
    22476. 

  22476.  if ((i3 | 0) != 0) {
    22477. 

  22477.   if ((i3 | 0) == 1) {
    22478. 

  22478.    i2 = (HEAP32[i2 >> 2] | 0) != 0;
    22479. 

  22479.   } else {
    22480. 

  22480.    i2 = 1;
    22481. 

  22481.   }
    22482. 

  22482.  } else {
    22483. 

  22483.   i2 = 0;
    22484. 

  22484.  }
    22485. 

  22485.  i13 = i2 & 1;
    22486. 

  22486.  STACKTOP = i1;
    22487. 

  22487.  return i13 | 0;
    22488. 

  22488. }
    22489. 

  22489. function _forbody(i1, i5, i6, i4, i9) {
    22490. 

  22490.  i1 = i1 | 0;
    22491. 

  22491.  i5 = i5 | 0;
    22492. 

  22492.  i6 = i6 | 0;
    22493. 

  22493.  i4 = i4 | 0;
    22494. 

  22494.  i9 = i9 | 0;
    22495. 

  22495.  var i2 = 0, i3 = 0, i7 = 0, i8 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0, i14 = 0, i15 = 0, i16 = 0, i17 = 0, i18 = 0, i19 = 0, i20 = 0, i21 = 0, i22 = 0;
    22496. 

  22496.  i3 = STACKTOP;
    22497. 

  22497.  STACKTOP = STACKTOP + 32 | 0;
    22498. 

  22498.  i8 = i3 + 12 | 0;
    22499. 

  22499.  i19 = i3;
    22500. 

  22500.  i11 = i1 + 48 | 0;
    22501. 

  22501.  i7 = HEAP32[i11 >> 2] | 0;
    22502. 

  22502.  i18 = i7 + 46 | 0;
    22503. 

  22503.  i22 = (HEAPU8[i18] | 0) + 3 | 0;
    22504. 

  22504.  HEAP8[i18] = i22;
    22505. 

  22505.  i21 = i7 + 20 | 0;
    22506. 

  22506.  i17 = i7 + 12 | 0;
    22507. 

  22507.  i2 = i7 + 40 | 0;
    22508. 

  22508.  i20 = HEAP32[(HEAP32[i7 >> 2] | 0) + 24 >> 2] | 0;
    22509. 

  22509.  i10 = HEAP32[HEAP32[(HEAP32[i17 >> 2] | 0) + 64 >> 2] >> 2] | 0;
    22510. 

  22510.  HEAP32[i20 + ((HEAP16[i10 + ((i22 & 255) + -3 + (HEAP32[i2 >> 2] | 0) << 1) >> 1] | 0) * 12 | 0) + 4 >> 2] = HEAP32[i21 >> 2];
    22511. 

  22511.  HEAP32[i20 + ((HEAP16[i10 + ((HEAPU8[i18] | 0) + -2 + (HEAP32[i2 >> 2] | 0) << 1) >> 1] | 0) * 12 | 0) + 4 >> 2] = HEAP32[i21 >> 2];
    22512. 

  22512.  HEAP32[i20 + ((HEAP16[i10 + ((HEAPU8[i18] | 0) + -1 + (HEAP32[i2 >> 2] | 0) << 1) >> 1] | 0) * 12 | 0) + 4 >> 2] = HEAP32[i21 >> 2];
    22513. 

  22513.  i2 = i1 + 16 | 0;
    22514. 

  22514.  if ((HEAP32[i2 >> 2] | 0) != 259) {
    22515. 

  22515.   _error_expected(i1, 259);
    22516. 

  22516.  }
    22517. 

  22517.  _luaX_next(i1);
    22518. 

  22518.  i10 = (i9 | 0) != 0;
    22519. 

  22519.  if (i10) {
    22520. 

  22520.   i9 = _luaK_codeABx(i7, 33, i5, 131070) | 0;
    22521. 

  22521.  } else {
    22522. 

  22522.   i9 = _luaK_jump(i7) | 0;
    22523. 

  22523.  }
    22524. 

  22524.  HEAP8[i19 + 10 | 0] = 0;
    22525. 

  22525.  HEAP8[i19 + 8 | 0] = HEAP8[i18] | 0;
    22526. 

  22526.  i17 = HEAP32[(HEAP32[i17 >> 2] | 0) + 64 >> 2] | 0;
    22527. 

  22527.  HEAP16[i19 + 4 >> 1] = HEAP32[i17 + 28 >> 2];
    22528. 

  22528.  HEAP16[i19 + 6 >> 1] = HEAP32[i17 + 16 >> 2];
    22529. 

  22529.  HEAP8[i19 + 9 | 0] = 0;
    22530. 

  22530.  i17 = i7 + 16 | 0;
    22531. 

  22531.  HEAP32[i19 >> 2] = HEAP32[i17 >> 2];
    22532. 

  22532.  HEAP32[i17 >> 2] = i19;
    22533. 

  22533.  i19 = HEAP32[i11 >> 2] | 0;
    22534. 

  22534.  i17 = i19 + 46 | 0;
    22535. 

  22535.  i18 = (HEAPU8[i17] | 0) + i4 | 0;
    22536. 

  22536.  HEAP8[i17] = i18;
    22537. 

  22537.  if ((i4 | 0) != 0 ? (i13 = i19 + 20 | 0, i12 = i19 + 40 | 0, i14 = HEAP32[(HEAP32[i19 >> 2] | 0) + 24 >> 2] | 0, i15 = HEAP32[HEAP32[(HEAP32[i19 + 12 >> 2] | 0) + 64 >> 2] >> 2] | 0, HEAP32[i14 + ((HEAP16[i15 + ((i18 & 255) - i4 + (HEAP32[i12 >> 2] | 0) << 1) >> 1] | 0) * 12 | 0) + 4 >> 2] = HEAP32[i13 >> 2], i16 = i4 + -1 | 0, (i16 | 0) != 0) : 0) {
    22538. 

  22538.   do {
    22539. 

  22539.    HEAP32[i14 + ((HEAP16[i15 + ((HEAPU8[i17] | 0) - i16 + (HEAP32[i12 >> 2] | 0) << 1) >> 1] | 0) * 12 | 0) + 4 >> 2] = HEAP32[i13 >> 2];
    22540. 

  22540.    i16 = i16 + -1 | 0;
    22541. 

  22541.   } while ((i16 | 0) != 0);
    22542. 

  22542.  }
    22543. 

  22543.  _luaK_reserveregs(i7, i4);
    22544. 

  22544.  i11 = HEAP32[i11 >> 2] | 0;
    22545. 

  22545.  HEAP8[i8 + 10 | 0] = 0;
    22546. 

  22546.  HEAP8[i8 + 8 | 0] = HEAP8[i11 + 46 | 0] | 0;
    22547. 

  22547.  i22 = HEAP32[(HEAP32[i11 + 12 >> 2] | 0) + 64 >> 2] | 0;
    22548. 

  22548.  HEAP16[i8 + 4 >> 1] = HEAP32[i22 + 28 >> 2];
    22549. 

  22549.  HEAP16[i8 + 6 >> 1] = HEAP32[i22 + 16 >> 2];
    22550. 

  22550.  HEAP8[i8 + 9 | 0] = 0;
    22551. 

  22551.  i22 = i11 + 16 | 0;
    22552. 

  22552.  HEAP32[i8 >> 2] = HEAP32[i22 >> 2];
    22553. 

  22553.  HEAP32[i22 >> 2] = i8;
    22554. 

  22554.  L13 : do {
    22555. 

  22555.   i8 = HEAP32[i2 >> 2] | 0;
    22556. 

  22556.   switch (i8 | 0) {
    22557. 

  22557.   case 277:
    22558. 

  22558.   case 286:
    22559. 

  22559.   case 262:
    22560. 

  22560.   case 261:
    22561. 

  22561.   case 260:
    22562. 

  22562.    {
    22563. 

  22563.     break L13;
    22564. 

  22564.    }
    22565. 

  22565.   default:
    22566. 

  22566.    {}
    22567. 

  22567.   }
    22568. 

  22568.   _statement(i1);
    22569. 

  22569.  } while ((i8 | 0) != 274);
    22570. 

  22570.  _leaveblock(i11);
    22571. 

  22571.  _leaveblock(i7);
    22572. 

  22572.  _luaK_patchtohere(i7, i9);
    22573. 

  22573.  if (i10) {
    22574. 

  22574.   i21 = _luaK_codeABx(i7, 32, i5, 131070) | 0;
    22575. 

  22575.   i22 = i9 + 1 | 0;
    22576. 

  22576.   _luaK_patchlist(i7, i21, i22);
    22577. 

  22577.   _luaK_fixline(i7, i6);
    22578. 

  22578.   STACKTOP = i3;
    22579. 

  22579.   return;
    22580. 

  22580.  } else {
    22581. 

  22581.   _luaK_codeABC(i7, 34, i5, 0, i4) | 0;
    22582. 

  22582.   _luaK_fixline(i7, i6);
    22583. 

  22583.   i21 = _luaK_codeABx(i7, 35, i5 + 2 | 0, 131070) | 0;
    22584. 

  22584.   i22 = i9 + 1 | 0;
    22585. 

  22585.   _luaK_patchlist(i7, i21, i22);
    22586. 

  22586.   _luaK_fixline(i7, i6);
    22587. 

  22587.   STACKTOP = i3;
    22588. 

  22588.   return;
    22589. 

  22589.  }
    22590. 

  22590. }
    22591. 

  22591. function _dotty(i1) {
    22592. 

  22592.  i1 = i1 | 0;
    22593. 

  22593.  var i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0;
    22594. 

  22594.  i6 = STACKTOP;
    22595. 

  22595.  STACKTOP = STACKTOP + 16 | 0;
    22596. 

  22596.  i3 = i6;
    22597. 

  22597.  i4 = i6 + 4 | 0;
    22598. 

  22598.  i2 = HEAP32[20] | 0;
    22599. 

  22599.  HEAP32[20] = 0;
    22600. 

  22600.  _lua_settop(i1, 0);
    22601. 

  22601.  if ((_pushline(i1, 1) | 0) == 0) {
    22602. 

  22602.   _lua_settop(i1, 0);
    22603. 

  22603.   i10 = HEAP32[_stdout >> 2] | 0;
    22604. 

  22604.   _fputc(10, i10 | 0) | 0;
    22605. 

  22605.   _fflush(i10 | 0) | 0;
    22606. 

  22606.   HEAP32[20] = i2;
    22607. 

  22607.   STACKTOP = i6;
    22608. 

  22608.   return;
    22609. 

  22609.  }
    22610. 

  22610.  i5 = HEAP32[_stderr >> 2] | 0;
    22611. 

  22611.  L4 : while (1) {
    22612. 

  22612.   i8 = _lua_tolstring(i1, 1, i4) | 0;
    22613. 

  22613.   i8 = _luaL_loadbufferx(i1, i8, HEAP32[i4 >> 2] | 0, 256, 0) | 0;
    22614. 

  22614.   L6 : do {
    22615. 

  22615.    if ((i8 | 0) == 3) {
    22616. 

  22616.     while (1) {
    22617. 

  22617.      i8 = _lua_tolstring(i1, -1, i3) | 0;
    22618. 

  22618.      i7 = HEAP32[i3 >> 2] | 0;
    22619. 

  22619.      if (!(i7 >>> 0 > 4)) {
    22620. 

  22620.       break;
    22621. 

  22621.      }
    22622. 

  22622.      if ((_strcmp(i8 + (i7 + -5) | 0, 264) | 0) != 0) {
    22623. 

  22623.       break;
    22624. 

  22624.      }
    22625. 

  22625.      _lua_settop(i1, -2);
    22626. 

  22626.      if ((_pushline(i1, 0) | 0) == 0) {
    22627. 

  22627.       i7 = 23;
    22628. 

  22628.       break L4;
    22629. 

  22629.      }
    22630. 

  22630.      _lua_pushlstring(i1, 184, 1) | 0;
    22631. 

  22631.      _lua_insert(i1, -2);
    22632. 

  22632.      _lua_concat(i1, 3);
    22633. 

  22633.      i8 = _lua_tolstring(i1, 1, i4) | 0;
    22634. 

  22634.      i8 = _luaL_loadbufferx(i1, i8, HEAP32[i4 >> 2] | 0, 256, 0) | 0;
    22635. 

  22635.      if ((i8 | 0) != 3) {
    22636. 

  22636.       i7 = 9;
    22637. 

  22637.       break L6;
    22638. 

  22638.      }
    22639. 

  22639.     }
    22640. 

  22640.     _lua_remove(i1, 1);
    22641. 

  22641.     i8 = 3;
    22642. 

  22642.     i7 = 10;
    22643. 

  22643.    } else {
    22644. 

  22644.     i7 = 9;
    22645. 

  22645.    }
    22646. 

  22646.   } while (0);
    22647. 

  22647.   do {
    22648. 

  22648.    if ((i7 | 0) == 9) {
    22649. 

  22649.     _lua_remove(i1, 1);
    22650. 

  22650.     if ((i8 | 0) == -1) {
    22651. 

  22651.      i7 = 23;
    22652. 

  22652.      break L4;
    22653. 

  22653.     } else if ((i8 | 0) != 0) {
    22654. 

  22654.      i7 = 10;
    22655. 

  22655.      break;
    22656. 

  22656.     }
    22657. 

  22657.     i9 = _lua_gettop(i1) | 0;
    22658. 

  22658.     _lua_pushcclosure(i1, 142, 0);
    22659. 

  22659.     _lua_insert(i1, i9);
    22660. 

  22660.     HEAP32[48] = i1;
    22661. 

  22661.     _signal(2, 1) | 0;
    22662. 

  22662.     i10 = _lua_pcallk(i1, 0, -1, i9, 0, 0) | 0;
    22663. 

  22663.     _signal(2, 0) | 0;
    22664. 

  22664.     _lua_remove(i1, i9);
    22665. 

  22665.     if ((i10 | 0) == 0) {
    22666. 

  22666.      i7 = 17;
    22667. 

  22667.     } else {
    22668. 

  22668.      i9 = 0;
    22669. 

  22669.      i7 = 12;
    22670. 

  22670.     }
    22671. 

  22671.    }
    22672. 

  22672.   } while (0);
    22673. 

  22673.   if ((i7 | 0) == 10) {
    22674. 

  22674.    i9 = (i8 | 0) == 0;
    22675. 

  22675.    i7 = 12;
    22676. 

  22676.   }
    22677. 

  22677.   do {
    22678. 

  22678.    if ((i7 | 0) == 12) {
    22679. 

  22679.     i7 = 0;
    22680. 

  22680.     if ((_lua_type(i1, -1) | 0) == 0) {
    22681. 

  22681.      if (i9) {
    22682. 

  22682.       i7 = 17;
    22683. 

  22683.       break;
    22684. 

  22684.      } else {
    22685. 

  22685.       break;
    22686. 

  22686.      }
    22687. 

  22687.     }
    22688. 

  22688.     i10 = _lua_tolstring(i1, -1, 0) | 0;
    22689. 

  22689.     i8 = HEAP32[20] | 0;
    22690. 

  22690.     if ((i8 | 0) != 0) {
    22691. 

  22691.      HEAP32[i3 >> 2] = i8;
    22692. 

  22692.      _fprintf(i5 | 0, 496, i3 | 0) | 0;
    22693. 

  22693.      _fflush(i5 | 0) | 0;
    22694. 

  22694.     }
    22695. 

  22695.     HEAP32[i3 >> 2] = (i10 | 0) == 0 ? 48 : i10;
    22696. 

  22696.     _fprintf(i5 | 0, 912, i3 | 0) | 0;
    22697. 

  22697.     _fflush(i5 | 0) | 0;
    22698. 

  22698.     _lua_settop(i1, -2);
    22699. 

  22699.     _lua_gc(i1, 2, 0) | 0;
    22700. 

  22700.     if (i9) {
    22701. 

  22701.      i7 = 17;
    22702. 

  22702.     }
    22703. 

  22703.    }
    22704. 

  22704.   } while (0);
    22705. 

  22705.   if (((i7 | 0) == 17 ? (0, (_lua_gettop(i1) | 0) > 0) : 0) ? (_luaL_checkstack(i1, 20, 112), _lua_getglobal(i1, 144), _lua_insert(i1, 1), (_lua_pcallk(i1, (_lua_gettop(i1) | 0) + -1 | 0, 0, 0, 0, 0) | 0) != 0) : 0) {
    22706. 

  22706.    i7 = HEAP32[20] | 0;
    22707. 

  22707.    HEAP32[i3 >> 2] = _lua_tolstring(i1, -1, 0) | 0;
    22708. 

  22708.    i8 = _lua_pushfstring(i1, 152, i3) | 0;
    22709. 

  22709.    if ((i7 | 0) != 0) {
    22710. 

  22710.     HEAP32[i3 >> 2] = i7;
    22711. 

  22711.     _fprintf(i5 | 0, 496, i3 | 0) | 0;
    22712. 

  22712.     _fflush(i5 | 0) | 0;
    22713. 

  22713.    }
    22714. 

  22714.    HEAP32[i3 >> 2] = i8;
    22715. 

  22715.    _fprintf(i5 | 0, 912, i3 | 0) | 0;
    22716. 

  22716.    _fflush(i5 | 0) | 0;
    22717. 

  22717.   }
    22718. 

  22718.   _lua_settop(i1, 0);
    22719. 

  22719.   if ((_pushline(i1, 1) | 0) == 0) {
    22720. 

  22720.    i7 = 23;
    22721. 

  22721.    break;
    22722. 

  22722.   }
    22723. 

  22723.  }
    22724. 

  22724.  if ((i7 | 0) == 23) {
    22725. 

  22725.   _lua_settop(i1, 0);
    22726. 

  22726.   i10 = HEAP32[_stdout >> 2] | 0;
    22727. 

  22727.   _fputc(10, i10 | 0) | 0;
    22728. 

  22728.   _fflush(i10 | 0) | 0;
    22729. 

  22729.   HEAP32[20] = i2;
    22730. 

  22730.   STACKTOP = i6;
    22731. 

  22731.   return;
    22732. 

  22732.  }
    22733. 

  22733. }
    22734. 

  22734. function _test_then_block(i5, i1) {
    22735. 

  22735.  i5 = i5 | 0;
    22736. 

  22736.  i1 = i1 | 0;
    22737. 

  22737.  var i2 = 0, i3 = 0, i4 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0, i14 = 0;
    22738. 

  22738.  i2 = STACKTOP;
    22739. 

  22739.  STACKTOP = STACKTOP + 48 | 0;
    22740. 

  22740.  i10 = i2 + 24 | 0;
    22741. 

  22741.  i9 = i2;
    22742. 

  22742.  i8 = i5 + 48 | 0;
    22743. 

  22743.  i4 = HEAP32[i8 >> 2] | 0;
    22744. 

  22744.  _luaX_next(i5);
    22745. 

  22745.  _subexpr(i5, i9, 0) | 0;
    22746. 

  22746.  i3 = i5 + 16 | 0;
    22747. 

  22747.  if ((HEAP32[i3 >> 2] | 0) != 275) {
    22748. 

  22748.   _error_expected(i5, 275);
    22749. 

  22749.  }
    22750. 

  22750.  _luaX_next(i5);
    22751. 

  22751.  i14 = HEAP32[i3 >> 2] | 0;
    22752. 

  22752.  do {
    22753. 

  22753.   if ((i14 | 0) == 258 | (i14 | 0) == 266) {
    22754. 

  22754.    _luaK_goiffalse(HEAP32[i8 >> 2] | 0, i9);
    22755. 

  22755.    HEAP8[i10 + 10 | 0] = 0;
    22756. 

  22756.    HEAP8[i10 + 8 | 0] = HEAP8[i4 + 46 | 0] | 0;
    22757. 

  22757.    i11 = HEAP32[(HEAP32[i4 + 12 >> 2] | 0) + 64 >> 2] | 0;
    22758. 

  22758.    HEAP16[i10 + 4 >> 1] = HEAP32[i11 + 28 >> 2];
    22759. 

  22759.    HEAP16[i10 + 6 >> 1] = HEAP32[i11 + 16 >> 2];
    22760. 

  22760.    HEAP8[i10 + 9 | 0] = 0;
    22761. 

  22761.    i11 = i4 + 16 | 0;
    22762. 

  22762.    HEAP32[i10 >> 2] = HEAP32[i11 >> 2];
    22763. 

  22763.    HEAP32[i11 >> 2] = i10;
    22764. 

  22764.    i11 = HEAP32[i9 + 16 >> 2] | 0;
    22765. 

  22765.    i10 = HEAP32[i5 + 4 >> 2] | 0;
    22766. 

  22766.    i14 = (HEAP32[i3 >> 2] | 0) == 266;
    22767. 

  22767.    _luaX_next(i5);
    22768. 

  22768.    do {
    22769. 

  22769.     if (i14) {
    22770. 

  22770.      if ((HEAP32[i3 >> 2] | 0) == 288) {
    22771. 

  22771.       i7 = HEAP32[i5 + 24 >> 2] | 0;
    22772. 

  22772.       _luaX_next(i5);
    22773. 

  22773.       break;
    22774. 

  22774.      } else {
    22775. 

  22775.       _error_expected(i5, 288);
    22776. 

  22776.      }
    22777. 

  22777.     } else {
    22778. 

  22778.      i7 = _luaS_new(HEAP32[i5 + 52 >> 2] | 0, 6304) | 0;
    22779. 

  22779.     }
    22780. 

  22780.    } while (0);
    22781. 

  22781.    i14 = HEAP32[i5 + 64 >> 2] | 0;
    22782. 

  22782.    i12 = i14 + 12 | 0;
    22783. 

  22783.    i13 = i14 + 16 | 0;
    22784. 

  22784.    i9 = HEAP32[i13 >> 2] | 0;
    22785. 

  22785.    i14 = i14 + 20 | 0;
    22786. 

  22786.    if ((i9 | 0) < (HEAP32[i14 >> 2] | 0)) {
    22787. 

  22787.     i14 = HEAP32[i12 >> 2] | 0;
    22788. 

  22788.    } else {
    22789. 

  22789.     i14 = _luaM_growaux_(HEAP32[i5 + 52 >> 2] | 0, HEAP32[i12 >> 2] | 0, i14, 16, 32767, 6312) | 0;
    22790. 

  22790.     HEAP32[i12 >> 2] = i14;
    22791. 

  22791.    }
    22792. 

  22792.    HEAP32[i14 + (i9 << 4) >> 2] = i7;
    22793. 

  22793.    i14 = HEAP32[i12 >> 2] | 0;
    22794. 

  22794.    HEAP32[i14 + (i9 << 4) + 8 >> 2] = i10;
    22795. 

  22795.    HEAP8[i14 + (i9 << 4) + 12 | 0] = HEAP8[(HEAP32[i8 >> 2] | 0) + 46 | 0] | 0;
    22796. 

  22796.    HEAP32[(HEAP32[i12 >> 2] | 0) + (i9 << 4) + 4 >> 2] = i11;
    22797. 

  22797.    HEAP32[i13 >> 2] = (HEAP32[i13 >> 2] | 0) + 1;
    22798. 

  22798.    _findlabel(i5, i9) | 0;
    22799. 

  22799.    L18 : while (1) {
    22800. 

  22800.     switch (HEAP32[i3 >> 2] | 0) {
    22801. 

  22801.     case 286:
    22802. 

  22802.     case 262:
    22803. 

  22803.     case 261:
    22804. 

  22804.     case 260:
    22805. 

  22805.      {
    22806. 

  22806.       break L18;
    22807. 

  22807.      }
    22808. 

  22808.     case 285:
    22809. 

  22809.     case 59:
    22810. 

  22810.      {
    22811. 

  22811.       break;
    22812. 

  22812.      }
    22813. 

  22813.     default:
    22814. 

  22814.      {
    22815. 

  22815.       i6 = 16;
    22816. 

  22816.       break L18;
    22817. 

  22817.      }
    22818. 

  22818.     }
    22819. 

  22819.     _statement(i5);
    22820. 

  22820.    }
    22821. 

  22821.    if ((i6 | 0) == 16) {
    22822. 

  22822.     i6 = _luaK_jump(i4) | 0;
    22823. 

  22823.     break;
    22824. 

  22824.    }
    22825. 

  22825.    _leaveblock(i4);
    22826. 

  22826.    STACKTOP = i2;
    22827. 

  22827.    return;
    22828. 

  22828.   } else {
    22829. 

  22829.    _luaK_goiftrue(HEAP32[i8 >> 2] | 0, i9);
    22830. 

  22830.    HEAP8[i10 + 10 | 0] = 0;
    22831. 

  22831.    HEAP8[i10 + 8 | 0] = HEAP8[i4 + 46 | 0] | 0;
    22832. 

  22832.    i6 = HEAP32[(HEAP32[i4 + 12 >> 2] | 0) + 64 >> 2] | 0;
    22833. 

  22833.    HEAP16[i10 + 4 >> 1] = HEAP32[i6 + 28 >> 2];
    22834. 

  22834.    HEAP16[i10 + 6 >> 1] = HEAP32[i6 + 16 >> 2];
    22835. 

  22835.    HEAP8[i10 + 9 | 0] = 0;
    22836. 

  22836.    i6 = i4 + 16 | 0;
    22837. 

  22837.    HEAP32[i10 >> 2] = HEAP32[i6 >> 2];
    22838. 

  22838.    HEAP32[i6 >> 2] = i10;
    22839. 

  22839.    i6 = HEAP32[i9 + 20 >> 2] | 0;
    22840. 

  22840.   }
    22841. 

  22841.  } while (0);
    22842. 

  22842.  L26 : do {
    22843. 

  22843.   i7 = HEAP32[i3 >> 2] | 0;
    22844. 

  22844.   switch (i7 | 0) {
    22845. 

  22845.   case 277:
    22846. 

  22846.   case 286:
    22847. 

  22847.   case 262:
    22848. 

  22848.   case 261:
    22849. 

  22849.   case 260:
    22850. 

  22850.    {
    22851. 

  22851.     break L26;
    22852. 

  22852.    }
    22853. 

  22853.   default:
    22854. 

  22854.    {}
    22855. 

  22855.   }
    22856. 

  22856.   _statement(i5);
    22857. 

  22857.  } while ((i7 | 0) != 274);
    22858. 

  22858.  _leaveblock(i4);
    22859. 

  22859.  if (((HEAP32[i3 >> 2] | 0) + -260 | 0) >>> 0 < 2) {
    22860. 

  22860.   _luaK_concat(i4, i1, _luaK_jump(i4) | 0);
    22861. 

  22861.  }
    22862. 

  22862.  _luaK_patchtohere(i4, i6);
    22863. 

  22863.  STACKTOP = i2;
    22864. 

  22864.  return;
    22865. 

  22865. }
    22866. 

  22866. function _luaL_gsub(i2, i13, i11, i10) {
    22867. 

  22867.  i2 = i2 | 0;
    22868. 

  22868.  i13 = i13 | 0;
    22869. 

  22869.  i11 = i11 | 0;
    22870. 

  22870.  i10 = i10 | 0;
    22871. 

  22871.  var i1 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i12 = 0, i14 = 0, i15 = 0, i16 = 0, i17 = 0;
    22872. 

  22872.  i1 = STACKTOP;
    22873. 

  22873.  STACKTOP = STACKTOP + 1056 | 0;
    22874. 

  22874.  i8 = i1;
    22875. 

  22875.  i4 = i1 + 8 | 0;
    22876. 

  22876.  i9 = _strlen(i11 | 0) | 0;
    22877. 

  22877.  i6 = i4 + 12 | 0;
    22878. 

  22878.  HEAP32[i6 >> 2] = i2;
    22879. 

  22879.  i3 = i4 + 16 | 0;
    22880. 

  22880.  HEAP32[i4 >> 2] = i3;
    22881. 

  22881.  i5 = i4 + 8 | 0;
    22882. 

  22882.  HEAP32[i5 >> 2] = 0;
    22883. 

  22883.  i7 = i4 + 4 | 0;
    22884. 

  22884.  HEAP32[i7 >> 2] = 1024;
    22885. 

  22885.  i12 = _strstr(i13, i11) | 0;
    22886. 

  22886.  if ((i12 | 0) == 0) {
    22887. 

  22887.   i14 = 0;
    22888. 

  22888.   i17 = 1024;
    22889. 

  22889.   i16 = i2;
    22890. 

  22890.  } else {
    22891. 

  22891.   i14 = 0;
    22892. 

  22892.   i17 = 1024;
    22893. 

  22893.   i16 = i2;
    22894. 

  22894.   do {
    22895. 

  22895.    i15 = i12 - i13 | 0;
    22896. 

  22896.    if ((i17 - i14 | 0) >>> 0 < i15 >>> 0) {
    22897. 

  22897.     i17 = i17 << 1;
    22898. 

  22898.     i17 = (i17 - i14 | 0) >>> 0 < i15 >>> 0 ? i14 + i15 | 0 : i17;
    22899. 

  22899.     if (i17 >>> 0 < i14 >>> 0 | (i17 - i14 | 0) >>> 0 < i15 >>> 0) {
    22900. 

  22900.      _luaL_error(i16, 1272, i8) | 0;
    22901. 

  22901.     }
    22902. 

  22902.     i14 = _lua_newuserdata(i16, i17) | 0;
    22903. 

  22903.     _memcpy(i14 | 0, HEAP32[i4 >> 2] | 0, HEAP32[i5 >> 2] | 0) | 0;
    22904. 

  22904.     if ((HEAP32[i4 >> 2] | 0) != (i3 | 0)) {
    22905. 

  22905.      _lua_remove(i16, -2);
    22906. 

  22906.     }
    22907. 

  22907.     HEAP32[i4 >> 2] = i14;
    22908. 

  22908.     HEAP32[i7 >> 2] = i17;
    22909. 

  22909.     i16 = i14;
    22910. 

  22910.     i14 = HEAP32[i5 >> 2] | 0;
    22911. 

  22911.    } else {
    22912. 

  22912.     i16 = HEAP32[i4 >> 2] | 0;
    22913. 

  22913.    }
    22914. 

  22914.    _memcpy(i16 + i14 | 0, i13 | 0, i15 | 0) | 0;
    22915. 

  22915.    i15 = (HEAP32[i5 >> 2] | 0) + i15 | 0;
    22916. 

  22916.    HEAP32[i5 >> 2] = i15;
    22917. 

  22917.    i13 = _strlen(i10 | 0) | 0;
    22918. 

  22918.    i14 = HEAP32[i6 >> 2] | 0;
    22919. 

  22919.    i16 = HEAP32[i7 >> 2] | 0;
    22920. 

  22920.    if ((i16 - i15 | 0) >>> 0 < i13 >>> 0) {
    22921. 

  22921.     i16 = i16 << 1;
    22922. 

  22922.     i16 = (i16 - i15 | 0) >>> 0 < i13 >>> 0 ? i15 + i13 | 0 : i16;
    22923. 

  22923.     if (i16 >>> 0 < i15 >>> 0 | (i16 - i15 | 0) >>> 0 < i13 >>> 0) {
    22924. 

  22924.      _luaL_error(i14, 1272, i8) | 0;
    22925. 

  22925.     }
    22926. 

  22926.     i15 = _lua_newuserdata(i14, i16) | 0;
    22927. 

  22927.     _memcpy(i15 | 0, HEAP32[i4 >> 2] | 0, HEAP32[i5 >> 2] | 0) | 0;
    22928. 

  22928.     if ((HEAP32[i4 >> 2] | 0) != (i3 | 0)) {
    22929. 

  22929.      _lua_remove(i14, -2);
    22930. 

  22930.     }
    22931. 

  22931.     HEAP32[i4 >> 2] = i15;
    22932. 

  22932.     HEAP32[i7 >> 2] = i16;
    22933. 

  22933.     i14 = i15;
    22934. 

  22934.     i15 = HEAP32[i5 >> 2] | 0;
    22935. 

  22935.    } else {
    22936. 

  22936.     i14 = HEAP32[i4 >> 2] | 0;
    22937. 

  22937.    }
    22938. 

  22938.    _memcpy(i14 + i15 | 0, i10 | 0, i13 | 0) | 0;
    22939. 

  22939.    i14 = (HEAP32[i5 >> 2] | 0) + i13 | 0;
    22940. 

  22940.    HEAP32[i5 >> 2] = i14;
    22941. 

  22941.    i13 = i12 + i9 | 0;
    22942. 

  22942.    i12 = _strstr(i13, i11) | 0;
    22943. 

  22943.    i16 = HEAP32[i6 >> 2] | 0;
    22944. 

  22944.    i17 = HEAP32[i7 >> 2] | 0;
    22945. 

  22945.   } while ((i12 | 0) != 0);
    22946. 

  22946.  }
    22947. 

  22947.  i9 = _strlen(i13 | 0) | 0;
    22948. 

  22948.  if ((i17 - i14 | 0) >>> 0 < i9 >>> 0) {
    22949. 

  22949.   i10 = i17 << 1;
    22950. 

  22950.   i10 = (i10 - i14 | 0) >>> 0 < i9 >>> 0 ? i14 + i9 | 0 : i10;
    22951. 

  22951.   if (i10 >>> 0 < i14 >>> 0 | (i10 - i14 | 0) >>> 0 < i9 >>> 0) {
    22952. 

  22952.    _luaL_error(i16, 1272, i8) | 0;
    22953. 

  22953.   }
    22954. 

  22954.   i8 = _lua_newuserdata(i16, i10) | 0;
    22955. 

  22955.   _memcpy(i8 | 0, HEAP32[i4 >> 2] | 0, HEAP32[i5 >> 2] | 0) | 0;
    22956. 

  22956.   if ((HEAP32[i4 >> 2] | 0) != (i3 | 0)) {
    22957. 

  22957.    _lua_remove(i16, -2);
    22958. 

  22958.   }
    22959. 

  22959.   HEAP32[i4 >> 2] = i8;
    22960. 

  22960.   HEAP32[i7 >> 2] = i10;
    22961. 

  22961.   i14 = HEAP32[i5 >> 2] | 0;
    22962. 

  22962.  } else {
    22963. 

  22963.   i8 = HEAP32[i4 >> 2] | 0;
    22964. 

  22964.  }
    22965. 

  22965.  _memcpy(i8 + i14 | 0, i13 | 0, i9 | 0) | 0;
    22966. 

  22966.  i17 = (HEAP32[i5 >> 2] | 0) + i9 | 0;
    22967. 

  22967.  HEAP32[i5 >> 2] = i17;
    22968. 

  22968.  i5 = HEAP32[i6 >> 2] | 0;
    22969. 

  22969.  _lua_pushlstring(i5, HEAP32[i4 >> 2] | 0, i17) | 0;
    22970. 

  22970.  if ((HEAP32[i4 >> 2] | 0) == (i3 | 0)) {
    22971. 

  22971.   i17 = _lua_tolstring(i2, -1, 0) | 0;
    22972. 

  22972.   STACKTOP = i1;
    22973. 

  22973.   return i17 | 0;
    22974. 

  22974.  }
    22975. 

  22975.  _lua_remove(i5, -2);
    22976. 

  22976.  i17 = _lua_tolstring(i2, -1, 0) | 0;
    22977. 

  22977.  STACKTOP = i1;
    22978. 

  22978.  return i17 | 0;
    22979. 

  22979. }
    22980. 

  22980. function _luaK_goiffalse(i1, i3) {
    22981. 

  22981.  i1 = i1 | 0;
    22982. 

  22982.  i3 = i3 | 0;
    22983. 

  22983.  var i2 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0;
    22984. 

  22984.  i2 = STACKTOP;
    22985. 

  22985.  _luaK_dischargevars(i1, i3);
    22986. 

  22986.  i9 = HEAP32[i3 >> 2] | 0;
    22987. 

  22987.  do {
    22988. 

  22988.   if ((i9 | 0) == 10) {
    22989. 

  22989.    i4 = HEAP32[i3 + 8 >> 2] | 0;
    22990. 

  22990.    i8 = 15;
    22991. 

  22991.   } else if (!((i9 | 0) == 3 | (i9 | 0) == 1)) {
    22992. 

  22992.    i4 = i3 + 8 | 0;
    22993. 

  22993.    if ((i9 | 0) == 6) {
    22994. 

  22994.     i8 = 11;
    22995. 

  22995.    } else if ((i9 | 0) == 11 ? (i10 = HEAP32[(HEAP32[(HEAP32[i1 >> 2] | 0) + 12 >> 2] | 0) + (HEAP32[i4 >> 2] << 2) >> 2] | 0, (i10 & 63 | 0) == 20) : 0) {
    22996. 

  22996.     i4 = i1 + 20 | 0;
    22997. 

  22997.     HEAP32[i4 >> 2] = (HEAP32[i4 >> 2] | 0) + -1;
    22998. 

  22998.     i4 = _condjump(i1, 27, i10 >>> 23, 0, 0) | 0;
    22999. 

  22999.     i8 = 15;
    23000. 

  23000.     break;
    23001. 

  23001.    } else {
    23002. 

  23002.     i8 = 6;
    23003. 

  23003.    }
    23004. 

  23004.    if ((i8 | 0) == 6) {
    23005. 

  23005.     i9 = i1 + 48 | 0;
    23006. 

  23006.     i11 = HEAP8[i9] | 0;
    23007. 

  23007.     i10 = (i11 & 255) + 1 | 0;
    23008. 

  23008.     i12 = (HEAP32[i1 >> 2] | 0) + 78 | 0;
    23009. 

  23009.     do {
    23010. 

  23010.      if (i10 >>> 0 > (HEAPU8[i12] | 0) >>> 0) {
    23011. 

  23011.       if (i10 >>> 0 > 249) {
    23012. 

  23012.        _luaX_syntaxerror(HEAP32[i1 + 12 >> 2] | 0, 10536);
    23013. 

  23013.       } else {
    23014. 

  23014.        HEAP8[i12] = i10;
    23015. 

  23015.        i7 = HEAP8[i9] | 0;
    23016. 

  23016.        break;
    23017. 

  23017.       }
    23018. 

  23018.      } else {
    23019. 

  23019.       i7 = i11;
    23020. 

  23020.      }
    23021. 

  23021.     } while (0);
    23022. 

  23022.     i12 = (i7 & 255) + 1 | 0;
    23023. 

  23023.     HEAP8[i9] = i12;
    23024. 

  23024.     _discharge2reg(i1, i3, (i12 & 255) + -1 | 0);
    23025. 

  23025.     if ((HEAP32[i3 >> 2] | 0) == 6) {
    23026. 

  23026.      i8 = 11;
    23027. 

  23027.     }
    23028. 

  23028.    }
    23029. 

  23029.    if (((i8 | 0) == 11 ? (i6 = HEAP32[i4 >> 2] | 0, (i6 & 256 | 0) == 0) : 0) ? (HEAPU8[i1 + 46 | 0] | 0 | 0) <= (i6 | 0) : 0) {
    23030. 

  23030.     i12 = i1 + 48 | 0;
    23031. 

  23031.     HEAP8[i12] = (HEAP8[i12] | 0) + -1 << 24 >> 24;
    23032. 

  23032.    }
    23033. 

  23033.    i4 = _condjump(i1, 28, 255, HEAP32[i4 >> 2] | 0, 1) | 0;
    23034. 

  23034.    i8 = 15;
    23035. 

  23035.   }
    23036. 

  23036.  } while (0);
    23037. 

  23037.  do {
    23038. 

  23038.   if ((i8 | 0) == 15 ? (i5 = i3 + 16 | 0, !((i4 | 0) == -1)) : 0) {
    23039. 

  23039.    i8 = HEAP32[i5 >> 2] | 0;
    23040. 

  23040.    if ((i8 | 0) == -1) {
    23041. 

  23041.     HEAP32[i5 >> 2] = i4;
    23042. 

  23042.     break;
    23043. 

  23043.    }
    23044. 

  23044.    i5 = HEAP32[(HEAP32[i1 >> 2] | 0) + 12 >> 2] | 0;
    23045. 

  23045.    while (1) {
    23046. 

  23046.     i7 = i5 + (i8 << 2) | 0;
    23047. 

  23047.     i6 = HEAP32[i7 >> 2] | 0;
    23048. 

  23048.     i9 = (i6 >>> 14) + -131071 | 0;
    23049. 

  23049.     if ((i9 | 0) == -1) {
    23050. 

  23050.      break;
    23051. 

  23051.     }
    23052. 

  23052.     i9 = i8 + 1 + i9 | 0;
    23053. 

  23053.     if ((i9 | 0) == -1) {
    23054. 

  23054.      break;
    23055. 

  23055.     } else {
    23056. 

  23056.      i8 = i9;
    23057. 

  23057.     }
    23058. 

  23058.    }
    23059. 

  23059.    i4 = i4 + ~i8 | 0;
    23060. 

  23060.    if ((((i4 | 0) > -1 ? i4 : 0 - i4 | 0) | 0) > 131071) {
    23061. 

  23061.     _luaX_syntaxerror(HEAP32[i1 + 12 >> 2] | 0, 10624);
    23062. 

  23062.    } else {
    23063. 

  23063.     HEAP32[i7 >> 2] = (i4 << 14) + 2147467264 | i6 & 16383;
    23064. 

  23064.     break;
    23065. 

  23065.    }
    23066. 

  23066.   }
    23067. 

  23067.  } while (0);
    23068. 

  23068.  i3 = i3 + 20 | 0;
    23069. 

  23069.  i4 = HEAP32[i3 >> 2] | 0;
    23070. 

  23070.  HEAP32[i1 + 24 >> 2] = HEAP32[i1 + 20 >> 2];
    23071. 

  23071.  i5 = i1 + 28 | 0;
    23072. 

  23072.  if ((i4 | 0) == -1) {
    23073. 

  23073.   HEAP32[i3 >> 2] = -1;
    23074. 

  23074.   STACKTOP = i2;
    23075. 

  23075.   return;
    23076. 

  23076.  }
    23077. 

  23077.  i8 = HEAP32[i5 >> 2] | 0;
    23078. 

  23078.  if ((i8 | 0) == -1) {
    23079. 

  23079.   HEAP32[i5 >> 2] = i4;
    23080. 

  23080.   HEAP32[i3 >> 2] = -1;
    23081. 

  23081.   STACKTOP = i2;
    23082. 

  23082.   return;
    23083. 

  23083.  }
    23084. 

  23084.  i7 = HEAP32[(HEAP32[i1 >> 2] | 0) + 12 >> 2] | 0;
    23085. 

  23085.  while (1) {
    23086. 

  23086.   i5 = i7 + (i8 << 2) | 0;
    23087. 

  23087.   i6 = HEAP32[i5 >> 2] | 0;
    23088. 

  23088.   i9 = (i6 >>> 14) + -131071 | 0;
    23089. 

  23089.   if ((i9 | 0) == -1) {
    23090. 

  23090.    break;
    23091. 

  23091.   }
    23092. 

  23092.   i9 = i8 + 1 + i9 | 0;
    23093. 

  23093.   if ((i9 | 0) == -1) {
    23094. 

  23094.    break;
    23095. 

  23095.   } else {
    23096. 

  23096.    i8 = i9;
    23097. 

  23097.   }
    23098. 

  23098.  }
    23099. 

  23099.  i4 = i4 + ~i8 | 0;
    23100. 

  23100.  if ((((i4 | 0) > -1 ? i4 : 0 - i4 | 0) | 0) > 131071) {
    23101. 

  23101.   _luaX_syntaxerror(HEAP32[i1 + 12 >> 2] | 0, 10624);
    23102. 

  23102.  }
    23103. 

  23103.  HEAP32[i5 >> 2] = (i4 << 14) + 2147467264 | i6 & 16383;
    23104. 

  23104.  HEAP32[i3 >> 2] = -1;
    23105. 

  23105.  STACKTOP = i2;
    23106. 

  23106.  return;
    23107. 

  23107. }
    23108. 

  23108. function _luaV_settable(i2, i11, i7, i9) {
    23109. 

  23109.  i2 = i2 | 0;
    23110. 

  23110.  i11 = i11 | 0;
    23111. 

  23111.  i7 = i7 | 0;
    23112. 

  23112.  i9 = i9 | 0;
    23113. 

  23113.  var i1 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i8 = 0, i10 = 0, i12 = 0, i13 = 0, i14 = 0;
    23114. 

  23114.  i6 = STACKTOP;
    23115. 

  23115.  STACKTOP = STACKTOP + 16 | 0;
    23116. 

  23116.  i5 = i6;
    23117. 

  23117.  i4 = i2 + 12 | 0;
    23118. 

  23118.  i3 = i11;
    23119. 

  23119.  i13 = HEAP32[i11 + 8 >> 2] | 0;
    23120. 

  23120.  i12 = 0;
    23121. 

  23121.  while (1) {
    23122. 

  23122.   i11 = i3 + 8 | 0;
    23123. 

  23123.   if ((i13 | 0) != 69) {
    23124. 

  23124.    i14 = _luaT_gettmbyobj(i2, i3, 1) | 0;
    23125. 

  23125.    i13 = HEAP32[i14 + 8 >> 2] | 0;
    23126. 

  23126.    if ((i13 | 0) == 0) {
    23127. 

  23127.     i1 = 16;
    23128. 

  23128.     break;
    23129. 

  23129.    }
    23130. 

  23130.   } else {
    23131. 

  23131.    i8 = HEAP32[i3 >> 2] | 0;
    23132. 

  23132.    i13 = _luaH_get(i8, i7) | 0;
    23133. 

  23133.    if ((HEAP32[i13 + 8 >> 2] | 0) != 0) {
    23134. 

  23134.     i10 = i13;
    23135. 

  23135.     break;
    23136. 

  23136.    }
    23137. 

  23137.    i14 = HEAP32[i8 + 8 >> 2] | 0;
    23138. 

  23138.    if ((i14 | 0) == 0) {
    23139. 

  23139.     i1 = 9;
    23140. 

  23140.     break;
    23141. 

  23141.    }
    23142. 

  23142.    if (!((HEAP8[i14 + 6 | 0] & 2) == 0)) {
    23143. 

  23143.     i1 = 9;
    23144. 

  23144.     break;
    23145. 

  23145.    }
    23146. 

  23146.    i14 = _luaT_gettm(i14, 1, HEAP32[(HEAP32[i4 >> 2] | 0) + 188 >> 2] | 0) | 0;
    23147. 

  23147.    if ((i14 | 0) == 0) {
    23148. 

  23148.     i1 = 9;
    23149. 

  23149.     break;
    23150. 

  23150.    }
    23151. 

  23151.    i13 = HEAP32[i14 + 8 >> 2] | 0;
    23152. 

  23152.   }
    23153. 

  23153.   i12 = i12 + 1 | 0;
    23154. 

  23154.   if ((i13 & 15 | 0) == 6) {
    23155. 

  23155.    i1 = 18;
    23156. 

  23156.    break;
    23157. 

  23157.   }
    23158. 

  23158.   if ((i12 | 0) < 100) {
    23159. 

  23159.    i3 = i14;
    23160. 

  23160.   } else {
    23161. 

  23161.    i1 = 19;
    23162. 

  23162.    break;
    23163. 

  23163.   }
    23164. 

  23164.  }
    23165. 

  23165.  if ((i1 | 0) == 9) {
    23166. 

  23166.   if ((i13 | 0) == 5192) {
    23167. 

  23167.    i10 = _luaH_newkey(i2, i8, i7) | 0;
    23168. 

  23168.   } else {
    23169. 

  23169.    i10 = i13;
    23170. 

  23170.   }
    23171. 

  23171.  } else if ((i1 | 0) == 16) {
    23172. 

  23172.   _luaG_typeerror(i2, i3, 8944);
    23173. 

  23173.  } else if ((i1 | 0) == 18) {
    23174. 

  23174.   i13 = i2 + 8 | 0;
    23175. 

  23175.   i8 = HEAP32[i13 >> 2] | 0;
    23176. 

  23176.   HEAP32[i13 >> 2] = i8 + 16;
    23177. 

  23177.   i5 = i14;
    23178. 

  23178.   i12 = HEAP32[i5 + 4 >> 2] | 0;
    23179. 

  23179.   i10 = i8;
    23180. 

  23180.   HEAP32[i10 >> 2] = HEAP32[i5 >> 2];
    23181. 

  23181.   HEAP32[i10 + 4 >> 2] = i12;
    23182. 

  23182.   HEAP32[i8 + 8 >> 2] = HEAP32[i14 + 8 >> 2];
    23183. 

  23183.   i14 = HEAP32[i13 >> 2] | 0;
    23184. 

  23184.   HEAP32[i13 >> 2] = i14 + 16;
    23185. 

  23185.   i8 = i3;
    23186. 

  23186.   i10 = HEAP32[i8 + 4 >> 2] | 0;
    23187. 

  23187.   i12 = i14;
    23188. 

  23188.   HEAP32[i12 >> 2] = HEAP32[i8 >> 2];
    23189. 

  23189.   HEAP32[i12 + 4 >> 2] = i10;
    23190. 

  23190.   HEAP32[i14 + 8 >> 2] = HEAP32[i11 >> 2];
    23191. 

  23191.   i14 = HEAP32[i13 >> 2] | 0;
    23192. 

  23192.   HEAP32[i13 >> 2] = i14 + 16;
    23193. 

  23193.   i12 = i7;
    23194. 

  23194.   i11 = HEAP32[i12 + 4 >> 2] | 0;
    23195. 

  23195.   i10 = i14;
    23196. 

  23196.   HEAP32[i10 >> 2] = HEAP32[i12 >> 2];
    23197. 

  23197.   HEAP32[i10 + 4 >> 2] = i11;
    23198. 

  23198.   HEAP32[i14 + 8 >> 2] = HEAP32[i7 + 8 >> 2];
    23199. 

  23199.   i14 = HEAP32[i13 >> 2] | 0;
    23200. 

  23200.   HEAP32[i13 >> 2] = i14 + 16;
    23201. 

  23201.   i10 = i9;
    23202. 

  23202.   i11 = HEAP32[i10 + 4 >> 2] | 0;
    23203. 

  23203.   i12 = i14;
    23204. 

  23204.   HEAP32[i12 >> 2] = HEAP32[i10 >> 2];
    23205. 

  23205.   HEAP32[i12 + 4 >> 2] = i11;
    23206. 

  23206.   HEAP32[i14 + 8 >> 2] = HEAP32[i9 + 8 >> 2];
    23207. 

  23207.   _luaD_call(i2, (HEAP32[i13 >> 2] | 0) + -64 | 0, 0, HEAP8[(HEAP32[i2 + 16 >> 2] | 0) + 18 | 0] & 1);
    23208. 

  23208.   STACKTOP = i6;
    23209. 

  23209.   return;
    23210. 

  23210.  } else if ((i1 | 0) == 19) {
    23211. 

  23211.   _luaG_runerror(i2, 8976, i5);
    23212. 

  23212.  }
    23213. 

  23213.  i12 = i9;
    23214. 

  23214.  i13 = HEAP32[i12 + 4 >> 2] | 0;
    23215. 

  23215.  i14 = i10;
    23216. 

  23216.  HEAP32[i14 >> 2] = HEAP32[i12 >> 2];
    23217. 

  23217.  HEAP32[i14 + 4 >> 2] = i13;
    23218. 

  23218.  i14 = i9 + 8 | 0;
    23219. 

  23219.  HEAP32[i10 + 8 >> 2] = HEAP32[i14 >> 2];
    23220. 

  23220.  HEAP8[i8 + 6 | 0] = 0;
    23221. 

  23221.  if ((HEAP32[i14 >> 2] & 64 | 0) == 0) {
    23222. 

  23222.   STACKTOP = i6;
    23223. 

  23223.   return;
    23224. 

  23224.  }
    23225. 

  23225.  if ((HEAP8[(HEAP32[i9 >> 2] | 0) + 5 | 0] & 3) == 0) {
    23226. 

  23226.   STACKTOP = i6;
    23227. 

  23227.   return;
    23228. 

  23228.  }
    23229. 

  23229.  if ((HEAP8[i8 + 5 | 0] & 4) == 0) {
    23230. 

  23230.   STACKTOP = i6;
    23231. 

  23231.   return;
    23232. 

  23232.  }
    23233. 

  23233.  _luaC_barrierback_(i2, i8);
    23234. 

  23234.  STACKTOP = i6;
    23235. 

  23235.  return;
    23236. 

  23236. }
    23237. 

  23237. function _luaK_code(i4, i5) {
    23238. 

  23238.  i4 = i4 | 0;
    23239. 

  23239.  i5 = i5 | 0;
    23240. 

  23240.  var i1 = 0, i2 = 0, i3 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0, i14 = 0, i15 = 0, i16 = 0, i17 = 0;
    23241. 

  23241.  i2 = STACKTOP;
    23242. 

  23242.  i1 = HEAP32[i4 >> 2] | 0;
    23243. 

  23243.  i7 = i4 + 28 | 0;
    23244. 

  23244.  i15 = HEAP32[i7 >> 2] | 0;
    23245. 

  23245.  i3 = i4 + 20 | 0;
    23246. 

  23246.  i8 = HEAP32[i3 >> 2] | 0;
    23247. 

  23247.  do {
    23248. 

  23248.   if (!((i15 | 0) == -1)) {
    23249. 

  23249.    i11 = HEAP32[i1 + 12 >> 2] | 0;
    23250. 

  23250.    while (1) {
    23251. 

  23251.     i12 = i11 + (i15 << 2) | 0;
    23252. 

  23252.     i14 = HEAP32[i12 >> 2] | 0;
    23253. 

  23253.     i13 = (i14 >>> 14) + -131071 | 0;
    23254. 

  23254.     if ((i13 | 0) == -1) {
    23255. 

  23255.      i13 = -1;
    23256. 

  23256.     } else {
    23257. 

  23257.      i13 = i15 + 1 + i13 | 0;
    23258. 

  23258.     }
    23259. 

  23259.     if ((i15 | 0) > 0 ? (i9 = i11 + (i15 + -1 << 2) | 0, i10 = HEAP32[i9 >> 2] | 0, (HEAP8[5584 + (i10 & 63) | 0] | 0) < 0) : 0) {
    23260. 

  23260.      i17 = i9;
    23261. 

  23261.      i16 = i10;
    23262. 

  23262.     } else {
    23263. 

  23263.      i17 = i12;
    23264. 

  23264.      i16 = i14;
    23265. 

  23265.     }
    23266. 

  23266.     if ((i16 & 63 | 0) == 28) {
    23267. 

  23267.      HEAP32[i17 >> 2] = i16 & 8372224 | i16 >>> 23 << 6 | 27;
    23268. 

  23268.      i14 = i8 + ~i15 | 0;
    23269. 

  23269.      if ((((i14 | 0) > -1 ? i14 : 0 - i14 | 0) | 0) > 131071) {
    23270. 

  23270.       i8 = 10;
    23271. 

  23271.       break;
    23272. 

  23272.      }
    23273. 

  23273.      i14 = HEAP32[i12 >> 2] & 16383 | (i14 << 14) + 2147467264;
    23274. 

  23274.     } else {
    23275. 

  23275.      i15 = i8 + ~i15 | 0;
    23276. 

  23276.      if ((((i15 | 0) > -1 ? i15 : 0 - i15 | 0) | 0) > 131071) {
    23277. 

  23277.       i8 = 13;
    23278. 

  23278.       break;
    23279. 

  23279.      }
    23280. 

  23280.      i14 = (i15 << 14) + 2147467264 | i14 & 16383;
    23281. 

  23281.     }
    23282. 

  23282.     HEAP32[i12 >> 2] = i14;
    23283. 

  23283.     if ((i13 | 0) == -1) {
    23284. 

  23284.      i8 = 16;
    23285. 

  23285.      break;
    23286. 

  23286.     } else {
    23287. 

  23287.      i15 = i13;
    23288. 

  23288.     }
    23289. 

  23289.    }
    23290. 

  23290.    if ((i8 | 0) == 10) {
    23291. 

  23291.     _luaX_syntaxerror(HEAP32[i4 + 12 >> 2] | 0, 10624);
    23292. 

  23292.    } else if ((i8 | 0) == 13) {
    23293. 

  23293.     _luaX_syntaxerror(HEAP32[i4 + 12 >> 2] | 0, 10624);
    23294. 

  23294.    } else if ((i8 | 0) == 16) {
    23295. 

  23295.     i6 = HEAP32[i3 >> 2] | 0;
    23296. 

  23296.     break;
    23297. 

  23297.    }
    23298. 

  23298.   } else {
    23299. 

  23299.    i6 = i8;
    23300. 

  23300.   }
    23301. 

  23301.  } while (0);
    23302. 

  23302.  HEAP32[i7 >> 2] = -1;
    23303. 

  23303.  i7 = i1 + 48 | 0;
    23304. 

  23304.  if ((i6 | 0) < (HEAP32[i7 >> 2] | 0)) {
    23305. 

  23305.   i7 = i1 + 12 | 0;
    23306. 

  23306.  } else {
    23307. 

  23307.   i6 = i1 + 12 | 0;
    23308. 

  23308.   HEAP32[i6 >> 2] = _luaM_growaux_(HEAP32[(HEAP32[i4 + 12 >> 2] | 0) + 52 >> 2] | 0, HEAP32[i6 >> 2] | 0, i7, 4, 2147483645, 10616) | 0;
    23309. 

  23309.   i7 = i6;
    23310. 

  23310.   i6 = HEAP32[i3 >> 2] | 0;
    23311. 

  23311.  }
    23312. 

  23312.  HEAP32[(HEAP32[i7 >> 2] | 0) + (i6 << 2) >> 2] = i5;
    23313. 

  23313.  i5 = HEAP32[i3 >> 2] | 0;
    23314. 

  23314.  i6 = i1 + 52 | 0;
    23315. 

  23315.  i4 = i4 + 12 | 0;
    23316. 

  23316.  if ((i5 | 0) < (HEAP32[i6 >> 2] | 0)) {
    23317. 

  23317.   i15 = i1 + 20 | 0;
    23318. 

  23318.   i17 = i5;
    23319. 

  23319.   i16 = HEAP32[i4 >> 2] | 0;
    23320. 

  23320.   i16 = i16 + 8 | 0;
    23321. 

  23321.   i16 = HEAP32[i16 >> 2] | 0;
    23322. 

  23322.   i15 = HEAP32[i15 >> 2] | 0;
    23323. 

  23323.   i17 = i15 + (i17 << 2) | 0;
    23324. 

  23324.   HEAP32[i17 >> 2] = i16;
    23325. 

  23325.   i17 = HEAP32[i3 >> 2] | 0;
    23326. 

  23326.   i16 = i17 + 1 | 0;
    23327. 

  23327.   HEAP32[i3 >> 2] = i16;
    23328. 

  23328.   STACKTOP = i2;
    23329. 

  23329.   return i17 | 0;
    23330. 

  23330.  } else {
    23331. 

  23331.   i15 = i1 + 20 | 0;
    23332. 

  23332.   HEAP32[i15 >> 2] = _luaM_growaux_(HEAP32[(HEAP32[i4 >> 2] | 0) + 52 >> 2] | 0, HEAP32[i15 >> 2] | 0, i6, 4, 2147483645, 10616) | 0;
    23333. 

  23333.   i17 = HEAP32[i3 >> 2] | 0;
    23334. 

  23334.   i16 = HEAP32[i4 >> 2] | 0;
    23335. 

  23335.   i16 = i16 + 8 | 0;
    23336. 

  23336.   i16 = HEAP32[i16 >> 2] | 0;
    23337. 

  23337.   i15 = HEAP32[i15 >> 2] | 0;
    23338. 

  23338.   i17 = i15 + (i17 << 2) | 0;
    23339. 

  23339.   HEAP32[i17 >> 2] = i16;
    23340. 

  23340.   i17 = HEAP32[i3 >> 2] | 0;
    23341. 

  23341.   i16 = i17 + 1 | 0;
    23342. 

  23342.   HEAP32[i3 >> 2] = i16;
    23343. 

  23343.   STACKTOP = i2;
    23344. 

  23344.   return i17 | 0;
    23345. 

  23345.  }
    23346. 

  23346.  return 0;
    23347. 

  23347. }
    23348. 

  23348. function _luaH_next(i9, i5, i2) {
    23349. 

  23349.  i9 = i9 | 0;
    23350. 

  23350.  i5 = i5 | 0;
    23351. 

  23351.  i2 = i2 | 0;
    23352. 

  23352.  var i1 = 0, i3 = 0, i4 = 0, i6 = 0, i7 = 0, i8 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0, d14 = 0.0;
    23353. 

  23353.  i1 = STACKTOP;
    23354. 

  23354.  STACKTOP = STACKTOP + 16 | 0;
    23355. 

  23355.  i8 = i1 + 8 | 0;
    23356. 

  23356.  i11 = i1;
    23357. 

  23357.  i3 = i2 + 8 | 0;
    23358. 

  23358.  i10 = HEAP32[i3 >> 2] | 0;
    23359. 

  23359.  do {
    23360. 

  23360.   if ((i10 | 0) != 0) {
    23361. 

  23361.    if ((((i10 | 0) == 3 ? (d14 = +HEAPF64[i2 >> 3], HEAPF64[i11 >> 3] = d14 + 6755399441055744.0, i12 = HEAP32[i11 >> 2] | 0, +(i12 | 0) == d14) : 0) ? (i12 | 0) > 0 : 0) ? (i13 = HEAP32[i5 + 28 >> 2] | 0, (i12 | 0) <= (i13 | 0)) : 0) {
    23362. 

  23362.     i6 = i13;
    23363. 

  23363.     i7 = i12 + -1 | 0;
    23364. 

  23364.     break;
    23365. 

  23365.    }
    23366. 

  23366.    i10 = _mainposition(i5, i2) | 0;
    23367. 

  23367.    while (1) {
    23368. 

  23368.     i4 = i10 + 16 | 0;
    23369. 

  23369.     i11 = i10 + 24 | 0;
    23370. 

  23370.     i12 = HEAP32[i11 >> 2] | 0;
    23371. 

  23371.     if ((i12 | 0) == (HEAP32[i3 >> 2] | 0)) {
    23372. 

  23372.      if ((_luaV_equalobj_(0, i4, i2) | 0) != 0) {
    23373. 

  23373.       i4 = 15;
    23374. 

  23374.       break;
    23375. 

  23375.      }
    23376. 

  23376.      i12 = HEAP32[i11 >> 2] | 0;
    23377. 

  23377.     }
    23378. 

  23378.     if (((i12 | 0) == 11 ? (HEAP32[i3 >> 2] & 64 | 0) != 0 : 0) ? (HEAP32[i4 >> 2] | 0) == (HEAP32[i2 >> 2] | 0) : 0) {
    23379. 

  23379.      i4 = 15;
    23380. 

  23380.      break;
    23381. 

  23381.     }
    23382. 

  23382.     i10 = HEAP32[i10 + 28 >> 2] | 0;
    23383. 

  23383.     if ((i10 | 0) == 0) {
    23384. 

  23384.      i4 = 18;
    23385. 

  23385.      break;
    23386. 

  23386.     }
    23387. 

  23387.    }
    23388. 

  23388.    if ((i4 | 0) == 15) {
    23389. 

  23389.     i7 = HEAP32[i5 + 28 >> 2] | 0;
    23390. 

  23390.     i6 = i7;
    23391. 

  23391.     i7 = (i10 - (HEAP32[i5 + 16 >> 2] | 0) >> 5) + i7 | 0;
    23392. 

  23392.     break;
    23393. 

  23393.    } else if ((i4 | 0) == 18) {
    23394. 

  23394.     _luaG_runerror(i9, 8064, i8);
    23395. 

  23395.    }
    23396. 

  23396.   } else {
    23397. 

  23397.    i6 = HEAP32[i5 + 28 >> 2] | 0;
    23398. 

  23398.    i7 = -1;
    23399. 

  23399.   }
    23400. 

  23400.  } while (0);
    23401. 

  23401.  i8 = i5 + 12 | 0;
    23402. 

  23402.  while (1) {
    23403. 

  23403.   i9 = i7 + 1 | 0;
    23404. 

  23404.   if ((i9 | 0) >= (i6 | 0)) {
    23405. 

  23405.    break;
    23406. 

  23406.   }
    23407. 

  23407.   i11 = HEAP32[i8 >> 2] | 0;
    23408. 

  23408.   i10 = i11 + (i9 << 4) + 8 | 0;
    23409. 

  23409.   if ((HEAP32[i10 >> 2] | 0) == 0) {
    23410. 

  23410.    i7 = i9;
    23411. 

  23411.   } else {
    23412. 

  23412.    i4 = 21;
    23413. 

  23413.    break;
    23414. 

  23414.   }
    23415. 

  23415.  }
    23416. 

  23416.  if ((i4 | 0) == 21) {
    23417. 

  23417.   HEAPF64[i2 >> 3] = +(i7 + 2 | 0);
    23418. 

  23418.   HEAP32[i3 >> 2] = 3;
    23419. 

  23419.   i11 = i11 + (i9 << 4) | 0;
    23420. 

  23420.   i12 = HEAP32[i11 + 4 >> 2] | 0;
    23421. 

  23421.   i13 = i2 + 16 | 0;
    23422. 

  23422.   HEAP32[i13 >> 2] = HEAP32[i11 >> 2];
    23423. 

  23423.   HEAP32[i13 + 4 >> 2] = i12;
    23424. 

  23424.   HEAP32[i2 + 24 >> 2] = HEAP32[i10 >> 2];
    23425. 

  23425.   i13 = 1;
    23426. 

  23426.   STACKTOP = i1;
    23427. 

  23427.   return i13 | 0;
    23428. 

  23428.  }
    23429. 

  23429.  i8 = i9 - i6 | 0;
    23430. 

  23430.  i6 = 1 << (HEAPU8[i5 + 7 | 0] | 0);
    23431. 

  23431.  if ((i8 | 0) >= (i6 | 0)) {
    23432. 

  23432.   i13 = 0;
    23433. 

  23433.   STACKTOP = i1;
    23434. 

  23434.   return i13 | 0;
    23435. 

  23435.  }
    23436. 

  23436.  i7 = i5 + 16 | 0;
    23437. 

  23437.  i5 = HEAP32[i7 >> 2] | 0;
    23438. 

  23438.  while (1) {
    23439. 

  23439.   i9 = i8 + 1 | 0;
    23440. 

  23440.   if ((HEAP32[i5 + (i8 << 5) + 8 >> 2] | 0) != 0) {
    23441. 

  23441.    break;
    23442. 

  23442.   }
    23443. 

  23443.   if ((i9 | 0) < (i6 | 0)) {
    23444. 

  23444.    i8 = i9;
    23445. 

  23445.   } else {
    23446. 

  23446.    i2 = 0;
    23447. 

  23447.    i4 = 27;
    23448. 

  23448.    break;
    23449. 

  23449.   }
    23450. 

  23450.  }
    23451. 

  23451.  if ((i4 | 0) == 27) {
    23452. 

  23452.   STACKTOP = i1;
    23453. 

  23453.   return i2 | 0;
    23454. 

  23454.  }
    23455. 

  23455.  i11 = i5 + (i8 << 5) + 16 | 0;
    23456. 

  23456.  i10 = HEAP32[i11 + 4 >> 2] | 0;
    23457. 

  23457.  i13 = i2;
    23458. 

  23458.  HEAP32[i13 >> 2] = HEAP32[i11 >> 2];
    23459. 

  23459.  HEAP32[i13 + 4 >> 2] = i10;
    23460. 

  23460.  HEAP32[i3 >> 2] = HEAP32[i5 + (i8 << 5) + 24 >> 2];
    23461. 

  23461.  i13 = HEAP32[i7 >> 2] | 0;
    23462. 

  23462.  i10 = i13 + (i8 << 5) | 0;
    23463. 

  23463.  i11 = HEAP32[i10 + 4 >> 2] | 0;
    23464. 

  23464.  i12 = i2 + 16 | 0;
    23465. 

  23465.  HEAP32[i12 >> 2] = HEAP32[i10 >> 2];
    23466. 

  23466.  HEAP32[i12 + 4 >> 2] = i11;
    23467. 

  23467.  HEAP32[i2 + 24 >> 2] = HEAP32[i13 + (i8 << 5) + 8 >> 2];
    23468. 

  23468.  i13 = 1;
    23469. 

  23469.  STACKTOP = i1;
    23470. 

  23470.  return i13 | 0;
    23471. 

  23471. }
    23472. 

  23472. function _g_read(i1, i3, i2) {
    23473. 

  23473.  i1 = i1 | 0;
    23474. 

  23474.  i3 = i3 | 0;
    23475. 

  23475.  i2 = i2 | 0;
    23476. 

  23476.  var i4 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0;
    23477. 

  23477.  i4 = STACKTOP;
    23478. 

  23478.  STACKTOP = STACKTOP + 1056 | 0;
    23479. 

  23479.  i7 = i4 + 8 | 0;
    23480. 

  23480.  i9 = i4;
    23481. 

  23481.  i10 = _lua_gettop(i1) | 0;
    23482. 

  23482.  _clearerr(i3 | 0);
    23483. 

  23483.  L1 : do {
    23484. 

  23484.   if ((i10 | 0) == 1) {
    23485. 

  23485.    i11 = i2 + 1 | 0;
    23486. 

  23486.    i12 = _read_line(i1, i3, 1) | 0;
    23487. 

  23487.   } else {
    23488. 

  23488.    _luaL_checkstack(i1, i10 + 19 | 0, 3256);
    23489. 

  23489.    i6 = i7 + 8 | 0;
    23490. 

  23490.    i5 = i7 + 8 | 0;
    23491. 

  23491.    i10 = i10 + -2 | 0;
    23492. 

  23492.    i11 = i2;
    23493. 

  23493.    L4 : while (1) {
    23494. 

  23494.     do {
    23495. 

  23495.      if ((_lua_type(i1, i11) | 0) == 3) {
    23496. 

  23496.       i12 = _lua_tointegerx(i1, i11, 0) | 0;
    23497. 

  23497.       if ((i12 | 0) == 0) {
    23498. 

  23498.        i12 = _fgetc(i3 | 0) | 0;
    23499. 

  23499.        _ungetc(i12 | 0, i3 | 0) | 0;
    23500. 

  23500.        _lua_pushlstring(i1, 0, 0) | 0;
    23501. 

  23501.        i12 = (i12 | 0) != -1 | 0;
    23502. 

  23502.        break;
    23503. 

  23503.       } else {
    23504. 

  23504.        _luaL_buffinit(i1, i7);
    23505. 

  23505.        i12 = _fread(_luaL_prepbuffsize(i7, i12) | 0, 1, i12 | 0, i3 | 0) | 0;
    23506. 

  23506.        HEAP32[i6 >> 2] = (HEAP32[i6 >> 2] | 0) + i12;
    23507. 

  23507.        _luaL_pushresult(i7);
    23508. 

  23508.        i12 = (i12 | 0) != 0 | 0;
    23509. 

  23509.        break;
    23510. 

  23510.       }
    23511. 

  23511.      } else {
    23512. 

  23512.       i12 = _lua_tolstring(i1, i11, 0) | 0;
    23513. 

  23513.       if (!((i12 | 0) != 0 ? (HEAP8[i12] | 0) == 42 : 0)) {
    23514. 

  23514.        _luaL_argerror(i1, i11, 3280) | 0;
    23515. 

  23515.       }
    23516. 

  23516.       i12 = HEAP8[i12 + 1 | 0] | 0;
    23517. 

  23517.       if ((i12 | 0) == 110) {
    23518. 

  23518.        HEAP32[i7 >> 2] = i9;
    23519. 

  23519.        if ((_fscanf(i3 | 0, 3312, i7 | 0) | 0) != 1) {
    23520. 

  23520.         i8 = 14;
    23521. 

  23521.         break L4;
    23522. 

  23522.        }
    23523. 

  23523.        _lua_pushnumber(i1, +HEAPF64[i9 >> 3]);
    23524. 

  23524.        i12 = 1;
    23525. 

  23525.        break;
    23526. 

  23526.       } else if ((i12 | 0) == 108) {
    23527. 

  23527.        i12 = _read_line(i1, i3, 1) | 0;
    23528. 

  23528.        break;
    23529. 

  23529.       } else if ((i12 | 0) == 76) {
    23530. 

  23530.        i12 = _read_line(i1, i3, 0) | 0;
    23531. 

  23531.        break;
    23532. 

  23532.       } else if ((i12 | 0) == 97) {
    23533. 

  23533.        _luaL_buffinit(i1, i7);
    23534. 

  23534.        i12 = _fread(_luaL_prepbuffsize(i7, 1024) | 0, 1, 1024, i3 | 0) | 0;
    23535. 

  23535.        HEAP32[i5 >> 2] = (HEAP32[i5 >> 2] | 0) + i12;
    23536. 

  23536.        if (!(i12 >>> 0 < 1024)) {
    23537. 

  23537.         i12 = 1024;
    23538. 

  23538.         do {
    23539. 

  23539.          i12 = i12 << (i12 >>> 0 < 1073741824);
    23540. 

  23540.          i13 = _fread(_luaL_prepbuffsize(i7, i12) | 0, 1, i12 | 0, i3 | 0) | 0;
    23541. 

  23541.          HEAP32[i5 >> 2] = (HEAP32[i5 >> 2] | 0) + i13;
    23542. 

  23542.         } while (!(i13 >>> 0 < i12 >>> 0));
    23543. 

  23543.        }
    23544. 

  23544.        _luaL_pushresult(i7);
    23545. 

  23545.        i12 = 1;
    23546. 

  23546.        break;
    23547. 

  23547.       } else {
    23548. 

  23548.        break L4;
    23549. 

  23549.       }
    23550. 

  23550.      }
    23551. 

  23551.     } while (0);
    23552. 

  23552.     i11 = i11 + 1 | 0;
    23553. 

  23553.     if ((i10 | 0) == 0 | (i12 | 0) == 0) {
    23554. 

  23554.      break L1;
    23555. 

  23555.     } else {
    23556. 

  23556.      i10 = i10 + -1 | 0;
    23557. 

  23557.     }
    23558. 

  23558.    }
    23559. 

  23559.    if ((i8 | 0) == 14) {
    23560. 

  23560.     _lua_pushnil(i1);
    23561. 

  23561.     i11 = i11 + 1 | 0;
    23562. 

  23562.     i12 = 0;
    23563. 

  23563.     break;
    23564. 

  23564.    }
    23565. 

  23565.    i13 = _luaL_argerror(i1, i11, 3296) | 0;
    23566. 

  23566.    STACKTOP = i4;
    23567. 

  23567.    return i13 | 0;
    23568. 

  23568.   }
    23569. 

  23569.  } while (0);
    23570. 

  23570.  if ((_ferror(i3 | 0) | 0) != 0) {
    23571. 

  23571.   i13 = _luaL_fileresult(i1, 0, 0) | 0;
    23572. 

  23572.   STACKTOP = i4;
    23573. 

  23573.   return i13 | 0;
    23574. 

  23574.  }
    23575. 

  23575.  if ((i12 | 0) == 0) {
    23576. 

  23576.   _lua_settop(i1, -2);
    23577. 

  23577.   _lua_pushnil(i1);
    23578. 

  23578.  }
    23579. 

  23579.  i13 = i11 - i2 | 0;
    23580. 

  23580.  STACKTOP = i4;
    23581. 

  23581.  return i13 | 0;
    23582. 

  23582. }
    23583. 

  23583. function _luaY_parser(i8, i12, i10, i11, i9, i13) {
    23584. 

  23584.  i8 = i8 | 0;
    23585. 

  23585.  i12 = i12 | 0;
    23586. 

  23586.  i10 = i10 | 0;
    23587. 

  23587.  i11 = i11 | 0;
    23588. 

  23588.  i9 = i9 | 0;
    23589. 

  23589.  i13 = i13 | 0;
    23590. 

  23590.  var i1 = 0, i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i14 = 0, i15 = 0;
    23591. 

  23591.  i2 = STACKTOP;
    23592. 

  23592.  STACKTOP = STACKTOP + 176 | 0;
    23593. 

  23593.  i5 = i2 + 156 | 0;
    23594. 

  23594.  i7 = i2 + 80 | 0;
    23595. 

  23595.  i4 = i2;
    23596. 

  23596.  i6 = i2 + 104 | 0;
    23597. 

  23597.  i3 = _luaF_newLclosure(i8, 1) | 0;
    23598. 

  23598.  i15 = i8 + 8 | 0;
    23599. 

  23599.  i14 = HEAP32[i15 >> 2] | 0;
    23600. 

  23600.  HEAP32[i14 >> 2] = i3;
    23601. 

  23601.  HEAP32[i14 + 8 >> 2] = 70;
    23602. 

  23602.  i14 = (HEAP32[i15 >> 2] | 0) + 16 | 0;
    23603. 

  23603.  HEAP32[i15 >> 2] = i14;
    23604. 

  23604.  if (((HEAP32[i8 + 24 >> 2] | 0) - i14 | 0) < 16) {
    23605. 

  23605.   _luaD_growstack(i8, 0);
    23606. 

  23606.  }
    23607. 

  23607.  i14 = _luaF_newproto(i8) | 0;
    23608. 

  23608.  HEAP32[i3 + 12 >> 2] = i14;
    23609. 

  23609.  HEAP32[i6 >> 2] = i14;
    23610. 

  23610.  i9 = _luaS_new(i8, i9) | 0;
    23611. 

  23611.  HEAP32[(HEAP32[i6 >> 2] | 0) + 36 >> 2] = i9;
    23612. 

  23612.  HEAP32[i4 + 60 >> 2] = i10;
    23613. 

  23613.  i9 = i4 + 64 | 0;
    23614. 

  23614.  HEAP32[i9 >> 2] = i11;
    23615. 

  23615.  HEAP32[i11 + 28 >> 2] = 0;
    23616. 

  23616.  HEAP32[i11 + 16 >> 2] = 0;
    23617. 

  23617.  HEAP32[i11 + 4 >> 2] = 0;
    23618. 

  23618.  _luaX_setinput(i8, i4, i12, HEAP32[(HEAP32[i6 >> 2] | 0) + 36 >> 2] | 0, i13);
    23619. 

  23619.  i10 = HEAP32[i4 + 52 >> 2] | 0;
    23620. 

  23620.  i13 = i4 + 48 | 0;
    23621. 

  23621.  HEAP32[i6 + 8 >> 2] = HEAP32[i13 >> 2];
    23622. 

  23622.  i8 = i6 + 12 | 0;
    23623. 

  23623.  HEAP32[i8 >> 2] = i4;
    23624. 

  23624.  HEAP32[i13 >> 2] = i6;
    23625. 

  23625.  HEAP32[i6 + 20 >> 2] = 0;
    23626. 

  23626.  HEAP32[i6 + 24 >> 2] = 0;
    23627. 

  23627.  HEAP32[i6 + 28 >> 2] = -1;
    23628. 

  23628.  HEAP32[i6 + 32 >> 2] = 0;
    23629. 

  23629.  HEAP32[i6 + 36 >> 2] = 0;
    23630. 

  23630.  i13 = i6 + 44 | 0;
    23631. 

  23631.  HEAP32[i13 + 0 >> 2] = 0;
    23632. 

  23632.  HEAP8[i13 + 4 | 0] = 0;
    23633. 

  23633.  HEAP32[i6 + 40 >> 2] = HEAP32[(HEAP32[i9 >> 2] | 0) + 4 >> 2];
    23634. 

  23634.  i9 = i6 + 16 | 0;
    23635. 

  23635.  HEAP32[i9 >> 2] = 0;
    23636. 

  23636.  i13 = HEAP32[i6 >> 2] | 0;
    23637. 

  23637.  HEAP32[i13 + 36 >> 2] = HEAP32[i4 + 68 >> 2];
    23638. 

  23638.  HEAP8[i13 + 78 | 0] = 2;
    23639. 

  23639.  i13 = _luaH_new(i10) | 0;
    23640. 

  23640.  HEAP32[i6 + 4 >> 2] = i13;
    23641. 

  23641.  i14 = i10 + 8 | 0;
    23642. 

  23642.  i15 = HEAP32[i14 >> 2] | 0;
    23643. 

  23643.  HEAP32[i15 >> 2] = i13;
    23644. 

  23644.  HEAP32[i15 + 8 >> 2] = 69;
    23645. 

  23645.  i15 = (HEAP32[i14 >> 2] | 0) + 16 | 0;
    23646. 

  23646.  HEAP32[i14 >> 2] = i15;
    23647. 

  23647.  if (((HEAP32[i10 + 24 >> 2] | 0) - i15 | 0) < 16) {
    23648. 

  23648.   _luaD_growstack(i10, 0);
    23649. 

  23649.  }
    23650. 

  23650.  HEAP8[i5 + 10 | 0] = 0;
    23651. 

  23651.  HEAP8[i5 + 8 | 0] = HEAP8[i6 + 46 | 0] | 0;
    23652. 

  23652.  i15 = HEAP32[(HEAP32[i8 >> 2] | 0) + 64 >> 2] | 0;
    23653. 

  23653.  HEAP16[i5 + 4 >> 1] = HEAP32[i15 + 28 >> 2];
    23654. 

  23654.  HEAP16[i5 + 6 >> 1] = HEAP32[i15 + 16 >> 2];
    23655. 

  23655.  HEAP8[i5 + 9 | 0] = 0;
    23656. 

  23656.  HEAP32[i5 >> 2] = HEAP32[i9 >> 2];
    23657. 

  23657.  HEAP32[i9 >> 2] = i5;
    23658. 

  23658.  HEAP8[(HEAP32[i6 >> 2] | 0) + 77 | 0] = 1;
    23659. 

  23659.  HEAP32[i7 + 16 >> 2] = -1;
    23660. 

  23660.  HEAP32[i7 + 20 >> 2] = -1;
    23661. 

  23661.  HEAP32[i7 >> 2] = 7;
    23662. 

  23662.  HEAP32[i7 + 8 >> 2] = 0;
    23663. 

  23663.  _newupvalue(i6, HEAP32[i4 + 72 >> 2] | 0, i7) | 0;
    23664. 

  23664.  _luaX_next(i4);
    23665. 

  23665.  i5 = i4 + 16 | 0;
    23666. 

  23666.  L7 : while (1) {
    23667. 

  23667.   i6 = HEAP32[i5 >> 2] | 0;
    23668. 

  23668.   switch (i6 | 0) {
    23669. 

  23669.   case 277:
    23670. 

  23670.   case 286:
    23671. 

  23671.   case 262:
    23672. 

  23672.   case 261:
    23673. 

  23673.   case 260:
    23674. 

  23674.    {
    23675. 

  23675.     break L7;
    23676. 

  23676.    }
    23677. 

  23677.   default:
    23678. 

  23678.    {}
    23679. 

  23679.   }
    23680. 

  23680.   _statement(i4);
    23681. 

  23681.   if ((i6 | 0) == 274) {
    23682. 

  23682.    i1 = 8;
    23683. 

  23683.    break;
    23684. 

  23684.   }
    23685. 

  23685.  }
    23686. 

  23686.  if ((i1 | 0) == 8) {
    23687. 

  23687.   i6 = HEAP32[i5 >> 2] | 0;
    23688. 

  23688.  }
    23689. 

  23689.  if ((i6 | 0) == 286) {
    23690. 

  23690.   _close_func(i4);
    23691. 

  23691.   STACKTOP = i2;
    23692. 

  23692.   return i3 | 0;
    23693. 

  23693.  } else {
    23694. 

  23694.   _error_expected(i4, 286);
    23695. 

  23695.  }
    23696. 

  23696.  return 0;
    23697. 

  23697. }
    23698. 

  23698. function _luaV_lessthan(i5, i4, i2) {
    23699. 

  23699.  i5 = i5 | 0;
    23700. 

  23700.  i4 = i4 | 0;
    23701. 

  23701.  i2 = i2 | 0;
    23702. 

  23702.  var i1 = 0, i3 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0;
    23703. 

  23703.  i1 = STACKTOP;
    23704. 

  23704.  i6 = i4 + 8 | 0;
    23705. 

  23705.  i7 = HEAP32[i6 >> 2] | 0;
    23706. 

  23706.  if ((i7 | 0) == 3) {
    23707. 

  23707.   if ((HEAP32[i2 + 8 >> 2] | 0) == 3) {
    23708. 

  23708.    i9 = +HEAPF64[i4 >> 3] < +HEAPF64[i2 >> 3] | 0;
    23709. 

  23709.    STACKTOP = i1;
    23710. 

  23710.    return i9 | 0;
    23711. 

  23711.   }
    23712. 

  23712.  } else {
    23713. 

  23713.   if ((i7 & 15 | 0) == 4 ? (HEAP32[i2 + 8 >> 2] & 15 | 0) == 4 : 0) {
    23714. 

  23714.    i6 = HEAP32[i4 >> 2] | 0;
    23715. 

  23715.    i4 = HEAP32[i2 >> 2] | 0;
    23716. 

  23716.    i3 = i6 + 16 | 0;
    23717. 

  23717.    i5 = i4 + 16 | 0;
    23718. 

  23718.    i7 = _strcmp(i3, i5) | 0;
    23719. 

  23719.    L8 : do {
    23720. 

  23720.     if ((i7 | 0) == 0) {
    23721. 

  23721.      i2 = HEAP32[i6 + 12 >> 2] | 0;
    23722. 

  23722.      i4 = HEAP32[i4 + 12 >> 2] | 0;
    23723. 

  23723.      while (1) {
    23724. 

  23724.       i7 = _strlen(i3 | 0) | 0;
    23725. 

  23725.       i6 = (i7 | 0) == (i2 | 0);
    23726. 

  23726.       if ((i7 | 0) == (i4 | 0)) {
    23727. 

  23727.        break;
    23728. 

  23728.       }
    23729. 

  23729.       if (i6) {
    23730. 

  23730.        i7 = -1;
    23731. 

  23731.        break L8;
    23732. 

  23732.       }
    23733. 

  23733.       i6 = i7 + 1 | 0;
    23734. 

  23734.       i3 = i3 + i6 | 0;
    23735. 

  23735.       i5 = i5 + i6 | 0;
    23736. 

  23736.       i7 = _strcmp(i3, i5) | 0;
    23737. 

  23737.       if ((i7 | 0) == 0) {
    23738. 

  23738.        i2 = i2 - i6 | 0;
    23739. 

  23739.        i4 = i4 - i6 | 0;
    23740. 

  23740.       } else {
    23741. 

  23741.        break L8;
    23742. 

  23742.       }
    23743. 

  23743.      }
    23744. 

  23744.      i7 = i6 & 1 ^ 1;
    23745. 

  23745.     }
    23746. 

  23746.    } while (0);
    23747. 

  23747.    i9 = i7 >>> 31;
    23748. 

  23748.    STACKTOP = i1;
    23749. 

  23749.    return i9 | 0;
    23750. 

  23750.   }
    23751. 

  23751.  }
    23752. 

  23752.  i8 = i5 + 8 | 0;
    23753. 

  23753.  i7 = HEAP32[i8 >> 2] | 0;
    23754. 

  23754.  i9 = _luaT_gettmbyobj(i5, i4, 13) | 0;
    23755. 

  23755.  if ((HEAP32[i9 + 8 >> 2] | 0) == 0) {
    23756. 

  23756.   i9 = _luaT_gettmbyobj(i5, i2, 13) | 0;
    23757. 

  23757.   if ((HEAP32[i9 + 8 >> 2] | 0) == 0) {
    23758. 

  23758.    _luaG_ordererror(i5, i4, i2);
    23759. 

  23759.   } else {
    23760. 

  23760.    i3 = i9;
    23761. 

  23761.   }
    23762. 

  23762.  } else {
    23763. 

  23763.   i3 = i9;
    23764. 

  23764.  }
    23765. 

  23765.  i10 = i5 + 28 | 0;
    23766. 

  23766.  i9 = i7 - (HEAP32[i10 >> 2] | 0) | 0;
    23767. 

  23767.  i11 = HEAP32[i8 >> 2] | 0;
    23768. 

  23768.  HEAP32[i8 >> 2] = i11 + 16;
    23769. 

  23769.  i13 = i3;
    23770. 

  23770.  i12 = HEAP32[i13 + 4 >> 2] | 0;
    23771. 

  23771.  i7 = i11;
    23772. 

  23772.  HEAP32[i7 >> 2] = HEAP32[i13 >> 2];
    23773. 

  23773.  HEAP32[i7 + 4 >> 2] = i12;
    23774. 

  23774.  HEAP32[i11 + 8 >> 2] = HEAP32[i3 + 8 >> 2];
    23775. 

  23775.  i3 = HEAP32[i8 >> 2] | 0;
    23776. 

  23776.  HEAP32[i8 >> 2] = i3 + 16;
    23777. 

  23777.  i11 = i4;
    23778. 

  23778.  i7 = HEAP32[i11 + 4 >> 2] | 0;
    23779. 

  23779.  i4 = i3;
    23780. 

  23780.  HEAP32[i4 >> 2] = HEAP32[i11 >> 2];
    23781. 

  23781.  HEAP32[i4 + 4 >> 2] = i7;
    23782. 

  23782.  HEAP32[i3 + 8 >> 2] = HEAP32[i6 >> 2];
    23783. 

  23783.  i3 = HEAP32[i8 >> 2] | 0;
    23784. 

  23784.  HEAP32[i8 >> 2] = i3 + 16;
    23785. 

  23785.  i4 = i2;
    23786. 

  23786.  i7 = HEAP32[i4 + 4 >> 2] | 0;
    23787. 

  23787.  i6 = i3;
    23788. 

  23788.  HEAP32[i6 >> 2] = HEAP32[i4 >> 2];
    23789. 

  23789.  HEAP32[i6 + 4 >> 2] = i7;
    23790. 

  23790.  HEAP32[i3 + 8 >> 2] = HEAP32[i2 + 8 >> 2];
    23791. 

  23791.  _luaD_call(i5, (HEAP32[i8 >> 2] | 0) + -48 | 0, 1, HEAP8[(HEAP32[i5 + 16 >> 2] | 0) + 18 | 0] & 1);
    23792. 

  23792.  i2 = HEAP32[i10 >> 2] | 0;
    23793. 

  23793.  i3 = HEAP32[i8 >> 2] | 0;
    23794. 

  23794.  i5 = i3 + -16 | 0;
    23795. 

  23795.  HEAP32[i8 >> 2] = i5;
    23796. 

  23796.  i6 = HEAP32[i5 + 4 >> 2] | 0;
    23797. 

  23797.  i7 = i2 + i9 | 0;
    23798. 

  23798.  HEAP32[i7 >> 2] = HEAP32[i5 >> 2];
    23799. 

  23799.  HEAP32[i7 + 4 >> 2] = i6;
    23800. 

  23800.  HEAP32[i2 + (i9 + 8) >> 2] = HEAP32[i3 + -8 >> 2];
    23801. 

  23801.  i2 = HEAP32[i8 >> 2] | 0;
    23802. 

  23802.  i3 = HEAP32[i2 + 8 >> 2] | 0;
    23803. 

  23803.  if ((i3 | 0) != 0) {
    23804. 

  23804.   if ((i3 | 0) == 1) {
    23805. 

  23805.    i2 = (HEAP32[i2 >> 2] | 0) != 0;
    23806. 

  23806.   } else {
    23807. 

  23807.    i2 = 1;
    23808. 

  23808.   }
    23809. 

  23809.  } else {
    23810. 

  23810.   i2 = 0;
    23811. 

  23811.  }
    23812. 

  23812.  i13 = i2 & 1;
    23813. 

  23813.  STACKTOP = i1;
    23814. 

  23814.  return i13 | 0;
    23815. 

  23815. }
    23816. 

  23816. function _discharge2reg(i4, i3, i1) {
    23817. 

  23817.  i4 = i4 | 0;
    23818. 

  23818.  i3 = i3 | 0;
    23819. 

  23819.  i1 = i1 | 0;
    23820. 

  23820.  var i2 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, d11 = 0.0;
    23821. 

  23821.  i2 = STACKTOP;
    23822. 

  23822.  STACKTOP = STACKTOP + 32 | 0;
    23823. 

  23823.  i9 = i2 + 16 | 0;
    23824. 

  23824.  i8 = i2;
    23825. 

  23825.  _luaK_dischargevars(i4, i3);
    23826. 

  23826.  i10 = HEAP32[i3 >> 2] | 0;
    23827. 

  23827.  L1 : do {
    23828. 

  23828.   switch (i10 | 0) {
    23829. 

  23829.   case 5:
    23830. 

  23830.    {
    23831. 

  23831.     d11 = +HEAPF64[i3 + 8 >> 3];
    23832. 

  23832.     HEAPF64[i9 >> 3] = d11;
    23833. 

  23833.     i5 = HEAP32[(HEAP32[i4 + 12 >> 2] | 0) + 52 >> 2] | 0;
    23834. 

  23834.     HEAPF64[i8 >> 3] = d11;
    23835. 

  23835.     HEAP32[i8 + 8 >> 2] = 3;
    23836. 

  23836.     if (d11 != d11 | 0.0 != 0.0 | d11 == 0.0) {
    23837. 

  23837.      i10 = i5 + 8 | 0;
    23838. 

  23838.      i7 = HEAP32[i10 >> 2] | 0;
    23839. 

  23839.      HEAP32[i10 >> 2] = i7 + 16;
    23840. 

  23840.      i5 = _luaS_newlstr(i5, i9, 8) | 0;
    23841. 

  23841.      HEAP32[i7 >> 2] = i5;
    23842. 

  23842.      HEAP32[i7 + 8 >> 2] = HEAPU8[i5 + 4 | 0] | 0 | 64;
    23843. 

  23843.      i5 = _addk(i4, (HEAP32[i10 >> 2] | 0) + -16 | 0, i8) | 0;
    23844. 

  23844.      HEAP32[i10 >> 2] = (HEAP32[i10 >> 2] | 0) + -16;
    23845. 

  23845.     } else {
    23846. 

  23846.      i5 = _addk(i4, i8, i8) | 0;
    23847. 

  23847.     }
    23848. 

  23848.     i6 = i1 << 6;
    23849. 

  23849.     if ((i5 | 0) < 262144) {
    23850. 

  23850.      _luaK_code(i4, i6 | i5 << 14 | 1) | 0;
    23851. 

  23851.      break L1;
    23852. 

  23852.     } else {
    23853. 

  23853.      _luaK_code(i4, i6 | 2) | 0;
    23854. 

  23854.      _luaK_code(i4, i5 << 6 | 39) | 0;
    23855. 

  23855.      break L1;
    23856. 

  23856.     }
    23857. 

  23857.    }
    23858. 

  23858.   case 2:
    23859. 

  23859.   case 3:
    23860. 

  23860.    {
    23861. 

  23861.     _luaK_code(i4, i1 << 6 | ((i10 | 0) == 2) << 23 | 3) | 0;
    23862. 

  23862.     break;
    23863. 

  23863.    }
    23864. 

  23864.   case 4:
    23865. 

  23865.    {
    23866. 

  23866.     i6 = HEAP32[i3 + 8 >> 2] | 0;
    23867. 

  23867.     i5 = i1 << 6;
    23868. 

  23868.     if ((i6 | 0) < 262144) {
    23869. 

  23869.      _luaK_code(i4, i5 | i6 << 14 | 1) | 0;
    23870. 

  23870.      break L1;
    23871. 

  23871.     } else {
    23872. 

  23872.      _luaK_code(i4, i5 | 2) | 0;
    23873. 

  23873.      _luaK_code(i4, i6 << 6 | 39) | 0;
    23874. 

  23874.      break L1;
    23875. 

  23875.     }
    23876. 

  23876.    }
    23877. 

  23877.   case 1:
    23878. 

  23878.    {
    23879. 

  23879.     i9 = i1 + 1 | 0;
    23880. 

  23880.     i8 = HEAP32[i4 + 20 >> 2] | 0;
    23881. 

  23881.     do {
    23882. 

  23882.      if ((i8 | 0) > (HEAP32[i4 + 24 >> 2] | 0) ? (i5 = (HEAP32[(HEAP32[i4 >> 2] | 0) + 12 >> 2] | 0) + (i8 + -1 << 2) | 0, i6 = HEAP32[i5 >> 2] | 0, (i6 & 63 | 0) == 4) : 0) {
    23883. 

  23883.       i10 = i6 >>> 6 & 255;
    23884. 

  23884.       i8 = i10 + (i6 >>> 23) | 0;
    23885. 

  23885.       if (!((i10 | 0) <= (i1 | 0) ? (i8 + 1 | 0) >= (i1 | 0) : 0)) {
    23886. 

  23886.        i7 = 6;
    23887. 

  23887.       }
    23888. 

  23888.       if ((i7 | 0) == 6 ? (i10 | 0) < (i1 | 0) | (i10 | 0) > (i9 | 0) : 0) {
    23889. 

  23889.        break;
    23890. 

  23890.       }
    23891. 

  23891.       i4 = (i10 | 0) < (i1 | 0) ? i10 : i1;
    23892. 

  23892.       HEAP32[i5 >> 2] = i4 << 6 & 16320 | i6 & 8372287 | ((i8 | 0) > (i1 | 0) ? i8 : i1) - i4 << 23;
    23893. 

  23893.       break L1;
    23894. 

  23894.      }
    23895. 

  23895.     } while (0);
    23896. 

  23896.     _luaK_code(i4, i1 << 6 | 4) | 0;
    23897. 

  23897.     break;
    23898. 

  23898.    }
    23899. 

  23899.   case 6:
    23900. 

  23900.    {
    23901. 

  23901.     i5 = HEAP32[i3 + 8 >> 2] | 0;
    23902. 

  23902.     if ((i5 | 0) != (i1 | 0)) {
    23903. 

  23903.      _luaK_code(i4, i5 << 23 | i1 << 6) | 0;
    23904. 

  23904.     }
    23905. 

  23905.     break;
    23906. 

  23906.    }
    23907. 

  23907.   case 11:
    23908. 

  23908.    {
    23909. 

  23909.     i10 = (HEAP32[(HEAP32[i4 >> 2] | 0) + 12 >> 2] | 0) + (HEAP32[i3 + 8 >> 2] << 2) | 0;
    23910. 

  23910.     HEAP32[i10 >> 2] = HEAP32[i10 >> 2] & -16321 | i1 << 6 & 16320;
    23911. 

  23911.     break;
    23912. 

  23912.    }
    23913. 

  23913.   default:
    23914. 

  23914.    {
    23915. 

  23915.     STACKTOP = i2;
    23916. 

  23916.     return;
    23917. 

  23917.    }
    23918. 

  23918.   }
    23919. 

  23919.  } while (0);
    23920. 

  23920.  HEAP32[i3 + 8 >> 2] = i1;
    23921. 

  23921.  HEAP32[i3 >> 2] = 6;
    23922. 

  23922.  STACKTOP = i2;
    23923. 

  23923.  return;
    23924. 

  23924. }
    23925. 

  23925. function _unroll(i3, i4) {
    23926. 

  23926.  i3 = i3 | 0;
    23927. 

  23927.  i4 = i4 | 0;
    23928. 

  23928.  var i1 = 0, i2 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0, i14 = 0, i15 = 0, i16 = 0, i17 = 0, i18 = 0;
    23929. 

  23929.  i9 = STACKTOP;
    23930. 

  23930.  i11 = i3 + 16 | 0;
    23931. 

  23931.  i13 = HEAP32[i11 >> 2] | 0;
    23932. 

  23932.  i5 = i3 + 72 | 0;
    23933. 

  23933.  if ((i13 | 0) == (i5 | 0)) {
    23934. 

  23934.   STACKTOP = i9;
    23935. 

  23935.   return;
    23936. 

  23936.  }
    23937. 

  23937.  i6 = i3 + 8 | 0;
    23938. 

  23938.  i10 = i3 + 40 | 0;
    23939. 

  23939.  i7 = i3 + 20 | 0;
    23940. 

  23940.  i8 = i3 + 28 | 0;
    23941. 

  23941.  i4 = i3 + 68 | 0;
    23942. 

  23942.  do {
    23943. 

  23943.   i12 = i13 + 18 | 0;
    23944. 

  23944.   i14 = HEAP8[i12] | 0;
    23945. 

  23945.   if ((i14 & 1) == 0) {
    23946. 

  23946.    i14 = i14 & 255;
    23947. 

  23947.    if ((i14 & 16 | 0) != 0) {
    23948. 

  23948.     HEAP8[i12] = i14 & 239;
    23949. 

  23949.     HEAP32[i4 >> 2] = HEAP32[i13 + 32 >> 2];
    23950. 

  23950.    }
    23951. 

  23951.    if ((HEAP16[i13 + 16 >> 1] | 0) == -1 ? (i2 = (HEAP32[i11 >> 2] | 0) + 4 | 0, i1 = HEAP32[i6 >> 2] | 0, (HEAP32[i2 >> 2] | 0) >>> 0 < i1 >>> 0) : 0) {
    23952. 

  23952.     HEAP32[i2 >> 2] = i1;
    23953. 

  23953.    }
    23954. 

  23954.    i14 = HEAP8[i12] | 0;
    23955. 

  23955.    if ((i14 & 32) == 0) {
    23956. 

  23956.     HEAP8[i13 + 37 | 0] = 1;
    23957. 

  23957.    }
    23958. 

  23958.    HEAP8[i12] = i14 & 199 | 8;
    23959. 

  23959.    i14 = FUNCTION_TABLE_ii[HEAP32[i13 + 28 >> 2] & 255](i3) | 0;
    23960. 

  23960.    i14 = (HEAP32[i6 >> 2] | 0) + (0 - i14 << 4) | 0;
    23961. 

  23961.    i13 = HEAP32[i11 >> 2] | 0;
    23962. 

  23962.    i12 = HEAPU8[i10] | 0;
    23963. 

  23963.    if ((i12 & 6 | 0) == 0) {
    23964. 

  23964.     i15 = i13 + 8 | 0;
    23965. 

  23965.    } else {
    23966. 

  23966.     if ((i12 & 2 | 0) != 0) {
    23967. 

  23967.      i14 = i14 - (HEAP32[i8 >> 2] | 0) | 0;
    23968. 

  23968.      _luaD_hook(i3, 1, -1);
    23969. 

  23969.      i14 = (HEAP32[i8 >> 2] | 0) + i14 | 0;
    23970. 

  23970.     }
    23971. 

  23971.     i15 = i13 + 8 | 0;
    23972. 

  23972.     HEAP32[i7 >> 2] = HEAP32[(HEAP32[i15 >> 2] | 0) + 28 >> 2];
    23973. 

  23973.    }
    23974. 

  23974.    i12 = HEAP32[i13 >> 2] | 0;
    23975. 

  23975.    i13 = HEAP16[i13 + 16 >> 1] | 0;
    23976. 

  23976.    HEAP32[i11 >> 2] = HEAP32[i15 >> 2];
    23977. 

  23977.    L25 : do {
    23978. 

  23978.     if (!(i13 << 16 >> 16 == 0)) {
    23979. 

  23979.      i15 = i13 << 16 >> 16;
    23980. 

  23980.      if (i14 >>> 0 < (HEAP32[i6 >> 2] | 0) >>> 0) {
    23981. 

  23981.       i13 = i14;
    23982. 

  23982.       i14 = i15;
    23983. 

  23983.       i15 = i12;
    23984. 

  23984.       while (1) {
    23985. 

  23985.        i12 = i15 + 16 | 0;
    23986. 

  23986.        i18 = i13;
    23987. 

  23987.        i17 = HEAP32[i18 + 4 >> 2] | 0;
    23988. 

  23988.        i16 = i15;
    23989. 

  23989.        HEAP32[i16 >> 2] = HEAP32[i18 >> 2];
    23990. 

  23990.        HEAP32[i16 + 4 >> 2] = i17;
    23991. 

  23991.        HEAP32[i15 + 8 >> 2] = HEAP32[i13 + 8 >> 2];
    23992. 

  23992.        i14 = i14 + -1 | 0;
    23993. 

  23993.        i13 = i13 + 16 | 0;
    23994. 

  23994.        if ((i14 | 0) == 0) {
    23995. 

  23995.         break L25;
    23996. 

  23996.        }
    23997. 

  23997.        if (i13 >>> 0 < (HEAP32[i6 >> 2] | 0) >>> 0) {
    23998. 

  23998.         i15 = i12;
    23999. 

  23999.        } else {
    24000. 

  24000.         i13 = i14;
    24001. 

  24001.         break;
    24002. 

  24002.        }
    24003. 

  24003.       }
    24004. 

  24004.      } else {
    24005. 

  24005.       i13 = i15;
    24006. 

  24006.      }
    24007. 

  24007.      if ((i13 | 0) > 0) {
    24008. 

  24008.       i14 = i13;
    24009. 

  24009.       i15 = i12;
    24010. 

  24010.       while (1) {
    24011. 

  24011.        i14 = i14 + -1 | 0;
    24012. 

  24012.        HEAP32[i15 + 8 >> 2] = 0;
    24013. 

  24013.        if ((i14 | 0) <= 0) {
    24014. 

  24014.         break;
    24015. 

  24015.        } else {
    24016. 

  24016.         i15 = i15 + 16 | 0;
    24017. 

  24017.        }
    24018. 

  24018.       }
    24019. 

  24019.       i12 = i12 + (i13 << 4) | 0;
    24020. 

  24020.      }
    24021. 

  24021.     }
    24022. 

  24022.    } while (0);
    24023. 

  24023.    HEAP32[i6 >> 2] = i12;
    24024. 

  24024.   } else {
    24025. 

  24025.    _luaV_finishOp(i3);
    24026. 

  24026.    _luaV_execute(i3);
    24027. 

  24027.   }
    24028. 

  24028.   i13 = HEAP32[i11 >> 2] | 0;
    24029. 

  24029.  } while ((i13 | 0) != (i5 | 0));
    24030. 

  24030.  STACKTOP = i9;
    24031. 

  24031.  return;
    24032. 

  24032. }
    24033. 

  24033. function _traverseephemeron(i1, i2) {
    24034. 

  24034.  i1 = i1 | 0;
    24035. 

  24035.  i2 = i2 | 0;
    24036. 

  24036.  var i3 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0, i14 = 0, i15 = 0;
    24037. 

  24037.  i3 = STACKTOP;
    24038. 

  24038.  i11 = i2 + 16 | 0;
    24039. 

  24039.  i9 = HEAP32[i11 >> 2] | 0;
    24040. 

  24040.  i5 = i9 + (1 << (HEAPU8[i2 + 7 | 0] | 0) << 5) | 0;
    24041. 

  24041.  i10 = i2 + 28 | 0;
    24042. 

  24042.  i13 = HEAP32[i10 >> 2] | 0;
    24043. 

  24043.  if ((i13 | 0) > 0) {
    24044. 

  24044.   i9 = i2 + 12 | 0;
    24045. 

  24045.   i12 = 0;
    24046. 

  24046.   i8 = 0;
    24047. 

  24047.   do {
    24048. 

  24048.    i14 = HEAP32[i9 >> 2] | 0;
    24049. 

  24049.    if ((HEAP32[i14 + (i12 << 4) + 8 >> 2] & 64 | 0) != 0 ? (i7 = HEAP32[i14 + (i12 << 4) >> 2] | 0, !((HEAP8[i7 + 5 | 0] & 3) == 0)) : 0) {
    24050. 

  24050.     _reallymarkobject(i1, i7);
    24051. 

  24051.     i13 = HEAP32[i10 >> 2] | 0;
    24052. 

  24052.     i8 = 1;
    24053. 

  24053.    }
    24054. 

  24054.    i12 = i12 + 1 | 0;
    24055. 

  24055.   } while ((i12 | 0) < (i13 | 0));
    24056. 

  24056.   i9 = HEAP32[i11 >> 2] | 0;
    24057. 

  24057.  } else {
    24058. 

  24058.   i8 = 0;
    24059. 

  24059.  }
    24060. 

  24060.  if (i9 >>> 0 < i5 >>> 0) {
    24061. 

  24061.   i7 = 0;
    24062. 

  24062.   i10 = 0;
    24063. 

  24063.   do {
    24064. 

  24064.    i11 = i9 + 8 | 0;
    24065. 

  24065.    i12 = HEAP32[i11 >> 2] | 0;
    24066. 

  24066.    i14 = i9 + 24 | 0;
    24067. 

  24067.    i13 = HEAP32[i14 >> 2] | 0;
    24068. 

  24068.    i15 = (i13 & 64 | 0) == 0;
    24069. 

  24069.    L14 : do {
    24070. 

  24070.     if ((i12 | 0) == 0) {
    24071. 

  24071.      if (!i15 ? !((HEAP8[(HEAP32[i9 + 16 >> 2] | 0) + 5 | 0] & 3) == 0) : 0) {
    24072. 

  24072.       HEAP32[i14 >> 2] = 11;
    24073. 

  24073.      }
    24074. 

  24074.     } else {
    24075. 

  24075.      do {
    24076. 

  24076.       if (i15) {
    24077. 

  24077.        i6 = i12;
    24078. 

  24078.        i4 = 18;
    24079. 

  24079.       } else {
    24080. 

  24080.        i14 = HEAP32[i9 + 16 >> 2] | 0;
    24081. 

  24081.        if ((i13 & 15 | 0) == 4) {
    24082. 

  24082.         if ((i14 | 0) == 0) {
    24083. 

  24083.          i6 = i12;
    24084. 

  24084.          i4 = 18;
    24085. 

  24085.          break;
    24086. 

  24086.         }
    24087. 

  24087.         if ((HEAP8[i14 + 5 | 0] & 3) == 0) {
    24088. 

  24088.          i6 = i12;
    24089. 

  24089.          i4 = 18;
    24090. 

  24090.          break;
    24091. 

  24091.         }
    24092. 

  24092.         _reallymarkobject(i1, i14);
    24093. 

  24093.         i6 = HEAP32[i11 >> 2] | 0;
    24094. 

  24094.         i4 = 18;
    24095. 

  24095.         break;
    24096. 

  24096.        }
    24097. 

  24097.        i11 = (i12 & 64 | 0) == 0;
    24098. 

  24098.        if ((HEAP8[i14 + 5 | 0] & 3) == 0) {
    24099. 

  24099.         if (i11) {
    24100. 

  24100.          break L14;
    24101. 

  24101.         } else {
    24102. 

  24102.          break;
    24103. 

  24103.         }
    24104. 

  24104.        }
    24105. 

  24105.        if (i11) {
    24106. 

  24106.         i7 = 1;
    24107. 

  24107.         break L14;
    24108. 

  24108.        }
    24109. 

  24109.        i7 = 1;
    24110. 

  24110.        i10 = (HEAP8[(HEAP32[i9 >> 2] | 0) + 5 | 0] & 3) == 0 ? i10 : 1;
    24111. 

  24111.        break L14;
    24112. 

  24112.       }
    24113. 

  24113.      } while (0);
    24114. 

  24114.      if ((i4 | 0) == 18 ? (i4 = 0, (i6 & 64 | 0) == 0) : 0) {
    24115. 

  24115.       break;
    24116. 

  24116.      }
    24117. 

  24117.      i11 = HEAP32[i9 >> 2] | 0;
    24118. 

  24118.      if (!((HEAP8[i11 + 5 | 0] & 3) == 0)) {
    24119. 

  24119.       _reallymarkobject(i1, i11);
    24120. 

  24120.       i8 = 1;
    24121. 

  24121.      }
    24122. 

  24122.     }
    24123. 

  24123.    } while (0);
    24124. 

  24124.    i9 = i9 + 32 | 0;
    24125. 

  24125.   } while (i9 >>> 0 < i5 >>> 0);
    24126. 

  24126.   if ((i10 | 0) != 0) {
    24127. 

  24127.    i15 = i1 + 96 | 0;
    24128. 

  24128.    HEAP32[i2 + 24 >> 2] = HEAP32[i15 >> 2];
    24129. 

  24129.    HEAP32[i15 >> 2] = i2;
    24130. 

  24130.    i15 = i8;
    24131. 

  24131.    STACKTOP = i3;
    24132. 

  24132.    return i15 | 0;
    24133. 

  24133.   }
    24134. 

  24134.   if ((i7 | 0) != 0) {
    24135. 

  24135.    i15 = i1 + 100 | 0;
    24136. 

  24136.    HEAP32[i2 + 24 >> 2] = HEAP32[i15 >> 2];
    24137. 

  24137.    HEAP32[i15 >> 2] = i2;
    24138. 

  24138.    i15 = i8;
    24139. 

  24139.    STACKTOP = i3;
    24140. 

  24140.    return i15 | 0;
    24141. 

  24141.   }
    24142. 

  24142.  }
    24143. 

  24143.  i15 = i1 + 88 | 0;
    24144. 

  24144.  HEAP32[i2 + 24 >> 2] = HEAP32[i15 >> 2];
    24145. 

  24145.  HEAP32[i15 >> 2] = i2;
    24146. 

  24146.  i15 = i8;
    24147. 

  24147.  STACKTOP = i3;
    24148. 

  24148.  return i15 | 0;
    24149. 

  24149. }
    24150. 

  24150. function _luaV_gettable(i2, i7, i5, i1) {
    24151. 

  24151.  i2 = i2 | 0;
    24152. 

  24152.  i7 = i7 | 0;
    24153. 

  24153.  i5 = i5 | 0;
    24154. 

  24154.  i1 = i1 | 0;
    24155. 

  24155.  var i3 = 0, i4 = 0, i6 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0;
    24156. 

  24156.  i6 = STACKTOP;
    24157. 

  24157.  STACKTOP = STACKTOP + 16 | 0;
    24158. 

  24158.  i4 = i6;
    24159. 

  24159.  i8 = i2 + 12 | 0;
    24160. 

  24160.  i3 = i7;
    24161. 

  24161.  i10 = HEAP32[i7 + 8 >> 2] | 0;
    24162. 

  24162.  i9 = 0;
    24163. 

  24163.  while (1) {
    24164. 

  24164.   i7 = i3 + 8 | 0;
    24165. 

  24165.   if ((i10 | 0) != 69) {
    24166. 

  24166.    i12 = _luaT_gettmbyobj(i2, i3, 0) | 0;
    24167. 

  24167.    i10 = HEAP32[i12 + 8 >> 2] | 0;
    24168. 

  24168.    if ((i10 | 0) == 0) {
    24169. 

  24169.     i8 = 11;
    24170. 

  24170.     break;
    24171. 

  24171.    }
    24172. 

  24172.   } else {
    24173. 

  24173.    i12 = HEAP32[i3 >> 2] | 0;
    24174. 

  24174.    i11 = _luaH_get(i12, i5) | 0;
    24175. 

  24175.    i10 = i11 + 8 | 0;
    24176. 

  24176.    if ((HEAP32[i10 >> 2] | 0) != 0) {
    24177. 

  24177.     i8 = 9;
    24178. 

  24178.     break;
    24179. 

  24179.    }
    24180. 

  24180.    i12 = HEAP32[i12 + 8 >> 2] | 0;
    24181. 

  24181.    if ((i12 | 0) == 0) {
    24182. 

  24182.     i8 = 9;
    24183. 

  24183.     break;
    24184. 

  24184.    }
    24185. 

  24185.    if (!((HEAP8[i12 + 6 | 0] & 1) == 0)) {
    24186. 

  24186.     i8 = 9;
    24187. 

  24187.     break;
    24188. 

  24188.    }
    24189. 

  24189.    i12 = _luaT_gettm(i12, 0, HEAP32[(HEAP32[i8 >> 2] | 0) + 184 >> 2] | 0) | 0;
    24190. 

  24190.    if ((i12 | 0) == 0) {
    24191. 

  24191.     i8 = 9;
    24192. 

  24192.     break;
    24193. 

  24193.    }
    24194. 

  24194.    i10 = HEAP32[i12 + 8 >> 2] | 0;
    24195. 

  24195.   }
    24196. 

  24196.   i9 = i9 + 1 | 0;
    24197. 

  24197.   if ((i10 & 15 | 0) == 6) {
    24198. 

  24198.    i8 = 13;
    24199. 

  24199.    break;
    24200. 

  24200.   }
    24201. 

  24201.   if ((i9 | 0) < 100) {
    24202. 

  24202.    i3 = i12;
    24203. 

  24203.   } else {
    24204. 

  24204.    i8 = 14;
    24205. 

  24205.    break;
    24206. 

  24206.   }
    24207. 

  24207.  }
    24208. 

  24208.  if ((i8 | 0) == 9) {
    24209. 

  24209.   i9 = i11;
    24210. 

  24210.   i11 = HEAP32[i9 + 4 >> 2] | 0;
    24211. 

  24211.   i12 = i1;
    24212. 

  24212.   HEAP32[i12 >> 2] = HEAP32[i9 >> 2];
    24213. 

  24213.   HEAP32[i12 + 4 >> 2] = i11;
    24214. 

  24214.   HEAP32[i1 + 8 >> 2] = HEAP32[i10 >> 2];
    24215. 

  24215.   STACKTOP = i6;
    24216. 

  24216.   return;
    24217. 

  24217.  } else if ((i8 | 0) == 11) {
    24218. 

  24218.   _luaG_typeerror(i2, i3, 8944);
    24219. 

  24219.  } else if ((i8 | 0) == 13) {
    24220. 

  24220.   i10 = i2 + 28 | 0;
    24221. 

  24221.   i11 = i1 - (HEAP32[i10 >> 2] | 0) | 0;
    24222. 

  24222.   i8 = i2 + 8 | 0;
    24223. 

  24223.   i9 = HEAP32[i8 >> 2] | 0;
    24224. 

  24224.   HEAP32[i8 >> 2] = i9 + 16;
    24225. 

  24225.   i13 = i12;
    24226. 

  24226.   i1 = HEAP32[i13 + 4 >> 2] | 0;
    24227. 

  24227.   i4 = i9;
    24228. 

  24228.   HEAP32[i4 >> 2] = HEAP32[i13 >> 2];
    24229. 

  24229.   HEAP32[i4 + 4 >> 2] = i1;
    24230. 

  24230.   HEAP32[i9 + 8 >> 2] = HEAP32[i12 + 8 >> 2];
    24231. 

  24231.   i12 = HEAP32[i8 >> 2] | 0;
    24232. 

  24232.   HEAP32[i8 >> 2] = i12 + 16;
    24233. 

  24233.   i9 = HEAP32[i3 + 4 >> 2] | 0;
    24234. 

  24234.   i4 = i12;
    24235. 

  24235.   HEAP32[i4 >> 2] = HEAP32[i3 >> 2];
    24236. 

  24236.   HEAP32[i4 + 4 >> 2] = i9;
    24237. 

  24237.   HEAP32[i12 + 8 >> 2] = HEAP32[i7 >> 2];
    24238. 

  24238.   i12 = HEAP32[i8 >> 2] | 0;
    24239. 

  24239.   HEAP32[i8 >> 2] = i12 + 16;
    24240. 

  24240.   i4 = i5;
    24241. 

  24241.   i9 = HEAP32[i4 + 4 >> 2] | 0;
    24242. 

  24242.   i7 = i12;
    24243. 

  24243.   HEAP32[i7 >> 2] = HEAP32[i4 >> 2];
    24244. 

  24244.   HEAP32[i7 + 4 >> 2] = i9;
    24245. 

  24245.   HEAP32[i12 + 8 >> 2] = HEAP32[i5 + 8 >> 2];
    24246. 

  24246.   _luaD_call(i2, (HEAP32[i8 >> 2] | 0) + -48 | 0, 1, HEAP8[(HEAP32[i2 + 16 >> 2] | 0) + 18 | 0] & 1);
    24247. 

  24247.   i12 = HEAP32[i10 >> 2] | 0;
    24248. 

  24248.   i10 = HEAP32[i8 >> 2] | 0;
    24249. 

  24249.   i7 = i10 + -16 | 0;
    24250. 

  24250.   HEAP32[i8 >> 2] = i7;
    24251. 

  24251.   i8 = HEAP32[i7 + 4 >> 2] | 0;
    24252. 

  24252.   i9 = i12 + i11 | 0;
    24253. 

  24253.   HEAP32[i9 >> 2] = HEAP32[i7 >> 2];
    24254. 

  24254.   HEAP32[i9 + 4 >> 2] = i8;
    24255. 

  24255.   HEAP32[i12 + (i11 + 8) >> 2] = HEAP32[i10 + -8 >> 2];
    24256. 

  24256.   STACKTOP = i6;
    24257. 

  24257.   return;
    24258. 

  24258.  } else if ((i8 | 0) == 14) {
    24259. 

  24259.   _luaG_runerror(i2, 8952, i4);
    24260. 

  24260.  }
    24261. 

  24261. }
    24262. 

  24262. function _db_getinfo(i1) {
    24263. 

  24263.  i1 = i1 | 0;
    24264. 

  24264.  var i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0;
    24265. 

  24265.  i2 = STACKTOP;
    24266. 

  24266.  STACKTOP = STACKTOP + 112 | 0;
    24267. 

  24267.  i3 = i2;
    24268. 

  24268.  if ((_lua_type(i1, 1) | 0) == 8) {
    24269. 

  24269.   i4 = _lua_tothread(i1, 1) | 0;
    24270. 

  24270.   i7 = 1;
    24271. 

  24271.  } else {
    24272. 

  24272.   i4 = i1;
    24273. 

  24273.   i7 = 0;
    24274. 

  24274.  }
    24275. 

  24275.  i5 = i7 | 2;
    24276. 

  24276.  i6 = _luaL_optlstring(i1, i5, 11784, 0) | 0;
    24277. 

  24277.  i7 = i7 + 1 | 0;
    24278. 

  24278.  do {
    24279. 

  24279.   if ((_lua_isnumber(i1, i7) | 0) != 0) {
    24280. 

  24280.    if ((_lua_getstack(i4, _lua_tointegerx(i1, i7, 0) | 0, i3) | 0) == 0) {
    24281. 

  24281.     _lua_pushnil(i1);
    24282. 

  24282.     i7 = 1;
    24283. 

  24283.     STACKTOP = i2;
    24284. 

  24284.     return i7 | 0;
    24285. 

  24285.    }
    24286. 

  24286.   } else {
    24287. 

  24287.    if ((_lua_type(i1, i7) | 0) == 6) {
    24288. 

  24288.     HEAP32[i3 >> 2] = i6;
    24289. 

  24289.     _lua_pushfstring(i1, 11792, i3) | 0;
    24290. 

  24290.     i6 = _lua_tolstring(i1, -1, 0) | 0;
    24291. 

  24291.     _lua_pushvalue(i1, i7);
    24292. 

  24292.     _lua_xmove(i1, i4, 1);
    24293. 

  24293.     break;
    24294. 

  24294.    }
    24295. 

  24295.    i7 = _luaL_argerror(i1, i7, 11800) | 0;
    24296. 

  24296.    STACKTOP = i2;
    24297. 

  24297.    return i7 | 0;
    24298. 

  24298.   }
    24299. 

  24299.  } while (0);
    24300. 

  24300.  if ((_lua_getinfo(i4, i6, i3) | 0) == 0) {
    24301. 

  24301.   i7 = _luaL_argerror(i1, i5, 11832) | 0;
    24302. 

  24302.   STACKTOP = i2;
    24303. 

  24303.   return i7 | 0;
    24304. 

  24304.  }
    24305. 

  24305.  _lua_createtable(i1, 0, 2);
    24306. 

  24306.  if ((_strchr(i6, 83) | 0) != 0) {
    24307. 

  24307.   _lua_pushstring(i1, HEAP32[i3 + 16 >> 2] | 0) | 0;
    24308. 

  24308.   _lua_setfield(i1, -2, 11848);
    24309. 

  24309.   _lua_pushstring(i1, i3 + 36 | 0) | 0;
    24310. 

  24310.   _lua_setfield(i1, -2, 11856);
    24311. 

  24311.   _lua_pushinteger(i1, HEAP32[i3 + 24 >> 2] | 0);
    24312. 

  24312.   _lua_setfield(i1, -2, 11872);
    24313. 

  24313.   _lua_pushinteger(i1, HEAP32[i3 + 28 >> 2] | 0);
    24314. 

  24314.   _lua_setfield(i1, -2, 11888);
    24315. 

  24315.   _lua_pushstring(i1, HEAP32[i3 + 12 >> 2] | 0) | 0;
    24316. 

  24316.   _lua_setfield(i1, -2, 11904);
    24317. 

  24317.  }
    24318. 

  24318.  if ((_strchr(i6, 108) | 0) != 0) {
    24319. 

  24319.   _lua_pushinteger(i1, HEAP32[i3 + 20 >> 2] | 0);
    24320. 

  24320.   _lua_setfield(i1, -2, 11912);
    24321. 

  24321.  }
    24322. 

  24322.  if ((_strchr(i6, 117) | 0) != 0) {
    24323. 

  24323.   _lua_pushinteger(i1, HEAPU8[i3 + 32 | 0] | 0);
    24324. 

  24324.   _lua_setfield(i1, -2, 11928);
    24325. 

  24325.   _lua_pushinteger(i1, HEAPU8[i3 + 33 | 0] | 0);
    24326. 

  24326.   _lua_setfield(i1, -2, 11936);
    24327. 

  24327.   _lua_pushboolean(i1, HEAP8[i3 + 34 | 0] | 0);
    24328. 

  24328.   _lua_setfield(i1, -2, 11944);
    24329. 

  24329.  }
    24330. 

  24330.  if ((_strchr(i6, 110) | 0) != 0) {
    24331. 

  24331.   _lua_pushstring(i1, HEAP32[i3 + 4 >> 2] | 0) | 0;
    24332. 

  24332.   _lua_setfield(i1, -2, 11960);
    24333. 

  24333.   _lua_pushstring(i1, HEAP32[i3 + 8 >> 2] | 0) | 0;
    24334. 

  24334.   _lua_setfield(i1, -2, 11968);
    24335. 

  24335.  }
    24336. 

  24336.  if ((_strchr(i6, 116) | 0) != 0) {
    24337. 

  24337.   _lua_pushboolean(i1, HEAP8[i3 + 35 | 0] | 0);
    24338. 

  24338.   _lua_setfield(i1, -2, 11984);
    24339. 

  24339.  }
    24340. 

  24340.  if ((_strchr(i6, 76) | 0) != 0) {
    24341. 

  24341.   if ((i4 | 0) == (i1 | 0)) {
    24342. 

  24342.    _lua_pushvalue(i1, -2);
    24343. 

  24343.    _lua_remove(i1, -3);
    24344. 

  24344.   } else {
    24345. 

  24345.    _lua_xmove(i4, i1, 1);
    24346. 

  24346.   }
    24347. 

  24347.   _lua_setfield(i1, -2, 12e3);
    24348. 

  24348.  }
    24349. 

  24349.  if ((_strchr(i6, 102) | 0) == 0) {
    24350. 

  24350.   i7 = 1;
    24351. 

  24351.   STACKTOP = i2;
    24352. 

  24352.   return i7 | 0;
    24353. 

  24353.  }
    24354. 

  24354.  if ((i4 | 0) == (i1 | 0)) {
    24355. 

  24355.   _lua_pushvalue(i1, -2);
    24356. 

  24356.   _lua_remove(i1, -3);
    24357. 

  24357.  } else {
    24358. 

  24358.   _lua_xmove(i4, i1, 1);
    24359. 

  24359.  }
    24360. 

  24360.  _lua_setfield(i1, -2, 12016);
    24361. 

  24361.  i7 = 1;
    24362. 

  24362.  STACKTOP = i2;
    24363. 

  24363.  return i7 | 0;
    24364. 

  24364. }
    24365. 

  24365. function _luaL_traceback(i4, i1, i9, i7) {
    24366. 

  24366.  i4 = i4 | 0;
    24367. 

  24367.  i1 = i1 | 0;
    24368. 

  24368.  i9 = i9 | 0;
    24369. 

  24369.  i7 = i7 | 0;
    24370. 

  24370.  var i2 = 0, i3 = 0, i5 = 0, i6 = 0, i8 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0, i14 = 0, i15 = 0, i16 = 0, i17 = 0;
    24371. 

  24371.  i3 = STACKTOP;
    24372. 

  24372.  STACKTOP = STACKTOP + 208 | 0;
    24373. 

  24373.  i6 = i3;
    24374. 

  24374.  i5 = i3 + 100 | 0;
    24375. 

  24375.  i2 = _lua_gettop(i4) | 0;
    24376. 

  24376.  i8 = 1;
    24377. 

  24377.  i10 = 1;
    24378. 

  24378.  while (1) {
    24379. 

  24379.   if ((_lua_getstack(i1, i8, i6) | 0) == 0) {
    24380. 

  24380.    break;
    24381. 

  24381.   } else {
    24382. 

  24382.    i10 = i8;
    24383. 

  24383.    i8 = i8 << 1;
    24384. 

  24384.   }
    24385. 

  24385.  }
    24386. 

  24386.  if ((i10 | 0) < (i8 | 0)) {
    24387. 

  24387.   while (1) {
    24388. 

  24388.    i11 = (i8 + i10 | 0) / 2 | 0;
    24389. 

  24389.    i12 = (_lua_getstack(i1, i11, i6) | 0) == 0;
    24390. 

  24390.    i8 = i12 ? i11 : i8;
    24391. 

  24391.    i10 = i12 ? i10 : i11 + 1 | 0;
    24392. 

  24392.    if ((i10 | 0) >= (i8 | 0)) {
    24393. 

  24393.     i10 = i8;
    24394. 

  24394.     break;
    24395. 

  24395.    }
    24396. 

  24396.   }
    24397. 

  24397.  } else {
    24398. 

  24398.   i10 = i8;
    24399. 

  24399.  }
    24400. 

  24400.  i8 = (i10 + -1 | 0) > 22 ? 12 : 0;
    24401. 

  24401.  if ((i9 | 0) != 0) {
    24402. 

  24402.   HEAP32[i6 >> 2] = i9;
    24403. 

  24403.   _lua_pushfstring(i4, 944, i6) | 0;
    24404. 

  24404.  }
    24405. 

  24405.  _lua_pushlstring(i4, 952, 16) | 0;
    24406. 

  24406.  if ((_lua_getstack(i1, i7, i5) | 0) == 0) {
    24407. 

  24407.   i17 = _lua_gettop(i4) | 0;
    24408. 

  24408.   i17 = i17 - i2 | 0;
    24409. 

  24409.   _lua_concat(i4, i17);
    24410. 

  24410.   STACKTOP = i3;
    24411. 

  24411.   return;
    24412. 

  24412.  }
    24413. 

  24413.  i10 = i10 + -11 | 0;
    24414. 

  24414.  i13 = i5 + 36 | 0;
    24415. 

  24415.  i9 = i5 + 20 | 0;
    24416. 

  24416.  i16 = i5 + 8 | 0;
    24417. 

  24417.  i12 = i5 + 12 | 0;
    24418. 

  24418.  i15 = i5 + 24 | 0;
    24419. 

  24419.  i14 = i5 + 35 | 0;
    24420. 

  24420.  i11 = i5 + 4 | 0;
    24421. 

  24421.  do {
    24422. 

  24422.   i7 = i7 + 1 | 0;
    24423. 

  24423.   if ((i7 | 0) == (i8 | 0)) {
    24424. 

  24424.    _lua_pushlstring(i4, 976, 5) | 0;
    24425. 

  24425.    i7 = i10;
    24426. 

  24426.   } else {
    24427. 

  24427.    _lua_getinfo(i1, 984, i5) | 0;
    24428. 

  24428.    HEAP32[i6 >> 2] = i13;
    24429. 

  24429.    _lua_pushfstring(i4, 992, i6) | 0;
    24430. 

  24430.    i17 = HEAP32[i9 >> 2] | 0;
    24431. 

  24431.    if ((i17 | 0) > 0) {
    24432. 

  24432.     HEAP32[i6 >> 2] = i17;
    24433. 

  24433.     _lua_pushfstring(i4, 1e3, i6) | 0;
    24434. 

  24434.    }
    24435. 

  24435.    _lua_pushlstring(i4, 1008, 4) | 0;
    24436. 

  24436.    do {
    24437. 

  24437.     if ((HEAP8[HEAP32[i16 >> 2] | 0] | 0) == 0) {
    24438. 

  24438.      i17 = HEAP8[HEAP32[i12 >> 2] | 0] | 0;
    24439. 

  24439.      if (i17 << 24 >> 24 == 109) {
    24440. 

  24440.       _lua_pushlstring(i4, 1800, 10) | 0;
    24441. 

  24441.       break;
    24442. 

  24442.      } else if (i17 << 24 >> 24 == 67) {
    24443. 

  24443.       if ((_pushglobalfuncname(i4, i5) | 0) == 0) {
    24444. 

  24444.        _lua_pushlstring(i4, 1112, 1) | 0;
    24445. 

  24445.        break;
    24446. 

  24446.       } else {
    24447. 

  24447.        HEAP32[i6 >> 2] = _lua_tolstring(i4, -1, 0) | 0;
    24448. 

  24448.        _lua_pushfstring(i4, 1784, i6) | 0;
    24449. 

  24449.        _lua_remove(i4, -2);
    24450. 

  24450.        break;
    24451. 

  24451.       }
    24452. 

  24452.      } else {
    24453. 

  24453.       i17 = HEAP32[i15 >> 2] | 0;
    24454. 

  24454.       HEAP32[i6 >> 2] = i13;
    24455. 

  24455.       HEAP32[i6 + 4 >> 2] = i17;
    24456. 

  24456.       _lua_pushfstring(i4, 1816, i6) | 0;
    24457. 

  24457.       break;
    24458. 

  24458.      }
    24459. 

  24459.     } else {
    24460. 

  24460.      HEAP32[i6 >> 2] = HEAP32[i11 >> 2];
    24461. 

  24461.      _lua_pushfstring(i4, 1784, i6) | 0;
    24462. 

  24462.     }
    24463. 

  24463.    } while (0);
    24464. 

  24464.    if ((HEAP8[i14] | 0) != 0) {
    24465. 

  24465.     _lua_pushlstring(i4, 1016, 20) | 0;
    24466. 

  24466.    }
    24467. 

  24467.    _lua_concat(i4, (_lua_gettop(i4) | 0) - i2 | 0);
    24468. 

  24468.   }
    24469. 

  24469.  } while ((_lua_getstack(i1, i7, i5) | 0) != 0);
    24470. 

  24470.  i17 = _lua_gettop(i4) | 0;
    24471. 

  24471.  i17 = i17 - i2 | 0;
    24472. 

  24472.  _lua_concat(i4, i17);
    24473. 

  24473.  STACKTOP = i3;
    24474. 

  24474.  return;
    24475. 

  24475. }
    24476. 

  24476. function _luaK_exp2RK(i3, i1) {
    24477. 

  24477.  i3 = i3 | 0;
    24478. 

  24478.  i1 = i1 | 0;
    24479. 

  24479.  var i2 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, d11 = 0.0, i12 = 0;
    24480. 

  24480.  i2 = STACKTOP;
    24481. 

  24481.  STACKTOP = STACKTOP + 32 | 0;
    24482. 

  24482.  i7 = i2 + 16 | 0;
    24483. 

  24483.  i6 = i2;
    24484. 

  24484.  i4 = i1 + 16 | 0;
    24485. 

  24485.  i5 = i1 + 20 | 0;
    24486. 

  24486.  i10 = (HEAP32[i4 >> 2] | 0) == (HEAP32[i5 >> 2] | 0);
    24487. 

  24487.  _luaK_dischargevars(i3, i1);
    24488. 

  24488.  do {
    24489. 

  24489.   if (!i10) {
    24490. 

  24490.    if ((HEAP32[i1 >> 2] | 0) == 6) {
    24491. 

  24491.     i10 = HEAP32[i1 + 8 >> 2] | 0;
    24492. 

  24492.     if ((HEAP32[i4 >> 2] | 0) == (HEAP32[i5 >> 2] | 0)) {
    24493. 

  24493.      break;
    24494. 

  24494.     }
    24495. 

  24495.     if ((i10 | 0) >= (HEAPU8[i3 + 46 | 0] | 0 | 0)) {
    24496. 

  24496.      _exp2reg(i3, i1, i10);
    24497. 

  24497.      break;
    24498. 

  24498.     }
    24499. 

  24499.    }
    24500. 

  24500.    _luaK_exp2nextreg(i3, i1);
    24501. 

  24501.   }
    24502. 

  24502.  } while (0);
    24503. 

  24503.  i10 = HEAP32[i1 >> 2] | 0;
    24504. 

  24504.  switch (i10 | 0) {
    24505. 

  24505.  case 4:
    24506. 

  24506.   {
    24507. 

  24507.    i8 = HEAP32[i1 + 8 >> 2] | 0;
    24508. 

  24508.    i9 = 18;
    24509. 

  24509.    break;
    24510. 

  24510.   }
    24511. 

  24511.  case 1:
    24512. 

  24512.  case 3:
    24513. 

  24513.  case 2:
    24514. 

  24514.   {
    24515. 

  24515.    if ((HEAP32[i3 + 32 >> 2] | 0) < 256) {
    24516. 

  24516.     if ((i10 | 0) == 1) {
    24517. 

  24517.      HEAP32[i6 + 8 >> 2] = 0;
    24518. 

  24518.      HEAP32[i7 >> 2] = HEAP32[i3 + 4 >> 2];
    24519. 

  24519.      HEAP32[i7 + 8 >> 2] = 69;
    24520. 

  24520.      i3 = _addk(i3, i7, i6) | 0;
    24521. 

  24521.     } else {
    24522. 

  24522.      HEAP32[i7 >> 2] = (i10 | 0) == 2;
    24523. 

  24523.      HEAP32[i7 + 8 >> 2] = 1;
    24524. 

  24524.      i3 = _addk(i3, i7, i7) | 0;
    24525. 

  24525.     }
    24526. 

  24526.     HEAP32[i1 + 8 >> 2] = i3;
    24527. 

  24527.     HEAP32[i1 >> 2] = 4;
    24528. 

  24528.     i10 = i3 | 256;
    24529. 

  24529.     STACKTOP = i2;
    24530. 

  24530.     return i10 | 0;
    24531. 

  24531.    }
    24532. 

  24532.    break;
    24533. 

  24533.   }
    24534. 

  24534.  case 5:
    24535. 

  24535.   {
    24536. 

  24536.    i9 = i1 + 8 | 0;
    24537. 

  24537.    d11 = +HEAPF64[i9 >> 3];
    24538. 

  24538.    HEAPF64[i7 >> 3] = d11;
    24539. 

  24539.    i8 = HEAP32[(HEAP32[i3 + 12 >> 2] | 0) + 52 >> 2] | 0;
    24540. 

  24540.    HEAPF64[i6 >> 3] = d11;
    24541. 

  24541.    HEAP32[i6 + 8 >> 2] = 3;
    24542. 

  24542.    if (d11 != d11 | 0.0 != 0.0 | d11 == 0.0) {
    24543. 

  24543.     i10 = i8 + 8 | 0;
    24544. 

  24544.     i12 = HEAP32[i10 >> 2] | 0;
    24545. 

  24545.     HEAP32[i10 >> 2] = i12 + 16;
    24546. 

  24546.     i8 = _luaS_newlstr(i8, i7, 8) | 0;
    24547. 

  24547.     HEAP32[i12 >> 2] = i8;
    24548. 

  24548.     HEAP32[i12 + 8 >> 2] = HEAPU8[i8 + 4 | 0] | 0 | 64;
    24549. 

  24549.     i8 = _addk(i3, (HEAP32[i10 >> 2] | 0) + -16 | 0, i6) | 0;
    24550. 

  24550.     HEAP32[i10 >> 2] = (HEAP32[i10 >> 2] | 0) + -16;
    24551. 

  24551.    } else {
    24552. 

  24552.     i8 = _addk(i3, i6, i6) | 0;
    24553. 

  24553.    }
    24554. 

  24554.    HEAP32[i9 >> 2] = i8;
    24555. 

  24555.    HEAP32[i1 >> 2] = 4;
    24556. 

  24556.    i9 = 18;
    24557. 

  24557.    break;
    24558. 

  24558.   }
    24559. 

  24559.  default:
    24560. 

  24560.   {}
    24561. 

  24561.  }
    24562. 

  24562.  if ((i9 | 0) == 18 ? (i8 | 0) < 256 : 0) {
    24563. 

  24563.   i12 = i8 | 256;
    24564. 

  24564.   STACKTOP = i2;
    24565. 

  24565.   return i12 | 0;
    24566. 

  24566.  }
    24567. 

  24567.  _luaK_dischargevars(i3, i1);
    24568. 

  24568.  if ((HEAP32[i1 >> 2] | 0) == 6) {
    24569. 

  24569.   i7 = i1 + 8 | 0;
    24570. 

  24570.   i6 = HEAP32[i7 >> 2] | 0;
    24571. 

  24571.   if ((HEAP32[i4 >> 2] | 0) == (HEAP32[i5 >> 2] | 0)) {
    24572. 

  24572.    i12 = i6;
    24573. 

  24573.    STACKTOP = i2;
    24574. 

  24574.    return i12 | 0;
    24575. 

  24575.   }
    24576. 

  24576.   if ((i6 | 0) >= (HEAPU8[i3 + 46 | 0] | 0 | 0)) {
    24577. 

  24577.    _exp2reg(i3, i1, i6);
    24578. 

  24578.    i12 = HEAP32[i7 >> 2] | 0;
    24579. 

  24579.    STACKTOP = i2;
    24580. 

  24580.    return i12 | 0;
    24581. 

  24581.   }
    24582. 

  24582.  } else {
    24583. 

  24583.   i7 = i1 + 8 | 0;
    24584. 

  24584.  }
    24585. 

  24585.  _luaK_exp2nextreg(i3, i1);
    24586. 

  24586.  i12 = HEAP32[i7 >> 2] | 0;
    24587. 

  24587.  STACKTOP = i2;
    24588. 

  24588.  return i12 | 0;
    24589. 

  24589. }
    24590. 

  24590. function _os_date(i1) {
    24591. 

  24591.  i1 = i1 | 0;
    24592. 

  24592.  var i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0, i14 = 0;
    24593. 

  24593.  i2 = STACKTOP;
    24594. 

  24594.  STACKTOP = STACKTOP + 1264 | 0;
    24595. 

  24595.  i4 = i2;
    24596. 

  24596.  i7 = i2 + 1048 | 0;
    24597. 

  24597.  i6 = i2 + 1256 | 0;
    24598. 

  24598.  i3 = i2 + 8 | 0;
    24599. 

  24599.  i5 = i2 + 1056 | 0;
    24600. 

  24600.  i12 = _luaL_optlstring(i1, 1, 6064, 0) | 0;
    24601. 

  24601.  if ((_lua_type(i1, 2) | 0) < 1) {
    24602. 

  24602.   i8 = _time(0) | 0;
    24603. 

  24603.  } else {
    24604. 

  24604.   i8 = ~~+_luaL_checknumber(i1, 2);
    24605. 

  24605.  }
    24606. 

  24606.  HEAP32[i7 >> 2] = i8;
    24607. 

  24607.  if ((HEAP8[i12] | 0) == 33) {
    24608. 

  24608.   i12 = i12 + 1 | 0;
    24609. 

  24609.   i10 = _gmtime(i7 | 0) | 0;
    24610. 

  24610.  } else {
    24611. 

  24611.   i10 = _localtime(i7 | 0) | 0;
    24612. 

  24612.  }
    24613. 

  24613.  if ((i10 | 0) == 0) {
    24614. 

  24614.   _lua_pushnil(i1);
    24615. 

  24615.   STACKTOP = i2;
    24616. 

  24616.   return 1;
    24617. 

  24617.  }
    24618. 

  24618.  if ((_strcmp(i12, 6072) | 0) == 0) {
    24619. 

  24619.   _lua_createtable(i1, 0, 9);
    24620. 

  24620.   _lua_pushinteger(i1, HEAP32[i10 >> 2] | 0);
    24621. 

  24621.   _lua_setfield(i1, -2, 5864);
    24622. 

  24622.   _lua_pushinteger(i1, HEAP32[i10 + 4 >> 2] | 0);
    24623. 

  24623.   _lua_setfield(i1, -2, 5872);
    24624. 

  24624.   _lua_pushinteger(i1, HEAP32[i10 + 8 >> 2] | 0);
    24625. 

  24625.   _lua_setfield(i1, -2, 5880);
    24626. 

  24626.   _lua_pushinteger(i1, HEAP32[i10 + 12 >> 2] | 0);
    24627. 

  24627.   _lua_setfield(i1, -2, 5888);
    24628. 

  24628.   _lua_pushinteger(i1, (HEAP32[i10 + 16 >> 2] | 0) + 1 | 0);
    24629. 

  24629.   _lua_setfield(i1, -2, 5896);
    24630. 

  24630.   _lua_pushinteger(i1, (HEAP32[i10 + 20 >> 2] | 0) + 1900 | 0);
    24631. 

  24631.   _lua_setfield(i1, -2, 5904);
    24632. 

  24632.   _lua_pushinteger(i1, (HEAP32[i10 + 24 >> 2] | 0) + 1 | 0);
    24633. 

  24633.   _lua_setfield(i1, -2, 6080);
    24634. 

  24634.   _lua_pushinteger(i1, (HEAP32[i10 + 28 >> 2] | 0) + 1 | 0);
    24635. 

  24635.   _lua_setfield(i1, -2, 6088);
    24636. 

  24636.   i3 = HEAP32[i10 + 32 >> 2] | 0;
    24637. 

  24637.   if ((i3 | 0) < 0) {
    24638. 

  24638.    STACKTOP = i2;
    24639. 

  24639.    return 1;
    24640. 

  24640.   }
    24641. 

  24641.   _lua_pushboolean(i1, i3);
    24642. 

  24642.   _lua_setfield(i1, -2, 5912);
    24643. 

  24643.   STACKTOP = i2;
    24644. 

  24644.   return 1;
    24645. 

  24645.  }
    24646. 

  24646.  HEAP8[i6] = 37;
    24647. 

  24647.  _luaL_buffinit(i1, i3);
    24648. 

  24648.  i11 = i3 + 8 | 0;
    24649. 

  24649.  i9 = i3 + 4 | 0;
    24650. 

  24650.  i8 = i6 + 1 | 0;
    24651. 

  24651.  i7 = i6 + 2 | 0;
    24652. 

  24652.  while (1) {
    24653. 

  24653.   i14 = HEAP8[i12] | 0;
    24654. 

  24654.   if (i14 << 24 >> 24 == 0) {
    24655. 

  24655.    break;
    24656. 

  24656.   } else if (!(i14 << 24 >> 24 == 37)) {
    24657. 

  24657.    i13 = HEAP32[i11 >> 2] | 0;
    24658. 

  24658.    if (!(i13 >>> 0 < (HEAP32[i9 >> 2] | 0) >>> 0)) {
    24659. 

  24659.     _luaL_prepbuffsize(i3, 1) | 0;
    24660. 

  24660.     i13 = HEAP32[i11 >> 2] | 0;
    24661. 

  24661.     i14 = HEAP8[i12] | 0;
    24662. 

  24662.    }
    24663. 

  24663.    HEAP32[i11 >> 2] = i13 + 1;
    24664. 

  24664.    HEAP8[(HEAP32[i3 >> 2] | 0) + i13 | 0] = i14;
    24665. 

  24665.    i12 = i12 + 1 | 0;
    24666. 

  24666.    continue;
    24667. 

  24667.   }
    24668. 

  24668.   i13 = i12 + 1 | 0;
    24669. 

  24669.   i12 = i12 + 2 | 0;
    24670. 

  24670.   i14 = HEAP8[i13] | 0;
    24671. 

  24671.   if (!(i14 << 24 >> 24 == 0) ? (_memchr(6096, i14 << 24 >> 24, 23) | 0) != 0 : 0) {
    24672. 

  24672.    HEAP8[i8] = i14;
    24673. 

  24673.    HEAP8[i7] = 0;
    24674. 

  24674.   } else {
    24675. 

  24675.    HEAP32[i4 >> 2] = i13;
    24676. 

  24676.    _luaL_argerror(i1, 1, _lua_pushfstring(i1, 6120, i4) | 0) | 0;
    24677. 

  24677.    i12 = i13;
    24678. 

  24678.   }
    24679. 

  24679.   _luaL_addlstring(i3, i5, _strftime(i5 | 0, 200, i6 | 0, i10 | 0) | 0);
    24680. 

  24680.  }
    24681. 

  24681.  _luaL_pushresult(i3);
    24682. 

  24682.  STACKTOP = i2;
    24683. 

  24683.  return 1;
    24684. 

  24684. }
    24685. 

  24685. function _luaV_finishOp(i3) {
    24686. 

  24686.  i3 = i3 | 0;
    24687. 

  24687.  var i1 = 0, i2 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0;
    24688. 

  24688.  i1 = STACKTOP;
    24689. 

  24689.  i8 = HEAP32[i3 + 16 >> 2] | 0;
    24690. 

  24690.  i7 = i8 + 24 | 0;
    24691. 

  24691.  i4 = HEAP32[i7 >> 2] | 0;
    24692. 

  24692.  i5 = i8 + 28 | 0;
    24693. 

  24693.  i2 = HEAP32[(HEAP32[i5 >> 2] | 0) + -4 >> 2] | 0;
    24694. 

  24694.  i6 = i2 & 63;
    24695. 

  24695.  switch (i6 | 0) {
    24696. 

  24696.  case 34:
    24697. 

  24697.   {
    24698. 

  24698.    HEAP32[i3 + 8 >> 2] = HEAP32[i8 + 4 >> 2];
    24699. 

  24699.    STACKTOP = i1;
    24700. 

  24700.    return;
    24701. 

  24701.   }
    24702. 

  24702.  case 24:
    24703. 

  24703.  case 25:
    24704. 

  24704.  case 26:
    24705. 

  24705.   {
    24706. 

  24706.    i7 = i3 + 8 | 0;
    24707. 

  24707.    i8 = HEAP32[i7 >> 2] | 0;
    24708. 

  24708.    i9 = HEAP32[i8 + -8 >> 2] | 0;
    24709. 

  24709.    if ((i9 | 0) != 0) {
    24710. 

  24710.     if ((i9 | 0) == 1) {
    24711. 

  24711.      i9 = (HEAP32[i8 + -16 >> 2] | 0) == 0;
    24712. 

  24712.     } else {
    24713. 

  24713.      i9 = 0;
    24714. 

  24714.     }
    24715. 

  24715.    } else {
    24716. 

  24716.     i9 = 1;
    24717. 

  24717.    }
    24718. 

  24718.    i9 = i9 & 1;
    24719. 

  24719.    i10 = i9 ^ 1;
    24720. 

  24720.    HEAP32[i7 >> 2] = i8 + -16;
    24721. 

  24721.    if ((i6 | 0) == 26) {
    24722. 

  24722.     i8 = (HEAP32[(_luaT_gettmbyobj(i3, i4 + (i2 >>> 23 << 4) | 0, 14) | 0) + 8 >> 2] | 0) == 0;
    24723. 

  24723.     i10 = i8 ? i9 : i10;
    24724. 

  24724.    }
    24725. 

  24725.    if ((i10 | 0) == (i2 >>> 6 & 255 | 0)) {
    24726. 

  24726.     STACKTOP = i1;
    24727. 

  24727.     return;
    24728. 

  24728.    }
    24729. 

  24729.    HEAP32[i5 >> 2] = (HEAP32[i5 >> 2] | 0) + 4;
    24730. 

  24730.    STACKTOP = i1;
    24731. 

  24731.    return;
    24732. 

  24732.   }
    24733. 

  24733.  case 22:
    24734. 

  24734.   {
    24735. 

  24735.    i5 = i3 + 8 | 0;
    24736. 

  24736.    i10 = HEAP32[i5 >> 2] | 0;
    24737. 

  24737.    i6 = i10 + -32 | 0;
    24738. 

  24738.    i4 = i6 - (i4 + (i2 >>> 23 << 4)) | 0;
    24739. 

  24739.    i12 = i10 + -16 | 0;
    24740. 

  24740.    i11 = HEAP32[i12 + 4 >> 2] | 0;
    24741. 

  24741.    i9 = i10 + -48 | 0;
    24742. 

  24742.    HEAP32[i9 >> 2] = HEAP32[i12 >> 2];
    24743. 

  24743.    HEAP32[i9 + 4 >> 2] = i11;
    24744. 

  24744.    HEAP32[i10 + -40 >> 2] = HEAP32[i10 + -8 >> 2];
    24745. 

  24745.    if ((i4 | 0) > 16) {
    24746. 

  24746.     HEAP32[i5 >> 2] = i6;
    24747. 

  24747.     _luaV_concat(i3, i4 >> 4);
    24748. 

  24748.    }
    24749. 

  24749.    i10 = HEAP32[i5 >> 2] | 0;
    24750. 

  24750.    i11 = HEAP32[i7 >> 2] | 0;
    24751. 

  24751.    i12 = i2 >>> 6 & 255;
    24752. 

  24752.    i6 = i10 + -16 | 0;
    24753. 

  24753.    i7 = HEAP32[i6 + 4 >> 2] | 0;
    24754. 

  24754.    i9 = i11 + (i12 << 4) | 0;
    24755. 

  24755.    HEAP32[i9 >> 2] = HEAP32[i6 >> 2];
    24756. 

  24756.    HEAP32[i9 + 4 >> 2] = i7;
    24757. 

  24757.    HEAP32[i11 + (i12 << 4) + 8 >> 2] = HEAP32[i10 + -8 >> 2];
    24758. 

  24758.    HEAP32[i5 >> 2] = HEAP32[i8 + 4 >> 2];
    24759. 

  24759.    STACKTOP = i1;
    24760. 

  24760.    return;
    24761. 

  24761.   }
    24762. 

  24762.  case 12:
    24763. 

  24763.  case 7:
    24764. 

  24764.  case 6:
    24765. 

  24765.  case 21:
    24766. 

  24766.  case 19:
    24767. 

  24767.  case 18:
    24768. 

  24768.  case 17:
    24769. 

  24769.  case 16:
    24770. 

  24770.  case 15:
    24771. 

  24771.  case 14:
    24772. 

  24772.  case 13:
    24773. 

  24773.   {
    24774. 

  24774.    i12 = i3 + 8 | 0;
    24775. 

  24775.    i11 = HEAP32[i12 >> 2] | 0;
    24776. 

  24776.    i8 = i11 + -16 | 0;
    24777. 

  24777.    HEAP32[i12 >> 2] = i8;
    24778. 

  24778.    i12 = i2 >>> 6 & 255;
    24779. 

  24779.    i9 = HEAP32[i8 + 4 >> 2] | 0;
    24780. 

  24780.    i10 = i4 + (i12 << 4) | 0;
    24781. 

  24781.    HEAP32[i10 >> 2] = HEAP32[i8 >> 2];
    24782. 

  24782.    HEAP32[i10 + 4 >> 2] = i9;
    24783. 

  24783.    HEAP32[i4 + (i12 << 4) + 8 >> 2] = HEAP32[i11 + -8 >> 2];
    24784. 

  24784.    STACKTOP = i1;
    24785. 

  24785.    return;
    24786. 

  24786.   }
    24787. 

  24787.  case 29:
    24788. 

  24788.   {
    24789. 

  24789.    if ((i2 & 8372224 | 0) == 0) {
    24790. 

  24790.     STACKTOP = i1;
    24791. 

  24791.     return;
    24792. 

  24792.    }
    24793. 

  24793.    HEAP32[i3 + 8 >> 2] = HEAP32[i8 + 4 >> 2];
    24794. 

  24794.    STACKTOP = i1;
    24795. 

  24795.    return;
    24796. 

  24796.   }
    24797. 

  24797.  default:
    24798. 

  24798.   {
    24799. 

  24799.    STACKTOP = i1;
    24800. 

  24800.    return;
    24801. 

  24801.   }
    24802. 

  24802.  }
    24803. 

  24803. }
    24804. 

  24804. function _auxsort(i2, i4, i5) {
    24805. 

  24805.  i2 = i2 | 0;
    24806. 

  24806.  i4 = i4 | 0;
    24807. 

  24807.  i5 = i5 | 0;
    24808. 

  24808.  var i1 = 0, i3 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0;
    24809. 

  24809.  i1 = STACKTOP;
    24810. 

  24810.  STACKTOP = STACKTOP + 16 | 0;
    24811. 

  24811.  i3 = i1;
    24812. 

  24812.  if ((i4 | 0) >= (i5 | 0)) {
    24813. 

  24813.   STACKTOP = i1;
    24814. 

  24814.   return;
    24815. 

  24815.  }
    24816. 

  24816.  while (1) {
    24817. 

  24817.   _lua_rawgeti(i2, 1, i4);
    24818. 

  24818.   _lua_rawgeti(i2, 1, i5);
    24819. 

  24819.   if ((_sort_comp(i2, -1, -2) | 0) == 0) {
    24820. 

  24820.    _lua_settop(i2, -3);
    24821. 

  24821.   } else {
    24822. 

  24822.    _lua_rawseti(i2, 1, i4);
    24823. 

  24823.    _lua_rawseti(i2, 1, i5);
    24824. 

  24824.   }
    24825. 

  24825.   i6 = i5 - i4 | 0;
    24826. 

  24826.   if ((i6 | 0) == 1) {
    24827. 

  24827.    i2 = 24;
    24828. 

  24828.    break;
    24829. 

  24829.   }
    24830. 

  24830.   i7 = (i5 + i4 | 0) / 2 | 0;
    24831. 

  24831.   _lua_rawgeti(i2, 1, i7);
    24832. 

  24832.   _lua_rawgeti(i2, 1, i4);
    24833. 

  24833.   do {
    24834. 

  24834.    if ((_sort_comp(i2, -2, -1) | 0) == 0) {
    24835. 

  24835.     _lua_settop(i2, -2);
    24836. 

  24836.     _lua_rawgeti(i2, 1, i5);
    24837. 

  24837.     if ((_sort_comp(i2, -1, -2) | 0) == 0) {
    24838. 

  24838.      _lua_settop(i2, -3);
    24839. 

  24839.      break;
    24840. 

  24840.     } else {
    24841. 

  24841.      _lua_rawseti(i2, 1, i7);
    24842. 

  24842.      _lua_rawseti(i2, 1, i5);
    24843. 

  24843.      break;
    24844. 

  24844.     }
    24845. 

  24845.    } else {
    24846. 

  24846.     _lua_rawseti(i2, 1, i7);
    24847. 

  24847.     _lua_rawseti(i2, 1, i4);
    24848. 

  24848.    }
    24849. 

  24849.   } while (0);
    24850. 

  24850.   if ((i6 | 0) == 2) {
    24851. 

  24851.    i2 = 24;
    24852. 

  24852.    break;
    24853. 

  24853.   }
    24854. 

  24854.   _lua_rawgeti(i2, 1, i7);
    24855. 

  24855.   _lua_pushvalue(i2, -1);
    24856. 

  24856.   i6 = i5 + -1 | 0;
    24857. 

  24857.   _lua_rawgeti(i2, 1, i6);
    24858. 

  24858.   _lua_rawseti(i2, 1, i7);
    24859. 

  24859.   _lua_rawseti(i2, 1, i6);
    24860. 

  24860.   i7 = i4;
    24861. 

  24861.   i9 = i6;
    24862. 

  24862.   while (1) {
    24863. 

  24863.    i8 = i7 + 1 | 0;
    24864. 

  24864.    _lua_rawgeti(i2, 1, i8);
    24865. 

  24865.    if ((_sort_comp(i2, -1, -2) | 0) != 0) {
    24866. 

  24866.     i7 = i8;
    24867. 

  24867.     while (1) {
    24868. 

  24868.      if ((i7 | 0) >= (i5 | 0)) {
    24869. 

  24869.       _luaL_error(i2, 8216, i3) | 0;
    24870. 

  24870.      }
    24871. 

  24871.      _lua_settop(i2, -2);
    24872. 

  24872.      i8 = i7 + 1 | 0;
    24873. 

  24873.      _lua_rawgeti(i2, 1, i8);
    24874. 

  24874.      if ((_sort_comp(i2, -1, -2) | 0) == 0) {
    24875. 

  24875.       break;
    24876. 

  24876.      } else {
    24877. 

  24877.       i7 = i8;
    24878. 

  24878.      }
    24879. 

  24879.     }
    24880. 

  24880.    }
    24881. 

  24881.    i10 = i9 + -1 | 0;
    24882. 

  24882.    _lua_rawgeti(i2, 1, i10);
    24883. 

  24883.    if ((_sort_comp(i2, -3, -1) | 0) != 0) {
    24884. 

  24884.     i9 = i10;
    24885. 

  24885.     while (1) {
    24886. 

  24886.      if ((i9 | 0) <= (i4 | 0)) {
    24887. 

  24887.       _luaL_error(i2, 8216, i3) | 0;
    24888. 

  24888.      }
    24889. 

  24889.      _lua_settop(i2, -2);
    24890. 

  24890.      i10 = i9 + -1 | 0;
    24891. 

  24891.      _lua_rawgeti(i2, 1, i10);
    24892. 

  24892.      if ((_sort_comp(i2, -3, -1) | 0) == 0) {
    24893. 

  24893.       break;
    24894. 

  24894.      } else {
    24895. 

  24895.       i9 = i10;
    24896. 

  24896.      }
    24897. 

  24897.     }
    24898. 

  24898.    }
    24899. 

  24899.    if ((i9 | 0) <= (i8 | 0)) {
    24900. 

  24900.     break;
    24901. 

  24901.    }
    24902. 

  24902.    _lua_rawseti(i2, 1, i8);
    24903. 

  24903.    _lua_rawseti(i2, 1, i10);
    24904. 

  24904.    i7 = i8;
    24905. 

  24905.    i9 = i10;
    24906. 

  24906.   }
    24907. 

  24907.   _lua_settop(i2, -4);
    24908. 

  24908.   _lua_rawgeti(i2, 1, i6);
    24909. 

  24909.   _lua_rawgeti(i2, 1, i8);
    24910. 

  24910.   _lua_rawseti(i2, 1, i6);
    24911. 

  24911.   _lua_rawseti(i2, 1, i8);
    24912. 

  24912.   i8 = (i8 - i4 | 0) < (i5 - i8 | 0);
    24913. 

  24913.   i9 = i7 + 2 | 0;
    24914. 

  24914.   i10 = i8 ? i9 : i4;
    24915. 

  24915.   i6 = i8 ? i5 : i7;
    24916. 

  24916.   _auxsort(i2, i8 ? i4 : i9, i8 ? i7 : i5);
    24917. 

  24917.   if ((i10 | 0) < (i6 | 0)) {
    24918. 

  24918.    i4 = i10;
    24919. 

  24919.    i5 = i6;
    24920. 

  24920.   } else {
    24921. 

  24921.    i2 = 24;
    24922. 

  24922.    break;
    24923. 

  24923.   }
    24924. 

  24924.  }
    24925. 

  24925.  if ((i2 | 0) == 24) {
    24926. 

  24926.   STACKTOP = i1;
    24927. 

  24927.   return;
    24928. 

  24928.  }
    24929. 

  24929. }
    24930. 

  24930. function _skip_sep(i3) {
    24931. 

  24931.  i3 = i3 | 0;
    24932. 

  24932.  var i1 = 0, i2 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0;
    24933. 

  24933.  i1 = STACKTOP;
    24934. 

  24934.  i2 = HEAP32[i3 >> 2] | 0;
    24935. 

  24935.  i4 = i3 + 60 | 0;
    24936. 

  24936.  i10 = HEAP32[i4 >> 2] | 0;
    24937. 

  24937.  i8 = i10 + 4 | 0;
    24938. 

  24938.  i11 = HEAP32[i8 >> 2] | 0;
    24939. 

  24939.  i7 = i10 + 8 | 0;
    24940. 

  24940.  i5 = HEAP32[i7 >> 2] | 0;
    24941. 

  24941.  do {
    24942. 

  24942.   if ((i11 + 1 | 0) >>> 0 > i5 >>> 0) {
    24943. 

  24943.    if (i5 >>> 0 > 2147483645) {
    24944. 

  24944.     _lexerror(i3, 12368, 0);
    24945. 

  24945.    }
    24946. 

  24946.    i12 = i5 << 1;
    24947. 

  24947.    i11 = HEAP32[i3 + 52 >> 2] | 0;
    24948. 

  24948.    if ((i12 | 0) == -2) {
    24949. 

  24949.     _luaM_toobig(i11);
    24950. 

  24950.    } else {
    24951. 

  24951.     i9 = _luaM_realloc_(i11, HEAP32[i10 >> 2] | 0, i5, i12) | 0;
    24952. 

  24952.     HEAP32[i10 >> 2] = i9;
    24953. 

  24953.     HEAP32[i7 >> 2] = i12;
    24954. 

  24954.     i6 = HEAP32[i8 >> 2] | 0;
    24955. 

  24955.     break;
    24956. 

  24956.    }
    24957. 

  24957.   } else {
    24958. 

  24958.    i6 = i11;
    24959. 

  24959.    i9 = HEAP32[i10 >> 2] | 0;
    24960. 

  24960.   }
    24961. 

  24961.  } while (0);
    24962. 

  24962.  HEAP32[i8 >> 2] = i6 + 1;
    24963. 

  24963.  HEAP8[i9 + i6 | 0] = i2;
    24964. 

  24964.  i5 = i3 + 56 | 0;
    24965. 

  24965.  i6 = HEAP32[i5 >> 2] | 0;
    24966. 

  24966.  i13 = HEAP32[i6 >> 2] | 0;
    24967. 

  24967.  HEAP32[i6 >> 2] = i13 + -1;
    24968. 

  24968.  if ((i13 | 0) == 0) {
    24969. 

  24969.   i6 = _luaZ_fill(i6) | 0;
    24970. 

  24970.  } else {
    24971. 

  24971.   i13 = i6 + 4 | 0;
    24972. 

  24972.   i6 = HEAP32[i13 >> 2] | 0;
    24973. 

  24973.   HEAP32[i13 >> 2] = i6 + 1;
    24974. 

  24974.   i6 = HEAPU8[i6] | 0;
    24975. 

  24975.  }
    24976. 

  24976.  HEAP32[i3 >> 2] = i6;
    24977. 

  24977.  if ((i6 | 0) != 61) {
    24978. 

  24978.   i12 = i6;
    24979. 

  24979.   i13 = 0;
    24980. 

  24980.   i12 = (i12 | 0) != (i2 | 0);
    24981. 

  24981.   i12 = i12 << 31 >> 31;
    24982. 

  24982.   i13 = i12 ^ i13;
    24983. 

  24983.   STACKTOP = i1;
    24984. 

  24984.   return i13 | 0;
    24985. 

  24985.  }
    24986. 

  24986.  i6 = i3 + 52 | 0;
    24987. 

  24987.  i7 = 0;
    24988. 

  24988.  while (1) {
    24989. 

  24989.   i9 = HEAP32[i4 >> 2] | 0;
    24990. 

  24990.   i8 = i9 + 4 | 0;
    24991. 

  24991.   i10 = HEAP32[i8 >> 2] | 0;
    24992. 

  24992.   i11 = i9 + 8 | 0;
    24993. 

  24993.   i12 = HEAP32[i11 >> 2] | 0;
    24994. 

  24994.   if ((i10 + 1 | 0) >>> 0 > i12 >>> 0) {
    24995. 

  24995.    if (i12 >>> 0 > 2147483645) {
    24996. 

  24996.     i4 = 16;
    24997. 

  24997.     break;
    24998. 

  24998.    }
    24999. 

  24999.    i13 = i12 << 1;
    25000. 

  25000.    i10 = HEAP32[i6 >> 2] | 0;
    25001. 

  25001.    if ((i13 | 0) == -2) {
    25002. 

  25002.     i4 = 18;
    25003. 

  25003.     break;
    25004. 

  25004.    }
    25005. 

  25005.    i12 = _luaM_realloc_(i10, HEAP32[i9 >> 2] | 0, i12, i13) | 0;
    25006. 

  25006.    HEAP32[i9 >> 2] = i12;
    25007. 

  25007.    HEAP32[i11 >> 2] = i13;
    25008. 

  25008.    i10 = HEAP32[i8 >> 2] | 0;
    25009. 

  25009.    i9 = i12;
    25010. 

  25010.   } else {
    25011. 

  25011.    i9 = HEAP32[i9 >> 2] | 0;
    25012. 

  25012.   }
    25013. 

  25013.   HEAP32[i8 >> 2] = i10 + 1;
    25014. 

  25014.   HEAP8[i9 + i10 | 0] = 61;
    25015. 

  25015.   i8 = HEAP32[i5 >> 2] | 0;
    25016. 

  25016.   i13 = HEAP32[i8 >> 2] | 0;
    25017. 

  25017.   HEAP32[i8 >> 2] = i13 + -1;
    25018. 

  25018.   if ((i13 | 0) == 0) {
    25019. 

  25019.    i8 = _luaZ_fill(i8) | 0;
    25020. 

  25020.   } else {
    25021. 

  25021.    i13 = i8 + 4 | 0;
    25022. 

  25022.    i8 = HEAP32[i13 >> 2] | 0;
    25023. 

  25023.    HEAP32[i13 >> 2] = i8 + 1;
    25024. 

  25024.    i8 = HEAPU8[i8] | 0;
    25025. 

  25025.   }
    25026. 

  25026.   HEAP32[i3 >> 2] = i8;
    25027. 

  25027.   i7 = i7 + 1 | 0;
    25028. 

  25028.   if ((i8 | 0) != 61) {
    25029. 

  25029.    i4 = 24;
    25030. 

  25030.    break;
    25031. 

  25031.   }
    25032. 

  25032.  }
    25033. 

  25033.  if ((i4 | 0) == 16) {
    25034. 

  25034.   _lexerror(i3, 12368, 0);
    25035. 

  25035.  } else if ((i4 | 0) == 18) {
    25036. 

  25036.   _luaM_toobig(i10);
    25037. 

  25037.  } else if ((i4 | 0) == 24) {
    25038. 

  25038.   i13 = (i8 | 0) != (i2 | 0);
    25039. 

  25039.   i13 = i13 << 31 >> 31;
    25040. 

  25040.   i13 = i13 ^ i7;
    25041. 

  25041.   STACKTOP = i1;
    25042. 

  25042.   return i13 | 0;
    25043. 

  25043.  }
    25044. 

  25044.  return 0;
    25045. 

  25045. }
    25046. 

  25046. function _luaV_arith(i8, i2, i3, i5, i4) {
    25047. 

  25047.  i8 = i8 | 0;
    25048. 

  25048.  i2 = i2 | 0;
    25049. 

  25049.  i3 = i3 | 0;
    25050. 

  25050.  i5 = i5 | 0;
    25051. 

  25051.  i4 = i4 | 0;
    25052. 

  25052.  var i1 = 0, i6 = 0, i7 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0, d14 = 0.0;
    25053. 

  25053.  i1 = STACKTOP;
    25054. 

  25054.  STACKTOP = STACKTOP + 32 | 0;
    25055. 

  25055.  i9 = i1 + 24 | 0;
    25056. 

  25056.  i13 = i1 + 16 | 0;
    25057. 

  25057.  i12 = i1;
    25058. 

  25058.  i6 = i3 + 8 | 0;
    25059. 

  25059.  i11 = HEAP32[i6 >> 2] | 0;
    25060. 

  25060.  if ((i11 | 0) != 3) {
    25061. 

  25061.   if ((i11 & 15 | 0) == 4 ? (i11 = HEAP32[i3 >> 2] | 0, (_luaO_str2d(i11 + 16 | 0, HEAP32[i11 + 12 >> 2] | 0, i13) | 0) != 0) : 0) {
    25062. 

  25062.    HEAPF64[i12 >> 3] = +HEAPF64[i13 >> 3];
    25063. 

  25063.    HEAP32[i12 + 8 >> 2] = 3;
    25064. 

  25064.    i10 = 5;
    25065. 

  25065.   }
    25066. 

  25066.  } else {
    25067. 

  25067.   i12 = i3;
    25068. 

  25068.   i10 = 5;
    25069. 

  25069.  }
    25070. 

  25070.  do {
    25071. 

  25071.   if ((i10 | 0) == 5) {
    25072. 

  25072.    i10 = HEAP32[i5 + 8 >> 2] | 0;
    25073. 

  25073.    if ((i10 | 0) == 3) {
    25074. 

  25074.     if ((i5 | 0) == 0) {
    25075. 

  25075.      break;
    25076. 

  25076.     }
    25077. 

  25077.     d14 = +HEAPF64[i5 >> 3];
    25078. 

  25078.    } else {
    25079. 

  25079.     if ((i10 & 15 | 0) != 4) {
    25080. 

  25080.      break;
    25081. 

  25081.     }
    25082. 

  25082.     i13 = HEAP32[i5 >> 2] | 0;
    25083. 

  25083.     if ((_luaO_str2d(i13 + 16 | 0, HEAP32[i13 + 12 >> 2] | 0, i9) | 0) == 0) {
    25084. 

  25084.      break;
    25085. 

  25085.     }
    25086. 

  25086.     d14 = +HEAPF64[i9 >> 3];
    25087. 

  25087.    }
    25088. 

  25088.    HEAPF64[i2 >> 3] = +_luaO_arith(i4 + -6 | 0, +HEAPF64[i12 >> 3], d14);
    25089. 

  25089.    HEAP32[i2 + 8 >> 2] = 3;
    25090. 

  25090.    STACKTOP = i1;
    25091. 

  25091.    return;
    25092. 

  25092.   }
    25093. 

  25093.  } while (0);
    25094. 

  25094.  i9 = _luaT_gettmbyobj(i8, i3, i4) | 0;
    25095. 

  25095.  if ((HEAP32[i9 + 8 >> 2] | 0) == 0) {
    25096. 

  25096.   i4 = _luaT_gettmbyobj(i8, i5, i4) | 0;
    25097. 

  25097.   if ((HEAP32[i4 + 8 >> 2] | 0) == 0) {
    25098. 

  25098.    _luaG_aritherror(i8, i3, i5);
    25099. 

  25099.   } else {
    25100. 

  25100.    i7 = i4;
    25101. 

  25101.   }
    25102. 

  25102.  } else {
    25103. 

  25103.   i7 = i9;
    25104. 

  25104.  }
    25105. 

  25105.  i12 = i8 + 28 | 0;
    25106. 

  25106.  i13 = i2 - (HEAP32[i12 >> 2] | 0) | 0;
    25107. 

  25107.  i9 = i8 + 8 | 0;
    25108. 

  25108.  i11 = HEAP32[i9 >> 2] | 0;
    25109. 

  25109.  HEAP32[i9 >> 2] = i11 + 16;
    25110. 

  25110.  i2 = i7;
    25111. 

  25111.  i10 = HEAP32[i2 + 4 >> 2] | 0;
    25112. 

  25112.  i4 = i11;
    25113. 

  25113.  HEAP32[i4 >> 2] = HEAP32[i2 >> 2];
    25114. 

  25114.  HEAP32[i4 + 4 >> 2] = i10;
    25115. 

  25115.  HEAP32[i11 + 8 >> 2] = HEAP32[i7 + 8 >> 2];
    25116. 

  25116.  i11 = HEAP32[i9 >> 2] | 0;
    25117. 

  25117.  HEAP32[i9 >> 2] = i11 + 16;
    25118. 

  25118.  i4 = i3;
    25119. 

  25119.  i10 = HEAP32[i4 + 4 >> 2] | 0;
    25120. 

  25120.  i7 = i11;
    25121. 

  25121.  HEAP32[i7 >> 2] = HEAP32[i4 >> 2];
    25122. 

  25122.  HEAP32[i7 + 4 >> 2] = i10;
    25123. 

  25123.  HEAP32[i11 + 8 >> 2] = HEAP32[i6 >> 2];
    25124. 

  25124.  i11 = HEAP32[i9 >> 2] | 0;
    25125. 

  25125.  HEAP32[i9 >> 2] = i11 + 16;
    25126. 

  25126.  i6 = i5;
    25127. 

  25127.  i7 = HEAP32[i6 + 4 >> 2] | 0;
    25128. 

  25128.  i10 = i11;
    25129. 

  25129.  HEAP32[i10 >> 2] = HEAP32[i6 >> 2];
    25130. 

  25130.  HEAP32[i10 + 4 >> 2] = i7;
    25131. 

  25131.  HEAP32[i11 + 8 >> 2] = HEAP32[i5 + 8 >> 2];
    25132. 

  25132.  _luaD_call(i8, (HEAP32[i9 >> 2] | 0) + -48 | 0, 1, HEAP8[(HEAP32[i8 + 16 >> 2] | 0) + 18 | 0] & 1);
    25133. 

  25133.  i12 = HEAP32[i12 >> 2] | 0;
    25134. 

  25134.  i11 = HEAP32[i9 >> 2] | 0;
    25135. 

  25135.  i8 = i11 + -16 | 0;
    25136. 

  25136.  HEAP32[i9 >> 2] = i8;
    25137. 

  25137.  i9 = HEAP32[i8 + 4 >> 2] | 0;
    25138. 

  25138.  i10 = i12 + i13 | 0;
    25139. 

  25139.  HEAP32[i10 >> 2] = HEAP32[i8 >> 2];
    25140. 

  25140.  HEAP32[i10 + 4 >> 2] = i9;
    25141. 

  25141.  HEAP32[i12 + (i13 + 8) >> 2] = HEAP32[i11 + -8 >> 2];
    25142. 

  25142.  STACKTOP = i1;
    25143. 

  25143.  return;
    25144. 

  25144. }
    25145. 

  25145. function _new_localvar(i1, i8) {
    25146. 

  25146.  i1 = i1 | 0;
    25147. 

  25147.  i8 = i8 | 0;
    25148. 

  25148.  var i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0;
    25149. 

  25149.  i3 = STACKTOP;
    25150. 

  25150.  STACKTOP = STACKTOP + 16 | 0;
    25151. 

  25151.  i4 = i3;
    25152. 

  25152.  i5 = HEAP32[i1 + 48 >> 2] | 0;
    25153. 

  25153.  i2 = HEAP32[i1 + 64 >> 2] | 0;
    25154. 

  25154.  i7 = HEAP32[i5 >> 2] | 0;
    25155. 

  25155.  i10 = i7 + 60 | 0;
    25156. 

  25156.  i11 = HEAP32[i10 >> 2] | 0;
    25157. 

  25157.  i6 = i5 + 44 | 0;
    25158. 

  25158.  if ((HEAP16[i6 >> 1] | 0) < (i11 | 0)) {
    25159. 

  25159.   i9 = i7 + 24 | 0;
    25160. 

  25160.   i10 = i11;
    25161. 

  25161.  } else {
    25162. 

  25162.   i9 = i7 + 24 | 0;
    25163. 

  25163.   HEAP32[i9 >> 2] = _luaM_growaux_(HEAP32[i1 + 52 >> 2] | 0, HEAP32[i9 >> 2] | 0, i10, 12, 32767, 6496) | 0;
    25164. 

  25164.   i10 = HEAP32[i10 >> 2] | 0;
    25165. 

  25165.  }
    25166. 

  25166.  if ((i11 | 0) < (i10 | 0)) {
    25167. 

  25167.   i12 = i11;
    25168. 

  25168.   while (1) {
    25169. 

  25169.    i11 = i12 + 1 | 0;
    25170. 

  25170.    HEAP32[(HEAP32[i9 >> 2] | 0) + (i12 * 12 | 0) >> 2] = 0;
    25171. 

  25171.    if ((i11 | 0) == (i10 | 0)) {
    25172. 

  25172.     break;
    25173. 

  25173.    } else {
    25174. 

  25174.     i12 = i11;
    25175. 

  25175.    }
    25176. 

  25176.   }
    25177. 

  25177.  }
    25178. 

  25178.  i10 = HEAP16[i6 >> 1] | 0;
    25179. 

  25179.  HEAP32[(HEAP32[i9 >> 2] | 0) + ((i10 << 16 >> 16) * 12 | 0) >> 2] = i8;
    25180. 

  25180.  if (!((HEAP8[i8 + 5 | 0] & 3) == 0) ? !((HEAP8[i7 + 5 | 0] & 4) == 0) : 0) {
    25181. 

  25181.   _luaC_barrier_(HEAP32[i1 + 52 >> 2] | 0, i7, i8);
    25182. 

  25182.   i7 = HEAP16[i6 >> 1] | 0;
    25183. 

  25183.  } else {
    25184. 

  25184.   i7 = i10;
    25185. 

  25185.  }
    25186. 

  25186.  HEAP16[i6 >> 1] = i7 + 1 << 16 >> 16;
    25187. 

  25187.  i6 = i2 + 4 | 0;
    25188. 

  25188.  i8 = HEAP32[i6 >> 2] | 0;
    25189. 

  25189.  if ((i8 + 1 - (HEAP32[i5 + 40 >> 2] | 0) | 0) > 200) {
    25190. 

  25190.   i10 = i5 + 12 | 0;
    25191. 

  25191.   i9 = HEAP32[(HEAP32[i10 >> 2] | 0) + 52 >> 2] | 0;
    25192. 

  25192.   i5 = HEAP32[(HEAP32[i5 >> 2] | 0) + 64 >> 2] | 0;
    25193. 

  25193.   if ((i5 | 0) == 0) {
    25194. 

  25194.    i11 = 6552;
    25195. 

  25195.    HEAP32[i4 >> 2] = 6496;
    25196. 

  25196.    i12 = i4 + 4 | 0;
    25197. 

  25197.    HEAP32[i12 >> 2] = 200;
    25198. 

  25198.    i12 = i4 + 8 | 0;
    25199. 

  25199.    HEAP32[i12 >> 2] = i11;
    25200. 

  25200.    i12 = _luaO_pushfstring(i9, 6592, i4) | 0;
    25201. 

  25201.    i11 = HEAP32[i10 >> 2] | 0;
    25202. 

  25202.    _luaX_syntaxerror(i11, i12);
    25203. 

  25203.   }
    25204. 

  25204.   HEAP32[i4 >> 2] = i5;
    25205. 

  25205.   i11 = _luaO_pushfstring(i9, 6568, i4) | 0;
    25206. 

  25206.   HEAP32[i4 >> 2] = 6496;
    25207. 

  25207.   i12 = i4 + 4 | 0;
    25208. 

  25208.   HEAP32[i12 >> 2] = 200;
    25209. 

  25209.   i12 = i4 + 8 | 0;
    25210. 

  25210.   HEAP32[i12 >> 2] = i11;
    25211. 

  25211.   i12 = _luaO_pushfstring(i9, 6592, i4) | 0;
    25212. 

  25212.   i11 = HEAP32[i10 >> 2] | 0;
    25213. 

  25213.   _luaX_syntaxerror(i11, i12);
    25214. 

  25214.  }
    25215. 

  25215.  i4 = i2 + 8 | 0;
    25216. 

  25216.  if ((i8 + 2 | 0) > (HEAP32[i4 >> 2] | 0)) {
    25217. 

  25217.   i11 = _luaM_growaux_(HEAP32[i1 + 52 >> 2] | 0, HEAP32[i2 >> 2] | 0, i4, 2, 2147483645, 6496) | 0;
    25218. 

  25218.   HEAP32[i2 >> 2] = i11;
    25219. 

  25219.   i12 = HEAP32[i6 >> 2] | 0;
    25220. 

  25220.   i10 = i12 + 1 | 0;
    25221. 

  25221.   HEAP32[i6 >> 2] = i10;
    25222. 

  25222.   i12 = i11 + (i12 << 1) | 0;
    25223. 

  25223.   HEAP16[i12 >> 1] = i7;
    25224. 

  25224.   STACKTOP = i3;
    25225. 

  25225.   return;
    25226. 

  25226.  } else {
    25227. 

  25227.   i12 = i8;
    25228. 

  25228.   i11 = HEAP32[i2 >> 2] | 0;
    25229. 

  25229.   i10 = i12 + 1 | 0;
    25230. 

  25230.   HEAP32[i6 >> 2] = i10;
    25231. 

  25231.   i12 = i11 + (i12 << 1) | 0;
    25232. 

  25232.   HEAP16[i12 >> 1] = i7;
    25233. 

  25233.   STACKTOP = i3;
    25234. 

  25234.   return;
    25235. 

  25235.  }
    25236. 

  25236. }
    25237. 

  25237. function _luaC_fullgc(i1, i5) {
    25238. 

  25238.  i1 = i1 | 0;
    25239. 

  25239.  i5 = i5 | 0;
    25240. 

  25240.  var i2 = 0, i3 = 0, i4 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0;
    25241. 

  25241.  i2 = STACKTOP;
    25242. 

  25242.  i4 = i1 + 12 | 0;
    25243. 

  25243.  i3 = HEAP32[i4 >> 2] | 0;
    25244. 

  25244.  i6 = i3 + 62 | 0;
    25245. 

  25245.  i8 = HEAP8[i6] | 0;
    25246. 

  25246.  i5 = (i5 | 0) != 0;
    25247. 

  25247.  if (!i5) {
    25248. 

  25248.   HEAP8[i6] = 0;
    25249. 

  25249.   i9 = (HEAP32[i4 >> 2] | 0) + 104 | 0;
    25250. 

  25250.   i10 = HEAP32[i9 >> 2] | 0;
    25251. 

  25251.   if ((i10 | 0) != 0) {
    25252. 

  25252.    do {
    25253. 

  25253.     i11 = i10 + 5 | 0;
    25254. 

  25254.     HEAP8[i11] = HEAP8[i11] & 191;
    25255. 

  25255.     _GCTM(i1, 1);
    25256. 

  25256.     i10 = HEAP32[i9 >> 2] | 0;
    25257. 

  25257.    } while ((i10 | 0) != 0);
    25258. 

  25258.    if ((HEAP8[i6] | 0) == 2) {
    25259. 

  25259.     i9 = 7;
    25260. 

  25260.    } else {
    25261. 

  25261.     i9 = 6;
    25262. 

  25262.    }
    25263. 

  25263.   } else {
    25264. 

  25264.    i9 = 6;
    25265. 

  25265.   }
    25266. 

  25266.  } else {
    25267. 

  25267.   HEAP8[i6] = 1;
    25268. 

  25268.   i9 = 6;
    25269. 

  25269.  }
    25270. 

  25270.  if ((i9 | 0) == 6 ? (HEAPU8[i3 + 61 | 0] | 0) < 2 : 0) {
    25271. 

  25271.   i9 = 7;
    25272. 

  25272.  }
    25273. 

  25273.  if ((i9 | 0) == 7) {
    25274. 

  25274.   i9 = HEAP32[i4 >> 2] | 0;
    25275. 

  25275.   HEAP8[i9 + 61 | 0] = 2;
    25276. 

  25276.   HEAP32[i9 + 64 >> 2] = 0;
    25277. 

  25277.   i10 = i9 + 72 | 0;
    25278. 

  25278.   do {
    25279. 

  25279.    i11 = _sweeplist(i1, i10, 1) | 0;
    25280. 

  25280.   } while ((i11 | 0) == (i10 | 0));
    25281. 

  25281.   HEAP32[i9 + 80 >> 2] = i11;
    25282. 

  25282.   i11 = i9 + 68 | 0;
    25283. 

  25283.   do {
    25284. 

  25284.    i10 = _sweeplist(i1, i11, 1) | 0;
    25285. 

  25285.   } while ((i10 | 0) == (i11 | 0));
    25286. 

  25286.   HEAP32[i9 + 76 >> 2] = i10;
    25287. 

  25287.  }
    25288. 

  25288.  i11 = HEAP32[i4 >> 2] | 0;
    25289. 

  25289.  i9 = i11 + 61 | 0;
    25290. 

  25290.  if ((HEAP8[i9] | 0) == 5) {
    25291. 

  25291.   i9 = 5;
    25292. 

  25292.  } else {
    25293. 

  25293.   do {
    25294. 

  25294.    _singlestep(i1) | 0;
    25295. 

  25295.   } while ((HEAP8[i9] | 0) != 5);
    25296. 

  25296.   i9 = HEAP32[i4 >> 2] | 0;
    25297. 

  25297.   i11 = i9;
    25298. 

  25298.   i9 = HEAP8[i9 + 61 | 0] | 0;
    25299. 

  25299.  }
    25300. 

  25300.  i10 = i11 + 61 | 0;
    25301. 

  25301.  if ((1 << (i9 & 255) & -33 | 0) == 0) {
    25302. 

  25302.   do {
    25303. 

  25303.    _singlestep(i1) | 0;
    25304. 

  25304.   } while ((1 << HEAPU8[i10] & -33 | 0) == 0);
    25305. 

  25305.   i9 = HEAP32[i4 >> 2] | 0;
    25306. 

  25306.   i11 = i9;
    25307. 

  25307.   i9 = HEAP8[i9 + 61 | 0] | 0;
    25308. 

  25308.  }
    25309. 

  25309.  i10 = i11 + 61 | 0;
    25310. 

  25310.  if (!(i9 << 24 >> 24 == 5)) {
    25311. 

  25311.   do {
    25312. 

  25312.    _singlestep(i1) | 0;
    25313. 

  25313.   } while ((HEAP8[i10] | 0) != 5);
    25314. 

  25314.  }
    25315. 

  25315.  if (i8 << 24 >> 24 == 2 ? (i7 = (HEAP32[i4 >> 2] | 0) + 61 | 0, (HEAP8[i7] | 0) != 0) : 0) {
    25316. 

  25316.   do {
    25317. 

  25317.    _singlestep(i1) | 0;
    25318. 

  25318.   } while ((HEAP8[i7] | 0) != 0);
    25319. 

  25319.  }
    25320. 

  25320.  HEAP8[i6] = i8;
    25321. 

  25321.  i6 = HEAP32[i3 + 8 >> 2] | 0;
    25322. 

  25322.  i7 = HEAP32[i3 + 12 >> 2] | 0;
    25323. 

  25323.  i8 = (i7 + i6 | 0) / 100 | 0;
    25324. 

  25324.  i9 = HEAP32[i3 + 156 >> 2] | 0;
    25325. 

  25325.  if ((i9 | 0) < (2147483644 / (i8 | 0) | 0 | 0)) {
    25326. 

  25326.   i8 = Math_imul(i9, i8) | 0;
    25327. 

  25327.  } else {
    25328. 

  25328.   i8 = 2147483644;
    25329. 

  25329.  }
    25330. 

  25330.  _luaE_setdebt(i3, i6 - i8 + i7 | 0);
    25331. 

  25331.  if (i5) {
    25332. 

  25332.   STACKTOP = i2;
    25333. 

  25333.   return;
    25334. 

  25334.  }
    25335. 

  25335.  i3 = (HEAP32[i4 >> 2] | 0) + 104 | 0;
    25336. 

  25336.  i4 = HEAP32[i3 >> 2] | 0;
    25337. 

  25337.  if ((i4 | 0) == 0) {
    25338. 

  25338.   STACKTOP = i2;
    25339. 

  25339.   return;
    25340. 

  25340.  }
    25341. 

  25341.  do {
    25342. 

  25342.   i11 = i4 + 5 | 0;
    25343. 

  25343.   HEAP8[i11] = HEAP8[i11] & 191;
    25344. 

  25344.   _GCTM(i1, 1);
    25345. 

  25345.   i4 = HEAP32[i3 >> 2] | 0;
    25346. 

  25346.  } while ((i4 | 0) != 0);
    25347. 

  25347.  STACKTOP = i2;
    25348. 

  25348.  return;
    25349. 

  25349. }
    25350. 

  25350. function _scanexp(i3, i6) {
    25351. 

  25351.  i3 = i3 | 0;
    25352. 

  25352.  i6 = i6 | 0;
    25353. 

  25353.  var i1 = 0, i2 = 0, i4 = 0, i5 = 0, i7 = 0, i8 = 0;
    25354. 

  25354.  i1 = STACKTOP;
    25355. 

  25355.  i2 = i3 + 4 | 0;
    25356. 

  25356.  i5 = HEAP32[i2 >> 2] | 0;
    25357. 

  25357.  i4 = i3 + 100 | 0;
    25358. 

  25358.  if (i5 >>> 0 < (HEAP32[i4 >> 2] | 0) >>> 0) {
    25359. 

  25359.   HEAP32[i2 >> 2] = i5 + 1;
    25360. 

  25360.   i8 = HEAPU8[i5] | 0;
    25361. 

  25361.  } else {
    25362. 

  25362.   i8 = ___shgetc(i3) | 0;
    25363. 

  25363.  }
    25364. 

  25364.  if ((i8 | 0) == 43 | (i8 | 0) == 45) {
    25365. 

  25365.   i5 = (i8 | 0) == 45 | 0;
    25366. 

  25366.   i7 = HEAP32[i2 >> 2] | 0;
    25367. 

  25367.   if (i7 >>> 0 < (HEAP32[i4 >> 2] | 0) >>> 0) {
    25368. 

  25368.    HEAP32[i2 >> 2] = i7 + 1;
    25369. 

  25369.    i8 = HEAPU8[i7] | 0;
    25370. 

  25370.   } else {
    25371. 

  25371.    i8 = ___shgetc(i3) | 0;
    25372. 

  25372.   }
    25373. 

  25373.   if (!((i8 + -48 | 0) >>> 0 < 10 | (i6 | 0) == 0) ? (HEAP32[i4 >> 2] | 0) != 0 : 0) {
    25374. 

  25374.    HEAP32[i2 >> 2] = (HEAP32[i2 >> 2] | 0) + -1;
    25375. 

  25375.   }
    25376. 

  25376.  } else {
    25377. 

  25377.   i5 = 0;
    25378. 

  25378.  }
    25379. 

  25379.  if ((i8 + -48 | 0) >>> 0 > 9) {
    25380. 

  25380.   if ((HEAP32[i4 >> 2] | 0) == 0) {
    25381. 

  25381.    i7 = -2147483648;
    25382. 

  25382.    i8 = 0;
    25383. 

  25383.    tempRet0 = i7;
    25384. 

  25384.    STACKTOP = i1;
    25385. 

  25385.    return i8 | 0;
    25386. 

  25386.   }
    25387. 

  25387.   HEAP32[i2 >> 2] = (HEAP32[i2 >> 2] | 0) + -1;
    25388. 

  25388.   i7 = -2147483648;
    25389. 

  25389.   i8 = 0;
    25390. 

  25390.   tempRet0 = i7;
    25391. 

  25391.   STACKTOP = i1;
    25392. 

  25392.   return i8 | 0;
    25393. 

  25393.  } else {
    25394. 

  25394.   i6 = 0;
    25395. 

  25395.  }
    25396. 

  25396.  while (1) {
    25397. 

  25397.   i6 = i8 + -48 + i6 | 0;
    25398. 

  25398.   i7 = HEAP32[i2 >> 2] | 0;
    25399. 

  25399.   if (i7 >>> 0 < (HEAP32[i4 >> 2] | 0) >>> 0) {
    25400. 

  25400.    HEAP32[i2 >> 2] = i7 + 1;
    25401. 

  25401.    i8 = HEAPU8[i7] | 0;
    25402. 

  25402.   } else {
    25403. 

  25403.    i8 = ___shgetc(i3) | 0;
    25404. 

  25404.   }
    25405. 

  25405.   if (!((i8 + -48 | 0) >>> 0 < 10 & (i6 | 0) < 214748364)) {
    25406. 

  25406.    break;
    25407. 

  25407.   }
    25408. 

  25408.   i6 = i6 * 10 | 0;
    25409. 

  25409.  }
    25410. 

  25410.  i7 = ((i6 | 0) < 0) << 31 >> 31;
    25411. 

  25411.  if ((i8 + -48 | 0) >>> 0 < 10) {
    25412. 

  25412.   do {
    25413. 

  25413.    i7 = ___muldi3(i6 | 0, i7 | 0, 10, 0) | 0;
    25414. 

  25414.    i6 = tempRet0;
    25415. 

  25415.    i8 = _i64Add(i8 | 0, ((i8 | 0) < 0) << 31 >> 31 | 0, -48, -1) | 0;
    25416. 

  25416.    i6 = _i64Add(i8 | 0, tempRet0 | 0, i7 | 0, i6 | 0) | 0;
    25417. 

  25417.    i7 = tempRet0;
    25418. 

  25418.    i8 = HEAP32[i2 >> 2] | 0;
    25419. 

  25419.    if (i8 >>> 0 < (HEAP32[i4 >> 2] | 0) >>> 0) {
    25420. 

  25420.     HEAP32[i2 >> 2] = i8 + 1;
    25421. 

  25421.     i8 = HEAPU8[i8] | 0;
    25422. 

  25422.    } else {
    25423. 

  25423.     i8 = ___shgetc(i3) | 0;
    25424. 

  25424.    }
    25425. 

  25425.   } while ((i8 + -48 | 0) >>> 0 < 10 & ((i7 | 0) < 21474836 | (i7 | 0) == 21474836 & i6 >>> 0 < 2061584302));
    25426. 

  25426.  }
    25427. 

  25427.  if ((i8 + -48 | 0) >>> 0 < 10) {
    25428. 

  25428.   do {
    25429. 

  25429.    i8 = HEAP32[i2 >> 2] | 0;
    25430. 

  25430.    if (i8 >>> 0 < (HEAP32[i4 >> 2] | 0) >>> 0) {
    25431. 

  25431.     HEAP32[i2 >> 2] = i8 + 1;
    25432. 

  25432.     i8 = HEAPU8[i8] | 0;
    25433. 

  25433.    } else {
    25434. 

  25434.     i8 = ___shgetc(i3) | 0;
    25435. 

  25435.    }
    25436. 

  25436.   } while ((i8 + -48 | 0) >>> 0 < 10);
    25437. 

  25437.  }
    25438. 

  25438.  if ((HEAP32[i4 >> 2] | 0) != 0) {
    25439. 

  25439.   HEAP32[i2 >> 2] = (HEAP32[i2 >> 2] | 0) + -1;
    25440. 

  25440.  }
    25441. 

  25441.  i3 = (i5 | 0) != 0;
    25442. 

  25442.  i2 = _i64Subtract(0, 0, i6 | 0, i7 | 0) | 0;
    25443. 

  25443.  i4 = i3 ? tempRet0 : i7;
    25444. 

  25444.  i8 = i3 ? i2 : i6;
    25445. 

  25445.  tempRet0 = i4;
    25446. 

  25446.  STACKTOP = i1;
    25447. 

  25447.  return i8 | 0;
    25448. 

  25448. }
    25449. 

  25449. function _sweeplist(i3, i8, i9) {
    25450. 

  25450.  i3 = i3 | 0;
    25451. 

  25451.  i8 = i8 | 0;
    25452. 

  25452.  i9 = i9 | 0;
    25453. 

  25453.  var i1 = 0, i2 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i10 = 0, i11 = 0, i12 = 0;
    25454. 

  25454.  i1 = STACKTOP;
    25455. 

  25455.  i5 = i3 + 12 | 0;
    25456. 

  25456.  i7 = HEAP32[i5 >> 2] | 0;
    25457. 

  25457.  i6 = HEAPU8[i7 + 60 | 0] | 0;
    25458. 

  25458.  i2 = i6 ^ 3;
    25459. 

  25459.  i7 = (HEAP8[i7 + 62 | 0] | 0) == 2;
    25460. 

  25460.  i4 = i7 ? 255 : 184;
    25461. 

  25461.  i6 = i7 ? 64 : i6 & 3;
    25462. 

  25462.  i7 = i7 ? 64 : 0;
    25463. 

  25463.  i10 = HEAP32[i8 >> 2] | 0;
    25464. 

  25464.  L1 : do {
    25465. 

  25465.   if ((i10 | 0) == 0) {
    25466. 

  25466.    i10 = 0;
    25467. 

  25467.   } else {
    25468. 

  25468.    i11 = i9;
    25469. 

  25469.    L2 : while (1) {
    25470. 

  25470.     i9 = i11 + -1 | 0;
    25471. 

  25471.     if ((i11 | 0) == 0) {
    25472. 

  25472.      break L1;
    25473. 

  25473.     }
    25474. 

  25474.     i11 = i10 + 5 | 0;
    25475. 

  25475.     i12 = HEAPU8[i11] | 0;
    25476. 

  25476.     L5 : do {
    25477. 

  25477.      if (((i12 ^ 3) & i2 | 0) == 0) {
    25478. 

  25478.       HEAP32[i8 >> 2] = HEAP32[i10 >> 2];
    25479. 

  25479.       switch (HEAPU8[i10 + 4 | 0] | 0) {
    25480. 

  25480.       case 4:
    25481. 

  25481.        {
    25482. 

  25482.         i12 = (HEAP32[i5 >> 2] | 0) + 28 | 0;
    25483. 

  25483.         HEAP32[i12 >> 2] = (HEAP32[i12 >> 2] | 0) + -1;
    25484. 

  25484.         break;
    25485. 

  25485.        }
    25486. 

  25486.       case 38:
    25487. 

  25487.        {
    25488. 

  25488.         _luaM_realloc_(i3, i10, (HEAPU8[i10 + 6 | 0] << 4) + 16 | 0, 0) | 0;
    25489. 

  25489.         break L5;
    25490. 

  25490.        }
    25491. 

  25491.       case 6:
    25492. 

  25492.        {
    25493. 

  25493.         _luaM_realloc_(i3, i10, (HEAPU8[i10 + 6 | 0] << 2) + 16 | 0, 0) | 0;
    25494. 

  25494.         break L5;
    25495. 

  25495.        }
    25496. 

  25496.       case 20:
    25497. 

  25497.        {
    25498. 

  25498.         break;
    25499. 

  25499.        }
    25500. 

  25500.       case 5:
    25501. 

  25501.        {
    25502. 

  25502.         _luaH_free(i3, i10);
    25503. 

  25503.         break L5;
    25504. 

  25504.        }
    25505. 

  25505.       case 10:
    25506. 

  25506.        {
    25507. 

  25507.         _luaF_freeupval(i3, i10);
    25508. 

  25508.         break L5;
    25509. 

  25509.        }
    25510. 

  25510.       case 8:
    25511. 

  25511.        {
    25512. 

  25512.         _luaE_freethread(i3, i10);
    25513. 

  25513.         break L5;
    25514. 

  25514.        }
    25515. 

  25515.       case 9:
    25516. 

  25516.        {
    25517. 

  25517.         _luaF_freeproto(i3, i10);
    25518. 

  25518.         break L5;
    25519. 

  25519.        }
    25520. 

  25520.       case 7:
    25521. 

  25521.        {
    25522. 

  25522.         _luaM_realloc_(i3, i10, (HEAP32[i10 + 16 >> 2] | 0) + 24 | 0, 0) | 0;
    25523. 

  25523.         break L5;
    25524. 

  25524.        }
    25525. 

  25525.       default:
    25526. 

  25526.        {
    25527. 

  25527.         break L5;
    25528. 

  25528.        }
    25529. 

  25529.       }
    25530. 

  25530.       _luaM_realloc_(i3, i10, (HEAP32[i10 + 12 >> 2] | 0) + 17 | 0, 0) | 0;
    25531. 

  25531.      } else {
    25532. 

  25532.       if ((i12 & i7 | 0) != 0) {
    25533. 

  25533.        i2 = 0;
    25534. 

  25534.        break L2;
    25535. 

  25535.       }
    25536. 

  25536.       if (((HEAP8[i10 + 4 | 0] | 0) == 8 ? (HEAP32[i10 + 28 >> 2] | 0) != 0 : 0) ? (_sweeplist(i3, i10 + 56 | 0, -3) | 0, _luaE_freeCI(i10), (HEAP8[(HEAP32[i5 >> 2] | 0) + 62 | 0] | 0) != 1) : 0) {
    25537. 

  25537.        _luaD_shrinkstack(i10);
    25538. 

  25538.       }
    25539. 

  25539.       HEAP8[i11] = i12 & i4 | i6;
    25540. 

  25540.       i8 = i10;
    25541. 

  25541.      }
    25542. 

  25542.     } while (0);
    25543. 

  25543.     i10 = HEAP32[i8 >> 2] | 0;
    25544. 

  25544.     if ((i10 | 0) == 0) {
    25545. 

  25545.      i10 = 0;
    25546. 

  25546.      break L1;
    25547. 

  25547.     } else {
    25548. 

  25548.      i11 = i9;
    25549. 

  25549.     }
    25550. 

  25550.    }
    25551. 

  25551.    STACKTOP = i1;
    25552. 

  25552.    return i2 | 0;
    25553. 

  25553.   }
    25554. 

  25554.  } while (0);
    25555. 

  25555.  i12 = (i10 | 0) == 0 ? 0 : i8;
    25556. 

  25556.  STACKTOP = i1;
    25557. 

  25557.  return i12 | 0;
    25558. 

  25558. }
    25559. 

  25559. function _resume(i1, i6) {
    25560. 

  25560.  i1 = i1 | 0;
    25561. 

  25561.  i6 = i6 | 0;
    25562. 

  25562.  var i2 = 0, i3 = 0, i4 = 0, i5 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0;
    25563. 

  25563.  i2 = STACKTOP;
    25564. 

  25564.  i3 = i1 + 16 | 0;
    25565. 

  25565.  i5 = HEAP32[i3 >> 2] | 0;
    25566. 

  25566.  if ((HEAPU16[i1 + 38 >> 1] | 0) > 199) {
    25567. 

  25567.   _resume_error(i1, 2240, i6);
    25568. 

  25568.  }
    25569. 

  25569.  i4 = i1 + 6 | 0;
    25570. 

  25570.  i7 = HEAP8[i4] | 0;
    25571. 

  25571.  if (i7 << 24 >> 24 == 0) {
    25572. 

  25572.   if ((i5 | 0) != (i1 + 72 | 0)) {
    25573. 

  25573.    _resume_error(i1, 2448, i6);
    25574. 

  25574.   }
    25575. 

  25575.   if ((_luaD_precall(i1, i6 + -16 | 0, -1) | 0) != 0) {
    25576. 

  25576.    STACKTOP = i2;
    25577. 

  25577.    return;
    25578. 

  25578.   }
    25579. 

  25579.   _luaV_execute(i1);
    25580. 

  25580.   STACKTOP = i2;
    25581. 

  25581.   return;
    25582. 

  25582.  } else if (i7 << 24 >> 24 == 1) {
    25583. 

  25583.   HEAP8[i4] = 0;
    25584. 

  25584.   i4 = i1 + 28 | 0;
    25585. 

  25585.   HEAP32[i5 >> 2] = (HEAP32[i4 >> 2] | 0) + (HEAP32[i5 + 20 >> 2] | 0);
    25586. 

  25586.   i8 = i5 + 18 | 0;
    25587. 

  25587.   i7 = HEAP8[i8] | 0;
    25588. 

  25588.   if ((i7 & 1) == 0) {
    25589. 

  25589.    i9 = HEAP32[i5 + 28 >> 2] | 0;
    25590. 

  25590.    if ((i9 | 0) != 0) {
    25591. 

  25591.     HEAP8[i5 + 37 | 0] = 1;
    25592. 

  25592.     HEAP8[i8] = i7 & 255 | 8;
    25593. 

  25593.     i6 = FUNCTION_TABLE_ii[i9 & 255](i1) | 0;
    25594. 

  25594.     i6 = (HEAP32[i1 + 8 >> 2] | 0) + (0 - i6 << 4) | 0;
    25595. 

  25595.    }
    25596. 

  25596.    i5 = HEAP32[i3 >> 2] | 0;
    25597. 

  25597.    i7 = HEAPU8[i1 + 40 | 0] | 0;
    25598. 

  25598.    if ((i7 & 6 | 0) == 0) {
    25599. 

  25599.     i7 = i5 + 8 | 0;
    25600. 

  25600.    } else {
    25601. 

  25601.     if ((i7 & 2 | 0) != 0) {
    25602. 

  25602.      i6 = i6 - (HEAP32[i4 >> 2] | 0) | 0;
    25603. 

  25603.      _luaD_hook(i1, 1, -1);
    25604. 

  25604.      i6 = (HEAP32[i4 >> 2] | 0) + i6 | 0;
    25605. 

  25605.     }
    25606. 

  25606.     i7 = i5 + 8 | 0;
    25607. 

  25607.     HEAP32[i1 + 20 >> 2] = HEAP32[(HEAP32[i7 >> 2] | 0) + 28 >> 2];
    25608. 

  25608.    }
    25609. 

  25609.    i4 = HEAP32[i5 >> 2] | 0;
    25610. 

  25610.    i5 = HEAP16[i5 + 16 >> 1] | 0;
    25611. 

  25611.    HEAP32[i3 >> 2] = HEAP32[i7 >> 2];
    25612. 

  25612.    i3 = i1 + 8 | 0;
    25613. 

  25613.    L27 : do {
    25614. 

  25614.     if (!(i5 << 16 >> 16 == 0)) {
    25615. 

  25615.      i5 = i5 << 16 >> 16;
    25616. 

  25616.      while (1) {
    25617. 

  25617.       if (!(i6 >>> 0 < (HEAP32[i3 >> 2] | 0) >>> 0)) {
    25618. 

  25618.        break;
    25619. 

  25619.       }
    25620. 

  25620.       i7 = i4 + 16 | 0;
    25621. 

  25621.       i10 = i6;
    25622. 

  25622.       i8 = HEAP32[i10 + 4 >> 2] | 0;
    25623. 

  25623.       i9 = i4;
    25624. 

  25624.       HEAP32[i9 >> 2] = HEAP32[i10 >> 2];
    25625. 

  25625.       HEAP32[i9 + 4 >> 2] = i8;
    25626. 

  25626.       HEAP32[i4 + 8 >> 2] = HEAP32[i6 + 8 >> 2];
    25627. 

  25627.       i5 = i5 + -1 | 0;
    25628. 

  25628.       if ((i5 | 0) == 0) {
    25629. 

  25629.        i4 = i7;
    25630. 

  25630.        break L27;
    25631. 

  25631.       }
    25632. 

  25632.       i6 = i6 + 16 | 0;
    25633. 

  25633.       i4 = i7;
    25634. 

  25634.      }
    25635. 

  25635.      if ((i5 | 0) > 0) {
    25636. 

  25636.       i7 = i5;
    25637. 

  25637.       i6 = i4;
    25638. 

  25638.       while (1) {
    25639. 

  25639.        i7 = i7 + -1 | 0;
    25640. 

  25640.        HEAP32[i6 + 8 >> 2] = 0;
    25641. 

  25641.        if ((i7 | 0) <= 0) {
    25642. 

  25642.         break;
    25643. 

  25643.        } else {
    25644. 

  25644.         i6 = i6 + 16 | 0;
    25645. 

  25645.        }
    25646. 

  25646.       }
    25647. 

  25647.       i4 = i4 + (i5 << 4) | 0;
    25648. 

  25648.      }
    25649. 

  25649.     }
    25650. 

  25650.    } while (0);
    25651. 

  25651.    HEAP32[i3 >> 2] = i4;
    25652. 

  25652.   } else {
    25653. 

  25653.    _luaV_execute(i1);
    25654. 

  25654.   }
    25655. 

  25655.   _unroll(i1, 0);
    25656. 

  25656.   STACKTOP = i2;
    25657. 

  25657.   return;
    25658. 

  25658.  } else {
    25659. 

  25659.   _resume_error(i1, 2488, i6);
    25660. 

  25660.  }
    25661. 

  25661. }
    25662. 

  25662. function _lua_setupvalue(i1, i5, i3) {
    25663. 

  25663.  i1 = i1 | 0;
    25664. 

  25664.  i5 = i5 | 0;
    25665. 

  25665.  i3 = i3 | 0;
    25666. 

  25666.  var i2 = 0, i4 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0;
    25667. 

  25667.  i2 = STACKTOP;
    25668. 

  25668.  i6 = HEAP32[i1 + 16 >> 2] | 0;
    25669. 

  25669.  do {
    25670. 

  25670.   if ((i5 | 0) <= 0) {
    25671. 

  25671.    if (!((i5 | 0) < -1000999)) {
    25672. 

  25672.     i5 = (HEAP32[i1 + 8 >> 2] | 0) + (i5 << 4) | 0;
    25673. 

  25673.     break;
    25674. 

  25674.    }
    25675. 

  25675.    if ((i5 | 0) == -1001e3) {
    25676. 

  25676.     i5 = (HEAP32[i1 + 12 >> 2] | 0) + 40 | 0;
    25677. 

  25677.     break;
    25678. 

  25678.    }
    25679. 

  25679.    i5 = -1001e3 - i5 | 0;
    25680. 

  25680.    i6 = HEAP32[i6 >> 2] | 0;
    25681. 

  25681.    if ((HEAP32[i6 + 8 >> 2] | 0) != 22 ? (i4 = HEAP32[i6 >> 2] | 0, (i5 | 0) <= (HEAPU8[i4 + 6 | 0] | 0 | 0)) : 0) {
    25682. 

  25682.     i5 = i4 + (i5 + -1 << 4) + 16 | 0;
    25683. 

  25683.    } else {
    25684. 

  25684.     i5 = 5192;
    25685. 

  25685.    }
    25686. 

  25686.   } else {
    25687. 

  25687.    i4 = (HEAP32[i6 >> 2] | 0) + (i5 << 4) | 0;
    25688. 

  25688.    i5 = i4 >>> 0 < (HEAP32[i1 + 8 >> 2] | 0) >>> 0 ? i4 : 5192;
    25689. 

  25689.   }
    25690. 

  25690.  } while (0);
    25691. 

  25691.  i4 = HEAP32[i5 + 8 >> 2] & 63;
    25692. 

  25692.  do {
    25693. 

  25693.   if ((i4 | 0) == 6) {
    25694. 

  25694.    i5 = HEAP32[i5 >> 2] | 0;
    25695. 

  25695.    i4 = HEAP32[i5 + 12 >> 2] | 0;
    25696. 

  25696.    if ((i3 | 0) <= 0) {
    25697. 

  25697.     i6 = 0;
    25698. 

  25698.     STACKTOP = i2;
    25699. 

  25699.     return i6 | 0;
    25700. 

  25700.    }
    25701. 

  25701.    if ((HEAP32[i4 + 40 >> 2] | 0) < (i3 | 0)) {
    25702. 

  25702.     i6 = 0;
    25703. 

  25703.     STACKTOP = i2;
    25704. 

  25704.     return i6 | 0;
    25705. 

  25705.    }
    25706. 

  25706.    i6 = i3 + -1 | 0;
    25707. 

  25707.    i3 = HEAP32[i5 + 16 + (i6 << 2) >> 2] | 0;
    25708. 

  25708.    i5 = HEAP32[i3 + 8 >> 2] | 0;
    25709. 

  25709.    i4 = HEAP32[(HEAP32[i4 + 28 >> 2] | 0) + (i6 << 3) >> 2] | 0;
    25710. 

  25710.    if ((i4 | 0) == 0) {
    25711. 

  25711.     i4 = 936;
    25712. 

  25712.    } else {
    25713. 

  25713.     i4 = i4 + 16 | 0;
    25714. 

  25714.    }
    25715. 

  25715.   } else if ((i4 | 0) == 38) {
    25716. 

  25716.    i6 = HEAP32[i5 >> 2] | 0;
    25717. 

  25717.    if ((i3 | 0) <= 0) {
    25718. 

  25718.     i6 = 0;
    25719. 

  25719.     STACKTOP = i2;
    25720. 

  25720.     return i6 | 0;
    25721. 

  25721.    }
    25722. 

  25722.    if ((HEAPU8[i6 + 6 | 0] | 0 | 0) >= (i3 | 0)) {
    25723. 

  25723.     i4 = 936;
    25724. 

  25724.     i5 = i6 + (i3 + -1 << 4) + 16 | 0;
    25725. 

  25725.     i3 = i6;
    25726. 

  25726.     break;
    25727. 

  25727.    } else {
    25728. 

  25728.     i6 = 0;
    25729. 

  25729.     STACKTOP = i2;
    25730. 

  25730.     return i6 | 0;
    25731. 

  25731.    }
    25732. 

  25732.   } else {
    25733. 

  25733.    i6 = 0;
    25734. 

  25734.    STACKTOP = i2;
    25735. 

  25735.    return i6 | 0;
    25736. 

  25736.   }
    25737. 

  25737.  } while (0);
    25738. 

  25738.  i6 = i1 + 8 | 0;
    25739. 

  25739.  i7 = HEAP32[i6 >> 2] | 0;
    25740. 

  25740.  i10 = i7 + -16 | 0;
    25741. 

  25741.  HEAP32[i6 >> 2] = i10;
    25742. 

  25742.  i9 = HEAP32[i10 + 4 >> 2] | 0;
    25743. 

  25743.  i8 = i5;
    25744. 

  25744.  HEAP32[i8 >> 2] = HEAP32[i10 >> 2];
    25745. 

  25745.  HEAP32[i8 + 4 >> 2] = i9;
    25746. 

  25746.  HEAP32[i5 + 8 >> 2] = HEAP32[i7 + -8 >> 2];
    25747. 

  25747.  i5 = HEAP32[i6 >> 2] | 0;
    25748. 

  25748.  if ((HEAP32[i5 + 8 >> 2] & 64 | 0) == 0) {
    25749. 

  25749.   i10 = i4;
    25750. 

  25750.   STACKTOP = i2;
    25751. 

  25751.   return i10 | 0;
    25752. 

  25752.  }
    25753. 

  25753.  i5 = HEAP32[i5 >> 2] | 0;
    25754. 

  25754.  if ((HEAP8[i5 + 5 | 0] & 3) == 0) {
    25755. 

  25755.   i10 = i4;
    25756. 

  25756.   STACKTOP = i2;
    25757. 

  25757.   return i10 | 0;
    25758. 

  25758.  }
    25759. 

  25759.  if ((HEAP8[i3 + 5 | 0] & 4) == 0) {
    25760. 

  25760.   i10 = i4;
    25761. 

  25761.   STACKTOP = i2;
    25762. 

  25762.   return i10 | 0;
    25763. 

  25763.  }
    25764. 

  25764.  _luaC_barrier_(i1, i3, i5);
    25765. 

  25765.  i10 = i4;
    25766. 

  25766.  STACKTOP = i2;
    25767. 

  25767.  return i10 | 0;
    25768. 

  25768. }
    25769. 

  25769. function _luaC_forcestep(i2) {
    25770. 

  25770.  i2 = i2 | 0;
    25771. 

  25771.  var i1 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0;
    25772. 

  25772.  i1 = STACKTOP;
    25773. 

  25773.  i3 = HEAP32[i2 + 12 >> 2] | 0;
    25774. 

  25774.  do {
    25775. 

  25775.   if ((HEAP8[i3 + 62 | 0] | 0) == 2) {
    25776. 

  25776.    i4 = i3 + 20 | 0;
    25777. 

  25777.    i6 = HEAP32[i4 >> 2] | 0;
    25778. 

  25778.    do {
    25779. 

  25779.     if ((i6 | 0) != 0) {
    25780. 

  25780.      i5 = i3 + 61 | 0;
    25781. 

  25781.      if ((HEAP8[i5] | 0) != 5) {
    25782. 

  25782.       do {
    25783. 

  25783.        _singlestep(i2) | 0;
    25784. 

  25784.       } while ((HEAP8[i5] | 0) != 5);
    25785. 

  25785.      }
    25786. 

  25786.      HEAP8[i5] = 0;
    25787. 

  25787.      i5 = HEAP32[i3 + 8 >> 2] | 0;
    25788. 

  25788.      i7 = HEAP32[i3 + 12 >> 2] | 0;
    25789. 

  25789.      if ((i7 + i5 | 0) >>> 0 > (Math_imul(HEAP32[i3 + 160 >> 2] | 0, (i6 >>> 0) / 100 | 0) | 0) >>> 0) {
    25790. 

  25790.       HEAP32[i4 >> 2] = 0;
    25791. 

  25791.       break;
    25792. 

  25792.      } else {
    25793. 

  25793.       HEAP32[i4 >> 2] = i6;
    25794. 

  25794.       break;
    25795. 

  25795.      }
    25796. 

  25796.     } else {
    25797. 

  25797.      _luaC_fullgc(i2, 0);
    25798. 

  25798.      i5 = HEAP32[i3 + 8 >> 2] | 0;
    25799. 

  25799.      i7 = HEAP32[i3 + 12 >> 2] | 0;
    25800. 

  25800.      HEAP32[i4 >> 2] = i7 + i5;
    25801. 

  25801.     }
    25802. 

  25802.    } while (0);
    25803. 

  25803.    i4 = i5 + i7 | 0;
    25804. 

  25804.    i5 = (i4 | 0) / 100 | 0;
    25805. 

  25805.    i6 = HEAP32[i3 + 156 >> 2] | 0;
    25806. 

  25806.    if ((i6 | 0) < (2147483644 / (i5 | 0) | 0 | 0)) {
    25807. 

  25807.     i5 = Math_imul(i6, i5) | 0;
    25808. 

  25808.    } else {
    25809. 

  25809.     i5 = 2147483644;
    25810. 

  25810.    }
    25811. 

  25811.    _luaE_setdebt(i3, i4 - i5 | 0);
    25812. 

  25812.    i5 = i3 + 61 | 0;
    25813. 

  25813.   } else {
    25814. 

  25814.    i4 = i3 + 12 | 0;
    25815. 

  25815.    i5 = HEAP32[i3 + 164 >> 2] | 0;
    25816. 

  25816.    i7 = (i5 | 0) < 40 ? 40 : i5;
    25817. 

  25817.    i5 = ((HEAP32[i4 >> 2] | 0) / 200 | 0) + 1 | 0;
    25818. 

  25818.    if ((i5 | 0) < (2147483644 / (i7 | 0) | 0 | 0)) {
    25819. 

  25819.     i8 = Math_imul(i5, i7) | 0;
    25820. 

  25820.    } else {
    25821. 

  25821.     i8 = 2147483644;
    25822. 

  25822.    }
    25823. 

  25823.    i5 = i3 + 61 | 0;
    25824. 

  25824.    do {
    25825. 

  25825.     i8 = i8 - (_singlestep(i2) | 0) | 0;
    25826. 

  25826.     i9 = (HEAP8[i5] | 0) == 5;
    25827. 

  25827.     if (!((i8 | 0) > -1600)) {
    25828. 

  25828.      i6 = 17;
    25829. 

  25829.      break;
    25830. 

  25830.     }
    25831. 

  25831.    } while (!i9);
    25832. 

  25832.    if ((i6 | 0) == 17 ? !i9 : 0) {
    25833. 

  25833.     _luaE_setdebt(i3, ((i8 | 0) / (i7 | 0) | 0) * 200 | 0);
    25834. 

  25834.     break;
    25835. 

  25835.    }
    25836. 

  25836.    i6 = (HEAP32[i3 + 20 >> 2] | 0) / 100 | 0;
    25837. 

  25837.    i7 = HEAP32[i3 + 156 >> 2] | 0;
    25838. 

  25838.    if ((i7 | 0) < (2147483644 / (i6 | 0) | 0 | 0)) {
    25839. 

  25839.     i6 = Math_imul(i7, i6) | 0;
    25840. 

  25840.    } else {
    25841. 

  25841.     i6 = 2147483644;
    25842. 

  25842.    }
    25843. 

  25843.    _luaE_setdebt(i3, (HEAP32[i3 + 8 >> 2] | 0) - i6 + (HEAP32[i4 >> 2] | 0) | 0);
    25844. 

  25844.   }
    25845. 

  25845.  } while (0);
    25846. 

  25846.  i3 = i3 + 104 | 0;
    25847. 

  25847.  if ((HEAP32[i3 >> 2] | 0) == 0) {
    25848. 

  25848.   STACKTOP = i1;
    25849. 

  25849.   return;
    25850. 

  25850.  } else {
    25851. 

  25851.   i4 = 0;
    25852. 

  25852.  }
    25853. 

  25853.  while (1) {
    25854. 

  25854.   if ((i4 | 0) >= 4 ? (HEAP8[i5] | 0) != 5 : 0) {
    25855. 

  25855.    i6 = 26;
    25856. 

  25856.    break;
    25857. 

  25857.   }
    25858. 

  25858.   _GCTM(i2, 1);
    25859. 

  25859.   if ((HEAP32[i3 >> 2] | 0) == 0) {
    25860. 

  25860.    i6 = 26;
    25861. 

  25861.    break;
    25862. 

  25862.   } else {
    25863. 

  25863.    i4 = i4 + 1 | 0;
    25864. 

  25864.   }
    25865. 

  25865.  }
    25866. 

  25866.  if ((i6 | 0) == 26) {
    25867. 

  25867.   STACKTOP = i1;
    25868. 

  25868.   return;
    25869. 

  25869.  }
    25870. 

  25870. }
    25871. 

  25871. function _luaL_loadfilex(i1, i9, i7) {
    25872. 

  25872.  i1 = i1 | 0;
    25873. 

  25873.  i9 = i9 | 0;
    25874. 

  25874.  i7 = i7 | 0;
    25875. 

  25875.  var i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i8 = 0, i10 = 0, i11 = 0;
    25876. 

  25876.  i5 = STACKTOP;
    25877. 

  25877.  STACKTOP = STACKTOP + 1056 | 0;
    25878. 

  25878.  i3 = i5;
    25879. 

  25879.  i6 = i5 + 16 | 0;
    25880. 

  25880.  i8 = i5 + 12 | 0;
    25881. 

  25881.  i2 = (_lua_gettop(i1) | 0) + 1 | 0;
    25882. 

  25882.  i4 = (i9 | 0) == 0;
    25883. 

  25883.  if (!i4) {
    25884. 

  25884.   HEAP32[i3 >> 2] = i9;
    25885. 

  25885.   _lua_pushfstring(i1, 1304, i3) | 0;
    25886. 

  25886.   i10 = _fopen(i9 | 0, 1312) | 0;
    25887. 

  25887.   HEAP32[i6 + 4 >> 2] = i10;
    25888. 

  25888.   if ((i10 | 0) == 0) {
    25889. 

  25889.    i10 = _strerror(HEAP32[(___errno_location() | 0) >> 2] | 0) | 0;
    25890. 

  25890.    i9 = (_lua_tolstring(i1, i2, 0) | 0) + 1 | 0;
    25891. 

  25891.    HEAP32[i3 >> 2] = 1320;
    25892. 

  25892.    HEAP32[i3 + 4 >> 2] = i9;
    25893. 

  25893.    HEAP32[i3 + 8 >> 2] = i10;
    25894. 

  25894.    _lua_pushfstring(i1, 1720, i3) | 0;
    25895. 

  25895.    _lua_remove(i1, i2);
    25896. 

  25896.    i10 = 7;
    25897. 

  25897.    STACKTOP = i5;
    25898. 

  25898.    return i10 | 0;
    25899. 

  25899.   }
    25900. 

  25900.  } else {
    25901. 

  25901.   _lua_pushlstring(i1, 1296, 6) | 0;
    25902. 

  25902.   HEAP32[i6 + 4 >> 2] = HEAP32[_stdin >> 2];
    25903. 

  25903.  }
    25904. 

  25904.  if ((_skipcomment(i6, i8) | 0) != 0) {
    25905. 

  25905.   i10 = HEAP32[i6 >> 2] | 0;
    25906. 

  25906.   HEAP32[i6 >> 2] = i10 + 1;
    25907. 

  25907.   HEAP8[i6 + i10 + 8 | 0] = 10;
    25908. 

  25908.  }
    25909. 

  25909.  i10 = HEAP32[i8 >> 2] | 0;
    25910. 

  25910.  do {
    25911. 

  25911.   if (!((i10 | 0) != 27 | i4)) {
    25912. 

  25912.    i11 = i6 + 4 | 0;
    25913. 

  25913.    i10 = _freopen(i9 | 0, 1328, HEAP32[i11 >> 2] | 0) | 0;
    25914. 

  25914.    HEAP32[i11 >> 2] = i10;
    25915. 

  25915.    if ((i10 | 0) != 0) {
    25916. 

  25916.     _skipcomment(i6, i8) | 0;
    25917. 

  25917.     i10 = HEAP32[i8 >> 2] | 0;
    25918. 

  25918.     break;
    25919. 

  25919.    }
    25920. 

  25920.    i11 = _strerror(HEAP32[(___errno_location() | 0) >> 2] | 0) | 0;
    25921. 

  25921.    i10 = (_lua_tolstring(i1, i2, 0) | 0) + 1 | 0;
    25922. 

  25922.    HEAP32[i3 >> 2] = 1336;
    25923. 

  25923.    HEAP32[i3 + 4 >> 2] = i10;
    25924. 

  25924.    HEAP32[i3 + 8 >> 2] = i11;
    25925. 

  25925.    _lua_pushfstring(i1, 1720, i3) | 0;
    25926. 

  25926.    _lua_remove(i1, i2);
    25927. 

  25927.    i11 = 7;
    25928. 

  25928.    STACKTOP = i5;
    25929. 

  25929.    return i11 | 0;
    25930. 

  25930.   }
    25931. 

  25931.  } while (0);
    25932. 

  25932.  if (!((i10 | 0) == -1)) {
    25933. 

  25933.   i11 = HEAP32[i6 >> 2] | 0;
    25934. 

  25934.   HEAP32[i6 >> 2] = i11 + 1;
    25935. 

  25935.   HEAP8[i6 + i11 + 8 | 0] = i10;
    25936. 

  25936.  }
    25937. 

  25937.  i7 = _lua_load(i1, 1, i6, _lua_tolstring(i1, -1, 0) | 0, i7) | 0;
    25938. 

  25938.  i8 = HEAP32[i6 + 4 >> 2] | 0;
    25939. 

  25939.  i6 = _ferror(i8 | 0) | 0;
    25940. 

  25940.  if (!i4) {
    25941. 

  25941.   _fclose(i8 | 0) | 0;
    25942. 

  25942.  }
    25943. 

  25943.  if ((i6 | 0) == 0) {
    25944. 

  25944.   _lua_remove(i1, i2);
    25945. 

  25945.   i11 = i7;
    25946. 

  25946.   STACKTOP = i5;
    25947. 

  25947.   return i11 | 0;
    25948. 

  25948.  } else {
    25949. 

  25949.   _lua_settop(i1, i2);
    25950. 

  25950.   i11 = _strerror(HEAP32[(___errno_location() | 0) >> 2] | 0) | 0;
    25951. 

  25951.   i10 = (_lua_tolstring(i1, i2, 0) | 0) + 1 | 0;
    25952. 

  25952.   HEAP32[i3 >> 2] = 1344;
    25953. 

  25953.   HEAP32[i3 + 4 >> 2] = i10;
    25954. 

  25954.   HEAP32[i3 + 8 >> 2] = i11;
    25955. 

  25955.   _lua_pushfstring(i1, 1720, i3) | 0;
    25956. 

  25956.   _lua_remove(i1, i2);
    25957. 

  25957.   i11 = 7;
    25958. 

  25958.   STACKTOP = i5;
    25959. 

  25959.   return i11 | 0;
    25960. 

  25960.  }
    25961. 

  25961.  return 0;
    25962. 

  25962. }
    25963. 

  25963. function _newupvalue(i3, i1, i2) {
    25964. 

  25964.  i3 = i3 | 0;
    25965. 

  25965.  i1 = i1 | 0;
    25966. 

  25966.  i2 = i2 | 0;
    25967. 

  25967.  var i4 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0, i14 = 0, i15 = 0;
    25968. 

  25968.  i4 = STACKTOP;
    25969. 

  25969.  STACKTOP = STACKTOP + 16 | 0;
    25970. 

  25970.  i12 = i4;
    25971. 

  25971.  i5 = HEAP32[i3 >> 2] | 0;
    25972. 

  25972.  i9 = i5 + 40 | 0;
    25973. 

  25973.  i7 = HEAP32[i9 >> 2] | 0;
    25974. 

  25974.  i6 = i3 + 47 | 0;
    25975. 

  25975.  i10 = HEAPU8[i6] | 0;
    25976. 

  25976.  if ((i10 + 1 | 0) >>> 0 > 255) {
    25977. 

  25977.   i11 = i3 + 12 | 0;
    25978. 

  25978.   i8 = HEAP32[(HEAP32[i11 >> 2] | 0) + 52 >> 2] | 0;
    25979. 

  25979.   i13 = HEAP32[i5 + 64 >> 2] | 0;
    25980. 

  25980.   if ((i13 | 0) == 0) {
    25981. 

  25981.    i15 = 6552;
    25982. 

  25982.    HEAP32[i12 >> 2] = 6880;
    25983. 

  25983.    i14 = i12 + 4 | 0;
    25984. 

  25984.    HEAP32[i14 >> 2] = 255;
    25985. 

  25985.    i14 = i12 + 8 | 0;
    25986. 

  25986.    HEAP32[i14 >> 2] = i15;
    25987. 

  25987.    i14 = _luaO_pushfstring(i8, 6592, i12) | 0;
    25988. 

  25988.    i15 = HEAP32[i11 >> 2] | 0;
    25989. 

  25989.    _luaX_syntaxerror(i15, i14);
    25990. 

  25990.   }
    25991. 

  25991.   HEAP32[i12 >> 2] = i13;
    25992. 

  25992.   i14 = _luaO_pushfstring(i8, 6568, i12) | 0;
    25993. 

  25993.   HEAP32[i12 >> 2] = 6880;
    25994. 

  25994.   i15 = i12 + 4 | 0;
    25995. 

  25995.   HEAP32[i15 >> 2] = 255;
    25996. 

  25996.   i15 = i12 + 8 | 0;
    25997. 

  25997.   HEAP32[i15 >> 2] = i14;
    25998. 

  25998.   i15 = _luaO_pushfstring(i8, 6592, i12) | 0;
    25999. 

  25999.   i14 = HEAP32[i11 >> 2] | 0;
    26000. 

  26000.   _luaX_syntaxerror(i14, i15);
    26001. 

  26001.  }
    26002. 

  26002.  if ((i10 | 0) < (i7 | 0)) {
    26003. 

  26003.   i8 = i7;
    26004. 

  26004.  } else {
    26005. 

  26005.   i8 = i5 + 28 | 0;
    26006. 

  26006.   HEAP32[i8 >> 2] = _luaM_growaux_(HEAP32[(HEAP32[i3 + 12 >> 2] | 0) + 52 >> 2] | 0, HEAP32[i8 >> 2] | 0, i9, 8, 255, 6880) | 0;
    26007. 

  26007.   i8 = HEAP32[i9 >> 2] | 0;
    26008. 

  26008.  }
    26009. 

  26009.  i9 = i5 + 28 | 0;
    26010. 

  26010.  if ((i7 | 0) < (i8 | 0)) {
    26011. 

  26011.   while (1) {
    26012. 

  26012.    i10 = i7 + 1 | 0;
    26013. 

  26013.    HEAP32[(HEAP32[i9 >> 2] | 0) + (i7 << 3) >> 2] = 0;
    26014. 

  26014.    if ((i10 | 0) < (i8 | 0)) {
    26015. 

  26015.     i7 = i10;
    26016. 

  26016.    } else {
    26017. 

  26017.     break;
    26018. 

  26018.    }
    26019. 

  26019.   }
    26020. 

  26020.  }
    26021. 

  26021.  HEAP8[(HEAP32[i9 >> 2] | 0) + ((HEAPU8[i6] | 0) << 3) + 4 | 0] = (HEAP32[i2 >> 2] | 0) == 7 | 0;
    26022. 

  26022.  HEAP8[(HEAP32[i9 >> 2] | 0) + ((HEAPU8[i6] | 0) << 3) + 5 | 0] = HEAP32[i2 + 8 >> 2];
    26023. 

  26023.  HEAP32[(HEAP32[i9 >> 2] | 0) + ((HEAPU8[i6] | 0) << 3) >> 2] = i1;
    26024. 

  26024.  if ((HEAP8[i1 + 5 | 0] & 3) == 0) {
    26025. 

  26025.   i15 = HEAP8[i6] | 0;
    26026. 

  26026.   i14 = i15 + 1 << 24 >> 24;
    26027. 

  26027.   HEAP8[i6] = i14;
    26028. 

  26028.   i15 = i15 & 255;
    26029. 

  26029.   STACKTOP = i4;
    26030. 

  26030.   return i15 | 0;
    26031. 

  26031.  }
    26032. 

  26032.  if ((HEAP8[i5 + 5 | 0] & 4) == 0) {
    26033. 

  26033.   i15 = HEAP8[i6] | 0;
    26034. 

  26034.   i14 = i15 + 1 << 24 >> 24;
    26035. 

  26035.   HEAP8[i6] = i14;
    26036. 

  26036.   i15 = i15 & 255;
    26037. 

  26037.   STACKTOP = i4;
    26038. 

  26038.   return i15 | 0;
    26039. 

  26039.  }
    26040. 

  26040.  _luaC_barrier_(HEAP32[(HEAP32[i3 + 12 >> 2] | 0) + 52 >> 2] | 0, i5, i1);
    26041. 

  26041.  i15 = HEAP8[i6] | 0;
    26042. 

  26042.  i14 = i15 + 1 << 24 >> 24;
    26043. 

  26043.  HEAP8[i6] = i14;
    26044. 

  26044.  i15 = i15 & 255;
    26045. 

  26045.  STACKTOP = i4;
    26046. 

  26046.  return i15 | 0;
    26047. 

  26047. }
    26048. 

  26048. function _close_func(i1) {
    26049. 

  26049.  i1 = i1 | 0;
    26050. 

  26050.  var i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0;
    26051. 

  26051.  i6 = STACKTOP;
    26052. 

  26052.  i2 = HEAP32[i1 + 52 >> 2] | 0;
    26053. 

  26053.  i5 = i1 + 48 | 0;
    26054. 

  26054.  i4 = HEAP32[i5 >> 2] | 0;
    26055. 

  26055.  i3 = HEAP32[i4 >> 2] | 0;
    26056. 

  26056.  _luaK_ret(i4, 0, 0);
    26057. 

  26057.  _leaveblock(i4);
    26058. 

  26058.  i7 = i4 + 20 | 0;
    26059. 

  26059.  i8 = HEAP32[i7 >> 2] | 0;
    26060. 

  26060.  if ((i8 + 1 | 0) >>> 0 > 1073741823) {
    26061. 

  26061.   _luaM_toobig(i2);
    26062. 

  26062.  }
    26063. 

  26063.  i10 = i3 + 12 | 0;
    26064. 

  26064.  i9 = i3 + 48 | 0;
    26065. 

  26065.  HEAP32[i10 >> 2] = _luaM_realloc_(i2, HEAP32[i10 >> 2] | 0, HEAP32[i9 >> 2] << 2, i8 << 2) | 0;
    26066. 

  26066.  HEAP32[i9 >> 2] = HEAP32[i7 >> 2];
    26067. 

  26067.  i8 = HEAP32[i7 >> 2] | 0;
    26068. 

  26068.  if ((i8 + 1 | 0) >>> 0 > 1073741823) {
    26069. 

  26069.   _luaM_toobig(i2);
    26070. 

  26070.  }
    26071. 

  26071.  i9 = i3 + 20 | 0;
    26072. 

  26072.  i10 = i3 + 52 | 0;
    26073. 

  26073.  HEAP32[i9 >> 2] = _luaM_realloc_(i2, HEAP32[i9 >> 2] | 0, HEAP32[i10 >> 2] << 2, i8 << 2) | 0;
    26074. 

  26074.  HEAP32[i10 >> 2] = HEAP32[i7 >> 2];
    26075. 

  26075.  i8 = i4 + 32 | 0;
    26076. 

  26076.  i7 = HEAP32[i8 >> 2] | 0;
    26077. 

  26077.  if ((i7 + 1 | 0) >>> 0 > 268435455) {
    26078. 

  26078.   _luaM_toobig(i2);
    26079. 

  26079.  }
    26080. 

  26080.  i9 = i3 + 8 | 0;
    26081. 

  26081.  i10 = i3 + 44 | 0;
    26082. 

  26082.  HEAP32[i9 >> 2] = _luaM_realloc_(i2, HEAP32[i9 >> 2] | 0, HEAP32[i10 >> 2] << 4, i7 << 4) | 0;
    26083. 

  26083.  HEAP32[i10 >> 2] = HEAP32[i8 >> 2];
    26084. 

  26084.  i8 = i4 + 36 | 0;
    26085. 

  26085.  i7 = HEAP32[i8 >> 2] | 0;
    26086. 

  26086.  if ((i7 + 1 | 0) >>> 0 > 1073741823) {
    26087. 

  26087.   _luaM_toobig(i2);
    26088. 

  26088.  }
    26089. 

  26089.  i9 = i3 + 16 | 0;
    26090. 

  26090.  i10 = i3 + 56 | 0;
    26091. 

  26091.  HEAP32[i9 >> 2] = _luaM_realloc_(i2, HEAP32[i9 >> 2] | 0, HEAP32[i10 >> 2] << 2, i7 << 2) | 0;
    26092. 

  26092.  HEAP32[i10 >> 2] = HEAP32[i8 >> 2];
    26093. 

  26093.  i7 = i4 + 44 | 0;
    26094. 

  26094.  i8 = HEAP16[i7 >> 1] | 0;
    26095. 

  26095.  if ((i8 + 1 | 0) >>> 0 > 357913941) {
    26096. 

  26096.   _luaM_toobig(i2);
    26097. 

  26097.  }
    26098. 

  26098.  i10 = i3 + 24 | 0;
    26099. 

  26099.  i9 = i3 + 60 | 0;
    26100. 

  26100.  HEAP32[i10 >> 2] = _luaM_realloc_(i2, HEAP32[i10 >> 2] | 0, (HEAP32[i9 >> 2] | 0) * 12 | 0, i8 * 12 | 0) | 0;
    26101. 

  26101.  HEAP32[i9 >> 2] = HEAP16[i7 >> 1] | 0;
    26102. 

  26102.  i9 = i4 + 47 | 0;
    26103. 

  26103.  i8 = i3 + 28 | 0;
    26104. 

  26104.  i10 = i3 + 40 | 0;
    26105. 

  26105.  HEAP32[i8 >> 2] = _luaM_realloc_(i2, HEAP32[i8 >> 2] | 0, HEAP32[i10 >> 2] << 3, HEAPU8[i9] << 3) | 0;
    26106. 

  26106.  HEAP32[i10 >> 2] = HEAPU8[i9] | 0;
    26107. 

  26107.  HEAP32[i5 >> 2] = HEAP32[i4 + 8 >> 2];
    26108. 

  26108.  if (((HEAP32[i1 + 16 >> 2] | 0) + -288 | 0) >>> 0 < 2) {
    26109. 

  26109.   i10 = HEAP32[i1 + 24 >> 2] | 0;
    26110. 

  26110.   _luaX_newstring(i1, i10 + 16 | 0, HEAP32[i10 + 12 >> 2] | 0) | 0;
    26111. 

  26111.  }
    26112. 

  26112.  i10 = i2 + 8 | 0;
    26113. 

  26113.  HEAP32[i10 >> 2] = (HEAP32[i10 >> 2] | 0) + -16;
    26114. 

  26114.  if ((HEAP32[(HEAP32[i2 + 12 >> 2] | 0) + 12 >> 2] | 0) <= 0) {
    26115. 

  26115.   STACKTOP = i6;
    26116. 

  26116.   return;
    26117. 

  26117.  }
    26118. 

  26118.  _luaC_step(i2);
    26119. 

  26119.  STACKTOP = i6;
    26120. 

  26120.  return;
    26121. 

  26121. }
    26122. 

  26122. function _lua_topointer(i3, i6) {
    26123. 

  26123.  i3 = i3 | 0;
    26124. 

  26124.  i6 = i6 | 0;
    26125. 

  26125.  var i1 = 0, i2 = 0, i4 = 0, i5 = 0, i7 = 0, i8 = 0, i9 = 0;
    26126. 

  26126.  i1 = STACKTOP;
    26127. 

  26127.  i4 = HEAP32[i3 + 16 >> 2] | 0;
    26128. 

  26128.  i5 = (i6 | 0) > 0;
    26129. 

  26129.  do {
    26130. 

  26130.   if (!i5) {
    26131. 

  26131.    if (!((i6 | 0) < -1000999)) {
    26132. 

  26132.     i7 = (HEAP32[i3 + 8 >> 2] | 0) + (i6 << 4) | 0;
    26133. 

  26133.     break;
    26134. 

  26134.    }
    26135. 

  26135.    if ((i6 | 0) == -1001e3) {
    26136. 

  26136.     i7 = (HEAP32[i3 + 12 >> 2] | 0) + 40 | 0;
    26137. 

  26137.     break;
    26138. 

  26138.    }
    26139. 

  26139.    i8 = -1001e3 - i6 | 0;
    26140. 

  26140.    i9 = HEAP32[i4 >> 2] | 0;
    26141. 

  26141.    if ((HEAP32[i9 + 8 >> 2] | 0) != 22 ? (i7 = HEAP32[i9 >> 2] | 0, (i8 | 0) <= (HEAPU8[i7 + 6 | 0] | 0 | 0)) : 0) {
    26142. 

  26142.     i7 = i7 + (i8 + -1 << 4) + 16 | 0;
    26143. 

  26143.    } else {
    26144. 

  26144.     i7 = 5192;
    26145. 

  26145.    }
    26146. 

  26146.   } else {
    26147. 

  26147.    i7 = (HEAP32[i4 >> 2] | 0) + (i6 << 4) | 0;
    26148. 

  26148.    i7 = i7 >>> 0 < (HEAP32[i3 + 8 >> 2] | 0) >>> 0 ? i7 : 5192;
    26149. 

  26149.   }
    26150. 

  26150.  } while (0);
    26151. 

  26151.  switch (HEAP32[i7 + 8 >> 2] & 63 | 0) {
    26152. 

  26152.  case 22:
    26153. 

  26153.   {
    26154. 

  26154.    i9 = HEAP32[i7 >> 2] | 0;
    26155. 

  26155.    STACKTOP = i1;
    26156. 

  26156.    return i9 | 0;
    26157. 

  26157.   }
    26158. 

  26158.  case 2:
    26159. 

  26159.  case 7:
    26160. 

  26160.   {
    26161. 

  26161.    do {
    26162. 

  26162.     if (!i5) {
    26163. 

  26163.      if (!((i6 | 0) < -1000999)) {
    26164. 

  26164.       i2 = (HEAP32[i3 + 8 >> 2] | 0) + (i6 << 4) | 0;
    26165. 

  26165.       break;
    26166. 

  26166.      }
    26167. 

  26167.      if ((i6 | 0) == -1001e3) {
    26168. 

  26168.       i2 = (HEAP32[i3 + 12 >> 2] | 0) + 40 | 0;
    26169. 

  26169.       break;
    26170. 

  26170.      }
    26171. 

  26171.      i3 = -1001e3 - i6 | 0;
    26172. 

  26172.      i4 = HEAP32[i4 >> 2] | 0;
    26173. 

  26173.      if ((HEAP32[i4 + 8 >> 2] | 0) != 22 ? (i2 = HEAP32[i4 >> 2] | 0, (i3 | 0) <= (HEAPU8[i2 + 6 | 0] | 0 | 0)) : 0) {
    26174. 

  26174.       i2 = i2 + (i3 + -1 << 4) + 16 | 0;
    26175. 

  26175.      } else {
    26176. 

  26176.       i2 = 5192;
    26177. 

  26177.      }
    26178. 

  26178.     } else {
    26179. 

  26179.      i2 = (HEAP32[i4 >> 2] | 0) + (i6 << 4) | 0;
    26180. 

  26180.      i2 = i2 >>> 0 < (HEAP32[i3 + 8 >> 2] | 0) >>> 0 ? i2 : 5192;
    26181. 

  26181.     }
    26182. 

  26182.    } while (0);
    26183. 

  26183.    i3 = HEAP32[i2 + 8 >> 2] & 15;
    26184. 

  26184.    if ((i3 | 0) == 7) {
    26185. 

  26185.     i9 = (HEAP32[i2 >> 2] | 0) + 24 | 0;
    26186. 

  26186.     STACKTOP = i1;
    26187. 

  26187.     return i9 | 0;
    26188. 

  26188.    } else if ((i3 | 0) == 2) {
    26189. 

  26189.     i9 = HEAP32[i2 >> 2] | 0;
    26190. 

  26190.     STACKTOP = i1;
    26191. 

  26191.     return i9 | 0;
    26192. 

  26192.    } else {
    26193. 

  26193.     i9 = 0;
    26194. 

  26194.     STACKTOP = i1;
    26195. 

  26195.     return i9 | 0;
    26196. 

  26196.    }
    26197. 

  26197.   }
    26198. 

  26198.  case 8:
    26199. 

  26199.   {
    26200. 

  26200.    i9 = HEAP32[i7 >> 2] | 0;
    26201. 

  26201.    STACKTOP = i1;
    26202. 

  26202.    return i9 | 0;
    26203. 

  26203.   }
    26204. 

  26204.  case 5:
    26205. 

  26205.   {
    26206. 

  26206.    i9 = HEAP32[i7 >> 2] | 0;
    26207. 

  26207.    STACKTOP = i1;
    26208. 

  26208.    return i9 | 0;
    26209. 

  26209.   }
    26210. 

  26210.  case 38:
    26211. 

  26211.   {
    26212. 

  26212.    i9 = HEAP32[i7 >> 2] | 0;
    26213. 

  26213.    STACKTOP = i1;
    26214. 

  26214.    return i9 | 0;
    26215. 

  26215.   }
    26216. 

  26216.  case 6:
    26217. 

  26217.   {
    26218. 

  26218.    i9 = HEAP32[i7 >> 2] | 0;
    26219. 

  26219.    STACKTOP = i1;
    26220. 

  26220.    return i9 | 0;
    26221. 

  26221.   }
    26222. 

  26222.  default:
    26223. 

  26223.   {
    26224. 

  26224.    i9 = 0;
    26225. 

  26225.    STACKTOP = i1;
    26226. 

  26226.    return i9 | 0;
    26227. 

  26227.   }
    26228. 

  26228.  }
    26229. 

  26229.  return 0;
    26230. 

  26230. }
    26231. 

  26231. function _luaH_get(i4, i6) {
    26232. 

  26232.  i4 = i4 | 0;
    26233. 

  26233.  i6 = i6 | 0;
    26234. 

  26234.  var i1 = 0, i2 = 0, i3 = 0, d5 = 0.0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, d11 = 0.0;
    26235. 

  26235.  i3 = STACKTOP;
    26236. 

  26236.  STACKTOP = STACKTOP + 16 | 0;
    26237. 

  26237.  i8 = i3 + 8 | 0;
    26238. 

  26238.  i9 = i3;
    26239. 

  26239.  i7 = i6 + 8 | 0;
    26240. 

  26240.  i10 = HEAP32[i7 >> 2] & 63;
    26241. 

  26241.  if ((i10 | 0) == 4) {
    26242. 

  26242.   i6 = HEAP32[i6 >> 2] | 0;
    26243. 

  26243.   i7 = (HEAP32[i4 + 16 >> 2] | 0) + (((1 << (HEAPU8[i4 + 7 | 0] | 0)) + -1 & HEAP32[i6 + 8 >> 2]) << 5) | 0;
    26244. 

  26244.   while (1) {
    26245. 

  26245.    if ((HEAP32[i7 + 24 >> 2] | 0) == 68 ? (HEAP32[i7 + 16 >> 2] | 0) == (i6 | 0) : 0) {
    26246. 

  26246.     break;
    26247. 

  26247.    }
    26248. 

  26248.    i4 = HEAP32[i7 + 28 >> 2] | 0;
    26249. 

  26249.    if ((i4 | 0) == 0) {
    26250. 

  26250.     i2 = 5192;
    26251. 

  26251.     i1 = 22;
    26252. 

  26252.     break;
    26253. 

  26253.    } else {
    26254. 

  26254.     i7 = i4;
    26255. 

  26255.    }
    26256. 

  26256.   }
    26257. 

  26257.   if ((i1 | 0) == 22) {
    26258. 

  26258.    STACKTOP = i3;
    26259. 

  26259.    return i2 | 0;
    26260. 

  26260.   }
    26261. 

  26261.   i10 = i7;
    26262. 

  26262.   STACKTOP = i3;
    26263. 

  26263.   return i10 | 0;
    26264. 

  26264.  } else if ((i10 | 0) == 3) {
    26265. 

  26265.   d11 = +HEAPF64[i6 >> 3];
    26266. 

  26266.   HEAPF64[i9 >> 3] = d11 + 6755399441055744.0;
    26267. 

  26267.   i9 = HEAP32[i9 >> 2] | 0;
    26268. 

  26268.   d5 = +(i9 | 0);
    26269. 

  26269.   if (d5 == d11) {
    26270. 

  26270.    i6 = i9 + -1 | 0;
    26271. 

  26271.    if (i6 >>> 0 < (HEAP32[i4 + 28 >> 2] | 0) >>> 0) {
    26272. 

  26272.     i10 = (HEAP32[i4 + 12 >> 2] | 0) + (i6 << 4) | 0;
    26273. 

  26273.     STACKTOP = i3;
    26274. 

  26274.     return i10 | 0;
    26275. 

  26275.    }
    26276. 

  26276.    HEAPF64[i8 >> 3] = d5 + 1.0;
    26277. 

  26277.    i6 = (HEAP32[i8 + 4 >> 2] | 0) + (HEAP32[i8 >> 2] | 0) | 0;
    26278. 

  26278.    if ((i6 | 0) < 0) {
    26279. 

  26279.     i7 = 0 - i6 | 0;
    26280. 

  26280.     i6 = (i6 | 0) == (i7 | 0) ? 0 : i7;
    26281. 

  26281.    }
    26282. 

  26282.    i4 = (HEAP32[i4 + 16 >> 2] | 0) + (((i6 | 0) % ((1 << (HEAPU8[i4 + 7 | 0] | 0)) + -1 | 1 | 0) | 0) << 5) | 0;
    26283. 

  26283.    while (1) {
    26284. 

  26284.     if ((HEAP32[i4 + 24 >> 2] | 0) == 3 ? +HEAPF64[i4 + 16 >> 3] == d5 : 0) {
    26285. 

  26285.      break;
    26286. 

  26286.     }
    26287. 

  26287.     i6 = HEAP32[i4 + 28 >> 2] | 0;
    26288. 

  26288.     if ((i6 | 0) == 0) {
    26289. 

  26289.      i2 = 5192;
    26290. 

  26290.      i1 = 22;
    26291. 

  26291.      break;
    26292. 

  26292.     } else {
    26293. 

  26293.      i4 = i6;
    26294. 

  26294.     }
    26295. 

  26295.    }
    26296. 

  26296.    if ((i1 | 0) == 22) {
    26297. 

  26297.     STACKTOP = i3;
    26298. 

  26298.     return i2 | 0;
    26299. 

  26299.    }
    26300. 

  26300.    i10 = i4;
    26301. 

  26301.    STACKTOP = i3;
    26302. 

  26302.    return i10 | 0;
    26303. 

  26303.   }
    26304. 

  26304.  } else if ((i10 | 0) == 0) {
    26305. 

  26305.   i10 = 5192;
    26306. 

  26306.   STACKTOP = i3;
    26307. 

  26307.   return i10 | 0;
    26308. 

  26308.  }
    26309. 

  26309.  i8 = _mainposition(i4, i6) | 0;
    26310. 

  26310.  while (1) {
    26311. 

  26311.   if ((HEAP32[i8 + 24 >> 2] | 0) == (HEAP32[i7 >> 2] | 0) ? (_luaV_equalobj_(0, i8 + 16 | 0, i6) | 0) != 0 : 0) {
    26312. 

  26312.    break;
    26313. 

  26313.   }
    26314. 

  26314.   i4 = HEAP32[i8 + 28 >> 2] | 0;
    26315. 

  26315.   if ((i4 | 0) == 0) {
    26316. 

  26316.    i2 = 5192;
    26317. 

  26317.    i1 = 22;
    26318. 

  26318.    break;
    26319. 

  26319.   } else {
    26320. 

  26320.    i8 = i4;
    26321. 

  26321.   }
    26322. 

  26322.  }
    26323. 

  26323.  if ((i1 | 0) == 22) {
    26324. 

  26324.   STACKTOP = i3;
    26325. 

  26325.   return i2 | 0;
    26326. 

  26326.  }
    26327. 

  26327.  i10 = i8;
    26328. 

  26328.  STACKTOP = i3;
    26329. 

  26329.  return i10 | 0;
    26330. 

  26330. }
    26331. 

  26331. function _suffixedexp(i1, i8) {
    26332. 

  26332.  i1 = i1 | 0;
    26333. 

  26333.  i8 = i8 | 0;
    26334. 

  26334.  var i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0, i14 = 0;
    26335. 

  26335.  i2 = STACKTOP;
    26336. 

  26336.  STACKTOP = STACKTOP + 80 | 0;
    26337. 

  26337.  i10 = i2 + 48 | 0;
    26338. 

  26338.  i3 = i2 + 24 | 0;
    26339. 

  26339.  i6 = i2;
    26340. 

  26340.  i4 = i1 + 48 | 0;
    26341. 

  26341.  i9 = HEAP32[i4 >> 2] | 0;
    26342. 

  26342.  i5 = HEAP32[i1 + 4 >> 2] | 0;
    26343. 

  26343.  i7 = i1 + 16 | 0;
    26344. 

  26344.  i12 = HEAP32[i7 >> 2] | 0;
    26345. 

  26345.  if ((i12 | 0) == 40) {
    26346. 

  26346.   _luaX_next(i1);
    26347. 

  26347.   _subexpr(i1, i8, 0) | 0;
    26348. 

  26348.   _check_match(i1, 41, 40, i5);
    26349. 

  26349.   _luaK_dischargevars(HEAP32[i4 >> 2] | 0, i8);
    26350. 

  26350.   i11 = i1 + 24 | 0;
    26351. 

  26351.  } else if ((i12 | 0) == 288) {
    26352. 

  26352.   i11 = i1 + 24 | 0;
    26353. 

  26353.   i13 = HEAP32[i11 >> 2] | 0;
    26354. 

  26354.   _luaX_next(i1);
    26355. 

  26355.   i12 = HEAP32[i4 >> 2] | 0;
    26356. 

  26356.   if ((_singlevaraux(i12, i13, i8, 1) | 0) == 0) {
    26357. 

  26357.    _singlevaraux(i12, HEAP32[i1 + 72 >> 2] | 0, i8, 1) | 0;
    26358. 

  26358.    i13 = _luaK_stringK(HEAP32[i4 >> 2] | 0, i13) | 0;
    26359. 

  26359.    HEAP32[i10 + 16 >> 2] = -1;
    26360. 

  26360.    HEAP32[i10 + 20 >> 2] = -1;
    26361. 

  26361.    HEAP32[i10 >> 2] = 4;
    26362. 

  26362.    HEAP32[i10 + 8 >> 2] = i13;
    26363. 

  26363.    _luaK_indexed(i12, i8, i10);
    26364. 

  26364.   }
    26365. 

  26365.  } else {
    26366. 

  26366.   _luaX_syntaxerror(i1, 6656);
    26367. 

  26367.  }
    26368. 

  26368.  i10 = i6 + 16 | 0;
    26369. 

  26369.  i12 = i6 + 20 | 0;
    26370. 

  26370.  i13 = i6 + 8 | 0;
    26371. 

  26371.  L7 : while (1) {
    26372. 

  26372.   switch (HEAP32[i7 >> 2] | 0) {
    26373. 

  26373.   case 46:
    26374. 

  26374.    {
    26375. 

  26375.     _fieldsel(i1, i8);
    26376. 

  26376.     continue L7;
    26377. 

  26377.    }
    26378. 

  26378.   case 91:
    26379. 

  26379.    {
    26380. 

  26380.     _luaK_exp2anyregup(i9, i8);
    26381. 

  26381.     _luaX_next(i1);
    26382. 

  26382.     _subexpr(i1, i3, 0) | 0;
    26383. 

  26383.     _luaK_exp2val(HEAP32[i4 >> 2] | 0, i3);
    26384. 

  26384.     if ((HEAP32[i7 >> 2] | 0) != 93) {
    26385. 

  26385.      i3 = 10;
    26386. 

  26386.      break L7;
    26387. 

  26387.     }
    26388. 

  26388.     _luaX_next(i1);
    26389. 

  26389.     _luaK_indexed(i9, i8, i3);
    26390. 

  26390.     continue L7;
    26391. 

  26391.    }
    26392. 

  26392.   case 58:
    26393. 

  26393.    {
    26394. 

  26394.     _luaX_next(i1);
    26395. 

  26395.     if ((HEAP32[i7 >> 2] | 0) != 288) {
    26396. 

  26396.      i3 = 13;
    26397. 

  26397.      break L7;
    26398. 

  26398.     }
    26399. 

  26399.     i14 = HEAP32[i11 >> 2] | 0;
    26400. 

  26400.     _luaX_next(i1);
    26401. 

  26401.     i14 = _luaK_stringK(HEAP32[i4 >> 2] | 0, i14) | 0;
    26402. 

  26402.     HEAP32[i10 >> 2] = -1;
    26403. 

  26403.     HEAP32[i12 >> 2] = -1;
    26404. 

  26404.     HEAP32[i6 >> 2] = 4;
    26405. 

  26405.     HEAP32[i13 >> 2] = i14;
    26406. 

  26406.     _luaK_self(i9, i8, i6);
    26407. 

  26407.     _funcargs(i1, i8, i5);
    26408. 

  26408.     continue L7;
    26409. 

  26409.    }
    26410. 

  26410.   case 123:
    26411. 

  26411.   case 289:
    26412. 

  26412.   case 40:
    26413. 

  26413.    {
    26414. 

  26414.     _luaK_exp2nextreg(i9, i8);
    26415. 

  26415.     _funcargs(i1, i8, i5);
    26416. 

  26416.     continue L7;
    26417. 

  26417.    }
    26418. 

  26418.   default:
    26419. 

  26419.    {
    26420. 

  26420.     i3 = 16;
    26421. 

  26421.     break L7;
    26422. 

  26422.    }
    26423. 

  26423.   }
    26424. 

  26424.  }
    26425. 

  26425.  if ((i3 | 0) == 10) {
    26426. 

  26426.   _error_expected(i1, 93);
    26427. 

  26427.  } else if ((i3 | 0) == 13) {
    26428. 

  26428.   _error_expected(i1, 288);
    26429. 

  26429.  } else if ((i3 | 0) == 16) {
    26430. 

  26430.   STACKTOP = i2;
    26431. 

  26431.   return;
    26432. 

  26432.  }
    26433. 

  26433. }
    26434. 

  26434. function _luaK_patchlist(i2, i7, i3) {
    26435. 

  26435.  i2 = i2 | 0;
    26436. 

  26436.  i7 = i7 | 0;
    26437. 

  26437.  i3 = i3 | 0;
    26438. 

  26438.  var i1 = 0, i4 = 0, i5 = 0, i6 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0;
    26439. 

  26439.  i1 = STACKTOP;
    26440. 

  26440.  if ((HEAP32[i2 + 20 >> 2] | 0) == (i3 | 0)) {
    26441. 

  26441.   HEAP32[i2 + 24 >> 2] = i3;
    26442. 

  26442.   i3 = i2 + 28 | 0;
    26443. 

  26443.   if ((i7 | 0) == -1) {
    26444. 

  26444.    STACKTOP = i1;
    26445. 

  26445.    return;
    26446. 

  26446.   }
    26447. 

  26447.   i6 = HEAP32[i3 >> 2] | 0;
    26448. 

  26448.   if ((i6 | 0) == -1) {
    26449. 

  26449.    HEAP32[i3 >> 2] = i7;
    26450. 

  26450.    STACKTOP = i1;
    26451. 

  26451.    return;
    26452. 

  26452.   }
    26453. 

  26453.   i5 = HEAP32[(HEAP32[i2 >> 2] | 0) + 12 >> 2] | 0;
    26454. 

  26454.   while (1) {
    26455. 

  26455.    i3 = i5 + (i6 << 2) | 0;
    26456. 

  26456.    i4 = HEAP32[i3 >> 2] | 0;
    26457. 

  26457.    i8 = (i4 >>> 14) + -131071 | 0;
    26458. 

  26458.    if ((i8 | 0) == -1) {
    26459. 

  26459.     break;
    26460. 

  26460.    }
    26461. 

  26461.    i8 = i6 + 1 + i8 | 0;
    26462. 

  26462.    if ((i8 | 0) == -1) {
    26463. 

  26463.     break;
    26464. 

  26464.    } else {
    26465. 

  26465.     i6 = i8;
    26466. 

  26466.    }
    26467. 

  26467.   }
    26468. 

  26468.   i5 = ~i6 + i7 | 0;
    26469. 

  26469.   if ((((i5 | 0) > -1 ? i5 : 0 - i5 | 0) | 0) > 131071) {
    26470. 

  26470.    _luaX_syntaxerror(HEAP32[i2 + 12 >> 2] | 0, 10624);
    26471. 

  26471.   }
    26472. 

  26472.   HEAP32[i3 >> 2] = (i5 << 14) + 2147467264 | i4 & 16383;
    26473. 

  26473.   STACKTOP = i1;
    26474. 

  26474.   return;
    26475. 

  26475.  }
    26476. 

  26476.  if ((i7 | 0) == -1) {
    26477. 

  26477.   STACKTOP = i1;
    26478. 

  26478.   return;
    26479. 

  26479.  }
    26480. 

  26480.  i6 = HEAP32[(HEAP32[i2 >> 2] | 0) + 12 >> 2] | 0;
    26481. 

  26481.  i10 = i7;
    26482. 

  26482.  while (1) {
    26483. 

  26483.   i7 = i6 + (i10 << 2) | 0;
    26484. 

  26484.   i9 = HEAP32[i7 >> 2] | 0;
    26485. 

  26485.   i8 = (i9 >>> 14) + -131071 | 0;
    26486. 

  26486.   if ((i8 | 0) == -1) {
    26487. 

  26487.    i8 = -1;
    26488. 

  26488.   } else {
    26489. 

  26489.    i8 = i10 + 1 + i8 | 0;
    26490. 

  26490.   }
    26491. 

  26491.   if ((i10 | 0) > 0 ? (i4 = i6 + (i10 + -1 << 2) | 0, i5 = HEAP32[i4 >> 2] | 0, (HEAP8[5584 + (i5 & 63) | 0] | 0) < 0) : 0) {
    26492. 

  26492.    i12 = i4;
    26493. 

  26493.    i11 = i5;
    26494. 

  26494.   } else {
    26495. 

  26495.    i12 = i7;
    26496. 

  26496.    i11 = i9;
    26497. 

  26497.   }
    26498. 

  26498.   if ((i11 & 63 | 0) == 28) {
    26499. 

  26499.    HEAP32[i12 >> 2] = i11 & 8372224 | i11 >>> 23 << 6 | 27;
    26500. 

  26500.    i9 = ~i10 + i3 | 0;
    26501. 

  26501.    if ((((i9 | 0) > -1 ? i9 : 0 - i9 | 0) | 0) > 131071) {
    26502. 

  26502.     i3 = 20;
    26503. 

  26503.     break;
    26504. 

  26504.    }
    26505. 

  26505.    i9 = HEAP32[i7 >> 2] & 16383 | (i9 << 14) + 2147467264;
    26506. 

  26506.   } else {
    26507. 

  26507.    i10 = ~i10 + i3 | 0;
    26508. 

  26508.    if ((((i10 | 0) > -1 ? i10 : 0 - i10 | 0) | 0) > 131071) {
    26509. 

  26509.     i3 = 23;
    26510. 

  26510.     break;
    26511. 

  26511.    }
    26512. 

  26512.    i9 = i9 & 16383 | (i10 << 14) + 2147467264;
    26513. 

  26513.   }
    26514. 

  26514.   HEAP32[i7 >> 2] = i9;
    26515. 

  26515.   if ((i8 | 0) == -1) {
    26516. 

  26516.    i3 = 26;
    26517. 

  26517.    break;
    26518. 

  26518.   } else {
    26519. 

  26519.    i10 = i8;
    26520. 

  26520.   }
    26521. 

  26521.  }
    26522. 

  26522.  if ((i3 | 0) == 20) {
    26523. 

  26523.   _luaX_syntaxerror(HEAP32[i2 + 12 >> 2] | 0, 10624);
    26524. 

  26524.  } else if ((i3 | 0) == 23) {
    26525. 

  26525.   _luaX_syntaxerror(HEAP32[i2 + 12 >> 2] | 0, 10624);
    26526. 

  26526.  } else if ((i3 | 0) == 26) {
    26527. 

  26527.   STACKTOP = i1;
    26528. 

  26528.   return;
    26529. 

  26529.  }
    26530. 

  26530. }
    26531. 

  26531. function _luaG_typeerror(i5, i6, i1) {
    26532. 

  26532.  i5 = i5 | 0;
    26533. 

  26533.  i6 = i6 | 0;
    26534. 

  26534.  i1 = i1 | 0;
    26535. 

  26535.  var i2 = 0, i3 = 0, i4 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0;
    26536. 

  26536.  i2 = STACKTOP;
    26537. 

  26537.  STACKTOP = STACKTOP + 32 | 0;
    26538. 

  26538.  i3 = i2;
    26539. 

  26539.  i2 = i2 + 16 | 0;
    26540. 

  26540.  i8 = HEAP32[i5 + 16 >> 2] | 0;
    26541. 

  26541.  HEAP32[i2 >> 2] = 0;
    26542. 

  26542.  i4 = HEAP32[8528 + ((HEAP32[i6 + 8 >> 2] & 15) + 1 << 2) >> 2] | 0;
    26543. 

  26543.  L1 : do {
    26544. 

  26544.   if (!((HEAP8[i8 + 18 | 0] & 1) == 0)) {
    26545. 

  26545.    i7 = HEAP32[HEAP32[i8 >> 2] >> 2] | 0;
    26546. 

  26546.    i10 = HEAP8[i7 + 6 | 0] | 0;
    26547. 

  26547.    L3 : do {
    26548. 

  26548.     if (!(i10 << 24 >> 24 == 0)) {
    26549. 

  26549.      i9 = i7 + 16 | 0;
    26550. 

  26550.      i11 = i10 & 255;
    26551. 

  26551.      i10 = 0;
    26552. 

  26552.      while (1) {
    26553. 

  26553.       i12 = i10 + 1 | 0;
    26554. 

  26554.       if ((HEAP32[(HEAP32[i9 + (i10 << 2) >> 2] | 0) + 8 >> 2] | 0) == (i6 | 0)) {
    26555. 

  26555.        break;
    26556. 

  26556.       }
    26557. 

  26557.       if ((i12 | 0) < (i11 | 0)) {
    26558. 

  26558.        i10 = i12;
    26559. 

  26559.       } else {
    26560. 

  26560.        break L3;
    26561. 

  26561.       }
    26562. 

  26562.      }
    26563. 

  26563.      i9 = HEAP32[(HEAP32[(HEAP32[i7 + 12 >> 2] | 0) + 28 >> 2] | 0) + (i10 << 3) >> 2] | 0;
    26564. 

  26564.      if ((i9 | 0) == 0) {
    26565. 

  26565.       i9 = 2104;
    26566. 

  26566.      } else {
    26567. 

  26567.       i9 = i9 + 16 | 0;
    26568. 

  26568.      }
    26569. 

  26569.      HEAP32[i2 >> 2] = i9;
    26570. 

  26570.      i11 = i9;
    26571. 

  26571.      i10 = 2072;
    26572. 

  26572.      HEAP32[i3 >> 2] = i1;
    26573. 

  26573.      i12 = i3 + 4 | 0;
    26574. 

  26574.      HEAP32[i12 >> 2] = i10;
    26575. 

  26575.      i12 = i3 + 8 | 0;
    26576. 

  26576.      HEAP32[i12 >> 2] = i11;
    26577. 

  26577.      i12 = i3 + 12 | 0;
    26578. 

  26578.      HEAP32[i12 >> 2] = i4;
    26579. 

  26579.      _luaG_runerror(i5, 1840, i3);
    26580. 

  26580.     }
    26581. 

  26581.    } while (0);
    26582. 

  26582.    i9 = HEAP32[i8 + 24 >> 2] | 0;
    26583. 

  26583.    i10 = HEAP32[i8 + 4 >> 2] | 0;
    26584. 

  26584.    if (i9 >>> 0 < i10 >>> 0) {
    26585. 

  26585.     i12 = i9;
    26586. 

  26586.     while (1) {
    26587. 

  26587.      i11 = i12 + 16 | 0;
    26588. 

  26588.      if ((i12 | 0) == (i6 | 0)) {
    26589. 

  26589.       break;
    26590. 

  26590.      }
    26591. 

  26591.      if (i11 >>> 0 < i10 >>> 0) {
    26592. 

  26592.       i12 = i11;
    26593. 

  26593.      } else {
    26594. 

  26594.       break L1;
    26595. 

  26595.      }
    26596. 

  26596.     }
    26597. 

  26597.     i12 = HEAP32[i7 + 12 >> 2] | 0;
    26598. 

  26598.     i6 = _getobjname(i12, ((HEAP32[i8 + 28 >> 2] | 0) - (HEAP32[i12 + 12 >> 2] | 0) >> 2) + -1 | 0, i6 - i9 >> 4, i2) | 0;
    26599. 

  26599.     if ((i6 | 0) != 0) {
    26600. 

  26600.      i11 = HEAP32[i2 >> 2] | 0;
    26601. 

  26601.      i10 = i6;
    26602. 

  26602.      HEAP32[i3 >> 2] = i1;
    26603. 

  26603.      i12 = i3 + 4 | 0;
    26604. 

  26604.      HEAP32[i12 >> 2] = i10;
    26605. 

  26605.      i12 = i3 + 8 | 0;
    26606. 

  26606.      HEAP32[i12 >> 2] = i11;
    26607. 

  26607.      i12 = i3 + 12 | 0;
    26608. 

  26608.      HEAP32[i12 >> 2] = i4;
    26609. 

  26609.      _luaG_runerror(i5, 1840, i3);
    26610. 

  26610.     }
    26611. 

  26611.    }
    26612. 

  26612.   }
    26613. 

  26613.  } while (0);
    26614. 

  26614.  HEAP32[i3 >> 2] = i1;
    26615. 

  26615.  HEAP32[i3 + 4 >> 2] = i4;
    26616. 

  26616.  _luaG_runerror(i5, 1880, i3);
    26617. 

  26617. }
    26618. 

  26618. function _lua_setmetatable(i1, i7) {
    26619. 

  26619.  i1 = i1 | 0;
    26620. 

  26620.  i7 = i7 | 0;
    26621. 

  26621.  var i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i8 = 0;
    26622. 

  26622.  i4 = STACKTOP;
    26623. 

  26623.  i6 = HEAP32[i1 + 16 >> 2] | 0;
    26624. 

  26624.  do {
    26625. 

  26625.   if ((i7 | 0) <= 0) {
    26626. 

  26626.    if (!((i7 | 0) < -1000999)) {
    26627. 

  26627.     i5 = (HEAP32[i1 + 8 >> 2] | 0) + (i7 << 4) | 0;
    26628. 

  26628.     break;
    26629. 

  26629.    }
    26630. 

  26630.    if ((i7 | 0) == -1001e3) {
    26631. 

  26631.     i5 = (HEAP32[i1 + 12 >> 2] | 0) + 40 | 0;
    26632. 

  26632.     break;
    26633. 

  26633.    }
    26634. 

  26634.    i7 = -1001e3 - i7 | 0;
    26635. 

  26635.    i6 = HEAP32[i6 >> 2] | 0;
    26636. 

  26636.    if ((HEAP32[i6 + 8 >> 2] | 0) != 22 ? (i5 = HEAP32[i6 >> 2] | 0, (i7 | 0) <= (HEAPU8[i5 + 6 | 0] | 0 | 0)) : 0) {
    26637. 

  26637.     i5 = i5 + (i7 + -1 << 4) + 16 | 0;
    26638. 

  26638.    } else {
    26639. 

  26639.     i5 = 5192;
    26640. 

  26640.    }
    26641. 

  26641.   } else {
    26642. 

  26642.    i5 = (HEAP32[i6 >> 2] | 0) + (i7 << 4) | 0;
    26643. 

  26643.    i5 = i5 >>> 0 < (HEAP32[i1 + 8 >> 2] | 0) >>> 0 ? i5 : 5192;
    26644. 

  26644.   }
    26645. 

  26645.  } while (0);
    26646. 

  26646.  i6 = i1 + 8 | 0;
    26647. 

  26647.  i7 = HEAP32[i6 >> 2] | 0;
    26648. 

  26648.  if ((HEAP32[i7 + -8 >> 2] | 0) == 0) {
    26649. 

  26649.   i7 = 0;
    26650. 

  26650.  } else {
    26651. 

  26651.   i7 = HEAP32[i7 + -16 >> 2] | 0;
    26652. 

  26652.  }
    26653. 

  26653.  i8 = HEAP32[i5 + 8 >> 2] & 15;
    26654. 

  26654.  if ((i8 | 0) == 5) {
    26655. 

  26655.   HEAP32[(HEAP32[i5 >> 2] | 0) + 8 >> 2] = i7;
    26656. 

  26656.   if ((i7 | 0) == 0) {
    26657. 

  26657.    i8 = HEAP32[i6 >> 2] | 0;
    26658. 

  26658.    i8 = i8 + -16 | 0;
    26659. 

  26659.    HEAP32[i6 >> 2] = i8;
    26660. 

  26660.    STACKTOP = i4;
    26661. 

  26661.    return 1;
    26662. 

  26662.   }
    26663. 

  26663.   if (!((HEAP8[i7 + 5 | 0] & 3) == 0) ? (i2 = HEAP32[i5 >> 2] | 0, !((HEAP8[i2 + 5 | 0] & 4) == 0)) : 0) {
    26664. 

  26664.    _luaC_barrierback_(i1, i2);
    26665. 

  26665.   }
    26666. 

  26666.   _luaC_checkfinalizer(i1, HEAP32[i5 >> 2] | 0, i7);
    26667. 

  26667.   i8 = HEAP32[i6 >> 2] | 0;
    26668. 

  26668.   i8 = i8 + -16 | 0;
    26669. 

  26669.   HEAP32[i6 >> 2] = i8;
    26670. 

  26670.   STACKTOP = i4;
    26671. 

  26671.   return 1;
    26672. 

  26672.  } else if ((i8 | 0) == 7) {
    26673. 

  26673.   HEAP32[(HEAP32[i5 >> 2] | 0) + 8 >> 2] = i7;
    26674. 

  26674.   if ((i7 | 0) == 0) {
    26675. 

  26675.    i8 = HEAP32[i6 >> 2] | 0;
    26676. 

  26676.    i8 = i8 + -16 | 0;
    26677. 

  26677.    HEAP32[i6 >> 2] = i8;
    26678. 

  26678.    STACKTOP = i4;
    26679. 

  26679.    return 1;
    26680. 

  26680.   }
    26681. 

  26681.   if (!((HEAP8[i7 + 5 | 0] & 3) == 0) ? (i3 = HEAP32[i5 >> 2] | 0, !((HEAP8[i3 + 5 | 0] & 4) == 0)) : 0) {
    26682. 

  26682.    _luaC_barrier_(i1, i3, i7);
    26683. 

  26683.   }
    26684. 

  26684.   _luaC_checkfinalizer(i1, HEAP32[i5 >> 2] | 0, i7);
    26685. 

  26685.   i8 = HEAP32[i6 >> 2] | 0;
    26686. 

  26686.   i8 = i8 + -16 | 0;
    26687. 

  26687.   HEAP32[i6 >> 2] = i8;
    26688. 

  26688.   STACKTOP = i4;
    26689. 

  26689.   return 1;
    26690. 

  26690.  } else {
    26691. 

  26691.   HEAP32[(HEAP32[i1 + 12 >> 2] | 0) + (i8 << 2) + 252 >> 2] = i7;
    26692. 

  26692.   i8 = HEAP32[i6 >> 2] | 0;
    26693. 

  26693.   i8 = i8 + -16 | 0;
    26694. 

  26694.   HEAP32[i6 >> 2] = i8;
    26695. 

  26695.   STACKTOP = i4;
    26696. 

  26696.   return 1;
    26697. 

  26697.  }
    26698. 

  26698.  return 0;
    26699. 

  26699. }
    26700. 

  26700. function _recfield(i2, i10) {
    26701. 

  26701.  i2 = i2 | 0;
    26702. 

  26702.  i10 = i10 | 0;
    26703. 

  26703.  var i1 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i11 = 0, i12 = 0, i13 = 0, i14 = 0, i15 = 0, i16 = 0;
    26704. 

  26704.  i1 = STACKTOP;
    26705. 

  26705.  STACKTOP = STACKTOP + 64 | 0;
    26706. 

  26706.  i9 = i1 + 48 | 0;
    26707. 

  26707.  i6 = i1 + 24 | 0;
    26708. 

  26708.  i3 = i1;
    26709. 

  26709.  i13 = i2 + 48 | 0;
    26710. 

  26710.  i8 = HEAP32[i13 >> 2] | 0;
    26711. 

  26711.  i5 = i8 + 48 | 0;
    26712. 

  26712.  i4 = HEAP8[i5] | 0;
    26713. 

  26713.  i7 = i2 + 16 | 0;
    26714. 

  26714.  do {
    26715. 

  26715.   if ((HEAP32[i7 >> 2] | 0) != 288) {
    26716. 

  26716.    _luaX_next(i2);
    26717. 

  26717.    _subexpr(i2, i6, 0) | 0;
    26718. 

  26718.    _luaK_exp2val(HEAP32[i13 >> 2] | 0, i6);
    26719. 

  26719.    if ((HEAP32[i7 >> 2] | 0) == 93) {
    26720. 

  26720.     _luaX_next(i2);
    26721. 

  26721.     i11 = i10 + 28 | 0;
    26722. 

  26722.     break;
    26723. 

  26723.    } else {
    26724. 

  26724.     _error_expected(i2, 93);
    26725. 

  26725.    }
    26726. 

  26726.   } else {
    26727. 

  26727.    i12 = i10 + 28 | 0;
    26728. 

  26728.    if ((HEAP32[i12 >> 2] | 0) <= 2147483645) {
    26729. 

  26729.     i11 = HEAP32[i2 + 24 >> 2] | 0;
    26730. 

  26730.     _luaX_next(i2);
    26731. 

  26731.     i11 = _luaK_stringK(HEAP32[i13 >> 2] | 0, i11) | 0;
    26732. 

  26732.     HEAP32[i6 + 16 >> 2] = -1;
    26733. 

  26733.     HEAP32[i6 + 20 >> 2] = -1;
    26734. 

  26734.     HEAP32[i6 >> 2] = 4;
    26735. 

  26735.     HEAP32[i6 + 8 >> 2] = i11;
    26736. 

  26736.     i11 = i12;
    26737. 

  26737.     break;
    26738. 

  26738.    }
    26739. 

  26739.    i14 = i8 + 12 | 0;
    26740. 

  26740.    i13 = HEAP32[(HEAP32[i14 >> 2] | 0) + 52 >> 2] | 0;
    26741. 

  26741.    i12 = HEAP32[(HEAP32[i8 >> 2] | 0) + 64 >> 2] | 0;
    26742. 

  26742.    if ((i12 | 0) == 0) {
    26743. 

  26743.     i16 = 6552;
    26744. 

  26744.     HEAP32[i9 >> 2] = 6528;
    26745. 

  26745.     i15 = i9 + 4 | 0;
    26746. 

  26746.     HEAP32[i15 >> 2] = 2147483645;
    26747. 

  26747.     i15 = i9 + 8 | 0;
    26748. 

  26748.     HEAP32[i15 >> 2] = i16;
    26749. 

  26749.     i15 = _luaO_pushfstring(i13, 6592, i9) | 0;
    26750. 

  26750.     i16 = HEAP32[i14 >> 2] | 0;
    26751. 

  26751.     _luaX_syntaxerror(i16, i15);
    26752. 

  26752.    }
    26753. 

  26753.    HEAP32[i9 >> 2] = i12;
    26754. 

  26754.    i15 = _luaO_pushfstring(i13, 6568, i9) | 0;
    26755. 

  26755.    HEAP32[i9 >> 2] = 6528;
    26756. 

  26756.    i16 = i9 + 4 | 0;
    26757. 

  26757.    HEAP32[i16 >> 2] = 2147483645;
    26758. 

  26758.    i16 = i9 + 8 | 0;
    26759. 

  26759.    HEAP32[i16 >> 2] = i15;
    26760. 

  26760.    i16 = _luaO_pushfstring(i13, 6592, i9) | 0;
    26761. 

  26761.    i15 = HEAP32[i14 >> 2] | 0;
    26762. 

  26762.    _luaX_syntaxerror(i15, i16);
    26763. 

  26763.   }
    26764. 

  26764.  } while (0);
    26765. 

  26765.  HEAP32[i11 >> 2] = (HEAP32[i11 >> 2] | 0) + 1;
    26766. 

  26766.  if ((HEAP32[i7 >> 2] | 0) == 61) {
    26767. 

  26767.   _luaX_next(i2);
    26768. 

  26768.   i16 = _luaK_exp2RK(i8, i6) | 0;
    26769. 

  26769.   _subexpr(i2, i3, 0) | 0;
    26770. 

  26770.   i15 = HEAP32[(HEAP32[i10 + 24 >> 2] | 0) + 8 >> 2] | 0;
    26771. 

  26771.   _luaK_codeABC(i8, 10, i15, i16, _luaK_exp2RK(i8, i3) | 0) | 0;
    26772. 

  26772.   HEAP8[i5] = i4;
    26773. 

  26773.   STACKTOP = i1;
    26774. 

  26774.   return;
    26775. 

  26775.  } else {
    26776. 

  26776.   _error_expected(i2, 61);
    26777. 

  26777.  }
    26778. 

  26778. }
    26779. 

  26779. function _lua_newstate(i3, i6) {
    26780. 

  26780.  i3 = i3 | 0;
    26781. 

  26781.  i6 = i6 | 0;
    26782. 

  26782.  var i1 = 0, i2 = 0, i4 = 0, i5 = 0, i7 = 0;
    26783. 

  26783.  i1 = STACKTOP;
    26784. 

  26784.  STACKTOP = STACKTOP + 32 | 0;
    26785. 

  26785.  i5 = i1 + 8 | 0;
    26786. 

  26786.  i4 = i1;
    26787. 

  26787.  i2 = FUNCTION_TABLE_iiiii[i3 & 3](i6, 0, 8, 400) | 0;
    26788. 

  26788.  if ((i2 | 0) == 0) {
    26789. 

  26789.   i6 = 0;
    26790. 

  26790.   STACKTOP = i1;
    26791. 

  26791.   return i6 | 0;
    26792. 

  26792.  }
    26793. 

  26793.  i7 = i2 + 112 | 0;
    26794. 

  26794.  HEAP32[i2 >> 2] = 0;
    26795. 

  26795.  HEAP8[i2 + 4 | 0] = 8;
    26796. 

  26796.  HEAP8[i2 + 172 | 0] = 33;
    26797. 

  26797.  HEAP8[i2 + 5 | 0] = 1;
    26798. 

  26798.  HEAP8[i2 + 174 | 0] = 0;
    26799. 

  26799.  HEAP32[i2 + 12 >> 2] = i7;
    26800. 

  26800.  HEAP32[i2 + 28 >> 2] = 0;
    26801. 

  26801.  HEAP32[i2 + 16 >> 2] = 0;
    26802. 

  26802.  HEAP32[i2 + 32 >> 2] = 0;
    26803. 

  26803.  HEAP32[i2 + 64 >> 2] = 0;
    26804. 

  26804.  HEAP16[i2 + 38 >> 1] = 0;
    26805. 

  26805.  HEAP32[i2 + 52 >> 2] = 0;
    26806. 

  26806.  HEAP8[i2 + 40 | 0] = 0;
    26807. 

  26807.  HEAP32[i2 + 44 >> 2] = 0;
    26808. 

  26808.  HEAP8[i2 + 41 | 0] = 1;
    26809. 

  26809.  HEAP32[i2 + 48 >> 2] = 0;
    26810. 

  26810.  HEAP32[i2 + 56 >> 2] = 0;
    26811. 

  26811.  HEAP16[i2 + 36 >> 1] = 1;
    26812. 

  26812.  HEAP8[i2 + 6 | 0] = 0;
    26813. 

  26813.  HEAP32[i2 + 68 >> 2] = 0;
    26814. 

  26814.  HEAP32[i7 >> 2] = i3;
    26815. 

  26815.  HEAP32[i2 + 116 >> 2] = i6;
    26816. 

  26816.  HEAP32[i2 + 284 >> 2] = i2;
    26817. 

  26817.  i3 = _time(0) | 0;
    26818. 

  26818.  HEAP32[i4 >> 2] = i3;
    26819. 

  26819.  HEAP32[i5 >> 2] = i2;
    26820. 

  26820.  HEAP32[i5 + 4 >> 2] = i4;
    26821. 

  26821.  HEAP32[i5 + 8 >> 2] = 5192;
    26822. 

  26822.  HEAP32[i5 + 12 >> 2] = 1;
    26823. 

  26823.  HEAP32[i2 + 168 >> 2] = _luaS_hash(i5, 16, i3) | 0;
    26824. 

  26824.  i4 = i2 + 224 | 0;
    26825. 

  26825.  HEAP32[i2 + 240 >> 2] = i4;
    26826. 

  26826.  HEAP32[i2 + 244 >> 2] = i4;
    26827. 

  26827.  HEAP8[i2 + 175 | 0] = 0;
    26828. 

  26828.  i4 = i2 + 132 | 0;
    26829. 

  26829.  HEAP32[i2 + 160 >> 2] = 0;
    26830. 

  26830.  HEAP32[i2 + 256 >> 2] = 0;
    26831. 

  26831.  HEAP32[i2 + 264 >> 2] = 0;
    26832. 

  26832.  HEAP32[i2 + 280 >> 2] = 0;
    26833. 

  26833.  HEAP32[i4 + 0 >> 2] = 0;
    26834. 

  26834.  HEAP32[i4 + 4 >> 2] = 0;
    26835. 

  26835.  HEAP32[i4 + 8 >> 2] = 0;
    26836. 

  26836.  HEAP32[i4 + 12 >> 2] = 0;
    26837. 

  26837.  HEAP32[i2 + 288 >> 2] = _lua_version(0) | 0;
    26838. 

  26838.  HEAP8[i2 + 173 | 0] = 5;
    26839. 

  26839.  i4 = i2 + 120 | 0;
    26840. 

  26840.  i5 = i2 + 180 | 0;
    26841. 

  26841.  i3 = i5 + 40 | 0;
    26842. 

  26842.  do {
    26843. 

  26843.   HEAP32[i5 >> 2] = 0;
    26844. 

  26844.   i5 = i5 + 4 | 0;
    26845. 

  26845.  } while ((i5 | 0) < (i3 | 0));
    26846. 

  26846.  HEAP32[i4 >> 2] = 400;
    26847. 

  26847.  HEAP32[i2 + 124 >> 2] = 0;
    26848. 

  26848.  HEAP32[i2 + 268 >> 2] = 200;
    26849. 

  26849.  HEAP32[i2 + 272 >> 2] = 200;
    26850. 

  26850.  HEAP32[i2 + 276 >> 2] = 200;
    26851. 

  26851.  i5 = i2 + 364 | 0;
    26852. 

  26852.  i3 = i5 + 36 | 0;
    26853. 

  26853.  do {
    26854. 

  26854.   HEAP32[i5 >> 2] = 0;
    26855. 

  26855.   i5 = i5 + 4 | 0;
    26856. 

  26856.  } while ((i5 | 0) < (i3 | 0));
    26857. 

  26857.  if ((_luaD_rawrunprotected(i2, 8, 0) | 0) == 0) {
    26858. 

  26858.   i7 = i2;
    26859. 

  26859.   STACKTOP = i1;
    26860. 

  26860.   return i7 | 0;
    26861. 

  26861.  }
    26862. 

  26862.  _close_state(i2);
    26863. 

  26863.  i7 = 0;
    26864. 

  26864.  STACKTOP = i1;
    26865. 

  26865.  return i7 | 0;
    26866. 

  26866. }
    26867. 

  26867. function _luaU_undump(i1, i7, i8, i9) {
    26868. 

  26868.  i1 = i1 | 0;
    26869. 

  26869.  i7 = i7 | 0;
    26870. 

  26870.  i8 = i8 | 0;
    26871. 

  26871.  i9 = i9 | 0;
    26872. 

  26872.  var i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0;
    26873. 

  26873.  i2 = STACKTOP;
    26874. 

  26874.  STACKTOP = STACKTOP + 64 | 0;
    26875. 

  26875.  i4 = i2 + 16 | 0;
    26876. 

  26876.  i5 = i2 + 34 | 0;
    26877. 

  26877.  i3 = i2;
    26878. 

  26878.  i6 = HEAP8[i9] | 0;
    26879. 

  26879.  if (i6 << 24 >> 24 == 27) {
    26880. 

  26880.   HEAP32[i3 + 12 >> 2] = 8800;
    26881. 

  26881.  } else if (i6 << 24 >> 24 == 61 | i6 << 24 >> 24 == 64) {
    26882. 

  26882.   HEAP32[i3 + 12 >> 2] = i9 + 1;
    26883. 

  26883.  } else {
    26884. 

  26884.   HEAP32[i3 + 12 >> 2] = i9;
    26885. 

  26885.  }
    26886. 

  26886.  HEAP32[i3 >> 2] = i1;
    26887. 

  26887.  HEAP32[i3 + 4 >> 2] = i7;
    26888. 

  26888.  HEAP32[i3 + 8 >> 2] = i8;
    26889. 

  26889.  HEAP32[i4 >> 2] = 1635077147;
    26890. 

  26890.  HEAP8[i4 + 4 | 0] = 82;
    26891. 

  26891.  HEAP8[i4 + 5 | 0] = 0;
    26892. 

  26892.  HEAP8[i4 + 6 | 0] = 1;
    26893. 

  26893.  HEAP8[i4 + 7 | 0] = 4;
    26894. 

  26894.  HEAP8[i4 + 8 | 0] = 4;
    26895. 

  26895.  HEAP8[i4 + 9 | 0] = 4;
    26896. 

  26896.  HEAP8[i4 + 10 | 0] = 8;
    26897. 

  26897.  i9 = i4 + 12 | 0;
    26898. 

  26898.  HEAP8[i4 + 11 | 0] = 0;
    26899. 

  26899.  HEAP8[i9 + 0 | 0] = HEAP8[8816 | 0] | 0;
    26900. 

  26900.  HEAP8[i9 + 1 | 0] = HEAP8[8817 | 0] | 0;
    26901. 

  26901.  HEAP8[i9 + 2 | 0] = HEAP8[8818 | 0] | 0;
    26902. 

  26902.  HEAP8[i9 + 3 | 0] = HEAP8[8819 | 0] | 0;
    26903. 

  26903.  HEAP8[i9 + 4 | 0] = HEAP8[8820 | 0] | 0;
    26904. 

  26904.  HEAP8[i9 + 5 | 0] = HEAP8[8821 | 0] | 0;
    26905. 

  26905.  HEAP8[i5] = 27;
    26906. 

  26906.  if ((_luaZ_read(i7, i5 + 1 | 0, 17) | 0) != 0) {
    26907. 

  26907.   _error(i3, 8824);
    26908. 

  26908.  }
    26909. 

  26909.  if ((_memcmp(i4, i5, 18) | 0) == 0) {
    26910. 

  26910.   i4 = _luaF_newLclosure(i1, 1) | 0;
    26911. 

  26911.   i5 = i1 + 8 | 0;
    26912. 

  26912.   i9 = HEAP32[i5 >> 2] | 0;
    26913. 

  26913.   HEAP32[i9 >> 2] = i4;
    26914. 

  26914.   HEAP32[i9 + 8 >> 2] = 70;
    26915. 

  26915.   i9 = (HEAP32[i5 >> 2] | 0) + 16 | 0;
    26916. 

  26916.   HEAP32[i5 >> 2] = i9;
    26917. 

  26917.   if (((HEAP32[i1 + 24 >> 2] | 0) - i9 | 0) < 16) {
    26918. 

  26918.    _luaD_growstack(i1, 0);
    26919. 

  26919.   }
    26920. 

  26920.   i9 = _luaF_newproto(i1) | 0;
    26921. 

  26921.   i6 = i4 + 12 | 0;
    26922. 

  26922.   HEAP32[i6 >> 2] = i9;
    26923. 

  26923.   _LoadFunction(i3, i9);
    26924. 

  26924.   i6 = HEAP32[i6 >> 2] | 0;
    26925. 

  26925.   i3 = HEAP32[i6 + 40 >> 2] | 0;
    26926. 

  26926.   if ((i3 | 0) == 1) {
    26927. 

  26927.    i9 = i4;
    26928. 

  26928.    STACKTOP = i2;
    26929. 

  26929.    return i9 | 0;
    26930. 

  26930.   }
    26931. 

  26931.   i9 = _luaF_newLclosure(i1, i3) | 0;
    26932. 

  26932.   HEAP32[i9 + 12 >> 2] = i6;
    26933. 

  26933.   i8 = HEAP32[i5 >> 2] | 0;
    26934. 

  26934.   HEAP32[i8 + -16 >> 2] = i9;
    26935. 

  26935.   HEAP32[i8 + -8 >> 2] = 70;
    26936. 

  26936.   STACKTOP = i2;
    26937. 

  26937.   return i9 | 0;
    26938. 

  26938.  }
    26939. 

  26939.  if ((_memcmp(i4, i5, 4) | 0) != 0) {
    26940. 

  26940.   _error(i3, 8888);
    26941. 

  26941.  }
    26942. 

  26942.  if ((_memcmp(i4, i5, 6) | 0) != 0) {
    26943. 

  26943.   _error(i3, 8896);
    26944. 

  26944.  }
    26945. 

  26945.  if ((_memcmp(i4, i5, 12) | 0) == 0) {
    26946. 

  26946.   _error(i3, 8872);
    26947. 

  26947.  } else {
    26948. 

  26948.   _error(i3, 8920);
    26949. 

  26949.  }
    26950. 

  26950.  return 0;
    26951. 

  26951. }
    26952. 

  26952. function _lua_compare(i2, i7, i5, i3) {
    26953. 

  26953.  i2 = i2 | 0;
    26954. 

  26954.  i7 = i7 | 0;
    26955. 

  26955.  i5 = i5 | 0;
    26956. 

  26956.  i3 = i3 | 0;
    26957. 

  26957.  var i1 = 0, i4 = 0, i6 = 0, i8 = 0;
    26958. 

  26958.  i1 = STACKTOP;
    26959. 

  26959.  i4 = HEAP32[i2 + 16 >> 2] | 0;
    26960. 

  26960.  do {
    26961. 

  26961.   if ((i7 | 0) <= 0) {
    26962. 

  26962.    if (!((i7 | 0) < -1000999)) {
    26963. 

  26963.     i6 = (HEAP32[i2 + 8 >> 2] | 0) + (i7 << 4) | 0;
    26964. 

  26964.     break;
    26965. 

  26965.    }
    26966. 

  26966.    if ((i7 | 0) == -1001e3) {
    26967. 

  26967.     i6 = (HEAP32[i2 + 12 >> 2] | 0) + 40 | 0;
    26968. 

  26968.     break;
    26969. 

  26969.    }
    26970. 

  26970.    i7 = -1001e3 - i7 | 0;
    26971. 

  26971.    i8 = HEAP32[i4 >> 2] | 0;
    26972. 

  26972.    if ((HEAP32[i8 + 8 >> 2] | 0) != 22 ? (i6 = HEAP32[i8 >> 2] | 0, (i7 | 0) <= (HEAPU8[i6 + 6 | 0] | 0 | 0)) : 0) {
    26973. 

  26973.     i6 = i6 + (i7 + -1 << 4) + 16 | 0;
    26974. 

  26974.    } else {
    26975. 

  26975.     i6 = 5192;
    26976. 

  26976.    }
    26977. 

  26977.   } else {
    26978. 

  26978.    i6 = (HEAP32[i4 >> 2] | 0) + (i7 << 4) | 0;
    26979. 

  26979.    i6 = i6 >>> 0 < (HEAP32[i2 + 8 >> 2] | 0) >>> 0 ? i6 : 5192;
    26980. 

  26980.   }
    26981. 

  26981.  } while (0);
    26982. 

  26982.  do {
    26983. 

  26983.   if ((i5 | 0) <= 0) {
    26984. 

  26984.    if (!((i5 | 0) < -1000999)) {
    26985. 

  26985.     i4 = (HEAP32[i2 + 8 >> 2] | 0) + (i5 << 4) | 0;
    26986. 

  26986.     break;
    26987. 

  26987.    }
    26988. 

  26988.    if ((i5 | 0) == -1001e3) {
    26989. 

  26989.     i4 = (HEAP32[i2 + 12 >> 2] | 0) + 40 | 0;
    26990. 

  26990.     break;
    26991. 

  26991.    }
    26992. 

  26992.    i5 = -1001e3 - i5 | 0;
    26993. 

  26993.    i4 = HEAP32[i4 >> 2] | 0;
    26994. 

  26994.    if ((HEAP32[i4 + 8 >> 2] | 0) == 22) {
    26995. 

  26995.     i8 = 0;
    26996. 

  26996.     STACKTOP = i1;
    26997. 

  26997.     return i8 | 0;
    26998. 

  26998.    }
    26999. 

  26999.    i4 = HEAP32[i4 >> 2] | 0;
    27000. 

  27000.    if ((i5 | 0) > (HEAPU8[i4 + 6 | 0] | 0 | 0)) {
    27001. 

  27001.     i8 = 0;
    27002. 

  27002.     STACKTOP = i1;
    27003. 

  27003.     return i8 | 0;
    27004. 

  27004.    } else {
    27005. 

  27005.     i4 = i4 + (i5 + -1 << 4) + 16 | 0;
    27006. 

  27006.     break;
    27007. 

  27007.    }
    27008. 

  27008.   } else {
    27009. 

  27009.    i4 = (HEAP32[i4 >> 2] | 0) + (i5 << 4) | 0;
    27010. 

  27010.    i4 = i4 >>> 0 < (HEAP32[i2 + 8 >> 2] | 0) >>> 0 ? i4 : 5192;
    27011. 

  27011.   }
    27012. 

  27012.  } while (0);
    27013. 

  27013.  if ((i6 | 0) == 5192 | (i4 | 0) == 5192) {
    27014. 

  27014.   i8 = 0;
    27015. 

  27015.   STACKTOP = i1;
    27016. 

  27016.   return i8 | 0;
    27017. 

  27017.  }
    27018. 

  27018.  if ((i3 | 0) == 1) {
    27019. 

  27019.   i8 = _luaV_lessthan(i2, i6, i4) | 0;
    27020. 

  27020.   STACKTOP = i1;
    27021. 

  27021.   return i8 | 0;
    27022. 

  27022.  } else if ((i3 | 0) == 2) {
    27023. 

  27023.   i8 = _luaV_lessequal(i2, i6, i4) | 0;
    27024. 

  27024.   STACKTOP = i1;
    27025. 

  27025.   return i8 | 0;
    27026. 

  27026.  } else if ((i3 | 0) == 0) {
    27027. 

  27027.   if ((HEAP32[i6 + 8 >> 2] | 0) == (HEAP32[i4 + 8 >> 2] | 0)) {
    27028. 

  27028.    i2 = (_luaV_equalobj_(i2, i6, i4) | 0) != 0;
    27029. 

  27029.   } else {
    27030. 

  27030.    i2 = 0;
    27031. 

  27031.   }
    27032. 

  27032.   i8 = i2 & 1;
    27033. 

  27033.   STACKTOP = i1;
    27034. 

  27034.   return i8 | 0;
    27035. 

  27035.  } else {
    27036. 

  27036.   i8 = 0;
    27037. 

  27037.   STACKTOP = i1;
    27038. 

  27038.   return i8 | 0;
    27039. 

  27039.  }
    27040. 

  27040.  return 0;
    27041. 

  27041. }
    27042. 

  27042. function _lexerror(i7, i3, i8) {
    27043. 

  27043.  i7 = i7 | 0;
    27044. 

  27044.  i3 = i3 | 0;
    27045. 

  27045.  i8 = i8 | 0;
    27046. 

  27046.  var i1 = 0, i2 = 0, i4 = 0, i5 = 0, i6 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0;
    27047. 

  27047.  i12 = STACKTOP;
    27048. 

  27048.  STACKTOP = STACKTOP + 80 | 0;
    27049. 

  27049.  i2 = i12;
    27050. 

  27050.  i12 = i12 + 12 | 0;
    27051. 

  27051.  _luaO_chunkid(i12, (HEAP32[i7 + 68 >> 2] | 0) + 16 | 0, 60);
    27052. 

  27052.  i1 = i7 + 52 | 0;
    27053. 

  27053.  i4 = HEAP32[i1 >> 2] | 0;
    27054. 

  27054.  i13 = HEAP32[i7 + 4 >> 2] | 0;
    27055. 

  27055.  HEAP32[i2 >> 2] = i12;
    27056. 

  27056.  HEAP32[i2 + 4 >> 2] = i13;
    27057. 

  27057.  HEAP32[i2 + 8 >> 2] = i3;
    27058. 

  27058.  i4 = _luaO_pushfstring(i4, 12592, i2) | 0;
    27059. 

  27059.  if ((i8 | 0) == 0) {
    27060. 

  27060.   i13 = HEAP32[i1 >> 2] | 0;
    27061. 

  27061.   _luaD_throw(i13, 3);
    27062. 

  27062.  }
    27063. 

  27063.  i3 = HEAP32[i1 >> 2] | 0;
    27064. 

  27064.  do {
    27065. 

  27065.   if (!((i8 + -287 | 0) >>> 0 < 3)) {
    27066. 

  27066.    if ((i8 | 0) >= 257) {
    27067. 

  27067.     i5 = HEAP32[12096 + (i8 + -257 << 2) >> 2] | 0;
    27068. 

  27068.     if ((i8 | 0) >= 286) {
    27069. 

  27069.      break;
    27070. 

  27070.     }
    27071. 

  27071.     HEAP32[i2 >> 2] = i5;
    27072. 

  27072.     i5 = _luaO_pushfstring(i3, 12256, i2) | 0;
    27073. 

  27073.     break;
    27074. 

  27074.    }
    27075. 

  27075.    if ((HEAP8[i8 + 10913 | 0] & 4) == 0) {
    27076. 

  27076.     HEAP32[i2 >> 2] = i8;
    27077. 

  27077.     i5 = _luaO_pushfstring(i3, 12240, i2) | 0;
    27078. 

  27078.     break;
    27079. 

  27079.    } else {
    27080. 

  27080.     HEAP32[i2 >> 2] = i8;
    27081. 

  27081.     i5 = _luaO_pushfstring(i3, 12232, i2) | 0;
    27082. 

  27082.     break;
    27083. 

  27083.    }
    27084. 

  27084.   } else {
    27085. 

  27085.    i11 = i7 + 60 | 0;
    27086. 

  27086.    i12 = HEAP32[i11 >> 2] | 0;
    27087. 

  27087.    i10 = i12 + 4 | 0;
    27088. 

  27088.    i13 = HEAP32[i10 >> 2] | 0;
    27089. 

  27089.    i8 = i12 + 8 | 0;
    27090. 

  27090.    i9 = HEAP32[i8 >> 2] | 0;
    27091. 

  27091.    do {
    27092. 

  27092.     if ((i13 + 1 | 0) >>> 0 > i9 >>> 0) {
    27093. 

  27093.      if (i9 >>> 0 > 2147483645) {
    27094. 

  27094.       _lexerror(i7, 12368, 0);
    27095. 

  27095.      }
    27096. 

  27096.      i7 = i9 << 1;
    27097. 

  27097.      if ((i7 | 0) == -2) {
    27098. 

  27098.       _luaM_toobig(i3);
    27099. 

  27099.      } else {
    27100. 

  27100.       i6 = _luaM_realloc_(i3, HEAP32[i12 >> 2] | 0, i9, i7) | 0;
    27101. 

  27101.       HEAP32[i12 >> 2] = i6;
    27102. 

  27102.       HEAP32[i8 >> 2] = i7;
    27103. 

  27103.       i5 = HEAP32[i10 >> 2] | 0;
    27104. 

  27104.       break;
    27105. 

  27105.      }
    27106. 

  27106.     } else {
    27107. 

  27107.      i5 = i13;
    27108. 

  27108.      i6 = HEAP32[i12 >> 2] | 0;
    27109. 

  27109.     }
    27110. 

  27110.    } while (0);
    27111. 

  27111.    HEAP32[i10 >> 2] = i5 + 1;
    27112. 

  27112.    HEAP8[i6 + i5 | 0] = 0;
    27113. 

  27113.    i5 = HEAP32[i1 >> 2] | 0;
    27114. 

  27114.    HEAP32[i2 >> 2] = HEAP32[HEAP32[i11 >> 2] >> 2];
    27115. 

  27115.    i5 = _luaO_pushfstring(i5, 12256, i2) | 0;
    27116. 

  27116.   }
    27117. 

  27117.  } while (0);
    27118. 

  27118.  HEAP32[i2 >> 2] = i4;
    27119. 

  27119.  HEAP32[i2 + 4 >> 2] = i5;
    27120. 

  27120.  _luaO_pushfstring(i3, 12608, i2) | 0;
    27121. 

  27121.  i13 = HEAP32[i1 >> 2] | 0;
    27122. 

  27122.  _luaD_throw(i13, 3);
    27123. 

  27123. }
    27124. 

  27124. function _luaV_objlen(i2, i5, i1) {
    27125. 

  27125.  i2 = i2 | 0;
    27126. 

  27126.  i5 = i5 | 0;
    27127. 

  27127.  i1 = i1 | 0;
    27128. 

  27128.  var i3 = 0, i4 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0;
    27129. 

  27129.  i3 = STACKTOP;
    27130. 

  27130.  i4 = i1 + 8 | 0;
    27131. 

  27131.  i8 = HEAP32[i4 >> 2] & 15;
    27132. 

  27132.  do {
    27133. 

  27133.   if ((i8 | 0) == 5) {
    27134. 

  27134.    i7 = HEAP32[i1 >> 2] | 0;
    27135. 

  27135.    i8 = HEAP32[i7 + 8 >> 2] | 0;
    27136. 

  27136.    if (((i8 | 0) != 0 ? (HEAP8[i8 + 6 | 0] & 16) == 0 : 0) ? (i6 = _luaT_gettm(i8, 4, HEAP32[(HEAP32[i2 + 12 >> 2] | 0) + 200 >> 2] | 0) | 0, (i6 | 0) != 0) : 0) {
    27137. 

  27137.     i7 = i6;
    27138. 

  27138.     break;
    27139. 

  27139.    }
    27140. 

  27140.    HEAPF64[i5 >> 3] = +(_luaH_getn(i7) | 0);
    27141. 

  27141.    HEAP32[i5 + 8 >> 2] = 3;
    27142. 

  27142.    STACKTOP = i3;
    27143. 

  27143.    return;
    27144. 

  27144.   } else if ((i8 | 0) != 4) {
    27145. 

  27145.    i6 = _luaT_gettmbyobj(i2, i1, 4) | 0;
    27146. 

  27146.    if ((HEAP32[i6 + 8 >> 2] | 0) == 0) {
    27147. 

  27147.     _luaG_typeerror(i2, i1, 9024);
    27148. 

  27148.    } else {
    27149. 

  27149.     i7 = i6;
    27150. 

  27150.    }
    27151. 

  27151.   } else {
    27152. 

  27152.    HEAPF64[i5 >> 3] = +((HEAP32[(HEAP32[i1 >> 2] | 0) + 12 >> 2] | 0) >>> 0);
    27153. 

  27153.    HEAP32[i5 + 8 >> 2] = 3;
    27154. 

  27154.    STACKTOP = i3;
    27155. 

  27155.    return;
    27156. 

  27156.   }
    27157. 

  27157.  } while (0);
    27158. 

  27158.  i6 = i2 + 28 | 0;
    27159. 

  27159.  i8 = i5 - (HEAP32[i6 >> 2] | 0) | 0;
    27160. 

  27160.  i5 = i2 + 8 | 0;
    27161. 

  27161.  i11 = HEAP32[i5 >> 2] | 0;
    27162. 

  27162.  HEAP32[i5 >> 2] = i11 + 16;
    27163. 

  27163.  i12 = i7;
    27164. 

  27164.  i10 = HEAP32[i12 + 4 >> 2] | 0;
    27165. 

  27165.  i9 = i11;
    27166. 

  27166.  HEAP32[i9 >> 2] = HEAP32[i12 >> 2];
    27167. 

  27167.  HEAP32[i9 + 4 >> 2] = i10;
    27168. 

  27168.  HEAP32[i11 + 8 >> 2] = HEAP32[i7 + 8 >> 2];
    27169. 

  27169.  i7 = HEAP32[i5 >> 2] | 0;
    27170. 

  27170.  HEAP32[i5 >> 2] = i7 + 16;
    27171. 

  27171.  i11 = i1;
    27172. 

  27172.  i9 = HEAP32[i11 + 4 >> 2] | 0;
    27173. 

  27173.  i10 = i7;
    27174. 

  27174.  HEAP32[i10 >> 2] = HEAP32[i11 >> 2];
    27175. 

  27175.  HEAP32[i10 + 4 >> 2] = i9;
    27176. 

  27176.  HEAP32[i7 + 8 >> 2] = HEAP32[i4 >> 2];
    27177. 

  27177.  i7 = HEAP32[i5 >> 2] | 0;
    27178. 

  27178.  HEAP32[i5 >> 2] = i7 + 16;
    27179. 

  27179.  i10 = i1;
    27180. 

  27180.  i9 = HEAP32[i10 + 4 >> 2] | 0;
    27181. 

  27181.  i1 = i7;
    27182. 

  27182.  HEAP32[i1 >> 2] = HEAP32[i10 >> 2];
    27183. 

  27183.  HEAP32[i1 + 4 >> 2] = i9;
    27184. 

  27184.  HEAP32[i7 + 8 >> 2] = HEAP32[i4 >> 2];
    27185. 

  27185.  _luaD_call(i2, (HEAP32[i5 >> 2] | 0) + -48 | 0, 1, HEAP8[(HEAP32[i2 + 16 >> 2] | 0) + 18 | 0] & 1);
    27186. 

  27186.  i7 = HEAP32[i6 >> 2] | 0;
    27187. 

  27187.  i6 = HEAP32[i5 >> 2] | 0;
    27188. 

  27188.  i2 = i6 + -16 | 0;
    27189. 

  27189.  HEAP32[i5 >> 2] = i2;
    27190. 

  27190.  i4 = HEAP32[i2 + 4 >> 2] | 0;
    27191. 

  27191.  i5 = i7 + i8 | 0;
    27192. 

  27192.  HEAP32[i5 >> 2] = HEAP32[i2 >> 2];
    27193. 

  27193.  HEAP32[i5 + 4 >> 2] = i4;
    27194. 

  27194.  HEAP32[i7 + (i8 + 8) >> 2] = HEAP32[i6 + -8 >> 2];
    27195. 

  27195.  STACKTOP = i3;
    27196. 

  27196.  return;
    27197. 

  27197. }
    27198. 

  27198. function _get_equalTM(i6, i5, i4) {
    27199. 

  27199.  i6 = i6 | 0;
    27200. 

  27200.  i5 = i5 | 0;
    27201. 

  27201.  i4 = i4 | 0;
    27202. 

  27202.  var i1 = 0, i2 = 0, i3 = 0, i7 = 0;
    27203. 

  27203.  i1 = STACKTOP;
    27204. 

  27204.  L1 : do {
    27205. 

  27205.   if (((i5 | 0) != 0 ? (HEAP8[i5 + 6 | 0] & 32) == 0 : 0) ? (i7 = i6 + 12 | 0, i2 = _luaT_gettm(i5, 5, HEAP32[(HEAP32[i7 >> 2] | 0) + 204 >> 2] | 0) | 0, (i2 | 0) != 0) : 0) {
    27206. 

  27206.    if ((i5 | 0) != (i4 | 0)) {
    27207. 

  27207.     if (((i4 | 0) != 0 ? (HEAP8[i4 + 6 | 0] & 32) == 0 : 0) ? (i3 = _luaT_gettm(i4, 5, HEAP32[(HEAP32[i7 >> 2] | 0) + 204 >> 2] | 0) | 0, (i3 | 0) != 0) : 0) {
    27208. 

  27208.      i4 = HEAP32[i2 + 8 >> 2] | 0;
    27209. 

  27209.      L9 : do {
    27210. 

  27210.       if ((i4 | 0) == (HEAP32[i3 + 8 >> 2] | 0)) {
    27211. 

  27211.        switch (i4 & 63 | 0) {
    27212. 

  27212.        case 3:
    27213. 

  27213.         {
    27214. 

  27214.          i3 = +HEAPF64[i2 >> 3] == +HEAPF64[i3 >> 3] | 0;
    27215. 

  27215.          break;
    27216. 

  27216.         }
    27217. 

  27217.        case 22:
    27218. 

  27218.         {
    27219. 

  27219.          i3 = (HEAP32[i2 >> 2] | 0) == (HEAP32[i3 >> 2] | 0) | 0;
    27220. 

  27220.          break;
    27221. 

  27221.         }
    27222. 

  27222.        case 5:
    27223. 

  27223.         {
    27224. 

  27224.          if ((HEAP32[i2 >> 2] | 0) == (HEAP32[i3 >> 2] | 0)) {
    27225. 

  27225.           break L1;
    27226. 

  27226.          } else {
    27227. 

  27227.           break L9;
    27228. 

  27228.          }
    27229. 

  27229.         }
    27230. 

  27230.        case 1:
    27231. 

  27231.         {
    27232. 

  27232.          i3 = (HEAP32[i2 >> 2] | 0) == (HEAP32[i3 >> 2] | 0) | 0;
    27233. 

  27233.          break;
    27234. 

  27234.         }
    27235. 

  27235.        case 4:
    27236. 

  27236.         {
    27237. 

  27237.          i3 = (HEAP32[i2 >> 2] | 0) == (HEAP32[i3 >> 2] | 0) | 0;
    27238. 

  27238.          break;
    27239. 

  27239.         }
    27240. 

  27240.        case 0:
    27241. 

  27241.         {
    27242. 

  27242.          break L1;
    27243. 

  27243.         }
    27244. 

  27244.        case 7:
    27245. 

  27245.         {
    27246. 

  27246.          if ((HEAP32[i2 >> 2] | 0) == (HEAP32[i3 >> 2] | 0)) {
    27247. 

  27247.           break L1;
    27248. 

  27248.          } else {
    27249. 

  27249.           break L9;
    27250. 

  27250.          }
    27251. 

  27251.         }
    27252. 

  27252.        case 2:
    27253. 

  27253.         {
    27254. 

  27254.          i3 = (HEAP32[i2 >> 2] | 0) == (HEAP32[i3 >> 2] | 0) | 0;
    27255. 

  27255.          break;
    27256. 

  27256.         }
    27257. 

  27257.        case 20:
    27258. 

  27258.         {
    27259. 

  27259.          i3 = _luaS_eqlngstr(HEAP32[i2 >> 2] | 0, HEAP32[i3 >> 2] | 0) | 0;
    27260. 

  27260.          break;
    27261. 

  27261.         }
    27262. 

  27262.        default:
    27263. 

  27263.         {
    27264. 

  27264.          i3 = (HEAP32[i2 >> 2] | 0) == (HEAP32[i3 >> 2] | 0) | 0;
    27265. 

  27265.         }
    27266. 

  27266.        }
    27267. 

  27267.        if ((i3 | 0) != 0) {
    27268. 

  27268.         break L1;
    27269. 

  27269.        }
    27270. 

  27270.       }
    27271. 

  27271.      } while (0);
    27272. 

  27272.      i2 = 0;
    27273. 

  27273.     } else {
    27274. 

  27274.      i2 = 0;
    27275. 

  27275.     }
    27276. 

  27276.    }
    27277. 

  27277.   } else {
    27278. 

  27278.    i2 = 0;
    27279. 

  27279.   }
    27280. 

  27280.  } while (0);
    27281. 

  27281.  STACKTOP = i1;
    27282. 

  27282.  return i2 | 0;
    27283. 

  27283. }
    27284. 

  27284. function _luaS_newlstr(i2, i4, i3) {
    27285. 

  27285.  i2 = i2 | 0;
    27286. 

  27286.  i4 = i4 | 0;
    27287. 

  27287.  i3 = i3 | 0;
    27288. 

  27288.  var i1 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0;
    27289. 

  27289.  i1 = STACKTOP;
    27290. 

  27290.  if (!(i3 >>> 0 < 41)) {
    27291. 

  27291.   if ((i3 + 1 | 0) >>> 0 > 4294967277) {
    27292. 

  27292.    _luaM_toobig(i2);
    27293. 

  27293.   }
    27294. 

  27294.   i10 = HEAP32[(HEAP32[i2 + 12 >> 2] | 0) + 56 >> 2] | 0;
    27295. 

  27295.   i11 = _luaC_newobj(i2, 20, i3 + 17 | 0, 0, 0) | 0;
    27296. 

  27296.   HEAP32[i11 + 12 >> 2] = i3;
    27297. 

  27297.   HEAP32[i11 + 8 >> 2] = i10;
    27298. 

  27298.   HEAP8[i11 + 6 | 0] = 0;
    27299. 

  27299.   i10 = i11 + 16 | 0;
    27300. 

  27300.   _memcpy(i10 | 0, i4 | 0, i3 | 0) | 0;
    27301. 

  27301.   HEAP8[i10 + i3 | 0] = 0;
    27302. 

  27302.   STACKTOP = i1;
    27303. 

  27303.   return i11 | 0;
    27304. 

  27304.  }
    27305. 

  27305.  i5 = HEAP32[i2 + 12 >> 2] | 0;
    27306. 

  27306.  i6 = HEAP32[i5 + 56 >> 2] ^ i3;
    27307. 

  27307.  i7 = (i3 >>> 5) + 1 | 0;
    27308. 

  27308.  if (!(i7 >>> 0 > i3 >>> 0)) {
    27309. 

  27309.   i8 = i3;
    27310. 

  27310.   do {
    27311. 

  27311.    i6 = (i6 << 5) + (i6 >>> 2) + (HEAPU8[i4 + (i8 + -1) | 0] | 0) ^ i6;
    27312. 

  27312.    i8 = i8 - i7 | 0;
    27313. 

  27313.   } while (!(i8 >>> 0 < i7 >>> 0));
    27314. 

  27314.  }
    27315. 

  27315.  i10 = i5 + 32 | 0;
    27316. 

  27316.  i9 = HEAP32[i10 >> 2] | 0;
    27317. 

  27317.  i7 = i5 + 24 | 0;
    27318. 

  27318.  i8 = HEAP32[i7 >> 2] | 0;
    27319. 

  27319.  i11 = HEAP32[i8 + ((i9 + -1 & i6) << 2) >> 2] | 0;
    27320. 

  27320.  L12 : do {
    27321. 

  27321.   if ((i11 | 0) != 0) {
    27322. 

  27322.    while (1) {
    27323. 

  27323.     if (((i6 | 0) == (HEAP32[i11 + 8 >> 2] | 0) ? (HEAP32[i11 + 12 >> 2] | 0) == (i3 | 0) : 0) ? (_memcmp(i4, i11 + 16 | 0, i3) | 0) == 0 : 0) {
    27324. 

  27324.      break;
    27325. 

  27325.     }
    27326. 

  27326.     i11 = HEAP32[i11 >> 2] | 0;
    27327. 

  27327.     if ((i11 | 0) == 0) {
    27328. 

  27328.      break L12;
    27329. 

  27329.     }
    27330. 

  27330.    }
    27331. 

  27331.    i2 = i11 + 5 | 0;
    27332. 

  27332.    i3 = (HEAPU8[i2] | 0) ^ 3;
    27333. 

  27333.    if ((((HEAPU8[i5 + 60 | 0] | 0) ^ 3) & i3 | 0) != 0) {
    27334. 

  27334.     STACKTOP = i1;
    27335. 

  27335.     return i11 | 0;
    27336. 

  27336.    }
    27337. 

  27337.    HEAP8[i2] = i3;
    27338. 

  27338.    STACKTOP = i1;
    27339. 

  27339.    return i11 | 0;
    27340. 

  27340.   }
    27341. 

  27341.  } while (0);
    27342. 

  27342.  i5 = i5 + 28 | 0;
    27343. 

  27343.  if ((HEAP32[i5 >> 2] | 0) >>> 0 >= i9 >>> 0 & (i9 | 0) < 1073741823) {
    27344. 

  27344.   _luaS_resize(i2, i9 << 1);
    27345. 

  27345.   i9 = HEAP32[i10 >> 2] | 0;
    27346. 

  27346.   i8 = HEAP32[i7 >> 2] | 0;
    27347. 

  27347.  }
    27348. 

  27348.  i11 = _luaC_newobj(i2, 4, i3 + 17 | 0, i8 + ((i9 + -1 & i6) << 2) | 0, 0) | 0;
    27349. 

  27349.  HEAP32[i11 + 12 >> 2] = i3;
    27350. 

  27350.  HEAP32[i11 + 8 >> 2] = i6;
    27351. 

  27351.  HEAP8[i11 + 6 | 0] = 0;
    27352. 

  27352.  i10 = i11 + 16 | 0;
    27353. 

  27353.  _memcpy(i10 | 0, i4 | 0, i3 | 0) | 0;
    27354. 

  27354.  HEAP8[i10 + i3 | 0] = 0;
    27355. 

  27355.  HEAP32[i5 >> 2] = (HEAP32[i5 >> 2] | 0) + 1;
    27356. 

  27356.  STACKTOP = i1;
    27357. 

  27357.  return i11 | 0;
    27358. 

  27358. }
    27359. 

  27359. function _lua_pcallk(i3, i7, i2, i9, i6, i5) {
    27360. 

  27360.  i3 = i3 | 0;
    27361. 

  27361.  i7 = i7 | 0;
    27362. 

  27362.  i2 = i2 | 0;
    27363. 

  27363.  i9 = i9 | 0;
    27364. 

  27364.  i6 = i6 | 0;
    27365. 

  27365.  i5 = i5 | 0;
    27366. 

  27366.  var i1 = 0, i4 = 0, i8 = 0, i10 = 0, i11 = 0;
    27367. 

  27367.  i1 = STACKTOP;
    27368. 

  27368.  STACKTOP = STACKTOP + 16 | 0;
    27369. 

  27369.  i4 = i1;
    27370. 

  27370.  if ((i9 | 0) == 0) {
    27371. 

  27371.   i9 = 0;
    27372. 

  27372.  } else {
    27373. 

  27373.   i10 = HEAP32[i3 + 16 >> 2] | 0;
    27374. 

  27374.   do {
    27375. 

  27375.    if ((i9 | 0) <= 0) {
    27376. 

  27376.     if (!((i9 | 0) < -1000999)) {
    27377. 

  27377.      i8 = (HEAP32[i3 + 8 >> 2] | 0) + (i9 << 4) | 0;
    27378. 

  27378.      break;
    27379. 

  27379.     }
    27380. 

  27380.     if ((i9 | 0) == -1001e3) {
    27381. 

  27381.      i8 = (HEAP32[i3 + 12 >> 2] | 0) + 40 | 0;
    27382. 

  27382.      break;
    27383. 

  27383.     }
    27384. 

  27384.     i9 = -1001e3 - i9 | 0;
    27385. 

  27385.     i10 = HEAP32[i10 >> 2] | 0;
    27386. 

  27386.     if ((HEAP32[i10 + 8 >> 2] | 0) != 22 ? (i8 = HEAP32[i10 >> 2] | 0, (i9 | 0) <= (HEAPU8[i8 + 6 | 0] | 0)) : 0) {
    27387. 

  27387.      i8 = i8 + (i9 + -1 << 4) + 16 | 0;
    27388. 

  27388.     } else {
    27389. 

  27389.      i8 = 5192;
    27390. 

  27390.     }
    27391. 

  27391.    } else {
    27392. 

  27392.     i8 = (HEAP32[i10 >> 2] | 0) + (i9 << 4) | 0;
    27393. 

  27393.     i8 = i8 >>> 0 < (HEAP32[i3 + 8 >> 2] | 0) >>> 0 ? i8 : 5192;
    27394. 

  27394.    }
    27395. 

  27395.   } while (0);
    27396. 

  27396.   i9 = i8 - (HEAP32[i3 + 28 >> 2] | 0) | 0;
    27397. 

  27397.  }
    27398. 

  27398.  i8 = i3 + 8 | 0;
    27399. 

  27399.  i7 = (HEAP32[i8 >> 2] | 0) + (~i7 << 4) | 0;
    27400. 

  27400.  HEAP32[i4 >> 2] = i7;
    27401. 

  27401.  if ((i5 | 0) != 0 ? (HEAP16[i3 + 36 >> 1] | 0) == 0 : 0) {
    27402. 

  27402.   i11 = HEAP32[i3 + 16 >> 2] | 0;
    27403. 

  27403.   HEAP32[i11 + 28 >> 2] = i5;
    27404. 

  27404.   HEAP32[i11 + 24 >> 2] = i6;
    27405. 

  27405.   HEAP32[i11 + 20 >> 2] = (HEAP32[i4 >> 2] | 0) - (HEAP32[i3 + 28 >> 2] | 0);
    27406. 

  27406.   HEAP8[i11 + 36 | 0] = HEAP8[i3 + 41 | 0] | 0;
    27407. 

  27407.   i10 = i3 + 68 | 0;
    27408. 

  27408.   i7 = i11 + 32 | 0;
    27409. 

  27409.   HEAP32[i7 >> 2] = HEAP32[i10 >> 2];
    27410. 

  27410.   HEAP32[i10 >> 2] = i9;
    27411. 

  27411.   i9 = i11 + 18 | 0;
    27412. 

  27412.   HEAP8[i9] = HEAPU8[i9] | 16;
    27413. 

  27413.   _luaD_call(i3, HEAP32[i4 >> 2] | 0, i2, 1);
    27414. 

  27414.   HEAP8[i9] = HEAP8[i9] & 239;
    27415. 

  27415.   HEAP32[i10 >> 2] = HEAP32[i7 >> 2];
    27416. 

  27416.   i4 = 0;
    27417. 

  27417.  } else {
    27418. 

  27418.   HEAP32[i4 + 4 >> 2] = i2;
    27419. 

  27419.   i4 = _luaD_pcall(i3, 3, i4, i7 - (HEAP32[i3 + 28 >> 2] | 0) | 0, i9) | 0;
    27420. 

  27420.  }
    27421. 

  27421.  if (!((i2 | 0) == -1)) {
    27422. 

  27422.   STACKTOP = i1;
    27423. 

  27423.   return i4 | 0;
    27424. 

  27424.  }
    27425. 

  27425.  i2 = (HEAP32[i3 + 16 >> 2] | 0) + 4 | 0;
    27426. 

  27426.  i3 = HEAP32[i8 >> 2] | 0;
    27427. 

  27427.  if (!((HEAP32[i2 >> 2] | 0) >>> 0 < i3 >>> 0)) {
    27428. 

  27428.   STACKTOP = i1;
    27429. 

  27429.   return i4 | 0;
    27430. 

  27430.  }
    27431. 

  27431.  HEAP32[i2 >> 2] = i3;
    27432. 

  27432.  STACKTOP = i1;
    27433. 

  27433.  return i4 | 0;
    27434. 

  27434. }
    27435. 

  27435. function _lua_getupvalue(i1, i6, i3) {
    27436. 

  27436.  i1 = i1 | 0;
    27437. 

  27437.  i6 = i6 | 0;
    27438. 

  27438.  i3 = i3 | 0;
    27439. 

  27439.  var i2 = 0, i4 = 0, i5 = 0, i7 = 0, i8 = 0;
    27440. 

  27440.  i2 = STACKTOP;
    27441. 

  27441.  i5 = HEAP32[i1 + 16 >> 2] | 0;
    27442. 

  27442.  do {
    27443. 

  27443.   if ((i6 | 0) <= 0) {
    27444. 

  27444.    if (!((i6 | 0) < -1000999)) {
    27445. 

  27445.     i4 = (HEAP32[i1 + 8 >> 2] | 0) + (i6 << 4) | 0;
    27446. 

  27446.     break;
    27447. 

  27447.    }
    27448. 

  27448.    if ((i6 | 0) == -1001e3) {
    27449. 

  27449.     i4 = (HEAP32[i1 + 12 >> 2] | 0) + 40 | 0;
    27450. 

  27450.     break;
    27451. 

  27451.    }
    27452. 

  27452.    i6 = -1001e3 - i6 | 0;
    27453. 

  27453.    i5 = HEAP32[i5 >> 2] | 0;
    27454. 

  27454.    if ((HEAP32[i5 + 8 >> 2] | 0) != 22 ? (i4 = HEAP32[i5 >> 2] | 0, (i6 | 0) <= (HEAPU8[i4 + 6 | 0] | 0 | 0)) : 0) {
    27455. 

  27455.     i4 = i4 + (i6 + -1 << 4) + 16 | 0;
    27456. 

  27456.    } else {
    27457. 

  27457.     i4 = 5192;
    27458. 

  27458.    }
    27459. 

  27459.   } else {
    27460. 

  27460.    i4 = (HEAP32[i5 >> 2] | 0) + (i6 << 4) | 0;
    27461. 

  27461.    i4 = i4 >>> 0 < (HEAP32[i1 + 8 >> 2] | 0) >>> 0 ? i4 : 5192;
    27462. 

  27462.   }
    27463. 

  27463.  } while (0);
    27464. 

  27464.  i5 = HEAP32[i4 + 8 >> 2] & 63;
    27465. 

  27465.  do {
    27466. 

  27466.   if ((i5 | 0) == 38) {
    27467. 

  27467.    i5 = HEAP32[i4 >> 2] | 0;
    27468. 

  27468.    if ((i3 | 0) <= 0) {
    27469. 

  27469.     i6 = 0;
    27470. 

  27470.     STACKTOP = i2;
    27471. 

  27471.     return i6 | 0;
    27472. 

  27472.    }
    27473. 

  27473.    if ((HEAPU8[i5 + 6 | 0] | 0 | 0) < (i3 | 0)) {
    27474. 

  27474.     i6 = 0;
    27475. 

  27475.     STACKTOP = i2;
    27476. 

  27476.     return i6 | 0;
    27477. 

  27477.    } else {
    27478. 

  27478.     i4 = 936;
    27479. 

  27479.     i3 = i5 + (i3 + -1 << 4) + 16 | 0;
    27480. 

  27480.     break;
    27481. 

  27481.    }
    27482. 

  27482.   } else if ((i5 | 0) == 6) {
    27483. 

  27483.    i5 = HEAP32[i4 >> 2] | 0;
    27484. 

  27484.    i4 = HEAP32[i5 + 12 >> 2] | 0;
    27485. 

  27485.    if ((i3 | 0) <= 0) {
    27486. 

  27486.     i6 = 0;
    27487. 

  27487.     STACKTOP = i2;
    27488. 

  27488.     return i6 | 0;
    27489. 

  27489.    }
    27490. 

  27490.    if ((HEAP32[i4 + 40 >> 2] | 0) < (i3 | 0)) {
    27491. 

  27491.     i6 = 0;
    27492. 

  27492.     STACKTOP = i2;
    27493. 

  27493.     return i6 | 0;
    27494. 

  27494.    }
    27495. 

  27495.    i6 = i3 + -1 | 0;
    27496. 

  27496.    i3 = HEAP32[(HEAP32[i5 + 16 + (i6 << 2) >> 2] | 0) + 8 >> 2] | 0;
    27497. 

  27497.    i4 = HEAP32[(HEAP32[i4 + 28 >> 2] | 0) + (i6 << 3) >> 2] | 0;
    27498. 

  27498.    if ((i4 | 0) == 0) {
    27499. 

  27499.     i4 = 936;
    27500. 

  27500.    } else {
    27501. 

  27501.     i4 = i4 + 16 | 0;
    27502. 

  27502.    }
    27503. 

  27503.   } else {
    27504. 

  27504.    i6 = 0;
    27505. 

  27505.    STACKTOP = i2;
    27506. 

  27506.    return i6 | 0;
    27507. 

  27507.   }
    27508. 

  27508.  } while (0);
    27509. 

  27509.  i6 = i1 + 8 | 0;
    27510. 

  27510.  i5 = HEAP32[i6 >> 2] | 0;
    27511. 

  27511.  i8 = i3;
    27512. 

  27512.  i7 = HEAP32[i8 + 4 >> 2] | 0;
    27513. 

  27513.  i1 = i5;
    27514. 

  27514.  HEAP32[i1 >> 2] = HEAP32[i8 >> 2];
    27515. 

  27515.  HEAP32[i1 + 4 >> 2] = i7;
    27516. 

  27516.  HEAP32[i5 + 8 >> 2] = HEAP32[i3 + 8 >> 2];
    27517. 

  27517.  HEAP32[i6 >> 2] = (HEAP32[i6 >> 2] | 0) + 16;
    27518. 

  27518.  i6 = i4;
    27519. 

  27519.  STACKTOP = i2;
    27520. 

  27520.  return i6 | 0;
    27521. 

  27521. }
    27522. 

  27522. function _lua_copy(i1, i8, i4) {
    27523. 

  27523.  i1 = i1 | 0;
    27524. 

  27524.  i8 = i8 | 0;
    27525. 

  27525.  i4 = i4 | 0;
    27526. 

  27526.  var i2 = 0, i3 = 0, i5 = 0, i6 = 0, i7 = 0, i9 = 0;
    27527. 

  27527.  i2 = STACKTOP;
    27528. 

  27528.  i3 = i1 + 16 | 0;
    27529. 

  27529.  i6 = HEAP32[i3 >> 2] | 0;
    27530. 

  27530.  do {
    27531. 

  27531.   if ((i8 | 0) <= 0) {
    27532. 

  27532.    if (!((i8 | 0) < -1000999)) {
    27533. 

  27533.     i7 = (HEAP32[i1 + 8 >> 2] | 0) + (i8 << 4) | 0;
    27534. 

  27534.     break;
    27535. 

  27535.    }
    27536. 

  27536.    if ((i8 | 0) == -1001e3) {
    27537. 

  27537.     i7 = (HEAP32[i1 + 12 >> 2] | 0) + 40 | 0;
    27538. 

  27538.     break;
    27539. 

  27539.    }
    27540. 

  27540.    i8 = -1001e3 - i8 | 0;
    27541. 

  27541.    i9 = HEAP32[i6 >> 2] | 0;
    27542. 

  27542.    if ((HEAP32[i9 + 8 >> 2] | 0) != 22 ? (i7 = HEAP32[i9 >> 2] | 0, (i8 | 0) <= (HEAPU8[i7 + 6 | 0] | 0 | 0)) : 0) {
    27543. 

  27543.     i7 = i7 + (i8 + -1 << 4) + 16 | 0;
    27544. 

  27544.    } else {
    27545. 

  27545.     i7 = 5192;
    27546. 

  27546.    }
    27547. 

  27547.   } else {
    27548. 

  27548.    i7 = (HEAP32[i6 >> 2] | 0) + (i8 << 4) | 0;
    27549. 

  27549.    i7 = i7 >>> 0 < (HEAP32[i1 + 8 >> 2] | 0) >>> 0 ? i7 : 5192;
    27550. 

  27550.   }
    27551. 

  27551.  } while (0);
    27552. 

  27552.  do {
    27553. 

  27553.   if ((i4 | 0) <= 0) {
    27554. 

  27554.    if (!((i4 | 0) < -1000999)) {
    27555. 

  27555.     i5 = (HEAP32[i1 + 8 >> 2] | 0) + (i4 << 4) | 0;
    27556. 

  27556.     break;
    27557. 

  27557.    }
    27558. 

  27558.    if ((i4 | 0) == -1001e3) {
    27559. 

  27559.     i5 = (HEAP32[i1 + 12 >> 2] | 0) + 40 | 0;
    27560. 

  27560.     break;
    27561. 

  27561.    }
    27562. 

  27562.    i8 = -1001e3 - i4 | 0;
    27563. 

  27563.    i6 = HEAP32[i6 >> 2] | 0;
    27564. 

  27564.    if ((HEAP32[i6 + 8 >> 2] | 0) != 22 ? (i5 = HEAP32[i6 >> 2] | 0, (i8 | 0) <= (HEAPU8[i5 + 6 | 0] | 0 | 0)) : 0) {
    27565. 

  27565.     i5 = i5 + (i8 + -1 << 4) + 16 | 0;
    27566. 

  27566.    } else {
    27567. 

  27567.     i5 = 5192;
    27568. 

  27568.    }
    27569. 

  27569.   } else {
    27570. 

  27570.    i5 = (HEAP32[i6 >> 2] | 0) + (i4 << 4) | 0;
    27571. 

  27571.    i5 = i5 >>> 0 < (HEAP32[i1 + 8 >> 2] | 0) >>> 0 ? i5 : 5192;
    27572. 

  27572.   }
    27573. 

  27573.  } while (0);
    27574. 

  27574.  i8 = i7;
    27575. 

  27575.  i9 = HEAP32[i8 + 4 >> 2] | 0;
    27576. 

  27576.  i6 = i5;
    27577. 

  27577.  HEAP32[i6 >> 2] = HEAP32[i8 >> 2];
    27578. 

  27578.  HEAP32[i6 + 4 >> 2] = i9;
    27579. 

  27579.  i6 = i7 + 8 | 0;
    27580. 

  27580.  HEAP32[i5 + 8 >> 2] = HEAP32[i6 >> 2];
    27581. 

  27581.  if (!((i4 | 0) < -1001e3)) {
    27582. 

  27582.   STACKTOP = i2;
    27583. 

  27583.   return;
    27584. 

  27584.  }
    27585. 

  27585.  if ((HEAP32[i6 >> 2] & 64 | 0) == 0) {
    27586. 

  27586.   STACKTOP = i2;
    27587. 

  27587.   return;
    27588. 

  27588.  }
    27589. 

  27589.  i4 = HEAP32[i7 >> 2] | 0;
    27590. 

  27590.  if ((HEAP8[i4 + 5 | 0] & 3) == 0) {
    27591. 

  27591.   STACKTOP = i2;
    27592. 

  27592.   return;
    27593. 

  27593.  }
    27594. 

  27594.  i3 = HEAP32[HEAP32[HEAP32[i3 >> 2] >> 2] >> 2] | 0;
    27595. 

  27595.  if ((HEAP8[i3 + 5 | 0] & 4) == 0) {
    27596. 

  27596.   STACKTOP = i2;
    27597. 

  27597.   return;
    27598. 

  27598.  }
    27599. 

  27599.  _luaC_barrier_(i1, i3, i4);
    27600. 

  27600.  STACKTOP = i2;
    27601. 

  27601.  return;
    27602. 

  27602. }
    27603. 

  27603. function _lua_tolstring(i4, i5, i1) {
    27604. 

  27604.  i4 = i4 | 0;
    27605. 

  27605.  i5 = i5 | 0;
    27606. 

  27606.  i1 = i1 | 0;
    27607. 

  27607.  var i2 = 0, i3 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0;
    27608. 

  27608.  i2 = STACKTOP;
    27609. 

  27609.  i7 = i4 + 16 | 0;
    27610. 

  27610.  i10 = HEAP32[i7 >> 2] | 0;
    27611. 

  27611.  i6 = (i5 | 0) > 0;
    27612. 

  27612.  do {
    27613. 

  27613.   if (!i6) {
    27614. 

  27614.    if (!((i5 | 0) < -1000999)) {
    27615. 

  27615.     i8 = (HEAP32[i4 + 8 >> 2] | 0) + (i5 << 4) | 0;
    27616. 

  27616.     break;
    27617. 

  27617.    }
    27618. 

  27618.    if ((i5 | 0) == -1001e3) {
    27619. 

  27619.     i8 = (HEAP32[i4 + 12 >> 2] | 0) + 40 | 0;
    27620. 

  27620.     break;
    27621. 

  27621.    }
    27622. 

  27622.    i9 = -1001e3 - i5 | 0;
    27623. 

  27623.    i10 = HEAP32[i10 >> 2] | 0;
    27624. 

  27624.    if ((HEAP32[i10 + 8 >> 2] | 0) != 22 ? (i8 = HEAP32[i10 >> 2] | 0, (i9 | 0) <= (HEAPU8[i8 + 6 | 0] | 0 | 0)) : 0) {
    27625. 

  27625.     i8 = i8 + (i9 + -1 << 4) + 16 | 0;
    27626. 

  27626.    } else {
    27627. 

  27627.     i8 = 5192;
    27628. 

  27628.    }
    27629. 

  27629.   } else {
    27630. 

  27630.    i8 = (HEAP32[i10 >> 2] | 0) + (i5 << 4) | 0;
    27631. 

  27631.    i8 = i8 >>> 0 < (HEAP32[i4 + 8 >> 2] | 0) >>> 0 ? i8 : 5192;
    27632. 

  27632.   }
    27633. 

  27633.  } while (0);
    27634. 

  27634.  do {
    27635. 

  27635.   if ((HEAP32[i8 + 8 >> 2] & 15 | 0) != 4) {
    27636. 

  27636.    if ((_luaV_tostring(i4, i8) | 0) == 0) {
    27637. 

  27637.     if ((i1 | 0) == 0) {
    27638. 

  27638.      i10 = 0;
    27639. 

  27639.      STACKTOP = i2;
    27640. 

  27640.      return i10 | 0;
    27641. 

  27641.     }
    27642. 

  27642.     HEAP32[i1 >> 2] = 0;
    27643. 

  27643.     i10 = 0;
    27644. 

  27644.     STACKTOP = i2;
    27645. 

  27645.     return i10 | 0;
    27646. 

  27646.    }
    27647. 

  27647.    i8 = i4 + 12 | 0;
    27648. 

  27648.    if ((HEAP32[(HEAP32[i8 >> 2] | 0) + 12 >> 2] | 0) > 0) {
    27649. 

  27649.     _luaC_step(i4);
    27650. 

  27650.    }
    27651. 

  27651.    i7 = HEAP32[i7 >> 2] | 0;
    27652. 

  27652.    if (i6) {
    27653. 

  27653.     i3 = (HEAP32[i7 >> 2] | 0) + (i5 << 4) | 0;
    27654. 

  27654.     i8 = i3 >>> 0 < (HEAP32[i4 + 8 >> 2] | 0) >>> 0 ? i3 : 5192;
    27655. 

  27655.     break;
    27656. 

  27656.    }
    27657. 

  27657.    if (!((i5 | 0) < -1000999)) {
    27658. 

  27658.     i8 = (HEAP32[i4 + 8 >> 2] | 0) + (i5 << 4) | 0;
    27659. 

  27659.     break;
    27660. 

  27660.    }
    27661. 

  27661.    if ((i5 | 0) == -1001e3) {
    27662. 

  27662.     i8 = (HEAP32[i8 >> 2] | 0) + 40 | 0;
    27663. 

  27663.     break;
    27664. 

  27664.    }
    27665. 

  27665.    i4 = -1001e3 - i5 | 0;
    27666. 

  27666.    i5 = HEAP32[i7 >> 2] | 0;
    27667. 

  27667.    if ((HEAP32[i5 + 8 >> 2] | 0) != 22 ? (i3 = HEAP32[i5 >> 2] | 0, (i4 | 0) <= (HEAPU8[i3 + 6 | 0] | 0 | 0)) : 0) {
    27668. 

  27668.     i8 = i3 + (i4 + -1 << 4) + 16 | 0;
    27669. 

  27669.    } else {
    27670. 

  27670.     i8 = 5192;
    27671. 

  27671.    }
    27672. 

  27672.   }
    27673. 

  27673.  } while (0);
    27674. 

  27674.  i3 = HEAP32[i8 >> 2] | 0;
    27675. 

  27675.  if ((i1 | 0) != 0) {
    27676. 

  27676.   HEAP32[i1 >> 2] = HEAP32[i3 + 12 >> 2];
    27677. 

  27677.  }
    27678. 

  27678.  i10 = i3 + 16 | 0;
    27679. 

  27679.  STACKTOP = i2;
    27680. 

  27680.  return i10 | 0;
    27681. 

  27681. }
    27682. 

  27682. function _luaD_pcall(i3, i6, i5, i13, i14) {
    27683. 

  27683.  i3 = i3 | 0;
    27684. 

  27684.  i6 = i6 | 0;
    27685. 

  27685.  i5 = i5 | 0;
    27686. 

  27686.  i13 = i13 | 0;
    27687. 

  27687.  i14 = i14 | 0;
    27688. 

  27688.  var i1 = 0, i2 = 0, i4 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i15 = 0, i16 = 0, i17 = 0, i18 = 0;
    27689. 

  27689.  i1 = STACKTOP;
    27690. 

  27690.  i10 = i3 + 16 | 0;
    27691. 

  27691.  i11 = HEAP32[i10 >> 2] | 0;
    27692. 

  27692.  i12 = i3 + 41 | 0;
    27693. 

  27693.  i7 = HEAP8[i12] | 0;
    27694. 

  27694.  i9 = i3 + 36 | 0;
    27695. 

  27695.  i8 = HEAP16[i9 >> 1] | 0;
    27696. 

  27696.  i4 = i3 + 68 | 0;
    27697. 

  27697.  i2 = HEAP32[i4 >> 2] | 0;
    27698. 

  27698.  HEAP32[i4 >> 2] = i14;
    27699. 

  27699.  i5 = _luaD_rawrunprotected(i3, i6, i5) | 0;
    27700. 

  27700.  if ((i5 | 0) == 0) {
    27701. 

  27701.   HEAP32[i4 >> 2] = i2;
    27702. 

  27702.   STACKTOP = i1;
    27703. 

  27703.   return i5 | 0;
    27704. 

  27704.  }
    27705. 

  27705.  i6 = i3 + 28 | 0;
    27706. 

  27706.  i14 = HEAP32[i6 >> 2] | 0;
    27707. 

  27707.  i15 = i14 + i13 | 0;
    27708. 

  27708.  _luaF_close(i3, i15);
    27709. 

  27709.  if ((i5 | 0) == 6) {
    27710. 

  27710.   i16 = _luaS_newlstr(i3, 2424, 23) | 0;
    27711. 

  27711.   HEAP32[i15 >> 2] = i16;
    27712. 

  27712.   HEAP32[i14 + (i13 + 8) >> 2] = HEAPU8[i16 + 4 | 0] | 0 | 64;
    27713. 

  27713.  } else if ((i5 | 0) == 4) {
    27714. 

  27714.   i16 = HEAP32[(HEAP32[i3 + 12 >> 2] | 0) + 180 >> 2] | 0;
    27715. 

  27715.   HEAP32[i15 >> 2] = i16;
    27716. 

  27716.   HEAP32[i14 + (i13 + 8) >> 2] = HEAPU8[i16 + 4 | 0] | 0 | 64;
    27717. 

  27717.  } else {
    27718. 

  27718.   i16 = HEAP32[i3 + 8 >> 2] | 0;
    27719. 

  27719.   i18 = i16 + -16 | 0;
    27720. 

  27720.   i17 = HEAP32[i18 + 4 >> 2] | 0;
    27721. 

  27721.   HEAP32[i15 >> 2] = HEAP32[i18 >> 2];
    27722. 

  27722.   HEAP32[i15 + 4 >> 2] = i17;
    27723. 

  27723.   HEAP32[i14 + (i13 + 8) >> 2] = HEAP32[i16 + -8 >> 2];
    27724. 

  27724.  }
    27725. 

  27725.  i13 = i14 + (i13 + 16) | 0;
    27726. 

  27726.  HEAP32[i3 + 8 >> 2] = i13;
    27727. 

  27727.  HEAP32[i10 >> 2] = i11;
    27728. 

  27728.  HEAP8[i12] = i7;
    27729. 

  27729.  HEAP16[i9 >> 1] = i8;
    27730. 

  27730.  if ((i11 | 0) != 0) {
    27731. 

  27731.   do {
    27732. 

  27732.    i7 = HEAP32[i11 + 4 >> 2] | 0;
    27733. 

  27733.    i13 = i13 >>> 0 < i7 >>> 0 ? i7 : i13;
    27734. 

  27734.    i11 = HEAP32[i11 + 8 >> 2] | 0;
    27735. 

  27735.   } while ((i11 | 0) != 0);
    27736. 

  27736.  }
    27737. 

  27737.  i6 = i13 - (HEAP32[i6 >> 2] | 0) | 0;
    27738. 

  27738.  i7 = (i6 >> 4) + 1 | 0;
    27739. 

  27739.  i7 = ((i7 | 0) / 8 | 0) + 10 + i7 | 0;
    27740. 

  27740.  i7 = (i7 | 0) > 1e6 ? 1e6 : i7;
    27741. 

  27741.  if ((i6 | 0) > 15999984) {
    27742. 

  27742.   HEAP32[i4 >> 2] = i2;
    27743. 

  27743.   STACKTOP = i1;
    27744. 

  27744.   return i5 | 0;
    27745. 

  27745.  }
    27746. 

  27746.  if ((i7 | 0) >= (HEAP32[i3 + 32 >> 2] | 0)) {
    27747. 

  27747.   HEAP32[i4 >> 2] = i2;
    27748. 

  27748.   STACKTOP = i1;
    27749. 

  27749.   return i5 | 0;
    27750. 

  27750.  }
    27751. 

  27751.  _luaD_reallocstack(i3, i7);
    27752. 

  27752.  HEAP32[i4 >> 2] = i2;
    27753. 

  27753.  STACKTOP = i1;
    27754. 

  27754.  return i5 | 0;
    27755. 

  27755. }
    27756. 

  27756. function _luaH_resize(i1, i4, i6, i9) {
    27757. 

  27757.  i1 = i1 | 0;
    27758. 

  27758.  i4 = i4 | 0;
    27759. 

  27759.  i6 = i6 | 0;
    27760. 

  27760.  i9 = i9 | 0;
    27761. 

  27761.  var i2 = 0, i3 = 0, i5 = 0, i7 = 0, i8 = 0, i10 = 0, i11 = 0;
    27762. 

  27762.  i3 = STACKTOP;
    27763. 

  27763.  i8 = i4 + 28 | 0;
    27764. 

  27764.  i5 = HEAP32[i8 >> 2] | 0;
    27765. 

  27765.  i7 = HEAPU8[i4 + 7 | 0] | 0;
    27766. 

  27766.  i2 = HEAP32[i4 + 16 >> 2] | 0;
    27767. 

  27767.  if ((i5 | 0) < (i6 | 0)) {
    27768. 

  27768.   if ((i6 + 1 | 0) >>> 0 > 268435455) {
    27769. 

  27769.    _luaM_toobig(i1);
    27770. 

  27770.   }
    27771. 

  27771.   i11 = i4 + 12 | 0;
    27772. 

  27772.   i10 = _luaM_realloc_(i1, HEAP32[i11 >> 2] | 0, i5 << 4, i6 << 4) | 0;
    27773. 

  27773.   HEAP32[i11 >> 2] = i10;
    27774. 

  27774.   i11 = HEAP32[i8 >> 2] | 0;
    27775. 

  27775.   if ((i11 | 0) < (i6 | 0)) {
    27776. 

  27776.    do {
    27777. 

  27777.     HEAP32[i10 + (i11 << 4) + 8 >> 2] = 0;
    27778. 

  27778.     i11 = i11 + 1 | 0;
    27779. 

  27779.    } while ((i11 | 0) != (i6 | 0));
    27780. 

  27780.   }
    27781. 

  27781.   HEAP32[i8 >> 2] = i6;
    27782. 

  27782.  }
    27783. 

  27783.  _setnodevector(i1, i4, i9);
    27784. 

  27784.  do {
    27785. 

  27785.   if ((i5 | 0) > (i6 | 0)) {
    27786. 

  27786.    HEAP32[i8 >> 2] = i6;
    27787. 

  27787.    i8 = i4 + 12 | 0;
    27788. 

  27788.    i9 = i6;
    27789. 

  27789.    do {
    27790. 

  27790.     i10 = HEAP32[i8 >> 2] | 0;
    27791. 

  27791.     if ((HEAP32[i10 + (i9 << 4) + 8 >> 2] | 0) == 0) {
    27792. 

  27792.      i9 = i9 + 1 | 0;
    27793. 

  27793.     } else {
    27794. 

  27794.      i11 = i9 + 1 | 0;
    27795. 

  27795.      _luaH_setint(i1, i4, i11, i10 + (i9 << 4) | 0);
    27796. 

  27796.      i9 = i11;
    27797. 

  27797.     }
    27798. 

  27798.    } while ((i9 | 0) != (i5 | 0));
    27799. 

  27799.    if ((i6 + 1 | 0) >>> 0 > 268435455) {
    27800. 

  27800.     _luaM_toobig(i1);
    27801. 

  27801.    } else {
    27802. 

  27802.     i11 = i4 + 12 | 0;
    27803. 

  27803.     HEAP32[i11 >> 2] = _luaM_realloc_(i1, HEAP32[i11 >> 2] | 0, i5 << 4, i6 << 4) | 0;
    27804. 

  27804.     break;
    27805. 

  27805.    }
    27806. 

  27806.   }
    27807. 

  27807.  } while (0);
    27808. 

  27808.  i5 = 1 << i7;
    27809. 

  27809.  if ((i5 | 0) > 0) {
    27810. 

  27810.   i6 = i5;
    27811. 

  27811.   do {
    27812. 

  27812.    i6 = i6 + -1 | 0;
    27813. 

  27813.    i7 = i2 + (i6 << 5) + 8 | 0;
    27814. 

  27814.    if ((HEAP32[i7 >> 2] | 0) != 0) {
    27815. 

  27815.     i8 = i2 + (i6 << 5) + 16 | 0;
    27816. 

  27816.     i9 = _luaH_get(i4, i8) | 0;
    27817. 

  27817.     if ((i9 | 0) == 5192) {
    27818. 

  27818.      i9 = _luaH_newkey(i1, i4, i8) | 0;
    27819. 

  27819.     }
    27820. 

  27820.     i8 = i2 + (i6 << 5) | 0;
    27821. 

  27821.     i10 = HEAP32[i8 + 4 >> 2] | 0;
    27822. 

  27822.     i11 = i9;
    27823. 

  27823.     HEAP32[i11 >> 2] = HEAP32[i8 >> 2];
    27824. 

  27824.     HEAP32[i11 + 4 >> 2] = i10;
    27825. 

  27825.     HEAP32[i9 + 8 >> 2] = HEAP32[i7 >> 2];
    27826. 

  27826.    }
    27827. 

  27827.   } while ((i6 | 0) > 0);
    27828. 

  27828.  }
    27829. 

  27829.  if ((i2 | 0) == 8016) {
    27830. 

  27830.   STACKTOP = i3;
    27831. 

  27831.   return;
    27832. 

  27832.  }
    27833. 

  27833.  _luaM_realloc_(i1, i2, i5 << 5, 0) | 0;
    27834. 

  27834.  STACKTOP = i3;
    27835. 

  27835.  return;
    27836. 

  27836. }
    27837. 

  27837. function _codearith(i4, i3, i2, i6, i5) {
    27838. 

  27838.  i4 = i4 | 0;
    27839. 

  27839.  i3 = i3 | 0;
    27840. 

  27840.  i2 = i2 | 0;
    27841. 

  27841.  i6 = i6 | 0;
    27842. 

  27842.  i5 = i5 | 0;
    27843. 

  27843.  var i1 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, d13 = 0.0;
    27844. 

  27844.  i7 = STACKTOP;
    27845. 

  27845.  if (((((((HEAP32[i2 >> 2] | 0) == 5 ? (HEAP32[i2 + 16 >> 2] | 0) == -1 : 0) ? (HEAP32[i2 + 20 >> 2] | 0) == -1 : 0) ? (HEAP32[i6 >> 2] | 0) == 5 : 0) ? (HEAP32[i6 + 16 >> 2] | 0) == -1 : 0) ? (HEAP32[i6 + 20 >> 2] | 0) == -1 : 0) ? (d13 = +HEAPF64[i6 + 8 >> 3], !((i3 & -2 | 0) == 16 & d13 == 0.0)) : 0) {
    27846. 

  27846.   i12 = i2 + 8 | 0;
    27847. 

  27847.   HEAPF64[i12 >> 3] = +_luaO_arith(i3 + -13 | 0, +HEAPF64[i12 >> 3], d13);
    27848. 

  27848.   STACKTOP = i7;
    27849. 

  27849.   return;
    27850. 

  27850.  }
    27851. 

  27851.  if ((i3 | 0) == 19 | (i3 | 0) == 21) {
    27852. 

  27852.   i11 = 0;
    27853. 

  27853.  } else {
    27854. 

  27854.   i11 = _luaK_exp2RK(i4, i6) | 0;
    27855. 

  27855.  }
    27856. 

  27856.  i12 = _luaK_exp2RK(i4, i2) | 0;
    27857. 

  27857.  if ((i12 | 0) > (i11 | 0)) {
    27858. 

  27858.   if (((HEAP32[i2 >> 2] | 0) == 6 ? (i8 = HEAP32[i2 + 8 >> 2] | 0, (i8 & 256 | 0) == 0) : 0) ? (HEAPU8[i4 + 46 | 0] | 0 | 0) <= (i8 | 0) : 0) {
    27859. 

  27859.    i10 = i4 + 48 | 0;
    27860. 

  27860.    HEAP8[i10] = (HEAP8[i10] | 0) + -1 << 24 >> 24;
    27861. 

  27861.   }
    27862. 

  27862.   if (((HEAP32[i6 >> 2] | 0) == 6 ? (i1 = HEAP32[i6 + 8 >> 2] | 0, (i1 & 256 | 0) == 0) : 0) ? (HEAPU8[i4 + 46 | 0] | 0 | 0) <= (i1 | 0) : 0) {
    27863. 

  27863.    i10 = i4 + 48 | 0;
    27864. 

  27864.    HEAP8[i10] = (HEAP8[i10] | 0) + -1 << 24 >> 24;
    27865. 

  27865.   }
    27866. 

  27866.  } else {
    27867. 

  27867.   if (((HEAP32[i6 >> 2] | 0) == 6 ? (i10 = HEAP32[i6 + 8 >> 2] | 0, (i10 & 256 | 0) == 0) : 0) ? (HEAPU8[i4 + 46 | 0] | 0 | 0) <= (i10 | 0) : 0) {
    27868. 

  27868.    i10 = i4 + 48 | 0;
    27869. 

  27869.    HEAP8[i10] = (HEAP8[i10] | 0) + -1 << 24 >> 24;
    27870. 

  27870.   }
    27871. 

  27871.   if (((HEAP32[i2 >> 2] | 0) == 6 ? (i9 = HEAP32[i2 + 8 >> 2] | 0, (i9 & 256 | 0) == 0) : 0) ? (HEAPU8[i4 + 46 | 0] | 0 | 0) <= (i9 | 0) : 0) {
    27872. 

  27872.    i10 = i4 + 48 | 0;
    27873. 

  27873.    HEAP8[i10] = (HEAP8[i10] | 0) + -1 << 24 >> 24;
    27874. 

  27874.   }
    27875. 

  27875.  }
    27876. 

  27876.  HEAP32[i2 + 8 >> 2] = _luaK_code(i4, i11 << 14 | i3 | i12 << 23) | 0;
    27877. 

  27877.  HEAP32[i2 >> 2] = 11;
    27878. 

  27878.  HEAP32[(HEAP32[(HEAP32[i4 >> 2] | 0) + 20 >> 2] | 0) + ((HEAP32[i4 + 20 >> 2] | 0) + -1 << 2) >> 2] = i5;
    27879. 

  27879.  STACKTOP = i7;
    27880. 

  27880.  return;
    27881. 

  27881. }
    27882. 

  27882. function _GCTM(i1, i3) {
    27883. 

  27883.  i1 = i1 | 0;
    27884. 

  27884.  i3 = i3 | 0;
    27885. 

  27885.  var i2 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0, i14 = 0, i15 = 0, i16 = 0;
    27886. 

  27886.  i4 = STACKTOP;
    27887. 

  27887.  STACKTOP = STACKTOP + 32 | 0;
    27888. 

  27888.  i2 = i4 + 16 | 0;
    27889. 

  27889.  i5 = i4;
    27890. 

  27890.  i6 = HEAP32[i1 + 12 >> 2] | 0;
    27891. 

  27891.  i9 = i6 + 104 | 0;
    27892. 

  27892.  i8 = HEAP32[i9 >> 2] | 0;
    27893. 

  27893.  HEAP32[i9 >> 2] = HEAP32[i8 >> 2];
    27894. 

  27894.  i9 = i6 + 68 | 0;
    27895. 

  27895.  HEAP32[i8 >> 2] = HEAP32[i9 >> 2];
    27896. 

  27896.  HEAP32[i9 >> 2] = i8;
    27897. 

  27897.  i9 = i8 + 5 | 0;
    27898. 

  27898.  i7 = HEAPU8[i9] | 0;
    27899. 

  27899.  HEAP8[i9] = i7 & 239;
    27900. 

  27900.  if ((HEAPU8[i6 + 61 | 0] | 0) >= 2) {
    27901. 

  27901.   HEAP8[i9] = HEAP8[i6 + 60 | 0] & 3 | i7 & 168;
    27902. 

  27902.  }
    27903. 

  27903.  HEAP32[i5 >> 2] = i8;
    27904. 

  27904.  i7 = i5 + 8 | 0;
    27905. 

  27905.  HEAP32[i7 >> 2] = HEAPU8[i8 + 4 | 0] | 0 | 64;
    27906. 

  27906.  i8 = _luaT_gettmbyobj(i1, i5, 2) | 0;
    27907. 

  27907.  if ((i8 | 0) == 0) {
    27908. 

  27908.   STACKTOP = i4;
    27909. 

  27909.   return;
    27910. 

  27910.  }
    27911. 

  27911.  i9 = i8 + 8 | 0;
    27912. 

  27912.  if ((HEAP32[i9 >> 2] & 15 | 0) != 6) {
    27913. 

  27913.   STACKTOP = i4;
    27914. 

  27914.   return;
    27915. 

  27915.  }
    27916. 

  27916.  i12 = i1 + 41 | 0;
    27917. 

  27917.  i13 = HEAP8[i12] | 0;
    27918. 

  27918.  i10 = i6 + 63 | 0;
    27919. 

  27919.  i11 = HEAP8[i10] | 0;
    27920. 

  27920.  HEAP8[i12] = 0;
    27921. 

  27921.  HEAP8[i10] = 0;
    27922. 

  27922.  i6 = i1 + 8 | 0;
    27923. 

  27923.  i14 = HEAP32[i6 >> 2] | 0;
    27924. 

  27924.  i16 = i8;
    27925. 

  27925.  i15 = HEAP32[i16 + 4 >> 2] | 0;
    27926. 

  27926.  i8 = i14;
    27927. 

  27927.  HEAP32[i8 >> 2] = HEAP32[i16 >> 2];
    27928. 

  27928.  HEAP32[i8 + 4 >> 2] = i15;
    27929. 

  27929.  HEAP32[i14 + 8 >> 2] = HEAP32[i9 >> 2];
    27930. 

  27930.  i9 = HEAP32[i6 >> 2] | 0;
    27931. 

  27931.  i14 = i5;
    27932. 

  27932.  i8 = HEAP32[i14 + 4 >> 2] | 0;
    27933. 

  27933.  i5 = i9 + 16 | 0;
    27934. 

  27934.  HEAP32[i5 >> 2] = HEAP32[i14 >> 2];
    27935. 

  27935.  HEAP32[i5 + 4 >> 2] = i8;
    27936. 

  27936.  HEAP32[i9 + 24 >> 2] = HEAP32[i7 >> 2];
    27937. 

  27937.  i5 = HEAP32[i6 >> 2] | 0;
    27938. 

  27938.  HEAP32[i6 >> 2] = i5 + 32;
    27939. 

  27939.  i5 = _luaD_pcall(i1, 7, 0, i5 - (HEAP32[i1 + 28 >> 2] | 0) | 0, 0) | 0;
    27940. 

  27940.  HEAP8[i12] = i13;
    27941. 

  27941.  HEAP8[i10] = i11;
    27942. 

  27942.  if ((i5 | 0) == 0 | (i3 | 0) == 0) {
    27943. 

  27943.   STACKTOP = i4;
    27944. 

  27944.   return;
    27945. 

  27945.  }
    27946. 

  27946.  if ((i5 | 0) != 2) {
    27947. 

  27947.   i16 = i5;
    27948. 

  27948.   _luaD_throw(i1, i16);
    27949. 

  27949.  }
    27950. 

  27950.  i3 = HEAP32[i6 >> 2] | 0;
    27951. 

  27951.  if ((HEAP32[i3 + -8 >> 2] & 15 | 0) == 4) {
    27952. 

  27952.   i3 = (HEAP32[i3 + -16 >> 2] | 0) + 16 | 0;
    27953. 

  27953.  } else {
    27954. 

  27954.   i3 = 2528;
    27955. 

  27955.  }
    27956. 

  27956.  HEAP32[i2 >> 2] = i3;
    27957. 

  27957.  _luaO_pushfstring(i1, 2544, i2) | 0;
    27958. 

  27958.  i16 = 5;
    27959. 

  27959.  _luaD_throw(i1, i16);
    27960. 

  27960. }
    27961. 

  27961. function _lua_gc(i3, i5, i4) {
    27962. 

  27962.  i3 = i3 | 0;
    27963. 

  27963.  i5 = i5 | 0;
    27964. 

  27964.  i4 = i4 | 0;
    27965. 

  27965.  var i1 = 0, i2 = 0;
    27966. 

  27966.  i1 = STACKTOP;
    27967. 

  27967.  i2 = HEAP32[i3 + 12 >> 2] | 0;
    27968. 

  27968.  L1 : do {
    27969. 

  27969.   switch (i5 | 0) {
    27970. 

  27970.   case 8:
    27971. 

  27971.    {
    27972. 

  27972.     i5 = i2 + 160 | 0;
    27973. 

  27973.     i2 = HEAP32[i5 >> 2] | 0;
    27974. 

  27974.     HEAP32[i5 >> 2] = i4;
    27975. 

  27975.     break;
    27976. 

  27976.    }
    27977. 

  27977.   case 11:
    27978. 

  27978.    {
    27979. 

  27979.     _luaC_changemode(i3, 0);
    27980. 

  27980.     i2 = 0;
    27981. 

  27981.     break;
    27982. 

  27982.    }
    27983. 

  27983.   case 2:
    27984. 

  27984.    {
    27985. 

  27985.     _luaC_fullgc(i3, 0);
    27986. 

  27986.     i2 = 0;
    27987. 

  27987.     break;
    27988. 

  27988.    }
    27989. 

  27989.   case 5:
    27990. 

  27990.    {
    27991. 

  27991.     if ((HEAP8[i2 + 62 | 0] | 0) == 2) {
    27992. 

  27992.      i2 = (HEAP32[i2 + 20 >> 2] | 0) == 0 | 0;
    27993. 

  27993.      _luaC_forcestep(i3);
    27994. 

  27994.      break L1;
    27995. 

  27995.     }
    27996. 

  27996.     i4 = (i4 << 10) + -1600 | 0;
    27997. 

  27997.     if ((HEAP8[i2 + 63 | 0] | 0) == 0) {
    27998. 

  27998.      i5 = i4;
    27999. 

  27999.      _luaE_setdebt(i2, i5);
    28000. 

  28000.      _luaC_forcestep(i3);
    28001. 

  28001.      i5 = i2 + 61 | 0;
    28002. 

  28002.      i5 = HEAP8[i5] | 0;
    28003. 

  28003.      i5 = i5 << 24 >> 24 == 5;
    28004. 

  28004.      i5 = i5 & 1;
    28005. 

  28005.      STACKTOP = i1;
    28006. 

  28006.      return i5 | 0;
    28007. 

  28007.     }
    28008. 

  28008.     i5 = (HEAP32[i2 + 12 >> 2] | 0) + i4 | 0;
    28009. 

  28009.     _luaE_setdebt(i2, i5);
    28010. 

  28010.     _luaC_forcestep(i3);
    28011. 

  28011.     i5 = i2 + 61 | 0;
    28012. 

  28012.     i5 = HEAP8[i5] | 0;
    28013. 

  28013.     i5 = i5 << 24 >> 24 == 5;
    28014. 

  28014.     i5 = i5 & 1;
    28015. 

  28015.     STACKTOP = i1;
    28016. 

  28016.     return i5 | 0;
    28017. 

  28017.    }
    28018. 

  28018.   case 4:
    28019. 

  28019.    {
    28020. 

  28020.     i2 = (HEAP32[i2 + 12 >> 2] | 0) + (HEAP32[i2 + 8 >> 2] | 0) & 1023;
    28021. 

  28021.     break;
    28022. 

  28022.    }
    28023. 

  28023.   case 1:
    28024. 

  28024.    {
    28025. 

  28025.     _luaE_setdebt(i2, 0);
    28026. 

  28026.     HEAP8[i2 + 63 | 0] = 1;
    28027. 

  28027.     i2 = 0;
    28028. 

  28028.     break;
    28029. 

  28029.    }
    28030. 

  28030.   case 3:
    28031. 

  28031.    {
    28032. 

  28032.     i2 = ((HEAP32[i2 + 12 >> 2] | 0) + (HEAP32[i2 + 8 >> 2] | 0) | 0) >>> 10;
    28033. 

  28033.     break;
    28034. 

  28034.    }
    28035. 

  28035.   case 7:
    28036. 

  28036.    {
    28037. 

  28037.     i5 = i2 + 164 | 0;
    28038. 

  28038.     i2 = HEAP32[i5 >> 2] | 0;
    28039. 

  28039.     HEAP32[i5 >> 2] = i4;
    28040. 

  28040.     break;
    28041. 

  28041.    }
    28042. 

  28042.   case 0:
    28043. 

  28043.    {
    28044. 

  28044.     HEAP8[i2 + 63 | 0] = 0;
    28045. 

  28045.     i2 = 0;
    28046. 

  28046.     break;
    28047. 

  28047.    }
    28048. 

  28048.   case 6:
    28049. 

  28049.    {
    28050. 

  28050.     i5 = i2 + 156 | 0;
    28051. 

  28051.     i2 = HEAP32[i5 >> 2] | 0;
    28052. 

  28052.     HEAP32[i5 >> 2] = i4;
    28053. 

  28053.     break;
    28054. 

  28054.    }
    28055. 

  28055.   case 9:
    28056. 

  28056.    {
    28057. 

  28057.     i2 = HEAPU8[i2 + 63 | 0] | 0;
    28058. 

  28058.     break;
    28059. 

  28059.    }
    28060. 

  28060.   case 10:
    28061. 

  28061.    {
    28062. 

  28062.     _luaC_changemode(i3, 2);
    28063. 

  28063.     i2 = 0;
    28064. 

  28064.     break;
    28065. 

  28065.    }
    28066. 

  28066.   default:
    28067. 

  28067.    {
    28068. 

  28068.     i2 = -1;
    28069. 

  28069.    }
    28070. 

  28070.   }
    28071. 

  28071.  } while (0);
    28072. 

  28072.  STACKTOP = i1;
    28073. 

  28073.  return i2 | 0;
    28074. 

  28074. }
    28075. 

  28075. function _os_time(i1) {
    28076. 

  28076.  i1 = i1 | 0;
    28077. 

  28077.  var i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0;
    28078. 

  28078.  i2 = STACKTOP;
    28079. 

  28079.  STACKTOP = STACKTOP + 64 | 0;
    28080. 

  28080.  i4 = i2;
    28081. 

  28081.  i5 = i2 + 48 | 0;
    28082. 

  28082.  i3 = i2 + 4 | 0;
    28083. 

  28083.  if ((_lua_type(i1, 1) | 0) < 1) {
    28084. 

  28084.   i3 = _time(0) | 0;
    28085. 

  28085.  } else {
    28086. 

  28086.   _luaL_checktype(i1, 1, 5);
    28087. 

  28087.   _lua_settop(i1, 1);
    28088. 

  28088.   _lua_getfield(i1, -1, 5864);
    28089. 

  28089.   i6 = _lua_tointegerx(i1, -1, i4) | 0;
    28090. 

  28090.   i6 = (HEAP32[i4 >> 2] | 0) == 0 ? 0 : i6;
    28091. 

  28091.   _lua_settop(i1, -2);
    28092. 

  28092.   HEAP32[i3 >> 2] = i6;
    28093. 

  28093.   _lua_getfield(i1, -1, 5872);
    28094. 

  28094.   i6 = _lua_tointegerx(i1, -1, i4) | 0;
    28095. 

  28095.   i6 = (HEAP32[i4 >> 2] | 0) == 0 ? 0 : i6;
    28096. 

  28096.   _lua_settop(i1, -2);
    28097. 

  28097.   HEAP32[i3 + 4 >> 2] = i6;
    28098. 

  28098.   _lua_getfield(i1, -1, 5880);
    28099. 

  28099.   i6 = _lua_tointegerx(i1, -1, i4) | 0;
    28100. 

  28100.   i6 = (HEAP32[i4 >> 2] | 0) == 0 ? 12 : i6;
    28101. 

  28101.   _lua_settop(i1, -2);
    28102. 

  28102.   HEAP32[i3 + 8 >> 2] = i6;
    28103. 

  28103.   _lua_getfield(i1, -1, 5888);
    28104. 

  28104.   i6 = _lua_tointegerx(i1, -1, i5) | 0;
    28105. 

  28105.   if ((HEAP32[i5 >> 2] | 0) == 0) {
    28106. 

  28106.    HEAP32[i4 >> 2] = 5888;
    28107. 

  28107.    i6 = _luaL_error(i1, 5920, i4) | 0;
    28108. 

  28108.   } else {
    28109. 

  28109.    _lua_settop(i1, -2);
    28110. 

  28110.   }
    28111. 

  28111.   HEAP32[i3 + 12 >> 2] = i6;
    28112. 

  28112.   _lua_getfield(i1, -1, 5896);
    28113. 

  28113.   i6 = _lua_tointegerx(i1, -1, i5) | 0;
    28114. 

  28114.   if ((HEAP32[i5 >> 2] | 0) == 0) {
    28115. 

  28115.    HEAP32[i4 >> 2] = 5896;
    28116. 

  28116.    i6 = _luaL_error(i1, 5920, i4) | 0;
    28117. 

  28117.   } else {
    28118. 

  28118.    _lua_settop(i1, -2);
    28119. 

  28119.   }
    28120. 

  28120.   HEAP32[i3 + 16 >> 2] = i6 + -1;
    28121. 

  28121.   _lua_getfield(i1, -1, 5904);
    28122. 

  28122.   i6 = _lua_tointegerx(i1, -1, i5) | 0;
    28123. 

  28123.   if ((HEAP32[i5 >> 2] | 0) == 0) {
    28124. 

  28124.    HEAP32[i4 >> 2] = 5904;
    28125. 

  28125.    i6 = _luaL_error(i1, 5920, i4) | 0;
    28126. 

  28126.   } else {
    28127. 

  28127.    _lua_settop(i1, -2);
    28128. 

  28128.   }
    28129. 

  28129.   HEAP32[i3 + 20 >> 2] = i6 + -1900;
    28130. 

  28130.   _lua_getfield(i1, -1, 5912);
    28131. 

  28131.   if ((_lua_type(i1, -1) | 0) == 0) {
    28132. 

  28132.    i4 = -1;
    28133. 

  28133.   } else {
    28134. 

  28134.    i4 = _lua_toboolean(i1, -1) | 0;
    28135. 

  28135.   }
    28136. 

  28136.   _lua_settop(i1, -2);
    28137. 

  28137.   HEAP32[i3 + 32 >> 2] = i4;
    28138. 

  28138.   i3 = _mktime(i3 | 0) | 0;
    28139. 

  28139.  }
    28140. 

  28140.  if ((i3 | 0) == -1) {
    28141. 

  28141.   _lua_pushnil(i1);
    28142. 

  28142.   STACKTOP = i2;
    28143. 

  28143.   return 1;
    28144. 

  28144.  } else {
    28145. 

  28145.   _lua_pushnumber(i1, +(i3 | 0));
    28146. 

  28146.   STACKTOP = i2;
    28147. 

  28147.   return 1;
    28148. 

  28148.  }
    28149. 

  28149.  return 0;
    28150. 

  28150. }
    28151. 

  28151. function _addk(i6, i4, i3) {
    28152. 

  28152.  i6 = i6 | 0;
    28153. 

  28153.  i4 = i4 | 0;
    28154. 

  28154.  i3 = i3 | 0;
    28155. 

  28155.  var i1 = 0, i2 = 0, i5 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0;
    28156. 

  28156.  i1 = STACKTOP;
    28157. 

  28157.  STACKTOP = STACKTOP + 16 | 0;
    28158. 

  28158.  i10 = i1;
    28159. 

  28159.  i2 = HEAP32[(HEAP32[i6 + 12 >> 2] | 0) + 52 >> 2] | 0;
    28160. 

  28160.  i8 = _luaH_set(i2, HEAP32[i6 + 4 >> 2] | 0, i4) | 0;
    28161. 

  28161.  i4 = HEAP32[i6 >> 2] | 0;
    28162. 

  28162.  i9 = i8 + 8 | 0;
    28163. 

  28163.  if (((HEAP32[i9 >> 2] | 0) == 3 ? (HEAPF64[i10 >> 3] = +HEAPF64[i8 >> 3] + 6755399441055744.0, i7 = HEAP32[i10 >> 2] | 0, i5 = HEAP32[i4 + 8 >> 2] | 0, (HEAP32[i5 + (i7 << 4) + 8 >> 2] | 0) == (HEAP32[i3 + 8 >> 2] | 0)) : 0) ? (_luaV_equalobj_(0, i5 + (i7 << 4) | 0, i3) | 0) != 0 : 0) {
    28164. 

  28164.   i10 = i7;
    28165. 

  28165.   STACKTOP = i1;
    28166. 

  28166.   return i10 | 0;
    28167. 

  28167.  }
    28168. 

  28168.  i5 = i4 + 44 | 0;
    28169. 

  28169.  i10 = HEAP32[i5 >> 2] | 0;
    28170. 

  28170.  i7 = i6 + 32 | 0;
    28171. 

  28171.  i6 = HEAP32[i7 >> 2] | 0;
    28172. 

  28172.  HEAPF64[i8 >> 3] = +(i6 | 0);
    28173. 

  28173.  HEAP32[i9 >> 2] = 3;
    28174. 

  28174.  i9 = HEAP32[i5 >> 2] | 0;
    28175. 

  28175.  if ((i6 | 0) >= (i9 | 0)) {
    28176. 

  28176.   i9 = i4 + 8 | 0;
    28177. 

  28177.   HEAP32[i9 >> 2] = _luaM_growaux_(i2, HEAP32[i9 >> 2] | 0, i5, 16, 67108863, 10600) | 0;
    28178. 

  28178.   i9 = HEAP32[i5 >> 2] | 0;
    28179. 

  28179.  }
    28180. 

  28180.  i8 = HEAP32[i4 + 8 >> 2] | 0;
    28181. 

  28181.  if ((i10 | 0) < (i9 | 0)) {
    28182. 

  28182.   while (1) {
    28183. 

  28183.    i9 = i10 + 1 | 0;
    28184. 

  28184.    HEAP32[i8 + (i10 << 4) + 8 >> 2] = 0;
    28185. 

  28185.    if ((i9 | 0) < (HEAP32[i5 >> 2] | 0)) {
    28186. 

  28186.     i10 = i9;
    28187. 

  28187.    } else {
    28188. 

  28188.     break;
    28189. 

  28189.    }
    28190. 

  28190.   }
    28191. 

  28191.  }
    28192. 

  28192.  i5 = i3;
    28193. 

  28193.  i9 = HEAP32[i5 + 4 >> 2] | 0;
    28194. 

  28194.  i10 = i8 + (i6 << 4) | 0;
    28195. 

  28195.  HEAP32[i10 >> 2] = HEAP32[i5 >> 2];
    28196. 

  28196.  HEAP32[i10 + 4 >> 2] = i9;
    28197. 

  28197.  i10 = i3 + 8 | 0;
    28198. 

  28198.  HEAP32[i8 + (i6 << 4) + 8 >> 2] = HEAP32[i10 >> 2];
    28199. 

  28199.  HEAP32[i7 >> 2] = (HEAP32[i7 >> 2] | 0) + 1;
    28200. 

  28200.  if ((HEAP32[i10 >> 2] & 64 | 0) == 0) {
    28201. 

  28201.   i10 = i6;
    28202. 

  28202.   STACKTOP = i1;
    28203. 

  28203.   return i10 | 0;
    28204. 

  28204.  }
    28205. 

  28205.  i3 = HEAP32[i3 >> 2] | 0;
    28206. 

  28206.  if ((HEAP8[i3 + 5 | 0] & 3) == 0) {
    28207. 

  28207.   i10 = i6;
    28208. 

  28208.   STACKTOP = i1;
    28209. 

  28209.   return i10 | 0;
    28210. 

  28210.  }
    28211. 

  28211.  if ((HEAP8[i4 + 5 | 0] & 4) == 0) {
    28212. 

  28212.   i10 = i6;
    28213. 

  28213.   STACKTOP = i1;
    28214. 

  28214.   return i10 | 0;
    28215. 

  28215.  }
    28216. 

  28216.  _luaC_barrier_(i2, i4, i3);
    28217. 

  28217.  i10 = i6;
    28218. 

  28218.  STACKTOP = i1;
    28219. 

  28219.  return i10 | 0;
    28220. 

  28220. }
    28221. 

  28221. function _singlevaraux(i5, i4, i2, i11) {
    28222. 

  28222.  i5 = i5 | 0;
    28223. 

  28223.  i4 = i4 | 0;
    28224. 

  28224.  i2 = i2 | 0;
    28225. 

  28225.  i11 = i11 | 0;
    28226. 

  28226.  var i1 = 0, i3 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0;
    28227. 

  28227.  i1 = STACKTOP;
    28228. 

  28228.  if ((i5 | 0) == 0) {
    28229. 

  28229.   i11 = 0;
    28230. 

  28230.   STACKTOP = i1;
    28231. 

  28231.   return i11 | 0;
    28232. 

  28232.  }
    28233. 

  28233.  i7 = i5 + 12 | 0;
    28234. 

  28234.  i8 = i5 + 40 | 0;
    28235. 

  28235.  i9 = HEAPU8[i5 + 46 | 0] | 0;
    28236. 

  28236.  while (1) {
    28237. 

  28237.   i6 = i9 + -1 | 0;
    28238. 

  28238.   i10 = HEAP32[i5 >> 2] | 0;
    28239. 

  28239.   if ((i9 | 0) <= 0) {
    28240. 

  28240.    break;
    28241. 

  28241.   }
    28242. 

  28242.   if ((_luaS_eqstr(i4, HEAP32[(HEAP32[i10 + 24 >> 2] | 0) + ((HEAP16[(HEAP32[HEAP32[(HEAP32[i7 >> 2] | 0) + 64 >> 2] >> 2] | 0) + ((HEAP32[i8 >> 2] | 0) + i6 << 1) >> 1] | 0) * 12 | 0) >> 2] | 0) | 0) == 0) {
    28243. 

  28243.    i9 = i6;
    28244. 

  28244.   } else {
    28245. 

  28245.    i3 = 5;
    28246. 

  28246.    break;
    28247. 

  28247.   }
    28248. 

  28248.  }
    28249. 

  28249.  if ((i3 | 0) == 5) {
    28250. 

  28250.   HEAP32[i2 + 16 >> 2] = -1;
    28251. 

  28251.   HEAP32[i2 + 20 >> 2] = -1;
    28252. 

  28252.   HEAP32[i2 >> 2] = 7;
    28253. 

  28253.   HEAP32[i2 + 8 >> 2] = i6;
    28254. 

  28254.   if ((i11 | 0) != 0) {
    28255. 

  28255.    i11 = 7;
    28256. 

  28256.    STACKTOP = i1;
    28257. 

  28257.    return i11 | 0;
    28258. 

  28258.   }
    28259. 

  28259.   i2 = i5 + 16 | 0;
    28260. 

  28260.   do {
    28261. 

  28261.    i2 = HEAP32[i2 >> 2] | 0;
    28262. 

  28262.   } while ((HEAPU8[i2 + 8 | 0] | 0) > (i6 | 0));
    28263. 

  28263.   HEAP8[i2 + 9 | 0] = 1;
    28264. 

  28264.   i11 = 7;
    28265. 

  28265.   STACKTOP = i1;
    28266. 

  28266.   return i11 | 0;
    28267. 

  28267.  }
    28268. 

  28268.  i7 = HEAP32[i10 + 28 >> 2] | 0;
    28269. 

  28269.  i6 = i5 + 47 | 0;
    28270. 

  28270.  L17 : do {
    28271. 

  28271.   if ((HEAP8[i6] | 0) != 0) {
    28272. 

  28272.    i8 = 0;
    28273. 

  28273.    while (1) {
    28274. 

  28274.     i9 = i8 + 1 | 0;
    28275. 

  28275.     if ((_luaS_eqstr(HEAP32[i7 + (i8 << 3) >> 2] | 0, i4) | 0) != 0) {
    28276. 

  28276.      break;
    28277. 

  28277.     }
    28278. 

  28278.     if ((i9 | 0) < (HEAPU8[i6] | 0)) {
    28279. 

  28279.      i8 = i9;
    28280. 

  28280.     } else {
    28281. 

  28281.      i3 = 13;
    28282. 

  28282.      break L17;
    28283. 

  28283.     }
    28284. 

  28284.    }
    28285. 

  28285.    if ((i8 | 0) < 0) {
    28286. 

  28286.     i3 = 13;
    28287. 

  28287.    }
    28288. 

  28288.   } else {
    28289. 

  28289.    i3 = 13;
    28290. 

  28290.   }
    28291. 

  28291.  } while (0);
    28292. 

  28292.  do {
    28293. 

  28293.   if ((i3 | 0) == 13) {
    28294. 

  28294.    if ((_singlevaraux(HEAP32[i5 + 8 >> 2] | 0, i4, i2, 0) | 0) == 0) {
    28295. 

  28295.     i11 = 0;
    28296. 

  28296.     STACKTOP = i1;
    28297. 

  28297.     return i11 | 0;
    28298. 

  28298.    } else {
    28299. 

  28299.     i8 = _newupvalue(i5, i4, i2) | 0;
    28300. 

  28300.     break;
    28301. 

  28301.    }
    28302. 

  28302.   }
    28303. 

  28303.  } while (0);
    28304. 

  28304.  HEAP32[i2 + 16 >> 2] = -1;
    28305. 

  28305.  HEAP32[i2 + 20 >> 2] = -1;
    28306. 

  28306.  HEAP32[i2 >> 2] = 8;
    28307. 

  28307.  HEAP32[i2 + 8 >> 2] = i8;
    28308. 

  28308.  i11 = 8;
    28309. 

  28309.  STACKTOP = i1;
    28310. 

  28310.  return i11 | 0;
    28311. 

  28311. }
    28312. 

  28312. function _mainposition(i1, i3) {
    28313. 

  28313.  i1 = i1 | 0;
    28314. 

  28314.  i3 = i3 | 0;
    28315. 

  28315.  var i2 = 0, i4 = 0, i5 = 0, i6 = 0;
    28316. 

  28316.  i2 = STACKTOP;
    28317. 

  28317.  STACKTOP = STACKTOP + 16 | 0;
    28318. 

  28318.  i4 = i2;
    28319. 

  28319.  switch (HEAP32[i3 + 8 >> 2] & 63 | 0) {
    28320. 

  28320.  case 3:
    28321. 

  28321.   {
    28322. 

  28322.    HEAPF64[i4 >> 3] = +HEAPF64[i3 >> 3] + 1.0;
    28323. 

  28323.    i3 = (HEAP32[i4 + 4 >> 2] | 0) + (HEAP32[i4 >> 2] | 0) | 0;
    28324. 

  28324.    if ((i3 | 0) < 0) {
    28325. 

  28325.     i4 = 0 - i3 | 0;
    28326. 

  28326.     i3 = (i3 | 0) == (i4 | 0) ? 0 : i4;
    28327. 

  28327.    }
    28328. 

  28328.    i5 = (HEAP32[i1 + 16 >> 2] | 0) + (((i3 | 0) % ((1 << HEAPU8[i1 + 7 | 0]) + -1 | 1 | 0) | 0) << 5) | 0;
    28329. 

  28329.    STACKTOP = i2;
    28330. 

  28330.    return i5 | 0;
    28331. 

  28331.   }
    28332. 

  28332.  case 2:
    28333. 

  28333.   {
    28334. 

  28334.    i5 = (HEAP32[i1 + 16 >> 2] | 0) + ((((HEAP32[i3 >> 2] | 0) >>> 0) % (((1 << HEAPU8[i1 + 7 | 0]) + -1 | 1) >>> 0) | 0) << 5) | 0;
    28335. 

  28335.    STACKTOP = i2;
    28336. 

  28336.    return i5 | 0;
    28337. 

  28337.   }
    28338. 

  28338.  case 20:
    28339. 

  28339.   {
    28340. 

  28340.    i5 = HEAP32[i3 >> 2] | 0;
    28341. 

  28341.    i4 = i5 + 6 | 0;
    28342. 

  28342.    if ((HEAP8[i4] | 0) == 0) {
    28343. 

  28343.     i6 = i5 + 8 | 0;
    28344. 

  28344.     HEAP32[i6 >> 2] = _luaS_hash(i5 + 16 | 0, HEAP32[i5 + 12 >> 2] | 0, HEAP32[i6 >> 2] | 0) | 0;
    28345. 

  28345.     HEAP8[i4] = 1;
    28346. 

  28346.     i5 = HEAP32[i3 >> 2] | 0;
    28347. 

  28347.    }
    28348. 

  28348.    i6 = (HEAP32[i1 + 16 >> 2] | 0) + (((1 << HEAPU8[i1 + 7 | 0]) + -1 & HEAP32[i5 + 8 >> 2]) << 5) | 0;
    28349. 

  28349.    STACKTOP = i2;
    28350. 

  28350.    return i6 | 0;
    28351. 

  28351.   }
    28352. 

  28352.  case 22:
    28353. 

  28353.   {
    28354. 

  28354.    i6 = (HEAP32[i1 + 16 >> 2] | 0) + ((((HEAP32[i3 >> 2] | 0) >>> 0) % (((1 << HEAPU8[i1 + 7 | 0]) + -1 | 1) >>> 0) | 0) << 5) | 0;
    28355. 

  28355.    STACKTOP = i2;
    28356. 

  28356.    return i6 | 0;
    28357. 

  28357.   }
    28358. 

  28358.  case 4:
    28359. 

  28359.   {
    28360. 

  28360.    i6 = (HEAP32[i1 + 16 >> 2] | 0) + (((1 << HEAPU8[i1 + 7 | 0]) + -1 & HEAP32[(HEAP32[i3 >> 2] | 0) + 8 >> 2]) << 5) | 0;
    28361. 

  28361.    STACKTOP = i2;
    28362. 

  28362.    return i6 | 0;
    28363. 

  28363.   }
    28364. 

  28364.  case 1:
    28365. 

  28365.   {
    28366. 

  28366.    i6 = (HEAP32[i1 + 16 >> 2] | 0) + (((1 << HEAPU8[i1 + 7 | 0]) + -1 & HEAP32[i3 >> 2]) << 5) | 0;
    28367. 

  28367.    STACKTOP = i2;
    28368. 

  28368.    return i6 | 0;
    28369. 

  28369.   }
    28370. 

  28370.  default:
    28371. 

  28371.   {
    28372. 

  28372.    i6 = (HEAP32[i1 + 16 >> 2] | 0) + ((((HEAP32[i3 >> 2] | 0) >>> 0) % (((1 << HEAPU8[i1 + 7 | 0]) + -1 | 1) >>> 0) | 0) << 5) | 0;
    28373. 

  28373.    STACKTOP = i2;
    28374. 

  28374.    return i6 | 0;
    28375. 

  28375.   }
    28376. 

  28376.  }
    28377. 

  28377.  return 0;
    28378. 

  28378. }
    28379. 

  28379. function _clearvalues(i2, i5, i1) {
    28380. 

  28380.  i2 = i2 | 0;
    28381. 

  28381.  i5 = i5 | 0;
    28382. 

  28382.  i1 = i1 | 0;
    28383. 

  28383.  var i3 = 0, i4 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0;
    28384. 

  28384.  i4 = STACKTOP;
    28385. 

  28385.  if ((i5 | 0) == (i1 | 0)) {
    28386. 

  28386.   STACKTOP = i4;
    28387. 

  28387.   return;
    28388. 

  28388.  }
    28389. 

  28389.  do {
    28390. 

  28390.   i7 = i5 + 16 | 0;
    28391. 

  28391.   i9 = HEAP32[i7 >> 2] | 0;
    28392. 

  28392.   i6 = i9 + (1 << (HEAPU8[i5 + 7 | 0] | 0) << 5) | 0;
    28393. 

  28393.   i8 = i5 + 28 | 0;
    28394. 

  28394.   if ((HEAP32[i8 >> 2] | 0) > 0) {
    28395. 

  28395.    i11 = i5 + 12 | 0;
    28396. 

  28396.    i12 = 0;
    28397. 

  28397.    do {
    28398. 

  28398.     i13 = HEAP32[i11 >> 2] | 0;
    28399. 

  28399.     i10 = i13 + (i12 << 4) + 8 | 0;
    28400. 

  28400.     i9 = HEAP32[i10 >> 2] | 0;
    28401. 

  28401.     do {
    28402. 

  28402.      if ((i9 & 64 | 0) != 0) {
    28403. 

  28403.       i13 = HEAP32[i13 + (i12 << 4) >> 2] | 0;
    28404. 

  28404.       if ((i9 & 15 | 0) != 4) {
    28405. 

  28405.        if ((HEAP8[i13 + 5 | 0] & 3) == 0) {
    28406. 

  28406.         break;
    28407. 

  28407.        }
    28408. 

  28408.        HEAP32[i10 >> 2] = 0;
    28409. 

  28409.        break;
    28410. 

  28410.       }
    28411. 

  28411.       if ((i13 | 0) != 0 ? !((HEAP8[i13 + 5 | 0] & 3) == 0) : 0) {
    28412. 

  28412.        _reallymarkobject(i2, i13);
    28413. 

  28413.       }
    28414. 

  28414.      }
    28415. 

  28415.     } while (0);
    28416. 

  28416.     i12 = i12 + 1 | 0;
    28417. 

  28417.    } while ((i12 | 0) < (HEAP32[i8 >> 2] | 0));
    28418. 

  28418.    i7 = HEAP32[i7 >> 2] | 0;
    28419. 

  28419.   } else {
    28420. 

  28420.    i7 = i9;
    28421. 

  28421.   }
    28422. 

  28422.   if (i7 >>> 0 < i6 >>> 0) {
    28423. 

  28423.    do {
    28424. 

  28424.     i8 = i7 + 8 | 0;
    28425. 

  28425.     i9 = HEAP32[i8 >> 2] | 0;
    28426. 

  28426.     do {
    28427. 

  28427.      if (!((i9 | 0) == 0 | (i9 & 64 | 0) == 0)) {
    28428. 

  28428.       i10 = HEAP32[i7 >> 2] | 0;
    28429. 

  28429.       if ((i9 & 15 | 0) == 4) {
    28430. 

  28430.        if ((i10 | 0) == 0) {
    28431. 

  28431.         break;
    28432. 

  28432.        }
    28433. 

  28433.        if ((HEAP8[i10 + 5 | 0] & 3) == 0) {
    28434. 

  28434.         break;
    28435. 

  28435.        }
    28436. 

  28436.        _reallymarkobject(i2, i10);
    28437. 

  28437.        break;
    28438. 

  28438.       }
    28439. 

  28439.       if ((!((HEAP8[i10 + 5 | 0] & 3) == 0) ? (HEAP32[i8 >> 2] = 0, i3 = i7 + 24 | 0, (HEAP32[i3 >> 2] & 64 | 0) != 0) : 0) ? !((HEAP8[(HEAP32[i7 + 16 >> 2] | 0) + 5 | 0] & 3) == 0) : 0) {
    28440. 

  28440.        HEAP32[i3 >> 2] = 11;
    28441. 

  28441.       }
    28442. 

  28442.      }
    28443. 

  28443.     } while (0);
    28444. 

  28444.     i7 = i7 + 32 | 0;
    28445. 

  28445.    } while (i7 >>> 0 < i6 >>> 0);
    28446. 

  28446.   }
    28447. 

  28447.   i5 = HEAP32[i5 + 24 >> 2] | 0;
    28448. 

  28448.  } while ((i5 | 0) != (i1 | 0));
    28449. 

  28449.  STACKTOP = i4;
    28450. 

  28450.  return;
    28451. 

  28451. }
    28452. 

  28452. function _reallymarkobject(i1, i4) {
    28453. 

  28453.  i1 = i1 | 0;
    28454. 

  28454.  i4 = i4 | 0;
    28455. 

  28455.  var i2 = 0, i3 = 0, i5 = 0, i6 = 0, i7 = 0;
    28456. 

  28456.  i3 = STACKTOP;
    28457. 

  28457.  i2 = i4 + 5 | 0;
    28458. 

  28458.  HEAP8[i2] = HEAP8[i2] & 252;
    28459. 

  28459.  switch (HEAPU8[i4 + 4 | 0] | 0 | 0) {
    28460. 

  28460.  case 6:
    28461. 

  28461.   {
    28462. 

  28462.    i7 = i1 + 84 | 0;
    28463. 

  28463.    HEAP32[i4 + 8 >> 2] = HEAP32[i7 >> 2];
    28464. 

  28464.    HEAP32[i7 >> 2] = i4;
    28465. 

  28465.    STACKTOP = i3;
    28466. 

  28466.    return;
    28467. 

  28467.   }
    28468. 

  28468.  case 20:
    28469. 

  28469.  case 4:
    28470. 

  28470.   {
    28471. 

  28471.    i4 = (HEAP32[i4 + 12 >> 2] | 0) + 17 | 0;
    28472. 

  28472.    break;
    28473. 

  28473.   }
    28474. 

  28474.  case 7:
    28475. 

  28475.   {
    28476. 

  28476.    i5 = HEAP32[i4 + 8 >> 2] | 0;
    28477. 

  28477.    if ((i5 | 0) != 0 ? !((HEAP8[i5 + 5 | 0] & 3) == 0) : 0) {
    28478. 

  28478.     _reallymarkobject(i1, i5);
    28479. 

  28479.    }
    28480. 

  28480.    i5 = HEAP32[i4 + 12 >> 2] | 0;
    28481. 

  28481.    if ((i5 | 0) != 0 ? !((HEAP8[i5 + 5 | 0] & 3) == 0) : 0) {
    28482. 

  28482.     _reallymarkobject(i1, i5);
    28483. 

  28483.    }
    28484. 

  28484.    i4 = (HEAP32[i4 + 16 >> 2] | 0) + 24 | 0;
    28485. 

  28485.    break;
    28486. 

  28486.   }
    28487. 

  28487.  case 8:
    28488. 

  28488.   {
    28489. 

  28489.    i7 = i1 + 84 | 0;
    28490. 

  28490.    HEAP32[i4 + 60 >> 2] = HEAP32[i7 >> 2];
    28491. 

  28491.    HEAP32[i7 >> 2] = i4;
    28492. 

  28492.    STACKTOP = i3;
    28493. 

  28493.    return;
    28494. 

  28494.   }
    28495. 

  28495.  case 10:
    28496. 

  28496.   {
    28497. 

  28497.    i6 = i4 + 8 | 0;
    28498. 

  28498.    i7 = HEAP32[i6 >> 2] | 0;
    28499. 

  28499.    if ((HEAP32[i7 + 8 >> 2] & 64 | 0) != 0 ? (i5 = HEAP32[i7 >> 2] | 0, !((HEAP8[i5 + 5 | 0] & 3) == 0)) : 0) {
    28500. 

  28500.     _reallymarkobject(i1, i5);
    28501. 

  28501.     i7 = HEAP32[i6 >> 2] | 0;
    28502. 

  28502.    }
    28503. 

  28503.    if ((i7 | 0) == (i4 + 16 | 0)) {
    28504. 

  28504.     i4 = 32;
    28505. 

  28505.    } else {
    28506. 

  28506.     STACKTOP = i3;
    28507. 

  28507.     return;
    28508. 

  28508.    }
    28509. 

  28509.    break;
    28510. 

  28510.   }
    28511. 

  28511.  case 5:
    28512. 

  28512.   {
    28513. 

  28513.    i7 = i1 + 84 | 0;
    28514. 

  28514.    HEAP32[i4 + 24 >> 2] = HEAP32[i7 >> 2];
    28515. 

  28515.    HEAP32[i7 >> 2] = i4;
    28516. 

  28516.    STACKTOP = i3;
    28517. 

  28517.    return;
    28518. 

  28518.   }
    28519. 

  28519.  case 38:
    28520. 

  28520.   {
    28521. 

  28521.    i7 = i1 + 84 | 0;
    28522. 

  28522.    HEAP32[i4 + 8 >> 2] = HEAP32[i7 >> 2];
    28523. 

  28523.    HEAP32[i7 >> 2] = i4;
    28524. 

  28524.    STACKTOP = i3;
    28525. 

  28525.    return;
    28526. 

  28526.   }
    28527. 

  28527.  case 9:
    28528. 

  28528.   {
    28529. 

  28529.    i7 = i1 + 84 | 0;
    28530. 

  28530.    HEAP32[i4 + 72 >> 2] = HEAP32[i7 >> 2];
    28531. 

  28531.    HEAP32[i7 >> 2] = i4;
    28532. 

  28532.    STACKTOP = i3;
    28533. 

  28533.    return;
    28534. 

  28534.   }
    28535. 

  28535.  default:
    28536. 

  28536.   {
    28537. 

  28537.    STACKTOP = i3;
    28538. 

  28538.    return;
    28539. 

  28539.   }
    28540. 

  28540.  }
    28541. 

  28541.  HEAP8[i2] = HEAPU8[i2] | 0 | 4;
    28542. 

  28542.  i7 = i1 + 16 | 0;
    28543. 

  28543.  HEAP32[i7 >> 2] = (HEAP32[i7 >> 2] | 0) + i4;
    28544. 

  28544.  STACKTOP = i3;
    28545. 

  28545.  return;
    28546. 

  28546. }
    28547. 

  28547. function _lua_upvaluejoin(i1, i9, i7, i6, i3) {
    28548. 

  28548.  i1 = i1 | 0;
    28549. 

  28549.  i9 = i9 | 0;
    28550. 

  28550.  i7 = i7 | 0;
    28551. 

  28551.  i6 = i6 | 0;
    28552. 

  28552.  i3 = i3 | 0;
    28553. 

  28553.  var i2 = 0, i4 = 0, i5 = 0, i8 = 0, i10 = 0;
    28554. 

  28554.  i2 = STACKTOP;
    28555. 

  28555.  i5 = HEAP32[i1 + 16 >> 2] | 0;
    28556. 

  28556.  do {
    28557. 

  28557.   if ((i9 | 0) <= 0) {
    28558. 

  28558.    if (!((i9 | 0) < -1000999)) {
    28559. 

  28559.     i8 = (HEAP32[i1 + 8 >> 2] | 0) + (i9 << 4) | 0;
    28560. 

  28560.     break;
    28561. 

  28561.    }
    28562. 

  28562.    if ((i9 | 0) == -1001e3) {
    28563. 

  28563.     i8 = (HEAP32[i1 + 12 >> 2] | 0) + 40 | 0;
    28564. 

  28564.     break;
    28565. 

  28565.    }
    28566. 

  28566.    i10 = -1001e3 - i9 | 0;
    28567. 

  28567.    i9 = HEAP32[i5 >> 2] | 0;
    28568. 

  28568.    if ((HEAP32[i9 + 8 >> 2] | 0) != 22 ? (i8 = HEAP32[i9 >> 2] | 0, (i10 | 0) <= (HEAPU8[i8 + 6 | 0] | 0 | 0)) : 0) {
    28569. 

  28569.     i8 = i8 + (i10 + -1 << 4) + 16 | 0;
    28570. 

  28570.    } else {
    28571. 

  28571.     i8 = 5192;
    28572. 

  28572.    }
    28573. 

  28573.   } else {
    28574. 

  28574.    i8 = (HEAP32[i5 >> 2] | 0) + (i9 << 4) | 0;
    28575. 

  28575.    i8 = i8 >>> 0 < (HEAP32[i1 + 8 >> 2] | 0) >>> 0 ? i8 : 5192;
    28576. 

  28576.   }
    28577. 

  28577.  } while (0);
    28578. 

  28578.  i8 = HEAP32[i8 >> 2] | 0;
    28579. 

  28579.  i7 = i8 + 16 + (i7 + -1 << 2) | 0;
    28580. 

  28580.  do {
    28581. 

  28581.   if ((i6 | 0) <= 0) {
    28582. 

  28582.    if (!((i6 | 0) < -1000999)) {
    28583. 

  28583.     i4 = (HEAP32[i1 + 8 >> 2] | 0) + (i6 << 4) | 0;
    28584. 

  28584.     break;
    28585. 

  28585.    }
    28586. 

  28586.    if ((i6 | 0) == -1001e3) {
    28587. 

  28587.     i4 = (HEAP32[i1 + 12 >> 2] | 0) + 40 | 0;
    28588. 

  28588.     break;
    28589. 

  28589.    }
    28590. 

  28590.    i6 = -1001e3 - i6 | 0;
    28591. 

  28591.    i5 = HEAP32[i5 >> 2] | 0;
    28592. 

  28592.    if ((HEAP32[i5 + 8 >> 2] | 0) != 22 ? (i4 = HEAP32[i5 >> 2] | 0, (i6 | 0) <= (HEAPU8[i4 + 6 | 0] | 0 | 0)) : 0) {
    28593. 

  28593.     i4 = i4 + (i6 + -1 << 4) + 16 | 0;
    28594. 

  28594.    } else {
    28595. 

  28595.     i4 = 5192;
    28596. 

  28596.    }
    28597. 

  28597.   } else {
    28598. 

  28598.    i4 = (HEAP32[i5 >> 2] | 0) + (i6 << 4) | 0;
    28599. 

  28599.    i4 = i4 >>> 0 < (HEAP32[i1 + 8 >> 2] | 0) >>> 0 ? i4 : 5192;
    28600. 

  28600.   }
    28601. 

  28601.  } while (0);
    28602. 

  28602.  i3 = (HEAP32[i4 >> 2] | 0) + 16 + (i3 + -1 << 2) | 0;
    28603. 

  28603.  HEAP32[i7 >> 2] = HEAP32[i3 >> 2];
    28604. 

  28604.  i3 = HEAP32[i3 >> 2] | 0;
    28605. 

  28605.  if ((HEAP8[i3 + 5 | 0] & 3) == 0) {
    28606. 

  28606.   STACKTOP = i2;
    28607. 

  28607.   return;
    28608. 

  28608.  }
    28609. 

  28609.  if ((HEAP8[i8 + 5 | 0] & 4) == 0) {
    28610. 

  28610.   STACKTOP = i2;
    28611. 

  28611.   return;
    28612. 

  28612.  }
    28613. 

  28613.  _luaC_barrier_(i1, i8, i3);
    28614. 

  28614.  STACKTOP = i2;
    28615. 

  28615.  return;
    28616. 

  28616. }
    28617. 

  28617. function _lua_upvalueid(i5, i7, i1) {
    28618. 

  28618.  i5 = i5 | 0;
    28619. 

  28619.  i7 = i7 | 0;
    28620. 

  28620.  i1 = i1 | 0;
    28621. 

  28621.  var i2 = 0, i3 = 0, i4 = 0, i6 = 0, i8 = 0, i9 = 0, i10 = 0;
    28622. 

  28622.  i2 = STACKTOP;
    28623. 

  28623.  i4 = HEAP32[i5 + 16 >> 2] | 0;
    28624. 

  28624.  i6 = (i7 | 0) > 0;
    28625. 

  28625.  do {
    28626. 

  28626.   if (!i6) {
    28627. 

  28627.    if (!((i7 | 0) < -1000999)) {
    28628. 

  28628.     i8 = (HEAP32[i5 + 8 >> 2] | 0) + (i7 << 4) | 0;
    28629. 

  28629.     break;
    28630. 

  28630.    }
    28631. 

  28631.    if ((i7 | 0) == -1001e3) {
    28632. 

  28632.     i8 = (HEAP32[i5 + 12 >> 2] | 0) + 40 | 0;
    28633. 

  28633.     break;
    28634. 

  28634.    }
    28635. 

  28635.    i10 = -1001e3 - i7 | 0;
    28636. 

  28636.    i9 = HEAP32[i4 >> 2] | 0;
    28637. 

  28637.    if ((HEAP32[i9 + 8 >> 2] | 0) != 22 ? (i8 = HEAP32[i9 >> 2] | 0, (i10 | 0) <= (HEAPU8[i8 + 6 | 0] | 0 | 0)) : 0) {
    28638. 

  28638.     i8 = i8 + (i10 + -1 << 4) + 16 | 0;
    28639. 

  28639.    } else {
    28640. 

  28640.     i8 = 5192;
    28641. 

  28641.    }
    28642. 

  28642.   } else {
    28643. 

  28643.    i8 = (HEAP32[i4 >> 2] | 0) + (i7 << 4) | 0;
    28644. 

  28644.    i8 = i8 >>> 0 < (HEAP32[i5 + 8 >> 2] | 0) >>> 0 ? i8 : 5192;
    28645. 

  28645.   }
    28646. 

  28646.  } while (0);
    28647. 

  28647.  i9 = HEAP32[i8 + 8 >> 2] & 63;
    28648. 

  28648.  if ((i9 | 0) == 38) {
    28649. 

  28649.   i10 = (HEAP32[i8 >> 2] | 0) + (i1 + -1 << 4) + 16 | 0;
    28650. 

  28650.   STACKTOP = i2;
    28651. 

  28651.   return i10 | 0;
    28652. 

  28652.  } else if ((i9 | 0) == 6) {
    28653. 

  28653.   do {
    28654. 

  28654.    if (!i6) {
    28655. 

  28655.     if (!((i7 | 0) < -1000999)) {
    28656. 

  28656.      i3 = (HEAP32[i5 + 8 >> 2] | 0) + (i7 << 4) | 0;
    28657. 

  28657.      break;
    28658. 

  28658.     }
    28659. 

  28659.     if ((i7 | 0) == -1001e3) {
    28660. 

  28660.      i3 = (HEAP32[i5 + 12 >> 2] | 0) + 40 | 0;
    28661. 

  28661.      break;
    28662. 

  28662.     }
    28663. 

  28663.     i5 = -1001e3 - i7 | 0;
    28664. 

  28664.     i4 = HEAP32[i4 >> 2] | 0;
    28665. 

  28665.     if ((HEAP32[i4 + 8 >> 2] | 0) != 22 ? (i3 = HEAP32[i4 >> 2] | 0, (i5 | 0) <= (HEAPU8[i3 + 6 | 0] | 0 | 0)) : 0) {
    28666. 

  28666.      i3 = i3 + (i5 + -1 << 4) + 16 | 0;
    28667. 

  28667.     } else {
    28668. 

  28668.      i3 = 5192;
    28669. 

  28669.     }
    28670. 

  28670.    } else {
    28671. 

  28671.     i3 = (HEAP32[i4 >> 2] | 0) + (i7 << 4) | 0;
    28672. 

  28672.     i3 = i3 >>> 0 < (HEAP32[i5 + 8 >> 2] | 0) >>> 0 ? i3 : 5192;
    28673. 

  28673.    }
    28674. 

  28674.   } while (0);
    28675. 

  28675.   i10 = HEAP32[(HEAP32[i3 >> 2] | 0) + 16 + (i1 + -1 << 2) >> 2] | 0;
    28676. 

  28676.   STACKTOP = i2;
    28677. 

  28677.   return i10 | 0;
    28678. 

  28678.  } else {
    28679. 

  28679.   i10 = 0;
    28680. 

  28680.   STACKTOP = i2;
    28681. 

  28681.   return i10 | 0;
    28682. 

  28682.  }
    28683. 

  28683.  return 0;
    28684. 

  28684. }
    28685. 

  28685. function _lua_rawequal(i2, i6, i4) {
    28686. 

  28686.  i2 = i2 | 0;
    28687. 

  28687.  i6 = i6 | 0;
    28688. 

  28688.  i4 = i4 | 0;
    28689. 

  28689.  var i1 = 0, i3 = 0, i5 = 0, i7 = 0;
    28690. 

  28690.  i1 = STACKTOP;
    28691. 

  28691.  i3 = HEAP32[i2 + 16 >> 2] | 0;
    28692. 

  28692.  do {
    28693. 

  28693.   if ((i6 | 0) <= 0) {
    28694. 

  28694.    if (!((i6 | 0) < -1000999)) {
    28695. 

  28695.     i5 = (HEAP32[i2 + 8 >> 2] | 0) + (i6 << 4) | 0;
    28696. 

  28696.     break;
    28697. 

  28697.    }
    28698. 

  28698.    if ((i6 | 0) == -1001e3) {
    28699. 

  28699.     i5 = (HEAP32[i2 + 12 >> 2] | 0) + 40 | 0;
    28700. 

  28700.     break;
    28701. 

  28701.    }
    28702. 

  28702.    i7 = -1001e3 - i6 | 0;
    28703. 

  28703.    i6 = HEAP32[i3 >> 2] | 0;
    28704. 

  28704.    if ((HEAP32[i6 + 8 >> 2] | 0) != 22 ? (i5 = HEAP32[i6 >> 2] | 0, (i7 | 0) <= (HEAPU8[i5 + 6 | 0] | 0 | 0)) : 0) {
    28705. 

  28705.     i5 = i5 + (i7 + -1 << 4) + 16 | 0;
    28706. 

  28706.    } else {
    28707. 

  28707.     i5 = 5192;
    28708. 

  28708.    }
    28709. 

  28709.   } else {
    28710. 

  28710.    i5 = (HEAP32[i3 >> 2] | 0) + (i6 << 4) | 0;
    28711. 

  28711.    i5 = i5 >>> 0 < (HEAP32[i2 + 8 >> 2] | 0) >>> 0 ? i5 : 5192;
    28712. 

  28712.   }
    28713. 

  28713.  } while (0);
    28714. 

  28714.  do {
    28715. 

  28715.   if ((i4 | 0) <= 0) {
    28716. 

  28716.    if (!((i4 | 0) < -1000999)) {
    28717. 

  28717.     i2 = (HEAP32[i2 + 8 >> 2] | 0) + (i4 << 4) | 0;
    28718. 

  28718.     break;
    28719. 

  28719.    }
    28720. 

  28720.    if ((i4 | 0) == -1001e3) {
    28721. 

  28721.     i2 = (HEAP32[i2 + 12 >> 2] | 0) + 40 | 0;
    28722. 

  28722.     break;
    28723. 

  28723.    }
    28724. 

  28724.    i2 = -1001e3 - i4 | 0;
    28725. 

  28725.    i3 = HEAP32[i3 >> 2] | 0;
    28726. 

  28726.    if ((HEAP32[i3 + 8 >> 2] | 0) == 22) {
    28727. 

  28727.     i7 = 0;
    28728. 

  28728.     STACKTOP = i1;
    28729. 

  28729.     return i7 | 0;
    28730. 

  28730.    }
    28731. 

  28731.    i3 = HEAP32[i3 >> 2] | 0;
    28732. 

  28732.    if ((i2 | 0) > (HEAPU8[i3 + 6 | 0] | 0 | 0)) {
    28733. 

  28733.     i7 = 0;
    28734. 

  28734.     STACKTOP = i1;
    28735. 

  28735.     return i7 | 0;
    28736. 

  28736.    } else {
    28737. 

  28737.     i2 = i3 + (i2 + -1 << 4) + 16 | 0;
    28738. 

  28738.     break;
    28739. 

  28739.    }
    28740. 

  28740.   } else {
    28741. 

  28741.    i3 = (HEAP32[i3 >> 2] | 0) + (i4 << 4) | 0;
    28742. 

  28742.    i2 = i3 >>> 0 < (HEAP32[i2 + 8 >> 2] | 0) >>> 0 ? i3 : 5192;
    28743. 

  28743.   }
    28744. 

  28744.  } while (0);
    28745. 

  28745.  if ((i5 | 0) == 5192 | (i2 | 0) == 5192) {
    28746. 

  28746.   i7 = 0;
    28747. 

  28747.   STACKTOP = i1;
    28748. 

  28748.   return i7 | 0;
    28749. 

  28749.  }
    28750. 

  28750.  if ((HEAP32[i5 + 8 >> 2] | 0) == (HEAP32[i2 + 8 >> 2] | 0)) {
    28751. 

  28751.   i2 = (_luaV_equalobj_(0, i5, i2) | 0) != 0;
    28752. 

  28752.  } else {
    28753. 

  28753.   i2 = 0;
    28754. 

  28754.  }
    28755. 

  28755.  i7 = i2 & 1;
    28756. 

  28756.  STACKTOP = i1;
    28757. 

  28757.  return i7 | 0;
    28758. 

  28758. }
    28759. 

  28759. function _luaO_chunkid(i1, i4, i6) {
    28760. 

  28760.  i1 = i1 | 0;
    28761. 

  28761.  i4 = i4 | 0;
    28762. 

  28762.  i6 = i6 | 0;
    28763. 

  28763.  var i2 = 0, i3 = 0, i5 = 0, i7 = 0, i8 = 0, i9 = 0;
    28764. 

  28764.  i2 = STACKTOP;
    28765. 

  28765.  i3 = _strlen(i4 | 0) | 0;
    28766. 

  28766.  i5 = HEAP8[i4] | 0;
    28767. 

  28767.  if (i5 << 24 >> 24 == 64) {
    28768. 

  28768.   if (i3 >>> 0 > i6 >>> 0) {
    28769. 

  28769.    HEAP8[i1 + 0 | 0] = HEAP8[5552 | 0] | 0;
    28770. 

  28770.    HEAP8[i1 + 1 | 0] = HEAP8[5553 | 0] | 0;
    28771. 

  28771.    HEAP8[i1 + 2 | 0] = HEAP8[5554 | 0] | 0;
    28772. 

  28772.    _memcpy(i1 + 3 | 0, i4 + (4 - i6 + i3) | 0, i6 + -3 | 0) | 0;
    28773. 

  28773.    STACKTOP = i2;
    28774. 

  28774.    return;
    28775. 

  28775.   } else {
    28776. 

  28776.    _memcpy(i1 | 0, i4 + 1 | 0, i3 | 0) | 0;
    28777. 

  28777.    STACKTOP = i2;
    28778. 

  28778.    return;
    28779. 

  28779.   }
    28780. 

  28780.  } else if (i5 << 24 >> 24 == 61) {
    28781. 

  28781.   i4 = i4 + 1 | 0;
    28782. 

  28782.   if (i3 >>> 0 > i6 >>> 0) {
    28783. 

  28783.    i9 = i6 + -1 | 0;
    28784. 

  28784.    _memcpy(i1 | 0, i4 | 0, i9 | 0) | 0;
    28785. 

  28785.    HEAP8[i1 + i9 | 0] = 0;
    28786. 

  28786.    STACKTOP = i2;
    28787. 

  28787.    return;
    28788. 

  28788.   } else {
    28789. 

  28789.    _memcpy(i1 | 0, i4 | 0, i3 | 0) | 0;
    28790. 

  28790.    STACKTOP = i2;
    28791. 

  28791.    return;
    28792. 

  28792.   }
    28793. 

  28793.  } else {
    28794. 

  28794.   i5 = _strchr(i4, 10) | 0;
    28795. 

  28795.   i9 = i1 + 0 | 0;
    28796. 

  28796.   i8 = 5560 | 0;
    28797. 

  28797.   i7 = i9 + 9 | 0;
    28798. 

  28798.   do {
    28799. 

  28799.    HEAP8[i9] = HEAP8[i8] | 0;
    28800. 

  28800.    i9 = i9 + 1 | 0;
    28801. 

  28801.    i8 = i8 + 1 | 0;
    28802. 

  28802.   } while ((i9 | 0) < (i7 | 0));
    28803. 

  28803.   i7 = i1 + 9 | 0;
    28804. 

  28804.   i6 = i6 + -15 | 0;
    28805. 

  28805.   i8 = (i5 | 0) == 0;
    28806. 

  28806.   if (i3 >>> 0 < i6 >>> 0 & i8) {
    28807. 

  28807.    _memcpy(i7 | 0, i4 | 0, i3 | 0) | 0;
    28808. 

  28808.    i3 = i3 + 9 | 0;
    28809. 

  28809.   } else {
    28810. 

  28810.    if (!i8) {
    28811. 

  28811.     i3 = i5 - i4 | 0;
    28812. 

  28812.    }
    28813. 

  28813.    i3 = i3 >>> 0 > i6 >>> 0 ? i6 : i3;
    28814. 

  28814.    _memcpy(i7 | 0, i4 | 0, i3 | 0) | 0;
    28815. 

  28815.    i9 = i1 + (i3 + 9) | 0;
    28816. 

  28816.    HEAP8[i9 + 0 | 0] = HEAP8[5552 | 0] | 0;
    28817. 

  28817.    HEAP8[i9 + 1 | 0] = HEAP8[5553 | 0] | 0;
    28818. 

  28818.    HEAP8[i9 + 2 | 0] = HEAP8[5554 | 0] | 0;
    28819. 

  28819.    i3 = i3 + 12 | 0;
    28820. 

  28820.   }
    28821. 

  28821.   i9 = i1 + i3 | 0;
    28822. 

  28822.   HEAP8[i9 + 0 | 0] = HEAP8[5576 | 0] | 0;
    28823. 

  28823.   HEAP8[i9 + 1 | 0] = HEAP8[5577 | 0] | 0;
    28824. 

  28824.   HEAP8[i9 + 2 | 0] = HEAP8[5578 | 0] | 0;
    28825. 

  28825.   STACKTOP = i2;
    28826. 

  28826.   return;
    28827. 

  28827.  }
    28828. 

  28828. }
    28829. 

  28829. function _luaS_resize(i4, i1) {
    28830. 

  28830.  i4 = i4 | 0;
    28831. 

  28831.  i1 = i1 | 0;
    28832. 

  28832.  var i2 = 0, i3 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0;
    28833. 

  28833.  i3 = STACKTOP;
    28834. 

  28834.  i5 = HEAP32[i4 + 12 >> 2] | 0;
    28835. 

  28835.  i2 = i5 + 24 | 0;
    28836. 

  28836.  _luaC_runtilstate(i4, -5);
    28837. 

  28837.  i5 = i5 + 32 | 0;
    28838. 

  28838.  i8 = HEAP32[i5 >> 2] | 0;
    28839. 

  28839.  L1 : do {
    28840. 

  28840.   if ((i8 | 0) < (i1 | 0)) {
    28841. 

  28841.    if ((i1 + 1 | 0) >>> 0 > 1073741823) {
    28842. 

  28842.     _luaM_toobig(i4);
    28843. 

  28843.    }
    28844. 

  28844.    i7 = _luaM_realloc_(i4, HEAP32[i2 >> 2] | 0, i8 << 2, i1 << 2) | 0;
    28845. 

  28845.    HEAP32[i2 >> 2] = i7;
    28846. 

  28846.    i6 = HEAP32[i5 >> 2] | 0;
    28847. 

  28847.    if ((i6 | 0) < (i1 | 0)) {
    28848. 

  28848.     i8 = i6;
    28849. 

  28849.     while (1) {
    28850. 

  28850.      HEAP32[i7 + (i8 << 2) >> 2] = 0;
    28851. 

  28851.      i8 = i8 + 1 | 0;
    28852. 

  28852.      if ((i8 | 0) == (i1 | 0)) {
    28853. 

  28853.       i8 = i6;
    28854. 

  28854.       break L1;
    28855. 

  28855.      }
    28856. 

  28856.      i7 = HEAP32[i2 >> 2] | 0;
    28857. 

  28857.     }
    28858. 

  28858.    } else {
    28859. 

  28859.     i8 = i6;
    28860. 

  28860.    }
    28861. 

  28861.   }
    28862. 

  28862.  } while (0);
    28863. 

  28863.  if ((i8 | 0) > 0) {
    28864. 

  28864.   i6 = i1 + -1 | 0;
    28865. 

  28865.   i7 = 0;
    28866. 

  28866.   do {
    28867. 

  28867.    i10 = (HEAP32[i2 >> 2] | 0) + (i7 << 2) | 0;
    28868. 

  28868.    i9 = HEAP32[i10 >> 2] | 0;
    28869. 

  28869.    HEAP32[i10 >> 2] = 0;
    28870. 

  28870.    if ((i9 | 0) != 0) {
    28871. 

  28871.     while (1) {
    28872. 

  28872.      i8 = HEAP32[i9 >> 2] | 0;
    28873. 

  28873.      i10 = HEAP32[i9 + 8 >> 2] & i6;
    28874. 

  28874.      HEAP32[i9 >> 2] = HEAP32[(HEAP32[i2 >> 2] | 0) + (i10 << 2) >> 2];
    28875. 

  28875.      HEAP32[(HEAP32[i2 >> 2] | 0) + (i10 << 2) >> 2] = i9;
    28876. 

  28876.      i10 = i9 + 5 | 0;
    28877. 

  28877.      HEAP8[i10] = HEAP8[i10] & 191;
    28878. 

  28878.      if ((i8 | 0) == 0) {
    28879. 

  28879.       break;
    28880. 

  28880.      } else {
    28881. 

  28881.       i9 = i8;
    28882. 

  28882.      }
    28883. 

  28883.     }
    28884. 

  28884.     i8 = HEAP32[i5 >> 2] | 0;
    28885. 

  28885.    }
    28886. 

  28886.    i7 = i7 + 1 | 0;
    28887. 

  28887.   } while ((i7 | 0) < (i8 | 0));
    28888. 

  28888.  }
    28889. 

  28889.  if ((i8 | 0) <= (i1 | 0)) {
    28890. 

  28890.   HEAP32[i5 >> 2] = i1;
    28891. 

  28891.   STACKTOP = i3;
    28892. 

  28892.   return;
    28893. 

  28893.  }
    28894. 

  28894.  if ((i1 + 1 | 0) >>> 0 > 1073741823) {
    28895. 

  28895.   _luaM_toobig(i4);
    28896. 

  28896.  }
    28897. 

  28897.  HEAP32[i2 >> 2] = _luaM_realloc_(i4, HEAP32[i2 >> 2] | 0, i8 << 2, i1 << 2) | 0;
    28898. 

  28898.  HEAP32[i5 >> 2] = i1;
    28899. 

  28899.  STACKTOP = i3;
    28900. 

  28900.  return;
    28901. 

  28901. }
    28902. 

  28902. function _luaD_poscall(i6, i7) {
    28903. 

  28903.  i6 = i6 | 0;
    28904. 

  28904.  i7 = i7 | 0;
    28905. 

  28905.  var i1 = 0, i2 = 0, i3 = 0, i4 = 0, i5 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0;
    28906. 

  28906.  i1 = STACKTOP;
    28907. 

  28907.  i4 = i6 + 16 | 0;
    28908. 

  28908.  i3 = HEAP32[i4 >> 2] | 0;
    28909. 

  28909.  i5 = HEAPU8[i6 + 40 | 0] | 0;
    28910. 

  28910.  if ((i5 & 6 | 0) == 0) {
    28911. 

  28911.   i8 = i3 + 8 | 0;
    28912. 

  28912.  } else {
    28913. 

  28913.   if ((i5 & 2 | 0) != 0) {
    28914. 

  28914.    i8 = i6 + 28 | 0;
    28915. 

  28915.    i7 = i7 - (HEAP32[i8 >> 2] | 0) | 0;
    28916. 

  28916.    _luaD_hook(i6, 1, -1);
    28917. 

  28917.    i7 = (HEAP32[i8 >> 2] | 0) + i7 | 0;
    28918. 

  28918.   }
    28919. 

  28919.   i8 = i3 + 8 | 0;
    28920. 

  28920.   HEAP32[i6 + 20 >> 2] = HEAP32[(HEAP32[i8 >> 2] | 0) + 28 >> 2];
    28921. 

  28921.  }
    28922. 

  28922.  i5 = HEAP32[i3 >> 2] | 0;
    28923. 

  28923.  i9 = HEAP16[i3 + 16 >> 1] | 0;
    28924. 

  28924.  i3 = i9 << 16 >> 16;
    28925. 

  28925.  HEAP32[i4 >> 2] = HEAP32[i8 >> 2];
    28926. 

  28926.  i4 = i6 + 8 | 0;
    28927. 

  28927.  if (i9 << 16 >> 16 == 0) {
    28928. 

  28928.   i9 = i5;
    28929. 

  28929.   HEAP32[i4 >> 2] = i9;
    28930. 

  28930.   i9 = i3 + 1 | 0;
    28931. 

  28931.   STACKTOP = i1;
    28932. 

  28932.   return i9 | 0;
    28933. 

  28933.  } else {
    28934. 

  28934.   i6 = i3;
    28935. 

  28935.  }
    28936. 

  28936.  while (1) {
    28937. 

  28937.   if (!(i7 >>> 0 < (HEAP32[i4 >> 2] | 0) >>> 0)) {
    28938. 

  28938.    break;
    28939. 

  28939.   }
    28940. 

  28940.   i8 = i5 + 16 | 0;
    28941. 

  28941.   i11 = i7;
    28942. 

  28942.   i10 = HEAP32[i11 + 4 >> 2] | 0;
    28943. 

  28943.   i9 = i5;
    28944. 

  28944.   HEAP32[i9 >> 2] = HEAP32[i11 >> 2];
    28945. 

  28945.   HEAP32[i9 + 4 >> 2] = i10;
    28946. 

  28946.   HEAP32[i5 + 8 >> 2] = HEAP32[i7 + 8 >> 2];
    28947. 

  28947.   i6 = i6 + -1 | 0;
    28948. 

  28948.   if ((i6 | 0) == 0) {
    28949. 

  28949.    i2 = 12;
    28950. 

  28950.    break;
    28951. 

  28951.   } else {
    28952. 

  28952.    i7 = i7 + 16 | 0;
    28953. 

  28953.    i5 = i8;
    28954. 

  28954.   }
    28955. 

  28955.  }
    28956. 

  28956.  if ((i2 | 0) == 12) {
    28957. 

  28957.   HEAP32[i4 >> 2] = i8;
    28958. 

  28958.   i11 = i3 + 1 | 0;
    28959. 

  28959.   STACKTOP = i1;
    28960. 

  28960.   return i11 | 0;
    28961. 

  28961.  }
    28962. 

  28962.  if ((i6 | 0) > 0) {
    28963. 

  28963.   i2 = i6;
    28964. 

  28964.   i7 = i5;
    28965. 

  28965.  } else {
    28966. 

  28966.   i11 = i5;
    28967. 

  28967.   HEAP32[i4 >> 2] = i11;
    28968. 

  28968.   i11 = i3 + 1 | 0;
    28969. 

  28969.   STACKTOP = i1;
    28970. 

  28970.   return i11 | 0;
    28971. 

  28971.  }
    28972. 

  28972.  while (1) {
    28973. 

  28973.   i2 = i2 + -1 | 0;
    28974. 

  28974.   HEAP32[i7 + 8 >> 2] = 0;
    28975. 

  28975.   if ((i2 | 0) <= 0) {
    28976. 

  28976.    break;
    28977. 

  28977.   } else {
    28978. 

  28978.    i7 = i7 + 16 | 0;
    28979. 

  28979.   }
    28980. 

  28980.  }
    28981. 

  28981.  i11 = i5 + (i6 << 4) | 0;
    28982. 

  28982.  HEAP32[i4 >> 2] = i11;
    28983. 

  28983.  i11 = i3 + 1 | 0;
    28984. 

  28984.  STACKTOP = i1;
    28985. 

  28985.  return i11 | 0;
    28986. 

  28986. }
    28987. 

  28987. function _lua_rawset(i1, i4) {
    28988. 

  28988.  i1 = i1 | 0;
    28989. 

  28989.  i4 = i4 | 0;
    28990. 

  28990.  var i2 = 0, i3 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0;
    28991. 

  28991.  i2 = STACKTOP;
    28992. 

  28992.  i5 = HEAP32[i1 + 16 >> 2] | 0;
    28993. 

  28993.  do {
    28994. 

  28994.   if ((i4 | 0) <= 0) {
    28995. 

  28995.    if (!((i4 | 0) < -1000999)) {
    28996. 

  28996.     i5 = (HEAP32[i1 + 8 >> 2] | 0) + (i4 << 4) | 0;
    28997. 

  28997.     break;
    28998. 

  28998.    }
    28999. 

  28999.    if ((i4 | 0) == -1001e3) {
    29000. 

  29000.     i5 = (HEAP32[i1 + 12 >> 2] | 0) + 40 | 0;
    29001. 

  29001.     break;
    29002. 

  29002.    }
    29003. 

  29003.    i4 = -1001e3 - i4 | 0;
    29004. 

  29004.    i5 = HEAP32[i5 >> 2] | 0;
    29005. 

  29005.    if ((HEAP32[i5 + 8 >> 2] | 0) != 22 ? (i3 = HEAP32[i5 >> 2] | 0, (i4 | 0) <= (HEAPU8[i3 + 6 | 0] | 0 | 0)) : 0) {
    29006. 

  29006.     i5 = i3 + (i4 + -1 << 4) + 16 | 0;
    29007. 

  29007.    } else {
    29008. 

  29008.     i5 = 5192;
    29009. 

  29009.    }
    29010. 

  29010.   } else {
    29011. 

  29011.    i3 = (HEAP32[i5 >> 2] | 0) + (i4 << 4) | 0;
    29012. 

  29012.    i5 = i3 >>> 0 < (HEAP32[i1 + 8 >> 2] | 0) >>> 0 ? i3 : 5192;
    29013. 

  29013.   }
    29014. 

  29014.  } while (0);
    29015. 

  29015.  i4 = i1 + 8 | 0;
    29016. 

  29016.  i6 = HEAP32[i4 >> 2] | 0;
    29017. 

  29017.  i3 = _luaH_set(i1, HEAP32[i5 >> 2] | 0, i6 + -32 | 0) | 0;
    29018. 

  29018.  i9 = i6 + -16 | 0;
    29019. 

  29019.  i8 = HEAP32[i9 + 4 >> 2] | 0;
    29020. 

  29020.  i7 = i3;
    29021. 

  29021.  HEAP32[i7 >> 2] = HEAP32[i9 >> 2];
    29022. 

  29022.  HEAP32[i7 + 4 >> 2] = i8;
    29023. 

  29023.  HEAP32[i3 + 8 >> 2] = HEAP32[i6 + -8 >> 2];
    29024. 

  29024.  HEAP8[(HEAP32[i5 >> 2] | 0) + 6 | 0] = 0;
    29025. 

  29025.  i3 = HEAP32[i4 >> 2] | 0;
    29026. 

  29026.  if ((HEAP32[i3 + -8 >> 2] & 64 | 0) == 0) {
    29027. 

  29027.   i9 = i3;
    29028. 

  29028.   i9 = i9 + -32 | 0;
    29029. 

  29029.   HEAP32[i4 >> 2] = i9;
    29030. 

  29030.   STACKTOP = i2;
    29031. 

  29031.   return;
    29032. 

  29032.  }
    29033. 

  29033.  if ((HEAP8[(HEAP32[i3 + -16 >> 2] | 0) + 5 | 0] & 3) == 0) {
    29034. 

  29034.   i9 = i3;
    29035. 

  29035.   i9 = i9 + -32 | 0;
    29036. 

  29036.   HEAP32[i4 >> 2] = i9;
    29037. 

  29037.   STACKTOP = i2;
    29038. 

  29038.   return;
    29039. 

  29039.  }
    29040. 

  29040.  i5 = HEAP32[i5 >> 2] | 0;
    29041. 

  29041.  if ((HEAP8[i5 + 5 | 0] & 4) == 0) {
    29042. 

  29042.   i9 = i3;
    29043. 

  29043.   i9 = i9 + -32 | 0;
    29044. 

  29044.   HEAP32[i4 >> 2] = i9;
    29045. 

  29045.   STACKTOP = i2;
    29046. 

  29046.   return;
    29047. 

  29047.  }
    29048. 

  29048.  _luaC_barrierback_(i1, i5);
    29049. 

  29049.  i9 = HEAP32[i4 >> 2] | 0;
    29050. 

  29050.  i9 = i9 + -32 | 0;
    29051. 

  29051.  HEAP32[i4 >> 2] = i9;
    29052. 

  29052.  STACKTOP = i2;
    29053. 

  29053.  return;
    29054. 

  29054. }
    29055. 

  29055. function _saveSetjmp(i4, i3, i1) {
    29056. 

  29056.  i4 = i4 | 0;
    29057. 

  29057.  i3 = i3 | 0;
    29058. 

  29058.  i1 = i1 | 0;
    29059. 

  29059.  var i2 = 0;
    29060. 

  29060.  setjmpId = setjmpId + 1 | 0;
    29061. 

  29061.  HEAP32[i4 >> 2] = setjmpId;
    29062. 

  29062.  while ((i2 | 0) < 40) {
    29063. 

  29063.   if ((HEAP32[i1 + (i2 << 2) >> 2] | 0) == 0) {
    29064. 

  29064.    HEAP32[i1 + (i2 << 2) >> 2] = setjmpId;
    29065. 

  29065.    HEAP32[i1 + ((i2 << 2) + 4) >> 2] = i3;
    29066. 

  29066.    HEAP32[i1 + ((i2 << 2) + 8) >> 2] = 0;
    29067. 

  29067.    return 0;
    29068. 

  29068.   }
    29069. 

  29069.   i2 = i2 + 2 | 0;
    29070. 

  29070.  }
    29071. 

  29071.  _putchar(116);
    29072. 

  29072.  _putchar(111);
    29073. 

  29073.  _putchar(111);
    29074. 

  29074.  _putchar(32);
    29075. 

  29075.  _putchar(109);
    29076. 

  29076.  _putchar(97);
    29077. 

  29077.  _putchar(110);
    29078. 

  29078.  _putchar(121);
    29079. 

  29079.  _putchar(32);
    29080. 

  29080.  _putchar(115);
    29081. 

  29081.  _putchar(101);
    29082. 

  29082.  _putchar(116);
    29083. 

  29083.  _putchar(106);
    29084. 

  29084.  _putchar(109);
    29085. 

  29085.  _putchar(112);
    29086. 

  29086.  _putchar(115);
    29087. 

  29087.  _putchar(32);
    29088. 

  29088.  _putchar(105);
    29089. 

  29089.  _putchar(110);
    29090. 

  29090.  _putchar(32);
    29091. 

  29091.  _putchar(97);
    29092. 

  29092.  _putchar(32);
    29093. 

  29093.  _putchar(102);
    29094. 

  29094.  _putchar(117);
    29095. 

  29095.  _putchar(110);
    29096. 

  29096.  _putchar(99);
    29097. 

  29097.  _putchar(116);
    29098. 

  29098.  _putchar(105);
    29099. 

  29099.  _putchar(111);
    29100. 

  29100.  _putchar(110);
    29101. 

  29101.  _putchar(32);
    29102. 

  29102.  _putchar(99);
    29103. 

  29103.  _putchar(97);
    29104. 

  29104.  _putchar(108);
    29105. 

  29105.  _putchar(108);
    29106. 

  29106.  _putchar(44);
    29107. 

  29107.  _putchar(32);
    29108. 

  29108.  _putchar(98);
    29109. 

  29109.  _putchar(117);
    29110. 

  29110.  _putchar(105);
    29111. 

  29111.  _putchar(108);
    29112. 

  29112.  _putchar(100);
    29113. 

  29113.  _putchar(32);
    29114. 

  29114.  _putchar(119);
    29115. 

  29115.  _putchar(105);
    29116. 

  29116.  _putchar(116);
    29117. 

  29117.  _putchar(104);
    29118. 

  29118.  _putchar(32);
    29119. 

  29119.  _putchar(97);
    29120. 

  29120.  _putchar(32);
    29121. 

  29121.  _putchar(104);
    29122. 

  29122.  _putchar(105);
    29123. 

  29123.  _putchar(103);
    29124. 

  29124.  _putchar(104);
    29125. 

  29125.  _putchar(101);
    29126. 

  29126.  _putchar(114);
    29127. 

  29127.  _putchar(32);
    29128. 

  29128.  _putchar(118);
    29129. 

  29129.  _putchar(97);
    29130. 

  29130.  _putchar(108);
    29131. 

  29131.  _putchar(117);
    29132. 

  29132.  _putchar(101);
    29133. 

  29133.  _putchar(32);
    29134. 

  29134.  _putchar(102);
    29135. 

  29135.  _putchar(111);
    29136. 

  29136.  _putchar(114);
    29137. 

  29137.  _putchar(32);
    29138. 

  29138.  _putchar(77);
    29139. 

  29139.  _putchar(65);
    29140. 

  29140.  _putchar(88);
    29141. 

  29141.  _putchar(95);
    29142. 

  29142.  _putchar(83);
    29143. 

  29143.  _putchar(69);
    29144. 

  29144.  _putchar(84);
    29145. 

  29145.  _putchar(74);
    29146. 

  29146.  _putchar(77);
    29147. 

  29147.  _putchar(80);
    29148. 

  29148.  _putchar(83);
    29149. 

  29149.  _putchar(10);
    29150. 

  29150.  abort(0);
    29151. 

  29151.  return 0;
    29152. 

  29152. }
    29153. 

  29153. function _lua_newthread(i5) {
    29154. 

  29154.  i5 = i5 | 0;
    29155. 

  29155.  var i1 = 0, i2 = 0, i3 = 0, i4 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0;
    29156. 

  29156.  i1 = STACKTOP;
    29157. 

  29157.  i3 = i5 + 12 | 0;
    29158. 

  29158.  if ((HEAP32[(HEAP32[i3 >> 2] | 0) + 12 >> 2] | 0) > 0) {
    29159. 

  29159.   _luaC_step(i5);
    29160. 

  29160.  }
    29161. 

  29161.  i2 = _luaC_newobj(i5, 8, 112, 0, 0) | 0;
    29162. 

  29162.  i6 = i5 + 8 | 0;
    29163. 

  29163.  i4 = HEAP32[i6 >> 2] | 0;
    29164. 

  29164.  HEAP32[i4 >> 2] = i2;
    29165. 

  29165.  HEAP32[i4 + 8 >> 2] = 72;
    29166. 

  29166.  HEAP32[i6 >> 2] = (HEAP32[i6 >> 2] | 0) + 16;
    29167. 

  29167.  HEAP32[i2 + 12 >> 2] = HEAP32[i3 >> 2];
    29168. 

  29168.  i6 = i2 + 28 | 0;
    29169. 

  29169.  HEAP32[i6 >> 2] = 0;
    29170. 

  29170.  i4 = i2 + 16 | 0;
    29171. 

  29171.  HEAP32[i4 >> 2] = 0;
    29172. 

  29172.  i3 = i2 + 32 | 0;
    29173. 

  29173.  HEAP32[i3 >> 2] = 0;
    29174. 

  29174.  HEAP32[i2 + 64 >> 2] = 0;
    29175. 

  29175.  HEAP16[i2 + 38 >> 1] = 0;
    29176. 

  29176.  i9 = i2 + 52 | 0;
    29177. 

  29177.  HEAP32[i9 >> 2] = 0;
    29178. 

  29178.  i8 = i2 + 40 | 0;
    29179. 

  29179.  HEAP8[i8] = 0;
    29180. 

  29180.  i10 = i2 + 44 | 0;
    29181. 

  29181.  HEAP32[i10 >> 2] = 0;
    29182. 

  29182.  HEAP8[i2 + 41 | 0] = 1;
    29183. 

  29183.  i7 = i2 + 48 | 0;
    29184. 

  29184.  HEAP32[i7 >> 2] = 0;
    29185. 

  29185.  HEAP32[i2 + 56 >> 2] = 0;
    29186. 

  29186.  HEAP16[i2 + 36 >> 1] = 1;
    29187. 

  29187.  HEAP8[i2 + 6 | 0] = 0;
    29188. 

  29188.  HEAP32[i2 + 68 >> 2] = 0;
    29189. 

  29189.  HEAP8[i8] = HEAP8[i5 + 40 | 0] | 0;
    29190. 

  29190.  i8 = HEAP32[i5 + 44 >> 2] | 0;
    29191. 

  29191.  HEAP32[i10 >> 2] = i8;
    29192. 

  29192.  HEAP32[i9 >> 2] = HEAP32[i5 + 52 >> 2];
    29193. 

  29193.  HEAP32[i7 >> 2] = i8;
    29194. 

  29194.  i5 = _luaM_realloc_(i5, 0, 0, 640) | 0;
    29195. 

  29195.  HEAP32[i6 >> 2] = i5;
    29196. 

  29196.  HEAP32[i3 >> 2] = 40;
    29197. 

  29197.  i6 = 0;
    29198. 

  29198.  do {
    29199. 

  29199.   HEAP32[i5 + (i6 << 4) + 8 >> 2] = 0;
    29200. 

  29200.   i6 = i6 + 1 | 0;
    29201. 

  29201.  } while ((i6 | 0) != 40);
    29202. 

  29202.  HEAP32[i2 + 24 >> 2] = i5 + ((HEAP32[i3 >> 2] | 0) + -5 << 4);
    29203. 

  29203.  i10 = i2 + 72 | 0;
    29204. 

  29204.  HEAP32[i2 + 80 >> 2] = 0;
    29205. 

  29205.  HEAP32[i2 + 84 >> 2] = 0;
    29206. 

  29206.  HEAP8[i2 + 90 | 0] = 0;
    29207. 

  29207.  HEAP32[i10 >> 2] = i5;
    29208. 

  29208.  HEAP32[i2 + 8 >> 2] = i5 + 16;
    29209. 

  29209.  HEAP32[i5 + 8 >> 2] = 0;
    29210. 

  29210.  HEAP32[i2 + 76 >> 2] = i5 + 336;
    29211. 

  29211.  HEAP32[i4 >> 2] = i10;
    29212. 

  29212.  STACKTOP = i1;
    29213. 

  29213.  return i2 | 0;
    29214. 

  29214. }
    29215. 

  29215. function _luaK_self(i2, i5, i3) {
    29216. 

  29216.  i2 = i2 | 0;
    29217. 

  29217.  i5 = i5 | 0;
    29218. 

  29218.  i3 = i3 | 0;
    29219. 

  29219.  var i1 = 0, i4 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0;
    29220. 

  29220.  i1 = STACKTOP;
    29221. 

  29221.  _luaK_dischargevars(i2, i5);
    29222. 

  29222.  if ((HEAP32[i5 >> 2] | 0) == 6) {
    29223. 

  29223.   i6 = i5 + 8 | 0;
    29224. 

  29224.   i8 = HEAP32[i6 >> 2] | 0;
    29225. 

  29225.   if ((HEAP32[i5 + 16 >> 2] | 0) != (HEAP32[i5 + 20 >> 2] | 0)) {
    29226. 

  29226.    if ((i8 | 0) < (HEAPU8[i2 + 46 | 0] | 0 | 0)) {
    29227. 

  29227.     i7 = 6;
    29228. 

  29228.    } else {
    29229. 

  29229.     _exp2reg(i2, i5, i8);
    29230. 

  29230.    }
    29231. 

  29231.   }
    29232. 

  29232.  } else {
    29233. 

  29233.   i6 = i5 + 8 | 0;
    29234. 

  29234.   i7 = 6;
    29235. 

  29235.  }
    29236. 

  29236.  if ((i7 | 0) == 6) {
    29237. 

  29237.   _luaK_exp2nextreg(i2, i5);
    29238. 

  29238.  }
    29239. 

  29239.  i8 = HEAP32[i6 >> 2] | 0;
    29240. 

  29240.  if (((HEAP32[i5 >> 2] | 0) == 6 ? (i8 & 256 | 0) == 0 : 0) ? (HEAPU8[i2 + 46 | 0] | 0 | 0) <= (i8 | 0) : 0) {
    29241. 

  29241.   i10 = i2 + 48 | 0;
    29242. 

  29242.   HEAP8[i10] = (HEAP8[i10] | 0) + -1 << 24 >> 24;
    29243. 

  29243.  }
    29244. 

  29244.  i7 = i2 + 48 | 0;
    29245. 

  29245.  HEAP32[i6 >> 2] = HEAPU8[i7] | 0;
    29246. 

  29246.  HEAP32[i5 >> 2] = 6;
    29247. 

  29247.  i10 = HEAP8[i7] | 0;
    29248. 

  29248.  i5 = (i10 & 255) + 2 | 0;
    29249. 

  29249.  i9 = (HEAP32[i2 >> 2] | 0) + 78 | 0;
    29250. 

  29250.  do {
    29251. 

  29251.   if (i5 >>> 0 > (HEAPU8[i9] | 0) >>> 0) {
    29252. 

  29252.    if (i5 >>> 0 > 249) {
    29253. 

  29253.     _luaX_syntaxerror(HEAP32[i2 + 12 >> 2] | 0, 10536);
    29254. 

  29254.    } else {
    29255. 

  29255.     HEAP8[i9] = i5;
    29256. 

  29256.     i4 = HEAP8[i7] | 0;
    29257. 

  29257.     break;
    29258. 

  29258.    }
    29259. 

  29259.   } else {
    29260. 

  29260.    i4 = i10;
    29261. 

  29261.   }
    29262. 

  29262.  } while (0);
    29263. 

  29263.  HEAP8[i7] = (i4 & 255) + 2;
    29264. 

  29264.  i10 = HEAP32[i6 >> 2] | 0;
    29265. 

  29265.  _luaK_code(i2, i8 << 23 | i10 << 6 | (_luaK_exp2RK(i2, i3) | 0) << 14 | 12) | 0;
    29266. 

  29266.  if ((HEAP32[i3 >> 2] | 0) != 6) {
    29267. 

  29267.   STACKTOP = i1;
    29268. 

  29268.   return;
    29269. 

  29269.  }
    29270. 

  29270.  i3 = HEAP32[i3 + 8 >> 2] | 0;
    29271. 

  29271.  if ((i3 & 256 | 0) != 0) {
    29272. 

  29272.   STACKTOP = i1;
    29273. 

  29273.   return;
    29274. 

  29274.  }
    29275. 

  29275.  if ((HEAPU8[i2 + 46 | 0] | 0 | 0) > (i3 | 0)) {
    29276. 

  29276.   STACKTOP = i1;
    29277. 

  29277.   return;
    29278. 

  29278.  }
    29279. 

  29279.  HEAP8[i7] = (HEAP8[i7] | 0) + -1 << 24 >> 24;
    29280. 

  29280.  STACKTOP = i1;
    29281. 

  29281.  return;
    29282. 

  29282. }
    29283. 

  29283. function _luaD_rawrunprotected(i10, i9, i11) {
    29284. 

  29284.  i10 = i10 | 0;
    29285. 

  29285.  i9 = i9 | 0;
    29286. 

  29286.  i11 = i11 | 0;
    29287. 

  29287.  var i1 = 0, i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i12 = 0, i13 = 0;
    29288. 

  29288.  i7 = STACKTOP;
    29289. 

  29289.  STACKTOP = STACKTOP + 176 | 0;
    29290. 

  29290.  i8 = STACKTOP;
    29291. 

  29291.  STACKTOP = STACKTOP + 168 | 0;
    29292. 

  29292.  HEAP32[i8 >> 2] = 0;
    29293. 

  29293.  i6 = i7;
    29294. 

  29294.  i5 = i10 + 38 | 0;
    29295. 

  29295.  i4 = HEAP16[i5 >> 1] | 0;
    29296. 

  29296.  i1 = i6 + 160 | 0;
    29297. 

  29297.  HEAP32[i1 >> 2] = 0;
    29298. 

  29298.  i3 = i10 + 64 | 0;
    29299. 

  29299.  HEAP32[i6 >> 2] = HEAP32[i3 >> 2];
    29300. 

  29300.  HEAP32[i3 >> 2] = i6;
    29301. 

  29301.  _saveSetjmp(i6 + 4 | 0, 1, i8 | 0) | 0;
    29302. 

  29302.  __THREW__ = 0;
    29303. 

  29303.  i13 = __THREW__;
    29304. 

  29304.  __THREW__ = 0;
    29305. 

  29305.  if ((i13 | 0) != 0 & (threwValue | 0) != 0) {
    29306. 

  29306.   i12 = _testSetjmp(HEAP32[i13 >> 2] | 0, i8) | 0;
    29307. 

  29307.   if ((i12 | 0) == 0) {
    29308. 

  29308.    _longjmp(i13 | 0, threwValue | 0);
    29309. 

  29309.   }
    29310. 

  29310.   tempRet0 = threwValue;
    29311. 

  29311.  } else {
    29312. 

  29312.   i12 = -1;
    29313. 

  29313.  }
    29314. 

  29314.  if ((i12 | 0) == 1) {
    29315. 

  29315.   i12 = tempRet0;
    29316. 

  29316.  } else {
    29317. 

  29317.   i12 = 0;
    29318. 

  29318.  }
    29319. 

  29319.  while (1) {
    29320. 

  29320.   if ((i12 | 0) != 0) {
    29321. 

  29321.    i2 = 6;
    29322. 

  29322.    break;
    29323. 

  29323.   }
    29324. 

  29324.   __THREW__ = 0;
    29325. 

  29325.   invoke_vii(i9 | 0, i10 | 0, i11 | 0);
    29326. 

  29326.   i13 = __THREW__;
    29327. 

  29327.   __THREW__ = 0;
    29328. 

  29328.   if ((i13 | 0) != 0 & (threwValue | 0) != 0) {
    29329. 

  29329.    i12 = _testSetjmp(HEAP32[i13 >> 2] | 0, i8) | 0;
    29330. 

  29330.    if ((i12 | 0) == 0) {
    29331. 

  29331.     _longjmp(i13 | 0, threwValue | 0);
    29332. 

  29332.    }
    29333. 

  29333.    tempRet0 = threwValue;
    29334. 

  29334.   } else {
    29335. 

  29335.    i12 = -1;
    29336. 

  29336.   }
    29337. 

  29337.   if ((i12 | 0) == 1) {
    29338. 

  29338.    i12 = tempRet0;
    29339. 

  29339.   } else {
    29340. 

  29340.    break;
    29341. 

  29341.   }
    29342. 

  29342.  }
    29343. 

  29343.  if ((i2 | 0) == 6) {
    29344. 

  29344.   i13 = HEAP32[i6 >> 2] | 0;
    29345. 

  29345.   HEAP32[i3 >> 2] = i13;
    29346. 

  29346.   HEAP16[i5 >> 1] = i4;
    29347. 

  29347.   i13 = HEAP32[i1 >> 2] | 0;
    29348. 

  29348.   STACKTOP = i7;
    29349. 

  29349.   return i13 | 0;
    29350. 

  29350.  }
    29351. 

  29351.  i13 = HEAP32[i6 >> 2] | 0;
    29352. 

  29352.  HEAP32[i3 >> 2] = i13;
    29353. 

  29353.  HEAP16[i5 >> 1] = i4;
    29354. 

  29354.  i13 = HEAP32[i1 >> 2] | 0;
    29355. 

  29355.  STACKTOP = i7;
    29356. 

  29356.  return i13 | 0;
    29357. 

  29357. }
    29358. 

  29358. function _luaB_tonumber(i1) {
    29359. 

  29359.  i1 = i1 | 0;
    29360. 

  29360.  var i2 = 0, i3 = 0, i4 = 0, i5 = 0, d6 = 0.0, i7 = 0, d8 = 0.0, i9 = 0, i10 = 0;
    29361. 

  29361.  i2 = STACKTOP;
    29362. 

  29362.  STACKTOP = STACKTOP + 16 | 0;
    29363. 

  29363.  i3 = i2 + 4 | 0;
    29364. 

  29364.  i4 = i2;
    29365. 

  29365.  do {
    29366. 

  29366.   if ((_lua_type(i1, 2) | 0) >= 1) {
    29367. 

  29367.    i9 = _luaL_checklstring(i1, 1, i4) | 0;
    29368. 

  29368.    i3 = i9 + (HEAP32[i4 >> 2] | 0) | 0;
    29369. 

  29369.    i5 = _luaL_checkinteger(i1, 2) | 0;
    29370. 

  29370.    if (!((i5 + -2 | 0) >>> 0 < 35)) {
    29371. 

  29371.     _luaL_argerror(i1, 2, 9648) | 0;
    29372. 

  29372.    }
    29373. 

  29373.    i10 = _strspn(i9, 9672) | 0;
    29374. 

  29374.    i7 = i9 + i10 | 0;
    29375. 

  29375.    i4 = HEAP8[i7] | 0;
    29376. 

  29376.    if (i4 << 24 >> 24 == 43) {
    29377. 

  29377.     i4 = 0;
    29378. 

  29378.     i7 = i9 + (i10 + 1) | 0;
    29379. 

  29379.    } else if (i4 << 24 >> 24 == 45) {
    29380. 

  29380.     i4 = 1;
    29381. 

  29381.     i7 = i9 + (i10 + 1) | 0;
    29382. 

  29382.    } else {
    29383. 

  29383.     i4 = 0;
    29384. 

  29384.    }
    29385. 

  29385.    if ((_isalnum(HEAPU8[i7] | 0 | 0) | 0) != 0) {
    29386. 

  29386.     d6 = +(i5 | 0);
    29387. 

  29387.     d8 = 0.0;
    29388. 

  29388.     do {
    29389. 

  29389.      i9 = HEAP8[i7] | 0;
    29390. 

  29390.      i10 = i9 & 255;
    29391. 

  29391.      if ((i10 + -48 | 0) >>> 0 < 10) {
    29392. 

  29392.       i9 = (i9 << 24 >> 24) + -48 | 0;
    29393. 

  29393.      } else {
    29394. 

  29394.       i9 = (_toupper(i10 | 0) | 0) + -55 | 0;
    29395. 

  29395.      }
    29396. 

  29396.      if ((i9 | 0) >= (i5 | 0)) {
    29397. 

  29397.       break;
    29398. 

  29398.      }
    29399. 

  29399.      d8 = d6 * d8 + +(i9 | 0);
    29400. 

  29400.      i7 = i7 + 1 | 0;
    29401. 

  29401.     } while ((_isalnum(HEAPU8[i7] | 0 | 0) | 0) != 0);
    29402. 

  29402.     if ((i7 + (_strspn(i7, 9672) | 0) | 0) == (i3 | 0)) {
    29403. 

  29403.      if ((i4 | 0) != 0) {
    29404. 

  29404.       d8 = -d8;
    29405. 

  29405.      }
    29406. 

  29406.      _lua_pushnumber(i1, d8);
    29407. 

  29407.      STACKTOP = i2;
    29408. 

  29408.      return 1;
    29409. 

  29409.     }
    29410. 

  29410.    }
    29411. 

  29411.   } else {
    29412. 

  29412.    d6 = +_lua_tonumberx(i1, 1, i3);
    29413. 

  29413.    if ((HEAP32[i3 >> 2] | 0) == 0) {
    29414. 

  29414.     _luaL_checkany(i1, 1);
    29415. 

  29415.     break;
    29416. 

  29416.    }
    29417. 

  29417.    _lua_pushnumber(i1, d6);
    29418. 

  29418.    STACKTOP = i2;
    29419. 

  29419.    return 1;
    29420. 

  29420.   }
    29421. 

  29421.  } while (0);
    29422. 

  29422.  _lua_pushnil(i1);
    29423. 

  29423.  STACKTOP = i2;
    29424. 

  29424.  return 1;
    29425. 

  29425. }
    29426. 

  29426. function _luaK_storevar(i1, i5, i3) {
    29427. 

  29427.  i1 = i1 | 0;
    29428. 

  29428.  i5 = i5 | 0;
    29429. 

  29429.  i3 = i3 | 0;
    29430. 

  29430.  var i2 = 0, i4 = 0, i6 = 0, i7 = 0;
    29431. 

  29431.  i2 = STACKTOP;
    29432. 

  29432.  i7 = HEAP32[i5 >> 2] | 0;
    29433. 

  29433.  if ((i7 | 0) == 7) {
    29434. 

  29434.   if (((HEAP32[i3 >> 2] | 0) == 6 ? (i6 = HEAP32[i3 + 8 >> 2] | 0, (i6 & 256 | 0) == 0) : 0) ? (HEAPU8[i1 + 46 | 0] | 0) <= (i6 | 0) : 0) {
    29435. 

  29435.    i7 = i1 + 48 | 0;
    29436. 

  29436.    HEAP8[i7] = (HEAP8[i7] | 0) + -1 << 24 >> 24;
    29437. 

  29437.   }
    29438. 

  29438.   _exp2reg(i1, i3, HEAP32[i5 + 8 >> 2] | 0);
    29439. 

  29439.   STACKTOP = i2;
    29440. 

  29440.   return;
    29441. 

  29441.  } else if ((i7 | 0) == 9) {
    29442. 

  29442.   i4 = i5 + 8 | 0;
    29443. 

  29443.   i7 = (HEAP8[i4 + 3 | 0] | 0) == 7 ? 10 : 8;
    29444. 

  29444.   i6 = _luaK_exp2RK(i1, i3) | 0;
    29445. 

  29445.   _luaK_code(i1, i6 << 14 | i7 | HEAPU8[i4 + 2 | 0] << 6 | HEAPU16[i4 >> 1] << 23) | 0;
    29446. 

  29446.  } else if ((i7 | 0) == 8) {
    29447. 

  29447.   _luaK_dischargevars(i1, i3);
    29448. 

  29448.   if ((HEAP32[i3 >> 2] | 0) == 6) {
    29449. 

  29449.    i6 = i3 + 8 | 0;
    29450. 

  29450.    i7 = HEAP32[i6 >> 2] | 0;
    29451. 

  29451.    if ((HEAP32[i3 + 16 >> 2] | 0) != (HEAP32[i3 + 20 >> 2] | 0)) {
    29452. 

  29452.     if ((i7 | 0) < (HEAPU8[i1 + 46 | 0] | 0)) {
    29453. 

  29453.      i4 = 12;
    29454. 

  29454.     } else {
    29455. 

  29455.      _exp2reg(i1, i3, i7);
    29456. 

  29456.      i7 = HEAP32[i6 >> 2] | 0;
    29457. 

  29457.     }
    29458. 

  29458.    }
    29459. 

  29459.   } else {
    29460. 

  29460.    i6 = i3 + 8 | 0;
    29461. 

  29461.    i4 = 12;
    29462. 

  29462.   }
    29463. 

  29463.   if ((i4 | 0) == 12) {
    29464. 

  29464.    _luaK_exp2nextreg(i1, i3);
    29465. 

  29465.    i7 = HEAP32[i6 >> 2] | 0;
    29466. 

  29466.   }
    29467. 

  29467.   _luaK_code(i1, i7 << 6 | HEAP32[i5 + 8 >> 2] << 23 | 9) | 0;
    29468. 

  29468.  }
    29469. 

  29469.  if ((HEAP32[i3 >> 2] | 0) != 6) {
    29470. 

  29470.   STACKTOP = i2;
    29471. 

  29471.   return;
    29472. 

  29472.  }
    29473. 

  29473.  i3 = HEAP32[i3 + 8 >> 2] | 0;
    29474. 

  29474.  if ((i3 & 256 | 0) != 0) {
    29475. 

  29475.   STACKTOP = i2;
    29476. 

  29476.   return;
    29477. 

  29477.  }
    29478. 

  29478.  if ((HEAPU8[i1 + 46 | 0] | 0) > (i3 | 0)) {
    29479. 

  29479.   STACKTOP = i2;
    29480. 

  29480.   return;
    29481. 

  29481.  }
    29482. 

  29482.  i7 = i1 + 48 | 0;
    29483. 

  29483.  HEAP8[i7] = (HEAP8[i7] | 0) + -1 << 24 >> 24;
    29484. 

  29484.  STACKTOP = i2;
    29485. 

  29485.  return;
    29486. 

  29486. }
    29487. 

  29487. function _closegoto(i10, i3, i9) {
    29488. 

  29488.  i10 = i10 | 0;
    29489. 

  29489.  i3 = i3 | 0;
    29490. 

  29490.  i9 = i9 | 0;
    29491. 

  29491.  var i1 = 0, i2 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i11 = 0, i12 = 0;
    29492. 

  29492.  i1 = STACKTOP;
    29493. 

  29493.  STACKTOP = STACKTOP + 16 | 0;
    29494. 

  29494.  i7 = i1;
    29495. 

  29495.  i4 = HEAP32[i10 + 48 >> 2] | 0;
    29496. 

  29496.  i6 = HEAP32[i10 + 64 >> 2] | 0;
    29497. 

  29497.  i2 = i6 + 12 | 0;
    29498. 

  29498.  i5 = HEAP32[i2 >> 2] | 0;
    29499. 

  29499.  i8 = HEAP8[i5 + (i3 << 4) + 12 | 0] | 0;
    29500. 

  29500.  if ((i8 & 255) < (HEAPU8[i9 + 12 | 0] | 0)) {
    29501. 

  29501.   i11 = HEAP32[i10 + 52 >> 2] | 0;
    29502. 

  29502.   i12 = HEAP32[i5 + (i3 << 4) + 8 >> 2] | 0;
    29503. 

  29503.   i8 = (HEAP32[(HEAP32[(HEAP32[i4 >> 2] | 0) + 24 >> 2] | 0) + ((HEAP16[(HEAP32[HEAP32[(HEAP32[i4 + 12 >> 2] | 0) + 64 >> 2] >> 2] | 0) + ((HEAP32[i4 + 40 >> 2] | 0) + (i8 & 255) << 1) >> 1] | 0) * 12 | 0) >> 2] | 0) + 16 | 0;
    29504. 

  29504.   HEAP32[i7 >> 2] = (HEAP32[i5 + (i3 << 4) >> 2] | 0) + 16;
    29505. 

  29505.   HEAP32[i7 + 4 >> 2] = i12;
    29506. 

  29506.   HEAP32[i7 + 8 >> 2] = i8;
    29507. 

  29507.   _semerror(i10, _luaO_pushfstring(i11, 6248, i7) | 0);
    29508. 

  29508.  }
    29509. 

  29509.  _luaK_patchlist(i4, HEAP32[i5 + (i3 << 4) + 4 >> 2] | 0, HEAP32[i9 + 4 >> 2] | 0);
    29510. 

  29510.  i4 = i6 + 16 | 0;
    29511. 

  29511.  i5 = (HEAP32[i4 >> 2] | 0) + -1 | 0;
    29512. 

  29512.  if ((i5 | 0) <= (i3 | 0)) {
    29513. 

  29513.   i12 = i5;
    29514. 

  29514.   HEAP32[i4 >> 2] = i12;
    29515. 

  29515.   STACKTOP = i1;
    29516. 

  29516.   return;
    29517. 

  29517.  }
    29518. 

  29518.  do {
    29519. 

  29519.   i12 = HEAP32[i2 >> 2] | 0;
    29520. 

  29520.   i5 = i12 + (i3 << 4) | 0;
    29521. 

  29521.   i3 = i3 + 1 | 0;
    29522. 

  29522.   i12 = i12 + (i3 << 4) | 0;
    29523. 

  29523.   HEAP32[i5 + 0 >> 2] = HEAP32[i12 + 0 >> 2];
    29524. 

  29524.   HEAP32[i5 + 4 >> 2] = HEAP32[i12 + 4 >> 2];
    29525. 

  29525.   HEAP32[i5 + 8 >> 2] = HEAP32[i12 + 8 >> 2];
    29526. 

  29526.   HEAP32[i5 + 12 >> 2] = HEAP32[i12 + 12 >> 2];
    29527. 

  29527.   i5 = (HEAP32[i4 >> 2] | 0) + -1 | 0;
    29528. 

  29528.  } while ((i3 | 0) < (i5 | 0));
    29529. 

  29529.  HEAP32[i4 >> 2] = i5;
    29530. 

  29530.  STACKTOP = i1;
    29531. 

  29531.  return;
    29532. 

  29532. }
    29533. 

  29533. function _luaM_growaux_(i4, i5, i1, i7, i8, i9) {
    29534. 

  29534.  i4 = i4 | 0;
    29535. 

  29535.  i5 = i5 | 0;
    29536. 

  29536.  i1 = i1 | 0;
    29537. 

  29537.  i7 = i7 | 0;
    29538. 

  29538.  i8 = i8 | 0;
    29539. 

  29539.  i9 = i9 | 0;
    29540. 

  29540.  var i2 = 0, i3 = 0, i6 = 0, i10 = 0, i11 = 0;
    29541. 

  29541.  i2 = STACKTOP;
    29542. 

  29542.  STACKTOP = STACKTOP + 16 | 0;
    29543. 

  29543.  i10 = i2;
    29544. 

  29544.  i6 = HEAP32[i1 >> 2] | 0;
    29545. 

  29545.  if ((i6 | 0) >= ((i8 | 0) / 2 | 0 | 0)) {
    29546. 

  29546.   if ((i6 | 0) < (i8 | 0)) {
    29547. 

  29547.    i3 = i8;
    29548. 

  29548.   } else {
    29549. 

  29549.    HEAP32[i10 >> 2] = i9;
    29550. 

  29550.    HEAP32[i10 + 4 >> 2] = i8;
    29551. 

  29551.    _luaG_runerror(i4, 4112, i10);
    29552. 

  29552.   }
    29553. 

  29553.  } else {
    29554. 

  29554.   i3 = i6 << 1;
    29555. 

  29555.   i3 = (i3 | 0) < 4 ? 4 : i3;
    29556. 

  29556.  }
    29557. 

  29557.  if ((i3 + 1 | 0) >>> 0 > (4294967293 / (i7 >>> 0) | 0) >>> 0) {
    29558. 

  29558.   _luaM_toobig(i4);
    29559. 

  29559.  }
    29560. 

  29560.  i6 = Math_imul(i6, i7) | 0;
    29561. 

  29561.  i8 = Math_imul(i3, i7) | 0;
    29562. 

  29562.  i9 = HEAP32[i4 + 12 >> 2] | 0;
    29563. 

  29563.  i7 = (i5 | 0) != 0;
    29564. 

  29564.  i11 = i9 + 4 | 0;
    29565. 

  29565.  i10 = FUNCTION_TABLE_iiiii[HEAP32[i9 >> 2] & 3](HEAP32[i11 >> 2] | 0, i5, i6, i8) | 0;
    29566. 

  29566.  if ((i10 | 0) != 0 | (i8 | 0) == 0) {
    29567. 

  29567.   i5 = i9 + 12 | 0;
    29568. 

  29568.   i4 = HEAP32[i5 >> 2] | 0;
    29569. 

  29569.   i6 = 0 - i6 | 0;
    29570. 

  29570.   i11 = i7 ? i6 : 0;
    29571. 

  29571.   i11 = i11 + i8 | 0;
    29572. 

  29572.   i11 = i11 + i4 | 0;
    29573. 

  29573.   HEAP32[i5 >> 2] = i11;
    29574. 

  29574.   HEAP32[i1 >> 2] = i3;
    29575. 

  29575.   STACKTOP = i2;
    29576. 

  29576.   return i10 | 0;
    29577. 

  29577.  }
    29578. 

  29578.  if ((HEAP8[i9 + 63 | 0] | 0) == 0) {
    29579. 

  29579.   _luaD_throw(i4, 4);
    29580. 

  29580.  }
    29581. 

  29581.  _luaC_fullgc(i4, 1);
    29582. 

  29582.  i10 = FUNCTION_TABLE_iiiii[HEAP32[i9 >> 2] & 3](HEAP32[i11 >> 2] | 0, i5, i6, i8) | 0;
    29583. 

  29583.  if ((i10 | 0) == 0) {
    29584. 

  29584.   _luaD_throw(i4, 4);
    29585. 

  29585.  } else {
    29586. 

  29586.   i5 = i9 + 12 | 0;
    29587. 

  29587.   i4 = HEAP32[i5 >> 2] | 0;
    29588. 

  29588.   i6 = 0 - i6 | 0;
    29589. 

  29589.   i11 = i7 ? i6 : 0;
    29590. 

  29590.   i11 = i11 + i8 | 0;
    29591. 

  29591.   i11 = i11 + i4 | 0;
    29592. 

  29592.   HEAP32[i5 >> 2] = i11;
    29593. 

  29593.   HEAP32[i1 >> 2] = i3;
    29594. 

  29594.   STACKTOP = i2;
    29595. 

  29595.   return i10 | 0;
    29596. 

  29596.  }
    29597. 

  29597.  return 0;
    29598. 

  29598. }
    29599. 

  29599. function _luaD_hook(i5, i14, i13) {
    29600. 

  29600.  i5 = i5 | 0;
    29601. 

  29601.  i14 = i14 | 0;
    29602. 

  29602.  i13 = i13 | 0;
    29603. 

  29603.  var i1 = 0, i2 = 0, i3 = 0, i4 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i15 = 0, i16 = 0;
    29604. 

  29604.  i11 = STACKTOP;
    29605. 

  29605.  STACKTOP = STACKTOP + 112 | 0;
    29606. 

  29606.  i4 = i11;
    29607. 

  29607.  i3 = HEAP32[i5 + 52 >> 2] | 0;
    29608. 

  29608.  if ((i3 | 0) == 0) {
    29609. 

  29609.   STACKTOP = i11;
    29610. 

  29610.   return;
    29611. 

  29611.  }
    29612. 

  29612.  i8 = i5 + 41 | 0;
    29613. 

  29613.  if ((HEAP8[i8] | 0) == 0) {
    29614. 

  29614.   STACKTOP = i11;
    29615. 

  29615.   return;
    29616. 

  29616.  }
    29617. 

  29617.  i10 = HEAP32[i5 + 16 >> 2] | 0;
    29618. 

  29618.  i6 = i5 + 8 | 0;
    29619. 

  29619.  i15 = HEAP32[i6 >> 2] | 0;
    29620. 

  29620.  i1 = i5 + 28 | 0;
    29621. 

  29621.  i16 = i15;
    29622. 

  29622.  i12 = HEAP32[i1 >> 2] | 0;
    29623. 

  29623.  i7 = i16 - i12 | 0;
    29624. 

  29624.  i9 = i10 + 4 | 0;
    29625. 

  29625.  i12 = (HEAP32[i9 >> 2] | 0) - i12 | 0;
    29626. 

  29626.  HEAP32[i4 >> 2] = i14;
    29627. 

  29627.  HEAP32[i4 + 20 >> 2] = i13;
    29628. 

  29628.  HEAP32[i4 + 96 >> 2] = i10;
    29629. 

  29629.  do {
    29630. 

  29630.   if (((HEAP32[i5 + 24 >> 2] | 0) - i16 | 0) < 336) {
    29631. 

  29631.    i14 = HEAP32[i5 + 32 >> 2] | 0;
    29632. 

  29632.    if ((i14 | 0) > 1e6) {
    29633. 

  29633.     _luaD_throw(i5, 6);
    29634. 

  29634.    }
    29635. 

  29635.    i13 = (i7 >> 4) + 25 | 0;
    29636. 

  29636.    i14 = i14 << 1;
    29637. 

  29637.    i14 = (i14 | 0) > 1e6 ? 1e6 : i14;
    29638. 

  29638.    i13 = (i14 | 0) < (i13 | 0) ? i13 : i14;
    29639. 

  29639.    if ((i13 | 0) > 1e6) {
    29640. 

  29640.     _luaD_reallocstack(i5, 1000200);
    29641. 

  29641.     _luaG_runerror(i5, 2224, i4);
    29642. 

  29642.    } else {
    29643. 

  29643.     _luaD_reallocstack(i5, i13);
    29644. 

  29644.     i2 = HEAP32[i6 >> 2] | 0;
    29645. 

  29645.     break;
    29646. 

  29646.    }
    29647. 

  29647.   } else {
    29648. 

  29648.    i2 = i15;
    29649. 

  29649.   }
    29650. 

  29650.  } while (0);
    29651. 

  29651.  HEAP32[i9 >> 2] = i2 + 320;
    29652. 

  29652.  HEAP8[i8] = 0;
    29653. 

  29653.  i16 = i10 + 18 | 0;
    29654. 

  29654.  HEAP8[i16] = HEAPU8[i16] | 2;
    29655. 

  29655.  FUNCTION_TABLE_vii[i3 & 15](i5, i4);
    29656. 

  29656.  HEAP8[i8] = 1;
    29657. 

  29657.  HEAP32[i9 >> 2] = (HEAP32[i1 >> 2] | 0) + i12;
    29658. 

  29658.  HEAP32[i6 >> 2] = (HEAP32[i1 >> 2] | 0) + i7;
    29659. 

  29659.  HEAP8[i16] = HEAP8[i16] & 253;
    29660. 

  29660.  STACKTOP = i11;
    29661. 

  29661.  return;
    29662. 

  29662. }
    29663. 

  29663. function _funcargs(i10, i2, i1) {
    29664. 

  29664.  i10 = i10 | 0;
    29665. 

  29665.  i2 = i2 | 0;
    29666. 

  29666.  i1 = i1 | 0;
    29667. 

  29667.  var i3 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0;
    29668. 

  29668.  i3 = STACKTOP;
    29669. 

  29669.  STACKTOP = STACKTOP + 32 | 0;
    29670. 

  29670.  i6 = i3;
    29671. 

  29671.  i9 = i10 + 48 | 0;
    29672. 

  29672.  i5 = HEAP32[i9 >> 2] | 0;
    29673. 

  29673.  i7 = i10 + 16 | 0;
    29674. 

  29674.  i8 = HEAP32[i7 >> 2] | 0;
    29675. 

  29675.  if ((i8 | 0) == 289) {
    29676. 

  29676.   i9 = _luaK_stringK(i5, HEAP32[i10 + 24 >> 2] | 0) | 0;
    29677. 

  29677.   HEAP32[i6 + 16 >> 2] = -1;
    29678. 

  29678.   HEAP32[i6 + 20 >> 2] = -1;
    29679. 

  29679.   HEAP32[i6 >> 2] = 4;
    29680. 

  29680.   HEAP32[i6 + 8 >> 2] = i9;
    29681. 

  29681.   _luaX_next(i10);
    29682. 

  29682.  } else if ((i8 | 0) == 40) {
    29683. 

  29683.   _luaX_next(i10);
    29684. 

  29684.   if ((HEAP32[i7 >> 2] | 0) == 41) {
    29685. 

  29685.    HEAP32[i6 >> 2] = 0;
    29686. 

  29686.   } else {
    29687. 

  29687.    _subexpr(i10, i6, 0) | 0;
    29688. 

  29688.    if ((HEAP32[i7 >> 2] | 0) == 44) {
    29689. 

  29689.     do {
    29690. 

  29690.      _luaX_next(i10);
    29691. 

  29691.      _luaK_exp2nextreg(HEAP32[i9 >> 2] | 0, i6);
    29692. 

  29692.      _subexpr(i10, i6, 0) | 0;
    29693. 

  29693.     } while ((HEAP32[i7 >> 2] | 0) == 44);
    29694. 

  29694.    }
    29695. 

  29695.    _luaK_setreturns(i5, i6, -1);
    29696. 

  29696.   }
    29697. 

  29697.   _check_match(i10, 41, 40, i1);
    29698. 

  29698.  } else if ((i8 | 0) == 123) {
    29699. 

  29699.   _constructor(i10, i6);
    29700. 

  29700.  } else {
    29701. 

  29701.   _luaX_syntaxerror(i10, 6624);
    29702. 

  29702.  }
    29703. 

  29703.  i8 = i2 + 8 | 0;
    29704. 

  29704.  i7 = HEAP32[i8 >> 2] | 0;
    29705. 

  29705.  i9 = HEAP32[i6 >> 2] | 0;
    29706. 

  29706.  if ((i9 | 0) == 0) {
    29707. 

  29707.   i4 = 13;
    29708. 

  29708.  } else if ((i9 | 0) == 13 | (i9 | 0) == 12) {
    29709. 

  29709.   i6 = 0;
    29710. 

  29710.  } else {
    29711. 

  29711.   _luaK_exp2nextreg(i5, i6);
    29712. 

  29712.   i4 = 13;
    29713. 

  29713.  }
    29714. 

  29714.  if ((i4 | 0) == 13) {
    29715. 

  29715.   i6 = (HEAPU8[i5 + 48 | 0] | 0) - i7 | 0;
    29716. 

  29716.  }
    29717. 

  29717.  i10 = _luaK_codeABC(i5, 29, i7, i6, 2) | 0;
    29718. 

  29718.  HEAP32[i2 + 16 >> 2] = -1;
    29719. 

  29719.  HEAP32[i2 + 20 >> 2] = -1;
    29720. 

  29720.  HEAP32[i2 >> 2] = 12;
    29721. 

  29721.  HEAP32[i8 >> 2] = i10;
    29722. 

  29722.  _luaK_fixline(i5, i1);
    29723. 

  29723.  HEAP8[i5 + 48 | 0] = i7 + 1;
    29724. 

  29724.  STACKTOP = i3;
    29725. 

  29725.  return;
    29726. 

  29726. }
    29727. 

  29727. function _luaD_reallocstack(i3, i6) {
    29728. 

  29728.  i3 = i3 | 0;
    29729. 

  29729.  i6 = i6 | 0;
    29730. 

  29730.  var i1 = 0, i2 = 0, i4 = 0, i5 = 0, i7 = 0, i8 = 0, i9 = 0;
    29731. 

  29731.  i1 = STACKTOP;
    29732. 

  29732.  i2 = i3 + 28 | 0;
    29733. 

  29733.  i8 = HEAP32[i2 >> 2] | 0;
    29734. 

  29734.  i7 = i3 + 32 | 0;
    29735. 

  29735.  i9 = HEAP32[i7 >> 2] | 0;
    29736. 

  29736.  if ((i6 + 1 | 0) >>> 0 > 268435455) {
    29737. 

  29737.   _luaM_toobig(i3);
    29738. 

  29738.  }
    29739. 

  29739.  i5 = _luaM_realloc_(i3, i8, i9 << 4, i6 << 4) | 0;
    29740. 

  29740.  HEAP32[i2 >> 2] = i5;
    29741. 

  29741.  if ((i9 | 0) < (i6 | 0)) {
    29742. 

  29742.   do {
    29743. 

  29743.    HEAP32[i5 + (i9 << 4) + 8 >> 2] = 0;
    29744. 

  29744.    i9 = i9 + 1 | 0;
    29745. 

  29745.   } while ((i9 | 0) != (i6 | 0));
    29746. 

  29746.  }
    29747. 

  29747.  HEAP32[i7 >> 2] = i6;
    29748. 

  29748.  HEAP32[i3 + 24 >> 2] = i5 + (i6 + -5 << 4);
    29749. 

  29749.  i6 = i3 + 8 | 0;
    29750. 

  29750.  HEAP32[i6 >> 2] = i5 + ((HEAP32[i6 >> 2] | 0) - i8 >> 4 << 4);
    29751. 

  29751.  i6 = HEAP32[i3 + 56 >> 2] | 0;
    29752. 

  29752.  if ((i6 | 0) != 0 ? (i4 = i6 + 8 | 0, HEAP32[i4 >> 2] = i5 + ((HEAP32[i4 >> 2] | 0) - i8 >> 4 << 4), i4 = HEAP32[i6 >> 2] | 0, (i4 | 0) != 0) : 0) {
    29753. 

  29753.   do {
    29754. 

  29754.    i9 = i4 + 8 | 0;
    29755. 

  29755.    HEAP32[i9 >> 2] = (HEAP32[i2 >> 2] | 0) + ((HEAP32[i9 >> 2] | 0) - i8 >> 4 << 4);
    29756. 

  29756.    i4 = HEAP32[i4 >> 2] | 0;
    29757. 

  29757.   } while ((i4 | 0) != 0);
    29758. 

  29758.  }
    29759. 

  29759.  i3 = HEAP32[i3 + 16 >> 2] | 0;
    29760. 

  29760.  if ((i3 | 0) == 0) {
    29761. 

  29761.   STACKTOP = i1;
    29762. 

  29762.   return;
    29763. 

  29763.  }
    29764. 

  29764.  do {
    29765. 

  29765.   i9 = i3 + 4 | 0;
    29766. 

  29766.   HEAP32[i9 >> 2] = (HEAP32[i2 >> 2] | 0) + ((HEAP32[i9 >> 2] | 0) - i8 >> 4 << 4);
    29767. 

  29767.   HEAP32[i3 >> 2] = (HEAP32[i2 >> 2] | 0) + ((HEAP32[i3 >> 2] | 0) - i8 >> 4 << 4);
    29768. 

  29768.   if (!((HEAP8[i3 + 18 | 0] & 1) == 0)) {
    29769. 

  29769.    i9 = i3 + 24 | 0;
    29770. 

  29770.    HEAP32[i9 >> 2] = (HEAP32[i2 >> 2] | 0) + ((HEAP32[i9 >> 2] | 0) - i8 >> 4 << 4);
    29771. 

  29771.   }
    29772. 

  29772.   i3 = HEAP32[i3 + 8 >> 2] | 0;
    29773. 

  29773.  } while ((i3 | 0) != 0);
    29774. 

  29774.  STACKTOP = i1;
    29775. 

  29775.  return;
    29776. 

  29776. }
    29777. 

  29777. function _luaF_close(i7, i6) {
    29778. 

  29778.  i7 = i7 | 0;
    29779. 

  29779.  i6 = i6 | 0;
    29780. 

  29780.  var i1 = 0, i2 = 0, i3 = 0, i4 = 0, i5 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0, i14 = 0;
    29781. 

  29781.  i1 = STACKTOP;
    29782. 

  29782.  i4 = HEAP32[i7 + 12 >> 2] | 0;
    29783. 

  29783.  i3 = i7 + 56 | 0;
    29784. 

  29784.  i8 = HEAP32[i3 >> 2] | 0;
    29785. 

  29785.  if ((i8 | 0) == 0) {
    29786. 

  29786.   STACKTOP = i1;
    29787. 

  29787.   return;
    29788. 

  29788.  }
    29789. 

  29789.  i5 = i4 + 60 | 0;
    29790. 

  29790.  i2 = i4 + 68 | 0;
    29791. 

  29791.  while (1) {
    29792. 

  29792.   i9 = i8 + 8 | 0;
    29793. 

  29793.   if ((HEAP32[i9 >> 2] | 0) >>> 0 < i6 >>> 0) {
    29794. 

  29794.    i2 = 10;
    29795. 

  29795.    break;
    29796. 

  29796.   }
    29797. 

  29797.   HEAP32[i3 >> 2] = HEAP32[i8 >> 2];
    29798. 

  29798.   if ((((HEAPU8[i5] | 0) ^ 3) & ((HEAPU8[i8 + 5 | 0] | 0) ^ 3) | 0) == 0) {
    29799. 

  29799.    if ((HEAP32[i9 >> 2] | 0) != (i8 + 16 | 0)) {
    29800. 

  29800.     i9 = i8 + 16 | 0;
    29801. 

  29801.     i10 = i9 + 4 | 0;
    29802. 

  29802.     HEAP32[(HEAP32[i10 >> 2] | 0) + 16 >> 2] = HEAP32[i9 >> 2];
    29803. 

  29803.     HEAP32[(HEAP32[i9 >> 2] | 0) + 20 >> 2] = HEAP32[i10 >> 2];
    29804. 

  29804.    }
    29805. 

  29805.    _luaM_realloc_(i7, i8, 32, 0) | 0;
    29806. 

  29806.   } else {
    29807. 

  29807.    i11 = i8 + 16 | 0;
    29808. 

  29808.    i10 = i11 + 4 | 0;
    29809. 

  29809.    HEAP32[(HEAP32[i10 >> 2] | 0) + 16 >> 2] = HEAP32[i11 >> 2];
    29810. 

  29810.    HEAP32[(HEAP32[i11 >> 2] | 0) + 20 >> 2] = HEAP32[i10 >> 2];
    29811. 

  29811.    i11 = HEAP32[i9 >> 2] | 0;
    29812. 

  29812.    i10 = i8 + 16 | 0;
    29813. 

  29813.    i14 = i11;
    29814. 

  29814.    i13 = HEAP32[i14 + 4 >> 2] | 0;
    29815. 

  29815.    i12 = i10;
    29816. 

  29816.    HEAP32[i12 >> 2] = HEAP32[i14 >> 2];
    29817. 

  29817.    HEAP32[i12 + 4 >> 2] = i13;
    29818. 

  29818.    HEAP32[i8 + 24 >> 2] = HEAP32[i11 + 8 >> 2];
    29819. 

  29819.    HEAP32[i9 >> 2] = i10;
    29820. 

  29820.    HEAP32[i8 >> 2] = HEAP32[i2 >> 2];
    29821. 

  29821.    HEAP32[i2 >> 2] = i8;
    29822. 

  29822.    _luaC_checkupvalcolor(i4, i8);
    29823. 

  29823.   }
    29824. 

  29824.   i8 = HEAP32[i3 >> 2] | 0;
    29825. 

  29825.   if ((i8 | 0) == 0) {
    29826. 

  29826.    i2 = 10;
    29827. 

  29827.    break;
    29828. 

  29828.   }
    29829. 

  29829.  }
    29830. 

  29830.  if ((i2 | 0) == 10) {
    29831. 

  29831.   STACKTOP = i1;
    29832. 

  29832.   return;
    29833. 

  29833.  }
    29834. 

  29834. }
    29835. 

  29835. function _luaK_dischargevars(i3, i1) {
    29836. 

  29836.  i3 = i3 | 0;
    29837. 

  29837.  i1 = i1 | 0;
    29838. 

  29838.  var i2 = 0, i4 = 0, i5 = 0, i6 = 0;
    29839. 

  29839.  i2 = STACKTOP;
    29840. 

  29840.  switch (HEAP32[i1 >> 2] | 0) {
    29841. 

  29841.  case 12:
    29842. 

  29842.   {
    29843. 

  29843.    HEAP32[i1 >> 2] = 6;
    29844. 

  29844.    i6 = i1 + 8 | 0;
    29845. 

  29845.    HEAP32[i6 >> 2] = (HEAP32[(HEAP32[(HEAP32[i3 >> 2] | 0) + 12 >> 2] | 0) + (HEAP32[i6 >> 2] << 2) >> 2] | 0) >>> 6 & 255;
    29846. 

  29846.    STACKTOP = i2;
    29847. 

  29847.    return;
    29848. 

  29848.   }
    29849. 

  29849.  case 13:
    29850. 

  29850.   {
    29851. 

  29851.    i6 = (HEAP32[(HEAP32[i3 >> 2] | 0) + 12 >> 2] | 0) + (HEAP32[i1 + 8 >> 2] << 2) | 0;
    29852. 

  29852.    HEAP32[i6 >> 2] = HEAP32[i6 >> 2] & 8388607 | 16777216;
    29853. 

  29853.    HEAP32[i1 >> 2] = 11;
    29854. 

  29854.    STACKTOP = i2;
    29855. 

  29855.    return;
    29856. 

  29856.   }
    29857. 

  29857.  case 9:
    29858. 

  29858.   {
    29859. 

  29859.    i4 = i1 + 8 | 0;
    29860. 

  29860.    i5 = HEAP16[i4 >> 1] | 0;
    29861. 

  29861.    if ((i5 & 256 | 0) == 0 ? (HEAPU8[i3 + 46 | 0] | 0) <= (i5 | 0) : 0) {
    29862. 

  29862.     i6 = i3 + 48 | 0;
    29863. 

  29863.     HEAP8[i6] = (HEAP8[i6] | 0) + -1 << 24 >> 24;
    29864. 

  29864.    }
    29865. 

  29865.    i5 = i4 + 2 | 0;
    29866. 

  29866.    if ((HEAP8[i4 + 3 | 0] | 0) == 7) {
    29867. 

  29867.     if ((HEAPU8[i3 + 46 | 0] | 0) > (HEAPU8[i5] | 0)) {
    29868. 

  29868.      i6 = 7;
    29869. 

  29869.     } else {
    29870. 

  29870.      i6 = i3 + 48 | 0;
    29871. 

  29871.      HEAP8[i6] = (HEAP8[i6] | 0) + -1 << 24 >> 24;
    29872. 

  29872.      i6 = 7;
    29873. 

  29873.     }
    29874. 

  29874.    } else {
    29875. 

  29875.     i6 = 6;
    29876. 

  29876.    }
    29877. 

  29877.    HEAP32[i4 >> 2] = _luaK_code(i3, HEAPU8[i5] << 23 | i6 | HEAP16[i4 >> 1] << 14) | 0;
    29878. 

  29878.    HEAP32[i1 >> 2] = 11;
    29879. 

  29879.    STACKTOP = i2;
    29880. 

  29880.    return;
    29881. 

  29881.   }
    29882. 

  29882.  case 7:
    29883. 

  29883.   {
    29884. 

  29884.    HEAP32[i1 >> 2] = 6;
    29885. 

  29885.    STACKTOP = i2;
    29886. 

  29886.    return;
    29887. 

  29887.   }
    29888. 

  29888.  case 8:
    29889. 

  29889.   {
    29890. 

  29890.    i6 = i1 + 8 | 0;
    29891. 

  29891.    HEAP32[i6 >> 2] = _luaK_code(i3, HEAP32[i6 >> 2] << 23 | 5) | 0;
    29892. 

  29892.    HEAP32[i1 >> 2] = 11;
    29893. 

  29893.    STACKTOP = i2;
    29894. 

  29894.    return;
    29895. 

  29895.   }
    29896. 

  29896.  default:
    29897. 

  29897.   {
    29898. 

  29898.    STACKTOP = i2;
    29899. 

  29899.    return;
    29900. 

  29900.   }
    29901. 

  29901.  }
    29902. 

  29902. }
    29903. 

  29903. function _gmatch_aux(i10) {
    29904. 

  29904.  i10 = i10 | 0;
    29905. 

  29905.  var i1 = 0, i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i11 = 0, i12 = 0;
    29906. 

  29906.  i1 = STACKTOP;
    29907. 

  29907.  STACKTOP = STACKTOP + 288 | 0;
    29908. 

  29908.  i2 = i1 + 8 | 0;
    29909. 

  29909.  i12 = i1 + 4 | 0;
    29910. 

  29910.  i3 = i1;
    29911. 

  29911.  i8 = _lua_tolstring(i10, -1001001, i12) | 0;
    29912. 

  29912.  i7 = _lua_tolstring(i10, -1001002, i3) | 0;
    29913. 

  29913.  i5 = i2 + 16 | 0;
    29914. 

  29914.  HEAP32[i5 >> 2] = i10;
    29915. 

  29915.  HEAP32[i2 >> 2] = 200;
    29916. 

  29916.  HEAP32[i2 + 4 >> 2] = i8;
    29917. 

  29917.  i9 = i2 + 8 | 0;
    29918. 

  29918.  HEAP32[i9 >> 2] = i8 + (HEAP32[i12 >> 2] | 0);
    29919. 

  29919.  HEAP32[i2 + 12 >> 2] = i7 + (HEAP32[i3 >> 2] | 0);
    29920. 

  29920.  i3 = i8 + (_lua_tointegerx(i10, -1001003, 0) | 0) | 0;
    29921. 

  29921.  if (i3 >>> 0 > (HEAP32[i9 >> 2] | 0) >>> 0) {
    29922. 

  29922.   i12 = 0;
    29923. 

  29923.   STACKTOP = i1;
    29924. 

  29924.   return i12 | 0;
    29925. 

  29925.  }
    29926. 

  29926.  i11 = i2 + 20 | 0;
    29927. 

  29927.  while (1) {
    29928. 

  29928.   HEAP32[i11 >> 2] = 0;
    29929. 

  29929.   i4 = _match(i2, i3, i7) | 0;
    29930. 

  29930.   i12 = i3 + 1 | 0;
    29931. 

  29931.   if ((i4 | 0) != 0) {
    29932. 

  29932.    break;
    29933. 

  29933.   }
    29934. 

  29934.   if (i12 >>> 0 > (HEAP32[i9 >> 2] | 0) >>> 0) {
    29935. 

  29935.    i2 = 0;
    29936. 

  29936.    i6 = 7;
    29937. 

  29937.    break;
    29938. 

  29938.   } else {
    29939. 

  29939.    i3 = i12;
    29940. 

  29940.   }
    29941. 

  29941.  }
    29942. 

  29942.  if ((i6 | 0) == 7) {
    29943. 

  29943.   STACKTOP = i1;
    29944. 

  29944.   return i2 | 0;
    29945. 

  29945.  }
    29946. 

  29946.  _lua_pushinteger(i10, i4 - i8 + ((i4 | 0) == (i3 | 0)) | 0);
    29947. 

  29947.  _lua_replace(i10, -1001003);
    29948. 

  29948.  i7 = HEAP32[i11 >> 2] | 0;
    29949. 

  29949.  i6 = (i7 | 0) != 0 | (i3 | 0) == 0 ? i7 : 1;
    29950. 

  29950.  _luaL_checkstack(HEAP32[i5 >> 2] | 0, i6, 7200);
    29951. 

  29951.  if ((i6 | 0) > 0) {
    29952. 

  29952.   i5 = 0;
    29953. 

  29953.  } else {
    29954. 

  29954.   i12 = i7;
    29955. 

  29955.   STACKTOP = i1;
    29956. 

  29956.   return i12 | 0;
    29957. 

  29957.  }
    29958. 

  29958.  while (1) {
    29959. 

  29959.   _push_onecapture(i2, i5, i3, i4);
    29960. 

  29960.   i5 = i5 + 1 | 0;
    29961. 

  29961.   if ((i5 | 0) == (i6 | 0)) {
    29962. 

  29962.    i2 = i6;
    29963. 

  29963.    break;
    29964. 

  29964.   }
    29965. 

  29965.  }
    29966. 

  29966.  STACKTOP = i1;
    29967. 

  29967.  return i2 | 0;
    29968. 

  29968. }
    29969. 

  29969. function _lua_rawseti(i1, i5, i3) {
    29970. 

  29970.  i1 = i1 | 0;
    29971. 

  29971.  i5 = i5 | 0;
    29972. 

  29972.  i3 = i3 | 0;
    29973. 

  29973.  var i2 = 0, i4 = 0, i6 = 0;
    29974. 

  29974.  i2 = STACKTOP;
    29975. 

  29975.  i6 = HEAP32[i1 + 16 >> 2] | 0;
    29976. 

  29976.  do {
    29977. 

  29977.   if ((i5 | 0) <= 0) {
    29978. 

  29978.    if (!((i5 | 0) < -1000999)) {
    29979. 

  29979.     i5 = (HEAP32[i1 + 8 >> 2] | 0) + (i5 << 4) | 0;
    29980. 

  29980.     break;
    29981. 

  29981.    }
    29982. 

  29982.    if ((i5 | 0) == -1001e3) {
    29983. 

  29983.     i5 = (HEAP32[i1 + 12 >> 2] | 0) + 40 | 0;
    29984. 

  29984.     break;
    29985. 

  29985.    }
    29986. 

  29986.    i5 = -1001e3 - i5 | 0;
    29987. 

  29987.    i6 = HEAP32[i6 >> 2] | 0;
    29988. 

  29988.    if ((HEAP32[i6 + 8 >> 2] | 0) != 22 ? (i4 = HEAP32[i6 >> 2] | 0, (i5 | 0) <= (HEAPU8[i4 + 6 | 0] | 0 | 0)) : 0) {
    29989. 

  29989.     i5 = i4 + (i5 + -1 << 4) + 16 | 0;
    29990. 

  29990.    } else {
    29991. 

  29991.     i5 = 5192;
    29992. 

  29992.    }
    29993. 

  29993.   } else {
    29994. 

  29994.    i4 = (HEAP32[i6 >> 2] | 0) + (i5 << 4) | 0;
    29995. 

  29995.    i5 = i4 >>> 0 < (HEAP32[i1 + 8 >> 2] | 0) >>> 0 ? i4 : 5192;
    29996. 

  29996.   }
    29997. 

  29997.  } while (0);
    29998. 

  29998.  i4 = i1 + 8 | 0;
    29999. 

  29999.  _luaH_setint(i1, HEAP32[i5 >> 2] | 0, i3, (HEAP32[i4 >> 2] | 0) + -16 | 0);
    30000. 

  30000.  i3 = HEAP32[i4 >> 2] | 0;
    30001. 

  30001.  if ((HEAP32[i3 + -8 >> 2] & 64 | 0) == 0) {
    30002. 

  30002.   i6 = i3;
    30003. 

  30003.   i6 = i6 + -16 | 0;
    30004. 

  30004.   HEAP32[i4 >> 2] = i6;
    30005. 

  30005.   STACKTOP = i2;
    30006. 

  30006.   return;
    30007. 

  30007.  }
    30008. 

  30008.  if ((HEAP8[(HEAP32[i3 + -16 >> 2] | 0) + 5 | 0] & 3) == 0) {
    30009. 

  30009.   i6 = i3;
    30010. 

  30010.   i6 = i6 + -16 | 0;
    30011. 

  30011.   HEAP32[i4 >> 2] = i6;
    30012. 

  30012.   STACKTOP = i2;
    30013. 

  30013.   return;
    30014. 

  30014.  }
    30015. 

  30015.  i5 = HEAP32[i5 >> 2] | 0;
    30016. 

  30016.  if ((HEAP8[i5 + 5 | 0] & 4) == 0) {
    30017. 

  30017.   i6 = i3;
    30018. 

  30018.   i6 = i6 + -16 | 0;
    30019. 

  30019.   HEAP32[i4 >> 2] = i6;
    30020. 

  30020.   STACKTOP = i2;
    30021. 

  30021.   return;
    30022. 

  30022.  }
    30023. 

  30023.  _luaC_barrierback_(i1, i5);
    30024. 

  30024.  i6 = HEAP32[i4 >> 2] | 0;
    30025. 

  30025.  i6 = i6 + -16 | 0;
    30026. 

  30026.  HEAP32[i4 >> 2] = i6;
    30027. 

  30027.  STACKTOP = i2;
    30028. 

  30028.  return;
    30029. 

  30029. }
    30030. 

  30030. function _ll_require(i1) {
    30031. 

  30031.  i1 = i1 | 0;
    30032. 

  30032.  var i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0;
    30033. 

  30033.  i2 = STACKTOP;
    30034. 

  30034.  STACKTOP = STACKTOP + 1056 | 0;
    30035. 

  30035.  i5 = i2;
    30036. 

  30036.  i4 = i2 + 8 | 0;
    30037. 

  30037.  i3 = _luaL_checklstring(i1, 1, 0) | 0;
    30038. 

  30038.  _lua_settop(i1, 1);
    30039. 

  30039.  _lua_getfield(i1, -1001e3, 4576);
    30040. 

  30040.  _lua_getfield(i1, 2, i3);
    30041. 

  30041.  if ((_lua_toboolean(i1, -1) | 0) != 0) {
    30042. 

  30042.   STACKTOP = i2;
    30043. 

  30043.   return 1;
    30044. 

  30044.  }
    30045. 

  30045.  _lua_settop(i1, -2);
    30046. 

  30046.  _luaL_buffinit(i1, i4);
    30047. 

  30047.  _lua_getfield(i1, -1001001, 4240);
    30048. 

  30048.  if ((_lua_type(i1, 3) | 0) == 5) {
    30049. 

  30049.   i6 = 1;
    30050. 

  30050.  } else {
    30051. 

  30051.   _luaL_error(i1, 4656, i5) | 0;
    30052. 

  30052.   i6 = 1;
    30053. 

  30053.  }
    30054. 

  30054.  while (1) {
    30055. 

  30055.   _lua_rawgeti(i1, 3, i6);
    30056. 

  30056.   if ((_lua_type(i1, -1) | 0) == 0) {
    30057. 

  30057.    _lua_settop(i1, -2);
    30058. 

  30058.    _luaL_pushresult(i4);
    30059. 

  30059.    i7 = _lua_tolstring(i1, -1, 0) | 0;
    30060. 

  30060.    HEAP32[i5 >> 2] = i3;
    30061. 

  30061.    HEAP32[i5 + 4 >> 2] = i7;
    30062. 

  30062.    _luaL_error(i1, 4696, i5) | 0;
    30063. 

  30063.   }
    30064. 

  30064.   _lua_pushstring(i1, i3) | 0;
    30065. 

  30065.   _lua_callk(i1, 1, 2, 0, 0);
    30066. 

  30066.   if ((_lua_type(i1, -2) | 0) == 6) {
    30067. 

  30067.    break;
    30068. 

  30068.   }
    30069. 

  30069.   if ((_lua_isstring(i1, -2) | 0) == 0) {
    30070. 

  30070.    _lua_settop(i1, -3);
    30071. 

  30071.   } else {
    30072. 

  30072.    _lua_settop(i1, -2);
    30073. 

  30073.    _luaL_addvalue(i4);
    30074. 

  30074.   }
    30075. 

  30075.   i6 = i6 + 1 | 0;
    30076. 

  30076.  }
    30077. 

  30077.  _lua_pushstring(i1, i3) | 0;
    30078. 

  30078.  _lua_insert(i1, -2);
    30079. 

  30079.  _lua_callk(i1, 2, 1, 0, 0);
    30080. 

  30080.  if ((_lua_type(i1, -1) | 0) != 0) {
    30081. 

  30081.   _lua_setfield(i1, 2, i3);
    30082. 

  30082.  }
    30083. 

  30083.  _lua_getfield(i1, 2, i3);
    30084. 

  30084.  if ((_lua_type(i1, -1) | 0) != 0) {
    30085. 

  30085.   STACKTOP = i2;
    30086. 

  30086.   return 1;
    30087. 

  30087.  }
    30088. 

  30088.  _lua_pushboolean(i1, 1);
    30089. 

  30089.  _lua_pushvalue(i1, -1);
    30090. 

  30090.  _lua_setfield(i1, 2, i3);
    30091. 

  30091.  STACKTOP = i2;
    30092. 

  30092.  return 1;
    30093. 

  30093. }
    30094. 

  30094. function _f_parser(i1, i3) {
    30095. 

  30095.  i1 = i1 | 0;
    30096. 

  30096.  i3 = i3 | 0;
    30097. 

  30097.  var i2 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0;
    30098. 

  30098.  i2 = STACKTOP;
    30099. 

  30099.  STACKTOP = STACKTOP + 16 | 0;
    30100. 

  30100.  i4 = i2;
    30101. 

  30101.  i5 = HEAP32[i3 >> 2] | 0;
    30102. 

  30102.  i8 = HEAP32[i5 >> 2] | 0;
    30103. 

  30103.  HEAP32[i5 >> 2] = i8 + -1;
    30104. 

  30104.  if ((i8 | 0) == 0) {
    30105. 

  30105.   i6 = _luaZ_fill(i5) | 0;
    30106. 

  30106.  } else {
    30107. 

  30107.   i8 = i5 + 4 | 0;
    30108. 

  30108.   i6 = HEAP32[i8 >> 2] | 0;
    30109. 

  30109.   HEAP32[i8 >> 2] = i6 + 1;
    30110. 

  30110.   i6 = HEAPU8[i6] | 0;
    30111. 

  30111.  }
    30112. 

  30112.  i5 = HEAP32[i3 + 52 >> 2] | 0;
    30113. 

  30113.  i7 = (i5 | 0) == 0;
    30114. 

  30114.  if ((i6 | 0) == 27) {
    30115. 

  30115.   if (!i7 ? (_strchr(i5, 98) | 0) == 0 : 0) {
    30116. 

  30116.    HEAP32[i4 >> 2] = 2360;
    30117. 

  30117.    HEAP32[i4 + 4 >> 2] = i5;
    30118. 

  30118.    _luaO_pushfstring(i1, 2376, i4) | 0;
    30119. 

  30119.    _luaD_throw(i1, 3);
    30120. 

  30120.   }
    30121. 

  30121.   i8 = _luaU_undump(i1, HEAP32[i3 >> 2] | 0, i3 + 4 | 0, HEAP32[i3 + 56 >> 2] | 0) | 0;
    30122. 

  30122.  } else {
    30123. 

  30123.   if (!i7 ? (_strchr(i5, 116) | 0) == 0 : 0) {
    30124. 

  30124.    HEAP32[i4 >> 2] = 2368;
    30125. 

  30125.    HEAP32[i4 + 4 >> 2] = i5;
    30126. 

  30126.    _luaO_pushfstring(i1, 2376, i4) | 0;
    30127. 

  30127.    _luaD_throw(i1, 3);
    30128. 

  30128.   }
    30129. 

  30129.   i8 = _luaY_parser(i1, HEAP32[i3 >> 2] | 0, i3 + 4 | 0, i3 + 16 | 0, HEAP32[i3 + 56 >> 2] | 0, i6) | 0;
    30130. 

  30130.  }
    30131. 

  30131.  i7 = i8 + 6 | 0;
    30132. 

  30132.  if ((HEAP8[i7] | 0) == 0) {
    30133. 

  30133.   STACKTOP = i2;
    30134. 

  30134.   return;
    30135. 

  30135.  }
    30136. 

  30136.  i5 = i8 + 16 | 0;
    30137. 

  30137.  i6 = i8 + 5 | 0;
    30138. 

  30138.  i4 = 0;
    30139. 

  30139.  do {
    30140. 

  30140.   i3 = _luaF_newupval(i1) | 0;
    30141. 

  30141.   HEAP32[i5 + (i4 << 2) >> 2] = i3;
    30142. 

  30142.   if (!((HEAP8[i3 + 5 | 0] & 3) == 0) ? !((HEAP8[i6] & 4) == 0) : 0) {
    30143. 

  30143.    _luaC_barrier_(i1, i8, i3);
    30144. 

  30144.   }
    30145. 

  30145.   i4 = i4 + 1 | 0;
    30146. 

  30146.  } while ((i4 | 0) < (HEAPU8[i7] | 0));
    30147. 

  30147.  STACKTOP = i2;
    30148. 

  30148.  return;
    30149. 

  30149. }
    30150. 

  30150. function _str_rep(i9) {
    30151. 

  30151.  i9 = i9 | 0;
    30152. 

  30152.  var i1 = 0, i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i10 = 0, i11 = 0, i12 = 0;
    30153. 

  30153.  i6 = STACKTOP;
    30154. 

  30154.  STACKTOP = STACKTOP + 1056 | 0;
    30155. 

  30155.  i4 = i6;
    30156. 

  30156.  i2 = i6 + 1044 | 0;
    30157. 

  30157.  i3 = i6 + 1040 | 0;
    30158. 

  30158.  i1 = _luaL_checklstring(i9, 1, i2) | 0;
    30159. 

  30159.  i8 = _luaL_checkinteger(i9, 2) | 0;
    30160. 

  30160.  i5 = _luaL_optlstring(i9, 3, 7040, i3) | 0;
    30161. 

  30161.  if ((i8 | 0) < 1) {
    30162. 

  30162.   _lua_pushlstring(i9, 7040, 0) | 0;
    30163. 

  30163.   i12 = 1;
    30164. 

  30164.   STACKTOP = i6;
    30165. 

  30165.   return i12 | 0;
    30166. 

  30166.  }
    30167. 

  30167.  i7 = HEAP32[i2 >> 2] | 0;
    30168. 

  30168.  i10 = HEAP32[i3 >> 2] | 0;
    30169. 

  30169.  i11 = i10 + i7 | 0;
    30170. 

  30170.  if (!(i11 >>> 0 < i7 >>> 0) ? i11 >>> 0 < (2147483647 / (i8 >>> 0) | 0) >>> 0 : 0) {
    30171. 

  30171.   i7 = (Math_imul(i10, i8 + -1 | 0) | 0) + (Math_imul(i7, i8) | 0) | 0;
    30172. 

  30172.   i11 = _luaL_buffinitsize(i9, i4, i7) | 0;
    30173. 

  30173.   _memcpy(i11 | 0, i1 | 0, HEAP32[i2 >> 2] | 0) | 0;
    30174. 

  30174.   if ((i8 | 0) > 1) {
    30175. 

  30175.    while (1) {
    30176. 

  30176.     i8 = i8 + -1 | 0;
    30177. 

  30177.     i9 = HEAP32[i2 >> 2] | 0;
    30178. 

  30178.     i10 = i11 + i9 | 0;
    30179. 

  30179.     i12 = HEAP32[i3 >> 2] | 0;
    30180. 

  30180.     if ((i12 | 0) == 0) {
    30181. 

  30181.      i12 = i9;
    30182. 

  30182.     } else {
    30183. 

  30183.      _memcpy(i10 | 0, i5 | 0, i12 | 0) | 0;
    30184. 

  30184.      i12 = HEAP32[i2 >> 2] | 0;
    30185. 

  30185.      i10 = i11 + ((HEAP32[i3 >> 2] | 0) + i9) | 0;
    30186. 

  30186.     }
    30187. 

  30187.     _memcpy(i10 | 0, i1 | 0, i12 | 0) | 0;
    30188. 

  30188.     if ((i8 | 0) <= 1) {
    30189. 

  30189.      break;
    30190. 

  30190.     } else {
    30191. 

  30191.      i11 = i10;
    30192. 

  30192.     }
    30193. 

  30193.    }
    30194. 

  30194.   }
    30195. 

  30195.   _luaL_pushresultsize(i4, i7);
    30196. 

  30196.   i12 = 1;
    30197. 

  30197.   STACKTOP = i6;
    30198. 

  30198.   return i12 | 0;
    30199. 

  30199.  }
    30200. 

  30200.  i12 = _luaL_error(i9, 7168, i4) | 0;
    30201. 

  30201.  STACKTOP = i6;
    30202. 

  30202.  return i12 | 0;
    30203. 

  30203. }
    30204. 

  30204. function ___strchrnul(i6, i2) {
    30205. 

  30205.  i6 = i6 | 0;
    30206. 

  30206.  i2 = i2 | 0;
    30207. 

  30207.  var i1 = 0, i3 = 0, i4 = 0, i5 = 0, i7 = 0;
    30208. 

  30208.  i1 = STACKTOP;
    30209. 

  30209.  i3 = i2 & 255;
    30210. 

  30210.  if ((i3 | 0) == 0) {
    30211. 

  30211.   i7 = i6 + (_strlen(i6 | 0) | 0) | 0;
    30212. 

  30212.   STACKTOP = i1;
    30213. 

  30213.   return i7 | 0;
    30214. 

  30214.  }
    30215. 

  30215.  L5 : do {
    30216. 

  30216.   if ((i6 & 3 | 0) != 0) {
    30217. 

  30217.    i4 = i2 & 255;
    30218. 

  30218.    while (1) {
    30219. 

  30219.     i5 = HEAP8[i6] | 0;
    30220. 

  30220.     if (i5 << 24 >> 24 == 0) {
    30221. 

  30221.      i4 = i6;
    30222. 

  30222.      i5 = 13;
    30223. 

  30223.      break;
    30224. 

  30224.     }
    30225. 

  30225.     i7 = i6 + 1 | 0;
    30226. 

  30226.     if (i5 << 24 >> 24 == i4 << 24 >> 24) {
    30227. 

  30227.      i4 = i6;
    30228. 

  30228.      i5 = 13;
    30229. 

  30229.      break;
    30230. 

  30230.     }
    30231. 

  30231.     if ((i7 & 3 | 0) == 0) {
    30232. 

  30232.      i4 = i7;
    30233. 

  30233.      break L5;
    30234. 

  30234.     } else {
    30235. 

  30235.      i6 = i7;
    30236. 

  30236.     }
    30237. 

  30237.    }
    30238. 

  30238.    if ((i5 | 0) == 13) {
    30239. 

  30239.     STACKTOP = i1;
    30240. 

  30240.     return i4 | 0;
    30241. 

  30241.    }
    30242. 

  30242.   } else {
    30243. 

  30243.    i4 = i6;
    30244. 

  30244.   }
    30245. 

  30245.  } while (0);
    30246. 

  30246.  i3 = Math_imul(i3, 16843009) | 0;
    30247. 

  30247.  i6 = HEAP32[i4 >> 2] | 0;
    30248. 

  30248.  L15 : do {
    30249. 

  30249.   if (((i6 & -2139062144 ^ -2139062144) & i6 + -16843009 | 0) == 0) {
    30250. 

  30250.    while (1) {
    30251. 

  30251.     i7 = i6 ^ i3;
    30252. 

  30252.     i5 = i4 + 4 | 0;
    30253. 

  30253.     if (((i7 & -2139062144 ^ -2139062144) & i7 + -16843009 | 0) != 0) {
    30254. 

  30254.      break L15;
    30255. 

  30255.     }
    30256. 

  30256.     i6 = HEAP32[i5 >> 2] | 0;
    30257. 

  30257.     if (((i6 & -2139062144 ^ -2139062144) & i6 + -16843009 | 0) == 0) {
    30258. 

  30258.      i4 = i5;
    30259. 

  30259.     } else {
    30260. 

  30260.      i4 = i5;
    30261. 

  30261.      break;
    30262. 

  30262.     }
    30263. 

  30263.    }
    30264. 

  30264.   }
    30265. 

  30265.  } while (0);
    30266. 

  30266.  i2 = i2 & 255;
    30267. 

  30267.  while (1) {
    30268. 

  30268.   i7 = HEAP8[i4] | 0;
    30269. 

  30269.   if (i7 << 24 >> 24 == 0 | i7 << 24 >> 24 == i2 << 24 >> 24) {
    30270. 

  30270.    break;
    30271. 

  30271.   } else {
    30272. 

  30272.    i4 = i4 + 1 | 0;
    30273. 

  30273.   }
    30274. 

  30274.  }
    30275. 

  30275.  STACKTOP = i1;
    30276. 

  30276.  return i4 | 0;
    30277. 

  30277. }
    30278. 

  30278. function _lua_replace(i2, i6) {
    30279. 

  30279.  i2 = i2 | 0;
    30280. 

  30280.  i6 = i6 | 0;
    30281. 

  30281.  var i1 = 0, i3 = 0, i4 = 0, i5 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0;
    30282. 

  30282.  i3 = STACKTOP;
    30283. 

  30283.  i7 = i2 + 8 | 0;
    30284. 

  30284.  i9 = HEAP32[i7 >> 2] | 0;
    30285. 

  30285.  i5 = i9 + -16 | 0;
    30286. 

  30286.  i4 = i2 + 16 | 0;
    30287. 

  30287.  i12 = HEAP32[i4 >> 2] | 0;
    30288. 

  30288.  do {
    30289. 

  30289.   if ((i6 | 0) <= 0) {
    30290. 

  30290.    if (!((i6 | 0) < -1000999)) {
    30291. 

  30291.     i10 = i9 + (i6 << 4) | 0;
    30292. 

  30292.     break;
    30293. 

  30293.    }
    30294. 

  30294.    if ((i6 | 0) == -1001e3) {
    30295. 

  30295.     i10 = (HEAP32[i2 + 12 >> 2] | 0) + 40 | 0;
    30296. 

  30296.     break;
    30297. 

  30297.    }
    30298. 

  30298.    i11 = -1001e3 - i6 | 0;
    30299. 

  30299.    i12 = HEAP32[i12 >> 2] | 0;
    30300. 

  30300.    if ((HEAP32[i12 + 8 >> 2] | 0) != 22 ? (i10 = HEAP32[i12 >> 2] | 0, (i11 | 0) <= (HEAPU8[i10 + 6 | 0] | 0 | 0)) : 0) {
    30301. 

  30301.     i10 = i10 + (i11 + -1 << 4) + 16 | 0;
    30302. 

  30302.    } else {
    30303. 

  30303.     i10 = 5192;
    30304. 

  30304.    }
    30305. 

  30305.   } else {
    30306. 

  30306.    i10 = (HEAP32[i12 >> 2] | 0) + (i6 << 4) | 0;
    30307. 

  30307.    i10 = i10 >>> 0 < i9 >>> 0 ? i10 : 5192;
    30308. 

  30308.   }
    30309. 

  30309.  } while (0);
    30310. 

  30310.  i13 = i5;
    30311. 

  30311.  i11 = HEAP32[i13 + 4 >> 2] | 0;
    30312. 

  30312.  i12 = i10;
    30313. 

  30313.  HEAP32[i12 >> 2] = HEAP32[i13 >> 2];
    30314. 

  30314.  HEAP32[i12 + 4 >> 2] = i11;
    30315. 

  30315.  i9 = i9 + -8 | 0;
    30316. 

  30316.  HEAP32[i10 + 8 >> 2] = HEAP32[i9 >> 2];
    30317. 

  30317.  if ((((i6 | 0) < -1001e3 ? (HEAP32[i9 >> 2] & 64 | 0) != 0 : 0) ? (i1 = HEAP32[i5 >> 2] | 0, !((HEAP8[i1 + 5 | 0] & 3) == 0)) : 0) ? (i8 = HEAP32[HEAP32[HEAP32[i4 >> 2] >> 2] >> 2] | 0, !((HEAP8[i8 + 5 | 0] & 4) == 0)) : 0) {
    30318. 

  30318.   _luaC_barrier_(i2, i8, i1);
    30319. 

  30319.  }
    30320. 

  30320.  HEAP32[i7 >> 2] = (HEAP32[i7 >> 2] | 0) + -16;
    30321. 

  30321.  STACKTOP = i3;
    30322. 

  30322.  return;
    30323. 

  30323. }
    30324. 

  30324. function _memchr(i4, i3, i6) {
    30325. 

  30325.  i4 = i4 | 0;
    30326. 

  30326.  i3 = i3 | 0;
    30327. 

  30327.  i6 = i6 | 0;
    30328. 

  30328.  var i1 = 0, i2 = 0, i5 = 0, i7 = 0;
    30329. 

  30329.  i1 = STACKTOP;
    30330. 

  30330.  i2 = i3 & 255;
    30331. 

  30331.  i7 = (i6 | 0) == 0;
    30332. 

  30332.  L1 : do {
    30333. 

  30333.   if ((i4 & 3 | 0) == 0 | i7) {
    30334. 

  30334.    i5 = i6;
    30335. 

  30335.    i6 = 5;
    30336. 

  30336.   } else {
    30337. 

  30337.    i5 = i3 & 255;
    30338. 

  30338.    while (1) {
    30339. 

  30339.     if ((HEAP8[i4] | 0) == i5 << 24 >> 24) {
    30340. 

  30340.      i5 = i6;
    30341. 

  30341.      i6 = 6;
    30342. 

  30342.      break L1;
    30343. 

  30343.     }
    30344. 

  30344.     i4 = i4 + 1 | 0;
    30345. 

  30345.     i6 = i6 + -1 | 0;
    30346. 

  30346.     i7 = (i6 | 0) == 0;
    30347. 

  30347.     if ((i4 & 3 | 0) == 0 | i7) {
    30348. 

  30348.      i5 = i6;
    30349. 

  30349.      i6 = 5;
    30350. 

  30350.      break;
    30351. 

  30351.     }
    30352. 

  30352.    }
    30353. 

  30353.   }
    30354. 

  30354.  } while (0);
    30355. 

  30355.  if ((i6 | 0) == 5) {
    30356. 

  30356.   if (i7) {
    30357. 

  30357.    i5 = 0;
    30358. 

  30358.   } else {
    30359. 

  30359.    i6 = 6;
    30360. 

  30360.   }
    30361. 

  30361.  }
    30362. 

  30362.  L8 : do {
    30363. 

  30363.   if ((i6 | 0) == 6) {
    30364. 

  30364.    i3 = i3 & 255;
    30365. 

  30365.    if (!((HEAP8[i4] | 0) == i3 << 24 >> 24)) {
    30366. 

  30366.     i2 = Math_imul(i2, 16843009) | 0;
    30367. 

  30367.     L11 : do {
    30368. 

  30368.      if (i5 >>> 0 > 3) {
    30369. 

  30369.       do {
    30370. 

  30370.        i7 = HEAP32[i4 >> 2] ^ i2;
    30371. 

  30371.        if (((i7 & -2139062144 ^ -2139062144) & i7 + -16843009 | 0) != 0) {
    30372. 

  30372.         break L11;
    30373. 

  30373.        }
    30374. 

  30374.        i4 = i4 + 4 | 0;
    30375. 

  30375.        i5 = i5 + -4 | 0;
    30376. 

  30376.       } while (i5 >>> 0 > 3);
    30377. 

  30377.      }
    30378. 

  30378.     } while (0);
    30379. 

  30379.     if ((i5 | 0) == 0) {
    30380. 

  30380.      i5 = 0;
    30381. 

  30381.     } else {
    30382. 

  30382.      while (1) {
    30383. 

  30383.       if ((HEAP8[i4] | 0) == i3 << 24 >> 24) {
    30384. 

  30384.        break L8;
    30385. 

  30385.       }
    30386. 

  30386.       i4 = i4 + 1 | 0;
    30387. 

  30387.       i5 = i5 + -1 | 0;
    30388. 

  30388.       if ((i5 | 0) == 0) {
    30389. 

  30389.        i5 = 0;
    30390. 

  30390.        break;
    30391. 

  30391.       }
    30392. 

  30392.      }
    30393. 

  30393.     }
    30394. 

  30394.    }
    30395. 

  30395.   }
    30396. 

  30396.  } while (0);
    30397. 

  30397.  STACKTOP = i1;
    30398. 

  30398.  return ((i5 | 0) != 0 ? i4 : 0) | 0;
    30399. 

  30399. }
    30400. 

  30400. function _lua_insert(i2, i5) {
    30401. 

  30401.  i2 = i2 | 0;
    30402. 

  30402.  i5 = i5 | 0;
    30403. 

  30403.  var i1 = 0, i3 = 0, i4 = 0, i6 = 0, i7 = 0, i8 = 0;
    30404. 

  30404.  i1 = STACKTOP;
    30405. 

  30405.  i4 = HEAP32[i2 + 16 >> 2] | 0;
    30406. 

  30406.  do {
    30407. 

  30407.   if ((i5 | 0) <= 0) {
    30408. 

  30408.    if (!((i5 | 0) < -1000999)) {
    30409. 

  30409.     i3 = (HEAP32[i2 + 8 >> 2] | 0) + (i5 << 4) | 0;
    30410. 

  30410.     break;
    30411. 

  30411.    }
    30412. 

  30412.    if ((i5 | 0) == -1001e3) {
    30413. 

  30413.     i3 = (HEAP32[i2 + 12 >> 2] | 0) + 40 | 0;
    30414. 

  30414.     break;
    30415. 

  30415.    }
    30416. 

  30416.    i5 = -1001e3 - i5 | 0;
    30417. 

  30417.    i4 = HEAP32[i4 >> 2] | 0;
    30418. 

  30418.    if ((HEAP32[i4 + 8 >> 2] | 0) != 22 ? (i3 = HEAP32[i4 >> 2] | 0, (i5 | 0) <= (HEAPU8[i3 + 6 | 0] | 0 | 0)) : 0) {
    30419. 

  30419.     i3 = i3 + (i5 + -1 << 4) + 16 | 0;
    30420. 

  30420.    } else {
    30421. 

  30421.     i3 = 5192;
    30422. 

  30422.    }
    30423. 

  30423.   } else {
    30424. 

  30424.    i3 = (HEAP32[i4 >> 2] | 0) + (i5 << 4) | 0;
    30425. 

  30425.    i3 = i3 >>> 0 < (HEAP32[i2 + 8 >> 2] | 0) >>> 0 ? i3 : 5192;
    30426. 

  30426.   }
    30427. 

  30427.  } while (0);
    30428. 

  30428.  i2 = i2 + 8 | 0;
    30429. 

  30429.  i4 = HEAP32[i2 >> 2] | 0;
    30430. 

  30430.  if (i4 >>> 0 > i3 >>> 0) {
    30431. 

  30431.   while (1) {
    30432. 

  30432.    i5 = i4 + -16 | 0;
    30433. 

  30433.    i8 = i5;
    30434. 

  30434.    i7 = HEAP32[i8 + 4 >> 2] | 0;
    30435. 

  30435.    i6 = i4;
    30436. 

  30436.    HEAP32[i6 >> 2] = HEAP32[i8 >> 2];
    30437. 

  30437.    HEAP32[i6 + 4 >> 2] = i7;
    30438. 

  30438.    HEAP32[i4 + 8 >> 2] = HEAP32[i4 + -8 >> 2];
    30439. 

  30439.    if (i5 >>> 0 > i3 >>> 0) {
    30440. 

  30440.     i4 = i5;
    30441. 

  30441.    } else {
    30442. 

  30442.     break;
    30443. 

  30443.    }
    30444. 

  30444.   }
    30445. 

  30445.   i4 = HEAP32[i2 >> 2] | 0;
    30446. 

  30446.  }
    30447. 

  30447.  i6 = i4;
    30448. 

  30448.  i7 = HEAP32[i6 + 4 >> 2] | 0;
    30449. 

  30449.  i8 = i3;
    30450. 

  30450.  HEAP32[i8 >> 2] = HEAP32[i6 >> 2];
    30451. 

  30451.  HEAP32[i8 + 4 >> 2] = i7;
    30452. 

  30452.  HEAP32[i3 + 8 >> 2] = HEAP32[i4 + 8 >> 2];
    30453. 

  30453.  STACKTOP = i1;
    30454. 

  30454.  return;
    30455. 

  30455. }
    30456. 

  30456. function _findlocal(i6, i4, i1, i2) {
    30457. 

  30457.  i6 = i6 | 0;
    30458. 

  30458.  i4 = i4 | 0;
    30459. 

  30459.  i1 = i1 | 0;
    30460. 

  30460.  i2 = i2 | 0;
    30461. 

  30461.  var i3 = 0, i5 = 0, i7 = 0, i8 = 0;
    30462. 

  30462.  i3 = STACKTOP;
    30463. 

  30463.  do {
    30464. 

  30464.   if ((HEAP8[i4 + 18 | 0] & 1) == 0) {
    30465. 

  30465.    i7 = (HEAP32[i4 >> 2] | 0) + 16 | 0;
    30466. 

  30466.    i5 = 7;
    30467. 

  30467.   } else {
    30468. 

  30468.    if ((i1 | 0) >= 0) {
    30469. 

  30469.     i8 = HEAP32[i4 + 24 >> 2] | 0;
    30470. 

  30470.     i7 = HEAP32[(HEAP32[HEAP32[i4 >> 2] >> 2] | 0) + 12 >> 2] | 0;
    30471. 

  30471.     i7 = _luaF_getlocalname(i7, i1, ((HEAP32[i4 + 28 >> 2] | 0) - (HEAP32[i7 + 12 >> 2] | 0) >> 2) + -1 | 0) | 0;
    30472. 

  30472.     if ((i7 | 0) == 0) {
    30473. 

  30473.      i7 = i8;
    30474. 

  30474.      i5 = 7;
    30475. 

  30475.      break;
    30476. 

  30476.     } else {
    30477. 

  30477.      break;
    30478. 

  30478.     }
    30479. 

  30479.    }
    30480. 

  30480.    i5 = HEAP32[i4 >> 2] | 0;
    30481. 

  30481.    i6 = HEAPU8[(HEAP32[(HEAP32[i5 >> 2] | 0) + 12 >> 2] | 0) + 76 | 0] | 0;
    30482. 

  30482.    if ((((HEAP32[i4 + 24 >> 2] | 0) - i5 >> 4) - i6 | 0) <= (0 - i1 | 0)) {
    30483. 

  30483.     i8 = 0;
    30484. 

  30484.     STACKTOP = i3;
    30485. 

  30485.     return i8 | 0;
    30486. 

  30486.    }
    30487. 

  30487.    HEAP32[i2 >> 2] = i5 + (i6 - i1 << 4);
    30488. 

  30488.    i8 = 2208;
    30489. 

  30489.    STACKTOP = i3;
    30490. 

  30490.    return i8 | 0;
    30491. 

  30491.   }
    30492. 

  30492.  } while (0);
    30493. 

  30493.  if ((i5 | 0) == 7) {
    30494. 

  30494.   if ((HEAP32[i6 + 16 >> 2] | 0) == (i4 | 0)) {
    30495. 

  30495.    i4 = i6 + 8 | 0;
    30496. 

  30496.   } else {
    30497. 

  30497.    i4 = HEAP32[i4 + 12 >> 2] | 0;
    30498. 

  30498.   }
    30499. 

  30499.   if (((HEAP32[i4 >> 2] | 0) - i7 >> 4 | 0) >= (i1 | 0) & (i1 | 0) > 0) {
    30500. 

  30500.    i8 = i7;
    30501. 

  30501.    i7 = 2192;
    30502. 

  30502.   } else {
    30503. 

  30503.    i8 = 0;
    30504. 

  30504.    STACKTOP = i3;
    30505. 

  30505.    return i8 | 0;
    30506. 

  30506.   }
    30507. 

  30507.  }
    30508. 

  30508.  HEAP32[i2 >> 2] = i8 + (i1 + -1 << 4);
    30509. 

  30509.  i8 = i7;
    30510. 

  30510.  STACKTOP = i3;
    30511. 

  30511.  return i8 | 0;
    30512. 

  30512. }
    30513. 

  30513. function _luaH_setint(i4, i5, i6, i1) {
    30514. 

  30514.  i4 = i4 | 0;
    30515. 

  30515.  i5 = i5 | 0;
    30516. 

  30516.  i6 = i6 | 0;
    30517. 

  30517.  i1 = i1 | 0;
    30518. 

  30518.  var i2 = 0, i3 = 0, d7 = 0.0, i8 = 0, i9 = 0;
    30519. 

  30519.  i2 = STACKTOP;
    30520. 

  30520.  STACKTOP = STACKTOP + 32 | 0;
    30521. 

  30521.  i8 = i2 + 16 | 0;
    30522. 

  30522.  i3 = i2;
    30523. 

  30523.  i9 = i6 + -1 | 0;
    30524. 

  30524.  L1 : do {
    30525. 

  30525.   if (i9 >>> 0 < (HEAP32[i5 + 28 >> 2] | 0) >>> 0) {
    30526. 

  30526.    i9 = (HEAP32[i5 + 12 >> 2] | 0) + (i9 << 4) | 0;
    30527. 

  30527.    i8 = 10;
    30528. 

  30528.   } else {
    30529. 

  30529.    d7 = +(i6 | 0);
    30530. 

  30530.    HEAPF64[i8 >> 3] = d7 + 1.0;
    30531. 

  30531.    i8 = (HEAP32[i8 + 4 >> 2] | 0) + (HEAP32[i8 >> 2] | 0) | 0;
    30532. 

  30532.    if ((i8 | 0) < 0) {
    30533. 

  30533.     i9 = 0 - i8 | 0;
    30534. 

  30534.     i8 = (i8 | 0) == (i9 | 0) ? 0 : i9;
    30535. 

  30535.    }
    30536. 

  30536.    i9 = (HEAP32[i5 + 16 >> 2] | 0) + (((i8 | 0) % ((1 << (HEAPU8[i5 + 7 | 0] | 0)) + -1 | 1 | 0) | 0) << 5) | 0;
    30537. 

  30537.    while (1) {
    30538. 

  30538.     if ((HEAP32[i9 + 24 >> 2] | 0) == 3 ? +HEAPF64[i9 + 16 >> 3] == d7 : 0) {
    30539. 

  30539.      break;
    30540. 

  30540.     }
    30541. 

  30541.     i9 = HEAP32[i9 + 28 >> 2] | 0;
    30542. 

  30542.     if ((i9 | 0) == 0) {
    30543. 

  30543.      i8 = 12;
    30544. 

  30544.      break L1;
    30545. 

  30545.     }
    30546. 

  30546.    }
    30547. 

  30547.    i8 = 10;
    30548. 

  30548.   }
    30549. 

  30549.  } while (0);
    30550. 

  30550.  if ((i8 | 0) == 10) {
    30551. 

  30551.   if ((i9 | 0) == 5192) {
    30552. 

  30552.    d7 = +(i6 | 0);
    30553. 

  30553.    i8 = 12;
    30554. 

  30554.   }
    30555. 

  30555.  }
    30556. 

  30556.  if ((i8 | 0) == 12) {
    30557. 

  30557.   HEAPF64[i3 >> 3] = d7;
    30558. 

  30558.   HEAP32[i3 + 8 >> 2] = 3;
    30559. 

  30559.   i9 = _luaH_newkey(i4, i5, i3) | 0;
    30560. 

  30560.  }
    30561. 

  30561.  i5 = i1;
    30562. 

  30562.  i6 = HEAP32[i5 + 4 >> 2] | 0;
    30563. 

  30563.  i8 = i9;
    30564. 

  30564.  HEAP32[i8 >> 2] = HEAP32[i5 >> 2];
    30565. 

  30565.  HEAP32[i8 + 4 >> 2] = i6;
    30566. 

  30566.  HEAP32[i9 + 8 >> 2] = HEAP32[i1 + 8 >> 2];
    30567. 

  30567.  STACKTOP = i2;
    30568. 

  30568.  return;
    30569. 

  30569. }
    30570. 

  30570. function _lua_tounsignedx(i6, i8, i1) {
    30571. 

  30571.  i6 = i6 | 0;
    30572. 

  30572.  i8 = i8 | 0;
    30573. 

  30573.  i1 = i1 | 0;
    30574. 

  30574.  var i2 = 0, i3 = 0, i4 = 0, i5 = 0, i7 = 0;
    30575. 

  30575.  i2 = STACKTOP;
    30576. 

  30576.  STACKTOP = STACKTOP + 32 | 0;
    30577. 

  30577.  i4 = i2 + 8 | 0;
    30578. 

  30578.  i3 = i2;
    30579. 

  30579.  i7 = HEAP32[i6 + 16 >> 2] | 0;
    30580. 

  30580.  do {
    30581. 

  30581.   if ((i8 | 0) <= 0) {
    30582. 

  30582.    if (!((i8 | 0) < -1000999)) {
    30583. 

  30583.     i5 = (HEAP32[i6 + 8 >> 2] | 0) + (i8 << 4) | 0;
    30584. 

  30584.     break;
    30585. 

  30585.    }
    30586. 

  30586.    if ((i8 | 0) == -1001e3) {
    30587. 

  30587.     i5 = (HEAP32[i6 + 12 >> 2] | 0) + 40 | 0;
    30588. 

  30588.     break;
    30589. 

  30589.    }
    30590. 

  30590.    i6 = -1001e3 - i8 | 0;
    30591. 

  30591.    i7 = HEAP32[i7 >> 2] | 0;
    30592. 

  30592.    if ((HEAP32[i7 + 8 >> 2] | 0) != 22 ? (i5 = HEAP32[i7 >> 2] | 0, (i6 | 0) <= (HEAPU8[i5 + 6 | 0] | 0 | 0)) : 0) {
    30593. 

  30593.     i5 = i5 + (i6 + -1 << 4) + 16 | 0;
    30594. 

  30594.    } else {
    30595. 

  30595.     i5 = 5192;
    30596. 

  30596.    }
    30597. 

  30597.   } else {
    30598. 

  30598.    i5 = (HEAP32[i7 >> 2] | 0) + (i8 << 4) | 0;
    30599. 

  30599.    i5 = i5 >>> 0 < (HEAP32[i6 + 8 >> 2] | 0) >>> 0 ? i5 : 5192;
    30600. 

  30600.   }
    30601. 

  30601.  } while (0);
    30602. 

  30602.  if ((HEAP32[i5 + 8 >> 2] | 0) != 3) {
    30603. 

  30603.   i5 = _luaV_tonumber(i5, i4) | 0;
    30604. 

  30604.   if ((i5 | 0) == 0) {
    30605. 

  30605.    if ((i1 | 0) == 0) {
    30606. 

  30606.     i8 = 0;
    30607. 

  30607.     STACKTOP = i2;
    30608. 

  30608.     return i8 | 0;
    30609. 

  30609.    }
    30610. 

  30610.    HEAP32[i1 >> 2] = 0;
    30611. 

  30611.    i8 = 0;
    30612. 

  30612.    STACKTOP = i2;
    30613. 

  30613.    return i8 | 0;
    30614. 

  30614.   }
    30615. 

  30615.  }
    30616. 

  30616.  HEAPF64[i3 >> 3] = +HEAPF64[i5 >> 3] + 6755399441055744.0;
    30617. 

  30617.  i3 = HEAP32[i3 >> 2] | 0;
    30618. 

  30618.  if ((i1 | 0) == 0) {
    30619. 

  30619.   i8 = i3;
    30620. 

  30620.   STACKTOP = i2;
    30621. 

  30621.   return i8 | 0;
    30622. 

  30622.  }
    30623. 

  30623.  HEAP32[i1 >> 2] = 1;
    30624. 

  30624.  i8 = i3;
    30625. 

  30625.  STACKTOP = i2;
    30626. 

  30626.  return i8 | 0;
    30627. 

  30627. }
    30628. 

  30628. function _luaC_freeallobjects(i1) {
    30629. 

  30629.  i1 = i1 | 0;
    30630. 

  30630.  var i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0;
    30631. 

  30631.  i2 = STACKTOP;
    30632. 

  30632.  i5 = i1 + 12 | 0;
    30633. 

  30633.  i3 = HEAP32[i5 >> 2] | 0;
    30634. 

  30634.  i7 = i3 + 104 | 0;
    30635. 

  30635.  while (1) {
    30636. 

  30636.   i4 = HEAP32[i7 >> 2] | 0;
    30637. 

  30637.   if ((i4 | 0) == 0) {
    30638. 

  30638.    break;
    30639. 

  30639.   } else {
    30640. 

  30640.    i7 = i4;
    30641. 

  30641.   }
    30642. 

  30642.  }
    30643. 

  30643.  i4 = i3 + 72 | 0;
    30644. 

  30644.  i6 = HEAP32[i4 >> 2] | 0;
    30645. 

  30645.  if ((i6 | 0) == 0) {
    30646. 

  30646.   i5 = i3;
    30647. 

  30647.  } else {
    30648. 

  30648.   while (1) {
    30649. 

  30649.    i8 = i6 + 5 | 0;
    30650. 

  30650.    HEAP8[i8] = HEAPU8[i8] | 0 | 8;
    30651. 

  30651.    HEAP32[i4 >> 2] = HEAP32[i6 >> 2];
    30652. 

  30652.    HEAP32[i6 >> 2] = HEAP32[i7 >> 2];
    30653. 

  30653.    HEAP32[i7 >> 2] = i6;
    30654. 

  30654.    i7 = HEAP32[i4 >> 2] | 0;
    30655. 

  30655.    if ((i7 | 0) == 0) {
    30656. 

  30656.     break;
    30657. 

  30657.    } else {
    30658. 

  30658.     i8 = i6;
    30659. 

  30659.     i6 = i7;
    30660. 

  30660.     i7 = i8;
    30661. 

  30661.    }
    30662. 

  30662.   }
    30663. 

  30663.   i5 = HEAP32[i5 >> 2] | 0;
    30664. 

  30664.  }
    30665. 

  30665.  i5 = i5 + 104 | 0;
    30666. 

  30666.  i6 = HEAP32[i5 >> 2] | 0;
    30667. 

  30667.  if ((i6 | 0) != 0) {
    30668. 

  30668.   do {
    30669. 

  30669.    i8 = i6 + 5 | 0;
    30670. 

  30670.    HEAP8[i8] = HEAP8[i8] & 191;
    30671. 

  30671.    _GCTM(i1, 0);
    30672. 

  30672.    i6 = HEAP32[i5 >> 2] | 0;
    30673. 

  30673.   } while ((i6 | 0) != 0);
    30674. 

  30674.  }
    30675. 

  30675.  HEAP8[i3 + 60 | 0] = 3;
    30676. 

  30676.  HEAP8[i3 + 62 | 0] = 0;
    30677. 

  30677.  _sweeplist(i1, i4, -3) | 0;
    30678. 

  30678.  _sweeplist(i1, i3 + 68 | 0, -3) | 0;
    30679. 

  30679.  i4 = i3 + 32 | 0;
    30680. 

  30680.  if ((HEAP32[i4 >> 2] | 0) <= 0) {
    30681. 

  30681.   STACKTOP = i2;
    30682. 

  30682.   return;
    30683. 

  30683.  }
    30684. 

  30684.  i3 = i3 + 24 | 0;
    30685. 

  30685.  i5 = 0;
    30686. 

  30686.  do {
    30687. 

  30687.   _sweeplist(i1, (HEAP32[i3 >> 2] | 0) + (i5 << 2) | 0, -3) | 0;
    30688. 

  30688.   i5 = i5 + 1 | 0;
    30689. 

  30689.  } while ((i5 | 0) < (HEAP32[i4 >> 2] | 0));
    30690. 

  30690.  STACKTOP = i2;
    30691. 

  30691.  return;
    30692. 

  30692. }
    30693. 

  30693. function _strspn(i1, i5) {
    30694. 

  30694.  i1 = i1 | 0;
    30695. 

  30695.  i5 = i5 | 0;
    30696. 

  30696.  var i2 = 0, i3 = 0, i4 = 0, i6 = 0, i7 = 0;
    30697. 

  30697.  i2 = STACKTOP;
    30698. 

  30698.  STACKTOP = STACKTOP + 32 | 0;
    30699. 

  30699.  i3 = i2;
    30700. 

  30700.  HEAP32[i3 + 0 >> 2] = 0;
    30701. 

  30701.  HEAP32[i3 + 4 >> 2] = 0;
    30702. 

  30702.  HEAP32[i3 + 8 >> 2] = 0;
    30703. 

  30703.  HEAP32[i3 + 12 >> 2] = 0;
    30704. 

  30704.  HEAP32[i3 + 16 >> 2] = 0;
    30705. 

  30705.  HEAP32[i3 + 20 >> 2] = 0;
    30706. 

  30706.  HEAP32[i3 + 24 >> 2] = 0;
    30707. 

  30707.  HEAP32[i3 + 28 >> 2] = 0;
    30708. 

  30708.  i4 = HEAP8[i5] | 0;
    30709. 

  30709.  if (i4 << 24 >> 24 == 0) {
    30710. 

  30710.   i6 = 0;
    30711. 

  30711.   STACKTOP = i2;
    30712. 

  30712.   return i6 | 0;
    30713. 

  30713.  }
    30714. 

  30714.  if ((HEAP8[i5 + 1 | 0] | 0) == 0) {
    30715. 

  30715.   i3 = i1;
    30716. 

  30716.   while (1) {
    30717. 

  30717.    if ((HEAP8[i3] | 0) == i4 << 24 >> 24) {
    30718. 

  30718.     i3 = i3 + 1 | 0;
    30719. 

  30719.    } else {
    30720. 

  30720.     break;
    30721. 

  30721.    }
    30722. 

  30722.   }
    30723. 

  30723.   i6 = i3 - i1 | 0;
    30724. 

  30724.   STACKTOP = i2;
    30725. 

  30725.   return i6 | 0;
    30726. 

  30726.  }
    30727. 

  30727.  do {
    30728. 

  30728.   i7 = i4 & 255;
    30729. 

  30729.   i6 = i3 + (i7 >>> 5 << 2) | 0;
    30730. 

  30730.   HEAP32[i6 >> 2] = HEAP32[i6 >> 2] | 1 << (i7 & 31);
    30731. 

  30731.   i5 = i5 + 1 | 0;
    30732. 

  30732.   i4 = HEAP8[i5] | 0;
    30733. 

  30733.  } while (!(i4 << 24 >> 24 == 0));
    30734. 

  30734.  i5 = HEAP8[i1] | 0;
    30735. 

  30735.  L12 : do {
    30736. 

  30736.   if (i5 << 24 >> 24 == 0) {
    30737. 

  30737.    i4 = i1;
    30738. 

  30738.   } else {
    30739. 

  30739.    i4 = i1;
    30740. 

  30740.    while (1) {
    30741. 

  30741.     i7 = i5 & 255;
    30742. 

  30742.     i6 = i4 + 1 | 0;
    30743. 

  30743.     if ((HEAP32[i3 + (i7 >>> 5 << 2) >> 2] & 1 << (i7 & 31) | 0) == 0) {
    30744. 

  30744.      break L12;
    30745. 

  30745.     }
    30746. 

  30746.     i5 = HEAP8[i6] | 0;
    30747. 

  30747.     if (i5 << 24 >> 24 == 0) {
    30748. 

  30748.      i4 = i6;
    30749. 

  30749.      break;
    30750. 

  30750.     } else {
    30751. 

  30751.      i4 = i6;
    30752. 

  30752.     }
    30753. 

  30753.    }
    30754. 

  30754.   }
    30755. 

  30755.  } while (0);
    30756. 

  30756.  i7 = i4 - i1 | 0;
    30757. 

  30757.  STACKTOP = i2;
    30758. 

  30758.  return i7 | 0;
    30759. 

  30759. }
    30760. 

  30760. function _lua_remove(i2, i4) {
    30761. 

  30761.  i2 = i2 | 0;
    30762. 

  30762.  i4 = i4 | 0;
    30763. 

  30763.  var i1 = 0, i3 = 0, i5 = 0, i6 = 0, i7 = 0;
    30764. 

  30764.  i1 = STACKTOP;
    30765. 

  30765.  i5 = HEAP32[i2 + 16 >> 2] | 0;
    30766. 

  30766.  do {
    30767. 

  30767.   if ((i4 | 0) <= 0) {
    30768. 

  30768.    if (!((i4 | 0) < -1000999)) {
    30769. 

  30769.     i3 = (HEAP32[i2 + 8 >> 2] | 0) + (i4 << 4) | 0;
    30770. 

  30770.     break;
    30771. 

  30771.    }
    30772. 

  30772.    if ((i4 | 0) == -1001e3) {
    30773. 

  30773.     i3 = (HEAP32[i2 + 12 >> 2] | 0) + 40 | 0;
    30774. 

  30774.     break;
    30775. 

  30775.    }
    30776. 

  30776.    i4 = -1001e3 - i4 | 0;
    30777. 

  30777.    i5 = HEAP32[i5 >> 2] | 0;
    30778. 

  30778.    if ((HEAP32[i5 + 8 >> 2] | 0) != 22 ? (i3 = HEAP32[i5 >> 2] | 0, (i4 | 0) <= (HEAPU8[i3 + 6 | 0] | 0 | 0)) : 0) {
    30779. 

  30779.     i3 = i3 + (i4 + -1 << 4) + 16 | 0;
    30780. 

  30780.    } else {
    30781. 

  30781.     i3 = 5192;
    30782. 

  30782.    }
    30783. 

  30783.   } else {
    30784. 

  30784.    i3 = (HEAP32[i5 >> 2] | 0) + (i4 << 4) | 0;
    30785. 

  30785.    i3 = i3 >>> 0 < (HEAP32[i2 + 8 >> 2] | 0) >>> 0 ? i3 : 5192;
    30786. 

  30786.   }
    30787. 

  30787.  } while (0);
    30788. 

  30788.  i4 = i3 + 16 | 0;
    30789. 

  30789.  i2 = i2 + 8 | 0;
    30790. 

  30790.  i5 = HEAP32[i2 >> 2] | 0;
    30791. 

  30791.  if (!(i4 >>> 0 < i5 >>> 0)) {
    30792. 

  30792.   i5 = i5 + -16 | 0;
    30793. 

  30793.   HEAP32[i2 >> 2] = i5;
    30794. 

  30794.   STACKTOP = i1;
    30795. 

  30795.   return;
    30796. 

  30796.  }
    30797. 

  30797.  while (1) {
    30798. 

  30798.   i7 = i4;
    30799. 

  30799.   i6 = HEAP32[i7 + 4 >> 2] | 0;
    30800. 

  30800.   i5 = i3;
    30801. 

  30801.   HEAP32[i5 >> 2] = HEAP32[i7 >> 2];
    30802. 

  30802.   HEAP32[i5 + 4 >> 2] = i6;
    30803. 

  30803.   HEAP32[i3 + 8 >> 2] = HEAP32[i3 + 24 >> 2];
    30804. 

  30804.   i5 = i4 + 16 | 0;
    30805. 

  30805.   i3 = HEAP32[i2 >> 2] | 0;
    30806. 

  30806.   if (i5 >>> 0 < i3 >>> 0) {
    30807. 

  30807.    i3 = i4;
    30808. 

  30808.    i4 = i5;
    30809. 

  30809.   } else {
    30810. 

  30810.    break;
    30811. 

  30811.   }
    30812. 

  30812.  }
    30813. 

  30813.  i7 = i3 + -16 | 0;
    30814. 

  30814.  HEAP32[i2 >> 2] = i7;
    30815. 

  30815.  STACKTOP = i1;
    30816. 

  30816.  return;
    30817. 

  30817. }
    30818. 

  30818. function _luaD_protectedparser(i1, i4, i3, i2) {
    30819. 

  30819.  i1 = i1 | 0;
    30820. 

  30820.  i4 = i4 | 0;
    30821. 

  30821.  i3 = i3 | 0;
    30822. 

  30822.  i2 = i2 | 0;
    30823. 

  30823.  var i5 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0;
    30824. 

  30824.  i5 = STACKTOP;
    30825. 

  30825.  STACKTOP = STACKTOP + 64 | 0;
    30826. 

  30826.  i13 = i5;
    30827. 

  30827.  i6 = i1 + 36 | 0;
    30828. 

  30828.  HEAP16[i6 >> 1] = (HEAP16[i6 >> 1] | 0) + 1 << 16 >> 16;
    30829. 

  30829.  HEAP32[i13 >> 2] = i4;
    30830. 

  30830.  HEAP32[i13 + 56 >> 2] = i3;
    30831. 

  30831.  HEAP32[i13 + 52 >> 2] = i2;
    30832. 

  30832.  i10 = i13 + 16 | 0;
    30833. 

  30833.  HEAP32[i10 >> 2] = 0;
    30834. 

  30834.  i9 = i13 + 24 | 0;
    30835. 

  30835.  HEAP32[i9 >> 2] = 0;
    30836. 

  30836.  i8 = i13 + 28 | 0;
    30837. 

  30837.  HEAP32[i8 >> 2] = 0;
    30838. 

  30838.  i7 = i13 + 36 | 0;
    30839. 

  30839.  HEAP32[i7 >> 2] = 0;
    30840. 

  30840.  i2 = i13 + 40 | 0;
    30841. 

  30841.  HEAP32[i2 >> 2] = 0;
    30842. 

  30842.  i3 = i13 + 48 | 0;
    30843. 

  30843.  HEAP32[i3 >> 2] = 0;
    30844. 

  30844.  i12 = i13 + 4 | 0;
    30845. 

  30845.  HEAP32[i12 >> 2] = 0;
    30846. 

  30846.  i11 = i13 + 12 | 0;
    30847. 

  30847.  HEAP32[i11 >> 2] = 0;
    30848. 

  30848.  i4 = _luaD_pcall(i1, 6, i13, (HEAP32[i1 + 8 >> 2] | 0) - (HEAP32[i1 + 28 >> 2] | 0) | 0, HEAP32[i1 + 68 >> 2] | 0) | 0;
    30849. 

  30849.  HEAP32[i12 >> 2] = _luaM_realloc_(i1, HEAP32[i12 >> 2] | 0, HEAP32[i11 >> 2] | 0, 0) | 0;
    30850. 

  30850.  HEAP32[i11 >> 2] = 0;
    30851. 

  30851.  _luaM_realloc_(i1, HEAP32[i10 >> 2] | 0, HEAP32[i9 >> 2] << 1, 0) | 0;
    30852. 

  30852.  _luaM_realloc_(i1, HEAP32[i8 >> 2] | 0, HEAP32[i7 >> 2] << 4, 0) | 0;
    30853. 

  30853.  _luaM_realloc_(i1, HEAP32[i2 >> 2] | 0, HEAP32[i3 >> 2] << 4, 0) | 0;
    30854. 

  30854.  HEAP16[i6 >> 1] = (HEAP16[i6 >> 1] | 0) + -1 << 16 >> 16;
    30855. 

  30855.  STACKTOP = i5;
    30856. 

  30856.  return i4 | 0;
    30857. 

  30857. }
    30858. 

  30858. function _markmt(i1) {
    30859. 

  30859.  i1 = i1 | 0;
    30860. 

  30860.  var i2 = 0, i3 = 0;
    30861. 

  30861.  i2 = STACKTOP;
    30862. 

  30862.  i3 = HEAP32[i1 + 252 >> 2] | 0;
    30863. 

  30863.  if ((i3 | 0) != 0 ? !((HEAP8[i3 + 5 | 0] & 3) == 0) : 0) {
    30864. 

  30864.   _reallymarkobject(i1, i3);
    30865. 

  30865.  }
    30866. 

  30866.  i3 = HEAP32[i1 + 256 >> 2] | 0;
    30867. 

  30867.  if ((i3 | 0) != 0 ? !((HEAP8[i3 + 5 | 0] & 3) == 0) : 0) {
    30868. 

  30868.   _reallymarkobject(i1, i3);
    30869. 

  30869.  }
    30870. 

  30870.  i3 = HEAP32[i1 + 260 >> 2] | 0;
    30871. 

  30871.  if ((i3 | 0) != 0 ? !((HEAP8[i3 + 5 | 0] & 3) == 0) : 0) {
    30872. 

  30872.   _reallymarkobject(i1, i3);
    30873. 

  30873.  }
    30874. 

  30874.  i3 = HEAP32[i1 + 264 >> 2] | 0;
    30875. 

  30875.  if ((i3 | 0) != 0 ? !((HEAP8[i3 + 5 | 0] & 3) == 0) : 0) {
    30876. 

  30876.   _reallymarkobject(i1, i3);
    30877. 

  30877.  }
    30878. 

  30878.  i3 = HEAP32[i1 + 268 >> 2] | 0;
    30879. 

  30879.  if ((i3 | 0) != 0 ? !((HEAP8[i3 + 5 | 0] & 3) == 0) : 0) {
    30880. 

  30880.   _reallymarkobject(i1, i3);
    30881. 

  30881.  }
    30882. 

  30882.  i3 = HEAP32[i1 + 272 >> 2] | 0;
    30883. 

  30883.  if ((i3 | 0) != 0 ? !((HEAP8[i3 + 5 | 0] & 3) == 0) : 0) {
    30884. 

  30884.   _reallymarkobject(i1, i3);
    30885. 

  30885.  }
    30886. 

  30886.  i3 = HEAP32[i1 + 276 >> 2] | 0;
    30887. 

  30887.  if ((i3 | 0) != 0 ? !((HEAP8[i3 + 5 | 0] & 3) == 0) : 0) {
    30888. 

  30888.   _reallymarkobject(i1, i3);
    30889. 

  30889.  }
    30890. 

  30890.  i3 = HEAP32[i1 + 280 >> 2] | 0;
    30891. 

  30891.  if ((i3 | 0) != 0 ? !((HEAP8[i3 + 5 | 0] & 3) == 0) : 0) {
    30892. 

  30892.   _reallymarkobject(i1, i3);
    30893. 

  30893.  }
    30894. 

  30894.  i3 = HEAP32[i1 + 284 >> 2] | 0;
    30895. 

  30895.  if ((i3 | 0) == 0) {
    30896. 

  30896.   STACKTOP = i2;
    30897. 

  30897.   return;
    30898. 

  30898.  }
    30899. 

  30899.  if ((HEAP8[i3 + 5 | 0] & 3) == 0) {
    30900. 

  30900.   STACKTOP = i2;
    30901. 

  30901.   return;
    30902. 

  30902.  }
    30903. 

  30903.  _reallymarkobject(i1, i3);
    30904. 

  30904.  STACKTOP = i2;
    30905. 

  30905.  return;
    30906. 

  30906. }
    30907. 

  30907. function _findlabel(i9, i2) {
    30908. 

  30908.  i9 = i9 | 0;
    30909. 

  30909.  i2 = i2 | 0;
    30910. 

  30910.  var i1 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0, i14 = 0, i15 = 0;
    30911. 

  30911.  i1 = STACKTOP;
    30912. 

  30912.  i3 = i9 + 48 | 0;
    30913. 

  30913.  i7 = HEAP32[(HEAP32[i3 >> 2] | 0) + 16 >> 2] | 0;
    30914. 

  30914.  i10 = HEAP32[i9 + 64 >> 2] | 0;
    30915. 

  30915.  i4 = HEAP32[i10 + 12 >> 2] | 0;
    30916. 

  30916.  i6 = i7 + 4 | 0;
    30917. 

  30917.  i13 = HEAP16[i6 >> 1] | 0;
    30918. 

  30918.  i5 = i10 + 28 | 0;
    30919. 

  30919.  if ((i13 | 0) >= (HEAP32[i5 >> 2] | 0)) {
    30920. 

  30920.   i15 = 0;
    30921. 

  30921.   STACKTOP = i1;
    30922. 

  30922.   return i15 | 0;
    30923. 

  30923.  }
    30924. 

  30924.  i10 = i10 + 24 | 0;
    30925. 

  30925.  i11 = i4 + (i2 << 4) | 0;
    30926. 

  30926.  while (1) {
    30927. 

  30927.   i14 = HEAP32[i10 >> 2] | 0;
    30928. 

  30928.   i12 = i14 + (i13 << 4) | 0;
    30929. 

  30929.   i15 = i13 + 1 | 0;
    30930. 

  30930.   if ((_luaS_eqstr(HEAP32[i12 >> 2] | 0, HEAP32[i11 >> 2] | 0) | 0) != 0) {
    30931. 

  30931.    break;
    30932. 

  30932.   }
    30933. 

  30933.   if ((i15 | 0) < (HEAP32[i5 >> 2] | 0)) {
    30934. 

  30934.    i13 = i15;
    30935. 

  30935.   } else {
    30936. 

  30936.    i2 = 0;
    30937. 

  30937.    i8 = 10;
    30938. 

  30938.    break;
    30939. 

  30939.   }
    30940. 

  30940.  }
    30941. 

  30941.  if ((i8 | 0) == 10) {
    30942. 

  30942.   STACKTOP = i1;
    30943. 

  30943.   return i2 | 0;
    30944. 

  30944.  }
    30945. 

  30945.  i8 = HEAP8[i14 + (i13 << 4) + 12 | 0] | 0;
    30946. 

  30946.  do {
    30947. 

  30947.   if ((HEAPU8[i4 + (i2 << 4) + 12 | 0] | 0) > (i8 & 255)) {
    30948. 

  30948.    if ((HEAP8[i7 + 9 | 0] | 0) == 0 ? (HEAP32[i5 >> 2] | 0) <= (HEAP16[i6 >> 1] | 0) : 0) {
    30949. 

  30949.     break;
    30950. 

  30950.    }
    30951. 

  30951.    _luaK_patchclose(HEAP32[i3 >> 2] | 0, HEAP32[i4 + (i2 << 4) + 4 >> 2] | 0, i8 & 255);
    30952. 

  30952.   }
    30953. 

  30953.  } while (0);
    30954. 

  30954.  _closegoto(i9, i2, i12);
    30955. 

  30955.  i15 = 1;
    30956. 

  30956.  STACKTOP = i1;
    30957. 

  30957.  return i15 | 0;
    30958. 

  30958. }
    30959. 

  30959. function _lua_getmetatable(i1, i5) {
    30960. 

  30960.  i1 = i1 | 0;
    30961. 

  30961.  i5 = i5 | 0;
    30962. 

  30962.  var i2 = 0, i3 = 0, i4 = 0;
    30963. 

  30963.  i2 = STACKTOP;
    30964. 

  30964.  i4 = HEAP32[i1 + 16 >> 2] | 0;
    30965. 

  30965.  do {
    30966. 

  30966.   if ((i5 | 0) <= 0) {
    30967. 

  30967.    if (!((i5 | 0) < -1000999)) {
    30968. 

  30968.     i4 = (HEAP32[i1 + 8 >> 2] | 0) + (i5 << 4) | 0;
    30969. 

  30969.     break;
    30970. 

  30970.    }
    30971. 

  30971.    if ((i5 | 0) == -1001e3) {
    30972. 

  30972.     i4 = (HEAP32[i1 + 12 >> 2] | 0) + 40 | 0;
    30973. 

  30973.     break;
    30974. 

  30974.    }
    30975. 

  30975.    i5 = -1001e3 - i5 | 0;
    30976. 

  30976.    i4 = HEAP32[i4 >> 2] | 0;
    30977. 

  30977.    if ((HEAP32[i4 + 8 >> 2] | 0) != 22 ? (i3 = HEAP32[i4 >> 2] | 0, (i5 | 0) <= (HEAPU8[i3 + 6 | 0] | 0 | 0)) : 0) {
    30978. 

  30978.     i4 = i3 + (i5 + -1 << 4) + 16 | 0;
    30979. 

  30979.    } else {
    30980. 

  30980.     i4 = 5192;
    30981. 

  30981.    }
    30982. 

  30982.   } else {
    30983. 

  30983.    i3 = (HEAP32[i4 >> 2] | 0) + (i5 << 4) | 0;
    30984. 

  30984.    i4 = i3 >>> 0 < (HEAP32[i1 + 8 >> 2] | 0) >>> 0 ? i3 : 5192;
    30985. 

  30985.   }
    30986. 

  30986.  } while (0);
    30987. 

  30987.  i3 = HEAP32[i4 + 8 >> 2] & 15;
    30988. 

  30988.  if ((i3 | 0) == 7) {
    30989. 

  30989.   i3 = HEAP32[(HEAP32[i4 >> 2] | 0) + 8 >> 2] | 0;
    30990. 

  30990.  } else if ((i3 | 0) == 5) {
    30991. 

  30991.   i3 = HEAP32[(HEAP32[i4 >> 2] | 0) + 8 >> 2] | 0;
    30992. 

  30992.  } else {
    30993. 

  30993.   i3 = HEAP32[(HEAP32[i1 + 12 >> 2] | 0) + (i3 << 2) + 252 >> 2] | 0;
    30994. 

  30994.  }
    30995. 

  30995.  if ((i3 | 0) == 0) {
    30996. 

  30996.   i5 = 0;
    30997. 

  30997.   STACKTOP = i2;
    30998. 

  30998.   return i5 | 0;
    30999. 

  30999.  }
    31000. 

  31000.  i5 = i1 + 8 | 0;
    31001. 

  31001.  i4 = HEAP32[i5 >> 2] | 0;
    31002. 

  31002.  HEAP32[i4 >> 2] = i3;
    31003. 

  31003.  HEAP32[i4 + 8 >> 2] = 69;
    31004. 

  31004.  HEAP32[i5 >> 2] = (HEAP32[i5 >> 2] | 0) + 16;
    31005. 

  31005.  i5 = 1;
    31006. 

  31006.  STACKTOP = i2;
    31007. 

  31007.  return i5 | 0;
    31008. 

  31008. }
    31009. 

  31009. function _str_byte(i2) {
    31010. 

  31010.  i2 = i2 | 0;
    31011. 

  31011.  var i1 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0;
    31012. 

  31012.  i1 = STACKTOP;
    31013. 

  31013.  STACKTOP = STACKTOP + 16 | 0;
    31014. 

  31014.  i6 = i1;
    31015. 

  31015.  i4 = i1 + 4 | 0;
    31016. 

  31016.  i3 = _luaL_checklstring(i2, 1, i4) | 0;
    31017. 

  31017.  i5 = _luaL_optinteger(i2, 2, 1) | 0;
    31018. 

  31018.  i7 = HEAP32[i4 >> 2] | 0;
    31019. 

  31019.  if (!((i5 | 0) > -1)) {
    31020. 

  31020.   if (i7 >>> 0 < (0 - i5 | 0) >>> 0) {
    31021. 

  31021.    i5 = 0;
    31022. 

  31022.   } else {
    31023. 

  31023.    i5 = i5 + 1 + i7 | 0;
    31024. 

  31024.   }
    31025. 

  31025.  }
    31026. 

  31026.  i8 = _luaL_optinteger(i2, 3, i5) | 0;
    31027. 

  31027.  i7 = HEAP32[i4 >> 2] | 0;
    31028. 

  31028.  if (!((i8 | 0) > -1)) {
    31029. 

  31029.   if (i7 >>> 0 < (0 - i8 | 0) >>> 0) {
    31030. 

  31030.    i8 = 0;
    31031. 

  31031.   } else {
    31032. 

  31032.    i8 = i8 + 1 + i7 | 0;
    31033. 

  31033.   }
    31034. 

  31034.  }
    31035. 

  31035.  i9 = (i5 | 0) == 0 ? 1 : i5;
    31036. 

  31036.  i10 = i8 >>> 0 > i7 >>> 0 ? i7 : i8;
    31037. 

  31037.  if (i9 >>> 0 > i10 >>> 0) {
    31038. 

  31038.   i10 = 0;
    31039. 

  31039.   STACKTOP = i1;
    31040. 

  31040.   return i10 | 0;
    31041. 

  31041.  }
    31042. 

  31042.  i4 = i10 - i9 + 1 | 0;
    31043. 

  31043.  if ((i10 | 0) == -1) {
    31044. 

  31044.   i10 = _luaL_error(i2, 7944, i6) | 0;
    31045. 

  31045.   STACKTOP = i1;
    31046. 

  31046.   return i10 | 0;
    31047. 

  31047.  }
    31048. 

  31048.  _luaL_checkstack(i2, i4, 7944);
    31049. 

  31049.  if ((i4 | 0) <= 0) {
    31050. 

  31050.   i10 = i4;
    31051. 

  31051.   STACKTOP = i1;
    31052. 

  31052.   return i10 | 0;
    31053. 

  31053.  }
    31054. 

  31054.  i6 = i9 + -1 | 0;
    31055. 

  31055.  i8 = ~i8;
    31056. 

  31056.  i7 = ~i7;
    31057. 

  31057.  i5 = 0 - (i8 >>> 0 > i7 >>> 0 ? i8 : i7) - (i5 >>> 0 > 1 ? i5 : 1) | 0;
    31058. 

  31058.  i7 = 0;
    31059. 

  31059.  do {
    31060. 

  31060.   _lua_pushinteger(i2, HEAPU8[i3 + (i6 + i7) | 0] | 0);
    31061. 

  31061.   i7 = i7 + 1 | 0;
    31062. 

  31062.  } while ((i7 | 0) != (i5 | 0));
    31063. 

  31063.  STACKTOP = i1;
    31064. 

  31064.  return i4 | 0;
    31065. 

  31065. }
    31066. 

  31066. function _lua_setuservalue(i1, i5) {
    31067. 

  31067.  i1 = i1 | 0;
    31068. 

  31068.  i5 = i5 | 0;
    31069. 

  31069.  var i2 = 0, i3 = 0, i4 = 0, i6 = 0;
    31070. 

  31070.  i3 = STACKTOP;
    31071. 

  31071.  i6 = HEAP32[i1 + 16 >> 2] | 0;
    31072. 

  31072.  do {
    31073. 

  31073.   if ((i5 | 0) <= 0) {
    31074. 

  31074.    if (!((i5 | 0) < -1000999)) {
    31075. 

  31075.     i5 = (HEAP32[i1 + 8 >> 2] | 0) + (i5 << 4) | 0;
    31076. 

  31076.     break;
    31077. 

  31077.    }
    31078. 

  31078.    if ((i5 | 0) == -1001e3) {
    31079. 

  31079.     i5 = (HEAP32[i1 + 12 >> 2] | 0) + 40 | 0;
    31080. 

  31080.     break;
    31081. 

  31081.    }
    31082. 

  31082.    i5 = -1001e3 - i5 | 0;
    31083. 

  31083.    i6 = HEAP32[i6 >> 2] | 0;
    31084. 

  31084.    if ((HEAP32[i6 + 8 >> 2] | 0) != 22 ? (i4 = HEAP32[i6 >> 2] | 0, (i5 | 0) <= (HEAPU8[i4 + 6 | 0] | 0 | 0)) : 0) {
    31085. 

  31085.     i5 = i4 + (i5 + -1 << 4) + 16 | 0;
    31086. 

  31086.    } else {
    31087. 

  31087.     i5 = 5192;
    31088. 

  31088.    }
    31089. 

  31089.   } else {
    31090. 

  31090.    i4 = (HEAP32[i6 >> 2] | 0) + (i5 << 4) | 0;
    31091. 

  31091.    i5 = i4 >>> 0 < (HEAP32[i1 + 8 >> 2] | 0) >>> 0 ? i4 : 5192;
    31092. 

  31092.   }
    31093. 

  31093.  } while (0);
    31094. 

  31094.  i4 = i1 + 8 | 0;
    31095. 

  31095.  i6 = HEAP32[i4 >> 2] | 0;
    31096. 

  31096.  if ((HEAP32[i6 + -8 >> 2] | 0) != 0) {
    31097. 

  31097.   HEAP32[(HEAP32[i5 >> 2] | 0) + 12 >> 2] = HEAP32[i6 + -16 >> 2];
    31098. 

  31098.   i6 = HEAP32[(HEAP32[i4 >> 2] | 0) + -16 >> 2] | 0;
    31099. 

  31099.   if (!((HEAP8[i6 + 5 | 0] & 3) == 0) ? (i2 = HEAP32[i5 >> 2] | 0, !((HEAP8[i2 + 5 | 0] & 4) == 0)) : 0) {
    31100. 

  31100.    _luaC_barrier_(i1, i2, i6);
    31101. 

  31101.   }
    31102. 

  31102.  } else {
    31103. 

  31103.   HEAP32[(HEAP32[i5 >> 2] | 0) + 12 >> 2] = 0;
    31104. 

  31104.  }
    31105. 

  31105.  HEAP32[i4 >> 2] = (HEAP32[i4 >> 2] | 0) + -16;
    31106. 

  31106.  STACKTOP = i3;
    31107. 

  31107.  return;
    31108. 

  31108. }
    31109. 

  31109. function _f_luaopen(i1, i2) {
    31110. 

  31110.  i1 = i1 | 0;
    31111. 

  31111.  i2 = i2 | 0;
    31112. 

  31112.  var i3 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0;
    31113. 

  31113.  i6 = STACKTOP;
    31114. 

  31114.  STACKTOP = STACKTOP + 16 | 0;
    31115. 

  31115.  i5 = i6;
    31116. 

  31116.  i4 = HEAP32[i1 + 12 >> 2] | 0;
    31117. 

  31117.  i2 = _luaM_realloc_(i1, 0, 0, 640) | 0;
    31118. 

  31118.  HEAP32[i1 + 28 >> 2] = i2;
    31119. 

  31119.  i3 = i1 + 32 | 0;
    31120. 

  31120.  HEAP32[i3 >> 2] = 40;
    31121. 

  31121.  i7 = 0;
    31122. 

  31122.  do {
    31123. 

  31123.   HEAP32[i2 + (i7 << 4) + 8 >> 2] = 0;
    31124. 

  31124.   i7 = i7 + 1 | 0;
    31125. 

  31125.  } while ((i7 | 0) != 40);
    31126. 

  31126.  HEAP32[i1 + 24 >> 2] = i2 + ((HEAP32[i3 >> 2] | 0) + -5 << 4);
    31127. 

  31127.  i7 = i1 + 72 | 0;
    31128. 

  31128.  HEAP32[i1 + 80 >> 2] = 0;
    31129. 

  31129.  HEAP32[i1 + 84 >> 2] = 0;
    31130. 

  31130.  HEAP8[i1 + 90 | 0] = 0;
    31131. 

  31131.  HEAP32[i7 >> 2] = i2;
    31132. 

  31132.  HEAP32[i1 + 8 >> 2] = i2 + 16;
    31133. 

  31133.  HEAP32[i2 + 8 >> 2] = 0;
    31134. 

  31134.  HEAP32[i1 + 76 >> 2] = i2 + 336;
    31135. 

  31135.  HEAP32[i1 + 16 >> 2] = i7;
    31136. 

  31136.  i7 = _luaH_new(i1) | 0;
    31137. 

  31137.  HEAP32[i4 + 40 >> 2] = i7;
    31138. 

  31138.  HEAP32[i4 + 48 >> 2] = 69;
    31139. 

  31139.  _luaH_resize(i1, i7, 2, 0);
    31140. 

  31140.  HEAP32[i5 >> 2] = i1;
    31141. 

  31141.  i3 = i5 + 8 | 0;
    31142. 

  31142.  HEAP32[i3 >> 2] = 72;
    31143. 

  31143.  _luaH_setint(i1, i7, 1, i5);
    31144. 

  31144.  HEAP32[i5 >> 2] = _luaH_new(i1) | 0;
    31145. 

  31145.  HEAP32[i3 >> 2] = 69;
    31146. 

  31146.  _luaH_setint(i1, i7, 2, i5);
    31147. 

  31147.  _luaS_resize(i1, 32);
    31148. 

  31148.  _luaT_init(i1);
    31149. 

  31149.  _luaX_init(i1);
    31150. 

  31150.  i7 = _luaS_newlstr(i1, 6896, 17) | 0;
    31151. 

  31151.  HEAP32[i4 + 180 >> 2] = i7;
    31152. 

  31152.  i7 = i7 + 5 | 0;
    31153. 

  31153.  HEAP8[i7] = HEAPU8[i7] | 0 | 32;
    31154. 

  31154.  HEAP8[i4 + 63 | 0] = 1;
    31155. 

  31155.  STACKTOP = i6;
    31156. 

  31156.  return;
    31157. 

  31157. }
    31158. 

  31158. function _lua_tointegerx(i6, i7, i1) {
    31159. 

  31159.  i6 = i6 | 0;
    31160. 

  31160.  i7 = i7 | 0;
    31161. 

  31161.  i1 = i1 | 0;
    31162. 

  31162.  var i2 = 0, i3 = 0, i4 = 0, i5 = 0;
    31163. 

  31163.  i2 = STACKTOP;
    31164. 

  31164.  STACKTOP = STACKTOP + 16 | 0;
    31165. 

  31165.  i3 = i2;
    31166. 

  31166.  i5 = HEAP32[i6 + 16 >> 2] | 0;
    31167. 

  31167.  do {
    31168. 

  31168.   if ((i7 | 0) <= 0) {
    31169. 

  31169.    if (!((i7 | 0) < -1000999)) {
    31170. 

  31170.     i4 = (HEAP32[i6 + 8 >> 2] | 0) + (i7 << 4) | 0;
    31171. 

  31171.     break;
    31172. 

  31172.    }
    31173. 

  31173.    if ((i7 | 0) == -1001e3) {
    31174. 

  31174.     i4 = (HEAP32[i6 + 12 >> 2] | 0) + 40 | 0;
    31175. 

  31175.     break;
    31176. 

  31176.    }
    31177. 

  31177.    i6 = -1001e3 - i7 | 0;
    31178. 

  31178.    i5 = HEAP32[i5 >> 2] | 0;
    31179. 

  31179.    if ((HEAP32[i5 + 8 >> 2] | 0) != 22 ? (i4 = HEAP32[i5 >> 2] | 0, (i6 | 0) <= (HEAPU8[i4 + 6 | 0] | 0 | 0)) : 0) {
    31180. 

  31180.     i4 = i4 + (i6 + -1 << 4) + 16 | 0;
    31181. 

  31181.    } else {
    31182. 

  31182.     i4 = 5192;
    31183. 

  31183.    }
    31184. 

  31184.   } else {
    31185. 

  31185.    i4 = (HEAP32[i5 >> 2] | 0) + (i7 << 4) | 0;
    31186. 

  31186.    i4 = i4 >>> 0 < (HEAP32[i6 + 8 >> 2] | 0) >>> 0 ? i4 : 5192;
    31187. 

  31187.   }
    31188. 

  31188.  } while (0);
    31189. 

  31189.  if ((HEAP32[i4 + 8 >> 2] | 0) != 3) {
    31190. 

  31190.   i4 = _luaV_tonumber(i4, i3) | 0;
    31191. 

  31191.   if ((i4 | 0) == 0) {
    31192. 

  31192.    if ((i1 | 0) == 0) {
    31193. 

  31193.     i7 = 0;
    31194. 

  31194.     STACKTOP = i2;
    31195. 

  31195.     return i7 | 0;
    31196. 

  31196.    }
    31197. 

  31197.    HEAP32[i1 >> 2] = 0;
    31198. 

  31198.    i7 = 0;
    31199. 

  31199.    STACKTOP = i2;
    31200. 

  31200.    return i7 | 0;
    31201. 

  31201.   }
    31202. 

  31202.  }
    31203. 

  31203.  i3 = ~~+HEAPF64[i4 >> 3];
    31204. 

  31204.  if ((i1 | 0) == 0) {
    31205. 

  31205.   i7 = i3;
    31206. 

  31206.   STACKTOP = i2;
    31207. 

  31207.   return i7 | 0;
    31208. 

  31208.  }
    31209. 

  31209.  HEAP32[i1 >> 2] = 1;
    31210. 

  31210.  i7 = i3;
    31211. 

  31211.  STACKTOP = i2;
    31212. 

  31212.  return i7 | 0;
    31213. 

  31213. }
    31214. 

  31214. function _close_state(i1) {
    31215. 

  31215.  i1 = i1 | 0;
    31216. 

  31216.  var i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0;
    31217. 

  31217.  i2 = STACKTOP;
    31218. 

  31218.  i6 = i1 + 12 | 0;
    31219. 

  31219.  i3 = HEAP32[i6 >> 2] | 0;
    31220. 

  31220.  i4 = i1 + 28 | 0;
    31221. 

  31221.  _luaF_close(i1, HEAP32[i4 >> 2] | 0);
    31222. 

  31222.  _luaC_freeallobjects(i1);
    31223. 

  31223.  i6 = HEAP32[i6 >> 2] | 0;
    31224. 

  31224.  _luaM_realloc_(i1, HEAP32[i6 + 24 >> 2] | 0, HEAP32[i6 + 32 >> 2] << 2, 0) | 0;
    31225. 

  31225.  i6 = i3 + 144 | 0;
    31226. 

  31226.  i5 = i3 + 152 | 0;
    31227. 

  31227.  HEAP32[i6 >> 2] = _luaM_realloc_(i1, HEAP32[i6 >> 2] | 0, HEAP32[i5 >> 2] | 0, 0) | 0;
    31228. 

  31228.  HEAP32[i5 >> 2] = 0;
    31229. 

  31229.  i5 = HEAP32[i4 >> 2] | 0;
    31230. 

  31230.  if ((i5 | 0) == 0) {
    31231. 

  31231.   i5 = HEAP32[i3 >> 2] | 0;
    31232. 

  31232.   i6 = i3 + 4 | 0;
    31233. 

  31233.   i6 = HEAP32[i6 >> 2] | 0;
    31234. 

  31234.   FUNCTION_TABLE_iiiii[i5 & 3](i6, i1, 400, 0) | 0;
    31235. 

  31235.   STACKTOP = i2;
    31236. 

  31236.   return;
    31237. 

  31237.  }
    31238. 

  31238.  HEAP32[i1 + 16 >> 2] = i1 + 72;
    31239. 

  31239.  i7 = i1 + 84 | 0;
    31240. 

  31240.  i6 = HEAP32[i7 >> 2] | 0;
    31241. 

  31241.  HEAP32[i7 >> 2] = 0;
    31242. 

  31242.  if ((i6 | 0) != 0) {
    31243. 

  31243.   while (1) {
    31244. 

  31244.    i5 = HEAP32[i6 + 12 >> 2] | 0;
    31245. 

  31245.    _luaM_realloc_(i1, i6, 40, 0) | 0;
    31246. 

  31246.    if ((i5 | 0) == 0) {
    31247. 

  31247.     break;
    31248. 

  31248.    } else {
    31249. 

  31249.     i6 = i5;
    31250. 

  31250.    }
    31251. 

  31251.   }
    31252. 

  31252.   i5 = HEAP32[i4 >> 2] | 0;
    31253. 

  31253.  }
    31254. 

  31254.  _luaM_realloc_(i1, i5, HEAP32[i1 + 32 >> 2] << 4, 0) | 0;
    31255. 

  31255.  i6 = HEAP32[i3 >> 2] | 0;
    31256. 

  31256.  i7 = i3 + 4 | 0;
    31257. 

  31257.  i7 = HEAP32[i7 >> 2] | 0;
    31258. 

  31258.  FUNCTION_TABLE_iiiii[i6 & 3](i7, i1, 400, 0) | 0;
    31259. 

  31259.  STACKTOP = i2;
    31260. 

  31260.  return;
    31261. 

  31261. }
    31262. 

  31262. function _ll_module(i1) {
    31263. 

  31263.  i1 = i1 | 0;
    31264. 

  31264.  var i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0;
    31265. 

  31265.  i2 = STACKTOP;
    31266. 

  31266.  STACKTOP = STACKTOP + 112 | 0;
    31267. 

  31267.  i4 = i2;
    31268. 

  31268.  i5 = i2 + 4 | 0;
    31269. 

  31269.  i6 = _luaL_checklstring(i1, 1, 0) | 0;
    31270. 

  31270.  i3 = _lua_gettop(i1) | 0;
    31271. 

  31271.  _luaL_pushmodule(i1, i6, 1);
    31272. 

  31272.  _lua_getfield(i1, -1, 4728);
    31273. 

  31273.  i7 = (_lua_type(i1, -1) | 0) == 0;
    31274. 

  31274.  _lua_settop(i1, -2);
    31275. 

  31275.  if (i7) {
    31276. 

  31276.   _lua_pushvalue(i1, -1);
    31277. 

  31277.   _lua_setfield(i1, -2, 4784);
    31278. 

  31278.   _lua_pushstring(i1, i6) | 0;
    31279. 

  31279.   _lua_setfield(i1, -2, 4728);
    31280. 

  31280.   i7 = _strrchr(i6, 46) | 0;
    31281. 

  31281.   _lua_pushlstring(i1, i6, ((i7 | 0) == 0 ? i6 : i7 + 1 | 0) - i6 | 0) | 0;
    31282. 

  31282.   _lua_setfield(i1, -2, 4792);
    31283. 

  31283.  }
    31284. 

  31284.  _lua_pushvalue(i1, -1);
    31285. 

  31285.  if (!(((_lua_getstack(i1, 1, i5) | 0) != 0 ? (_lua_getinfo(i1, 4736, i5) | 0) != 0 : 0) ? (_lua_iscfunction(i1, -1) | 0) == 0 : 0)) {
    31286. 

  31286.   _luaL_error(i1, 4744, i4) | 0;
    31287. 

  31287.  }
    31288. 

  31288.  _lua_pushvalue(i1, -2);
    31289. 

  31289.  _lua_setupvalue(i1, -2, 1) | 0;
    31290. 

  31290.  _lua_settop(i1, -2);
    31291. 

  31291.  if ((i3 | 0) < 2) {
    31292. 

  31292.   STACKTOP = i2;
    31293. 

  31293.   return 1;
    31294. 

  31294.  } else {
    31295. 

  31295.   i4 = 2;
    31296. 

  31296.  }
    31297. 

  31297.  while (1) {
    31298. 

  31298.   if ((_lua_type(i1, i4) | 0) == 6) {
    31299. 

  31299.    _lua_pushvalue(i1, i4);
    31300. 

  31300.    _lua_pushvalue(i1, -2);
    31301. 

  31301.    _lua_callk(i1, 1, 0, 0, 0);
    31302. 

  31302.   }
    31303. 

  31303.   if ((i4 | 0) == (i3 | 0)) {
    31304. 

  31304.    break;
    31305. 

  31305.   } else {
    31306. 

  31306.    i4 = i4 + 1 | 0;
    31307. 

  31307.   }
    31308. 

  31308.  }
    31309. 

  31309.  STACKTOP = i2;
    31310. 

  31310.  return 1;
    31311. 

  31311. }
    31312. 

  31312. function _strcspn(i2, i5) {
    31313. 

  31313.  i2 = i2 | 0;
    31314. 

  31314.  i5 = i5 | 0;
    31315. 

  31315.  var i1 = 0, i3 = 0, i4 = 0, i6 = 0, i7 = 0;
    31316. 

  31316.  i1 = STACKTOP;
    31317. 

  31317.  STACKTOP = STACKTOP + 32 | 0;
    31318. 

  31318.  i3 = i1;
    31319. 

  31319.  i4 = HEAP8[i5] | 0;
    31320. 

  31320.  if (!(i4 << 24 >> 24 == 0) ? (HEAP8[i5 + 1 | 0] | 0) != 0 : 0) {
    31321. 

  31321.   HEAP32[i3 + 0 >> 2] = 0;
    31322. 

  31322.   HEAP32[i3 + 4 >> 2] = 0;
    31323. 

  31323.   HEAP32[i3 + 8 >> 2] = 0;
    31324. 

  31324.   HEAP32[i3 + 12 >> 2] = 0;
    31325. 

  31325.   HEAP32[i3 + 16 >> 2] = 0;
    31326. 

  31326.   HEAP32[i3 + 20 >> 2] = 0;
    31327. 

  31327.   HEAP32[i3 + 24 >> 2] = 0;
    31328. 

  31328.   HEAP32[i3 + 28 >> 2] = 0;
    31329. 

  31329.   do {
    31330. 

  31330.    i7 = i4 & 255;
    31331. 

  31331.    i6 = i3 + (i7 >>> 5 << 2) | 0;
    31332. 

  31332.    HEAP32[i6 >> 2] = HEAP32[i6 >> 2] | 1 << (i7 & 31);
    31333. 

  31333.    i5 = i5 + 1 | 0;
    31334. 

  31334.    i4 = HEAP8[i5] | 0;
    31335. 

  31335.   } while (!(i4 << 24 >> 24 == 0));
    31336. 

  31336.   i5 = HEAP8[i2] | 0;
    31337. 

  31337.   L7 : do {
    31338. 

  31338.    if (i5 << 24 >> 24 == 0) {
    31339. 

  31339.     i4 = i2;
    31340. 

  31340.    } else {
    31341. 

  31341.     i4 = i2;
    31342. 

  31342.     while (1) {
    31343. 

  31343.      i7 = i5 & 255;
    31344. 

  31344.      i6 = i4 + 1 | 0;
    31345. 

  31345.      if ((HEAP32[i3 + (i7 >>> 5 << 2) >> 2] & 1 << (i7 & 31) | 0) != 0) {
    31346. 

  31346.       break L7;
    31347. 

  31347.      }
    31348. 

  31348.      i5 = HEAP8[i6] | 0;
    31349. 

  31349.      if (i5 << 24 >> 24 == 0) {
    31350. 

  31350.       i4 = i6;
    31351. 

  31351.       break;
    31352. 

  31352.      } else {
    31353. 

  31353.       i4 = i6;
    31354. 

  31354.      }
    31355. 

  31355.     }
    31356. 

  31356.    }
    31357. 

  31357.   } while (0);
    31358. 

  31358.   i7 = i4 - i2 | 0;
    31359. 

  31359.   STACKTOP = i1;
    31360. 

  31360.   return i7 | 0;
    31361. 

  31361.  }
    31362. 

  31362.  i7 = (___strchrnul(i2, i4 << 24 >> 24) | 0) - i2 | 0;
    31363. 

  31363.  STACKTOP = i1;
    31364. 

  31364.  return i7 | 0;
    31365. 

  31365. }
    31366. 

  31366. function _main(i4, i5) {
    31367. 

  31367.  i4 = i4 | 0;
    31368. 

  31368.  i5 = i5 | 0;
    31369. 

  31369.  var i1 = 0, i2 = 0, i3 = 0, i6 = 0, i7 = 0, i8 = 0;
    31370. 

  31370.  i1 = STACKTOP;
    31371. 

  31371.  STACKTOP = STACKTOP + 16 | 0;
    31372. 

  31372.  i2 = i1;
    31373. 

  31373.  i3 = _luaL_newstate() | 0;
    31374. 

  31374.  if ((i3 | 0) == 0) {
    31375. 

  31375.   i4 = HEAP32[i5 >> 2] | 0;
    31376. 

  31376.   i3 = HEAP32[_stderr >> 2] | 0;
    31377. 

  31377.   if ((i4 | 0) != 0) {
    31378. 

  31378.    HEAP32[i2 >> 2] = i4;
    31379. 

  31379.    _fprintf(i3 | 0, 496, i2 | 0) | 0;
    31380. 

  31380.    _fflush(i3 | 0) | 0;
    31381. 

  31381.   }
    31382. 

  31382.   HEAP32[i2 >> 2] = 8;
    31383. 

  31383.   _fprintf(i3 | 0, 912, i2 | 0) | 0;
    31384. 

  31384.   _fflush(i3 | 0) | 0;
    31385. 

  31385.   i8 = 1;
    31386. 

  31386.   STACKTOP = i1;
    31387. 

  31387.   return i8 | 0;
    31388. 

  31388.  }
    31389. 

  31389.  _lua_pushcclosure(i3, 141, 0);
    31390. 

  31390.  _lua_pushinteger(i3, i4);
    31391. 

  31391.  _lua_pushlightuserdata(i3, i5);
    31392. 

  31392.  i6 = _lua_pcallk(i3, 2, 1, 0, 0, 0) | 0;
    31393. 

  31393.  i7 = _lua_toboolean(i3, -1) | 0;
    31394. 

  31394.  i6 = (i6 | 0) == 0;
    31395. 

  31395.  if (!i6) {
    31396. 

  31396.   if ((_lua_type(i3, -1) | 0) == 4) {
    31397. 

  31397.    i8 = _lua_tolstring(i3, -1, 0) | 0;
    31398. 

  31398.   } else {
    31399. 

  31399.    i8 = 0;
    31400. 

  31400.   }
    31401. 

  31401.   i4 = HEAP32[20] | 0;
    31402. 

  31402.   i5 = HEAP32[_stderr >> 2] | 0;
    31403. 

  31403.   if ((i4 | 0) != 0) {
    31404. 

  31404.    HEAP32[i2 >> 2] = i4;
    31405. 

  31405.    _fprintf(i5 | 0, 496, i2 | 0) | 0;
    31406. 

  31406.    _fflush(i5 | 0) | 0;
    31407. 

  31407.   }
    31408. 

  31408.   HEAP32[i2 >> 2] = (i8 | 0) == 0 ? 48 : i8;
    31409. 

  31409.   _fprintf(i5 | 0, 912, i2 | 0) | 0;
    31410. 

  31410.   _fflush(i5 | 0) | 0;
    31411. 

  31411.   _lua_settop(i3, -2);
    31412. 

  31412.  }
    31413. 

  31413.  _lua_close(i3);
    31414. 

  31414.  i8 = i6 & (i7 | 0) != 0 & 1 ^ 1;
    31415. 

  31415.  STACKTOP = i1;
    31416. 

  31416.  return i8 | 0;
    31417. 

  31417. }
    31418. 

  31418. function _db_sethook(i1) {
    31419. 

  31419.  i1 = i1 | 0;
    31420. 

  31420.  var i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0;
    31421. 

  31421.  i4 = STACKTOP;
    31422. 

  31422.  if ((_lua_type(i1, 1) | 0) == 8) {
    31423. 

  31423.   i2 = _lua_tothread(i1, 1) | 0;
    31424. 

  31424.   i5 = 1;
    31425. 

  31425.  } else {
    31426. 

  31426.   i2 = i1;
    31427. 

  31427.   i5 = 0;
    31428. 

  31428.  }
    31429. 

  31429.  i3 = i5 + 1 | 0;
    31430. 

  31430.  if ((_lua_type(i1, i3) | 0) < 1) {
    31431. 

  31431.   _lua_settop(i1, i3);
    31432. 

  31432.   i6 = 0;
    31433. 

  31433.   i7 = 0;
    31434. 

  31434.   i5 = 0;
    31435. 

  31435.  } else {
    31436. 

  31436.   i6 = _luaL_checklstring(i1, i5 | 2, 0) | 0;
    31437. 

  31437.   _luaL_checktype(i1, i3, 6);
    31438. 

  31438.   i5 = _luaL_optinteger(i1, i5 + 3 | 0, 0) | 0;
    31439. 

  31439.   i7 = (_strchr(i6, 99) | 0) != 0 | 0;
    31440. 

  31440.   i8 = (_strchr(i6, 114) | 0) == 0;
    31441. 

  31441.   i7 = i8 ? i7 : i7 | 2;
    31442. 

  31442.   i8 = (_strchr(i6, 108) | 0) == 0;
    31443. 

  31443.   i8 = i8 ? i7 : i7 | 4;
    31444. 

  31444.   i6 = i5;
    31445. 

  31445.   i7 = 9;
    31446. 

  31446.   i5 = (i5 | 0) > 0 ? i8 | 8 : i8;
    31447. 

  31447.  }
    31448. 

  31448.  if ((_luaL_getsubtable(i1, -1001e3, 11584) | 0) != 0) {
    31449. 

  31449.   _lua_pushthread(i2) | 0;
    31450. 

  31450.   _lua_xmove(i2, i1, 1);
    31451. 

  31451.   _lua_pushvalue(i1, i3);
    31452. 

  31452.   _lua_rawset(i1, -3);
    31453. 

  31453.   _lua_sethook(i2, i7, i5, i6) | 0;
    31454. 

  31454.   STACKTOP = i4;
    31455. 

  31455.   return 0;
    31456. 

  31456.  }
    31457. 

  31457.  _lua_pushstring(i1, 11592) | 0;
    31458. 

  31458.  _lua_setfield(i1, -2, 11600);
    31459. 

  31459.  _lua_pushvalue(i1, -1);
    31460. 

  31460.  _lua_setmetatable(i1, -2) | 0;
    31461. 

  31461.  _lua_pushthread(i2) | 0;
    31462. 

  31462.  _lua_xmove(i2, i1, 1);
    31463. 

  31463.  _lua_pushvalue(i1, i3);
    31464. 

  31464.  _lua_rawset(i1, -3);
    31465. 

  31465.  _lua_sethook(i2, i7, i5, i6) | 0;
    31466. 

  31466.  STACKTOP = i4;
    31467. 

  31467.  return 0;
    31468. 

  31468. }
    31469. 

  31469. function _tconcat(i1) {
    31470. 

  31470.  i1 = i1 | 0;
    31471. 

  31471.  var i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0;
    31472. 

  31472.  i3 = STACKTOP;
    31473. 

  31473.  STACKTOP = STACKTOP + 1056 | 0;
    31474. 

  31474.  i6 = i3;
    31475. 

  31475.  i2 = i3 + 16 | 0;
    31476. 

  31476.  i5 = i3 + 8 | 0;
    31477. 

  31477.  i4 = _luaL_optlstring(i1, 2, 8208, i5) | 0;
    31478. 

  31478.  _luaL_checktype(i1, 1, 5);
    31479. 

  31479.  i8 = _luaL_optinteger(i1, 3, 1) | 0;
    31480. 

  31480.  if ((_lua_type(i1, 4) | 0) < 1) {
    31481. 

  31481.   i7 = _luaL_len(i1, 1) | 0;
    31482. 

  31482.  } else {
    31483. 

  31483.   i7 = _luaL_checkinteger(i1, 4) | 0;
    31484. 

  31484.  }
    31485. 

  31485.  _luaL_buffinit(i1, i2);
    31486. 

  31486.  if ((i8 | 0) >= (i7 | 0)) {
    31487. 

  31487.   if ((i8 | 0) != (i7 | 0)) {
    31488. 

  31488.    _luaL_pushresult(i2);
    31489. 

  31489.    STACKTOP = i3;
    31490. 

  31490.    return 1;
    31491. 

  31491.   }
    31492. 

  31492.  } else {
    31493. 

  31493.   do {
    31494. 

  31494.    _lua_rawgeti(i1, 1, i8);
    31495. 

  31495.    if ((_lua_isstring(i1, -1) | 0) == 0) {
    31496. 

  31496.     HEAP32[i6 >> 2] = _lua_typename(i1, _lua_type(i1, -1) | 0) | 0;
    31497. 

  31497.     HEAP32[i6 + 4 >> 2] = i8;
    31498. 

  31498.     _luaL_error(i1, 8360, i6) | 0;
    31499. 

  31499.    }
    31500. 

  31500.    _luaL_addvalue(i2);
    31501. 

  31501.    _luaL_addlstring(i2, i4, HEAP32[i5 >> 2] | 0);
    31502. 

  31502.    i8 = i8 + 1 | 0;
    31503. 

  31503.   } while ((i8 | 0) != (i7 | 0));
    31504. 

  31504.  }
    31505. 

  31505.  _lua_rawgeti(i1, 1, i7);
    31506. 

  31506.  if ((_lua_isstring(i1, -1) | 0) == 0) {
    31507. 

  31507.   HEAP32[i6 >> 2] = _lua_typename(i1, _lua_type(i1, -1) | 0) | 0;
    31508. 

  31508.   HEAP32[i6 + 4 >> 2] = i7;
    31509. 

  31509.   _luaL_error(i1, 8360, i6) | 0;
    31510. 

  31510.  }
    31511. 

  31511.  _luaL_addvalue(i2);
    31512. 

  31512.  _luaL_pushresult(i2);
    31513. 

  31513.  STACKTOP = i3;
    31514. 

  31514.  return 1;
    31515. 

  31515. }
    31516. 

  31516. function _searcher_Croot(i1) {
    31517. 

  31517.  i1 = i1 | 0;
    31518. 

  31518.  var i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0;
    31519. 

  31519.  i2 = STACKTOP;
    31520. 

  31520.  STACKTOP = STACKTOP + 16 | 0;
    31521. 

  31521.  i3 = i2;
    31522. 

  31522.  i4 = _luaL_checklstring(i1, 1, 0) | 0;
    31523. 

  31523.  i5 = _strchr(i4, 46) | 0;
    31524. 

  31524.  if ((i5 | 0) == 0) {
    31525. 

  31525.   i6 = 0;
    31526. 

  31526.   STACKTOP = i2;
    31527. 

  31527.   return i6 | 0;
    31528. 

  31528.  }
    31529. 

  31529.  _lua_pushlstring(i1, i4, i5 - i4 | 0) | 0;
    31530. 

  31530.  i5 = _lua_tolstring(i1, -1, 0) | 0;
    31531. 

  31531.  _lua_getfield(i1, -1001001, 4440);
    31532. 

  31532.  i6 = _lua_tolstring(i1, -1, 0) | 0;
    31533. 

  31533.  if ((i6 | 0) == 0) {
    31534. 

  31534.   HEAP32[i3 >> 2] = 4440;
    31535. 

  31535.   _luaL_error(i1, 5032, i3) | 0;
    31536. 

  31536.  }
    31537. 

  31537.  i5 = _searchpath(i1, i5, i6, 4936, 4848) | 0;
    31538. 

  31538.  if ((i5 | 0) == 0) {
    31539. 

  31539.   i6 = 1;
    31540. 

  31540.   STACKTOP = i2;
    31541. 

  31541.   return i6 | 0;
    31542. 

  31542.  }
    31543. 

  31543.  i6 = _loadfunc(i1, i5, i4) | 0;
    31544. 

  31544.  if ((i6 | 0) == 2) {
    31545. 

  31545.   HEAP32[i3 >> 2] = i4;
    31546. 

  31546.   HEAP32[i3 + 4 >> 2] = i5;
    31547. 

  31547.   _lua_pushfstring(i1, 4856, i3) | 0;
    31548. 

  31548.   i6 = 1;
    31549. 

  31549.   STACKTOP = i2;
    31550. 

  31550.   return i6 | 0;
    31551. 

  31551.  } else if ((i6 | 0) == 0) {
    31552. 

  31552.   _lua_pushstring(i1, i5) | 0;
    31553. 

  31553.   i6 = 2;
    31554. 

  31554.   STACKTOP = i2;
    31555. 

  31555.   return i6 | 0;
    31556. 

  31556.  } else {
    31557. 

  31557.   i4 = _lua_tolstring(i1, 1, 0) | 0;
    31558. 

  31558.   i6 = _lua_tolstring(i1, -1, 0) | 0;
    31559. 

  31559.   HEAP32[i3 >> 2] = i4;
    31560. 

  31560.   HEAP32[i3 + 4 >> 2] = i5;
    31561. 

  31561.   HEAP32[i3 + 8 >> 2] = i6;
    31562. 

  31562.   i6 = _luaL_error(i1, 4888, i3) | 0;
    31563. 

  31563.   STACKTOP = i2;
    31564. 

  31564.   return i6 | 0;
    31565. 

  31565.  }
    31566. 

  31566.  return 0;
    31567. 

  31567. }
    31568. 

  31568. function _lua_tonumberx(i5, i7, i1) {
    31569. 

  31569.  i5 = i5 | 0;
    31570. 

  31570.  i7 = i7 | 0;
    31571. 

  31571.  i1 = i1 | 0;
    31572. 

  31572.  var i2 = 0, i3 = 0, i4 = 0, i6 = 0, d8 = 0.0;
    31573. 

  31573.  i2 = STACKTOP;
    31574. 

  31574.  STACKTOP = STACKTOP + 16 | 0;
    31575. 

  31575.  i3 = i2;
    31576. 

  31576.  i6 = HEAP32[i5 + 16 >> 2] | 0;
    31577. 

  31577.  do {
    31578. 

  31578.   if ((i7 | 0) <= 0) {
    31579. 

  31579.    if (!((i7 | 0) < -1000999)) {
    31580. 

  31580.     i4 = (HEAP32[i5 + 8 >> 2] | 0) + (i7 << 4) | 0;
    31581. 

  31581.     break;
    31582. 

  31582.    }
    31583. 

  31583.    if ((i7 | 0) == -1001e3) {
    31584. 

  31584.     i4 = (HEAP32[i5 + 12 >> 2] | 0) + 40 | 0;
    31585. 

  31585.     break;
    31586. 

  31586.    }
    31587. 

  31587.    i5 = -1001e3 - i7 | 0;
    31588. 

  31588.    i6 = HEAP32[i6 >> 2] | 0;
    31589. 

  31589.    if ((HEAP32[i6 + 8 >> 2] | 0) != 22 ? (i4 = HEAP32[i6 >> 2] | 0, (i5 | 0) <= (HEAPU8[i4 + 6 | 0] | 0 | 0)) : 0) {
    31590. 

  31590.     i4 = i4 + (i5 + -1 << 4) + 16 | 0;
    31591. 

  31591.    } else {
    31592. 

  31592.     i4 = 5192;
    31593. 

  31593.    }
    31594. 

  31594.   } else {
    31595. 

  31595.    i4 = (HEAP32[i6 >> 2] | 0) + (i7 << 4) | 0;
    31596. 

  31596.    i4 = i4 >>> 0 < (HEAP32[i5 + 8 >> 2] | 0) >>> 0 ? i4 : 5192;
    31597. 

  31597.   }
    31598. 

  31598.  } while (0);
    31599. 

  31599.  if ((HEAP32[i4 + 8 >> 2] | 0) != 3) {
    31600. 

  31600.   i4 = _luaV_tonumber(i4, i3) | 0;
    31601. 

  31601.   if ((i4 | 0) == 0) {
    31602. 

  31602.    if ((i1 | 0) == 0) {
    31603. 

  31603.     d8 = 0.0;
    31604. 

  31604.     STACKTOP = i2;
    31605. 

  31605.     return +d8;
    31606. 

  31606.    }
    31607. 

  31607.    HEAP32[i1 >> 2] = 0;
    31608. 

  31608.    d8 = 0.0;
    31609. 

  31609.    STACKTOP = i2;
    31610. 

  31610.    return +d8;
    31611. 

  31611.   }
    31612. 

  31612.  }
    31613. 

  31613.  if ((i1 | 0) != 0) {
    31614. 

  31614.   HEAP32[i1 >> 2] = 1;
    31615. 

  31615.  }
    31616. 

  31616.  d8 = +HEAPF64[i4 >> 3];
    31617. 

  31617.  STACKTOP = i2;
    31618. 

  31618.  return +d8;
    31619. 

  31619. }
    31620. 

  31620. function _luaopen_package(i1) {
    31621. 

  31621.  i1 = i1 | 0;
    31622. 

  31622.  var i2 = 0;
    31623. 

  31623.  i2 = STACKTOP;
    31624. 

  31624.  _luaL_getsubtable(i1, -1001e3, 4184) | 0;
    31625. 

  31625.  _lua_createtable(i1, 0, 1);
    31626. 

  31626.  _lua_pushcclosure(i1, 158, 0);
    31627. 

  31627.  _lua_setfield(i1, -2, 4192);
    31628. 

  31628.  _lua_setmetatable(i1, -2) | 0;
    31629. 

  31629.  _lua_createtable(i1, 0, 3);
    31630. 

  31630.  _luaL_setfuncs(i1, 4200, 0);
    31631. 

  31631.  _lua_createtable(i1, 4, 0);
    31632. 

  31632.  _lua_pushvalue(i1, -2);
    31633. 

  31633.  _lua_pushcclosure(i1, 159, 1);
    31634. 

  31634.  _lua_rawseti(i1, -2, 1);
    31635. 

  31635.  _lua_pushvalue(i1, -2);
    31636. 

  31636.  _lua_pushcclosure(i1, 160, 1);
    31637. 

  31637.  _lua_rawseti(i1, -2, 2);
    31638. 

  31638.  _lua_pushvalue(i1, -2);
    31639. 

  31639.  _lua_pushcclosure(i1, 161, 1);
    31640. 

  31640.  _lua_rawseti(i1, -2, 3);
    31641. 

  31641.  _lua_pushvalue(i1, -2);
    31642. 

  31642.  _lua_pushcclosure(i1, 162, 1);
    31643. 

  31643.  _lua_rawseti(i1, -2, 4);
    31644. 

  31644.  _lua_pushvalue(i1, -1);
    31645. 

  31645.  _lua_setfield(i1, -3, 4232);
    31646. 

  31646.  _lua_setfield(i1, -2, 4240);
    31647. 

  31647.  _setpath(i1, 4256, 4264, 4280, 4296);
    31648. 

  31648.  _setpath(i1, 4440, 4448, 4464, 4480);
    31649. 

  31649.  _lua_pushlstring(i1, 4552, 10) | 0;
    31650. 

  31650.  _lua_setfield(i1, -2, 4568);
    31651. 

  31651.  _luaL_getsubtable(i1, -1001e3, 4576) | 0;
    31652. 

  31652.  _lua_setfield(i1, -2, 4584);
    31653. 

  31653.  _luaL_getsubtable(i1, -1001e3, 4592) | 0;
    31654. 

  31654.  _lua_setfield(i1, -2, 4608);
    31655. 

  31655.  _lua_rawgeti(i1, -1001e3, 2);
    31656. 

  31656.  _lua_pushvalue(i1, -2);
    31657. 

  31657.  _luaL_setfuncs(i1, 4616, 1);
    31658. 

  31658.  _lua_settop(i1, -2);
    31659. 

  31659.  STACKTOP = i2;
    31660. 

  31660.  return 1;
    31661. 

  31661. }
    31662. 

  31662. function _lua_rawlen(i3, i5) {
    31663. 

  31663.  i3 = i3 | 0;
    31664. 

  31664.  i5 = i5 | 0;
    31665. 

  31665.  var i1 = 0, i2 = 0, i4 = 0;
    31666. 

  31666.  i1 = STACKTOP;
    31667. 

  31667.  i4 = HEAP32[i3 + 16 >> 2] | 0;
    31668. 

  31668.  do {
    31669. 

  31669.   if ((i5 | 0) <= 0) {
    31670. 

  31670.    if (!((i5 | 0) < -1000999)) {
    31671. 

  31671.     i2 = (HEAP32[i3 + 8 >> 2] | 0) + (i5 << 4) | 0;
    31672. 

  31672.     break;
    31673. 

  31673.    }
    31674. 

  31674.    if ((i5 | 0) == -1001e3) {
    31675. 

  31675.     i2 = (HEAP32[i3 + 12 >> 2] | 0) + 40 | 0;
    31676. 

  31676.     break;
    31677. 

  31677.    }
    31678. 

  31678.    i3 = -1001e3 - i5 | 0;
    31679. 

  31679.    i4 = HEAP32[i4 >> 2] | 0;
    31680. 

  31680.    if ((HEAP32[i4 + 8 >> 2] | 0) != 22 ? (i2 = HEAP32[i4 >> 2] | 0, (i3 | 0) <= (HEAPU8[i2 + 6 | 0] | 0 | 0)) : 0) {
    31681. 

  31681.     i2 = i2 + (i3 + -1 << 4) + 16 | 0;
    31682. 

  31682.    } else {
    31683. 

  31683.     i2 = 5192;
    31684. 

  31684.    }
    31685. 

  31685.   } else {
    31686. 

  31686.    i2 = (HEAP32[i4 >> 2] | 0) + (i5 << 4) | 0;
    31687. 

  31687.    i2 = i2 >>> 0 < (HEAP32[i3 + 8 >> 2] | 0) >>> 0 ? i2 : 5192;
    31688. 

  31688.   }
    31689. 

  31689.  } while (0);
    31690. 

  31690.  i3 = HEAP32[i2 + 8 >> 2] & 15;
    31691. 

  31691.  if ((i3 | 0) == 5) {
    31692. 

  31692.   i5 = _luaH_getn(HEAP32[i2 >> 2] | 0) | 0;
    31693. 

  31693.   STACKTOP = i1;
    31694. 

  31694.   return i5 | 0;
    31695. 

  31695.  } else if ((i3 | 0) == 4) {
    31696. 

  31696.   i5 = HEAP32[(HEAP32[i2 >> 2] | 0) + 12 >> 2] | 0;
    31697. 

  31697.   STACKTOP = i1;
    31698. 

  31698.   return i5 | 0;
    31699. 

  31699.  } else if ((i3 | 0) == 7) {
    31700. 

  31700.   i5 = HEAP32[(HEAP32[i2 >> 2] | 0) + 16 >> 2] | 0;
    31701. 

  31701.   STACKTOP = i1;
    31702. 

  31702.   return i5 | 0;
    31703. 

  31703.  } else {
    31704. 

  31704.   i5 = 0;
    31705. 

  31705.   STACKTOP = i1;
    31706. 

  31706.   return i5 | 0;
    31707. 

  31707.  }
    31708. 

  31708.  return 0;
    31709. 

  31709. }
    31710. 

  31710. function _searchpath(i3, i5, i6, i7, i8) {
    31711. 

  31711.  i3 = i3 | 0;
    31712. 

  31712.  i5 = i5 | 0;
    31713. 

  31713.  i6 = i6 | 0;
    31714. 

  31714.  i7 = i7 | 0;
    31715. 

  31715.  i8 = i8 | 0;
    31716. 

  31716.  var i1 = 0, i2 = 0, i4 = 0;
    31717. 

  31717.  i2 = STACKTOP;
    31718. 

  31718.  STACKTOP = STACKTOP + 1056 | 0;
    31719. 

  31719.  i4 = i2;
    31720. 

  31720.  i1 = i2 + 8 | 0;
    31721. 

  31721.  _luaL_buffinit(i3, i1);
    31722. 

  31722.  if ((HEAP8[i7] | 0) != 0) {
    31723. 

  31723.   i5 = _luaL_gsub(i3, i5, i7, i8) | 0;
    31724. 

  31724.  }
    31725. 

  31725.  while (1) {
    31726. 

  31726.   i7 = HEAP8[i6] | 0;
    31727. 

  31727.   if (i7 << 24 >> 24 == 59) {
    31728. 

  31728.    i6 = i6 + 1 | 0;
    31729. 

  31729.    continue;
    31730. 

  31730.   } else if (i7 << 24 >> 24 == 0) {
    31731. 

  31731.    i3 = 12;
    31732. 

  31732.    break;
    31733. 

  31733.   }
    31734. 

  31734.   i8 = _strchr(i6, 59) | 0;
    31735. 

  31735.   if ((i8 | 0) == 0) {
    31736. 

  31736.    i8 = i6 + (_strlen(i6 | 0) | 0) | 0;
    31737. 

  31737.   }
    31738. 

  31738.   _lua_pushlstring(i3, i6, i8 - i6 | 0) | 0;
    31739. 

  31739.   if ((i8 | 0) == 0) {
    31740. 

  31740.    i3 = 12;
    31741. 

  31741.    break;
    31742. 

  31742.   }
    31743. 

  31743.   i6 = _luaL_gsub(i3, _lua_tolstring(i3, -1, 0) | 0, 5064, i5) | 0;
    31744. 

  31744.   _lua_remove(i3, -2);
    31745. 

  31745.   i7 = _fopen(i6 | 0, 5088) | 0;
    31746. 

  31746.   if ((i7 | 0) != 0) {
    31747. 

  31747.    i3 = 10;
    31748. 

  31748.    break;
    31749. 

  31749.   }
    31750. 

  31750.   HEAP32[i4 >> 2] = i6;
    31751. 

  31751.   _lua_pushfstring(i3, 5072, i4) | 0;
    31752. 

  31752.   _lua_remove(i3, -2);
    31753. 

  31753.   _luaL_addvalue(i1);
    31754. 

  31754.   i6 = i8;
    31755. 

  31755.  }
    31756. 

  31756.  if ((i3 | 0) == 10) {
    31757. 

  31757.   _fclose(i7 | 0) | 0;
    31758. 

  31758.   i8 = i6;
    31759. 

  31759.   STACKTOP = i2;
    31760. 

  31760.   return i8 | 0;
    31761. 

  31761.  } else if ((i3 | 0) == 12) {
    31762. 

  31762.   _luaL_pushresult(i1);
    31763. 

  31763.   i8 = 0;
    31764. 

  31764.   STACKTOP = i2;
    31765. 

  31765.   return i8 | 0;
    31766. 

  31766.  }
    31767. 

  31767.  return 0;
    31768. 

  31768. }
    31769. 

  31769. function _io_readline(i1) {
    31770. 

  31770.  i1 = i1 | 0;
    31771. 

  31771.  var i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0;
    31772. 

  31772.  i2 = STACKTOP;
    31773. 

  31773.  STACKTOP = STACKTOP + 16 | 0;
    31774. 

  31774.  i3 = i2;
    31775. 

  31775.  i4 = _lua_touserdata(i1, -1001001) | 0;
    31776. 

  31776.  i5 = _lua_tointegerx(i1, -1001002, 0) | 0;
    31777. 

  31777.  if ((HEAP32[i4 + 4 >> 2] | 0) == 0) {
    31778. 

  31778.   i6 = _luaL_error(i1, 3344, i3) | 0;
    31779. 

  31779.   STACKTOP = i2;
    31780. 

  31780.   return i6 | 0;
    31781. 

  31781.  }
    31782. 

  31782.  _lua_settop(i1, 1);
    31783. 

  31783.  if ((i5 | 0) >= 1) {
    31784. 

  31784.   i6 = 1;
    31785. 

  31785.   while (1) {
    31786. 

  31786.    _lua_pushvalue(i1, -1001003 - i6 | 0);
    31787. 

  31787.    if ((i6 | 0) == (i5 | 0)) {
    31788. 

  31788.     break;
    31789. 

  31789.    } else {
    31790. 

  31790.     i6 = i6 + 1 | 0;
    31791. 

  31791.    }
    31792. 

  31792.   }
    31793. 

  31793.  }
    31794. 

  31794.  i4 = _g_read(i1, HEAP32[i4 >> 2] | 0, 2) | 0;
    31795. 

  31795.  if ((_lua_type(i1, 0 - i4 | 0) | 0) != 0) {
    31796. 

  31796.   i6 = i4;
    31797. 

  31797.   STACKTOP = i2;
    31798. 

  31798.   return i6 | 0;
    31799. 

  31799.  }
    31800. 

  31800.  if ((i4 | 0) > 1) {
    31801. 

  31801.   HEAP32[i3 >> 2] = _lua_tolstring(i1, 1 - i4 | 0, 0) | 0;
    31802. 

  31802.   i6 = _luaL_error(i1, 3368, i3) | 0;
    31803. 

  31803.   STACKTOP = i2;
    31804. 

  31804.   return i6 | 0;
    31805. 

  31805.  }
    31806. 

  31806.  if ((_lua_toboolean(i1, -1001003) | 0) == 0) {
    31807. 

  31807.   i6 = 0;
    31808. 

  31808.   STACKTOP = i2;
    31809. 

  31809.   return i6 | 0;
    31810. 

  31810.  }
    31811. 

  31811.  _lua_settop(i1, 0);
    31812. 

  31812.  _lua_pushvalue(i1, -1001001);
    31813. 

  31813.  i5 = (_luaL_checkudata(i1, 1, 2832) | 0) + 4 | 0;
    31814. 

  31814.  i6 = HEAP32[i5 >> 2] | 0;
    31815. 

  31815.  HEAP32[i5 >> 2] = 0;
    31816. 

  31816.  FUNCTION_TABLE_ii[i6 & 255](i1) | 0;
    31817. 

  31817.  i6 = 0;
    31818. 

  31818.  STACKTOP = i2;
    31819. 

  31819.  return i6 | 0;
    31820. 

  31820. }
    31821. 

  31821. function _luaK_setreturns(i3, i5, i6) {
    31822. 

  31822.  i3 = i3 | 0;
    31823. 

  31823.  i5 = i5 | 0;
    31824. 

  31824.  i6 = i6 | 0;
    31825. 

  31825.  var i1 = 0, i2 = 0, i4 = 0, i7 = 0, i8 = 0;
    31826. 

  31826.  i2 = STACKTOP;
    31827. 

  31827.  i4 = HEAP32[i5 >> 2] | 0;
    31828. 

  31828.  if ((i4 | 0) == 13) {
    31829. 

  31829.   i7 = i5 + 8 | 0;
    31830. 

  31830.   i8 = HEAP32[i3 >> 2] | 0;
    31831. 

  31831.   i4 = HEAP32[i8 + 12 >> 2] | 0;
    31832. 

  31832.   i5 = i4 + (HEAP32[i7 >> 2] << 2) | 0;
    31833. 

  31833.   HEAP32[i5 >> 2] = HEAP32[i5 >> 2] & 8388607 | (i6 << 23) + 8388608;
    31834. 

  31834.   i7 = i4 + (HEAP32[i7 >> 2] << 2) | 0;
    31835. 

  31835.   i4 = i3 + 48 | 0;
    31836. 

  31836.   HEAP32[i7 >> 2] = (HEAPU8[i4] | 0) << 6 | HEAP32[i7 >> 2] & -16321;
    31837. 

  31837.   i7 = HEAP8[i4] | 0;
    31838. 

  31838.   i5 = (i7 & 255) + 1 | 0;
    31839. 

  31839.   i6 = i8 + 78 | 0;
    31840. 

  31840.   do {
    31841. 

  31841.    if (i5 >>> 0 > (HEAPU8[i6] | 0) >>> 0) {
    31842. 

  31842.     if (i5 >>> 0 > 249) {
    31843. 

  31843.      _luaX_syntaxerror(HEAP32[i3 + 12 >> 2] | 0, 10536);
    31844. 

  31844.     } else {
    31845. 

  31845.      HEAP8[i6] = i5;
    31846. 

  31846.      i1 = HEAP8[i4] | 0;
    31847. 

  31847.      break;
    31848. 

  31848.     }
    31849. 

  31849.    } else {
    31850. 

  31850.     i1 = i7;
    31851. 

  31851.    }
    31852. 

  31852.   } while (0);
    31853. 

  31853.   HEAP8[i4] = (i1 & 255) + 1;
    31854. 

  31854.   STACKTOP = i2;
    31855. 

  31855.   return;
    31856. 

  31856.  } else if ((i4 | 0) == 12) {
    31857. 

  31857.   i8 = (HEAP32[(HEAP32[i3 >> 2] | 0) + 12 >> 2] | 0) + (HEAP32[i5 + 8 >> 2] << 2) | 0;
    31858. 

  31858.   HEAP32[i8 >> 2] = HEAP32[i8 >> 2] & -8372225 | (i6 << 14) + 16384 & 8372224;
    31859. 

  31859.   STACKTOP = i2;
    31860. 

  31860.   return;
    31861. 

  31861.  } else {
    31862. 

  31862.   STACKTOP = i2;
    31863. 

  31863.   return;
    31864. 

  31864.  }
    31865. 

  31865. }
    31866. 

  31866. function _luaZ_read(i2, i9, i8) {
    31867. 

  31867.  i2 = i2 | 0;
    31868. 

  31868.  i9 = i9 | 0;
    31869. 

  31869.  i8 = i8 | 0;
    31870. 

  31870.  var i1 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i10 = 0, i11 = 0;
    31871. 

  31871.  i1 = STACKTOP;
    31872. 

  31872.  STACKTOP = STACKTOP + 16 | 0;
    31873. 

  31873.  i3 = i1;
    31874. 

  31874.  if ((i8 | 0) == 0) {
    31875. 

  31875.   i11 = 0;
    31876. 

  31876.   STACKTOP = i1;
    31877. 

  31877.   return i11 | 0;
    31878. 

  31878.  }
    31879. 

  31879.  i7 = i2 + 16 | 0;
    31880. 

  31880.  i6 = i2 + 8 | 0;
    31881. 

  31881.  i4 = i2 + 12 | 0;
    31882. 

  31882.  i5 = i2 + 4 | 0;
    31883. 

  31883.  i11 = HEAP32[i2 >> 2] | 0;
    31884. 

  31884.  while (1) {
    31885. 

  31885.   if ((i11 | 0) == 0) {
    31886. 

  31886.    i10 = FUNCTION_TABLE_iiii[HEAP32[i6 >> 2] & 3](HEAP32[i7 >> 2] | 0, HEAP32[i4 >> 2] | 0, i3) | 0;
    31887. 

  31887.    if ((i10 | 0) == 0) {
    31888. 

  31888.     i2 = 9;
    31889. 

  31889.     break;
    31890. 

  31890.    }
    31891. 

  31891.    i11 = HEAP32[i3 >> 2] | 0;
    31892. 

  31892.    if ((i11 | 0) == 0) {
    31893. 

  31893.     i2 = 9;
    31894. 

  31894.     break;
    31895. 

  31895.    }
    31896. 

  31896.    HEAP32[i2 >> 2] = i11;
    31897. 

  31897.    HEAP32[i5 >> 2] = i10;
    31898. 

  31898.   } else {
    31899. 

  31899.    i10 = HEAP32[i5 >> 2] | 0;
    31900. 

  31900.   }
    31901. 

  31901.   i11 = i8 >>> 0 > i11 >>> 0 ? i11 : i8;
    31902. 

  31902.   _memcpy(i9 | 0, i10 | 0, i11 | 0) | 0;
    31903. 

  31903.   i10 = (HEAP32[i2 >> 2] | 0) - i11 | 0;
    31904. 

  31904.   HEAP32[i2 >> 2] = i10;
    31905. 

  31905.   HEAP32[i5 >> 2] = (HEAP32[i5 >> 2] | 0) + i11;
    31906. 

  31906.   if ((i8 | 0) == (i11 | 0)) {
    31907. 

  31907.    i8 = 0;
    31908. 

  31908.    i2 = 9;
    31909. 

  31909.    break;
    31910. 

  31910.   } else {
    31911. 

  31911.    i8 = i8 - i11 | 0;
    31912. 

  31912.    i9 = i9 + i11 | 0;
    31913. 

  31913.    i11 = i10;
    31914. 

  31914.   }
    31915. 

  31915.  }
    31916. 

  31916.  if ((i2 | 0) == 9) {
    31917. 

  31917.   STACKTOP = i1;
    31918. 

  31918.   return i8 | 0;
    31919. 

  31919.  }
    31920. 

  31920.  return 0;
    31921. 

  31921. }
    31922. 

  31922. function _lua_load(i1, i5, i4, i3, i6) {
    31923. 

  31923.  i1 = i1 | 0;
    31924. 

  31924.  i5 = i5 | 0;
    31925. 

  31925.  i4 = i4 | 0;
    31926. 

  31926.  i3 = i3 | 0;
    31927. 

  31927.  i6 = i6 | 0;
    31928. 

  31928.  var i2 = 0, i7 = 0, i8 = 0, i9 = 0;
    31929. 

  31929.  i2 = STACKTOP;
    31930. 

  31930.  STACKTOP = STACKTOP + 32 | 0;
    31931. 

  31931.  i7 = i2;
    31932. 

  31932.  _luaZ_init(i1, i7, i5, i4);
    31933. 

  31933.  i3 = _luaD_protectedparser(i1, i7, (i3 | 0) == 0 ? 928 : i3, i6) | 0;
    31934. 

  31934.  if ((i3 | 0) != 0) {
    31935. 

  31935.   STACKTOP = i2;
    31936. 

  31936.   return i3 | 0;
    31937. 

  31937.  }
    31938. 

  31938.  i4 = HEAP32[(HEAP32[i1 + 8 >> 2] | 0) + -16 >> 2] | 0;
    31939. 

  31939.  if ((HEAP8[i4 + 6 | 0] | 0) != 1) {
    31940. 

  31940.   STACKTOP = i2;
    31941. 

  31941.   return i3 | 0;
    31942. 

  31942.  }
    31943. 

  31943.  i5 = _luaH_getint(HEAP32[(HEAP32[i1 + 12 >> 2] | 0) + 40 >> 2] | 0, 2) | 0;
    31944. 

  31944.  i4 = i4 + 16 | 0;
    31945. 

  31945.  i6 = HEAP32[(HEAP32[i4 >> 2] | 0) + 8 >> 2] | 0;
    31946. 

  31946.  i9 = i5;
    31947. 

  31947.  i8 = HEAP32[i9 + 4 >> 2] | 0;
    31948. 

  31948.  i7 = i6;
    31949. 

  31949.  HEAP32[i7 >> 2] = HEAP32[i9 >> 2];
    31950. 

  31950.  HEAP32[i7 + 4 >> 2] = i8;
    31951. 

  31951.  i7 = i5 + 8 | 0;
    31952. 

  31952.  HEAP32[i6 + 8 >> 2] = HEAP32[i7 >> 2];
    31953. 

  31953.  if ((HEAP32[i7 >> 2] & 64 | 0) == 0) {
    31954. 

  31954.   STACKTOP = i2;
    31955. 

  31955.   return i3 | 0;
    31956. 

  31956.  }
    31957. 

  31957.  i5 = HEAP32[i5 >> 2] | 0;
    31958. 

  31958.  if ((HEAP8[i5 + 5 | 0] & 3) == 0) {
    31959. 

  31959.   STACKTOP = i2;
    31960. 

  31960.   return i3 | 0;
    31961. 

  31961.  }
    31962. 

  31962.  i4 = HEAP32[i4 >> 2] | 0;
    31963. 

  31963.  if ((HEAP8[i4 + 5 | 0] & 4) == 0) {
    31964. 

  31964.   STACKTOP = i2;
    31965. 

  31965.   return i3 | 0;
    31966. 

  31966.  }
    31967. 

  31967.  _luaC_barrier_(i1, i4, i5);
    31968. 

  31968.  STACKTOP = i2;
    31969. 

  31969.  return i3 | 0;
    31970. 

  31970. }
    31971. 

  31971. function _g_write(i1, i4, i8) {
    31972. 

  31972.  i1 = i1 | 0;
    31973. 

  31973.  i4 = i4 | 0;
    31974. 

  31974.  i8 = i8 | 0;
    31975. 

  31975.  var i2 = 0, i3 = 0, i5 = 0, i6 = 0, i7 = 0, i9 = 0, d10 = 0.0;
    31976. 

  31976.  i5 = STACKTOP;
    31977. 

  31977.  STACKTOP = STACKTOP + 16 | 0;
    31978. 

  31978.  i2 = i5;
    31979. 

  31979.  i3 = i5 + 8 | 0;
    31980. 

  31980.  i7 = _lua_gettop(i1) | 0;
    31981. 

  31981.  if ((i7 | 0) == (i8 | 0)) {
    31982. 

  31982.   i9 = 1;
    31983. 

  31983.   STACKTOP = i5;
    31984. 

  31984.   return i9 | 0;
    31985. 

  31985.  }
    31986. 

  31986.  i6 = i8;
    31987. 

  31987.  i7 = i7 - i8 | 0;
    31988. 

  31988.  i9 = 1;
    31989. 

  31989.  while (1) {
    31990. 

  31990.   i7 = i7 + -1 | 0;
    31991. 

  31991.   if ((_lua_type(i1, i6) | 0) == 3) {
    31992. 

  31992.    if ((i9 | 0) == 0) {
    31993. 

  31993.     i8 = 0;
    31994. 

  31994.    } else {
    31995. 

  31995.     d10 = +_lua_tonumberx(i1, i6, 0);
    31996. 

  31996.     HEAPF64[tempDoublePtr >> 3] = d10;
    31997. 

  31997.     HEAP32[i2 >> 2] = HEAP32[tempDoublePtr >> 2];
    31998. 

  31998.     HEAP32[i2 + 4 >> 2] = HEAP32[tempDoublePtr + 4 >> 2];
    31999. 

  31999.     i8 = (_fprintf(i4 | 0, 3072, i2 | 0) | 0) > 0;
    32000. 

  32000.    }
    32001. 

  32001.   } else {
    32002. 

  32002.    i8 = _luaL_checklstring(i1, i6, i3) | 0;
    32003. 

  32003.    if ((i9 | 0) == 0) {
    32004. 

  32004.     i8 = 0;
    32005. 

  32005.    } else {
    32006. 

  32006.     i8 = _fwrite(i8 | 0, 1, HEAP32[i3 >> 2] | 0, i4 | 0) | 0;
    32007. 

  32007.     i8 = (i8 | 0) == (HEAP32[i3 >> 2] | 0);
    32008. 

  32008.    }
    32009. 

  32009.   }
    32010. 

  32010.   if ((i7 | 0) == 0) {
    32011. 

  32011.    break;
    32012. 

  32012.   } else {
    32013. 

  32013.    i6 = i6 + 1 | 0;
    32014. 

  32014.    i9 = i8 & 1;
    32015. 

  32015.   }
    32016. 

  32016.  }
    32017. 

  32017.  if (i8) {
    32018. 

  32018.   i9 = 1;
    32019. 

  32019.   STACKTOP = i5;
    32020. 

  32020.   return i9 | 0;
    32021. 

  32021.  }
    32022. 

  32022.  i9 = _luaL_fileresult(i1, 0, 0) | 0;
    32023. 

  32023.  STACKTOP = i5;
    32024. 

  32024.  return i9 | 0;
    32025. 

  32025. }
    32026. 

  32026. function _lua_getuservalue(i2, i5) {
    32027. 

  32027.  i2 = i2 | 0;
    32028. 

  32028.  i5 = i5 | 0;
    32029. 

  32029.  var i1 = 0, i3 = 0, i4 = 0;
    32030. 

  32030.  i1 = STACKTOP;
    32031. 

  32031.  i4 = HEAP32[i2 + 16 >> 2] | 0;
    32032. 

  32032.  do {
    32033. 

  32033.   if ((i5 | 0) <= 0) {
    32034. 

  32034.    if (!((i5 | 0) < -1000999)) {
    32035. 

  32035.     i3 = (HEAP32[i2 + 8 >> 2] | 0) + (i5 << 4) | 0;
    32036. 

  32036.     break;
    32037. 

  32037.    }
    32038. 

  32038.    if ((i5 | 0) == -1001e3) {
    32039. 

  32039.     i3 = (HEAP32[i2 + 12 >> 2] | 0) + 40 | 0;
    32040. 

  32040.     break;
    32041. 

  32041.    }
    32042. 

  32042.    i5 = -1001e3 - i5 | 0;
    32043. 

  32043.    i4 = HEAP32[i4 >> 2] | 0;
    32044. 

  32044.    if ((HEAP32[i4 + 8 >> 2] | 0) != 22 ? (i3 = HEAP32[i4 >> 2] | 0, (i5 | 0) <= (HEAPU8[i3 + 6 | 0] | 0 | 0)) : 0) {
    32045. 

  32045.     i3 = i3 + (i5 + -1 << 4) + 16 | 0;
    32046. 

  32046.    } else {
    32047. 

  32047.     i3 = 5192;
    32048. 

  32048.    }
    32049. 

  32049.   } else {
    32050. 

  32050.    i3 = (HEAP32[i4 >> 2] | 0) + (i5 << 4) | 0;
    32051. 

  32051.    i3 = i3 >>> 0 < (HEAP32[i2 + 8 >> 2] | 0) >>> 0 ? i3 : 5192;
    32052. 

  32052.   }
    32053. 

  32053.  } while (0);
    32054. 

  32054.  i3 = HEAP32[(HEAP32[i3 >> 2] | 0) + 12 >> 2] | 0;
    32055. 

  32055.  i2 = i2 + 8 | 0;
    32056. 

  32056.  i4 = HEAP32[i2 >> 2] | 0;
    32057. 

  32057.  if ((i3 | 0) == 0) {
    32058. 

  32058.   HEAP32[i4 + 8 >> 2] = 0;
    32059. 

  32059.   i5 = i4;
    32060. 

  32060.   i5 = i5 + 16 | 0;
    32061. 

  32061.   HEAP32[i2 >> 2] = i5;
    32062. 

  32062.   STACKTOP = i1;
    32063. 

  32063.   return;
    32064. 

  32064.  } else {
    32065. 

  32065.   HEAP32[i4 >> 2] = i3;
    32066. 

  32066.   HEAP32[i4 + 8 >> 2] = 69;
    32067. 

  32067.   i5 = HEAP32[i2 >> 2] | 0;
    32068. 

  32068.   i5 = i5 + 16 | 0;
    32069. 

  32069.   HEAP32[i2 >> 2] = i5;
    32070. 

  32070.   STACKTOP = i1;
    32071. 

  32071.   return;
    32072. 

  32072.  }
    32073. 

  32073. }
    32074. 

  32074. function _luaL_addlstring(i7, i6, i1) {
    32075. 

  32075.  i7 = i7 | 0;
    32076. 

  32076.  i6 = i6 | 0;
    32077. 

  32077.  i1 = i1 | 0;
    32078. 

  32078.  var i2 = 0, i3 = 0, i4 = 0, i5 = 0, i8 = 0, i9 = 0;
    32079. 

  32079.  i5 = STACKTOP;
    32080. 

  32080.  STACKTOP = STACKTOP + 16 | 0;
    32081. 

  32081.  i4 = HEAP32[i7 + 12 >> 2] | 0;
    32082. 

  32082.  i3 = i7 + 4 | 0;
    32083. 

  32083.  i9 = HEAP32[i3 >> 2] | 0;
    32084. 

  32084.  i2 = i7 + 8 | 0;
    32085. 

  32085.  i8 = HEAP32[i2 >> 2] | 0;
    32086. 

  32086.  if (!((i9 - i8 | 0) >>> 0 < i1 >>> 0)) {
    32087. 

  32087.   i7 = HEAP32[i7 >> 2] | 0;
    32088. 

  32088.   i9 = i8;
    32089. 

  32089.   i9 = i7 + i9 | 0;
    32090. 

  32090.   _memcpy(i9 | 0, i6 | 0, i1 | 0) | 0;
    32091. 

  32091.   i9 = HEAP32[i2 >> 2] | 0;
    32092. 

  32092.   i9 = i9 + i1 | 0;
    32093. 

  32093.   HEAP32[i2 >> 2] = i9;
    32094. 

  32094.   STACKTOP = i5;
    32095. 

  32095.   return;
    32096. 

  32096.  }
    32097. 

  32097.  i9 = i9 << 1;
    32098. 

  32098.  i9 = (i9 - i8 | 0) >>> 0 < i1 >>> 0 ? i8 + i1 | 0 : i9;
    32099. 

  32099.  if (i9 >>> 0 < i8 >>> 0 | (i9 - i8 | 0) >>> 0 < i1 >>> 0) {
    32100. 

  32100.   _luaL_error(i4, 1272, i5) | 0;
    32101. 

  32101.  }
    32102. 

  32102.  i8 = _lua_newuserdata(i4, i9) | 0;
    32103. 

  32103.  _memcpy(i8 | 0, HEAP32[i7 >> 2] | 0, HEAP32[i2 >> 2] | 0) | 0;
    32104. 

  32104.  if ((HEAP32[i7 >> 2] | 0) != (i7 + 16 | 0)) {
    32105. 

  32105.   _lua_remove(i4, -2);
    32106. 

  32106.  }
    32107. 

  32107.  HEAP32[i7 >> 2] = i8;
    32108. 

  32108.  HEAP32[i3 >> 2] = i9;
    32109. 

  32109.  i9 = HEAP32[i2 >> 2] | 0;
    32110. 

  32110.  i9 = i8 + i9 | 0;
    32111. 

  32111.  _memcpy(i9 | 0, i6 | 0, i1 | 0) | 0;
    32112. 

  32112.  i9 = HEAP32[i2 >> 2] | 0;
    32113. 

  32113.  i9 = i9 + i1 | 0;
    32114. 

  32114.  HEAP32[i2 >> 2] = i9;
    32115. 

  32115.  STACKTOP = i5;
    32116. 

  32116.  return;
    32117. 

  32117. }
    32118. 

  32118. function _lua_rawgeti(i3, i6, i1) {
    32119. 

  32119.  i3 = i3 | 0;
    32120. 

  32120.  i6 = i6 | 0;
    32121. 

  32121.  i1 = i1 | 0;
    32122. 

  32122.  var i2 = 0, i4 = 0, i5 = 0, i7 = 0;
    32123. 

  32123.  i2 = STACKTOP;
    32124. 

  32124.  i5 = HEAP32[i3 + 16 >> 2] | 0;
    32125. 

  32125.  do {
    32126. 

  32126.   if ((i6 | 0) <= 0) {
    32127. 

  32127.    if (!((i6 | 0) < -1000999)) {
    32128. 

  32128.     i4 = (HEAP32[i3 + 8 >> 2] | 0) + (i6 << 4) | 0;
    32129. 

  32129.     break;
    32130. 

  32130.    }
    32131. 

  32131.    if ((i6 | 0) == -1001e3) {
    32132. 

  32132.     i4 = (HEAP32[i3 + 12 >> 2] | 0) + 40 | 0;
    32133. 

  32133.     break;
    32134. 

  32134.    }
    32135. 

  32135.    i6 = -1001e3 - i6 | 0;
    32136. 

  32136.    i5 = HEAP32[i5 >> 2] | 0;
    32137. 

  32137.    if ((HEAP32[i5 + 8 >> 2] | 0) != 22 ? (i4 = HEAP32[i5 >> 2] | 0, (i6 | 0) <= (HEAPU8[i4 + 6 | 0] | 0 | 0)) : 0) {
    32138. 

  32138.     i4 = i4 + (i6 + -1 << 4) + 16 | 0;
    32139. 

  32139.    } else {
    32140. 

  32140.     i4 = 5192;
    32141. 

  32141.    }
    32142. 

  32142.   } else {
    32143. 

  32143.    i4 = (HEAP32[i5 >> 2] | 0) + (i6 << 4) | 0;
    32144. 

  32144.    i4 = i4 >>> 0 < (HEAP32[i3 + 8 >> 2] | 0) >>> 0 ? i4 : 5192;
    32145. 

  32145.   }
    32146. 

  32146.  } while (0);
    32147. 

  32147.  i4 = _luaH_getint(HEAP32[i4 >> 2] | 0, i1) | 0;
    32148. 

  32148.  i6 = i3 + 8 | 0;
    32149. 

  32149.  i5 = HEAP32[i6 >> 2] | 0;
    32150. 

  32150.  i7 = i4;
    32151. 

  32151.  i1 = HEAP32[i7 + 4 >> 2] | 0;
    32152. 

  32152.  i3 = i5;
    32153. 

  32153.  HEAP32[i3 >> 2] = HEAP32[i7 >> 2];
    32154. 

  32154.  HEAP32[i3 + 4 >> 2] = i1;
    32155. 

  32155.  HEAP32[i5 + 8 >> 2] = HEAP32[i4 + 8 >> 2];
    32156. 

  32156.  HEAP32[i6 >> 2] = (HEAP32[i6 >> 2] | 0) + 16;
    32157. 

  32157.  STACKTOP = i2;
    32158. 

  32158.  return;
    32159. 

  32159. }
    32160. 

  32160. function _lua_setfield(i1, i6, i3) {
    32161. 

  32161.  i1 = i1 | 0;
    32162. 

  32162.  i6 = i6 | 0;
    32163. 

  32163.  i3 = i3 | 0;
    32164. 

  32164.  var i2 = 0, i4 = 0, i5 = 0;
    32165. 

  32165.  i2 = STACKTOP;
    32166. 

  32166.  i5 = HEAP32[i1 + 16 >> 2] | 0;
    32167. 

  32167.  do {
    32168. 

  32168.   if ((i6 | 0) <= 0) {
    32169. 

  32169.    if (!((i6 | 0) < -1000999)) {
    32170. 

  32170.     i4 = (HEAP32[i1 + 8 >> 2] | 0) + (i6 << 4) | 0;
    32171. 

  32171.     break;
    32172. 

  32172.    }
    32173. 

  32173.    if ((i6 | 0) == -1001e3) {
    32174. 

  32174.     i4 = (HEAP32[i1 + 12 >> 2] | 0) + 40 | 0;
    32175. 

  32175.     break;
    32176. 

  32176.    }
    32177. 

  32177.    i6 = -1001e3 - i6 | 0;
    32178. 

  32178.    i5 = HEAP32[i5 >> 2] | 0;
    32179. 

  32179.    if ((HEAP32[i5 + 8 >> 2] | 0) != 22 ? (i4 = HEAP32[i5 >> 2] | 0, (i6 | 0) <= (HEAPU8[i4 + 6 | 0] | 0 | 0)) : 0) {
    32180. 

  32180.     i4 = i4 + (i6 + -1 << 4) + 16 | 0;
    32181. 

  32181.    } else {
    32182. 

  32182.     i4 = 5192;
    32183. 

  32183.    }
    32184. 

  32184.   } else {
    32185. 

  32185.    i4 = (HEAP32[i5 >> 2] | 0) + (i6 << 4) | 0;
    32186. 

  32186.    i4 = i4 >>> 0 < (HEAP32[i1 + 8 >> 2] | 0) >>> 0 ? i4 : 5192;
    32187. 

  32187.   }
    32188. 

  32188.  } while (0);
    32189. 

  32189.  i6 = i1 + 8 | 0;
    32190. 

  32190.  i5 = HEAP32[i6 >> 2] | 0;
    32191. 

  32191.  HEAP32[i6 >> 2] = i5 + 16;
    32192. 

  32192.  i3 = _luaS_new(i1, i3) | 0;
    32193. 

  32193.  HEAP32[i5 >> 2] = i3;
    32194. 

  32194.  HEAP32[i5 + 8 >> 2] = HEAPU8[i3 + 4 | 0] | 0 | 64;
    32195. 

  32195.  i5 = HEAP32[i6 >> 2] | 0;
    32196. 

  32196.  _luaV_settable(i1, i4, i5 + -16 | 0, i5 + -32 | 0);
    32197. 

  32197.  HEAP32[i6 >> 2] = (HEAP32[i6 >> 2] | 0) + -32;
    32198. 

  32198.  STACKTOP = i2;
    32199. 

  32199.  return;
    32200. 

  32200. }
    32201. 

  32201. function _luaopen_io(i1) {
    32202. 

  32202.  i1 = i1 | 0;
    32203. 

  32203.  var i2 = 0, i3 = 0, i4 = 0, i5 = 0;
    32204. 

  32204.  i2 = STACKTOP;
    32205. 

  32205.  _lua_createtable(i1, 0, 11);
    32206. 

  32206.  _luaL_setfuncs(i1, 2680, 0);
    32207. 

  32207.  _luaL_newmetatable(i1, 2832) | 0;
    32208. 

  32208.  _lua_pushvalue(i1, -1);
    32209. 

  32209.  _lua_setfield(i1, -2, 2872);
    32210. 

  32210.  _luaL_setfuncs(i1, 2880, 0);
    32211. 

  32211.  _lua_settop(i1, -2);
    32212. 

  32212.  i5 = HEAP32[_stdin >> 2] | 0;
    32213. 

  32213.  i4 = _lua_newuserdata(i1, 8) | 0;
    32214. 

  32214.  i3 = i4 + 4 | 0;
    32215. 

  32215.  HEAP32[i3 >> 2] = 0;
    32216. 

  32216.  _luaL_setmetatable(i1, 2832);
    32217. 

  32217.  HEAP32[i4 >> 2] = i5;
    32218. 

  32218.  HEAP32[i3 >> 2] = 154;
    32219. 

  32219.  _lua_pushvalue(i1, -1);
    32220. 

  32220.  _lua_setfield(i1, -1001e3, 2776);
    32221. 

  32221.  _lua_setfield(i1, -2, 2792);
    32222. 

  32222.  i3 = HEAP32[_stdout >> 2] | 0;
    32223. 

  32223.  i4 = _lua_newuserdata(i1, 8) | 0;
    32224. 

  32224.  i5 = i4 + 4 | 0;
    32225. 

  32225.  HEAP32[i5 >> 2] = 0;
    32226. 

  32226.  _luaL_setmetatable(i1, 2832);
    32227. 

  32227.  HEAP32[i4 >> 2] = i3;
    32228. 

  32228.  HEAP32[i5 >> 2] = 154;
    32229. 

  32229.  _lua_pushvalue(i1, -1);
    32230. 

  32230.  _lua_setfield(i1, -1001e3, 2800);
    32231. 

  32231.  _lua_setfield(i1, -2, 2816);
    32232. 

  32232.  i5 = HEAP32[_stderr >> 2] | 0;
    32233. 

  32233.  i4 = _lua_newuserdata(i1, 8) | 0;
    32234. 

  32234.  i3 = i4 + 4 | 0;
    32235. 

  32235.  HEAP32[i3 >> 2] = 0;
    32236. 

  32236.  _luaL_setmetatable(i1, 2832);
    32237. 

  32237.  HEAP32[i4 >> 2] = i5;
    32238. 

  32238.  HEAP32[i3 >> 2] = 154;
    32239. 

  32239.  _lua_setfield(i1, -2, 2824);
    32240. 

  32240.  STACKTOP = i2;
    32241. 

  32241.  return 1;
    32242. 

  32242. }
    32243. 

  32243. function _lua_pushcclosure(i1, i4, i5) {
    32244. 

  32244.  i1 = i1 | 0;
    32245. 

  32245.  i4 = i4 | 0;
    32246. 

  32246.  i5 = i5 | 0;
    32247. 

  32247.  var i2 = 0, i3 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0;
    32248. 

  32248.  i2 = STACKTOP;
    32249. 

  32249.  if ((i5 | 0) == 0) {
    32250. 

  32250.   i6 = HEAP32[i1 + 8 >> 2] | 0;
    32251. 

  32251.   HEAP32[i6 >> 2] = i4;
    32252. 

  32252.   HEAP32[i6 + 8 >> 2] = 22;
    32253. 

  32253.   i6 = i1 + 8 | 0;
    32254. 

  32254.   i5 = HEAP32[i6 >> 2] | 0;
    32255. 

  32255.   i5 = i5 + 16 | 0;
    32256. 

  32256.   HEAP32[i6 >> 2] = i5;
    32257. 

  32257.   STACKTOP = i2;
    32258. 

  32258.   return;
    32259. 

  32259.  }
    32260. 

  32260.  if ((HEAP32[(HEAP32[i1 + 12 >> 2] | 0) + 12 >> 2] | 0) > 0) {
    32261. 

  32261.   _luaC_step(i1);
    32262. 

  32262.  }
    32263. 

  32263.  i3 = _luaF_newCclosure(i1, i5) | 0;
    32264. 

  32264.  HEAP32[i3 + 12 >> 2] = i4;
    32265. 

  32265.  i4 = i1 + 8 | 0;
    32266. 

  32266.  i6 = (HEAP32[i4 >> 2] | 0) + (0 - i5 << 4) | 0;
    32267. 

  32267.  HEAP32[i4 >> 2] = i6;
    32268. 

  32268.  do {
    32269. 

  32269.   i5 = i5 + -1 | 0;
    32270. 

  32270.   i9 = i6 + (i5 << 4) | 0;
    32271. 

  32271.   i8 = HEAP32[i9 + 4 >> 2] | 0;
    32272. 

  32272.   i7 = i3 + (i5 << 4) + 16 | 0;
    32273. 

  32273.   HEAP32[i7 >> 2] = HEAP32[i9 >> 2];
    32274. 

  32274.   HEAP32[i7 + 4 >> 2] = i8;
    32275. 

  32275.   HEAP32[i3 + (i5 << 4) + 24 >> 2] = HEAP32[i6 + (i5 << 4) + 8 >> 2];
    32276. 

  32276.   i6 = HEAP32[i4 >> 2] | 0;
    32277. 

  32277.  } while ((i5 | 0) != 0);
    32278. 

  32278.  HEAP32[i6 >> 2] = i3;
    32279. 

  32279.  HEAP32[i6 + 8 >> 2] = 102;
    32280. 

  32280.  i9 = i1 + 8 | 0;
    32281. 

  32281.  i8 = HEAP32[i9 >> 2] | 0;
    32282. 

  32282.  i8 = i8 + 16 | 0;
    32283. 

  32283.  HEAP32[i9 >> 2] = i8;
    32284. 

  32284.  STACKTOP = i2;
    32285. 

  32285.  return;
    32286. 

  32286. }
    32287. 

  32287. function _luaF_findupval(i3, i4) {
    32288. 

  32288.  i3 = i3 | 0;
    32289. 

  32289.  i4 = i4 | 0;
    32290. 

  32290.  var i1 = 0, i2 = 0, i5 = 0, i6 = 0, i7 = 0;
    32291. 

  32291.  i1 = STACKTOP;
    32292. 

  32292.  i2 = HEAP32[i3 + 12 >> 2] | 0;
    32293. 

  32293.  i6 = i3 + 56 | 0;
    32294. 

  32294.  i5 = HEAP32[i6 >> 2] | 0;
    32295. 

  32295.  L1 : do {
    32296. 

  32296.   if ((i5 | 0) == 0) {
    32297. 

  32297.    i5 = i6;
    32298. 

  32298.   } else {
    32299. 

  32299.    while (1) {
    32300. 

  32300.     i7 = HEAP32[i5 + 8 >> 2] | 0;
    32301. 

  32301.     if (i7 >>> 0 < i4 >>> 0) {
    32302. 

  32302.      i5 = i6;
    32303. 

  32303.      break L1;
    32304. 

  32304.     }
    32305. 

  32305.     if ((i7 | 0) == (i4 | 0)) {
    32306. 

  32306.      break;
    32307. 

  32307.     }
    32308. 

  32308.     i6 = HEAP32[i5 >> 2] | 0;
    32309. 

  32309.     if ((i6 | 0) == 0) {
    32310. 

  32310.      break L1;
    32311. 

  32311.     } else {
    32312. 

  32312.      i7 = i5;
    32313. 

  32313.      i5 = i6;
    32314. 

  32314.      i6 = i7;
    32315. 

  32315.     }
    32316. 

  32316.    }
    32317. 

  32317.    i4 = i5 + 5 | 0;
    32318. 

  32318.    i3 = (HEAPU8[i4] | 0) ^ 3;
    32319. 

  32319.    if ((((HEAPU8[i2 + 60 | 0] | 0) ^ 3) & i3 | 0) != 0) {
    32320. 

  32320.     i7 = i5;
    32321. 

  32321.     STACKTOP = i1;
    32322. 

  32322.     return i7 | 0;
    32323. 

  32323.    }
    32324. 

  32324.    HEAP8[i4] = i3;
    32325. 

  32325.    i7 = i5;
    32326. 

  32326.    STACKTOP = i1;
    32327. 

  32327.    return i7 | 0;
    32328. 

  32328.   }
    32329. 

  32329.  } while (0);
    32330. 

  32330.  i7 = _luaC_newobj(i3, 10, 32, i5, 0) | 0;
    32331. 

  32331.  HEAP32[i7 + 8 >> 2] = i4;
    32332. 

  32332.  i4 = i7 + 16 | 0;
    32333. 

  32333.  HEAP32[i4 >> 2] = i2 + 112;
    32334. 

  32334.  i6 = i2 + 132 | 0;
    32335. 

  32335.  i5 = HEAP32[i6 >> 2] | 0;
    32336. 

  32336.  HEAP32[i4 + 4 >> 2] = i5;
    32337. 

  32337.  HEAP32[i5 + 16 >> 2] = i7;
    32338. 

  32338.  HEAP32[i6 >> 2] = i7;
    32339. 

  32339.  STACKTOP = i1;
    32340. 

  32340.  return i7 | 0;
    32341. 

  32341. }
    32342. 

  32342. function _luaC_checkfinalizer(i5, i4, i6) {
    32343. 

  32343.  i5 = i5 | 0;
    32344. 

  32344.  i4 = i4 | 0;
    32345. 

  32345.  i6 = i6 | 0;
    32346. 

  32346.  var i1 = 0, i2 = 0, i3 = 0, i7 = 0, i8 = 0;
    32347. 

  32347.  i3 = STACKTOP;
    32348. 

  32348.  i1 = HEAP32[i5 + 12 >> 2] | 0;
    32349. 

  32349.  i2 = i4 + 5 | 0;
    32350. 

  32350.  if ((HEAP8[i2] & 24) != 0 | (i6 | 0) == 0) {
    32351. 

  32351.   STACKTOP = i3;
    32352. 

  32352.   return;
    32353. 

  32353.  }
    32354. 

  32354.  if (!((HEAP8[i6 + 6 | 0] & 4) == 0)) {
    32355. 

  32355.   STACKTOP = i3;
    32356. 

  32356.   return;
    32357. 

  32357.  }
    32358. 

  32358.  if ((_luaT_gettm(i6, 2, HEAP32[i1 + 192 >> 2] | 0) | 0) == 0) {
    32359. 

  32359.   STACKTOP = i3;
    32360. 

  32360.   return;
    32361. 

  32361.  }
    32362. 

  32362.  i7 = i1 + 76 | 0;
    32363. 

  32363.  i8 = HEAP32[i7 >> 2] | 0;
    32364. 

  32364.  if ((i8 | 0) == (i4 | 0)) {
    32365. 

  32365.   do {
    32366. 

  32366.    i6 = _sweeplist(i5, i8, 1) | 0;
    32367. 

  32367.   } while ((i6 | 0) == (i8 | 0));
    32368. 

  32368.   HEAP32[i7 >> 2] = i6;
    32369. 

  32369.  }
    32370. 

  32370.  i5 = i1 + 68 | 0;
    32371. 

  32371.  while (1) {
    32372. 

  32372.   i6 = HEAP32[i5 >> 2] | 0;
    32373. 

  32373.   if ((i6 | 0) == (i4 | 0)) {
    32374. 

  32374.    break;
    32375. 

  32375.   } else {
    32376. 

  32376.    i5 = i6;
    32377. 

  32377.   }
    32378. 

  32378.  }
    32379. 

  32379.  HEAP32[i5 >> 2] = HEAP32[i4 >> 2];
    32380. 

  32380.  i8 = i1 + 72 | 0;
    32381. 

  32381.  HEAP32[i4 >> 2] = HEAP32[i8 >> 2];
    32382. 

  32382.  HEAP32[i8 >> 2] = i4;
    32383. 

  32383.  i4 = HEAPU8[i2] | 0 | 16;
    32384. 

  32384.  HEAP8[i2] = i4;
    32385. 

  32385.  if ((HEAPU8[i1 + 61 | 0] | 0) < 2) {
    32386. 

  32386.   HEAP8[i2] = i4 & 191;
    32387. 

  32387.   STACKTOP = i3;
    32388. 

  32388.   return;
    32389. 

  32389.  } else {
    32390. 

  32390.   HEAP8[i2] = HEAP8[i1 + 60 | 0] & 3 | i4 & 184;
    32391. 

  32391.   STACKTOP = i3;
    32392. 

  32392.   return;
    32393. 

  32393.  }
    32394. 

  32394. }
    32395. 

  32395. function _io_lines(i1) {
    32396. 

  32396.  i1 = i1 | 0;
    32397. 

  32397.  var i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0;
    32398. 

  32398.  i2 = STACKTOP;
    32399. 

  32399.  STACKTOP = STACKTOP + 16 | 0;
    32400. 

  32400.  i3 = i2;
    32401. 

  32401.  if ((_lua_type(i1, 1) | 0) == -1) {
    32402. 

  32402.   _lua_pushnil(i1);
    32403. 

  32403.  }
    32404. 

  32404.  if ((_lua_type(i1, 1) | 0) == 0) {
    32405. 

  32405.   _lua_getfield(i1, -1001e3, 2776);
    32406. 

  32406.   _lua_replace(i1, 1);
    32407. 

  32407.   if ((HEAP32[(_luaL_checkudata(i1, 1, 2832) | 0) + 4 >> 2] | 0) != 0) {
    32408. 

  32408.    i4 = 0;
    32409. 

  32409.    _aux_lines(i1, i4);
    32410. 

  32410.    STACKTOP = i2;
    32411. 

  32411.    return 1;
    32412. 

  32412.   }
    32413. 

  32413.   _luaL_error(i1, 3080, i3) | 0;
    32414. 

  32414.   i4 = 0;
    32415. 

  32415.   _aux_lines(i1, i4);
    32416. 

  32416.   STACKTOP = i2;
    32417. 

  32417.   return 1;
    32418. 

  32418.  } else {
    32419. 

  32419.   i4 = _luaL_checklstring(i1, 1, 0) | 0;
    32420. 

  32420.   i6 = _lua_newuserdata(i1, 8) | 0;
    32421. 

  32421.   i5 = i6 + 4 | 0;
    32422. 

  32422.   HEAP32[i5 >> 2] = 0;
    32423. 

  32423.   _luaL_setmetatable(i1, 2832);
    32424. 

  32424.   HEAP32[i6 >> 2] = 0;
    32425. 

  32425.   HEAP32[i5 >> 2] = 156;
    32426. 

  32426.   i5 = _fopen(i4 | 0, 3480) | 0;
    32427. 

  32427.   HEAP32[i6 >> 2] = i5;
    32428. 

  32428.   if ((i5 | 0) == 0) {
    32429. 

  32429.    i6 = _strerror(HEAP32[(___errno_location() | 0) >> 2] | 0) | 0;
    32430. 

  32430.    HEAP32[i3 >> 2] = i4;
    32431. 

  32431.    HEAP32[i3 + 4 >> 2] = i6;
    32432. 

  32432.    _luaL_error(i1, 3520, i3) | 0;
    32433. 

  32433.   }
    32434. 

  32434.   _lua_replace(i1, 1);
    32435. 

  32435.   i6 = 1;
    32436. 

  32436.   _aux_lines(i1, i6);
    32437. 

  32437.   STACKTOP = i2;
    32438. 

  32438.   return 1;
    32439. 

  32439.  }
    32440. 

  32440.  return 0;
    32441. 

  32441. }
    32442. 

  32442. function _luaC_changemode(i2, i6) {
    32443. 

  32443.  i2 = i2 | 0;
    32444. 

  32444.  i6 = i6 | 0;
    32445. 

  32445.  var i1 = 0, i3 = 0, i4 = 0, i5 = 0;
    32446. 

  32446.  i1 = STACKTOP;
    32447. 

  32447.  i3 = i2 + 12 | 0;
    32448. 

  32448.  i5 = HEAP32[i3 >> 2] | 0;
    32449. 

  32449.  i4 = i5 + 62 | 0;
    32450. 

  32450.  if ((HEAPU8[i4] | 0) == (i6 | 0)) {
    32451. 

  32451.   STACKTOP = i1;
    32452. 

  32452.   return;
    32453. 

  32453.  }
    32454. 

  32454.  if ((i6 | 0) == 2) {
    32455. 

  32455.   i3 = i5 + 61 | 0;
    32456. 

  32456.   if ((HEAP8[i3] | 0) != 0) {
    32457. 

  32457.    do {
    32458. 

  32458.     _singlestep(i2) | 0;
    32459. 

  32459.    } while ((HEAP8[i3] | 0) != 0);
    32460. 

  32460.   }
    32461. 

  32461.   HEAP32[i5 + 20 >> 2] = (HEAP32[i5 + 12 >> 2] | 0) + (HEAP32[i5 + 8 >> 2] | 0);
    32462. 

  32462.   HEAP8[i4] = 2;
    32463. 

  32463.   STACKTOP = i1;
    32464. 

  32464.   return;
    32465. 

  32465.  }
    32466. 

  32466.  HEAP8[i4] = 0;
    32467. 

  32467.  i4 = HEAP32[i3 >> 2] | 0;
    32468. 

  32468.  HEAP8[i4 + 61 | 0] = 2;
    32469. 

  32469.  HEAP32[i4 + 64 >> 2] = 0;
    32470. 

  32470.  i5 = i4 + 72 | 0;
    32471. 

  32471.  do {
    32472. 

  32472.   i6 = _sweeplist(i2, i5, 1) | 0;
    32473. 

  32473.  } while ((i6 | 0) == (i5 | 0));
    32474. 

  32474.  HEAP32[i4 + 80 >> 2] = i6;
    32475. 

  32475.  i5 = i4 + 68 | 0;
    32476. 

  32476.  do {
    32477. 

  32477.   i6 = _sweeplist(i2, i5, 1) | 0;
    32478. 

  32478.  } while ((i6 | 0) == (i5 | 0));
    32479. 

  32479.  HEAP32[i4 + 76 >> 2] = i6;
    32480. 

  32480.  i3 = (HEAP32[i3 >> 2] | 0) + 61 | 0;
    32481. 

  32481.  if ((1 << HEAPU8[i3] & -29 | 0) != 0) {
    32482. 

  32482.   STACKTOP = i1;
    32483. 

  32483.   return;
    32484. 

  32484.  }
    32485. 

  32485.  do {
    32486. 

  32486.   _singlestep(i2) | 0;
    32487. 

  32487.  } while ((1 << HEAPU8[i3] & -29 | 0) == 0);
    32488. 

  32488.  STACKTOP = i1;
    32489. 

  32489.  return;
    32490. 

  32490. }
    32491. 

  32491. function _lua_rawget(i1, i5) {
    32492. 

  32492.  i1 = i1 | 0;
    32493. 

  32493.  i5 = i5 | 0;
    32494. 

  32494.  var i2 = 0, i3 = 0, i4 = 0, i6 = 0;
    32495. 

  32495.  i2 = STACKTOP;
    32496. 

  32496.  i4 = HEAP32[i1 + 16 >> 2] | 0;
    32497. 

  32497.  do {
    32498. 

  32498.   if ((i5 | 0) <= 0) {
    32499. 

  32499.    if (!((i5 | 0) < -1000999)) {
    32500. 

  32500.     i3 = (HEAP32[i1 + 8 >> 2] | 0) + (i5 << 4) | 0;
    32501. 

  32501.     break;
    32502. 

  32502.    }
    32503. 

  32503.    if ((i5 | 0) == -1001e3) {
    32504. 

  32504.     i3 = (HEAP32[i1 + 12 >> 2] | 0) + 40 | 0;
    32505. 

  32505.     break;
    32506. 

  32506.    }
    32507. 

  32507.    i5 = -1001e3 - i5 | 0;
    32508. 

  32508.    i4 = HEAP32[i4 >> 2] | 0;
    32509. 

  32509.    if ((HEAP32[i4 + 8 >> 2] | 0) != 22 ? (i3 = HEAP32[i4 >> 2] | 0, (i5 | 0) <= (HEAPU8[i3 + 6 | 0] | 0 | 0)) : 0) {
    32510. 

  32510.     i3 = i3 + (i5 + -1 << 4) + 16 | 0;
    32511. 

  32511.    } else {
    32512. 

  32512.     i3 = 5192;
    32513. 

  32513.    }
    32514. 

  32514.   } else {
    32515. 

  32515.    i3 = (HEAP32[i4 >> 2] | 0) + (i5 << 4) | 0;
    32516. 

  32516.    i3 = i3 >>> 0 < (HEAP32[i1 + 8 >> 2] | 0) >>> 0 ? i3 : 5192;
    32517. 

  32517.   }
    32518. 

  32518.  } while (0);
    32519. 

  32519.  i5 = i1 + 8 | 0;
    32520. 

  32520.  i4 = _luaH_get(HEAP32[i3 >> 2] | 0, (HEAP32[i5 >> 2] | 0) + -16 | 0) | 0;
    32521. 

  32521.  i5 = HEAP32[i5 >> 2] | 0;
    32522. 

  32522.  i6 = i4;
    32523. 

  32523.  i1 = HEAP32[i6 + 4 >> 2] | 0;
    32524. 

  32524.  i3 = i5 + -16 | 0;
    32525. 

  32525.  HEAP32[i3 >> 2] = HEAP32[i6 >> 2];
    32526. 

  32526.  HEAP32[i3 + 4 >> 2] = i1;
    32527. 

  32527.  HEAP32[i5 + -8 >> 2] = HEAP32[i4 + 8 >> 2];
    32528. 

  32528.  STACKTOP = i2;
    32529. 

  32529.  return;
    32530. 

  32530. }
    32531. 

  32531. function _lua_isstring(i2, i4) {
    32532. 

  32532.  i2 = i2 | 0;
    32533. 

  32533.  i4 = i4 | 0;
    32534. 

  32534.  var i1 = 0, i3 = 0;
    32535. 

  32535.  i1 = STACKTOP;
    32536. 

  32536.  i3 = HEAP32[i2 + 16 >> 2] | 0;
    32537. 

  32537.  do {
    32538. 

  32538.   if ((i4 | 0) <= 0) {
    32539. 

  32539.    if (!((i4 | 0) < -1000999)) {
    32540. 

  32540.     i2 = (HEAP32[i2 + 8 >> 2] | 0) + (i4 << 4) | 0;
    32541. 

  32541.     break;
    32542. 

  32542.    }
    32543. 

  32543.    if ((i4 | 0) == -1001e3) {
    32544. 

  32544.     i2 = (HEAP32[i2 + 12 >> 2] | 0) + 40 | 0;
    32545. 

  32545.     break;
    32546. 

  32546.    }
    32547. 

  32547.    i2 = -1001e3 - i4 | 0;
    32548. 

  32548.    i3 = HEAP32[i3 >> 2] | 0;
    32549. 

  32549.    if ((HEAP32[i3 + 8 >> 2] | 0) == 22) {
    32550. 

  32550.     i4 = 0;
    32551. 

  32551.     i4 = i4 & 1;
    32552. 

  32552.     STACKTOP = i1;
    32553. 

  32553.     return i4 | 0;
    32554. 

  32554.    }
    32555. 

  32555.    i3 = HEAP32[i3 >> 2] | 0;
    32556. 

  32556.    if ((i2 | 0) > (HEAPU8[i3 + 6 | 0] | 0 | 0)) {
    32557. 

  32557.     i4 = 0;
    32558. 

  32558.     i4 = i4 & 1;
    32559. 

  32559.     STACKTOP = i1;
    32560. 

  32560.     return i4 | 0;
    32561. 

  32561.    } else {
    32562. 

  32562.     i2 = i3 + (i2 + -1 << 4) + 16 | 0;
    32563. 

  32563.     break;
    32564. 

  32564.    }
    32565. 

  32565.   } else {
    32566. 

  32566.    i3 = (HEAP32[i3 >> 2] | 0) + (i4 << 4) | 0;
    32567. 

  32567.    i2 = i3 >>> 0 < (HEAP32[i2 + 8 >> 2] | 0) >>> 0 ? i3 : 5192;
    32568. 

  32568.   }
    32569. 

  32569.  } while (0);
    32570. 

  32570.  if ((i2 | 0) == 5192) {
    32571. 

  32571.   i4 = 0;
    32572. 

  32572.   i4 = i4 & 1;
    32573. 

  32573.   STACKTOP = i1;
    32574. 

  32574.   return i4 | 0;
    32575. 

  32575.  }
    32576. 

  32576.  i4 = ((HEAP32[i2 + 8 >> 2] & 15) + -3 | 0) >>> 0 < 2;
    32577. 

  32577.  i4 = i4 & 1;
    32578. 

  32578.  STACKTOP = i1;
    32579. 

  32579.  return i4 | 0;
    32580. 

  32580. }
    32581. 

  32581. function _setnodevector(i5, i1, i3) {
    32582. 

  32582.  i5 = i5 | 0;
    32583. 

  32583.  i1 = i1 | 0;
    32584. 

  32584.  i3 = i3 | 0;
    32585. 

  32585.  var i2 = 0, i4 = 0, i6 = 0, i7 = 0;
    32586. 

  32586.  i2 = STACKTOP;
    32587. 

  32587.  STACKTOP = STACKTOP + 16 | 0;
    32588. 

  32588.  if ((i3 | 0) == 0) {
    32589. 

  32589.   HEAP32[i1 + 16 >> 2] = 8016;
    32590. 

  32590.   i6 = 0;
    32591. 

  32591.   i7 = 8016;
    32592. 

  32592.   i4 = 0;
    32593. 

  32593.   i5 = i1 + 7 | 0;
    32594. 

  32594.   HEAP8[i5] = i4;
    32595. 

  32595.   i6 = i7 + (i6 << 5) | 0;
    32596. 

  32596.   i7 = i1 + 20 | 0;
    32597. 

  32597.   HEAP32[i7 >> 2] = i6;
    32598. 

  32598.   STACKTOP = i2;
    32599. 

  32599.   return;
    32600. 

  32600.  }
    32601. 

  32601.  i4 = _luaO_ceillog2(i3) | 0;
    32602. 

  32602.  if ((i4 | 0) > 30) {
    32603. 

  32603.   _luaG_runerror(i5, 8048, i2);
    32604. 

  32604.  }
    32605. 

  32605.  i3 = 1 << i4;
    32606. 

  32606.  if ((i3 + 1 | 0) >>> 0 > 134217727) {
    32607. 

  32607.   _luaM_toobig(i5);
    32608. 

  32608.  }
    32609. 

  32609.  i6 = _luaM_realloc_(i5, 0, 0, i3 << 5) | 0;
    32610. 

  32610.  i5 = i1 + 16 | 0;
    32611. 

  32611.  HEAP32[i5 >> 2] = i6;
    32612. 

  32612.  if ((i3 | 0) > 0) {
    32613. 

  32613.   i7 = 0;
    32614. 

  32614.   do {
    32615. 

  32615.    HEAP32[i6 + (i7 << 5) + 28 >> 2] = 0;
    32616. 

  32616.    HEAP32[i6 + (i7 << 5) + 24 >> 2] = 0;
    32617. 

  32617.    HEAP32[i6 + (i7 << 5) + 8 >> 2] = 0;
    32618. 

  32618.    i7 = i7 + 1 | 0;
    32619. 

  32619.    i6 = HEAP32[i5 >> 2] | 0;
    32620. 

  32620.   } while ((i7 | 0) != (i3 | 0));
    32621. 

  32621.  }
    32622. 

  32622.  i7 = i3;
    32623. 

  32623.  i4 = i4 & 255;
    32624. 

  32624.  i5 = i1 + 7 | 0;
    32625. 

  32625.  HEAP8[i5] = i4;
    32626. 

  32626.  i6 = i6 + (i7 << 5) | 0;
    32627. 

  32627.  i7 = i1 + 20 | 0;
    32628. 

  32628.  HEAP32[i7 >> 2] = i6;
    32629. 

  32629.  STACKTOP = i2;
    32630. 

  32630.  return;
    32631. 

  32631. }
    32632. 

  32632. function _lua_pushvalue(i1, i5) {
    32633. 

  32633.  i1 = i1 | 0;
    32634. 

  32634.  i5 = i5 | 0;
    32635. 

  32635.  var i2 = 0, i3 = 0, i4 = 0, i6 = 0, i7 = 0;
    32636. 

  32636.  i2 = STACKTOP;
    32637. 

  32637.  i4 = HEAP32[i1 + 16 >> 2] | 0;
    32638. 

  32638.  do {
    32639. 

  32639.   if ((i5 | 0) <= 0) {
    32640. 

  32640.    if (!((i5 | 0) < -1000999)) {
    32641. 

  32641.     i3 = (HEAP32[i1 + 8 >> 2] | 0) + (i5 << 4) | 0;
    32642. 

  32642.     break;
    32643. 

  32643.    }
    32644. 

  32644.    if ((i5 | 0) == -1001e3) {
    32645. 

  32645.     i3 = (HEAP32[i1 + 12 >> 2] | 0) + 40 | 0;
    32646. 

  32646.     break;
    32647. 

  32647.    }
    32648. 

  32648.    i5 = -1001e3 - i5 | 0;
    32649. 

  32649.    i4 = HEAP32[i4 >> 2] | 0;
    32650. 

  32650.    if ((HEAP32[i4 + 8 >> 2] | 0) != 22 ? (i3 = HEAP32[i4 >> 2] | 0, (i5 | 0) <= (HEAPU8[i3 + 6 | 0] | 0 | 0)) : 0) {
    32651. 

  32651.     i3 = i3 + (i5 + -1 << 4) + 16 | 0;
    32652. 

  32652.    } else {
    32653. 

  32653.     i3 = 5192;
    32654. 

  32654.    }
    32655. 

  32655.   } else {
    32656. 

  32656.    i3 = (HEAP32[i4 >> 2] | 0) + (i5 << 4) | 0;
    32657. 

  32657.    i3 = i3 >>> 0 < (HEAP32[i1 + 8 >> 2] | 0) >>> 0 ? i3 : 5192;
    32658. 

  32658.   }
    32659. 

  32659.  } while (0);
    32660. 

  32660.  i5 = i1 + 8 | 0;
    32661. 

  32661.  i4 = HEAP32[i5 >> 2] | 0;
    32662. 

  32662.  i7 = i3;
    32663. 

  32663.  i6 = HEAP32[i7 + 4 >> 2] | 0;
    32664. 

  32664.  i1 = i4;
    32665. 

  32665.  HEAP32[i1 >> 2] = HEAP32[i7 >> 2];
    32666. 

  32666.  HEAP32[i1 + 4 >> 2] = i6;
    32667. 

  32667.  HEAP32[i4 + 8 >> 2] = HEAP32[i3 + 8 >> 2];
    32668. 

  32668.  HEAP32[i5 >> 2] = (HEAP32[i5 >> 2] | 0) + 16;
    32669. 

  32669.  STACKTOP = i2;
    32670. 

  32670.  return;
    32671. 

  32671. }
    32672. 

  32672. function _luaL_setfuncs(i3, i6, i1) {
    32673. 

  32673.  i3 = i3 | 0;
    32674. 

  32674.  i6 = i6 | 0;
    32675. 

  32675.  i1 = i1 | 0;
    32676. 

  32676.  var i2 = 0, i4 = 0, i5 = 0, i7 = 0;
    32677. 

  32677.  i2 = STACKTOP;
    32678. 

  32678.  STACKTOP = STACKTOP + 16 | 0;
    32679. 

  32679.  i4 = i2;
    32680. 

  32680.  _luaL_checkversion_(i3, 502.0);
    32681. 

  32681.  if ((_lua_checkstack(i3, i1 + 20 | 0) | 0) == 0) {
    32682. 

  32682.   HEAP32[i4 >> 2] = 1472;
    32683. 

  32683.   _luaL_error(i3, 1216, i4) | 0;
    32684. 

  32684.  }
    32685. 

  32685.  if ((HEAP32[i6 >> 2] | 0) == 0) {
    32686. 

  32686.   i7 = ~i1;
    32687. 

  32687.   _lua_settop(i3, i7);
    32688. 

  32688.   STACKTOP = i2;
    32689. 

  32689.   return;
    32690. 

  32690.  }
    32691. 

  32691.  i4 = -2 - i1 | 0;
    32692. 

  32692.  i5 = 0 - i1 | 0;
    32693. 

  32693.  if ((i1 | 0) <= 0) {
    32694. 

  32694.   do {
    32695. 

  32695.    _lua_pushcclosure(i3, HEAP32[i6 + 4 >> 2] | 0, i1);
    32696. 

  32696.    _lua_setfield(i3, i4, HEAP32[i6 >> 2] | 0);
    32697. 

  32697.    i6 = i6 + 8 | 0;
    32698. 

  32698.   } while ((HEAP32[i6 >> 2] | 0) != 0);
    32699. 

  32699.   i7 = ~i1;
    32700. 

  32700.   _lua_settop(i3, i7);
    32701. 

  32701.   STACKTOP = i2;
    32702. 

  32702.   return;
    32703. 

  32703.  }
    32704. 

  32704.  do {
    32705. 

  32705.   i7 = 0;
    32706. 

  32706.   do {
    32707. 

  32707.    _lua_pushvalue(i3, i5);
    32708. 

  32708.    i7 = i7 + 1 | 0;
    32709. 

  32709.   } while ((i7 | 0) != (i1 | 0));
    32710. 

  32710.   _lua_pushcclosure(i3, HEAP32[i6 + 4 >> 2] | 0, i1);
    32711. 

  32711.   _lua_setfield(i3, i4, HEAP32[i6 >> 2] | 0);
    32712. 

  32712.   i6 = i6 + 8 | 0;
    32713. 

  32713.  } while ((HEAP32[i6 >> 2] | 0) != 0);
    32714. 

  32714.  i7 = ~i1;
    32715. 

  32715.  _lua_settop(i3, i7);
    32716. 

  32716.  STACKTOP = i2;
    32717. 

  32717.  return;
    32718. 

  32718. }
    32719. 

  32719. function _lua_touserdata(i3, i5) {
    32720. 

  32720.  i3 = i3 | 0;
    32721. 

  32721.  i5 = i5 | 0;
    32722. 

  32722.  var i1 = 0, i2 = 0, i4 = 0;
    32723. 

  32723.  i1 = STACKTOP;
    32724. 

  32724.  i4 = HEAP32[i3 + 16 >> 2] | 0;
    32725. 

  32725.  do {
    32726. 

  32726.   if ((i5 | 0) <= 0) {
    32727. 

  32727.    if (!((i5 | 0) < -1000999)) {
    32728. 

  32728.     i2 = (HEAP32[i3 + 8 >> 2] | 0) + (i5 << 4) | 0;
    32729. 

  32729.     break;
    32730. 

  32730.    }
    32731. 

  32731.    if ((i5 | 0) == -1001e3) {
    32732. 

  32732.     i2 = (HEAP32[i3 + 12 >> 2] | 0) + 40 | 0;
    32733. 

  32733.     break;
    32734. 

  32734.    }
    32735. 

  32735.    i3 = -1001e3 - i5 | 0;
    32736. 

  32736.    i4 = HEAP32[i4 >> 2] | 0;
    32737. 

  32737.    if ((HEAP32[i4 + 8 >> 2] | 0) != 22 ? (i2 = HEAP32[i4 >> 2] | 0, (i3 | 0) <= (HEAPU8[i2 + 6 | 0] | 0 | 0)) : 0) {
    32738. 

  32738.     i2 = i2 + (i3 + -1 << 4) + 16 | 0;
    32739. 

  32739.    } else {
    32740. 

  32740.     i2 = 5192;
    32741. 

  32741.    }
    32742. 

  32742.   } else {
    32743. 

  32743.    i2 = (HEAP32[i4 >> 2] | 0) + (i5 << 4) | 0;
    32744. 

  32744.    i2 = i2 >>> 0 < (HEAP32[i3 + 8 >> 2] | 0) >>> 0 ? i2 : 5192;
    32745. 

  32745.   }
    32746. 

  32746.  } while (0);
    32747. 

  32747.  i3 = HEAP32[i2 + 8 >> 2] & 15;
    32748. 

  32748.  if ((i3 | 0) == 2) {
    32749. 

  32749.   i5 = HEAP32[i2 >> 2] | 0;
    32750. 

  32750.   STACKTOP = i1;
    32751. 

  32751.   return i5 | 0;
    32752. 

  32752.  } else if ((i3 | 0) == 7) {
    32753. 

  32753.   i5 = (HEAP32[i2 >> 2] | 0) + 24 | 0;
    32754. 

  32754.   STACKTOP = i1;
    32755. 

  32755.   return i5 | 0;
    32756. 

  32756.  } else {
    32757. 

  32757.   i5 = 0;
    32758. 

  32758.   STACKTOP = i1;
    32759. 

  32759.   return i5 | 0;
    32760. 

  32760.  }
    32761. 

  32761.  return 0;
    32762. 

  32762. }
    32763. 

  32763. function _luaL_checkoption(i2, i3, i6, i4) {
    32764. 

  32764.  i2 = i2 | 0;
    32765. 

  32765.  i3 = i3 | 0;
    32766. 

  32766.  i6 = i6 | 0;
    32767. 

  32767.  i4 = i4 | 0;
    32768. 

  32768.  var i1 = 0, i5 = 0, i7 = 0, i8 = 0, i9 = 0;
    32769. 

  32769.  i1 = STACKTOP;
    32770. 

  32770.  STACKTOP = STACKTOP + 16 | 0;
    32771. 

  32771.  i5 = i1;
    32772. 

  32772.  if ((i6 | 0) == 0) {
    32773. 

  32773.   i6 = _lua_tolstring(i2, i3, 0) | 0;
    32774. 

  32774.   if ((i6 | 0) == 0) {
    32775. 

  32775.    i9 = _lua_typename(i2, 4) | 0;
    32776. 

  32776.    i6 = _lua_typename(i2, _lua_type(i2, i3) | 0) | 0;
    32777. 

  32777.    HEAP32[i5 >> 2] = i9;
    32778. 

  32778.    HEAP32[i5 + 4 >> 2] = i6;
    32779. 

  32779.    _luaL_argerror(i2, i3, _lua_pushfstring(i2, 1744, i5) | 0) | 0;
    32780. 

  32780.    i6 = 0;
    32781. 

  32781.   }
    32782. 

  32782.  } else {
    32783. 

  32783.   i6 = _luaL_optlstring(i2, i3, i6, 0) | 0;
    32784. 

  32784.  }
    32785. 

  32785.  i9 = HEAP32[i4 >> 2] | 0;
    32786. 

  32786.  L6 : do {
    32787. 

  32787.   if ((i9 | 0) != 0) {
    32788. 

  32788.    i8 = 0;
    32789. 

  32789.    while (1) {
    32790. 

  32790.     i7 = i8 + 1 | 0;
    32791. 

  32791.     if ((_strcmp(i9, i6) | 0) == 0) {
    32792. 

  32792.      break;
    32793. 

  32793.     }
    32794. 

  32794.     i9 = HEAP32[i4 + (i7 << 2) >> 2] | 0;
    32795. 

  32795.     if ((i9 | 0) == 0) {
    32796. 

  32796.      break L6;
    32797. 

  32797.     } else {
    32798. 

  32798.      i8 = i7;
    32799. 

  32799.     }
    32800. 

  32800.    }
    32801. 

  32801.    STACKTOP = i1;
    32802. 

  32802.    return i8 | 0;
    32803. 

  32803.   }
    32804. 

  32804.  } while (0);
    32805. 

  32805.  HEAP32[i5 >> 2] = i6;
    32806. 

  32806.  i9 = _luaL_argerror(i2, i3, _lua_pushfstring(i2, 1192, i5) | 0) | 0;
    32807. 

  32807.  STACKTOP = i1;
    32808. 

  32808.  return i9 | 0;
    32809. 

  32809. }
    32810. 

  32810. function _lua_toboolean(i3, i5) {
    32811. 

  32811.  i3 = i3 | 0;
    32812. 

  32812.  i5 = i5 | 0;
    32813. 

  32813.  var i1 = 0, i2 = 0, i4 = 0;
    32814. 

  32814.  i1 = STACKTOP;
    32815. 

  32815.  i4 = HEAP32[i3 + 16 >> 2] | 0;
    32816. 

  32816.  do {
    32817. 

  32817.   if ((i5 | 0) <= 0) {
    32818. 

  32818.    if (!((i5 | 0) < -1000999)) {
    32819. 

  32819.     i3 = (HEAP32[i3 + 8 >> 2] | 0) + (i5 << 4) | 0;
    32820. 

  32820.     break;
    32821. 

  32821.    }
    32822. 

  32822.    if ((i5 | 0) == -1001e3) {
    32823. 

  32823.     i3 = (HEAP32[i3 + 12 >> 2] | 0) + 40 | 0;
    32824. 

  32824.     break;
    32825. 

  32825.    }
    32826. 

  32826.    i3 = -1001e3 - i5 | 0;
    32827. 

  32827.    i4 = HEAP32[i4 >> 2] | 0;
    32828. 

  32828.    if ((HEAP32[i4 + 8 >> 2] | 0) != 22 ? (i2 = HEAP32[i4 >> 2] | 0, (i3 | 0) <= (HEAPU8[i2 + 6 | 0] | 0 | 0)) : 0) {
    32829. 

  32829.     i3 = i2 + (i3 + -1 << 4) + 16 | 0;
    32830. 

  32830.    } else {
    32831. 

  32831.     i3 = 5192;
    32832. 

  32832.    }
    32833. 

  32833.   } else {
    32834. 

  32834.    i2 = (HEAP32[i4 >> 2] | 0) + (i5 << 4) | 0;
    32835. 

  32835.    i3 = i2 >>> 0 < (HEAP32[i3 + 8 >> 2] | 0) >>> 0 ? i2 : 5192;
    32836. 

  32836.   }
    32837. 

  32837.  } while (0);
    32838. 

  32838.  i2 = HEAP32[i3 + 8 >> 2] | 0;
    32839. 

  32839.  if ((i2 | 0) == 0) {
    32840. 

  32840.   i5 = 0;
    32841. 

  32841.   i5 = i5 & 1;
    32842. 

  32842.   STACKTOP = i1;
    32843. 

  32843.   return i5 | 0;
    32844. 

  32844.  }
    32845. 

  32845.  if ((i2 | 0) != 1) {
    32846. 

  32846.   i5 = 1;
    32847. 

  32847.   i5 = i5 & 1;
    32848. 

  32848.   STACKTOP = i1;
    32849. 

  32849.   return i5 | 0;
    32850. 

  32850.  }
    32851. 

  32851.  i5 = (HEAP32[i3 >> 2] | 0) != 0;
    32852. 

  32852.  i5 = i5 & 1;
    32853. 

  32853.  STACKTOP = i1;
    32854. 

  32854.  return i5 | 0;
    32855. 

  32855. }
    32856. 

  32856. function _lua_getfield(i1, i6, i3) {
    32857. 

  32857.  i1 = i1 | 0;
    32858. 

  32858.  i6 = i6 | 0;
    32859. 

  32859.  i3 = i3 | 0;
    32860. 

  32860.  var i2 = 0, i4 = 0, i5 = 0;
    32861. 

  32861.  i2 = STACKTOP;
    32862. 

  32862.  i5 = HEAP32[i1 + 16 >> 2] | 0;
    32863. 

  32863.  do {
    32864. 

  32864.   if ((i6 | 0) <= 0) {
    32865. 

  32865.    if (!((i6 | 0) < -1000999)) {
    32866. 

  32866.     i4 = (HEAP32[i1 + 8 >> 2] | 0) + (i6 << 4) | 0;
    32867. 

  32867.     break;
    32868. 

  32868.    }
    32869. 

  32869.    if ((i6 | 0) == -1001e3) {
    32870. 

  32870.     i4 = (HEAP32[i1 + 12 >> 2] | 0) + 40 | 0;
    32871. 

  32871.     break;
    32872. 

  32872.    }
    32873. 

  32873.    i6 = -1001e3 - i6 | 0;
    32874. 

  32874.    i5 = HEAP32[i5 >> 2] | 0;
    32875. 

  32875.    if ((HEAP32[i5 + 8 >> 2] | 0) != 22 ? (i4 = HEAP32[i5 >> 2] | 0, (i6 | 0) <= (HEAPU8[i4 + 6 | 0] | 0 | 0)) : 0) {
    32876. 

  32876.     i4 = i4 + (i6 + -1 << 4) + 16 | 0;
    32877. 

  32877.    } else {
    32878. 

  32878.     i4 = 5192;
    32879. 

  32879.    }
    32880. 

  32880.   } else {
    32881. 

  32881.    i4 = (HEAP32[i5 >> 2] | 0) + (i6 << 4) | 0;
    32882. 

  32882.    i4 = i4 >>> 0 < (HEAP32[i1 + 8 >> 2] | 0) >>> 0 ? i4 : 5192;
    32883. 

  32883.   }
    32884. 

  32884.  } while (0);
    32885. 

  32885.  i5 = i1 + 8 | 0;
    32886. 

  32886.  i6 = HEAP32[i5 >> 2] | 0;
    32887. 

  32887.  i3 = _luaS_new(i1, i3) | 0;
    32888. 

  32888.  HEAP32[i6 >> 2] = i3;
    32889. 

  32889.  HEAP32[i6 + 8 >> 2] = HEAPU8[i3 + 4 | 0] | 0 | 64;
    32890. 

  32890.  i6 = HEAP32[i5 >> 2] | 0;
    32891. 

  32891.  HEAP32[i5 >> 2] = i6 + 16;
    32892. 

  32892.  _luaV_gettable(i1, i4, i6, i6);
    32893. 

  32893.  STACKTOP = i2;
    32894. 

  32894.  return;
    32895. 

  32895. }
    32896. 

  32896. function _luaL_argerror(i1, i6, i3) {
    32897. 

  32897.  i1 = i1 | 0;
    32898. 

  32898.  i6 = i6 | 0;
    32899. 

  32899.  i3 = i3 | 0;
    32900. 

  32900.  var i2 = 0, i4 = 0, i5 = 0, i7 = 0, i8 = 0;
    32901. 

  32901.  i4 = STACKTOP;
    32902. 

  32902.  STACKTOP = STACKTOP + 112 | 0;
    32903. 

  32903.  i2 = i4;
    32904. 

  32904.  i5 = i4 + 12 | 0;
    32905. 

  32905.  if ((_lua_getstack(i1, 0, i5) | 0) == 0) {
    32906. 

  32906.   HEAP32[i2 >> 2] = i6;
    32907. 

  32907.   HEAP32[i2 + 4 >> 2] = i3;
    32908. 

  32908.   i8 = _luaL_error(i1, 1040, i2) | 0;
    32909. 

  32909.   STACKTOP = i4;
    32910. 

  32910.   return i8 | 0;
    32911. 

  32911.  }
    32912. 

  32912.  _lua_getinfo(i1, 1064, i5) | 0;
    32913. 

  32913.  if ((_strcmp(HEAP32[i5 + 8 >> 2] | 0, 1072) | 0) == 0) {
    32914. 

  32914.   i6 = i6 + -1 | 0;
    32915. 

  32915.   if ((i6 | 0) == 0) {
    32916. 

  32916.    HEAP32[i2 >> 2] = HEAP32[i5 + 4 >> 2];
    32917. 

  32917.    HEAP32[i2 + 4 >> 2] = i3;
    32918. 

  32918.    i8 = _luaL_error(i1, 1080, i2) | 0;
    32919. 

  32919.    STACKTOP = i4;
    32920. 

  32920.    return i8 | 0;
    32921. 

  32921.   }
    32922. 

  32922.  }
    32923. 

  32923.  i7 = i5 + 4 | 0;
    32924. 

  32924.  i8 = HEAP32[i7 >> 2] | 0;
    32925. 

  32925.  if ((i8 | 0) == 0) {
    32926. 

  32926.   if ((_pushglobalfuncname(i1, i5) | 0) == 0) {
    32927. 

  32927.    i8 = 1112;
    32928. 

  32928.   } else {
    32929. 

  32929.    i8 = _lua_tolstring(i1, -1, 0) | 0;
    32930. 

  32930.   }
    32931. 

  32931.   HEAP32[i7 >> 2] = i8;
    32932. 

  32932.  }
    32933. 

  32933.  HEAP32[i2 >> 2] = i6;
    32934. 

  32934.  HEAP32[i2 + 4 >> 2] = i8;
    32935. 

  32935.  HEAP32[i2 + 8 >> 2] = i3;
    32936. 

  32936.  i8 = _luaL_error(i1, 1120, i2) | 0;
    32937. 

  32937.  STACKTOP = i4;
    32938. 

  32938.  return i8 | 0;
    32939. 

  32939. }
    32940. 

  32940. function _match_class(i3, i2) {
    32941. 

  32941.  i3 = i3 | 0;
    32942. 

  32942.  i2 = i2 | 0;
    32943. 

  32943.  var i1 = 0;
    32944. 

  32944.  i1 = STACKTOP;
    32945. 

  32945.  switch (_tolower(i2 | 0) | 0) {
    32946. 

  32946.  case 117:
    32947. 

  32947.   {
    32948. 

  32948.    i3 = _isupper(i3 | 0) | 0;
    32949. 

  32949.    break;
    32950. 

  32950.   }
    32951. 

  32951.  case 97:
    32952. 

  32952.   {
    32953. 

  32953.    i3 = _isalpha(i3 | 0) | 0;
    32954. 

  32954.    break;
    32955. 

  32955.   }
    32956. 

  32956.  case 99:
    32957. 

  32957.   {
    32958. 

  32958.    i3 = _iscntrl(i3 | 0) | 0;
    32959. 

  32959.    break;
    32960. 

  32960.   }
    32961. 

  32961.  case 120:
    32962. 

  32962.   {
    32963. 

  32963.    i3 = _isxdigit(i3 | 0) | 0;
    32964. 

  32964.    break;
    32965. 

  32965.   }
    32966. 

  32966.  case 119:
    32967. 

  32967.   {
    32968. 

  32968.    i3 = _isalnum(i3 | 0) | 0;
    32969. 

  32969.    break;
    32970. 

  32970.   }
    32971. 

  32971.  case 112:
    32972. 

  32972.   {
    32973. 

  32973.    i3 = _ispunct(i3 | 0) | 0;
    32974. 

  32974.    break;
    32975. 

  32975.   }
    32976. 

  32976.  case 100:
    32977. 

  32977.   {
    32978. 

  32978.    i3 = (i3 + -48 | 0) >>> 0 < 10 | 0;
    32979. 

  32979.    break;
    32980. 

  32980.   }
    32981. 

  32981.  case 108:
    32982. 

  32982.   {
    32983. 

  32983.    i3 = _islower(i3 | 0) | 0;
    32984. 

  32984.    break;
    32985. 

  32985.   }
    32986. 

  32986.  case 122:
    32987. 

  32987.   {
    32988. 

  32988.    i3 = (i3 | 0) == 0 | 0;
    32989. 

  32989.    break;
    32990. 

  32990.   }
    32991. 

  32991.  case 103:
    32992. 

  32992.   {
    32993. 

  32993.    i3 = _isgraph(i3 | 0) | 0;
    32994. 

  32994.    break;
    32995. 

  32995.   }
    32996. 

  32996.  case 115:
    32997. 

  32997.   {
    32998. 

  32998.    i3 = _isspace(i3 | 0) | 0;
    32999. 

  32999.    break;
    33000. 

  33000.   }
    33001. 

  33001.  default:
    33002. 

  33002.   {
    33003. 

  33003.    i3 = (i2 | 0) == (i3 | 0) | 0;
    33004. 

  33004.    STACKTOP = i1;
    33005. 

  33005.    return i3 | 0;
    33006. 

  33006.   }
    33007. 

  33007.  }
    33008. 

  33008.  if ((_islower(i2 | 0) | 0) != 0) {
    33009. 

  33009.   STACKTOP = i1;
    33010. 

  33010.   return i3 | 0;
    33011. 

  33011.  }
    33012. 

  33012.  i3 = (i3 | 0) == 0 | 0;
    33013. 

  33013.  STACKTOP = i1;
    33014. 

  33014.  return i3 | 0;
    33015. 

  33015. }
    33016. 

  33016. function _condjump(i1, i3, i6, i4, i5) {
    33017. 

  33017.  i1 = i1 | 0;
    33018. 

  33018.  i3 = i3 | 0;
    33019. 

  33019.  i6 = i6 | 0;
    33020. 

  33020.  i4 = i4 | 0;
    33021. 

  33021.  i5 = i5 | 0;
    33022. 

  33022.  var i2 = 0, i7 = 0, i8 = 0, i9 = 0;
    33023. 

  33023.  i2 = STACKTOP;
    33024. 

  33024.  _luaK_code(i1, i6 << 6 | i3 | i4 << 23 | i5 << 14) | 0;
    33025. 

  33025.  i3 = i1 + 28 | 0;
    33026. 

  33026.  i6 = HEAP32[i3 >> 2] | 0;
    33027. 

  33027.  HEAP32[i3 >> 2] = -1;
    33028. 

  33028.  i3 = _luaK_code(i1, 2147450903) | 0;
    33029. 

  33029.  if ((i6 | 0) == -1) {
    33030. 

  33030.   i9 = i3;
    33031. 

  33031.   STACKTOP = i2;
    33032. 

  33032.   return i9 | 0;
    33033. 

  33033.  }
    33034. 

  33034.  if ((i3 | 0) == -1) {
    33035. 

  33035.   i9 = i6;
    33036. 

  33036.   STACKTOP = i2;
    33037. 

  33037.   return i9 | 0;
    33038. 

  33038.  }
    33039. 

  33039.  i8 = HEAP32[(HEAP32[i1 >> 2] | 0) + 12 >> 2] | 0;
    33040. 

  33040.  i7 = i3;
    33041. 

  33041.  while (1) {
    33042. 

  33042.   i4 = i8 + (i7 << 2) | 0;
    33043. 

  33043.   i5 = HEAP32[i4 >> 2] | 0;
    33044. 

  33044.   i9 = (i5 >>> 14) + -131071 | 0;
    33045. 

  33045.   if ((i9 | 0) == -1) {
    33046. 

  33046.    break;
    33047. 

  33047.   }
    33048. 

  33048.   i9 = i7 + 1 + i9 | 0;
    33049. 

  33049.   if ((i9 | 0) == -1) {
    33050. 

  33050.    break;
    33051. 

  33051.   } else {
    33052. 

  33052.    i7 = i9;
    33053. 

  33053.   }
    33054. 

  33054.  }
    33055. 

  33055.  i6 = i6 + ~i7 | 0;
    33056. 

  33056.  if ((((i6 | 0) > -1 ? i6 : 0 - i6 | 0) | 0) > 131071) {
    33057. 

  33057.   _luaX_syntaxerror(HEAP32[i1 + 12 >> 2] | 0, 10624);
    33058. 

  33058.  }
    33059. 

  33059.  HEAP32[i4 >> 2] = (i6 << 14) + 2147467264 | i5 & 16383;
    33060. 

  33060.  i9 = i3;
    33061. 

  33061.  STACKTOP = i2;
    33062. 

  33062.  return i9 | 0;
    33063. 

  33063. }
    33064. 

  33064. function _skipcomment(i6, i1) {
    33065. 

  33065.  i6 = i6 | 0;
    33066. 

  33066.  i1 = i1 | 0;
    33067. 

  33067.  var i2 = 0, i3 = 0, i4 = 0, i5 = 0, i7 = 0, i8 = 0;
    33068. 

  33068.  i2 = STACKTOP;
    33069. 

  33069.  HEAP32[i6 >> 2] = 0;
    33070. 

  33070.  i3 = i6 + 4 | 0;
    33071. 

  33071.  i5 = 1712;
    33072. 

  33072.  while (1) {
    33073. 

  33073.   i7 = _fgetc(HEAP32[i3 >> 2] | 0) | 0;
    33074. 

  33074.   if ((i7 | 0) == -1) {
    33075. 

  33075.    i4 = 3;
    33076. 

  33076.    break;
    33077. 

  33077.   }
    33078. 

  33078.   i8 = i5 + 1 | 0;
    33079. 

  33079.   if ((i7 | 0) != (HEAPU8[i5] | 0)) {
    33080. 

  33080.    break;
    33081. 

  33081.   }
    33082. 

  33082.   i5 = HEAP32[i6 >> 2] | 0;
    33083. 

  33083.   HEAP32[i6 >> 2] = i5 + 1;
    33084. 

  33084.   HEAP8[i6 + i5 + 8 | 0] = i7;
    33085. 

  33085.   if ((HEAP8[i8] | 0) == 0) {
    33086. 

  33086.    i4 = 6;
    33087. 

  33087.    break;
    33088. 

  33088.   } else {
    33089. 

  33089.    i5 = i8;
    33090. 

  33090.   }
    33091. 

  33091.  }
    33092. 

  33092.  if ((i4 | 0) == 3) {
    33093. 

  33093.   HEAP32[i1 >> 2] = -1;
    33094. 

  33094.   i8 = 0;
    33095. 

  33095.   STACKTOP = i2;
    33096. 

  33096.   return i8 | 0;
    33097. 

  33097.  } else if ((i4 | 0) == 6) {
    33098. 

  33098.   HEAP32[i6 >> 2] = 0;
    33099. 

  33099.   i7 = _fgetc(HEAP32[i3 >> 2] | 0) | 0;
    33100. 

  33100.  }
    33101. 

  33101.  HEAP32[i1 >> 2] = i7;
    33102. 

  33102.  if ((i7 | 0) != 35) {
    33103. 

  33103.   i8 = 0;
    33104. 

  33104.   STACKTOP = i2;
    33105. 

  33105.   return i8 | 0;
    33106. 

  33106.  }
    33107. 

  33107.  do {
    33108. 

  33108.   i8 = _fgetc(HEAP32[i3 >> 2] | 0) | 0;
    33109. 

  33109.  } while (!((i8 | 0) == 10 | (i8 | 0) == -1));
    33110. 

  33110.  HEAP32[i1 >> 2] = _fgetc(HEAP32[i3 >> 2] | 0) | 0;
    33111. 

  33111.  i8 = 1;
    33112. 

  33112.  STACKTOP = i2;
    33113. 

  33113.  return i8 | 0;
    33114. 

  33114. }
    33115. 

  33115. function _lua_isnumber(i4, i6) {
    33116. 

  33116.  i4 = i4 | 0;
    33117. 

  33117.  i6 = i6 | 0;
    33118. 

  33118.  var i1 = 0, i2 = 0, i3 = 0, i5 = 0;
    33119. 

  33119.  i1 = STACKTOP;
    33120. 

  33120.  STACKTOP = STACKTOP + 16 | 0;
    33121. 

  33121.  i2 = i1;
    33122. 

  33122.  i5 = HEAP32[i4 + 16 >> 2] | 0;
    33123. 

  33123.  do {
    33124. 

  33124.   if ((i6 | 0) <= 0) {
    33125. 

  33125.    if (!((i6 | 0) < -1000999)) {
    33126. 

  33126.     i3 = (HEAP32[i4 + 8 >> 2] | 0) + (i6 << 4) | 0;
    33127. 

  33127.     break;
    33128. 

  33128.    }
    33129. 

  33129.    if ((i6 | 0) == -1001e3) {
    33130. 

  33130.     i3 = (HEAP32[i4 + 12 >> 2] | 0) + 40 | 0;
    33131. 

  33131.     break;
    33132. 

  33132.    }
    33133. 

  33133.    i4 = -1001e3 - i6 | 0;
    33134. 

  33134.    i5 = HEAP32[i5 >> 2] | 0;
    33135. 

  33135.    if ((HEAP32[i5 + 8 >> 2] | 0) != 22 ? (i3 = HEAP32[i5 >> 2] | 0, (i4 | 0) <= (HEAPU8[i3 + 6 | 0] | 0 | 0)) : 0) {
    33136. 

  33136.     i3 = i3 + (i4 + -1 << 4) + 16 | 0;
    33137. 

  33137.    } else {
    33138. 

  33138.     i3 = 5192;
    33139. 

  33139.    }
    33140. 

  33140.   } else {
    33141. 

  33141.    i3 = (HEAP32[i5 >> 2] | 0) + (i6 << 4) | 0;
    33142. 

  33142.    i3 = i3 >>> 0 < (HEAP32[i4 + 8 >> 2] | 0) >>> 0 ? i3 : 5192;
    33143. 

  33143.   }
    33144. 

  33144.  } while (0);
    33145. 

  33145.  if ((HEAP32[i3 + 8 >> 2] | 0) == 3) {
    33146. 

  33146.   i6 = 1;
    33147. 

  33147.   i6 = i6 & 1;
    33148. 

  33148.   STACKTOP = i1;
    33149. 

  33149.   return i6 | 0;
    33150. 

  33150.  }
    33151. 

  33151.  i6 = (_luaV_tonumber(i3, i2) | 0) != 0;
    33152. 

  33152.  i6 = i6 & 1;
    33153. 

  33153.  STACKTOP = i1;
    33154. 

  33154.  return i6 | 0;
    33155. 

  33155. }
    33156. 

  33156. function ___shgetc(i3) {
    33157. 

  33157.  i3 = i3 | 0;
    33158. 

  33158.  var i1 = 0, i2 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0;
    33159. 

  33159.  i2 = STACKTOP;
    33160. 

  33160.  i7 = i3 + 104 | 0;
    33161. 

  33161.  i6 = HEAP32[i7 >> 2] | 0;
    33162. 

  33162.  if (!((i6 | 0) != 0 ? (HEAP32[i3 + 108 >> 2] | 0) >= (i6 | 0) : 0)) {
    33163. 

  33163.   i8 = 3;
    33164. 

  33164.  }
    33165. 

  33165.  if ((i8 | 0) == 3 ? (i1 = ___uflow(i3) | 0, (i1 | 0) >= 0) : 0) {
    33166. 

  33166.   i7 = HEAP32[i7 >> 2] | 0;
    33167. 

  33167.   i6 = HEAP32[i3 + 8 >> 2] | 0;
    33168. 

  33168.   if ((i7 | 0) != 0 ? (i4 = HEAP32[i3 + 4 >> 2] | 0, i5 = i7 - (HEAP32[i3 + 108 >> 2] | 0) + -1 | 0, (i6 - i4 | 0) > (i5 | 0)) : 0) {
    33169. 

  33169.    HEAP32[i3 + 100 >> 2] = i4 + i5;
    33170. 

  33170.   } else {
    33171. 

  33171.    HEAP32[i3 + 100 >> 2] = i6;
    33172. 

  33172.   }
    33173. 

  33173.   i4 = HEAP32[i3 + 4 >> 2] | 0;
    33174. 

  33174.   if ((i6 | 0) != 0) {
    33175. 

  33175.    i8 = i3 + 108 | 0;
    33176. 

  33176.    HEAP32[i8 >> 2] = i6 + 1 - i4 + (HEAP32[i8 >> 2] | 0);
    33177. 

  33177.   }
    33178. 

  33178.   i3 = i4 + -1 | 0;
    33179. 

  33179.   if ((HEAPU8[i3] | 0 | 0) == (i1 | 0)) {
    33180. 

  33180.    i8 = i1;
    33181. 

  33181.    STACKTOP = i2;
    33182. 

  33182.    return i8 | 0;
    33183. 

  33183.   }
    33184. 

  33184.   HEAP8[i3] = i1;
    33185. 

  33185.   i8 = i1;
    33186. 

  33186.   STACKTOP = i2;
    33187. 

  33187.   return i8 | 0;
    33188. 

  33188.  }
    33189. 

  33189.  HEAP32[i3 + 100 >> 2] = 0;
    33190. 

  33190.  i8 = -1;
    33191. 

  33191.  STACKTOP = i2;
    33192. 

  33192.  return i8 | 0;
    33193. 

  33193. }
    33194. 

  33194. function _lua_type(i2, i4) {
    33195. 

  33195.  i2 = i2 | 0;
    33196. 

  33196.  i4 = i4 | 0;
    33197. 

  33197.  var i1 = 0, i3 = 0;
    33198. 

  33198.  i1 = STACKTOP;
    33199. 

  33199.  i3 = HEAP32[i2 + 16 >> 2] | 0;
    33200. 

  33200.  do {
    33201. 

  33201.   if ((i4 | 0) <= 0) {
    33202. 

  33202.    if (!((i4 | 0) < -1000999)) {
    33203. 

  33203.     i2 = (HEAP32[i2 + 8 >> 2] | 0) + (i4 << 4) | 0;
    33204. 

  33204.     break;
    33205. 

  33205.    }
    33206. 

  33206.    if ((i4 | 0) == -1001e3) {
    33207. 

  33207.     i2 = (HEAP32[i2 + 12 >> 2] | 0) + 40 | 0;
    33208. 

  33208.     break;
    33209. 

  33209.    }
    33210. 

  33210.    i2 = -1001e3 - i4 | 0;
    33211. 

  33211.    i3 = HEAP32[i3 >> 2] | 0;
    33212. 

  33212.    if ((HEAP32[i3 + 8 >> 2] | 0) == 22) {
    33213. 

  33213.     i4 = -1;
    33214. 

  33214.     STACKTOP = i1;
    33215. 

  33215.     return i4 | 0;
    33216. 

  33216.    }
    33217. 

  33217.    i3 = HEAP32[i3 >> 2] | 0;
    33218. 

  33218.    if ((i2 | 0) > (HEAPU8[i3 + 6 | 0] | 0 | 0)) {
    33219. 

  33219.     i4 = -1;
    33220. 

  33220.     STACKTOP = i1;
    33221. 

  33221.     return i4 | 0;
    33222. 

  33222.    } else {
    33223. 

  33223.     i2 = i3 + (i2 + -1 << 4) + 16 | 0;
    33224. 

  33224.     break;
    33225. 

  33225.    }
    33226. 

  33226.   } else {
    33227. 

  33227.    i3 = (HEAP32[i3 >> 2] | 0) + (i4 << 4) | 0;
    33228. 

  33228.    i2 = i3 >>> 0 < (HEAP32[i2 + 8 >> 2] | 0) >>> 0 ? i3 : 5192;
    33229. 

  33229.   }
    33230. 

  33230.  } while (0);
    33231. 

  33231.  if ((i2 | 0) == 5192) {
    33232. 

  33232.   i4 = -1;
    33233. 

  33233.   STACKTOP = i1;
    33234. 

  33234.   return i4 | 0;
    33235. 

  33235.  }
    33236. 

  33236.  i4 = HEAP32[i2 + 8 >> 2] & 15;
    33237. 

  33237.  STACKTOP = i1;
    33238. 

  33238.  return i4 | 0;
    33239. 

  33239. }
    33240. 

  33240. function _g_iofile(i4, i1, i5) {
    33241. 

  33241.  i4 = i4 | 0;
    33242. 

  33242.  i1 = i1 | 0;
    33243. 

  33243.  i5 = i5 | 0;
    33244. 

  33244.  var i2 = 0, i3 = 0, i6 = 0, i7 = 0, i8 = 0;
    33245. 

  33245.  i2 = STACKTOP;
    33246. 

  33246.  STACKTOP = STACKTOP + 16 | 0;
    33247. 

  33247.  i3 = i2;
    33248. 

  33248.  if ((_lua_type(i4, 1) | 0) < 1) {
    33249. 

  33249.   _lua_getfield(i4, -1001e3, i1);
    33250. 

  33250.   STACKTOP = i2;
    33251. 

  33251.   return;
    33252. 

  33252.  }
    33253. 

  33253.  i6 = _lua_tolstring(i4, 1, 0) | 0;
    33254. 

  33254.  if ((i6 | 0) != 0) {
    33255. 

  33255.   i7 = _lua_newuserdata(i4, 8) | 0;
    33256. 

  33256.   i8 = i7 + 4 | 0;
    33257. 

  33257.   HEAP32[i8 >> 2] = 0;
    33258. 

  33258.   _luaL_setmetatable(i4, 2832);
    33259. 

  33259.   HEAP32[i7 >> 2] = 0;
    33260. 

  33260.   HEAP32[i8 >> 2] = 156;
    33261. 

  33261.   i5 = _fopen(i6 | 0, i5 | 0) | 0;
    33262. 

  33262.   HEAP32[i7 >> 2] = i5;
    33263. 

  33263.   if ((i5 | 0) == 0) {
    33264. 

  33264.    i8 = _strerror(HEAP32[(___errno_location() | 0) >> 2] | 0) | 0;
    33265. 

  33265.    HEAP32[i3 >> 2] = i6;
    33266. 

  33266.    HEAP32[i3 + 4 >> 2] = i8;
    33267. 

  33267.    _luaL_error(i4, 3520, i3) | 0;
    33268. 

  33268.   }
    33269. 

  33269.  } else {
    33270. 

  33270.   if ((HEAP32[(_luaL_checkudata(i4, 1, 2832) | 0) + 4 >> 2] | 0) == 0) {
    33271. 

  33271.    _luaL_error(i4, 3080, i3) | 0;
    33272. 

  33272.   }
    33273. 

  33273.   _lua_pushvalue(i4, 1);
    33274. 

  33274.  }
    33275. 

  33275.  _lua_setfield(i4, -1001e3, i1);
    33276. 

  33276.  _lua_getfield(i4, -1001e3, i1);
    33277. 

  33277.  STACKTOP = i2;
    33278. 

  33278.  return;
    33279. 

  33279. }
    33280. 

  33280. function _lua_getlocal(i4, i5, i2) {
    33281. 

  33281.  i4 = i4 | 0;
    33282. 

  33282.  i5 = i5 | 0;
    33283. 

  33283.  i2 = i2 | 0;
    33284. 

  33284.  var i1 = 0, i3 = 0, i6 = 0, i7 = 0, i8 = 0;
    33285. 

  33285.  i1 = STACKTOP;
    33286. 

  33286.  STACKTOP = STACKTOP + 16 | 0;
    33287. 

  33287.  i3 = i1;
    33288. 

  33288.  if ((i5 | 0) == 0) {
    33289. 

  33289.   i3 = HEAP32[i4 + 8 >> 2] | 0;
    33290. 

  33290.   if ((HEAP32[i3 + -8 >> 2] | 0) != 70) {
    33291. 

  33291.    i5 = 0;
    33292. 

  33292.    STACKTOP = i1;
    33293. 

  33293.    return i5 | 0;
    33294. 

  33294.   }
    33295. 

  33295.   i5 = _luaF_getlocalname(HEAP32[(HEAP32[i3 + -16 >> 2] | 0) + 12 >> 2] | 0, i2, 0) | 0;
    33296. 

  33296.   STACKTOP = i1;
    33297. 

  33297.   return i5 | 0;
    33298. 

  33298.  } else {
    33299. 

  33299.   HEAP32[i3 >> 2] = 0;
    33300. 

  33300.   i2 = _findlocal(i4, HEAP32[i5 + 96 >> 2] | 0, i2, i3) | 0;
    33301. 

  33301.   if ((i2 | 0) == 0) {
    33302. 

  33302.    i5 = 0;
    33303. 

  33303.    STACKTOP = i1;
    33304. 

  33304.    return i5 | 0;
    33305. 

  33305.   }
    33306. 

  33306.   i3 = HEAP32[i3 >> 2] | 0;
    33307. 

  33307.   i5 = i4 + 8 | 0;
    33308. 

  33308.   i4 = HEAP32[i5 >> 2] | 0;
    33309. 

  33309.   i8 = i3;
    33310. 

  33310.   i7 = HEAP32[i8 + 4 >> 2] | 0;
    33311. 

  33311.   i6 = i4;
    33312. 

  33312.   HEAP32[i6 >> 2] = HEAP32[i8 >> 2];
    33313. 

  33313.   HEAP32[i6 + 4 >> 2] = i7;
    33314. 

  33314.   HEAP32[i4 + 8 >> 2] = HEAP32[i3 + 8 >> 2];
    33315. 

  33315.   HEAP32[i5 >> 2] = (HEAP32[i5 >> 2] | 0) + 16;
    33316. 

  33316.   i5 = i2;
    33317. 

  33317.   STACKTOP = i1;
    33318. 

  33318.   return i5 | 0;
    33319. 

  33319.  }
    33320. 

  33320.  return 0;
    33321. 

  33321. }
    33322. 

  33322. function _lua_checkstack(i7, i4) {
    33323. 

  33323.  i7 = i7 | 0;
    33324. 

  33324.  i4 = i4 | 0;
    33325. 

  33325.  var i1 = 0, i2 = 0, i3 = 0, i5 = 0, i6 = 0, i8 = 0;
    33326. 

  33326.  i1 = STACKTOP;
    33327. 

  33327.  STACKTOP = STACKTOP + 16 | 0;
    33328. 

  33328.  i3 = i1;
    33329. 

  33329.  HEAP32[i3 >> 2] = i4;
    33330. 

  33330.  i2 = HEAP32[i7 + 16 >> 2] | 0;
    33331. 

  33331.  i5 = i7 + 8 | 0;
    33332. 

  33332.  i6 = HEAP32[i5 >> 2] | 0;
    33333. 

  33333.  i8 = i6;
    33334. 

  33334.  do {
    33335. 

  33335.   if (((HEAP32[i7 + 24 >> 2] | 0) - i8 >> 4 | 0) <= (i4 | 0)) {
    33336. 

  33336.    if (((i8 - (HEAP32[i7 + 28 >> 2] | 0) >> 4) + 5 | 0) > (1e6 - i4 | 0)) {
    33337. 

  33337.     i8 = 0;
    33338. 

  33338.     STACKTOP = i1;
    33339. 

  33339.     return i8 | 0;
    33340. 

  33340.    }
    33341. 

  33341.    i6 = (_luaD_rawrunprotected(i7, 2, i3) | 0) == 0;
    33342. 

  33342.    if (i6) {
    33343. 

  33343.     i5 = HEAP32[i5 >> 2] | 0;
    33344. 

  33344.     i4 = HEAP32[i3 >> 2] | 0;
    33345. 

  33345.     i3 = i6 & 1;
    33346. 

  33346.     break;
    33347. 

  33347.    } else {
    33348. 

  33348.     i8 = 0;
    33349. 

  33349.     STACKTOP = i1;
    33350. 

  33350.     return i8 | 0;
    33351. 

  33351.    }
    33352. 

  33352.   } else {
    33353. 

  33353.    i5 = i6;
    33354. 

  33354.    i3 = 1;
    33355. 

  33355.   }
    33356. 

  33356.  } while (0);
    33357. 

  33357.  i2 = i2 + 4 | 0;
    33358. 

  33358.  i4 = i5 + (i4 << 4) | 0;
    33359. 

  33359.  if (!((HEAP32[i2 >> 2] | 0) >>> 0 < i4 >>> 0)) {
    33360. 

  33360.   i8 = i3;
    33361. 

  33361.   STACKTOP = i1;
    33362. 

  33362.   return i8 | 0;
    33363. 

  33363.  }
    33364. 

  33364.  HEAP32[i2 >> 2] = i4;
    33365. 

  33365.  i8 = i3;
    33366. 

  33366.  STACKTOP = i1;
    33367. 

  33367.  return i8 | 0;
    33368. 

  33368. }
    33369. 

  33369. function _luaK_exp2nextreg(i1, i3) {
    33370. 

  33370.  i1 = i1 | 0;
    33371. 

  33371.  i3 = i3 | 0;
    33372. 

  33372.  var i2 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0;
    33373. 

  33373.  i2 = STACKTOP;
    33374. 

  33374.  _luaK_dischargevars(i1, i3);
    33375. 

  33375.  if (((HEAP32[i3 >> 2] | 0) == 6 ? (i4 = HEAP32[i3 + 8 >> 2] | 0, (i4 & 256 | 0) == 0) : 0) ? (HEAPU8[i1 + 46 | 0] | 0 | 0) <= (i4 | 0) : 0) {
    33376. 

  33376.   i7 = i1 + 48 | 0;
    33377. 

  33377.   HEAP8[i7] = (HEAP8[i7] | 0) + -1 << 24 >> 24;
    33378. 

  33378.  }
    33379. 

  33379.  i4 = i1 + 48 | 0;
    33380. 

  33380.  i5 = HEAP8[i4] | 0;
    33381. 

  33381.  i6 = (i5 & 255) + 1 | 0;
    33382. 

  33382.  i7 = (HEAP32[i1 >> 2] | 0) + 78 | 0;
    33383. 

  33383.  if (!(i6 >>> 0 > (HEAPU8[i7] | 0) >>> 0)) {
    33384. 

  33384.   i7 = i5;
    33385. 

  33385.   i7 = i7 & 255;
    33386. 

  33386.   i7 = i7 + 1 | 0;
    33387. 

  33387.   i6 = i7 & 255;
    33388. 

  33388.   HEAP8[i4] = i6;
    33389. 

  33389.   i7 = i7 & 255;
    33390. 

  33390.   i7 = i7 + -1 | 0;
    33391. 

  33391.   _exp2reg(i1, i3, i7);
    33392. 

  33392.   STACKTOP = i2;
    33393. 

  33393.   return;
    33394. 

  33394.  }
    33395. 

  33395.  if (i6 >>> 0 > 249) {
    33396. 

  33396.   _luaX_syntaxerror(HEAP32[i1 + 12 >> 2] | 0, 10536);
    33397. 

  33397.  }
    33398. 

  33398.  HEAP8[i7] = i6;
    33399. 

  33399.  i7 = HEAP8[i4] | 0;
    33400. 

  33400.  i7 = i7 & 255;
    33401. 

  33401.  i7 = i7 + 1 | 0;
    33402. 

  33402.  i6 = i7 & 255;
    33403. 

  33403.  HEAP8[i4] = i6;
    33404. 

  33404.  i7 = i7 & 255;
    33405. 

  33405.  i7 = i7 + -1 | 0;
    33406. 

  33406.  _exp2reg(i1, i3, i7);
    33407. 

  33407.  STACKTOP = i2;
    33408. 

  33408.  return;
    33409. 

  33409. }
    33410. 

  33410. function _lua_next(i2, i4) {
    33411. 

  33411.  i2 = i2 | 0;
    33412. 

  33412.  i4 = i4 | 0;
    33413. 

  33413.  var i1 = 0, i3 = 0, i5 = 0;
    33414. 

  33414.  i1 = STACKTOP;
    33415. 

  33415.  i5 = HEAP32[i2 + 16 >> 2] | 0;
    33416. 

  33416.  do {
    33417. 

  33417.   if ((i4 | 0) <= 0) {
    33418. 

  33418.    if (!((i4 | 0) < -1000999)) {
    33419. 

  33419.     i4 = (HEAP32[i2 + 8 >> 2] | 0) + (i4 << 4) | 0;
    33420. 

  33420.     break;
    33421. 

  33421.    }
    33422. 

  33422.    if ((i4 | 0) == -1001e3) {
    33423. 

  33423.     i4 = (HEAP32[i2 + 12 >> 2] | 0) + 40 | 0;
    33424. 

  33424.     break;
    33425. 

  33425.    }
    33426. 

  33426.    i4 = -1001e3 - i4 | 0;
    33427. 

  33427.    i5 = HEAP32[i5 >> 2] | 0;
    33428. 

  33428.    if ((HEAP32[i5 + 8 >> 2] | 0) != 22 ? (i3 = HEAP32[i5 >> 2] | 0, (i4 | 0) <= (HEAPU8[i3 + 6 | 0] | 0 | 0)) : 0) {
    33429. 

  33429.     i4 = i3 + (i4 + -1 << 4) + 16 | 0;
    33430. 

  33430.    } else {
    33431. 

  33431.     i4 = 5192;
    33432. 

  33432.    }
    33433. 

  33433.   } else {
    33434. 

  33434.    i3 = (HEAP32[i5 >> 2] | 0) + (i4 << 4) | 0;
    33435. 

  33435.    i4 = i3 >>> 0 < (HEAP32[i2 + 8 >> 2] | 0) >>> 0 ? i3 : 5192;
    33436. 

  33436.   }
    33437. 

  33437.  } while (0);
    33438. 

  33438.  i3 = i2 + 8 | 0;
    33439. 

  33439.  i2 = _luaH_next(i2, HEAP32[i4 >> 2] | 0, (HEAP32[i3 >> 2] | 0) + -16 | 0) | 0;
    33440. 

  33440.  i4 = HEAP32[i3 >> 2] | 0;
    33441. 

  33441.  HEAP32[i3 >> 2] = (i2 | 0) == 0 ? i4 + -16 | 0 : i4 + 16 | 0;
    33442. 

  33442.  STACKTOP = i1;
    33443. 

  33443.  return i2 | 0;
    33444. 

  33444. }
    33445. 

  33445. function _inclinenumber(i1) {
    33446. 

  33446.  i1 = i1 | 0;
    33447. 

  33447.  var i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0;
    33448. 

  33448.  i2 = STACKTOP;
    33449. 

  33449.  i4 = HEAP32[i1 >> 2] | 0;
    33450. 

  33450.  i3 = i1 + 56 | 0;
    33451. 

  33451.  i5 = HEAP32[i3 >> 2] | 0;
    33452. 

  33452.  i6 = HEAP32[i5 >> 2] | 0;
    33453. 

  33453.  HEAP32[i5 >> 2] = i6 + -1;
    33454. 

  33454.  if ((i6 | 0) == 0) {
    33455. 

  33455.   i5 = _luaZ_fill(i5) | 0;
    33456. 

  33456.  } else {
    33457. 

  33457.   i6 = i5 + 4 | 0;
    33458. 

  33458.   i5 = HEAP32[i6 >> 2] | 0;
    33459. 

  33459.   HEAP32[i6 >> 2] = i5 + 1;
    33460. 

  33460.   i5 = HEAPU8[i5] | 0;
    33461. 

  33461.  }
    33462. 

  33462.  HEAP32[i1 >> 2] = i5;
    33463. 

  33463.  if ((i5 | 0) == 13 | (i5 | 0) == 10 ? (i5 | 0) != (i4 | 0) : 0) {
    33464. 

  33464.   i3 = HEAP32[i3 >> 2] | 0;
    33465. 

  33465.   i6 = HEAP32[i3 >> 2] | 0;
    33466. 

  33466.   HEAP32[i3 >> 2] = i6 + -1;
    33467. 

  33467.   if ((i6 | 0) == 0) {
    33468. 

  33468.    i3 = _luaZ_fill(i3) | 0;
    33469. 

  33469.   } else {
    33470. 

  33470.    i6 = i3 + 4 | 0;
    33471. 

  33471.    i3 = HEAP32[i6 >> 2] | 0;
    33472. 

  33472.    HEAP32[i6 >> 2] = i3 + 1;
    33473. 

  33473.    i3 = HEAPU8[i3] | 0;
    33474. 

  33474.   }
    33475. 

  33475.   HEAP32[i1 >> 2] = i3;
    33476. 

  33476.  }
    33477. 

  33477.  i5 = i1 + 4 | 0;
    33478. 

  33478.  i6 = HEAP32[i5 >> 2] | 0;
    33479. 

  33479.  HEAP32[i5 >> 2] = i6 + 1;
    33480. 

  33480.  if ((i6 | 0) > 2147483643) {
    33481. 

  33481.   _luaX_syntaxerror(i1, 12560);
    33482. 

  33482.  } else {
    33483. 

  33483.   STACKTOP = i2;
    33484. 

  33484.   return;
    33485. 

  33485.  }
    33486. 

  33486. }
    33487. 

  33487. function _lua_yieldk(i5, i6, i1, i7) {
    33488. 

  33488.  i5 = i5 | 0;
    33489. 

  33489.  i6 = i6 | 0;
    33490. 

  33490.  i1 = i1 | 0;
    33491. 

  33491.  i7 = i7 | 0;
    33492. 

  33492.  var i2 = 0, i3 = 0, i4 = 0;
    33493. 

  33493.  i2 = STACKTOP;
    33494. 

  33494.  STACKTOP = STACKTOP + 16 | 0;
    33495. 

  33495.  i4 = i2;
    33496. 

  33496.  i3 = HEAP32[i5 + 16 >> 2] | 0;
    33497. 

  33497.  if ((HEAP16[i5 + 36 >> 1] | 0) != 0) {
    33498. 

  33498.   if ((HEAP32[(HEAP32[i5 + 12 >> 2] | 0) + 172 >> 2] | 0) == (i5 | 0)) {
    33499. 

  33499.    _luaG_runerror(i5, 2312, i4);
    33500. 

  33500.   } else {
    33501. 

  33501.    _luaG_runerror(i5, 2264, i4);
    33502. 

  33502.   }
    33503. 

  33503.  }
    33504. 

  33504.  HEAP8[i5 + 6 | 0] = 1;
    33505. 

  33505.  HEAP32[i3 + 20 >> 2] = (HEAP32[i3 >> 2] | 0) - (HEAP32[i5 + 28 >> 2] | 0);
    33506. 

  33506.  if (!((HEAP8[i3 + 18 | 0] & 1) == 0)) {
    33507. 

  33507.   STACKTOP = i2;
    33508. 

  33508.   return 0;
    33509. 

  33509.  }
    33510. 

  33510.  HEAP32[i3 + 28 >> 2] = i7;
    33511. 

  33511.  if ((i7 | 0) == 0) {
    33512. 

  33512.   i4 = i5 + 8 | 0;
    33513. 

  33513.   i4 = HEAP32[i4 >> 2] | 0;
    33514. 

  33514.   i7 = ~i6;
    33515. 

  33515.   i7 = i4 + (i7 << 4) | 0;
    33516. 

  33516.   HEAP32[i3 >> 2] = i7;
    33517. 

  33517.   _luaD_throw(i5, 1);
    33518. 

  33518.  }
    33519. 

  33519.  HEAP32[i3 + 24 >> 2] = i1;
    33520. 

  33520.  i4 = i5 + 8 | 0;
    33521. 

  33521.  i4 = HEAP32[i4 >> 2] | 0;
    33522. 

  33522.  i7 = ~i6;
    33523. 

  33523.  i7 = i4 + (i7 << 4) | 0;
    33524. 

  33524.  HEAP32[i3 >> 2] = i7;
    33525. 

  33525.  _luaD_throw(i5, 1);
    33526. 

  33526.  return 0;
    33527. 

  33527. }
    33528. 

  33528. function _luaH_getint(i4, i6) {
    33529. 

  33529.  i4 = i4 | 0;
    33530. 

  33530.  i6 = i6 | 0;
    33531. 

  33531.  var i1 = 0, i2 = 0, d3 = 0.0, i5 = 0, i7 = 0;
    33532. 

  33532.  i1 = STACKTOP;
    33533. 

  33533.  STACKTOP = STACKTOP + 16 | 0;
    33534. 

  33534.  i5 = i1;
    33535. 

  33535.  i7 = i6 + -1 | 0;
    33536. 

  33536.  if (i7 >>> 0 < (HEAP32[i4 + 28 >> 2] | 0) >>> 0) {
    33537. 

  33537.   i7 = (HEAP32[i4 + 12 >> 2] | 0) + (i7 << 4) | 0;
    33538. 

  33538.   STACKTOP = i1;
    33539. 

  33539.   return i7 | 0;
    33540. 

  33540.  }
    33541. 

  33541.  d3 = +(i6 | 0);
    33542. 

  33542.  HEAPF64[i5 >> 3] = d3 + 1.0;
    33543. 

  33543.  i5 = (HEAP32[i5 + 4 >> 2] | 0) + (HEAP32[i5 >> 2] | 0) | 0;
    33544. 

  33544.  if ((i5 | 0) < 0) {
    33545. 

  33545.   i6 = 0 - i5 | 0;
    33546. 

  33546.   i5 = (i5 | 0) == (i6 | 0) ? 0 : i6;
    33547. 

  33547.  }
    33548. 

  33548.  i4 = (HEAP32[i4 + 16 >> 2] | 0) + (((i5 | 0) % ((1 << (HEAPU8[i4 + 7 | 0] | 0)) + -1 | 1 | 0) | 0) << 5) | 0;
    33549. 

  33549.  while (1) {
    33550. 

  33550.   if ((HEAP32[i4 + 24 >> 2] | 0) == 3 ? +HEAPF64[i4 + 16 >> 3] == d3 : 0) {
    33551. 

  33551.    break;
    33552. 

  33552.   }
    33553. 

  33553.   i4 = HEAP32[i4 + 28 >> 2] | 0;
    33554. 

  33554.   if ((i4 | 0) == 0) {
    33555. 

  33555.    i4 = 5192;
    33556. 

  33556.    i2 = 10;
    33557. 

  33557.    break;
    33558. 

  33558.   }
    33559. 

  33559.  }
    33560. 

  33560.  if ((i2 | 0) == 10) {
    33561. 

  33561.   STACKTOP = i1;
    33562. 

  33562.   return i4 | 0;
    33563. 

  33563.  }
    33564. 

  33564.  i7 = i4;
    33565. 

  33565.  STACKTOP = i1;
    33566. 

  33566.  return i7 | 0;
    33567. 

  33567. }
    33568. 

  33568. function _luaL_checkversion_(i1, d4) {
    33569. 

  33569.  i1 = i1 | 0;
    33570. 

  33570.  d4 = +d4;
    33571. 

  33571.  var i2 = 0, i3 = 0, i5 = 0, d6 = 0.0;
    33572. 

  33572.  i2 = STACKTOP;
    33573. 

  33573.  STACKTOP = STACKTOP + 16 | 0;
    33574. 

  33574.  i3 = i2;
    33575. 

  33575.  i5 = _lua_version(i1) | 0;
    33576. 

  33576.  if ((i5 | 0) == (_lua_version(0) | 0)) {
    33577. 

  33577.   d6 = +HEAPF64[i5 >> 3];
    33578. 

  33578.   if (d6 != d4) {
    33579. 

  33579.    HEAPF64[tempDoublePtr >> 3] = d4;
    33580. 

  33580.    HEAP32[i3 >> 2] = HEAP32[tempDoublePtr >> 2];
    33581. 

  33581.    HEAP32[i3 + 4 >> 2] = HEAP32[tempDoublePtr + 4 >> 2];
    33582. 

  33582.    i5 = i3 + 8 | 0;
    33583. 

  33583.    HEAPF64[tempDoublePtr >> 3] = d6;
    33584. 

  33584.    HEAP32[i5 >> 2] = HEAP32[tempDoublePtr >> 2];
    33585. 

  33585.    HEAP32[i5 + 4 >> 2] = HEAP32[tempDoublePtr + 4 >> 2];
    33586. 

  33586.    _luaL_error(i1, 1528, i3) | 0;
    33587. 

  33587.   }
    33588. 

  33588.  } else {
    33589. 

  33589.   _luaL_error(i1, 1496, i3) | 0;
    33590. 

  33590.  }
    33591. 

  33591.  _lua_pushnumber(i1, -4660.0);
    33592. 

  33592.  if ((_lua_tointegerx(i1, -1, 0) | 0) == -4660 ? (_lua_tounsignedx(i1, -1, 0) | 0) == -4660 : 0) {
    33593. 

  33593.   _lua_settop(i1, -2);
    33594. 

  33594.   STACKTOP = i2;
    33595. 

  33595.   return;
    33596. 

  33596.  }
    33597. 

  33597.  _luaL_error(i1, 1584, i3) | 0;
    33598. 

  33598.  _lua_settop(i1, -2);
    33599. 

  33599.  STACKTOP = i2;
    33600. 

  33600.  return;
    33601. 

  33601. }
    33602. 

  33602. function _math_random(i1) {
    33603. 

  33603.  i1 = i1 | 0;
    33604. 

  33604.  var i2 = 0, d3 = 0.0, i4 = 0, i5 = 0, d6 = 0.0, d7 = 0.0;
    33605. 

  33605.  i2 = STACKTOP;
    33606. 

  33606.  STACKTOP = STACKTOP + 16 | 0;
    33607. 

  33607.  i4 = i2;
    33608. 

  33608.  d3 = +((_rand() | 0) % 2147483647 | 0 | 0) / 2147483647.0;
    33609. 

  33609.  i5 = _lua_gettop(i1) | 0;
    33610. 

  33610.  if ((i5 | 0) == 0) {
    33611. 

  33611.   _lua_pushnumber(i1, d3);
    33612. 

  33612.   i5 = 1;
    33613. 

  33613.   STACKTOP = i2;
    33614. 

  33614.   return i5 | 0;
    33615. 

  33615.  } else if ((i5 | 0) == 1) {
    33616. 

  33616.   d6 = +_luaL_checknumber(i1, 1);
    33617. 

  33617.   if (!(d6 >= 1.0)) {
    33618. 

  33618.    _luaL_argerror(i1, 1, 4056) | 0;
    33619. 

  33619.   }
    33620. 

  33620.   _lua_pushnumber(i1, +Math_floor(+(d3 * d6)) + 1.0);
    33621. 

  33621.   i5 = 1;
    33622. 

  33622.   STACKTOP = i2;
    33623. 

  33623.   return i5 | 0;
    33624. 

  33624.  } else if ((i5 | 0) == 2) {
    33625. 

  33625.   d6 = +_luaL_checknumber(i1, 1);
    33626. 

  33626.   d7 = +_luaL_checknumber(i1, 2);
    33627. 

  33627.   if (!(d6 <= d7)) {
    33628. 

  33628.    _luaL_argerror(i1, 2, 4056) | 0;
    33629. 

  33629.   }
    33630. 

  33630.   _lua_pushnumber(i1, d6 + +Math_floor(+(d3 * (d7 - d6 + 1.0))));
    33631. 

  33631.   i5 = 1;
    33632. 

  33632.   STACKTOP = i2;
    33633. 

  33633.   return i5 | 0;
    33634. 

  33634.  } else {
    33635. 

  33635.   i5 = _luaL_error(i1, 4080, i4) | 0;
    33636. 

  33636.   STACKTOP = i2;
    33637. 

  33637.   return i5 | 0;
    33638. 

  33638.  }
    33639. 

  33639.  return 0;
    33640. 

  33640. }
    33641. 

  33641. function _push_onecapture(i2, i3, i4, i6) {
    33642. 

  33642.  i2 = i2 | 0;
    33643. 

  33643.  i3 = i3 | 0;
    33644. 

  33644.  i4 = i4 | 0;
    33645. 

  33645.  i6 = i6 | 0;
    33646. 

  33646.  var i1 = 0, i5 = 0;
    33647. 

  33647.  i1 = STACKTOP;
    33648. 

  33648.  STACKTOP = STACKTOP + 16 | 0;
    33649. 

  33649.  i5 = i1;
    33650. 

  33650.  if ((HEAP32[i2 + 20 >> 2] | 0) <= (i3 | 0)) {
    33651. 

  33651.   i2 = HEAP32[i2 + 16 >> 2] | 0;
    33652. 

  33652.   if ((i3 | 0) == 0) {
    33653. 

  33653.    _lua_pushlstring(i2, i4, i6 - i4 | 0) | 0;
    33654. 

  33654.    STACKTOP = i1;
    33655. 

  33655.    return;
    33656. 

  33656.   } else {
    33657. 

  33657.    _luaL_error(i2, 7224, i5) | 0;
    33658. 

  33658.    STACKTOP = i1;
    33659. 

  33659.    return;
    33660. 

  33660.   }
    33661. 

  33661.  }
    33662. 

  33662.  i4 = HEAP32[i2 + (i3 << 3) + 28 >> 2] | 0;
    33663. 

  33663.  if (!((i4 | 0) == -1)) {
    33664. 

  33664.   i5 = HEAP32[i2 + 16 >> 2] | 0;
    33665. 

  33665.   i3 = HEAP32[i2 + (i3 << 3) + 24 >> 2] | 0;
    33666. 

  33666.   if ((i4 | 0) == -2) {
    33667. 

  33667.    _lua_pushinteger(i5, i3 + 1 - (HEAP32[i2 + 4 >> 2] | 0) | 0);
    33668. 

  33668.    STACKTOP = i1;
    33669. 

  33669.    return;
    33670. 

  33670.   }
    33671. 

  33671.  } else {
    33672. 

  33672.   i6 = i2 + 16 | 0;
    33673. 

  33673.   _luaL_error(HEAP32[i6 >> 2] | 0, 7248, i5) | 0;
    33674. 

  33674.   i5 = HEAP32[i6 >> 2] | 0;
    33675. 

  33675.   i3 = HEAP32[i2 + (i3 << 3) + 24 >> 2] | 0;
    33676. 

  33676.  }
    33677. 

  33677.  _lua_pushlstring(i5, i3, i4) | 0;
    33678. 

  33678.  STACKTOP = i1;
    33679. 

  33679.  return;
    33680. 

  33680. }
    33681. 

  33681. function _luaK_nil(i7, i6, i5) {
    33682. 

  33682.  i7 = i7 | 0;
    33683. 

  33683.  i6 = i6 | 0;
    33684. 

  33684.  i5 = i5 | 0;
    33685. 

  33685.  var i1 = 0, i2 = 0, i3 = 0, i4 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0;
    33686. 

  33686.  i2 = STACKTOP;
    33687. 

  33687.  i9 = i5 + i6 | 0;
    33688. 

  33688.  i1 = i9 + -1 | 0;
    33689. 

  33689.  i10 = HEAP32[i7 + 20 >> 2] | 0;
    33690. 

  33690.  do {
    33691. 

  33691.   if ((i10 | 0) > (HEAP32[i7 + 24 >> 2] | 0) ? (i4 = (HEAP32[(HEAP32[i7 >> 2] | 0) + 12 >> 2] | 0) + (i10 + -1 << 2) | 0, i3 = HEAP32[i4 >> 2] | 0, (i3 & 63 | 0) == 4) : 0) {
    33692. 

  33692.    i11 = i3 >>> 6 & 255;
    33693. 

  33693.    i10 = i11 + (i3 >>> 23) | 0;
    33694. 

  33694.    if (!((i11 | 0) <= (i6 | 0) ? (i10 + 1 | 0) >= (i6 | 0) : 0)) {
    33695. 

  33695.     i8 = 5;
    33696. 

  33696.    }
    33697. 

  33697.    if ((i8 | 0) == 5 ? (i11 | 0) < (i6 | 0) | (i11 | 0) > (i9 | 0) : 0) {
    33698. 

  33698.     break;
    33699. 

  33699.    }
    33700. 

  33700.    i5 = (i11 | 0) < (i6 | 0) ? i11 : i6;
    33701. 

  33701.    HEAP32[i4 >> 2] = ((i10 | 0) > (i1 | 0) ? i10 : i1) - i5 << 23 | i5 << 6 & 16320 | i3 & 8372287;
    33702. 

  33702.    STACKTOP = i2;
    33703. 

  33703.    return;
    33704. 

  33704.   }
    33705. 

  33705.  } while (0);
    33706. 

  33706.  _luaK_code(i7, i6 << 6 | (i5 << 23) + -8388608 | 4) | 0;
    33707. 

  33707.  STACKTOP = i2;
    33708. 

  33708.  return;
    33709. 

  33709. }
    33710. 

  33710. function _lua_settable(i1, i5) {
    33711. 

  33711.  i1 = i1 | 0;
    33712. 

  33712.  i5 = i5 | 0;
    33713. 

  33713.  var i2 = 0, i3 = 0, i4 = 0;
    33714. 

  33714.  i2 = STACKTOP;
    33715. 

  33715.  i4 = HEAP32[i1 + 16 >> 2] | 0;
    33716. 

  33716.  do {
    33717. 

  33717.   if ((i5 | 0) <= 0) {
    33718. 

  33718.    if (!((i5 | 0) < -1000999)) {
    33719. 

  33719.     i3 = (HEAP32[i1 + 8 >> 2] | 0) + (i5 << 4) | 0;
    33720. 

  33720.     break;
    33721. 

  33721.    }
    33722. 

  33722.    if ((i5 | 0) == -1001e3) {
    33723. 

  33723.     i3 = (HEAP32[i1 + 12 >> 2] | 0) + 40 | 0;
    33724. 

  33724.     break;
    33725. 

  33725.    }
    33726. 

  33726.    i5 = -1001e3 - i5 | 0;
    33727. 

  33727.    i4 = HEAP32[i4 >> 2] | 0;
    33728. 

  33728.    if ((HEAP32[i4 + 8 >> 2] | 0) != 22 ? (i3 = HEAP32[i4 >> 2] | 0, (i5 | 0) <= (HEAPU8[i3 + 6 | 0] | 0 | 0)) : 0) {
    33729. 

  33729.     i3 = i3 + (i5 + -1 << 4) + 16 | 0;
    33730. 

  33730.    } else {
    33731. 

  33731.     i3 = 5192;
    33732. 

  33732.    }
    33733. 

  33733.   } else {
    33734. 

  33734.    i3 = (HEAP32[i4 >> 2] | 0) + (i5 << 4) | 0;
    33735. 

  33735.    i3 = i3 >>> 0 < (HEAP32[i1 + 8 >> 2] | 0) >>> 0 ? i3 : 5192;
    33736. 

  33736.   }
    33737. 

  33737.  } while (0);
    33738. 

  33738.  i5 = i1 + 8 | 0;
    33739. 

  33739.  i4 = HEAP32[i5 >> 2] | 0;
    33740. 

  33740.  _luaV_settable(i1, i3, i4 + -32 | 0, i4 + -16 | 0);
    33741. 

  33741.  HEAP32[i5 >> 2] = (HEAP32[i5 >> 2] | 0) + -32;
    33742. 

  33742.  STACKTOP = i2;
    33743. 

  33743.  return;
    33744. 

  33744. }
    33745. 

  33745. function _luaL_findtable(i3, i6, i5, i4) {
    33746. 

  33746.  i3 = i3 | 0;
    33747. 

  33747.  i6 = i6 | 0;
    33748. 

  33748.  i5 = i5 | 0;
    33749. 

  33749.  i4 = i4 | 0;
    33750. 

  33750.  var i1 = 0, i2 = 0, i7 = 0;
    33751. 

  33751.  i2 = STACKTOP;
    33752. 

  33752.  if ((i6 | 0) != 0) {
    33753. 

  33753.   _lua_pushvalue(i3, i6);
    33754. 

  33754.  }
    33755. 

  33755.  while (1) {
    33756. 

  33756.   i6 = _strchr(i5, 46) | 0;
    33757. 

  33757.   if ((i6 | 0) == 0) {
    33758. 

  33758.    i6 = i5 + (_strlen(i5 | 0) | 0) | 0;
    33759. 

  33759.   }
    33760. 

  33760.   i7 = i6 - i5 | 0;
    33761. 

  33761.   _lua_pushlstring(i3, i5, i7) | 0;
    33762. 

  33762.   _lua_rawget(i3, -2);
    33763. 

  33763.   if ((_lua_type(i3, -1) | 0) != 0) {
    33764. 

  33764.    if ((_lua_type(i3, -1) | 0) != 5) {
    33765. 

  33765.     break;
    33766. 

  33766.    }
    33767. 

  33767.   } else {
    33768. 

  33768.    _lua_settop(i3, -2);
    33769. 

  33769.    _lua_createtable(i3, 0, (HEAP8[i6] | 0) == 46 ? 1 : i4);
    33770. 

  33770.    _lua_pushlstring(i3, i5, i7) | 0;
    33771. 

  33771.    _lua_pushvalue(i3, -2);
    33772. 

  33772.    _lua_settable(i3, -4);
    33773. 

  33773.   }
    33774. 

  33774.   _lua_remove(i3, -2);
    33775. 

  33775.   if ((HEAP8[i6] | 0) == 46) {
    33776. 

  33776.    i5 = i6 + 1 | 0;
    33777. 

  33777.   } else {
    33778. 

  33778.    i3 = 0;
    33779. 

  33779.    i1 = 10;
    33780. 

  33780.    break;
    33781. 

  33781.   }
    33782. 

  33782.  }
    33783. 

  33783.  if ((i1 | 0) == 10) {
    33784. 

  33784.   STACKTOP = i2;
    33785. 

  33785.   return i3 | 0;
    33786. 

  33786.  }
    33787. 

  33787.  _lua_settop(i3, -3);
    33788. 

  33788.  i7 = i5;
    33789. 

  33789.  STACKTOP = i2;
    33790. 

  33790.  return i7 | 0;
    33791. 

  33791. }
    33792. 

  33792. function _luaD_call(i1, i4, i5, i8) {
    33793. 

  33793.  i1 = i1 | 0;
    33794. 

  33794.  i4 = i4 | 0;
    33795. 

  33795.  i5 = i5 | 0;
    33796. 

  33796.  i8 = i8 | 0;
    33797. 

  33797.  var i2 = 0, i3 = 0, i6 = 0, i7 = 0;
    33798. 

  33798.  i3 = STACKTOP;
    33799. 

  33799.  STACKTOP = STACKTOP + 16 | 0;
    33800. 

  33800.  i7 = i3;
    33801. 

  33801.  i2 = i1 + 38 | 0;
    33802. 

  33802.  i6 = (HEAP16[i2 >> 1] | 0) + 1 << 16 >> 16;
    33803. 

  33803.  HEAP16[i2 >> 1] = i6;
    33804. 

  33804.  if ((i6 & 65535) > 199) {
    33805. 

  33805.   if (i6 << 16 >> 16 == 200) {
    33806. 

  33806.    _luaG_runerror(i1, 2240, i7);
    33807. 

  33807.   }
    33808. 

  33808.   if ((i6 & 65535) > 224) {
    33809. 

  33809.    _luaD_throw(i1, 6);
    33810. 

  33810.   }
    33811. 

  33811.  }
    33812. 

  33812.  i6 = (i8 | 0) != 0;
    33813. 

  33813.  if (!i6) {
    33814. 

  33814.   i8 = i1 + 36 | 0;
    33815. 

  33815.   HEAP16[i8 >> 1] = (HEAP16[i8 >> 1] | 0) + 1 << 16 >> 16;
    33816. 

  33816.  }
    33817. 

  33817.  if ((_luaD_precall(i1, i4, i5) | 0) == 0) {
    33818. 

  33818.   _luaV_execute(i1);
    33819. 

  33819.  }
    33820. 

  33820.  if (i6) {
    33821. 

  33821.   i8 = HEAP16[i2 >> 1] | 0;
    33822. 

  33822.   i8 = i8 + -1 << 16 >> 16;
    33823. 

  33823.   HEAP16[i2 >> 1] = i8;
    33824. 

  33824.   STACKTOP = i3;
    33825. 

  33825.   return;
    33826. 

  33826.  }
    33827. 

  33827.  i8 = i1 + 36 | 0;
    33828. 

  33828.  HEAP16[i8 >> 1] = (HEAP16[i8 >> 1] | 0) + -1 << 16 >> 16;
    33829. 

  33829.  i8 = HEAP16[i2 >> 1] | 0;
    33830. 

  33830.  i8 = i8 + -1 << 16 >> 16;
    33831. 

  33831.  HEAP16[i2 >> 1] = i8;
    33832. 

  33832.  STACKTOP = i3;
    33833. 

  33833.  return;
    33834. 

  33834. }
    33835. 

  33835. function _pushline(i6, i1) {
    33836. 

  33836.  i6 = i6 | 0;
    33837. 

  33837.  i1 = i1 | 0;
    33838. 

  33838.  var i2 = 0, i3 = 0, i4 = 0, i5 = 0, i7 = 0, i8 = 0;
    33839. 

  33839.  i2 = STACKTOP;
    33840. 

  33840.  STACKTOP = STACKTOP + 528 | 0;
    33841. 

  33841.  i4 = i2;
    33842. 

  33842.  i3 = i2 + 8 | 0;
    33843. 

  33843.  i7 = (i1 | 0) != 0;
    33844. 

  33844.  _lua_getglobal(i6, i7 ? 288 : 296);
    33845. 

  33845.  i8 = _lua_tolstring(i6, -1, 0) | 0;
    33846. 

  33846.  if ((i8 | 0) == 0) {
    33847. 

  33847.   i8 = i7 ? 312 : 320;
    33848. 

  33848.  }
    33849. 

  33849.  i7 = HEAP32[_stdout >> 2] | 0;
    33850. 

  33850.  _fputs(i8 | 0, i7 | 0) | 0;
    33851. 

  33851.  _fflush(i7 | 0) | 0;
    33852. 

  33852.  i8 = (_fgets(i3 | 0, 512, HEAP32[_stdin >> 2] | 0) | 0) == 0;
    33853. 

  33853.  _lua_settop(i6, -2);
    33854. 

  33854.  if (i8) {
    33855. 

  33855.   i8 = 0;
    33856. 

  33856.   STACKTOP = i2;
    33857. 

  33857.   return i8 | 0;
    33858. 

  33858.  }
    33859. 

  33859.  i7 = _strlen(i3 | 0) | 0;
    33860. 

  33860.  if ((i7 | 0) != 0 ? (i5 = i3 + (i7 + -1) | 0, (HEAP8[i5] | 0) == 10) : 0) {
    33861. 

  33861.   HEAP8[i5] = 0;
    33862. 

  33862.  }
    33863. 

  33863.  if ((i1 | 0) != 0 ? (HEAP8[i3] | 0) == 61 : 0) {
    33864. 

  33864.   HEAP32[i4 >> 2] = i3 + 1;
    33865. 

  33865.   _lua_pushfstring(i6, 272, i4) | 0;
    33866. 

  33866.   i8 = 1;
    33867. 

  33867.   STACKTOP = i2;
    33868. 

  33868.   return i8 | 0;
    33869. 

  33869.  }
    33870. 

  33870.  _lua_pushstring(i6, i3) | 0;
    33871. 

  33871.  i8 = 1;
    33872. 

  33872.  STACKTOP = i2;
    33873. 

  33873.  return i8 | 0;
    33874. 

  33874. }
    33875. 

  33875. function _db_getlocal(i1) {
    33876. 

  33876.  i1 = i1 | 0;
    33877. 

  33877.  var i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0;
    33878. 

  33878.  i2 = STACKTOP;
    33879. 

  33879.  STACKTOP = STACKTOP + 112 | 0;
    33880. 

  33880.  i4 = i2;
    33881. 

  33881.  if ((_lua_type(i1, 1) | 0) == 8) {
    33882. 

  33882.   i3 = _lua_tothread(i1, 1) | 0;
    33883. 

  33883.   i6 = 1;
    33884. 

  33884.  } else {
    33885. 

  33885.   i3 = i1;
    33886. 

  33886.   i6 = 0;
    33887. 

  33887.  }
    33888. 

  33888.  i5 = _luaL_checkinteger(i1, i6 | 2) | 0;
    33889. 

  33889.  i6 = i6 + 1 | 0;
    33890. 

  33890.  if ((_lua_type(i1, i6) | 0) == 6) {
    33891. 

  33891.   _lua_pushvalue(i1, i6);
    33892. 

  33892.   _lua_pushstring(i1, _lua_getlocal(i1, 0, i5) | 0) | 0;
    33893. 

  33893.   i6 = 1;
    33894. 

  33894.   STACKTOP = i2;
    33895. 

  33895.   return i6 | 0;
    33896. 

  33896.  }
    33897. 

  33897.  if ((_lua_getstack(i3, _luaL_checkinteger(i1, i6) | 0, i4) | 0) == 0) {
    33898. 

  33898.   i6 = _luaL_argerror(i1, i6, 11560) | 0;
    33899. 

  33899.   STACKTOP = i2;
    33900. 

  33900.   return i6 | 0;
    33901. 

  33901.  }
    33902. 

  33902.  i4 = _lua_getlocal(i3, i4, i5) | 0;
    33903. 

  33903.  if ((i4 | 0) == 0) {
    33904. 

  33904.   _lua_pushnil(i1);
    33905. 

  33905.   i6 = 1;
    33906. 

  33906.   STACKTOP = i2;
    33907. 

  33907.   return i6 | 0;
    33908. 

  33908.  } else {
    33909. 

  33909.   _lua_xmove(i3, i1, 1);
    33910. 

  33910.   _lua_pushstring(i1, i4) | 0;
    33911. 

  33911.   _lua_pushvalue(i1, -2);
    33912. 

  33912.   i6 = 2;
    33913. 

  33913.   STACKTOP = i2;
    33914. 

  33914.   return i6 | 0;
    33915. 

  33915.  }
    33916. 

  33916.  return 0;
    33917. 

  33917. }
    33918. 

  33918. function _luaB_print(i1) {
    33919. 

  33919.  i1 = i1 | 0;
    33920. 

  33920.  var i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0;
    33921. 

  33921.  i3 = STACKTOP;
    33922. 

  33922.  STACKTOP = STACKTOP + 16 | 0;
    33923. 

  33923.  i2 = i3;
    33924. 

  33924.  i4 = i3 + 4 | 0;
    33925. 

  33925.  i6 = _lua_gettop(i1) | 0;
    33926. 

  33926.  _lua_getglobal(i1, 9584);
    33927. 

  33927.  i5 = HEAP32[_stdout >> 2] | 0;
    33928. 

  33928.  L1 : do {
    33929. 

  33929.   if ((i6 | 0) >= 1) {
    33930. 

  33930.    i7 = 1;
    33931. 

  33931.    while (1) {
    33932. 

  33932.     _lua_pushvalue(i1, -1);
    33933. 

  33933.     _lua_pushvalue(i1, i7);
    33934. 

  33934.     _lua_callk(i1, 1, 1, 0, 0);
    33935. 

  33935.     i8 = _lua_tolstring(i1, -1, i4) | 0;
    33936. 

  33936.     if ((i8 | 0) == 0) {
    33937. 

  33937.      break;
    33938. 

  33938.     }
    33939. 

  33939.     if ((i7 | 0) > 1) {
    33940. 

  33940.      _fputc(9, i5 | 0) | 0;
    33941. 

  33941.     }
    33942. 

  33942.     _fwrite(i8 | 0, 1, HEAP32[i4 >> 2] | 0, i5 | 0) | 0;
    33943. 

  33943.     _lua_settop(i1, -2);
    33944. 

  33944.     if ((i7 | 0) < (i6 | 0)) {
    33945. 

  33945.      i7 = i7 + 1 | 0;
    33946. 

  33946.     } else {
    33947. 

  33947.      break L1;
    33948. 

  33948.     }
    33949. 

  33949.    }
    33950. 

  33950.    i8 = _luaL_error(i1, 9816, i2) | 0;
    33951. 

  33951.    STACKTOP = i3;
    33952. 

  33952.    return i8 | 0;
    33953. 

  33953.   }
    33954. 

  33954.  } while (0);
    33955. 

  33955.  _fputc(10, i5 | 0) | 0;
    33956. 

  33956.  _fflush(i5 | 0) | 0;
    33957. 

  33957.  i8 = 0;
    33958. 

  33958.  STACKTOP = i3;
    33959. 

  33959.  return i8 | 0;
    33960. 

  33960. }
    33961. 

  33961. function _luaB_load(i1) {
    33962. 

  33962.  i1 = i1 | 0;
    33963. 

  33963.  var i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0;
    33964. 

  33964.  i2 = STACKTOP;
    33965. 

  33965.  STACKTOP = STACKTOP + 16 | 0;
    33966. 

  33966.  i5 = i2;
    33967. 

  33967.  i6 = _lua_tolstring(i1, 1, i5) | 0;
    33968. 

  33968.  i4 = _luaL_optlstring(i1, 3, 9872, 0) | 0;
    33969. 

  33969.  i3 = (_lua_type(i1, 4) | 0) != -1;
    33970. 

  33970.  if ((i6 | 0) == 0) {
    33971. 

  33971.   i6 = _luaL_optlstring(i1, 2, 9880, 0) | 0;
    33972. 

  33972.   _luaL_checktype(i1, 1, 6);
    33973. 

  33973.   _lua_settop(i1, 5);
    33974. 

  33974.   i4 = _lua_load(i1, 3, 0, i6, i4) | 0;
    33975. 

  33975.  } else {
    33976. 

  33976.   i7 = _luaL_optlstring(i1, 2, i6, 0) | 0;
    33977. 

  33977.   i4 = _luaL_loadbufferx(i1, i6, HEAP32[i5 >> 2] | 0, i7, i4) | 0;
    33978. 

  33978.  }
    33979. 

  33979.  if ((i4 | 0) != 0) {
    33980. 

  33980.   _lua_pushnil(i1);
    33981. 

  33981.   _lua_insert(i1, -2);
    33982. 

  33982.   i7 = 2;
    33983. 

  33983.   STACKTOP = i2;
    33984. 

  33984.   return i7 | 0;
    33985. 

  33985.  }
    33986. 

  33986.  if (!i3) {
    33987. 

  33987.   i7 = 1;
    33988. 

  33988.   STACKTOP = i2;
    33989. 

  33989.   return i7 | 0;
    33990. 

  33990.  }
    33991. 

  33991.  _lua_pushvalue(i1, i3 ? 4 : 0);
    33992. 

  33992.  if ((_lua_setupvalue(i1, -2, 1) | 0) != 0) {
    33993. 

  33993.   i7 = 1;
    33994. 

  33994.   STACKTOP = i2;
    33995. 

  33995.   return i7 | 0;
    33996. 

  33996.  }
    33997. 

  33997.  _lua_settop(i1, -2);
    33998. 

  33998.  i7 = 1;
    33999. 

  33999.  STACKTOP = i2;
    34000. 

  34000.  return i7 | 0;
    34001. 

  34001. }
    34002. 

  34002. function _db_debug(i2) {
    34003. 

  34003.  i2 = i2 | 0;
    34004. 

  34004.  var i1 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0;
    34005. 

  34005.  i1 = STACKTOP;
    34006. 

  34006.  STACKTOP = STACKTOP + 256 | 0;
    34007. 

  34007.  i6 = i1;
    34008. 

  34008.  i4 = i1 + 4 | 0;
    34009. 

  34009.  i3 = HEAP32[_stderr >> 2] | 0;
    34010. 

  34010.  _fwrite(12040, 11, 1, i3 | 0) | 0;
    34011. 

  34011.  _fflush(i3 | 0) | 0;
    34012. 

  34012.  i5 = HEAP32[_stdin >> 2] | 0;
    34013. 

  34013.  if ((_fgets(i4 | 0, 250, i5 | 0) | 0) == 0) {
    34014. 

  34014.   STACKTOP = i1;
    34015. 

  34015.   return 0;
    34016. 

  34016.  }
    34017. 

  34017.  while (1) {
    34018. 

  34018.   if ((_strcmp(i4, 12056) | 0) == 0) {
    34019. 

  34019.    i2 = 7;
    34020. 

  34020.    break;
    34021. 

  34021.   }
    34022. 

  34022.   if (!((_luaL_loadbufferx(i2, i4, _strlen(i4 | 0) | 0, 12064, 0) | 0) == 0 ? (_lua_pcallk(i2, 0, 0, 0, 0, 0) | 0) == 0 : 0)) {
    34023. 

  34023.    HEAP32[i6 >> 2] = _lua_tolstring(i2, -1, 0) | 0;
    34024. 

  34024.    _fprintf(i3 | 0, 12088, i6 | 0) | 0;
    34025. 

  34025.    _fflush(i3 | 0) | 0;
    34026. 

  34026.   }
    34027. 

  34027.   _lua_settop(i2, 0);
    34028. 

  34028.   _fwrite(12040, 11, 1, i3 | 0) | 0;
    34029. 

  34029.   _fflush(i3 | 0) | 0;
    34030. 

  34030.   if ((_fgets(i4 | 0, 250, i5 | 0) | 0) == 0) {
    34031. 

  34031.    i2 = 7;
    34032. 

  34032.    break;
    34033. 

  34033.   }
    34034. 

  34034.  }
    34035. 

  34035.  if ((i2 | 0) == 7) {
    34036. 

  34036.   STACKTOP = i1;
    34037. 

  34037.   return 0;
    34038. 

  34038.  }
    34039. 

  34039.  return 0;
    34040. 

  34040. }
    34041. 

  34041. function _luaL_prepbuffsize(i2, i7) {
    34042. 

  34042.  i2 = i2 | 0;
    34043. 

  34043.  i7 = i7 | 0;
    34044. 

  34044.  var i1 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i8 = 0;
    34045. 

  34045.  i3 = STACKTOP;
    34046. 

  34046.  STACKTOP = STACKTOP + 16 | 0;
    34047. 

  34047.  i1 = HEAP32[i2 + 12 >> 2] | 0;
    34048. 

  34048.  i4 = i2 + 4 | 0;
    34049. 

  34049.  i8 = HEAP32[i4 >> 2] | 0;
    34050. 

  34050.  i5 = i2 + 8 | 0;
    34051. 

  34051.  i6 = HEAP32[i5 >> 2] | 0;
    34052. 

  34052.  if (!((i8 - i6 | 0) >>> 0 < i7 >>> 0)) {
    34053. 

  34053.   i7 = HEAP32[i2 >> 2] | 0;
    34054. 

  34054.   i8 = i6;
    34055. 

  34055.   i8 = i7 + i8 | 0;
    34056. 

  34056.   STACKTOP = i3;
    34057. 

  34057.   return i8 | 0;
    34058. 

  34058.  }
    34059. 

  34059.  i8 = i8 << 1;
    34060. 

  34060.  i8 = (i8 - i6 | 0) >>> 0 < i7 >>> 0 ? i6 + i7 | 0 : i8;
    34061. 

  34061.  if (i8 >>> 0 < i6 >>> 0 | (i8 - i6 | 0) >>> 0 < i7 >>> 0) {
    34062. 

  34062.   _luaL_error(i1, 1272, i3) | 0;
    34063. 

  34063.  }
    34064. 

  34064.  i6 = _lua_newuserdata(i1, i8) | 0;
    34065. 

  34065.  _memcpy(i6 | 0, HEAP32[i2 >> 2] | 0, HEAP32[i5 >> 2] | 0) | 0;
    34066. 

  34066.  if ((HEAP32[i2 >> 2] | 0) != (i2 + 16 | 0)) {
    34067. 

  34067.   _lua_remove(i1, -2);
    34068. 

  34068.  }
    34069. 

  34069.  HEAP32[i2 >> 2] = i6;
    34070. 

  34070.  HEAP32[i4 >> 2] = i8;
    34071. 

  34071.  i7 = i6;
    34072. 

  34072.  i8 = HEAP32[i5 >> 2] | 0;
    34073. 

  34073.  i8 = i7 + i8 | 0;
    34074. 

  34074.  STACKTOP = i3;
    34075. 

  34075.  return i8 | 0;
    34076. 

  34076. }
    34077. 

  34077. function _luaG_runerror(i1, i5, i4) {
    34078. 

  34078.  i1 = i1 | 0;
    34079. 

  34079.  i5 = i5 | 0;
    34080. 

  34080.  i4 = i4 | 0;
    34081. 

  34081.  var i2 = 0, i3 = 0, i6 = 0, i7 = 0;
    34082. 

  34082.  i6 = STACKTOP;
    34083. 

  34083.  STACKTOP = STACKTOP + 96 | 0;
    34084. 

  34084.  i2 = i6;
    34085. 

  34085.  i3 = i6 + 32 | 0;
    34086. 

  34086.  i6 = i6 + 16 | 0;
    34087. 

  34087.  HEAP32[i6 >> 2] = i4;
    34088. 

  34088.  i4 = _luaO_pushvfstring(i1, i5, i6) | 0;
    34089. 

  34089.  i6 = HEAP32[i1 + 16 >> 2] | 0;
    34090. 

  34090.  if ((HEAP8[i6 + 18 | 0] & 1) == 0) {
    34091. 

  34091.   _luaG_errormsg(i1);
    34092. 

  34092.  }
    34093. 

  34093.  i5 = HEAP32[(HEAP32[HEAP32[i6 >> 2] >> 2] | 0) + 12 >> 2] | 0;
    34094. 

  34094.  i7 = HEAP32[i5 + 20 >> 2] | 0;
    34095. 

  34095.  if ((i7 | 0) == 0) {
    34096. 

  34096.   i6 = 0;
    34097. 

  34097.  } else {
    34098. 

  34098.   i6 = HEAP32[i7 + (((HEAP32[i6 + 28 >> 2] | 0) - (HEAP32[i5 + 12 >> 2] | 0) >> 2) + -1 << 2) >> 2] | 0;
    34099. 

  34099.  }
    34100. 

  34100.  i5 = HEAP32[i5 + 36 >> 2] | 0;
    34101. 

  34101.  if ((i5 | 0) == 0) {
    34102. 

  34102.   HEAP8[i3] = 63;
    34103. 

  34103.   HEAP8[i3 + 1 | 0] = 0;
    34104. 

  34104.  } else {
    34105. 

  34105.   _luaO_chunkid(i3, i5 + 16 | 0, 60);
    34106. 

  34106.  }
    34107. 

  34107.  HEAP32[i2 >> 2] = i3;
    34108. 

  34108.  HEAP32[i2 + 4 >> 2] = i6;
    34109. 

  34109.  HEAP32[i2 + 8 >> 2] = i4;
    34110. 

  34110.  _luaO_pushfstring(i1, 2024, i2) | 0;
    34111. 

  34111.  _luaG_errormsg(i1);
    34112. 

  34112. }
    34113. 

  34113. function _db_upvaluejoin(i1) {
    34114. 

  34114.  i1 = i1 | 0;
    34115. 

  34115.  var i2 = 0, i3 = 0, i4 = 0, i5 = 0;
    34116. 

  34116.  i3 = STACKTOP;
    34117. 

  34117.  STACKTOP = STACKTOP + 112 | 0;
    34118. 

  34118.  i4 = i3;
    34119. 

  34119.  i2 = _luaL_checkinteger(i1, 2) | 0;
    34120. 

  34120.  _luaL_checktype(i1, 1, 6);
    34121. 

  34121.  _lua_pushvalue(i1, 1);
    34122. 

  34122.  _lua_getinfo(i1, 11728, i4) | 0;
    34123. 

  34123.  if (!((i2 | 0) > 0 ? (i2 | 0) <= (HEAPU8[i4 + 32 | 0] | 0 | 0) : 0)) {
    34124. 

  34124.   _luaL_argerror(i1, 2, 11736) | 0;
    34125. 

  34125.  }
    34126. 

  34126.  i5 = _luaL_checkinteger(i1, 4) | 0;
    34127. 

  34127.  _luaL_checktype(i1, 3, 6);
    34128. 

  34128.  _lua_pushvalue(i1, 3);
    34129. 

  34129.  _lua_getinfo(i1, 11728, i4) | 0;
    34130. 

  34130.  if (!((i5 | 0) > 0 ? (i5 | 0) <= (HEAPU8[i4 + 32 | 0] | 0 | 0) : 0)) {
    34131. 

  34131.   _luaL_argerror(i1, 4, 11736) | 0;
    34132. 

  34132.  }
    34133. 

  34133.  if ((_lua_iscfunction(i1, 1) | 0) != 0) {
    34134. 

  34134.   _luaL_argerror(i1, 1, 11760) | 0;
    34135. 

  34135.  }
    34136. 

  34136.  if ((_lua_iscfunction(i1, 3) | 0) == 0) {
    34137. 

  34137.   _lua_upvaluejoin(i1, 1, i2, 3, i5);
    34138. 

  34138.   STACKTOP = i3;
    34139. 

  34139.   return 0;
    34140. 

  34140.  }
    34141. 

  34141.  _luaL_argerror(i1, 3, 11760) | 0;
    34142. 

  34142.  _lua_upvaluejoin(i1, 1, i2, 3, i5);
    34143. 

  34143.  STACKTOP = i3;
    34144. 

  34144.  return 0;
    34145. 

  34145. }
    34146. 

  34146. function _luaK_jump(i1) {
    34147. 

  34147.  i1 = i1 | 0;
    34148. 

  34148.  var i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0;
    34149. 

  34149.  i3 = STACKTOP;
    34150. 

  34150.  i2 = i1 + 28 | 0;
    34151. 

  34151.  i7 = HEAP32[i2 >> 2] | 0;
    34152. 

  34152.  HEAP32[i2 >> 2] = -1;
    34153. 

  34153.  i2 = _luaK_code(i1, 2147450903) | 0;
    34154. 

  34154.  if ((i7 | 0) == -1) {
    34155. 

  34155.   i9 = i2;
    34156. 

  34156.   STACKTOP = i3;
    34157. 

  34157.   return i9 | 0;
    34158. 

  34158.  }
    34159. 

  34159.  if ((i2 | 0) == -1) {
    34160. 

  34160.   i9 = i7;
    34161. 

  34161.   STACKTOP = i3;
    34162. 

  34162.   return i9 | 0;
    34163. 

  34163.  }
    34164. 

  34164.  i6 = HEAP32[(HEAP32[i1 >> 2] | 0) + 12 >> 2] | 0;
    34165. 

  34165.  i8 = i2;
    34166. 

  34166.  while (1) {
    34167. 

  34167.   i5 = i6 + (i8 << 2) | 0;
    34168. 

  34168.   i4 = HEAP32[i5 >> 2] | 0;
    34169. 

  34169.   i9 = (i4 >>> 14) + -131071 | 0;
    34170. 

  34170.   if ((i9 | 0) == -1) {
    34171. 

  34171.    break;
    34172. 

  34172.   }
    34173. 

  34173.   i9 = i8 + 1 + i9 | 0;
    34174. 

  34174.   if ((i9 | 0) == -1) {
    34175. 

  34175.    break;
    34176. 

  34176.   } else {
    34177. 

  34177.    i8 = i9;
    34178. 

  34178.   }
    34179. 

  34179.  }
    34180. 

  34180.  i6 = i7 + ~i8 | 0;
    34181. 

  34181.  if ((((i6 | 0) > -1 ? i6 : 0 - i6 | 0) | 0) > 131071) {
    34182. 

  34182.   _luaX_syntaxerror(HEAP32[i1 + 12 >> 2] | 0, 10624);
    34183. 

  34183.  }
    34184. 

  34184.  HEAP32[i5 >> 2] = (i6 << 14) + 2147467264 | i4 & 16383;
    34185. 

  34185.  i9 = i2;
    34186. 

  34186.  STACKTOP = i3;
    34187. 

  34187.  return i9 | 0;
    34188. 

  34188. }
    34189. 

  34189. function _findfield(i2, i3, i4) {
    34190. 

  34190.  i2 = i2 | 0;
    34191. 

  34191.  i3 = i3 | 0;
    34192. 

  34192.  i4 = i4 | 0;
    34193. 

  34193.  var i1 = 0;
    34194. 

  34194.  i1 = STACKTOP;
    34195. 

  34195.  L1 : do {
    34196. 

  34196.   if (((i4 | 0) != 0 ? (_lua_type(i2, -1) | 0) == 5 : 0) ? (_lua_pushnil(i2), (_lua_next(i2, -2) | 0) != 0) : 0) {
    34197. 

  34197.    i4 = i4 + -1 | 0;
    34198. 

  34198.    while (1) {
    34199. 

  34199.     if ((_lua_type(i2, -2) | 0) == 4) {
    34200. 

  34200.      if ((_lua_rawequal(i2, i3, -1) | 0) != 0) {
    34201. 

  34201.       i3 = 7;
    34202. 

  34202.       break;
    34203. 

  34203.      }
    34204. 

  34204.      if ((_findfield(i2, i3, i4) | 0) != 0) {
    34205. 

  34205.       i3 = 9;
    34206. 

  34206.       break;
    34207. 

  34207.      }
    34208. 

  34208.     }
    34209. 

  34209.     _lua_settop(i2, -2);
    34210. 

  34210.     if ((_lua_next(i2, -2) | 0) == 0) {
    34211. 

  34211.      i2 = 0;
    34212. 

  34212.      break L1;
    34213. 

  34213.     }
    34214. 

  34214.    }
    34215. 

  34215.    if ((i3 | 0) == 7) {
    34216. 

  34216.     _lua_settop(i2, -2);
    34217. 

  34217.     i2 = 1;
    34218. 

  34218.     break;
    34219. 

  34219.    } else if ((i3 | 0) == 9) {
    34220. 

  34220.     _lua_remove(i2, -2);
    34221. 

  34221.     _lua_pushlstring(i2, 1776, 1) | 0;
    34222. 

  34222.     _lua_insert(i2, -2);
    34223. 

  34223.     _lua_concat(i2, 3);
    34224. 

  34224.     i2 = 1;
    34225. 

  34225.     break;
    34226. 

  34226.    }
    34227. 

  34227.   } else {
    34228. 

  34228.    i2 = 0;
    34229. 

  34229.   }
    34230. 

  34230.  } while (0);
    34231. 

  34231.  STACKTOP = i1;
    34232. 

  34232.  return i2 | 0;
    34233. 

  34233. }
    34234. 

  34234. function _db_gethook(i1) {
    34235. 

  34235.  i1 = i1 | 0;
    34236. 

  34236.  var i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0;
    34237. 

  34237.  i3 = STACKTOP;
    34238. 

  34238.  STACKTOP = STACKTOP + 16 | 0;
    34239. 

  34239.  i2 = i3;
    34240. 

  34240.  if ((_lua_type(i1, 1) | 0) == 8) {
    34241. 

  34241.   i4 = _lua_tothread(i1, 1) | 0;
    34242. 

  34242.  } else {
    34243. 

  34243.   i4 = i1;
    34244. 

  34244.  }
    34245. 

  34245.  i5 = _lua_gethookmask(i4) | 0;
    34246. 

  34246.  i6 = _lua_gethook(i4) | 0;
    34247. 

  34247.  if ((i6 | 0) != 0 & (i6 | 0) != 9) {
    34248. 

  34248.   _lua_pushlstring(i1, 12024, 13) | 0;
    34249. 

  34249.  } else {
    34250. 

  34250.   _luaL_getsubtable(i1, -1001e3, 11584) | 0;
    34251. 

  34251.   _lua_pushthread(i4) | 0;
    34252. 

  34252.   _lua_xmove(i4, i1, 1);
    34253. 

  34253.   _lua_rawget(i1, -2);
    34254. 

  34254.   _lua_remove(i1, -2);
    34255. 

  34255.  }
    34256. 

  34256.  if ((i5 & 1 | 0) == 0) {
    34257. 

  34257.   i6 = 0;
    34258. 

  34258.  } else {
    34259. 

  34259.   HEAP8[i2] = 99;
    34260. 

  34260.   i6 = 1;
    34261. 

  34261.  }
    34262. 

  34262.  if ((i5 & 2 | 0) != 0) {
    34263. 

  34263.   HEAP8[i2 + i6 | 0] = 114;
    34264. 

  34264.   i6 = i6 + 1 | 0;
    34265. 

  34265.  }
    34266. 

  34266.  if ((i5 & 4 | 0) != 0) {
    34267. 

  34267.   HEAP8[i2 + i6 | 0] = 108;
    34268. 

  34268.   i6 = i6 + 1 | 0;
    34269. 

  34269.  }
    34270. 

  34270.  HEAP8[i2 + i6 | 0] = 0;
    34271. 

  34271.  _lua_pushstring(i1, i2) | 0;
    34272. 

  34272.  _lua_pushinteger(i1, _lua_gethookcount(i4) | 0);
    34273. 

  34273.  STACKTOP = i3;
    34274. 

  34274.  return 3;
    34275. 

  34275. }
    34276. 

  34276. function _lua_tothread(i3, i5) {
    34277. 

  34277.  i3 = i3 | 0;
    34278. 

  34278.  i5 = i5 | 0;
    34279. 

  34279.  var i1 = 0, i2 = 0, i4 = 0;
    34280. 

  34280.  i1 = STACKTOP;
    34281. 

  34281.  i4 = HEAP32[i3 + 16 >> 2] | 0;
    34282. 

  34282.  do {
    34283. 

  34283.   if ((i5 | 0) <= 0) {
    34284. 

  34284.    if (!((i5 | 0) < -1000999)) {
    34285. 

  34285.     i2 = (HEAP32[i3 + 8 >> 2] | 0) + (i5 << 4) | 0;
    34286. 

  34286.     break;
    34287. 

  34287.    }
    34288. 

  34288.    if ((i5 | 0) == -1001e3) {
    34289. 

  34289.     i2 = (HEAP32[i3 + 12 >> 2] | 0) + 40 | 0;
    34290. 

  34290.     break;
    34291. 

  34291.    }
    34292. 

  34292.    i3 = -1001e3 - i5 | 0;
    34293. 

  34293.    i4 = HEAP32[i4 >> 2] | 0;
    34294. 

  34294.    if ((HEAP32[i4 + 8 >> 2] | 0) != 22 ? (i2 = HEAP32[i4 >> 2] | 0, (i3 | 0) <= (HEAPU8[i2 + 6 | 0] | 0 | 0)) : 0) {
    34295. 

  34295.     i2 = i2 + (i3 + -1 << 4) + 16 | 0;
    34296. 

  34296.    } else {
    34297. 

  34297.     i2 = 5192;
    34298. 

  34298.    }
    34299. 

  34299.   } else {
    34300. 

  34300.    i2 = (HEAP32[i4 >> 2] | 0) + (i5 << 4) | 0;
    34301. 

  34301.    i2 = i2 >>> 0 < (HEAP32[i3 + 8 >> 2] | 0) >>> 0 ? i2 : 5192;
    34302. 

  34302.   }
    34303. 

  34303.  } while (0);
    34304. 

  34304.  if ((HEAP32[i2 + 8 >> 2] | 0) != 72) {
    34305. 

  34305.   i5 = 0;
    34306. 

  34306.   STACKTOP = i1;
    34307. 

  34307.   return i5 | 0;
    34308. 

  34308.  }
    34309. 

  34309.  i5 = HEAP32[i2 >> 2] | 0;
    34310. 

  34310.  STACKTOP = i1;
    34311. 

  34311.  return i5 | 0;
    34312. 

  34312. }
    34313. 

  34313. function _luaD_throw(i1, i2) {
    34314. 

  34314.  i1 = i1 | 0;
    34315. 

  34315.  i2 = i2 | 0;
    34316. 

  34316.  var i3 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0;
    34317. 

  34317.  i3 = i1 + 64 | 0;
    34318. 

  34318.  i4 = HEAP32[i3 >> 2] | 0;
    34319. 

  34319.  if ((i4 | 0) != 0) {
    34320. 

  34320.   HEAP32[i4 + 160 >> 2] = i2;
    34321. 

  34321.   _longjmp((HEAP32[i3 >> 2] | 0) + 4 | 0, 1);
    34322. 

  34322.  }
    34323. 

  34323.  HEAP8[i1 + 6 | 0] = i2;
    34324. 

  34324.  i4 = i1 + 12 | 0;
    34325. 

  34325.  i3 = HEAP32[i4 >> 2] | 0;
    34326. 

  34326.  i5 = HEAP32[i3 + 172 >> 2] | 0;
    34327. 

  34327.  if ((HEAP32[i5 + 64 >> 2] | 0) != 0) {
    34328. 

  34328.   i6 = HEAP32[i1 + 8 >> 2] | 0;
    34329. 

  34329.   i9 = i5 + 8 | 0;
    34330. 

  34330.   i5 = HEAP32[i9 >> 2] | 0;
    34331. 

  34331.   HEAP32[i9 >> 2] = i5 + 16;
    34332. 

  34332.   i9 = i6 + -16 | 0;
    34333. 

  34333.   i8 = HEAP32[i9 + 4 >> 2] | 0;
    34334. 

  34334.   i7 = i5;
    34335. 

  34335.   HEAP32[i7 >> 2] = HEAP32[i9 >> 2];
    34336. 

  34336.   HEAP32[i7 + 4 >> 2] = i8;
    34337. 

  34337.   HEAP32[i5 + 8 >> 2] = HEAP32[i6 + -8 >> 2];
    34338. 

  34338.   _luaD_throw(HEAP32[(HEAP32[i4 >> 2] | 0) + 172 >> 2] | 0, i2);
    34339. 

  34339.  }
    34340. 

  34340.  i2 = HEAP32[i3 + 168 >> 2] | 0;
    34341. 

  34341.  if ((i2 | 0) == 0) {
    34342. 

  34342.   _abort();
    34343. 

  34343.  }
    34344. 

  34344.  FUNCTION_TABLE_ii[i2 & 255](i1) | 0;
    34345. 

  34345.  _abort();
    34346. 

  34346. }
    34347. 

  34347. function _lua_len(i1, i5) {
    34348. 

  34348.  i1 = i1 | 0;
    34349. 

  34349.  i5 = i5 | 0;
    34350. 

  34350.  var i2 = 0, i3 = 0, i4 = 0;
    34351. 

  34351.  i2 = STACKTOP;
    34352. 

  34352.  i4 = HEAP32[i1 + 16 >> 2] | 0;
    34353. 

  34353.  do {
    34354. 

  34354.   if ((i5 | 0) <= 0) {
    34355. 

  34355.    if (!((i5 | 0) < -1000999)) {
    34356. 

  34356.     i3 = (HEAP32[i1 + 8 >> 2] | 0) + (i5 << 4) | 0;
    34357. 

  34357.     break;
    34358. 

  34358.    }
    34359. 

  34359.    if ((i5 | 0) == -1001e3) {
    34360. 

  34360.     i3 = (HEAP32[i1 + 12 >> 2] | 0) + 40 | 0;
    34361. 

  34361.     break;
    34362. 

  34362.    }
    34363. 

  34363.    i5 = -1001e3 - i5 | 0;
    34364. 

  34364.    i4 = HEAP32[i4 >> 2] | 0;
    34365. 

  34365.    if ((HEAP32[i4 + 8 >> 2] | 0) != 22 ? (i3 = HEAP32[i4 >> 2] | 0, (i5 | 0) <= (HEAPU8[i3 + 6 | 0] | 0 | 0)) : 0) {
    34366. 

  34366.     i3 = i3 + (i5 + -1 << 4) + 16 | 0;
    34367. 

  34367.    } else {
    34368. 

  34368.     i3 = 5192;
    34369. 

  34369.    }
    34370. 

  34370.   } else {
    34371. 

  34371.    i3 = (HEAP32[i4 >> 2] | 0) + (i5 << 4) | 0;
    34372. 

  34372.    i3 = i3 >>> 0 < (HEAP32[i1 + 8 >> 2] | 0) >>> 0 ? i3 : 5192;
    34373. 

  34373.   }
    34374. 

  34374.  } while (0);
    34375. 

  34375.  i5 = i1 + 8 | 0;
    34376. 

  34376.  _luaV_objlen(i1, HEAP32[i5 >> 2] | 0, i3);
    34377. 

  34377.  HEAP32[i5 >> 2] = (HEAP32[i5 >> 2] | 0) + 16;
    34378. 

  34378.  STACKTOP = i2;
    34379. 

  34379.  return;
    34380. 

  34380. }
    34381. 

  34381. function _read_line(i4, i5, i1) {
    34382. 

  34382.  i4 = i4 | 0;
    34383. 

  34383.  i5 = i5 | 0;
    34384. 

  34384.  i1 = i1 | 0;
    34385. 

  34385.  var i2 = 0, i3 = 0, i6 = 0, i7 = 0, i8 = 0;
    34386. 

  34386.  i3 = STACKTOP;
    34387. 

  34387.  STACKTOP = STACKTOP + 1040 | 0;
    34388. 

  34388.  i2 = i3;
    34389. 

  34389.  _luaL_buffinit(i4, i2);
    34390. 

  34390.  i7 = _luaL_prepbuffsize(i2, 1024) | 0;
    34391. 

  34391.  L1 : do {
    34392. 

  34392.   if ((_fgets(i7 | 0, 1024, i5 | 0) | 0) != 0) {
    34393. 

  34393.    i6 = i2 + 8 | 0;
    34394. 

  34394.    while (1) {
    34395. 

  34395.     i8 = _strlen(i7 | 0) | 0;
    34396. 

  34396.     if ((i8 | 0) != 0 ? (HEAP8[i7 + (i8 + -1) | 0] | 0) == 10 : 0) {
    34397. 

  34397.      break;
    34398. 

  34398.     }
    34399. 

  34399.     HEAP32[i6 >> 2] = (HEAP32[i6 >> 2] | 0) + i8;
    34400. 

  34400.     i7 = _luaL_prepbuffsize(i2, 1024) | 0;
    34401. 

  34401.     if ((_fgets(i7 | 0, 1024, i5 | 0) | 0) == 0) {
    34402. 

  34402.      break L1;
    34403. 

  34403.     }
    34404. 

  34404.    }
    34405. 

  34405.    HEAP32[i6 >> 2] = i8 - i1 + (HEAP32[i6 >> 2] | 0);
    34406. 

  34406.    _luaL_pushresult(i2);
    34407. 

  34407.    i8 = 1;
    34408. 

  34408.    STACKTOP = i3;
    34409. 

  34409.    return i8 | 0;
    34410. 

  34410.   }
    34411. 

  34411.  } while (0);
    34412. 

  34412.  _luaL_pushresult(i2);
    34413. 

  34413.  i8 = (_lua_rawlen(i4, -1) | 0) != 0 | 0;
    34414. 

  34414.  STACKTOP = i3;
    34415. 

  34415.  return i8 | 0;
    34416. 

  34416. }
    34417. 

  34417. function _luaL_tolstring(i1, i5, i4) {
    34418. 

  34418.  i1 = i1 | 0;
    34419. 

  34419.  i5 = i5 | 0;
    34420. 

  34420.  i4 = i4 | 0;
    34421. 

  34421.  var i2 = 0, i3 = 0, i6 = 0, i7 = 0;
    34422. 

  34422.  i2 = STACKTOP;
    34423. 

  34423.  STACKTOP = STACKTOP + 16 | 0;
    34424. 

  34424.  i3 = i2;
    34425. 

  34425.  do {
    34426. 

  34426.   if ((_luaL_callmeta(i1, i5, 1384) | 0) == 0) {
    34427. 

  34427.    i6 = _lua_type(i1, i5) | 0;
    34428. 

  34428.    if ((i6 | 0) == 0) {
    34429. 

  34429.     _lua_pushlstring(i1, 1416, 3) | 0;
    34430. 

  34430.     break;
    34431. 

  34431.    } else if ((i6 | 0) == 1) {
    34432. 

  34432.     i6 = (_lua_toboolean(i1, i5) | 0) != 0;
    34433. 

  34433.     _lua_pushstring(i1, i6 ? 1400 : 1408) | 0;
    34434. 

  34434.     break;
    34435. 

  34435.    } else if ((i6 | 0) == 4 | (i6 | 0) == 3) {
    34436. 

  34436.     _lua_pushvalue(i1, i5);
    34437. 

  34437.     break;
    34438. 

  34438.    } else {
    34439. 

  34439.     i7 = _lua_typename(i1, _lua_type(i1, i5) | 0) | 0;
    34440. 

  34440.     i6 = _lua_topointer(i1, i5) | 0;
    34441. 

  34441.     HEAP32[i3 >> 2] = i7;
    34442. 

  34442.     HEAP32[i3 + 4 >> 2] = i6;
    34443. 

  34443.     _lua_pushfstring(i1, 1424, i3) | 0;
    34444. 

  34444.     break;
    34445. 

  34445.    }
    34446. 

  34446.   }
    34447. 

  34447.  } while (0);
    34448. 

  34448.  i7 = _lua_tolstring(i1, -1, i4) | 0;
    34449. 

  34449.  STACKTOP = i2;
    34450. 

  34450.  return i7 | 0;
    34451. 

  34451. }
    34452. 

  34452. function _save(i7, i1) {
    34453. 

  34453.  i7 = i7 | 0;
    34454. 

  34454.  i1 = i1 | 0;
    34455. 

  34455.  var i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i8 = 0;
    34456. 

  34456.  i2 = STACKTOP;
    34457. 

  34457.  i4 = HEAP32[i7 + 60 >> 2] | 0;
    34458. 

  34458.  i3 = i4 + 4 | 0;
    34459. 

  34459.  i8 = HEAP32[i3 >> 2] | 0;
    34460. 

  34460.  i6 = i4 + 8 | 0;
    34461. 

  34461.  i5 = HEAP32[i6 >> 2] | 0;
    34462. 

  34462.  if (!((i8 + 1 | 0) >>> 0 > i5 >>> 0)) {
    34463. 

  34463.   i6 = HEAP32[i4 >> 2] | 0;
    34464. 

  34464.   i7 = i1 & 255;
    34465. 

  34465.   i5 = i8 + 1 | 0;
    34466. 

  34466.   HEAP32[i3 >> 2] = i5;
    34467. 

  34467.   i8 = i6 + i8 | 0;
    34468. 

  34468.   HEAP8[i8] = i7;
    34469. 

  34469.   STACKTOP = i2;
    34470. 

  34470.   return;
    34471. 

  34471.  }
    34472. 

  34472.  if (i5 >>> 0 > 2147483645) {
    34473. 

  34473.   _lexerror(i7, 12368, 0);
    34474. 

  34474.  }
    34475. 

  34475.  i8 = i5 << 1;
    34476. 

  34476.  i7 = HEAP32[i7 + 52 >> 2] | 0;
    34477. 

  34477.  if ((i8 | 0) == -2) {
    34478. 

  34478.   _luaM_toobig(i7);
    34479. 

  34479.  }
    34480. 

  34480.  i7 = _luaM_realloc_(i7, HEAP32[i4 >> 2] | 0, i5, i8) | 0;
    34481. 

  34481.  HEAP32[i4 >> 2] = i7;
    34482. 

  34482.  HEAP32[i6 >> 2] = i8;
    34483. 

  34483.  i8 = HEAP32[i3 >> 2] | 0;
    34484. 

  34484.  i6 = i7;
    34485. 

  34485.  i7 = i1 & 255;
    34486. 

  34486.  i5 = i8 + 1 | 0;
    34487. 

  34487.  HEAP32[i3 >> 2] = i5;
    34488. 

  34488.  i8 = i6 + i8 | 0;
    34489. 

  34489.  HEAP8[i8] = i7;
    34490. 

  34490.  STACKTOP = i2;
    34491. 

  34491.  return;
    34492. 

  34492. }
    34493. 

  34493. function _luaK_patchtohere(i1, i3) {
    34494. 

  34494.  i1 = i1 | 0;
    34495. 

  34495.  i3 = i3 | 0;
    34496. 

  34496.  var i2 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0;
    34497. 

  34497.  i2 = STACKTOP;
    34498. 

  34498.  HEAP32[i1 + 24 >> 2] = HEAP32[i1 + 20 >> 2];
    34499. 

  34499.  i4 = i1 + 28 | 0;
    34500. 

  34500.  if ((i3 | 0) == -1) {
    34501. 

  34501.   STACKTOP = i2;
    34502. 

  34502.   return;
    34503. 

  34503.  }
    34504. 

  34504.  i7 = HEAP32[i4 >> 2] | 0;
    34505. 

  34505.  if ((i7 | 0) == -1) {
    34506. 

  34506.   HEAP32[i4 >> 2] = i3;
    34507. 

  34507.   STACKTOP = i2;
    34508. 

  34508.   return;
    34509. 

  34509.  }
    34510. 

  34510.  i4 = HEAP32[(HEAP32[i1 >> 2] | 0) + 12 >> 2] | 0;
    34511. 

  34511.  while (1) {
    34512. 

  34512.   i6 = i4 + (i7 << 2) | 0;
    34513. 

  34513.   i5 = HEAP32[i6 >> 2] | 0;
    34514. 

  34514.   i8 = (i5 >>> 14) + -131071 | 0;
    34515. 

  34515.   if ((i8 | 0) == -1) {
    34516. 

  34516.    break;
    34517. 

  34517.   }
    34518. 

  34518.   i8 = i7 + 1 + i8 | 0;
    34519. 

  34519.   if ((i8 | 0) == -1) {
    34520. 

  34520.    break;
    34521. 

  34521.   } else {
    34522. 

  34522.    i7 = i8;
    34523. 

  34523.   }
    34524. 

  34524.  }
    34525. 

  34525.  i3 = ~i7 + i3 | 0;
    34526. 

  34526.  if ((((i3 | 0) > -1 ? i3 : 0 - i3 | 0) | 0) > 131071) {
    34527. 

  34527.   _luaX_syntaxerror(HEAP32[i1 + 12 >> 2] | 0, 10624);
    34528. 

  34528.  }
    34529. 

  34529.  HEAP32[i6 >> 2] = (i3 << 14) + 2147467264 | i5 & 16383;
    34530. 

  34530.  STACKTOP = i2;
    34531. 

  34531.  return;
    34532. 

  34532. }
    34533. 

  34533. function _tinsert(i1) {
    34534. 

  34534.  i1 = i1 | 0;
    34535. 

  34535.  var i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0;
    34536. 

  34536.  i2 = STACKTOP;
    34537. 

  34537.  STACKTOP = STACKTOP + 16 | 0;
    34538. 

  34538.  i7 = i2;
    34539. 

  34539.  _luaL_checktype(i1, 1, 5);
    34540. 

  34540.  i4 = _luaL_len(i1, 1) | 0;
    34541. 

  34541.  i3 = i4 + 1 | 0;
    34542. 

  34542.  i6 = _lua_gettop(i1) | 0;
    34543. 

  34543.  if ((i6 | 0) == 3) {
    34544. 

  34544.   i5 = 2;
    34545. 

  34545.  } else if ((i6 | 0) != 2) {
    34546. 

  34546.   i7 = _luaL_error(i1, 8320, i7) | 0;
    34547. 

  34547.   STACKTOP = i2;
    34548. 

  34548.   return i7 | 0;
    34549. 

  34549.  }
    34550. 

  34550.  if ((i5 | 0) == 2) {
    34551. 

  34551.   i5 = _luaL_checkinteger(i1, 2) | 0;
    34552. 

  34552.   if ((i5 | 0) < 1 | (i5 | 0) > (i3 | 0)) {
    34553. 

  34553.    _luaL_argerror(i1, 2, 8256) | 0;
    34554. 

  34554.   }
    34555. 

  34555.   if ((i4 | 0) < (i5 | 0)) {
    34556. 

  34556.    i3 = i5;
    34557. 

  34557.   } else {
    34558. 

  34558.    while (1) {
    34559. 

  34559.     i4 = i3 + -1 | 0;
    34560. 

  34560.     _lua_rawgeti(i1, 1, i4);
    34561. 

  34561.     _lua_rawseti(i1, 1, i3);
    34562. 

  34562.     if ((i4 | 0) > (i5 | 0)) {
    34563. 

  34563.      i3 = i4;
    34564. 

  34564.     } else {
    34565. 

  34565.      i3 = i5;
    34566. 

  34566.      break;
    34567. 

  34567.     }
    34568. 

  34568.    }
    34569. 

  34569.   }
    34570. 

  34570.  }
    34571. 

  34571.  _lua_rawseti(i1, 1, i3);
    34572. 

  34572.  i7 = 0;
    34573. 

  34573.  STACKTOP = i2;
    34574. 

  34574.  return i7 | 0;
    34575. 

  34575. }
    34576. 

  34576. function _lua_iscfunction(i3, i5) {
    34577. 

  34577.  i3 = i3 | 0;
    34578. 

  34578.  i5 = i5 | 0;
    34579. 

  34579.  var i1 = 0, i2 = 0, i4 = 0;
    34580. 

  34580.  i1 = STACKTOP;
    34581. 

  34581.  i4 = HEAP32[i3 + 16 >> 2] | 0;
    34582. 

  34582.  do {
    34583. 

  34583.   if ((i5 | 0) <= 0) {
    34584. 

  34584.    if (!((i5 | 0) < -1000999)) {
    34585. 

  34585.     i2 = (HEAP32[i3 + 8 >> 2] | 0) + (i5 << 4) | 0;
    34586. 

  34586.     break;
    34587. 

  34587.    }
    34588. 

  34588.    if ((i5 | 0) == -1001e3) {
    34589. 

  34589.     i2 = (HEAP32[i3 + 12 >> 2] | 0) + 40 | 0;
    34590. 

  34590.     break;
    34591. 

  34591.    }
    34592. 

  34592.    i3 = -1001e3 - i5 | 0;
    34593. 

  34593.    i4 = HEAP32[i4 >> 2] | 0;
    34594. 

  34594.    if ((HEAP32[i4 + 8 >> 2] | 0) != 22 ? (i2 = HEAP32[i4 >> 2] | 0, (i3 | 0) <= (HEAPU8[i2 + 6 | 0] | 0 | 0)) : 0) {
    34595. 

  34595.     i2 = i2 + (i3 + -1 << 4) + 16 | 0;
    34596. 

  34596.    } else {
    34597. 

  34597.     i2 = 5192;
    34598. 

  34598.    }
    34599. 

  34599.   } else {
    34600. 

  34600.    i2 = (HEAP32[i4 >> 2] | 0) + (i5 << 4) | 0;
    34601. 

  34601.    i2 = i2 >>> 0 < (HEAP32[i3 + 8 >> 2] | 0) >>> 0 ? i2 : 5192;
    34602. 

  34602.   }
    34603. 

  34603.  } while (0);
    34604. 

  34604.  i5 = HEAP32[i2 + 8 >> 2] | 0;
    34605. 

  34605.  STACKTOP = i1;
    34606. 

  34606.  return ((i5 | 0) == 22 | (i5 | 0) == 102) & 1 | 0;
    34607. 

  34607. }
    34608. 

  34608. function _lua_gettable(i1, i5) {
    34609. 

  34609.  i1 = i1 | 0;
    34610. 

  34610.  i5 = i5 | 0;
    34611. 

  34611.  var i2 = 0, i3 = 0, i4 = 0;
    34612. 

  34612.  i2 = STACKTOP;
    34613. 

  34613.  i4 = HEAP32[i1 + 16 >> 2] | 0;
    34614. 

  34614.  do {
    34615. 

  34615.   if ((i5 | 0) <= 0) {
    34616. 

  34616.    if (!((i5 | 0) < -1000999)) {
    34617. 

  34617.     i3 = (HEAP32[i1 + 8 >> 2] | 0) + (i5 << 4) | 0;
    34618. 

  34618.     break;
    34619. 

  34619.    }
    34620. 

  34620.    if ((i5 | 0) == -1001e3) {
    34621. 

  34621.     i3 = (HEAP32[i1 + 12 >> 2] | 0) + 40 | 0;
    34622. 

  34622.     break;
    34623. 

  34623.    }
    34624. 

  34624.    i5 = -1001e3 - i5 | 0;
    34625. 

  34625.    i4 = HEAP32[i4 >> 2] | 0;
    34626. 

  34626.    if ((HEAP32[i4 + 8 >> 2] | 0) != 22 ? (i3 = HEAP32[i4 >> 2] | 0, (i5 | 0) <= (HEAPU8[i3 + 6 | 0] | 0 | 0)) : 0) {
    34627. 

  34627.     i3 = i3 + (i5 + -1 << 4) + 16 | 0;
    34628. 

  34628.    } else {
    34629. 

  34629.     i3 = 5192;
    34630. 

  34630.    }
    34631. 

  34631.   } else {
    34632. 

  34632.    i3 = (HEAP32[i4 >> 2] | 0) + (i5 << 4) | 0;
    34633. 

  34633.    i3 = i3 >>> 0 < (HEAP32[i1 + 8 >> 2] | 0) >>> 0 ? i3 : 5192;
    34634. 

  34634.   }
    34635. 

  34635.  } while (0);
    34636. 

  34636.  i5 = (HEAP32[i1 + 8 >> 2] | 0) + -16 | 0;
    34637. 

  34637.  _luaV_gettable(i1, i3, i5, i5);
    34638. 

  34638.  STACKTOP = i2;
    34639. 

  34639.  return;
    34640. 

  34640. }
    34641. 

  34641. function _luaG_errormsg(i1) {
    34642. 

  34642.  i1 = i1 | 0;
    34643. 

  34643.  var i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0;
    34644. 

  34644.  i2 = HEAP32[i1 + 68 >> 2] | 0;
    34645. 

  34645.  if ((i2 | 0) == 0) {
    34646. 

  34646.   _luaD_throw(i1, 2);
    34647. 

  34647.  }
    34648. 

  34648.  i4 = HEAP32[i1 + 28 >> 2] | 0;
    34649. 

  34649.  i3 = i4 + (i2 + 8) | 0;
    34650. 

  34650.  if ((HEAP32[i3 >> 2] & 15 | 0) != 6) {
    34651. 

  34651.   _luaD_throw(i1, 6);
    34652. 

  34652.  }
    34653. 

  34653.  i5 = i1 + 8 | 0;
    34654. 

  34654.  i6 = HEAP32[i5 >> 2] | 0;
    34655. 

  34655.  i9 = i6 + -16 | 0;
    34656. 

  34656.  i8 = HEAP32[i9 + 4 >> 2] | 0;
    34657. 

  34657.  i7 = i6;
    34658. 

  34658.  HEAP32[i7 >> 2] = HEAP32[i9 >> 2];
    34659. 

  34659.  HEAP32[i7 + 4 >> 2] = i8;
    34660. 

  34660.  HEAP32[i6 + 8 >> 2] = HEAP32[i6 + -8 >> 2];
    34661. 

  34661.  i6 = HEAP32[i5 >> 2] | 0;
    34662. 

  34662.  i7 = i4 + i2 | 0;
    34663. 

  34663.  i2 = HEAP32[i7 + 4 >> 2] | 0;
    34664. 

  34664.  i4 = i6 + -16 | 0;
    34665. 

  34665.  HEAP32[i4 >> 2] = HEAP32[i7 >> 2];
    34666. 

  34666.  HEAP32[i4 + 4 >> 2] = i2;
    34667. 

  34667.  HEAP32[i6 + -8 >> 2] = HEAP32[i3 >> 2];
    34668. 

  34668.  i4 = HEAP32[i5 >> 2] | 0;
    34669. 

  34669.  HEAP32[i5 >> 2] = i4 + 16;
    34670. 

  34670.  _luaD_call(i1, i4 + -16 | 0, 1, 0);
    34671. 

  34671.  _luaD_throw(i1, 2);
    34672. 

  34672. }
    34673. 

  34673. function _luaB_costatus(i1) {
    34674. 

  34674.  i1 = i1 | 0;
    34675. 

  34675.  var i2 = 0, i3 = 0, i4 = 0, i5 = 0;
    34676. 

  34676.  i4 = STACKTOP;
    34677. 

  34677.  STACKTOP = STACKTOP + 112 | 0;
    34678. 

  34678.  i3 = i4;
    34679. 

  34679.  i2 = _lua_tothread(i1, 1) | 0;
    34680. 

  34680.  if ((i2 | 0) == 0) {
    34681. 

  34681.   _luaL_argerror(i1, 1, 10856) | 0;
    34682. 

  34682.  }
    34683. 

  34683.  do {
    34684. 

  34684.   if ((i2 | 0) != (i1 | 0)) {
    34685. 

  34685.    i5 = _lua_status(i2) | 0;
    34686. 

  34686.    if ((i5 | 0) == 0) {
    34687. 

  34687.     if ((_lua_getstack(i2, 0, i3) | 0) > 0) {
    34688. 

  34688.      _lua_pushlstring(i1, 10896, 6) | 0;
    34689. 

  34689.      break;
    34690. 

  34690.     }
    34691. 

  34691.     if ((_lua_gettop(i2) | 0) == 0) {
    34692. 

  34692.      _lua_pushlstring(i1, 10904, 4) | 0;
    34693. 

  34693.      break;
    34694. 

  34694.     } else {
    34695. 

  34695.      _lua_pushlstring(i1, 10880, 9) | 0;
    34696. 

  34696.      break;
    34697. 

  34697.     }
    34698. 

  34698.    } else if ((i5 | 0) == 1) {
    34699. 

  34699.     _lua_pushlstring(i1, 10880, 9) | 0;
    34700. 

  34700.     break;
    34701. 

  34701.    } else {
    34702. 

  34702.     _lua_pushlstring(i1, 10904, 4) | 0;
    34703. 

  34703.     break;
    34704. 

  34704.    }
    34705. 

  34705.   } else {
    34706. 

  34706.    _lua_pushlstring(i1, 10728, 7) | 0;
    34707. 

  34707.   }
    34708. 

  34708.  } while (0);
    34709. 

  34709.  STACKTOP = i4;
    34710. 

  34710.  return 1;
    34711. 

  34711. }
    34712. 

  34712. function _searcher_Lua(i1) {
    34713. 

  34713.  i1 = i1 | 0;
    34714. 

  34714.  var i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0;
    34715. 

  34715.  i2 = STACKTOP;
    34716. 

  34716.  STACKTOP = STACKTOP + 16 | 0;
    34717. 

  34717.  i3 = i2;
    34718. 

  34718.  i4 = _luaL_checklstring(i1, 1, 0) | 0;
    34719. 

  34719.  _lua_getfield(i1, -1001001, 4256);
    34720. 

  34720.  i5 = _lua_tolstring(i1, -1, 0) | 0;
    34721. 

  34721.  if ((i5 | 0) == 0) {
    34722. 

  34722.   HEAP32[i3 >> 2] = 4256;
    34723. 

  34723.   _luaL_error(i1, 5032, i3) | 0;
    34724. 

  34724.  }
    34725. 

  34725.  i4 = _searchpath(i1, i4, i5, 4936, 4848) | 0;
    34726. 

  34726.  if ((i4 | 0) == 0) {
    34727. 

  34727.   i5 = 1;
    34728. 

  34728.   STACKTOP = i2;
    34729. 

  34729.   return i5 | 0;
    34730. 

  34730.  }
    34731. 

  34731.  if ((_luaL_loadfilex(i1, i4, 0) | 0) == 0) {
    34732. 

  34732.   _lua_pushstring(i1, i4) | 0;
    34733. 

  34733.   i5 = 2;
    34734. 

  34734.   STACKTOP = i2;
    34735. 

  34735.   return i5 | 0;
    34736. 

  34736.  } else {
    34737. 

  34737.   i6 = _lua_tolstring(i1, 1, 0) | 0;
    34738. 

  34738.   i5 = _lua_tolstring(i1, -1, 0) | 0;
    34739. 

  34739.   HEAP32[i3 >> 2] = i6;
    34740. 

  34740.   HEAP32[i3 + 4 >> 2] = i4;
    34741. 

  34741.   HEAP32[i3 + 8 >> 2] = i5;
    34742. 

  34742.   i5 = _luaL_error(i1, 4888, i3) | 0;
    34743. 

  34743.   STACKTOP = i2;
    34744. 

  34744.   return i5 | 0;
    34745. 

  34745.  }
    34746. 

  34746.  return 0;
    34747. 

  34747. }
    34748. 

  34748. function _str_sub(i1) {
    34749. 

  34749.  i1 = i1 | 0;
    34750. 

  34750.  var i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0;
    34751. 

  34751.  i3 = STACKTOP;
    34752. 

  34752.  STACKTOP = STACKTOP + 16 | 0;
    34753. 

  34753.  i4 = i3;
    34754. 

  34754.  i2 = _luaL_checklstring(i1, 1, i4) | 0;
    34755. 

  34755.  i5 = _luaL_checkinteger(i1, 2) | 0;
    34756. 

  34756.  i6 = HEAP32[i4 >> 2] | 0;
    34757. 

  34757.  if (!((i5 | 0) > -1)) {
    34758. 

  34758.   if (i6 >>> 0 < (0 - i5 | 0) >>> 0) {
    34759. 

  34759.    i5 = 0;
    34760. 

  34760.   } else {
    34761. 

  34761.    i5 = i5 + 1 + i6 | 0;
    34762. 

  34762.   }
    34763. 

  34763.  }
    34764. 

  34764.  i6 = _luaL_optinteger(i1, 3, -1) | 0;
    34765. 

  34765.  i4 = HEAP32[i4 >> 2] | 0;
    34766. 

  34766.  if (!((i6 | 0) > -1)) {
    34767. 

  34767.   if (i4 >>> 0 < (0 - i6 | 0) >>> 0) {
    34768. 

  34768.    i6 = 0;
    34769. 

  34769.   } else {
    34770. 

  34770.    i6 = i6 + 1 + i4 | 0;
    34771. 

  34771.   }
    34772. 

  34772.  }
    34773. 

  34773.  i5 = (i5 | 0) == 0 ? 1 : i5;
    34774. 

  34774.  i4 = i6 >>> 0 > i4 >>> 0 ? i4 : i6;
    34775. 

  34775.  if (i5 >>> 0 > i4 >>> 0) {
    34776. 

  34776.   _lua_pushlstring(i1, 7040, 0) | 0;
    34777. 

  34777.   STACKTOP = i3;
    34778. 

  34778.   return 1;
    34779. 

  34779.  } else {
    34780. 

  34780.   _lua_pushlstring(i1, i2 + (i5 + -1) | 0, 1 - i5 + i4 | 0) | 0;
    34781. 

  34781.   STACKTOP = i3;
    34782. 

  34782.   return 1;
    34783. 

  34783.  }
    34784. 

  34784.  return 0;
    34785. 

  34785. }
    34786. 

  34786. function _searcher_C(i1) {
    34787. 

  34787.  i1 = i1 | 0;
    34788. 

  34788.  var i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0;
    34789. 

  34789.  i2 = STACKTOP;
    34790. 

  34790.  STACKTOP = STACKTOP + 16 | 0;
    34791. 

  34791.  i3 = i2;
    34792. 

  34792.  i4 = _luaL_checklstring(i1, 1, 0) | 0;
    34793. 

  34793.  _lua_getfield(i1, -1001001, 4440);
    34794. 

  34794.  i5 = _lua_tolstring(i1, -1, 0) | 0;
    34795. 

  34795.  if ((i5 | 0) == 0) {
    34796. 

  34796.   HEAP32[i3 >> 2] = 4440;
    34797. 

  34797.   _luaL_error(i1, 5032, i3) | 0;
    34798. 

  34798.  }
    34799. 

  34799.  i5 = _searchpath(i1, i4, i5, 4936, 4848) | 0;
    34800. 

  34800.  if ((i5 | 0) == 0) {
    34801. 

  34801.   i5 = 1;
    34802. 

  34802.   STACKTOP = i2;
    34803. 

  34803.   return i5 | 0;
    34804. 

  34804.  }
    34805. 

  34805.  if ((_loadfunc(i1, i5, i4) | 0) == 0) {
    34806. 

  34806.   _lua_pushstring(i1, i5) | 0;
    34807. 

  34807.   i5 = 2;
    34808. 

  34808.   STACKTOP = i2;
    34809. 

  34809.   return i5 | 0;
    34810. 

  34810.  } else {
    34811. 

  34811.   i6 = _lua_tolstring(i1, 1, 0) | 0;
    34812. 

  34812.   i4 = _lua_tolstring(i1, -1, 0) | 0;
    34813. 

  34813.   HEAP32[i3 >> 2] = i6;
    34814. 

  34814.   HEAP32[i3 + 4 >> 2] = i5;
    34815. 

  34815.   HEAP32[i3 + 8 >> 2] = i4;
    34816. 

  34816.   i5 = _luaL_error(i1, 4888, i3) | 0;
    34817. 

  34817.   STACKTOP = i2;
    34818. 

  34818.   return i5 | 0;
    34819. 

  34819.  }
    34820. 

  34820.  return 0;
    34821. 

  34821. }
    34822. 

  34822. function _io_open(i1) {
    34823. 

  34823.  i1 = i1 | 0;
    34824. 

  34824.  var i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0;
    34825. 

  34825.  i5 = STACKTOP;
    34826. 

  34826.  i2 = _luaL_checklstring(i1, 1, 0) | 0;
    34827. 

  34827.  i3 = _luaL_optlstring(i1, 2, 3480, 0) | 0;
    34828. 

  34828.  i4 = _lua_newuserdata(i1, 8) | 0;
    34829. 

  34829.  i6 = i4 + 4 | 0;
    34830. 

  34830.  HEAP32[i6 >> 2] = 0;
    34831. 

  34831.  _luaL_setmetatable(i1, 2832);
    34832. 

  34832.  HEAP32[i4 >> 2] = 0;
    34833. 

  34833.  HEAP32[i6 >> 2] = 156;
    34834. 

  34834.  i6 = HEAP8[i3] | 0;
    34835. 

  34835.  if (!((!(i6 << 24 >> 24 == 0) ? (i7 = i3 + 1 | 0, (_memchr(3552, i6 << 24 >> 24, 4) | 0) != 0) : 0) ? (i6 = (HEAP8[i7] | 0) == 43 ? i3 + 2 | 0 : i7, (HEAP8[(HEAP8[i6] | 0) == 98 ? i6 + 1 | 0 : i6] | 0) == 0) : 0)) {
    34836. 

  34836.   _luaL_argerror(i1, 2, 3560) | 0;
    34837. 

  34837.  }
    34838. 

  34838.  i7 = _fopen(i2 | 0, i3 | 0) | 0;
    34839. 

  34839.  HEAP32[i4 >> 2] = i7;
    34840. 

  34840.  if ((i7 | 0) != 0) {
    34841. 

  34841.   i7 = 1;
    34842. 

  34842.   STACKTOP = i5;
    34843. 

  34843.   return i7 | 0;
    34844. 

  34844.  }
    34845. 

  34845.  i7 = _luaL_fileresult(i1, 0, i2) | 0;
    34846. 

  34846.  STACKTOP = i5;
    34847. 

  34847.  return i7 | 0;
    34848. 

  34848. }
    34849. 

  34849. function _unpack(i2) {
    34850. 

  34850.  i2 = i2 | 0;
    34851. 

  34851.  var i1 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0;
    34852. 

  34852.  i1 = STACKTOP;
    34853. 

  34853.  STACKTOP = STACKTOP + 16 | 0;
    34854. 

  34854.  i6 = i1;
    34855. 

  34855.  _luaL_checktype(i2, 1, 5);
    34856. 

  34856.  i5 = _luaL_optinteger(i2, 2, 1) | 0;
    34857. 

  34857.  if ((_lua_type(i2, 3) | 0) < 1) {
    34858. 

  34858.   i3 = _luaL_len(i2, 1) | 0;
    34859. 

  34859.  } else {
    34860. 

  34860.   i3 = _luaL_checkinteger(i2, 3) | 0;
    34861. 

  34861.  }
    34862. 

  34862.  if ((i5 | 0) > (i3 | 0)) {
    34863. 

  34863.   i6 = 0;
    34864. 

  34864.   STACKTOP = i1;
    34865. 

  34865.   return i6 | 0;
    34866. 

  34866.  }
    34867. 

  34867.  i7 = i3 - i5 | 0;
    34868. 

  34868.  i4 = i7 + 1 | 0;
    34869. 

  34869.  if ((i7 | 0) >= 0 ? (_lua_checkstack(i2, i4) | 0) != 0 : 0) {
    34870. 

  34870.   _lua_rawgeti(i2, 1, i5);
    34871. 

  34871.   if ((i5 | 0) >= (i3 | 0)) {
    34872. 

  34872.    i7 = i4;
    34873. 

  34873.    STACKTOP = i1;
    34874. 

  34874.    return i7 | 0;
    34875. 

  34875.   }
    34876. 

  34876.   do {
    34877. 

  34877.    i5 = i5 + 1 | 0;
    34878. 

  34878.    _lua_rawgeti(i2, 1, i5);
    34879. 

  34879.   } while ((i5 | 0) != (i3 | 0));
    34880. 

  34880.   STACKTOP = i1;
    34881. 

  34881.   return i4 | 0;
    34882. 

  34882.  }
    34883. 

  34883.  i7 = _luaL_error(i2, 8280, i6) | 0;
    34884. 

  34884.  STACKTOP = i1;
    34885. 

  34885.  return i7 | 0;
    34886. 

  34886. }
    34887. 

  34887. function _luaF_getlocalname(i4, i6, i2) {
    34888. 

  34888.  i4 = i4 | 0;
    34889. 

  34889.  i6 = i6 | 0;
    34890. 

  34890.  i2 = i2 | 0;
    34891. 

  34891.  var i1 = 0, i3 = 0, i5 = 0;
    34892. 

  34892.  i1 = STACKTOP;
    34893. 

  34893.  i3 = HEAP32[i4 + 60 >> 2] | 0;
    34894. 

  34894.  if ((i3 | 0) <= 0) {
    34895. 

  34895.   i6 = 0;
    34896. 

  34896.   STACKTOP = i1;
    34897. 

  34897.   return i6 | 0;
    34898. 

  34898.  }
    34899. 

  34899.  i4 = HEAP32[i4 + 24 >> 2] | 0;
    34900. 

  34900.  i5 = 0;
    34901. 

  34901.  while (1) {
    34902. 

  34902.   if ((HEAP32[i4 + (i5 * 12 | 0) + 4 >> 2] | 0) > (i2 | 0)) {
    34903. 

  34903.    i3 = 0;
    34904. 

  34904.    i2 = 8;
    34905. 

  34905.    break;
    34906. 

  34906.   }
    34907. 

  34907.   if ((HEAP32[i4 + (i5 * 12 | 0) + 8 >> 2] | 0) > (i2 | 0)) {
    34908. 

  34908.    i6 = i6 + -1 | 0;
    34909. 

  34909.    if ((i6 | 0) == 0) {
    34910. 

  34910.     i2 = 6;
    34911. 

  34911.     break;
    34912. 

  34912.    }
    34913. 

  34913.   }
    34914. 

  34914.   i5 = i5 + 1 | 0;
    34915. 

  34915.   if ((i5 | 0) >= (i3 | 0)) {
    34916. 

  34916.    i3 = 0;
    34917. 

  34917.    i2 = 8;
    34918. 

  34918.    break;
    34919. 

  34919.   }
    34920. 

  34920.  }
    34921. 

  34921.  if ((i2 | 0) == 6) {
    34922. 

  34922.   i6 = (HEAP32[i4 + (i5 * 12 | 0) >> 2] | 0) + 16 | 0;
    34923. 

  34923.   STACKTOP = i1;
    34924. 

  34924.   return i6 | 0;
    34925. 

  34925.  } else if ((i2 | 0) == 8) {
    34926. 

  34926.   STACKTOP = i1;
    34927. 

  34927.   return i3 | 0;
    34928. 

  34928.  }
    34929. 

  34929.  return 0;
    34930. 

  34930. }
    34931. 

  34931. function _luaK_concat(i1, i4, i3) {
    34932. 

  34932.  i1 = i1 | 0;
    34933. 

  34933.  i4 = i4 | 0;
    34934. 

  34934.  i3 = i3 | 0;
    34935. 

  34935.  var i2 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0;
    34936. 

  34936.  i2 = STACKTOP;
    34937. 

  34937.  if ((i3 | 0) == -1) {
    34938. 

  34938.   STACKTOP = i2;
    34939. 

  34939.   return;
    34940. 

  34940.  }
    34941. 

  34941.  i7 = HEAP32[i4 >> 2] | 0;
    34942. 

  34942.  if ((i7 | 0) == -1) {
    34943. 

  34943.   HEAP32[i4 >> 2] = i3;
    34944. 

  34944.   STACKTOP = i2;
    34945. 

  34945.   return;
    34946. 

  34946.  }
    34947. 

  34947.  i4 = HEAP32[(HEAP32[i1 >> 2] | 0) + 12 >> 2] | 0;
    34948. 

  34948.  while (1) {
    34949. 

  34949.   i6 = i4 + (i7 << 2) | 0;
    34950. 

  34950.   i5 = HEAP32[i6 >> 2] | 0;
    34951. 

  34951.   i8 = (i5 >>> 14) + -131071 | 0;
    34952. 

  34952.   if ((i8 | 0) == -1) {
    34953. 

  34953.    break;
    34954. 

  34954.   }
    34955. 

  34955.   i8 = i7 + 1 + i8 | 0;
    34956. 

  34956.   if ((i8 | 0) == -1) {
    34957. 

  34957.    break;
    34958. 

  34958.   } else {
    34959. 

  34959.    i7 = i8;
    34960. 

  34960.   }
    34961. 

  34961.  }
    34962. 

  34962.  i3 = ~i7 + i3 | 0;
    34963. 

  34963.  if ((((i3 | 0) > -1 ? i3 : 0 - i3 | 0) | 0) > 131071) {
    34964. 

  34964.   _luaX_syntaxerror(HEAP32[i1 + 12 >> 2] | 0, 10624);
    34965. 

  34965.  }
    34966. 

  34966.  HEAP32[i6 >> 2] = i5 & 16383 | (i3 << 14) + 2147467264;
    34967. 

  34967.  STACKTOP = i2;
    34968. 

  34968.  return;
    34969. 

  34969. }
    34970. 

  34970. function _scalbn(d3, i2) {
    34971. 

  34971.  d3 = +d3;
    34972. 

  34972.  i2 = i2 | 0;
    34973. 

  34973.  var i1 = 0, i4 = 0;
    34974. 

  34974.  i1 = STACKTOP;
    34975. 

  34975.  if ((i2 | 0) > 1023) {
    34976. 

  34976.   d3 = d3 * 8.98846567431158e+307;
    34977. 

  34977.   i4 = i2 + -1023 | 0;
    34978. 

  34978.   if ((i4 | 0) > 1023) {
    34979. 

  34979.    i2 = i2 + -2046 | 0;
    34980. 

  34980.    i2 = (i2 | 0) > 1023 ? 1023 : i2;
    34981. 

  34981.    d3 = d3 * 8.98846567431158e+307;
    34982. 

  34982.   } else {
    34983. 

  34983.    i2 = i4;
    34984. 

  34984.   }
    34985. 

  34985.  } else {
    34986. 

  34986.   if ((i2 | 0) < -1022) {
    34987. 

  34987.    d3 = d3 * 2.2250738585072014e-308;
    34988. 

  34988.    i4 = i2 + 1022 | 0;
    34989. 

  34989.    if ((i4 | 0) < -1022) {
    34990. 

  34990.     i2 = i2 + 2044 | 0;
    34991. 

  34991.     i2 = (i2 | 0) < -1022 ? -1022 : i2;
    34992. 

  34992.     d3 = d3 * 2.2250738585072014e-308;
    34993. 

  34993.    } else {
    34994. 

  34994.     i2 = i4;
    34995. 

  34995.    }
    34996. 

  34996.   }
    34997. 

  34997.  }
    34998. 

  34998.  i2 = _bitshift64Shl(i2 + 1023 | 0, 0, 52) | 0;
    34999. 

  34999.  i4 = tempRet0;
    35000. 

  35000.  HEAP32[tempDoublePtr >> 2] = i2;
    35001. 

  35001.  HEAP32[tempDoublePtr + 4 >> 2] = i4;
    35002. 

  35002.  d3 = d3 * +HEAPF64[tempDoublePtr >> 3];
    35003. 

  35003.  STACKTOP = i1;
    35004. 

  35004.  return +d3;
    35005. 

  35005. }
    35006. 

  35006. function _luaK_numberK(i1, d6) {
    35007. 

  35007.  i1 = i1 | 0;
    35008. 

  35008.  d6 = +d6;
    35009. 

  35009.  var i2 = 0, i3 = 0, i4 = 0, i5 = 0, i7 = 0, i8 = 0;
    35010. 

  35010.  i2 = STACKTOP;
    35011. 

  35011.  STACKTOP = STACKTOP + 32 | 0;
    35012. 

  35012.  i4 = i2 + 16 | 0;
    35013. 

  35013.  i3 = i2;
    35014. 

  35014.  HEAPF64[i4 >> 3] = d6;
    35015. 

  35015.  i5 = HEAP32[(HEAP32[i1 + 12 >> 2] | 0) + 52 >> 2] | 0;
    35016. 

  35016.  HEAPF64[i3 >> 3] = d6;
    35017. 

  35017.  HEAP32[i3 + 8 >> 2] = 3;
    35018. 

  35018.  if (d6 != d6 | 0.0 != 0.0 | d6 == 0.0) {
    35019. 

  35019.   i7 = i5 + 8 | 0;
    35020. 

  35020.   i8 = HEAP32[i7 >> 2] | 0;
    35021. 

  35021.   HEAP32[i7 >> 2] = i8 + 16;
    35022. 

  35022.   i5 = _luaS_newlstr(i5, i4, 8) | 0;
    35023. 

  35023.   HEAP32[i8 >> 2] = i5;
    35024. 

  35024.   HEAP32[i8 + 8 >> 2] = HEAPU8[i5 + 4 | 0] | 0 | 64;
    35025. 

  35025.   i5 = _addk(i1, (HEAP32[i7 >> 2] | 0) + -16 | 0, i3) | 0;
    35026. 

  35026.   HEAP32[i7 >> 2] = (HEAP32[i7 >> 2] | 0) + -16;
    35027. 

  35027.   STACKTOP = i2;
    35028. 

  35028.   return i5 | 0;
    35029. 

  35029.  } else {
    35030. 

  35030.   i8 = _addk(i1, i3, i3) | 0;
    35031. 

  35031.   STACKTOP = i2;
    35032. 

  35032.   return i8 | 0;
    35033. 

  35033.  }
    35034. 

  35034.  return 0;
    35035. 

  35035. }
    35036. 

  35036. function _auxresume(i2, i3, i4) {
    35037. 

  35037.  i2 = i2 | 0;
    35038. 

  35038.  i3 = i3 | 0;
    35039. 

  35039.  i4 = i4 | 0;
    35040. 

  35040.  var i1 = 0;
    35041. 

  35041.  i1 = STACKTOP;
    35042. 

  35042.  do {
    35043. 

  35043.   if ((_lua_checkstack(i3, i4) | 0) != 0) {
    35044. 

  35044.    if ((_lua_status(i3) | 0) == 0 ? (_lua_gettop(i3) | 0) == 0 : 0) {
    35045. 

  35045.     _lua_pushlstring(i2, 10792, 28) | 0;
    35046. 

  35046.     i4 = -1;
    35047. 

  35047.     break;
    35048. 

  35048.    }
    35049. 

  35049.    _lua_xmove(i2, i3, i4);
    35050. 

  35050.    if (!((_lua_resume(i3, i2, i4) | 0) >>> 0 < 2)) {
    35051. 

  35051.     _lua_xmove(i3, i2, 1);
    35052. 

  35052.     i4 = -1;
    35053. 

  35053.     break;
    35054. 

  35054.    }
    35055. 

  35055.    i4 = _lua_gettop(i3) | 0;
    35056. 

  35056.    if ((_lua_checkstack(i2, i4 + 1 | 0) | 0) == 0) {
    35057. 

  35057.     _lua_settop(i3, ~i4);
    35058. 

  35058.     _lua_pushlstring(i2, 10824, 26) | 0;
    35059. 

  35059.     i4 = -1;
    35060. 

  35060.     break;
    35061. 

  35061.    } else {
    35062. 

  35062.     _lua_xmove(i3, i2, i4);
    35063. 

  35063.     break;
    35064. 

  35064.    }
    35065. 

  35065.   } else {
    35066. 

  35066.    _lua_pushlstring(i2, 10760, 28) | 0;
    35067. 

  35067.    i4 = -1;
    35068. 

  35068.   }
    35069. 

  35069.  } while (0);
    35070. 

  35070.  STACKTOP = i1;
    35071. 

  35071.  return i4 | 0;
    35072. 

  35072. }
    35073. 

  35073. function _luaX_setinput(i2, i1, i4, i3, i5) {
    35074. 

  35074.  i2 = i2 | 0;
    35075. 

  35075.  i1 = i1 | 0;
    35076. 

  35076.  i4 = i4 | 0;
    35077. 

  35077.  i3 = i3 | 0;
    35078. 

  35078.  i5 = i5 | 0;
    35079. 

  35079.  var i6 = 0, i7 = 0;
    35080. 

  35080.  i6 = STACKTOP;
    35081. 

  35081.  HEAP8[i1 + 76 | 0] = 46;
    35082. 

  35082.  i7 = i1 + 52 | 0;
    35083. 

  35083.  HEAP32[i7 >> 2] = i2;
    35084. 

  35084.  HEAP32[i1 >> 2] = i5;
    35085. 

  35085.  HEAP32[i1 + 32 >> 2] = 286;
    35086. 

  35086.  HEAP32[i1 + 56 >> 2] = i4;
    35087. 

  35087.  HEAP32[i1 + 48 >> 2] = 0;
    35088. 

  35088.  HEAP32[i1 + 4 >> 2] = 1;
    35089. 

  35089.  HEAP32[i1 + 8 >> 2] = 1;
    35090. 

  35090.  HEAP32[i1 + 68 >> 2] = i3;
    35091. 

  35091.  i5 = _luaS_new(i2, 12264) | 0;
    35092. 

  35092.  HEAP32[i1 + 72 >> 2] = i5;
    35093. 

  35093.  i5 = i5 + 5 | 0;
    35094. 

  35094.  HEAP8[i5] = HEAPU8[i5] | 0 | 32;
    35095. 

  35095.  i5 = i1 + 60 | 0;
    35096. 

  35096.  i4 = HEAP32[i5 >> 2] | 0;
    35097. 

  35097.  i4 = _luaM_realloc_(HEAP32[i7 >> 2] | 0, HEAP32[i4 >> 2] | 0, HEAP32[i4 + 8 >> 2] | 0, 32) | 0;
    35098. 

  35098.  HEAP32[HEAP32[i5 >> 2] >> 2] = i4;
    35099. 

  35099.  HEAP32[(HEAP32[i5 >> 2] | 0) + 8 >> 2] = 32;
    35100. 

  35100.  STACKTOP = i6;
    35101. 

  35101.  return;
    35102. 

  35102. }
    35103. 

  35103. function _luaL_optlstring(i2, i4, i6, i5) {
    35104. 

  35104.  i2 = i2 | 0;
    35105. 

  35105.  i4 = i4 | 0;
    35106. 

  35106.  i6 = i6 | 0;
    35107. 

  35107.  i5 = i5 | 0;
    35108. 

  35108.  var i1 = 0, i3 = 0;
    35109. 

  35109.  i1 = STACKTOP;
    35110. 

  35110.  STACKTOP = STACKTOP + 16 | 0;
    35111. 

  35111.  i3 = i1;
    35112. 

  35112.  if ((_lua_type(i2, i4) | 0) >= 1) {
    35113. 

  35113.   i5 = _lua_tolstring(i2, i4, i5) | 0;
    35114. 

  35114.   if ((i5 | 0) != 0) {
    35115. 

  35115.    i6 = i5;
    35116. 

  35116.    STACKTOP = i1;
    35117. 

  35117.    return i6 | 0;
    35118. 

  35118.   }
    35119. 

  35119.   i5 = _lua_typename(i2, 4) | 0;
    35120. 

  35120.   i6 = _lua_typename(i2, _lua_type(i2, i4) | 0) | 0;
    35121. 

  35121.   HEAP32[i3 >> 2] = i5;
    35122. 

  35122.   HEAP32[i3 + 4 >> 2] = i6;
    35123. 

  35123.   _luaL_argerror(i2, i4, _lua_pushfstring(i2, 1744, i3) | 0) | 0;
    35124. 

  35124.   i6 = 0;
    35125. 

  35125.   STACKTOP = i1;
    35126. 

  35126.   return i6 | 0;
    35127. 

  35127.  }
    35128. 

  35128.  if ((i5 | 0) == 0) {
    35129. 

  35129.   STACKTOP = i1;
    35130. 

  35130.   return i6 | 0;
    35131. 

  35131.  }
    35132. 

  35132.  if ((i6 | 0) == 0) {
    35133. 

  35133.   i2 = 0;
    35134. 

  35134.  } else {
    35135. 

  35135.   i2 = _strlen(i6 | 0) | 0;
    35136. 

  35136.  }
    35137. 

  35137.  HEAP32[i5 >> 2] = i2;
    35138. 

  35138.  STACKTOP = i1;
    35139. 

  35139.  return i6 | 0;
    35140. 

  35140. }
    35141. 

  35141. function _lua_xmove(i3, i4, i1) {
    35142. 

  35142.  i3 = i3 | 0;
    35143. 

  35143.  i4 = i4 | 0;
    35144. 

  35144.  i1 = i1 | 0;
    35145. 

  35145.  var i2 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0;
    35146. 

  35146.  i2 = STACKTOP;
    35147. 

  35147.  if ((i3 | 0) == (i4 | 0)) {
    35148. 

  35148.   STACKTOP = i2;
    35149. 

  35149.   return;
    35150. 

  35150.  }
    35151. 

  35151.  i3 = i3 + 8 | 0;
    35152. 

  35152.  i5 = (HEAP32[i3 >> 2] | 0) + (0 - i1 << 4) | 0;
    35153. 

  35153.  HEAP32[i3 >> 2] = i5;
    35154. 

  35154.  if ((i1 | 0) <= 0) {
    35155. 

  35155.   STACKTOP = i2;
    35156. 

  35156.   return;
    35157. 

  35157.  }
    35158. 

  35158.  i4 = i4 + 8 | 0;
    35159. 

  35159.  i6 = 0;
    35160. 

  35160.  while (1) {
    35161. 

  35161.   i7 = HEAP32[i4 >> 2] | 0;
    35162. 

  35162.   HEAP32[i4 >> 2] = i7 + 16;
    35163. 

  35163.   i10 = i5 + (i6 << 4) | 0;
    35164. 

  35164.   i9 = HEAP32[i10 + 4 >> 2] | 0;
    35165. 

  35165.   i8 = i7;
    35166. 

  35166.   HEAP32[i8 >> 2] = HEAP32[i10 >> 2];
    35167. 

  35167.   HEAP32[i8 + 4 >> 2] = i9;
    35168. 

  35168.   HEAP32[i7 + 8 >> 2] = HEAP32[i5 + (i6 << 4) + 8 >> 2];
    35169. 

  35169.   i6 = i6 + 1 | 0;
    35170. 

  35170.   if ((i6 | 0) == (i1 | 0)) {
    35171. 

  35171.    break;
    35172. 

  35172.   }
    35173. 

  35173.   i5 = HEAP32[i3 >> 2] | 0;
    35174. 

  35174.  }
    35175. 

  35175.  STACKTOP = i2;
    35176. 

  35176.  return;
    35177. 

  35177. }
    35178. 

  35178. function _luaM_realloc_(i7, i10, i3, i2) {
    35179. 

  35179.  i7 = i7 | 0;
    35180. 

  35180.  i10 = i10 | 0;
    35181. 

  35181.  i3 = i3 | 0;
    35182. 

  35182.  i2 = i2 | 0;
    35183. 

  35183.  var i1 = 0, i4 = 0, i5 = 0, i6 = 0, i8 = 0, i9 = 0;
    35184. 

  35184.  i5 = STACKTOP;
    35185. 

  35185.  i6 = HEAP32[i7 + 12 >> 2] | 0;
    35186. 

  35186.  i4 = (i10 | 0) != 0;
    35187. 

  35187.  i9 = i6 + 4 | 0;
    35188. 

  35188.  i8 = FUNCTION_TABLE_iiiii[HEAP32[i6 >> 2] & 3](HEAP32[i9 >> 2] | 0, i10, i3, i2) | 0;
    35189. 

  35189.  if (!((i8 | 0) != 0 | (i2 | 0) == 0)) {
    35190. 

  35190.   if ((HEAP8[i6 + 63 | 0] | 0) == 0) {
    35191. 

  35191.    _luaD_throw(i7, 4);
    35192. 

  35192.   }
    35193. 

  35193.   _luaC_fullgc(i7, 1);
    35194. 

  35194.   i8 = FUNCTION_TABLE_iiiii[HEAP32[i6 >> 2] & 3](HEAP32[i9 >> 2] | 0, i10, i3, i2) | 0;
    35195. 

  35195.   if ((i8 | 0) == 0) {
    35196. 

  35196.    _luaD_throw(i7, 4);
    35197. 

  35197.   } else {
    35198. 

  35198.    i1 = i8;
    35199. 

  35199.   }
    35200. 

  35200.  } else {
    35201. 

  35201.   i1 = i8;
    35202. 

  35202.  }
    35203. 

  35203.  i6 = i6 + 12 | 0;
    35204. 

  35204.  HEAP32[i6 >> 2] = (i4 ? 0 - i3 | 0 : 0) + i2 + (HEAP32[i6 >> 2] | 0);
    35205. 

  35205.  STACKTOP = i5;
    35206. 

  35206.  return i1 | 0;
    35207. 

  35207. }
    35208. 

  35208. function _realloc(i2, i3) {
    35209. 

  35209.  i2 = i2 | 0;
    35210. 

  35210.  i3 = i3 | 0;
    35211. 

  35211.  var i1 = 0, i4 = 0, i5 = 0;
    35212. 

  35212.  i1 = STACKTOP;
    35213. 

  35213.  do {
    35214. 

  35214.   if ((i2 | 0) != 0) {
    35215. 

  35215.    if (i3 >>> 0 > 4294967231) {
    35216. 

  35216.     HEAP32[(___errno_location() | 0) >> 2] = 12;
    35217. 

  35217.     i4 = 0;
    35218. 

  35218.     break;
    35219. 

  35219.    }
    35220. 

  35220.    if (i3 >>> 0 < 11) {
    35221. 

  35221.     i4 = 16;
    35222. 

  35222.    } else {
    35223. 

  35223.     i4 = i3 + 11 & -8;
    35224. 

  35224.    }
    35225. 

  35225.    i4 = _try_realloc_chunk(i2 + -8 | 0, i4) | 0;
    35226. 

  35226.    if ((i4 | 0) != 0) {
    35227. 

  35227.     i4 = i4 + 8 | 0;
    35228. 

  35228.     break;
    35229. 

  35229.    }
    35230. 

  35230.    i4 = _malloc(i3) | 0;
    35231. 

  35231.    if ((i4 | 0) == 0) {
    35232. 

  35232.     i4 = 0;
    35233. 

  35233.    } else {
    35234. 

  35234.     i5 = HEAP32[i2 + -4 >> 2] | 0;
    35235. 

  35235.     i5 = (i5 & -8) - ((i5 & 3 | 0) == 0 ? 8 : 4) | 0;
    35236. 

  35236.     _memcpy(i4 | 0, i2 | 0, (i5 >>> 0 < i3 >>> 0 ? i5 : i3) | 0) | 0;
    35237. 

  35237.     _free(i2);
    35238. 

  35238.    }
    35239. 

  35239.   } else {
    35240. 

  35240.    i4 = _malloc(i3) | 0;
    35241. 

  35241.   }
    35242. 

  35242.  } while (0);
    35243. 

  35243.  STACKTOP = i1;
    35244. 

  35244.  return i4 | 0;
    35245. 

  35245. }
    35246. 

  35246. function _lua_setlocal(i3, i5, i4) {
    35247. 

  35247.  i3 = i3 | 0;
    35248. 

  35248.  i5 = i5 | 0;
    35249. 

  35249.  i4 = i4 | 0;
    35250. 

  35250.  var i1 = 0, i2 = 0, i6 = 0, i7 = 0, i8 = 0;
    35251. 

  35251.  i1 = STACKTOP;
    35252. 

  35252.  STACKTOP = STACKTOP + 16 | 0;
    35253. 

  35253.  i2 = i1;
    35254. 

  35254.  HEAP32[i2 >> 2] = 0;
    35255. 

  35255.  i4 = _findlocal(i3, HEAP32[i5 + 96 >> 2] | 0, i4, i2) | 0;
    35256. 

  35256.  i3 = i3 + 8 | 0;
    35257. 

  35257.  if ((i4 | 0) == 0) {
    35258. 

  35258.   i5 = HEAP32[i3 >> 2] | 0;
    35259. 

  35259.   i5 = i5 + -16 | 0;
    35260. 

  35260.   HEAP32[i3 >> 2] = i5;
    35261. 

  35261.   STACKTOP = i1;
    35262. 

  35262.   return i4 | 0;
    35263. 

  35263.  }
    35264. 

  35264.  i6 = HEAP32[i3 >> 2] | 0;
    35265. 

  35265.  i5 = HEAP32[i2 >> 2] | 0;
    35266. 

  35266.  i8 = i6 + -16 | 0;
    35267. 

  35267.  i7 = HEAP32[i8 + 4 >> 2] | 0;
    35268. 

  35268.  i2 = i5;
    35269. 

  35269.  HEAP32[i2 >> 2] = HEAP32[i8 >> 2];
    35270. 

  35270.  HEAP32[i2 + 4 >> 2] = i7;
    35271. 

  35271.  HEAP32[i5 + 8 >> 2] = HEAP32[i6 + -8 >> 2];
    35272. 

  35272.  i5 = HEAP32[i3 >> 2] | 0;
    35273. 

  35273.  i5 = i5 + -16 | 0;
    35274. 

  35274.  HEAP32[i3 >> 2] = i5;
    35275. 

  35275.  STACKTOP = i1;
    35276. 

  35276.  return i4 | 0;
    35277. 

  35277. }
    35278. 

  35278. function ___remdi3(i1, i4, i5, i6) {
    35279. 

  35279.  i1 = i1 | 0;
    35280. 

  35280.  i4 = i4 | 0;
    35281. 

  35281.  i5 = i5 | 0;
    35282. 

  35282.  i6 = i6 | 0;
    35283. 

  35283.  var i2 = 0, i3 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0;
    35284. 

  35284.  i3 = STACKTOP;
    35285. 

  35285.  STACKTOP = STACKTOP + 8 | 0;
    35286. 

  35286.  i2 = i3 | 0;
    35287. 

  35287.  i7 = i4 >> 31 | ((i4 | 0) < 0 ? -1 : 0) << 1;
    35288. 

  35288.  i8 = ((i4 | 0) < 0 ? -1 : 0) >> 31 | ((i4 | 0) < 0 ? -1 : 0) << 1;
    35289. 

  35289.  i9 = i6 >> 31 | ((i6 | 0) < 0 ? -1 : 0) << 1;
    35290. 

  35290.  i10 = ((i6 | 0) < 0 ? -1 : 0) >> 31 | ((i6 | 0) < 0 ? -1 : 0) << 1;
    35291. 

  35291.  i1 = _i64Subtract(i7 ^ i1, i8 ^ i4, i7, i8) | 0;
    35292. 

  35292.  i4 = tempRet0;
    35293. 

  35293.  ___udivmoddi4(i1, i4, _i64Subtract(i9 ^ i5, i10 ^ i6, i9, i10) | 0, tempRet0, i2) | 0;
    35294. 

  35294.  i9 = _i64Subtract(HEAP32[i2 >> 2] ^ i7, HEAP32[i2 + 4 >> 2] ^ i8, i7, i8) | 0;
    35295. 

  35295.  i8 = tempRet0;
    35296. 

  35296.  STACKTOP = i3;
    35297. 

  35297.  return (tempRet0 = i8, i9) | 0;
    35298. 

  35298. }
    35299. 

  35299. function _luaC_barrierproto_(i3, i4, i2) {
    35300. 

  35300.  i3 = i3 | 0;
    35301. 

  35301.  i4 = i4 | 0;
    35302. 

  35302.  i2 = i2 | 0;
    35303. 

  35303.  var i1 = 0, i5 = 0;
    35304. 

  35304.  i1 = STACKTOP;
    35305. 

  35305.  if ((HEAP32[i4 + 32 >> 2] | 0) != 0) {
    35306. 

  35306.   i5 = HEAP32[i3 + 12 >> 2] | 0;
    35307. 

  35307.   i3 = i4 + 5 | 0;
    35308. 

  35308.   HEAP8[i3] = HEAP8[i3] & 251;
    35309. 

  35309.   i5 = i5 + 88 | 0;
    35310. 

  35310.   HEAP32[i4 + 72 >> 2] = HEAP32[i5 >> 2];
    35311. 

  35311.   HEAP32[i5 >> 2] = i4;
    35312. 

  35312.   STACKTOP = i1;
    35313. 

  35313.   return;
    35314. 

  35314.  }
    35315. 

  35315.  if ((HEAP8[i2 + 5 | 0] & 3) == 0) {
    35316. 

  35316.   STACKTOP = i1;
    35317. 

  35317.   return;
    35318. 

  35318.  }
    35319. 

  35319.  i5 = i4 + 5 | 0;
    35320. 

  35320.  i4 = HEAP8[i5] | 0;
    35321. 

  35321.  if ((i4 & 4) == 0) {
    35322. 

  35322.   STACKTOP = i1;
    35323. 

  35323.   return;
    35324. 

  35324.  }
    35325. 

  35325.  i3 = HEAP32[i3 + 12 >> 2] | 0;
    35326. 

  35326.  if ((HEAPU8[i3 + 61 | 0] | 0) < 2) {
    35327. 

  35327.   _reallymarkobject(i3, i2);
    35328. 

  35328.   STACKTOP = i1;
    35329. 

  35329.   return;
    35330. 

  35330.  } else {
    35331. 

  35331.   HEAP8[i5] = HEAP8[i3 + 60 | 0] & 3 | i4 & 184;
    35332. 

  35332.   STACKTOP = i1;
    35333. 

  35333.   return;
    35334. 

  35334.  }
    35335. 

  35335. }
    35336. 

  35336. function _luaL_openlibs(i1) {
    35337. 

  35337.  i1 = i1 | 0;
    35338. 

  35338.  var i2 = 0;
    35339. 

  35339.  i2 = STACKTOP;
    35340. 

  35340.  _luaL_requiref(i1, 2592, 144, 1);
    35341. 

  35341.  _lua_settop(i1, -2);
    35342. 

  35342.  _luaL_requiref(i1, 2600, 145, 1);
    35343. 

  35343.  _lua_settop(i1, -2);
    35344. 

  35344.  _luaL_requiref(i1, 2608, 146, 1);
    35345. 

  35345.  _lua_settop(i1, -2);
    35346. 

  35346.  _luaL_requiref(i1, 2624, 147, 1);
    35347. 

  35347.  _lua_settop(i1, -2);
    35348. 

  35348.  _luaL_requiref(i1, 2632, 148, 1);
    35349. 

  35349.  _lua_settop(i1, -2);
    35350. 

  35350.  _luaL_requiref(i1, 2640, 149, 1);
    35351. 

  35351.  _lua_settop(i1, -2);
    35352. 

  35352.  _luaL_requiref(i1, 2648, 150, 1);
    35353. 

  35353.  _lua_settop(i1, -2);
    35354. 

  35354.  _luaL_requiref(i1, 2656, 151, 1);
    35355. 

  35355.  _lua_settop(i1, -2);
    35356. 

  35356.  _luaL_requiref(i1, 2664, 152, 1);
    35357. 

  35357.  _lua_settop(i1, -2);
    35358. 

  35358.  _luaL_requiref(i1, 2672, 153, 1);
    35359. 

  35359.  _lua_settop(i1, -2);
    35360. 

  35360.  _luaL_getsubtable(i1, -1001e3, 2576) | 0;
    35361. 

  35361.  _lua_settop(i1, -2);
    35362. 

  35362.  STACKTOP = i2;
    35363. 

  35363.  return;
    35364. 

  35364. }
    35365. 

  35365. function _luaX_token2str(i4, i3) {
    35366. 

  35366.  i4 = i4 | 0;
    35367. 

  35367.  i3 = i3 | 0;
    35368. 

  35368.  var i1 = 0, i2 = 0, i5 = 0;
    35369. 

  35369.  i1 = STACKTOP;
    35370. 

  35370.  STACKTOP = STACKTOP + 16 | 0;
    35371. 

  35371.  i2 = i1;
    35372. 

  35372.  if ((i3 | 0) >= 257) {
    35373. 

  35373.   i5 = HEAP32[12096 + (i3 + -257 << 2) >> 2] | 0;
    35374. 

  35374.   if ((i3 | 0) >= 286) {
    35375. 

  35375.    STACKTOP = i1;
    35376. 

  35376.    return i5 | 0;
    35377. 

  35377.   }
    35378. 

  35378.   i4 = HEAP32[i4 + 52 >> 2] | 0;
    35379. 

  35379.   HEAP32[i2 >> 2] = i5;
    35380. 

  35380.   i5 = _luaO_pushfstring(i4, 12256, i2) | 0;
    35381. 

  35381.   STACKTOP = i1;
    35382. 

  35382.   return i5 | 0;
    35383. 

  35383.  }
    35384. 

  35384.  i4 = HEAP32[i4 + 52 >> 2] | 0;
    35385. 

  35385.  if ((HEAP8[i3 + 10913 | 0] & 4) == 0) {
    35386. 

  35386.   HEAP32[i2 >> 2] = i3;
    35387. 

  35387.   i5 = _luaO_pushfstring(i4, 12240, i2) | 0;
    35388. 

  35388.   STACKTOP = i1;
    35389. 

  35389.   return i5 | 0;
    35390. 

  35390.  } else {
    35391. 

  35391.   HEAP32[i2 >> 2] = i3;
    35392. 

  35392.   i5 = _luaO_pushfstring(i4, 12232, i2) | 0;
    35393. 

  35393.   STACKTOP = i1;
    35394. 

  35394.   return i5 | 0;
    35395. 

  35395.  }
    35396. 

  35396.  return 0;
    35397. 

  35397. }
    35398. 

  35398. function _luaL_buffinitsize(i6, i1, i7) {
    35399. 

  35399.  i6 = i6 | 0;
    35400. 

  35400.  i1 = i1 | 0;
    35401. 

  35401.  i7 = i7 | 0;
    35402. 

  35402.  var i2 = 0, i3 = 0, i4 = 0, i5 = 0, i8 = 0;
    35403. 

  35403.  i2 = STACKTOP;
    35404. 

  35404.  HEAP32[i1 + 12 >> 2] = i6;
    35405. 

  35405.  i3 = i1 + 16 | 0;
    35406. 

  35406.  HEAP32[i1 >> 2] = i3;
    35407. 

  35407.  i5 = i1 + 8 | 0;
    35408. 

  35408.  HEAP32[i5 >> 2] = 0;
    35409. 

  35409.  i4 = i1 + 4 | 0;
    35410. 

  35410.  HEAP32[i4 >> 2] = 1024;
    35411. 

  35411.  if (!(i7 >>> 0 > 1024)) {
    35412. 

  35412.   i7 = i3;
    35413. 

  35413.   i8 = 0;
    35414. 

  35414.   i8 = i7 + i8 | 0;
    35415. 

  35415.   STACKTOP = i2;
    35416. 

  35416.   return i8 | 0;
    35417. 

  35417.  }
    35418. 

  35418.  i8 = i7 >>> 0 > 2048 ? i7 : 2048;
    35419. 

  35419.  i7 = _lua_newuserdata(i6, i8) | 0;
    35420. 

  35420.  _memcpy(i7 | 0, HEAP32[i1 >> 2] | 0, HEAP32[i5 >> 2] | 0) | 0;
    35421. 

  35421.  if ((HEAP32[i1 >> 2] | 0) != (i3 | 0)) {
    35422. 

  35422.   _lua_remove(i6, -2);
    35423. 

  35423.  }
    35424. 

  35424.  HEAP32[i1 >> 2] = i7;
    35425. 

  35425.  HEAP32[i4 >> 2] = i8;
    35426. 

  35426.  i8 = HEAP32[i5 >> 2] | 0;
    35427. 

  35427.  i8 = i7 + i8 | 0;
    35428. 

  35428.  STACKTOP = i2;
    35429. 

  35429.  return i8 | 0;
    35430. 

  35430. }
    35431. 

  35431. function _luaE_freethread(i1, i3) {
    35432. 

  35432.  i1 = i1 | 0;
    35433. 

  35433.  i3 = i3 | 0;
    35434. 

  35434.  var i2 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0;
    35435. 

  35435.  i2 = STACKTOP;
    35436. 

  35436.  i4 = i3 + 28 | 0;
    35437. 

  35437.  _luaF_close(i3, HEAP32[i4 >> 2] | 0);
    35438. 

  35438.  i5 = HEAP32[i4 >> 2] | 0;
    35439. 

  35439.  if ((i5 | 0) == 0) {
    35440. 

  35440.   _luaM_realloc_(i1, i3, 112, 0) | 0;
    35441. 

  35441.   STACKTOP = i2;
    35442. 

  35442.   return;
    35443. 

  35443.  }
    35444. 

  35444.  HEAP32[i3 + 16 >> 2] = i3 + 72;
    35445. 

  35445.  i7 = i3 + 84 | 0;
    35446. 

  35446.  i6 = HEAP32[i7 >> 2] | 0;
    35447. 

  35447.  HEAP32[i7 >> 2] = 0;
    35448. 

  35448.  if ((i6 | 0) != 0) {
    35449. 

  35449.   while (1) {
    35450. 

  35450.    i5 = HEAP32[i6 + 12 >> 2] | 0;
    35451. 

  35451.    _luaM_realloc_(i3, i6, 40, 0) | 0;
    35452. 

  35452.    if ((i5 | 0) == 0) {
    35453. 

  35453.     break;
    35454. 

  35454.    } else {
    35455. 

  35455.     i6 = i5;
    35456. 

  35456.    }
    35457. 

  35457.   }
    35458. 

  35458.   i5 = HEAP32[i4 >> 2] | 0;
    35459. 

  35459.  }
    35460. 

  35460.  _luaM_realloc_(i3, i5, HEAP32[i3 + 32 >> 2] << 4, 0) | 0;
    35461. 

  35461.  _luaM_realloc_(i1, i3, 112, 0) | 0;
    35462. 

  35462.  STACKTOP = i2;
    35463. 

  35463.  return;
    35464. 

  35464. }
    35465. 

  35465. function ___toread(i1) {
    35466. 

  35466.  i1 = i1 | 0;
    35467. 

  35467.  var i2 = 0, i3 = 0, i4 = 0;
    35468. 

  35468.  i3 = STACKTOP;
    35469. 

  35469.  i4 = i1 + 74 | 0;
    35470. 

  35470.  i2 = HEAP8[i4] | 0;
    35471. 

  35471.  HEAP8[i4] = i2 + 255 | i2;
    35472. 

  35472.  i4 = i1 + 20 | 0;
    35473. 

  35473.  i2 = i1 + 44 | 0;
    35474. 

  35474.  if ((HEAP32[i4 >> 2] | 0) >>> 0 > (HEAP32[i2 >> 2] | 0) >>> 0) {
    35475. 

  35475.   FUNCTION_TABLE_iiii[HEAP32[i1 + 36 >> 2] & 3](i1, 0, 0) | 0;
    35476. 

  35476.  }
    35477. 

  35477.  HEAP32[i1 + 16 >> 2] = 0;
    35478. 

  35478.  HEAP32[i1 + 28 >> 2] = 0;
    35479. 

  35479.  HEAP32[i4 >> 2] = 0;
    35480. 

  35480.  i4 = HEAP32[i1 >> 2] | 0;
    35481. 

  35481.  if ((i4 & 20 | 0) == 0) {
    35482. 

  35482.   i4 = HEAP32[i2 >> 2] | 0;
    35483. 

  35483.   HEAP32[i1 + 8 >> 2] = i4;
    35484. 

  35484.   HEAP32[i1 + 4 >> 2] = i4;
    35485. 

  35485.   i4 = 0;
    35486. 

  35486.   STACKTOP = i3;
    35487. 

  35487.   return i4 | 0;
    35488. 

  35488.  }
    35489. 

  35489.  if ((i4 & 4 | 0) == 0) {
    35490. 

  35490.   i4 = -1;
    35491. 

  35491.   STACKTOP = i3;
    35492. 

  35492.   return i4 | 0;
    35493. 

  35493.  }
    35494. 

  35494.  HEAP32[i1 >> 2] = i4 | 32;
    35495. 

  35495.  i4 = -1;
    35496. 

  35496.  STACKTOP = i3;
    35497. 

  35497.  return i4 | 0;
    35498. 

  35498. }
    35499. 

  35499. function _lua_callk(i3, i7, i4, i6, i5) {
    35500. 

  35500.  i3 = i3 | 0;
    35501. 

  35501.  i7 = i7 | 0;
    35502. 

  35502.  i4 = i4 | 0;
    35503. 

  35503.  i6 = i6 | 0;
    35504. 

  35504.  i5 = i5 | 0;
    35505. 

  35505.  var i1 = 0, i2 = 0, i8 = 0;
    35506. 

  35506.  i1 = STACKTOP;
    35507. 

  35507.  i2 = i3 + 8 | 0;
    35508. 

  35508.  i7 = (HEAP32[i2 >> 2] | 0) + (~i7 << 4) | 0;
    35509. 

  35509.  if ((i5 | 0) != 0 ? (HEAP16[i3 + 36 >> 1] | 0) == 0 : 0) {
    35510. 

  35510.   i8 = i3 + 16 | 0;
    35511. 

  35511.   HEAP32[(HEAP32[i8 >> 2] | 0) + 28 >> 2] = i5;
    35512. 

  35512.   HEAP32[(HEAP32[i8 >> 2] | 0) + 24 >> 2] = i6;
    35513. 

  35513.   _luaD_call(i3, i7, i4, 1);
    35514. 

  35514.  } else {
    35515. 

  35515.   _luaD_call(i3, i7, i4, 0);
    35516. 

  35516.  }
    35517. 

  35517.  if (!((i4 | 0) == -1)) {
    35518. 

  35518.   STACKTOP = i1;
    35519. 

  35519.   return;
    35520. 

  35520.  }
    35521. 

  35521.  i3 = (HEAP32[i3 + 16 >> 2] | 0) + 4 | 0;
    35522. 

  35522.  i2 = HEAP32[i2 >> 2] | 0;
    35523. 

  35523.  if (!((HEAP32[i3 >> 2] | 0) >>> 0 < i2 >>> 0)) {
    35524. 

  35524.   STACKTOP = i1;
    35525. 

  35525.   return;
    35526. 

  35526.  }
    35527. 

  35527.  HEAP32[i3 >> 2] = i2;
    35528. 

  35528.  STACKTOP = i1;
    35529. 

  35529.  return;
    35530. 

  35530. }
    35531. 

  35531. function _luaX_newstring(i3, i5, i4) {
    35532. 

  35532.  i3 = i3 | 0;
    35533. 

  35533.  i5 = i5 | 0;
    35534. 

  35534.  i4 = i4 | 0;
    35535. 

  35535.  var i1 = 0, i2 = 0, i6 = 0;
    35536. 

  35536.  i1 = STACKTOP;
    35537. 

  35537.  i2 = HEAP32[i3 + 52 >> 2] | 0;
    35538. 

  35538.  i5 = _luaS_newlstr(i2, i5, i4) | 0;
    35539. 

  35539.  i4 = i2 + 8 | 0;
    35540. 

  35540.  i6 = HEAP32[i4 >> 2] | 0;
    35541. 

  35541.  HEAP32[i4 >> 2] = i6 + 16;
    35542. 

  35542.  HEAP32[i6 >> 2] = i5;
    35543. 

  35543.  HEAP32[i6 + 8 >> 2] = HEAPU8[i5 + 4 | 0] | 0 | 64;
    35544. 

  35544.  i6 = _luaH_set(i2, HEAP32[(HEAP32[i3 + 48 >> 2] | 0) + 4 >> 2] | 0, (HEAP32[i4 >> 2] | 0) + -16 | 0) | 0;
    35545. 

  35545.  i3 = i6 + 8 | 0;
    35546. 

  35546.  if ((HEAP32[i3 >> 2] | 0) == 0 ? (HEAP32[i6 >> 2] = 1, HEAP32[i3 >> 2] = 1, (HEAP32[(HEAP32[i2 + 12 >> 2] | 0) + 12 >> 2] | 0) > 0) : 0) {
    35547. 

  35547.   _luaC_step(i2);
    35548. 

  35548.  }
    35549. 

  35549.  HEAP32[i4 >> 2] = (HEAP32[i4 >> 2] | 0) + -16;
    35550. 

  35550.  STACKTOP = i1;
    35551. 

  35551.  return i5 | 0;
    35552. 

  35552. }
    35553. 

  35553. function _strtod(i3, i2) {
    35554. 

  35554.  i3 = i3 | 0;
    35555. 

  35555.  i2 = i2 | 0;
    35556. 

  35556.  var i1 = 0, i4 = 0, d5 = 0.0, i6 = 0, i7 = 0;
    35557. 

  35557.  i1 = STACKTOP;
    35558. 

  35558.  STACKTOP = STACKTOP + 112 | 0;
    35559. 

  35559.  i4 = i1;
    35560. 

  35560.  i7 = i4 + 0 | 0;
    35561. 

  35561.  i6 = i7 + 112 | 0;
    35562. 

  35562.  do {
    35563. 

  35563.   HEAP32[i7 >> 2] = 0;
    35564. 

  35564.   i7 = i7 + 4 | 0;
    35565. 

  35565.  } while ((i7 | 0) < (i6 | 0));
    35566. 

  35566.  i6 = i4 + 4 | 0;
    35567. 

  35567.  HEAP32[i6 >> 2] = i3;
    35568. 

  35568.  i7 = i4 + 8 | 0;
    35569. 

  35569.  HEAP32[i7 >> 2] = -1;
    35570. 

  35570.  HEAP32[i4 + 44 >> 2] = i3;
    35571. 

  35571.  HEAP32[i4 + 76 >> 2] = -1;
    35572. 

  35572.  ___shlim(i4, 0);
    35573. 

  35573.  d5 = +___floatscan(i4, 1, 1);
    35574. 

  35574.  i4 = (HEAP32[i6 >> 2] | 0) - (HEAP32[i7 >> 2] | 0) + (HEAP32[i4 + 108 >> 2] | 0) | 0;
    35575. 

  35575.  if ((i2 | 0) == 0) {
    35576. 

  35576.   STACKTOP = i1;
    35577. 

  35577.   return +d5;
    35578. 

  35578.  }
    35579. 

  35579.  if ((i4 | 0) != 0) {
    35580. 

  35580.   i3 = i3 + i4 | 0;
    35581. 

  35581.  }
    35582. 

  35582.  HEAP32[i2 >> 2] = i3;
    35583. 

  35583.  STACKTOP = i1;
    35584. 

  35584.  return +d5;
    35585. 

  35585. }
    35586. 

  35586. function _f_seek(i1) {
    35587. 

  35587.  i1 = i1 | 0;
    35588. 

  35588.  var i2 = 0, i3 = 0, i4 = 0, i5 = 0, d6 = 0.0;
    35589. 

  35589.  i2 = STACKTOP;
    35590. 

  35590.  STACKTOP = STACKTOP + 16 | 0;
    35591. 

  35591.  i3 = _luaL_checkudata(i1, 1, 2832) | 0;
    35592. 

  35592.  if ((HEAP32[i3 + 4 >> 2] | 0) == 0) {
    35593. 

  35593.   _luaL_error(i1, 3080, i2) | 0;
    35594. 

  35594.  }
    35595. 

  35595.  i3 = HEAP32[i3 >> 2] | 0;
    35596. 

  35596.  i5 = _luaL_checkoption(i1, 2, 3208, 3184) | 0;
    35597. 

  35597.  d6 = +_luaL_optnumber(i1, 3, 0.0);
    35598. 

  35598.  i4 = ~~d6;
    35599. 

  35599.  if (!(+(i4 | 0) == d6)) {
    35600. 

  35600.   _luaL_argerror(i1, 3, 3224) | 0;
    35601. 

  35601.  }
    35602. 

  35602.  if ((_fseek(i3 | 0, i4 | 0, HEAP32[3168 + (i5 << 2) >> 2] | 0) | 0) == 0) {
    35603. 

  35603.   _lua_pushnumber(i1, +(_ftell(i3 | 0) | 0));
    35604. 

  35604.   i5 = 1;
    35605. 

  35605.   STACKTOP = i2;
    35606. 

  35606.   return i5 | 0;
    35607. 

  35607.  } else {
    35608. 

  35608.   i5 = _luaL_fileresult(i1, 0, 0) | 0;
    35609. 

  35609.   STACKTOP = i2;
    35610. 

  35610.   return i5 | 0;
    35611. 

  35611.  }
    35612. 

  35612.  return 0;
    35613. 

  35613. }
    35614. 

  35614. function _setpath(i1, i4, i8, i7, i3) {
    35615. 

  35615.  i1 = i1 | 0;
    35616. 

  35616.  i4 = i4 | 0;
    35617. 

  35617.  i8 = i8 | 0;
    35618. 

  35618.  i7 = i7 | 0;
    35619. 

  35619.  i3 = i3 | 0;
    35620. 

  35620.  var i2 = 0, i5 = 0, i6 = 0;
    35621. 

  35621.  i2 = STACKTOP;
    35622. 

  35622.  i8 = _getenv(i8 | 0) | 0;
    35623. 

  35623.  if ((i8 | 0) == 0) {
    35624. 

  35624.   i7 = _getenv(i7 | 0) | 0;
    35625. 

  35625.   if ((i7 | 0) != 0) {
    35626. 

  35626.    i5 = i7;
    35627. 

  35627.    i6 = 3;
    35628. 

  35628.   }
    35629. 

  35629.  } else {
    35630. 

  35630.   i5 = i8;
    35631. 

  35631.   i6 = 3;
    35632. 

  35632.  }
    35633. 

  35633.  if ((i6 | 0) == 3 ? (_lua_getfield(i1, -1001e3, 4832), i8 = _lua_toboolean(i1, -1) | 0, _lua_settop(i1, -2), (i8 | 0) == 0) : 0) {
    35634. 

  35634.   _luaL_gsub(i1, _luaL_gsub(i1, i5, 4808, 4816) | 0, 4824, i3) | 0;
    35635. 

  35635.   _lua_remove(i1, -2);
    35636. 

  35636.   _lua_setfield(i1, -2, i4);
    35637. 

  35637.   STACKTOP = i2;
    35638. 

  35638.   return;
    35639. 

  35639.  }
    35640. 

  35640.  _lua_pushstring(i1, i3) | 0;
    35641. 

  35641.  _lua_setfield(i1, -2, i4);
    35642. 

  35642.  STACKTOP = i2;
    35643. 

  35643.  return;
    35644. 

  35644. }
    35645. 

  35645. function _luaU_header(i1) {
    35646. 

  35646.  i1 = i1 | 0;
    35647. 

  35647.  var i2 = 0, i3 = 0;
    35648. 

  35648.  i2 = STACKTOP;
    35649. 

  35649.  HEAP8[i1] = 1635077147;
    35650. 

  35650.  HEAP8[i1 + 1 | 0] = 6387020;
    35651. 

  35651.  HEAP8[i1 + 2 | 0] = 24949;
    35652. 

  35652.  HEAP8[i1 + 3 | 0] = 97;
    35653. 

  35653.  HEAP8[i1 + 4 | 0] = 82;
    35654. 

  35654.  HEAP8[i1 + 5 | 0] = 0;
    35655. 

  35655.  HEAP8[i1 + 6 | 0] = 1;
    35656. 

  35656.  HEAP8[i1 + 7 | 0] = 4;
    35657. 

  35657.  HEAP8[i1 + 8 | 0] = 4;
    35658. 

  35658.  HEAP8[i1 + 9 | 0] = 4;
    35659. 

  35659.  HEAP8[i1 + 10 | 0] = 8;
    35660. 

  35660.  i3 = i1 + 12 | 0;
    35661. 

  35661.  HEAP8[i1 + 11 | 0] = 0;
    35662. 

  35662.  HEAP8[i3 + 0 | 0] = HEAP8[8816 | 0] | 0;
    35663. 

  35663.  HEAP8[i3 + 1 | 0] = HEAP8[8817 | 0] | 0;
    35664. 

  35664.  HEAP8[i3 + 2 | 0] = HEAP8[8818 | 0] | 0;
    35665. 

  35665.  HEAP8[i3 + 3 | 0] = HEAP8[8819 | 0] | 0;
    35666. 

  35666.  HEAP8[i3 + 4 | 0] = HEAP8[8820 | 0] | 0;
    35667. 

  35667.  HEAP8[i3 + 5 | 0] = HEAP8[8821 | 0] | 0;
    35668. 

  35668.  STACKTOP = i2;
    35669. 

  35669.  return;
    35670. 

  35670. }
    35671. 

  35671. function _db_setlocal(i1) {
    35672. 

  35672.  i1 = i1 | 0;
    35673. 

  35673.  var i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0;
    35674. 

  35674.  i2 = STACKTOP;
    35675. 

  35675.  STACKTOP = STACKTOP + 112 | 0;
    35676. 

  35676.  i3 = i2;
    35677. 

  35677.  if ((_lua_type(i1, 1) | 0) == 8) {
    35678. 

  35678.   i5 = _lua_tothread(i1, 1) | 0;
    35679. 

  35679.   i4 = 1;
    35680. 

  35680.  } else {
    35681. 

  35681.   i5 = i1;
    35682. 

  35682.   i4 = 0;
    35683. 

  35683.  }
    35684. 

  35684.  i6 = i4 + 1 | 0;
    35685. 

  35685.  if ((_lua_getstack(i5, _luaL_checkinteger(i1, i6) | 0, i3) | 0) == 0) {
    35686. 

  35686.   i6 = _luaL_argerror(i1, i6, 11560) | 0;
    35687. 

  35687.   STACKTOP = i2;
    35688. 

  35688.   return i6 | 0;
    35689. 

  35689.  } else {
    35690. 

  35690.   i6 = i4 + 3 | 0;
    35691. 

  35691.   _luaL_checkany(i1, i6);
    35692. 

  35692.   _lua_settop(i1, i6);
    35693. 

  35693.   _lua_xmove(i1, i5, 1);
    35694. 

  35694.   _lua_pushstring(i1, _lua_setlocal(i5, i3, _luaL_checkinteger(i1, i4 | 2) | 0) | 0) | 0;
    35695. 

  35695.   i6 = 1;
    35696. 

  35696.   STACKTOP = i2;
    35697. 

  35697.   return i6 | 0;
    35698. 

  35698.  }
    35699. 

  35699.  return 0;
    35700. 

  35700. }
    35701. 

  35701. function _tremove(i1) {
    35702. 

  35702.  i1 = i1 | 0;
    35703. 

  35703.  var i2 = 0, i3 = 0, i4 = 0, i5 = 0;
    35704. 

  35704.  i2 = STACKTOP;
    35705. 

  35705.  _luaL_checktype(i1, 1, 5);
    35706. 

  35706.  i3 = _luaL_len(i1, 1) | 0;
    35707. 

  35707.  i4 = _luaL_optinteger(i1, 2, i3) | 0;
    35708. 

  35708.  if ((i4 | 0) != (i3 | 0) ? (i4 | 0) < 1 | (i4 | 0) > (i3 + 1 | 0) : 0) {
    35709. 

  35709.   _luaL_argerror(i1, 1, 8256) | 0;
    35710. 

  35710.  }
    35711. 

  35711.  _lua_rawgeti(i1, 1, i4);
    35712. 

  35712.  if ((i4 | 0) >= (i3 | 0)) {
    35713. 

  35713.   i5 = i4;
    35714. 

  35714.   _lua_pushnil(i1);
    35715. 

  35715.   _lua_rawseti(i1, 1, i5);
    35716. 

  35716.   STACKTOP = i2;
    35717. 

  35717.   return 1;
    35718. 

  35718.  }
    35719. 

  35719.  while (1) {
    35720. 

  35720.   i5 = i4 + 1 | 0;
    35721. 

  35721.   _lua_rawgeti(i1, 1, i5);
    35722. 

  35722.   _lua_rawseti(i1, 1, i4);
    35723. 

  35723.   if ((i5 | 0) == (i3 | 0)) {
    35724. 

  35724.    break;
    35725. 

  35725.   } else {
    35726. 

  35726.    i4 = i5;
    35727. 

  35727.   }
    35728. 

  35728.  }
    35729. 

  35729.  _lua_pushnil(i1);
    35730. 

  35730.  _lua_rawseti(i1, 1, i3);
    35731. 

  35731.  STACKTOP = i2;
    35732. 

  35732.  return 1;
    35733. 

  35733. }
    35734. 

  35734. function _luaL_checkudata(i1, i7, i5) {
    35735. 

  35735.  i1 = i1 | 0;
    35736. 

  35736.  i7 = i7 | 0;
    35737. 

  35737.  i5 = i5 | 0;
    35738. 

  35738.  var i2 = 0, i3 = 0, i4 = 0, i6 = 0;
    35739. 

  35739.  i2 = STACKTOP;
    35740. 

  35740.  STACKTOP = STACKTOP + 16 | 0;
    35741. 

  35741.  i4 = i2;
    35742. 

  35742.  i3 = _lua_touserdata(i1, i7) | 0;
    35743. 

  35743.  if (((i3 | 0) != 0 ? (_lua_getmetatable(i1, i7) | 0) != 0 : 0) ? (_lua_getfield(i1, -1001e3, i5), i6 = (_lua_rawequal(i1, -1, -2) | 0) == 0, i6 = i6 ? 0 : i3, _lua_settop(i1, -3), (i6 | 0) != 0) : 0) {
    35744. 

  35744.   i7 = i6;
    35745. 

  35745.   STACKTOP = i2;
    35746. 

  35746.   return i7 | 0;
    35747. 

  35747.  }
    35748. 

  35748.  i6 = _lua_typename(i1, _lua_type(i1, i7) | 0) | 0;
    35749. 

  35749.  HEAP32[i4 >> 2] = i5;
    35750. 

  35750.  HEAP32[i4 + 4 >> 2] = i6;
    35751. 

  35751.  _luaL_argerror(i1, i7, _lua_pushfstring(i1, 1744, i4) | 0) | 0;
    35752. 

  35752.  i7 = 0;
    35753. 

  35753.  STACKTOP = i2;
    35754. 

  35754.  return i7 | 0;
    35755. 

  35755. }
    35756. 

  35756. function _luaL_error(i1, i5, i7) {
    35757. 

  35757.  i1 = i1 | 0;
    35758. 

  35758.  i5 = i5 | 0;
    35759. 

  35759.  i7 = i7 | 0;
    35760. 

  35760.  var i2 = 0, i3 = 0, i4 = 0, i6 = 0;
    35761. 

  35761.  i4 = STACKTOP;
    35762. 

  35762.  STACKTOP = STACKTOP + 128 | 0;
    35763. 

  35763.  i3 = i4;
    35764. 

  35764.  i2 = i4 + 24 | 0;
    35765. 

  35765.  i4 = i4 + 8 | 0;
    35766. 

  35766.  HEAP32[i4 >> 2] = i7;
    35767. 

  35767.  if ((_lua_getstack(i1, 1, i2) | 0) != 0 ? (_lua_getinfo(i1, 1152, i2) | 0, i6 = HEAP32[i2 + 20 >> 2] | 0, (i6 | 0) > 0) : 0) {
    35768. 

  35768.   HEAP32[i3 >> 2] = i2 + 36;
    35769. 

  35769.   HEAP32[i3 + 4 >> 2] = i6;
    35770. 

  35770.   _lua_pushfstring(i1, 1160, i3) | 0;
    35771. 

  35771.   _lua_pushvfstring(i1, i5, i4) | 0;
    35772. 

  35772.   _lua_concat(i1, 2);
    35773. 

  35773.   _lua_error(i1) | 0;
    35774. 

  35774.  }
    35775. 

  35775.  _lua_pushlstring(i1, 1168, 0) | 0;
    35776. 

  35776.  _lua_pushvfstring(i1, i5, i4) | 0;
    35777. 

  35777.  _lua_concat(i1, 2);
    35778. 

  35778.  _lua_error(i1) | 0;
    35779. 

  35779.  return 0;
    35780. 

  35780. }
    35781. 

  35781. function _luaK_infix(i1, i4, i3) {
    35782. 

  35782.  i1 = i1 | 0;
    35783. 

  35783.  i4 = i4 | 0;
    35784. 

  35784.  i3 = i3 | 0;
    35785. 

  35785.  var i2 = 0;
    35786. 

  35786.  i2 = STACKTOP;
    35787. 

  35787.  L1 : do {
    35788. 

  35788.   switch (i4 | 0) {
    35789. 

  35789.   case 6:
    35790. 

  35790.    {
    35791. 

  35791.     _luaK_exp2nextreg(i1, i3);
    35792. 

  35792.     break;
    35793. 

  35793.    }
    35794. 

  35794.   case 5:
    35795. 

  35795.   case 4:
    35796. 

  35796.   case 3:
    35797. 

  35797.   case 2:
    35798. 

  35798.   case 1:
    35799. 

  35799.   case 0:
    35800. 

  35800.    {
    35801. 

  35801.     if (((HEAP32[i3 >> 2] | 0) == 5 ? (HEAP32[i3 + 16 >> 2] | 0) == -1 : 0) ? (HEAP32[i3 + 20 >> 2] | 0) == -1 : 0) {
    35802. 

  35802.      break L1;
    35803. 

  35803.     }
    35804. 

  35804.     _luaK_exp2RK(i1, i3) | 0;
    35805. 

  35805.     break;
    35806. 

  35806.    }
    35807. 

  35807.   case 13:
    35808. 

  35808.    {
    35809. 

  35809.     _luaK_goiftrue(i1, i3);
    35810. 

  35810.     break;
    35811. 

  35811.    }
    35812. 

  35812.   case 14:
    35813. 

  35813.    {
    35814. 

  35814.     _luaK_goiffalse(i1, i3);
    35815. 

  35815.     break;
    35816. 

  35816.    }
    35817. 

  35817.   default:
    35818. 

  35818.    {
    35819. 

  35819.     _luaK_exp2RK(i1, i3) | 0;
    35820. 

  35820.    }
    35821. 

  35821.   }
    35822. 

  35822.  } while (0);
    35823. 

  35823.  STACKTOP = i2;
    35824. 

  35824.  return;
    35825. 

  35825. }
    35826. 

  35826. function _luaD_shrinkstack(i1) {
    35827. 

  35827.  i1 = i1 | 0;
    35828. 

  35828.  var i2 = 0, i3 = 0, i4 = 0, i5 = 0;
    35829. 

  35829.  i2 = STACKTOP;
    35830. 

  35830.  i4 = HEAP32[i1 + 8 >> 2] | 0;
    35831. 

  35831.  i3 = HEAP32[i1 + 16 >> 2] | 0;
    35832. 

  35832.  if ((i3 | 0) != 0) {
    35833. 

  35833.   do {
    35834. 

  35834.    i5 = HEAP32[i3 + 4 >> 2] | 0;
    35835. 

  35835.    i4 = i4 >>> 0 < i5 >>> 0 ? i5 : i4;
    35836. 

  35836.    i3 = HEAP32[i3 + 8 >> 2] | 0;
    35837. 

  35837.   } while ((i3 | 0) != 0);
    35838. 

  35838.  }
    35839. 

  35839.  i3 = i4 - (HEAP32[i1 + 28 >> 2] | 0) | 0;
    35840. 

  35840.  i4 = (i3 >> 4) + 1 | 0;
    35841. 

  35841.  i4 = ((i4 | 0) / 8 | 0) + 10 + i4 | 0;
    35842. 

  35842.  i4 = (i4 | 0) > 1e6 ? 1e6 : i4;
    35843. 

  35843.  if ((i3 | 0) > 15999984) {
    35844. 

  35844.   STACKTOP = i2;
    35845. 

  35845.   return;
    35846. 

  35846.  }
    35847. 

  35847.  if ((i4 | 0) >= (HEAP32[i1 + 32 >> 2] | 0)) {
    35848. 

  35848.   STACKTOP = i2;
    35849. 

  35849.   return;
    35850. 

  35850.  }
    35851. 

  35851.  _luaD_reallocstack(i1, i4);
    35852. 

  35852.  STACKTOP = i2;
    35853. 

  35853.  return;
    35854. 

  35854. }
    35855. 

  35855. function _luaF_newproto(i1) {
    35856. 

  35856.  i1 = i1 | 0;
    35857. 

  35857.  var i2 = 0;
    35858. 

  35858.  i2 = STACKTOP;
    35859. 

  35859.  i1 = _luaC_newobj(i1, 9, 80, 0, 0) | 0;
    35860. 

  35860.  HEAP32[i1 + 8 >> 2] = 0;
    35861. 

  35861.  HEAP32[i1 + 44 >> 2] = 0;
    35862. 

  35862.  HEAP32[i1 + 16 >> 2] = 0;
    35863. 

  35863.  HEAP32[i1 + 56 >> 2] = 0;
    35864. 

  35864.  HEAP32[i1 + 12 >> 2] = 0;
    35865. 

  35865.  HEAP32[i1 + 32 >> 2] = 0;
    35866. 

  35866.  HEAP32[i1 + 48 >> 2] = 0;
    35867. 

  35867.  HEAP32[i1 + 20 >> 2] = 0;
    35868. 

  35868.  HEAP32[i1 + 52 >> 2] = 0;
    35869. 

  35869.  HEAP32[i1 + 28 >> 2] = 0;
    35870. 

  35870.  HEAP32[i1 + 40 >> 2] = 0;
    35871. 

  35871.  HEAP8[i1 + 76 | 0] = 0;
    35872. 

  35872.  HEAP8[i1 + 77 | 0] = 0;
    35873. 

  35873.  HEAP8[i1 + 78 | 0] = 0;
    35874. 

  35874.  HEAP32[i1 + 24 >> 2] = 0;
    35875. 

  35875.  HEAP32[i1 + 60 >> 2] = 0;
    35876. 

  35876.  HEAP32[i1 + 64 >> 2] = 0;
    35877. 

  35877.  HEAP32[i1 + 68 >> 2] = 0;
    35878. 

  35878.  HEAP32[i1 + 36 >> 2] = 0;
    35879. 

  35879.  STACKTOP = i2;
    35880. 

  35880.  return i1 | 0;
    35881. 

  35881. }
    35882. 

  35882. function _luaF_freeproto(i2, i1) {
    35883. 

  35883.  i2 = i2 | 0;
    35884. 

  35884.  i1 = i1 | 0;
    35885. 

  35885.  var i3 = 0;
    35886. 

  35886.  i3 = STACKTOP;
    35887. 

  35887.  _luaM_realloc_(i2, HEAP32[i1 + 12 >> 2] | 0, HEAP32[i1 + 48 >> 2] << 2, 0) | 0;
    35888. 

  35888.  _luaM_realloc_(i2, HEAP32[i1 + 16 >> 2] | 0, HEAP32[i1 + 56 >> 2] << 2, 0) | 0;
    35889. 

  35889.  _luaM_realloc_(i2, HEAP32[i1 + 8 >> 2] | 0, HEAP32[i1 + 44 >> 2] << 4, 0) | 0;
    35890. 

  35890.  _luaM_realloc_(i2, HEAP32[i1 + 20 >> 2] | 0, HEAP32[i1 + 52 >> 2] << 2, 0) | 0;
    35891. 

  35891.  _luaM_realloc_(i2, HEAP32[i1 + 24 >> 2] | 0, (HEAP32[i1 + 60 >> 2] | 0) * 12 | 0, 0) | 0;
    35892. 

  35892.  _luaM_realloc_(i2, HEAP32[i1 + 28 >> 2] | 0, HEAP32[i1 + 40 >> 2] << 3, 0) | 0;
    35893. 

  35893.  _luaM_realloc_(i2, i1, 80, 0) | 0;
    35894. 

  35894.  STACKTOP = i3;
    35895. 

  35895.  return;
    35896. 

  35896. }
    35897. 

  35897. function _luaK_patchclose(i3, i7, i4) {
    35898. 

  35898.  i3 = i3 | 0;
    35899. 

  35899.  i7 = i7 | 0;
    35900. 

  35900.  i4 = i4 | 0;
    35901. 

  35901.  var i1 = 0, i2 = 0, i5 = 0, i6 = 0, i8 = 0;
    35902. 

  35902.  i2 = STACKTOP;
    35903. 

  35903.  if ((i7 | 0) == -1) {
    35904. 

  35904.   STACKTOP = i2;
    35905. 

  35905.   return;
    35906. 

  35906.  }
    35907. 

  35907.  i3 = HEAP32[(HEAP32[i3 >> 2] | 0) + 12 >> 2] | 0;
    35908. 

  35908.  i4 = (i4 << 6) + 64 & 16320;
    35909. 

  35909.  while (1) {
    35910. 

  35910.   i6 = i3 + (i7 << 2) | 0;
    35911. 

  35911.   i5 = HEAP32[i6 >> 2] | 0;
    35912. 

  35912.   i8 = (i5 >>> 14) + -131071 | 0;
    35913. 

  35913.   if ((i8 | 0) == -1) {
    35914. 

  35914.    break;
    35915. 

  35915.   }
    35916. 

  35916.   i7 = i7 + 1 + i8 | 0;
    35917. 

  35917.   HEAP32[i6 >> 2] = i5 & -16321 | i4;
    35918. 

  35918.   if ((i7 | 0) == -1) {
    35919. 

  35919.    i1 = 6;
    35920. 

  35920.    break;
    35921. 

  35921.   }
    35922. 

  35922.  }
    35923. 

  35923.  if ((i1 | 0) == 6) {
    35924. 

  35924.   STACKTOP = i2;
    35925. 

  35925.   return;
    35926. 

  35926.  }
    35927. 

  35927.  HEAP32[i6 >> 2] = i5 & -16321 | i4;
    35928. 

  35928.  STACKTOP = i2;
    35929. 

  35929.  return;
    35930. 

  35930. }
    35931. 

  35931. function _loadfunc(i1, i4, i5) {
    35932. 

  35932.  i1 = i1 | 0;
    35933. 

  35933.  i4 = i4 | 0;
    35934. 

  35934.  i5 = i5 | 0;
    35935. 

  35935.  var i2 = 0, i3 = 0, i6 = 0;
    35936. 

  35936.  i2 = STACKTOP;
    35937. 

  35937.  STACKTOP = STACKTOP + 16 | 0;
    35938. 

  35938.  i3 = i2;
    35939. 

  35939.  i6 = _luaL_gsub(i1, i5, 4936, 4944) | 0;
    35940. 

  35940.  i5 = _strchr(i6, 45) | 0;
    35941. 

  35941.  do {
    35942. 

  35942.   if ((i5 | 0) != 0) {
    35943. 

  35943.    HEAP32[i3 >> 2] = _lua_pushlstring(i1, i6, i5 - i6 | 0) | 0;
    35944. 

  35944.    i6 = _ll_loadfunc(i1, i4, _lua_pushfstring(i1, 4952, i3) | 0) | 0;
    35945. 

  35945.    if ((i6 | 0) == 2) {
    35946. 

  35946.     i6 = i5 + 1 | 0;
    35947. 

  35947.     break;
    35948. 

  35948.    } else {
    35949. 

  35949.     STACKTOP = i2;
    35950. 

  35950.     return i6 | 0;
    35951. 

  35951.    }
    35952. 

  35952.   }
    35953. 

  35953.  } while (0);
    35954. 

  35954.  HEAP32[i3 >> 2] = i6;
    35955. 

  35955.  i6 = _ll_loadfunc(i1, i4, _lua_pushfstring(i1, 4952, i3) | 0) | 0;
    35956. 

  35956.  STACKTOP = i2;
    35957. 

  35957.  return i6 | 0;
    35958. 

  35958. }
    35959. 

  35959. function _luaK_setlist(i1, i3, i4, i5) {
    35960. 

  35960.  i1 = i1 | 0;
    35961. 

  35961.  i3 = i3 | 0;
    35962. 

  35962.  i4 = i4 | 0;
    35963. 

  35963.  i5 = i5 | 0;
    35964. 

  35964.  var i2 = 0;
    35965. 

  35965.  i2 = STACKTOP;
    35966. 

  35966.  i4 = ((i4 + -1 | 0) / 50 | 0) + 1 | 0;
    35967. 

  35967.  i5 = (i5 | 0) == -1 ? 0 : i5;
    35968. 

  35968.  if ((i4 | 0) < 512) {
    35969. 

  35969.   _luaK_code(i1, i3 << 6 | i5 << 23 | i4 << 14 | 36) | 0;
    35970. 

  35970.   i4 = i3 + 1 | 0;
    35971. 

  35971.   i4 = i4 & 255;
    35972. 

  35972.   i5 = i1 + 48 | 0;
    35973. 

  35973.   HEAP8[i5] = i4;
    35974. 

  35974.   STACKTOP = i2;
    35975. 

  35975.   return;
    35976. 

  35976.  }
    35977. 

  35977.  if ((i4 | 0) >= 67108864) {
    35978. 

  35978.   _luaX_syntaxerror(HEAP32[i1 + 12 >> 2] | 0, 10576);
    35979. 

  35979.  }
    35980. 

  35980.  _luaK_code(i1, i3 << 6 | i5 << 23 | 36) | 0;
    35981. 

  35981.  _luaK_code(i1, i4 << 6 | 39) | 0;
    35982. 

  35982.  i4 = i3 + 1 | 0;
    35983. 

  35983.  i4 = i4 & 255;
    35984. 

  35984.  i5 = i1 + 48 | 0;
    35985. 

  35985.  HEAP8[i5] = i4;
    35986. 

  35986.  STACKTOP = i2;
    35987. 

  35987.  return;
    35988. 

  35988. }
    35989. 

  35989. function _lua_getstack(i2, i6, i3) {
    35990. 

  35990.  i2 = i2 | 0;
    35991. 

  35991.  i6 = i6 | 0;
    35992. 

  35992.  i3 = i3 | 0;
    35993. 

  35993.  var i1 = 0, i4 = 0, i5 = 0;
    35994. 

  35994.  i1 = STACKTOP;
    35995. 

  35995.  L1 : do {
    35996. 

  35996.   if ((i6 | 0) >= 0) {
    35997. 

  35997.    i5 = HEAP32[i2 + 16 >> 2] | 0;
    35998. 

  35998.    if ((i6 | 0) > 0) {
    35999. 

  35999.     i4 = i2 + 72 | 0;
    36000. 

  36000.     do {
    36001. 

  36001.      if ((i5 | 0) == (i4 | 0)) {
    36002. 

  36002.       i2 = 0;
    36003. 

  36003.       break L1;
    36004. 

  36004.      }
    36005. 

  36005.      i6 = i6 + -1 | 0;
    36006. 

  36006.      i5 = HEAP32[i5 + 8 >> 2] | 0;
    36007. 

  36007.     } while ((i6 | 0) > 0);
    36008. 

  36008.     if ((i6 | 0) != 0) {
    36009. 

  36009.      i2 = 0;
    36010. 

  36010.      break;
    36011. 

  36011.     }
    36012. 

  36012.    }
    36013. 

  36013.    if ((i5 | 0) != (i2 + 72 | 0)) {
    36014. 

  36014.     HEAP32[i3 + 96 >> 2] = i5;
    36015. 

  36015.     i2 = 1;
    36016. 

  36016.    } else {
    36017. 

  36017.     i2 = 0;
    36018. 

  36018.    }
    36019. 

  36019.   } else {
    36020. 

  36020.    i2 = 0;
    36021. 

  36021.   }
    36022. 

  36022.  } while (0);
    36023. 

  36023.  STACKTOP = i1;
    36024. 

  36024.  return i2 | 0;
    36025. 

  36025. }
    36026. 

  36026. function _luaC_checkupvalcolor(i1, i5) {
    36027. 

  36027.  i1 = i1 | 0;
    36028. 

  36028.  i5 = i5 | 0;
    36029. 

  36029.  var i2 = 0, i3 = 0, i4 = 0;
    36030. 

  36030.  i2 = STACKTOP;
    36031. 

  36031.  i4 = i5 + 5 | 0;
    36032. 

  36032.  i3 = HEAPU8[i4] | 0;
    36033. 

  36033.  if ((i3 & 7 | 0) != 0) {
    36034. 

  36034.   STACKTOP = i2;
    36035. 

  36035.   return;
    36036. 

  36036.  }
    36037. 

  36037.  if ((HEAP8[i1 + 62 | 0] | 0) != 2 ? (HEAPU8[i1 + 61 | 0] | 0) >= 2 : 0) {
    36038. 

  36038.   HEAP8[i4] = HEAP8[i1 + 60 | 0] & 3 | i3 & 184;
    36039. 

  36039.   STACKTOP = i2;
    36040. 

  36040.   return;
    36041. 

  36041.  }
    36042. 

  36042.  HEAP8[i4] = i3 & 187 | 4;
    36043. 

  36043.  i3 = HEAP32[i5 + 8 >> 2] | 0;
    36044. 

  36044.  if ((HEAP32[i3 + 8 >> 2] & 64 | 0) == 0) {
    36045. 

  36045.   STACKTOP = i2;
    36046. 

  36046.   return;
    36047. 

  36047.  }
    36048. 

  36048.  i3 = HEAP32[i3 >> 2] | 0;
    36049. 

  36049.  if ((HEAP8[i3 + 5 | 0] & 3) == 0) {
    36050. 

  36050.   STACKTOP = i2;
    36051. 

  36051.   return;
    36052. 

  36052.  }
    36053. 

  36053.  _reallymarkobject(i1, i3);
    36054. 

  36054.  STACKTOP = i2;
    36055. 

  36055.  return;
    36056. 

  36056. }
    36057. 

  36057. function _luaB_collectgarbage(i1) {
    36058. 

  36058.  i1 = i1 | 0;
    36059. 

  36059.  var i2 = 0, i3 = 0, i4 = 0;
    36060. 

  36060.  i2 = STACKTOP;
    36061. 

  36061.  i4 = HEAP32[10160 + ((_luaL_checkoption(i1, 1, 10040, 9976) | 0) << 2) >> 2] | 0;
    36062. 

  36062.  i3 = _lua_gc(i1, i4, _luaL_optinteger(i1, 2, 0) | 0) | 0;
    36063. 

  36063.  if ((i4 | 0) == 3) {
    36064. 

  36064.   i4 = _lua_gc(i1, 4, 0) | 0;
    36065. 

  36065.   _lua_pushnumber(i1, +(i3 | 0) + +(i4 | 0) * .0009765625);
    36066. 

  36066.   _lua_pushinteger(i1, i4);
    36067. 

  36067.   i4 = 2;
    36068. 

  36068.   STACKTOP = i2;
    36069. 

  36069.   return i4 | 0;
    36070. 

  36070.  } else if ((i4 | 0) == 9 | (i4 | 0) == 5) {
    36071. 

  36071.   _lua_pushboolean(i1, i3);
    36072. 

  36072.   i4 = 1;
    36073. 

  36073.   STACKTOP = i2;
    36074. 

  36074.   return i4 | 0;
    36075. 

  36075.  } else {
    36076. 

  36076.   _lua_pushinteger(i1, i3);
    36077. 

  36077.   i4 = 1;
    36078. 

  36078.   STACKTOP = i2;
    36079. 

  36079.   return i4 | 0;
    36080. 

  36080.  }
    36081. 

  36081.  return 0;
    36082. 

  36082. }
    36083. 

  36083. function _maxn(i1) {
    36084. 

  36084.  i1 = i1 | 0;
    36085. 

  36085.  var i2 = 0, d3 = 0.0, d4 = 0.0;
    36086. 

  36086.  i2 = STACKTOP;
    36087. 

  36087.  _luaL_checktype(i1, 1, 5);
    36088. 

  36088.  _lua_pushnil(i1);
    36089. 

  36089.  L1 : do {
    36090. 

  36090.   if ((_lua_next(i1, 1) | 0) == 0) {
    36091. 

  36091.    d3 = 0.0;
    36092. 

  36092.   } else {
    36093. 

  36093.    d4 = 0.0;
    36094. 

  36094.    while (1) {
    36095. 

  36095.     while (1) {
    36096. 

  36096.      _lua_settop(i1, -2);
    36097. 

  36097.      if ((_lua_type(i1, -1) | 0) == 3 ? (d3 = +_lua_tonumberx(i1, -1, 0), d3 > d4) : 0) {
    36098. 

  36098.       break;
    36099. 

  36099.      }
    36100. 

  36100.      if ((_lua_next(i1, 1) | 0) == 0) {
    36101. 

  36101.       d3 = d4;
    36102. 

  36102.       break L1;
    36103. 

  36103.      }
    36104. 

  36104.     }
    36105. 

  36105.     if ((_lua_next(i1, 1) | 0) == 0) {
    36106. 

  36106.      break;
    36107. 

  36107.     } else {
    36108. 

  36108.      d4 = d3;
    36109. 

  36109.     }
    36110. 

  36110.    }
    36111. 

  36111.   }
    36112. 

  36112.  } while (0);
    36113. 

  36113.  _lua_pushnumber(i1, d3);
    36114. 

  36114.  STACKTOP = i2;
    36115. 

  36115.  return 1;
    36116. 

  36116. }
    36117. 

  36117. function _str_char(i1) {
    36118. 

  36118.  i1 = i1 | 0;
    36119. 

  36119.  var i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0;
    36120. 

  36120.  i2 = STACKTOP;
    36121. 

  36121.  STACKTOP = STACKTOP + 1040 | 0;
    36122. 

  36122.  i4 = i2;
    36123. 

  36123.  i3 = _lua_gettop(i1) | 0;
    36124. 

  36124.  i5 = _luaL_buffinitsize(i1, i4, i3) | 0;
    36125. 

  36125.  if ((i3 | 0) < 1) {
    36126. 

  36126.   _luaL_pushresultsize(i4, i3);
    36127. 

  36127.   STACKTOP = i2;
    36128. 

  36128.   return 1;
    36129. 

  36129.  } else {
    36130. 

  36130.   i6 = 1;
    36131. 

  36131.  }
    36132. 

  36132.  while (1) {
    36133. 

  36133.   i7 = _luaL_checkinteger(i1, i6) | 0;
    36134. 

  36134.   if ((i7 & 255 | 0) != (i7 | 0)) {
    36135. 

  36135.    _luaL_argerror(i1, i6, 7920) | 0;
    36136. 

  36136.   }
    36137. 

  36137.   HEAP8[i5 + (i6 + -1) | 0] = i7;
    36138. 

  36138.   if ((i6 | 0) == (i3 | 0)) {
    36139. 

  36139.    break;
    36140. 

  36140.   } else {
    36141. 

  36141.    i6 = i6 + 1 | 0;
    36142. 

  36142.   }
    36143. 

  36143.  }
    36144. 

  36144.  _luaL_pushresultsize(i4, i3);
    36145. 

  36145.  STACKTOP = i2;
    36146. 

  36146.  return 1;
    36147. 

  36147. }
    36148. 

  36148. function _memcpy(i3, i2, i1) {
    36149. 

  36149.  i3 = i3 | 0;
    36150. 

  36150.  i2 = i2 | 0;
    36151. 

  36151.  i1 = i1 | 0;
    36152. 

  36152.  var i4 = 0;
    36153. 

  36153.  if ((i1 | 0) >= 4096) return _emscripten_memcpy_big(i3 | 0, i2 | 0, i1 | 0) | 0;
    36154. 

  36154.  i4 = i3 | 0;
    36155. 

  36155.  if ((i3 & 3) == (i2 & 3)) {
    36156. 

  36156.   while (i3 & 3) {
    36157. 

  36157.    if ((i1 | 0) == 0) return i4 | 0;
    36158. 

  36158.    HEAP8[i3] = HEAP8[i2] | 0;
    36159. 

  36159.    i3 = i3 + 1 | 0;
    36160. 

  36160.    i2 = i2 + 1 | 0;
    36161. 

  36161.    i1 = i1 - 1 | 0;
    36162. 

  36162.   }
    36163. 

  36163.   while ((i1 | 0) >= 4) {
    36164. 

  36164.    HEAP32[i3 >> 2] = HEAP32[i2 >> 2];
    36165. 

  36165.    i3 = i3 + 4 | 0;
    36166. 

  36166.    i2 = i2 + 4 | 0;
    36167. 

  36167.    i1 = i1 - 4 | 0;
    36168. 

  36168.   }
    36169. 

  36169.  }
    36170. 

  36170.  while ((i1 | 0) > 0) {
    36171. 

  36171.   HEAP8[i3] = HEAP8[i2] | 0;
    36172. 

  36172.   i3 = i3 + 1 | 0;
    36173. 

  36173.   i2 = i2 + 1 | 0;
    36174. 

  36174.   i1 = i1 - 1 | 0;
    36175. 

  36175.  }
    36176. 

  36176.  return i4 | 0;
    36177. 

  36177. }
    36178. 

  36178. function _luaK_exp2val(i1, i5) {
    36179. 

  36179.  i1 = i1 | 0;
    36180. 

  36180.  i5 = i5 | 0;
    36181. 

  36181.  var i2 = 0, i3 = 0, i4 = 0, i6 = 0;
    36182. 

  36182.  i2 = STACKTOP;
    36183. 

  36183.  i3 = i5 + 16 | 0;
    36184. 

  36184.  i4 = i5 + 20 | 0;
    36185. 

  36185.  if ((HEAP32[i3 >> 2] | 0) == (HEAP32[i4 >> 2] | 0)) {
    36186. 

  36186.   _luaK_dischargevars(i1, i5);
    36187. 

  36187.   STACKTOP = i2;
    36188. 

  36188.   return;
    36189. 

  36189.  }
    36190. 

  36190.  _luaK_dischargevars(i1, i5);
    36191. 

  36191.  if ((HEAP32[i5 >> 2] | 0) == 6) {
    36192. 

  36192.   i6 = HEAP32[i5 + 8 >> 2] | 0;
    36193. 

  36193.   if ((HEAP32[i3 >> 2] | 0) == (HEAP32[i4 >> 2] | 0)) {
    36194. 

  36194.    STACKTOP = i2;
    36195. 

  36195.    return;
    36196. 

  36196.   }
    36197. 

  36197.   if ((i6 | 0) >= (HEAPU8[i1 + 46 | 0] | 0 | 0)) {
    36198. 

  36198.    _exp2reg(i1, i5, i6);
    36199. 

  36199.    STACKTOP = i2;
    36200. 

  36200.    return;
    36201. 

  36201.   }
    36202. 

  36202.  }
    36203. 

  36203.  _luaK_exp2nextreg(i1, i5);
    36204. 

  36204.  STACKTOP = i2;
    36205. 

  36205.  return;
    36206. 

  36206. }
    36207. 

  36207. function _str_reverse(i5) {
    36208. 

  36208.  i5 = i5 | 0;
    36209. 

  36209.  var i1 = 0, i2 = 0, i3 = 0, i4 = 0, i6 = 0, i7 = 0;
    36210. 

  36210.  i2 = STACKTOP;
    36211. 

  36211.  STACKTOP = STACKTOP + 1056 | 0;
    36212. 

  36212.  i4 = i2 + 1040 | 0;
    36213. 

  36213.  i1 = i2;
    36214. 

  36214.  i3 = _luaL_checklstring(i5, 1, i4) | 0;
    36215. 

  36215.  i5 = _luaL_buffinitsize(i5, i1, HEAP32[i4 >> 2] | 0) | 0;
    36216. 

  36216.  i6 = HEAP32[i4 >> 2] | 0;
    36217. 

  36217.  if ((i6 | 0) == 0) {
    36218. 

  36218.   i7 = 0;
    36219. 

  36219.   _luaL_pushresultsize(i1, i7);
    36220. 

  36220.   STACKTOP = i2;
    36221. 

  36221.   return 1;
    36222. 

  36222.  } else {
    36223. 

  36223.   i7 = 0;
    36224. 

  36224.  }
    36225. 

  36225.  do {
    36226. 

  36226.   HEAP8[i5 + i7 | 0] = HEAP8[i3 + (i6 + ~i7) | 0] | 0;
    36227. 

  36227.   i7 = i7 + 1 | 0;
    36228. 

  36228.   i6 = HEAP32[i4 >> 2] | 0;
    36229. 

  36229.  } while (i7 >>> 0 < i6 >>> 0);
    36230. 

  36230.  _luaL_pushresultsize(i1, i6);
    36231. 

  36231.  STACKTOP = i2;
    36232. 

  36232.  return 1;
    36233. 

  36233. }
    36234. 

  36234. function _str_upper(i5) {
    36235. 

  36235.  i5 = i5 | 0;
    36236. 

  36236.  var i1 = 0, i2 = 0, i3 = 0, i4 = 0, i6 = 0, i7 = 0;
    36237. 

  36237.  i1 = STACKTOP;
    36238. 

  36238.  STACKTOP = STACKTOP + 1056 | 0;
    36239. 

  36239.  i4 = i1 + 1040 | 0;
    36240. 

  36240.  i2 = i1;
    36241. 

  36241.  i3 = _luaL_checklstring(i5, 1, i4) | 0;
    36242. 

  36242.  i5 = _luaL_buffinitsize(i5, i2, HEAP32[i4 >> 2] | 0) | 0;
    36243. 

  36243.  if ((HEAP32[i4 >> 2] | 0) == 0) {
    36244. 

  36244.   i7 = 0;
    36245. 

  36245.   _luaL_pushresultsize(i2, i7);
    36246. 

  36246.   STACKTOP = i1;
    36247. 

  36247.   return 1;
    36248. 

  36248.  } else {
    36249. 

  36249.   i6 = 0;
    36250. 

  36250.  }
    36251. 

  36251.  do {
    36252. 

  36252.   HEAP8[i5 + i6 | 0] = _toupper(HEAPU8[i3 + i6 | 0] | 0 | 0) | 0;
    36253. 

  36253.   i6 = i6 + 1 | 0;
    36254. 

  36254.   i7 = HEAP32[i4 >> 2] | 0;
    36255. 

  36255.  } while (i6 >>> 0 < i7 >>> 0);
    36256. 

  36256.  _luaL_pushresultsize(i2, i7);
    36257. 

  36257.  STACKTOP = i1;
    36258. 

  36258.  return 1;
    36259. 

  36259. }
    36260. 

  36260. function _str_lower(i5) {
    36261. 

  36261.  i5 = i5 | 0;
    36262. 

  36262.  var i1 = 0, i2 = 0, i3 = 0, i4 = 0, i6 = 0, i7 = 0;
    36263. 

  36263.  i1 = STACKTOP;
    36264. 

  36264.  STACKTOP = STACKTOP + 1056 | 0;
    36265. 

  36265.  i4 = i1 + 1040 | 0;
    36266. 

  36266.  i2 = i1;
    36267. 

  36267.  i3 = _luaL_checklstring(i5, 1, i4) | 0;
    36268. 

  36268.  i5 = _luaL_buffinitsize(i5, i2, HEAP32[i4 >> 2] | 0) | 0;
    36269. 

  36269.  if ((HEAP32[i4 >> 2] | 0) == 0) {
    36270. 

  36270.   i7 = 0;
    36271. 

  36271.   _luaL_pushresultsize(i2, i7);
    36272. 

  36272.   STACKTOP = i1;
    36273. 

  36273.   return 1;
    36274. 

  36274.  } else {
    36275. 

  36275.   i6 = 0;
    36276. 

  36276.  }
    36277. 

  36277.  do {
    36278. 

  36278.   HEAP8[i5 + i6 | 0] = _tolower(HEAPU8[i3 + i6 | 0] | 0 | 0) | 0;
    36279. 

  36279.   i6 = i6 + 1 | 0;
    36280. 

  36280.   i7 = HEAP32[i4 >> 2] | 0;
    36281. 

  36281.  } while (i6 >>> 0 < i7 >>> 0);
    36282. 

  36282.  _luaL_pushresultsize(i2, i7);
    36283. 

  36283.  STACKTOP = i1;
    36284. 

  36284.  return 1;
    36285. 

  36285. }
    36286. 

  36286. function ___divdi3(i1, i2, i3, i4) {
    36287. 

  36287.  i1 = i1 | 0;
    36288. 

  36288.  i2 = i2 | 0;
    36289. 

  36289.  i3 = i3 | 0;
    36290. 

  36290.  i4 = i4 | 0;
    36291. 

  36291.  var i5 = 0, i6 = 0, i7 = 0, i8 = 0;
    36292. 

  36292.  i5 = i2 >> 31 | ((i2 | 0) < 0 ? -1 : 0) << 1;
    36293. 

  36293.  i6 = ((i2 | 0) < 0 ? -1 : 0) >> 31 | ((i2 | 0) < 0 ? -1 : 0) << 1;
    36294. 

  36294.  i7 = i4 >> 31 | ((i4 | 0) < 0 ? -1 : 0) << 1;
    36295. 

  36295.  i8 = ((i4 | 0) < 0 ? -1 : 0) >> 31 | ((i4 | 0) < 0 ? -1 : 0) << 1;
    36296. 

  36296.  i1 = _i64Subtract(i5 ^ i1, i6 ^ i2, i5, i6) | 0;
    36297. 

  36297.  i2 = tempRet0;
    36298. 

  36298.  i5 = i7 ^ i5;
    36299. 

  36299.  i6 = i8 ^ i6;
    36300. 

  36300.  i7 = _i64Subtract((___udivmoddi4(i1, i2, _i64Subtract(i7 ^ i3, i8 ^ i4, i7, i8) | 0, tempRet0, 0) | 0) ^ i5, tempRet0 ^ i6, i5, i6) | 0;
    36301. 

  36301.  return i7 | 0;
    36302. 

  36302. }
    36303. 

  36303. function _luaK_setoneret(i1, i4) {
    36304. 

  36304.  i1 = i1 | 0;
    36305. 

  36305.  i4 = i4 | 0;
    36306. 

  36306.  var i2 = 0, i3 = 0;
    36307. 

  36307.  i2 = STACKTOP;
    36308. 

  36308.  i3 = HEAP32[i4 >> 2] | 0;
    36309. 

  36309.  if ((i3 | 0) == 13) {
    36310. 

  36310.   i3 = (HEAP32[(HEAP32[i1 >> 2] | 0) + 12 >> 2] | 0) + (HEAP32[i4 + 8 >> 2] << 2) | 0;
    36311. 

  36311.   HEAP32[i3 >> 2] = HEAP32[i3 >> 2] & 8388607 | 16777216;
    36312. 

  36312.   HEAP32[i4 >> 2] = 11;
    36313. 

  36313.   STACKTOP = i2;
    36314. 

  36314.   return;
    36315. 

  36315.  } else if ((i3 | 0) == 12) {
    36316. 

  36316.   HEAP32[i4 >> 2] = 6;
    36317. 

  36317.   i4 = i4 + 8 | 0;
    36318. 

  36318.   HEAP32[i4 >> 2] = (HEAP32[(HEAP32[(HEAP32[i1 >> 2] | 0) + 12 >> 2] | 0) + (HEAP32[i4 >> 2] << 2) >> 2] | 0) >>> 6 & 255;
    36319. 

  36319.   STACKTOP = i2;
    36320. 

  36320.   return;
    36321. 

  36321.  } else {
    36322. 

  36322.   STACKTOP = i2;
    36323. 

  36323.   return;
    36324. 

  36324.  }
    36325. 

  36325. }
    36326. 

  36326. function _luaV_tostring(i6, i1) {
    36327. 

  36327.  i6 = i6 | 0;
    36328. 

  36328.  i1 = i1 | 0;
    36329. 

  36329.  var i2 = 0, i3 = 0, i4 = 0, i5 = 0;
    36330. 

  36330.  i2 = STACKTOP;
    36331. 

  36331.  STACKTOP = STACKTOP + 48 | 0;
    36332. 

  36332.  i3 = i2;
    36333. 

  36333.  i4 = i2 + 8 | 0;
    36334. 

  36334.  i5 = i1 + 8 | 0;
    36335. 

  36335.  if ((HEAP32[i5 >> 2] | 0) != 3) {
    36336. 

  36336.   i6 = 0;
    36337. 

  36337.   STACKTOP = i2;
    36338. 

  36338.   return i6 | 0;
    36339. 

  36339.  }
    36340. 

  36340.  HEAPF64[tempDoublePtr >> 3] = +HEAPF64[i1 >> 3];
    36341. 

  36341.  HEAP32[i3 >> 2] = HEAP32[tempDoublePtr >> 2];
    36342. 

  36342.  HEAP32[i3 + 4 >> 2] = HEAP32[tempDoublePtr + 4 >> 2];
    36343. 

  36343.  i6 = _luaS_newlstr(i6, i4, _sprintf(i4 | 0, 8936, i3 | 0) | 0) | 0;
    36344. 

  36344.  HEAP32[i1 >> 2] = i6;
    36345. 

  36345.  HEAP32[i5 >> 2] = HEAPU8[i6 + 4 | 0] | 0 | 64;
    36346. 

  36346.  i6 = 1;
    36347. 

  36347.  STACKTOP = i2;
    36348. 

  36348.  return i6 | 0;
    36349. 

  36349. }
    36350. 

  36350. function _strcmp(i4, i2) {
    36351. 

  36351.  i4 = i4 | 0;
    36352. 

  36352.  i2 = i2 | 0;
    36353. 

  36353.  var i1 = 0, i3 = 0, i5 = 0;
    36354. 

  36354.  i1 = STACKTOP;
    36355. 

  36355.  i5 = HEAP8[i4] | 0;
    36356. 

  36356.  i3 = HEAP8[i2] | 0;
    36357. 

  36357.  if (i5 << 24 >> 24 != i3 << 24 >> 24 | i5 << 24 >> 24 == 0 | i3 << 24 >> 24 == 0) {
    36358. 

  36358.   i4 = i5;
    36359. 

  36359.   i5 = i3;
    36360. 

  36360.   i4 = i4 & 255;
    36361. 

  36361.   i5 = i5 & 255;
    36362. 

  36362.   i5 = i4 - i5 | 0;
    36363. 

  36363.   STACKTOP = i1;
    36364. 

  36364.   return i5 | 0;
    36365. 

  36365.  }
    36366. 

  36366.  do {
    36367. 

  36367.   i4 = i4 + 1 | 0;
    36368. 

  36368.   i2 = i2 + 1 | 0;
    36369. 

  36369.   i5 = HEAP8[i4] | 0;
    36370. 

  36370.   i3 = HEAP8[i2] | 0;
    36371. 

  36371.  } while (!(i5 << 24 >> 24 != i3 << 24 >> 24 | i5 << 24 >> 24 == 0 | i3 << 24 >> 24 == 0));
    36372. 

  36372.  i4 = i5 & 255;
    36373. 

  36373.  i5 = i3 & 255;
    36374. 

  36374.  i5 = i4 - i5 | 0;
    36375. 

  36375.  STACKTOP = i1;
    36376. 

  36376.  return i5 | 0;
    36377. 

  36377. }
    36378. 

  36378. function _lua_pushstring(i1, i3) {
    36379. 

  36379.  i1 = i1 | 0;
    36380. 

  36380.  i3 = i3 | 0;
    36381. 

  36381.  var i2 = 0, i4 = 0;
    36382. 

  36382.  i2 = STACKTOP;
    36383. 

  36383.  if ((i3 | 0) == 0) {
    36384. 

  36384.   i3 = i1 + 8 | 0;
    36385. 

  36385.   i1 = HEAP32[i3 >> 2] | 0;
    36386. 

  36386.   HEAP32[i1 + 8 >> 2] = 0;
    36387. 

  36387.   HEAP32[i3 >> 2] = i1 + 16;
    36388. 

  36388.   i3 = 0;
    36389. 

  36389.   STACKTOP = i2;
    36390. 

  36390.   return i3 | 0;
    36391. 

  36391.  }
    36392. 

  36392.  if ((HEAP32[(HEAP32[i1 + 12 >> 2] | 0) + 12 >> 2] | 0) > 0) {
    36393. 

  36393.   _luaC_step(i1);
    36394. 

  36394.  }
    36395. 

  36395.  i3 = _luaS_new(i1, i3) | 0;
    36396. 

  36396.  i1 = i1 + 8 | 0;
    36397. 

  36397.  i4 = HEAP32[i1 >> 2] | 0;
    36398. 

  36398.  HEAP32[i4 >> 2] = i3;
    36399. 

  36399.  HEAP32[i4 + 8 >> 2] = HEAPU8[i3 + 4 | 0] | 0 | 64;
    36400. 

  36400.  HEAP32[i1 >> 2] = (HEAP32[i1 >> 2] | 0) + 16;
    36401. 

  36401.  i3 = i3 + 16 | 0;
    36402. 

  36402.  STACKTOP = i2;
    36403. 

  36403.  return i3 | 0;
    36404. 

  36404. }
    36405. 

  36405. function _luaK_exp2anyreg(i1, i3) {
    36406. 

  36406.  i1 = i1 | 0;
    36407. 

  36407.  i3 = i3 | 0;
    36408. 

  36408.  var i2 = 0, i4 = 0, i5 = 0;
    36409. 

  36409.  i2 = STACKTOP;
    36410. 

  36410.  _luaK_dischargevars(i1, i3);
    36411. 

  36411.  if ((HEAP32[i3 >> 2] | 0) == 6) {
    36412. 

  36412.   i5 = i3 + 8 | 0;
    36413. 

  36413.   i4 = HEAP32[i5 >> 2] | 0;
    36414. 

  36414.   if ((HEAP32[i3 + 16 >> 2] | 0) == (HEAP32[i3 + 20 >> 2] | 0)) {
    36415. 

  36415.    i5 = i4;
    36416. 

  36416.    STACKTOP = i2;
    36417. 

  36417.    return i5 | 0;
    36418. 

  36418.   }
    36419. 

  36419.   if ((i4 | 0) >= (HEAPU8[i1 + 46 | 0] | 0 | 0)) {
    36420. 

  36420.    _exp2reg(i1, i3, i4);
    36421. 

  36421.    i5 = HEAP32[i5 >> 2] | 0;
    36422. 

  36422.    STACKTOP = i2;
    36423. 

  36423.    return i5 | 0;
    36424. 

  36424.   }
    36425. 

  36425.  } else {
    36426. 

  36426.   i5 = i3 + 8 | 0;
    36427. 

  36427.  }
    36428. 

  36428.  _luaK_exp2nextreg(i1, i3);
    36429. 

  36429.  i5 = HEAP32[i5 >> 2] | 0;
    36430. 

  36430.  STACKTOP = i2;
    36431. 

  36431.  return i5 | 0;
    36432. 

  36432. }
    36433. 

  36433. function _check_match(i1, i4, i5, i6) {
    36434. 

  36434.  i1 = i1 | 0;
    36435. 

  36435.  i4 = i4 | 0;
    36436. 

  36436.  i5 = i5 | 0;
    36437. 

  36437.  i6 = i6 | 0;
    36438. 

  36438.  var i2 = 0, i3 = 0;
    36439. 

  36439.  i2 = STACKTOP;
    36440. 

  36440.  STACKTOP = STACKTOP + 16 | 0;
    36441. 

  36441.  i3 = i2;
    36442. 

  36442.  if ((HEAP32[i1 + 16 >> 2] | 0) == (i4 | 0)) {
    36443. 

  36443.   _luaX_next(i1);
    36444. 

  36444.   STACKTOP = i2;
    36445. 

  36445.   return;
    36446. 

  36446.  }
    36447. 

  36447.  if ((HEAP32[i1 + 4 >> 2] | 0) == (i6 | 0)) {
    36448. 

  36448.   _error_expected(i1, i4);
    36449. 

  36449.  } else {
    36450. 

  36450.   i2 = HEAP32[i1 + 52 >> 2] | 0;
    36451. 

  36451.   i4 = _luaX_token2str(i1, i4) | 0;
    36452. 

  36452.   i5 = _luaX_token2str(i1, i5) | 0;
    36453. 

  36453.   HEAP32[i3 >> 2] = i4;
    36454. 

  36454.   HEAP32[i3 + 4 >> 2] = i5;
    36455. 

  36455.   HEAP32[i3 + 8 >> 2] = i6;
    36456. 

  36456.   _luaX_syntaxerror(i1, _luaO_pushfstring(i2, 6840, i3) | 0);
    36457. 

  36457.  }
    36458. 

  36458. }
    36459. 

  36459. function _fieldsel(i1, i6) {
    36460. 

  36460.  i1 = i1 | 0;
    36461. 

  36461.  i6 = i6 | 0;
    36462. 

  36462.  var i2 = 0, i3 = 0, i4 = 0, i5 = 0, i7 = 0;
    36463. 

  36463.  i2 = STACKTOP;
    36464. 

  36464.  STACKTOP = STACKTOP + 32 | 0;
    36465. 

  36465.  i3 = i2;
    36466. 

  36466.  i5 = i1 + 48 | 0;
    36467. 

  36467.  i4 = HEAP32[i5 >> 2] | 0;
    36468. 

  36468.  _luaK_exp2anyregup(i4, i6);
    36469. 

  36469.  _luaX_next(i1);
    36470. 

  36470.  if ((HEAP32[i1 + 16 >> 2] | 0) == 288) {
    36471. 

  36471.   i7 = HEAP32[i1 + 24 >> 2] | 0;
    36472. 

  36472.   _luaX_next(i1);
    36473. 

  36473.   i5 = _luaK_stringK(HEAP32[i5 >> 2] | 0, i7) | 0;
    36474. 

  36474.   HEAP32[i3 + 16 >> 2] = -1;
    36475. 

  36475.   HEAP32[i3 + 20 >> 2] = -1;
    36476. 

  36476.   HEAP32[i3 >> 2] = 4;
    36477. 

  36477.   HEAP32[i3 + 8 >> 2] = i5;
    36478. 

  36478.   _luaK_indexed(i4, i6, i3);
    36479. 

  36479.   STACKTOP = i2;
    36480. 

  36480.   return;
    36481. 

  36481.  } else {
    36482. 

  36482.   _error_expected(i1, 288);
    36483. 

  36483.  }
    36484. 

  36484. }
    36485. 

  36485. function _luaK_exp2anyregup(i1, i3) {
    36486. 

  36486.  i1 = i1 | 0;
    36487. 

  36487.  i3 = i3 | 0;
    36488. 

  36488.  var i2 = 0, i4 = 0;
    36489. 

  36489.  i2 = STACKTOP;
    36490. 

  36490.  if ((HEAP32[i3 >> 2] | 0) == 8 ? (HEAP32[i3 + 16 >> 2] | 0) == (HEAP32[i3 + 20 >> 2] | 0) : 0) {
    36491. 

  36491.   STACKTOP = i2;
    36492. 

  36492.   return;
    36493. 

  36493.  }
    36494. 

  36494.  _luaK_dischargevars(i1, i3);
    36495. 

  36495.  if ((HEAP32[i3 >> 2] | 0) == 6) {
    36496. 

  36496.   i4 = HEAP32[i3 + 8 >> 2] | 0;
    36497. 

  36497.   if ((HEAP32[i3 + 16 >> 2] | 0) == (HEAP32[i3 + 20 >> 2] | 0)) {
    36498. 

  36498.    STACKTOP = i2;
    36499. 

  36499.    return;
    36500. 

  36500.   }
    36501. 

  36501.   if ((i4 | 0) >= (HEAPU8[i1 + 46 | 0] | 0 | 0)) {
    36502. 

  36502.    _exp2reg(i1, i3, i4);
    36503. 

  36503.    STACKTOP = i2;
    36504. 

  36504.    return;
    36505. 

  36505.   }
    36506. 

  36506.  }
    36507. 

  36507.  _luaK_exp2nextreg(i1, i3);
    36508. 

  36508.  STACKTOP = i2;
    36509. 

  36509.  return;
    36510. 

  36510. }
    36511. 

  36511. function _lua_settop(i3, i5) {
    36512. 

  36512.  i3 = i3 | 0;
    36513. 

  36513.  i5 = i5 | 0;
    36514. 

  36514.  var i1 = 0, i2 = 0, i4 = 0;
    36515. 

  36515.  i1 = STACKTOP;
    36516. 

  36516.  if (!((i5 | 0) > -1)) {
    36517. 

  36517.   i4 = i3 + 8 | 0;
    36518. 

  36518.   HEAP32[i4 >> 2] = (HEAP32[i4 >> 2] | 0) + (i5 + 1 << 4);
    36519. 

  36519.   STACKTOP = i1;
    36520. 

  36520.   return;
    36521. 

  36521.  }
    36522. 

  36522.  i2 = i3 + 8 | 0;
    36523. 

  36523.  i4 = HEAP32[i2 >> 2] | 0;
    36524. 

  36524.  i3 = (HEAP32[HEAP32[i3 + 16 >> 2] >> 2] | 0) + (i5 + 1 << 4) | 0;
    36525. 

  36525.  if (i4 >>> 0 < i3 >>> 0) {
    36526. 

  36526.   while (1) {
    36527. 

  36527.    i5 = i4 + 16 | 0;
    36528. 

  36528.    HEAP32[i4 + 8 >> 2] = 0;
    36529. 

  36529.    if (i5 >>> 0 < i3 >>> 0) {
    36530. 

  36530.     i4 = i5;
    36531. 

  36531.    } else {
    36532. 

  36532.     break;
    36533. 

  36533.    }
    36534. 

  36534.   }
    36535. 

  36535.   HEAP32[i2 >> 2] = i5;
    36536. 

  36536.  }
    36537. 

  36537.  HEAP32[i2 >> 2] = i3;
    36538. 

  36538.  STACKTOP = i1;
    36539. 

  36539.  return;
    36540. 

  36540. }
    36541. 

  36541. function _luaL_fileresult(i1, i6, i5) {
    36542. 

  36542.  i1 = i1 | 0;
    36543. 

  36543.  i6 = i6 | 0;
    36544. 

  36544.  i5 = i5 | 0;
    36545. 

  36545.  var i2 = 0, i3 = 0, i4 = 0;
    36546. 

  36546.  i2 = STACKTOP;
    36547. 

  36547.  STACKTOP = STACKTOP + 16 | 0;
    36548. 

  36548.  i4 = i2;
    36549. 

  36549.  i3 = HEAP32[(___errno_location() | 0) >> 2] | 0;
    36550. 

  36550.  if ((i6 | 0) != 0) {
    36551. 

  36551.   _lua_pushboolean(i1, 1);
    36552. 

  36552.   i6 = 1;
    36553. 

  36553.   STACKTOP = i2;
    36554. 

  36554.   return i6 | 0;
    36555. 

  36555.  }
    36556. 

  36556.  _lua_pushnil(i1);
    36557. 

  36557.  i6 = _strerror(i3 | 0) | 0;
    36558. 

  36558.  if ((i5 | 0) == 0) {
    36559. 

  36559.   _lua_pushstring(i1, i6) | 0;
    36560. 

  36560.  } else {
    36561. 

  36561.   HEAP32[i4 >> 2] = i5;
    36562. 

  36562.   HEAP32[i4 + 4 >> 2] = i6;
    36563. 

  36563.   _lua_pushfstring(i1, 1176, i4) | 0;
    36564. 

  36564.  }
    36565. 

  36565.  _lua_pushinteger(i1, i3);
    36566. 

  36566.  i6 = 3;
    36567. 

  36567.  STACKTOP = i2;
    36568. 

  36568.  return i6 | 0;
    36569. 

  36569. }
    36570. 

  36570. function _luaL_pushmodule(i1, i4, i5) {
    36571. 

  36571.  i1 = i1 | 0;
    36572. 

  36572.  i4 = i4 | 0;
    36573. 

  36573.  i5 = i5 | 0;
    36574. 

  36574.  var i2 = 0, i3 = 0;
    36575. 

  36575.  i2 = STACKTOP;
    36576. 

  36576.  STACKTOP = STACKTOP + 16 | 0;
    36577. 

  36577.  i3 = i2;
    36578. 

  36578.  _luaL_findtable(i1, -1001e3, 1432, 1) | 0;
    36579. 

  36579.  _lua_getfield(i1, -1, i4);
    36580. 

  36580.  if ((_lua_type(i1, -1) | 0) == 5) {
    36581. 

  36581.   _lua_remove(i1, -2);
    36582. 

  36582.   STACKTOP = i2;
    36583. 

  36583.   return;
    36584. 

  36584.  }
    36585. 

  36585.  _lua_settop(i1, -2);
    36586. 

  36586.  _lua_rawgeti(i1, -1001e3, 2);
    36587. 

  36587.  if ((_luaL_findtable(i1, 0, i4, i5) | 0) != 0) {
    36588. 

  36588.   HEAP32[i3 >> 2] = i4;
    36589. 

  36589.   _luaL_error(i1, 1440, i3) | 0;
    36590. 

  36590.  }
    36591. 

  36591.  _lua_pushvalue(i1, -1);
    36592. 

  36592.  _lua_setfield(i1, -3, i4);
    36593. 

  36593.  _lua_remove(i1, -2);
    36594. 

  36594.  STACKTOP = i2;
    36595. 

  36595.  return;
    36596. 

  36596. }
    36597. 

  36597. function _b_replace(i1) {
    36598. 

  36598.  i1 = i1 | 0;
    36599. 

  36599.  var i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0;
    36600. 

  36600.  i6 = STACKTOP;
    36601. 

  36601.  STACKTOP = STACKTOP + 16 | 0;
    36602. 

  36602.  i3 = _luaL_checkunsigned(i1, 1) | 0;
    36603. 

  36603.  i5 = _luaL_checkunsigned(i1, 2) | 0;
    36604. 

  36604.  i4 = _luaL_checkinteger(i1, 3) | 0;
    36605. 

  36605.  i2 = _luaL_optinteger(i1, 4, 1) | 0;
    36606. 

  36606.  if (!((i4 | 0) > -1)) {
    36607. 

  36607.   _luaL_argerror(i1, 3, 10440) | 0;
    36608. 

  36608.  }
    36609. 

  36609.  if ((i2 | 0) <= 0) {
    36610. 

  36610.   _luaL_argerror(i1, 4, 10472) | 0;
    36611. 

  36611.  }
    36612. 

  36612.  if ((i2 + i4 | 0) > 32) {
    36613. 

  36613.   _luaL_error(i1, 10496, i6) | 0;
    36614. 

  36614.  }
    36615. 

  36615.  i2 = ~(-2 << i2 + -1);
    36616. 

  36616.  _lua_pushunsigned(i1, i3 & ~(i2 << i4) | (i5 & i2) << i4);
    36617. 

  36617.  STACKTOP = i6;
    36618. 

  36618.  return 1;
    36619. 

  36619. }
    36620. 

  36620. function _luaT_gettmbyobj(i1, i5, i3) {
    36621. 

  36621.  i1 = i1 | 0;
    36622. 

  36622.  i5 = i5 | 0;
    36623. 

  36623.  i3 = i3 | 0;
    36624. 

  36624.  var i2 = 0, i4 = 0;
    36625. 

  36625.  i2 = STACKTOP;
    36626. 

  36626.  i4 = HEAP32[i5 + 8 >> 2] & 15;
    36627. 

  36627.  if ((i4 | 0) == 5) {
    36628. 

  36628.   i4 = HEAP32[(HEAP32[i5 >> 2] | 0) + 8 >> 2] | 0;
    36629. 

  36629.  } else if ((i4 | 0) == 7) {
    36630. 

  36630.   i4 = HEAP32[(HEAP32[i5 >> 2] | 0) + 8 >> 2] | 0;
    36631. 

  36631.  } else {
    36632. 

  36632.   i4 = HEAP32[(HEAP32[i1 + 12 >> 2] | 0) + (i4 << 2) + 252 >> 2] | 0;
    36633. 

  36633.  }
    36634. 

  36634.  if ((i4 | 0) == 0) {
    36635. 

  36635.   i5 = 5192;
    36636. 

  36636.   STACKTOP = i2;
    36637. 

  36637.   return i5 | 0;
    36638. 

  36638.  }
    36639. 

  36639.  i5 = _luaH_getstr(i4, HEAP32[(HEAP32[i1 + 12 >> 2] | 0) + (i3 << 2) + 184 >> 2] | 0) | 0;
    36640. 

  36640.  STACKTOP = i2;
    36641. 

  36641.  return i5 | 0;
    36642. 

  36642. }
    36643. 

  36643. function _luaS_eqstr(i2, i3) {
    36644. 

  36644.  i2 = i2 | 0;
    36645. 

  36645.  i3 = i3 | 0;
    36646. 

  36646.  var i1 = 0, i4 = 0;
    36647. 

  36647.  i1 = STACKTOP;
    36648. 

  36648.  i4 = HEAP8[i2 + 4 | 0] | 0;
    36649. 

  36649.  do {
    36650. 

  36650.   if (i4 << 24 >> 24 == (HEAP8[i3 + 4 | 0] | 0)) {
    36651. 

  36651.    if (i4 << 24 >> 24 == 4) {
    36652. 

  36652.     i2 = (i2 | 0) == (i3 | 0);
    36653. 

  36653.     break;
    36654. 

  36654.    }
    36655. 

  36655.    i4 = HEAP32[i2 + 12 >> 2] | 0;
    36656. 

  36656.    if ((i2 | 0) != (i3 | 0)) {
    36657. 

  36657.     if ((i4 | 0) == (HEAP32[i3 + 12 >> 2] | 0)) {
    36658. 

  36658.      i2 = (_memcmp(i2 + 16 | 0, i3 + 16 | 0, i4) | 0) == 0;
    36659. 

  36659.     } else {
    36660. 

  36660.      i2 = 0;
    36661. 

  36661.     }
    36662. 

  36662.    } else {
    36663. 

  36663.     i2 = 1;
    36664. 

  36664.    }
    36665. 

  36665.   } else {
    36666. 

  36666.    i2 = 0;
    36667. 

  36667.   }
    36668. 

  36668.  } while (0);
    36669. 

  36669.  STACKTOP = i1;
    36670. 

  36670.  return i2 & 1 | 0;
    36671. 

  36671. }
    36672. 

  36672. function _lua_concat(i1, i3) {
    36673. 

  36673.  i1 = i1 | 0;
    36674. 

  36674.  i3 = i3 | 0;
    36675. 

  36675.  var i2 = 0, i4 = 0;
    36676. 

  36676.  i2 = STACKTOP;
    36677. 

  36677.  if ((i3 | 0) > 1) {
    36678. 

  36678.   if ((HEAP32[(HEAP32[i1 + 12 >> 2] | 0) + 12 >> 2] | 0) > 0) {
    36679. 

  36679.    _luaC_step(i1);
    36680. 

  36680.   }
    36681. 

  36681.   _luaV_concat(i1, i3);
    36682. 

  36682.   STACKTOP = i2;
    36683. 

  36683.   return;
    36684. 

  36684.  } else {
    36685. 

  36685.   if ((i3 | 0) != 0) {
    36686. 

  36686.    STACKTOP = i2;
    36687. 

  36687.    return;
    36688. 

  36688.   }
    36689. 

  36689.   i3 = i1 + 8 | 0;
    36690. 

  36690.   i4 = HEAP32[i3 >> 2] | 0;
    36691. 

  36691.   i1 = _luaS_newlstr(i1, 936, 0) | 0;
    36692. 

  36692.   HEAP32[i4 >> 2] = i1;
    36693. 

  36693.   HEAP32[i4 + 8 >> 2] = HEAPU8[i1 + 4 | 0] | 0 | 64;
    36694. 

  36694.   HEAP32[i3 >> 2] = (HEAP32[i3 >> 2] | 0) + 16;
    36695. 

  36695.   STACKTOP = i2;
    36696. 

  36696.   return;
    36697. 

  36697.  }
    36698. 

  36698. }
    36699. 

  36699. function _ll_loadfunc(i1, i4, i3) {
    36700. 

  36700.  i1 = i1 | 0;
    36701. 

  36701.  i4 = i4 | 0;
    36702. 

  36702.  i3 = i3 | 0;
    36703. 

  36703.  var i2 = 0;
    36704. 

  36704.  i2 = STACKTOP;
    36705. 

  36705.  _lua_getfield(i1, -1001e3, 4184);
    36706. 

  36706.  _lua_getfield(i1, -1, i4);
    36707. 

  36707.  i4 = _lua_touserdata(i1, -1) | 0;
    36708. 

  36708.  _lua_settop(i1, -3);
    36709. 

  36709.  if ((i4 | 0) == 0) {
    36710. 

  36710.   _lua_pushlstring(i1, 4968, 58) | 0;
    36711. 

  36711.   i4 = 1;
    36712. 

  36712.   STACKTOP = i2;
    36713. 

  36713.   return i4 | 0;
    36714. 

  36714.  }
    36715. 

  36715.  if ((HEAP8[i3] | 0) == 42) {
    36716. 

  36716.   _lua_pushboolean(i1, 1);
    36717. 

  36717.   i4 = 0;
    36718. 

  36718.   STACKTOP = i2;
    36719. 

  36719.   return i4 | 0;
    36720. 

  36720.  } else {
    36721. 

  36721.   _lua_pushlstring(i1, 4968, 58) | 0;
    36722. 

  36722.   i4 = 2;
    36723. 

  36723.   STACKTOP = i2;
    36724. 

  36724.   return i4 | 0;
    36725. 

  36725.  }
    36726. 

  36726.  return 0;
    36727. 

  36727. }
    36728. 

  36728. function _memset(i1, i4, i3) {
    36729. 

  36729.  i1 = i1 | 0;
    36730. 

  36730.  i4 = i4 | 0;
    36731. 

  36731.  i3 = i3 | 0;
    36732. 

  36732.  var i2 = 0, i5 = 0, i6 = 0, i7 = 0;
    36733. 

  36733.  i2 = i1 + i3 | 0;
    36734. 

  36734.  if ((i3 | 0) >= 20) {
    36735. 

  36735.   i4 = i4 & 255;
    36736. 

  36736.   i7 = i1 & 3;
    36737. 

  36737.   i6 = i4 | i4 << 8 | i4 << 16 | i4 << 24;
    36738. 

  36738.   i5 = i2 & ~3;
    36739. 

  36739.   if (i7) {
    36740. 

  36740.    i7 = i1 + 4 - i7 | 0;
    36741. 

  36741.    while ((i1 | 0) < (i7 | 0)) {
    36742. 

  36742.     HEAP8[i1] = i4;
    36743. 

  36743.     i1 = i1 + 1 | 0;
    36744. 

  36744.    }
    36745. 

  36745.   }
    36746. 

  36746.   while ((i1 | 0) < (i5 | 0)) {
    36747. 

  36747.    HEAP32[i1 >> 2] = i6;
    36748. 

  36748.    i1 = i1 + 4 | 0;
    36749. 

  36749.   }
    36750. 

  36750.  }
    36751. 

  36751.  while ((i1 | 0) < (i2 | 0)) {
    36752. 

  36752.   HEAP8[i1] = i4;
    36753. 

  36753.   i1 = i1 + 1 | 0;
    36754. 

  36754.  }
    36755. 

  36755.  return i1 - i3 | 0;
    36756. 

  36756. }
    36757. 

  36757. function _luaD_growstack(i1, i3) {
    36758. 

  36758.  i1 = i1 | 0;
    36759. 

  36759.  i3 = i3 | 0;
    36760. 

  36760.  var i2 = 0, i4 = 0;
    36761. 

  36761.  i2 = STACKTOP;
    36762. 

  36762.  STACKTOP = STACKTOP + 16 | 0;
    36763. 

  36763.  i4 = HEAP32[i1 + 32 >> 2] | 0;
    36764. 

  36764.  if ((i4 | 0) > 1e6) {
    36765. 

  36765.   _luaD_throw(i1, 6);
    36766. 

  36766.  }
    36767. 

  36767.  i3 = i3 + 5 + ((HEAP32[i1 + 8 >> 2] | 0) - (HEAP32[i1 + 28 >> 2] | 0) >> 4) | 0;
    36768. 

  36768.  i4 = i4 << 1;
    36769. 

  36769.  i4 = (i4 | 0) > 1e6 ? 1e6 : i4;
    36770. 

  36770.  i3 = (i4 | 0) < (i3 | 0) ? i3 : i4;
    36771. 

  36771.  if ((i3 | 0) > 1e6) {
    36772. 

  36772.   _luaD_reallocstack(i1, 1000200);
    36773. 

  36773.   _luaG_runerror(i1, 2224, i2);
    36774. 

  36774.  } else {
    36775. 

  36775.   _luaD_reallocstack(i1, i3);
    36776. 

  36776.   STACKTOP = i2;
    36777. 

  36777.   return;
    36778. 

  36778.  }
    36779. 

  36779. }
    36780. 

  36780. function _luaL_callmeta(i1, i4, i3) {
    36781. 

  36781.  i1 = i1 | 0;
    36782. 

  36782.  i4 = i4 | 0;
    36783. 

  36783.  i3 = i3 | 0;
    36784. 

  36784.  var i2 = 0;
    36785. 

  36785.  i2 = STACKTOP;
    36786. 

  36786.  i4 = _lua_absindex(i1, i4) | 0;
    36787. 

  36787.  if ((_lua_getmetatable(i1, i4) | 0) == 0) {
    36788. 

  36788.   i4 = 0;
    36789. 

  36789.   STACKTOP = i2;
    36790. 

  36790.   return i4 | 0;
    36791. 

  36791.  }
    36792. 

  36792.  _lua_pushstring(i1, i3) | 0;
    36793. 

  36793.  _lua_rawget(i1, -2);
    36794. 

  36794.  if ((_lua_type(i1, -1) | 0) == 0) {
    36795. 

  36795.   _lua_settop(i1, -3);
    36796. 

  36796.   i4 = 0;
    36797. 

  36797.   STACKTOP = i2;
    36798. 

  36798.   return i4 | 0;
    36799. 

  36799.  } else {
    36800. 

  36800.   _lua_remove(i1, -2);
    36801. 

  36801.   _lua_pushvalue(i1, i4);
    36802. 

  36802.   _lua_callk(i1, 1, 1, 0, 0);
    36803. 

  36803.   i4 = 1;
    36804. 

  36804.   STACKTOP = i2;
    36805. 

  36805.   return i4 | 0;
    36806. 

  36806.  }
    36807. 

  36807.  return 0;
    36808. 

  36808. }
    36809. 

  36809. function _luaK_reserveregs(i8, i7) {
    36810. 

  36810.  i8 = i8 | 0;
    36811. 

  36811.  i7 = i7 | 0;
    36812. 

  36812.  var i1 = 0, i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0;
    36813. 

  36813.  i3 = STACKTOP;
    36814. 

  36814.  i2 = i8 + 48 | 0;
    36815. 

  36815.  i6 = HEAP8[i2] | 0;
    36816. 

  36816.  i4 = (i6 & 255) + i7 | 0;
    36817. 

  36817.  i5 = (HEAP32[i8 >> 2] | 0) + 78 | 0;
    36818. 

  36818.  do {
    36819. 

  36819.   if ((i4 | 0) > (HEAPU8[i5] | 0 | 0)) {
    36820. 

  36820.    if ((i4 | 0) > 249) {
    36821. 

  36821.     _luaX_syntaxerror(HEAP32[i8 + 12 >> 2] | 0, 10536);
    36822. 

  36822.    } else {
    36823. 

  36823.     HEAP8[i5] = i4;
    36824. 

  36824.     i1 = HEAP8[i2] | 0;
    36825. 

  36825.     break;
    36826. 

  36826.    }
    36827. 

  36827.   } else {
    36828. 

  36828.    i1 = i6;
    36829. 

  36829.   }
    36830. 

  36830.  } while (0);
    36831. 

  36831.  HEAP8[i2] = (i1 & 255) + i7;
    36832. 

  36832.  STACKTOP = i3;
    36833. 

  36833.  return;
    36834. 

  36834. }
    36835. 

  36835. function _aux_lines(i1, i5) {
    36836. 

  36836.  i1 = i1 | 0;
    36837. 

  36837.  i5 = i5 | 0;
    36838. 

  36838.  var i2 = 0, i3 = 0, i4 = 0, i6 = 0;
    36839. 

  36839.  i4 = STACKTOP;
    36840. 

  36840.  i3 = _lua_gettop(i1) | 0;
    36841. 

  36841.  i2 = i3 + -1 | 0;
    36842. 

  36842.  if ((i3 | 0) >= 19) {
    36843. 

  36843.   _luaL_argerror(i1, 17, 3320) | 0;
    36844. 

  36844.  }
    36845. 

  36845.  _lua_pushvalue(i1, 1);
    36846. 

  36846.  _lua_pushinteger(i1, i2);
    36847. 

  36847.  _lua_pushboolean(i1, i5);
    36848. 

  36848.  if ((i3 | 0) >= 2) {
    36849. 

  36849.   i5 = 1;
    36850. 

  36850.   while (1) {
    36851. 

  36851.    i6 = i5 + 1 | 0;
    36852. 

  36852.    _lua_pushvalue(i1, i6);
    36853. 

  36853.    if ((i5 | 0) < (i2 | 0)) {
    36854. 

  36854.     i5 = i6;
    36855. 

  36855.    } else {
    36856. 

  36856.     break;
    36857. 

  36857.    }
    36858. 

  36858.   }
    36859. 

  36859.  }
    36860. 

  36860.  _lua_pushcclosure(i1, 155, i3 + 2 | 0);
    36861. 

  36861.  STACKTOP = i4;
    36862. 

  36862.  return;
    36863. 

  36863. }
    36864. 

  36864. function _memcmp(i2, i4, i3) {
    36865. 

  36865.  i2 = i2 | 0;
    36866. 

  36866.  i4 = i4 | 0;
    36867. 

  36867.  i3 = i3 | 0;
    36868. 

  36868.  var i1 = 0, i5 = 0, i6 = 0;
    36869. 

  36869.  i1 = STACKTOP;
    36870. 

  36870.  L1 : do {
    36871. 

  36871.   if ((i3 | 0) == 0) {
    36872. 

  36872.    i2 = 0;
    36873. 

  36873.   } else {
    36874. 

  36874.    while (1) {
    36875. 

  36875.     i6 = HEAP8[i2] | 0;
    36876. 

  36876.     i5 = HEAP8[i4] | 0;
    36877. 

  36877.     if (!(i6 << 24 >> 24 == i5 << 24 >> 24)) {
    36878. 

  36878.      break;
    36879. 

  36879.     }
    36880. 

  36880.     i3 = i3 + -1 | 0;
    36881. 

  36881.     if ((i3 | 0) == 0) {
    36882. 

  36882.      i2 = 0;
    36883. 

  36883.      break L1;
    36884. 

  36884.     } else {
    36885. 

  36885.      i2 = i2 + 1 | 0;
    36886. 

  36886.      i4 = i4 + 1 | 0;
    36887. 

  36887.     }
    36888. 

  36888.    }
    36889. 

  36889.    i2 = (i6 & 255) - (i5 & 255) | 0;
    36890. 

  36890.   }
    36891. 

  36891.  } while (0);
    36892. 

  36892.  STACKTOP = i1;
    36893. 

  36893.  return i2 | 0;
    36894. 

  36894. }
    36895. 

  36895. function _b_arshift(i1) {
    36896. 

  36896.  i1 = i1 | 0;
    36897. 

  36897.  var i2 = 0, i3 = 0, i4 = 0, i5 = 0;
    36898. 

  36898.  i2 = STACKTOP;
    36899. 

  36899.  i3 = _luaL_checkunsigned(i1, 1) | 0;
    36900. 

  36900.  i4 = _luaL_checkinteger(i1, 2) | 0;
    36901. 

  36901.  if ((i4 | 0) > -1 & (i3 | 0) < 0) {
    36902. 

  36902.   if ((i4 | 0) > 31) {
    36903. 

  36903.    i3 = -1;
    36904. 

  36904.   } else {
    36905. 

  36905.    i3 = i3 >>> i4 | ~(-1 >>> i4);
    36906. 

  36906.   }
    36907. 

  36907.   _lua_pushunsigned(i1, i3);
    36908. 

  36908.   STACKTOP = i2;
    36909. 

  36909.   return 1;
    36910. 

  36910.  }
    36911. 

  36911.  i5 = 0 - i4 | 0;
    36912. 

  36912.  if ((i4 | 0) > 0) {
    36913. 

  36913.   i3 = (i4 | 0) > 31 ? 0 : i3 >>> i4;
    36914. 

  36914.  } else {
    36915. 

  36915.   i3 = (i5 | 0) > 31 ? 0 : i3 << i5;
    36916. 

  36916.  }
    36917. 

  36917.  _lua_pushunsigned(i1, i3);
    36918. 

  36918.  STACKTOP = i2;
    36919. 

  36919.  return 1;
    36920. 

  36920. }
    36921. 

  36921. function _luaL_checkunsigned(i1, i5) {
    36922. 

  36922.  i1 = i1 | 0;
    36923. 

  36923.  i5 = i5 | 0;
    36924. 

  36924.  var i2 = 0, i3 = 0, i4 = 0, i6 = 0, i7 = 0;
    36925. 

  36925.  i3 = STACKTOP;
    36926. 

  36926.  STACKTOP = STACKTOP + 16 | 0;
    36927. 

  36927.  i4 = i3;
    36928. 

  36928.  i6 = i3 + 8 | 0;
    36929. 

  36929.  i2 = _lua_tounsignedx(i1, i5, i6) | 0;
    36930. 

  36930.  if ((HEAP32[i6 >> 2] | 0) != 0) {
    36931. 

  36931.   STACKTOP = i3;
    36932. 

  36932.   return i2 | 0;
    36933. 

  36933.  }
    36934. 

  36934.  i7 = _lua_typename(i1, 3) | 0;
    36935. 

  36935.  i6 = _lua_typename(i1, _lua_type(i1, i5) | 0) | 0;
    36936. 

  36936.  HEAP32[i4 >> 2] = i7;
    36937. 

  36937.  HEAP32[i4 + 4 >> 2] = i6;
    36938. 

  36938.  _luaL_argerror(i1, i5, _lua_pushfstring(i1, 1744, i4) | 0) | 0;
    36939. 

  36939.  STACKTOP = i3;
    36940. 

  36940.  return i2 | 0;
    36941. 

  36941. }
    36942. 

  36942. function _luaB_loadfile(i2) {
    36943. 

  36943.  i2 = i2 | 0;
    36944. 

  36944.  var i1 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0;
    36945. 

  36945.  i1 = STACKTOP;
    36946. 

  36946.  i4 = _luaL_optlstring(i2, 1, 0, 0) | 0;
    36947. 

  36947.  i5 = _luaL_optlstring(i2, 2, 0, 0) | 0;
    36948. 

  36948.  i3 = (_lua_type(i2, 3) | 0) != -1;
    36949. 

  36949.  i6 = i3 ? 3 : 0;
    36950. 

  36950.  if ((_luaL_loadfilex(i2, i4, i5) | 0) == 0) {
    36951. 

  36951.   if (i3 ? (_lua_pushvalue(i2, i6), (_lua_setupvalue(i2, -2, 1) | 0) == 0) : 0) {
    36952. 

  36952.    _lua_settop(i2, -2);
    36953. 

  36953.    i2 = 1;
    36954. 

  36954.   } else {
    36955. 

  36955.    i2 = 1;
    36956. 

  36956.   }
    36957. 

  36957.  } else {
    36958. 

  36958.   _lua_pushnil(i2);
    36959. 

  36959.   _lua_insert(i2, -2);
    36960. 

  36960.   i2 = 2;
    36961. 

  36961.  }
    36962. 

  36962.  STACKTOP = i1;
    36963. 

  36963.  return i2 | 0;
    36964. 

  36964. }
    36965. 

  36965. function _luaL_checkinteger(i1, i5) {
    36966. 

  36966.  i1 = i1 | 0;
    36967. 

  36967.  i5 = i5 | 0;
    36968. 

  36968.  var i2 = 0, i3 = 0, i4 = 0, i6 = 0, i7 = 0;
    36969. 

  36969.  i3 = STACKTOP;
    36970. 

  36970.  STACKTOP = STACKTOP + 16 | 0;
    36971. 

  36971.  i4 = i3;
    36972. 

  36972.  i6 = i3 + 8 | 0;
    36973. 

  36973.  i2 = _lua_tointegerx(i1, i5, i6) | 0;
    36974. 

  36974.  if ((HEAP32[i6 >> 2] | 0) != 0) {
    36975. 

  36975.   STACKTOP = i3;
    36976. 

  36976.   return i2 | 0;
    36977. 

  36977.  }
    36978. 

  36978.  i7 = _lua_typename(i1, 3) | 0;
    36979. 

  36979.  i6 = _lua_typename(i1, _lua_type(i1, i5) | 0) | 0;
    36980. 

  36980.  HEAP32[i4 >> 2] = i7;
    36981. 

  36981.  HEAP32[i4 + 4 >> 2] = i6;
    36982. 

  36982.  _luaL_argerror(i1, i5, _lua_pushfstring(i1, 1744, i4) | 0) | 0;
    36983. 

  36983.  STACKTOP = i3;
    36984. 

  36984.  return i2 | 0;
    36985. 

  36985. }
    36986. 

  36986. function _luaB_select(i1) {
    36987. 

  36987.  i1 = i1 | 0;
    36988. 

  36988.  var i2 = 0, i3 = 0, i4 = 0;
    36989. 

  36989.  i3 = STACKTOP;
    36990. 

  36990.  i2 = _lua_gettop(i1) | 0;
    36991. 

  36991.  if ((_lua_type(i1, 1) | 0) == 4 ? (HEAP8[_lua_tolstring(i1, 1, 0) | 0] | 0) == 35 : 0) {
    36992. 

  36992.   _lua_pushinteger(i1, i2 + -1 | 0);
    36993. 

  36993.   i4 = 1;
    36994. 

  36994.   STACKTOP = i3;
    36995. 

  36995.   return i4 | 0;
    36996. 

  36996.  }
    36997. 

  36997.  i4 = _luaL_checkinteger(i1, 1) | 0;
    36998. 

  36998.  if ((i4 | 0) < 0) {
    36999. 

  36999.   i4 = i4 + i2 | 0;
    37000. 

  37000.  } else {
    37001. 

  37001.   i4 = (i4 | 0) > (i2 | 0) ? i2 : i4;
    37002. 

  37002.  }
    37003. 

  37003.  if ((i4 | 0) <= 0) {
    37004. 

  37004.   _luaL_argerror(i1, 1, 9760) | 0;
    37005. 

  37005.  }
    37006. 

  37006.  i4 = i2 - i4 | 0;
    37007. 

  37007.  STACKTOP = i3;
    37008. 

  37008.  return i4 | 0;
    37009. 

  37009. }
    37010. 

  37010. function _luaX_next(i1) {
    37011. 

  37011.  i1 = i1 | 0;
    37012. 

  37012.  var i2 = 0, i3 = 0;
    37013. 

  37013.  i2 = STACKTOP;
    37014. 

  37014.  HEAP32[i1 + 8 >> 2] = HEAP32[i1 + 4 >> 2];
    37015. 

  37015.  i3 = i1 + 32 | 0;
    37016. 

  37016.  if ((HEAP32[i3 >> 2] | 0) == 286) {
    37017. 

  37017.   HEAP32[i1 + 16 >> 2] = _llex(i1, i1 + 24 | 0) | 0;
    37018. 

  37018.   STACKTOP = i2;
    37019. 

  37019.   return;
    37020. 

  37020.  } else {
    37021. 

  37021.   i1 = i1 + 16 | 0;
    37022. 

  37022.   HEAP32[i1 + 0 >> 2] = HEAP32[i3 + 0 >> 2];
    37023. 

  37023.   HEAP32[i1 + 4 >> 2] = HEAP32[i3 + 4 >> 2];
    37024. 

  37024.   HEAP32[i1 + 8 >> 2] = HEAP32[i3 + 8 >> 2];
    37025. 

  37025.   HEAP32[i1 + 12 >> 2] = HEAP32[i3 + 12 >> 2];
    37026. 

  37026.   HEAP32[i3 >> 2] = 286;
    37027. 

  37027.   STACKTOP = i2;
    37028. 

  37028.   return;
    37029. 

  37029.  }
    37030. 

  37030. }
    37031. 

  37031. function _lua_setglobal(i1, i2) {
    37032. 

  37032.  i1 = i1 | 0;
    37033. 

  37033.  i2 = i2 | 0;
    37034. 

  37034.  var i3 = 0, i4 = 0, i5 = 0, i6 = 0;
    37035. 

  37035.  i3 = STACKTOP;
    37036. 

  37036.  i5 = _luaH_getint(HEAP32[(HEAP32[i1 + 12 >> 2] | 0) + 40 >> 2] | 0, 2) | 0;
    37037. 

  37037.  i4 = i1 + 8 | 0;
    37038. 

  37038.  i6 = HEAP32[i4 >> 2] | 0;
    37039. 

  37039.  HEAP32[i4 >> 2] = i6 + 16;
    37040. 

  37040.  i2 = _luaS_new(i1, i2) | 0;
    37041. 

  37041.  HEAP32[i6 >> 2] = i2;
    37042. 

  37042.  HEAP32[i6 + 8 >> 2] = HEAPU8[i2 + 4 | 0] | 0 | 64;
    37043. 

  37043.  i2 = HEAP32[i4 >> 2] | 0;
    37044. 

  37044.  _luaV_settable(i1, i5, i2 + -16 | 0, i2 + -32 | 0);
    37045. 

  37045.  HEAP32[i4 >> 2] = (HEAP32[i4 >> 2] | 0) + -32;
    37046. 

  37046.  STACKTOP = i3;
    37047. 

  37047.  return;
    37048. 

  37048. }
    37049. 

  37049. function _luaL_checknumber(i1, i5) {
    37050. 

  37050.  i1 = i1 | 0;
    37051. 

  37051.  i5 = i5 | 0;
    37052. 

  37052.  var d2 = 0.0, i3 = 0, i4 = 0, i6 = 0, i7 = 0;
    37053. 

  37053.  i3 = STACKTOP;
    37054. 

  37054.  STACKTOP = STACKTOP + 16 | 0;
    37055. 

  37055.  i4 = i3;
    37056. 

  37056.  i6 = i3 + 8 | 0;
    37057. 

  37057.  d2 = +_lua_tonumberx(i1, i5, i6);
    37058. 

  37058.  if ((HEAP32[i6 >> 2] | 0) != 0) {
    37059. 

  37059.   STACKTOP = i3;
    37060. 

  37060.   return +d2;
    37061. 

  37061.  }
    37062. 

  37062.  i7 = _lua_typename(i1, 3) | 0;
    37063. 

  37063.  i6 = _lua_typename(i1, _lua_type(i1, i5) | 0) | 0;
    37064. 

  37064.  HEAP32[i4 >> 2] = i7;
    37065. 

  37065.  HEAP32[i4 + 4 >> 2] = i6;
    37066. 

  37066.  _luaL_argerror(i1, i5, _lua_pushfstring(i1, 1744, i4) | 0) | 0;
    37067. 

  37067.  STACKTOP = i3;
    37068. 

  37068.  return +d2;
    37069. 

  37069. }
    37070. 

  37070. function _luaZ_fill(i1) {
    37071. 

  37071.  i1 = i1 | 0;
    37072. 

  37072.  var i2 = 0, i3 = 0, i4 = 0;
    37073. 

  37073.  i2 = STACKTOP;
    37074. 

  37074.  STACKTOP = STACKTOP + 16 | 0;
    37075. 

  37075.  i4 = i2;
    37076. 

  37076.  i3 = FUNCTION_TABLE_iiii[HEAP32[i1 + 8 >> 2] & 3](HEAP32[i1 + 16 >> 2] | 0, HEAP32[i1 + 12 >> 2] | 0, i4) | 0;
    37077. 

  37077.  if ((i3 | 0) == 0) {
    37078. 

  37078.   i4 = -1;
    37079. 

  37079.   STACKTOP = i2;
    37080. 

  37080.   return i4 | 0;
    37081. 

  37081.  }
    37082. 

  37082.  i4 = HEAP32[i4 >> 2] | 0;
    37083. 

  37083.  if ((i4 | 0) == 0) {
    37084. 

  37084.   i4 = -1;
    37085. 

  37085.   STACKTOP = i2;
    37086. 

  37086.   return i4 | 0;
    37087. 

  37087.  }
    37088. 

  37088.  HEAP32[i1 >> 2] = i4 + -1;
    37089. 

  37089.  HEAP32[i1 + 4 >> 2] = i3 + 1;
    37090. 

  37090.  i4 = HEAPU8[i3] | 0;
    37091. 

  37091.  STACKTOP = i2;
    37092. 

  37092.  return i4 | 0;
    37093. 

  37093. }
    37094. 

  37094. function _lua_createtable(i1, i3, i4) {
    37095. 

  37095.  i1 = i1 | 0;
    37096. 

  37096.  i3 = i3 | 0;
    37097. 

  37097.  i4 = i4 | 0;
    37098. 

  37098.  var i2 = 0, i5 = 0, i6 = 0, i7 = 0;
    37099. 

  37099.  i2 = STACKTOP;
    37100. 

  37100.  if ((HEAP32[(HEAP32[i1 + 12 >> 2] | 0) + 12 >> 2] | 0) > 0) {
    37101. 

  37101.   _luaC_step(i1);
    37102. 

  37102.  }
    37103. 

  37103.  i5 = _luaH_new(i1) | 0;
    37104. 

  37104.  i6 = i1 + 8 | 0;
    37105. 

  37105.  i7 = HEAP32[i6 >> 2] | 0;
    37106. 

  37106.  HEAP32[i7 >> 2] = i5;
    37107. 

  37107.  HEAP32[i7 + 8 >> 2] = 69;
    37108. 

  37108.  HEAP32[i6 >> 2] = (HEAP32[i6 >> 2] | 0) + 16;
    37109. 

  37109.  if (!((i3 | 0) > 0 | (i4 | 0) > 0)) {
    37110. 

  37110.   STACKTOP = i2;
    37111. 

  37111.   return;
    37112. 

  37112.  }
    37113. 

  37113.  _luaH_resize(i1, i5, i3, i4);
    37114. 

  37114.  STACKTOP = i2;
    37115. 

  37115.  return;
    37116. 

  37116. }
    37117. 

  37117. function _generic_reader(i1, i3, i2) {
    37118. 

  37118.  i1 = i1 | 0;
    37119. 

  37119.  i3 = i3 | 0;
    37120. 

  37120.  i2 = i2 | 0;
    37121. 

  37121.  i3 = STACKTOP;
    37122. 

  37122.  STACKTOP = STACKTOP + 16 | 0;
    37123. 

  37123.  _luaL_checkstack(i1, 2, 9888);
    37124. 

  37124.  _lua_pushvalue(i1, 1);
    37125. 

  37125.  _lua_callk(i1, 0, 1, 0, 0);
    37126. 

  37126.  if ((_lua_type(i1, -1) | 0) == 0) {
    37127. 

  37127.   _lua_settop(i1, -2);
    37128. 

  37128.   HEAP32[i2 >> 2] = 0;
    37129. 

  37129.   i2 = 0;
    37130. 

  37130.   STACKTOP = i3;
    37131. 

  37131.   return i2 | 0;
    37132. 

  37132.  }
    37133. 

  37133.  if ((_lua_isstring(i1, -1) | 0) == 0) {
    37134. 

  37134.   _luaL_error(i1, 9920, i3) | 0;
    37135. 

  37135.  }
    37136. 

  37136.  _lua_replace(i1, 5);
    37137. 

  37137.  i2 = _lua_tolstring(i1, 5, i2) | 0;
    37138. 

  37138.  STACKTOP = i3;
    37139. 

  37139.  return i2 | 0;
    37140. 

  37140. }
    37141. 

  37141. function _luaZ_openspace(i5, i1, i6) {
    37142. 

  37142.  i5 = i5 | 0;
    37143. 

  37143.  i1 = i1 | 0;
    37144. 

  37144.  i6 = i6 | 0;
    37145. 

  37145.  var i2 = 0, i3 = 0, i4 = 0;
    37146. 

  37146.  i2 = STACKTOP;
    37147. 

  37147.  i4 = i1 + 8 | 0;
    37148. 

  37148.  i3 = HEAP32[i4 >> 2] | 0;
    37149. 

  37149.  if (!(i3 >>> 0 < i6 >>> 0)) {
    37150. 

  37150.   i6 = HEAP32[i1 >> 2] | 0;
    37151. 

  37151.   STACKTOP = i2;
    37152. 

  37152.   return i6 | 0;
    37153. 

  37153.  }
    37154. 

  37154.  i6 = i6 >>> 0 < 32 ? 32 : i6;
    37155. 

  37155.  if ((i6 + 1 | 0) >>> 0 > 4294967293) {
    37156. 

  37156.   _luaM_toobig(i5);
    37157. 

  37157.  }
    37158. 

  37158.  i5 = _luaM_realloc_(i5, HEAP32[i1 >> 2] | 0, i3, i6) | 0;
    37159. 

  37159.  HEAP32[i1 >> 2] = i5;
    37160. 

  37160.  HEAP32[i4 >> 2] = i6;
    37161. 

  37161.  i6 = i5;
    37162. 

  37162.  STACKTOP = i2;
    37163. 

  37163.  return i6 | 0;
    37164. 

  37164. }
    37165. 

  37165. function _luaH_getstr(i4, i3) {
    37166. 

  37166.  i4 = i4 | 0;
    37167. 

  37167.  i3 = i3 | 0;
    37168. 

  37168.  var i1 = 0, i2 = 0;
    37169. 

  37169.  i2 = STACKTOP;
    37170. 

  37170.  i4 = (HEAP32[i4 + 16 >> 2] | 0) + (((1 << (HEAPU8[i4 + 7 | 0] | 0)) + -1 & HEAP32[i3 + 8 >> 2]) << 5) | 0;
    37171. 

  37171.  while (1) {
    37172. 

  37172.   if ((HEAP32[i4 + 24 >> 2] | 0) == 68 ? (HEAP32[i4 + 16 >> 2] | 0) == (i3 | 0) : 0) {
    37173. 

  37173.    break;
    37174. 

  37174.   }
    37175. 

  37175.   i4 = HEAP32[i4 + 28 >> 2] | 0;
    37176. 

  37176.   if ((i4 | 0) == 0) {
    37177. 

  37177.    i3 = 5192;
    37178. 

  37178.    i1 = 6;
    37179. 

  37179.    break;
    37180. 

  37180.   }
    37181. 

  37181.  }
    37182. 

  37182.  if ((i1 | 0) == 6) {
    37183. 

  37183.   STACKTOP = i2;
    37184. 

  37184.   return i3 | 0;
    37185. 

  37185.  }
    37186. 

  37186.  STACKTOP = i2;
    37187. 

  37187.  return i4 | 0;
    37188. 

  37188. }
    37189. 

  37189. function _b_extract(i1) {
    37190. 

  37190.  i1 = i1 | 0;
    37191. 

  37191.  var i2 = 0, i3 = 0, i4 = 0, i5 = 0;
    37192. 

  37192.  i5 = STACKTOP;
    37193. 

  37193.  STACKTOP = STACKTOP + 16 | 0;
    37194. 

  37194.  i2 = _luaL_checkunsigned(i1, 1) | 0;
    37195. 

  37195.  i3 = _luaL_checkinteger(i1, 2) | 0;
    37196. 

  37196.  i4 = _luaL_optinteger(i1, 3, 1) | 0;
    37197. 

  37197.  if (!((i3 | 0) > -1)) {
    37198. 

  37198.   _luaL_argerror(i1, 2, 10440) | 0;
    37199. 

  37199.  }
    37200. 

  37200.  if ((i4 | 0) <= 0) {
    37201. 

  37201.   _luaL_argerror(i1, 3, 10472) | 0;
    37202. 

  37202.  }
    37203. 

  37203.  if ((i4 + i3 | 0) > 32) {
    37204. 

  37204.   _luaL_error(i1, 10496, i5) | 0;
    37205. 

  37205.  }
    37206. 

  37206.  _lua_pushunsigned(i1, i2 >>> i3 & ~(-2 << i4 + -1));
    37207. 

  37207.  STACKTOP = i5;
    37208. 

  37208.  return 1;
    37209. 

  37209. }
    37210. 

  37210. function _luaL_checklstring(i1, i4, i5) {
    37211. 

  37211.  i1 = i1 | 0;
    37212. 

  37212.  i4 = i4 | 0;
    37213. 

  37213.  i5 = i5 | 0;
    37214. 

  37214.  var i2 = 0, i3 = 0, i6 = 0, i7 = 0;
    37215. 

  37215.  i2 = STACKTOP;
    37216. 

  37216.  STACKTOP = STACKTOP + 16 | 0;
    37217. 

  37217.  i3 = i2;
    37218. 

  37218.  i5 = _lua_tolstring(i1, i4, i5) | 0;
    37219. 

  37219.  if ((i5 | 0) != 0) {
    37220. 

  37220.   STACKTOP = i2;
    37221. 

  37221.   return i5 | 0;
    37222. 

  37222.  }
    37223. 

  37223.  i7 = _lua_typename(i1, 4) | 0;
    37224. 

  37224.  i6 = _lua_typename(i1, _lua_type(i1, i4) | 0) | 0;
    37225. 

  37225.  HEAP32[i3 >> 2] = i7;
    37226. 

  37226.  HEAP32[i3 + 4 >> 2] = i6;
    37227. 

  37227.  _luaL_argerror(i1, i4, _lua_pushfstring(i1, 1744, i3) | 0) | 0;
    37228. 

  37228.  STACKTOP = i2;
    37229. 

  37229.  return i5 | 0;
    37230. 

  37230. }
    37231. 

  37231. function _db_traceback(i1) {
    37232. 

  37232.  i1 = i1 | 0;
    37233. 

  37233.  var i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0;
    37234. 

  37234.  i2 = STACKTOP;
    37235. 

  37235.  if ((_lua_type(i1, 1) | 0) == 8) {
    37236. 

  37236.   i3 = _lua_tothread(i1, 1) | 0;
    37237. 

  37237.   i4 = 1;
    37238. 

  37238.  } else {
    37239. 

  37239.   i3 = i1;
    37240. 

  37240.   i4 = 0;
    37241. 

  37241.  }
    37242. 

  37242.  i5 = i4 + 1 | 0;
    37243. 

  37243.  i6 = _lua_tolstring(i1, i5, 0) | 0;
    37244. 

  37244.  if ((i6 | 0) == 0 ? (_lua_type(i1, i5) | 0) >= 1 : 0) {
    37245. 

  37245.   _lua_pushvalue(i1, i5);
    37246. 

  37246.   STACKTOP = i2;
    37247. 

  37247.   return 1;
    37248. 

  37248.  }
    37249. 

  37249.  _luaL_traceback(i1, i3, i6, _luaL_optinteger(i1, i4 | 2, (i3 | 0) == (i1 | 0) | 0) | 0);
    37250. 

  37250.  STACKTOP = i2;
    37251. 

  37251.  return 1;
    37252. 

  37252. }
    37253. 

  37253. function _f_setvbuf(i1) {
    37254. 

  37254.  i1 = i1 | 0;
    37255. 

  37255.  var i2 = 0, i3 = 0, i4 = 0, i5 = 0;
    37256. 

  37256.  i2 = STACKTOP;
    37257. 

  37257.  STACKTOP = STACKTOP + 16 | 0;
    37258. 

  37258.  i3 = _luaL_checkudata(i1, 1, 2832) | 0;
    37259. 

  37259.  if ((HEAP32[i3 + 4 >> 2] | 0) == 0) {
    37260. 

  37260.   _luaL_error(i1, 3080, i2) | 0;
    37261. 

  37261.  }
    37262. 

  37262.  i5 = HEAP32[i3 >> 2] | 0;
    37263. 

  37263.  i4 = _luaL_checkoption(i1, 2, 0, 3128) | 0;
    37264. 

  37264.  i3 = _luaL_optinteger(i1, 3, 1024) | 0;
    37265. 

  37265.  i3 = _luaL_fileresult(i1, (_setvbuf(i5 | 0, 0, HEAP32[3112 + (i4 << 2) >> 2] | 0, i3 | 0) | 0) == 0 | 0, 0) | 0;
    37266. 

  37266.  STACKTOP = i2;
    37267. 

  37267.  return i3 | 0;
    37268. 

  37268. }
    37269. 

  37269. function _luaU_dump(i3, i1, i4, i2, i5) {
    37270. 

  37270.  i3 = i3 | 0;
    37271. 

  37271.  i1 = i1 | 0;
    37272. 

  37272.  i4 = i4 | 0;
    37273. 

  37273.  i2 = i2 | 0;
    37274. 

  37274.  i5 = i5 | 0;
    37275. 

  37275.  var i6 = 0, i7 = 0, i8 = 0;
    37276. 

  37276.  i6 = STACKTOP;
    37277. 

  37277.  STACKTOP = STACKTOP + 48 | 0;
    37278. 

  37278.  i8 = i6 + 20 | 0;
    37279. 

  37279.  i7 = i6;
    37280. 

  37280.  HEAP32[i7 >> 2] = i3;
    37281. 

  37281.  HEAP32[i7 + 4 >> 2] = i4;
    37282. 

  37282.  HEAP32[i7 + 8 >> 2] = i2;
    37283. 

  37283.  HEAP32[i7 + 12 >> 2] = i5;
    37284. 

  37284.  i5 = i7 + 16 | 0;
    37285. 

  37285.  _luaU_header(i8);
    37286. 

  37286.  HEAP32[i5 >> 2] = FUNCTION_TABLE_iiiii[i4 & 3](i3, i8, 18, i2) | 0;
    37287. 

  37287.  _DumpFunction(i1, i7);
    37288. 

  37288.  STACKTOP = i6;
    37289. 

  37289.  return HEAP32[i5 >> 2] | 0;
    37290. 

  37290. }
    37291. 

  37291. function _luaB_setmetatable(i1) {
    37292. 

  37292.  i1 = i1 | 0;
    37293. 

  37293.  var i2 = 0, i3 = 0;
    37294. 

  37294.  i2 = STACKTOP;
    37295. 

  37295.  STACKTOP = STACKTOP + 16 | 0;
    37296. 

  37296.  i3 = _lua_type(i1, 2) | 0;
    37297. 

  37297.  _luaL_checktype(i1, 1, 5);
    37298. 

  37298.  if (!((i3 | 0) == 0 | (i3 | 0) == 5)) {
    37299. 

  37299.   _luaL_argerror(i1, 2, 9680) | 0;
    37300. 

  37300.  }
    37301. 

  37301.  if ((_luaL_getmetafield(i1, 1, 9704) | 0) == 0) {
    37302. 

  37302.   _lua_settop(i1, 2);
    37303. 

  37303.   _lua_setmetatable(i1, 1) | 0;
    37304. 

  37304.   i3 = 1;
    37305. 

  37305.   STACKTOP = i2;
    37306. 

  37306.   return i3 | 0;
    37307. 

  37307.  } else {
    37308. 

  37308.   i3 = _luaL_error(i1, 9720, i2) | 0;
    37309. 

  37309.   STACKTOP = i2;
    37310. 

  37310.   return i3 | 0;
    37311. 

  37311.  }
    37312. 

  37312.  return 0;
    37313. 

  37313. }
    37314. 

  37314. function _getF(i3, i2, i1) {
    37315. 

  37315.  i3 = i3 | 0;
    37316. 

  37316.  i2 = i2 | 0;
    37317. 

  37317.  i1 = i1 | 0;
    37318. 

  37318.  var i4 = 0;
    37319. 

  37319.  i3 = STACKTOP;
    37320. 

  37320.  i4 = HEAP32[i2 >> 2] | 0;
    37321. 

  37321.  if ((i4 | 0) > 0) {
    37322. 

  37322.   HEAP32[i1 >> 2] = i4;
    37323. 

  37323.   HEAP32[i2 >> 2] = 0;
    37324. 

  37324.   i4 = i2 + 8 | 0;
    37325. 

  37325.   STACKTOP = i3;
    37326. 

  37326.   return i4 | 0;
    37327. 

  37327.  }
    37328. 

  37328.  i4 = i2 + 4 | 0;
    37329. 

  37329.  if ((_feof(HEAP32[i4 >> 2] | 0) | 0) != 0) {
    37330. 

  37330.   i4 = 0;
    37331. 

  37331.   STACKTOP = i3;
    37332. 

  37332.   return i4 | 0;
    37333. 

  37333.  }
    37334. 

  37334.  i2 = i2 + 8 | 0;
    37335. 

  37335.  HEAP32[i1 >> 2] = _fread(i2 | 0, 1, 1024, HEAP32[i4 >> 2] | 0) | 0;
    37336. 

  37336.  i4 = i2;
    37337. 

  37337.  STACKTOP = i3;
    37338. 

  37338.  return i4 | 0;
    37339. 

  37339. }
    37340. 

  37340. function _luaL_where(i1, i6) {
    37341. 

  37341.  i1 = i1 | 0;
    37342. 

  37342.  i6 = i6 | 0;
    37343. 

  37343.  var i2 = 0, i3 = 0, i4 = 0, i5 = 0;
    37344. 

  37344.  i4 = STACKTOP;
    37345. 

  37345.  STACKTOP = STACKTOP + 112 | 0;
    37346. 

  37346.  i3 = i4;
    37347. 

  37347.  i2 = i4 + 8 | 0;
    37348. 

  37348.  if ((_lua_getstack(i1, i6, i2) | 0) != 0 ? (_lua_getinfo(i1, 1152, i2) | 0, i5 = HEAP32[i2 + 20 >> 2] | 0, (i5 | 0) > 0) : 0) {
    37349. 

  37349.   HEAP32[i3 >> 2] = i2 + 36;
    37350. 

  37350.   HEAP32[i3 + 4 >> 2] = i5;
    37351. 

  37351.   _lua_pushfstring(i1, 1160, i3) | 0;
    37352. 

  37352.   STACKTOP = i4;
    37353. 

  37353.   return;
    37354. 

  37354.  }
    37355. 

  37355.  _lua_pushlstring(i1, 1168, 0) | 0;
    37356. 

  37356.  STACKTOP = i4;
    37357. 

  37357.  return;
    37358. 

  37358. }
    37359. 

  37359. function _hookf(i1, i3) {
    37360. 

  37360.  i1 = i1 | 0;
    37361. 

  37361.  i3 = i3 | 0;
    37362. 

  37362.  var i2 = 0;
    37363. 

  37363.  i2 = STACKTOP;
    37364. 

  37364.  _luaL_getsubtable(i1, -1001e3, 11584) | 0;
    37365. 

  37365.  _lua_pushthread(i1) | 0;
    37366. 

  37366.  _lua_rawget(i1, -2);
    37367. 

  37367.  if ((_lua_type(i1, -1) | 0) != 6) {
    37368. 

  37368.   STACKTOP = i2;
    37369. 

  37369.   return;
    37370. 

  37370.  }
    37371. 

  37371.  _lua_pushstring(i1, HEAP32[11608 + (HEAP32[i3 >> 2] << 2) >> 2] | 0) | 0;
    37372. 

  37372.  i3 = HEAP32[i3 + 20 >> 2] | 0;
    37373. 

  37373.  if ((i3 | 0) > -1) {
    37374. 

  37374.   _lua_pushinteger(i1, i3);
    37375. 

  37375.  } else {
    37376. 

  37376.   _lua_pushnil(i1);
    37377. 

  37377.  }
    37378. 

  37378.  _lua_callk(i1, 2, 0, 0, 0);
    37379. 

  37379.  STACKTOP = i2;
    37380. 

  37380.  return;
    37381. 

  37381. }
    37382. 

  37382. function _luaV_tonumber(i5, i2) {
    37383. 

  37383.  i5 = i5 | 0;
    37384. 

  37384.  i2 = i2 | 0;
    37385. 

  37385.  var i1 = 0, i3 = 0, i4 = 0;
    37386. 

  37386.  i1 = STACKTOP;
    37387. 

  37387.  STACKTOP = STACKTOP + 16 | 0;
    37388. 

  37388.  i3 = i1;
    37389. 

  37389.  i4 = HEAP32[i5 + 8 >> 2] | 0;
    37390. 

  37390.  if ((i4 | 0) != 3) {
    37391. 

  37391.   if ((i4 & 15 | 0) == 4 ? (i5 = HEAP32[i5 >> 2] | 0, (_luaO_str2d(i5 + 16 | 0, HEAP32[i5 + 12 >> 2] | 0, i3) | 0) != 0) : 0) {
    37392. 

  37392.    HEAPF64[i2 >> 3] = +HEAPF64[i3 >> 3];
    37393. 

  37393.    HEAP32[i2 + 8 >> 2] = 3;
    37394. 

  37394.   } else {
    37395. 

  37395.    i2 = 0;
    37396. 

  37396.   }
    37397. 

  37397.  } else {
    37398. 

  37398.   i2 = i5;
    37399. 

  37399.  }
    37400. 

  37400.  STACKTOP = i1;
    37401. 

  37401.  return i2 | 0;
    37402. 

  37402. }
    37403. 

  37403. function _luaO_arith(i3, d1, d2) {
    37404. 

  37404.  i3 = i3 | 0;
    37405. 

  37405.  d1 = +d1;
    37406. 

  37406.  d2 = +d2;
    37407. 

  37407.  switch (i3 | 0) {
    37408. 

  37408.  case 4:
    37409. 

  37409.   {
    37410. 

  37410.    d1 = d1 - +Math_floor(+(d1 / d2)) * d2;
    37411. 

  37411.    break;
    37412. 

  37412.   }
    37413. 

  37413.  case 6:
    37414. 

  37414.   {
    37415. 

  37415.    d1 = -d1;
    37416. 

  37416.    break;
    37417. 

  37417.   }
    37418. 

  37418.  case 0:
    37419. 

  37419.   {
    37420. 

  37420.    d1 = d1 + d2;
    37421. 

  37421.    break;
    37422. 

  37422.   }
    37423. 

  37423.  case 1:
    37424. 

  37424.   {
    37425. 

  37425.    d1 = d1 - d2;
    37426. 

  37426.    break;
    37427. 

  37427.   }
    37428. 

  37428.  case 5:
    37429. 

  37429.   {
    37430. 

  37430.    d1 = +Math_pow(+d1, +d2);
    37431. 

  37431.    break;
    37432. 

  37432.   }
    37433. 

  37433.  case 3:
    37434. 

  37434.   {
    37435. 

  37435.    d1 = d1 / d2;
    37436. 

  37436.    break;
    37437. 

  37437.   }
    37438. 

  37438.  case 2:
    37439. 

  37439.   {
    37440. 

  37440.    d1 = d1 * d2;
    37441. 

  37441.    break;
    37442. 

  37442.   }
    37443. 

  37443.  default:
    37444. 

  37444.   {
    37445. 

  37445.    d1 = 0.0;
    37446. 

  37446.   }
    37447. 

  37447.  }
    37448. 

  37448.  return +d1;
    37449. 

  37449. }
    37450. 

  37450. function _luaB_coresume(i1) {
    37451. 

  37451.  i1 = i1 | 0;
    37452. 

  37452.  var i2 = 0, i3 = 0;
    37453. 

  37453.  i2 = STACKTOP;
    37454. 

  37454.  i3 = _lua_tothread(i1, 1) | 0;
    37455. 

  37455.  if ((i3 | 0) == 0) {
    37456. 

  37456.   _luaL_argerror(i1, 1, 10856) | 0;
    37457. 

  37457.  }
    37458. 

  37458.  i3 = _auxresume(i1, i3, (_lua_gettop(i1) | 0) + -1 | 0) | 0;
    37459. 

  37459.  if ((i3 | 0) < 0) {
    37460. 

  37460.   _lua_pushboolean(i1, 0);
    37461. 

  37461.   _lua_insert(i1, -2);
    37462. 

  37462.   i3 = 2;
    37463. 

  37463.   STACKTOP = i2;
    37464. 

  37464.   return i3 | 0;
    37465. 

  37465.  } else {
    37466. 

  37466.   _lua_pushboolean(i1, 1);
    37467. 

  37467.   _lua_insert(i1, ~i3);
    37468. 

  37468.   i3 = i3 + 1 | 0;
    37469. 

  37469.   STACKTOP = i2;
    37470. 

  37470.   return i3 | 0;
    37471. 

  37471.  }
    37472. 

  37472.  return 0;
    37473. 

  37473. }
    37474. 

  37474. function _pairsmeta(i1, i5, i4, i3) {
    37475. 

  37475.  i1 = i1 | 0;
    37476. 

  37476.  i5 = i5 | 0;
    37477. 

  37477.  i4 = i4 | 0;
    37478. 

  37478.  i3 = i3 | 0;
    37479. 

  37479.  var i2 = 0;
    37480. 

  37480.  i2 = STACKTOP;
    37481. 

  37481.  if ((_luaL_getmetafield(i1, 1, i5) | 0) != 0) {
    37482. 

  37482.   _lua_pushvalue(i1, 1);
    37483. 

  37483.   _lua_callk(i1, 1, 3, 0, 0);
    37484. 

  37484.   STACKTOP = i2;
    37485. 

  37485.   return;
    37486. 

  37486.  }
    37487. 

  37487.  _luaL_checktype(i1, 1, 5);
    37488. 

  37488.  _lua_pushcclosure(i1, i3, 0);
    37489. 

  37489.  _lua_pushvalue(i1, 1);
    37490. 

  37490.  if ((i4 | 0) == 0) {
    37491. 

  37491.   _lua_pushnil(i1);
    37492. 

  37492.   STACKTOP = i2;
    37493. 

  37493.   return;
    37494. 

  37494.  } else {
    37495. 

  37495.   _lua_pushinteger(i1, 0);
    37496. 

  37496.   STACKTOP = i2;
    37497. 

  37497.   return;
    37498. 

  37498.  }
    37499. 

  37499. }
    37500. 

  37500. function _io_close(i1) {
    37501. 

  37501.  i1 = i1 | 0;
    37502. 

  37502.  var i2 = 0, i3 = 0, i4 = 0;
    37503. 

  37503.  i2 = STACKTOP;
    37504. 

  37504.  STACKTOP = STACKTOP + 16 | 0;
    37505. 

  37505.  if ((_lua_type(i1, 1) | 0) == -1) {
    37506. 

  37506.   _lua_getfield(i1, -1001e3, 2800);
    37507. 

  37507.  }
    37508. 

  37508.  if ((HEAP32[(_luaL_checkudata(i1, 1, 2832) | 0) + 4 >> 2] | 0) == 0) {
    37509. 

  37509.   _luaL_error(i1, 3080, i2) | 0;
    37510. 

  37510.  }
    37511. 

  37511.  i4 = (_luaL_checkudata(i1, 1, 2832) | 0) + 4 | 0;
    37512. 

  37512.  i3 = HEAP32[i4 >> 2] | 0;
    37513. 

  37513.  HEAP32[i4 >> 2] = 0;
    37514. 

  37514.  i1 = FUNCTION_TABLE_ii[i3 & 255](i1) | 0;
    37515. 

  37515.  STACKTOP = i2;
    37516. 

  37516.  return i1 | 0;
    37517. 

  37517. }
    37518. 

  37518. function _pack(i1) {
    37519. 

  37519.  i1 = i1 | 0;
    37520. 

  37520.  var i2 = 0, i3 = 0;
    37521. 

  37521.  i2 = STACKTOP;
    37522. 

  37522.  i3 = _lua_gettop(i1) | 0;
    37523. 

  37523.  _lua_createtable(i1, i3, 1);
    37524. 

  37524.  _lua_pushinteger(i1, i3);
    37525. 

  37525.  _lua_setfield(i1, -2, 8312);
    37526. 

  37526.  if ((i3 | 0) <= 0) {
    37527. 

  37527.   STACKTOP = i2;
    37528. 

  37528.   return 1;
    37529. 

  37529.  }
    37530. 

  37530.  _lua_pushvalue(i1, 1);
    37531. 

  37531.  _lua_rawseti(i1, -2, 1);
    37532. 

  37532.  _lua_replace(i1, 1);
    37533. 

  37533.  if ((i3 | 0) <= 1) {
    37534. 

  37534.   STACKTOP = i2;
    37535. 

  37535.   return 1;
    37536. 

  37536.  }
    37537. 

  37537.  do {
    37538. 

  37538.   _lua_rawseti(i1, 1, i3);
    37539. 

  37539.   i3 = i3 + -1 | 0;
    37540. 

  37540.  } while ((i3 | 0) > 1);
    37541. 

  37541.  STACKTOP = i2;
    37542. 

  37542.  return 1;
    37543. 

  37543. }
    37544. 

  37544. function _luaL_execresult(i1, i3) {
    37545. 

  37545.  i1 = i1 | 0;
    37546. 

  37546.  i3 = i3 | 0;
    37547. 

  37547.  var i2 = 0;
    37548. 

  37548.  i2 = STACKTOP;
    37549. 

  37549.  if ((i3 | 0) == -1) {
    37550. 

  37550.   i3 = HEAP32[(___errno_location() | 0) >> 2] | 0;
    37551. 

  37551.   _lua_pushnil(i1);
    37552. 

  37552.   _lua_pushstring(i1, _strerror(i3 | 0) | 0) | 0;
    37553. 

  37553.   _lua_pushinteger(i1, i3);
    37554. 

  37554.   STACKTOP = i2;
    37555. 

  37555.   return 3;
    37556. 

  37556.  } else if ((i3 | 0) == 0) {
    37557. 

  37557.   _lua_pushboolean(i1, 1);
    37558. 

  37558.  } else {
    37559. 

  37559.   _lua_pushnil(i1);
    37560. 

  37560.  }
    37561. 

  37561.  _lua_pushstring(i1, 1184) | 0;
    37562. 

  37562.  _lua_pushinteger(i1, i3);
    37563. 

  37563.  STACKTOP = i2;
    37564. 

  37564.  return 3;
    37565. 

  37565. }
    37566. 

  37566. function _lua_getglobal(i1, i2) {
    37567. 

  37567.  i1 = i1 | 0;
    37568. 

  37568.  i2 = i2 | 0;
    37569. 

  37569.  var i3 = 0, i4 = 0, i5 = 0, i6 = 0;
    37570. 

  37570.  i3 = STACKTOP;
    37571. 

  37571.  i4 = _luaH_getint(HEAP32[(HEAP32[i1 + 12 >> 2] | 0) + 40 >> 2] | 0, 2) | 0;
    37572. 

  37572.  i5 = i1 + 8 | 0;
    37573. 

  37573.  i6 = HEAP32[i5 >> 2] | 0;
    37574. 

  37574.  HEAP32[i5 >> 2] = i6 + 16;
    37575. 

  37575.  i2 = _luaS_new(i1, i2) | 0;
    37576. 

  37576.  HEAP32[i6 >> 2] = i2;
    37577. 

  37577.  HEAP32[i6 + 8 >> 2] = HEAPU8[i2 + 4 | 0] | 0 | 64;
    37578. 

  37578.  i2 = (HEAP32[i5 >> 2] | 0) + -16 | 0;
    37579. 

  37579.  _luaV_gettable(i1, i4, i2, i2);
    37580. 

  37580.  STACKTOP = i3;
    37581. 

  37581.  return;
    37582. 

  37582. }
    37583. 

  37583. function _luaL_checktype(i1, i5, i4) {
    37584. 

  37584.  i1 = i1 | 0;
    37585. 

  37585.  i5 = i5 | 0;
    37586. 

  37586.  i4 = i4 | 0;
    37587. 

  37587.  var i2 = 0, i3 = 0, i6 = 0;
    37588. 

  37588.  i2 = STACKTOP;
    37589. 

  37589.  STACKTOP = STACKTOP + 16 | 0;
    37590. 

  37590.  i3 = i2;
    37591. 

  37591.  if ((_lua_type(i1, i5) | 0) == (i4 | 0)) {
    37592. 

  37592.   STACKTOP = i2;
    37593. 

  37593.   return;
    37594. 

  37594.  }
    37595. 

  37595.  i6 = _lua_typename(i1, i4) | 0;
    37596. 

  37596.  i4 = _lua_typename(i1, _lua_type(i1, i5) | 0) | 0;
    37597. 

  37597.  HEAP32[i3 >> 2] = i6;
    37598. 

  37598.  HEAP32[i3 + 4 >> 2] = i4;
    37599. 

  37599.  _luaL_argerror(i1, i5, _lua_pushfstring(i1, 1744, i3) | 0) | 0;
    37600. 

  37600.  STACKTOP = i2;
    37601. 

  37601.  return;
    37602. 

  37602. }
    37603. 

  37603. function _luaC_newobj(i7, i4, i6, i5, i1) {
    37604. 

  37604.  i7 = i7 | 0;
    37605. 

  37605.  i4 = i4 | 0;
    37606. 

  37606.  i6 = i6 | 0;
    37607. 

  37607.  i5 = i5 | 0;
    37608. 

  37608.  i1 = i1 | 0;
    37609. 

  37609.  var i2 = 0, i3 = 0;
    37610. 

  37610.  i2 = STACKTOP;
    37611. 

  37611.  i3 = HEAP32[i7 + 12 >> 2] | 0;
    37612. 

  37612.  i7 = _luaM_realloc_(i7, 0, i4 & 15, i6) | 0;
    37613. 

  37613.  i6 = i7 + i1 | 0;
    37614. 

  37614.  i5 = (i5 | 0) == 0 ? i3 + 68 | 0 : i5;
    37615. 

  37615.  HEAP8[i7 + (i1 + 5) | 0] = HEAP8[i3 + 60 | 0] & 3;
    37616. 

  37616.  HEAP8[i7 + (i1 + 4) | 0] = i4;
    37617. 

  37617.  HEAP32[i6 >> 2] = HEAP32[i5 >> 2];
    37618. 

  37618.  HEAP32[i5 >> 2] = i6;
    37619. 

  37619.  STACKTOP = i2;
    37620. 

  37620.  return i6 | 0;
    37621. 

  37621. }
    37622. 

  37622. function _luaL_requiref(i1, i3, i5, i4) {
    37623. 

  37623.  i1 = i1 | 0;
    37624. 

  37624.  i3 = i3 | 0;
    37625. 

  37625.  i5 = i5 | 0;
    37626. 

  37626.  i4 = i4 | 0;
    37627. 

  37627.  var i2 = 0;
    37628. 

  37628.  i2 = STACKTOP;
    37629. 

  37629.  _lua_pushcclosure(i1, i5, 0);
    37630. 

  37630.  _lua_pushstring(i1, i3) | 0;
    37631. 

  37631.  _lua_callk(i1, 1, 1, 0, 0);
    37632. 

  37632.  _luaL_getsubtable(i1, -1001e3, 1432) | 0;
    37633. 

  37633.  _lua_pushvalue(i1, -2);
    37634. 

  37634.  _lua_setfield(i1, -2, i3);
    37635. 

  37635.  _lua_settop(i1, -2);
    37636. 

  37636.  if ((i4 | 0) == 0) {
    37637. 

  37637.   STACKTOP = i2;
    37638. 

  37638.   return;
    37639. 

  37639.  }
    37640. 

  37640.  _lua_pushvalue(i1, -1);
    37641. 

  37641.  _lua_setglobal(i1, i3);
    37642. 

  37642.  STACKTOP = i2;
    37643. 

  37643.  return;
    37644. 

  37644. }
    37645. 

  37645. function _luaG_ordererror(i1, i3, i4) {
    37646. 

  37646.  i1 = i1 | 0;
    37647. 

  37647.  i3 = i3 | 0;
    37648. 

  37648.  i4 = i4 | 0;
    37649. 

  37649.  var i2 = 0;
    37650. 

  37650.  i2 = STACKTOP;
    37651. 

  37651.  STACKTOP = STACKTOP + 16 | 0;
    37652. 

  37652.  i3 = HEAP32[8528 + ((HEAP32[i3 + 8 >> 2] & 15) + 1 << 2) >> 2] | 0;
    37653. 

  37653.  i4 = HEAP32[8528 + ((HEAP32[i4 + 8 >> 2] & 15) + 1 << 2) >> 2] | 0;
    37654. 

  37654.  if ((i3 | 0) == (i4 | 0)) {
    37655. 

  37655.   HEAP32[i2 >> 2] = i3;
    37656. 

  37656.   _luaG_runerror(i1, 1952, i2);
    37657. 

  37657.  } else {
    37658. 

  37658.   HEAP32[i2 >> 2] = i3;
    37659. 

  37659.   HEAP32[i2 + 4 >> 2] = i4;
    37660. 

  37660.   _luaG_runerror(i1, 1992, i2);
    37661. 

  37661.  }
    37662. 

  37662. }
    37663. 

  37663. function _io_popen(i1) {
    37664. 

  37664.  i1 = i1 | 0;
    37665. 

  37665.  var i2 = 0, i3 = 0, i4 = 0, i5 = 0;
    37666. 

  37666.  i2 = STACKTOP;
    37667. 

  37667.  STACKTOP = STACKTOP + 16 | 0;
    37668. 

  37668.  i3 = _luaL_checklstring(i1, 1, 0) | 0;
    37669. 

  37669.  _luaL_optlstring(i1, 2, 3480, 0) | 0;
    37670. 

  37670.  i5 = _lua_newuserdata(i1, 8) | 0;
    37671. 

  37671.  i4 = i5 + 4 | 0;
    37672. 

  37672.  HEAP32[i4 >> 2] = 0;
    37673. 

  37673.  _luaL_setmetatable(i1, 2832);
    37674. 

  37674.  _luaL_error(i1, 3488, i2) | 0;
    37675. 

  37675.  HEAP32[i5 >> 2] = 0;
    37676. 

  37676.  HEAP32[i4 >> 2] = 157;
    37677. 

  37677.  i1 = _luaL_fileresult(i1, 0, i3) | 0;
    37678. 

  37678.  STACKTOP = i2;
    37679. 

  37679.  return i1 | 0;
    37680. 

  37680. }
    37681. 

  37681. function _sort_comp(i1, i3, i4) {
    37682. 

  37682.  i1 = i1 | 0;
    37683. 

  37683.  i3 = i3 | 0;
    37684. 

  37684.  i4 = i4 | 0;
    37685. 

  37685.  var i2 = 0;
    37686. 

  37686.  i2 = STACKTOP;
    37687. 

  37687.  if ((_lua_type(i1, 2) | 0) == 0) {
    37688. 

  37688.   i4 = _lua_compare(i1, i3, i4, 1) | 0;
    37689. 

  37689.   STACKTOP = i2;
    37690. 

  37690.   return i4 | 0;
    37691. 

  37691.  } else {
    37692. 

  37692.   _lua_pushvalue(i1, 2);
    37693. 

  37693.   _lua_pushvalue(i1, i3 + -1 | 0);
    37694. 

  37694.   _lua_pushvalue(i1, i4 + -2 | 0);
    37695. 

  37695.   _lua_callk(i1, 2, 1, 0, 0);
    37696. 

  37696.   i4 = _lua_toboolean(i1, -1) | 0;
    37697. 

  37697.   _lua_settop(i1, -2);
    37698. 

  37698.   STACKTOP = i2;
    37699. 

  37699.   return i4 | 0;
    37700. 

  37700.  }
    37701. 

  37701.  return 0;
    37702. 

  37702. }
    37703. 

  37703. function _db_upvalueid(i1) {
    37704. 

  37704.  i1 = i1 | 0;
    37705. 

  37705.  var i2 = 0, i3 = 0, i4 = 0;
    37706. 

  37706.  i3 = STACKTOP;
    37707. 

  37707.  STACKTOP = STACKTOP + 112 | 0;
    37708. 

  37708.  i4 = i3;
    37709. 

  37709.  i2 = _luaL_checkinteger(i1, 2) | 0;
    37710. 

  37710.  _luaL_checktype(i1, 1, 6);
    37711. 

  37711.  _lua_pushvalue(i1, 1);
    37712. 

  37712.  _lua_getinfo(i1, 11728, i4) | 0;
    37713. 

  37713.  if (!((i2 | 0) > 0 ? (i2 | 0) <= (HEAPU8[i4 + 32 | 0] | 0 | 0) : 0)) {
    37714. 

  37714.   _luaL_argerror(i1, 2, 11736) | 0;
    37715. 

  37715.  }
    37716. 

  37716.  _lua_pushlightuserdata(i1, _lua_upvalueid(i1, 1, i2) | 0);
    37717. 

  37717.  STACKTOP = i3;
    37718. 

  37718.  return 1;
    37719. 

  37719. }
    37720. 

  37720. function _luaL_getmetafield(i2, i4, i3) {
    37721. 

  37721.  i2 = i2 | 0;
    37722. 

  37722.  i4 = i4 | 0;
    37723. 

  37723.  i3 = i3 | 0;
    37724. 

  37724.  var i1 = 0;
    37725. 

  37725.  i1 = STACKTOP;
    37726. 

  37726.  do {
    37727. 

  37727.   if ((_lua_getmetatable(i2, i4) | 0) != 0) {
    37728. 

  37728.    _lua_pushstring(i2, i3) | 0;
    37729. 

  37729.    _lua_rawget(i2, -2);
    37730. 

  37730.    if ((_lua_type(i2, -1) | 0) == 0) {
    37731. 

  37731.     _lua_settop(i2, -3);
    37732. 

  37732.     i2 = 0;
    37733. 

  37733.     break;
    37734. 

  37734.    } else {
    37735. 

  37735.     _lua_remove(i2, -2);
    37736. 

  37736.     i2 = 1;
    37737. 

  37737.     break;
    37738. 

  37738.    }
    37739. 

  37739.   } else {
    37740. 

  37740.    i2 = 0;
    37741. 

  37741.   }
    37742. 

  37742.  } while (0);
    37743. 

  37743.  STACKTOP = i1;
    37744. 

  37744.  return i2 | 0;
    37745. 

  37745. }
    37746. 

  37746. function _luaF_freeupval(i1, i3) {
    37747. 

  37747.  i1 = i1 | 0;
    37748. 

  37748.  i3 = i3 | 0;
    37749. 

  37749.  var i2 = 0, i4 = 0, i5 = 0;
    37750. 

  37750.  i2 = STACKTOP;
    37751. 

  37751.  if ((HEAP32[i3 + 8 >> 2] | 0) == (i3 + 16 | 0)) {
    37752. 

  37752.   _luaM_realloc_(i1, i3, 32, 0) | 0;
    37753. 

  37753.   STACKTOP = i2;
    37754. 

  37754.   return;
    37755. 

  37755.  }
    37756. 

  37756.  i4 = i3 + 16 | 0;
    37757. 

  37757.  i5 = i4 + 4 | 0;
    37758. 

  37758.  HEAP32[(HEAP32[i5 >> 2] | 0) + 16 >> 2] = HEAP32[i4 >> 2];
    37759. 

  37759.  HEAP32[(HEAP32[i4 >> 2] | 0) + 20 >> 2] = HEAP32[i5 >> 2];
    37760. 

  37760.  _luaM_realloc_(i1, i3, 32, 0) | 0;
    37761. 

  37761.  STACKTOP = i2;
    37762. 

  37762.  return;
    37763. 

  37763. }
    37764. 

  37764. function _luaL_addvalue(i1) {
    37765. 

  37765.  i1 = i1 | 0;
    37766. 

  37766.  var i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0;
    37767. 

  37767.  i2 = STACKTOP;
    37768. 

  37768.  STACKTOP = STACKTOP + 16 | 0;
    37769. 

  37769.  i4 = i2;
    37770. 

  37770.  i5 = HEAP32[i1 + 12 >> 2] | 0;
    37771. 

  37771.  i3 = _lua_tolstring(i5, -1, i4) | 0;
    37772. 

  37772.  i6 = i1 + 16 | 0;
    37773. 

  37773.  if ((HEAP32[i1 >> 2] | 0) != (i6 | 0)) {
    37774. 

  37774.   _lua_insert(i5, -2);
    37775. 

  37775.  }
    37776. 

  37776.  _luaL_addlstring(i1, i3, HEAP32[i4 >> 2] | 0);
    37777. 

  37777.  _lua_remove(i5, (HEAP32[i1 >> 2] | 0) != (i6 | 0) ? -2 : -1);
    37778. 

  37778.  STACKTOP = i2;
    37779. 

  37779.  return;
    37780. 

  37780. }
    37781. 

  37781. function _escerror(i1, i4, i3, i2) {
    37782. 

  37782.  i1 = i1 | 0;
    37783. 

  37783.  i4 = i4 | 0;
    37784. 

  37784.  i3 = i3 | 0;
    37785. 

  37785.  i2 = i2 | 0;
    37786. 

  37786.  var i5 = 0, i6 = 0;
    37787. 

  37787.  HEAP32[(HEAP32[i1 + 60 >> 2] | 0) + 4 >> 2] = 0;
    37788. 

  37788.  _save(i1, 92);
    37789. 

  37789.  L1 : do {
    37790. 

  37790.   if ((i3 | 0) > 0) {
    37791. 

  37791.    i5 = 0;
    37792. 

  37792.    do {
    37793. 

  37793.     i6 = HEAP32[i4 + (i5 << 2) >> 2] | 0;
    37794. 

  37794.     if ((i6 | 0) == -1) {
    37795. 

  37795.      break L1;
    37796. 

  37796.     }
    37797. 

  37797.     _save(i1, i6);
    37798. 

  37798.     i5 = i5 + 1 | 0;
    37799. 

  37799.    } while ((i5 | 0) < (i3 | 0));
    37800. 

  37800.   }
    37801. 

  37801.  } while (0);
    37802. 

  37802.  _lexerror(i1, i2, 289);
    37803. 

  37803. }
    37804. 

  37804. function _pushglobalfuncname(i1, i4) {
    37805. 

  37805.  i1 = i1 | 0;
    37806. 

  37806.  i4 = i4 | 0;
    37807. 

  37807.  var i2 = 0, i3 = 0;
    37808. 

  37808.  i2 = STACKTOP;
    37809. 

  37809.  i3 = _lua_gettop(i1) | 0;
    37810. 

  37810.  _lua_getinfo(i1, 1768, i4) | 0;
    37811. 

  37811.  _lua_rawgeti(i1, -1001e3, 2);
    37812. 

  37812.  i4 = i3 + 1 | 0;
    37813. 

  37813.  if ((_findfield(i1, i4, 2) | 0) == 0) {
    37814. 

  37814.   _lua_settop(i1, i3);
    37815. 

  37815.   i4 = 0;
    37816. 

  37816.   STACKTOP = i2;
    37817. 

  37817.   return i4 | 0;
    37818. 

  37818.  } else {
    37819. 

  37819.   _lua_copy(i1, -1, i4);
    37820. 

  37820.   _lua_settop(i1, -3);
    37821. 

  37821.   i4 = 1;
    37822. 

  37822.   STACKTOP = i2;
    37823. 

  37823.   return i4 | 0;
    37824. 

  37824.  }
    37825. 

  37825.  return 0;
    37826. 

  37826. }
    37827. 

  37827. function copyTempDouble(i1) {
    37828. 

  37828.  i1 = i1 | 0;
    37829. 

  37829.  HEAP8[tempDoublePtr] = HEAP8[i1];
    37830. 

  37830.  HEAP8[tempDoublePtr + 1 | 0] = HEAP8[i1 + 1 | 0];
    37831. 

  37831.  HEAP8[tempDoublePtr + 2 | 0] = HEAP8[i1 + 2 | 0];
    37832. 

  37832.  HEAP8[tempDoublePtr + 3 | 0] = HEAP8[i1 + 3 | 0];
    37833. 

  37833.  HEAP8[tempDoublePtr + 4 | 0] = HEAP8[i1 + 4 | 0];
    37834. 

  37834.  HEAP8[tempDoublePtr + 5 | 0] = HEAP8[i1 + 5 | 0];
    37835. 

  37835.  HEAP8[tempDoublePtr + 6 | 0] = HEAP8[i1 + 6 | 0];
    37836. 

  37836.  HEAP8[tempDoublePtr + 7 | 0] = HEAP8[i1 + 7 | 0];
    37837. 

  37837. }
    37838. 

  37838. function _lua_pushlstring(i1, i3, i4) {
    37839. 

  37839.  i1 = i1 | 0;
    37840. 

  37840.  i3 = i3 | 0;
    37841. 

  37841.  i4 = i4 | 0;
    37842. 

  37842.  var i2 = 0;
    37843. 

  37843.  i2 = STACKTOP;
    37844. 

  37844.  if ((HEAP32[(HEAP32[i1 + 12 >> 2] | 0) + 12 >> 2] | 0) > 0) {
    37845. 

  37845.   _luaC_step(i1);
    37846. 

  37846.  }
    37847. 

  37847.  i4 = _luaS_newlstr(i1, i3, i4) | 0;
    37848. 

  37848.  i3 = i1 + 8 | 0;
    37849. 

  37849.  i1 = HEAP32[i3 >> 2] | 0;
    37850. 

  37850.  HEAP32[i1 >> 2] = i4;
    37851. 

  37851.  HEAP32[i1 + 8 >> 2] = HEAPU8[i4 + 4 | 0] | 0 | 64;
    37852. 

  37852.  HEAP32[i3 >> 2] = (HEAP32[i3 >> 2] | 0) + 16;
    37853. 

  37853.  STACKTOP = i2;
    37854. 

  37854.  return i4 + 16 | 0;
    37855. 

  37855. }
    37856. 

  37856. function _ll_searchpath(i1) {
    37857. 

  37857.  i1 = i1 | 0;
    37858. 

  37858.  var i2 = 0, i3 = 0, i4 = 0, i5 = 0;
    37859. 

  37859.  i2 = STACKTOP;
    37860. 

  37860.  i5 = _luaL_checklstring(i1, 1, 0) | 0;
    37861. 

  37861.  i4 = _luaL_checklstring(i1, 2, 0) | 0;
    37862. 

  37862.  i3 = _luaL_optlstring(i1, 3, 4936, 0) | 0;
    37863. 

  37863.  if ((_searchpath(i1, i5, i4, i3, _luaL_optlstring(i1, 4, 4848, 0) | 0) | 0) != 0) {
    37864. 

  37864.   i5 = 1;
    37865. 

  37865.   STACKTOP = i2;
    37866. 

  37866.   return i5 | 0;
    37867. 

  37867.  }
    37868. 

  37868.  _lua_pushnil(i1);
    37869. 

  37869.  _lua_insert(i1, -2);
    37870. 

  37870.  i5 = 2;
    37871. 

  37871.  STACKTOP = i2;
    37872. 

  37872.  return i5 | 0;
    37873. 

  37873. }
    37874. 

  37874. function _math_log(i1) {
    37875. 

  37875.  i1 = i1 | 0;
    37876. 

  37876.  var i2 = 0, d3 = 0.0, d4 = 0.0;
    37877. 

  37877.  i2 = STACKTOP;
    37878. 

  37878.  d3 = +_luaL_checknumber(i1, 1);
    37879. 

  37879.  do {
    37880. 

  37880.   if ((_lua_type(i1, 2) | 0) >= 1) {
    37881. 

  37881.    d4 = +_luaL_checknumber(i1, 2);
    37882. 

  37882.    if (d4 == 10.0) {
    37883. 

  37883.     d3 = +_log10(+d3);
    37884. 

  37884.     break;
    37885. 

  37885.    } else {
    37886. 

  37886.     d3 = +Math_log(+d3) / +Math_log(+d4);
    37887. 

  37887.     break;
    37888. 

  37888.    }
    37889. 

  37889.   } else {
    37890. 

  37890.    d3 = +Math_log(+d3);
    37891. 

  37891.   }
    37892. 

  37892.  } while (0);
    37893. 

  37893.  _lua_pushnumber(i1, d3);
    37894. 

  37894.  STACKTOP = i2;
    37895. 

  37895.  return 1;
    37896. 

  37896. }
    37897. 

  37897. function _luaT_init(i1) {
    37898. 

  37898.  i1 = i1 | 0;
    37899. 

  37899.  var i2 = 0, i3 = 0, i4 = 0, i5 = 0;
    37900. 

  37900.  i2 = STACKTOP;
    37901. 

  37901.  i3 = i1 + 12 | 0;
    37902. 

  37902.  i4 = 0;
    37903. 

  37903.  do {
    37904. 

  37904.   i5 = _luaS_new(i1, HEAP32[8576 + (i4 << 2) >> 2] | 0) | 0;
    37905. 

  37905.   HEAP32[(HEAP32[i3 >> 2] | 0) + (i4 << 2) + 184 >> 2] = i5;
    37906. 

  37906.   i5 = (HEAP32[(HEAP32[i3 >> 2] | 0) + (i4 << 2) + 184 >> 2] | 0) + 5 | 0;
    37907. 

  37907.   HEAP8[i5] = HEAPU8[i5] | 0 | 32;
    37908. 

  37908.   i4 = i4 + 1 | 0;
    37909. 

  37909.  } while ((i4 | 0) != 17);
    37910. 

  37910.  STACKTOP = i2;
    37911. 

  37911.  return;
    37912. 

  37912. }
    37913. 

  37913. function _f_gc(i1) {
    37914. 

  37914.  i1 = i1 | 0;
    37915. 

  37915.  var i2 = 0, i3 = 0, i4 = 0;
    37916. 

  37916.  i2 = STACKTOP;
    37917. 

  37917.  i3 = _luaL_checkudata(i1, 1, 2832) | 0;
    37918. 

  37918.  if ((HEAP32[i3 + 4 >> 2] | 0) == 0) {
    37919. 

  37919.   STACKTOP = i2;
    37920. 

  37920.   return 0;
    37921. 

  37921.  }
    37922. 

  37922.  if ((HEAP32[i3 >> 2] | 0) == 0) {
    37923. 

  37923.   STACKTOP = i2;
    37924. 

  37924.   return 0;
    37925. 

  37925.  }
    37926. 

  37926.  i4 = (_luaL_checkudata(i1, 1, 2832) | 0) + 4 | 0;
    37927. 

  37927.  i3 = HEAP32[i4 >> 2] | 0;
    37928. 

  37928.  HEAP32[i4 >> 2] = 0;
    37929. 

  37929.  FUNCTION_TABLE_ii[i3 & 255](i1) | 0;
    37930. 

  37930.  STACKTOP = i2;
    37931. 

  37931.  return 0;
    37932. 

  37932. }
    37933. 

  37933. function ___shlim(i1, i5) {
    37934. 

  37934.  i1 = i1 | 0;
    37935. 

  37935.  i5 = i5 | 0;
    37936. 

  37936.  var i2 = 0, i3 = 0, i4 = 0, i6 = 0;
    37937. 

  37937.  i2 = STACKTOP;
    37938. 

  37938.  HEAP32[i1 + 104 >> 2] = i5;
    37939. 

  37939.  i4 = HEAP32[i1 + 8 >> 2] | 0;
    37940. 

  37940.  i3 = HEAP32[i1 + 4 >> 2] | 0;
    37941. 

  37941.  i6 = i4 - i3 | 0;
    37942. 

  37942.  HEAP32[i1 + 108 >> 2] = i6;
    37943. 

  37943.  if ((i5 | 0) != 0 & (i6 | 0) > (i5 | 0)) {
    37944. 

  37944.   HEAP32[i1 + 100 >> 2] = i3 + i5;
    37945. 

  37945.   STACKTOP = i2;
    37946. 

  37946.   return;
    37947. 

  37947.  } else {
    37948. 

  37948.   HEAP32[i1 + 100 >> 2] = i4;
    37949. 

  37949.   STACKTOP = i2;
    37950. 

  37950.   return;
    37951. 

  37951.  }
    37952. 

  37952. }
    37953. 

  37953. function _lua_sethook(i4, i6, i1, i5) {
    37954. 

  37954.  i4 = i4 | 0;
    37955. 

  37955.  i6 = i6 | 0;
    37956. 

  37956.  i1 = i1 | 0;
    37957. 

  37957.  i5 = i5 | 0;
    37958. 

  37958.  var i2 = 0, i3 = 0;
    37959. 

  37959.  i2 = (i6 | 0) == 0 | (i1 | 0) == 0;
    37960. 

  37960.  i3 = HEAP32[i4 + 16 >> 2] | 0;
    37961. 

  37961.  if (!((HEAP8[i3 + 18 | 0] & 1) == 0)) {
    37962. 

  37962.   HEAP32[i4 + 20 >> 2] = HEAP32[i3 + 28 >> 2];
    37963. 

  37963.  }
    37964. 

  37964.  HEAP32[i4 + 52 >> 2] = i2 ? 0 : i6;
    37965. 

  37965.  HEAP32[i4 + 44 >> 2] = i5;
    37966. 

  37966.  HEAP32[i4 + 48 >> 2] = i5;
    37967. 

  37967.  HEAP8[i4 + 40 | 0] = i2 ? 0 : i1 & 255;
    37968. 

  37968.  return 1;
    37969. 

  37969. }
    37970. 

  37970. function _io_tmpfile(i1) {
    37971. 

  37971.  i1 = i1 | 0;
    37972. 

  37972.  var i2 = 0, i3 = 0, i4 = 0;
    37973. 

  37973.  i2 = STACKTOP;
    37974. 

  37974.  i4 = _lua_newuserdata(i1, 8) | 0;
    37975. 

  37975.  i3 = i4 + 4 | 0;
    37976. 

  37976.  HEAP32[i3 >> 2] = 0;
    37977. 

  37977.  _luaL_setmetatable(i1, 2832);
    37978. 

  37978.  HEAP32[i4 >> 2] = 0;
    37979. 

  37979.  HEAP32[i3 >> 2] = 156;
    37980. 

  37980.  i3 = _tmpfile() | 0;
    37981. 

  37981.  HEAP32[i4 >> 2] = i3;
    37982. 

  37982.  if ((i3 | 0) != 0) {
    37983. 

  37983.   i4 = 1;
    37984. 

  37984.   STACKTOP = i2;
    37985. 

  37985.   return i4 | 0;
    37986. 

  37986.  }
    37987. 

  37987.  i4 = _luaL_fileresult(i1, 0, 0) | 0;
    37988. 

  37988.  STACKTOP = i2;
    37989. 

  37989.  return i4 | 0;
    37990. 

  37990. }
    37991. 

  37991. function _luaL_checkstack(i1, i5, i4) {
    37992. 

  37992.  i1 = i1 | 0;
    37993. 

  37993.  i5 = i5 | 0;
    37994. 

  37994.  i4 = i4 | 0;
    37995. 

  37995.  var i2 = 0, i3 = 0;
    37996. 

  37996.  i2 = STACKTOP;
    37997. 

  37997.  STACKTOP = STACKTOP + 16 | 0;
    37998. 

  37998.  i3 = i2;
    37999. 

  37999.  if ((_lua_checkstack(i1, i5 + 20 | 0) | 0) != 0) {
    38000. 

  38000.   STACKTOP = i2;
    38001. 

  38001.   return;
    38002. 

  38002.  }
    38003. 

  38003.  if ((i4 | 0) == 0) {
    38004. 

  38004.   _luaL_error(i1, 1240, i3) | 0;
    38005. 

  38005.   STACKTOP = i2;
    38006. 

  38006.   return;
    38007. 

  38007.  } else {
    38008. 

  38008.   HEAP32[i3 >> 2] = i4;
    38009. 

  38009.   _luaL_error(i1, 1216, i3) | 0;
    38010. 

  38010.   STACKTOP = i2;
    38011. 

  38011.   return;
    38012. 

  38012.  }
    38013. 

  38013. }
    38014. 

  38014. function _b_rshift(i1) {
    38015. 

  38015.  i1 = i1 | 0;
    38016. 

  38016.  var i2 = 0, i3 = 0, i4 = 0, i5 = 0;
    38017. 

  38017.  i2 = STACKTOP;
    38018. 

  38018.  i4 = _luaL_checkunsigned(i1, 1) | 0;
    38019. 

  38019.  i3 = _luaL_checkinteger(i1, 2) | 0;
    38020. 

  38020.  i5 = 0 - i3 | 0;
    38021. 

  38021.  if ((i3 | 0) > 0) {
    38022. 

  38022.   i5 = (i3 | 0) > 31 ? 0 : i4 >>> i3;
    38023. 

  38023.   _lua_pushunsigned(i1, i5);
    38024. 

  38024.   STACKTOP = i2;
    38025. 

  38025.   return 1;
    38026. 

  38026.  } else {
    38027. 

  38027.   i5 = (i5 | 0) > 31 ? 0 : i4 << i5;
    38028. 

  38028.   _lua_pushunsigned(i1, i5);
    38029. 

  38029.   STACKTOP = i2;
    38030. 

  38030.   return 1;
    38031. 

  38031.  }
    38032. 

  38032.  return 0;
    38033. 

  38033. }
    38034. 

  38034. function _b_lshift(i1) {
    38035. 

  38035.  i1 = i1 | 0;
    38036. 

  38036.  var i2 = 0, i3 = 0, i4 = 0;
    38037. 

  38037.  i2 = STACKTOP;
    38038. 

  38038.  i3 = _luaL_checkunsigned(i1, 1) | 0;
    38039. 

  38039.  i4 = _luaL_checkinteger(i1, 2) | 0;
    38040. 

  38040.  if ((i4 | 0) < 0) {
    38041. 

  38041.   i4 = 0 - i4 | 0;
    38042. 

  38042.   i4 = (i4 | 0) > 31 ? 0 : i3 >>> i4;
    38043. 

  38043.   _lua_pushunsigned(i1, i4);
    38044. 

  38044.   STACKTOP = i2;
    38045. 

  38045.   return 1;
    38046. 

  38046.  } else {
    38047. 

  38047.   i4 = (i4 | 0) > 31 ? 0 : i3 << i4;
    38048. 

  38048.   _lua_pushunsigned(i1, i4);
    38049. 

  38049.   STACKTOP = i2;
    38050. 

  38050.   return 1;
    38051. 

  38051.  }
    38052. 

  38052.  return 0;
    38053. 

  38053. }
    38054. 

  38054. function _math_min(i1) {
    38055. 

  38055.  i1 = i1 | 0;
    38056. 

  38056.  var i2 = 0, i3 = 0, i4 = 0, d5 = 0.0, d6 = 0.0;
    38057. 

  38057.  i2 = STACKTOP;
    38058. 

  38058.  i3 = _lua_gettop(i1) | 0;
    38059. 

  38059.  d5 = +_luaL_checknumber(i1, 1);
    38060. 

  38060.  if ((i3 | 0) >= 2) {
    38061. 

  38061.   i4 = 2;
    38062. 

  38062.   while (1) {
    38063. 

  38063.    d6 = +_luaL_checknumber(i1, i4);
    38064. 

  38064.    d5 = d6 < d5 ? d6 : d5;
    38065. 

  38065.    if ((i4 | 0) == (i3 | 0)) {
    38066. 

  38066.     break;
    38067. 

  38067.    } else {
    38068. 

  38068.     i4 = i4 + 1 | 0;
    38069. 

  38069.    }
    38070. 

  38070.   }
    38071. 

  38071.  }
    38072. 

  38072.  _lua_pushnumber(i1, d5);
    38073. 

  38073.  STACKTOP = i2;
    38074. 

  38074.  return 1;
    38075. 

  38075. }
    38076. 

  38076. function _math_max(i1) {
    38077. 

  38077.  i1 = i1 | 0;
    38078. 

  38078.  var i2 = 0, i3 = 0, i4 = 0, d5 = 0.0, d6 = 0.0;
    38079. 

  38079.  i2 = STACKTOP;
    38080. 

  38080.  i3 = _lua_gettop(i1) | 0;
    38081. 

  38081.  d5 = +_luaL_checknumber(i1, 1);
    38082. 

  38082.  if ((i3 | 0) >= 2) {
    38083. 

  38083.   i4 = 2;
    38084. 

  38084.   while (1) {
    38085. 

  38085.    d6 = +_luaL_checknumber(i1, i4);
    38086. 

  38086.    d5 = d6 > d5 ? d6 : d5;
    38087. 

  38087.    if ((i4 | 0) == (i3 | 0)) {
    38088. 

  38088.     break;
    38089. 

  38089.    } else {
    38090. 

  38090.     i4 = i4 + 1 | 0;
    38091. 

  38091.    }
    38092. 

  38092.   }
    38093. 

  38093.  }
    38094. 

  38094.  _lua_pushnumber(i1, d5);
    38095. 

  38095.  STACKTOP = i2;
    38096. 

  38096.  return 1;
    38097. 

  38097. }
    38098. 

  38098. function _io_type(i1) {
    38099. 

  38099.  i1 = i1 | 0;
    38100. 

  38100.  var i2 = 0, i3 = 0;
    38101. 

  38101.  i2 = STACKTOP;
    38102. 

  38102.  _luaL_checkany(i1, 1);
    38103. 

  38103.  i3 = _luaL_testudata(i1, 1, 2832) | 0;
    38104. 

  38104.  if ((i3 | 0) == 0) {
    38105. 

  38105.   _lua_pushnil(i1);
    38106. 

  38106.   STACKTOP = i2;
    38107. 

  38107.   return 1;
    38108. 

  38108.  }
    38109. 

  38109.  if ((HEAP32[i3 + 4 >> 2] | 0) == 0) {
    38110. 

  38110.   _lua_pushlstring(i1, 3456, 11) | 0;
    38111. 

  38111.   STACKTOP = i2;
    38112. 

  38112.   return 1;
    38113. 

  38113.  } else {
    38114. 

  38114.   _lua_pushlstring(i1, 3472, 4) | 0;
    38115. 

  38115.   STACKTOP = i2;
    38116. 

  38116.   return 1;
    38117. 

  38117.  }
    38118. 

  38118.  return 0;
    38119. 

  38119. }
    38120. 

  38120. function _luaF_newLclosure(i3, i2) {
    38121. 

  38121.  i3 = i3 | 0;
    38122. 

  38122.  i2 = i2 | 0;
    38123. 

  38123.  var i1 = 0, i4 = 0;
    38124. 

  38124.  i1 = STACKTOP;
    38125. 

  38125.  i3 = _luaC_newobj(i3, 6, (i2 << 2) + 16 | 0, 0, 0) | 0;
    38126. 

  38126.  HEAP32[i3 + 12 >> 2] = 0;
    38127. 

  38127.  HEAP8[i3 + 6 | 0] = i2;
    38128. 

  38128.  if ((i2 | 0) == 0) {
    38129. 

  38129.   STACKTOP = i1;
    38130. 

  38130.   return i3 | 0;
    38131. 

  38131.  }
    38132. 

  38132.  i4 = i3 + 16 | 0;
    38133. 

  38133.  do {
    38134. 

  38134.   i2 = i2 + -1 | 0;
    38135. 

  38135.   HEAP32[i4 + (i2 << 2) >> 2] = 0;
    38136. 

  38136.  } while ((i2 | 0) != 0);
    38137. 

  38137.  STACKTOP = i1;
    38138. 

  38138.  return i3 | 0;
    38139. 

  38139. }
    38140. 

  38140. function _io_flush(i1) {
    38141. 

  38141.  i1 = i1 | 0;
    38142. 

  38142.  var i2 = 0, i3 = 0, i4 = 0;
    38143. 

  38143.  i2 = STACKTOP;
    38144. 

  38144.  STACKTOP = STACKTOP + 16 | 0;
    38145. 

  38145.  i4 = i2;
    38146. 

  38146.  _lua_getfield(i1, -1001e3, 2800);
    38147. 

  38147.  i3 = _lua_touserdata(i1, -1) | 0;
    38148. 

  38148.  if ((HEAP32[i3 + 4 >> 2] | 0) == 0) {
    38149. 

  38149.   HEAP32[i4 >> 2] = 2804;
    38150. 

  38150.   _luaL_error(i1, 3424, i4) | 0;
    38151. 

  38151.  }
    38152. 

  38152.  i4 = _luaL_fileresult(i1, (_fflush(HEAP32[i3 >> 2] | 0) | 0) == 0 | 0, 0) | 0;
    38153. 

  38153.  STACKTOP = i2;
    38154. 

  38154.  return i4 | 0;
    38155. 

  38155. }
    38156. 

  38156. function _b_test(i1) {
    38157. 

  38157.  i1 = i1 | 0;
    38158. 

  38158.  var i2 = 0, i3 = 0, i4 = 0, i5 = 0;
    38159. 

  38159.  i2 = STACKTOP;
    38160. 

  38160.  i3 = _lua_gettop(i1) | 0;
    38161. 

  38161.  if ((i3 | 0) < 1) {
    38162. 

  38162.   i3 = 1;
    38163. 

  38163.  } else {
    38164. 

  38164.   i4 = 1;
    38165. 

  38165.   i5 = -1;
    38166. 

  38166.   while (1) {
    38167. 

  38167.    i5 = (_luaL_checkunsigned(i1, i4) | 0) & i5;
    38168. 

  38168.    if ((i4 | 0) == (i3 | 0)) {
    38169. 

  38169.     break;
    38170. 

  38170.    } else {
    38171. 

  38171.     i4 = i4 + 1 | 0;
    38172. 

  38172.    }
    38173. 

  38173.   }
    38174. 

  38174.   i3 = (i5 | 0) != 0;
    38175. 

  38175.  }
    38176. 

  38176.  _lua_pushboolean(i1, i3 & 1);
    38177. 

  38177.  STACKTOP = i2;
    38178. 

  38178.  return 1;
    38179. 

  38179. }
    38180. 

  38180. function ___muldsi3(i2, i1) {
    38181. 

  38181.  i2 = i2 | 0;
    38182. 

  38182.  i1 = i1 | 0;
    38183. 

  38183.  var i3 = 0, i4 = 0, i5 = 0, i6 = 0;
    38184. 

  38184.  i6 = i2 & 65535;
    38185. 

  38185.  i4 = i1 & 65535;
    38186. 

  38186.  i3 = Math_imul(i4, i6) | 0;
    38187. 

  38187.  i5 = i2 >>> 16;
    38188. 

  38188.  i4 = (i3 >>> 16) + (Math_imul(i4, i5) | 0) | 0;
    38189. 

  38189.  i1 = i1 >>> 16;
    38190. 

  38190.  i2 = Math_imul(i1, i6) | 0;
    38191. 

  38191.  return (tempRet0 = (i4 >>> 16) + (Math_imul(i1, i5) | 0) + (((i4 & 65535) + i2 | 0) >>> 16) | 0, i4 + i2 << 16 | i3 & 65535 | 0) | 0;
    38192. 

  38192. }
    38193. 

  38193. function _str_dump(i1) {
    38194. 

  38194.  i1 = i1 | 0;
    38195. 

  38195.  var i2 = 0, i3 = 0;
    38196. 

  38196.  i2 = STACKTOP;
    38197. 

  38197.  STACKTOP = STACKTOP + 1056 | 0;
    38198. 

  38198.  i3 = i2 + 8 | 0;
    38199. 

  38199.  _luaL_checktype(i1, 1, 6);
    38200. 

  38200.  _lua_settop(i1, 1);
    38201. 

  38201.  _luaL_buffinit(i1, i3);
    38202. 

  38202.  if ((_lua_dump(i1, 2, i3) | 0) == 0) {
    38203. 

  38203.   _luaL_pushresult(i3);
    38204. 

  38204.   i3 = 1;
    38205. 

  38205.   STACKTOP = i2;
    38206. 

  38206.   return i3 | 0;
    38207. 

  38207.  } else {
    38208. 

  38208.   i3 = _luaL_error(i1, 7888, i2) | 0;
    38209. 

  38209.   STACKTOP = i2;
    38210. 

  38210.   return i3 | 0;
    38211. 

  38211.  }
    38212. 

  38212.  return 0;
    38213. 

  38213. }
    38214. 

  38214. function ___memrchr(i2, i3, i5) {
    38215. 

  38215.  i2 = i2 | 0;
    38216. 

  38216.  i3 = i3 | 0;
    38217. 

  38217.  i5 = i5 | 0;
    38218. 

  38218.  var i1 = 0, i4 = 0;
    38219. 

  38219.  i1 = STACKTOP;
    38220. 

  38220.  i3 = i3 & 255;
    38221. 

  38221.  while (1) {
    38222. 

  38222.   i4 = i5 + -1 | 0;
    38223. 

  38223.   if ((i5 | 0) == 0) {
    38224. 

  38224.    i5 = 0;
    38225. 

  38225.    i2 = 4;
    38226. 

  38226.    break;
    38227. 

  38227.   }
    38228. 

  38228.   i5 = i2 + i4 | 0;
    38229. 

  38229.   if ((HEAP8[i5] | 0) == i3 << 24 >> 24) {
    38230. 

  38230.    i2 = 4;
    38231. 

  38231.    break;
    38232. 

  38232.   } else {
    38233. 

  38233.    i5 = i4;
    38234. 

  38234.   }
    38235. 

  38235.  }
    38236. 

  38236.  if ((i2 | 0) == 4) {
    38237. 

  38237.   STACKTOP = i1;
    38238. 

  38238.   return i5 | 0;
    38239. 

  38239.  }
    38240. 

  38240.  return 0;
    38241. 

  38241. }
    38242. 

  38242. function _luaL_getsubtable(i1, i3, i4) {
    38243. 

  38243.  i1 = i1 | 0;
    38244. 

  38244.  i3 = i3 | 0;
    38245. 

  38245.  i4 = i4 | 0;
    38246. 

  38246.  var i2 = 0;
    38247. 

  38247.  i2 = STACKTOP;
    38248. 

  38248.  _lua_getfield(i1, i3, i4);
    38249. 

  38249.  if ((_lua_type(i1, -1) | 0) == 5) {
    38250. 

  38250.   i4 = 1;
    38251. 

  38251.   STACKTOP = i2;
    38252. 

  38252.   return i4 | 0;
    38253. 

  38253.  }
    38254. 

  38254.  _lua_settop(i1, -2);
    38255. 

  38255.  i3 = _lua_absindex(i1, i3) | 0;
    38256. 

  38256.  _lua_createtable(i1, 0, 0);
    38257. 

  38257.  _lua_pushvalue(i1, -1);
    38258. 

  38258.  _lua_setfield(i1, i3, i4);
    38259. 

  38259.  i4 = 0;
    38260. 

  38260.  STACKTOP = i2;
    38261. 

  38261.  return i4 | 0;
    38262. 

  38262. }
    38263. 

  38263. function _luaE_freeCI(i1) {
    38264. 

  38264.  i1 = i1 | 0;
    38265. 

  38265.  var i2 = 0, i3 = 0, i4 = 0;
    38266. 

  38266.  i2 = STACKTOP;
    38267. 

  38267.  i4 = (HEAP32[i1 + 16 >> 2] | 0) + 12 | 0;
    38268. 

  38268.  i3 = HEAP32[i4 >> 2] | 0;
    38269. 

  38269.  HEAP32[i4 >> 2] = 0;
    38270. 

  38270.  if ((i3 | 0) == 0) {
    38271. 

  38271.   STACKTOP = i2;
    38272. 

  38272.   return;
    38273. 

  38273.  }
    38274. 

  38274.  while (1) {
    38275. 

  38275.   i4 = HEAP32[i3 + 12 >> 2] | 0;
    38276. 

  38276.   _luaM_realloc_(i1, i3, 40, 0) | 0;
    38277. 

  38277.   if ((i4 | 0) == 0) {
    38278. 

  38278.    break;
    38279. 

  38279.   } else {
    38280. 

  38280.    i3 = i4;
    38281. 

  38281.   }
    38282. 

  38282.  }
    38283. 

  38283.  STACKTOP = i2;
    38284. 

  38284.  return;
    38285. 

  38285. }
    38286. 

  38286. function _f_tostring(i1) {
    38287. 

  38287.  i1 = i1 | 0;
    38288. 

  38288.  var i2 = 0, i3 = 0, i4 = 0;
    38289. 

  38289.  i2 = STACKTOP;
    38290. 

  38290.  STACKTOP = STACKTOP + 16 | 0;
    38291. 

  38291.  i3 = i2;
    38292. 

  38292.  i4 = _luaL_checkudata(i1, 1, 2832) | 0;
    38293. 

  38293.  if ((HEAP32[i4 + 4 >> 2] | 0) == 0) {
    38294. 

  38294.   _lua_pushlstring(i1, 3040, 13) | 0;
    38295. 

  38295.   STACKTOP = i2;
    38296. 

  38296.   return 1;
    38297. 

  38297.  } else {
    38298. 

  38298.   HEAP32[i3 >> 2] = HEAP32[i4 >> 2];
    38299. 

  38299.   _lua_pushfstring(i1, 3056, i3) | 0;
    38300. 

  38300.   STACKTOP = i2;
    38301. 

  38301.   return 1;
    38302. 

  38302.  }
    38303. 

  38303.  return 0;
    38304. 

  38304. }
    38305. 

  38305. function _lua_newuserdata(i1, i3) {
    38306. 

  38306.  i1 = i1 | 0;
    38307. 

  38307.  i3 = i3 | 0;
    38308. 

  38308.  var i2 = 0, i4 = 0;
    38309. 

  38309.  i2 = STACKTOP;
    38310. 

  38310.  if ((HEAP32[(HEAP32[i1 + 12 >> 2] | 0) + 12 >> 2] | 0) > 0) {
    38311. 

  38311.   _luaC_step(i1);
    38312. 

  38312.  }
    38313. 

  38313.  i3 = _luaS_newudata(i1, i3, 0) | 0;
    38314. 

  38314.  i1 = i1 + 8 | 0;
    38315. 

  38315.  i4 = HEAP32[i1 >> 2] | 0;
    38316. 

  38316.  HEAP32[i4 >> 2] = i3;
    38317. 

  38317.  HEAP32[i4 + 8 >> 2] = 71;
    38318. 

  38318.  HEAP32[i1 >> 2] = (HEAP32[i1 >> 2] | 0) + 16;
    38319. 

  38319.  STACKTOP = i2;
    38320. 

  38320.  return i3 + 24 | 0;
    38321. 

  38321. }
    38322. 

  38322. function _luaL_pushresultsize(i1, i3) {
    38323. 

  38323.  i1 = i1 | 0;
    38324. 

  38324.  i3 = i3 | 0;
    38325. 

  38325.  var i2 = 0, i4 = 0, i5 = 0;
    38326. 

  38326.  i2 = STACKTOP;
    38327. 

  38327.  i5 = i1 + 8 | 0;
    38328. 

  38328.  i4 = (HEAP32[i5 >> 2] | 0) + i3 | 0;
    38329. 

  38329.  HEAP32[i5 >> 2] = i4;
    38330. 

  38330.  i3 = HEAP32[i1 + 12 >> 2] | 0;
    38331. 

  38331.  _lua_pushlstring(i3, HEAP32[i1 >> 2] | 0, i4) | 0;
    38332. 

  38332.  if ((HEAP32[i1 >> 2] | 0) == (i1 + 16 | 0)) {
    38333. 

  38333.   STACKTOP = i2;
    38334. 

  38334.   return;
    38335. 

  38335.  }
    38336. 

  38336.  _lua_remove(i3, -2);
    38337. 

  38337.  STACKTOP = i2;
    38338. 

  38338.  return;
    38339. 

  38339. }
    38340. 

  38340. function _luaL_testudata(i2, i5, i4) {
    38341. 

  38341.  i2 = i2 | 0;
    38342. 

  38342.  i5 = i5 | 0;
    38343. 

  38343.  i4 = i4 | 0;
    38344. 

  38344.  var i1 = 0, i3 = 0;
    38345. 

  38345.  i1 = STACKTOP;
    38346. 

  38346.  i3 = _lua_touserdata(i2, i5) | 0;
    38347. 

  38347.  if ((i3 | 0) != 0 ? (_lua_getmetatable(i2, i5) | 0) != 0 : 0) {
    38348. 

  38348.   _lua_getfield(i2, -1001e3, i4);
    38349. 

  38349.   i5 = (_lua_rawequal(i2, -1, -2) | 0) == 0;
    38350. 

  38350.   _lua_settop(i2, -3);
    38351. 

  38351.   i2 = i5 ? 0 : i3;
    38352. 

  38352.  } else {
    38353. 

  38353.   i2 = 0;
    38354. 

  38354.  }
    38355. 

  38355.  STACKTOP = i1;
    38356. 

  38356.  return i2 | 0;
    38357. 

  38357. }
    38358. 

  38358. function _finishpcall(i1, i3) {
    38359. 

  38359.  i1 = i1 | 0;
    38360. 

  38360.  i3 = i3 | 0;
    38361. 

  38361.  var i2 = 0;
    38362. 

  38362.  i2 = STACKTOP;
    38363. 

  38363.  if ((_lua_checkstack(i1, 1) | 0) == 0) {
    38364. 

  38364.   _lua_settop(i1, 0);
    38365. 

  38365.   _lua_pushboolean(i1, 0);
    38366. 

  38366.   _lua_pushstring(i1, 9632) | 0;
    38367. 

  38367.   i3 = 2;
    38368. 

  38368.   STACKTOP = i2;
    38369. 

  38369.   return i3 | 0;
    38370. 

  38370.  } else {
    38371. 

  38371.   _lua_pushboolean(i1, i3);
    38372. 

  38372.   _lua_replace(i1, 1);
    38373. 

  38373.   i3 = _lua_gettop(i1) | 0;
    38374. 

  38374.   STACKTOP = i2;
    38375. 

  38375.   return i3 | 0;
    38376. 

  38376.  }
    38377. 

  38377.  return 0;
    38378. 

  38378. }
    38379. 

  38379. function _searcher_preload(i1) {
    38380. 

  38380.  i1 = i1 | 0;
    38381. 

  38381.  var i2 = 0, i3 = 0, i4 = 0;
    38382. 

  38382.  i2 = STACKTOP;
    38383. 

  38383.  STACKTOP = STACKTOP + 16 | 0;
    38384. 

  38384.  i4 = i2;
    38385. 

  38385.  i3 = _luaL_checklstring(i1, 1, 0) | 0;
    38386. 

  38386.  _lua_getfield(i1, -1001e3, 4592);
    38387. 

  38387.  _lua_getfield(i1, -1, i3);
    38388. 

  38388.  if ((_lua_type(i1, -1) | 0) != 0) {
    38389. 

  38389.   STACKTOP = i2;
    38390. 

  38390.   return 1;
    38391. 

  38391.  }
    38392. 

  38392.  HEAP32[i4 >> 2] = i3;
    38393. 

  38393.  _lua_pushfstring(i1, 5096, i4) | 0;
    38394. 

  38394.  STACKTOP = i2;
    38395. 

  38395.  return 1;
    38396. 

  38396. }
    38397. 

  38397. function _luaB_auxwrap(i1) {
    38398. 

  38398.  i1 = i1 | 0;
    38399. 

  38399.  var i2 = 0, i3 = 0;
    38400. 

  38400.  i3 = STACKTOP;
    38401. 

  38401.  i2 = _lua_tothread(i1, -1001001) | 0;
    38402. 

  38402.  i2 = _auxresume(i1, i2, _lua_gettop(i1) | 0) | 0;
    38403. 

  38403.  if ((i2 | 0) >= 0) {
    38404. 

  38404.   STACKTOP = i3;
    38405. 

  38405.   return i2 | 0;
    38406. 

  38406.  }
    38407. 

  38407.  if ((_lua_isstring(i1, -1) | 0) == 0) {
    38408. 

  38408.   _lua_error(i1) | 0;
    38409. 

  38409.  }
    38410. 

  38410.  _luaL_where(i1, 1);
    38411. 

  38411.  _lua_insert(i1, -2);
    38412. 

  38412.  _lua_concat(i1, 2);
    38413. 

  38413.  _lua_error(i1) | 0;
    38414. 

  38414.  return 0;
    38415. 

  38415. }
    38416. 

  38416. function _ll_loadlib(i1) {
    38417. 

  38417.  i1 = i1 | 0;
    38418. 

  38418.  var i2 = 0, i3 = 0;
    38419. 

  38419.  i2 = STACKTOP;
    38420. 

  38420.  i3 = _luaL_checklstring(i1, 1, 0) | 0;
    38421. 

  38421.  i3 = _ll_loadfunc(i1, i3, _luaL_checklstring(i1, 2, 0) | 0) | 0;
    38422. 

  38422.  if ((i3 | 0) == 0) {
    38423. 

  38423.   i3 = 1;
    38424. 

  38424.   STACKTOP = i2;
    38425. 

  38425.   return i3 | 0;
    38426. 

  38426.  }
    38427. 

  38427.  _lua_pushnil(i1);
    38428. 

  38428.  _lua_insert(i1, -2);
    38429. 

  38429.  _lua_pushstring(i1, (i3 | 0) == 1 ? 5176 : 5184) | 0;
    38430. 

  38430.  i3 = 3;
    38431. 

  38431.  STACKTOP = i2;
    38432. 

  38432.  return i3 | 0;
    38433. 

  38433. }
    38434. 

  38434. function _luaS_hash(i2, i4, i3) {
    38435. 

  38435.  i2 = i2 | 0;
    38436. 

  38436.  i4 = i4 | 0;
    38437. 

  38437.  i3 = i3 | 0;
    38438. 

  38438.  var i1 = 0, i5 = 0;
    38439. 

  38439.  i1 = STACKTOP;
    38440. 

  38440.  i5 = i3 ^ i4;
    38441. 

  38441.  i3 = (i4 >>> 5) + 1 | 0;
    38442. 

  38442.  if (i3 >>> 0 > i4 >>> 0) {
    38443. 

  38443.   STACKTOP = i1;
    38444. 

  38444.   return i5 | 0;
    38445. 

  38445.  }
    38446. 

  38446.  do {
    38447. 

  38447.   i5 = (i5 << 5) + (i5 >>> 2) + (HEAPU8[i2 + (i4 + -1) | 0] | 0) ^ i5;
    38448. 

  38448.   i4 = i4 - i3 | 0;
    38449. 

  38449.  } while (!(i4 >>> 0 < i3 >>> 0));
    38450. 

  38450.  STACKTOP = i1;
    38451. 

  38451.  return i5 | 0;
    38452. 

  38452. }
    38453. 

  38453. function _b_and(i1) {
    38454. 

  38454.  i1 = i1 | 0;
    38455. 

  38455.  var i2 = 0, i3 = 0, i4 = 0, i5 = 0;
    38456. 

  38456.  i2 = STACKTOP;
    38457. 

  38457.  i3 = _lua_gettop(i1) | 0;
    38458. 

  38458.  if ((i3 | 0) < 1) {
    38459. 

  38459.   i5 = -1;
    38460. 

  38460.  } else {
    38461. 

  38461.   i4 = 1;
    38462. 

  38462.   i5 = -1;
    38463. 

  38463.   while (1) {
    38464. 

  38464.    i5 = (_luaL_checkunsigned(i1, i4) | 0) & i5;
    38465. 

  38465.    if ((i4 | 0) == (i3 | 0)) {
    38466. 

  38466.     break;
    38467. 

  38467.    } else {
    38468. 

  38468.     i4 = i4 + 1 | 0;
    38469. 

  38469.    }
    38470. 

  38470.   }
    38471. 

  38471.  }
    38472. 

  38472.  _lua_pushunsigned(i1, i5);
    38473. 

  38473.  STACKTOP = i2;
    38474. 

  38474.  return 1;
    38475. 

  38475. }
    38476. 

  38476. function _luaopen_string(i1) {
    38477. 

  38477.  i1 = i1 | 0;
    38478. 

  38478.  var i2 = 0;
    38479. 

  38479.  i2 = STACKTOP;
    38480. 

  38480.  _lua_createtable(i1, 0, 14);
    38481. 

  38481.  _luaL_setfuncs(i1, 6920, 0);
    38482. 

  38482.  _lua_createtable(i1, 0, 1);
    38483. 

  38483.  _lua_pushlstring(i1, 7040, 0) | 0;
    38484. 

  38484.  _lua_pushvalue(i1, -2);
    38485. 

  38485.  _lua_setmetatable(i1, -2) | 0;
    38486. 

  38486.  _lua_settop(i1, -2);
    38487. 

  38487.  _lua_pushvalue(i1, -2);
    38488. 

  38488.  _lua_setfield(i1, -2, 7048);
    38489. 

  38489.  _lua_settop(i1, -2);
    38490. 

  38490.  STACKTOP = i2;
    38491. 

  38491.  return 1;
    38492. 

  38492. }
    38493. 

  38493. function _b_xor(i1) {
    38494. 

  38494.  i1 = i1 | 0;
    38495. 

  38495.  var i2 = 0, i3 = 0, i4 = 0, i5 = 0;
    38496. 

  38496.  i2 = STACKTOP;
    38497. 

  38497.  i3 = _lua_gettop(i1) | 0;
    38498. 

  38498.  if ((i3 | 0) < 1) {
    38499. 

  38499.   i5 = 0;
    38500. 

  38500.  } else {
    38501. 

  38501.   i4 = 1;
    38502. 

  38502.   i5 = 0;
    38503. 

  38503.   while (1) {
    38504. 

  38504.    i5 = (_luaL_checkunsigned(i1, i4) | 0) ^ i5;
    38505. 

  38505.    if ((i4 | 0) == (i3 | 0)) {
    38506. 

  38506.     break;
    38507. 

  38507.    } else {
    38508. 

  38508.     i4 = i4 + 1 | 0;
    38509. 

  38509.    }
    38510. 

  38510.   }
    38511. 

  38511.  }
    38512. 

  38512.  _lua_pushunsigned(i1, i5);
    38513. 

  38513.  STACKTOP = i2;
    38514. 

  38514.  return 1;
    38515. 

  38515. }
    38516. 

  38516. function _luaB_assert(i1) {
    38517. 

  38517.  i1 = i1 | 0;
    38518. 

  38518.  var i2 = 0, i3 = 0;
    38519. 

  38519.  i2 = STACKTOP;
    38520. 

  38520.  STACKTOP = STACKTOP + 16 | 0;
    38521. 

  38521.  i3 = i2;
    38522. 

  38522.  if ((_lua_toboolean(i1, 1) | 0) == 0) {
    38523. 

  38523.   HEAP32[i3 >> 2] = _luaL_optlstring(i1, 2, 10216, 0) | 0;
    38524. 

  38524.   i3 = _luaL_error(i1, 10208, i3) | 0;
    38525. 

  38525.   STACKTOP = i2;
    38526. 

  38526.   return i3 | 0;
    38527. 

  38527.  } else {
    38528. 

  38528.   i3 = _lua_gettop(i1) | 0;
    38529. 

  38529.   STACKTOP = i2;
    38530. 

  38530.   return i3 | 0;
    38531. 

  38531.  }
    38532. 

  38532.  return 0;
    38533. 

  38533. }
    38534. 

  38534. function _b_or(i1) {
    38535. 

  38535.  i1 = i1 | 0;
    38536. 

  38536.  var i2 = 0, i3 = 0, i4 = 0, i5 = 0;
    38537. 

  38537.  i2 = STACKTOP;
    38538. 

  38538.  i3 = _lua_gettop(i1) | 0;
    38539. 

  38539.  if ((i3 | 0) < 1) {
    38540. 

  38540.   i5 = 0;
    38541. 

  38541.  } else {
    38542. 

  38542.   i4 = 1;
    38543. 

  38543.   i5 = 0;
    38544. 

  38544.   while (1) {
    38545. 

  38545.    i5 = _luaL_checkunsigned(i1, i4) | 0 | i5;
    38546. 

  38546.    if ((i4 | 0) == (i3 | 0)) {
    38547. 

  38547.     break;
    38548. 

  38548.    } else {
    38549. 

  38549.     i4 = i4 + 1 | 0;
    38550. 

  38550.    }
    38551. 

  38551.   }
    38552. 

  38552.  }
    38553. 

  38553.  _lua_pushunsigned(i1, i5);
    38554. 

  38554.  STACKTOP = i2;
    38555. 

  38555.  return 1;
    38556. 

  38556. }
    38557. 

  38557. function _io_write(i1) {
    38558. 

  38558.  i1 = i1 | 0;
    38559. 

  38559.  var i2 = 0, i3 = 0, i4 = 0;
    38560. 

  38560.  i2 = STACKTOP;
    38561. 

  38561.  STACKTOP = STACKTOP + 16 | 0;
    38562. 

  38562.  i4 = i2;
    38563. 

  38563.  _lua_getfield(i1, -1001e3, 2800);
    38564. 

  38564.  i3 = _lua_touserdata(i1, -1) | 0;
    38565. 

  38565.  if ((HEAP32[i3 + 4 >> 2] | 0) == 0) {
    38566. 

  38566.   HEAP32[i4 >> 2] = 2804;
    38567. 

  38567.   _luaL_error(i1, 3424, i4) | 0;
    38568. 

  38568.  }
    38569. 

  38569.  i4 = _g_write(i1, HEAP32[i3 >> 2] | 0, 1) | 0;
    38570. 

  38570.  STACKTOP = i2;
    38571. 

  38571.  return i4 | 0;
    38572. 

  38572. }
    38573. 

  38573. function _luaK_checkstack(i1, i3) {
    38574. 

  38574.  i1 = i1 | 0;
    38575. 

  38575.  i3 = i3 | 0;
    38576. 

  38576.  var i2 = 0, i4 = 0;
    38577. 

  38577.  i2 = STACKTOP;
    38578. 

  38578.  i3 = (HEAPU8[i1 + 48 | 0] | 0) + i3 | 0;
    38579. 

  38579.  i4 = (HEAP32[i1 >> 2] | 0) + 78 | 0;
    38580. 

  38580.  if ((i3 | 0) <= (HEAPU8[i4] | 0 | 0)) {
    38581. 

  38581.   STACKTOP = i2;
    38582. 

  38582.   return;
    38583. 

  38583.  }
    38584. 

  38584.  if ((i3 | 0) > 249) {
    38585. 

  38585.   _luaX_syntaxerror(HEAP32[i1 + 12 >> 2] | 0, 10536);
    38586. 

  38586.  }
    38587. 

  38587.  HEAP8[i4] = i3;
    38588. 

  38588.  STACKTOP = i2;
    38589. 

  38589.  return;
    38590. 

  38590. }
    38591. 

  38591. function _io_read(i1) {
    38592. 

  38592.  i1 = i1 | 0;
    38593. 

  38593.  var i2 = 0, i3 = 0, i4 = 0;
    38594. 

  38594.  i2 = STACKTOP;
    38595. 

  38595.  STACKTOP = STACKTOP + 16 | 0;
    38596. 

  38596.  i4 = i2;
    38597. 

  38597.  _lua_getfield(i1, -1001e3, 2776);
    38598. 

  38598.  i3 = _lua_touserdata(i1, -1) | 0;
    38599. 

  38599.  if ((HEAP32[i3 + 4 >> 2] | 0) == 0) {
    38600. 

  38600.   HEAP32[i4 >> 2] = 2780;
    38601. 

  38601.   _luaL_error(i1, 3424, i4) | 0;
    38602. 

  38602.  }
    38603. 

  38603.  i4 = _g_read(i1, HEAP32[i3 >> 2] | 0, 1) | 0;
    38604. 

  38604.  STACKTOP = i2;
    38605. 

  38605.  return i4 | 0;
    38606. 

  38606. }
    38607. 

  38607. function _db_setupvalue(i1) {
    38608. 

  38608.  i1 = i1 | 0;
    38609. 

  38609.  var i2 = 0, i3 = 0;
    38610. 

  38610.  i2 = STACKTOP;
    38611. 

  38611.  _luaL_checkany(i1, 3);
    38612. 

  38612.  i3 = _luaL_checkinteger(i1, 2) | 0;
    38613. 

  38613.  _luaL_checktype(i1, 1, 6);
    38614. 

  38614.  i3 = _lua_setupvalue(i1, 1, i3) | 0;
    38615. 

  38615.  if ((i3 | 0) == 0) {
    38616. 

  38616.   i3 = 0;
    38617. 

  38617.   STACKTOP = i2;
    38618. 

  38618.   return i3 | 0;
    38619. 

  38619.  }
    38620. 

  38620.  _lua_pushstring(i1, i3) | 0;
    38621. 

  38621.  _lua_insert(i1, -1);
    38622. 

  38622.  i3 = 1;
    38623. 

  38623.  STACKTOP = i2;
    38624. 

  38624.  return i3 | 0;
    38625. 

  38625. }
    38626. 

  38626. function ___uflow(i2) {
    38627. 

  38627.  i2 = i2 | 0;
    38628. 

  38628.  var i1 = 0, i3 = 0;
    38629. 

  38629.  i1 = STACKTOP;
    38630. 

  38630.  STACKTOP = STACKTOP + 16 | 0;
    38631. 

  38631.  i3 = i1;
    38632. 

  38632.  if ((HEAP32[i2 + 8 >> 2] | 0) == 0 ? (___toread(i2) | 0) != 0 : 0) {
    38633. 

  38633.   i2 = -1;
    38634. 

  38634.  } else {
    38635. 

  38635.   if ((FUNCTION_TABLE_iiii[HEAP32[i2 + 32 >> 2] & 3](i2, i3, 1) | 0) == 1) {
    38636. 

  38636.    i2 = HEAPU8[i3] | 0;
    38637. 

  38637.   } else {
    38638. 

  38638.    i2 = -1;
    38639. 

  38639.   }
    38640. 

  38640.  }
    38641. 

  38641.  STACKTOP = i1;
    38642. 

  38642.  return i2 | 0;
    38643. 

  38643. }
    38644. 

  38644. function _llvm_cttz_i32(i1) {
    38645. 

  38645.  i1 = i1 | 0;
    38646. 

  38646.  var i2 = 0;
    38647. 

  38647.  i2 = HEAP8[cttz_i8 + (i1 & 255) | 0] | 0;
    38648. 

  38648.  if ((i2 | 0) < 8) return i2 | 0;
    38649. 

  38649.  i2 = HEAP8[cttz_i8 + (i1 >> 8 & 255) | 0] | 0;
    38650. 

  38650.  if ((i2 | 0) < 8) return i2 + 8 | 0;
    38651. 

  38651.  i2 = HEAP8[cttz_i8 + (i1 >> 16 & 255) | 0] | 0;
    38652. 

  38652.  if ((i2 | 0) < 8) return i2 + 16 | 0;
    38653. 

  38653.  return (HEAP8[cttz_i8 + (i1 >>> 24) | 0] | 0) + 24 | 0;
    38654. 

  38654. }
    38655. 

  38655. function _llvm_ctlz_i32(i1) {
    38656. 

  38656.  i1 = i1 | 0;
    38657. 

  38657.  var i2 = 0;
    38658. 

  38658.  i2 = HEAP8[ctlz_i8 + (i1 >>> 24) | 0] | 0;
    38659. 

  38659.  if ((i2 | 0) < 8) return i2 | 0;
    38660. 

  38660.  i2 = HEAP8[ctlz_i8 + (i1 >> 16 & 255) | 0] | 0;
    38661. 

  38661.  if ((i2 | 0) < 8) return i2 + 8 | 0;
    38662. 

  38662.  i2 = HEAP8[ctlz_i8 + (i1 >> 8 & 255) | 0] | 0;
    38663. 

  38663.  if ((i2 | 0) < 8) return i2 + 16 | 0;
    38664. 

  38664.  return (HEAP8[ctlz_i8 + (i1 & 255) | 0] | 0) + 24 | 0;
    38665. 

  38665. }
    38666. 

  38666. function _luaO_ceillog2(i2) {
    38667. 

  38667.  i2 = i2 | 0;
    38668. 

  38668.  var i1 = 0, i3 = 0, i4 = 0;
    38669. 

  38669.  i1 = STACKTOP;
    38670. 

  38670.  i2 = i2 + -1 | 0;
    38671. 

  38671.  if (i2 >>> 0 > 255) {
    38672. 

  38672.   i3 = 0;
    38673. 

  38673.   while (1) {
    38674. 

  38674.    i3 = i3 + 8 | 0;
    38675. 

  38675.    i4 = i2 >>> 8;
    38676. 

  38676.    if (i2 >>> 0 > 65535) {
    38677. 

  38677.     i2 = i4;
    38678. 

  38678.    } else {
    38679. 

  38679.     i2 = i4;
    38680. 

  38680.     break;
    38681. 

  38681.    }
    38682. 

  38682.   }
    38683. 

  38683.  } else {
    38684. 

  38684.   i3 = 0;
    38685. 

  38685.  }
    38686. 

  38686.  STACKTOP = i1;
    38687. 

  38687.  return (HEAPU8[5208 + i2 | 0] | 0) + i3 | 0;
    38688. 

  38688. }
    38689. 

  38689. function _os_exit(i1) {
    38690. 

  38690.  i1 = i1 | 0;
    38691. 

  38691.  var i2 = 0, i3 = 0;
    38692. 

  38692.  i2 = STACKTOP;
    38693. 

  38693.  if ((_lua_type(i1, 1) | 0) == 1) {
    38694. 

  38694.   i3 = (_lua_toboolean(i1, 1) | 0) == 0 | 0;
    38695. 

  38695.  } else {
    38696. 

  38696.   i3 = _luaL_optinteger(i1, 1, 0) | 0;
    38697. 

  38697.  }
    38698. 

  38698.  if ((_lua_toboolean(i1, 2) | 0) != 0) {
    38699. 

  38699.   _lua_close(i1);
    38700. 

  38700.  }
    38701. 

  38701.  if ((i1 | 0) == 0) {
    38702. 

  38702.   STACKTOP = i2;
    38703. 

  38703.   return 0;
    38704. 

  38704.  } else {
    38705. 

  38705.   _exit(i3 | 0);
    38706. 

  38706.  }
    38707. 

  38707.  return 0;
    38708. 

  38708. }
    38709. 

  38709. function _luaL_newmetatable(i1, i3) {
    38710. 

  38710.  i1 = i1 | 0;
    38711. 

  38711.  i3 = i3 | 0;
    38712. 

  38712.  var i2 = 0;
    38713. 

  38713.  i2 = STACKTOP;
    38714. 

  38714.  _lua_getfield(i1, -1001e3, i3);
    38715. 

  38715.  if ((_lua_type(i1, -1) | 0) != 0) {
    38716. 

  38716.   i3 = 0;
    38717. 

  38717.   STACKTOP = i2;
    38718. 

  38718.   return i3 | 0;
    38719. 

  38719.  }
    38720. 

  38720.  _lua_settop(i1, -2);
    38721. 

  38721.  _lua_createtable(i1, 0, 0);
    38722. 

  38722.  _lua_pushvalue(i1, -1);
    38723. 

  38723.  _lua_setfield(i1, -1001e3, i3);
    38724. 

  38724.  i3 = 1;
    38725. 

  38725.  STACKTOP = i2;
    38726. 

  38726.  return i3 | 0;
    38727. 

  38727. }
    38728. 

  38728. function _luaH_free(i1, i4) {
    38729. 

  38729.  i1 = i1 | 0;
    38730. 

  38730.  i4 = i4 | 0;
    38731. 

  38731.  var i2 = 0, i3 = 0;
    38732. 

  38732.  i2 = STACKTOP;
    38733. 

  38733.  i3 = HEAP32[i4 + 16 >> 2] | 0;
    38734. 

  38734.  if ((i3 | 0) != 8016) {
    38735. 

  38735.   _luaM_realloc_(i1, i3, 32 << (HEAPU8[i4 + 7 | 0] | 0), 0) | 0;
    38736. 

  38736.  }
    38737. 

  38737.  _luaM_realloc_(i1, HEAP32[i4 + 12 >> 2] | 0, HEAP32[i4 + 28 >> 2] << 4, 0) | 0;
    38738. 

  38738.  _luaM_realloc_(i1, i4, 32, 0) | 0;
    38739. 

  38739.  STACKTOP = i2;
    38740. 

  38740.  return;
    38741. 

  38741. }
    38742. 

  38742. function _luaO_int2fb(i3) {
    38743. 

  38743.  i3 = i3 | 0;
    38744. 

  38744.  var i1 = 0, i2 = 0, i4 = 0;
    38745. 

  38745.  i1 = STACKTOP;
    38746. 

  38746.  if (i3 >>> 0 < 8) {
    38747. 

  38747.   STACKTOP = i1;
    38748. 

  38748.   return i3 | 0;
    38749. 

  38749.  }
    38750. 

  38750.  if (i3 >>> 0 > 15) {
    38751. 

  38751.   i2 = 1;
    38752. 

  38752.   do {
    38753. 

  38753.    i4 = i3 + 1 | 0;
    38754. 

  38754.    i3 = i4 >>> 1;
    38755. 

  38755.    i2 = i2 + 1 | 0;
    38756. 

  38756.   } while (i4 >>> 0 > 31);
    38757. 

  38757.   i2 = i2 << 3;
    38758. 

  38758.  } else {
    38759. 

  38759.   i2 = 8;
    38760. 

  38760.  }
    38761. 

  38761.  i4 = i2 | i3 + -8;
    38762. 

  38762.  STACKTOP = i1;
    38763. 

  38763.  return i4 | 0;
    38764. 

  38764. }
    38765. 

  38765. function _luaK_codek(i3, i4, i1) {
    38766. 

  38766.  i3 = i3 | 0;
    38767. 

  38767.  i4 = i4 | 0;
    38768. 

  38768.  i1 = i1 | 0;
    38769. 

  38769.  var i2 = 0;
    38770. 

  38770.  i2 = STACKTOP;
    38771. 

  38771.  i4 = i4 << 6;
    38772. 

  38772.  if ((i1 | 0) < 262144) {
    38773. 

  38773.   i4 = _luaK_code(i3, i4 | i1 << 14 | 1) | 0;
    38774. 

  38774.   STACKTOP = i2;
    38775. 

  38775.   return i4 | 0;
    38776. 

  38776.  } else {
    38777. 

  38777.   i4 = _luaK_code(i3, i4 | 2) | 0;
    38778. 

  38778.   _luaK_code(i3, i1 << 6 | 39) | 0;
    38779. 

  38779.   STACKTOP = i2;
    38780. 

  38780.   return i4 | 0;
    38781. 

  38781.  }
    38782. 

  38782.  return 0;
    38783. 

  38783. }
    38784. 

  38784. function _luaB_xpcall(i1) {
    38785. 

  38785.  i1 = i1 | 0;
    38786. 

  38786.  var i2 = 0, i3 = 0;
    38787. 

  38787.  i2 = STACKTOP;
    38788. 

  38788.  i3 = _lua_gettop(i1) | 0;
    38789. 

  38789.  if ((i3 | 0) <= 1) {
    38790. 

  38790.   _luaL_argerror(i1, 2, 9616) | 0;
    38791. 

  38791.  }
    38792. 

  38792.  _lua_pushvalue(i1, 1);
    38793. 

  38793.  _lua_copy(i1, 2, 1);
    38794. 

  38794.  _lua_replace(i1, 2);
    38795. 

  38795.  i3 = _finishpcall(i1, (_lua_pcallk(i1, i3 + -2 | 0, -1, 1, 0, 166) | 0) == 0 | 0) | 0;
    38796. 

  38796.  STACKTOP = i2;
    38797. 

  38797.  return i3 | 0;
    38798. 

  38798. }
    38799. 

  38799. function _luaS_newudata(i1, i3, i4) {
    38800. 

  38800.  i1 = i1 | 0;
    38801. 

  38801.  i3 = i3 | 0;
    38802. 

  38802.  i4 = i4 | 0;
    38803. 

  38803.  var i2 = 0;
    38804. 

  38804.  i2 = STACKTOP;
    38805. 

  38805.  if (i3 >>> 0 > 4294967269) {
    38806. 

  38806.   _luaM_toobig(i1);
    38807. 

  38807.  } else {
    38808. 

  38808.   i1 = _luaC_newobj(i1, 7, i3 + 24 | 0, 0, 0) | 0;
    38809. 

  38809.   HEAP32[i1 + 16 >> 2] = i3;
    38810. 

  38810.   HEAP32[i1 + 8 >> 2] = 0;
    38811. 

  38811.   HEAP32[i1 + 12 >> 2] = i4;
    38812. 

  38812.   STACKTOP = i2;
    38813. 

  38813.   return i1 | 0;
    38814. 

  38814.  }
    38815. 

  38815.  return 0;
    38816. 

  38816. }
    38817. 

  38817. function _lua_dump(i1, i4, i5) {
    38818. 

  38818.  i1 = i1 | 0;
    38819. 

  38819.  i4 = i4 | 0;
    38820. 

  38820.  i5 = i5 | 0;
    38821. 

  38821.  var i2 = 0, i3 = 0;
    38822. 

  38822.  i2 = STACKTOP;
    38823. 

  38823.  i3 = HEAP32[i1 + 8 >> 2] | 0;
    38824. 

  38824.  if ((HEAP32[i3 + -8 >> 2] | 0) != 70) {
    38825. 

  38825.   i5 = 1;
    38826. 

  38826.   STACKTOP = i2;
    38827. 

  38827.   return i5 | 0;
    38828. 

  38828.  }
    38829. 

  38829.  i5 = _luaU_dump(i1, HEAP32[(HEAP32[i3 + -16 >> 2] | 0) + 12 >> 2] | 0, i4, i5, 0) | 0;
    38830. 

  38830.  STACKTOP = i2;
    38831. 

  38831.  return i5 | 0;
    38832. 

  38832. }
    38833. 

  38833. function _luaS_eqlngstr(i2, i4) {
    38834. 

  38834.  i2 = i2 | 0;
    38835. 

  38835.  i4 = i4 | 0;
    38836. 

  38836.  var i1 = 0, i3 = 0;
    38837. 

  38837.  i1 = STACKTOP;
    38838. 

  38838.  i3 = HEAP32[i2 + 12 >> 2] | 0;
    38839. 

  38839.  if ((i2 | 0) != (i4 | 0)) {
    38840. 

  38840.   if ((i3 | 0) == (HEAP32[i4 + 12 >> 2] | 0)) {
    38841. 

  38841.    i2 = (_memcmp(i2 + 16 | 0, i4 + 16 | 0, i3) | 0) == 0;
    38842. 

  38842.   } else {
    38843. 

  38843.    i2 = 0;
    38844. 

  38844.   }
    38845. 

  38845.  } else {
    38846. 

  38846.   i2 = 1;
    38847. 

  38847.  }
    38848. 

  38848.  STACKTOP = i1;
    38849. 

  38849.  return i2 & 1 | 0;
    38850. 

  38850. }
    38851. 

  38851. function _luaC_barrier_(i4, i3, i1) {
    38852. 

  38852.  i4 = i4 | 0;
    38853. 

  38853.  i3 = i3 | 0;
    38854. 

  38854.  i1 = i1 | 0;
    38855. 

  38855.  var i2 = 0;
    38856. 

  38856.  i2 = STACKTOP;
    38857. 

  38857.  i4 = HEAP32[i4 + 12 >> 2] | 0;
    38858. 

  38858.  if ((HEAPU8[i4 + 61 | 0] | 0) < 2) {
    38859. 

  38859.   _reallymarkobject(i4, i1);
    38860. 

  38860.   STACKTOP = i2;
    38861. 

  38861.   return;
    38862. 

  38862.  } else {
    38863. 

  38863.   i3 = i3 + 5 | 0;
    38864. 

  38864.   HEAP8[i3] = HEAP8[i4 + 60 | 0] & 3 | HEAP8[i3] & 184;
    38865. 

  38865.   STACKTOP = i2;
    38866. 

  38866.   return;
    38867. 

  38867.  }
    38868. 

  38868. }
    38869. 

  38869. function _db_getupvalue(i1) {
    38870. 

  38870.  i1 = i1 | 0;
    38871. 

  38871.  var i2 = 0, i3 = 0;
    38872. 

  38872.  i2 = STACKTOP;
    38873. 

  38873.  i3 = _luaL_checkinteger(i1, 2) | 0;
    38874. 

  38874.  _luaL_checktype(i1, 1, 6);
    38875. 

  38875.  i3 = _lua_getupvalue(i1, 1, i3) | 0;
    38876. 

  38876.  if ((i3 | 0) == 0) {
    38877. 

  38877.   i3 = 0;
    38878. 

  38878.   STACKTOP = i2;
    38879. 

  38879.   return i3 | 0;
    38880. 

  38880.  }
    38881. 

  38881.  _lua_pushstring(i1, i3) | 0;
    38882. 

  38882.  _lua_insert(i1, -2);
    38883. 

  38883.  i3 = 2;
    38884. 

  38884.  STACKTOP = i2;
    38885. 

  38885.  return i3 | 0;
    38886. 

  38886. }
    38887. 

  38887. function _os_execute(i1) {
    38888. 

  38888.  i1 = i1 | 0;
    38889. 

  38889.  var i2 = 0, i3 = 0, i4 = 0;
    38890. 

  38890.  i2 = STACKTOP;
    38891. 

  38891.  i4 = _luaL_optlstring(i1, 1, 0, 0) | 0;
    38892. 

  38892.  i3 = _system(i4 | 0) | 0;
    38893. 

  38893.  if ((i4 | 0) == 0) {
    38894. 

  38894.   _lua_pushboolean(i1, i3);
    38895. 

  38895.   i4 = 1;
    38896. 

  38896.   STACKTOP = i2;
    38897. 

  38897.   return i4 | 0;
    38898. 

  38898.  } else {
    38899. 

  38899.   i4 = _luaL_execresult(i1, i3) | 0;
    38900. 

  38900.   STACKTOP = i2;
    38901. 

  38901.   return i4 | 0;
    38902. 

  38902.  }
    38903. 

  38903.  return 0;
    38904. 

  38904. }
    38905. 

  38905. function _lua_pushfstring(i4, i5, i1) {
    38906. 

  38906.  i4 = i4 | 0;
    38907. 

  38907.  i5 = i5 | 0;
    38908. 

  38908.  i1 = i1 | 0;
    38909. 

  38909.  var i2 = 0, i3 = 0;
    38910. 

  38910.  i2 = STACKTOP;
    38911. 

  38911.  STACKTOP = STACKTOP + 16 | 0;
    38912. 

  38912.  i3 = i2;
    38913. 

  38913.  if ((HEAP32[(HEAP32[i4 + 12 >> 2] | 0) + 12 >> 2] | 0) > 0) {
    38914. 

  38914.   _luaC_step(i4);
    38915. 

  38915.  }
    38916. 

  38916.  HEAP32[i3 >> 2] = i1;
    38917. 

  38917.  i5 = _luaO_pushvfstring(i4, i5, i3) | 0;
    38918. 

  38918.  STACKTOP = i2;
    38919. 

  38919.  return i5 | 0;
    38920. 

  38920. }
    38921. 

  38921. function _luaB_dofile(i1) {
    38922. 

  38922.  i1 = i1 | 0;
    38923. 

  38923.  var i2 = 0, i3 = 0;
    38924. 

  38924.  i2 = STACKTOP;
    38925. 

  38925.  i3 = _luaL_optlstring(i1, 1, 0, 0) | 0;
    38926. 

  38926.  _lua_settop(i1, 1);
    38927. 

  38927.  if ((_luaL_loadfilex(i1, i3, 0) | 0) == 0) {
    38928. 

  38928.   _lua_callk(i1, 0, -1, 0, 164);
    38929. 

  38929.   i3 = (_lua_gettop(i1) | 0) + -1 | 0;
    38930. 

  38930.   STACKTOP = i2;
    38931. 

  38931.   return i3 | 0;
    38932. 

  38932.  } else {
    38933. 

  38933.   _lua_error(i1) | 0;
    38934. 

  38934.  }
    38935. 

  38935.  return 0;
    38936. 

  38936. }
    38937. 

  38937. function _f_write(i1) {
    38938. 

  38938.  i1 = i1 | 0;
    38939. 

  38939.  var i2 = 0, i3 = 0;
    38940. 

  38940.  i2 = STACKTOP;
    38941. 

  38941.  STACKTOP = STACKTOP + 16 | 0;
    38942. 

  38942.  i3 = _luaL_checkudata(i1, 1, 2832) | 0;
    38943. 

  38943.  if ((HEAP32[i3 + 4 >> 2] | 0) == 0) {
    38944. 

  38944.   _luaL_error(i1, 3080, i2) | 0;
    38945. 

  38945.  }
    38946. 

  38946.  i3 = HEAP32[i3 >> 2] | 0;
    38947. 

  38947.  _lua_pushvalue(i1, 1);
    38948. 

  38948.  i3 = _g_write(i1, i3, 2) | 0;
    38949. 

  38949.  STACKTOP = i2;
    38950. 

  38950.  return i3 | 0;
    38951. 

  38951. }
    38952. 

  38952. function _lua_getctx(i3, i1) {
    38953. 

  38953.  i3 = i3 | 0;
    38954. 

  38954.  i1 = i1 | 0;
    38955. 

  38955.  var i2 = 0;
    38956. 

  38956.  i2 = STACKTOP;
    38957. 

  38957.  i3 = HEAP32[i3 + 16 >> 2] | 0;
    38958. 

  38958.  if ((HEAP8[i3 + 18 | 0] & 8) == 0) {
    38959. 

  38959.   i3 = 0;
    38960. 

  38960.   STACKTOP = i2;
    38961. 

  38961.   return i3 | 0;
    38962. 

  38962.  }
    38963. 

  38963.  if ((i1 | 0) != 0) {
    38964. 

  38964.   HEAP32[i1 >> 2] = HEAP32[i3 + 24 >> 2];
    38965. 

  38965.  }
    38966. 

  38966.  i3 = HEAPU8[i3 + 37 | 0] | 0;
    38967. 

  38967.  STACKTOP = i2;
    38968. 

  38968.  return i3 | 0;
    38969. 

  38969. }
    38970. 

  38970. function _f_flush(i1) {
    38971. 

  38971.  i1 = i1 | 0;
    38972. 

  38972.  var i2 = 0, i3 = 0;
    38973. 

  38973.  i2 = STACKTOP;
    38974. 

  38974.  STACKTOP = STACKTOP + 16 | 0;
    38975. 

  38975.  i3 = _luaL_checkudata(i1, 1, 2832) | 0;
    38976. 

  38976.  if ((HEAP32[i3 + 4 >> 2] | 0) == 0) {
    38977. 

  38977.   _luaL_error(i1, 3080, i2) | 0;
    38978. 

  38978.  }
    38979. 

  38979.  i3 = _luaL_fileresult(i1, (_fflush(HEAP32[i3 >> 2] | 0) | 0) == 0 | 0, 0) | 0;
    38980. 

  38980.  STACKTOP = i2;
    38981. 

  38981.  return i3 | 0;
    38982. 

  38982. }
    38983. 

  38983. function _os_tmpname(i1) {
    38984. 

  38984.  i1 = i1 | 0;
    38985. 

  38985.  var i2 = 0, i3 = 0;
    38986. 

  38986.  i2 = STACKTOP;
    38987. 

  38987.  STACKTOP = STACKTOP + 32 | 0;
    38988. 

  38988.  i3 = i2 + 4 | 0;
    38989. 

  38989.  if ((_tmpnam(i3 | 0) | 0) == 0) {
    38990. 

  38990.   i3 = _luaL_error(i1, 5824, i2) | 0;
    38991. 

  38991.   STACKTOP = i2;
    38992. 

  38992.   return i3 | 0;
    38993. 

  38993.  } else {
    38994. 

  38994.   _lua_pushstring(i1, i3) | 0;
    38995. 

  38995.   i3 = 1;
    38996. 

  38996.   STACKTOP = i2;
    38997. 

  38997.   return i3 | 0;
    38998. 

  38998.  }
    38999. 

  38999.  return 0;
    39000. 

  39000. }
    39001. 

  39001. function _traceback(i1) {
    39002. 

  39002.  i1 = i1 | 0;
    39003. 

  39003.  var i2 = 0, i3 = 0;
    39004. 

  39004.  i2 = STACKTOP;
    39005. 

  39005.  i3 = _lua_tolstring(i1, 1, 0) | 0;
    39006. 

  39006.  if ((i3 | 0) == 0) {
    39007. 

  39007.   if ((_lua_type(i1, 1) | 0) >= 1 ? (_luaL_callmeta(i1, 1, 216) | 0) == 0 : 0) {
    39008. 

  39008.    _lua_pushlstring(i1, 232, 18) | 0;
    39009. 

  39009.   }
    39010. 

  39010.  } else {
    39011. 

  39011.   _luaL_traceback(i1, i1, i3, 1);
    39012. 

  39012.  }
    39013. 

  39013.  STACKTOP = i2;
    39014. 

  39014.  return 1;
    39015. 

  39015. }
    39016. 

  39016. function _luaH_new(i1) {
    39017. 

  39017.  i1 = i1 | 0;
    39018. 

  39018.  var i2 = 0;
    39019. 

  39019.  i2 = STACKTOP;
    39020. 

  39020.  i1 = _luaC_newobj(i1, 5, 32, 0, 0) | 0;
    39021. 

  39021.  HEAP32[i1 + 8 >> 2] = 0;
    39022. 

  39022.  HEAP8[i1 + 6 | 0] = -1;
    39023. 

  39023.  HEAP32[i1 + 12 >> 2] = 0;
    39024. 

  39024.  HEAP32[i1 + 28 >> 2] = 0;
    39025. 

  39025.  HEAP32[i1 + 16 >> 2] = 8016;
    39026. 

  39026.  HEAP8[i1 + 7 | 0] = 0;
    39027. 

  39027.  HEAP32[i1 + 20 >> 2] = 8016;
    39028. 

  39028.  STACKTOP = i2;
    39029. 

  39029.  return i1 | 0;
    39030. 

  39030. }
    39031. 

  39031. function _luaL_len(i1, i3) {
    39032. 

  39032.  i1 = i1 | 0;
    39033. 

  39033.  i3 = i3 | 0;
    39034. 

  39034.  var i2 = 0, i4 = 0;
    39035. 

  39035.  i2 = STACKTOP;
    39036. 

  39036.  STACKTOP = STACKTOP + 16 | 0;
    39037. 

  39037.  i4 = i2 + 4 | 0;
    39038. 

  39038.  _lua_len(i1, i3);
    39039. 

  39039.  i3 = _lua_tointegerx(i1, -1, i4) | 0;
    39040. 

  39040.  if ((HEAP32[i4 >> 2] | 0) == 0) {
    39041. 

  39041.   _luaL_error(i1, 1352, i2) | 0;
    39042. 

  39042.  }
    39043. 

  39043.  _lua_settop(i1, -2);
    39044. 

  39044.  STACKTOP = i2;
    39045. 

  39045.  return i3 | 0;
    39046. 

  39046. }
    39047. 

  39047. function _getS(i3, i2, i1) {
    39048. 

  39048.  i3 = i3 | 0;
    39049. 

  39049.  i2 = i2 | 0;
    39050. 

  39050.  i1 = i1 | 0;
    39051. 

  39051.  var i4 = 0, i5 = 0;
    39052. 

  39052.  i3 = STACKTOP;
    39053. 

  39053.  i5 = i2 + 4 | 0;
    39054. 

  39054.  i4 = HEAP32[i5 >> 2] | 0;
    39055. 

  39055.  if ((i4 | 0) == 0) {
    39056. 

  39056.   i5 = 0;
    39057. 

  39057.   STACKTOP = i3;
    39058. 

  39058.   return i5 | 0;
    39059. 

  39059.  }
    39060. 

  39060.  HEAP32[i1 >> 2] = i4;
    39061. 

  39061.  HEAP32[i5 >> 2] = 0;
    39062. 

  39062.  i5 = HEAP32[i2 >> 2] | 0;
    39063. 

  39063.  STACKTOP = i3;
    39064. 

  39064.  return i5 | 0;
    39065. 

  39065. }
    39066. 

  39066. function _luaC_runtilstate(i1, i4) {
    39067. 

  39067.  i1 = i1 | 0;
    39068. 

  39068.  i4 = i4 | 0;
    39069. 

  39069.  var i2 = 0, i3 = 0;
    39070. 

  39070.  i2 = STACKTOP;
    39071. 

  39071.  i3 = (HEAP32[i1 + 12 >> 2] | 0) + 61 | 0;
    39072. 

  39072.  if ((1 << (HEAPU8[i3] | 0) & i4 | 0) != 0) {
    39073. 

  39073.   STACKTOP = i2;
    39074. 

  39074.   return;
    39075. 

  39075.  }
    39076. 

  39076.  do {
    39077. 

  39077.   _singlestep(i1) | 0;
    39078. 

  39078.  } while ((1 << (HEAPU8[i3] | 0) & i4 | 0) == 0);
    39079. 

  39079.  STACKTOP = i2;
    39080. 

  39080.  return;
    39081. 

  39081. }
    39082. 

  39082. function _luaX_init(i1) {
    39083. 

  39083.  i1 = i1 | 0;
    39084. 

  39084.  var i2 = 0, i3 = 0, i4 = 0, i5 = 0;
    39085. 

  39085.  i2 = STACKTOP;
    39086. 

  39086.  i3 = 0;
    39087. 

  39087.  do {
    39088. 

  39088.   i4 = _luaS_new(i1, HEAP32[12096 + (i3 << 2) >> 2] | 0) | 0;
    39089. 

  39089.   i5 = i4 + 5 | 0;
    39090. 

  39090.   HEAP8[i5] = HEAPU8[i5] | 0 | 32;
    39091. 

  39091.   i3 = i3 + 1 | 0;
    39092. 

  39092.   HEAP8[i4 + 6 | 0] = i3;
    39093. 

  39093.  } while ((i3 | 0) != 22);
    39094. 

  39094.  STACKTOP = i2;
    39095. 

  39095.  return;
    39096. 

  39096. }
    39097. 

  39097. function _luaK_indexed(i5, i1, i4) {
    39098. 

  39098.  i5 = i5 | 0;
    39099. 

  39099.  i1 = i1 | 0;
    39100. 

  39100.  i4 = i4 | 0;
    39101. 

  39101.  var i2 = 0, i3 = 0;
    39102. 

  39102.  i3 = STACKTOP;
    39103. 

  39103.  i2 = i1 + 8 | 0;
    39104. 

  39104.  HEAP8[i2 + 2 | 0] = HEAP32[i2 >> 2];
    39105. 

  39105.  HEAP16[i2 >> 1] = _luaK_exp2RK(i5, i4) | 0;
    39106. 

  39106.  HEAP8[i2 + 3 | 0] = (HEAP32[i1 >> 2] | 0) == 8 ? 8 : 7;
    39107. 

  39107.  HEAP32[i1 >> 2] = 9;
    39108. 

  39108.  STACKTOP = i3;
    39109. 

  39109.  return;
    39110. 

  39110. }
    39111. 

  39111. function _db_setuservalue(i1) {
    39112. 

  39112.  i1 = i1 | 0;
    39113. 

  39113.  var i2 = 0;
    39114. 

  39114.  i2 = STACKTOP;
    39115. 

  39115.  if ((_lua_type(i1, 1) | 0) == 2) {
    39116. 

  39116.   _luaL_argerror(i1, 1, 11680) | 0;
    39117. 

  39117.  }
    39118. 

  39118.  _luaL_checktype(i1, 1, 7);
    39119. 

  39119.  if ((_lua_type(i1, 2) | 0) >= 1) {
    39120. 

  39120.   _luaL_checktype(i1, 2, 5);
    39121. 

  39121.  }
    39122. 

  39122.  _lua_settop(i1, 2);
    39123. 

  39123.  _lua_setuservalue(i1, 1);
    39124. 

  39124.  STACKTOP = i2;
    39125. 

  39125.  return 1;
    39126. 

  39126. }
    39127. 

  39127. function _ll_seeall(i1) {
    39128. 

  39128.  i1 = i1 | 0;
    39129. 

  39129.  var i2 = 0;
    39130. 

  39130.  i2 = STACKTOP;
    39131. 

  39131.  _luaL_checktype(i1, 1, 5);
    39132. 

  39132.  if ((_lua_getmetatable(i1, 1) | 0) == 0) {
    39133. 

  39133.   _lua_createtable(i1, 0, 1);
    39134. 

  39134.   _lua_pushvalue(i1, -1);
    39135. 

  39135.   _lua_setmetatable(i1, 1) | 0;
    39136. 

  39136.  }
    39137. 

  39137.  _lua_rawgeti(i1, -1001e3, 2);
    39138. 

  39138.  _lua_setfield(i1, -2, 5168);
    39139. 

  39139.  STACKTOP = i2;
    39140. 

  39140.  return 0;
    39141. 

  39141. }
    39142. 

  39142. function _luaL_loadbufferx(i3, i5, i4, i2, i1) {
    39143. 

  39143.  i3 = i3 | 0;
    39144. 

  39144.  i5 = i5 | 0;
    39145. 

  39145.  i4 = i4 | 0;
    39146. 

  39146.  i2 = i2 | 0;
    39147. 

  39147.  i1 = i1 | 0;
    39148. 

  39148.  var i6 = 0, i7 = 0;
    39149. 

  39149.  i6 = STACKTOP;
    39150. 

  39150.  STACKTOP = STACKTOP + 16 | 0;
    39151. 

  39151.  i7 = i6;
    39152. 

  39152.  HEAP32[i7 >> 2] = i5;
    39153. 

  39153.  HEAP32[i7 + 4 >> 2] = i4;
    39154. 

  39154.  i5 = _lua_load(i3, 2, i7, i2, i1) | 0;
    39155. 

  39155.  STACKTOP = i6;
    39156. 

  39156.  return i5 | 0;
    39157. 

  39157. }
    39158. 

  39158. function _luaT_gettm(i1, i3, i4) {
    39159. 

  39159.  i1 = i1 | 0;
    39160. 

  39160.  i3 = i3 | 0;
    39161. 

  39161.  i4 = i4 | 0;
    39162. 

  39162.  var i2 = 0;
    39163. 

  39163.  i2 = STACKTOP;
    39164. 

  39164.  i4 = _luaH_getstr(i1, i4) | 0;
    39165. 

  39165.  if ((HEAP32[i4 + 8 >> 2] | 0) != 0) {
    39166. 

  39166.   STACKTOP = i2;
    39167. 

  39167.   return i4 | 0;
    39168. 

  39168.  }
    39169. 

  39169.  i4 = i1 + 6 | 0;
    39170. 

  39170.  HEAP8[i4] = HEAPU8[i4] | 0 | 1 << i3;
    39171. 

  39171.  i4 = 0;
    39172. 

  39172.  STACKTOP = i2;
    39173. 

  39173.  return i4 | 0;
    39174. 

  39174. }
    39175. 

  39175. function _luaL_pushresult(i1) {
    39176. 

  39176.  i1 = i1 | 0;
    39177. 

  39177.  var i2 = 0, i3 = 0;
    39178. 

  39178.  i2 = STACKTOP;
    39179. 

  39179.  i3 = HEAP32[i1 + 12 >> 2] | 0;
    39180. 

  39180.  _lua_pushlstring(i3, HEAP32[i1 >> 2] | 0, HEAP32[i1 + 8 >> 2] | 0) | 0;
    39181. 

  39181.  if ((HEAP32[i1 >> 2] | 0) == (i1 + 16 | 0)) {
    39182. 

  39182.   STACKTOP = i2;
    39183. 

  39183.   return;
    39184. 

  39184.  }
    39185. 

  39185.  _lua_remove(i3, -2);
    39186. 

  39186.  STACKTOP = i2;
    39187. 

  39187.  return;
    39188. 

  39188. }
    39189. 

  39189. function _resume_error(i1, i3, i2) {
    39190. 

  39190.  i1 = i1 | 0;
    39191. 

  39191.  i3 = i3 | 0;
    39192. 

  39192.  i2 = i2 | 0;
    39193. 

  39193.  var i4 = 0;
    39194. 

  39194.  i4 = i1 + 8 | 0;
    39195. 

  39195.  HEAP32[i4 >> 2] = i2;
    39196. 

  39196.  i3 = _luaS_new(i1, i3) | 0;
    39197. 

  39197.  HEAP32[i2 >> 2] = i3;
    39198. 

  39198.  HEAP32[i2 + 8 >> 2] = HEAPU8[i3 + 4 | 0] | 0 | 64;
    39199. 

  39199.  HEAP32[i4 >> 2] = (HEAP32[i4 >> 2] | 0) + 16;
    39200. 

  39200.  _luaD_throw(i1, -1);
    39201. 

  39201. }
    39202. 

  39202. function _lua_absindex(i3, i1) {
    39203. 

  39203.  i3 = i3 | 0;
    39204. 

  39204.  i1 = i1 | 0;
    39205. 

  39205.  var i2 = 0;
    39206. 

  39206.  i2 = STACKTOP;
    39207. 

  39207.  if ((i1 + 1000999 | 0) >>> 0 > 1000999) {
    39208. 

  39208.   i3 = i1;
    39209. 

  39209.   STACKTOP = i2;
    39210. 

  39210.   return i3 | 0;
    39211. 

  39211.  }
    39212. 

  39212.  i3 = ((HEAP32[i3 + 8 >> 2] | 0) - (HEAP32[HEAP32[i3 + 16 >> 2] >> 2] | 0) >> 4) + i1 | 0;
    39213. 

  39213.  STACKTOP = i2;
    39214. 

  39214.  return i3 | 0;
    39215. 

  39215. }
    39216. 

  39216. function ___uremdi3(i4, i3, i2, i1) {
    39217. 

  39217.  i4 = i4 | 0;
    39218. 

  39218.  i3 = i3 | 0;
    39219. 

  39219.  i2 = i2 | 0;
    39220. 

  39220.  i1 = i1 | 0;
    39221. 

  39221.  var i5 = 0, i6 = 0;
    39222. 

  39222.  i6 = STACKTOP;
    39223. 

  39223.  STACKTOP = STACKTOP + 8 | 0;
    39224. 

  39224.  i5 = i6 | 0;
    39225. 

  39225.  ___udivmoddi4(i4, i3, i2, i1, i5) | 0;
    39226. 

  39226.  STACKTOP = i6;
    39227. 

  39227.  return (tempRet0 = HEAP32[i5 + 4 >> 2] | 0, HEAP32[i5 >> 2] | 0) | 0;
    39228. 

  39228. }
    39229. 

  39229. function _f_read(i1) {
    39230. 

  39230.  i1 = i1 | 0;
    39231. 

  39231.  var i2 = 0, i3 = 0;
    39232. 

  39232.  i2 = STACKTOP;
    39233. 

  39233.  STACKTOP = STACKTOP + 16 | 0;
    39234. 

  39234.  i3 = _luaL_checkudata(i1, 1, 2832) | 0;
    39235. 

  39235.  if ((HEAP32[i3 + 4 >> 2] | 0) == 0) {
    39236. 

  39236.   _luaL_error(i1, 3080, i2) | 0;
    39237. 

  39237.  }
    39238. 

  39238.  i3 = _g_read(i1, HEAP32[i3 >> 2] | 0, 2) | 0;
    39239. 

  39239.  STACKTOP = i2;
    39240. 

  39240.  return i3 | 0;
    39241. 

  39241. }
    39242. 

  39242. function _sort(i1) {
    39243. 

  39243.  i1 = i1 | 0;
    39244. 

  39244.  var i2 = 0, i3 = 0;
    39245. 

  39245.  i2 = STACKTOP;
    39246. 

  39246.  _luaL_checktype(i1, 1, 5);
    39247. 

  39247.  i3 = _luaL_len(i1, 1) | 0;
    39248. 

  39248.  _luaL_checkstack(i1, 40, 8208);
    39249. 

  39249.  if ((_lua_type(i1, 2) | 0) >= 1) {
    39250. 

  39250.   _luaL_checktype(i1, 2, 6);
    39251. 

  39251.  }
    39252. 

  39252.  _lua_settop(i1, 2);
    39253. 

  39253.  _auxsort(i1, 1, i3);
    39254. 

  39254.  STACKTOP = i2;
    39255. 

  39255.  return 0;
    39256. 

  39256. }
    39257. 

  39257. function _luaB_error(i1) {
    39258. 

  39258.  i1 = i1 | 0;
    39259. 

  39259.  var i2 = 0;
    39260. 

  39260.  i2 = _luaL_optinteger(i1, 2, 1) | 0;
    39261. 

  39261.  _lua_settop(i1, 1);
    39262. 

  39262.  if (!((_lua_isstring(i1, 1) | 0) != 0 & (i2 | 0) > 0)) {
    39263. 

  39263.   _lua_error(i1) | 0;
    39264. 

  39264.  }
    39265. 

  39265.  _luaL_where(i1, i2);
    39266. 

  39266.  _lua_pushvalue(i1, 1);
    39267. 

  39267.  _lua_concat(i1, 2);
    39268. 

  39268.  _lua_error(i1) | 0;
    39269. 

  39269.  return 0;
    39270. 

  39270. }
    39271. 

  39271. function _error(i1, i2) {
    39272. 

  39272.  i1 = i1 | 0;
    39273. 

  39273.  i2 = i2 | 0;
    39274. 

  39274.  var i3 = 0, i4 = 0;
    39275. 

  39275.  i3 = STACKTOP;
    39276. 

  39276.  STACKTOP = STACKTOP + 16 | 0;
    39277. 

  39277.  i4 = HEAP32[i1 >> 2] | 0;
    39278. 

  39278.  HEAP32[i3 >> 2] = HEAP32[i1 + 12 >> 2];
    39279. 

  39279.  HEAP32[i3 + 4 >> 2] = i2;
    39280. 

  39280.  _luaO_pushfstring(i4, 8840, i3) | 0;
    39281. 

  39281.  _luaD_throw(HEAP32[i1 >> 2] | 0, 3);
    39282. 

  39282. }
    39283. 

  39283. function _ipairsaux(i1) {
    39284. 

  39284.  i1 = i1 | 0;
    39285. 

  39285.  var i2 = 0, i3 = 0;
    39286. 

  39286.  i2 = STACKTOP;
    39287. 

  39287.  i3 = _luaL_checkinteger(i1, 2) | 0;
    39288. 

  39288.  _luaL_checktype(i1, 1, 5);
    39289. 

  39289.  i3 = i3 + 1 | 0;
    39290. 

  39290.  _lua_pushinteger(i1, i3);
    39291. 

  39291.  _lua_rawgeti(i1, 1, i3);
    39292. 

  39292.  i1 = (_lua_type(i1, -1) | 0) == 0;
    39293. 

  39293.  STACKTOP = i2;
    39294. 

  39294.  return (i1 ? 1 : 2) | 0;
    39295. 

  39295. }
    39296. 

  39296. function _panic(i1) {
    39297. 

  39297.  i1 = i1 | 0;
    39298. 

  39298.  var i2 = 0, i3 = 0, i4 = 0;
    39299. 

  39299.  i2 = STACKTOP;
    39300. 

  39300.  STACKTOP = STACKTOP + 16 | 0;
    39301. 

  39301.  i4 = i2;
    39302. 

  39302.  i3 = HEAP32[_stderr >> 2] | 0;
    39303. 

  39303.  HEAP32[i4 >> 2] = _lua_tolstring(i1, -1, 0) | 0;
    39304. 

  39304.  _fprintf(i3 | 0, 1656, i4 | 0) | 0;
    39305. 

  39305.  _fflush(i3 | 0) | 0;
    39306. 

  39306.  STACKTOP = i2;
    39307. 

  39307.  return 0;
    39308. 

  39308. }
    39309. 

  39309. function _testSetjmp(i1, i2) {
    39310. 

  39310.  i1 = i1 | 0;
    39311. 

  39311.  i2 = i2 | 0;
    39312. 

  39312.  var i3 = 0, i4 = 0;
    39313. 

  39313.  while ((i3 | 0) < 20) {
    39314. 

  39314.   i4 = HEAP32[i2 + (i3 << 2) >> 2] | 0;
    39315. 

  39315.   if ((i4 | 0) == 0) break;
    39316. 

  39316.   if ((i4 | 0) == (i1 | 0)) {
    39317. 

  39317.    return HEAP32[i2 + ((i3 << 2) + 4) >> 2] | 0;
    39318. 

  39318.   }
    39319. 

  39319.   i3 = i3 + 2 | 0;
    39320. 

  39320.  }
    39321. 

  39321.  return 0;
    39322. 

  39322. }
    39323. 

  39323. function _luaopen_math(i1) {
    39324. 

  39324.  i1 = i1 | 0;
    39325. 

  39325.  var i2 = 0;
    39326. 

  39326.  i2 = STACKTOP;
    39327. 

  39327.  _lua_createtable(i1, 0, 28);
    39328. 

  39328.  _luaL_setfuncs(i1, 3576, 0);
    39329. 

  39329.  _lua_pushnumber(i1, 3.141592653589793);
    39330. 

  39330.  _lua_setfield(i1, -2, 3808);
    39331. 

  39331.  _lua_pushnumber(i1, inf);
    39332. 

  39332.  _lua_setfield(i1, -2, 3816);
    39333. 

  39333.  STACKTOP = i2;
    39334. 

  39334.  return 1;
    39335. 

  39335. }
    39336. 

  39336. function _luaopen_base(i1) {
    39337. 

  39337.  i1 = i1 | 0;
    39338. 

  39338.  var i2 = 0;
    39339. 

  39339.  i2 = STACKTOP;
    39340. 

  39340.  _lua_rawgeti(i1, -1001e3, 2);
    39341. 

  39341.  _lua_rawgeti(i1, -1001e3, 2);
    39342. 

  39342.  _lua_setfield(i1, -2, 9144);
    39343. 

  39343.  _luaL_setfuncs(i1, 9152, 0);
    39344. 

  39344.  _lua_pushlstring(i1, 9344, 7) | 0;
    39345. 

  39345.  _lua_setfield(i1, -2, 9352);
    39346. 

  39346.  STACKTOP = i2;
    39347. 

  39347.  return 1;
    39348. 

  39348. }
    39349. 

  39349. function _luaE_extendCI(i1) {
    39350. 

  39350.  i1 = i1 | 0;
    39351. 

  39351.  var i2 = 0, i3 = 0;
    39352. 

  39352.  i3 = STACKTOP;
    39353. 

  39353.  i2 = _luaM_realloc_(i1, 0, 0, 40) | 0;
    39354. 

  39354.  i1 = i1 + 16 | 0;
    39355. 

  39355.  HEAP32[(HEAP32[i1 >> 2] | 0) + 12 >> 2] = i2;
    39356. 

  39356.  HEAP32[i2 + 8 >> 2] = HEAP32[i1 >> 2];
    39357. 

  39357.  HEAP32[i2 + 12 >> 2] = 0;
    39358. 

  39358.  STACKTOP = i3;
    39359. 

  39359.  return i2 | 0;
    39360. 

  39360. }
    39361. 

  39361. function _luaB_getmetatable(i1) {
    39362. 

  39362.  i1 = i1 | 0;
    39363. 

  39363.  var i2 = 0;
    39364. 

  39364.  i2 = STACKTOP;
    39365. 

  39365.  _luaL_checkany(i1, 1);
    39366. 

  39366.  if ((_lua_getmetatable(i1, 1) | 0) == 0) {
    39367. 

  39367.   _lua_pushnil(i1);
    39368. 

  39368.   STACKTOP = i2;
    39369. 

  39369.   return 1;
    39370. 

  39370.  } else {
    39371. 

  39371.   _luaL_getmetafield(i1, 1, 9704) | 0;
    39372. 

  39372.   STACKTOP = i2;
    39373. 

  39373.   return 1;
    39374. 

  39374.  }
    39375. 

  39375.  return 0;
    39376. 

  39376. }
    39377. 

  39377. function _lua_pushunsigned(i1, i2) {
    39378. 

  39378.  i1 = i1 | 0;
    39379. 

  39379.  i2 = i2 | 0;
    39380. 

  39380.  var d3 = 0.0;
    39381. 

  39381.  if ((i2 | 0) > -1) {
    39382. 

  39382.   d3 = +(i2 | 0);
    39383. 

  39383.  } else {
    39384. 

  39384.   d3 = +(i2 >>> 0);
    39385. 

  39385.  }
    39386. 

  39386.  i2 = i1 + 8 | 0;
    39387. 

  39387.  i1 = HEAP32[i2 >> 2] | 0;
    39388. 

  39388.  HEAPF64[i1 >> 3] = d3;
    39389. 

  39389.  HEAP32[i1 + 8 >> 2] = 3;
    39390. 

  39390.  HEAP32[i2 >> 2] = i1 + 16;
    39391. 

  39391.  return;
    39392. 

  39392. }
    39393. 

  39393. function _lua_pushthread(i1) {
    39394. 

  39394.  i1 = i1 | 0;
    39395. 

  39395.  var i2 = 0, i3 = 0;
    39396. 

  39396.  i2 = i1 + 8 | 0;
    39397. 

  39397.  i3 = HEAP32[i2 >> 2] | 0;
    39398. 

  39398.  HEAP32[i3 >> 2] = i1;
    39399. 

  39399.  HEAP32[i3 + 8 >> 2] = 72;
    39400. 

  39400.  HEAP32[i2 >> 2] = (HEAP32[i2 >> 2] | 0) + 16;
    39401. 

  39401.  return (HEAP32[(HEAP32[i1 + 12 >> 2] | 0) + 172 >> 2] | 0) == (i1 | 0) | 0;
    39402. 

  39402. }
    39403. 

  39403. function _gctm(i1) {
    39404. 

  39404.  i1 = i1 | 0;
    39405. 

  39405.  var i2 = 0, i3 = 0;
    39406. 

  39406.  i2 = STACKTOP;
    39407. 

  39407.  i3 = _luaL_len(i1, 1) | 0;
    39408. 

  39408.  if ((i3 | 0) <= 0) {
    39409. 

  39409.   STACKTOP = i2;
    39410. 

  39410.   return 0;
    39411. 

  39411.  }
    39412. 

  39412.  do {
    39413. 

  39413.   _lua_rawgeti(i1, 1, i3);
    39414. 

  39414.   _lua_settop(i1, -2);
    39415. 

  39415.   i3 = i3 + -1 | 0;
    39416. 

  39416.  } while ((i3 | 0) > 0);
    39417. 

  39417.  STACKTOP = i2;
    39418. 

  39418.  return 0;
    39419. 

  39419. }
    39420. 

  39420. function ___muldi3(i4, i2, i3, i1) {
    39421. 

  39421.  i4 = i4 | 0;
    39422. 

  39422.  i2 = i2 | 0;
    39423. 

  39423.  i3 = i3 | 0;
    39424. 

  39424.  i1 = i1 | 0;
    39425. 

  39425.  var i5 = 0, i6 = 0;
    39426. 

  39426.  i5 = i4;
    39427. 

  39427.  i6 = i3;
    39428. 

  39428.  i4 = ___muldsi3(i5, i6) | 0;
    39429. 

  39429.  i3 = tempRet0;
    39430. 

  39430.  return (tempRet0 = (Math_imul(i2, i6) | 0) + (Math_imul(i1, i5) | 0) + i3 | i3 & 0, i4 | 0 | 0) | 0;
    39431. 

  39431. }
    39432. 

  39432. function _luaH_resizearray(i1, i3, i4) {
    39433. 

  39433.  i1 = i1 | 0;
    39434. 

  39434.  i3 = i3 | 0;
    39435. 

  39435.  i4 = i4 | 0;
    39436. 

  39436.  var i2 = 0, i5 = 0;
    39437. 

  39437.  i2 = STACKTOP;
    39438. 

  39438.  if ((HEAP32[i3 + 16 >> 2] | 0) == 8016) {
    39439. 

  39439.   i5 = 0;
    39440. 

  39440.  } else {
    39441. 

  39441.   i5 = 1 << (HEAPU8[i3 + 7 | 0] | 0);
    39442. 

  39442.  }
    39443. 

  39443.  _luaH_resize(i1, i3, i4, i5);
    39444. 

  39444.  STACKTOP = i2;
    39445. 

  39445.  return;
    39446. 

  39446. }
    39447. 

  39447. function _luaK_stringK(i1, i2) {
    39448. 

  39448.  i1 = i1 | 0;
    39449. 

  39449.  i2 = i2 | 0;
    39450. 

  39450.  var i3 = 0, i4 = 0;
    39451. 

  39451.  i3 = STACKTOP;
    39452. 

  39452.  STACKTOP = STACKTOP + 16 | 0;
    39453. 

  39453.  i4 = i3;
    39454. 

  39454.  HEAP32[i4 >> 2] = i2;
    39455. 

  39455.  HEAP32[i4 + 8 >> 2] = HEAPU8[i2 + 4 | 0] | 0 | 64;
    39456. 

  39456.  i2 = _addk(i1, i4, i4) | 0;
    39457. 

  39457.  STACKTOP = i3;
    39458. 

  39458.  return i2 | 0;
    39459. 

  39459. }
    39460. 

  39460. function _math_modf(i1) {
    39461. 

  39461.  i1 = i1 | 0;
    39462. 

  39462.  var i2 = 0, d3 = 0.0, i4 = 0;
    39463. 

  39463.  i2 = STACKTOP;
    39464. 

  39464.  STACKTOP = STACKTOP + 16 | 0;
    39465. 

  39465.  i4 = i2;
    39466. 

  39466.  d3 = +_modf(+(+_luaL_checknumber(i1, 1)), i4 | 0);
    39467. 

  39467.  _lua_pushnumber(i1, +HEAPF64[i4 >> 3]);
    39468. 

  39468.  _lua_pushnumber(i1, d3);
    39469. 

  39469.  STACKTOP = i2;
    39470. 

  39470.  return 2;
    39471. 

  39471. }
    39472. 

  39472. function _os_setlocale(i1) {
    39473. 

  39473.  i1 = i1 | 0;
    39474. 

  39474.  var i2 = 0, i3 = 0;
    39475. 

  39475.  i2 = STACKTOP;
    39476. 

  39476.  i3 = _luaL_optlstring(i1, 1, 0, 0) | 0;
    39477. 

  39477.  _lua_pushstring(i1, _setlocale(HEAP32[5960 + ((_luaL_checkoption(i1, 2, 6016, 5984) | 0) << 2) >> 2] | 0, i3 | 0) | 0) | 0;
    39478. 

  39478.  STACKTOP = i2;
    39479. 

  39479.  return 1;
    39480. 

  39480. }
    39481. 

  39481. function _luaB_pcall(i1) {
    39482. 

  39482.  i1 = i1 | 0;
    39483. 

  39483.  var i2 = 0;
    39484. 

  39484.  i2 = STACKTOP;
    39485. 

  39485.  _luaL_checkany(i1, 1);
    39486. 

  39486.  _lua_pushnil(i1);
    39487. 

  39487.  _lua_insert(i1, 1);
    39488. 

  39488.  i1 = _finishpcall(i1, (_lua_pcallk(i1, (_lua_gettop(i1) | 0) + -2 | 0, -1, 0, 0, 166) | 0) == 0 | 0) | 0;
    39489. 

  39489.  STACKTOP = i2;
    39490. 

  39490.  return i1 | 0;
    39491. 

  39491. }
    39492. 

  39492. function _error_expected(i1, i2) {
    39493. 

  39493.  i1 = i1 | 0;
    39494. 

  39494.  i2 = i2 | 0;
    39495. 

  39495.  var i3 = 0, i4 = 0;
    39496. 

  39496.  i3 = STACKTOP;
    39497. 

  39497.  STACKTOP = STACKTOP + 16 | 0;
    39498. 

  39498.  i4 = HEAP32[i1 + 52 >> 2] | 0;
    39499. 

  39499.  HEAP32[i3 >> 2] = _luaX_token2str(i1, i2) | 0;
    39500. 

  39500.  _luaX_syntaxerror(i1, _luaO_pushfstring(i4, 6328, i3) | 0);
    39501. 

  39501. }
    39502. 

  39502. function _lua_pushvfstring(i1, i3, i4) {
    39503. 

  39503.  i1 = i1 | 0;
    39504. 

  39504.  i3 = i3 | 0;
    39505. 

  39505.  i4 = i4 | 0;
    39506. 

  39506.  var i2 = 0;
    39507. 

  39507.  i2 = STACKTOP;
    39508. 

  39508.  if ((HEAP32[(HEAP32[i1 + 12 >> 2] | 0) + 12 >> 2] | 0) > 0) {
    39509. 

  39509.   _luaC_step(i1);
    39510. 

  39510.  }
    39511. 

  39511.  i4 = _luaO_pushvfstring(i1, i3, i4) | 0;
    39512. 

  39512.  STACKTOP = i2;
    39513. 

  39513.  return i4 | 0;
    39514. 

  39514. }
    39515. 

  39515. function _db_setmetatable(i1) {
    39516. 

  39516.  i1 = i1 | 0;
    39517. 

  39517.  var i2 = 0, i3 = 0;
    39518. 

  39518.  i2 = STACKTOP;
    39519. 

  39519.  i3 = _lua_type(i1, 2) | 0;
    39520. 

  39520.  if (!((i3 | 0) == 0 | (i3 | 0) == 5)) {
    39521. 

  39521.   _luaL_argerror(i1, 2, 11536) | 0;
    39522. 

  39522.  }
    39523. 

  39523.  _lua_settop(i1, 2);
    39524. 

  39524.  _lua_setmetatable(i1, 1) | 0;
    39525. 

  39525.  STACKTOP = i2;
    39526. 

  39526.  return 1;
    39527. 

  39527. }
    39528. 

  39528. function _b_rrot(i1) {
    39529. 

  39529.  i1 = i1 | 0;
    39530. 

  39530.  var i2 = 0, i3 = 0, i4 = 0;
    39531. 

  39531.  i2 = STACKTOP;
    39532. 

  39532.  i3 = 0 - (_luaL_checkinteger(i1, 2) | 0) | 0;
    39533. 

  39533.  i4 = _luaL_checkunsigned(i1, 1) | 0;
    39534. 

  39534.  i3 = i3 & 31;
    39535. 

  39535.  _lua_pushunsigned(i1, i4 >>> (32 - i3 | 0) | i4 << i3);
    39536. 

  39536.  STACKTOP = i2;
    39537. 

  39537.  return 1;
    39538. 

  39538. }
    39539. 

  39539. function _luaC_step(i1) {
    39540. 

  39540.  i1 = i1 | 0;
    39541. 

  39541.  var i2 = 0, i3 = 0;
    39542. 

  39542.  i2 = STACKTOP;
    39543. 

  39543.  i3 = HEAP32[i1 + 12 >> 2] | 0;
    39544. 

  39544.  if ((HEAP8[i3 + 63 | 0] | 0) == 0) {
    39545. 

  39545.   _luaE_setdebt(i3, -1600);
    39546. 

  39546.   STACKTOP = i2;
    39547. 

  39547.   return;
    39548. 

  39548.  } else {
    39549. 

  39549.   _luaC_forcestep(i1);
    39550. 

  39550.   STACKTOP = i2;
    39551. 

  39551.   return;
    39552. 

  39552.  }
    39553. 

  39553. }
    39554. 

  39554. function _math_frexp(i1) {
    39555. 

  39555.  i1 = i1 | 0;
    39556. 

  39556.  var i2 = 0, i3 = 0;
    39557. 

  39557.  i2 = STACKTOP;
    39558. 

  39558.  STACKTOP = STACKTOP + 16 | 0;
    39559. 

  39559.  i3 = i2;
    39560. 

  39560.  _lua_pushnumber(i1, +_frexp(+(+_luaL_checknumber(i1, 1)), i3 | 0));
    39561. 

  39561.  _lua_pushinteger(i1, HEAP32[i3 >> 2] | 0);
    39562. 

  39562.  STACKTOP = i2;
    39563. 

  39563.  return 2;
    39564. 

  39564. }
    39565. 

  39565. function _luaO_pushfstring(i2, i1, i3) {
    39566. 

  39566.  i2 = i2 | 0;
    39567. 

  39567.  i1 = i1 | 0;
    39568. 

  39568.  i3 = i3 | 0;
    39569. 

  39569.  var i4 = 0, i5 = 0;
    39570. 

  39570.  i4 = STACKTOP;
    39571. 

  39571.  STACKTOP = STACKTOP + 16 | 0;
    39572. 

  39572.  i5 = i4;
    39573. 

  39573.  HEAP32[i5 >> 2] = i3;
    39574. 

  39574.  i3 = _luaO_pushvfstring(i2, i1, i5) | 0;
    39575. 

  39575.  STACKTOP = i4;
    39576. 

  39576.  return i3 | 0;
    39577. 

  39577. }
    39578. 

  39578. function _luaO_hexavalue(i1) {
    39579. 

  39579.  i1 = i1 | 0;
    39580. 

  39580.  var i2 = 0;
    39581. 

  39581.  i2 = STACKTOP;
    39582. 

  39582.  if ((HEAP8[i1 + 10913 | 0] & 2) == 0) {
    39583. 

  39583.   i1 = (i1 | 32) + -87 | 0;
    39584. 

  39584.   STACKTOP = i2;
    39585. 

  39585.   return i1 | 0;
    39586. 

  39586.  } else {
    39587. 

  39587.   i1 = i1 + -48 | 0;
    39588. 

  39588.   STACKTOP = i2;
    39589. 

  39589.   return i1 | 0;
    39590. 

  39590.  }
    39591. 

  39591.  return 0;
    39592. 

  39592. }
    39593. 

  39593. function _b_lrot(i1) {
    39594. 

  39594.  i1 = i1 | 0;
    39595. 

  39595.  var i2 = 0, i3 = 0, i4 = 0;
    39596. 

  39596.  i2 = STACKTOP;
    39597. 

  39597.  i3 = _luaL_checkinteger(i1, 2) | 0;
    39598. 

  39598.  i4 = _luaL_checkunsigned(i1, 1) | 0;
    39599. 

  39599.  i3 = i3 & 31;
    39600. 

  39600.  _lua_pushunsigned(i1, i4 >>> (32 - i3 | 0) | i4 << i3);
    39601. 

  39601.  STACKTOP = i2;
    39602. 

  39602.  return 1;
    39603. 

  39603. }
    39604. 

  39604. function _f_lines(i1) {
    39605. 

  39605.  i1 = i1 | 0;
    39606. 

  39606.  var i2 = 0;
    39607. 

  39607.  i2 = STACKTOP;
    39608. 

  39608.  STACKTOP = STACKTOP + 16 | 0;
    39609. 

  39609.  if ((HEAP32[(_luaL_checkudata(i1, 1, 2832) | 0) + 4 >> 2] | 0) == 0) {
    39610. 

  39610.   _luaL_error(i1, 3080, i2) | 0;
    39611. 

  39611.  }
    39612. 

  39612.  _aux_lines(i1, 0);
    39613. 

  39613.  STACKTOP = i2;
    39614. 

  39614.  return 1;
    39615. 

  39615. }
    39616. 

  39616. function _luaC_barrierback_(i2, i1) {
    39617. 

  39617.  i2 = i2 | 0;
    39618. 

  39618.  i1 = i1 | 0;
    39619. 

  39619.  var i3 = 0;
    39620. 

  39620.  i2 = HEAP32[i2 + 12 >> 2] | 0;
    39621. 

  39621.  i3 = i1 + 5 | 0;
    39622. 

  39622.  HEAP8[i3] = HEAP8[i3] & 251;
    39623. 

  39623.  i2 = i2 + 88 | 0;
    39624. 

  39624.  HEAP32[i1 + 24 >> 2] = HEAP32[i2 >> 2];
    39625. 

  39625.  HEAP32[i2 >> 2] = i1;
    39626. 

  39626.  return;
    39627. 

  39627. }
    39628. 

  39628. function _os_rename(i1) {
    39629. 

  39629.  i1 = i1 | 0;
    39630. 

  39630.  var i2 = 0, i3 = 0;
    39631. 

  39631.  i2 = STACKTOP;
    39632. 

  39632.  i3 = _luaL_checklstring(i1, 1, 0) | 0;
    39633. 

  39633.  i1 = _luaL_fileresult(i1, (_rename(i3 | 0, _luaL_checklstring(i1, 2, 0) | 0) | 0) == 0 | 0, 0) | 0;
    39634. 

  39634.  STACKTOP = i2;
    39635. 

  39635.  return i1 | 0;
    39636. 

  39636. }
    39637. 

  39637. function _bitshift64Ashr(i3, i2, i1) {
    39638. 

  39638.  i3 = i3 | 0;
    39639. 

  39639.  i2 = i2 | 0;
    39640. 

  39640.  i1 = i1 | 0;
    39641. 

  39641.  if ((i1 | 0) < 32) {
    39642. 

  39642.   tempRet0 = i2 >> i1;
    39643. 

  39643.   return i3 >>> i1 | (i2 & (1 << i1) - 1) << 32 - i1;
    39644. 

  39644.  }
    39645. 

  39645.  tempRet0 = (i2 | 0) < 0 ? -1 : 0;
    39646. 

  39646.  return i2 >> i1 - 32 | 0;
    39647. 

  39647. }
    39648. 

  39648. function _luaB_cowrap(i1) {
    39649. 

  39649.  i1 = i1 | 0;
    39650. 

  39650.  var i2 = 0, i3 = 0;
    39651. 

  39651.  i2 = STACKTOP;
    39652. 

  39652.  _luaL_checktype(i1, 1, 6);
    39653. 

  39653.  i3 = _lua_newthread(i1) | 0;
    39654. 

  39654.  _lua_pushvalue(i1, 1);
    39655. 

  39655.  _lua_xmove(i1, i3, 1);
    39656. 

  39656.  _lua_pushcclosure(i1, 167, 1);
    39657. 

  39657.  STACKTOP = i2;
    39658. 

  39658.  return 1;
    39659. 

  39659. }
    39660. 

  39660. function _gmatch(i1) {
    39661. 

  39661.  i1 = i1 | 0;
    39662. 

  39662.  var i2 = 0;
    39663. 

  39663.  i2 = STACKTOP;
    39664. 

  39664.  _luaL_checklstring(i1, 1, 0) | 0;
    39665. 

  39665.  _luaL_checklstring(i1, 2, 0) | 0;
    39666. 

  39666.  _lua_settop(i1, 2);
    39667. 

  39667.  _lua_pushinteger(i1, 0);
    39668. 

  39668.  _lua_pushcclosure(i1, 163, 3);
    39669. 

  39669.  STACKTOP = i2;
    39670. 

  39670.  return 1;
    39671. 

  39671. }
    39672. 

  39672. function _luaB_next(i2) {
    39673. 

  39673.  i2 = i2 | 0;
    39674. 

  39674.  var i1 = 0;
    39675. 

  39675.  i1 = STACKTOP;
    39676. 

  39676.  _luaL_checktype(i2, 1, 5);
    39677. 

  39677.  _lua_settop(i2, 2);
    39678. 

  39678.  if ((_lua_next(i2, 1) | 0) == 0) {
    39679. 

  39679.   _lua_pushnil(i2);
    39680. 

  39680.   i2 = 1;
    39681. 

  39681.  } else {
    39682. 

  39682.   i2 = 2;
    39683. 

  39683.  }
    39684. 

  39684.  STACKTOP = i1;
    39685. 

  39685.  return i2 | 0;
    39686. 

  39686. }
    39687. 

  39687. function _luaK_codeABC(i5, i3, i4, i2, i1) {
    39688. 

  39688.  i5 = i5 | 0;
    39689. 

  39689.  i3 = i3 | 0;
    39690. 

  39690.  i4 = i4 | 0;
    39691. 

  39691.  i2 = i2 | 0;
    39692. 

  39692.  i1 = i1 | 0;
    39693. 

  39693.  var i6 = 0;
    39694. 

  39694.  i6 = STACKTOP;
    39695. 

  39695.  i5 = _luaK_code(i5, i4 << 6 | i3 | i2 << 23 | i1 << 14) | 0;
    39696. 

  39696.  STACKTOP = i6;
    39697. 

  39697.  return i5 | 0;
    39698. 

  39698. }
    39699. 

  39699. function _luaH_set(i2, i4, i5) {
    39700. 

  39700.  i2 = i2 | 0;
    39701. 

  39701.  i4 = i4 | 0;
    39702. 

  39702.  i5 = i5 | 0;
    39703. 

  39703.  var i1 = 0, i3 = 0;
    39704. 

  39704.  i1 = STACKTOP;
    39705. 

  39705.  i3 = _luaH_get(i4, i5) | 0;
    39706. 

  39706.  if ((i3 | 0) == 5192) {
    39707. 

  39707.   i3 = _luaH_newkey(i2, i4, i5) | 0;
    39708. 

  39708.  }
    39709. 

  39709.  STACKTOP = i1;
    39710. 

  39710.  return i3 | 0;
    39711. 

  39711. }
    39712. 

  39712. function _luaZ_init(i4, i1, i3, i2) {
    39713. 

  39713.  i4 = i4 | 0;
    39714. 

  39714.  i1 = i1 | 0;
    39715. 

  39715.  i3 = i3 | 0;
    39716. 

  39716.  i2 = i2 | 0;
    39717. 

  39717.  HEAP32[i1 + 16 >> 2] = i4;
    39718. 

  39718.  HEAP32[i1 + 8 >> 2] = i3;
    39719. 

  39719.  HEAP32[i1 + 12 >> 2] = i2;
    39720. 

  39720.  HEAP32[i1 >> 2] = 0;
    39721. 

  39721.  HEAP32[i1 + 4 >> 2] = 0;
    39722. 

  39722.  return;
    39723. 

  39723. }
    39724. 

  39724. function _lua_pushlightuserdata(i2, i1) {
    39725. 

  39725.  i2 = i2 | 0;
    39726. 

  39726.  i1 = i1 | 0;
    39727. 

  39727.  var i3 = 0;
    39728. 

  39728.  i2 = i2 + 8 | 0;
    39729. 

  39729.  i3 = HEAP32[i2 >> 2] | 0;
    39730. 

  39730.  HEAP32[i3 >> 2] = i1;
    39731. 

  39731.  HEAP32[i3 + 8 >> 2] = 2;
    39732. 

  39732.  HEAP32[i2 >> 2] = (HEAP32[i2 >> 2] | 0) + 16;
    39733. 

  39733.  return;
    39734. 

  39734. }
    39735. 

  39735. function copyTempFloat(i1) {
    39736. 

  39736.  i1 = i1 | 0;
    39737. 

  39737.  HEAP8[tempDoublePtr] = HEAP8[i1];
    39738. 

  39738.  HEAP8[tempDoublePtr + 1 | 0] = HEAP8[i1 + 1 | 0];
    39739. 

  39739.  HEAP8[tempDoublePtr + 2 | 0] = HEAP8[i1 + 2 | 0];
    39740. 

  39740.  HEAP8[tempDoublePtr + 3 | 0] = HEAP8[i1 + 3 | 0];
    39741. 

  39741. }
    39742. 

  39742. function _bitshift64Shl(i2, i3, i1) {
    39743. 

  39743.  i2 = i2 | 0;
    39744. 

  39744.  i3 = i3 | 0;
    39745. 

  39745.  i1 = i1 | 0;
    39746. 

  39746.  if ((i1 | 0) < 32) {
    39747. 

  39747.   tempRet0 = i3 << i1 | (i2 & (1 << i1) - 1 << 32 - i1) >>> 32 - i1;
    39748. 

  39748.   return i2 << i1;
    39749. 

  39749.  }
    39750. 

  39750.  tempRet0 = i2 << i1 - 32;
    39751. 

  39751.  return 0;
    39752. 

  39752. }
    39753. 

  39753. function _luaB_rawlen(i1) {
    39754. 

  39754.  i1 = i1 | 0;
    39755. 

  39755.  var i2 = 0;
    39756. 

  39756.  i2 = STACKTOP;
    39757. 

  39757.  if (((_lua_type(i1, 1) | 0) & -2 | 0) != 4) {
    39758. 

  39758.   _luaL_argerror(i1, 1, 9784) | 0;
    39759. 

  39759.  }
    39760. 

  39760.  _lua_pushinteger(i1, _lua_rawlen(i1, 1) | 0);
    39761. 

  39761.  STACKTOP = i2;
    39762. 

  39762.  return 1;
    39763. 

  39763. }
    39764. 

  39764. function _l_alloc(i3, i1, i4, i2) {
    39765. 

  39765.  i3 = i3 | 0;
    39766. 

  39766.  i1 = i1 | 0;
    39767. 

  39767.  i4 = i4 | 0;
    39768. 

  39768.  i2 = i2 | 0;
    39769. 

  39769.  i3 = STACKTOP;
    39770. 

  39770.  if ((i2 | 0) == 0) {
    39771. 

  39771.   _free(i1);
    39772. 

  39772.   i1 = 0;
    39773. 

  39773.  } else {
    39774. 

  39774.   i1 = _realloc(i1, i2) | 0;
    39775. 

  39775.  }
    39776. 

  39776.  STACKTOP = i3;
    39777. 

  39777.  return i1 | 0;
    39778. 

  39778. }
    39779. 

  39779. function _bitshift64Lshr(i3, i2, i1) {
    39780. 

  39780.  i3 = i3 | 0;
    39781. 

  39781.  i2 = i2 | 0;
    39782. 

  39782.  i1 = i1 | 0;
    39783. 

  39783.  if ((i1 | 0) < 32) {
    39784. 

  39784.   tempRet0 = i2 >>> i1;
    39785. 

  39785.   return i3 >>> i1 | (i2 & (1 << i1) - 1) << 32 - i1;
    39786. 

  39786.  }
    39787. 

  39787.  tempRet0 = 0;
    39788. 

  39788.  return i2 >>> i1 - 32 | 0;
    39789. 

  39789. }
    39790. 

  39790. function _luaG_aritherror(i3, i1, i2) {
    39791. 

  39791.  i3 = i3 | 0;
    39792. 

  39792.  i1 = i1 | 0;
    39793. 

  39793.  i2 = i2 | 0;
    39794. 

  39794.  var i4 = 0;
    39795. 

  39795.  i4 = STACKTOP;
    39796. 

  39796.  STACKTOP = STACKTOP + 16 | 0;
    39797. 

  39797.  i4 = (_luaV_tonumber(i1, i4) | 0) == 0;
    39798. 

  39798.  _luaG_typeerror(i3, i4 ? i1 : i2, 1928);
    39799. 

  39799. }
    39800. 

  39800. function _str_len(i1) {
    39801. 

  39801.  i1 = i1 | 0;
    39802. 

  39802.  var i2 = 0, i3 = 0;
    39803. 

  39803.  i2 = STACKTOP;
    39804. 

  39804.  STACKTOP = STACKTOP + 16 | 0;
    39805. 

  39805.  i3 = i2;
    39806. 

  39806.  _luaL_checklstring(i1, 1, i3) | 0;
    39807. 

  39807.  _lua_pushinteger(i1, HEAP32[i3 >> 2] | 0);
    39808. 

  39808.  STACKTOP = i2;
    39809. 

  39809.  return 1;
    39810. 

  39810. }
    39811. 

  39811. function _luaL_optinteger(i3, i4, i2) {
    39812. 

  39812.  i3 = i3 | 0;
    39813. 

  39813.  i4 = i4 | 0;
    39814. 

  39814.  i2 = i2 | 0;
    39815. 

  39815.  var i1 = 0;
    39816. 

  39816.  i1 = STACKTOP;
    39817. 

  39817.  if ((_lua_type(i3, i4) | 0) >= 1) {
    39818. 

  39818.   i2 = _luaL_checkinteger(i3, i4) | 0;
    39819. 

  39819.  }
    39820. 

  39820.  STACKTOP = i1;
    39821. 

  39821.  return i2 | 0;
    39822. 

  39822. }
    39823. 

  39823. function _os_difftime(i1) {
    39824. 

  39824.  i1 = i1 | 0;
    39825. 

  39825.  var i2 = 0, i3 = 0;
    39826. 

  39826.  i2 = STACKTOP;
    39827. 

  39827.  i3 = ~~+_luaL_checknumber(i1, 1);
    39828. 

  39828.  _lua_pushnumber(i1, +_difftime(i3 | 0, ~~+_luaL_optnumber(i1, 2, 0.0) | 0));
    39829. 

  39829.  STACKTOP = i2;
    39830. 

  39830.  return 1;
    39831. 

  39831. }
    39832. 

  39832. function _lua_pushboolean(i2, i1) {
    39833. 

  39833.  i2 = i2 | 0;
    39834. 

  39834.  i1 = i1 | 0;
    39835. 

  39835.  var i3 = 0;
    39836. 

  39836.  i2 = i2 + 8 | 0;
    39837. 

  39837.  i3 = HEAP32[i2 >> 2] | 0;
    39838. 

  39838.  HEAP32[i3 >> 2] = (i1 | 0) != 0;
    39839. 

  39839.  HEAP32[i3 + 8 >> 2] = 1;
    39840. 

  39840.  HEAP32[i2 >> 2] = i3 + 16;
    39841. 

  39841.  return;
    39842. 

  39842. }
    39843. 

  39843. function _os_remove(i1) {
    39844. 

  39844.  i1 = i1 | 0;
    39845. 

  39845.  var i2 = 0, i3 = 0;
    39846. 

  39846.  i2 = STACKTOP;
    39847. 

  39847.  i3 = _luaL_checklstring(i1, 1, 0) | 0;
    39848. 

  39848.  i1 = _luaL_fileresult(i1, (_remove(i3 | 0) | 0) == 0 | 0, i3) | 0;
    39849. 

  39849.  STACKTOP = i2;
    39850. 

  39850.  return i1 | 0;
    39851. 

  39851. }
    39852. 

  39852. function _luaopen_table(i1) {
    39853. 

  39853.  i1 = i1 | 0;
    39854. 

  39854.  var i2 = 0;
    39855. 

  39855.  i2 = STACKTOP;
    39856. 

  39856.  _lua_createtable(i1, 0, 7);
    39857. 

  39857.  _luaL_setfuncs(i1, 8088, 0);
    39858. 

  39858.  _lua_getfield(i1, -1, 8152);
    39859. 

  39859.  _lua_setglobal(i1, 8152);
    39860. 

  39860.  STACKTOP = i2;
    39861. 

  39861.  return 1;
    39862. 

  39862. }
    39863. 

  39863. function _lua_pushinteger(i2, i1) {
    39864. 

  39864.  i2 = i2 | 0;
    39865. 

  39865.  i1 = i1 | 0;
    39866. 

  39866.  var i3 = 0;
    39867. 

  39867.  i2 = i2 + 8 | 0;
    39868. 

  39868.  i3 = HEAP32[i2 >> 2] | 0;
    39869. 

  39869.  HEAPF64[i3 >> 3] = +(i1 | 0);
    39870. 

  39870.  HEAP32[i3 + 8 >> 2] = 3;
    39871. 

  39871.  HEAP32[i2 >> 2] = i3 + 16;
    39872. 

  39872.  return;
    39873. 

  39873. }
    39874. 

  39874. function _luaB_rawset(i1) {
    39875. 

  39875.  i1 = i1 | 0;
    39876. 

  39876.  var i2 = 0;
    39877. 

  39877.  i2 = STACKTOP;
    39878. 

  39878.  _luaL_checktype(i1, 1, 5);
    39879. 

  39879.  _luaL_checkany(i1, 2);
    39880. 

  39880.  _luaL_checkany(i1, 3);
    39881. 

  39881.  _lua_settop(i1, 3);
    39882. 

  39882.  _lua_rawset(i1, 1);
    39883. 

  39883.  STACKTOP = i2;
    39884. 

  39884.  return 1;
    39885. 

  39885. }
    39886. 

  39886. function _luaE_setdebt(i2, i1) {
    39887. 

  39887.  i2 = i2 | 0;
    39888. 

  39888.  i1 = i1 | 0;
    39889. 

  39889.  var i3 = 0;
    39890. 

  39890.  i3 = i2 + 12 | 0;
    39891. 

  39891.  i2 = i2 + 8 | 0;
    39892. 

  39892.  HEAP32[i2 >> 2] = (HEAP32[i3 >> 2] | 0) - i1 + (HEAP32[i2 >> 2] | 0);
    39893. 

  39893.  HEAP32[i3 >> 2] = i1;
    39894. 

  39894.  return;
    39895. 

  39895. }
    39896. 

  39896. function _luaB_cocreate(i1) {
    39897. 

  39897.  i1 = i1 | 0;
    39898. 

  39898.  var i2 = 0, i3 = 0;
    39899. 

  39899.  i2 = STACKTOP;
    39900. 

  39900.  _luaL_checktype(i1, 1, 6);
    39901. 

  39901.  i3 = _lua_newthread(i1) | 0;
    39902. 

  39902.  _lua_pushvalue(i1, 1);
    39903. 

  39903.  _lua_xmove(i1, i3, 1);
    39904. 

  39904.  STACKTOP = i2;
    39905. 

  39905.  return 1;
    39906. 

  39906. }
    39907. 

  39907. function _io_noclose(i1) {
    39908. 

  39908.  i1 = i1 | 0;
    39909. 

  39909.  var i2 = 0;
    39910. 

  39910.  i2 = STACKTOP;
    39911. 

  39911.  HEAP32[(_luaL_checkudata(i1, 1, 2832) | 0) + 4 >> 2] = 154;
    39912. 

  39912.  _lua_pushnil(i1);
    39913. 

  39913.  _lua_pushlstring(i1, 2840, 26) | 0;
    39914. 

  39914.  STACKTOP = i2;
    39915. 

  39915.  return 2;
    39916. 

  39916. }
    39917. 

  39917. function _io_fclose(i1) {
    39918. 

  39918.  i1 = i1 | 0;
    39919. 

  39919.  var i2 = 0;
    39920. 

  39920.  i2 = STACKTOP;
    39921. 

  39921.  i1 = _luaL_fileresult(i1, (_fclose(HEAP32[(_luaL_checkudata(i1, 1, 2832) | 0) >> 2] | 0) | 0) == 0 | 0, 0) | 0;
    39922. 

  39922.  STACKTOP = i2;
    39923. 

  39923.  return i1 | 0;
    39924. 

  39924. }
    39925. 

  39925. function _luaL_optnumber(i3, i4, d2) {
    39926. 

  39926.  i3 = i3 | 0;
    39927. 

  39927.  i4 = i4 | 0;
    39928. 

  39928.  d2 = +d2;
    39929. 

  39929.  var i1 = 0;
    39930. 

  39930.  i1 = STACKTOP;
    39931. 

  39931.  if ((_lua_type(i3, i4) | 0) >= 1) {
    39932. 

  39932.   d2 = +_luaL_checknumber(i3, i4);
    39933. 

  39933.  }
    39934. 

  39934.  STACKTOP = i1;
    39935. 

  39935.  return +d2;
    39936. 

  39936. }
    39937. 

  39937. function _math_atan2(i1) {
    39938. 

  39938.  i1 = i1 | 0;
    39939. 

  39939.  var i2 = 0, d3 = 0.0;
    39940. 

  39940.  i2 = STACKTOP;
    39941. 

  39941.  d3 = +_luaL_checknumber(i1, 1);
    39942. 

  39942.  _lua_pushnumber(i1, +Math_atan2(+d3, +(+_luaL_checknumber(i1, 2))));
    39943. 

  39943.  STACKTOP = i2;
    39944. 

  39944.  return 1;
    39945. 

  39945. }
    39946. 

  39946. function _luaK_codeABx(i4, i2, i3, i1) {
    39947. 

  39947.  i4 = i4 | 0;
    39948. 

  39948.  i2 = i2 | 0;
    39949. 

  39949.  i3 = i3 | 0;
    39950. 

  39950.  i1 = i1 | 0;
    39951. 

  39951.  var i5 = 0;
    39952. 

  39952.  i5 = STACKTOP;
    39953. 

  39953.  i4 = _luaK_code(i4, i3 << 6 | i2 | i1 << 14) | 0;
    39954. 

  39954.  STACKTOP = i5;
    39955. 

  39955.  return i4 | 0;
    39956. 

  39956. }
    39957. 

  39957. function _luaF_newCclosure(i2, i1) {
    39958. 

  39958.  i2 = i2 | 0;
    39959. 

  39959.  i1 = i1 | 0;
    39960. 

  39960.  var i3 = 0;
    39961. 

  39961.  i3 = STACKTOP;
    39962. 

  39962.  i2 = _luaC_newobj(i2, 38, (i1 << 4) + 16 | 0, 0, 0) | 0;
    39963. 

  39963.  HEAP8[i2 + 6 | 0] = i1;
    39964. 

  39964.  STACKTOP = i3;
    39965. 

  39965.  return i2 | 0;
    39966. 

  39966. }
    39967. 

  39967. function _math_pow(i1) {
    39968. 

  39968.  i1 = i1 | 0;
    39969. 

  39969.  var i2 = 0, d3 = 0.0;
    39970. 

  39970.  i2 = STACKTOP;
    39971. 

  39971.  d3 = +_luaL_checknumber(i1, 1);
    39972. 

  39972.  _lua_pushnumber(i1, +Math_pow(+d3, +(+_luaL_checknumber(i1, 2))));
    39973. 

  39973.  STACKTOP = i2;
    39974. 

  39974.  return 1;
    39975. 

  39975. }
    39976. 

  39976. function _math_ldexp(i1) {
    39977. 

  39977.  i1 = i1 | 0;
    39978. 

  39978.  var i2 = 0, d3 = 0.0;
    39979. 

  39979.  i2 = STACKTOP;
    39980. 

  39980.  d3 = +_luaL_checknumber(i1, 1);
    39981. 

  39981.  _lua_pushnumber(i1, +_ldexp(d3, _luaL_checkinteger(i1, 2) | 0));
    39982. 

  39982.  STACKTOP = i2;
    39983. 

  39983.  return 1;
    39984. 

  39984. }
    39985. 

  39985. function _luaF_newupval(i1) {
    39986. 

  39986.  i1 = i1 | 0;
    39987. 

  39987.  var i2 = 0;
    39988. 

  39988.  i2 = STACKTOP;
    39989. 

  39989.  i1 = _luaC_newobj(i1, 10, 32, 0, 0) | 0;
    39990. 

  39990.  HEAP32[i1 + 8 >> 2] = i1 + 16;
    39991. 

  39991.  HEAP32[i1 + 24 >> 2] = 0;
    39992. 

  39992.  STACKTOP = i2;
    39993. 

  39993.  return i1 | 0;
    39994. 

  39994. }
    39995. 

  39995. function _lua_pushnumber(i2, d1) {
    39996. 

  39996.  i2 = i2 | 0;
    39997. 

  39997.  d1 = +d1;
    39998. 

  39998.  var i3 = 0;
    39999. 

  39999.  i2 = i2 + 8 | 0;
    40000. 

  40000.  i3 = HEAP32[i2 >> 2] | 0;
    40001. 

  40001.  HEAPF64[i3 >> 3] = d1;
    40002. 

  40002.  HEAP32[i3 + 8 >> 2] = 3;
    40003. 

  40003.  HEAP32[i2 >> 2] = i3 + 16;
    40004. 

  40004.  return;
    40005. 

  40005. }
    40006. 

  40006. function _math_fmod(i1) {
    40007. 

  40007.  i1 = i1 | 0;
    40008. 

  40008.  var i2 = 0, d3 = 0.0;
    40009. 

  40009.  i2 = STACKTOP;
    40010. 

  40010.  d3 = +_luaL_checknumber(i1, 1);
    40011. 

  40011.  _lua_pushnumber(i1, +_fmod(+d3, +(+_luaL_checknumber(i1, 2))));
    40012. 

  40012.  STACKTOP = i2;
    40013. 

  40013.  return 1;
    40014. 

  40014. }
    40015. 

  40015. function _luaG_concaterror(i3, i2, i1) {
    40016. 

  40016.  i3 = i3 | 0;
    40017. 

  40017.  i2 = i2 | 0;
    40018. 

  40018.  i1 = i1 | 0;
    40019. 

  40019.  var i4 = 0;
    40020. 

  40020.  i4 = HEAP32[i2 + 8 >> 2] | 0;
    40021. 

  40021.  _luaG_typeerror(i3, (i4 & 15 | 0) == 4 | (i4 | 0) == 3 ? i1 : i2, 1912);
    40022. 

  40022. }
    40023. 

  40023. function _luaB_rawequal(i1) {
    40024. 

  40024.  i1 = i1 | 0;
    40025. 

  40025.  var i2 = 0;
    40026. 

  40026.  i2 = STACKTOP;
    40027. 

  40027.  _luaL_checkany(i1, 1);
    40028. 

  40028.  _luaL_checkany(i1, 2);
    40029. 

  40029.  _lua_pushboolean(i1, _lua_rawequal(i1, 1, 2) | 0);
    40030. 

  40030.  STACKTOP = i2;
    40031. 

  40031.  return 1;
    40032. 

  40032. }
    40033. 

  40033. function _db_getuservalue(i1) {
    40034. 

  40034.  i1 = i1 | 0;
    40035. 

  40035.  var i2 = 0;
    40036. 

  40036.  i2 = STACKTOP;
    40037. 

  40037.  if ((_lua_type(i1, 1) | 0) == 7) {
    40038. 

  40038.   _lua_getuservalue(i1, 1);
    40039. 

  40039.  } else {
    40040. 

  40040.   _lua_pushnil(i1);
    40041. 

  40041.  }
    40042. 

  40042.  STACKTOP = i2;
    40043. 

  40043.  return 1;
    40044. 

  40044. }
    40045. 

  40045. function _strchr(i2, i1) {
    40046. 

  40046.  i2 = i2 | 0;
    40047. 

  40047.  i1 = i1 | 0;
    40048. 

  40048.  var i3 = 0;
    40049. 

  40049.  i3 = STACKTOP;
    40050. 

  40050.  i2 = ___strchrnul(i2, i1) | 0;
    40051. 

  40051.  STACKTOP = i3;
    40052. 

  40052.  return ((HEAP8[i2] | 0) == (i1 & 255) << 24 >> 24 ? i2 : 0) | 0;
    40053. 

  40053. }
    40054. 

  40054. function runPostSets() {}
    40055. 

  40055. function _rand_r(i1) {
    40056. 

  40056.  i1 = i1 | 0;
    40057. 

  40057.  var i2 = 0;
    40058. 

  40058.  i2 = (Math_imul(HEAP32[i1 >> 2] | 0, 31010991) | 0) + 1735287159 & 2147483647;
    40059. 

  40059.  HEAP32[i1 >> 2] = i2;
    40060. 

  40060.  return i2 | 0;
    40061. 

  40061. }
    40062. 

  40062. function _luaL_checkany(i1, i3) {
    40063. 

  40063.  i1 = i1 | 0;
    40064. 

  40064.  i3 = i3 | 0;
    40065. 

  40065.  var i2 = 0;
    40066. 

  40066.  i2 = STACKTOP;
    40067. 

  40067.  if ((_lua_type(i1, i3) | 0) == -1) {
    40068. 

  40068.   _luaL_argerror(i1, i3, 1256) | 0;
    40069. 

  40069.  }
    40070. 

  40070.  STACKTOP = i2;
    40071. 

  40071.  return;
    40072. 

  40072. }
    40073. 

  40073. function _i64Subtract(i2, i4, i1, i3) {
    40074. 

  40074.  i2 = i2 | 0;
    40075. 

  40075.  i4 = i4 | 0;
    40076. 

  40076.  i1 = i1 | 0;
    40077. 

  40077.  i3 = i3 | 0;
    40078. 

  40078.  i4 = i4 - i3 - (i1 >>> 0 > i2 >>> 0 | 0) >>> 0;
    40079. 

  40079.  return (tempRet0 = i4, i2 - i1 >>> 0 | 0) | 0;
    40080. 

  40080. }
    40081. 

  40081. function _db_getmetatable(i1) {
    40082. 

  40082.  i1 = i1 | 0;
    40083. 

  40083.  var i2 = 0;
    40084. 

  40084.  i2 = STACKTOP;
    40085. 

  40085.  _luaL_checkany(i1, 1);
    40086. 

  40086.  if ((_lua_getmetatable(i1, 1) | 0) == 0) {
    40087. 

  40087.   _lua_pushnil(i1);
    40088. 

  40088.  }
    40089. 

  40089.  STACKTOP = i2;
    40090. 

  40090.  return 1;
    40091. 

  40091. }
    40092. 

  40092. function _luaB_rawget(i1) {
    40093. 

  40093.  i1 = i1 | 0;
    40094. 

  40094.  var i2 = 0;
    40095. 

  40095.  i2 = STACKTOP;
    40096. 

  40096.  _luaL_checktype(i1, 1, 5);
    40097. 

  40097.  _luaL_checkany(i1, 2);
    40098. 

  40098.  _lua_settop(i1, 2);
    40099. 

  40099.  _lua_rawget(i1, 1);
    40100. 

  40100.  STACKTOP = i2;
    40101. 

  40101.  return 1;
    40102. 

  40102. }
    40103. 

  40103. function _luaB_type(i1) {
    40104. 

  40104.  i1 = i1 | 0;
    40105. 

  40105.  var i2 = 0;
    40106. 

  40106.  i2 = STACKTOP;
    40107. 

  40107.  _luaL_checkany(i1, 1);
    40108. 

  40108.  _lua_pushstring(i1, _lua_typename(i1, _lua_type(i1, 1) | 0) | 0) | 0;
    40109. 

  40109.  STACKTOP = i2;
    40110. 

  40110.  return 1;
    40111. 

  40111. }
    40112. 

  40112. function dynCall_iiiii(i5, i4, i3, i2, i1) {
    40113. 

  40113.  i5 = i5 | 0;
    40114. 

  40114.  i4 = i4 | 0;
    40115. 

  40115.  i3 = i3 | 0;
    40116. 

  40116.  i2 = i2 | 0;
    40117. 

  40117.  i1 = i1 | 0;
    40118. 

  40118.  return FUNCTION_TABLE_iiiii[i5 & 3](i4 | 0, i3 | 0, i2 | 0, i1 | 0) | 0;
    40119. 

  40119. }
    40120. 

  40120. function _lstop(i1, i2) {
    40121. 

  40121.  i1 = i1 | 0;
    40122. 

  40122.  i2 = i2 | 0;
    40123. 

  40123.  i2 = STACKTOP;
    40124. 

  40124.  STACKTOP = STACKTOP + 16 | 0;
    40125. 

  40125.  _lua_sethook(i1, 0, 0, 0) | 0;
    40126. 

  40126.  _luaL_error(i1, 200, i2) | 0;
    40127. 

  40127.  STACKTOP = i2;
    40128. 

  40128.  return;
    40129. 

  40129. }
    40130. 

  40130. function _i64Add(i1, i3, i4, i2) {
    40131. 

  40131.  i1 = i1 | 0;
    40132. 

  40132.  i3 = i3 | 0;
    40133. 

  40133.  i4 = i4 | 0;
    40134. 

  40134.  i2 = i2 | 0;
    40135. 

  40135.  i4 = i1 + i4 >>> 0;
    40136. 

  40136.  return (tempRet0 = i3 + i2 + (i4 >>> 0 < i1 >>> 0 | 0) >>> 0, i4 | 0) | 0;
    40137. 

  40137. }
    40138. 

  40138. function _luaK_ret(i3, i2, i1) {
    40139. 

  40139.  i3 = i3 | 0;
    40140. 

  40140.  i2 = i2 | 0;
    40141. 

  40141.  i1 = i1 | 0;
    40142. 

  40142.  var i4 = 0;
    40143. 

  40143.  i4 = STACKTOP;
    40144. 

  40144.  _luaK_code(i3, i2 << 6 | (i1 << 23) + 8388608 | 31) | 0;
    40145. 

  40145.  STACKTOP = i4;
    40146. 

  40146.  return;
    40147. 

  40147. }
    40148. 

  40148. function _strpbrk(i2, i1) {
    40149. 

  40149.  i2 = i2 | 0;
    40150. 

  40150.  i1 = i1 | 0;
    40151. 

  40151.  var i3 = 0;
    40152. 

  40152.  i3 = STACKTOP;
    40153. 

  40153.  i1 = i2 + (_strcspn(i2, i1) | 0) | 0;
    40154. 

  40154.  STACKTOP = i3;
    40155. 

  40155.  return ((HEAP8[i1] | 0) != 0 ? i1 : 0) | 0;
    40156. 

  40156. }
    40157. 

  40157. function _luaL_setmetatable(i1, i2) {
    40158. 

  40158.  i1 = i1 | 0;
    40159. 

  40159.  i2 = i2 | 0;
    40160. 

  40160.  var i3 = 0;
    40161. 

  40161.  i3 = STACKTOP;
    40162. 

  40162.  _lua_getfield(i1, -1001e3, i2);
    40163. 

  40163.  _lua_setmetatable(i1, -2) | 0;
    40164. 

  40164.  STACKTOP = i3;
    40165. 

  40165.  return;
    40166. 

  40166. }
    40167. 

  40167. function _lua_atpanic(i2, i1) {
    40168. 

  40168.  i2 = i2 | 0;
    40169. 

  40169.  i1 = i1 | 0;
    40170. 

  40170.  var i3 = 0;
    40171. 

  40171.  i3 = (HEAP32[i2 + 12 >> 2] | 0) + 168 | 0;
    40172. 

  40172.  i2 = HEAP32[i3 >> 2] | 0;
    40173. 

  40173.  HEAP32[i3 >> 2] = i1;
    40174. 

  40174.  return i2 | 0;
    40175. 

  40175. }
    40176. 

  40176. function _luaL_newstate() {
    40177. 

  40177.  var i1 = 0, i2 = 0;
    40178. 

  40178.  i2 = STACKTOP;
    40179. 

  40179.  i1 = _lua_newstate(1, 0) | 0;
    40180. 

  40180.  if ((i1 | 0) != 0) {
    40181. 

  40181.   _lua_atpanic(i1, 143) | 0;
    40182. 

  40182.  }
    40183. 

  40183.  STACKTOP = i2;
    40184. 

  40184.  return i1 | 0;
    40185. 

  40185. }
    40186. 

  40186. function _luaL_buffinit(i2, i1) {
    40187. 

  40187.  i2 = i2 | 0;
    40188. 

  40188.  i1 = i1 | 0;
    40189. 

  40189.  HEAP32[i1 + 12 >> 2] = i2;
    40190. 

  40190.  HEAP32[i1 >> 2] = i1 + 16;
    40191. 

  40191.  HEAP32[i1 + 8 >> 2] = 0;
    40192. 

  40192.  HEAP32[i1 + 4 >> 2] = 1024;
    40193. 

  40193.  return;
    40194. 

  40194. }
    40195. 

  40195. function _strrchr(i1, i2) {
    40196. 

  40196.  i1 = i1 | 0;
    40197. 

  40197.  i2 = i2 | 0;
    40198. 

  40198.  var i3 = 0;
    40199. 

  40199.  i3 = STACKTOP;
    40200. 

  40200.  i2 = ___memrchr(i1, i2, (_strlen(i1 | 0) | 0) + 1 | 0) | 0;
    40201. 

  40201.  STACKTOP = i3;
    40202. 

  40202.  return i2 | 0;
    40203. 

  40203. }
    40204. 

  40204. function _luaK_fixline(i1, i2) {
    40205. 

  40205.  i1 = i1 | 0;
    40206. 

  40206.  i2 = i2 | 0;
    40207. 

  40207.  HEAP32[(HEAP32[(HEAP32[i1 >> 2] | 0) + 20 >> 2] | 0) + ((HEAP32[i1 + 20 >> 2] | 0) + -1 << 2) >> 2] = i2;
    40208. 

  40208.  return;
    40209. 

  40209. }
    40210. 

  40210. function _luaX_lookahead(i1) {
    40211. 

  40211.  i1 = i1 | 0;
    40212. 

  40212.  var i2 = 0, i3 = 0;
    40213. 

  40213.  i3 = STACKTOP;
    40214. 

  40214.  i2 = _llex(i1, i1 + 40 | 0) | 0;
    40215. 

  40215.  HEAP32[i1 + 32 >> 2] = i2;
    40216. 

  40216.  STACKTOP = i3;
    40217. 

  40217.  return i2 | 0;
    40218. 

  40218. }
    40219. 

  40219. function _f_call(i2, i1) {
    40220. 

  40220.  i2 = i2 | 0;
    40221. 

  40221.  i1 = i1 | 0;
    40222. 

  40222.  var i3 = 0;
    40223. 

  40223.  i3 = STACKTOP;
    40224. 

  40224.  _luaD_call(i2, HEAP32[i1 >> 2] | 0, HEAP32[i1 + 4 >> 2] | 0, 0);
    40225. 

  40225.  STACKTOP = i3;
    40226. 

  40226.  return;
    40227. 

  40227. }
    40228. 

  40228. function _io_pclose(i1) {
    40229. 

  40229.  i1 = i1 | 0;
    40230. 

  40230.  var i2 = 0;
    40231. 

  40231.  i2 = STACKTOP;
    40232. 

  40232.  _luaL_checkudata(i1, 1, 2832) | 0;
    40233. 

  40233.  i1 = _luaL_execresult(i1, -1) | 0;
    40234. 

  40234.  STACKTOP = i2;
    40235. 

  40235.  return i1 | 0;
    40236. 

  40236. }
    40237. 

  40237. function _luaS_new(i2, i1) {
    40238. 

  40238.  i2 = i2 | 0;
    40239. 

  40239.  i1 = i1 | 0;
    40240. 

  40240.  var i3 = 0;
    40241. 

  40241.  i3 = STACKTOP;
    40242. 

  40242.  i2 = _luaS_newlstr(i2, i1, _strlen(i1 | 0) | 0) | 0;
    40243. 

  40243.  STACKTOP = i3;
    40244. 

  40244.  return i2 | 0;
    40245. 

  40245. }
    40246. 

  40246. function _os_getenv(i1) {
    40247. 

  40247.  i1 = i1 | 0;
    40248. 

  40248.  var i2 = 0;
    40249. 

  40249.  i2 = STACKTOP;
    40250. 

  40250.  _lua_pushstring(i1, _getenv(_luaL_checklstring(i1, 1, 0) | 0) | 0) | 0;
    40251. 

  40251.  STACKTOP = i2;
    40252. 

  40252.  return 1;
    40253. 

  40253. }
    40254. 

  40254. function _math_rad(i1) {
    40255. 

  40255.  i1 = i1 | 0;
    40256. 

  40256.  var i2 = 0;
    40257. 

  40257.  i2 = STACKTOP;
    40258. 

  40258.  _lua_pushnumber(i1, +_luaL_checknumber(i1, 1) * .017453292519943295);
    40259. 

  40259.  STACKTOP = i2;
    40260. 

  40260.  return 1;
    40261. 

  40261. }
    40262. 

  40262. function _math_deg(i1) {
    40263. 

  40263.  i1 = i1 | 0;
    40264. 

  40264.  var i2 = 0;
    40265. 

  40265.  i2 = STACKTOP;
    40266. 

  40266.  _lua_pushnumber(i1, +_luaL_checknumber(i1, 1) / .017453292519943295);
    40267. 

  40267.  STACKTOP = i2;
    40268. 

  40268.  return 1;
    40269. 

  40269. }
    40270. 

  40270. function _writer(i4, i2, i1, i3) {
    40271. 

  40271.  i4 = i4 | 0;
    40272. 

  40272.  i2 = i2 | 0;
    40273. 

  40273.  i1 = i1 | 0;
    40274. 

  40274.  i3 = i3 | 0;
    40275. 

  40275.  i4 = STACKTOP;
    40276. 

  40276.  _luaL_addlstring(i3, i2, i1);
    40277. 

  40277.  STACKTOP = i4;
    40278. 

  40278.  return 0;
    40279. 

  40279. }
    40280. 

  40280. function _luaL_addstring(i2, i1) {
    40281. 

  40281.  i2 = i2 | 0;
    40282. 

  40282.  i1 = i1 | 0;
    40283. 

  40283.  var i3 = 0;
    40284. 

  40284.  i3 = STACKTOP;
    40285. 

  40285.  _luaL_addlstring(i2, i1, _strlen(i1 | 0) | 0);
    40286. 

  40286.  STACKTOP = i3;
    40287. 

  40287.  return;
    40288. 

  40288. }
    40289. 

  40289. function _pcallcont(i1) {
    40290. 

  40290.  i1 = i1 | 0;
    40291. 

  40291.  var i2 = 0;
    40292. 

  40292.  i2 = STACKTOP;
    40293. 

  40293.  i1 = _finishpcall(i1, (_lua_getctx(i1, 0) | 0) == 1 | 0) | 0;
    40294. 

  40294.  STACKTOP = i2;
    40295. 

  40295.  return i1 | 0;
    40296. 

  40296. }
    40297. 

  40297. function _luaopen_coroutine(i1) {
    40298. 

  40298.  i1 = i1 | 0;
    40299. 

  40299.  var i2 = 0;
    40300. 

  40300.  i2 = STACKTOP;
    40301. 

  40301.  _lua_createtable(i1, 0, 6);
    40302. 

  40302.  _luaL_setfuncs(i1, 10656, 0);
    40303. 

  40303.  STACKTOP = i2;
    40304. 

  40304.  return 1;
    40305. 

  40305. }
    40306. 

  40306. function _lua_version(i1) {
    40307. 

  40307.  i1 = i1 | 0;
    40308. 

  40308.  if ((i1 | 0) == 0) {
    40309. 

  40309.   i1 = 920;
    40310. 

  40310.  } else {
    40311. 

  40311.   i1 = HEAP32[(HEAP32[i1 + 12 >> 2] | 0) + 176 >> 2] | 0;
    40312. 

  40312.  }
    40313. 

  40313.  return i1 | 0;
    40314. 

  40314. }
    40315. 

  40315. function _lua_pushnil(i1) {
    40316. 

  40316.  i1 = i1 | 0;
    40317. 

  40317.  var i2 = 0;
    40318. 

  40318.  i1 = i1 + 8 | 0;
    40319. 

  40319.  i2 = HEAP32[i1 >> 2] | 0;
    40320. 

  40320.  HEAP32[i2 + 8 >> 2] = 0;
    40321. 

  40321.  HEAP32[i1 >> 2] = i2 + 16;
    40322. 

  40322.  return;
    40323. 

  40323. }
    40324. 

  40324. function _math_floor(i1) {
    40325. 

  40325.  i1 = i1 | 0;
    40326. 

  40326.  var i2 = 0;
    40327. 

  40327.  i2 = STACKTOP;
    40328. 

  40328.  _lua_pushnumber(i1, +Math_floor(+(+_luaL_checknumber(i1, 1))));
    40329. 

  40329.  STACKTOP = i2;
    40330. 

  40330.  return 1;
    40331. 

  40331. }
    40332. 

  40332. function _laction(i1) {
    40333. 

  40333.  i1 = i1 | 0;
    40334. 

  40334.  var i2 = 0;
    40335. 

  40335.  i2 = STACKTOP;
    40336. 

  40336.  _signal(i1 | 0, 0) | 0;
    40337. 

  40337.  _lua_sethook(HEAP32[48] | 0, 1, 11, 1) | 0;
    40338. 

  40338.  STACKTOP = i2;
    40339. 

  40339.  return;
    40340. 

  40340. }
    40341. 

  40341. function dynCall_iiii(i4, i3, i2, i1) {
    40342. 

  40342.  i4 = i4 | 0;
    40343. 

  40343.  i3 = i3 | 0;
    40344. 

  40344.  i2 = i2 | 0;
    40345. 

  40345.  i1 = i1 | 0;
    40346. 

  40346.  return FUNCTION_TABLE_iiii[i4 & 3](i3 | 0, i2 | 0, i1 | 0) | 0;
    40347. 

  40347. }
    40348. 

  40348. function _luaopen_debug(i1) {
    40349. 

  40349.  i1 = i1 | 0;
    40350. 

  40350.  var i2 = 0;
    40351. 

  40351.  i2 = STACKTOP;
    40352. 

  40352.  _lua_createtable(i1, 0, 16);
    40353. 

  40353.  _luaL_setfuncs(i1, 11176, 0);
    40354. 

  40354.  STACKTOP = i2;
    40355. 

  40355.  return 1;
    40356. 

  40356. }
    40357. 

  40357. function _luaopen_bit32(i1) {
    40358. 

  40358.  i1 = i1 | 0;
    40359. 

  40359.  var i2 = 0;
    40360. 

  40360.  i2 = STACKTOP;
    40361. 

  40361.  _lua_createtable(i1, 0, 12);
    40362. 

  40362.  _luaL_setfuncs(i1, 10240, 0);
    40363. 

  40363.  STACKTOP = i2;
    40364. 

  40364.  return 1;
    40365. 

  40365. }
    40366. 

  40366. function _math_sqrt(i1) {
    40367. 

  40367.  i1 = i1 | 0;
    40368. 

  40368.  var i2 = 0;
    40369. 

  40369.  i2 = STACKTOP;
    40370. 

  40370.  _lua_pushnumber(i1, +Math_sqrt(+(+_luaL_checknumber(i1, 1))));
    40371. 

  40371.  STACKTOP = i2;
    40372. 

  40372.  return 1;
    40373. 

  40373. }
    40374. 

  40374. function _math_ceil(i1) {
    40375. 

  40375.  i1 = i1 | 0;
    40376. 

  40376.  var i2 = 0;
    40377. 

  40377.  i2 = STACKTOP;
    40378. 

  40378.  _lua_pushnumber(i1, +Math_ceil(+(+_luaL_checknumber(i1, 1))));
    40379. 

  40379.  STACKTOP = i2;
    40380. 

  40380.  return 1;
    40381. 

  40381. }
    40382. 

  40382. function _math_atan(i1) {
    40383. 

  40383.  i1 = i1 | 0;
    40384. 

  40384.  var i2 = 0;
    40385. 

  40385.  i2 = STACKTOP;
    40386. 

  40386.  _lua_pushnumber(i1, +Math_atan(+(+_luaL_checknumber(i1, 1))));
    40387. 

  40387.  STACKTOP = i2;
    40388. 

  40388.  return 1;
    40389. 

  40389. }
    40390. 

  40390. function _math_asin(i1) {
    40391. 

  40391.  i1 = i1 | 0;
    40392. 

  40392.  var i2 = 0;
    40393. 

  40393.  i2 = STACKTOP;
    40394. 

  40394.  _lua_pushnumber(i1, +Math_asin(+(+_luaL_checknumber(i1, 1))));
    40395. 

  40395.  STACKTOP = i2;
    40396. 

  40396.  return 1;
    40397. 

  40397. }
    40398. 

  40398. function _math_acos(i1) {
    40399. 

  40399.  i1 = i1 | 0;
    40400. 

  40400.  var i2 = 0;
    40401. 

  40401.  i2 = STACKTOP;
    40402. 

  40402.  _lua_pushnumber(i1, +Math_acos(+(+_luaL_checknumber(i1, 1))));
    40403. 

  40403.  STACKTOP = i2;
    40404. 

  40404.  return 1;
    40405. 

  40405. }
    40406. 

  40406. function _lua_close(i1) {
    40407. 

  40407.  i1 = i1 | 0;
    40408. 

  40408.  var i2 = 0;
    40409. 

  40409.  i2 = STACKTOP;
    40410. 

  40410.  _close_state(HEAP32[(HEAP32[i1 + 12 >> 2] | 0) + 172 >> 2] | 0);
    40411. 

  40411.  STACKTOP = i2;
    40412. 

  40412.  return;
    40413. 

  40413. }
    40414. 

  40414. function _dothecall(i1, i2) {
    40415. 

  40415.  i1 = i1 | 0;
    40416. 

  40416.  i2 = i2 | 0;
    40417. 

  40417.  i2 = STACKTOP;
    40418. 

  40418.  _luaD_call(i1, (HEAP32[i1 + 8 >> 2] | 0) + -32 | 0, 0, 0);
    40419. 

  40419.  STACKTOP = i2;
    40420. 

  40420.  return;
    40421. 

  40421. }
    40422. 

  40422. function _math_tan(i1) {
    40423. 

  40423.  i1 = i1 | 0;
    40424. 

  40424.  var i2 = 0;
    40425. 

  40425.  i2 = STACKTOP;
    40426. 

  40426.  _lua_pushnumber(i1, +Math_tan(+(+_luaL_checknumber(i1, 1))));
    40427. 

  40427.  STACKTOP = i2;
    40428. 

  40428.  return 1;
    40429. 

  40429. }
    40430. 

  40430. function _math_sin(i1) {
    40431. 

  40431.  i1 = i1 | 0;
    40432. 

  40432.  var i2 = 0;
    40433. 

  40433.  i2 = STACKTOP;
    40434. 

  40434.  _lua_pushnumber(i1, +Math_sin(+(+_luaL_checknumber(i1, 1))));
    40435. 

  40435.  STACKTOP = i2;
    40436. 

  40436.  return 1;
    40437. 

  40437. }
    40438. 

  40438. function _math_log10(i1) {
    40439. 

  40439.  i1 = i1 | 0;
    40440. 

  40440.  var i2 = 0;
    40441. 

  40441.  i2 = STACKTOP;
    40442. 

  40442.  _lua_pushnumber(i1, +_log10(+(+_luaL_checknumber(i1, 1))));
    40443. 

  40443.  STACKTOP = i2;
    40444. 

  40444.  return 1;
    40445. 

  40445. }
    40446. 

  40446. function _math_exp(i1) {
    40447. 

  40447.  i1 = i1 | 0;
    40448. 

  40448.  var i2 = 0;
    40449. 

  40449.  i2 = STACKTOP;
    40450. 

  40450.  _lua_pushnumber(i1, +Math_exp(+(+_luaL_checknumber(i1, 1))));
    40451. 

  40451.  STACKTOP = i2;
    40452. 

  40452.  return 1;
    40453. 

  40453. }
    40454. 

  40454. function _math_cos(i1) {
    40455. 

  40455.  i1 = i1 | 0;
    40456. 

  40456.  var i2 = 0;
    40457. 

  40457.  i2 = STACKTOP;
    40458. 

  40458.  _lua_pushnumber(i1, +Math_cos(+(+_luaL_checknumber(i1, 1))));
    40459. 

  40459.  STACKTOP = i2;
    40460. 

  40460.  return 1;
    40461. 

  40461. }
    40462. 

  40462. function _math_abs(i1) {
    40463. 

  40463.  i1 = i1 | 0;
    40464. 

  40464.  var i2 = 0;
    40465. 

  40465.  i2 = STACKTOP;
    40466. 

  40466.  _lua_pushnumber(i1, +Math_abs(+(+_luaL_checknumber(i1, 1))));
    40467. 

  40467.  STACKTOP = i2;
    40468. 

  40468.  return 1;
    40469. 

  40469. }
    40470. 

  40470. function _math_randomseed(i1) {
    40471. 

  40471.  i1 = i1 | 0;
    40472. 

  40472.  var i2 = 0;
    40473. 

  40473.  i2 = STACKTOP;
    40474. 

  40474.  _srand(_luaL_checkunsigned(i1, 1) | 0);
    40475. 

  40475.  _rand() | 0;
    40476. 

  40476.  STACKTOP = i2;
    40477. 

  40477.  return 0;
    40478. 

  40478. }
    40479. 

  40479. function _luaopen_os(i1) {
    40480. 

  40480.  i1 = i1 | 0;
    40481. 

  40481.  var i2 = 0;
    40482. 

  40482.  i2 = STACKTOP;
    40483. 

  40483.  _lua_createtable(i1, 0, 11);
    40484. 

  40484.  _luaL_setfuncs(i1, 5624, 0);
    40485. 

  40485.  STACKTOP = i2;
    40486. 

  40486.  return 1;
    40487. 

  40487. }
    40488. 

  40488. function _math_tanh(i1) {
    40489. 

  40489.  i1 = i1 | 0;
    40490. 

  40490.  var i2 = 0;
    40491. 

  40491.  i2 = STACKTOP;
    40492. 

  40492.  _lua_pushnumber(i1, +_tanh(+(+_luaL_checknumber(i1, 1))));
    40493. 

  40493.  STACKTOP = i2;
    40494. 

  40494.  return 1;
    40495. 

  40495. }
    40496. 

  40496. function _math_sinh(i1) {
    40497. 

  40497.  i1 = i1 | 0;
    40498. 

  40498.  var i2 = 0;
    40499. 

  40499.  i2 = STACKTOP;
    40500. 

  40500.  _lua_pushnumber(i1, +_sinh(+(+_luaL_checknumber(i1, 1))));
    40501. 

  40501.  STACKTOP = i2;
    40502. 

  40502.  return 1;
    40503. 

  40503. }
    40504. 

  40504. function _math_cosh(i1) {
    40505. 

  40505.  i1 = i1 | 0;
    40506. 

  40506.  var i2 = 0;
    40507. 

  40507.  i2 = STACKTOP;
    40508. 

  40508.  _lua_pushnumber(i1, +_cosh(+(+_luaL_checknumber(i1, 1))));
    40509. 

  40509.  STACKTOP = i2;
    40510. 

  40510.  return 1;
    40511. 

  40511. }
    40512. 

  40512. function _luaB_yield(i1) {
    40513. 

  40513.  i1 = i1 | 0;
    40514. 

  40514.  var i2 = 0;
    40515. 

  40515.  i2 = STACKTOP;
    40516. 

  40516.  i1 = _lua_yieldk(i1, _lua_gettop(i1) | 0, 0, 0) | 0;
    40517. 

  40517.  STACKTOP = i2;
    40518. 

  40518.  return i1 | 0;
    40519. 

  40519. }
    40520. 

  40520. function _luaB_tostring(i1) {
    40521. 

  40521.  i1 = i1 | 0;
    40522. 

  40522.  var i2 = 0;
    40523. 

  40523.  i2 = STACKTOP;
    40524. 

  40524.  _luaL_checkany(i1, 1);
    40525. 

  40525.  _luaL_tolstring(i1, 1, 0) | 0;
    40526. 

  40526.  STACKTOP = i2;
    40527. 

  40527.  return 1;
    40528. 

  40528. }
    40529. 

  40529. function _growstack(i2, i1) {
    40530. 

  40530.  i2 = i2 | 0;
    40531. 

  40531.  i1 = i1 | 0;
    40532. 

  40532.  var i3 = 0;
    40533. 

  40533.  i3 = STACKTOP;
    40534. 

  40534.  _luaD_growstack(i2, HEAP32[i1 >> 2] | 0);
    40535. 

  40535.  STACKTOP = i3;
    40536. 

  40536.  return;
    40537. 

  40537. }
    40538. 

  40538. function ___udivdi3(i4, i3, i2, i1) {
    40539. 

  40539.  i4 = i4 | 0;
    40540. 

  40540.  i3 = i3 | 0;
    40541. 

  40541.  i2 = i2 | 0;
    40542. 

  40542.  i1 = i1 | 0;
    40543. 

  40543.  i4 = ___udivmoddi4(i4, i3, i2, i1, 0) | 0;
    40544. 

  40544.  return i4 | 0;
    40545. 

  40545. }
    40546. 

  40546. function _b_not(i1) {
    40547. 

  40547.  i1 = i1 | 0;
    40548. 

  40548.  var i2 = 0;
    40549. 

  40549.  i2 = STACKTOP;
    40550. 

  40550.  _lua_pushunsigned(i1, ~(_luaL_checkunsigned(i1, 1) | 0));
    40551. 

  40551.  STACKTOP = i2;
    40552. 

  40552.  return 1;
    40553. 

  40553. }
    40554. 

  40554. function _luaO_fb2int(i1) {
    40555. 

  40555.  i1 = i1 | 0;
    40556. 

  40556.  var i2 = 0;
    40557. 

  40557.  i2 = i1 >>> 3 & 31;
    40558. 

  40558.  if ((i2 | 0) != 0) {
    40559. 

  40559.   i1 = (i1 & 7 | 8) << i2 + -1;
    40560. 

  40560.  }
    40561. 

  40561.  return i1 | 0;
    40562. 

  40562. }
    40563. 

  40563. function _luaB_corunning(i1) {
    40564. 

  40564.  i1 = i1 | 0;
    40565. 

  40565.  var i2 = 0;
    40566. 

  40566.  i2 = STACKTOP;
    40567. 

  40567.  _lua_pushboolean(i1, _lua_pushthread(i1) | 0);
    40568. 

  40568.  STACKTOP = i2;
    40569. 

  40569.  return 2;
    40570. 

  40570. }
    40571. 

  40571. function stackAlloc(i1) {
    40572. 

  40572.  i1 = i1 | 0;
    40573. 

  40573.  var i2 = 0;
    40574. 

  40574.  i2 = STACKTOP;
    40575. 

  40575.  STACKTOP = STACKTOP + i1 | 0;
    40576. 

  40576.  STACKTOP = STACKTOP + 7 & -8;
    40577. 

  40577.  return i2 | 0;
    40578. 

  40578. }
    40579. 

  40579. function _strcoll(i2, i1) {
    40580. 

  40580.  i2 = i2 | 0;
    40581. 

  40581.  i1 = i1 | 0;
    40582. 

  40582.  var i3 = 0;
    40583. 

  40583.  i3 = STACKTOP;
    40584. 

  40584.  i2 = _strcmp(i2, i1) | 0;
    40585. 

  40585.  STACKTOP = i3;
    40586. 

  40586.  return i2 | 0;
    40587. 

  40587. }
    40588. 

  40588. function _os_clock(i1) {
    40589. 

  40589.  i1 = i1 | 0;
    40590. 

  40590.  var i2 = 0;
    40591. 

  40591.  i2 = STACKTOP;
    40592. 

  40592.  _lua_pushnumber(i1, +(_clock() | 0) / 1.0e6);
    40593. 

  40593.  STACKTOP = i2;
    40594. 

  40594.  return 1;
    40595. 

  40595. }
    40596. 

  40596. function _dofilecont(i1) {
    40597. 

  40597.  i1 = i1 | 0;
    40598. 

  40598.  var i2 = 0;
    40599. 

  40599.  i2 = STACKTOP;
    40600. 

  40600.  i1 = (_lua_gettop(i1) | 0) + -1 | 0;
    40601. 

  40601.  STACKTOP = i2;
    40602. 

  40602.  return i1 | 0;
    40603. 

  40603. }
    40604. 

  40604. function _scalbnl(d2, i1) {
    40605. 

  40605.  d2 = +d2;
    40606. 

  40606.  i1 = i1 | 0;
    40607. 

  40607.  var i3 = 0;
    40608. 

  40608.  i3 = STACKTOP;
    40609. 

  40609.  d2 = +_scalbn(d2, i1);
    40610. 

  40610.  STACKTOP = i3;
    40611. 

  40611.  return +d2;
    40612. 

  40612. }
    40613. 

  40613. function _tolower(i1) {
    40614. 

  40614.  i1 = i1 | 0;
    40615. 

  40615.  if ((i1 | 0) < 65) return i1 | 0;
    40616. 

  40616.  if ((i1 | 0) > 90) return i1 | 0;
    40617. 

  40617.  return i1 - 65 + 97 | 0;
    40618. 

  40618. }
    40619. 

  40619. function _lua_gettop(i1) {
    40620. 

  40620.  i1 = i1 | 0;
    40621. 

  40621.  return (HEAP32[i1 + 8 >> 2] | 0) - ((HEAP32[HEAP32[i1 + 16 >> 2] >> 2] | 0) + 16) >> 4 | 0;
    40622. 

  40622. }
    40623. 

  40623. function dynCall_iii(i3, i2, i1) {
    40624. 

  40624.  i3 = i3 | 0;
    40625. 

  40625.  i2 = i2 | 0;
    40626. 

  40626.  i1 = i1 | 0;
    40627. 

  40627.  return FUNCTION_TABLE_iii[i3 & 1](i2 | 0, i1 | 0) | 0;
    40628. 

  40628. }
    40629. 

  40629. function _str_match(i1) {
    40630. 

  40630.  i1 = i1 | 0;
    40631. 

  40631.  var i2 = 0;
    40632. 

  40632.  i2 = STACKTOP;
    40633. 

  40633.  i1 = _str_find_aux(i1, 0) | 0;
    40634. 

  40634.  STACKTOP = i2;
    40635. 

  40635.  return i1 | 0;
    40636. 

  40636. }
    40637. 

  40637. function _luaM_toobig(i1) {
    40638. 

  40638.  i1 = i1 | 0;
    40639. 

  40639.  var i2 = 0;
    40640. 

  40640.  i2 = STACKTOP;
    40641. 

  40641.  STACKTOP = STACKTOP + 16 | 0;
    40642. 

  40642.  _luaG_runerror(i1, 4144, i2);
    40643. 

  40643. }
    40644. 

  40644. function _luaK_getlabel(i1) {
    40645. 

  40645.  i1 = i1 | 0;
    40646. 

  40646.  var i2 = 0;
    40647. 

  40647.  i2 = HEAP32[i1 + 20 >> 2] | 0;
    40648. 

  40648.  HEAP32[i1 + 24 >> 2] = i2;
    40649. 

  40649.  return i2 | 0;
    40650. 

  40650. }
    40651. 

  40651. function _ldexp(d2, i1) {
    40652. 

  40652.  d2 = +d2;
    40653. 

  40653.  i1 = i1 | 0;
    40654. 

  40654.  var i3 = 0;
    40655. 

  40655.  i3 = STACKTOP;
    40656. 

  40656.  d2 = +_scalbn(d2, i1);
    40657. 

  40657.  STACKTOP = i3;
    40658. 

  40658.  return +d2;
    40659. 

  40659. }
    40660. 

  40660. function _str_find(i1) {
    40661. 

  40661.  i1 = i1 | 0;
    40662. 

  40662.  var i2 = 0;
    40663. 

  40663.  i2 = STACKTOP;
    40664. 

  40664.  i1 = _str_find_aux(i1, 1) | 0;
    40665. 

  40665.  STACKTOP = i2;
    40666. 

  40666.  return i1 | 0;
    40667. 

  40667. }
    40668. 

  40668. function _db_getregistry(i1) {
    40669. 

  40669.  i1 = i1 | 0;
    40670. 

  40670.  var i2 = 0;
    40671. 

  40671.  i2 = STACKTOP;
    40672. 

  40672.  _lua_pushvalue(i1, -1001e3);
    40673. 

  40673.  STACKTOP = i2;
    40674. 

  40674.  return 1;
    40675. 

  40675. }
    40676. 

  40676. function _luaB_ipairs(i1) {
    40677. 

  40677.  i1 = i1 | 0;
    40678. 

  40678.  var i2 = 0;
    40679. 

  40679.  i2 = STACKTOP;
    40680. 

  40680.  _pairsmeta(i1, 9960, 1, 165);
    40681. 

  40681.  STACKTOP = i2;
    40682. 

  40682.  return 3;
    40683. 

  40683. }
    40684. 

  40684. function _strlen(i1) {
    40685. 

  40685.  i1 = i1 | 0;
    40686. 

  40686.  var i2 = 0;
    40687. 

  40687.  i2 = i1;
    40688. 

  40688.  while (HEAP8[i2] | 0) {
    40689. 

  40689.   i2 = i2 + 1 | 0;
    40690. 

  40690.  }
    40691. 

  40691.  return i2 - i1 | 0;
    40692. 

  40692. }
    40693. 

  40693. function _luaB_pairs(i1) {
    40694. 

  40694.  i1 = i1 | 0;
    40695. 

  40695.  var i2 = 0;
    40696. 

  40696.  i2 = STACKTOP;
    40697. 

  40697.  _pairsmeta(i1, 9864, 0, 93);
    40698. 

  40698.  STACKTOP = i2;
    40699. 

  40699.  return 3;
    40700. 

  40700. }
    40701. 

  40701. function setThrew(i1, i2) {
    40702. 

  40702.  i1 = i1 | 0;
    40703. 

  40703.  i2 = i2 | 0;
    40704. 

  40704.  if ((__THREW__ | 0) == 0) {
    40705. 

  40705.   __THREW__ = i1;
    40706. 

  40706.   threwValue = i2;
    40707. 

  40707.  }
    40708. 

  40708. }
    40709. 

  40709. function _io_output(i1) {
    40710. 

  40710.  i1 = i1 | 0;
    40711. 

  40711.  var i2 = 0;
    40712. 

  40712.  i2 = STACKTOP;
    40713. 

  40713.  _g_iofile(i1, 2800, 3512);
    40714. 

  40714.  STACKTOP = i2;
    40715. 

  40715.  return 1;
    40716. 

  40716. }
    40717. 

  40717. function dynCall_vii(i3, i2, i1) {
    40718. 

  40718.  i3 = i3 | 0;
    40719. 

  40719.  i2 = i2 | 0;
    40720. 

  40720.  i1 = i1 | 0;
    40721. 

  40721.  FUNCTION_TABLE_vii[i3 & 15](i2 | 0, i1 | 0);
    40722. 

  40722. }
    40723. 

  40723. function _io_input(i1) {
    40724. 

  40724.  i1 = i1 | 0;
    40725. 

  40725.  var i2 = 0;
    40726. 

  40726.  i2 = STACKTOP;
    40727. 

  40727.  _g_iofile(i1, 2776, 3480);
    40728. 

  40728.  STACKTOP = i2;
    40729. 

  40729.  return 1;
    40730. 

  40730. }
    40731. 

  40731. function _semerror(i2, i1) {
    40732. 

  40732.  i2 = i2 | 0;
    40733. 

  40733.  i1 = i1 | 0;
    40734. 

  40734.  HEAP32[i2 + 16 >> 2] = 0;
    40735. 

  40735.  _luaX_syntaxerror(i2, i1);
    40736. 

  40736. }
    40737. 

  40737. function _luaX_syntaxerror(i1, i2) {
    40738. 

  40738.  i1 = i1 | 0;
    40739. 

  40739.  i2 = i2 | 0;
    40740. 

  40740.  _lexerror(i1, i2, HEAP32[i1 + 16 >> 2] | 0);
    40741. 

  40741. }
    40742. 

  40742. function b4(i1, i2, i3, i4) {
    40743. 

  40743.  i1 = i1 | 0;
    40744. 

  40744.  i2 = i2 | 0;
    40745. 

  40745.  i3 = i3 | 0;
    40746. 

  40746.  i4 = i4 | 0;
    40747. 

  40747.  abort(4);
    40748. 

  40748.  return 0;
    40749. 

  40749. }
    40750. 

  40750. function _lua_typename(i2, i1) {
    40751. 

  40751.  i2 = i2 | 0;
    40752. 

  40752.  i1 = i1 | 0;
    40753. 

  40753.  return HEAP32[8528 + (i1 + 1 << 2) >> 2] | 0;
    40754. 

  40754. }
    40755. 

  40755. function dynCall_ii(i2, i1) {
    40756. 

  40756.  i2 = i2 | 0;
    40757. 

  40757.  i1 = i1 | 0;
    40758. 

  40758.  return FUNCTION_TABLE_ii[i2 & 255](i1 | 0) | 0;
    40759. 

  40759. }
    40760. 

  40760. function dynCall_vi(i2, i1) {
    40761. 

  40761.  i2 = i2 | 0;
    40762. 

  40762.  i1 = i1 | 0;
    40763. 

  40763.  FUNCTION_TABLE_vi[i2 & 1](i1 | 0);
    40764. 

  40764. }
    40765. 

  40765. function b0(i1, i2, i3) {
    40766. 

  40766.  i1 = i1 | 0;
    40767. 

  40767.  i2 = i2 | 0;
    40768. 

  40768.  i3 = i3 | 0;
    40769. 

  40769.  abort(0);
    40770. 

  40770.  return 0;
    40771. 

  40771. }
    40772. 

  40772. function _lua_gethookmask(i1) {
    40773. 

  40773.  i1 = i1 | 0;
    40774. 

  40774.  return HEAPU8[i1 + 40 | 0] | 0 | 0;
    40775. 

  40775. }
    40776. 

  40776. function _lua_gethookcount(i1) {
    40777. 

  40777.  i1 = i1 | 0;
    40778. 

  40778.  return HEAP32[i1 + 44 >> 2] | 0;
    40779. 

  40779. }
    40780. 

  40780. function _lua_status(i1) {
    40781. 

  40781.  i1 = i1 | 0;
    40782. 

  40782.  return HEAPU8[i1 + 6 | 0] | 0 | 0;
    40783. 

  40783. }
    40784. 

  40784. function _lua_gethook(i1) {
    40785. 

  40785.  i1 = i1 | 0;
    40786. 

  40786.  return HEAP32[i1 + 52 >> 2] | 0;
    40787. 

  40787. }
    40788. 

  40788. function b5(i1, i2) {
    40789. 

  40789.  i1 = i1 | 0;
    40790. 

  40790.  i2 = i2 | 0;
    40791. 

  40791.  abort(5);
    40792. 

  40792.  return 0;
    40793. 

  40793. }
    40794. 

  40794. function _lua_error(i1) {
    40795. 

  40795.  i1 = i1 | 0;
    40796. 

  40796.  _luaG_errormsg(i1);
    40797. 

  40797.  return 0;
    40798. 

  40798. }
    40799. 

  40799. function b2(i1, i2) {
    40800. 

  40800.  i1 = i1 | 0;
    40801. 

  40801.  i2 = i2 | 0;
    40802. 

  40802.  abort(2);
    40803. 

  40803. }
    40804. 

  40804. function stackRestore(i1) {
    40805. 

  40805.  i1 = i1 | 0;
    40806. 

  40806.  STACKTOP = i1;
    40807. 

  40807. }
    40808. 

  40808. function setTempRet9(i1) {
    40809. 

  40809.  i1 = i1 | 0;
    40810. 

  40810.  tempRet9 = i1;
    40811. 

  40811. }
    40812. 

  40812. function setTempRet8(i1) {
    40813. 

  40813.  i1 = i1 | 0;
    40814. 

  40814.  tempRet8 = i1;
    40815. 

  40815. }
    40816. 

  40816. function setTempRet7(i1) {
    40817. 

  40817.  i1 = i1 | 0;
    40818. 

  40818.  tempRet7 = i1;
    40819. 

  40819. }
    40820. 

  40820. function setTempRet6(i1) {
    40821. 

  40821.  i1 = i1 | 0;
    40822. 

  40822.  tempRet6 = i1;
    40823. 

  40823. }
    40824. 

  40824. function setTempRet5(i1) {
    40825. 

  40825.  i1 = i1 | 0;
    40826. 

  40826.  tempRet5 = i1;
    40827. 

  40827. }
    40828. 

  40828. function setTempRet4(i1) {
    40829. 

  40829.  i1 = i1 | 0;
    40830. 

  40830.  tempRet4 = i1;
    40831. 

  40831. }
    40832. 

  40832. function setTempRet3(i1) {
    40833. 

  40833.  i1 = i1 | 0;
    40834. 

  40834.  tempRet3 = i1;
    40835. 

  40835. }
    40836. 

  40836. function setTempRet2(i1) {
    40837. 

  40837.  i1 = i1 | 0;
    40838. 

  40838.  tempRet2 = i1;
    40839. 

  40839. }
    40840. 

  40840. function setTempRet1(i1) {
    40841. 

  40841.  i1 = i1 | 0;
    40842. 

  40842.  tempRet1 = i1;
    40843. 

  40843. }
    40844. 

  40844. function setTempRet0(i1) {
    40845. 

  40845.  i1 = i1 | 0;
    40846. 

  40846.  tempRet0 = i1;
    40847. 

  40847. }
    40848. 

  40848. function b3(i1) {
    40849. 

  40849.  i1 = i1 | 0;
    40850. 

  40850.  abort(3);
    40851. 

  40851.  return 0;
    40852. 

  40852. }
    40853. 

  40853. function _rand() {
    40854. 

  40854.  return _rand_r(___rand_seed) | 0;
    40855. 

  40855. }
    40856. 

  40856. function stackSave() {
    40857. 

  40857.  return STACKTOP | 0;
    40858. 

  40858. }
    40859. 

  40859. function b1(i1) {
    40860. 

  40860.  i1 = i1 | 0;
    40861. 

  40861.  abort(1);
    40862. 

  40862. }
    40863. 

  40863. 

  40864. // EMSCRIPTEN_END_FUNCS
    40865. 

  40865.   var FUNCTION_TABLE_iiii = [b0,_getF,_getS,_generic_reader];
    40866. 

  40866.   var FUNCTION_TABLE_vi = [b1,_laction];
    40867. 

  40867.   var FUNCTION_TABLE_vii = [b2,_lstop,_growstack,_f_call,_resume,_unroll,_f_parser,_dothecall,_f_luaopen,_hookf,b2,b2,b2,b2,b2,b2];
    40868. 

  40868.   var FUNCTION_TABLE_ii = [b3,_io_close,_io_flush,_io_input,_io_lines,_io_open,_io_output,_io_popen,_io_read,_io_tmpfile,_io_type,_io_write,_f_flush,_f_lines,_f_read,_f_seek,_f_setvbuf,_f_write,_f_gc,_f_tostring,_math_abs,_math_acos,_math_asin,_math_atan2,_math_atan,_math_ceil,_math_cosh,_math_cos,_math_deg
    40869. 

  40869.   ,_math_exp,_math_floor,_math_fmod,_math_frexp,_math_ldexp,_math_log10,_math_log,_math_max,_math_min,_math_modf,_math_pow,_math_rad,_math_random,_math_randomseed,_math_sinh,_math_sin,_math_sqrt,_math_tanh,_math_tan,_ll_loadlib,_ll_searchpath,_ll_seeall,_ll_module,_ll_require,_os_clock,_os_date,_os_difftime,_os_execute,_os_exit,_os_getenv
    40870. 

  40870.   ,_os_remove,_os_rename,_os_setlocale,_os_time,_os_tmpname,_str_byte,_str_char,_str_dump,_str_find,_str_format,_gmatch,_str_gsub,_str_len,_str_lower,_str_match,_str_rep,_str_reverse,_str_sub,_str_upper,_tconcat,_maxn,_tinsert,_pack,_unpack,_tremove,_sort,_luaB_assert,_luaB_collectgarbage,_luaB_dofile,_luaB_error
    40871. 

  40871.   ,_luaB_getmetatable,_luaB_ipairs,_luaB_loadfile,_luaB_load,_luaB_next,_luaB_pairs,_luaB_pcall,_luaB_print,_luaB_rawequal,_luaB_rawlen,_luaB_rawget,_luaB_rawset,_luaB_select,_luaB_setmetatable,_luaB_tonumber,_luaB_tostring,_luaB_type,_luaB_xpcall,_b_arshift,_b_and,_b_not,_b_or,_b_xor,_b_test,_b_extract,_b_lrot,_b_lshift,_b_replace,_b_rrot,_b_rshift
    40872. 

  40872.   ,_luaB_cocreate,_luaB_coresume,_luaB_corunning,_luaB_costatus,_luaB_cowrap,_luaB_yield,_db_debug,_db_getuservalue,_db_gethook,_db_getinfo,_db_getlocal,_db_getregistry,_db_getmetatable,_db_getupvalue,_db_upvaluejoin,_db_upvalueid,_db_setuservalue,_db_sethook,_db_setlocal,_db_setmetatable,_db_setupvalue,_db_traceback,_pmain,_traceback,_panic,_luaopen_base,_luaopen_package,_luaopen_coroutine,_luaopen_table,_luaopen_io
    40873. 

  40873.   ,_luaopen_os,_luaopen_string,_luaopen_bit32,_luaopen_math,_luaopen_debug,_io_noclose,_io_readline,_io_fclose,_io_pclose,_gctm,_searcher_preload,_searcher_Lua,_searcher_C,_searcher_Croot,_gmatch_aux,_dofilecont,_ipairsaux,_pcallcont,_luaB_auxwrap,b3,b3,b3,b3,b3,b3,b3,b3,b3,b3,b3
    40874. 

  40874.   ,b3,b3,b3,b3,b3,b3,b3,b3,b3,b3,b3,b3,b3,b3,b3,b3,b3,b3,b3,b3,b3,b3,b3,b3,b3,b3,b3,b3,b3,b3
    40875. 

  40875.   ,b3,b3,b3,b3,b3,b3,b3,b3,b3,b3,b3,b3,b3,b3,b3,b3,b3,b3,b3,b3,b3,b3,b3,b3,b3,b3,b3,b3,b3,b3
    40876. 

  40876.   ,b3,b3,b3,b3,b3,b3,b3,b3,b3,b3,b3,b3,b3,b3,b3,b3,b3];
    40877. 

  40877.   var FUNCTION_TABLE_iiiii = [b4,_l_alloc,_writer,b4];
    40878. 

  40878.   var FUNCTION_TABLE_iii = [b5,_lua_newstate];
    40879. 

  40879. 

  40880.   return { _testSetjmp: _testSetjmp, _i64Subtract: _i64Subtract, _free: _free, _main: _main, _rand_r: _rand_r, _realloc: _realloc, _i64Add: _i64Add, _tolower: _tolower, _saveSetjmp: _saveSetjmp, _memset: _memset, _malloc: _malloc, _memcpy: _memcpy, _strlen: _strlen, _rand: _rand, _bitshift64Shl: _bitshift64Shl, runPostSets: runPostSets, stackAlloc: stackAlloc, stackSave: stackSave, stackRestore: stackRestore, setThrew: setThrew, setTempRet0: setTempRet0, setTempRet1: setTempRet1, setTempRet2: setTempRet2, setTempRet3: setTempRet3, setTempRet4: setTempRet4, setTempRet5: setTempRet5, setTempRet6: setTempRet6, setTempRet7: setTempRet7, setTempRet8: setTempRet8, setTempRet9: setTempRet9, dynCall_iiii: dynCall_iiii, dynCall_vi: dynCall_vi, dynCall_vii: dynCall_vii, dynCall_ii: dynCall_ii, dynCall_iiiii: dynCall_iiiii, dynCall_iii: dynCall_iii };
    40881. 

  40881. })
    40882. 

  40882. // EMSCRIPTEN_END_ASM
    40883. 

  40883. ({ "Math": Math, "Int8Array": Int8Array, "Int16Array": Int16Array, "Int32Array": Int32Array, "Uint8Array": Uint8Array, "Uint16Array": Uint16Array, "Uint32Array": Uint32Array, "Float32Array": Float32Array, "Float64Array": Float64Array }, { "abort": abort, "assert": assert, "asmPrintInt": asmPrintInt, "asmPrintFloat": asmPrintFloat, "min": Math_min, "invoke_iiii": invoke_iiii, "invoke_vi": invoke_vi, "invoke_vii": invoke_vii, "invoke_ii": invoke_ii, "invoke_iiiii": invoke_iiiii, "invoke_iii": invoke_iii, "_isalnum": _isalnum, "_fabs": _fabs, "_frexp": _frexp, "_exp": _exp, "_fread": _fread, "__reallyNegative": __reallyNegative, "_longjmp": _longjmp, "__addDays": __addDays, "_fsync": _fsync, "_signal": _signal, "_rename": _rename, "_sbrk": _sbrk, "_emscripten_memcpy_big": _emscripten_memcpy_big, "_sinh": _sinh, "_sysconf": _sysconf, "_close": _close, "_ferror": _ferror, "_clock": _clock, "_cos": _cos, "_tanh": _tanh, "_unlink": _unlink, "_write": _write, "__isLeapYear": __isLeapYear, "_ftell": _ftell, "_isupper": _isupper, "_gmtime_r": _gmtime_r, "_islower": _islower, "_tmpnam": _tmpnam, "_tmpfile": _tmpfile, "_send": _send, "_abort": _abort, "_setvbuf": _setvbuf, "_atan2": _atan2, "_setlocale": _setlocale, "_isgraph": _isgraph, "_modf": _modf, "_strerror_r": _strerror_r, "_fscanf": _fscanf, "___setErrNo": ___setErrNo, "_isalpha": _isalpha, "_srand": _srand, "_mktime": _mktime, "_putchar": _putchar, "_gmtime": _gmtime, "_localeconv": _localeconv, "_sprintf": _sprintf, "_localtime": _localtime, "_read": _read, "_fwrite": _fwrite, "_time": _time, "_fprintf": _fprintf, "_exit": _exit, "_freopen": _freopen, "_llvm_pow_f64": _llvm_pow_f64, "_fgetc": _fgetc, "_fmod": _fmod, "_lseek": _lseek, "_rmdir": _rmdir, "_asin": _asin, "_floor": _floor, "_pwrite": _pwrite, "_localtime_r": _localtime_r, "_tzset": _tzset, "_open": _open, "_remove": _remove, "_snprintf": _snprintf, "__scanString": __scanString, "_strftime": _strftime, "_fseek": _fseek, "_iscntrl": _iscntrl, "_isxdigit": _isxdigit, "_fclose": _fclose, "_log": _log, "_recv": _recv, "_tan": _tan, "_copysign": _copysign, "__getFloat": __getFloat, "_fputc": _fputc, "_ispunct": _ispunct, "_ceil": _ceil, "_isspace": _isspace, "_fopen": _fopen, "_sin": _sin, "_acos": _acos, "_cosh": _cosh, "___buildEnvironment": ___buildEnvironment, "_difftime": _difftime, "_ungetc": _ungetc, "_system": _system, "_fflush": _fflush, "_log10": _log10, "_fileno": _fileno, "__exit": __exit, "__arraySum": __arraySum, "_fgets": _fgets, "_atan": _atan, "_pread": _pread, "_mkport": _mkport, "_toupper": _toupper, "_feof": _feof, "___errno_location": ___errno_location, "_clearerr": _clearerr, "_getenv": _getenv, "_strerror": _strerror, "_emscripten_longjmp": _emscripten_longjmp, "__formatString": __formatString, "_fputs": _fputs, "_sqrt": _sqrt, "STACKTOP": STACKTOP, "STACK_MAX": STACK_MAX, "tempDoublePtr": tempDoublePtr, "ABORT": ABORT, "cttz_i8": cttz_i8, "ctlz_i8": ctlz_i8, "___rand_seed": ___rand_seed, "NaN": NaN, "Infinity": Infinity, "_stderr": _stderr, "_stdin": _stdin, "_stdout": _stdout }, buffer);
    40884. 

  40884. var _testSetjmp = Module["_testSetjmp"] = asm["_testSetjmp"];
    40885. 

  40885. var _i64Subtract = Module["_i64Subtract"] = asm["_i64Subtract"];
    40886. 

  40886. var _free = Module["_free"] = asm["_free"];
    40887. 

  40887. var _main = Module["_main"] = asm["_main"];
    40888. 

  40888. var _rand_r = Module["_rand_r"] = asm["_rand_r"];
    40889. 

  40889. var _realloc = Module["_realloc"] = asm["_realloc"];
    40890. 

  40890. var _i64Add = Module["_i64Add"] = asm["_i64Add"];
    40891. 

  40891. var _tolower = Module["_tolower"] = asm["_tolower"];
    40892. 

  40892. var _saveSetjmp = Module["_saveSetjmp"] = asm["_saveSetjmp"];
    40893. 

  40893. var _memset = Module["_memset"] = asm["_memset"];
    40894. 

  40894. var _malloc = Module["_malloc"] = asm["_malloc"];
    40895. 

  40895. var _memcpy = Module["_memcpy"] = asm["_memcpy"];
    40896. 

  40896. var _strlen = Module["_strlen"] = asm["_strlen"];
    40897. 

  40897. var _rand = Module["_rand"] = asm["_rand"];
    40898. 

  40898. var _bitshift64Shl = Module["_bitshift64Shl"] = asm["_bitshift64Shl"];
    40899. 

  40899. var runPostSets = Module["runPostSets"] = asm["runPostSets"];
    40900. 

  40900. var dynCall_iiii = Module["dynCall_iiii"] = asm["dynCall_iiii"];
    40901. 

  40901. var dynCall_vi = Module["dynCall_vi"] = asm["dynCall_vi"];
    40902. 

  40902. var dynCall_vii = Module["dynCall_vii"] = asm["dynCall_vii"];
    40903. 

  40903. var dynCall_ii = Module["dynCall_ii"] = asm["dynCall_ii"];
    40904. 

  40904. var dynCall_iiiii = Module["dynCall_iiiii"] = asm["dynCall_iiiii"];
    40905. 

  40905. var dynCall_iii = Module["dynCall_iii"] = asm["dynCall_iii"];
    40906. 

  40906. 

  40907. Runtime.stackAlloc = function(size) { return asm['stackAlloc'](size) };
    40908. 

  40908. Runtime.stackSave = function() { return asm['stackSave']() };
    40909. 

  40909. Runtime.stackRestore = function(top) { asm['stackRestore'](top) };
    40910. 

  40910. 

  40911. 

  40912. // TODO: strip out parts of this we do not need
    40913. 

  40913. 

  40914. //======= begin closure i64 code =======
    40915. 

  40915. 

  40916. // Copyright 2009 The Closure Library Authors. All Rights Reserved.
    40917. 

  40917. //
    40918. 

  40918. // Licensed under the Apache License, Version 2.0 (the "License");
    40919. 

  40919. // you may not use this file except in compliance with the License.
    40920. 

  40920. // You may obtain a copy of the License at
    40921. 

  40921. //
    40922. 

  40922. //      http://www.apache.org/licenses/LICENSE-2.0
    40923. 

  40923. //
    40924. 

  40924. // Unless required by applicable law or agreed to in writing, software
    40925. 

  40925. // distributed under the License is distributed on an "AS-IS" BASIS,
    40926. 

  40926. // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    40927. 

  40927. // See the License for the specific language governing permissions and
    40928. 

  40928. // limitations under the License.
    40929. 

  40929. 

  40930. /**
    40931. 

  40931.  * @fileoverview Defines a Long class for representing a 64-bit two's-complement
    40932. 

  40932.  * integer value, which faithfully simulates the behavior of a Java "long". This
    40933. 

  40933.  * implementation is derived from LongLib in GWT.
    40934. 

  40934.  *
    40935. 

  40935.  */
    40936. 

  40936. 

  40937. var i64Math = (function() { // Emscripten wrapper
    40938. 

  40938.   var goog = { math: {} };
    40939. 

  40939. 

  40940. 

  40941.   /**
    40942. 

  40942.    * Constructs a 64-bit two's-complement integer, given its low and high 32-bit
    40943. 

  40943.    * values as *signed* integers.  See the from* functions below for more
    40944. 

  40944.    * convenient ways of constructing Longs.
    40945. 

  40945.    *
    40946. 

  40946.    * The internal representation of a long is the two given signed, 32-bit values.
    40947. 

  40947.    * We use 32-bit pieces because these are the size of integers on which
    40948. 

  40948.    * Javascript performs bit-operations.  For operations like addition and
    40949. 

  40949.    * multiplication, we split each number into 16-bit pieces, which can easily be
    40950. 

  40950.    * multiplied within Javascript's floating-point representation without overflow
    40951. 

  40951.    * or change in sign.
    40952. 

  40952.    *
    40953. 

  40953.    * In the algorithms below, we frequently reduce the negative case to the
    40954. 

  40954.    * positive case by negating the input(s) and then post-processing the result.
    40955. 

  40955.    * Note that we must ALWAYS check specially whether those values are MIN_VALUE
    40956. 

  40956.    * (-2^63) because -MIN_VALUE == MIN_VALUE (since 2^63 cannot be represented as
    40957. 

  40957.    * a positive number, it overflows back into a negative).  Not handling this
    40958. 

  40958.    * case would often result in infinite recursion.
    40959. 

  40959.    *
    40960. 

  40960.    * @param {number} low  The low (signed) 32 bits of the long.
    40961. 

  40961.    * @param {number} high  The high (signed) 32 bits of the long.
    40962. 

  40962.    * @constructor
    40963. 

  40963.    */
    40964. 

  40964.   goog.math.Long = function(low, high) {
    40965. 

  40965.     /**
    40966. 

  40966.      * @type {number}
    40967. 

  40967.      * @private
    40968. 

  40968.      */
    40969. 

  40969.     this.low_ = low | 0;  // force into 32 signed bits.
    40970. 

  40970. 

  40971.     /**
    40972. 

  40972.      * @type {number}
    40973. 

  40973.      * @private
    40974. 

  40974.      */
    40975. 

  40975.     this.high_ = high | 0;  // force into 32 signed bits.
    40976. 

  40976.   };
    40977. 

  40977. 

  40978. 

  40979.   // NOTE: Common constant values ZERO, ONE, NEG_ONE, etc. are defined below the
    40980. 

  40980.   // from* methods on which they depend.
    40981. 

  40981. 

  40982. 

  40983.   /**
    40984. 

  40984.    * A cache of the Long representations of small integer values.
    40985. 

  40985.    * @type {!Object}
    40986. 

  40986.    * @private
    40987. 

  40987.    */
    40988. 

  40988.   goog.math.Long.IntCache_ = {};
    40989. 

  40989. 

  40990. 

  40991.   /**
    40992. 

  40992.    * Returns a Long representing the given (32-bit) integer value.
    40993. 

  40993.    * @param {number} value The 32-bit integer in question.
    40994. 

  40994.    * @return {!goog.math.Long} The corresponding Long value.
    40995. 

  40995.    */
    40996. 

  40996.   goog.math.Long.fromInt = function(value) {
    40997. 

  40997.     if (-128 <= value && value < 128) {
    40998. 

  40998.       var cachedObj = goog.math.Long.IntCache_[value];
    40999. 

  40999.       if (cachedObj) {
    41000. 

  41000.         return cachedObj;
    41001. 

  41001.       }
    41002. 

  41002.     }
    41003. 

  41003. 

  41004.     var obj = new goog.math.Long(value | 0, value < 0 ? -1 : 0);
    41005. 

  41005.     if (-128 <= value && value < 128) {
    41006. 

  41006.       goog.math.Long.IntCache_[value] = obj;
    41007. 

  41007.     }
    41008. 

  41008.     return obj;
    41009. 

  41009.   };
    41010. 

  41010. 

  41011. 

  41012.   /**
    41013. 

  41013.    * Returns a Long representing the given value, provided that it is a finite
    41014. 

  41014.    * number.  Otherwise, zero is returned.
    41015. 

  41015.    * @param {number} value The number in question.
    41016. 

  41016.    * @return {!goog.math.Long} The corresponding Long value.
    41017. 

  41017.    */
    41018. 

  41018.   goog.math.Long.fromNumber = function(value) {
    41019. 

  41019.     if (isNaN(value) || !isFinite(value)) {
    41020. 

  41020.       return goog.math.Long.ZERO;
    41021. 

  41021.     } else if (value <= -goog.math.Long.TWO_PWR_63_DBL_) {
    41022. 

  41022.       return goog.math.Long.MIN_VALUE;
    41023. 

  41023.     } else if (value + 1 >= goog.math.Long.TWO_PWR_63_DBL_) {
    41024. 

  41024.       return goog.math.Long.MAX_VALUE;
    41025. 

  41025.     } else if (value < 0) {
    41026. 

  41026.       return goog.math.Long.fromNumber(-value).negate();
    41027. 

  41027.     } else {
    41028. 

  41028.       return new goog.math.Long(
    41029. 

  41029.           (value % goog.math.Long.TWO_PWR_32_DBL_) | 0,
    41030. 

  41030.           (value / goog.math.Long.TWO_PWR_32_DBL_) | 0);
    41031. 

  41031.     }
    41032. 

  41032.   };
    41033. 

  41033. 

  41034. 

  41035.   /**
    41036. 

  41036.    * Returns a Long representing the 64-bit integer that comes by concatenating
    41037. 

  41037.    * the given high and low bits.  Each is assumed to use 32 bits.
    41038. 

  41038.    * @param {number} lowBits The low 32-bits.
    41039. 

  41039.    * @param {number} highBits The high 32-bits.
    41040. 

  41040.    * @return {!goog.math.Long} The corresponding Long value.
    41041. 

  41041.    */
    41042. 

  41042.   goog.math.Long.fromBits = function(lowBits, highBits) {
    41043. 

  41043.     return new goog.math.Long(lowBits, highBits);
    41044. 

  41044.   };
    41045. 

  41045. 

  41046. 

  41047.   /**
    41048. 

  41048.    * Returns a Long representation of the given string, written using the given
    41049. 

  41049.    * radix.
    41050. 

  41050.    * @param {string} str The textual representation of the Long.
    41051. 

  41051.    * @param {number=} opt_radix The radix in which the text is written.
    41052. 

  41052.    * @return {!goog.math.Long} The corresponding Long value.
    41053. 

  41053.    */
    41054. 

  41054.   goog.math.Long.fromString = function(str, opt_radix) {
    41055. 

  41055.     if (str.length == 0) {
    41056. 

  41056.       throw Error('number format error: empty string');
    41057. 

  41057.     }
    41058. 

  41058. 

  41059.     var radix = opt_radix || 10;
    41060. 

  41060.     if (radix < 2 || 36 < radix) {
    41061. 

  41061.       throw Error('radix out of range: ' + radix);
    41062. 

  41062.     }
    41063. 

  41063. 

  41064.     if (str.charAt(0) == '-') {
    41065. 

  41065.       return goog.math.Long.fromString(str.substring(1), radix).negate();
    41066. 

  41066.     } else if (str.indexOf('-') >= 0) {
    41067. 

  41067.       throw Error('number format error: interior "-" character: ' + str);
    41068. 

  41068.     }
    41069. 

  41069. 

  41070.     // Do several (8) digits each time through the loop, so as to
    41071. 

  41071.     // minimize the calls to the very expensive emulated div.
    41072. 

  41072.     var radixToPower = goog.math.Long.fromNumber(Math.pow(radix, 8));
    41073. 

  41073. 

  41074.     var result = goog.math.Long.ZERO;
    41075. 

  41075.     for (var i = 0; i < str.length; i += 8) {
    41076. 

  41076.       var size = Math.min(8, str.length - i);
    41077. 

  41077.       var value = parseInt(str.substring(i, i + size), radix);
    41078. 

  41078.       if (size < 8) {
    41079. 

  41079.         var power = goog.math.Long.fromNumber(Math.pow(radix, size));
    41080. 

  41080.         result = result.multiply(power).add(goog.math.Long.fromNumber(value));
    41081. 

  41081.       } else {
    41082. 

  41082.         result = result.multiply(radixToPower);
    41083. 

  41083.         result = result.add(goog.math.Long.fromNumber(value));
    41084. 

  41084.       }
    41085. 

  41085.     }
    41086. 

  41086.     return result;
    41087. 

  41087.   };
    41088. 

  41088. 

  41089. 

  41090.   // NOTE: the compiler should inline these constant values below and then remove
    41091. 

  41091.   // these variables, so there should be no runtime penalty for these.
    41092. 

  41092. 

  41093. 

  41094.   /**
    41095. 

  41095.    * Number used repeated below in calculations.  This must appear before the
    41096. 

  41096.    * first call to any from* function below.
    41097. 

  41097.    * @type {number}
    41098. 

  41098.    * @private
    41099. 

  41099.    */
    41100. 

  41100.   goog.math.Long.TWO_PWR_16_DBL_ = 1 << 16;
    41101. 

  41101. 

  41102. 

  41103.   /**
    41104. 

  41104.    * @type {number}
    41105. 

  41105.    * @private
    41106. 

  41106.    */
    41107. 

  41107.   goog.math.Long.TWO_PWR_24_DBL_ = 1 << 24;
    41108. 

  41108. 

  41109. 

  41110.   /**
    41111. 

  41111.    * @type {number}
    41112. 

  41112.    * @private
    41113. 

  41113.    */
    41114. 

  41114.   goog.math.Long.TWO_PWR_32_DBL_ =
    41115. 

  41115.       goog.math.Long.TWO_PWR_16_DBL_ * goog.math.Long.TWO_PWR_16_DBL_;
    41116. 

  41116. 

  41117. 

  41118.   /**
    41119. 

  41119.    * @type {number}
    41120. 

  41120.    * @private
    41121. 

  41121.    */
    41122. 

  41122.   goog.math.Long.TWO_PWR_31_DBL_ =
    41123. 

  41123.       goog.math.Long.TWO_PWR_32_DBL_ / 2;
    41124. 

  41124. 

  41125. 

  41126.   /**
    41127. 

  41127.    * @type {number}
    41128. 

  41128.    * @private
    41129. 

  41129.    */
    41130. 

  41130.   goog.math.Long.TWO_PWR_48_DBL_ =
    41131. 

  41131.       goog.math.Long.TWO_PWR_32_DBL_ * goog.math.Long.TWO_PWR_16_DBL_;
    41132. 

  41132. 

  41133. 

  41134.   /**
    41135. 

  41135.    * @type {number}
    41136. 

  41136.    * @private
    41137. 

  41137.    */
    41138. 

  41138.   goog.math.Long.TWO_PWR_64_DBL_ =
    41139. 

  41139.       goog.math.Long.TWO_PWR_32_DBL_ * goog.math.Long.TWO_PWR_32_DBL_;
    41140. 

  41140. 

  41141. 

  41142.   /**
    41143. 

  41143.    * @type {number}
    41144. 

  41144.    * @private
    41145. 

  41145.    */
    41146. 

  41146.   goog.math.Long.TWO_PWR_63_DBL_ =
    41147. 

  41147.       goog.math.Long.TWO_PWR_64_DBL_ / 2;
    41148. 

  41148. 

  41149. 

  41150.   /** @type {!goog.math.Long} */
    41151. 

  41151.   goog.math.Long.ZERO = goog.math.Long.fromInt(0);
    41152. 

  41152. 

  41153. 

  41154.   /** @type {!goog.math.Long} */
    41155. 

  41155.   goog.math.Long.ONE = goog.math.Long.fromInt(1);
    41156. 

  41156. 

  41157. 

  41158.   /** @type {!goog.math.Long} */
    41159. 

  41159.   goog.math.Long.NEG_ONE = goog.math.Long.fromInt(-1);
    41160. 

  41160. 

  41161. 

  41162.   /** @type {!goog.math.Long} */
    41163. 

  41163.   goog.math.Long.MAX_VALUE =
    41164. 

  41164.       goog.math.Long.fromBits(0xFFFFFFFF | 0, 0x7FFFFFFF | 0);
    41165. 

  41165. 

  41166. 

  41167.   /** @type {!goog.math.Long} */
    41168. 

  41168.   goog.math.Long.MIN_VALUE = goog.math.Long.fromBits(0, 0x80000000 | 0);
    41169. 

  41169. 

  41170. 

  41171.   /**
    41172. 

  41172.    * @type {!goog.math.Long}
    41173. 

  41173.    * @private
    41174. 

  41174.    */
    41175. 

  41175.   goog.math.Long.TWO_PWR_24_ = goog.math.Long.fromInt(1 << 24);
    41176. 

  41176. 

  41177. 

  41178.   /** @return {number} The value, assuming it is a 32-bit integer. */
    41179. 

  41179.   goog.math.Long.prototype.toInt = function() {
    41180. 

  41180.     return this.low_;
    41181. 

  41181.   };
    41182. 

  41182. 

  41183. 

  41184.   /** @return {number} The closest floating-point representation to this value. */
    41185. 

  41185.   goog.math.Long.prototype.toNumber = function() {
    41186. 

  41186.     return this.high_ * goog.math.Long.TWO_PWR_32_DBL_ +
    41187. 

  41187.            this.getLowBitsUnsigned();
    41188. 

  41188.   };
    41189. 

  41189. 

  41190. 

  41191.   /**
    41192. 

  41192.    * @param {number=} opt_radix The radix in which the text should be written.
    41193. 

  41193.    * @return {string} The textual representation of this value.
    41194. 

  41194.    */
    41195. 

  41195.   goog.math.Long.prototype.toString = function(opt_radix) {
    41196. 

  41196.     var radix = opt_radix || 10;
    41197. 

  41197.     if (radix < 2 || 36 < radix) {
    41198. 

  41198.       throw Error('radix out of range: ' + radix);
    41199. 

  41199.     }
    41200. 

  41200. 

  41201.     if (this.isZero()) {
    41202. 

  41202.       return '0';
    41203. 

  41203.     }
    41204. 

  41204. 

  41205.     if (this.isNegative()) {
    41206. 

  41206.       if (this.equals(goog.math.Long.MIN_VALUE)) {
    41207. 

  41207.         // We need to change the Long value before it can be negated, so we remove
    41208. 

  41208.         // the bottom-most digit in this base and then recurse to do the rest.
    41209. 

  41209.         var radixLong = goog.math.Long.fromNumber(radix);
    41210. 

  41210.         var div = this.div(radixLong);
    41211. 

  41211.         var rem = div.multiply(radixLong).subtract(this);
    41212. 

  41212.         return div.toString(radix) + rem.toInt().toString(radix);
    41213. 

  41213.       } else {
    41214. 

  41214.         return '-' + this.negate().toString(radix);
    41215. 

  41215.       }
    41216. 

  41216.     }
    41217. 

  41217. 

  41218.     // Do several (6) digits each time through the loop, so as to
    41219. 

  41219.     // minimize the calls to the very expensive emulated div.
    41220. 

  41220.     var radixToPower = goog.math.Long.fromNumber(Math.pow(radix, 6));
    41221. 

  41221. 

  41222.     var rem = this;
    41223. 

  41223.     var result = '';
    41224. 

  41224.     while (true) {
    41225. 

  41225.       var remDiv = rem.div(radixToPower);
    41226. 

  41226.       var intval = rem.subtract(remDiv.multiply(radixToPower)).toInt();
    41227. 

  41227.       var digits = intval.toString(radix);
    41228. 

  41228. 

  41229.       rem = remDiv;
    41230. 

  41230.       if (rem.isZero()) {
    41231. 

  41231.         return digits + result;
    41232. 

  41232.       } else {
    41233. 

  41233.         while (digits.length < 6) {
    41234. 

  41234.           digits = '0' + digits;
    41235. 

  41235.         }
    41236. 

  41236.         result = '' + digits + result;
    41237. 

  41237.       }
    41238. 

  41238.     }
    41239. 

  41239.   };
    41240. 

  41240. 

  41241. 

  41242.   /** @return {number} The high 32-bits as a signed value. */
    41243. 

  41243.   goog.math.Long.prototype.getHighBits = function() {
    41244. 

  41244.     return this.high_;
    41245. 

  41245.   };
    41246. 

  41246. 

  41247. 

  41248.   /** @return {number} The low 32-bits as a signed value. */
    41249. 

  41249.   goog.math.Long.prototype.getLowBits = function() {
    41250. 

  41250.     return this.low_;
    41251. 

  41251.   };
    41252. 

  41252. 

  41253. 

  41254.   /** @return {number} The low 32-bits as an unsigned value. */
    41255. 

  41255.   goog.math.Long.prototype.getLowBitsUnsigned = function() {
    41256. 

  41256.     return (this.low_ >= 0) ?
    41257. 

  41257.         this.low_ : goog.math.Long.TWO_PWR_32_DBL_ + this.low_;
    41258. 

  41258.   };
    41259. 

  41259. 

  41260. 

  41261.   /**
    41262. 

  41262.    * @return {number} Returns the number of bits needed to represent the absolute
    41263. 

  41263.    *     value of this Long.
    41264. 

  41264.    */
    41265. 

  41265.   goog.math.Long.prototype.getNumBitsAbs = function() {
    41266. 

  41266.     if (this.isNegative()) {
    41267. 

  41267.       if (this.equals(goog.math.Long.MIN_VALUE)) {
    41268. 

  41268.         return 64;
    41269. 

  41269.       } else {
    41270. 

  41270.         return this.negate().getNumBitsAbs();
    41271. 

  41271.       }
    41272. 

  41272.     } else {
    41273. 

  41273.       var val = this.high_ != 0 ? this.high_ : this.low_;
    41274. 

  41274.       for (var bit = 31; bit > 0; bit--) {
    41275. 

  41275.         if ((val & (1 << bit)) != 0) {
    41276. 

  41276.           break;
    41277. 

  41277.         }
    41278. 

  41278.       }
    41279. 

  41279.       return this.high_ != 0 ? bit + 33 : bit + 1;
    41280. 

  41280.     }
    41281. 

  41281.   };
    41282. 

  41282. 

  41283. 

  41284.   /** @return {boolean} Whether this value is zero. */
    41285. 

  41285.   goog.math.Long.prototype.isZero = function() {
    41286. 

  41286.     return this.high_ == 0 && this.low_ == 0;
    41287. 

  41287.   };
    41288. 

  41288. 

  41289. 

  41290.   /** @return {boolean} Whether this value is negative. */
    41291. 

  41291.   goog.math.Long.prototype.isNegative = function() {
    41292. 

  41292.     return this.high_ < 0;
    41293. 

  41293.   };
    41294. 

  41294. 

  41295. 

  41296.   /** @return {boolean} Whether this value is odd. */
    41297. 

  41297.   goog.math.Long.prototype.isOdd = function() {
    41298. 

  41298.     return (this.low_ & 1) == 1;
    41299. 

  41299.   };
    41300. 

  41300. 

  41301. 

  41302.   /**
    41303. 

  41303.    * @param {goog.math.Long} other Long to compare against.
    41304. 

  41304.    * @return {boolean} Whether this Long equals the other.
    41305. 

  41305.    */
    41306. 

  41306.   goog.math.Long.prototype.equals = function(other) {
    41307. 

  41307.     return (this.high_ == other.high_) && (this.low_ == other.low_);
    41308. 

  41308.   };
    41309. 

  41309. 

  41310. 

  41311.   /**
    41312. 

  41312.    * @param {goog.math.Long} other Long to compare against.
    41313. 

  41313.    * @return {boolean} Whether this Long does not equal the other.
    41314. 

  41314.    */
    41315. 

  41315.   goog.math.Long.prototype.notEquals = function(other) {
    41316. 

  41316.     return (this.high_ != other.high_) || (this.low_ != other.low_);
    41317. 

  41317.   };
    41318. 

  41318. 

  41319. 

  41320.   /**
    41321. 

  41321.    * @param {goog.math.Long} other Long to compare against.
    41322. 

  41322.    * @return {boolean} Whether this Long is less than the other.
    41323. 

  41323.    */
    41324. 

  41324.   goog.math.Long.prototype.lessThan = function(other) {
    41325. 

  41325.     return this.compare(other) < 0;
    41326. 

  41326.   };
    41327. 

  41327. 

  41328. 

  41329.   /**
    41330. 

  41330.    * @param {goog.math.Long} other Long to compare against.
    41331. 

  41331.    * @return {boolean} Whether this Long is less than or equal to the other.
    41332. 

  41332.    */
    41333. 

  41333.   goog.math.Long.prototype.lessThanOrEqual = function(other) {
    41334. 

  41334.     return this.compare(other) <= 0;
    41335. 

  41335.   };
    41336. 

  41336. 

  41337. 

  41338.   /**
    41339. 

  41339.    * @param {goog.math.Long} other Long to compare against.
    41340. 

  41340.    * @return {boolean} Whether this Long is greater than the other.
    41341. 

  41341.    */
    41342. 

  41342.   goog.math.Long.prototype.greaterThan = function(other) {
    41343. 

  41343.     return this.compare(other) > 0;
    41344. 

  41344.   };
    41345. 

  41345. 

  41346. 

  41347.   /**
    41348. 

  41348.    * @param {goog.math.Long} other Long to compare against.
    41349. 

  41349.    * @return {boolean} Whether this Long is greater than or equal to the other.
    41350. 

  41350.    */
    41351. 

  41351.   goog.math.Long.prototype.greaterThanOrEqual = function(other) {
    41352. 

  41352.     return this.compare(other) >= 0;
    41353. 

  41353.   };
    41354. 

  41354. 

  41355. 

  41356.   /**
    41357. 

  41357.    * Compares this Long with the given one.
    41358. 

  41358.    * @param {goog.math.Long} other Long to compare against.
    41359. 

  41359.    * @return {number} 0 if they are the same, 1 if the this is greater, and -1
    41360. 

  41360.    *     if the given one is greater.
    41361. 

  41361.    */
    41362. 

  41362.   goog.math.Long.prototype.compare = function(other) {
    41363. 

  41363.     if (this.equals(other)) {
    41364. 

  41364.       return 0;
    41365. 

  41365.     }
    41366. 

  41366. 

  41367.     var thisNeg = this.isNegative();
    41368. 

  41368.     var otherNeg = other.isNegative();
    41369. 

  41369.     if (thisNeg && !otherNeg) {
    41370. 

  41370.       return -1;
    41371. 

  41371.     }
    41372. 

  41372.     if (!thisNeg && otherNeg) {
    41373. 

  41373.       return 1;
    41374. 

  41374.     }
    41375. 

  41375. 

  41376.     // at this point, the signs are the same, so subtraction will not overflow
    41377. 

  41377.     if (this.subtract(other).isNegative()) {
    41378. 

  41378.       return -1;
    41379. 

  41379.     } else {
    41380. 

  41380.       return 1;
    41381. 

  41381.     }
    41382. 

  41382.   };
    41383. 

  41383. 

  41384. 

  41385.   /** @return {!goog.math.Long} The negation of this value. */
    41386. 

  41386.   goog.math.Long.prototype.negate = function() {
    41387. 

  41387.     if (this.equals(goog.math.Long.MIN_VALUE)) {
    41388. 

  41388.       return goog.math.Long.MIN_VALUE;
    41389. 

  41389.     } else {
    41390. 

  41390.       return this.not().add(goog.math.Long.ONE);
    41391. 

  41391.     }
    41392. 

  41392.   };
    41393. 

  41393. 

  41394. 

  41395.   /**
    41396. 

  41396.    * Returns the sum of this and the given Long.
    41397. 

  41397.    * @param {goog.math.Long} other Long to add to this one.
    41398. 

  41398.    * @return {!goog.math.Long} The sum of this and the given Long.
    41399. 

  41399.    */
    41400. 

  41400.   goog.math.Long.prototype.add = function(other) {
    41401. 

  41401.     // Divide each number into 4 chunks of 16 bits, and then sum the chunks.
    41402. 

  41402. 

  41403.     var a48 = this.high_ >>> 16;
    41404. 

  41404.     var a32 = this.high_ & 0xFFFF;
    41405. 

  41405.     var a16 = this.low_ >>> 16;
    41406. 

  41406.     var a00 = this.low_ & 0xFFFF;
    41407. 

  41407. 

  41408.     var b48 = other.high_ >>> 16;
    41409. 

  41409.     var b32 = other.high_ & 0xFFFF;
    41410. 

  41410.     var b16 = other.low_ >>> 16;
    41411. 

  41411.     var b00 = other.low_ & 0xFFFF;
    41412. 

  41412. 

  41413.     var c48 = 0, c32 = 0, c16 = 0, c00 = 0;
    41414. 

  41414.     c00 += a00 + b00;
    41415. 

  41415.     c16 += c00 >>> 16;
    41416. 

  41416.     c00 &= 0xFFFF;
    41417. 

  41417.     c16 += a16 + b16;
    41418. 

  41418.     c32 += c16 >>> 16;
    41419. 

  41419.     c16 &= 0xFFFF;
    41420. 

  41420.     c32 += a32 + b32;
    41421. 

  41421.     c48 += c32 >>> 16;
    41422. 

  41422.     c32 &= 0xFFFF;
    41423. 

  41423.     c48 += a48 + b48;
    41424. 

  41424.     c48 &= 0xFFFF;
    41425. 

  41425.     return goog.math.Long.fromBits((c16 << 16) | c00, (c48 << 16) | c32);
    41426. 

  41426.   };
    41427. 

  41427. 

  41428. 

  41429.   /**
    41430. 

  41430.    * Returns the difference of this and the given Long.
    41431. 

  41431.    * @param {goog.math.Long} other Long to subtract from this.
    41432. 

  41432.    * @return {!goog.math.Long} The difference of this and the given Long.
    41433. 

  41433.    */
    41434. 

  41434.   goog.math.Long.prototype.subtract = function(other) {
    41435. 

  41435.     return this.add(other.negate());
    41436. 

  41436.   };
    41437. 

  41437. 

  41438. 

  41439.   /**
    41440. 

  41440.    * Returns the product of this and the given long.
    41441. 

  41441.    * @param {goog.math.Long} other Long to multiply with this.
    41442. 

  41442.    * @return {!goog.math.Long} The product of this and the other.
    41443. 

  41443.    */
    41444. 

  41444.   goog.math.Long.prototype.multiply = function(other) {
    41445. 

  41445.     if (this.isZero()) {
    41446. 

  41446.       return goog.math.Long.ZERO;
    41447. 

  41447.     } else if (other.isZero()) {
    41448. 

  41448.       return goog.math.Long.ZERO;
    41449. 

  41449.     }
    41450. 

  41450. 

  41451.     if (this.equals(goog.math.Long.MIN_VALUE)) {
    41452. 

  41452.       return other.isOdd() ? goog.math.Long.MIN_VALUE : goog.math.Long.ZERO;
    41453. 

  41453.     } else if (other.equals(goog.math.Long.MIN_VALUE)) {
    41454. 

  41454.       return this.isOdd() ? goog.math.Long.MIN_VALUE : goog.math.Long.ZERO;
    41455. 

  41455.     }
    41456. 

  41456. 

  41457.     if (this.isNegative()) {
    41458. 

  41458.       if (other.isNegative()) {
    41459. 

  41459.         return this.negate().multiply(other.negate());
    41460. 

  41460.       } else {
    41461. 

  41461.         return this.negate().multiply(other).negate();
    41462. 

  41462.       }
    41463. 

  41463.     } else if (other.isNegative()) {
    41464. 

  41464.       return this.multiply(other.negate()).negate();
    41465. 

  41465.     }
    41466. 

  41466. 

  41467.     // If both longs are small, use float multiplication
    41468. 

  41468.     if (this.lessThan(goog.math.Long.TWO_PWR_24_) &&
    41469. 

  41469.         other.lessThan(goog.math.Long.TWO_PWR_24_)) {
    41470. 

  41470.       return goog.math.Long.fromNumber(this.toNumber() * other.toNumber());
    41471. 

  41471.     }
    41472. 

  41472. 

  41473.     // Divide each long into 4 chunks of 16 bits, and then add up 4x4 products.
    41474. 

  41474.     // We can skip products that would overflow.
    41475. 

  41475. 

  41476.     var a48 = this.high_ >>> 16;
    41477. 

  41477.     var a32 = this.high_ & 0xFFFF;
    41478. 

  41478.     var a16 = this.low_ >>> 16;
    41479. 

  41479.     var a00 = this.low_ & 0xFFFF;
    41480. 

  41480. 

  41481.     var b48 = other.high_ >>> 16;
    41482. 

  41482.     var b32 = other.high_ & 0xFFFF;
    41483. 

  41483.     var b16 = other.low_ >>> 16;
    41484. 

  41484.     var b00 = other.low_ & 0xFFFF;
    41485. 

  41485. 

  41486.     var c48 = 0, c32 = 0, c16 = 0, c00 = 0;
    41487. 

  41487.     c00 += a00 * b00;
    41488. 

  41488.     c16 += c00 >>> 16;
    41489. 

  41489.     c00 &= 0xFFFF;
    41490. 

  41490.     c16 += a16 * b00;
    41491. 

  41491.     c32 += c16 >>> 16;
    41492. 

  41492.     c16 &= 0xFFFF;
    41493. 

  41493.     c16 += a00 * b16;
    41494. 

  41494.     c32 += c16 >>> 16;
    41495. 

  41495.     c16 &= 0xFFFF;
    41496. 

  41496.     c32 += a32 * b00;
    41497. 

  41497.     c48 += c32 >>> 16;
    41498. 

  41498.     c32 &= 0xFFFF;
    41499. 

  41499.     c32 += a16 * b16;
    41500. 

  41500.     c48 += c32 >>> 16;
    41501. 

  41501.     c32 &= 0xFFFF;
    41502. 

  41502.     c32 += a00 * b32;
    41503. 

  41503.     c48 += c32 >>> 16;
    41504. 

  41504.     c32 &= 0xFFFF;
    41505. 

  41505.     c48 += a48 * b00 + a32 * b16 + a16 * b32 + a00 * b48;
    41506. 

  41506.     c48 &= 0xFFFF;
    41507. 

  41507.     return goog.math.Long.fromBits((c16 << 16) | c00, (c48 << 16) | c32);
    41508. 

  41508.   };
    41509. 

  41509. 

  41510. 

  41511.   /**
    41512. 

  41512.    * Returns this Long divided by the given one.
    41513. 

  41513.    * @param {goog.math.Long} other Long by which to divide.
    41514. 

  41514.    * @return {!goog.math.Long} This Long divided by the given one.
    41515. 

  41515.    */
    41516. 

  41516.   goog.math.Long.prototype.div = function(other) {
    41517. 

  41517.     if (other.isZero()) {
    41518. 

  41518.       throw Error('division by zero');
    41519. 

  41519.     } else if (this.isZero()) {
    41520. 

  41520.       return goog.math.Long.ZERO;
    41521. 

  41521.     }
    41522. 

  41522. 

  41523.     if (this.equals(goog.math.Long.MIN_VALUE)) {
    41524. 

  41524.       if (other.equals(goog.math.Long.ONE) ||
    41525. 

  41525.           other.equals(goog.math.Long.NEG_ONE)) {
    41526. 

  41526.         return goog.math.Long.MIN_VALUE;  // recall that -MIN_VALUE == MIN_VALUE
    41527. 

  41527.       } else if (other.equals(goog.math.Long.MIN_VALUE)) {
    41528. 

  41528.         return goog.math.Long.ONE;
    41529. 

  41529.       } else {
    41530. 

  41530.         // At this point, we have |other| >= 2, so |this/other| < |MIN_VALUE|.
    41531. 

  41531.         var halfThis = this.shiftRight(1);
    41532. 

  41532.         var approx = halfThis.div(other).shiftLeft(1);
    41533. 

  41533.         if (approx.equals(goog.math.Long.ZERO)) {
    41534. 

  41534.           return other.isNegative() ? goog.math.Long.ONE : goog.math.Long.NEG_ONE;
    41535. 

  41535.         } else {
    41536. 

  41536.           var rem = this.subtract(other.multiply(approx));
    41537. 

  41537.           var result = approx.add(rem.div(other));
    41538. 

  41538.           return result;
    41539. 

  41539.         }
    41540. 

  41540.       }
    41541. 

  41541.     } else if (other.equals(goog.math.Long.MIN_VALUE)) {
    41542. 

  41542.       return goog.math.Long.ZERO;
    41543. 

  41543.     }
    41544. 

  41544. 

  41545.     if (this.isNegative()) {
    41546. 

  41546.       if (other.isNegative()) {
    41547. 

  41547.         return this.negate().div(other.negate());
    41548. 

  41548.       } else {
    41549. 

  41549.         return this.negate().div(other).negate();
    41550. 

  41550.       }
    41551. 

  41551.     } else if (other.isNegative()) {
    41552. 

  41552.       return this.div(other.negate()).negate();
    41553. 

  41553.     }
    41554. 

  41554. 

  41555.     // Repeat the following until the remainder is less than other:  find a
    41556. 

  41556.     // floating-point that approximates remainder / other *from below*, add this
    41557. 

  41557.     // into the result, and subtract it from the remainder.  It is critical that
    41558. 

  41558.     // the approximate value is less than or equal to the real value so that the
    41559. 

  41559.     // remainder never becomes negative.
    41560. 

  41560.     var res = goog.math.Long.ZERO;
    41561. 

  41561.     var rem = this;
    41562. 

  41562.     while (rem.greaterThanOrEqual(other)) {
    41563. 

  41563.       // Approximate the result of division. This may be a little greater or
    41564. 

  41564.       // smaller than the actual value.
    41565. 

  41565.       var approx = Math.max(1, Math.floor(rem.toNumber() / other.toNumber()));
    41566. 

  41566. 

  41567.       // We will tweak the approximate result by changing it in the 48-th digit or
    41568. 

  41568.       // the smallest non-fractional digit, whichever is larger.
    41569. 

  41569.       var log2 = Math.ceil(Math.log(approx) / Math.LN2);
    41570. 

  41570.       var delta = (log2 <= 48) ? 1 : Math.pow(2, log2 - 48);
    41571. 

  41571. 

  41572.       // Decrease the approximation until it is smaller than the remainder.  Note
    41573. 

  41573.       // that if it is too large, the product overflows and is negative.
    41574. 

  41574.       var approxRes = goog.math.Long.fromNumber(approx);
    41575. 

  41575.       var approxRem = approxRes.multiply(other);
    41576. 

  41576.       while (approxRem.isNegative() || approxRem.greaterThan(rem)) {
    41577. 

  41577.         approx -= delta;
    41578. 

  41578.         approxRes = goog.math.Long.fromNumber(approx);
    41579. 

  41579.         approxRem = approxRes.multiply(other);
    41580. 

  41580.       }
    41581. 

  41581. 

  41582.       // We know the answer can't be zero... and actually, zero would cause
    41583. 

  41583.       // infinite recursion since we would make no progress.
    41584. 

  41584.       if (approxRes.isZero()) {
    41585. 

  41585.         approxRes = goog.math.Long.ONE;
    41586. 

  41586.       }
    41587. 

  41587. 

  41588.       res = res.add(approxRes);
    41589. 

  41589.       rem = rem.subtract(approxRem);
    41590. 

  41590.     }
    41591. 

  41591.     return res;
    41592. 

  41592.   };
    41593. 

  41593. 

  41594. 

  41595.   /**
    41596. 

  41596.    * Returns this Long modulo the given one.
    41597. 

  41597.    * @param {goog.math.Long} other Long by which to mod.
    41598. 

  41598.    * @return {!goog.math.Long} This Long modulo the given one.
    41599. 

  41599.    */
    41600. 

  41600.   goog.math.Long.prototype.modulo = function(other) {
    41601. 

  41601.     return this.subtract(this.div(other).multiply(other));
    41602. 

  41602.   };
    41603. 

  41603. 

  41604. 

  41605.   /** @return {!goog.math.Long} The bitwise-NOT of this value. */
    41606. 

  41606.   goog.math.Long.prototype.not = function() {
    41607. 

  41607.     return goog.math.Long.fromBits(~this.low_, ~this.high_);
    41608. 

  41608.   };
    41609. 

  41609. 

  41610. 

  41611.   /**
    41612. 

  41612.    * Returns the bitwise-AND of this Long and the given one.
    41613. 

  41613.    * @param {goog.math.Long} other The Long with which to AND.
    41614. 

  41614.    * @return {!goog.math.Long} The bitwise-AND of this and the other.
    41615. 

  41615.    */
    41616. 

  41616.   goog.math.Long.prototype.and = function(other) {
    41617. 

  41617.     return goog.math.Long.fromBits(this.low_ & other.low_,
    41618. 

  41618.                                    this.high_ & other.high_);
    41619. 

  41619.   };
    41620. 

  41620. 

  41621. 

  41622.   /**
    41623. 

  41623.    * Returns the bitwise-OR of this Long and the given one.
    41624. 

  41624.    * @param {goog.math.Long} other The Long with which to OR.
    41625. 

  41625.    * @return {!goog.math.Long} The bitwise-OR of this and the other.
    41626. 

  41626.    */
    41627. 

  41627.   goog.math.Long.prototype.or = function(other) {
    41628. 

  41628.     return goog.math.Long.fromBits(this.low_ | other.low_,
    41629. 

  41629.                                    this.high_ | other.high_);
    41630. 

  41630.   };
    41631. 

  41631. 

  41632. 

  41633.   /**
    41634. 

  41634.    * Returns the bitwise-XOR of this Long and the given one.
    41635. 

  41635.    * @param {goog.math.Long} other The Long with which to XOR.
    41636. 

  41636.    * @return {!goog.math.Long} The bitwise-XOR of this and the other.
    41637. 

  41637.    */
    41638. 

  41638.   goog.math.Long.prototype.xor = function(other) {
    41639. 

  41639.     return goog.math.Long.fromBits(this.low_ ^ other.low_,
    41640. 

  41640.                                    this.high_ ^ other.high_);
    41641. 

  41641.   };
    41642. 

  41642. 

  41643. 

  41644.   /**
    41645. 

  41645.    * Returns this Long with bits shifted to the left by the given amount.
    41646. 

  41646.    * @param {number} numBits The number of bits by which to shift.
    41647. 

  41647.    * @return {!goog.math.Long} This shifted to the left by the given amount.
    41648. 

  41648.    */
    41649. 

  41649.   goog.math.Long.prototype.shiftLeft = function(numBits) {
    41650. 

  41650.     numBits &= 63;
    41651. 

  41651.     if (numBits == 0) {
    41652. 

  41652.       return this;
    41653. 

  41653.     } else {
    41654. 

  41654.       var low = this.low_;
    41655. 

  41655.       if (numBits < 32) {
    41656. 

  41656.         var high = this.high_;
    41657. 

  41657.         return goog.math.Long.fromBits(
    41658. 

  41658.             low << numBits,
    41659. 

  41659.             (high << numBits) | (low >>> (32 - numBits)));
    41660. 

  41660.       } else {
    41661. 

  41661.         return goog.math.Long.fromBits(0, low << (numBits - 32));
    41662. 

  41662.       }
    41663. 

  41663.     }
    41664. 

  41664.   };
    41665. 

  41665. 

  41666. 

  41667.   /**
    41668. 

  41668.    * Returns this Long with bits shifted to the right by the given amount.
    41669. 

  41669.    * @param {number} numBits The number of bits by which to shift.
    41670. 

  41670.    * @return {!goog.math.Long} This shifted to the right by the given amount.
    41671. 

  41671.    */
    41672. 

  41672.   goog.math.Long.prototype.shiftRight = function(numBits) {
    41673. 

  41673.     numBits &= 63;
    41674. 

  41674.     if (numBits == 0) {
    41675. 

  41675.       return this;
    41676. 

  41676.     } else {
    41677. 

  41677.       var high = this.high_;
    41678. 

  41678.       if (numBits < 32) {
    41679. 

  41679.         var low = this.low_;
    41680. 

  41680.         return goog.math.Long.fromBits(
    41681. 

  41681.             (low >>> numBits) | (high << (32 - numBits)),
    41682. 

  41682.             high >> numBits);
    41683. 

  41683.       } else {
    41684. 

  41684.         return goog.math.Long.fromBits(
    41685. 

  41685.             high >> (numBits - 32),
    41686. 

  41686.             high >= 0 ? 0 : -1);
    41687. 

  41687.       }
    41688. 

  41688.     }
    41689. 

  41689.   };
    41690. 

  41690. 

  41691. 

  41692.   /**
    41693. 

  41693.    * Returns this Long with bits shifted to the right by the given amount, with
    41694. 

  41694.    * the new top bits matching the current sign bit.
    41695. 

  41695.    * @param {number} numBits The number of bits by which to shift.
    41696. 

  41696.    * @return {!goog.math.Long} This shifted to the right by the given amount, with
    41697. 

  41697.    *     zeros placed into the new leading bits.
    41698. 

  41698.    */
    41699. 

  41699.   goog.math.Long.prototype.shiftRightUnsigned = function(numBits) {
    41700. 

  41700.     numBits &= 63;
    41701. 

  41701.     if (numBits == 0) {
    41702. 

  41702.       return this;
    41703. 

  41703.     } else {
    41704. 

  41704.       var high = this.high_;
    41705. 

  41705.       if (numBits < 32) {
    41706. 

  41706.         var low = this.low_;
    41707. 

  41707.         return goog.math.Long.fromBits(
    41708. 

  41708.             (low >>> numBits) | (high << (32 - numBits)),
    41709. 

  41709.             high >>> numBits);
    41710. 

  41710.       } else if (numBits == 32) {
    41711. 

  41711.         return goog.math.Long.fromBits(high, 0);
    41712. 

  41712.       } else {
    41713. 

  41713.         return goog.math.Long.fromBits(high >>> (numBits - 32), 0);
    41714. 

  41714.       }
    41715. 

  41715.     }
    41716. 

  41716.   };
    41717. 

  41717. 

  41718.   //======= begin jsbn =======
    41719. 

  41719. 

  41720.   var navigator = { appName: 'Modern Browser' }; // polyfill a little
    41721. 

  41721. 

  41722.   // Copyright (c) 2005  Tom Wu
    41723. 

  41723.   // All Rights Reserved.
    41724. 

  41724.   // http://www-cs-students.stanford.edu/~tjw/jsbn/
    41725. 

  41725. 

  41726.   /*
    41727. 

  41727.    * Copyright (c) 2003-2005  Tom Wu
    41728. 

  41728.    * All Rights Reserved.
    41729. 

  41729.    *
    41730. 

  41730.    * Permission is hereby granted, free of charge, to any person obtaining
    41731. 

  41731.    * a copy of this software and associated documentation files (the
    41732. 

  41732.    * "Software"), to deal in the Software without restriction, including
    41733. 

  41733.    * without limitation the rights to use, copy, modify, merge, publish,
    41734. 

  41734.    * distribute, sublicense, and/or sell copies of the Software, and to
    41735. 

  41735.    * permit persons to whom the Software is furnished to do so, subject to
    41736. 

  41736.    * the following conditions:
    41737. 

  41737.    *
    41738. 

  41738.    * The above copyright notice and this permission notice shall be
    41739. 

  41739.    * included in all copies or substantial portions of the Software.
    41740. 

  41740.    *
    41741. 

  41741.    * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
    41742. 

  41742.    * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
    41743. 

  41743.    * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
    41744. 

  41744.    *
    41745. 

  41745.    * IN NO EVENT SHALL TOM WU BE LIABLE FOR ANY SPECIAL, INCIDENTAL,
    41746. 

  41746.    * INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND, OR ANY DAMAGES WHATSOEVER
    41747. 

  41747.    * RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER OR NOT ADVISED OF
    41748. 

  41748.    * THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF LIABILITY, ARISING OUT
    41749. 

  41749.    * OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
    41750. 

  41750.    *
    41751. 

  41751.    * In addition, the following condition applies:
    41752. 

  41752.    *
    41753. 

  41753.    * All redistributions must retain an intact copy of this copyright notice
    41754. 

  41754.    * and disclaimer.
    41755. 

  41755.    */
    41756. 

  41756. 

  41757.   // Basic JavaScript BN library - subset useful for RSA encryption.
    41758. 

  41758. 

  41759.   // Bits per digit
    41760. 

  41760.   var dbits;
    41761. 

  41761. 

  41762.   // JavaScript engine analysis
    41763. 

  41763.   var canary = 0xdeadbeefcafe;
    41764. 

  41764.   var j_lm = ((canary&0xffffff)==0xefcafe);
    41765. 

  41765. 

  41766.   // (public) Constructor
    41767. 

  41767.   function BigInteger(a,b,c) {
    41768. 

  41768.     if(a != null)
    41769. 

  41769.       if("number" == typeof a) this.fromNumber(a,b,c);
    41770. 

  41770.       else if(b == null && "string" != typeof a) this.fromString(a,256);
    41771. 

  41771.       else this.fromString(a,b);
    41772. 

  41772.   }
    41773. 

  41773. 

  41774.   // return new, unset BigInteger
    41775. 

  41775.   function nbi() { return new BigInteger(null); }
    41776. 

  41776. 

  41777.   // am: Compute w_j += (x*this_i), propagate carries,
    41778. 

  41778.   // c is initial carry, returns final carry.
    41779. 

  41779.   // c < 3*dvalue, x < 2*dvalue, this_i < dvalue
    41780. 

  41780.   // We need to select the fastest one that works in this environment.
    41781. 

  41781. 

  41782.   // am1: use a single mult and divide to get the high bits,
    41783. 

  41783.   // max digit bits should be 26 because
    41784. 

  41784.   // max internal value = 2*dvalue^2-2*dvalue (< 2^53)
    41785. 

  41785.   function am1(i,x,w,j,c,n) {
    41786. 

  41786.     while(--n >= 0) {
    41787. 

  41787.       var v = x*this[i++]+w[j]+c;
    41788. 

  41788.       c = Math.floor(v/0x4000000);
    41789. 

  41789.       w[j++] = v&0x3ffffff;
    41790. 

  41790.     }
    41791. 

  41791.     return c;
    41792. 

  41792.   }
    41793. 

  41793.   // am2 avoids a big mult-and-extract completely.
    41794. 

  41794.   // Max digit bits should be <= 30 because we do bitwise ops
    41795. 

  41795.   // on values up to 2*hdvalue^2-hdvalue-1 (< 2^31)
    41796. 

  41796.   function am2(i,x,w,j,c,n) {
    41797. 

  41797.     var xl = x&0x7fff, xh = x>>15;
    41798. 

  41798.     while(--n >= 0) {
    41799. 

  41799.       var l = this[i]&0x7fff;
    41800. 

  41800.       var h = this[i++]>>15;
    41801. 

  41801.       var m = xh*l+h*xl;
    41802. 

  41802.       l = xl*l+((m&0x7fff)<<15)+w[j]+(c&0x3fffffff);
    41803. 

  41803.       c = (l>>>30)+(m>>>15)+xh*h+(c>>>30);
    41804. 

  41804.       w[j++] = l&0x3fffffff;
    41805. 

  41805.     }
    41806. 

  41806.     return c;
    41807. 

  41807.   }
    41808. 

  41808.   // Alternately, set max digit bits to 28 since some
    41809. 

  41809.   // browsers slow down when dealing with 32-bit numbers.
    41810. 

  41810.   function am3(i,x,w,j,c,n) {
    41811. 

  41811.     var xl = x&0x3fff, xh = x>>14;
    41812. 

  41812.     while(--n >= 0) {
    41813. 

  41813.       var l = this[i]&0x3fff;
    41814. 

  41814.       var h = this[i++]>>14;
    41815. 

  41815.       var m = xh*l+h*xl;
    41816. 

  41816.       l = xl*l+((m&0x3fff)<<14)+w[j]+c;
    41817. 

  41817.       c = (l>>28)+(m>>14)+xh*h;
    41818. 

  41818.       w[j++] = l&0xfffffff;
    41819. 

  41819.     }
    41820. 

  41820.     return c;
    41821. 

  41821.   }
    41822. 

  41822.   if(j_lm && (navigator.appName == "Microsoft Internet Explorer")) {
    41823. 

  41823.     BigInteger.prototype.am = am2;
    41824. 

  41824.     dbits = 30;
    41825. 

  41825.   }
    41826. 

  41826.   else if(j_lm && (navigator.appName != "Netscape")) {
    41827. 

  41827.     BigInteger.prototype.am = am1;
    41828. 

  41828.     dbits = 26;
    41829. 

  41829.   }
    41830. 

  41830.   else { // Mozilla/Netscape seems to prefer am3
    41831. 

  41831.     BigInteger.prototype.am = am3;
    41832. 

  41832.     dbits = 28;
    41833. 

  41833.   }
    41834. 

  41834. 

  41835.   BigInteger.prototype.DB = dbits;
    41836. 

  41836.   BigInteger.prototype.DM = ((1<<dbits)-1);
    41837. 

  41837.   BigInteger.prototype.DV = (1<<dbits);
    41838. 

  41838. 

  41839.   var BI_FP = 52;
    41840. 

  41840.   BigInteger.prototype.FV = Math.pow(2,BI_FP);
    41841. 

  41841.   BigInteger.prototype.F1 = BI_FP-dbits;
    41842. 

  41842.   BigInteger.prototype.F2 = 2*dbits-BI_FP;
    41843. 

  41843. 

  41844.   // Digit conversions
    41845. 

  41845.   var BI_RM = "0123456789abcdefghijklmnopqrstuvwxyz";
    41846. 

  41846.   var BI_RC = new Array();
    41847. 

  41847.   var rr,vv;
    41848. 

  41848.   rr = "0".charCodeAt(0);
    41849. 

  41849.   for(vv = 0; vv <= 9; ++vv) BI_RC[rr++] = vv;
    41850. 

  41850.   rr = "a".charCodeAt(0);
    41851. 

  41851.   for(vv = 10; vv < 36; ++vv) BI_RC[rr++] = vv;
    41852. 

  41852.   rr = "A".charCodeAt(0);
    41853. 

  41853.   for(vv = 10; vv < 36; ++vv) BI_RC[rr++] = vv;
    41854. 

  41854. 

  41855.   function int2char(n) { return BI_RM.charAt(n); }
    41856. 

  41856.   function intAt(s,i) {
    41857. 

  41857.     var c = BI_RC[s.charCodeAt(i)];
    41858. 

  41858.     return (c==null)?-1:c;
    41859. 

  41859.   }
    41860. 

  41860. 

  41861.   // (protected) copy this to r
    41862. 

  41862.   function bnpCopyTo(r) {
    41863. 

  41863.     for(var i = this.t-1; i >= 0; --i) r[i] = this[i];
    41864. 

  41864.     r.t = this.t;
    41865. 

  41865.     r.s = this.s;
    41866. 

  41866.   }
    41867. 

  41867. 

  41868.   // (protected) set from integer value x, -DV <= x < DV
    41869. 

  41869.   function bnpFromInt(x) {
    41870. 

  41870.     this.t = 1;
    41871. 

  41871.     this.s = (x<0)?-1:0;
    41872. 

  41872.     if(x > 0) this[0] = x;
    41873. 

  41873.     else if(x < -1) this[0] = x+DV;
    41874. 

  41874.     else this.t = 0;
    41875. 

  41875.   }
    41876. 

  41876. 

  41877.   // return bigint initialized to value
    41878. 

  41878.   function nbv(i) { var r = nbi(); r.fromInt(i); return r; }
    41879. 

  41879. 

  41880.   // (protected) set from string and radix
    41881. 

  41881.   function bnpFromString(s,b) {
    41882. 

  41882.     var k;
    41883. 

  41883.     if(b == 16) k = 4;
    41884. 

  41884.     else if(b == 8) k = 3;
    41885. 

  41885.     else if(b == 256) k = 8; // byte array
    41886. 

  41886.     else if(b == 2) k = 1;
    41887. 

  41887.     else if(b == 32) k = 5;
    41888. 

  41888.     else if(b == 4) k = 2;
    41889. 

  41889.     else { this.fromRadix(s,b); return; }
    41890. 

  41890.     this.t = 0;
    41891. 

  41891.     this.s = 0;
    41892. 

  41892.     var i = s.length, mi = false, sh = 0;
    41893. 

  41893.     while(--i >= 0) {
    41894. 

  41894.       var x = (k==8)?s[i]&0xff:intAt(s,i);
    41895. 

  41895.       if(x < 0) {
    41896. 

  41896.         if(s.charAt(i) == "-") mi = true;
    41897. 

  41897.         continue;
    41898. 

  41898.       }
    41899. 

  41899.       mi = false;
    41900. 

  41900.       if(sh == 0)
    41901. 

  41901.         this[this.t++] = x;
    41902. 

  41902.       else if(sh+k > this.DB) {
    41903. 

  41903.         this[this.t-1] |= (x&((1<<(this.DB-sh))-1))<<sh;
    41904. 

  41904.         this[this.t++] = (x>>(this.DB-sh));
    41905. 

  41905.       }
    41906. 

  41906.       else
    41907. 

  41907.         this[this.t-1] |= x<<sh;
    41908. 

  41908.       sh += k;
    41909. 

  41909.       if(sh >= this.DB) sh -= this.DB;
    41910. 

  41910.     }
    41911. 

  41911.     if(k == 8 && (s[0]&0x80) != 0) {
    41912. 

  41912.       this.s = -1;
    41913. 

  41913.       if(sh > 0) this[this.t-1] |= ((1<<(this.DB-sh))-1)<<sh;
    41914. 

  41914.     }
    41915. 

  41915.     this.clamp();
    41916. 

  41916.     if(mi) BigInteger.ZERO.subTo(this,this);
    41917. 

  41917.   }
    41918. 

  41918. 

  41919.   // (protected) clamp off excess high words
    41920. 

  41920.   function bnpClamp() {
    41921. 

  41921.     var c = this.s&this.DM;
    41922. 

  41922.     while(this.t > 0 && this[this.t-1] == c) --this.t;
    41923. 

  41923.   }
    41924. 

  41924. 

  41925.   // (public) return string representation in given radix
    41926. 

  41926.   function bnToString(b) {
    41927. 

  41927.     if(this.s < 0) return "-"+this.negate().toString(b);
    41928. 

  41928.     var k;
    41929. 

  41929.     if(b == 16) k = 4;
    41930. 

  41930.     else if(b == 8) k = 3;
    41931. 

  41931.     else if(b == 2) k = 1;
    41932. 

  41932.     else if(b == 32) k = 5;
    41933. 

  41933.     else if(b == 4) k = 2;
    41934. 

  41934.     else return this.toRadix(b);
    41935. 

  41935.     var km = (1<<k)-1, d, m = false, r = "", i = this.t;
    41936. 

  41936.     var p = this.DB-(i*this.DB)%k;
    41937. 

  41937.     if(i-- > 0) {
    41938. 

  41938.       if(p < this.DB && (d = this[i]>>p) > 0) { m = true; r = int2char(d); }
    41939. 

  41939.       while(i >= 0) {
    41940. 

  41940.         if(p < k) {
    41941. 

  41941.           d = (this[i]&((1<<p)-1))<<(k-p);
    41942. 

  41942.           d |= this[--i]>>(p+=this.DB-k);
    41943. 

  41943.         }
    41944. 

  41944.         else {
    41945. 

  41945.           d = (this[i]>>(p-=k))&km;
    41946. 

  41946.           if(p <= 0) { p += this.DB; --i; }
    41947. 

  41947.         }
    41948. 

  41948.         if(d > 0) m = true;
    41949. 

  41949.         if(m) r += int2char(d);
    41950. 

  41950.       }
    41951. 

  41951.     }
    41952. 

  41952.     return m?r:"0";
    41953. 

  41953.   }
    41954. 

  41954. 

  41955.   // (public) -this
    41956. 

  41956.   function bnNegate() { var r = nbi(); BigInteger.ZERO.subTo(this,r); return r; }
    41957. 

  41957. 

  41958.   // (public) |this|
    41959. 

  41959.   function bnAbs() { return (this.s<0)?this.negate():this; }
    41960. 

  41960. 

  41961.   // (public) return + if this > a, - if this < a, 0 if equal
    41962. 

  41962.   function bnCompareTo(a) {
    41963. 

  41963.     var r = this.s-a.s;
    41964. 

  41964.     if(r != 0) return r;
    41965. 

  41965.     var i = this.t;
    41966. 

  41966.     r = i-a.t;
    41967. 

  41967.     if(r != 0) return (this.s<0)?-r:r;
    41968. 

  41968.     while(--i >= 0) if((r=this[i]-a[i]) != 0) return r;
    41969. 

  41969.     return 0;
    41970. 

  41970.   }
    41971. 

  41971. 

  41972.   // returns bit length of the integer x
    41973. 

  41973.   function nbits(x) {
    41974. 

  41974.     var r = 1, t;
    41975. 

  41975.     if((t=x>>>16) != 0) { x = t; r += 16; }
    41976. 

  41976.     if((t=x>>8) != 0) { x = t; r += 8; }
    41977. 

  41977.     if((t=x>>4) != 0) { x = t; r += 4; }
    41978. 

  41978.     if((t=x>>2) != 0) { x = t; r += 2; }
    41979. 

  41979.     if((t=x>>1) != 0) { x = t; r += 1; }
    41980. 

  41980.     return r;
    41981. 

  41981.   }
    41982. 

  41982. 

  41983.   // (public) return the number of bits in "this"
    41984. 

  41984.   function bnBitLength() {
    41985. 

  41985.     if(this.t <= 0) return 0;
    41986. 

  41986.     return this.DB*(this.t-1)+nbits(this[this.t-1]^(this.s&this.DM));
    41987. 

  41987.   }
    41988. 

  41988. 

  41989.   // (protected) r = this << n*DB
    41990. 

  41990.   function bnpDLShiftTo(n,r) {
    41991. 

  41991.     var i;
    41992. 

  41992.     for(i = this.t-1; i >= 0; --i) r[i+n] = this[i];
    41993. 

  41993.     for(i = n-1; i >= 0; --i) r[i] = 0;
    41994. 

  41994.     r.t = this.t+n;
    41995. 

  41995.     r.s = this.s;
    41996. 

  41996.   }
    41997. 

  41997. 

  41998.   // (protected) r = this >> n*DB
    41999. 

  41999.   function bnpDRShiftTo(n,r) {
    42000. 

  42000.     for(var i = n; i < this.t; ++i) r[i-n] = this[i];
    42001. 

  42001.     r.t = Math.max(this.t-n,0);
    42002. 

  42002.     r.s = this.s;
    42003. 

  42003.   }
    42004. 

  42004. 

  42005.   // (protected) r = this << n
    42006. 

  42006.   function bnpLShiftTo(n,r) {
    42007. 

  42007.     var bs = n%this.DB;
    42008. 

  42008.     var cbs = this.DB-bs;
    42009. 

  42009.     var bm = (1<<cbs)-1;
    42010. 

  42010.     var ds = Math.floor(n/this.DB), c = (this.s<<bs)&this.DM, i;
    42011. 

  42011.     for(i = this.t-1; i >= 0; --i) {
    42012. 

  42012.       r[i+ds+1] = (this[i]>>cbs)|c;
    42013. 

  42013.       c = (this[i]&bm)<<bs;
    42014. 

  42014.     }
    42015. 

  42015.     for(i = ds-1; i >= 0; --i) r[i] = 0;
    42016. 

  42016.     r[ds] = c;
    42017. 

  42017.     r.t = this.t+ds+1;
    42018. 

  42018.     r.s = this.s;
    42019. 

  42019.     r.clamp();
    42020. 

  42020.   }
    42021. 

  42021. 

  42022.   // (protected) r = this >> n
    42023. 

  42023.   function bnpRShiftTo(n,r) {
    42024. 

  42024.     r.s = this.s;
    42025. 

  42025.     var ds = Math.floor(n/this.DB);
    42026. 

  42026.     if(ds >= this.t) { r.t = 0; return; }
    42027. 

  42027.     var bs = n%this.DB;
    42028. 

  42028.     var cbs = this.DB-bs;
    42029. 

  42029.     var bm = (1<<bs)-1;
    42030. 

  42030.     r[0] = this[ds]>>bs;
    42031. 

  42031.     for(var i = ds+1; i < this.t; ++i) {
    42032. 

  42032.       r[i-ds-1] |= (this[i]&bm)<<cbs;
    42033. 

  42033.       r[i-ds] = this[i]>>bs;
    42034. 

  42034.     }
    42035. 

  42035.     if(bs > 0) r[this.t-ds-1] |= (this.s&bm)<<cbs;
    42036. 

  42036.     r.t = this.t-ds;
    42037. 

  42037.     r.clamp();
    42038. 

  42038.   }
    42039. 

  42039. 

  42040.   // (protected) r = this - a
    42041. 

  42041.   function bnpSubTo(a,r) {
    42042. 

  42042.     var i = 0, c = 0, m = Math.min(a.t,this.t);
    42043. 

  42043.     while(i < m) {
    42044. 

  42044.       c += this[i]-a[i];
    42045. 

  42045.       r[i++] = c&this.DM;
    42046. 

  42046.       c >>= this.DB;
    42047. 

  42047.     }
    42048. 

  42048.     if(a.t < this.t) {
    42049. 

  42049.       c -= a.s;
    42050. 

  42050.       while(i < this.t) {
    42051. 

  42051.         c += this[i];
    42052. 

  42052.         r[i++] = c&this.DM;
    42053. 

  42053.         c >>= this.DB;
    42054. 

  42054.       }
    42055. 

  42055.       c += this.s;
    42056. 

  42056.     }
    42057. 

  42057.     else {
    42058. 

  42058.       c += this.s;
    42059. 

  42059.       while(i < a.t) {
    42060. 

  42060.         c -= a[i];
    42061. 

  42061.         r[i++] = c&this.DM;
    42062. 

  42062.         c >>= this.DB;
    42063. 

  42063.       }
    42064. 

  42064.       c -= a.s;
    42065. 

  42065.     }
    42066. 

  42066.     r.s = (c<0)?-1:0;
    42067. 

  42067.     if(c < -1) r[i++] = this.DV+c;
    42068. 

  42068.     else if(c > 0) r[i++] = c;
    42069. 

  42069.     r.t = i;
    42070. 

  42070.     r.clamp();
    42071. 

  42071.   }
    42072. 

  42072. 

  42073.   // (protected) r = this * a, r != this,a (HAC 14.12)
    42074. 

  42074.   // "this" should be the larger one if appropriate.
    42075. 

  42075.   function bnpMultiplyTo(a,r) {
    42076. 

  42076.     var x = this.abs(), y = a.abs();
    42077. 

  42077.     var i = x.t;
    42078. 

  42078.     r.t = i+y.t;
    42079. 

  42079.     while(--i >= 0) r[i] = 0;
    42080. 

  42080.     for(i = 0; i < y.t; ++i) r[i+x.t] = x.am(0,y[i],r,i,0,x.t);
    42081. 

  42081.     r.s = 0;
    42082. 

  42082.     r.clamp();
    42083. 

  42083.     if(this.s != a.s) BigInteger.ZERO.subTo(r,r);
    42084. 

  42084.   }
    42085. 

  42085. 

  42086.   // (protected) r = this^2, r != this (HAC 14.16)
    42087. 

  42087.   function bnpSquareTo(r) {
    42088. 

  42088.     var x = this.abs();
    42089. 

  42089.     var i = r.t = 2*x.t;
    42090. 

  42090.     while(--i >= 0) r[i] = 0;
    42091. 

  42091.     for(i = 0; i < x.t-1; ++i) {
    42092. 

  42092.       var c = x.am(i,x[i],r,2*i,0,1);
    42093. 

  42093.       if((r[i+x.t]+=x.am(i+1,2*x[i],r,2*i+1,c,x.t-i-1)) >= x.DV) {
    42094. 

  42094.         r[i+x.t] -= x.DV;
    42095. 

  42095.         r[i+x.t+1] = 1;
    42096. 

  42096.       }
    42097. 

  42097.     }
    42098. 

  42098.     if(r.t > 0) r[r.t-1] += x.am(i,x[i],r,2*i,0,1);
    42099. 

  42099.     r.s = 0;
    42100. 

  42100.     r.clamp();
    42101. 

  42101.   }
    42102. 

  42102. 

  42103.   // (protected) divide this by m, quotient and remainder to q, r (HAC 14.20)
    42104. 

  42104.   // r != q, this != m.  q or r may be null.
    42105. 

  42105.   function bnpDivRemTo(m,q,r) {
    42106. 

  42106.     var pm = m.abs();
    42107. 

  42107.     if(pm.t <= 0) return;
    42108. 

  42108.     var pt = this.abs();
    42109. 

  42109.     if(pt.t < pm.t) {
    42110. 

  42110.       if(q != null) q.fromInt(0);
    42111. 

  42111.       if(r != null) this.copyTo(r);
    42112. 

  42112.       return;
    42113. 

  42113.     }
    42114. 

  42114.     if(r == null) r = nbi();
    42115. 

  42115.     var y = nbi(), ts = this.s, ms = m.s;
    42116. 

  42116.     var nsh = this.DB-nbits(pm[pm.t-1]);  // normalize modulus
    42117. 

  42117.     if(nsh > 0) { pm.lShiftTo(nsh,y); pt.lShiftTo(nsh,r); }
    42118. 

  42118.     else { pm.copyTo(y); pt.copyTo(r); }
    42119. 

  42119.     var ys = y.t;
    42120. 

  42120.     var y0 = y[ys-1];
    42121. 

  42121.     if(y0 == 0) return;
    42122. 

  42122.     var yt = y0*(1<<this.F1)+((ys>1)?y[ys-2]>>this.F2:0);
    42123. 

  42123.     var d1 = this.FV/yt, d2 = (1<<this.F1)/yt, e = 1<<this.F2;
    42124. 

  42124.     var i = r.t, j = i-ys, t = (q==null)?nbi():q;
    42125. 

  42125.     y.dlShiftTo(j,t);
    42126. 

  42126.     if(r.compareTo(t) >= 0) {
    42127. 

  42127.       r[r.t++] = 1;
    42128. 

  42128.       r.subTo(t,r);
    42129. 

  42129.     }
    42130. 

  42130.     BigInteger.ONE.dlShiftTo(ys,t);
    42131. 

  42131.     t.subTo(y,y);  // "negative" y so we can replace sub with am later
    42132. 

  42132.     while(y.t < ys) y[y.t++] = 0;
    42133. 

  42133.     while(--j >= 0) {
    42134. 

  42134.       // Estimate quotient digit
    42135. 

  42135.       var qd = (r[--i]==y0)?this.DM:Math.floor(r[i]*d1+(r[i-1]+e)*d2);
    42136. 

  42136.       if((r[i]+=y.am(0,qd,r,j,0,ys)) < qd) {  // Try it out
    42137. 

  42137.         y.dlShiftTo(j,t);
    42138. 

  42138.         r.subTo(t,r);
    42139. 

  42139.         while(r[i] < --qd) r.subTo(t,r);
    42140. 

  42140.       }
    42141. 

  42141.     }
    42142. 

  42142.     if(q != null) {
    42143. 

  42143.       r.drShiftTo(ys,q);
    42144. 

  42144.       if(ts != ms) BigInteger.ZERO.subTo(q,q);
    42145. 

  42145.     }
    42146. 

  42146.     r.t = ys;
    42147. 

  42147.     r.clamp();
    42148. 

  42148.     if(nsh > 0) r.rShiftTo(nsh,r);  // Denormalize remainder
    42149. 

  42149.     if(ts < 0) BigInteger.ZERO.subTo(r,r);
    42150. 

  42150.   }
    42151. 

  42151. 

  42152.   // (public) this mod a
    42153. 

  42153.   function bnMod(a) {
    42154. 

  42154.     var r = nbi();
    42155. 

  42155.     this.abs().divRemTo(a,null,r);
    42156. 

  42156.     if(this.s < 0 && r.compareTo(BigInteger.ZERO) > 0) a.subTo(r,r);
    42157. 

  42157.     return r;
    42158. 

  42158.   }
    42159. 

  42159. 

  42160.   // Modular reduction using "classic" algorithm
    42161. 

  42161.   function Classic(m) { this.m = m; }
    42162. 

  42162.   function cConvert(x) {
    42163. 

  42163.     if(x.s < 0 || x.compareTo(this.m) >= 0) return x.mod(this.m);
    42164. 

  42164.     else return x;
    42165. 

  42165.   }
    42166. 

  42166.   function cRevert(x) { return x; }
    42167. 

  42167.   function cReduce(x) { x.divRemTo(this.m,null,x); }
    42168. 

  42168.   function cMulTo(x,y,r) { x.multiplyTo(y,r); this.reduce(r); }
    42169. 

  42169.   function cSqrTo(x,r) { x.squareTo(r); this.reduce(r); }
    42170. 

  42170. 

  42171.   Classic.prototype.convert = cConvert;
    42172. 

  42172.   Classic.prototype.revert = cRevert;
    42173. 

  42173.   Classic.prototype.reduce = cReduce;
    42174. 

  42174.   Classic.prototype.mulTo = cMulTo;
    42175. 

  42175.   Classic.prototype.sqrTo = cSqrTo;
    42176. 

  42176. 

  42177.   // (protected) return "-1/this % 2^DB"; useful for Mont. reduction
    42178. 

  42178.   // justification:
    42179. 

  42179.   //         xy == 1 (mod m)
    42180. 

  42180.   //         xy =  1+km
    42181. 

  42181.   //   xy(2-xy) = (1+km)(1-km)
    42182. 

  42182.   // x[y(2-xy)] = 1-k^2m^2
    42183. 

  42183.   // x[y(2-xy)] == 1 (mod m^2)
    42184. 

  42184.   // if y is 1/x mod m, then y(2-xy) is 1/x mod m^2
    42185. 

  42185.   // should reduce x and y(2-xy) by m^2 at each step to keep size bounded.
    42186. 

  42186.   // JS multiply "overflows" differently from C/C++, so care is needed here.
    42187. 

  42187.   function bnpInvDigit() {
    42188. 

  42188.     if(this.t < 1) return 0;
    42189. 

  42189.     var x = this[0];
    42190. 

  42190.     if((x&1) == 0) return 0;
    42191. 

  42191.     var y = x&3;    // y == 1/x mod 2^2
    42192. 

  42192.     y = (y*(2-(x&0xf)*y))&0xf;  // y == 1/x mod 2^4
    42193. 

  42193.     y = (y*(2-(x&0xff)*y))&0xff;  // y == 1/x mod 2^8
    42194. 

  42194.     y = (y*(2-(((x&0xffff)*y)&0xffff)))&0xffff;  // y == 1/x mod 2^16
    42195. 

  42195.     // last step - calculate inverse mod DV directly;
    42196. 

  42196.     // assumes 16 < DB <= 32 and assumes ability to handle 48-bit ints
    42197. 

  42197.     y = (y*(2-x*y%this.DV))%this.DV;    // y == 1/x mod 2^dbits
    42198. 

  42198.     // we really want the negative inverse, and -DV < y < DV
    42199. 

  42199.     return (y>0)?this.DV-y:-y;
    42200. 

  42200.   }
    42201. 

  42201. 

  42202.   // Montgomery reduction
    42203. 

  42203.   function Montgomery(m) {
    42204. 

  42204.     this.m = m;
    42205. 

  42205.     this.mp = m.invDigit();
    42206. 

  42206.     this.mpl = this.mp&0x7fff;
    42207. 

  42207.     this.mph = this.mp>>15;
    42208. 

  42208.     this.um = (1<<(m.DB-15))-1;
    42209. 

  42209.     this.mt2 = 2*m.t;
    42210. 

  42210.   }
    42211. 

  42211. 

  42212.   // xR mod m
    42213. 

  42213.   function montConvert(x) {
    42214. 

  42214.     var r = nbi();
    42215. 

  42215.     x.abs().dlShiftTo(this.m.t,r);
    42216. 

  42216.     r.divRemTo(this.m,null,r);
    42217. 

  42217.     if(x.s < 0 && r.compareTo(BigInteger.ZERO) > 0) this.m.subTo(r,r);
    42218. 

  42218.     return r;
    42219. 

  42219.   }
    42220. 

  42220. 

  42221.   // x/R mod m
    42222. 

  42222.   function montRevert(x) {
    42223. 

  42223.     var r = nbi();
    42224. 

  42224.     x.copyTo(r);
    42225. 

  42225.     this.reduce(r);
    42226. 

  42226.     return r;
    42227. 

  42227.   }
    42228. 

  42228. 

  42229.   // x = x/R mod m (HAC 14.32)
    42230. 

  42230.   function montReduce(x) {
    42231. 

  42231.     while(x.t <= this.mt2)  // pad x so am has enough room later
    42232. 

  42232.       x[x.t++] = 0;
    42233. 

  42233.     for(var i = 0; i < this.m.t; ++i) {
    42234. 

  42234.       // faster way of calculating u0 = x[i]*mp mod DV
    42235. 

  42235.       var j = x[i]&0x7fff;
    42236. 

  42236.       var u0 = (j*this.mpl+(((j*this.mph+(x[i]>>15)*this.mpl)&this.um)<<15))&x.DM;
    42237. 

  42237.       // use am to combine the multiply-shift-add into one call
    42238. 

  42238.       j = i+this.m.t;
    42239. 

  42239.       x[j] += this.m.am(0,u0,x,i,0,this.m.t);
    42240. 

  42240.       // propagate carry
    42241. 

  42241.       while(x[j] >= x.DV) { x[j] -= x.DV; x[++j]++; }
    42242. 

  42242.     }
    42243. 

  42243.     x.clamp();
    42244. 

  42244.     x.drShiftTo(this.m.t,x);
    42245. 

  42245.     if(x.compareTo(this.m) >= 0) x.subTo(this.m,x);
    42246. 

  42246.   }
    42247. 

  42247. 

  42248.   // r = "x^2/R mod m"; x != r
    42249. 

  42249.   function montSqrTo(x,r) { x.squareTo(r); this.reduce(r); }
    42250. 

  42250. 

  42251.   // r = "xy/R mod m"; x,y != r
    42252. 

  42252.   function montMulTo(x,y,r) { x.multiplyTo(y,r); this.reduce(r); }
    42253. 

  42253. 

  42254.   Montgomery.prototype.convert = montConvert;
    42255. 

  42255.   Montgomery.prototype.revert = montRevert;
    42256. 

  42256.   Montgomery.prototype.reduce = montReduce;
    42257. 

  42257.   Montgomery.prototype.mulTo = montMulTo;
    42258. 

  42258.   Montgomery.prototype.sqrTo = montSqrTo;
    42259. 

  42259. 

  42260.   // (protected) true iff this is even
    42261. 

  42261.   function bnpIsEven() { return ((this.t>0)?(this[0]&1):this.s) == 0; }
    42262. 

  42262. 

  42263.   // (protected) this^e, e < 2^32, doing sqr and mul with "r" (HAC 14.79)
    42264. 

  42264.   function bnpExp(e,z) {
    42265. 

  42265.     if(e > 0xffffffff || e < 1) return BigInteger.ONE;
    42266. 

  42266.     var r = nbi(), r2 = nbi(), g = z.convert(this), i = nbits(e)-1;
    42267. 

  42267.     g.copyTo(r);
    42268. 

  42268.     while(--i >= 0) {
    42269. 

  42269.       z.sqrTo(r,r2);
    42270. 

  42270.       if((e&(1<<i)) > 0) z.mulTo(r2,g,r);
    42271. 

  42271.       else { var t = r; r = r2; r2 = t; }
    42272. 

  42272.     }
    42273. 

  42273.     return z.revert(r);
    42274. 

  42274.   }
    42275. 

  42275. 

  42276.   // (public) this^e % m, 0 <= e < 2^32
    42277. 

  42277.   function bnModPowInt(e,m) {
    42278. 

  42278.     var z;
    42279. 

  42279.     if(e < 256 || m.isEven()) z = new Classic(m); else z = new Montgomery(m);
    42280. 

  42280.     return this.exp(e,z);
    42281. 

  42281.   }
    42282. 

  42282. 

  42283.   // protected
    42284. 

  42284.   BigInteger.prototype.copyTo = bnpCopyTo;
    42285. 

  42285.   BigInteger.prototype.fromInt = bnpFromInt;
    42286. 

  42286.   BigInteger.prototype.fromString = bnpFromString;
    42287. 

  42287.   BigInteger.prototype.clamp = bnpClamp;
    42288. 

  42288.   BigInteger.prototype.dlShiftTo = bnpDLShiftTo;
    42289. 

  42289.   BigInteger.prototype.drShiftTo = bnpDRShiftTo;
    42290. 

  42290.   BigInteger.prototype.lShiftTo = bnpLShiftTo;
    42291. 

  42291.   BigInteger.prototype.rShiftTo = bnpRShiftTo;
    42292. 

  42292.   BigInteger.prototype.subTo = bnpSubTo;
    42293. 

  42293.   BigInteger.prototype.multiplyTo = bnpMultiplyTo;
    42294. 

  42294.   BigInteger.prototype.squareTo = bnpSquareTo;
    42295. 

  42295.   BigInteger.prototype.divRemTo = bnpDivRemTo;
    42296. 

  42296.   BigInteger.prototype.invDigit = bnpInvDigit;
    42297. 

  42297.   BigInteger.prototype.isEven = bnpIsEven;
    42298. 

  42298.   BigInteger.prototype.exp = bnpExp;
    42299. 

  42299. 

  42300.   // public
    42301. 

  42301.   BigInteger.prototype.toString = bnToString;
    42302. 

  42302.   BigInteger.prototype.negate = bnNegate;
    42303. 

  42303.   BigInteger.prototype.abs = bnAbs;
    42304. 

  42304.   BigInteger.prototype.compareTo = bnCompareTo;
    42305. 

  42305.   BigInteger.prototype.bitLength = bnBitLength;
    42306. 

  42306.   BigInteger.prototype.mod = bnMod;
    42307. 

  42307.   BigInteger.prototype.modPowInt = bnModPowInt;
    42308. 

  42308. 

  42309.   // "constants"
    42310. 

  42310.   BigInteger.ZERO = nbv(0);
    42311. 

  42311.   BigInteger.ONE = nbv(1);
    42312. 

  42312. 

  42313.   // jsbn2 stuff
    42314. 

  42314. 

  42315.   // (protected) convert from radix string
    42316. 

  42316.   function bnpFromRadix(s,b) {
    42317. 

  42317.     this.fromInt(0);
    42318. 

  42318.     if(b == null) b = 10;
    42319. 

  42319.     var cs = this.chunkSize(b);
    42320. 

  42320.     var d = Math.pow(b,cs), mi = false, j = 0, w = 0;
    42321. 

  42321.     for(var i = 0; i < s.length; ++i) {
    42322. 

  42322.       var x = intAt(s,i);
    42323. 

  42323.       if(x < 0) {
    42324. 

  42324.         if(s.charAt(i) == "-" && this.signum() == 0) mi = true;
    42325. 

  42325.         continue;
    42326. 

  42326.       }
    42327. 

  42327.       w = b*w+x;
    42328. 

  42328.       if(++j >= cs) {
    42329. 

  42329.         this.dMultiply(d);
    42330. 

  42330.         this.dAddOffset(w,0);
    42331. 

  42331.         j = 0;
    42332. 

  42332.         w = 0;
    42333. 

  42333.       }
    42334. 

  42334.     }
    42335. 

  42335.     if(j > 0) {
    42336. 

  42336.       this.dMultiply(Math.pow(b,j));
    42337. 

  42337.       this.dAddOffset(w,0);
    42338. 

  42338.     }
    42339. 

  42339.     if(mi) BigInteger.ZERO.subTo(this,this);
    42340. 

  42340.   }
    42341. 

  42341. 

  42342.   // (protected) return x s.t. r^x < DV
    42343. 

  42343.   function bnpChunkSize(r) { return Math.floor(Math.LN2*this.DB/Math.log(r)); }
    42344. 

  42344. 

  42345.   // (public) 0 if this == 0, 1 if this > 0
    42346. 

  42346.   function bnSigNum() {
    42347. 

  42347.     if(this.s < 0) return -1;
    42348. 

  42348.     else if(this.t <= 0 || (this.t == 1 && this[0] <= 0)) return 0;
    42349. 

  42349.     else return 1;
    42350. 

  42350.   }
    42351. 

  42351. 

  42352.   // (protected) this *= n, this >= 0, 1 < n < DV
    42353. 

  42353.   function bnpDMultiply(n) {
    42354. 

  42354.     this[this.t] = this.am(0,n-1,this,0,0,this.t);
    42355. 

  42355.     ++this.t;
    42356. 

  42356.     this.clamp();
    42357. 

  42357.   }
    42358. 

  42358. 

  42359.   // (protected) this += n << w words, this >= 0
    42360. 

  42360.   function bnpDAddOffset(n,w) {
    42361. 

  42361.     if(n == 0) return;
    42362. 

  42362.     while(this.t <= w) this[this.t++] = 0;
    42363. 

  42363.     this[w] += n;
    42364. 

  42364.     while(this[w] >= this.DV) {
    42365. 

  42365.       this[w] -= this.DV;
    42366. 

  42366.       if(++w >= this.t) this[this.t++] = 0;
    42367. 

  42367.       ++this[w];
    42368. 

  42368.     }
    42369. 

  42369.   }
    42370. 

  42370. 

  42371.   // (protected) convert to radix string
    42372. 

  42372.   function bnpToRadix(b) {
    42373. 

  42373.     if(b == null) b = 10;
    42374. 

  42374.     if(this.signum() == 0 || b < 2 || b > 36) return "0";
    42375. 

  42375.     var cs = this.chunkSize(b);
    42376. 

  42376.     var a = Math.pow(b,cs);
    42377. 

  42377.     var d = nbv(a), y = nbi(), z = nbi(), r = "";
    42378. 

  42378.     this.divRemTo(d,y,z);
    42379. 

  42379.     while(y.signum() > 0) {
    42380. 

  42380.       r = (a+z.intValue()).toString(b).substr(1) + r;
    42381. 

  42381.       y.divRemTo(d,y,z);
    42382. 

  42382.     }
    42383. 

  42383.     return z.intValue().toString(b) + r;
    42384. 

  42384.   }
    42385. 

  42385. 

  42386.   // (public) return value as integer
    42387. 

  42387.   function bnIntValue() {
    42388. 

  42388.     if(this.s < 0) {
    42389. 

  42389.       if(this.t == 1) return this[0]-this.DV;
    42390. 

  42390.       else if(this.t == 0) return -1;
    42391. 

  42391.     }
    42392. 

  42392.     else if(this.t == 1) return this[0];
    42393. 

  42393.     else if(this.t == 0) return 0;
    42394. 

  42394.     // assumes 16 < DB < 32
    42395. 

  42395.     return ((this[1]&((1<<(32-this.DB))-1))<<this.DB)|this[0];
    42396. 

  42396.   }
    42397. 

  42397. 

  42398.   // (protected) r = this + a
    42399. 

  42399.   function bnpAddTo(a,r) {
    42400. 

  42400.     var i = 0, c = 0, m = Math.min(a.t,this.t);
    42401. 

  42401.     while(i < m) {
    42402. 

  42402.       c += this[i]+a[i];
    42403. 

  42403.       r[i++] = c&this.DM;
    42404. 

  42404.       c >>= this.DB;
    42405. 

  42405.     }
    42406. 

  42406.     if(a.t < this.t) {
    42407. 

  42407.       c += a.s;
    42408. 

  42408.       while(i < this.t) {
    42409. 

  42409.         c += this[i];
    42410. 

  42410.         r[i++] = c&this.DM;
    42411. 

  42411.         c >>= this.DB;
    42412. 

  42412.       }
    42413. 

  42413.       c += this.s;
    42414. 

  42414.     }
    42415. 

  42415.     else {
    42416. 

  42416.       c += this.s;
    42417. 

  42417.       while(i < a.t) {
    42418. 

  42418.         c += a[i];
    42419. 

  42419.         r[i++] = c&this.DM;
    42420. 

  42420.         c >>= this.DB;
    42421. 

  42421.       }
    42422. 

  42422.       c += a.s;
    42423. 

  42423.     }
    42424. 

  42424.     r.s = (c<0)?-1:0;
    42425. 

  42425.     if(c > 0) r[i++] = c;
    42426. 

  42426.     else if(c < -1) r[i++] = this.DV+c;
    42427. 

  42427.     r.t = i;
    42428. 

  42428.     r.clamp();
    42429. 

  42429.   }
    42430. 

  42430. 

  42431.   BigInteger.prototype.fromRadix = bnpFromRadix;
    42432. 

  42432.   BigInteger.prototype.chunkSize = bnpChunkSize;
    42433. 

  42433.   BigInteger.prototype.signum = bnSigNum;
    42434. 

  42434.   BigInteger.prototype.dMultiply = bnpDMultiply;
    42435. 

  42435.   BigInteger.prototype.dAddOffset = bnpDAddOffset;
    42436. 

  42436.   BigInteger.prototype.toRadix = bnpToRadix;
    42437. 

  42437.   BigInteger.prototype.intValue = bnIntValue;
    42438. 

  42438.   BigInteger.prototype.addTo = bnpAddTo;
    42439. 

  42439. 

  42440.   //======= end jsbn =======
    42441. 

  42441. 

  42442.   // Emscripten wrapper
    42443. 

  42443.   var Wrapper = {
    42444. 

  42444.     abs: function(l, h) {
    42445. 

  42445.       var x = new goog.math.Long(l, h);
    42446. 

  42446.       var ret;
    42447. 

  42447.       if (x.isNegative()) {
    42448. 

  42448.         ret = x.negate();
    42449. 

  42449.       } else {
    42450. 

  42450.         ret = x;
    42451. 

  42451.       }
    42452. 

  42452.       HEAP32[tempDoublePtr>>2] = ret.low_;
    42453. 

  42453.       HEAP32[tempDoublePtr+4>>2] = ret.high_;
    42454. 

  42454.     },
    42455. 

  42455.     ensureTemps: function() {
    42456. 

  42456.       if (Wrapper.ensuredTemps) return;
    42457. 

  42457.       Wrapper.ensuredTemps = true;
    42458. 

  42458.       Wrapper.two32 = new BigInteger();
    42459. 

  42459.       Wrapper.two32.fromString('4294967296', 10);
    42460. 

  42460.       Wrapper.two64 = new BigInteger();
    42461. 

  42461.       Wrapper.two64.fromString('18446744073709551616', 10);
    42462. 

  42462.       Wrapper.temp1 = new BigInteger();
    42463. 

  42463.       Wrapper.temp2 = new BigInteger();
    42464. 

  42464.     },
    42465. 

  42465.     lh2bignum: function(l, h) {
    42466. 

  42466.       var a = new BigInteger();
    42467. 

  42467.       a.fromString(h.toString(), 10);
    42468. 

  42468.       var b = new BigInteger();
    42469. 

  42469.       a.multiplyTo(Wrapper.two32, b);
    42470. 

  42470.       var c = new BigInteger();
    42471. 

  42471.       c.fromString(l.toString(), 10);
    42472. 

  42472.       var d = new BigInteger();
    42473. 

  42473.       c.addTo(b, d);
    42474. 

  42474.       return d;
    42475. 

  42475.     },
    42476. 

  42476.     stringify: function(l, h, unsigned) {
    42477. 

  42477.       var ret = new goog.math.Long(l, h).toString();
    42478. 

  42478.       if (unsigned && ret[0] == '-') {
    42479. 

  42479.         // unsign slowly using jsbn bignums
    42480. 

  42480.         Wrapper.ensureTemps();
    42481. 

  42481.         var bignum = new BigInteger();
    42482. 

  42482.         bignum.fromString(ret, 10);
    42483. 

  42483.         ret = new BigInteger();
    42484. 

  42484.         Wrapper.two64.addTo(bignum, ret);
    42485. 

  42485.         ret = ret.toString(10);
    42486. 

  42486.       }
    42487. 

  42487.       return ret;
    42488. 

  42488.     },
    42489. 

  42489.     fromString: function(str, base, min, max, unsigned) {
    42490. 

  42490.       Wrapper.ensureTemps();
    42491. 

  42491.       var bignum = new BigInteger();
    42492. 

  42492.       bignum.fromString(str, base);
    42493. 

  42493.       var bigmin = new BigInteger();
    42494. 

  42494.       bigmin.fromString(min, 10);
    42495. 

  42495.       var bigmax = new BigInteger();
    42496. 

  42496.       bigmax.fromString(max, 10);
    42497. 

  42497.       if (unsigned && bignum.compareTo(BigInteger.ZERO) < 0) {
    42498. 

  42498.         var temp = new BigInteger();
    42499. 

  42499.         bignum.addTo(Wrapper.two64, temp);
    42500. 

  42500.         bignum = temp;
    42501. 

  42501.       }
    42502. 

  42502.       var error = false;
    42503. 

  42503.       if (bignum.compareTo(bigmin) < 0) {
    42504. 

  42504.         bignum = bigmin;
    42505. 

  42505.         error = true;
    42506. 

  42506.       } else if (bignum.compareTo(bigmax) > 0) {
    42507. 

  42507.         bignum = bigmax;
    42508. 

  42508.         error = true;
    42509. 

  42509.       }
    42510. 

  42510.       var ret = goog.math.Long.fromString(bignum.toString()); // min-max checks should have clamped this to a range goog.math.Long can handle well
    42511. 

  42511.       HEAP32[tempDoublePtr>>2] = ret.low_;
    42512. 

  42512.       HEAP32[tempDoublePtr+4>>2] = ret.high_;
    42513. 

  42513.       if (error) throw 'range error';
    42514. 

  42514.     }
    42515. 

  42515.   };
    42516. 

  42516.   return Wrapper;
    42517. 

  42517. })();
    42518. 

  42518. 

  42519. //======= end closure i64 code =======
    42520. 

  42520. 

  42521. 

  42522. 

  42523. // === Auto-generated postamble setup entry stuff ===
    42524. 

  42524. 

  42525. if (memoryInitializer) {
    42526. 

  42526.   if (ENVIRONMENT_IS_NODE || ENVIRONMENT_IS_SHELL) {
    42527. 

  42527.     var data = Module['readBinary'](memoryInitializer);
    42528. 

  42528.     HEAPU8.set(data, STATIC_BASE);
    42529. 

  42529.   } else {
    42530. 

  42530.     addRunDependency('memory initializer');
    42531. 

  42531.     Browser.asyncLoad(memoryInitializer, function(data) {
    42532. 

  42532.       HEAPU8.set(data, STATIC_BASE);
    42533. 

  42533.       removeRunDependency('memory initializer');
    42534. 

  42534.     }, function(data) {
    42535. 

  42535.       throw 'could not load memory initializer ' + memoryInitializer;
    42536. 

  42536.     });
    42537. 

  42537.   }
    42538. 

  42538. }
    42539. 

  42539. 

  42540. function ExitStatus(status) {
    42541. 

  42541.   this.name = "ExitStatus";
    42542. 

  42542.   this.message = "Program terminated with exit(" + status + ")";
    42543. 

  42543.   this.status = status;
    42544. 

  42544. };
    42545. 

  42545. ExitStatus.prototype = new Error();
    42546. 

  42546. ExitStatus.prototype.constructor = ExitStatus;
    42547. 

  42547. 

  42548. var initialStackTop;
    42549. 

  42549. var preloadStartTime = null;
    42550. 

  42550. var calledMain = false;
    42551. 

  42551. 

  42552. dependenciesFulfilled = function runCaller() {
    42553. 

  42553.   // If run has never been called, and we should call run (INVOKE_RUN is true, and Module.noInitialRun is not false)
    42554. 

  42554.   if (!Module['calledRun'] && shouldRunNow) run(['binarytrees.lua'].concat(Module["arguments"]));
    42555. 

  42555.   if (!Module['calledRun']) dependenciesFulfilled = runCaller; // try this again later, after new deps are fulfilled
    42556. 

  42556. }
    42557. 

  42557. 

  42558. Module['callMain'] = Module.callMain = function callMain(args) {
    42559. 

  42559.   assert(runDependencies == 0, 'cannot call main when async dependencies remain! (listen on __ATMAIN__)');
    42560. 

  42560.   assert(__ATPRERUN__.length == 0, 'cannot call main when preRun functions remain to be called');
    42561. 

  42561. 

  42562.   args = args || [];
    42563. 

  42563. 

  42564.   ensureInitRuntime();
    42565. 

  42565. 

  42566.   var argc = args.length+1;
    42567. 

  42567.   function pad() {
    42568. 

  42568.     for (var i = 0; i < 4-1; i++) {
    42569. 

  42569.       argv.push(0);
    42570. 

  42570.     }
    42571. 

  42571.   }
    42572. 

  42572.   var argv = [allocate(intArrayFromString("/bin/this.program"), 'i8', ALLOC_NORMAL) ];
    42573. 

  42573.   pad();
    42574. 

  42574.   for (var i = 0; i < argc-1; i = i + 1) {
    42575. 

  42575.     argv.push(allocate(intArrayFromString(args[i]), 'i8', ALLOC_NORMAL));
    42576. 

  42576.     pad();
    42577. 

  42577.   }
    42578. 

  42578.   argv.push(0);
    42579. 

  42579.   argv = allocate(argv, 'i32', ALLOC_NORMAL);
    42580. 

  42580. 

  42581.   initialStackTop = STACKTOP;
    42582. 

  42582. 

  42583.   try {
    42584. 

  42584. 

  42585.     var ret = Module['_main'](argc, argv, 0);
    42586. 

  42586. 

  42587. 

  42588.     // if we're not running an evented main loop, it's time to exit
    42589. 

  42589.     if (!Module['noExitRuntime']) {
    42590. 

  42590.       exit(ret);
    42591. 

  42591.     }
    42592. 

  42592.   }
    42593. 

  42593.   catch(e) {
    42594. 

  42594.     if (e instanceof ExitStatus) {
    42595. 

  42595.       // exit() throws this once it's done to make sure execution
    42596. 

  42596.       // has been stopped completely
    42597. 

  42597.       return;
    42598. 

  42598.     } else if (e == 'SimulateInfiniteLoop') {
    42599. 

  42599.       // running an evented main loop, don't immediately exit
    42600. 

  42600.       Module['noExitRuntime'] = true;
    42601. 

  42601.       return;
    42602. 

  42602.     } else {
    42603. 

  42603.       if (e && typeof e === 'object' && e.stack) Module.printErr('exception thrown: ' + [e, e.stack]);
    42604. 

  42604.       throw e;
    42605. 

  42605.     }
    42606. 

  42606.   } finally {
    42607. 

  42607.     calledMain = true;
    42608. 

  42608.   }
    42609. 

  42609. }
    42610. 

  42610. 

  42611. 

  42612. 

  42613. 

  42614. function run(args) {
    42615. 

  42615.   args = args || Module['arguments'];
    42616. 

  42616. 

  42617.   if (preloadStartTime === null) preloadStartTime = Date.now();
    42618. 

  42618. 

  42619.   if (runDependencies > 0) {
    42620. 

  42620.     Module.printErr('run() called, but dependencies remain, so not running');
    42621. 

  42621.     return;
    42622. 

  42622.   }
    42623. 

  42623. 

  42624.   preRun();
    42625. 

  42625. 

  42626.   if (runDependencies > 0) return; // a preRun added a dependency, run will be called later
    42627. 

  42627.   if (Module['calledRun']) return; // run may have just been called through dependencies being fulfilled just in this very frame
    42628. 

  42628. 

  42629.   function doRun() {
    42630. 

  42630.     if (Module['calledRun']) return; // run may have just been called while the async setStatus time below was happening
    42631. 

  42631.     Module['calledRun'] = true;
    42632. 

  42632. 

  42633.     ensureInitRuntime();
    42634. 

  42634. 

  42635.     preMain();
    42636. 

  42636. 

  42637.     if (ENVIRONMENT_IS_WEB && preloadStartTime !== null) {
    42638. 

  42638.       Module.printErr('pre-main prep time: ' + (Date.now() - preloadStartTime) + ' ms');
    42639. 

  42639.     }
    42640. 

  42640. 

  42641.     if (Module['_main'] && shouldRunNow) {
    42642. 

  42642.       Module['callMain'](args);
    42643. 

  42643.     }
    42644. 

  42644. 

  42645.     postRun();
    42646. 

  42646.   }
    42647. 

  42647. 

  42648.   if (Module['setStatus']) {
    42649. 

  42649.     Module['setStatus']('Running...');
    42650. 

  42650.     setTimeout(function() {
    42651. 

  42651.       setTimeout(function() {
    42652. 

  42652.         Module['setStatus']('');
    42653. 

  42653.       }, 1);
    42654. 

  42654.       if (!ABORT) doRun();
    42655. 

  42655.     }, 1);
    42656. 

  42656.   } else {
    42657. 

  42657.     doRun();
    42658. 

  42658.   }
    42659. 

  42659. }
    42660. 

  42660. Module['run'] = Module.run = run;
    42661. 

  42661. 

  42662. function exit(status) {
    42663. 

  42663.   ABORT = true;
    42664. 

  42664.   EXITSTATUS = status;
    42665. 

  42665.   STACKTOP = initialStackTop;
    42666. 

  42666. 

  42667.   // exit the runtime
    42668. 

  42668.   exitRuntime();
    42669. 

  42669. 

  42670.   // TODO We should handle this differently based on environment.
    42671. 

  42671.   // In the browser, the best we can do is throw an exception
    42672. 

  42672.   // to halt execution, but in node we could process.exit and
    42673. 

  42673.   // I'd imagine SM shell would have something equivalent.
    42674. 

  42674.   // This would let us set a proper exit status (which
    42675. 

  42675.   // would be great for checking test exit statuses).
    42676. 

  42676.   // https://github.com/kripken/emscripten/issues/1371
    42677. 

  42677. 

  42678.   // throw an exception to halt the current execution
    42679. 

  42679.   throw new ExitStatus(status);
    42680. 

  42680. }
    42681. 

  42681. Module['exit'] = Module.exit = exit;
    42682. 

  42682. 

  42683. function abort(text) {
    42684. 

  42684.   if (text) {
    42685. 

  42685.     Module.print(text);
    42686. 

  42686.     Module.printErr(text);
    42687. 

  42687.   }
    42688. 

  42688. 

  42689.   ABORT = true;
    42690. 

  42690.   EXITSTATUS = 1;
    42691. 

  42691. 

  42692.   var extra = '\nIf this abort() is unexpected, build with -s ASSERTIONS=1 which can give more information.';
    42693. 

  42693. 

  42694.   throw 'abort() at ' + stackTrace() + extra;
    42695. 

  42695. }
    42696. 

  42696. Module['abort'] = Module.abort = abort;
    42697. 

  42697. 

  42698. // {{PRE_RUN_ADDITIONS}}
    42699. 

  42699. 

  42700. if (Module['preInit']) {
    42701. 

  42701.   if (typeof Module['preInit'] == 'function') Module['preInit'] = [Module['preInit']];
    42702. 

  42702.   while (Module['preInit'].length > 0) {
    42703. 

  42703.     Module['preInit'].pop()();
    42704. 

  42704.   }
    42705. 

  42705. }
    42706. 

  42706. 

  42707. // shouldRunNow refers to calling main(), not run().
    42708. 

  42708. var shouldRunNow = true;
    42709. 

  42709. if (Module['noInitialRun']) {
    42710. 

  42710.   shouldRunNow = false;
    42711. 

  42711. }
    42712. 

  42712. 

  42713. 

  42714. run(['binarytrees.lua'].concat(Module["arguments"]));
    42715.