optimize raytrace demo

2 files changed, 1971 insertions, 961 deletions

diff --git a/demos/raytrace.html b/demos/raytrace.html
index fcfd56e1..a95d4468 100644
--- a/demos/raytrace.html
+++ b/demos/raytrace.html
@@ -57,7 +57,6 @@
   <hr>
   Simple raytracing demo. The <a href="http://ompf.org/ray/sphereflake/">original C++ source</a> was
   automatically converted to JavaScript using <a href="http://emscripten.org">Emscripten</a>.
-  <b>Note</b>: This was done with Emscripten 0.3, which is designed for correctness, not speed!
 </body>
 </html>
 
diff --git a/demos/raytrace.js b/demos/raytrace.js
index 1b00e962..2f4dffeb 100644
--- a/demos/raytrace.js
+++ b/demos/raytrace.js
@@ -7,1073 +7,2084 @@
 // Optimized using Closure Compiler
 //====================================================================================
 
+
+// === Auto-generated preamble library stuff ===
+
 function __globalConstructor__() {
 }
-var __THREW__ = false, __ATEXIT__ = [];
-function assert(b, d) {
-  if(!b) {
-    d = "Assertion failed: " + d;
-    print(d + ":\n" + Error().stack);
-    this[alert] && alert(d);
-    throw"Assertion: " + d;
+
+var __THREW__ = false; // Used in checking for thrown exceptions.
+
+var __ATEXIT__ = [];
+
+
+
+
+function assert(condition, text) {
+  if (!condition) {
+    var text = "Assertion failed: " + text;
+    print(text + ':\n' + (new Error).stack);
+    throw "Assertion: " + text;
   }
 }
-function Pointer_niceify(b) {
-  return{slab:HEAP, pos:b}
+
+function Pointer_niceify(ptr) {
+  return { slab: HEAP, pos: ptr };
 }
-function Pointer_make(b, d, a) {
-  function c(f) {
-    if(!f || f.length === undefined || typeof f === "function") {
-      return[f]
-    }
-    return f.map(c).reduce(function(g, h) {
-      return g.concat(h)
-    }, [])
-  }
-  d = d ? d : 0;
-  if(b === HEAP) {
-    return d
+
+// Creates a pointer for a certain slab and a certain address in that slab.
+// If just a slab is given, will allocate room for it and copy it there. In
+// other words, do whatever is necessary in order to return a pointer, that
+// points to the slab (and possibly position) we are given.
+
+ALLOC_NORMAL = 0; // Tries to use _malloc()
+ALLOC_STACK = 1; // Lives for the duration of the current function call
+ALLOC_STATIC = 2; // Cannot be freed
+
+function Pointer_make(slab, pos, allocator) {
+  pos = pos ? pos : 0;
+  if (slab === HEAP) return pos;
+  // Flatten out - needed for global consts/vars
+  function flatten(slab) {
+    if (!slab || slab.length === undefined || typeof slab === 'function') return [slab];
+    return slab.map(flatten).reduce(function(a,b) { return a.concat(b) }, []);
   }
-  b = c(b);
-  a = [_malloc, stackAlloc, staticAlloc][a ? a : ALLOC_STATIC](Math.max(b.length - d, 1));
-  for(var e = 0;e < b.length - d;e++) {
-    HEAP[a + e] = b[d + e]
+  var slab = flatten(slab);
+  // Finalize
+  var ret = [_malloc, stackAlloc, staticAlloc][allocator ? allocator : ALLOC_STATIC](Math.max(slab.length - pos, 1));
+  for (var i = 0; i < slab.length - pos; i++) {
+    HEAP[ret + i] = slab[pos + i];
   }
-  return a
+  return ret;
 }
-function Pointer_stringify(b) {
-  b = Pointer_niceify(b);
-  for(var d = "", a = 0, c;;) {
-    if(b.pos + a >= b.slab.length) {
-      break
-    }
-    c = String.fromCharCode(b.slab[b.pos + a]);
-    if(c == "\u0000") {
-      break
-    }
-    d += c;
-    a += 1
+
+function Pointer_stringify(ptr) {
+  ptr = Pointer_niceify(ptr);
+
+  var ret = "";
+  var i = 0;
+  var t;
+  while (1) {
+//    if ((ptr.pos + i) >= ptr.slab.length) { return "<< Invalid read: " + (ptr.pos+i) + " : " + ptr.slab.length + " >>"; } else {}
+    if ((ptr.pos+i) >= ptr.slab.length) { break; } else {}
+    t = String.fromCharCode(ptr.slab[ptr.pos + i]);
+    if (t == "\0") { break; } else {}
+    ret += t;
+    i += 1;
   }
-  return d
-}
-ALLOC_NORMAL = 0;
-ALLOC_STACK = 1;
-ALLOC_STATIC = 2;
-function alignMemory(b) {
-  return Math.ceil(b / 1) * 1
+  return ret;
 }
+
+// Memory management
+
 PAGE_SIZE = 4096;
-function alignMemoryPage(b) {
-  return Math.ceil(b / PAGE_SIZE) * PAGE_SIZE
-}
-function stackEnter() {
-  STACK_STACK.push(STACKTOP)
-}
-function stackExit() {
-  STACKTOP = STACK_STACK.pop()
-}
-function stackAlloc(b) {
-  b = alignMemory(b);
-  assert(STACKTOP + b - STACKROOT < TOTAL_STACK, "No room on stack!");
-  var d = STACKTOP;
-  STACKTOP += b;
-  return d
+function alignMemoryPage(x) {
+  return Math.ceil(x/PAGE_SIZE)*PAGE_SIZE;
 }
-function staticAlloc(b) {
-  b = alignMemory(b);
-  assert(STATICTOP + b - STATICROOT < TOTAL_STATIC, "No room for static allocation!");
-  var d = STATICTOP;
-  STATICTOP += b;
-  return d
-}
-if(!this._malloc) {
+
+// If we don't have malloc/free implemented, use a simple implementation.
+if (!this._malloc) {
   _malloc = staticAlloc;
-  _free = function() {
-  }
+  _free = function() { }; // leak!
 }
-__Znwm = __Znam = __Znaj = __Znwj = _malloc;
-__ZdaPv = __ZdlPv = _free;
+
+// Mangled "new"s... need a heuristic for autogeneration...
+__Znwj = _malloc; // llvm-gcc
+__Znaj = _malloc; // llvm-gcc
+__Znam = _malloc; // clang
+__Znwm = _malloc; // clang
+// Mangled "delete"s... need a heuristic for autogeneration...
+__ZdlPv = _free; // llvm-gcc
+__ZdaPv = _free; // llvm-gcc
+
 function __initializeRuntime__() {
-  HEAP = intArrayFromString("(null)");
-  this.TOTAL_STATIC || (TOTAL_STATIC = 6553600);
-  STATICROOT = STATICTOP = alignMemoryPage(HEAP.length);
-  this.TOTAL_STACK || (TOTAL_STACK = 655360);
+  HEAP = intArrayFromString('(null)'); // So printing %s of NULL gives '(null)'
+                                       // Also this ensures we leave 0 as an invalid address, 'NULL'
+
   STACK_STACK = [];
-  STACKROOT = STACKTOP = alignMemoryPage(STATICROOT + TOTAL_STATIC);
-  HEAPTOP = alignMemoryPage(STACKROOT + TOTAL_STACK)
+  STACK_ROOT = STACKTOP = alignMemoryPage(10);
+  if (!this['TOTAL_STACK']) TOTAL_STACK = 64*1024*100; // Reserved room for stack
+  STACK_MAX = STACK_ROOT + TOTAL_STACK;
+
+  STATICTOP = alignMemoryPage(STACK_MAX);
 }
+
+// stdio.h
+
+// C-style: we work on ints on the HEAP.
 function __formatString() {
-  for(var b = arguments[0], d = 1, a = [], c = -1;c != 0;) {
-    c = HEAP[b];
-    next = HEAP[b + 1];
-    if(c == "%".charCodeAt(0) && ["d", "u", "f", "."].indexOf(String.fromCharCode(next)) != -1) {
-      var e = String(arguments[d]);
-      if(next == ".".charCodeAt(0)) {
-        var f = parseInt(String.fromCharCode(HEAP[b + 2])), g = e.indexOf(".");
-        if(g == -1) {
-          g = e.length;
-          e += "."
-        }
-        e += "00000000000";
-        e = e.substr(0, g + 1 + f);
-        b += 2
-      }else {
-        if(next == "u".charCodeAt(0)) {
-          e = String(unSign(arguments[d], 32))
+  var textIndex = arguments[0];
+  var argIndex = 1;
+  var ret = [];
+  var curr = -1;
+  while (curr != 0) {
+    curr = HEAP[textIndex];
+    next = HEAP[textIndex+1];
+    if (curr == '%'.charCodeAt(0) && ['d', 'u', 'f', '.'].indexOf(String.fromCharCode(next)) != -1) {
+      var argText = String(arguments[argIndex]);
+      // Handle very very simply formatting, namely only %.Xf
+      if (next == '.'.charCodeAt(0)) {
+        var limit = parseInt(String.fromCharCode(HEAP[textIndex+2]));
+        var dotIndex = argText.indexOf('.');
+        if (dotIndex == -1) {
+          dotIndex = argText.length;
+          argText += '.';
         }
+        argText += '00000000000'; // padding
+        argText = argText.substr(0, dotIndex+1+limit);
+        textIndex += 2;
+      } else if (next == 'u'.charCodeAt(0)) {
+        argText = String(unSign(arguments[argIndex], 32));
       }
-      e.split("").forEach(function(h) {
-        a.push(h.charCodeAt(0))
+      argText.split('').forEach(function(chr) {
+        ret.push(chr.charCodeAt(0));
       });
-      d += 1;
-      b += 2
-    }else {
-      if(c == "%".charCodeAt(0) && next == "s".charCodeAt(0)) {
-        a = a.concat(String_copy(arguments[d]));
-        d += 1;
-        b += 2
-      }else {
-        a.push(c);
-        b += 1
-      }
+      argIndex += 1;
+      textIndex += 2;
+    } else if (curr == '%'.charCodeAt(0) && next == 's'.charCodeAt(0)) {
+      ret = ret.concat(String_copy(arguments[argIndex]));
+      argIndex += 1;
+      textIndex += 2;
+    } else {
+      ret.push(curr);
+      textIndex += 1;
     }
   }
-  return Pointer_make(a, 0, ALLOC_STACK)
+  return Pointer_make(ret, 0, ALLOC_STACK); // NB: Stored on the stack
 }
-function Array_copy(b, d) {
-  return HEAP.slice(b, b + d)
+
+// Copies a list of num items on the HEAP into a
+// a normal JavaScript array of numbers
+function Array_copy(ptr, num) {
+  // XXX hardcoded ptr impl
+  return HEAP.slice(ptr, ptr+num);
 }
-function String_copy(b, d) {
-  return Array_copy(b, _strlen(b)).concat(d ? [0] : [])
+
+// Copies a C-style string, terminated by a zero, from the HEAP into
+// a normal JavaScript array of numbers
+function String_copy(ptr, addZero) {
+  // XXX hardcoded ptr impl
+  return Array_copy(ptr, _strlen(ptr)).concat(addZero ? [0] : []);
 }
-function _atoi(b) {
-  return Math.floor(Number(Pointer_stringify(b)))
+
+// stdlib.h
+
+// Get a pointer, return int value of the string it points to
+function _atoi(s) {
+  return Math.floor(Number(Pointer_stringify(s)));
 }
-function _llvm_memcpy_i32(b, d, a) {
-  for(var c = 0;c < a;c++) {
-    HEAP[b + c] = HEAP[d + c]
+
+function _llvm_memcpy_i32(dest, src, num, idunno) {
+// XXX hardcoded ptr impl
+  for (var i = 0; i < num; i++) {
+    HEAP[dest + i] = HEAP[src + i];
   }
+//  dest = Pointer_niceify(dest);
+//  src = Pointer_niceify(src);
+//  dest.slab = src.slab.slice(src.pos);
 }
 _llvm_memcpy_i64 = _llvm_memcpy_i32;
-PRINTBUFFER = "";
-function __print__(b) {
-  for(PRINTBUFFER += b;(b = PRINTBUFFER.indexOf("\n")) != -1;) {
-    print(PRINTBUFFER.substr(0, b));
-    PRINTBUFFER = PRINTBUFFER.substr(b + 1)
+
+// Tools
+
+PRINTBUFFER = '';
+function __print__(text) {
+  // We print only when we see a '\n', as console JS engines always add
+  // one anyhow.
+  PRINTBUFFER = PRINTBUFFER + text;
+  var endIndex;
+  while ((endIndex = PRINTBUFFER.indexOf('\n')) != -1) {
+    print(PRINTBUFFER.substr(0, endIndex));
+    PRINTBUFFER = PRINTBUFFER.substr(endIndex + 1);
   }
 }
-function jrint(b, d) {
-  if(d) {
-    b += " : "
-  }else {
-    d = b;
-    b = ""
-  }
-  print(b + JSON.stringify(d))
+
+function jrint(label, obj) { // XXX manual debugging
+  if (!obj) {
+    obj = label;
+    label = '';
+  } else
+    label = label + ' : ';
+  print(label + JSON.stringify(obj));
 }
-function intArrayFromString(b) {
-  for(var d = [], a = 0;a < b.length;) {
-    d.push(b.charCodeAt(a));
-    a += 1
+
+// This processes a 'normal' string into a C-line array of numbers.
+// For LLVM-originating strings, see parser.js:parseLLVMString function
+function intArrayFromString(stringy) {
+  var ret = [];
+  var t;
+  var i = 0;
+  while (i < stringy.length) {
+    ret.push(stringy.charCodeAt(i));
+    i = i + 1;
   }
-  d.push(0);
-  return d
+  ret.push(0);
+  return ret;
 }
-function unSign(b, d) {
-  if(b >= 0) {
-    return b
-  }
-  return 2 * Math.abs(1 << d - 1) + b
+
+// Converts a value we have as signed, into an unsigned value. For
+// example, -1 in int32 would be a very large number as unsigned.
+function unSign(value, bits) {
+  if (value >= 0) return value;
+  return 2*Math.abs(1 << (bits-1)) + value;
 }
-var _0___FLATTENER = [0, 1], _struct__1__pthread_mutex_s___FLATTENER = [0, 1, 2, 3, 4, 5], _struct_SDL_BlitMap___FLATTENER = [], _struct_SDL_Color___FLATTENER = [0, 1, 2, 3], _struct_SDL_Palette___FLATTENER = [0, 1], _struct_SDL_PixelFormat___FLATTENER = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16], _struct_SDL_Rect___FLATTENER = [0, 1, 2, 3], _struct_SDL_Surface___FLATTENER = [0, 1, 2, 3, 4, 5, 6, 7, 8, 12, 13, 14, 15, 16], _struct___pthread_slist_t___FLATTENER = [0], _struct_basis_t___FLATTENER = 
-[0, 3, 6], _struct_hit_t___FLATTENER = [0, 3], _struct_node_t___FLATTENER = [0, 4, 8], _struct_private_hwdata___FLATTENER = [], _struct_ray_t___FLATTENER = [0, 3], _struct_sphere_t___FLATTENER = [0, 3], __struct_std__ios_base__Init____FLATTENER = [0], _struct_v_t___FLATTENER = [0, 1, 2], _union__0__45___FLATTENER = [0], _union_pthread_attr_t___FLATTENER = [0, 1], _union_pthread_mutex_t___FLATTENER = [0], _union_pthread_mutexattr_t___FLATTENER = [0];
-this.__defineGetter__("_screen", function() {
-  delete _screen;
-  return _screen = Pointer_make([0], 0, ALLOC_STATIC)
-});
-this.__defineGetter__("__ZStL8__ioinit", function() {
-  delete __ZStL8__ioinit;
-  return __ZStL8__ioinit = Pointer_make([0], 0, ALLOC_STATIC)
-});
-var ___dso_handle = 0;
-this.__defineGetter__("__ZL5light", function() {
-  delete __ZL5light;
-  return __ZL5light = Pointer_make([0, 0, 0], 0, ALLOC_STATIC)
-});
-this.__defineGetter__("__ZL4pool", function() {
-  delete __ZL4pool;
-  return __ZL4pool = Pointer_make([0], 0, ALLOC_STATIC)
-});
-this.__defineGetter__("__ZL3end", function() {
-  delete __ZL3end;
-  return __ZL3end = Pointer_make([0], 0, ALLOC_STATIC)
-});
-this.__defineGetter__("__ZL4grid", function() {
-  delete __ZL4grid;
-  return __ZL4grid = Pointer_make([[-1, -0.3333333333333333], [0.3333333333333333, -1], [-0.3333333333333333, 1], [1, 0.3333333333333333]], 0, ALLOC_STATIC)
-});
+
+// === Body ===
+
+function stackAlloc(size) { var ret = STACKTOP; STACKTOP += size; return ret; }
+function staticAlloc(size) { var ret = STATICTOP; STATICTOP += size; return ret; }
+
+var _0___FLATTENER = [0,1];
+var _struct__1__pthread_mutex_s___FLATTENER = [0,1,2,3,4,5];
+var _struct_SDL_BlitMap___FLATTENER = [];
+var _struct_SDL_Color___FLATTENER = [0,1,2,3];
+var _struct_SDL_Palette___FLATTENER = [0,1];
+var _struct_SDL_PixelFormat___FLATTENER = [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16];
+var _struct_SDL_Rect___FLATTENER = [0,1,2,3];
+var _struct_SDL_Surface___FLATTENER = [0,1,2,3,4,5,6,7,8,12,13,14,15,16];
+var _struct___pthread_slist_t___FLATTENER = [0];
+var _struct_basis_t___FLATTENER = [0,3,6];
+var _struct_hit_t___FLATTENER = [0,3];
+var _struct_node_t___FLATTENER = [0,4,8];
+var _struct_private_hwdata___FLATTENER = [];
+var _struct_ray_t___FLATTENER = [0,3];
+var _struct_sphere_t___FLATTENER = [0,3];
+var __struct_std__ios_base__Init____FLATTENER = [0];
+var _struct_v_t___FLATTENER = [0,1,2];
+var _union__0__45___FLATTENER = [0];
+var _union_pthread_attr_t___FLATTENER = [0,1];
+var _union_pthread_mutex_t___FLATTENER = [0];
+var _union_pthread_mutexattr_t___FLATTENER = [0];
+this.__defineGetter__("_screen", function() { delete _screen; _screen = Pointer_make([0], 0, ALLOC_STATIC); return _screen });
+this.__defineGetter__("__ZStL8__ioinit", function() { delete __ZStL8__ioinit; __ZStL8__ioinit = Pointer_make([0], 0, ALLOC_STATIC); return __ZStL8__ioinit });
+var ___dso_handle = 0; /* external value? */
+this.__defineGetter__("__ZL5light", function() { delete __ZL5light; __ZL5light = Pointer_make([0,0,0], 0, ALLOC_STATIC); return __ZL5light });
+this.__defineGetter__("__ZL4pool", function() { delete __ZL4pool; __ZL4pool = Pointer_make([0], 0, ALLOC_STATIC); return __ZL4pool });
+this.__defineGetter__("__ZL3end", function() { delete __ZL3end; __ZL3end = Pointer_make([0], 0, ALLOC_STATIC); return __ZL3end });
+this.__defineGetter__("__ZL4grid", function() { delete __ZL4grid; __ZL4grid = Pointer_make([ [-1.000000e+00, -0.3333333333333333], [0.3333333333333333, -1.000000e+00], [-0.3333333333333333, 1.000000e+00], [1.000000e+00, 0.3333333333333333] ], 0, ALLOC_STATIC); return __ZL4grid });
+
 __globalConstructor__ = function() {
-  __GLOBAL__I_screen()
-};
-_sqrt = function(b) {
-  return Math.sqrt(b)
-};
-__ZNSt8ios_base4InitC1Ev = function() {
-  __ZSt4cout = 1;
-  __ZSt4cerr = 2
-};
-___cxa_atexit = function(b) {
-  __ATEXIT__.push(b)
-};
-__ZNSt8ios_base4InitD1Ev = function() {
-  __ZSt4cout = 1;
-  __ZSt4cerr = 2
-};
-_cos = function(b) {
-  return Math.cos(b)
-};
-_sin = function(b) {
-  return Math.sin(b)
-};
-_SDL_LockSurface = function(b) {
-  var d = SDL_SURFACES[b];
-  d.image = d.ctx.getImageData(0, 0, d.width, d.height);
-  for(var a = d.image.data.length, c = 0;c < a;c++) {
-    HEAP[d.buffer + c] = d.image.data[c]
+  __GLOBAL__I_screen();
+}
+
+
+_sqrt = function (x) { return Math.sqrt(x) }
+__ZNSt8ios_base4InitC1Ev = function () {
+    // need valid 'file descriptors'
+    __ZSt4cout = 1;
+    __ZSt4cerr = 2;
+  }
+___cxa_atexit = function (func) {
+    __ATEXIT__.push(func);
+  }
+__ZNSt8ios_base4InitD1Ev = function () {
+    // need valid 'file descriptors'
+    __ZSt4cout = 1;
+    __ZSt4cerr = 2;
+  }
+_cos = function (x) { return Math.cos(x) }
+_sin = function (x) { return Math.sin(x) }
+_SDL_LockSurface = function (surf) {
+    var surfData = SDL_SURFACES[surf];
+    surfData.image = surfData.ctx.getImageData(0, 0, surfData.width, surfData.height);
+    // Copy pixel data to somewhere accessible to 'C/C++'
+    var num = surfData.image.data.length;
+    for (var i = 0; i < num; i++) {
+      HEAP[surfData.buffer+i] = surfData.image.data[i];
+    }
+    // Mark in C/C++-accessible SDL structure
+    // SDL_Surface has the following fields: Uint32 flags, SDL_PixelFormat *format; int w, h; Uint16 pitch; void *pixels; ...
+    // So we have fields all of the same size, and 5 of them before us.
+    HEAP[surf + 5*1] = surfData.buffer;
+  }
+_SDL_UnlockSurface = function (surf) {
+    var surfData = SDL_SURFACES[surf];
+    // Copy pixel data to image
+    var num = surfData.image.data.length;
+    for (var i = 0; i < num; i++) {
+      surfData.image.data[i] = HEAP[surfData.buffer+i];
+    }
+    for (var i = 0; i < num/4; i++) {
+      surfData.image.data[i*4+3] = 255; // opacity, as canvases blend alpha
+    }
+    // Copy to canvas
+    surfData.ctx.putImageData(surfData.image, 0, 0);
+    // Cleanup
+    surfData.image = null;
+  }
+_SDL_Flip = function (surf) {
+    // We actually do this in Unlock...
+  }
+// stub for _atoi
+// stub for __Znaj
+_SDL_Init = function (what) {
+    SDL_SURFACES = {};
+    return 1;
   }
-  HEAP[b + 5] = d.buffer
-};
-_SDL_UnlockSurface = function(b) {
-  b = SDL_SURFACES[b];
-  for(var d = b.image.data.length, a = 0;a < d;a++) {
-    b.image.data[a] = HEAP[b.buffer + a]
+_SDL_SetVideoMode = function (width, height, depth, flags, canvas) {
+  //                                                      ^^^^^^ a 'canvas' parameter is added here; supply a canvas from JS there
+    var surf = _malloc(14*1); // SDL_Surface has 14 fields of quantum size
+    SDL_SURFACES[surf] = {
+      width: width,
+      height: height,
+      canvas: canvas,
+      ctx: canvas.getContext('2d'),
+      surf: surf,
+      buffer: _malloc(width*height*4),
+    };
+    return surf;
   }
-  for(a = 0;a < d / 4;a++) {
-    b.image.data[a * 4 + 3] = 255
+_SDL_Delay = function (delay) {
+    // No can do... unless you were a generator...
   }
-  b.ctx.putImageData(b.image, 0, 0);
-  b.image = null
-};
-_SDL_Flip = function() {
-};
-_SDL_Init = function() {
-  SDL_SURFACES = {};
-  return 1
-};
-_SDL_SetVideoMode = function(b, d, a, c, e) {
-  a = _malloc(14);
-  SDL_SURFACES[a] = {width:b, height:d, canvas:e, ctx:e.getContext("2d"), surf:a, buffer:_malloc(b * d * 4)};
-  return a
-};
-_SDL_Delay = function() {
-};
-_SDL_Quit = function() {
-  return 1
-};
+_SDL_Quit = function () {
+    return 1;
+  }
+// stub for i32
+// stub for i8_
+// stub for i32
+// stub for i32
+// stub for i32
+// stub for i32
+// stub for i32
+// stub for i32
+// stub for i32
+// stub for i32
+// stub for i32
+// stub for i32
+// stub for i32
+// stub for i32
+
+
 function __GLOBAL__I_screen() {
-  stackEnter();
+  STACK_STACK.push(STACKTOP);
+  var __label__;
   __Z41__static_initialization_and_destruction_0ii(1, 65535);
-  stackExit()
+  __label__ = 0; /* _return */ 
+  STACKTOP = STACK_STACK.pop();
+  return;
 }
-function __ZnwjPv(b, d) {
-  stackEnter();
-  var a = Pointer_make([0], 0, ALLOC_STACK), c = Pointer_make([0], 0, ALLOC_STACK), e = Pointer_make([0], 0, ALLOC_STACK);
-  HEAP[a] = d;
-  HEAP[e] = HEAP[a];
-  HEAP[e] = HEAP[e];
-  HEAP[c] = HEAP[e];
-  a = HEAP[c];
-  stackExit();
-  return a
+
+
+function __ZnwjPv(_unnamed_arg, ___p) {
+  STACK_STACK.push(STACKTOP);
+  var __label__;
+  var _unnamed_arg_addr;
+  var ___p_addr = STACKTOP; STACKTOP += 1;
+  var _retval = STACKTOP; STACKTOP += 1;
+  var _0 = STACKTOP; STACKTOP += 1;
+  var __alloca_point_ = 0;
+  _unnamed_arg_addr = _unnamed_arg;
+  HEAP[___p_addr] = ___p;
+  var _1 = HEAP[___p_addr];
+  HEAP[_0] = _1;
+  var _2 = HEAP[_0];
+  HEAP[_0] = _2;
+  var _3 = HEAP[_0];
+  HEAP[_retval] = _3;
+  __label__ = 0; /* _return */ 
+  var _retval1 = HEAP[_retval];
+  STACKTOP = STACK_STACK.pop();
+  return _retval1;
 }
-function __ZN3v_tC1Ev(b) {
-  stackEnter();
-  var d = Pointer_make([0], 0, ALLOC_STACK);
-  HEAP[d] = b;
-  stackExit()
+
+
+function __ZN3v_tC1Ev(_this) {
+  STACK_STACK.push(STACKTOP);
+  var __label__;
+  var _this_addr = STACKTOP; STACKTOP += 1;
+  var __alloca_point_ = 0;
+  HEAP[_this_addr] = _this;
+  __label__ = 0; /* _return */ 
+  STACKTOP = STACK_STACK.pop();
+  return;
 }
-function __ZNK3v_tplERKS_(b, d, a) {
-  stackEnter();
-  var c = Pointer_make([0], 0, ALLOC_STACK), e = Pointer_make([0], 0, ALLOC_STACK);
-  HEAP[c] = d;
-  HEAP[e] = a;
-  __ZN3v_tC1Eddd(b, HEAP[0 + HEAP[c] + 0] + HEAP[0 + HEAP[e] + 0], HEAP[0 + HEAP[c] + 1] + HEAP[0 + HEAP[e] + 1], HEAP[0 + HEAP[c] + 2] + HEAP[0 + HEAP[e] + 2]);
-  stackExit()
+
+
+function __ZNK3v_tplERKS_(_agg_result, _this, _v) {
+  STACK_STACK.push(STACKTOP);
+  var __label__;
+  var _this_addr = STACKTOP; STACKTOP += 1;
+  var _v_addr = STACKTOP; STACKTOP += 1;
+  var __alloca_point_ = 0;
+  HEAP[_this_addr] = _this;
+  HEAP[_v_addr] = _v;
+  var _0 = HEAP[_this_addr];
+  var _2 = HEAP[0 + _0+2*1];
+  var _3 = HEAP[_v_addr];
+  var _5 = HEAP[0 + _3+2*1];
+  var _6 = _2 + _5;
+  var _7 = HEAP[_this_addr];
+  var _9 = HEAP[0 + _7+1*1];
+  var _10 = HEAP[_v_addr];
+  var _12 = HEAP[0 + _10+1*1];
+  var _13 = _9 + _12;
+  var _14 = HEAP[_this_addr];
+  var _16 = HEAP[0 + _14+0*1];
+  var _17 = HEAP[_v_addr];
+  var _19 = HEAP[0 + _17+0*1];
+  var _20 = _16 + _19;
+  __ZN3v_tC1Eddd(_agg_result, _20, _13, _6);
+  __label__ = 0; /* _return */ 
+  STACKTOP = STACK_STACK.pop();
+  return;
 }
-function __ZNK3v_tmiERKS_(b, d, a) {
-  stackEnter();
-  var c = Pointer_make([0], 0, ALLOC_STACK), e = Pointer_make([0], 0, ALLOC_STACK);
-  HEAP[c] = d;
-  HEAP[e] = a;
-  __ZN3v_tC1Eddd(b, HEAP[0 + HEAP[c] + 0] - HEAP[0 + HEAP[e] + 0], HEAP[0 + HEAP[c] + 1] - HEAP[0 + HEAP[e] + 1], HEAP[0 + HEAP[c] + 2] - HEAP[0 + HEAP[e] + 2]);
-  stackExit()
+
+
+function __ZNK3v_tmiERKS_(_agg_result, _this, _v) {
+  STACK_STACK.push(STACKTOP);
+  var __label__;
+  var _this_addr = STACKTOP; STACKTOP += 1;
+  var _v_addr = STACKTOP; STACKTOP += 1;
+  var __alloca_point_ = 0;
+  HEAP[_this_addr] = _this;
+  HEAP[_v_addr] = _v;
+  var _0 = HEAP[_this_addr];
+  var _2 = HEAP[0 + _0+2*1];
+  var _3 = HEAP[_v_addr];
+  var _5 = HEAP[0 + _3+2*1];
+  var _6 = _2 - _5;
+  var _7 = HEAP[_this_addr];
+  var _9 = HEAP[0 + _7+1*1];
+  var _10 = HEAP[_v_addr];
+  var _12 = HEAP[0 + _10+1*1];
+  var _13 = _9 - _12;
+  var _14 = HEAP[_this_addr];
+  var _16 = HEAP[0 + _14+0*1];
+  var _17 = HEAP[_v_addr];
+  var _19 = HEAP[0 + _17+0*1];
+  var _20 = _16 - _19;
+  __ZN3v_tC1Eddd(_agg_result, _20, _13, _6);
+  __label__ = 0; /* _return */ 
+  STACKTOP = STACK_STACK.pop();
+  return;
 }
-function __ZNK3v_tngEv(b, d) {
-  stackEnter();
-  var a = Pointer_make([0], 0, ALLOC_STACK);
-  HEAP[a] = d;
-  __ZN3v_tC1Eddd(b, 0 - HEAP[0 + HEAP[a] + 0], 0 - HEAP[0 + HEAP[a] + 1], 0 - HEAP[0 + HEAP[a] + 2]);
-  stackExit()
+
+
+function __ZNK3v_tngEv(_agg_result, _this) {
+  STACK_STACK.push(STACKTOP);
+  var __label__;
+  var _this_addr = STACKTOP; STACKTOP += 1;
+  var __alloca_point_ = 0;
+  HEAP[_this_addr] = _this;
+  var _0 = HEAP[_this_addr];
+  var _2 = HEAP[0 + _0+2*1];
+  var _3 = -0.000000e+00 - _2;
+  var _4 = HEAP[_this_addr];
+  var _6 = HEAP[0 + _4+1*1];
+  var _7 = -0.000000e+00 - _6;
+  var _8 = HEAP[_this_addr];
+  var _10 = HEAP[0 + _8+0*1];
+  var _11 = -0.000000e+00 - _10;
+  __ZN3v_tC1Eddd(_agg_result, _11, _7, _3);
+  __label__ = 0; /* _return */ 
+  STACKTOP = STACK_STACK.pop();
+  return;
 }
-function __ZNK3v_tmlEd(b, d, a) {
-  stackEnter();
-  var c = Pointer_make([0], 0, ALLOC_STACK);
-  HEAP[c] = d;
-  __ZN3v_tC1Eddd(b, HEAP[0 + HEAP[c] + 0] * a, HEAP[0 + HEAP[c] + 1] * a, HEAP[0 + HEAP[c] + 2] * a);
-  stackExit()
+
+
+function __ZNK3v_tmlEd(_agg_result, _this, _d) {
+  STACK_STACK.push(STACKTOP);
+  var __label__;
+  var _this_addr = STACKTOP; STACKTOP += 1;
+  var _d_addr;
+  var __alloca_point_ = 0;
+  HEAP[_this_addr] = _this;
+  _d_addr = _d;
+  var _0 = HEAP[_this_addr];
+  var _2 = HEAP[0 + _0+2*1];
+  var _3 = _d_addr;
+  var _4 = _2 * _3;
+  var _5 = HEAP[_this_addr];
+  var _7 = HEAP[0 + _5+1*1];
+  var _8 = _d_addr;
+  var _9 = _7 * _8;
+  var _10 = HEAP[_this_addr];
+  var _12 = HEAP[0 + _10+0*1];
+  var _13 = _d_addr;
+  var _14 = _12 * _13;
+  __ZN3v_tC1Eddd(_agg_result, _14, _9, _4);
+  __label__ = 0; /* _return */ 
+  STACKTOP = STACK_STACK.pop();
+  return;
 }
-function __ZNK3v_t5crossERKS_(b, d, a) {
-  stackEnter();
-  var c = Pointer_make([0], 0, ALLOC_STACK), e = Pointer_make([0], 0, ALLOC_STACK);
-  HEAP[c] = d;
-  HEAP[e] = a;
-  __ZN3v_tC1Eddd(b, HEAP[0 + HEAP[c] + 1] * HEAP[0 + HEAP[e] + 2] - HEAP[0 + HEAP[c] + 2] * HEAP[0 + HEAP[e] + 1], HEAP[0 + HEAP[c] + 2] * HEAP[0 + HEAP[e] + 0] - HEAP[0 + HEAP[c] + 0] * HEAP[0 + HEAP[e] + 2], HEAP[0 + HEAP[c] + 0] * HEAP[0 + HEAP[e] + 1] - HEAP[0 + HEAP[c] + 1] * HEAP[0 + HEAP[e] + 0]);
-  stackExit()
+
+
+function __ZNK3v_t5crossERKS_(_agg_result, _this, _v) {
+  STACK_STACK.push(STACKTOP);
+  var __label__;
+  var _this_addr = STACKTOP; STACKTOP += 1;
+  var _v_addr = STACKTOP; STACKTOP += 1;
+  var __alloca_point_ = 0;
+  HEAP[_this_addr] = _this;
+  HEAP[_v_addr] = _v;
+  var _0 = HEAP[_this_addr];
+  var _2 = HEAP[0 + _0+0*1];
+  var _3 = HEAP[_v_addr];
+  var _5 = HEAP[0 + _3+1*1];
+  var _6 = _2 * _5;
+  var _7 = HEAP[_this_addr];
+  var _9 = HEAP[0 + _7+1*1];
+  var _10 = HEAP[_v_addr];
+  var _12 = HEAP[0 + _10+0*1];
+  var _13 = _9 * _12;
+  var _14 = _6 - _13;
+  var _15 = HEAP[_this_addr];
+  var _17 = HEAP[0 + _15+2*1];
+  var _18 = HEAP[_v_addr];
+  var _20 = HEAP[0 + _18+0*1];
+  var _21 = _17 * _20;
+  var _22 = HEAP[_this_addr];
+  var _24 = HEAP[0 + _22+0*1];
+  var _25 = HEAP[_v_addr];
+  var _27 = HEAP[0 + _25+2*1];
+  var _28 = _24 * _27;
+  var _29 = _21 - _28;
+  var _30 = HEAP[_this_addr];
+  var _32 = HEAP[0 + _30+1*1];
+  var _33 = HEAP[_v_addr];
+  var _35 = HEAP[0 + _33+2*1];
+  var _36 = _32 * _35;
+  var _37 = HEAP[_this_addr];
+  var _39 = HEAP[0 + _37+2*1];
+  var _40 = HEAP[_v_addr];
+  var _42 = HEAP[0 + _40+1*1];
+  var _43 = _39 * _42;
+  var _44 = _36 - _43;
+  __ZN3v_tC1Eddd(_agg_result, _44, _29, _14);
+  __label__ = 0; /* _return */ 
+  STACKTOP = STACK_STACK.pop();
+  return;
 }
-function __ZNK3v_t3dotERKS_(b, d) {
-  stackEnter();
-  var a = Pointer_make([0], 0, ALLOC_STACK), c = Pointer_make([0], 0, ALLOC_STACK);
-  HEAP[a] = b;
-  HEAP[c] = d;
-  a = HEAP[0 + HEAP[a] + 0] * HEAP[0 + HEAP[c] + 0] + HEAP[0 + HEAP[a] + 1] * HEAP[0 + HEAP[c] + 1] + HEAP[0 + HEAP[a] + 2] * HEAP[0 + HEAP[c] + 2];
-  stackExit();
-  return a
+
+
+function __ZNK3v_t3dotERKS_(_this, _v) {
+  STACK_STACK.push(STACKTOP);
+  var __label__;
+  var _this_addr = STACKTOP; STACKTOP += 1;
+  var _v_addr = STACKTOP; STACKTOP += 1;
+  var _retval;
+  var _0;
+  var __alloca_point_ = 0;
+  HEAP[_this_addr] = _this;
+  HEAP[_v_addr] = _v;
+  var _1 = HEAP[_this_addr];
+  var _3 = HEAP[0 + _1+0*1];
+  var _4 = HEAP[_v_addr];
+  var _6 = HEAP[0 + _4+0*1];
+  var _7 = _3 * _6;
+  var _8 = HEAP[_this_addr];
+  var _10 = HEAP[0 + _8+1*1];
+  var _11 = HEAP[_v_addr];
+  var _13 = HEAP[0 + _11+1*1];
+  var _14 = _10 * _13;
+  var _15 = _7 + _14;
+  var _16 = HEAP[_this_addr];
+  var _18 = HEAP[0 + _16+2*1];
+  var _19 = HEAP[_v_addr];
+  var _21 = HEAP[0 + _19+2*1];
+  var _22 = _18 * _21;
+  _0 = _15 + _22;
+  _retval = _0;
+  __label__ = 0; /* _return */ 
+  var _retval1 = _retval;
+  STACKTOP = STACK_STACK.pop();
+  return _retval1;
 }
-function __ZSt3maxIdERKT_S2_S2_(b, d) {
-  stackEnter();
-  var a, c = Pointer_make([0], 0, ALLOC_STACK), e = Pointer_make([0], 0, ALLOC_STACK), f = Pointer_make([0], 0, ALLOC_STACK), g = Pointer_make([0], 0, ALLOC_STACK);
-  HEAP[c] = b;
-  HEAP[e] = d;
-  a = 0 + (HEAP[HEAP[c]] < HEAP[HEAP[e]]) ? 1 : 2;
-  a:do {
-    if(a == 1) {
-      HEAP[g] = HEAP[e];
-      break a
-    }else {
-      if(a == 2) {
-        HEAP[g] = HEAP[c];
-        break a
-      }
+
+
+function __ZSt3maxIdERKT_S2_S2_(___a, ___b) {
+  STACK_STACK.push(STACKTOP);
+  var __label__;
+  var ___a_addr = STACKTOP; STACKTOP += 1;
+  var ___b_addr = STACKTOP; STACKTOP += 1;
+  var _retval = STACKTOP; STACKTOP += 1;
+  var _0 = STACKTOP; STACKTOP += 1;
+  var __alloca_point_ = 0;
+  HEAP[___a_addr] = ___a;
+  HEAP[___b_addr] = ___b;
+  var _1 = HEAP[___a_addr];
+  var _2 = HEAP[_1];
+  var _3 = HEAP[___b_addr];
+  var _4 = HEAP[_3];
+  var _5 = 0+(_2 < _4);
+  if (_5) { __label__ = 1; /* _bb */  } else { __label__ = 2; /* _bb1 */  }
+  _bb: do { 
+    if (__label__ == 1) {
+      var _6 = HEAP[___b_addr];
+      HEAP[_0] = _6;
+      __label__ = 3; /* _bb2 */ break _bb;
+    }
+    else   if (__label__ == 2) {
+      var _7 = HEAP[___a_addr];
+      HEAP[_0] = _7;
+      __label__ = 3; /* _bb2 */ break _bb;
     }
-  }while(0);
-  HEAP[f] = HEAP[g];
-  a = HEAP[f];
-  stackExit();
-  return a
+  } while(0);
+  var _8 = HEAP[_0];
+  HEAP[_retval] = _8;
+  __label__ = 0; /* _return */ 
+  var _retval3 = HEAP[_retval];
+  STACKTOP = STACK_STACK.pop();
+  return _retval3;
 }
-function __ZSt3maxIiERKT_S2_S2_(b, d) {
-  stackEnter();
-  var a, c = Pointer_make([0], 0, ALLOC_STACK), e = Pointer_make([0], 0, ALLOC_STACK), f = Pointer_make([0], 0, ALLOC_STACK), g = Pointer_make([0], 0, ALLOC_STACK);
-  HEAP[c] = b;
-  HEAP[e] = d;
-  a = 0 + (HEAP[HEAP[c]] < HEAP[HEAP[e]]) ? 1 : 2;
-  a:do {
-    if(a == 1) {
-      HEAP[g] = HEAP[e];
-      break a
-    }else {
-      if(a == 2) {
-        HEAP[g] = HEAP[c];
-        break a
-      }
+
+
+function __ZSt3maxIiERKT_S2_S2_(___a, ___b) {
+  STACK_STACK.push(STACKTOP);
+  var __label__;
+  var ___a_addr = STACKTOP; STACKTOP += 1;
+  var ___b_addr = STACKTOP; STACKTOP += 1;
+  var _retval = STACKTOP; STACKTOP += 1;
+  var _0 = STACKTOP; STACKTOP += 1;
+  var __alloca_point_ = 0;
+  HEAP[___a_addr] = ___a;
+  HEAP[___b_addr] = ___b;
+  var _1 = HEAP[___a_addr];
+  var _2 = HEAP[_1];
+  var _3 = HEAP[___b_addr];
+  var _4 = HEAP[_3];
+  var _5 = 0+(_2 < _4);
+  if (_5) { __label__ = 1; /* _bb */  } else { __label__ = 2; /* _bb1 */  }
+  _bb: do { 
+    if (__label__ == 1) {
+      var _6 = HEAP[___b_addr];
+      HEAP[_0] = _6;
+      __label__ = 3; /* _bb2 */ break _bb;
+    }
+    else   if (__label__ == 2) {
+      var _7 = HEAP[___a_addr];
+      HEAP[_0] = _7;
+      __label__ = 3; /* _bb2 */ break _bb;
     }
-  }while(0);
-  HEAP[f] = HEAP[g];
-  a = HEAP[f];
-  stackExit();
-  return a
+  } while(0);
+  var _8 = HEAP[_0];
+  HEAP[_retval] = _8;
+  __label__ = 0; /* _return */ 
+  var _retval3 = HEAP[_retval];
+  STACKTOP = STACK_STACK.pop();
+  return _retval3;
 }
-function ___tcf_0(b) {
-  stackEnter();
-  var d = Pointer_make([0], 0, ALLOC_STACK);
-  HEAP[d] = b;
+
+
+function ___tcf_0(_unnamed_arg) {
+  STACK_STACK.push(STACKTOP);
+  var __label__;
+  var _unnamed_arg_addr = STACKTOP; STACKTOP += 1;
+  var __alloca_point_ = 0;
+  HEAP[_unnamed_arg_addr] = _unnamed_arg;
   __ZNSt8ios_base4InitD1Ev(__ZStL8__ioinit);
-  stackExit()
+  __label__ = 0; /* _return */ 
+  STACKTOP = STACK_STACK.pop();
+  return;
 }
-function __ZN3v_tC1Eddd(b, d, a, c) {
-  stackEnter();
-  var e = Pointer_make([0], 0, ALLOC_STACK);
-  HEAP[e] = b;
-  HEAP[HEAP[e] + 0] = d;
-  HEAP[HEAP[e] + 1] = a;
-  HEAP[HEAP[e] + 2] = c;
-  stackExit()
+
+
+function __ZN3v_tC1Eddd(_this, _a, _b, _c) {
+  STACK_STACK.push(STACKTOP);
+  var __label__;
+  var _this_addr = STACKTOP; STACKTOP += 1;
+  var _a_addr;
+  var _b_addr;
+  var _c_addr;
+  var __alloca_point_ = 0;
+  HEAP[_this_addr] = _this;
+  _a_addr = _a;
+  _b_addr = _b;
+  _c_addr = _c;
+  var _0 = HEAP[_this_addr];
+  var _1 = _0+0*1;
+  HEAP[_1] = _a_addr;
+  var _3 = HEAP[_this_addr];
+  var _4 = _3+1*1;
+  HEAP[_4] = _b_addr;
+  var _6 = HEAP[_this_addr];
+  var _7 = _6+2*1;
+  HEAP[_7] = _c_addr;
+  __label__ = 0; /* _return */ 
+  STACKTOP = STACK_STACK.pop();
+  return;
 }
-function __ZN5ray_tC1ERK3v_t(b, d) {
-  stackEnter();
-  var a = Pointer_make([0], 0, ALLOC_STACK), c = Pointer_make([0], 0, ALLOC_STACK);
-  HEAP[a] = b;
-  HEAP[c] = d;
-  var e = HEAP[a] + 0;
-  c = HEAP[c];
-  HEAP[e + 0] = HEAP[0 + c + 0];
-  HEAP[e + 1] = HEAP[0 + c + 1];
-  HEAP[e + 2] = HEAP[0 + c + 2];
-  __ZN3v_tC1Ev(HEAP[a] + 3);
-  stackExit()
+
+
+function __ZN5ray_tC1ERK3v_t(_this, _v) {
+  STACK_STACK.push(STACKTOP);
+  var __label__;
+  var _this_addr = STACKTOP; STACKTOP += 1;
+  var _v_addr = STACKTOP; STACKTOP += 1;
+  var __alloca_point_ = 0;
+  HEAP[_this_addr] = _this;
+  HEAP[_v_addr] = _v;
+  var _0 = HEAP[_this_addr];
+  var _1 = _0+0*3;
+  var _2 = HEAP[_v_addr];
+  var _3 = _1+0*1;
+  var _5 = HEAP[0 + _2+0*1];
+  HEAP[_3] = _5;
+  var _6 = _1+1*1;
+  var _8 = HEAP[0 + _2+1*1];
+  HEAP[_6] = _8;
+  var _9 = _1+2*1;
+  var _11 = HEAP[0 + _2+2*1];
+  HEAP[_9] = _11;
+  var _12 = HEAP[_this_addr];
+  var _13 = _12+1*3;
+  __ZN3v_tC1Ev(_13);
+  __label__ = 0; /* _return */ 
+  STACKTOP = STACK_STACK.pop();
+  return;
 }
-function __ZN5ray_tC1ERK3v_tS2_(b, d, a) {
-  stackEnter();
-  var c = Pointer_make([0], 0, ALLOC_STACK), e = Pointer_make([0], 0, ALLOC_STACK), f = Pointer_make([0], 0, ALLOC_STACK);
-  HEAP[c] = b;
-  HEAP[e] = d;
-  HEAP[f] = a;
-  b = HEAP[c] + 0;
-  e = HEAP[e];
-  HEAP[b + 0] = HEAP[0 + e + 0];
-  HEAP[b + 1] = HEAP[0 + e + 1];
-  HEAP[b + 2] = HEAP[0 + e + 2];
-  c = HEAP[c] + 3;
-  f = HEAP[f];
-  HEAP[c + 0] = HEAP[0 + f + 0];