aboutsummaryrefslogtreecommitdiff
path: root/demos/raytrace.js
diff options
context:
space:
mode:
Diffstat (limited to 'demos/raytrace.js')
-rw-r--r--demos/raytrace.js2025
1 files changed, 2025 insertions, 0 deletions
diff --git a/demos/raytrace.js b/demos/raytrace.js
new file mode 100644
index 00000000..ebc375d0
--- /dev/null
+++ b/demos/raytrace.js
@@ -0,0 +1,2025 @@
+arguments = ['3'] // 6!
+
+//====================
+// Auto-generated code
+//====================
+
+// === Auto-generated preamble library stuff ===
+
+function __globalConstructor__() {
+}
+
+var __THREW__ = false; // Used in checking for thrown exceptions.
+
+var __ATEXIT__ = [];
+
+var HEAP = [];
+var HEAPTOP = 0;
+Pointer_make(intArrayFromString('(null)')); // So printing %s of NULL gives '(null)'
+ // Also this ensures we leave 0 as an invalid address, 'NULL'
+
+
+
+START_TIME = Date.now();
+
+function abort(text) {
+ text = "ABORT: " + text;
+ print(text + "\n");
+// print((new Error).stack); // for stack traces
+ print("\n");
+ throw text;
+}
+
+function Pointer_niceify(ptr) {
+// XXX hardcoded ptr impl
+ return { slab: HEAP, pos: ptr };
+// if (!ptr.slab)
+// return { slab: ptr[0], pos: ptr[1] };
+// else
+// return ptr;
+}
+
+function Pointer_make(slab, pos) {
+ pos = pos ? pos : 0;
+// XXX hardcoded ptr impl
+ 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) }, []);
+ }
+ var slab = flatten(slab);
+ // Finalize
+ var ret = _malloc(Math.max(slab.length - pos, 1));
+ for (var i = 0; i < slab.length - pos; i++) {
+ HEAP[ret + i] = slab[pos + i];
+ }
+ return ret;
+// return { slab: slab, pos: pos ? pos : 0 };
+}
+
+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 ret;
+}
+
+function _malloc(size) {
+// XXX hardcoded ptr impl
+ size = Math.ceil(size/1)*1; // Allocate blocks of proper minimum size
+ // Also keeps HEAPTOP aligned
+ var ret = HEAPTOP;
+ HEAPTOP += size;
+ return ret;
+ // We don't actually do new Array(size) - memory is uninitialized anyhow
+// return Pointer_make([]);
+}
+
+// Mangled "new"s... need a heuristic for autogeneration...
+__Znwj = _malloc; // gcc
+__Znaj = _malloc; // gcc
+__Znam = _malloc; // clang
+__Znwm = _malloc; // clang
+
+function _free(ptr) {
+// XXX hardcoded ptr impl
+ // XXX TODO - actual implementation! Currently we leak it all
+
+ // Nothing needs to be done! But we mark the pointer
+ // as invalid. Note that we should do it for all other
+ // pointers of this slab too.
+// ptr.slab = null;
+// ptr[0] = null;
+}
+
+// Mangled "delete"s... need a heuristic for autogeneration...
+__ZdlPv = _free; // gcc
+__ZdaPv = _free; // gcc
+
+// stdio.h
+
+// C-style: we work on ints on the HEAP.
+function __formatString() {
+ 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', '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;
+ }
+ argText.split('').forEach(function(chr) {
+ ret.push(chr.charCodeAt(0));
+ });
+ 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(ret);
+}
+
+// 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);
+}
+
+// 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] : []);
+}
+
+// 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(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;
+
+// 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(label, obj) { // XXX manual debugging
+ if (!obj) {
+ obj = label;
+ label = '';
+ } else
+ label = label + ' : ';
+ print(label + JSON.stringify(obj));
+}
+
+// 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;
+ }
+ ret.push(0);
+ return ret;
+}
+
+// === Body ===
+
+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); return _screen });
+this.__defineGetter__("__ZStL8__ioinit", function() { delete __ZStL8__ioinit; __ZStL8__ioinit = Pointer_make([0], 0); return __ZStL8__ioinit });
+var ___dso_handle = 0; /* external value? */
+this.__defineGetter__("__ZL5light", function() { delete __ZL5light; __ZL5light = Pointer_make([0,0,0], 0); return __ZL5light });
+this.__defineGetter__("__ZL4pool", function() { delete __ZL4pool; __ZL4pool = Pointer_make([0], 0); return __ZL4pool });
+this.__defineGetter__("__ZL3end", function() { delete __ZL3end; __ZL3end = Pointer_make([0], 0); 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); return __ZL4grid });
+
+__globalConstructor__ = function() {
+ __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;
+ surfData.buffer = _malloc(num);
+ 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;
+ _free(surfData.buffer);
+ surfData.buffer = 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;
+ }
+_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,
+ };
+ return surf;
+ }
+_SDL_Delay = function (delay) {
+ // No can do... unless you were a generator...
+ }
+_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() {
+ var __label__ = 18; /* _entry */
+ while(1) switch(__label__) {
+ case 18: // _entry
+ __Z41__static_initialization_and_destruction_0ii(1, 65535);
+ __label__ = 0; break;
+ case 0: // _return
+ return;
+ }
+}
+
+
+function __ZnwjPv(_unnamed_arg, ___p) {
+ var __label__ = 18; /* _entry */
+ while(1) switch(__label__) {
+ case 18: // _entry
+ var _unnamed_arg_addr;
+ var ___p_addr = Pointer_make([0], 0);
+ var _retval = Pointer_make([0], 0);
+ var _0 = Pointer_make([0], 0);
+ 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; break;
+ case 0: // _return
+ var _retval1 = HEAP[_retval];
+ return _retval1;
+ }
+}
+
+
+function __ZN3v_tC1Ev(_this) {
+ var __label__ = 18; /* _entry */
+ while(1) switch(__label__) {
+ case 18: // _entry
+ var _this_addr = Pointer_make([0], 0);
+ var __alloca_point_ = 0;
+ HEAP[_this_addr] = _this;
+ __label__ = 0; break;
+ case 0: // _return
+ return;
+ }
+}
+
+
+function __ZNK3v_tplERKS_(_agg_result, _this, _v) {
+ var __label__ = 18; /* _entry */
+ while(1) switch(__label__) {
+ case 18: // _entry
+ var _this_addr = Pointer_make([0], 0);
+ var _v_addr = Pointer_make([0], 0);
+ 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; break;
+ case 0: // _return
+ return;
+ }
+}
+
+
+function __ZNK3v_tmiERKS_(_agg_result, _this, _v) {
+ var __label__ = 18; /* _entry */
+ while(1) switch(__label__) {
+ case 18: // _entry
+ var _this_addr = Pointer_make([0], 0);
+ var _v_addr = Pointer_make([0], 0);
+ 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; break;
+ case 0: // _return
+ return;
+ }
+}
+
+
+function __ZNK3v_tngEv(_agg_result, _this) {
+ var __label__ = 18; /* _entry */
+ while(1) switch(__label__) {
+ case 18: // _entry
+ var _this_addr = Pointer_make([0], 0);
+ 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; break;
+ case 0: // _return
+ return;
+ }
+}
+
+
+function __ZNK3v_tmlEd(_agg_result, _this, _d) {
+ var __label__ = 18; /* _entry */
+ while(1) switch(__label__) {
+ case 18: // _entry
+ var _this_addr = Pointer_make([0], 0);
+ 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 _4 = _2 * _d_addr;
+ var _5 = HEAP[_this_addr];
+ var _7 = HEAP[0 + _5+1*1];
+ var _9 = _7 * _d_addr;
+ var _10 = HEAP[_this_addr];
+ var _12 = HEAP[0 + _10+0*1];
+ var _14 = _12 * _d_addr;
+ __ZN3v_tC1Eddd(_agg_result, _14, _9, _4);
+ __label__ = 0; break;
+ case 0: // _return
+ return;
+ }
+}
+
+
+function __ZNK3v_t5crossERKS_(_agg_result, _this, _v) {
+ var __label__ = 18; /* _entry */
+ while(1) switch(__label__) {
+ case 18: // _entry
+ var _this_addr = Pointer_make([0], 0);
+ var _v_addr = Pointer_make([0], 0);
+ 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; break;
+ case 0: // _return
+ return;
+ }
+}
+
+
+function __ZNK3v_t3dotERKS_(_this, _v) {
+ var __label__ = 18; /* _entry */
+ while(1) switch(__label__) {
+ case 18: // _entry
+ var _this_addr = Pointer_make([0], 0);
+ var _v_addr = Pointer_make([0], 0);
+ 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; break;
+ case 0: // _return
+ var _retval1 = _retval;
+ return _retval1;
+ }
+}
+
+
+function __ZSt3maxIdERKT_S2_S2_(___a, ___b) {
+ var __label__ = 18; /* _entry */
+ while(1) switch(__label__) {
+ case 18: // _entry
+ var ___a_addr = Pointer_make([0], 0);
+ var ___b_addr = Pointer_make([0], 0);
+ var _retval = Pointer_make([0], 0);
+ var _0 = Pointer_make([0], 0);
+ 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; break; } else { __label__ = 2; break; }
+ case 1: // _bb
+ var _6 = HEAP[___b_addr];
+ HEAP[_0] = _6;
+ __label__ = 3; break;
+ case 2: // _bb1
+ var _7 = HEAP[___a_addr];
+ HEAP[_0] = _7;
+ __label__ = 3; break;
+ case 3: // _bb2
+ var _8 = HEAP[_0];
+ HEAP[_retval] = _8;
+ __label__ = 0; break;
+ case 0: // _return
+ var _retval3 = HEAP[_retval];
+ return _retval3;
+ }
+}
+
+
+function __ZSt3maxIiERKT_S2_S2_(___a, ___b) {
+ var __label__ = 18; /* _entry */
+ while(1) switch(__label__) {
+ case 18: // _entry
+ var ___a_addr = Pointer_make([0], 0);
+ var ___b_addr = Pointer_make([0], 0);
+ var _retval = Pointer_make([0], 0);
+ var _0 = Pointer_make([0], 0);
+ 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; break; } else { __label__ = 2; break; }
+ case 1: // _bb
+ var _6 = HEAP[___b_addr];
+ HEAP[_0] = _6;
+ __label__ = 3; break;
+ case 2: // _bb1
+ var _7 = HEAP[___a_addr];
+ HEAP[_0] = _7;
+ __label__ = 3; break;
+ case 3: // _bb2
+ var _8 = HEAP[_0];
+ HEAP[_retval] = _8;
+ __label__ = 0; break;
+ case 0: // _return
+ var _retval3 = HEAP[_retval];
+ return _retval3;
+ }
+}
+
+
+function ___tcf_0(_unnamed_arg) {
+ var __label__ = 18; /* _entry */
+ while(1) switch(__label__) {
+ case 18: // _entry
+ var _unnamed_arg_addr = Pointer_make([0], 0);
+ var __alloca_point_ = 0;
+ HEAP[_unnamed_arg_addr] = _unnamed_arg;
+ __ZNSt8ios_base4InitD1Ev(__ZStL8__ioinit);
+ __label__ = 0; break;
+ case 0: // _return
+ return;
+ }
+}
+
+
+function __ZN3v_tC1Eddd(_this, _a, _b, _c) {
+ var __label__ = 18; /* _entry */
+ while(1) switch(__label__) {
+ case 18: // _entry
+ var _this_addr = Pointer_make([0], 0);
+ 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; break;
+ case 0: // _return
+ return;
+ }
+}
+
+
+function __ZN5ray_tC1ERK3v_t(_this, _v) {
+ var __label__ = 18; /* _entry */
+ while(1) switch(__label__) {
+ case 18: // _entry
+ var _this_addr = Pointer_make([0], 0);
+ var _v_addr = Pointer_make([0], 0);
+ 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; break;
+ case 0: // _return
+ return;
+ }
+}
+
+
+function __ZN5ray_tC1ERK3v_tS2_(_this, _v, _w) {
+ var __label__ = 18; /* _entry */
+ while(1) switch(__label__) {
+ case 18: // _entry
+ var _this_addr = Pointer_make([0], 0);
+ var _v_addr = Pointer_make([0], 0);
+ var _w_addr = Pointer_make([0], 0);
+ var __alloca_point_ = 0;
+ HEAP[_this_addr] = _this;
+ HEAP[_v_addr] = _v;
+ HEAP[_w_addr] = _w;
+ 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;
+ var _14 = HEAP[_w_addr];
+ var _15 = _13+0*1;
+ var _17 = HEAP[0 + _14+0*1];
+ HEAP[_15] = _17;
+ var _18 = _13+1*1;
+ var _20 = HEAP[0 + _14+1*1];
+ HEAP[_18] = _20;
+ var _21 = _13+2*1;
+ var _23 = HEAP[0 + _14+2*1];
+ HEAP[_21] = _23;
+ __label__ = 0; break;
+ case 0: // _return
+ return;
+ }
+}
+
+
+function __ZN5hit_tC1Ev(_this) {
+ var __label__ = 18; /* _entry */
+ while(1) switch(__label__) {
+ case 18: // _entry
+ var _this_addr = Pointer_make([0], 0);
+ var __alloca_point_ = 0;
+ HEAP[_this_addr] = _this;
+ var _0 = HEAP[_this_addr];
+ var _1 = _0+_struct_hit_t___FLATTENER[0];
+ __ZN3v_tC1Eddd(_1, 0.000000e+00, 0.000000e+00, 0.000000e+00);
+ var _2 = HEAP[_this_addr];
+ HEAP[0 + _2+_struct_hit_t___FLATTENER[1]] = Infinity;
+ __label__ = 0; break;
+ case 0: // _return
+ return;
+ }
+}
+
+
+function __ZN8sphere_tC1Ev(_this) {
+ var __label__ = 18; /* _entry */
+ while(1) switch(__label__) {
+ case 18: // _entry
+ var _this_addr = Pointer_make([0], 0);
+ var __alloca_point_ = 0;
+ HEAP[_this_addr] = _this;
+ var _0 = HEAP[_this_addr];
+ var _1 = _0+_struct_hit_t___FLATTENER[0];
+ __ZN3v_tC1Ev(_1);
+ __label__ = 0; break;
+ case 0: // _return
+ return;
+ }
+}
+
+
+function __ZN8sphere_tC1ERK3v_td(_this, _v, _d) {
+ var __label__ = 18; /* _entry */
+ while(1) switch(__label__) {
+ case 18: // _entry
+ var _this_addr = Pointer_make([0], 0);
+ var _v_addr = Pointer_make([0], 0);
+ var _d_addr;
+ var __alloca_point_ = 0;
+ HEAP[_this_addr] = _this;
+ HEAP[_v_addr] = _v;
+ _d_addr = _d;
+ var _0 = HEAP[_this_addr];
+ var _1 = _0+_struct_hit_t___FLATTENER[0];
+ 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+_struct_hit_t___FLATTENER[1];
+ HEAP[_13] = _d_addr;
+ __label__ = 0; break;
+ case 0: // _return
+ return;
+ }
+}
+
+
+function __ZNK8sphere_t10get_normalERK3v_t(_agg_result, _this, _v) {
+ var __label__ = 18; /* _entry */
+ while(1) switch(__label__) {
+ case 18: // _entry
+ var _this_addr = Pointer_make([0], 0);
+ var _v_addr = Pointer_make([0], 0);
+ var _0 = Pointer_make([0,0,0], 0);
+ var __alloca_point_ = 0;
+ HEAP[_this_addr] = _this;
+ HEAP[_v_addr] = _v;
+ var _1 = HEAP[_this_addr];
+ var _3 = HEAP[0 + _1+_struct_hit_t___FLATTENER[1]];
+ var _4 = 1.000000e+00 / _3;
+ var _5 = HEAP[_this_addr];
+ var _6 = _5+_struct_hit_t___FLATTENER[0];
+ var _7 = HEAP[_v_addr];
+ __ZNK3v_tmiERKS_(_0, _7, _6);
+ __ZNK3v_tmlEd(_agg_result, _0, _4);
+ __label__ = 0; break;
+ case 0: // _return
+ return;
+ }
+}
+
+
+function __ZN6node_tC1Ev(_this) {
+ var __label__ = 18; /* _entry */
+ while(1) switch(__label__) {
+ case 18: // _entry
+ var _this_addr = Pointer_make([0], 0);
+ var __alloca_point_ = 0;
+ HEAP[_this_addr] = _this;
+ var _0 = HEAP[_this_addr];
+ var _1 = _0+_struct_node_t___FLATTENER[0];
+ __ZN8sphere_tC1Ev(_1);
+ var _2 = HEAP[_this_addr];
+ var _3 = _2+_struct_node_t___FLATTENER[1];
+ __ZN8sphere_tC1Ev(_3);
+ __label__ = 0; break;
+ case 0: // _return
+ return;
+ }
+}
+
+
+function __ZN6node_tC1ERK8sphere_tS2_l(_this, _b, _l, _jump) {
+ var __label__ = 18; /* _entry */
+ while(1) switch(__label__) {
+ case 18: // _entry
+ var _this_addr = Pointer_make([0], 0);
+ var _b_addr = Pointer_make([0], 0);
+ var _l_addr = Pointer_make([0], 0);
+ var _jump_addr;
+ var __alloca_point_ = 0;
+ HEAP[_this_addr] = _this;
+ HEAP[_b_addr] = _b;
+ HEAP[_l_addr] = _l;
+ _jump_addr = _jump;
+ var _0 = HEAP[_this_addr];
+ var _1 = _0+_struct_node_t___FLATTENER[0];
+ var _2 = HEAP[_b_addr];
+ var _3 = _1+_struct_hit_t___FLATTENER[0];
+ var _4 = _2+_struct_hit_t___FLATTENER[0];
+ var _5 = _3+0*1;
+ var _7 = HEAP[0 + _4+0*1];
+ HEAP[_5] = _7;
+ var _8 = _3+1*1;
+ var _10 = HEAP[0 + _4+1*1];
+ HEAP[_8] = _10;
+ var _11 = _3+2*1;
+ var _13 = HEAP[0 + _4+2*1];
+ HEAP[_11] = _13;
+ var _14 = _1+_struct_hit_t___FLATTENER[1];
+ var _16 = HEAP[0 + _2+_struct_hit_t___FLATTENER[1]];
+ HEAP[_14] = _16;
+ var _17 = HEAP[_this_addr];
+ var _18 = _17+_struct_node_t___FLATTENER[1];
+ var _19 = HEAP[_l_addr];
+ var _20 = _18+_struct_hit_t___FLATTENER[0];
+ var _21 = _19+_struct_hit_t___FLATTENER[0];
+ var _22 = _20+0*1;
+ var _24 = HEAP[0 + _21+0*1];
+ HEAP[_22] = _24;
+ var _25 = _20+1*1;
+ var _27 = HEAP[0 + _21+1*1];
+ HEAP[_25] = _27;
+ var _28 = _20+2*1;
+ var _30 = HEAP[0 + _21+2*1];
+ HEAP[_28] = _30;
+ var _31 = _18+_struct_hit_t___FLATTENER[1];
+ var _33 = HEAP[0 + _19+_struct_hit_t___FLATTENER[1]];
+ HEAP[_31] = _33;
+ var _34 = HEAP[_this_addr];
+ var _35 = _34+_struct_node_t___FLATTENER[2];
+ HEAP[_35] = _jump_addr;
+ __label__ = 0; break;
+ case 0: // _return
+ return;
+ }
+}
+
+
+function __ZN7basis_tC1ERK3v_t(_this, _v) {
+ var __label__ = 18; /* _entry */
+ while(1) switch(__label__) {
+ case 18: // _entry
+ var _this_addr = Pointer_make([0], 0);
+ var _v_addr = Pointer_make([0], 0);
+ var _0 = Pointer_make([0,0,0], 0);
+ var _n = Pointer_make([0,0,0], 0);
+ var _memtmp = Pointer_make([0,0,0], 0);
+ var _memtmp12 = Pointer_make([0,0,0], 0);
+ var __alloca_point_ = 0;
+ HEAP[_this_addr] = _this;
+ HEAP[_v_addr] = _v;
+ var _1 = HEAP[_this_addr];
+ var _2 = _1+0*3;
+ __ZN3v_tC1Ev(_2);
+ var _3 = HEAP[_this_addr];
+ var _4 = _3+1*3;
+ __ZN3v_tC1Ev(_4);
+ var _5 = HEAP[_this_addr];
+ var _6 = _5+2*3;
+ __ZN3v_tC1Ev(_6);
+ var _7 = HEAP[_v_addr];
+ __ZNK3v_t4normEv(_n, _7);
+ var _9 = HEAP[0 + _n+0*1];
+ var _11 = HEAP[0 + _n+0*1];
+ var _12 = _9 * _11;
+ var _13 = 0+(_12 != 1.000000e+00);
+ var _14 = _13;
+ var _16 = HEAP[0 + _n+1*1];
+ var _18 = HEAP[0 + _n+1*1];
+ var _19 = _16 * _18;
+ var _20 = 0+(_19 != 1.000000e+00);
+ var _21 = _20;
+ var _toBool = 0+(_14 != 0);
+ var _toBool1 = 0+(_21 != 0);
+ var _22 = _toBool & _toBool1;
+ var _23 = _22;
+ var _24 = _23;
+ var _26 = HEAP[0 + _n+2*1];
+ var _28 = HEAP[0 + _n+2*1];
+ var _29 = _26 * _28;
+ var _30 = 0+(_29 != 1.000000e+00);
+ var _31 = _30;
+ var _32 = _24 & _31;
+ var _33 = 0+(_32 != 0);
+ if (_33) { __label__ = 1; break; } else { __label__ = 4; break; }
+ case 1: // _bb
+ var _34 = HEAP[_this_addr];
+ var _35 = _34+1*3;
+ var _36 = _35+0*1;
+ var _38 = HEAP[0 + _n+0*1];
+ HEAP[_36] = _38;
+ var _39 = _35+1*1;
+ var _41 = HEAP[0 + _n+1*1];
+ HEAP[_39] = _41;
+ var _42 = _35+2*1;
+ var _44 = HEAP[0 + _n+2*1];
+ HEAP[_42] = _44;
+ var _46 = HEAP[0 + _n+1*1];
+ var _48 = HEAP[0 + _n+1*1];
+ var _49 = _46 * _48;
+ var _51 = HEAP[0 + _n+0*1];
+ var _53 = HEAP[0 + _n+0*1];
+ var _54 = _51 * _53;
+ var _55 = 0+(_49 > _54);
+ if (_55) { __label__ = 3; break; } else { __label__ = 5; break; }
+ case 3: // _bb2
+ var _57 = HEAP[0 + _n+1*1];
+ var _59 = HEAP[0 + _n+1*1];
+ var _60 = _57 * _59;
+ var _62 = HEAP[0 + _n+2*1];
+ var _64 = HEAP[0 + _n+2*1];
+ var _65 = _62 * _64;
+ var _66 = 0+(_60 > _65);
+ if (_66) { __label__ = 6; break; } else { __label__ = 7; break; }
+ case 6: // _bb3
+ var _67 = HEAP[_this_addr];
+ var _68 = _67+1*3;
+ var _70 = HEAP[0 + _68+1*1];
+ var _71 = -0.000000e+00 - _70;
+ var _72 = HEAP[_this_addr];
+ var _73 = _72+1*3;
+ HEAP[0 + _73+1*1] = _71;
+ __label__ = 8; break;
+ case 7: // _bb4
+ var _75 = HEAP[_this_addr];
+ var _76 = _75+1*3;
+ var _78 = HEAP[0 + _76+2*1];
+ var _79 = -0.000000e+00 - _78;
+ var _80 = HEAP[_this_addr];
+ var _81 = _80+1*3;
+ HEAP[0 + _81+2*1] = _79;
+ __label__ = 8; break;
+ case 8: // _bb5
+ __label__ = 9; break;
+ case 5: // _bb6
+ var _84 = HEAP[0 + _n+2*1];
+ var _86 = HEAP[0 + _n+2*1];
+ var _87 = _84 * _86;
+ var _89 = HEAP[0 + _n+0*1];
+ var _91 = HEAP[0 + _n+0*1];
+ var _92 = _89 * _91;
+ var _93 = 0+(_87 > _92);
+ if (_93) { __label__ = 10; break; } else { __label__ = 11; break; }
+ case 10: // _bb7
+ var _94 = HEAP[_this_addr];
+ var _95 = _94+1*3;
+ var _97 = HEAP[0 + _95+2*1];
+ var _98 = -0.000000e+00 - _97;
+ var _99 = HEAP[_this_addr];
+ var _100 = _99+1*3;
+ HEAP[0 + _100+2*1] = _98;
+ __label__ = 9; break;
+ case 11: // _bb8
+ var _102 = HEAP[_this_addr];
+ var _103 = _102+1*3;
+ var _105 = HEAP[0 + _103+0*1];
+ var _106 = -0.000000e+00 - _105;
+ var _107 = HEAP[_this_addr];
+ var _108 = _107+1*3;
+ HEAP[0 + _108+0*1] = _106;
+ __label__ = 9; break;
+ case 9: // _bb9
+ __label__ = 12; break;
+ case 4: // _bb10
+ var _111 = HEAP[0 + _n+1*1];
+ var _113 = HEAP[0 + _n+0*1];
+ var _115 = HEAP[0 + _n+2*1];
+ __ZN3v_tC1Eddd(_0, _115, _113, _111);
+ var _116 = HEAP[_this_addr];
+ var _117 = _116+1*3;
+ var _118 = _117+0*1;
+ var _120 = HEAP[0 + _0+0*1];
+ HEAP[_118] = _120;
+ var _121 = _117+1*1;
+ var _123 = HEAP[0 + _0+1*1];
+ HEAP[_121] = _123;
+ var _124 = _117+2*1;
+ var _126 = HEAP[0 + _0+2*1];
+ HEAP[_124] = _126;
+ __label__ = 12; break;
+ case 12: // _bb11
+ var _127 = HEAP[_this_addr];
+ var _128 = _127+0*3;
+ var _129 = _128+0*1;
+ var _131 = HEAP[0 + _n+0*1];
+ HEAP[_129] = _131;
+ var _132 = _128+1*1;
+ var _134 = HEAP[0 + _n+1*1];
+ HEAP[_132] = _134;
+ var _135 = _128+2*1;
+ var _137 = HEAP[0 + _n+2*1];
+ HEAP[_135] = _137;
+ var _138 = HEAP[_this_addr];
+ var _139 = _138+1*3;
+ var _140 = HEAP[_this_addr];
+ var _141 = _140+0*3;
+ var _142 = HEAP[_this_addr];
+ var _143 = _142+2*3;
+ __ZNK3v_t5crossERKS_(_memtmp, _141, _139);
+ var _144 = _143+0*1;
+ var _146 = HEAP[0 + _memtmp+0*1];
+ HEAP[_144] = _146;
+ var _147 = _143+1*1;
+ var _149 = HEAP[0 + _memtmp+1*1];
+ HEAP[_147] = _149;
+ var _150 = _143+2*1;
+ var _152 = HEAP[0 + _memtmp+2*1];
+ HEAP[_150] = _152;
+ var _153 = HEAP[_this_addr];
+ var _154 = _153+2*3;
+ var _155 = HEAP[_this_addr];
+ var _156 = _155+0*3;
+ var _157 = HEAP[_this_addr];
+ var _158 = _157+1*3;
+ __ZNK3v_t5crossERKS_(_memtmp12, _156, _154);
+ var _159 = _158+0*1;
+ var _161 = HEAP[0 + _memtmp12+0*1];
+ HEAP[_159] = _161;
+ var _162 = _158+1*1;
+ var _164 = HEAP[0 + _memtmp12+1*1];
+ HEAP[_162] = _164;
+ var _165 = _158+2*1;
+ var _167 = HEAP[0 + _memtmp12+2*1];
+ HEAP[_165] = _167;
+ __label__ = 0; break;
+ case 0: // _return
+ return;
+ }
+}
+
+
+function __ZNK3v_t6magsqrEv(_this) {
+ var __label__ = 18; /* _entry */
+ while(1) switch(__label__) {
+ case 18: // _entry