Quelle  mandreel.js

// Portions copyright 2012 Google, Inc.
// Copyright 2012 Onan Games. All rights reserved.
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
//     * Redistributions of source code must retain the above copyright
//       notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above
//       copyright notice, this list of conditions and the following
//       disclaimer in the documentation and/or other materials provided
//       with the distribution.
//     * Neither the name of Google Inc. nor the names of its
//       contributors may be used to endorse or promote products derived
//       from this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

var MandreelBenchmark = new BenchmarkSuite('Mandreel', [16831872, 49852],
                                            [new Benchmark('Mandreel',
                                                           false,
                                                           false,
                                                           15,
                                                           runMandreel,
                                                           setupMandreel,
                                                           tearDownMandreel,
                                                           RMSMandreel,
                                                           4)]);

var mandreelSumSquaredPauses = 0;
var mandreelSamples = 0;
var mandreelSampleTimeStart = 0.0;

function setupMandreel() {
  // Check for Typed Arrays support, throw error if not.
  if (!(typeof Uint8Array != "undefined" &&
    typeof Float64Array != "undefined" &&
    typeof (new Uint8Array(0)).subarray != "undefined")) {
      throw "TypedArrayUnsupported";
  }

  my_old_constructors = mandreel_call_constructors;
  mandreel_call_constructors = my_mandreel_call_constructors;
  startMandreelTimer();
  startApp();
  _mandreelAppAudioReady();
}

function runMandreel() {
  Mandreel_currentTime = 0;
  var sp = g_stack_pointer+800*1024;
  for (var i=0;i<mandreel_total_memory/4;i++) {
    heap32[i] = my_heap32[i];
  }
  tlsf_ptr = 0;
  heapNewPos = my_heapNewPos;
  my_old_constructors(llvm_2E_global_ctors,5,sp);
  heapU32[sp>>2] = 640;
  heapU32[(sp+4)>>2] = 480;
  __mandreel_internal_SetResolution(sp);
  __mandreel_internal_init(g_stack_pointer+800*1024);
  __init(g_stack_pointer+800*1024);
  for (var i = 0; i < 20; i++) {
    render();
    Mandreel_flushTimeouts();
    updateMandreelStats(performance.now());
  }
  Mandreel_checkState();
}

function updateMandreelStats(time) {
  var pause = time - mandreelSampleTimeStart;
  mandreelSampleTimeStart = time;
  mandreelSumSquaredPauses += (pause * pause);
  mandreelSamples++;
}

function startMandreelTimer() {
  mandreelSampleTimeStart = performance.now();
}

function RMSMandreel() {
  return Math.round(Math.sqrt(mandreelSumSquaredPauses / mandreelSamples) * 100);
}

function tearDownMandreel() {
  my_old_constructors = null;
  my_heap = null;
  my_heap8 = null;
  my_heap32 = null;

  heap = null;
  heap8 = null;
  heapU8 = null;
  heap16 = null;
  heapU16 = null;
  heap32 = null;
  heapU32 = null;
  heapFloat = null;
  heapDouble = null;
  mandreelAppUsePackAsyncTexture = null;
  mandreelSumSquaredPauses = 0;
  mandreelSamples = 0;
}

// Mocks for browser functions.

function Mandreel_setTimeout(cmd, delay) {
  timeouts.push(cmd);
}

function Mandreel_flushTimeouts() {
  while (Mandreel_timeouts.length != 0) {
    var next = Mandreel_timeouts.pop();
    eval(next);
  }
}

Mandreel_timeouts = new Array();

Mandreel_XMLHttpRequest = function() {
  this.open = function(type, url, some_bool) {
    this.url = url;
  }
  this.overrideMimeType = function() {
  }
  this.send = function() {
    this.response = null;
    this.readyState = 4;
    this.status = 0;
    this.onreadystatechange();
  }
};

function Mandreel_Element(type) {
  this.element_type = type;
  this.insertBefore = function() {
  }
}


function Mandreel_Context() {
}

function Mandreel_Canvas() {
}

function Mandreel_CanvasDiv() {
}

Mandreel_document = {
  createElement : function(element_type) {
    var element = new Mandreel_Element(element_type);
    element.parentNode = new Mandreel_Element("dummy_parent");
    return element;
  },
  getElementById : function(name) {
    if (name === "canvas") {
      return new Mandreel_Canvas();
    } else if (name === "canvasDiv") {
      return new Mandreel_CanvasDiv();
    } else {
      return undefined;
    }
  },
  getElementsByTagName : function(element) {
    if (element === "script") {
      return new Array(new this.createElement(element));
    }
  }

};

Mandreel_window = {
  WebGLRenderingContext: {},
  Float64Array: Float64Array,
  Float32Array: Float32Array,
  Int32Array: Int32Array,
  Uint32Array: Uint32Array,
  Int16Array: Int16Array,
  Uint16Array: Uint16Array,
  Int8Array: Int8Array,
  Uint8Array: Uint8Array,
  setTimeout: Mandreel_setTimeout,
  addEventListener : function () {},
  document: Mandreel_document
};

function dump(x) { }

alert = typeof alert != "undefined" ? alert : function(x) {
  print(x);
}

var my_old_constructors;
var my_heap;
var my_heap8;
var my_heap32;
var my_heapNewPos;

function my_mandreel_call_constructors(_ptr, size,stackPos) {
  my_heapNewPos = heapNewPos;
  my_heap = new ArrayBuffer(mandreel_total_memory);
  my_heap8 = new Int8Array(my_heap);
  my_heap32 = new Int32Array(my_heap);
  for (var i=0;i<mandreel_total_memory/4;i++) {
    my_heap32[i] = heap32[i];
  }
  my_old_constructors(_ptr,size,stackPos);
}


var Mandreel_currentTime = 0;

function Date_now() {
   Mandreel_currentTime += 16;
   return Mandreel_currentTime;
}

function Mandreel_checkState() {
  var sum = 0;
  for (var i = 0; i < heap32.length; i += 100) {
    sum = (sum * 3 + heap32[i]) & 0xFFFFFF;
  }
  if (sum != 8001026) {
    alert("Check sum mismatch: expected ???, actual " + sum);
  }
}

// Original Mandreel code follows.
// Modifications for benchmarking are marked in comments.

// Start of js/main.js file:

////////////////////////////////////////////
function startApp(_platform)
{
 // Start mandreel
 var params =
 {
  platform : _platform,
  width : 1024,
  height : 768,
  webglCanvas : "canvas",
  flashCanvas : "FlashDiv",
  workingFolderFlash : "data/as3/",
  workingFolderWebgl : "data/js/",
  swfFlash : "mandreel.swf",
  log : true
 };
 mandreelAppStart(appStartState,params);
}

////////////////////////////////////////////
function appStartState(state,param)
{
 // mandreel.js program is been loaded
 if ( state == "loadingScript" )
 {
 }

 // mandreel.js program has been loaded
 if ( state == "scriptLoaded" )
 {
 }

 // loading pack data file
 if (state == "loadingData")
 {
  // param bytes loaded
 }

 // Audio system is been started
 if ( state == "loadingAudio" )
 {
 }

 // Audio system is ready and the default audio preloading has been done
 if ( state == "audioLoaded" )
 {
 }



 // Mandreel has been started, render will start automatically
 if ( state == "ready" )
 {
  // Hide loading image
  var canvasElement = Mandreel_document.getElementById('loading');
  if ( canvasElement != null )
   canvasElement.style.visibility = "hidden";
 }

 // An error has been produced during the start process and the app must quit
 if ( state == "error" )
 {
  if ( param == "webgl_not_found" )
  {
   window.location = "http://get.webgl.org";
   return;
  }
  alert(param);
 }
}

// End of js/main.js file.

// Start of js/mandreelapp.js file.

var mandreelAppMandreelJs = "mandreel.js";
var mandreelAppMandreelJsCompressed = false;
var mandreelAppWorkingFolder = "data/js/";
var mandreelAppLog = false;
var mandreelAppLocalHost = "http://localhost";
var mandreelAppReadDataFromLocalHost = false;
var mandreelAppReadMandreelJsFromLocalHost = false;
var mandreelAppHostedAudioServer = null;
var mandreelAppHostedAudioUrl = null;
var mandrelCurrentFatVersion = "1.4";
var mandreelAppPlatform = "webgl";
var mandreelAppCanvasWidth = 1024;
var mandreelAppCanvasHeight = 768;
var mandreelAppWidthSrc = 1024;
var mandreelAppHeightSrc = 768;
var mandreelAppCanvasName = "canvas";
var mandreelAppCanvasDiv = "canvasDiv";
var mandreelAppUseFlashSockets = false;
var mandreelAppUsePackAsyncTexture = new Array();
//var mandreelBufferPackAsyncTexture = null;
var mandreelAppForceFocus = true;
var _imandreel_pause_game = false;

/* The following code was removed for benchmarking:
navigator.pointer = navigator.pointer || navigator.webkitPointer || navigator.mozPointer || null;*/

/* The following code was removed for benchmarking:
 if (!Date_now) {
   Date_now = function() {
     return +new Date();
   };
 };*/

////////////////////////////////////////////

if (Mandreel_window["console"])
{
 if (!Mandreel_window["dump"]) Mandreel_window["dump"] = function dump(str){ if ( mandreelAppLog ) console.log(str) };
}
else
{
 if (!Mandreel_window["dump"]) Mandreel_window["dump"] = function dump(str){ };
}

/* The following code is removed for benchmarking:
var mandreel_BrowserDetect = {
init: function () {
this.browser = this.searchString(this.dataBrowser) || "An unknown browser";
this.version = this.searchVersion(navigator.userAgent)
|| this.searchVersion(navigator.appVersion)
|| "an unknown version";
this.OS = this.searchString(this.dataOS) || "an unknown OS";
},
searchString: function (data) {
for (var i=0;i<data.length;i++) {
var dataString = data[i].string;
var dataProp = data[i].prop;
this.versionSearchString = data[i].versionSearch || data[i].identity;
if (dataString) {
if (dataString.indexOf(data[i].subString) != -1)
return data[i].identity;
}
else if (dataProp)
return data[i].identity;
}
},
searchVersion: function (dataString) {
var index = dataString.indexOf(this.versionSearchString);
if (index == -1) return;
return parseFloat(dataString.substring(index+this.versionSearchString.length+1));
},
dataBrowser: [
{
string: navigator.userAgent,
subString: "Chrome",
identity: "Chrome"
},
{  string: navigator.userAgent,
subString: "OmniWeb",
versionSearch: "OmniWeb/",
identity: "OmniWeb"
},
{
string: navigator.vendor,
subString: "Apple",
identity: "Safari",
versionSearch: "Version"
},
{
prop: window.opera,
identity: "Opera",
versionSearch: "Version"
},
{
string: navigator.vendor,
subString: "iCab",
identity: "iCab"
},
{
string: navigator.vendor,
subString: "KDE",
identity: "Konqueror"
},
{
string: navigator.userAgent,
subString: "Firefox",
identity: "Firefox"
},
{
string: navigator.vendor,
subString: "Camino",
identity: "Camino"
},
{ // for newer Netscapes (6+)
string: navigator.userAgent,
subString: "Netscape",
identity: "Netscape"
},
{
string: navigator.userAgent,
subString: "MSIE",
identity: "Explorer",
versionSearch: "MSIE"
},
{
string: navigator.userAgent,
subString: "Gecko",
identity: "Mozilla",
versionSearch: "rv"
},
{  // for older Netscapes (4-)
string: navigator.userAgent,
subString: "Mozilla",
identity: "Netscape",
versionSearch: "Mozilla"
}
],
dataOS : [
{
string: navigator.platform,
subString: "Win",
identity: "Windows"
},
{
string: navigator.platform,
subString: "Mac",
identity: "Mac"
},
{
   string: navigator.userAgent,
   subString: "iPhone",
   identity: "iPhone/iPod"
    },
{
string: navigator.platform,
subString: "Linux",
identity: "Linux"
}
]

};
mandreel_BrowserDetect.init(); */

////////////////////////////////////////////
var mandreel_packfiledata_name = null;
var mandreel_packfiledata_compressed = false;
var mandreel_packfiledata_size = 0;
var mandreel_total_packtexture_size = 0;
var mandreel_total_pogfile_size = 0;
var mandreel_loaded_packtexture_size = 0;
var mandreel_jslzma_size = 0;
var mandreel_swf_size = 0;

var mandreelJsScriptLoaded_loaded = false;

var mandreel_swf_last_total_size = 0;
function mandreel_swf_size_updated(str)
{
 var params = str.split(',');
 if ( mandreel_swf_size == 0 )
 {
  mandreel_swf_last_loaded_size = 0;
 }
 mandreel_swf_size = parseInt(params[0]);
 var loaded = parseInt(params[1]);
 var delta_size = loaded - mandreel_swf_last_loaded_size;
 mandreel_swf_last_loaded_size = loaded;

 var percentage = ((100*loaded)/mandreel_swf_size)|0;
 if (percentage>100)
  percentage = 100;

 if ( mandreelAppStartStateFunc )
  mandreelAppStartStateFunc("loadingScriptUpdate",percentage);

 imandreel_update_load(delta_size,0);
}

function mandreel_swf_size_loaded(str)
{
 if ( mandreelAppStartStateFunc )
  mandreelAppStartStateFunc("scriptLoaded","");
}

function mandreelNextDecompress(mandreel_result_lzma)
{

 if ( mandreelAppStartStateFunc )
 {
  var totalBytesLeft = mandreel_result_lzma.totalSize - mandreel_result_lzma.remainingBytes;

  var percentage;

  if (totalBytesLeft == 0)
   percentage = 0;
  else
   percentage = ((100*totalBytesLeft)/mandreel_result_lzma.totalSize)|0;

  mandreelAppStartStateFunc("uncompressingDataUpdate",percentage);
 }

 var old_result = mandreel_result_lzma;
 mandreel_result_lzma = LZMA.decompress2(mandreel_result_lzma.inStream,mandreel_result_lzma.inStream,mandreel_result_lzma.outStream,mandreel_result_lzma);

 if (mandreel_result_lzma == null)
 {
  //setTimeout(mandreelLoadScript,10,old_result.my_outStream.data);

  //mandreel_fs_saveFile('data.bin', old_result.my_outStream.arrayBuffer);
  //callback(old_result.my_outStream.arrayBuffer);
  //alert('done');
  mandreelLoadPackData(old_result.my_outStream.arrayBuffer,true);
 }
 else
 {
  Mandreel_setTimeout(mandreelNextDecompress,10,mandreel_result_lzma);
 }


}

function mandreel_load_packfile(array_buffer)
{
 if (array_buffer)
 {
  mandreelLoadPackData(array_buffer,false);
  return;
 }

 var working_folder = mandreelAppWorkingFolder;
 if ( mandreelAppReadDataFromLocalHost )
  working_folder = mandreelAppLocalHost+"/"+mandreelAppWorkingFolder;
 var packdata_request = new XMLHttpRequest();
 var url = working_folder+mandreel_packfiledata_name;

 packdata_request.open("GET", url, true);

 if("responseType" in packdata_request)
  packdata_request.responseType="arraybuffer";
 else
  packdata_request.overrideMimeType('text/plain; charset=x-user-defined');

 var last_loaded_size = 0;

 packdata_request.onreadystatechange = function()
 {
  if (packdata_request.readyState != 4) return;

  if (packdata_request.status == 200)
  {
   var buffer;
   if (packdata_request.responseType=="arraybuffer")
    buffer=packdata_request.response;
   else if (packdata_request.mozResponseArrayBuffer != null)
    buffer = packdata_request.mozResponseArrayBuffer;
   else
    buffer=packdata_request.response;

   if (mandreel_packfiledata_compressed)
   {
    var inStream = {
      data: new Uint8Array(buffer),
      offset: 0,
      readByte: function(){
     return this.data[this.offset ++];
      }
    };

    var outStream = {
      data: null,
      offset: 0,
      binary_mode : true,
      writeByte: function(value){
     this.data[this.offset ++] = value;
      }
    };


    var result = LZMA.decompress2(inStream,inStream,outStream,null);

    if (result == null)
     mandreelLoadPackData(outStream.arrayBuffer,true);
    else
     Mandreel_setTimeout(mandreelNextDecompress,10,result);
   }
   else
    mandreelLoadPackData(buffer,true);
  }
  else
  {
   if ( mandreelAppStartStateFunc )
    mandreelAppStartStateFunc("error","can't load packfile data");
  }
 }
 packdata_request.onprogress = function(e)
 {
  var delta_size = e.loaded - last_loaded_size;
  last_loaded_size = e.loaded;
  var percentage = ((100*e.loaded)/mandreel_packfiledata_size)|0;


  imandreel_update_load(delta_size,0);

  if (percentage>100)
   percentage = 100;

  if ( mandreelAppStartStateFunc )
   mandreelAppStartStateFunc("loadingData",percentage);
 }

 packdata_request.send();
}

function mandreelJsScriptLoaded()
{
 if (mandreelJsScriptLoaded_loaded)
  return;

 if (typeof(mandreel_cache_files)=="undefined")
 {
  Mandreel_setTimeout(mandreelJsScriptLoaded,10);
  return;
 }

 mandreelJsScriptLoaded_loaded = true;

 if ( mandreelAppStartStateFunc )
  mandreelAppStartStateFunc("scriptLoaded","");

 if (mandreel_packfiledata_name)
 {

  mandreel_fs_load_binary(mandreel_packfiledata_name, mandreel_load_packfile);


 }
 else
 {
  mandreelCacheMandreelFat();
  imandreelJsScriptLoaded();
 }
}

function imandreelLoadAudio()
{
 g_mandreel_working_folder = mandreelAppWorkingFolder;
 if ( mandreelAppReadDataFromLocalHost )
  g_mandreel_working_folder = mandreelAppLocalHost+"/"+mandreelAppWorkingFolder;

 // load audio
 if ( mandreelAppStartStateFunc )
  mandreelAppStartStateFunc("loadingAudio","");
 mandreel_start_audio(mandreelAppHostedAudioServer,mandreelAppHostedAudioUrl,_mandreelAppAudioReady);
}

var _mandreel_currentPackTexture = '';

function imandreel_packasynctexture_loaded(buffer,save_file)
{
 if (save_file)
  mandreel_fs_saveFile(_mandreel_currentPackTexture,buffer);

 //mandreelBufferPackAsyncTexture = buffer;
 Mandreel_TextureAsync_PackBufferData[_mandreel_currentPackTexture] = buffer;

 imandreelLoadNextTexturePack();
}

var mandreel_update_total_size = 0;

function imandreel_update_load(size, total)
{
 if (total == 0)
  total = mandreel_packfiledata_size + mandreel_total_packtexture_size + mandreel_total_pogfile_size + mandreel_jslzma_size + mandreel_swf_size;


 mandreel_update_total_size+=size;

 var percentage = ((100*mandreel_update_total_size)/total)|0;

 if (percentage>100)
  percentage = 100;
 if (mandreelAppStartStateFunc)
  mandreelAppStartStateFunc("loadingProgress",percentage);

}


function imandreel_packasynctexture_load(array_buffer)
{
 if (array_buffer)
 {
  imandreel_packasynctexture_loaded(array_buffer, false);
  return;
 }


 var working_folder = mandreelAppWorkingFolder;
 if ( mandreelAppReadDataFromLocalHost )
  working_folder = mandreelAppLocalHost+"/"+mandreelAppWorkingFolder;
 var packdata_request = new XMLHttpRequest();
 var url = working_folder+_mandreel_currentPackTexture;

 packdata_request.open("GET", url, true);

 if("responseType" in packdata_request)
  packdata_request.responseType="arraybuffer";
 else
  packdata_request.overrideMimeType('text/plain; charset=x-user-defined');

 var last_loaded_size = 0;

 packdata_request.onreadystatechange = function()
 {
  if (packdata_request.readyState != 4) return;

  if (packdata_request.status == 200)
  {
   var buffer;
   if (packdata_request.responseType=="arraybuffer")
    buffer=packdata_request.response;
   else if (packdata_request.mozResponseArrayBuffer != null)
    buffer = packdata_request.mozResponseArrayBuffer;
   else
    buffer=packdata_request.response;

   imandreel_packasynctexture_loaded(buffer, true);
  }
  else
  {
   if ( mandreelAppStartStateFunc )
    mandreelAppStartStateFunc("error","can't load textureasync pack data");
  }
 }
 packdata_request.onprogress = function(e)
 {
  var delta_size = e.loaded - last_loaded_size;
  last_loaded_size = e.loaded;
  mandreel_loaded_packtexture_size+=delta_size;

  imandreel_update_load(delta_size,0);

  var percentage = ((100*mandreel_loaded_packtexture_size)/mandreel_total_packtexture_size)|0;

  if (percentage>100)
   percentage = 100;

  if ( mandreelAppStartStateFunc )
   mandreelAppStartStateFunc("loadingTextureAsyncPack",percentage);
 }

 packdata_request.send();

}

function imandreelLoadNextTexturePack()
{
 if (mandreelAppUsePackAsyncTexture.length)
 {
  _mandreel_currentPackTexture = mandreelAppUsePackAsyncTexture.pop();
  mandreel_fs_load_binary(_mandreel_currentPackTexture, imandreel_packasynctexture_load);
 }
 else
  imandreelLoadAudio();
}

function imandreelJsScriptLoaded()
{
 imandreelLoadNextTexturePack();
}

////////////////////////////////////////////

function mandreelDecompressJSReady(code, save_file)
{
 if (save_file)
  mandreel_fs_saveFile(mandreelAppMandreelJs + ".lzma", code);

 var ga = Mandreel_document.createElement('script');
 ga.type = "text/javascript";
 ga.text = code;
 var s = Mandreel_document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);
 s.parentNode.removeChild(ga);
 mandreelJsScriptLoaded();
}

function mandreelNextDecompressJS(mandreel_result_lzma)
{

 if ( mandreelAppStartStateFunc )
 {
  var totalBytesLeft = mandreel_result_lzma.totalSize - mandreel_result_lzma.remainingBytes;

  var percentage;

  if (totalBytesLeft == 0)
   percentage = 0;
  else
   percentage = ((100*totalBytesLeft)/mandreel_result_lzma.totalSize)|0;

  mandreelAppStartStateFunc("uncompressingScriptUpdate",percentage);
 }

 var old_result = mandreel_result_lzma;
 mandreel_result_lzma = LZMA.decompress2(mandreel_result_lzma.inStream,mandreel_result_lzma.inStream,mandreel_result_lzma.outStream,mandreel_result_lzma);

 if (mandreel_result_lzma == null)
 {
  mandreelDecompressJSReady(old_result.my_outStream.data,true);
 }
 else
 {
  Mandreel_setTimeout(mandreelNextDecompressJS,10,mandreel_result_lzma);
 }


}

function mandreel_load_compressed_js(code_js)
{
 if (code_js)
 {
  mandreelDecompressJSReady(code_js,false);
  return;
 }
  var xmlhttp_get = new XMLHttpRequest();

  var url = mandreelAppMandreelJs + ".lzma";
  if ( mandreelAppReadMandreelJsFromLocalHost )
  url = mandreelAppLocalHost+"/"+url;

  xmlhttp_get.open('GET',url);


 if("responseType" in xmlhttp_get)
  xmlhttp_get.responseType="arraybuffer";
 else
  xmlhttp_get.overrideMimeType('text/plain; charset=x-user-defined');

 var last_loaded_size = 0;

 xmlhttp_get.onreadystatechange = function()
 {
  if (xmlhttp_get.readyState==4)
  {
   if (xmlhttp_get.status==200 || xmlhttp_get.status==0)
   {

    var inStream = {
      data: new Uint8Array(xmlhttp_get.response),
      offset: 0,
      readByte: function(){
     return this.data[this.offset ++];
      }
    };

    var outStream = {
      data: new String(""),
      offset: 0,
      binary_mode : false,
      writeByte: function(value){
     this.data+=String.fromCharCode(value);
      }
    };


    var result = LZMA.decompress2(inStream,inStream,outStream,null);
    if (result == null)
     mandreelDecompressJSReady(outStream.data,true);
    else
     Mandreel_setTimeout(mandreelNextDecompressJS,10,result);
   }
   else
   {
    alert('error ' + xmlhttp_get.status);
   }
  }

 }

 xmlhttp_get.onprogress = function(e)
 {
  var delta_size = e.loaded - last_loaded_size;
  last_loaded_size = e.loaded;

  var percentage = ((100*e.loaded)/e.total)|0;

  mandreel_jslzma_size = e.total;

  imandreel_update_load(delta_size,0);

  if (percentage>100)
   percentage = 100;

  if ( mandreelAppStartStateFunc )
   mandreelAppStartStateFunc("loadingScriptUpdate",percentage);
 }

 xmlhttp_get.send();

}

function mandreelLoadMandreelJsScript()
{
 if (mandreelAppMandreelJsCompressed)
 {
  mandreel_fs_load_text(mandreelAppMandreelJs + ".lzma", mandreel_load_compressed_js);

 }
 else
 {
  var ga = Mandreel_document.createElement('script');
  ga.type = 'text/javascript';
  ga.async = true;
  ga.onload = ga.onreadystatechange = mandreelJsScriptLoaded;
  var url = mandreelAppMandreelJs;
  if ( mandreelAppReadMandreelJsFromLocalHost )
   ga.src = mandreelAppLocalHost+"/"+url;
  else
   ga.src = url;
  var s = Mandreel_document.getElementsByTagName('script')[0];
  if ( mandreelAppStartStateFunc )
   mandreelAppStartStateFunc("loadingScript","");
  s.parentNode.insertBefore(ga, s);
 }
}

////////////////////////////////////////////
function mandreelFatLoaded()
{
 if ( mandreelAppPlatform == "nacl" )
 {
  g_mandreel_working_folder = mandreelAppWorkingFolder;
  if ( mandreelAppReadDataFromLocalHost )
   g_mandreel_working_folder = mandreelAppLocalHost+"/"+mandreelAppWorkingFolder;

  // load audio
  if ( mandreelAppStartStateFunc )
   mandreelAppStartStateFunc("loadingAudio","");
  _mandreelAppAudioReady();
 }
 else
  mandreelLoadMandreelJsScript();
}

var mandreelFatData = "";
var mandreelFatPreloadRequest = 0;
////////////////////////////////////////////

function mandreel_chanka_fixfile(fileName)
{
 var fileNameNoExt = fileName.toLowerCase();
 fileNameNoExt = fileNameNoExt.replace(/\\/g,"/");

 fileNameNoExt =  fileNameNoExt.substr(1);

 var new_fileName = '';

 for(var j = 0; j < fileNameNoExt.length; j++)
 {
  var data = fileNameNoExt.charCodeAt(j);

  if (data != 13)
  {
    var t = String.fromCharCode(data);
    new_fileName+=t;
  }
 }

 return  new_fileName;
}

function mandreel_removecr(my_string)
{
 var new_string = '';
 for(var j = 0; j < my_string.length; j++)
 {
  var data = my_string.charCodeAt(j);

  if (data != 13)
  {
    var t = String.fromCharCode(data);
    new_string+=t;
  }
 }

 return  new_string;
}

function mandreelCacheMandreelFat()
{
 var array_mandreel_fat = new ArrayBuffer(mandreelFatData.length+1);


 {
  var j;
  var len = mandreelFatData.length;
  var data_char;

  var my_bytes = new Uint8Array(array_mandreel_fat);

  for(j = 0; j < len; j++)
  {
   data_char = mandreelFatData.charCodeAt(j);

   my_bytes[j] = data_char;
  }
  my_bytes[j] = 0;
 }


 mandreel_cache_files['mandreel.fat'] = array_mandreel_fat;
}

function mandreelLoadPackData(data, save_pack)
{
 var files = mandreelFatData.split('\n');

 var current_dir = '';
 var current_offset = 0;

 if (save_pack)
  mandreel_fs_saveFile(mandreel_packfiledata_name,data);


 for (var i=0;i<files.length;++i)
 {
  var file_data = files[i].split(',');

  if (file_data[0] == 'dir')
  {
   current_dir = file_data[1];
   //current_dir = current_dir.substr(0,current_dir.lengh-1);
  }
  else if (file_data[0] == 'file')
  {
   var file_name = current_dir + file_data[1];
   file_name = mandreel_chanka_fixfile(file_name) ;
   //dump('new file ' + file_name + ' ' + current_offset);
   //dump(file_name);
   var file_size = parseInt(file_data[2]);

   var my_array = new ArrayBuffer(file_size);

   var my_bytes = new Uint8Array(my_array);

   var data_bytes = new Uint8Array(data,current_offset,file_size);

   my_bytes.set(data_bytes);

   mandreel_cache_files[file_name] = my_array;


   current_offset+=file_size;


  }
 }



 g_mandreel_datafiles_sufix = '';
 mandreelCacheMandreelFat();

 imandreelJsScriptLoaded();
}

var preCreatedWebAudioContext = null;

function mandreelLoadFat()
{
 mandreelFatPreloadRequest = new Mandreel_XMLHttpRequest();
 var working_folder = mandreelAppWorkingFolder;
 if ( mandreelAppReadDataFromLocalHost )
  working_folder = mandreelAppLocalHost+"/"+mandreelAppWorkingFolder;
 var url = working_folder+"mandreel.fat.dat";
 if ( mandreelAppPlatform == "nacl" )
  url = working_folder+"mandreel.fat";
 mandreelFatPreloadRequest.open("GET", url, true);
 mandreelFatPreloadRequest.onreadystatechange = function()
 {
  if (mandreelFatPreloadRequest.readyState != 4) return;
  if ( mandreelFatPreloadRequest.status != 404 && mandreelFatPreloadRequest.response != null )
  {
   mandreelFatData = mandreelFatPreloadRequest.response;
  }
  if ( mandreelFatData == "" )
  {
   dump("error loading mandreel.fat file, Maybe the working folder is not correctly set???");
  }

  var packfiledata = null;
  var compressed = false;
  var packfiledata_size = 0;
  var total_packtexture_size = 0;
  var pogsize = 0;

  // Check version
  var FatLines = mandreelFatData.split('\n');
  for ( var i=0;i<FatLines.length;++i )
  {
   var line = mandreel_removecr(FatLines[i]);
   var params = line.split(',');
   if ( params[0] == "version" )
   {
    if ( params[1] != mandrelCurrentFatVersion )
     dump("warning: mandreel.fat version number is ("+params[1]+") and it should be ("+mandrelCurrentFatVersion+")");

   }
   else if ( params[0] == "platform" && params[1] != "js" && (mandreelAppPlatform == "webgl" || mandreelAppPlatform == "canvas")  )
    dump("warning: mandreel.fat platform is ("+params[1]+") and it should be (js)");
   else if ( params[0] == "platform" && params[1] != "nacl" && mandreelAppPlatform == "nacl"  )
    dump("warning: mandreel.fat platform is ("+params[1]+") and it should be (nacl)");
   else if (params[0] == 'packdata')
   {
    packfiledata = params[1];
    compressed = params[2].charAt(0) == '1';
    packfiledata_size =  parseInt(params[3], 10);
   }
   else if (params[0] == 'flashsockets')
   {
    mandreelAppUseFlashSockets = true;
   }
   else if (params[0] == 'packtexture')
   {
    var filename = params[1];
    var size_packtexture = parseInt(params[3], 10);
    total_packtexture_size+=size_packtexture;
    mandreelAppUsePackAsyncTexture.push(filename);
   }
   else if (params[0] == 'audiopreloadfile')
   {
    pogsize = parseInt(params[2],10);
   }
   else if (params[0] == 'audiodriver' && params[1] == 'webaudio')
   {
    try { preCreatedWebAudioContext = new webkitAudioContext(); } catch(err) { preCreatedWebAudioContext = null; }
   }
  }

  if ( preCreatedWebAudioContext != null )
   mandreel_total_pogfile_size = pogsize;
  mandreel_packfiledata_name = packfiledata;
  mandreel_packfiledata_compressed = compressed;
  mandreel_packfiledata_size = packfiledata_size;
  mandreel_total_packtexture_size = total_packtexture_size;
  mandreelFatLoaded();
 }
 mandreelFatPreloadRequest.send();
}

var mandreelAppStartStateFunc = 0;
var mandreelDisableSpaceKey = true;
////////////////////////////////////////////
function mandreelAppStart(startStateFunc,params)
{
 mandreelAppStartStateFunc = startStateFunc;




 if ( typeof(params.log) != 'undefined' )
  mandreelAppLog = params.log;

 if ( typeof(params.platform) != 'undefined' )
  mandreelAppPlatform = params.platform;

 if (typeof(params.mandreelJSCompressed) != 'undefined' )
  mandreelAppMandreelJsCompressed = params.mandreelJSCompressed;


/*  The following code is removed for benchmarking:
if ((mandreel_BrowserDetect.browser == 'Chrome' || mandreel_BrowserDetect.browser == 'Safari') && mandreel_BrowserDetect.OS == 'Mac' && mandreelAppPlatform == "flash")
mandreelDisableSpaceKey = false; */

 if ( mandreelAppPlatform != "webgl" && mandreelAppPlatform != "flash" && mandreelAppPlatform != "nacl" && mandreelAppPlatform != "canvas" && mandreelAppPlatform != "plugin")
 {
  mandreelAppStartStateFunc("error",'platform ('+mandreelAppPlatform+') not supported');
  return;
 }

 if ( mandreelAppPlatform == "webgl" || mandreelAppPlatform == "canvas" )
 {
  mandreelAppWorkingFolder = "data/js/";
  if ( typeof(params.workingFolderWebgl) != 'undefined' )
   mandreelAppWorkingFolder = params.workingFolderWebgl;
  // Check Float64Array availability
  if ( !Mandreel_window["Float64Array"] )
  {
   mandreelAppStartStateFunc("error",'Browser unsupported: Float64Array not available');
   return;
  }

  var flashElement = Mandreel_document.getElementById('FlashWrapper');
  if ( flashElement != null )
  {
   flashElement.style.visibility = "hidden";
   flashElement.style.width = "0px";
   flashElement.style.height = "0px";
  }
  var flashElement = Mandreel_document.getElementById('FlashDiv');
  if ( flashElement != null )
  {
   flashElement.style.visibility = "hidden";
   flashElement.style.width = "0px";
   flashElement.style.height = "0px";
  }

  // Setup WebGL
  if ( typeof(params.webglCanvas) == 'undefined' )
  {
   mandreelAppStartStateFunc("error",'canvas parameter not found');
   return;
  }
  var canvas = Mandreel_document.getElementById(params.webglCanvas);
  if ( canvas == null )
  {
   mandreelAppStartStateFunc("error",'canvas object ('+params.webglCanvas+') not found');
   return;
  }
  if ( params.width != null )
  {
   canvas.width = params.width;
   mandreelAppWidthSrc = params.width;
  }
  if ( params.height != null )
  {
   canvas.height = params.height;
   mandreelAppHeightSrc = params.height;
  }
  if ( mandreelAppPlatform == "webgl" )
  {
   // The following code is removed for benchmarking:
   // imandreel_gl = WebGLUtils.setupWebGL(canvas,{premultipliedAlpha:false,alpha:false});
   // if (imandreel_gl == null)
   // {
   // mandreelAppStartStateFunc("error","webgl_not_found");
   // return;
   // }
  }

  if ( mandreelAppPlatform == "canvas" )
  {
   imandreel_ctx_canvas = canvas.getContext('2d');
   if ( imandreel_ctx_canvas == null )
   {
    mandreelAppStartStateFunc("error","canvas context 2d not found");
    return;
   }
  }

  if (params.cache != null)
  {
   //alert( params.cache.size + params.cache.url);
   mandreel_fs_init(function() { if ( mandreelAppStartStateFunc )
    mandreelAppStartStateFunc("loadingFat","");
   mandreelLoadFat();}, params.cache.size,params.cache.url);
  }
  else
  {
   // load Fat
   if ( mandreelAppStartStateFunc )
    mandreelAppStartStateFunc("loadingFat","");
   mandreelLoadFat();
  }
 }

 if ( mandreelAppPlatform == "flash" )
 {
  mandreelAppWorkingFolder = "data/as3/";
  if ( typeof(params.workingFolderFlash) != 'undefined' )
   mandreelAppWorkingFolder = params.workingFolderFlash;
  if (!swfobject.hasFlashPlayerVersion('11.2.0'))
  {
   mandreelAppStartStateFunc("error","flash 11 not found");
   return;
  }

  if ( typeof(params.flashCanvas) == 'undefined' )
  {
   mandreelAppStartStateFunc("error",'canvas parameter not found');
   return;
  }

  if ( true ) // hide webgl canvas
  {
   var canvas = Mandreel_document.getElementById(mandreelAppCanvasDiv);
   if ( canvas != null )
   {
    canvas.style.visibility = "hidden";
    canvas.style.width = "0px";
    canvas.style.height = "0px";
   }
  }

  if ( params.width != null )
  {
   mandreelAppCanvasWidth = params.width;
  }
  if ( params.height != null )
  {
   mandreelAppCanvasHeight = params.height;
  }

  mandreelAppCanvasDiv = params.flashCanvas;

  try
  {
   var mandreelSocketsSwf = "mandreel.swf";
   if ( typeof(params.swfFlash) != 'undefined' )
    mandreelSocketsSwf = params.swfFlash;

   var my_flashvars = "workingFolder=" + encodeURIComponent(mandreelAppWorkingFolder);
   if ( typeof(params.log) != 'undefined' && params.log == true)
     my_flashvars += "&log=true"
   my_flashvars += "&width=" + params.width;
   my_flashvars += "&height=" + params.height;
   my_flashvars += "&swfloader=" + mandreelSocketsSwf;

   if (typeof(params.restore_context) != 'undefined' && params.restore_context == true)
    my_flashvars += "&restore_context=1";

   if (typeof(params.antialiasing) != 'undefined')
    my_flashvars += "&antialiasing=" + params.antialiasing;

   if (typeof(params.right_click_enable) != 'undefined' && params.right_click_enable == true)
    my_flashvars += "&right_click=1";

   if (typeof(params.disable_depth) != 'undefined' && params.disable_depth == true)
    my_flashvars += "&disable_depth=1";

   var swfname = "mandreelloader.swf";
   if ( typeof(params.swfPreloader) != 'undefined' && params.swfPreloader == false)
    swfname = mandreelSocketsSwf;

   var swf = swfobject.createSWF({ data:swfname, width:"100%", height:"100%" }, { menu:"false",allowScriptAccess:"always",allowFullScreen:"true",wmode:"direct",scale:"noscale",salign :"tl",bgcolor:"#000000",flashvars:my_flashvars}, params.flashCanvas);
   if ( !swf )
   {
    mandreelAppStartStateFunc("error","error loading " + swfname);
    return;
   }
   else
   {
    if ( mandreelAppStartStateFunc )
     mandreelAppStartStateFunc("loadingScript","");
   }
  }
  catch(err)
  {
   mandreelAppStartStateFunc("error","exception " + err + " while loading " + mandreelSocketsSwf);
   return;
  }

  appStartState('loadingScript');
 }

 if ( mandreelAppPlatform == "nacl" )
 {
  mandreelAppWorkingFolder = "data/nacl/";

  // load Fat
  if ( mandreelAppStartStateFunc )
   mandreelAppStartStateFunc("loadingFat","");
  mandreelLoadFat();

 }

 if ( mandreelAppPlatform == "plugin" )
 {
  mandreelInitPluginPlatform(params);
 }
}


////////////////////////////////////////////
function MandreelAudioStartedNacl()
{
 var helloWorldModule = null;
 helloWorldModule = Mandreel_document.getElementById('hello_world');
 helloWorldModule.postMessage('init');
 var flashElement = Mandreel_document.getElementById('FlashWrapper');
 if ( flashElement != null )
  flashElement.style.visibility = "hidden";
 mandreelAppStartStateFunc("ready",mandreelAppCanvasWidth,mandreelAppCanvasHeight);
}

////////////////////////////////////////////
function _mandreelAppStartReady()
{
 if ( mandreelAppPlatform == "nacl" )
 {
  wa_initWebAudio();
  mandreel_webAudio_PreloadAssets();
 }
 else
 {
  if ( mandreelAppStartStateFunc )
  {
   mandreelAppStartRenderWebGL();
   mandreelAppStartStateFunc("ready",mandreelAppCanvasWidth,mandreelAppCanvasHeight);
  }
 }
}
////////////////////////////////////////////
function _mandreelAppAudioReady()
{
 if ( mandreelAppStartStateFunc )
  mandreelAppStartStateFunc("audioLoaded","");

 if ( mandreelAppUseFlashSockets )
  mandreel_flash_sockets_load_flash(_mandreelAppStartReady);
 else
  _mandreelAppStartReady();
}

////////////////////////////////////////////
function mandreelAppInit()
{
 if ( mandreelAppPlatform == "webgl" || mandreelAppPlatform == "canvas" )
 {
  global_init(g_stack_pointer+800*1024);

  //Mandreel_TextureAsync_PackBufferData[_mandreel_currentPackTexture] = mandreelBufferPackAsyncTexture;
  //mandreelBufferPackAsyncTexture = null;
  var sp = g_stack_pointer+800*1024;
  heapU32[sp>>2] = mandreelAppCanvasWidth;
  heapU32[(sp+4)>>2] = mandreelAppCanvasHeight;
  __mandreel_internal_SetResolution(sp);
  __mandreel_internal_init(g_stack_pointer+800*1024);
  __init(g_stack_pointer+800*1024);
 }
}

////////////////////////////////////////////
function mandreelAppDraw(elapsed)
{
 if ( mandreelAppPlatform == "webgl" || mandreelAppPlatform == "canvas" )
 {
  if ( mandreelAppPlatform == "canvas" && imandreel_ctx_canvas != null )
  {
   var canvas = Mandreel_document.getElementById(mandreelAppCanvasName);
   imandreel_ctx_canvas.clearRect(0,0,canvas.width,canvas.height);
  }
  var sp = g_stack_pointer+800*1024;
  __mandreel_internal_preupdate(sp);
  heapU32[sp>>2] = elapsed;
  __draw(sp);
  __mandreel_internal_update(sp);
  __mandreel_process_async_calls();
 }
}

////////////////////////////////////////////
function mandreelAppMouseWheel(delta)
{
 if ( mandreelAppPlatform == "webgl" || mandreelAppPlatform == "canvas" )
 {
  var i7 = MandreelLockFrame();
  heap32[(i7+0)>>2] = delta;
  __mouseWheelDelta(i7);
  MandreelUnlockFrame();
 }
}

////////////////////////////////////////////
function mandreelAppMouseMove(x,y)
{
 if ( mandreelAppPlatform == "webgl" || mandreelAppPlatform == "canvas" )
 {
  var i7 = MandreelLockFrame();
  heap32[(i7+0)>>2] = x;
  heap32[(i7+4)>>2] = y;
  __mouseMove(i7);
  MandreelUnlockFrame();
 }
}

////////////////////////////////////////////
function mandreelAppResize(x,y)
{
 if ( mandreelAppPlatform == "webgl" || mandreelAppPlatform == "canvas" )
 {
  var i7 = MandreelLockFrame();
  heap32[(i7+0)>>2] = x;
  heap32[(i7+4)>>2] = y;
  __resize(i7);
  heap32[(i7+0)>>2] = x;
  heap32[(i7+4)>>2] = y;
  __mandreel_internal_SetResolution(i7);
  MandreelUnlockFrame();
 }
}

////////////////////////////////////////////
function mandreelAppMouseButton(down,x,y)
{
 if ( mandreelAppPlatform == "webgl" || mandreelAppPlatform == "canvas" )
 {
  var i7 = MandreelLockFrame();
  heap32[(i7+0)>>2] = down;
  heap32[(i7+4)>>2] = x;
  heap32[(i7+8)>>2] = y;
  __mouseButton(i7);
  MandreelUnlockFrame();
 }
}

////////////////////////////////////////////
function mandreelAppMouseDblClick(x,y)
{
 if ( mandreelAppPlatform == "webgl" || mandreelAppPlatform == "canvas" )
 {
  var i7 = MandreelLockFrame();
  heap32[(i7+0)>>2] = x;
  heap32[(i7+4)>>2] = y;
  __mouseDoubleClick(i7);
  MandreelUnlockFrame();
 }
}

////////////////////////////////////////////
function mandreelAppKeyEvent(down,keyId)
{
 if ( mandreelAppPlatform == "webgl" || mandreelAppPlatform == "canvas" )
 {
  var i7 = MandreelLockFrame();
  heap32[(i7+0)>>2] = down;
  heap32[(i7+4)>>2] = keyId;
  __keyEvent(i7);
  MandreelUnlockFrame();
 }
}

////////////////////////////////////////////
function mandreelAppGetPlatform()
{
 return mandreelAppPlatform;
}

////////////////////////////////////////////
function mandreelAppGetElementAbsolutePos(elementName)
{
 var element = Mandreel_document.getElementById(elementName);
 var res = new Object();
 res.x = 0; res.y = 0;
 if (element !== null)
 {
  if (element.getBoundingClientRect)
  {
   var viewportElement = Mandreel_document.documentElement;
   var box = element.getBoundingClientRect();
   var scrollLeft = viewportElement.scrollLeft;
   var scrollTop = viewportElement.scrollTop;
   res.x = box.left + scrollLeft;
   res.y = box.top + scrollTop;
  }
  else
  { //for old browsers
   res.x = element.offsetLeft;
   res.y = element.offsetTop;
   var parentNode = element.parentNode;
   var borderWidth = null;
   while (offsetParent != null)
   {
    res.x += offsetParent.offsetLeft;
    res.y += offsetParent.offsetTop;
    var parentTagName = offsetParent.tagName.toLowerCase();
    if ((__isIEOld && parentTagName != "table") ||
     ((__isFireFoxNew || __isChrome) &&
      parentTagName == "td"))
    {
     borderWidth = kGetBorderWidth(offsetParent);
     res.x += borderWidth.left;
     res.y += borderWidth.top;
    }

    if (offsetParent != Mandreel_document.body &&
    offsetParent != Mandreel_document.documentElement)
    {
     res.x -= offsetParent.scrollLeft;
     res.y -= offsetParent.scrollTop;
    }

    //next lines are necessary to fix the problem
    //with offsetParent
    if (!__isIE && !__isOperaOld || __isIENew)
    {
     while (offsetParent != parentNode &&
      parentNode !== null) {
      res.x -= parentNode.scrollLeft;
      res.y -= parentNode.scrollTop;
      if (__isFireFoxOld || __isWebKit)
      {
          borderWidth =
           kGetBorderWidth(parentNode);
          res.x += borderWidth.left;
          res.y += borderWidth.top;
      }
      parentNode = parentNode.parentNode;
     }
    }

    parentNode = offsetParent.parentNode;
    offsetParent = offsetParent.offsetParent;
   }
  }
 }
 return res;
}
function __getIEVersion()
{
 var rv = -1; // Return value assumes failure.
 if (navigator.appName == 'Microsoft Internet Explorer')
 {
  var ua = navigator.userAgent;
  var re = new RegExp("MSIE ([0-9]{1,}[\.0-9]{0,})");
  if (re.exec(ua) != null)
   rv = parseFloat(RegExp.$1);
 }
 return rv;
}
function __getOperaVersion()
{
 var rv = 0; // Default value
 if (Mandreel_window.opera)
 {
  var sver = Mandreel_window.opera.version();
  rv = parseFloat(sver);
 }
 return rv;
}
/* The following code was removed for benchmarking:
var __userAgent = navigator.userAgent;
var __isIE =  navigator.appVersion.match(/MSIE/) != null;
var __IEVersion = __getIEVersion();
var __isIENew = __isIE && __IEVersion >= 8;
var __isIEOld = __isIE && !__isIENew;
var __isFireFox = __userAgent.match(/firefox/i) != null;
var __isFireFoxOld = __isFireFox && ((__userAgent.match(/firefox\/2./i) != null) || (__userAgent.match(/firefox\/1./i) != null));
var __isFireFoxNew = __isFireFox && !__isFireFoxOld;
var __isWebKit =  navigator.appVersion.match(/WebKit/) != null;
var __isChrome =  navigator.appVersion.match(/Chrome/) != null;
var __isOpera =  Mandreel_window.opera != null;
var __operaVersion = __getOperaVersion();
var __isOperaOld = __isOpera && (__operaVersion < 10); */
function __parseBorderWidth(width)
{
 var res = 0;
 if (typeof(width) == "string" && width != null && width != "" )
 {
  var p = width.indexOf("px");
  if (p >= 0)
  {
   res = parseInt(width.substring(0, p));
  }
  else
  {
   //do not know how to calculate other values (such as 0.5em or 0.1cm) correctly now so just set the width to 1 pixel
   res = 1;
  }
 }
 return res;
}
function __getBorderWidth(element)
{
 var res = new Object();
 res.left = 0; res.top = 0; res.right = 0; res.bottom = 0;
 if (Mandreel_window.getComputedStyle)
 {
  //for Firefox
  var elStyle = Mandreel_window.getComputedStyle(element, null);
  res.left = parseInt(elStyle.borderLeftWidth.slice(0, -2));
  res.top = parseInt(elStyle.borderTopWidth.slice(0, -2));
  res.right = parseInt(elStyle.borderRightWidth.slice(0, -2));
  res.bottom = parseInt(elStyle.borderBottomWidth.slice(0, -2));
 }
 else
 {
  //for other browsers
  res.left = __parseBorderWidth(element.style.borderLeftWidth);
  res.top = __parseBorderWidth(element.style.borderTopWidth);
  res.right = __parseBorderWidth(element.style.borderRightWidth);
  res.bottom = __parseBorderWidth(element.style.borderBottomWidth);
 }
 return res;
}


////////////////////////////////////////////
// WebGL
////////////////////////////////////////////
 var imandreel_gl = null;
 var imandreel_ctx_canvas = null;
 var imandreel_is_ready = 0;
 var imandreel_oldTime = Date_now();

 function mandreel_wheel(event) { imandreel_onMouseWheel(event);event.preventDefault(); event.returnValue=false; }

 ////////////////////////////////////////////
 function mandreelAppStartRenderWebGL()
 {
/* The following code was removed for benchmarking:
var canvas = document.getElementById(mandreelAppCanvasName);

mandreelAppCanvasWidth = canvas.width;
mandreelAppCanvasHeight = canvas.height;

// Register event handlers
if(window.addEventListener){ window.addEventListener('DOMMouseScroll',mandreel_wheel,false); }  window.onmousewheel=document.onmousewheel=mandreel_wheel;

window.addEventListener('mousedown',imandreel_onMouseDown,false);
window.addEventListener('mouseup',imandreel_onMouseUp,false);
window.addEventListener('mousemove',imandreel_onMouseMove,false);
window.addEventListener('dblclick',imandreel_onMouseDblClick,false);

document.body.oncontextmenu = function() { return false;};

var canvasDiv = document.getElementById(mandreelAppCanvasDiv);
canvasDiv.addEventListener('keydown',imandreel_onKeyDown,false);
canvasDiv.addEventListener('keyup',imandreel_onKeyUp,false);
canvasDiv.focus();*/

  // Call mandreel app init funtion (__init())
  mandreelAppInit();

  // Start rendering
  imandreel_is_ready = 1;
  //imandreel_render();
 }

 ////////////////////////////////////////////
 function imandreel_render()
 {
  if( ABORT )
   return;

  var canvas = Mandreel_document.getElementById(mandreelAppCanvasName);
  WebGLUtils.requestAnimationFrame(canvas, imandreel_render);


  // Reshape
  if (canvas.clientWidth != mandreelAppCanvasWidth || canvas.clientHeight != mandreelAppCanvasHeight)
  {
   mandreelAppCanvasWidth = canvas.clientWidth;
   mandreelAppCanvasHeight = canvas.clientHeight;
   imandreel_gl.viewport(0, 0, mandreelAppCanvasWidth, mandreelAppCanvasHeight);
  }

  // Set the focus to the canvas div
  if (mandreelAppForceFocus)
  {
   var canvasDiv = Mandreel_document.getElementById(mandreelAppCanvasDiv);
   canvasDiv.focus();
  }

  // Call mandreel app draw funtion (__draw())
  var nowTime = Date_now();
  if (!g_mandreel_frame_locked)
  {
   g_mandreel_frame_inframe = true;
   if (!_imandreel_pause_game)
    mandreelAppDraw(nowTime-imandreel_oldTime);
   g_mandreel_frame_inframe = false;
  }
  imandreel_oldTime = nowTime;
 }

 function render()
 {
  // Call mandreel app draw funtion (__draw())
  var nowTime = Date_now();
  if (!g_mandreel_frame_locked)
  {
   g_mandreel_frame_inframe = true;
   if (!_imandreel_pause_game)
    mandreelAppDraw(nowTime-imandreel_oldTime);
   g_mandreel_frame_inframe = false;
  }
  imandreel_oldTime = nowTime;
 }

 var imandreel_last_movex = 0;
 var imandreel_last_movey = 0;

 ////////////////////////////////////////////
 function imandreel_onMouseMove(e)
 {
  if (!imandreel_is_ready)
   return;

  if (_imandreel_pause_game)
   return;

  var pos = mandreelAppGetElementAbsolutePos(mandreelAppCanvasName);
  var setX = e.clientX - pos.x;
  var setY = e.clientY - pos.y;

    if(navigator.pointer && navigator.pointer.isLocked) {
            var deltaX = event.movementX || event.webkitMovementX || event.mozMovementX || 0;
            var deltaY = event.movementY || event.webkitMovementY || event.mozMovementX || 0;

   setX = imandreel_last_movex+deltaX;
   setY = imandreel_last_movey+deltaY;
   }


  imandreel_last_movex = setX;
  imandreel_last_movey = setY;
  mandreelAppMouseMove(setX,setY);
 }

 ////////////////////////////////////////////
 function imandreel_onMouseDblClick(e)
 {
  if (!imandreel_is_ready)
   return;

  if (_imandreel_pause_game)
   return;

  var pos = mandreelAppGetElementAbsolutePos(mandreelAppCanvasName);
  var setX = e.clientX - pos.x;
  var setY = e.clientY - pos.y;
  mandreelAppMouseDblClick(setX,setY);
 }

 ////////////////////////////////////////////
 var mandreel_mouse_down = false;
 var mandreel_rmouse_down = false;
 function imandreel_onMouseDown(e)
 {
  if (!imandreel_is_ready)
   return;

  if (_imandreel_pause_game)
   return;

  var rightclick;
  if (!e) var e = Mandreel_window.event;
  if (e.which) rightclick = (e.which == 3);
  else if (e.button) rightclick = (e.button == 2);

  var pos = mandreelAppGetElementAbsolutePos(mandreelAppCanvasName);
  var setX = e.clientX - pos.x;
  var setY = e.clientY - pos.y;

  if (!rightclick)
  {
   if (mandreel_mouse_down)
    return;

   mandreel_mouse_down = true;
   mandreelAppMouseButton(1,setX,setY);
  }
  else
  {
   if (mandreel_rmouse_down)
    return;

   mandreel_rmouse_down = true;
   mandreelAppMouseButton(3,setX,setY);
  }
 }

 ////////////////////////////////////////////
 function imandreel_onMouseUp(e)
 {
  if (!imandreel_is_ready)
   return;

  if (_imandreel_pause_game)
   return;

  var rightclick;
  if (!e) var e = Mandreel_window.event;
  if (e.which) rightclick = (e.which == 3);
  else if (e.button) rightclick = (e.button == 2);

  var pos = mandreelAppGetElementAbsolutePos(mandreelAppCanvasName);
  var setX = e.clientX - pos.x;
  var setY = e.clientY - pos.y;


  if (!rightclick)
  {
   if (mandreel_mouse_down == false)
    return;

   mandreel_mouse_down = false;
   mandreelAppMouseButton(0,setX,setY);
  }
  else
  {
   if (mandreel_rmouse_down == false)
    return;

   mandreel_rmouse_down = false;
   mandreelAppMouseButton(2,setX,setY);
  }
 }

 ////////////////////////////////////////////
 function imandreel_onMouseWheel(e)
 {
  if (!imandreel_is_ready)
   return;

  if (_imandreel_pause_game)
   return;

  mandreelAppMouseWheel(e.wheelDelta);
 }

 ////////////////////////////////////////////
 function imandreel_onKeyUp(e)
 {
  if (!imandreel_is_ready)
   return;

  if (_imandreel_pause_game)
   return;

  var KeyID = e.keyCode;
  mandreelAppKeyEvent(0,KeyID);
 }

 ////////////////////////////////////////////
 Mandreel_window.onkeydown = function(e)
 {
  if (mandreelDisableSpaceKey == false && e.keyCode == 32)
   return;
  return !(e.keyCode == 32 || e.keyCode == 9);
 };

 ////////////////////////////////////////////
 function imandreel_onKeyDown(e)
 {
  if (e.which === 8) // disable back button on browser
        {
         e.preventDefault();
     }
  if (!imandreel_is_ready)
   return;

  if (_imandreel_pause_game)
   return;

  var KeyID = e.keyCode;
  mandreelAppKeyEvent(1,KeyID);
 }


////////////////////////////////////////////
// Flash
////////////////////////////////////////////

(function(){
  try {
   // Disabling SWFObject's Autohide feature
   if (typeof swfobject.switchOffAutoHideShow === "function") {
    swfobject.switchOffAutoHideShow();
   }
  } catch(e) {}
 })();

var imandreel_flash_global_sp = 0;
var imandreel_flash_global_sp2 = 0;
var imandreel_flash_current_sp = 0;

function MandreelInterSwfLoaded2()
{
}
function MandreelInterSwfLoaded()
{
 appStartState('scriptLoaded');
 var flashMovie = swfobject.getObjectById(mandreelAppCanvasDiv)
 dump(flashMovie.width);
 flashMovie.MandreelInit();

 imandreel_flash_global_sp = MandreelInterGetSWF().MandreelInterGetGlobalStack();
 imandreel_flash_global_sp2 = MandreelInterGetSWF().MandreelInterGetGlobalStack2();
 if ( mandreelAppStartStateFunc )
  mandreelAppStartStateFunc("ready",mandreelAppCanvasWidth,mandreelAppCanvasHeight);
}



var g_mandreel_swf = null;

function MandreelInterGetSWF()
{
 if (g_mandreel_swf)
  return g_mandreel_swf;

 g_mandreel_swf = swfobject.getObjectById(mandreelAppCanvasDiv)
 return g_mandreel_swf;
}

function MandreelInterWriteInt(ptr, value)
{
 MandreelInterGetSWF().MandreelInterWriteInt(ptr,value);
}

function MandreelInterWriteFloat(ptr, value)
{
 MandreelInterGetSWF().MandreelInterWriteFloat(ptr,value);
}

function MandreelInterWriteString(ptr, value)
{
 MandreelInterGetSWF().MandreelInterWriteString(ptr,value);
}

function MandreelInterWriteWString(ptr, value)
{
 MandreelInterGetSWF().MandreelInterWriteWString(ptr,value);
}

function MandreelInterCallFunctionRaw(sp, func_name, returnType)
{
 return MandreelInterGetSWF().MandreelInterCallFunctionRaw(sp,func_name,returnType);
}


function assert(condition, _text) {
//console.assert(condition, _text);
    if (!condition) {
      var text = "Assertion failed: " + _text;
      alert(text + ':\n' + (new Error).stack);
      ABORT = true;
      throw "Assertion: " + text;
    }
  }



function MandreelLockFrame()
{
 MandreelInterGetSWF().MandreelLockFrame();

 imandreel_flash_current_sp += 300*1024;

 assert(imandreel_flash_current_sp<1024*1024);

 return imandreel_flash_current_sp;
}

function MandreelPause()
{
 MandreelInterGetSWF().MandreelPause();
}

function MandreelResume()
{
 MandreelInterGetSWF().MandreelResume();
}


function MandreelUnlockFrame()
{
 imandreel_flash_current_sp -= 300*1024;
 MandreelInterGetSWF().MandreelUnlockFrame();
}



function MandreelInterCallFunctionAsync(func_name,param)
{
 return MandreelInterGetSWF().MandreelInterCallFunctionAsync(func_name, param);
}


function MandreelInterCallFunction(returnType,func_name)
{
 var size_params = 0;

 var i;
 var num_params = (arguments.length-2)/2;
 num_params|=0;
 for (i=2;i<num_params*2+2;i+=2)
 {
  var type = arguments[i];

  var size_arg = 0;
  switch(type)
  {
   case 'int':
    size_arg = 4;
    break;
   case 'float':
    size_arg = 4;
    break;
   case 'string':
    size_arg = 4;
    size_arg += ((arguments[i+1].length + 4) & 0xfffffffc);
    break;
   case 'wstring':
    size_arg = 4;
    size_arg += ((arguments[i+1].length*2 + 4) & 0xfffffffc);
    break;
   default:
    assert(false);
  }

  size_params += size_arg;
 }

 // stack always 8 byte aligned
 size_params=((size_params+7)& 0xfffffff8);

 var sp = 0;

 if (i<(arguments.length))
  sp = arguments[i];
 else
 {
  assert(false);
 }


 sp-=size_params;

 MandreelLockFrame();

 var offset = 0;
 var ptr_data = num_params*4+sp;
    for (i=2;i<num_params*2+2;i+=2)
 {
  var type = arguments[i];


  var size_arg = 0;
  switch(type)
  {
   case 'int':
    MandreelInterWriteInt((sp+offset),arguments[i+1]);
    break;
   case 'float':
    MandreelInterWriteFloat((sp+offset),arguments[i+1]);
    break;
   case 'string':
    {
     MandreelInterWriteInt((sp+offset),ptr_data);
     var string = arguments[i+1];
     MandreelInterWriteString(ptr_data,string);

     ptr_data += ((string.length + 4) & 0xfffffffc);
    }
    break;
   case 'wstring':
    {
     MandreelInterWriteInt((sp+offset),ptr_data);
     var string = arguments[i+1];
     MandreelInterWriteWString(ptr_data,string);

     ptr_data += ((string.length*2 + 4) & 0xfffffffc);
    }
    break;
   default:
    assert(false);
  }
  offset+=4;
 }

 return_value = MandreelInterCallFunctionRaw(sp, func_name, returnType);

 MandreelUnlockFrame();

 if (returnType == 'int')
  return parseInt(return_value);
 else if (returnType == 'float')
  return parseFloat(return_value);

 return;
}



// file system

var g_mandreel_timestamp_fs = 0;
var g_mandreel_fs = null;

function onMandreelQuotaOk(fs)
{
 g_mandreel_fs = fs;
 dump('onMandreelQuotaOk');
}


function MandreelFsErrorHandler(e) {
  var msg = '';

  switch (e.code) {
    case FileError.QUOTA_EXCEEDED_ERR:
      msg = 'QUOTA_EXCEEDED_ERR';
      break;
    case FileError.NOT_FOUND_ERR:
      msg = 'NOT_FOUND_ERR';
      break;
    case FileError.SECURITY_ERR:
      msg = 'SECURITY_ERR';
      break;
    case FileError.INVALID_MODIFICATION_ERR:
      msg = 'INVALID_MODIFICATION_ERR';
      break;
    case FileError.INVALID_STATE_ERR:
      msg = 'INVALID_STATE_ERR';
      break;
    default:
      msg = 'Unknown Error';
      break;
  };

  dump('Error: ' + msg);
  dump(e);
}

var indexedDB = Mandreel_window.indexedDB || Mandreel_window.webkitIndexedDB ||
                Mandreel_window.mozIndexedDB;

if ('webkitIndexedDB' in Mandreel_window) {
  Mandreel_window.IDBTransaction = Mandreel_window.webkitIDBTransaction;
  Mandreel_window.IDBKeyRange = Mandreel_window.webkitIDBKeyRange;
}


var mandreel_indexedDB = {};
mandreel_indexedDB.db = null;
mandreel_indexedDB.callback_init = false;

mandreel_indexedDB.onerror = function(e) {
  dump(e);
};

mandreel_indexedDB.init = function(callback)
{
 try {
 var request = indexedDB.open('my_cache', 2);

 request.onerror = function(event) {
  callback(false);
  };
 request.onupgradeneeded = function(event) {
 dump('onupgradeneeded\n');
 mandreel_indexedDB.db = event.target.result;
    var db = mandreel_indexedDB.db;
 var objectStore = db.createObjectStore("cache",{keyPath: "fileName"});
 }

  request.onsuccess = function(event) {
  dump('onsuccess\n');
    mandreel_indexedDB.db = event.target.result;
     callback(true);

  };
  }
  catch(e)
  {
 callback(false);
  }

}

function mandreel_fs_init(callback, size_bytes, url_time)
{

 g_mandreel_timestamp_fs = 99999999999999;




 var aux = null;
 try { aux = webkitStorageInfo; } catch(err) { aux = null; }
 if (aux == null)
 {
  //callback(false);

  var time_request = new XMLHttpRequest();
 time_request.open('GET',url_time);
 time_request.onreadystatechange = function()
 {
  if (time_request.readyState==4)
  {
   if (time_request.status==200 || time_request.status==0)
   {

    if (time_request.responseText)
    {
     g_mandreel_timestamp_fs = parseFloat(time_request.responseText);
     dump('mandreel_init_fs time ' + g_mandreel_timestamp_fs);
    }
   }

   mandreel_indexedDB.init(callback);
  }
 }
 time_request.send();


  return;
 }

 webkitStorageInfo.requestQuota(
  webkitStorageInfo.PERSISTENT ,   // or PERSISTENT
  size_bytes,
  function(bytes) {  dump('request quota succeed');},
  function () { dump('request quota failed');} );


// g_mandreel_timestamp_fs =0;

 var time_request = new XMLHttpRequest();
 time_request.open('GET',url_time);
 time_request.onreadystatechange = function()
 {
  if (time_request.readyState==4)
  {
   if (time_request.status==200 || time_request.status==0)
   {

    if (time_request.responseText)
    {
     g_mandreel_timestamp_fs = parseFloat(time_request.responseText);
     dump('mandreel_init_fs time ' + g_mandreel_timestamp_fs);
    }
   }

   var my_requestFileSystem  = Mandreel_window.requestFileSystem || Mandreel_window.webkitRequestFileSystem;

   my_requestFileSystem(Mandreel_window.PERSISTENT, size_bytes,
    function(result)
    {
     onMandreelQuotaOk(result);


     if (callback)
      Mandreel_setTimeout(callback, 100, true);
    } , function(e) { MandreelFsErrorHandler(e); if (callback) callback(false); } );
  }
 }
 time_request.send();
}


mandreel_indexedDB.load = function(file_name, callback)
{
 var db = mandreel_indexedDB.db;
 var trans = db.transaction(["cache"]);
 var store = trans.objectStore("cache");

 var key = file_name;

  var getReq = store.get(key);
    getReq.onsuccess = function (ev) {
   if (getReq.result)
 {
 dump('chanka ' + g_mandreel_timestamp_fs + ' ' + getReq.result.timeStamp + '\n');
    if (getReq.result.timeStamp>=g_mandreel_timestamp_fs)
     callback(getReq.result.data);
    else
     callback(null);
   }
   else
    callback(null);
    }
    getReq.onerror = function (ev) {
     console.log("index.get failed. Error: " + ev.message);
    }
}

function mandreel_fs_get_url(file_name, callback)
{
 if (mandreel_indexedDB.db)
 {
  callback(null);
  return;
 }


 if (g_mandreel_fs == null)
 {
  callback(null);
  return;
 }

 g_mandreel_fs.root.getFile(file_name, {}, function(fileEntry) {

 fileEntry.getMetadata(function(metaData){
 var my_seconds = metaData.modificationTime.getTime()/1000;

 if (g_mandreel_timestamp_fs>my_seconds)
 {
  callback(null);
 }
 else
 {
  //alert('mandreel_fscachefile2');


  if (Mandreel_window.localStorage.getItem(mandreel_fs_get_key(file_name)) != null)
   callback(fileEntry.toURL());
  else
   callback(null);

 }


  }, MandreelFsErrorHandler);


  }, function(error) {callback(null);});

  return;

}

function mandreel_fs_load_binary(file_name, callback)
 {
 if (mandreel_indexedDB.db)
 {
  mandreel_indexedDB.load(file_name,callback);
  return;
 }


 if (g_mandreel_fs == null)
 {
  callback(null);
  return;
 }


 g_mandreel_fs.root.getFile(file_name, {}, function(fileEntry) {

 fileEntry.getMetadata(function(metaData){
 var my_seconds = metaData.modificationTime.getTime()/1000;

 if (g_mandreel_timestamp_fs>my_seconds)
 {
  dump('mandreel_fscachefile1');
  Mandreel_window.localStorage.removeItem(mandreel_fs_get_key(file_name));
  fileEntry.remove(function() {
    callback(null);
   }, MandreelFsErrorHandler);

 }
 else
 {
  //alert('mandreel_fscachefile2');
  dump('mandreel_fscachefile2 ' + my_seconds);

  fileEntry.file(function(file) {

    var reader = new FileReader();


      reader.onloadend = function(e) {

       if (this.result.byteLength && Mandreel_window.localStorage.getItem(mandreel_fs_get_key(file_name)) != null)
       {
      dump('mandreel_fs_loadFile ' + file_name);
      callback(this.result);
     }
     else
      callback(null);

      };


     reader.readAsArrayBuffer(file);


   }, MandreelFsErrorHandler);

 }


  }, MandreelFsErrorHandler);


  }, function(error) {dump('mandreel_fscachefile3'); callback(null);});

  return;
 }


 mandreel_indexedDB.save = function(file_name, data)
{
 var db = mandreel_indexedDB.db;


  var trans = db.transaction(["cache"], IDBTransaction.READ_WRITE);
  var store = trans.objectStore("cache");
  var request = store.put({
    "data": data,
 "timeStamp" : Date_now()/1000,
    "fileName" : file_name
  });

  request.onsuccess = function(e) {
    // Re-render all the todo's
   // html5rocks.indexedDB.getAllTodoItems();
   dump('mandreel_indexedDB.save ok ');
  };

  request.onerror = function(e) {
    dump('mandreel_indexedDB.save onerror ' + file_name);
 dump(e);
  };
}

function mandreel_fs_get_key(name)
{
 return 'mandreel_fs_' + name;
}

function mandreel_is_filesystem()
{
 if (mandreel_indexedDB.db)
  return false;

 if (!g_mandreel_fs)
  return false;

 return true;
}

function mandreel_is_indexeddb()
{
 if (mandreel_indexedDB.db)
  return true;

 return false;
}

 function mandreel_fs_saveFile(name, my_arrayBuffer)
{
 if (mandreel_indexedDB.db)
 {
  mandreel_indexedDB.save(name,my_arrayBuffer);
  return;
 }

 if (!g_mandreel_fs)
  return;

 Mandreel_window.localStorage.removeItem(mandreel_fs_get_key(name));
 g_mandreel_fs.root.getFile(name, {create: true}, function(fileEntry) {

    // Create a FileWriter object for our FileEntry (log.txt).
    fileEntry.createWriter(function(fileWriter) {

      fileWriter.onwriteend = function(e) {
  Mandreel_window.localStorage.setItem(mandreel_fs_get_key(name),'valid');
        dump('Write completed.');
      };

      fileWriter.onerror = function(e) {
        dump('Write failed: ' + e.toString());
      };

   var my_BlobBuilder = Mandreel_window.MozBlobBuilder || Mandreel_window.WebKitBlobBuilder || Mandreel_window.BlobBuilder;

   var bb = new my_BlobBuilder(); // Note: window.WebKitBlobBuilder in Chrome 12.
      bb.append(my_arrayBuffer);
      fileWriter.write(bb.getBlob('text/plain'));



    }, MandreelFsErrorHandler);

  }, MandreelFsErrorHandler);
}


function mandreel_fs_load_text(file_name, callback)
 {

 if (mandreel_indexedDB.db)
 {
  mandreel_indexedDB.load(file_name,callback);
  return;
 }

 if (g_mandreel_fs == null)
 {
  callback(null);
  return;
 }


 g_mandreel_fs.root.getFile(file_name, {}, function(fileEntry) {

 fileEntry.getMetadata(function(metaData){
 var my_seconds = metaData.modificationTime.getTime()/1000;

 if (g_mandreel_timestamp_fs>my_seconds)
 {
  dump('mandreel_fscachefile1');
  Mandreel_window.localStorage.removeItem(mandreel_fs_get_key(file_name));
  fileEntry.remove(function() {
    callback(null);
   }, MandreelFsErrorHandler);

 }
 else
 {
  //alert('mandreel_fscachefile2');
  dump('mandreel_fscachefile2 ' + my_seconds);

  fileEntry.file(function(file) {

    var reader = new FileReader();


      reader.onloadend = function(e) {


       if (this.result.length && Mandreel_window.localStorage.getItem(mandreel_fs_get_key(file_name)) != null)
       {
      dump('mandreel_fs_loadFile ' + file_name);
      callback(this.result);
     }
     else
      callback(null);

      };


     reader.readAsText(file);


   }, MandreelFsErrorHandler);

 }


  }, MandreelFsErrorHandler);


  }, function(error) {dump('mandreel_fscachefile3'); callback(null);});

  return;
 }


 // full screen


/* The following code was removed for benchmarking:
 var __screen = screen; */

 try
 {
 (function(global) {
    "use strict";
 var elementPrototype = (global.HTMLElement || global.Element)["prototype"];

  // document.isFullScreen
    if(!Mandreel_document.hasOwnProperty("fullscreenEnabled")) {
        var getter = (function() {
            // These are the functions that match the spec, and should be preferred
            if("webkitIsFullScreen" in Mandreel_document) {
                return function() { return Mandreel_document.webkitIsFullScreen; }
            }
            if("mozFullScreen" in Mandreel_document) {
                return function() { return Mandreel_document.mozFullScreen; }
            }
            return function() { return false }; // not supported, never fullscreen
        })();

        Object.defineProperty(Mandreel_document, "fullscreenEnabled", {
            enumerable: true, configurable: false, writeable: false,
            get: getter
        });
    }

    if(!Mandreel_document.hasOwnProperty("fullscreenElement")) {
        var getter = (function() {
            // These are the functions that match the spec, and should be preferred
            if("webkitFullscreenElement" in Mandreel_document) {
                return function() { return Mandreel_document.webkitFullscreenElement; }
            }
            if("mozFullscreenElemen" in Mandreel_document) {
                return function() { return Mandreel_document.mozFullscreenElemen; }
            }
            return function() { return null }; // not supported
        })();

        Object.defineProperty(Mandreel_document, "fullscreenElement", {
            enumerable: true, configurable: false, writeable: false,
            get: getter
        });
    }

    // Document event: fullscreenchange
    function fullscreenchange(oldEvent) {
        var newEvent = Mandreel_document.createEvent("CustomEvent");
        newEvent.initCustomEvent("fullscreenchange", true, false, null);
        // TODO: Any need for variable copy?
        Mandreel_document.dispatchEvent(newEvent);
    }
    Mandreel_document.addEventListener("webkitfullscreenchange", fullscreenchange, false);
    Mandreel_document.addEventListener("mozfullscreenchange", fullscreenchange, false);

    // Document event: fullscreenerror
    function fullscreenerror(oldEvent) {
        var newEvent = Mandreel_document.createEvent("CustomEvent");
        newEvent.initCustomEvent("fullscreenerror", true, false, null);
        // TODO: Any need for variable copy?
        Mandreel_document.dispatchEvent(newEvent);
    }
    Mandreel_document.addEventListener("webkitfullscreenerror", fullscreenerror, false);
    Mandreel_document.addEventListener("mozfullscreenerror", fullscreenerror, false);

    // element.requestFullScreen
    if(!elementPrototype.requestFullScreen) {
        elementPrototype.requestFullScreen = (function() {
            if(elementPrototype.webkitRequestFullScreen) {
                return function() {
                    this.webkitRequestFullScreen(Element.ALLOW_KEYBOARD_INPUT);
                }
            }

            return  elementPrototype.mozRequestFullScreen    ||
                    function(){ /* unsupported, fail silently */ };
        })();
    }

    // document.cancelFullscreen
    if(!Mandreel_document.cancelFullScreen) {
        Mandreel_document.cancelFullScreen = (function() {
            return  Mandreel_document.webkitCancelFullScreen ||
                    Mandreel_document.mozCancelFullScreen ||
                    function(){ /* unsupported, fail silently */ };
        })();
    }
 })((typeof(exports) != 'undefined') ? global : Mandreel_window);
 }
 catch(e)
 {
 }


try
 {
var __onErrorFullscreen = function() {
  dump("Mouse lock was not successful.");
};

Mandreel_document.addEventListener('fullscreenchange', function(e) {

var width;
var height;
 var canvas = Mandreel_document.getElementById(mandreelAppCanvasName);
 if(Mandreel_document.fullscreenEnabled) {


            width = __screen.width;
            height = __screen.height;

        } else {
            width = mandreelAppWidthSrc;
            height = mandreelAppHeightSrc;
        }

  canvas.width = width;
  canvas.height = height;
  mandreelAppResize(width, height);

  if (Mandreel_document.fullscreenEnabled && navigator.pointer) {
    navigator.pointer.lock(Mandreel_document.body, function() {
      // Locked and ready to play.
    }, __onErrorFullscreen);
  }
}, false);

}
catch(e)
{
}



function mandreelAppFullscreen(enable)
{
 var canvas = Mandreel_document.getElementById(mandreelAppCanvasName);
 if ( mandreelAppPlatform == "webgl" || mandreelAppPlatform == "canvas" )
 {
  if (canvas)
  {
   if (enable)
    canvas.requestFullScreen();
   else
    Mandreel_document.cancelFullScreen();
  }
 }
}


function mandreelAppDisableForceFocus()
{
 mandreelAppForceFocus = false;
}

function mandreelAppEnableForceFocus()
{
 mandreelAppForceFocus = true;
}

var imandreel_base64 = {};
imandreel_base64.PADCHAR = '=';
imandreel_base64.ALPHA = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';

imandreel_base64.makeDOMException = function() {
    // sadly in FF,Safari,Chrome you can't make a DOMException
    var e, tmp;

    try {
        return new DOMException(DOMException.INVALID_CHARACTER_ERR);
    } catch (tmp) {
        // not available, just passback a duck-typed equiv
        // https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Global_Objects/Error
        // https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Global_Objects/Error/prototype
        var ex = new Error("DOM Exception 5");

        // ex.number and ex.description is IE-specific.
        ex.code = ex.number = 5;
        ex.name = ex.description = "INVALID_CHARACTER_ERR";

        // Safari/Chrome output format
        ex.toString = function() { return 'Error: ' + ex.name + ': ' + ex.message; };
        return ex;
    }
}

imandreel_base64.getbyte64 = function(s,i) {
    // This is oddly fast, except on Chrome/V8.
    //  Minimal or no improvement in performance by using a
    //   object with properties mapping chars to value (eg. 'A': 0)
    var idx = imandreel_base64.ALPHA.indexOf(s.charAt(i));
    if (idx === -1) {
        throw imandreel_base64.makeDOMException();
    }
    return idx;
}

imandreel_base64.decode = function(s) {
    // convert to string
    s = '' + s;
    var getbyte64 = imandreel_base64.getbyte64;
    var pads, i, b10;
    var imax = s.length
    if (imax === 0) {
        return s;
    }

    if (imax % 4 !== 0) {
        throw imandreel_base64.makeDOMException();
    }

    pads = 0
    if (s.charAt(imax - 1) === imandreel_base64.PADCHAR) {
        pads = 1;
        if (s.charAt(imax - 2) === imandreel_base64.PADCHAR) {
            pads = 2;
        }
        // either way, we want to ignore this last block
        imax -= 4;
    }

    var x = [];
    for (i = 0; i < imax; i += 4) {
        b10 = (getbyte64(s,i) << 18) | (getbyte64(s,i+1) << 12) |
            (getbyte64(s,i+2) << 6) | getbyte64(s,i+3);
        x.push(String.fromCharCode(b10 >> 16, (b10 >> 8) & 0xff, b10 & 0xff));
    }

    switch (pads) {
    case 1:
        b10 = (getbyte64(s,i) << 18) | (getbyte64(s,i+1) << 12) | (getbyte64(s,i+2) << 6);
        x.push(String.fromCharCode(b10 >> 16, (b10 >> 8) & 0xff));
        break;
    case 2:
        b10 = (getbyte64(s,i) << 18) | (getbyte64(s,i+1) << 12);
        x.push(String.fromCharCode(b10 >> 16));
        break;
    }
    return x.join('');
}

if (!Mandreel_window.atob) {
Mandreel_window.atob = function(a) { return  imandreel_base64.decode(a); }
}


function imandreel_interop_callbridge(new_method, sp)
{

 var n = new Array();

 for( var i = 2; i < arguments.length; i++ )
 {

  if (typeof arguments[i] == 'string')
   n.push(atob(arguments[i]));
  else
   n.push(arguments[i]);
 }

 var total_args = arguments.length-2;

 switch(total_args)
 {
  case 0:
   return Mandreel_window[new_method](sp);
  case 1:
   return Mandreel_window[new_method](sp, n[0]);
  case 2:
   return Mandreel_window[new_method](sp, n[0], n[1]);
  case 3:
   return Mandreel_window[new_method](sp, n[0], n[1], n[2]);
  case 4:
   return Mandreel_window[new_method](sp, n[0], n[1], n[2], n[3]);
  case 5:
   return Mandreel_window[new_method](sp, n[0], n[1], n[2], n[3], n[4]);
  case 6:
   return Mandreel_window[new_method](sp, n[0], n[1], n[2], n[3], n[4], n[5]);
  case 7:
   return Mandreel_window[new_method](sp, n[0], n[1], n[2], n[3], n[4], n[5], n[6]);
  case 8:
   return Mandreel_window[new_method](sp, n[0], n[1], n[2], n[3], n[4], n[5], n[6], n[7]);
  case 9:
   return Mandreel_window[new_method](sp, n[0], n[1], n[2], n[3], n[4], n[5], n[6], n[7], n[8]);
  case 10:
   return Mandreel_window[new_method](sp, n[0], n[1], n[2], n[3], n[4], n[5], n[6], n[7], n[8], n[9]);
  case 11:
   return Mandreel_window[new_method](sp, n[0], n[1], n[2], n[3], n[4], n[5], n[6], n[7], n[8], n[9], n[10]);
  case 12:
   return Mandreel_window[new_method](sp, n[0], n[1], n[2], n[3], n[4], n[5], n[6], n[7], n[8], n[9], n[10], n[11]);
  case 13:
   return Mandreel_window[new_method](sp, n[0], n[1], n[2], n[3], n[4], n[5], n[6], n[7], n[8], n[9], n[10], n[11], n[12]);
  case 14:
   return Mandreel_window[new_method](sp, n[0], n[1], n[2], n[3], n[4], n[5], n[6], n[7], n[8], n[9], n[10], n[11], n[12], n[13]);
  case 15:
   return Mandreel_window[new_method](sp, n[0], n[1], n[2], n[3], n[4], n[5], n[6], n[7], n[8], n[9], n[10], n[11], n[12], n[13], n[14]);
  case 16:
   return Mandreel_window[new_method](sp, n[0], n[1], n[2], n[3], n[4], n[5], n[6], n[7], n[8], n[9], n[10], n[11], n[12], n[13], n[14], n[15]);
  break;
 }

}
function imandreel_as3_dump(param)
{
 dump(atob(param));
}


var mandreel_embed_plugin;

function PluginMandreelInterWriteInt(ptr, value)
{
 mandreel_embed_plugin.MandreelInterCalls("WriteInt", ptr,value);
}

function PluginMandreelInterWriteFloat(ptr, value)
{
 mandreel_embed_plugin.MandreelInterCalls("WriteFloat", ptr,value);
}

function PluginMandreelInterWriteString(ptr, value)
{
 mandreel_embed_plugin.MandreelInterCalls("WriteString", ptr,value);
}

function PluginMandreelInterWriteWString(ptr, value)
{
 mandreel_embed_plugin.MandreelInterCalls("WriteWString", ptr,value);
}

var mandreel_plugin_current_sp = 0;

function PluginMandreelLockFrame()
{
 var result = mandreel_embed_plugin.MandreelInterCalls("LockFrame");

 mandreel_plugin_current_sp+=300*1024;

 assert(mandreel_plugin_current_sp<1024*1024);

 return result+mandreel_plugin_current_sp;
}

function PluginMandreelPause()
{
 mandreel_embed_plugin.MandreelInterCalls("Pause");
}

function PluginMandreelResume()
{
 mandreel_embed_plugin.MandreelInterCalls("Resume");
}


function PluginMandreelUnlockFrame()
{
 mandreel_embed_plugin.MandreelInterCalls("UnlockFrame");

 mandreel_plugin_current_sp-=300*1024;
}

function PluginMandreelInterCallFunction()
{
 var total_args = arguments.length;

 switch(total_args)
 {
  case 0:
   return mandreel_embed_plugin.MandreelInterCallFunction();
  case 1:
   return mandreel_embed_plugin.MandreelInterCallFunction(arguments[0]);
  case 2:
   return mandreel_embed_plugin.MandreelInterCallFunction(arguments[0], arguments[1]);
  case 3:
   return mandreel_embed_plugin.MandreelInterCallFunction(arguments[0], arguments[1], arguments[2]);
  case 4:
   return mandreel_embed_plugin.MandreelInterCallFunction(arguments[0], arguments[1], arguments[2], arguments[3]);
  case 5:
   return mandreel_embed_plugin.MandreelInterCallFunction(arguments[0], arguments[1], arguments[2], arguments[3], arguments[4]);
  case 6:
   return mandreel_embed_plugin.MandreelInterCallFunction(arguments[0], arguments[1], arguments[2], arguments[3], arguments[4], arguments[5]);
  case 7:
   return mandreel_embed_plugin.MandreelInterCallFunction(arguments[0], arguments[1], arguments[2], arguments[3], arguments[4], arguments[5], arguments[6]);
  case 8:
   return mandreel_embed_plugin.MandreelInterCallFunction(arguments[0], arguments[1], arguments[2], arguments[3], arguments[4], arguments[5], arguments[6], arguments[7]);
  case 9:
   return mandreel_embed_plugin.MandreelInterCallFunction(arguments[0], arguments[1], arguments[2], arguments[3], arguments[4], arguments[5], arguments[6], arguments[7], arguments[8]);
  case 10:
   return mandreel_embed_plugin.MandreelInterCallFunction(arguments[0], arguments[1], arguments[2], arguments[3], arguments[4], arguments[5], arguments[6], arguments[7], arguments[8], arguments[9]);
  case 11:
   return mandreel_embed_plugin.MandreelInterCallFunction(arguments[0], arguments[1], arguments[2], arguments[3], arguments[4], arguments[5], arguments[6], arguments[7], arguments[8], arguments[9], arguments[10]);
  case 12:
   return mandreel_embed_plugin.MandreelInterCallFunction(arguments[0], arguments[1], arguments[2], arguments[3], arguments[4], arguments[5], arguments[6], arguments[7], arguments[8], arguments[9], arguments[10], arguments[11]);
  case 13:
   return mandreel_embed_plugin.MandreelInterCallFunction(arguments[0], arguments[1], arguments[2], arguments[3], arguments[4], arguments[5], arguments[6], arguments[7], arguments[8], arguments[9], arguments[10], arguments[11], arguments[12]);
  case 14:
   return mandreel_embed_plugin.MandreelInterCallFunction(arguments[0], arguments[1], arguments[2], arguments[3], arguments[4], arguments[5], arguments[6], arguments[7], arguments[8], arguments[9], arguments[10], arguments[11], arguments[12], arguments[13]);
  case 15:
   return mandreel_embed_plugin.MandreelInterCallFunction(arguments[0], arguments[1], arguments[2], arguments[3], arguments[4], arguments[5], arguments[6], arguments[7], arguments[8], arguments[9], arguments[10], arguments[11], arguments[12], arguments[13], arguments[14]);
  case 16:
   return mandreel_embed_plugin.MandreelInterCallFunction(arguments[0], arguments[1], arguments[2], arguments[3], arguments[4], arguments[5], arguments[6], arguments[7], arguments[8], arguments[9], arguments[10], arguments[11], arguments[12], arguments[13], arguments[14], arguments[15]);
  break;
 }
}

function mandreel_plugin_draw()
{
 var canvas = Mandreel_document.getElementById('canvasDiv');
 WebGLUtils.requestAnimationFrame(canvas, mandreel_plugin_draw);
 mandreel_embed_plugin.MandreelInterCalls("AppDraw");

}

function mandreelInitPluginPlatform(params)
{

 if ( params.width != null )
  mandreelAppWidthSrc = params.width;

 if ( params.height != null )
  mandreelAppHeightSrc = params.height;


 mandreel_embed_plugin = Mandreel_document.createElement('embed');
 mandreel_embed_plugin.setAttribute('width',mandreelAppWidthSrc);
 mandreel_embed_plugin.setAttribute('height',mandreelAppHeightSrc);
 mandreel_embed_plugin.setAttribute('type',"application/halfbrick-npruntime-scriptable-plugin");

 var div = Mandreel_document.getElementById('canvasDiv');


 var oChild=div.firstChild;

 div.replaceChild(mandreel_embed_plugin, oChild);

 var flashElement = Mandreel_document.getElementById('FlashWrapper');
 if ( flashElement != null )
 {
  flashElement.style.visibility = "hidden";
  flashElement.style.width = "0px";
  flashElement.style.height = "0px";
 }





 Mandreel_window.MandreelInterWriteInt     = PluginMandreelInterWriteInt;
 Mandreel_window.MandreelInterWriteFloat   = PluginMandreelInterWriteInt;
 Mandreel_window.MandreelInterWriteString  = PluginMandreelInterWriteString;
 Mandreel_window.MandreelInterWriteWString = PluginMandreelInterWriteWString;
 Mandreel_window.MandreelLockFrame         = PluginMandreelLockFrame;
 Mandreel_window.MandreelUnlockFrame       = PluginMandreelUnlockFrame;
 Mandreel_window.MandreelInterCallFunction = PluginMandreelInterCallFunction;
 Mandreel_window.MandreelPause     = PluginMandreelPause;
 Mandreel_window.MandreelResume     = PluginMandreelResume;

 Mandreel_setTimeout(function () {

 if ( typeof(params.pluginSolutionName) != 'undefined' )
  mandreel_embed_plugin.init(params.pluginDLL, params.pluginWorkingFolder,params.pluginSolutionName);
 else
  mandreel_embed_plugin.init(params.pluginDLL, params.pluginWorkingFolder);


 mandreelAppStartStateFunc("ready",mandreelAppWidthSrc,mandreelAppHeightSrc);

 Mandreel_setTimeout("mandreel_plugin_draw()", 16);
 }, 100);

}


function MandreelInterSwfProgress(mode, percentage, bytes, totalbytes)
{
 imandreel_update_load(bytes, totalbytes);
 if (mode == 'files')
 {
  if ( mandreelAppStartStateFunc )
   mandreelAppStartStateFunc("loadingData",percentage);
 }
 else if (mode == 'audio')
 {
  if ( mandreelAppStartStateFunc )
   mandreelAppStartStateFunc("loadingAudioUpdate",percentage);
 }
 else if (mode == 'textureasync')
 {
  if ( mandreelAppStartStateFunc )
   mandreelAppStartStateFunc("loadingTextureAsyncPack",percentage);
 }

}

function MandreelInterSwfCheckMethod(method)
{
 if (typeof(Mandreel_window[method])=="undefined")
  return 0;
 else
  return 1;
}

// End of js/mandreelapp.js file.

// Start of mandreel.js file.

var mandreel_total_memory = 15908864;
var mandreel_stack_memory = 1048576;
var mandreel_heap_memory = 13591752; //init_memory = 744248
/////////////////////////////////////////////
// Heap
/////////////////////////////////////////////
var heap;
var heap8;
var heapU8;
var heap16;
var heapU16;
var heap32;
var heapU32;
var heapFloat;
var heapDouble;
var heapNewPos = 512;

var ABORT = false;

var g_mandreel_cache_files = false;


var g_mandreel_frame_locked = false;
var g_mandreel_frame_inframe = false;

var mandreel_cache_files = [];
var g_mandreel_working_folder = 'DataPC/';
var g_mandreel_datafiles_sufix = '.dat';
var __FUNCTION_TABLE__ = [];
var mandreel_pos_function_table = 1;
function register_delegate(ptr_func)
{
 var functionId = mandreel_pos_function_table;
 __FUNCTION_TABLE__[functionId] = ptr_func;

 mandreel_pos_function_table++;
 return functionId*4;
}


var g_addr_emit = 0;
function emit_start(addr)
{
 g_addr_emit = addr;
}

function emit_8(data)
{
 heapU8[g_addr_emit] = data;
 g_addr_emit++;
}

function emit_16(data)
{
 heapU16[g_addr_emit>>1] = data;
 g_addr_emit+=2;
}

function emit_32(data)
{
 heapU32[g_addr_emit>>2] = data;
 g_addr_emit+=4;
}

function emit_fill(data, size)
{
 var j;
 for (j=0;j<size;j++)
 {
  heapU8[g_addr_emit] = data;
  g_addr_emit++;
 }
}

function emit_string(v)
{
 var j;
 var len = v.length;
 var data;

 for(j = 0; j < len; j++)
 {
  data = v.charCodeAt(j);

  heapU8[g_addr_emit] = data;
  g_addr_emit++;
 }
}





var g_stack_pointer = Malloc(mandreel_stack_memory);

function assert_unalign()
{
 dump("fatal error: unaligned memory access detected!!!!");
 assert(false);
}

function _assert(sp)
{
 var p0 = heap32[sp>>2];sp+=4;
  var p1 = heap32[sp>>2];sp+=4;
  var line = heap32[sp>>2];sp+=4;
 var name = get_string_from_ptr(p0);
 var file = get_string_from_ptr(p1);
 assert(false, name + file + ' ' + line);
}
__cxa_pure_virtual.__index__ = 0;
function __cxa_pure_virtual()
{
 assert(0);
}

// operator delete[]
function _ZdaPv(sp)
{
 free(sp);
}

// operator delete
function _ZdlPv(sp)
{
 free(sp);
}

// operator new[](unsigned int)
function _Znaj(sp)
{
 malloc(sp);
}
// operator new[](unsigned int)
function _Znwj(sp)
{
 malloc(sp);
}

function abort(sp)
{
 assert(0);
}

var r_g0 = 0;
var r_g1 = 0;
var f_g0 = 0;

//isFinite(aux)
//isNaN(aux)

var tlsf_ptr = 0;


function initHeap()
{
 heap = new ArrayBuffer(mandreel_total_memory);
 heap8 = new Int8Array(heap);
 heapU8 = new Uint8Array(heap);
 heap16 = new Int16Array(heap);
 heapU16 = new Uint16Array(heap);
 heap32 = new Int32Array(heap);
 heapU32 = new Uint32Array(heap);
 heapFloat = new Float32Array(heap);
 heapDouble = new Float64Array(heap);


 for (var i=0;i<mandreel_total_memory/4;i++)
 {
  heapU32[i] = 0;
 }
}

function Malloc(bytes)
{
 if ( heap == undefined )
 {
  //initHeap();
 }
 var newOffset = heapNewPos;
 // Always 32 bit aligned
 heapNewPos += ((bytes + 3) & 0xfffffffc);

 if (heapNewPos>mandreel_total_memory)
 {
  assert(false);
 }

 return newOffset;
}

function assert(condition, _text) {
//console.assert(condition, _text);
    if (!condition) {
      var text = "Assertion failed: " + _text;
      alert(text + ':\n' + (new Error).stack);
      ABORT = true;
      throw "Assertion: " + text;
    }
  }

  function my_assert(sp)
  {
 var p0 = heap32[sp>>2];sp+=4;
  var p1 = heap32[sp>>2];sp+=4;
 //var name = get_string_from_ptr(p1);

 assert(false, 'hola');
  }

  function WriteHeapDouble(addr, value)
  {
  //assert((addr&7)==0);
 heapDouble[addr>>3] = value;
  }

    function WriteHeapU64(addr, value)
  {
 heap32[addr>>2] = value.l;
 heap32[(addr>>2)+1] = value.h;
  }


var arg_test_local = Malloc(8);
function my_arg_test(sp)
{
 var ptr = heapU32[sp>>2];
 var size = heapU32[(sp+4)>>2];

 var arg = heapU32[ptr>>2];


 if (size == 4)
 {
 heap32[ptr>>2] = arg+4;

 arg = heap32[arg>>2];

 heap32[arg_test_local>>2] = arg;

 //dump('my_arg_test ' + arg + ' ' + ptr + '\n');

 }
 else
 {
  arg = (arg+7) & ~7;

  heap32[ptr>>2] = arg+8;

 //assert((arg&7)==0);
 var value0 = heap32[arg>>2];
 var value1 = heap32[(arg+4)>>2];
 //arg = llvm_readDouble(arg);

 //assert((arg_test_local&7)==0);

 heap32[arg_test_local>>2] = value0;
 heap32[(arg_test_local+4)>>2] = value1;

 //llvm_writeDouble(arg_test_local,arg);

 //dump('my_arg_test ' + arg + ' ' + ptr + '\n');


 }




 r_g0 = arg_test_local;
}






function uint(value) {
    if (value >= 0) return value;
    return 4294967296 + value;
  }



function puts(sp)
{
 var addr = heapU32[sp>>2];

 var name = get_string_from_ptr(addr);

 name+='\n';

 dump(name);

}

function _Z11print_valued(_stack_pos, value)
{
 dump(value);
 dump('\n');
}

function _Z11print_labelPKc(_stack_pos, addr)
{
 puts(_stack_pos,addr);
 dump('\n');
}




function gettimeofday(sp)
  {
  var ptr = heap32[sp>>2];
  var time_ms = Date_now();
 heap32[ptr>>2] = time_ms/1000;
 heap32[(ptr>>2)+1] = (time_ms%1000)*1000;
 r_g0 = 0;
  }


  function free(sp)
  {
 var ptr = heapU32[sp>>2];
   sp-=8;

 heap32[(sp)>>2] = tlsf_ptr;
 heap32[(sp+4)>>2] = ptr;
 tlsf_free(sp);
  }

  function malloc_size(sp)
  {
  var ptr = heapU32[sp>>2];

 sp-=4;

 heap32[(sp)>>2] = ptr;
 tlsf_block_size(sp);
  }


  function realloc(sp)
  {
 var ptr = heapU32[sp>>2];
 var size = heapU32[(sp+4)>>2];

 //assert(ptr == 0);

 sp-=12;

 //dump('realloc ' + sp + ' ' + ptr + ' ' + size + '\n');

 heap32[(sp)>>2] = tlsf_ptr;
 heap32[(sp+4)>>2] = ptr;
 heap32[(sp+8)>>2] = size;
 tlsf_realloc(sp);

 //dump('return ' + r_g0 + '\n');
  }

  var llvm_double_addr = Malloc(8);

  function llvm_writeDouble(addr,src)
  {
  //assert((llvm_double_addr&7)==0);
 heapDouble[llvm_double_addr>>3] = src;

 //assert((addr&7)==0);

 var val0 = heap32[(llvm_double_addr)>>2];
 var val1 = heap32[(llvm_double_addr+4)>>2];

 heap32[(addr)>>2] = val0;
 heap32[(addr+4)>>2] = val1;
  }

  function llvm_readDouble(addr)
  {
   //assert((addr&7)==0);

 var val0 = heap32[(addr)>>2];
 var val1 = heap32[(addr+4)>>2];

 heap32[(llvm_double_addr)>>2] = val0;
 heap32[(llvm_double_addr+4)>>2] = val1;


// assert((llvm_double_addr&7)==0);
 var result = heapDouble[llvm_double_addr>>3];


 return result;

  }

  function llvm_move_double(addr_dst, addr_src)
  {

 var val0 = heapU32[(addr_src)>>2];
 var val1 = heapU32[(addr_src+4)>>2];

 heapU32[(addr_dst)>>2] = val0;
 heapU32[(addr_dst+4)>>2] = val1;

  }

  function llvm_move_float(addr_dst, addr_src)
  {
 heapU32[(addr_dst)] = heapU32[(addr_src)];
  }

  function malloc(sp)
  {
 var size = heapU32[sp>>2];

 if (size == 0)
 {
  size = 4;
 }


 if (tlsf_ptr == 0)
 {
  var addr = Malloc(mandreel_heap_memory);

  sp-=8;
  heap32[(sp)>>2] = addr;
  heap32[(sp+4)>>2] = mandreel_heap_memory;
  tlsf_create(sp);
  tlsf_ptr = r_g0;
 }

 sp-=8;

 heap32[(sp)>>2] = tlsf_ptr;
 heap32[(sp+4)>>2] = size;
 tlsf_malloc(sp);

 if (r_g0 == 0)
 {
  dump('malloc failed ' + size + '\n');
  assert(false);
 }
  }


   function log10f(sp)
  {
  var value = heapFloat[sp>>2];
 f_g0 = Math.log(value)/Math.LN10;
  }

   function log10(sp)
  {
  var value = heapDouble[sp>>3];
 f_g0 = Math.log(value)/Math.LN10;
  }

function logf(sp)
  {
  var value = heapFloat[sp>>2];
 f_g0 = Math.log(value);
  }

  function log(sp)
  {
  var value = heapDouble[sp>>3];
 f_g0 = Math.log(value);
  }



  function cosf(sp)
  {
  var value = heapFloat[sp>>2];
 f_g0 = Math.cos(value);
 //assert (isNaN(f_g0) == false);
  }

  function acosf(sp)
  {
  var value = heapFloat[sp>>2];
 f_g0 = Math.acos(value);
  }

  function asinf(sp)
  {
  var value = heapFloat[sp>>2];
 f_g0 = Math.asin(value);
  }

  function asin(sp)
  {
  var value = heapDouble[sp>>3];
 f_g0 = Math.asin(value);
  }

  function acos(sp)
  {
  var value = heapDouble[sp>>3];
 f_g0 = Math.acos(value);
  }

  function floor(sp)
  {
  var value = heapDouble[sp>>3];
 f_g0 = Math.floor(value);
  }

  function floorf(sp)
  {
  var value = heapFloat[sp>>2];
 f_g0 = Math.floor(value);
  }

  function round(sp)
  {
  var value = heapDouble[sp>>3];
 f_g0 = Math.round(value);
  }

  function roundf(sp)
  {
  var value = heapFloat[sp>>2];
 f_g0 = Math.round(value);
  }

  function ceilf(sp)
  {
  var value = heapFloat[sp>>2];
 f_g0 = Math.ceil(value);
  }

  function ceil(sp)
  {
  var value = heapDouble[sp>>3];
 f_g0 = Math.ceil(value);
  }


  function exp2(sp)
  {
  var value = heapDouble[sp>>3];

 f_g0 = Math.pow(2,value);
  }

  function exp2f(sp)
  {
  var value = heapFloat[sp>>2];

 f_g0 = Math.pow(2,value);
  }



  function pow(sp)
  {
  var value = heapDouble[sp>>3];
  var value2 = heapDouble[(sp+8)>>3];
 f_g0 = Math.pow(value,value2);
  }

  function powf(sp)
  {
  var value = heapFloat[sp>>2];
  var value2 = heapFloat[(sp+4)>>2];
 f_g0 = Math.pow(value,value2);
  }

  function cos(sp)
  {
  var value = heapDouble[sp>>3];
 f_g0 = Math.cos(value);
 //assert (isNaN(f_g0) == false);
  }

  function tan(sp)
  {
  var value = heapDouble[sp>>3];
 f_g0 = Math.tan(value);
 //assert (isNaN(f_g0) == false);
  }

   function sinf(sp)
  {
  var value = heapFloat[sp>>2];
 f_g0 = Math.sin(value);

 //assert (isNaN(f_g0) == false);
  }

  function expf(sp)
  {
  var value = heapFloat[sp>>2];
 f_g0 = Math.exp(value);
  }

  function exp(sp)
  {
  var value = heapDouble[sp>>3];
 f_g0 = Math.exp(value);
  }

  function tanf(sp)
  {
  var value = heapFloat[sp>>2];
 f_g0 = Math.tan(value);
  }

 function atanf(sp)
  {
  var value = heapFloat[sp>>2];
 f_g0 = Math.atan(value);
  }

  function atan(sp)
  {
  var value = heapDouble[sp>>3];
 f_g0 = Math.atan(value);
  }

  function abs(sp)
  {
  var value = heap32[sp>>2];
  if (value<0)
  r_g0 = -value;
  else
  r_g0 = value;
  }

  function sin(sp)
  {
  var value = heapDouble[sp>>3];
 f_g0 = Math.sin(value);
  }

  function sqrtf(sp)
  {
  var value = heapFloat[sp>>2];
 f_g0 = Math.sqrt(value);
  }

  function sqrt(sp)
  {
  var value = heapDouble[sp>>3];
 f_g0 = Math.sqrt(value);
  }

  function fmod(sp)
  {
  var value = heapDouble[sp>>3];sp+=8;
  var value2 = heapDouble[sp>>3];
 f_g0 = value % value2;
  }

   function fmodf(sp)
  {
  var value = heapFloat[sp>>2];sp+=4;
  var value2 = heapFloat[sp>>2];
 f_g0 = value % value2;
  }


  function atan2f(sp)
  {
  var x = heapFloat[sp>>2];sp+=4;
  var y = heapFloat[sp>>2];
 f_g0 = Math.atan2(x,y);
  }

  function atan2(sp)
  {
  var x = heapDouble[sp>>3];
  var y = heapDouble[(sp+8)>>3];
 f_g0 = Math.atan2(x,y);
  }

  function fabs(sp)
  {
  var value = heapDouble[sp>>3];
 f_g0 = Math.abs(value);
  }


  function _Z18OutputDebugStringAPKc(sp)
  {
  puts(sp);

  }


  function getenv(sp)
  {
  r_g0 = 0;
  }


  function mandreel_fcmp_ord(X, Y)
  {
 return (X == X && Y == Y);
  }

  function mandreel_fcmp_uno(X, Y)
{

        return (X != X || Y != Y);
}

var llvm_errno = Malloc(4);
function _errno(sp)
{
 r_g0 = llvm_errno;
}




if (!Mandreel_window["dump"])
 Mandreel_window["dump"] = function dump(str){console.log(str)} ;




  function get_string_from_ptr(ptr)
  {
 var ret = "";

 if (ptr == 0)
  return ret;

 var i = 0;
 while (1) {
  //    if ((ptr.pos + i) >= ptr.slab.length) { return "<< Invalid read: " + (ptr.pos+i) + " : " + ptr.slab.length + " >>"; } else {}
 if (heapU8[ptr + i] == 0)
  break;

      var t = String.fromCharCode(heapU8[ptr + i]);
      ret += t;
      i += 1;
    }

 return ret;
  }

  function fill_ptr_from_string(ptr, v)
  {
 var j;
 var len = v.length;
 var data;

   for(j = 0; j < len; j++)
 {
  data = v.charCodeAt(j);

  heapU8[ptr] = data;
  ptr++;
 }
  heapU8[ptr] = 0;
 }

  var file_ids = [];
  var current_file_id = 20;

  function create_file_id(buffer)
  {
 this.buffer = buffer;
 this.offset = 0;
 this.byteArray = new Uint8Array(buffer);
  }

  function mandreel_rewind(sp)
  {
  var file_id = heap32[sp>>2];sp+=4;

  file_ids[file_id].offset = 0;

 r_g0 = 0;

 //return 0;
  }


  function mandreel_fseek(sp)
  {
  var file_id = heap32[sp>>2];sp+=4;
  var pos = heap32[sp>>2];sp+=4;
  var type = heap32[sp>>2];sp+=4;

 if (type == 2)
 {
  file_ids[file_id].offset = file_ids[file_id].buffer.byteLength + pos;
 }
 else if (type == 1)
 {
  file_ids[file_id].offset = file_ids[file_id].offset + pos;

 }
 else if (type == 0)
 {
  file_ids[file_id].offset = pos;

 }

 r_g0 = 0;

 //return 0;
  }

  function mandreel_fclose(sp)
  {
  var file_id = heap32[sp>>2];sp+=4;

 file_ids[file_id] = null;
 r_g0 = 0;
 //return 0;
  }



  function mandreel_feof(sp)
  {
  var file_id = heap32[sp>>2];sp+=4;

  var offset = file_ids[file_id].offset;
  var total = file_ids[file_id].buffer.byteLength;

  if (offset>=total)
  r_g0 = 1;
  else
  r_g0 = 0;

  }

  function mandreel_getc(sp)
  {
  var file_id = heap32[sp>>2];sp+=4;


  var offset = file_ids[file_id].offset;


 var buffer = file_ids[file_id].buffer;

 var byteArray = file_ids[file_id].byteArray;

 var total = 1;

 var result;

 if ((offset+total)>buffer.byteLength)
 {
  result = -1;
 }
 else
 {
  result = byteArray[offset];
  file_ids[file_id].offset+=total;
 }

 r_g0 = result;
  }



  function mandreel_fread(sp)
  {
  var ptr = heap32[sp>>2];sp+=4;
  var size = heap32[sp>>2];sp+=4;
  var count = heap32[sp>>2];sp+=4;
  var file_id = heap32[sp>>2];sp+=4;

  var offset = file_ids[file_id].offset;

  //dump('fread ' + ptr + ' ' + size + ' ' + count + ' ' + file_id + ' ' + offset + '\n');

 var buffer = file_ids[file_id].buffer;

 var total = size*count;

 if ((offset+total)>buffer.byteLength)
  total = buffer.byteLength-offset;

 var byteArray = file_ids[file_id].byteArray;


 var sub_array = byteArray.subarray(offset, offset+total);

 heapU8.set(sub_array,ptr);


 //heapU8.set(byteArray, ptr);
 //for (var i=0;i<total;++i)
 //{
// heapU8[ptr+i] = byteArray[i+offset];
// }


 file_ids[file_id].offset+=total;

 r_g0 = total/size;
 //return total;
  }

  function mandreel_ftell(sp)
  {
  var file_id = heap32[sp>>2];sp+=4;

 var value = file_ids[file_id].offset;
 //dump('offset ftell ' + value + '\n');
 r_g0 = value;
 //return value;
  }

  function _Z30mandreel_fopen_enable_checkfatb(sp)
  {
  }

  function mandreel_ungetc(sp)
  {
 var my_char = heap32[sp>>2];sp+=4;
 var file_id = heap32[sp>>2];sp+=4;

 var offset = file_ids[file_id].offset-1;

 var byteArray = file_ids[file_id].byteArray;

 assert(byteArray[offset] == my_char);

 file_ids[file_id].offset = offset;

 return my_char;
  }
  function mandreel_fopen(sp)
  {
  var ptr_name = heap32[sp>>2];sp+=4;
  var ptr_flags = heap32[sp>>2];sp+=4;


 var name = get_string_from_ptr(ptr_name);
 var flags = get_string_from_ptr(ptr_flags);
 //dump('fopen\n');
 //dump(name);
 //dump('\n');
 //dump(flags);
 //dump('\n');

 var buffer;

 var full_name;

 name = name.toLowerCase();

 name = name.replace(/\\/g,"/");

 full_name = g_mandreel_working_folder + name + g_mandreel_datafiles_sufix;


 buffer =mandreel_cache_files[name];

 if (buffer == null)
 {
 r_g0 = 0;
 return;
 }



 //dump('\nopening file ' + full_name + ' ' + buffer.byteLength + '\n');


 file_ids[current_file_id] = new create_file_id(buffer);

 var old_id = current_file_id;
 current_file_id++;

 r_g0 = old_id;
 //return old_id;
  }

  function llvm_store_unalign32_float(addr, value)
  {
 heapFloat[0] = value;
 var data = heap32[0];
 heap8[addr] = data&0xff;
 heap8[addr+1] = (data>>>8)&0xff;
 heap8[addr+2] = (data>>>16)&0xff;
 heap8[addr+3] = (data>>>24)&0xff;
  }
  function llvm_store_unalign32(addr, value)
  {
 heap8[addr] = value&0xff;
 heap8[addr+1] = (value>>>8)&0xff;
 heap8[addr+2] = (value>>>16)&0xff;
 heap8[addr+3] = (value>>>24)&0xff;
  }

  function llvm_read_unalign32(addr)
  {
 var value;
 value = heapU8[addr];
 value |= heapU8[addr+1]<<8;
 value |= heapU8[addr+2]<<16;
 value |= heapU8[addr+3]<<24;
 return value;
  }

  function llvm_read_unalign32_float(addr)
  {
 var value;
 value = heapU8[addr];
 value |= heapU8[addr+1]<<8;
 value |= heapU8[addr+2]<<16;
 value |= heapU8[addr+3]<<24;

 heap32[0] = value;
 return  heapFloat[0];
  }

  function mandreel_getlocalstorage()
  {
 return Mandreel_window.localStorage;
 //return Mandreel_window.sessionStorage;
  }

  function mandreel_openls(sp)
  {
 var ptr_name = heap32[sp>>2];sp+=4;

 var key = get_string_from_ptr(ptr_name);

 var my_localStorage = mandreel_getlocalstorage();

 var value = my_localStorage.getItem(key);

 if (value == null)
 {
  r_g0 = -1;
  return;
 }


 var length = my_localStorage.getItem(key + '_size');

 if (length == null)
 {
  r_g0 = -1;
  return;
 }




 dump('mandreel_openls ' + key + ' return ' + length);


 r_g0 = parseInt(length);



 return;

  }

  function mandreel_readls(sp)
  {
 var ptr_name = heap32[sp>>2];sp+=4;
 var data_dst = heap32[sp>>2];sp+=4;
 var data_len = heap32[sp>>2];sp+=4;

 var key = get_string_from_ptr(ptr_name);

 var my_localStorage = mandreel_getlocalstorage();

 var value = my_localStorage.getItem(key);

 var data = JSON.parse(value);


 for (var i=0;i<data_len;++i)
 {
  heapU8[data_dst+i] = data[i];
 }

 r_g0 =  data_len;
 return;

}

function mandreel_removels(sp)
 {
 var ptr_name_a = heap32[sp>>2];sp+=4;
 var key_a = get_string_from_ptr(ptr_name_a);

 var my_localStorage = mandreel_getlocalstorage();

 my_localStorage.removeItem(key_a);
 my_localStorage.removeItem(key_a + '_size');
 r_g0 = 0;

 }


function mandreel_renamels(sp)
 {
 var ptr_name_a = heap32[sp>>2];sp+=4;
  var ptr_name_b = heap32[sp>>2];sp+=4;

  var key_a = get_string_from_ptr(ptr_name_a);
  var key_b = get_string_from_ptr(ptr_name_b);

  var my_localStorage = mandreel_getlocalstorage();


  var value = my_localStorage.getItem(key_a);
  var value2 = my_localStorage.getItem(key_a + '_size');

  if (value != null && value2 != null)
  {
 my_localStorage.setItem(key_b, value);
 my_localStorage.setItem(key_b + '_size', value2);

 my_localStorage.removeItem(key_a);
 my_localStorage.removeItem(key_a + '_size');


 r_g0 = 0;
}
else
 r_g0 = -1;
 }

function mandreel_writels(sp)
  {
 var ptr_name = heap32[sp>>2];sp+=4;
 var data_src = heap32[sp>>2];sp+=4;
 var data_len = heap32[sp>>2];sp+=4;

 var key = get_string_from_ptr(ptr_name);



 var data = new Uint8Array(heap,data_src,data_len);

 var value = JSON.stringify(data);

 var my_localStorage = mandreel_getlocalstorage();

 try
 {
  my_localStorage.setItem(key, value);
 } catch(e)
 {
  dump('error saving ' + key);
  dump(e.message);
  r_g0 =  0;
  return;
 }

 try
 {
  my_localStorage.setItem(key + '_size', data_len);
 } catch(e)
 {
  dump('error saving ' + key);
  dump(e.message);
  r_g0 =  0;
  return;
 }


 r_g0 =  data_len;
 return;

}

function mandreel_call_constructors(_ptr, size,stackPos)
{
var ptr = _ptr;

ptr = ptr >> 2;

for (var i=0;i<size;++i)
{


var tag = heap32[ptr];
var ptr_id = heap32[ptr+1];

__FUNCTION_TABLE__[(ptr_id)>>2](stackPos);

ptr+=2;

}
}

function get_string_from_wptr(ptr)
  {
 var ret = "";

 if (ptr == 0)
  return ret;

 assert((ptr&1)==0);
 ptr>>=1;
 var i = 0;
 while (1) {
  //    if ((ptr.pos + i) >= ptr.slab.length) { return "<< Invalid read: " + (ptr.pos+i) + " : " + ptr.slab.length + " >>"; } else {}
 if (heapU16[ptr + i] == 0)
  break;

      var t = String.fromCharCode(heapU16[ptr + i]);
     // if (t == "\0") { break; } else {}
      ret += t;
      i += 1;
    }

 return ret;
  }

  function fill_wptr_from_string(ptr, v)
  {
 var j;
 var len = v.length;
 var data;

 assert((ptr&1)==0);
 ptr>>=1;

   for(j = 0; j < len; j++)
 {
  data = v.charCodeAt(j);

  heapU16[ptr] = data;
  ptr++;
 }
  heapU16[ptr] = 0;
 }

function mandreelInterGetParams(sp)
{
 var params = [];

 var offset = 0;
 for (i=1;i<arguments.length;++i)
 {
  var type = arguments[i];

  switch(type)
  {
   case 'int':
    params[i-1] = heap32[(sp+offset)>>2];
    break;
   case 'float':
    params[i-1] = heapFloat[(sp+offset)>>2];
    break;
   case 'string':
    params[i-1] = get_string_from_ptr(heap32[(sp+offset)>>2]);
    break;
   default:
    assert(false);
  }
  offset+=4;
 }

 return params;
}

function mandreelInterRetParam(type, value)
{
 switch(type)
 {
  case 'int':
   r_g0 = value;
   break;
  case 'float':
   f_g0 = value;
   break;
  default:
   assert(false);
 }

 return 0;
}

function MandreelInterGetFunctionPtr(value)
{
 return __FUNCTION_TABLE__[value >> 2];
}


function MandreelInterCallFunction(returnType,func_name)
{
 var size_params = 0;

 var i;
 var num_params = (arguments.length-2)/2;
 num_params|=0;
 for (i=2;i<num_params*2+2;i+=2)
 {
  var type = arguments[i];

  var size_arg = 0;
  switch(type)
  {
   case 'int':
    size_arg = 4;
    break;
   case 'float':
    size_arg = 4;
    break;
   case 'string':
    size_arg = 4;
    size_arg += ((arguments[i+1].length + 4) & 0xfffffffc);
    break;
   case 'wstring':
    size_arg = 4;
    size_arg += ((arguments[i+1].length*2 + 4) & 0xfffffffc);
    break;
   default:
    assert(false);
  }

  size_params += size_arg;
 }

 // stack always 8 byte aligned
 size_params=((size_params+7)& 0xfffffff8);

 var sp = 0;

 if (i<(arguments.length))
  sp = arguments[i];
 else
 {
  assert(false,"MandreelInterCallFunction missing stack pointer paramenter");
  //assert(g_mandreel_frame_locked == true);
  //sp = g_stack_pointer+800*1024;
 }

 sp-=size_params;

 var offset = 0;
 var ptr_data = num_params*4+sp;
    for (i=2;i<num_params*2+2;i+=2)
 {
  var type = arguments[i];

  var size_arg = 0;
  switch(type)
  {
   case 'int':
    heap32[(sp+offset)>>2] = arguments[i+1];
    break;
   case 'float':
    heapFloat[(sp+offset)>>2] = arguments[i+1];
    break;
   case 'string':
    {
     heap32[(sp+offset)>>2] = ptr_data;
     var string = arguments[i+1];
     fill_ptr_from_string(ptr_data,string);

     ptr_data += ((string.length + 4) & 0xfffffffc);
    }
    break;
   case 'wstring':
    {
     MandreelInterWriteInt((sp+offset),ptr_data);
     var string = arguments[i+1];
     MandreelInterWriteWString(ptr_data,string);

     ptr_data += ((string.length*2 + 4) & 0xfffffffc);
    }
    break;
   default:
    assert(false);
  }
  offset+=4;
 }

 Mandreel_window[func_name](sp);

 if (returnType == 'int')
  return r_g0;
 else if (returnType == 'float')
  return f_g0;
 else
 {
  assert(returnType == 'void');
  return;
 }
}


function MandreelInterCallFunctionPtr(returnType,func_ptr)
{
 var size_params = 0;

 var i;
 var num_params = (arguments.length-2)/2;
 num_params|=0;
 for (i=2;i<num_params*2+2;i+=2)
 {
  var type = arguments[i];

  var size_arg = 0;
  switch(type)
  {
   case 'int':
    size_arg = 4;
    break;
   case 'float':
    size_arg = 4;
    break;
   case 'string':
    size_arg = 4;
    size_arg += ((arguments[i+1].length + 4) & 0xfffffffc);
    break;
   case 'wstring':
    size_arg = 4;
    size_arg += ((arguments[i+1].length*2 + 4) & 0xfffffffc);
    break;
   default:
    assert(false);
  }

  size_params += size_arg;
 }

 // stack always 8 byte aligned
 size_params=((size_params+7)& 0xfffffff8);

 var sp = 0;

 if (i<(arguments.length))
  sp = arguments[i];
 else
 {
  assert(false);
  //assert(g_mandreel_frame_locked == true);
  //sp = g_stack_pointer+800*1024;
 }

 sp-=size_params;

 var offset = 0;
 var ptr_data = num_params*4+sp;
    for (i=2;i<num_params*2+2;i+=2)
 {
  var type = arguments[i];

  var size_arg = 0;
  switch(type)
  {
   case 'int':
    heap32[(sp+offset)>>2] = arguments[i+1];
    break;
   case 'float':
    heapFloat[(sp+offset)>>2] = arguments[i+1];
    break;
   case 'string':
    {
     heap32[(sp+offset)>>2] = ptr_data;
     var string = arguments[i+1];
     fill_ptr_from_string(ptr_data,string);

     ptr_data += ((string.length + 4) & 0xfffffffc);
    }
    break;
   case 'wstring':
    {
     MandreelInterWriteInt((sp+offset),ptr_data);
     var string = arguments[i+1];
     MandreelInterWriteWString(ptr_data,string);

     ptr_data += ((string.length*2 + 4) & 0xfffffffc);
    }
    break;
   default:
    assert(false);
  }
  offset+=4;
 }

 __FUNCTION_TABLE__[(func_ptr)>>2](sp);

 if (returnType == 'int')
  return r_g0;
 else if (returnType == 'float')
  return f_g0;
 else
 {
  assert(returnType == 'void');
  return;
 }
}


var MANDREEL_HTTP_REQUEST_MODE_GET = 0;
var MANDREEL_HTTP_REQUEST_MODE_POST = 1;
var MANDREEL_HTTP_REQUEST_MODE_PUT = 2;

var MANDREEL_HTTP_REQUEST_STATUS_ERROR = 0;
var MANDREEL_HTTP_REQUEST_STATUS_BUSY = 1;
var MANDREEL_HTTP_REQUEST_STATUS_FINISHED = 2;
var MANDREEL_HTTP_REQUEST_STATUS_INIT = 3;


var mandreel_js_mapping_ids = [];
var mandreel_js_mapping_ids_free = [];


function Mandreel_HttpRequest_Create(sp)
{
 var ptr_url = heap32[sp>>2];sp+=4;
 var type = heap32[sp>>2];sp+=4;


 var url = get_string_from_ptr(ptr_url);


 var str_type = 'GET';
 if (type == MANDREEL_HTTP_REQUEST_MODE_GET)
  str_type = 'GET';
 else if (type == MANDREEL_HTTP_REQUEST_MODE_PUT)
  str_type = 'PUT';
 else if (type == MANDREEL_HTTP_REQUEST_MODE_POST)
  str_type = 'POST';

 var xmlhttp_get = new XMLHttpRequest();
 xmlhttp_get.open(str_type,url);

 if("responseType" in xmlhttp_get)
  xmlhttp_get.responseType="arraybuffer";
    else
 {
  xmlhttp_get.overrideMimeType('text/plain; charset=x-user-defined');
 }

 if (mandreel_js_mapping_ids_free.length == 0)
  mandreel_js_mapping_ids_free.push(mandreel_js_mapping_ids.length);

 var new_id = mandreel_js_mapping_ids_free.pop();

 var my_state = {
 buffer : null,
 httpRequest : xmlhttp_get,
 status : MANDREEL_HTTP_REQUEST_STATUS_INIT,
 offset_read : 0
  };



 mandreel_js_mapping_ids[new_id] = my_state;

 r_g0 = new_id+1;
}

function Mandreel_HttpRequest_Send(sp)
{
 var _id = heap32[sp>>2];sp+=4;
 var ptr_data = heap32[sp>>2];sp+=4;
 var id = _id-1;

 var data;

 if (ptr_data)
  data = get_string_from_ptr(ptr_data);
 else
  data = null;

 var my_state = mandreel_js_mapping_ids[id];


 my_state.status = MANDREEL_HTTP_REQUEST_STATUS_BUSY;

 my_state.httpRequest.onreadystatechange = function()
 {
  if (my_state.httpRequest.readyState==4)
  {
   if (my_state.httpRequest.status==200)
   {
    var buffer;

    if (my_state.httpRequest.responseType=="arraybuffer")
     buffer=my_state.httpRequest.response;
    else if (my_state.httpRequest.mozResponseArrayBuffer != null)
     buffer = my_state.httpRequest.mozResponseArrayBuffer;
    else
     buffer=my_state.httpRequest.response;

    my_state.status = MANDREEL_HTTP_REQUEST_STATUS_FINISHED;
    my_state.buffer =  new Uint8Array(buffer);
    //alert(my_state.buffer.length);

    //alert(mandreel_js_mapping_ids[id].buffer);

   }
   else
    my_state.status = MANDREEL_HTTP_REQUEST_STATUS_ERROR;
  }
 }

 my_state.httpRequest.send(data);
}


function Mandreel_HttpRequest_Status(sp)
{
 var _id = heap32[sp>>2];sp+=4;
 var id = _id-1;


 r_g0 = mandreel_js_mapping_ids[id].status;
}

function Mandreel_HttpRequest_Read(sp)
{
 var _id = heap32[sp>>2];sp+=4;
 var ptr = heap32[sp>>2];sp+=4;
 var size = heap32[sp>>2];sp+=4;
 var id = _id-1;

 var remaining_bytes =  mandreel_js_mapping_ids[id].buffer.length - mandreel_js_mapping_ids[id].offset_read;

 if (size>remaining_bytes)
  size = remaining_bytes;

 var sub_array = mandreel_js_mapping_ids[id].buffer.subarray(mandreel_js_mapping_ids[id].offset_read, mandreel_js_mapping_ids[id].offset_read+size);
 heapU8.set(sub_array,ptr);

 mandreel_js_mapping_ids[id].offset_read+=size;

 r_g0 = size;
}

function Mandreel_HttpRequest_BytesAvalable(sp)
{
 var _id = heap32[sp>>2];sp+=4;
 var id = _id-1;


 if (mandreel_js_mapping_ids[id].buffer)
  r_g0 = mandreel_js_mapping_ids[id].buffer.length - mandreel_js_mapping_ids[id].offset_read;
 else
  r_g0 = 0;
}

function Mandreel_HttpRequest_Close(sp)
{
 var _id = heap32[sp>>2];sp+=4;
 var id = _id-1;

 mandreel_js_mapping_ids[id] = null;
 mandreel_js_mapping_ids_free.push(id);
}

function Mandreel_HttpRequest_SetRequestHeader(sp)
{
 var _id = heap32[sp>>2];sp+=4;
 var ptr_a = heap32[sp>>2];sp+=4;
 var ptr_b = heap32[sp>>2];sp+=4;
 var id = _id-1;

 var str_a = get_string_from_ptr(ptr_a);
 var str_b = get_string_from_ptr(ptr_b);

 var my_state = mandreel_js_mapping_ids[id];

 my_state.httpRequest.setRequestHeader(str_a, str_b);
}


var Mandreel_TextureAsync_textures = 0;
var Mandreel_TextureAsync_textures_loaded = 0;

var Mandreel_TextureAsync_PackBufferData = new Array();

function Mandreel_TextureAsync_SetData(sp)
{
 var texture_id = heap32[sp>>2];sp+=4;

 var tex = array_ids_ogl[texture_id];

 if ( mandreelAppPlatform != "canvas" )
 {
  imandreel_gl.texImage2D(imandreel_gl.TEXTURE_2D, 0, imandreel_gl.RGBA, imandreel_gl.RGBA, imandreel_gl.UNSIGNED_BYTE, tex.image);
  tex.image = null;
 }
}

function Mandreel_TextureAsync_CheckPending(sp)
{
 r_g0 = Mandreel_TextureAsync_textures - Mandreel_TextureAsync_textures_loaded;
}

function Mandreel_TextureAsync_GetProperties(sp)
{
 var texture_id = heap32[sp>>2];sp+=4;
 var ptr_width = heap32[sp>>2];sp+=4;
 var ptr_height = heap32[sp>>2];sp+=4;

 var tex = array_ids_ogl[texture_id];

 if (tex == null || tex.mandreel_width == undefined)
  r_g0 = 0;
 else
 {
  heap32[ptr_width>>2] = tex.mandreel_width;
  heap32[ptr_height>>2] = tex.mandreel_height;
  r_g0 = 1;
 }
}

function mandreel_arrayBufferDataUri(offset, size, buffer) {
var bytes = new Uint8Array(buffer,offset,size)
   var ascii = '';
   for (var i=0; i<bytes.length; i++)
     ascii += String.fromCharCode(bytes[i]);
   var base64 = btoa(ascii);

  if (/^\x89PNG/.test(ascii))
    return 'data:image/png;base64,'+base64;
  else
    return 'data:image/jpeg;base64,'+base64;
  }

 function mandreel_texture_async_fix_name(name)
{
 var ascii = '';

 var j;
 var len = name.length;


 for(j = 0; j < len; j++)
 {
  var my_char = name[j];

  if (my_char == '/')
   my_char = '_';

  ascii+=my_char;

 }

   return ascii;
}



function Mandreel_TextureAsync_Load(sp)
{
 var ptr_name = heap32[sp>>2];sp+=4;
 var texture_id = heap32[sp>>2];sp+=4;

 var name = get_string_from_ptr(ptr_name);

 var nameSrc = name;

 name = name.toLowerCase();


 var full_name = g_mandreel_working_folder + name;

 var image  = new Image();


 Mandreel_TextureAsync_textures++;

 var imgURL = null;




 image.onerror = function() {
          dump('error loading texture ' + image.src + '\n');
    Mandreel_TextureAsync_textures_loaded++;
      }
 image.onload = function()
 {
  if (imgURL)
  {
   var URL = Mandreel_window.URL || Mandreel_window.webkitURL;
   URL.revokeObjectURL(imgURL);
  }
  if ( mandreelAppPlatform == "canvas" )
  {
   array_ids_ogl[texture_id] = image;
   Mandreel_TextureAsync_textures_loaded++;
  }
  else
  {
   var tex = array_ids_ogl[texture_id];
   if (tex)
   {
    tex.image = image;
    tex.mandreel_width = image.width;
    tex.mandreel_height = image.height;
    Mandreel_TextureAsync_textures_loaded++;

    var sp = MandreelLockFrame();
    MandreelInterCallFunction('void',"Mandreel_TextureAsync_Loaded",'int',texture_id,'int',image.width,'int',image.height, sp);
    MandreelUnlockFrame();
  }
   else
   {
    dump('texture not valid ' + texture_id + ' ' + name + '\n');
    Mandreel_TextureAsync_textures_loaded++;
   }
  }


 }

 var new_sp = sp-4096;

 var packfile = new_sp + 2048;
 var offset_ptr = new_sp + 2048+1024;
 var size_ptr = new_sp + 2048+1024+4;

 fill_ptr_from_string(new_sp + 1024,name);

 heap32[(new_sp)>>2] = new_sp + 1024;
 heap32[(new_sp+4)>>2] = offset_ptr;
 heap32[(new_sp+8)>>2] = size_ptr;
 heap32[(new_sp+12)>>2] = packfile;
 iMandreel_TextureAsync_GetPackOffset(new_sp);


 var image_src;

 var image_src_valid = true;

 if (r_g0)
 {
  var packfilename = get_string_from_ptr(packfile);
  image_src = mandreel_arrayBufferDataUri(heap32[offset_ptr>>2],heap32[size_ptr>>2],Mandreel_TextureAsync_PackBufferData[packfilename]);
 }
 else
 {

  if (nameSrc.search('http:') != -1 || nameSrc.search('https:') != -1)
  {
   image.crossOrigin = 'anonymous'; // no credentials flag. Same as
   image_src = nameSrc;
  }
  else
  {
   if (mandreel_is_filesystem())
   {
    image_src_valid = false;

    var new_name = mandreel_texture_async_fix_name(full_name);
    mandreel_fs_get_url(new_name, function Mandreel_TextureAsync_Load_FS(data) {
     if (data)
     {
      image.src = data;
     }
     else
     {
      var packdata_request = new XMLHttpRequest();

      packdata_request.open("GET", full_name, true);

      if("responseType" in packdata_request)
       packdata_request.responseType="arraybuffer";
      else
       packdata_request.overrideMimeType('text/plain; charset=x-user-defined');

      packdata_request.onreadystatechange = function()
      {
       if (packdata_request.readyState != 4) return;

       if (packdata_request.status == 200)
       {
        var buffer;
        if (packdata_request.responseType=="arraybuffer")
         buffer=packdata_request.response;
        else if (packdata_request.mozResponseArrayBuffer != null)
         buffer = packdata_request.mozResponseArrayBuffer;
        else
         buffer=packdata_request.response;

        mandreel_fs_saveFile(new_name, buffer);

        var uri = mandreel_arrayBufferDataUri(0,buffer.byteLength,buffer);

        image.src = uri;

       }
       else
       {

        Mandreel_TextureAsync_textures_loaded++;

       }
      }

      packdata_request.send();

     }
    }
    );
   }
   else if (mandreel_is_indexeddb())
   {
    image_src_valid = false;

    var new_name = mandreel_texture_async_fix_name(full_name);
    mandreel_indexedDB.load(new_name,function Mandreel_TextureAsync_Load_IDB(data) {
     if (data)
     {
       var URL = Mandreel_window.URL || Mandreel_window.webkitURL;


      // Create and revoke ObjectURL
      imgURL = URL.createObjectURL(data);

      image.src = imgURL;
     }
     else
     {
      var packdata_request = new XMLHttpRequest();

      packdata_request.open("GET", full_name, true);

       packdata_request.responseType = "blob";



      packdata_request.onreadystatechange = function()
      {
       if (packdata_request.readyState != 4) return;

       if (packdata_request.status == 200)
       {
        var buffer=packdata_request.response;

         var URL = Mandreel_window.URL || Mandreel_window.webkitURL;

        // Create and revoke ObjectURL
        imgURL = URL.createObjectURL(buffer);

        image.src = imgURL;

        mandreel_fs_saveFile(new_name, buffer);

       }
       else
       {

        Mandreel_TextureAsync_textures_loaded++;

       }
      }

      packdata_request.send();
     }

    }
    );
   }
   else
    image_src = full_name;
  }
 }


 if (image_src_valid)
 {
  setTimeout( function Mandreel_TextureAsync_Load_callback() {
      image.src = image_src;
     }, 1);
 }
}



function __sandbox_OutputDebugString(sp)
{
 puts(sp);
}




var MANDREELCALLJS_TYPE_RETURN_VOID = 0;
var MANDREELCALLJS_TYPE_INT = 1;
var MANDREELCALLJS_TYPE_FLOAT =  2;
var MANDREELCALLJS_TYPE_STRING =  3;
var MANDREELCALLJS_TYPE_RETURN_INT =  4;
var MANDREELCALLJS_TYPE_RETURN_FLOAT =  5;

function MandreelInterWriteString(ptr, value)
{
 fill_ptr_from_string(ptr,value);
}

function MandreelInterWriteWString(ptr, value)
{
 fill_wptr_from_string(ptr, value);
}

function MandreelInterWriteFloat(ptr, value)
{
 heapFloat[ptr>>2] = value;
}

function MandreelPause()
{
 _imandreel_pause_game = true;
}

function MandreelResume()
{
 _imandreel_pause_game = false;
}


function MandreelLockFrame()
{
 assert(g_mandreel_frame_inframe == false, "calling lockframe during render frame");
 assert(g_mandreel_frame_locked == false, "calling lockframe twice");
 g_mandreel_frame_locked = true;

 return g_stack_pointer+800*1024;
}

function MandreelUnlockFrame()
{
 assert(g_mandreel_frame_inframe == false);
 g_mandreel_frame_locked = false;
}


function MandreelInterWriteInt(ptr, value)
{
 heap32[ptr>>2] = value;
}

function MandreelInterStringFromWPtr(ptr)
{
 return get_string_from_wptr(ptr);
}

function MandreelInterStringFromPtr(ptr)
{
 return get_string_from_ptr(ptr);
}

function mandreel_my_call_external_array(method, params)
{
 var result
 var resultString;
 try
 {
  switch(params.length)
  {
   case 1:
    resultString = Mandreel_window[method](params[0]);
    break;
   case 2:
    resultString = Mandreel_window[method](params[0],params[1]);
    break;
   case 3:
    resultString = Mandreel_window[method](params[0],params[1],params[2]);
    break;
   case 4:
    resultString = Mandreel_window[method](params[0],params[1],params[2],params[3]);
    break;
   case 5:
    resultString = Mandreel_window[method](params[0],params[1],params[2],params[3],params[4]);
    break;
   case 6:
    resultString = Mandreel_window[method](params[0],params[1],params[2],params[3],params[4],params[5]);
    break;
   case 7:
    resultString = Mandreel_window[method](params[0],params[1],params[2],params[3],params[4],params[5],params[6]);
    break;
   case 8:
    resultString = Mandreel_window[method](params[0],params[1],params[2],params[3],params[4],params[5],params[6],params[7]);
    break;
   case 9:
    resultString = Mandreel_window[method](params[0],params[1],params[2],params[3],params[4],params[5],params[6],params[7],params[8]);
    break;
   case 10:
    resultString = Mandreel_window[method](params[0],params[1],params[2],params[3],params[4],params[5],params[6],params[7],params[8],params[9]);
    break;
   case 11:
    resultString = Mandreel_window[method](params[0],params[1],params[2],params[3],params[4],params[5],params[6],params[7],params[8],params[9],params[10]);
    break;
   case 12:
    resultString = Mandreel_window[method](params[0],params[1],params[2],params[3],params[4],params[5],params[6],params[7],params[8],params[9],params[10],params[11]);
    break;
   case 13:
    resultString = Mandreel_window[method](params[0],params[1],params[2],params[3],params[4],params[5],params[6],params[7],params[8],params[9],params[10],params[11],params[12]);
    break;
   case 14:
    resultString = Mandreel_window[method](params[0],params[1],params[2],params[3],params[4],params[5],params[6],params[7],params[8],params[9],params[10],params[11],params[12],params[13]);
    break;
   case 15:
    resultString = Mandreel_window[method](params[0],params[1],params[2],params[3],params[4],params[5],params[6],params[7],params[8],params[9],params[10],params[11],params[12],params[13],params[14]);
    break;
   default:
    assert(false);
  }
  result = 0;
 } catch(e) { dump('error calling ' + method + '\n'); dump(e); result = 1;}

 return [result,resultString];
}


function Mandreel_InterJS_Call(sp)
{
 var new_sp = sp;
 var method_ptr = heap32[sp>>2];sp+=4;
 var method = get_string_from_ptr(method_ptr);

 var params = new Array();


 params.push(new_sp);

 var var_int;
 var var_string;
 var var_double;

 var return_type;
 var return_ptr;
 while (true)
 {
  var my_type = heap32[sp>>2];sp+=4;


  if (my_type == MANDREELCALLJS_TYPE_RETURN_VOID)
  {
   return_type = my_type;
   break;
  }
  else if (my_type == MANDREELCALLJS_TYPE_INT)
  {
   var_int = heap32[sp>>2];

   params.push(var_int);
   sp+=4;
  }
  else if (my_type == MANDREELCALLJS_TYPE_FLOAT)
  {
   sp = (sp+7) & ~7;

   var_double = llvm_readDouble(sp);

   params.push(var_double);
   sp+=8;
  }
  else if (my_type == MANDREELCALLJS_TYPE_STRING)
  {
   var_int = heap32[sp>>2];
   var_string = get_string_from_ptr(var_int);

   params.push(var_string);
   sp+=4;
  }
  else if (my_type == MANDREELCALLJS_TYPE_RETURN_INT)
  {
   return_type = my_type;
   return_ptr = heap32[sp>>2];
   break;
  }
  else if (my_type == MANDREELCALLJS_TYPE_RETURN_FLOAT)
  {
   return_type = my_type;
   return_ptr = heap32[sp>>2];
   break;
  }
  else
  {
   assert(false, "invalid arguments calling Mandreel_InterJS_Call");
  }
 }

 var result = mandreel_my_call_external_array(method,params);

 r_g0 = result[0];


 if (r_g0 == 0)
 {
  if (return_type == MANDREELCALLJS_TYPE_RETURN_INT)
  {
   heap32[return_ptr>>2] = result[1];
  }
  else if (return_type == MANDREELCALLJS_TYPE_RETURN_FLOAT)
  {
   heapFloat[return_ptr>>2] = result[1];
  }

 }
}

function iMandreelRegisterExternalCallback()
{
}

function __mandreel_internal_CreateWindow()
{
}

var __mandreel_async_calls_mandreel = [];
var __mandreel_async_calls_js = [];


function Mandreel_InterJS_AsyncCall(sp)
{
 var method_ptr = heap32[sp>>2];sp+=4;
 var _func_name = get_string_from_ptr(method_ptr);
 var param_ptr = heap32[sp>>2];sp+=4;
 var _param = get_string_from_ptr(param_ptr);

 __mandreel_async_calls_js.push({func_name:_func_name,param:_param});
}




function MandreelInterCallFunctionAsync(_func_name, _param)
{
 __mandreel_async_calls_mandreel.push({func_name:_func_name,param:_param});


}

function __mandreel_process_async_calls()
{
 if (__mandreel_async_calls_mandreel.length)
 {
  var temp_list = __mandreel_async_calls_mandreel.slice(0);

  __mandreel_async_calls_mandreel = [];

  for (var i=0;i<temp_list.length;++i)
  {
   var param = temp_list[i].param;
   var func_name = temp_list[i].func_name;

   var size = ((param.length + 1)+7)&0xFFFFFFF8;

   var sp = g_stack_pointer+800*1024;

   var str_ptr = sp - size;
   fill_ptr_from_string(str_ptr,param);

   sp = str_ptr - 4;
   heap32[sp>>2] = str_ptr;

   Mandreel_window[func_name](sp);
  }
 }

 if (__mandreel_async_calls_js.length)
 {
  var temp_list = __mandreel_async_calls_js.slice(0);

  __mandreel_async_calls_js = [];

  for (var i=0;i<temp_list.length;++i)
  {
   var param = temp_list[i].param;
   var func_name = temp_list[i].func_name;

   Mandreel_window[func_name](param);

  }
 }
}

function mandreel_internal_isCanvas(sp)
{
 if ( mandreelAppPlatform == "canvas" )
  r_g0 = 1;
 else
  r_g0 = 0;
}

function Mandreel_Device_SetFullScreen(sp)
{
 var enable = heap32[sp>>2];sp+=4;
 mandreelAppFullscreen(enable);
}

var array_ids_ogl = [];

var max_ogl_id = 8192;

var array_ids_ogl_enable = [];
var g_current_program_id = 0;


var uniformArrays2 = [];
var uniformArrays3 = [];
var uniformArrays4 = [];
var uniformArraysCreated = 0;
var mandreel_draw_enable = true;


if (typeof imandreel_gl=="undefined")
{
 alert('using old template, update code');
}

function myglCreateUniformArrays()
{
 if ( uniformArraysCreated == 0 )
 {
  for(var i=0; i<256;i++ )
  {
   uniformArrays2[i] = new Float32Array(i*2);
   uniformArrays3[i] = new Float32Array(i*3);
   uniformArrays4[i] = new Float32Array(i*4);
  }
  uniformArraysCreated = 1;
 }
}

var my_super_id = 1;
function myglNewSlot()
{
 //var id = array_ids_ogl_enable.pop();
 var id = my_super_id;
 my_super_id++;
 return id;
}

function myglFreeSlot(id)
{
 //array_ids_ogl_enable.push(id);
}


function myglCreateProgram(sp)
{
 var id = myglNewSlot();
 var program = imandreel_gl.createProgram();

 program.uniform_locations_current_id = 0;
 program.array_uniform_locations = [];

 array_ids_ogl[id] = program;


 r_g0 = id;
}

function myglCreateShader(sp)
{
 var type = heap32[sp>>2];sp+=4;
 var id = myglNewSlot();

 array_ids_ogl[id] = imandreel_gl.createShader(type);

 r_g0 = id;
}

function myglAttachShader(sp)
{
 var program_id = heap32[sp>>2];sp+=4;
 var shader_id = heap32[sp>>2];sp+=4;

 imandreel_gl.attachShader(array_ids_ogl[program_id], array_ids_ogl[shader_id]);
}

function myglBindAttribLocation(sp)
{
 var program_id = heap32[sp>>2];sp+=4;
 var index = heap32[sp>>2];sp+=4;
 var ptr_string = heap32[sp>>2];sp+=4;

 var string = get_string_from_ptr(ptr_string);

 imandreel_gl.bindAttribLocation(array_ids_ogl[program_id], index, string);
}

function myglLinkProgram(sp)
{
 var program_id = heap32[sp>>2];sp+=4;

 imandreel_gl.linkProgram(array_ids_ogl[program_id]);
}

function myglShaderSource(sp)
{
 var id = heap32[sp>>2];sp+=4;
 var ptr_string = heap32[sp>>2];sp+=4;

 var shader = array_ids_ogl[id];

 var shader_code = get_string_from_ptr(ptr_string);

 //dump(shader_code);


 imandreel_gl.shaderSource(shader, shader_code);
}


function myglDrawArrays(sp)
{
 var mode = heap32[sp>>2];sp+=4;
 var first = heap32[sp>>2];sp+=4;
 var count = heap32[sp>>2];sp+=4;

 if (mandreel_draw_enable)
  imandreel_gl.drawArrays(mode, first, count);


 //dump('draw arrays ' + mode + ' ' + first + ' ' + count + '\n');
 }

function myglDrawElements(sp)
{
 var mode = heapU32[sp>>2]; sp+=4;
 var count = heapU32[sp>>2]; sp+=4;
 var type = heapU32[sp>>2]; sp+=4;
 var offset = heapU32[sp>>2]; sp+=4;


 if (mandreel_draw_enable)
  imandreel_gl.drawElements(mode, count, type, offset);



}

function myglCreateTexture(sp)
{
 var id = myglNewSlot();
 array_ids_ogl[id] = imandreel_gl.createTexture();

 r_g0 = id;
}

function myglCreateRenderBuffer(sp) {
 var id = myglNewSlot();
    array_ids_ogl[id] = imandreel_gl.createRenderbuffer();

    r_g0 = id;
}

function myglCreateFrameBuffer(sp) {
 var id = myglNewSlot();
    array_ids_ogl[id] = imandreel_gl.createFramebuffer();

    r_g0 = id;
}

function myglBindFramebuffer(sp)
{
    var target = heap32[sp >> 2]; sp += 4;
    var framebuffer_id = heap32[sp >> 2]; sp += 4;

 if (framebuffer_id != 0)
 {
  var framebuffer = array_ids_ogl[framebuffer_id];
  imandreel_gl.bindFramebuffer(target,framebuffer);
 }
 else
  imandreel_gl.bindFramebuffer(target,null);

}

function myglBindRenderbuffer(sp)
{
    var target = heap32[sp >> 2]; sp += 4;
    var renderbuffer_id = heap32[sp >> 2]; sp += 4;

    var renderbuffer = array_ids_ogl[renderbuffer_id];

    imandreel_gl.bindRenderbuffer(target,renderbuffer);

}


function myglRenderbufferStorage(sp) {
    var target = heap32[sp >> 2]; sp += 4;
    var internalformat = heap32[sp >> 2]; sp += 4;
    var witdth = heap32[sp >> 2]; sp += 4;
    var height = heap32[sp >> 2]; sp += 4;

    imandreel_gl.renderbufferStorage(target, internalformat, witdth, height);

}

function myglFramebufferRenderbuffer (sp)
{
  var target = heap32[sp>>2];sp+=4;
  var attachment = heap32[sp>>2];sp+=4;
  var renderbuffertarget = heap32[sp>>2];sp+=4;
  var renderbuffer_id = heap32[sp>>2];sp+=4;

    var renderbuffer = array_ids_ogl[renderbuffer_id];

    imandreel_gl.framebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);

}

function myglFramebufferTexture2D (sp)
{
  var target = heap32[sp>>2];sp+=4;
  var attachment = heap32[sp>>2];sp+=4;
  var textarget = heap32[sp>>2];sp+=4;
  var texture_id = heap32[sp>>2];sp+=4;
  var level = heap32[sp>>2];sp+=4;

  var texture = array_ids_ogl[texture_id];

  imandreel_gl.framebufferTexture2D(target, attachment, textarget, texture, level);


}

function myglTexImage2D(sp)
 {
  var target = heap32[sp>>2];sp+=4;
  var level = heap32[sp>>2];sp+=4;
  var internalFormat = heap32[sp>>2];sp+=4;
  var width = heap32[sp>>2];sp+=4;
  var height = heap32[sp>>2];sp+=4;
  var border = heap32[sp>>2];sp+=4;
  var format = heap32[sp>>2];sp+=4;
  var type = heap32[sp>>2];sp+=4;
  var data = heap32[sp>>2];sp+=4;

  if (level>0 && target==imandreel_gl.TEXTURE_2D)
 return;

   if (data == 0)
  {
 //imandreel_gl.texImage2D(target, level, internalFormat, width, height, border, format, type, null);
 var buffer;
 var bufferView;

 if (type == imandreel_gl.UNSIGNED_SHORT_5_6_5 || type == imandreel_gl.UNSIGNED_SHORT_4_4_4_4 || type == imandreel_gl.UNSIGNED_SHORT_5_5_5_1)
    {
  buffer = new ArrayBuffer(width*height*2);
  bufferView = new Uint16Array(buffer);
 }
 else
 {
  var size;
  if (format == imandreel_gl.LUMINANCE)
   size = width*height;
  else if (format == imandreel_gl.RGB)
   size = width*height*3;
  else if (format == imandreel_gl.RGBA)
   size = width*height*4;
  else if (format == imandreel_gl.ALPHA)
   size = width*height;
  else if (format == imandreel_gl.LUMINANCE_ALPHA)
   size = width*height*2;

  buffer = new ArrayBuffer(size);
  bufferView = new Uint8Array(buffer);
 }

 imandreel_gl.texImage2D(target, level, internalFormat, width, height, border, format, type, bufferView);
 return;
  }


   var bufferView;
   if (type == imandreel_gl.UNSIGNED_SHORT_5_6_5 || type == imandreel_gl.UNSIGNED_SHORT_4_4_4_4 || type == imandreel_gl.UNSIGNED_SHORT_5_5_5_1)
   {
  bufferView = new Uint16Array(heap,data,width*height);
 }
 else if (type == imandreel_gl.UNSIGNED_BYTE)
 {
  if (format == imandreel_gl.LUMINANCE)
   bufferView = new Uint8Array(heap,data,width*height);
  else if (format == imandreel_gl.RGB)
   bufferView = new Uint8Array(heap,data,width*height*3);
  else if (format == imandreel_gl.RGBA)
   bufferView = new Uint8Array(heap,data,width*height*4);
  else if (format == imandreel_gl.ALPHA)
   bufferView = new Uint8Array(heap,data,width*height);
  else if (format == imandreel_gl.LUMINANCE_ALPHA)
   bufferView = new Uint8Array(heap,data,width*height*2);
  else
  {
   dump('format unknown ' + format + '\n');
   assert(false);
  }
 }
 else
 {
 dump('type unknown ' + type + '\n');
  assert(false);
 }

  imandreel_gl.texImage2D(target, level, internalFormat, width, height, border, format, type, bufferView);
  if ((width&(width-1))==0 && (height&(height-1))==0)
  {
    if (target==imandreel_gl.TEXTURE_2D)
 imandreel_gl.generateMipmap(target);
}
 }
  function myglStencilFunc(sp)
  {
  var func = heap32[sp>>2];sp+=4;
  var ref = heap32[sp>>2];sp+=4;
  var mask = heap32[sp>>2];sp+=4;

  imandreel_gl.stencilFunc(func, ref, mask);
  }

  function myglStencilFuncSeparate(sp)
  {
  var face = heap32[sp>>2];sp+=4;
  var func = heap32[sp>>2];sp+=4;
  var ref = heap32[sp>>2];sp+=4;
  var mask = heap32[sp>>2];sp+=4;

  imandreel_gl.stencilFuncSeparate(face,func,ref,mask);
  }

  function myglStencilMaskSeparate(sp)
  {
  var face = heap32[sp>>2];sp+=4;
   var mask = heap32[sp>>2];sp+=4;

   imandreel_gl.stencilMaskSeparate(face,mask);
  }

  function myglStencilMask(sp)
  {
   var mask = heap32[sp>>2];sp+=4;

   imandreel_gl.stencilMask(mask);
  }
  function myglStencilOp (sp)
  {
   var fail = heap32[sp>>2];sp+=4;
  var zfail = heap32[sp>>2];sp+=4;
   var zpass = heap32[sp>>2];sp+=4;

  imandreel_gl.stencilOp(fail, zfail, zpass);
  }

  function myglStencilOpSeparate (sp)
  {
  var face = heap32[sp>>2];sp+=4;
   var fail = heap32[sp>>2];sp+=4;
  var zfail = heap32[sp>>2];sp+=4;
   var zpass = heap32[sp>>2];sp+=4;

  imandreel_gl.stencilOpSeparate(face, fail, zfail, zpass);
  }

 function myglTexSubImage2D(sp)
 {
  var target = heap32[sp>>2];sp+=4;
  var level = heap32[sp>>2];sp+=4;
  var xoffset = heap32[sp>>2];sp+=4;
  var yoffset = heap32[sp>>2];sp+=4;
  var width = heap32[sp>>2];sp+=4;
  var height = heap32[sp>>2];sp+=4;
  var format = heap32[sp>>2];sp+=4;
  var type = heap32[sp>>2];sp+=4;
  var data = heap32[sp>>2];sp+=4;



   var bufferView;
   if (type == imandreel_gl.UNSIGNED_SHORT_5_6_5 || type == imandreel_gl.UNSIGNED_SHORT_4_4_4_4 || type == imandreel_gl.UNSIGNED_SHORT_5_5_5_1)
   {
  bufferView = new Uint16Array(heap,data,width*height);
 }
 else if (type == imandreel_gl.UNSIGNED_BYTE)
 {
  if (format == imandreel_gl.LUMINANCE)
   bufferView = new Uint8Array(heap,data,width*height);
  else if (format == imandreel_gl.RGB)
   bufferView = new Uint8Array(heap,data,width*height*3);
  else if (format == imandreel_gl.RGBA)
   bufferView = new Uint8Array(heap,data,width*height*4);
  else if (format == imandreel_gl.ALPHA)
   bufferView = new Uint8Array(heap,data,width*height);
 }

  imandreel_gl.texSubImage2D(target, level, xoffset, yoffset, width, height, format, type, bufferView);
 }


  function myglCreateBuffer(sp)
{
 var id = myglNewSlot();
 array_ids_ogl[id] = imandreel_gl.createBuffer();

 r_g0 = id;
}

var glBufferDataArray = [];

function myglBufferData(sp)
{
 var target = heapU32[sp>>2]; sp+=4;
 var size = heapU32[sp>>2]; sp+=4;
 var data = heapU32[sp>>2]; sp+=4;
 var usage = heapU32[sp>>2]; sp+=4;

 if (data == 0)
  imandreel_gl.bufferData(target, size, usage);
 else
 {
  if (usage == imandreel_gl.STATIC_DRAW || true)
  {
   var buffer_data = new Int8Array(heap, data, size);
   imandreel_gl.bufferData(target, buffer_data, usage);
  }
  else
  {
   var new_size = size/4;
   var buffer_data = glBufferDataArray[new_size];

   if (buffer_data == null)
   {
    buffer_data =  new Int32Array(new_size);
    glBufferDataArray[new_size] = buffer_data;
   }

   var new_data = data>>2;

   for ( var i = 0 ; i < new_size ; ++i )
   {
    buffer_data[i] = heap32[new_data+i];
   }

   imandreel_gl.bufferData(target, buffer_data, usage);
  }
 }
}

function myglBufferSubData(sp)
{
 var target = heapU32[sp>>2]; sp+=4;
 var offset = heapU32[sp>>2]; sp+=4;
 var size = heapU32[sp>>2]; sp+=4;
 var data = heapU32[sp>>2]; sp+=4;


 var buffer_data = new Int8Array(heap, data, size);
 imandreel_gl.bufferSubData(target, offset, buffer_data);

// dump('buffer sub data ' + offset + ' ' + size + ' ' + data + '\n')

}


function myglBindBuffer(sp)
{
 var target = heapU32[sp>>2]; sp+=4;
 var id = heapU32[sp>>2]; sp+=4;

 imandreel_gl.bindBuffer(target, array_ids_ogl[id]);
}


function myglUseProgram(sp)
{
 var program_id = heap32[sp>>2];sp+=4;

 g_current_program_id = program_id;

 imandreel_gl.useProgram(array_ids_ogl[program_id]);

}

function myglDisableVertexAttribArray(sp)
{
 var idx = heapU32[sp>>2];sp+=4;
 imandreel_gl.disableVertexAttribArray(idx);
}
function myglEnableVertexAttribArray(sp)
{
 var idx = heapU32[sp>>2];sp+=4;
 imandreel_gl.enableVertexAttribArray(idx);
}

function myglVertexAttribPointer(sp)
{
 var idx = heapU32[sp>>2];sp+=4;
 var size = heapU32[sp>>2];sp+=4;
 var type = heapU32[sp>>2];sp+=4;
 var normalized = heapU32[sp>>2];sp+=4;
 var stride = heapU32[sp>>2];sp+=4;
 var ptr = heapU32[sp>>2];sp+=4;

 //dump(idx + ' ' + size + ' ' + type + ' ' + normalized + ' ' + stride + ' ' + ptr + '\n');


 imandreel_gl.vertexAttribPointer(idx, size, type, normalized, stride, ptr);
}

function myglPolygonOffset(sp)
{
 var factor = heapFloat[sp>>2]; sp+=4;
 var units = heapFloat[sp>>2]; sp+=4;
 imandreel_gl.polygonOffset(factor, units);
}

function myglEnable(sp)
 {
 var value = heap32[sp>>2];sp+=4;

 imandreel_gl.enable(value);
  }

function myglDisable(sp)
 {
 var value = heap32[sp>>2];sp+=4;

 imandreel_gl.disable(value);
  }

  function myglDepthFunc(sp)
  {
 var func = heapU32[sp>>2];sp+=4;

 imandreel_gl.depthFunc(func);

  }

  function myglGenerateMipmap(sp)
  {
 var texture_type = heap32[sp>>2];sp+=4;
 imandreel_gl.generateMipmap(texture_type);
  }

  function myglPixelStorei (sp)
  {
 var pname = heap32[sp>>2];sp+=4;
 var param = heap32[sp>>2];sp+=4;
 imandreel_gl.pixelStorei(pname,param);
  }


  function myglBindTexture(sp)
  {
  var texture_type = heap32[sp>>2];sp+=4;
  var texture_id = heap32[sp>>2];sp+=4;

if (texture_id == 0)
{
 imandreel_gl.bindTexture(texture_type, null);
}
else
{
 var tex = array_ids_ogl[texture_id];
 imandreel_gl.bindTexture(texture_type, tex);
 }

  }

  function myglActiveTexture(sp)
{
 var param = heapU32[sp>>2];sp+=4;
 imandreel_gl.activeTexture(param);
}

function myglCompileShader(sp)
{
 var id = heap32[sp>>2];sp+=4;

 var shader = array_ids_ogl[id];

 imandreel_gl.compileShader(shader);
}

function myglGetUniformLocation(sp)
{
 var program_id = heap32[sp>>2];sp+=4;
 var ptr_string = heap32[sp>>2];sp+=4;

 var string = get_string_from_ptr(ptr_string);
 var program = array_ids_ogl[program_id];
 var result = imandreel_gl.getUniformLocation(program, string);

 if (result != null)
 {
  program.array_uniform_locations[program.uniform_locations_current_id] = result;
  r_g0 = program.uniform_locations_current_id;
  program.uniform_locations_current_id++;
 }
 else
  r_g0 = -1;
}

function myglIsEnabled(sp)
{
 var cap = heap32[sp>>2];sp+=4;

 r_g0 = imandreel_gl.isEnabled(cap);
}


function myglUniform1i(sp)
{
 var index = heap32[sp>>2];sp+=4;
 var value = heap32[sp>>2];sp+=4;

 var program = array_ids_ogl[g_current_program_id];

 var uniform_value = program.array_uniform_locations[index];

 imandreel_gl.uniform1i(uniform_value, value);
}

function myglUniform2i(sp)
{
 var index = heap32[sp>>2];sp+=4;
 var x = heap32[sp>>2];sp+=4;
 var y = heap32[sp>>2];sp+=4;

 var program = array_ids_ogl[g_current_program_id];

 var uniform_value = program.array_uniform_locations[index];

 imandreel_gl.uniform2i(uniform_value, x,y);
}

function myglUniform3i(sp)
{
 var index = heap32[sp>>2];sp+=4;
 var x = heap32[sp>>2];sp+=4;
 var y = heap32[sp>>2];sp+=4;
 var z = heap32[sp>>2];sp+=4;

 var program = array_ids_ogl[g_current_program_id];

 var uniform_value = program.array_uniform_locations[index];

 imandreel_gl.uniform3i(uniform_value, x,y,z);
}

function myglUniform4i(sp)
{
 var index = heap32[sp>>2];sp+=4;
 var x = heap32[sp>>2];sp+=4;
 var y = heap32[sp>>2];sp+=4;
 var z = heap32[sp>>2];sp+=4;
 var w = heap32[sp>>2];sp+=4;

 var program = array_ids_ogl[g_current_program_id];

 var uniform_value = program.array_uniform_locations[index];

 imandreel_gl.uniform4i(uniform_value, x,y,z,w);
}

function myglUniform1f(sp)
{
 var index = heap32[sp>>2];sp+=4;
 var value = heapFloat[sp>>2];sp+=4;

 var program = array_ids_ogl[g_current_program_id];

 var uniform_value = program.array_uniform_locations[index];

 imandreel_gl.uniform1f(uniform_value, value);
}

function myglUniform3f(sp)
{
 var index = heap32[sp>>2];sp+=4;
 var x = heapFloat[sp>>2];sp+=4;
 var y = heapFloat[sp>>2];sp+=4;
 var z = heapFloat[sp>>2];sp+=4;

 var program = array_ids_ogl[g_current_program_id];

 var uniform_value = program.array_uniform_locations[index];

 imandreel_gl.uniform3f(uniform_value, x,y,z);
}

function myglUniform2f(sp)
{
 var index = heap32[sp>>2];sp+=4;
 var x = heapFloat[sp>>2];sp+=4;
 var y = heapFloat[sp>>2];sp+=4;

 var program = array_ids_ogl[g_current_program_id];

 var uniform_value = program.array_uniform_locations[index];

 imandreel_gl.uniform2f(uniform_value, x,y);
}


function myglUniform4f(sp)
{
 var index = heap32[sp>>2];sp+=4;
 var x = heapFloat[sp>>2];sp+=4;
 var y = heapFloat[sp>>2];sp+=4;
 var z = heapFloat[sp>>2];sp+=4;
 var w = heapFloat[sp>>2];sp+=4;

 var program = array_ids_ogl[g_current_program_id];
 var uniform_value = program.array_uniform_locations[index];

 imandreel_gl.uniform4f(uniform_value, x,y,z,w);
}

function myglUniform1fv(sp)
{
 var index = heap32[sp>>2];sp+=4;
 var count = heap32[sp>>2];sp+=4;
 var data = heap32[sp>>2];sp+=4;

 var new_data = data>>2;
 var new_count = count;
 var bufferView = new Float32Array(new_count);

 for ( var i = 0 ; i < new_count ; ++i )
 {
  bufferView[i] = heapFloat[new_data+i];
 }

 var program = array_ids_ogl[g_current_program_id];
 var uniform_value = program.array_uniform_locations[index];
 imandreel_gl.uniform1fv(uniform_value, bufferView);


}

function myglUniform1iv(sp)
{
 var index = heap32[sp>>2];sp+=4;
 var count = heap32[sp>>2];sp+=4;
 var data = heap32[sp>>2];sp+=4;

 var new_data = data>>2;
 var new_count = count;
 var bufferView = new Int32Array(new_count);

 for ( var i = 0 ; i < new_count ; ++i )
 {
  bufferView[i] = heap32[new_data+i];
 }

 var program = array_ids_ogl[g_current_program_id];
 var uniform_value = program.array_uniform_locations[index];
 imandreel_gl.uniform1iv(uniform_value, bufferView);
}

function myglUniform2iv(sp)
{
 var index = heap32[sp>>2];sp+=4;
 var count = heap32[sp>>2];sp+=4;
 var data = heap32[sp>>2];sp+=4;

 var new_data = data>>2;
 var new_count = count*2;
 var bufferView = new Int32Array(new_count);

 for ( var i = 0 ; i < new_count ; ++i )
 {
  bufferView[i] = heap32[new_data+i];
 }

 var program = array_ids_ogl[g_current_program_id];
 var uniform_value = program.array_uniform_locations[index];
 imandreel_gl.uniform2iv(uniform_value, bufferView);
}

function myglUniform3iv(sp)
{
 var index = heap32[sp>>2];sp+=4;
 var count = heap32[sp>>2];sp+=4;
 var data = heap32[sp>>2];sp+=4;

 var new_data = data>>2;
 var new_count = count*3;
 var bufferView = new Int32Array(new_count);

 for ( var i = 0 ; i < new_count ; ++i )
 {
  bufferView[i] = heap32[new_data+i];
 }

 var program = array_ids_ogl[g_current_program_id];
 var uniform_value = program.array_uniform_locations[index];
 imandreel_gl.uniform3iv(uniform_value, bufferView);
}

function myglUniform4iv(sp)
{
 var index = heap32[sp>>2];sp+=4;
 var count = heap32[sp>>2];sp+=4;
 var data = heap32[sp>>2];sp+=4;

 var new_data = data>>2;
 var new_count = count*4;
 var bufferView = new Int32Array(new_count);

 for ( var i = 0 ; i < new_count ; ++i )
 {
  bufferView[i] = heap32[new_data+i];
 }

 var program = array_ids_ogl[g_current_program_id];
 var uniform_value = program.array_uniform_locations[index];
 imandreel_gl.uniform4iv(uniform_value, bufferView);
}



function myglUniform3fv(sp)
{
 myglCreateUniformArrays();

 var index = heap32[sp>>2];sp+=4;
 var count = heap32[sp>>2];sp+=4;
 var data = heap32[sp>>2];sp+=4;

 var new_data = data>>2;
 var new_count = count*3;
 var bufferView = uniformArrays3[count];

 for ( var i = 0 ; i < new_count ; ++i )
 {
  bufferView[i] = heapFloat[new_data+i];
 }

 var program = array_ids_ogl[g_current_program_id];
 var uniform_value = program.array_uniform_locations[index];
 imandreel_gl.uniform3fv(uniform_value, bufferView);
}

function myglUniform2fv(sp)
{
 myglCreateUniformArrays();

    var index = heap32[sp >> 2]; sp += 4;
    var count = heap32[sp >> 2]; sp += 4;
    var data = heap32[sp >> 2]; sp += 4;

 var new_data = data>>2;
 var new_count = count*2;
 var bufferView = uniformArrays2[count];

 for ( var i = 0 ; i < new_count ; ++i )
 {
  bufferView[i] = heapFloat[new_data+i];
 }


 var program = array_ids_ogl[g_current_program_id];
    var uniform_value = program.array_uniform_locations[index];
    imandreel_gl.uniform2fv(uniform_value, bufferView);
}


function myglUniform4fv(sp)
{
 myglCreateUniformArrays();

 var index = heap32[sp>>2];sp+=4;
 var count = heap32[sp>>2];sp+=4;
 var data = heap32[sp>>2];sp+=4;


 var new_data = data>>2;
 var new_count = count*4;
 var bufferView = uniformArrays4[count];

 for ( var i = 0 ; i < new_count ; ++i )
 {
  bufferView[i] = heapFloat[new_data+i];
 }


 var program = array_ids_ogl[g_current_program_id];
 var uniform_value = program.array_uniform_locations[index];
 imandreel_gl.uniform4fv(uniform_value, bufferView);
}


function myglUniformMatrix4fv(sp)
{
 myglCreateUniformArrays();

 var index = heap32[sp>>2];sp+=4;
 var count = heap32[sp>>2];sp+=4;
 var transpose = heap32[sp>>2];sp+=4;
 var ptr = heap32[sp>>2];sp+=4;

 var program = array_ids_ogl[g_current_program_id];
 var uniform_value = program.array_uniform_locations[index];

 //var buffer_data = new Float32Array(heap, ptr, count*16);
 for ( var i = 0 ; i < count*16 ; ++i )
 {
  uniformArrays4[count*4][i] = heapFloat[(ptr>>2)+i];
 }

 //imandreel_gl.uniformMatrix4fv(uniform_value, transpose, buffer_data);
 //imandreel_gl.uniformMatrix4fv(uniform_value, transpose, heapFloat.subarray(ptr/4,(ptr/4)+(count*16)));
 imandreel_gl.uniformMatrix4fv(uniform_value, transpose, uniformArrays4[count*4]);
}

function myglUniformMatrix3fv(sp)
{
 myglCreateUniformArrays();

 var index = heap32[sp>>2];sp+=4;
 var count = heap32[sp>>2];sp+=4;
 var transpose = heap32[sp>>2];sp+=4;
 var ptr = heap32[sp>>2];sp+=4;

 var program = array_ids_ogl[g_current_program_id];
 var uniform_value = program.array_uniform_locations[index];

 //var buffer_data = new Float32Array(heap, ptr, count*9);
 for ( var i = 0 ; i < count*9 ; ++i )
 {
  uniformArrays3[count*3][i] = heapFloat[(ptr>>2)+i];
 }

 //imandreel_gl.uniformMatrix3fv(uniform_value, transpose, buffer_data);
 //imandreel_gl.uniformMatrix3fv(uniform_value, transpose, heapFloat.subarray(ptr/4,(ptr/4)+(count*9)));
 imandreel_gl.uniformMatrix3fv(uniform_value, transpose, uniformArrays3[count*3]);
}



function myglValidateProgram(sp)
{
 var program_id = heap32[sp>>2];sp+=4;

 imandreel_gl.validateProgram(array_ids_ogl[program_id]);
}

function myglGetAttribLocation(sp)
{
 var program_id = heap32[sp>>2];sp+=4;
 var ptr_string = heap32[sp>>2];sp+=4;

 var string = get_string_from_ptr(ptr_string);
 var result = imandreel_gl.getAttribLocation(array_ids_ogl[program_id], string);

 r_g0 = result;
}

function myglGetProgramInfoLogLength(sp)
{
 var program_id = heap32[sp>>2];sp+=4;

 var info_log = imandreel_gl.getProgramInfoLog(array_ids_ogl[program_id]);

 if (info_log)
  r_g0 = info_log.length+1;
 else
  r_g0 = 0;
}


function myglGetProgramInfoLog(sp)
{
 var program_id = heap32[sp>>2];sp+=4;
 var ptr_string = heap32[sp>>2];sp+=4;

 var info_log = imandreel_gl.getProgramInfoLog(array_ids_ogl[program_id]);

 fill_ptr_from_string(ptr_string, info_log);
}

function myglGetShaderInfoLogLength(sp)
{
 var program_id = heap32[sp>>2];sp+=4;

 var info_log = imandreel_gl.getShaderInfoLog(array_ids_ogl[program_id]);

 if (info_log)
  r_g0 = info_log.length+1;
 else
  r_g0 = 0;
}

function myglGetShaderInfoLog(sp)
{
 var program_id = heap32[sp>>2];sp+=4;
 var ptr_string = heap32[sp>>2];sp+=4;

 var info_log = imandreel_gl.getShaderInfoLog(array_ids_ogl[program_id]);

 fill_ptr_from_string(ptr_string, info_log);
}

function myglViewport(sp) {
    var x = heap32[sp >> 2]; sp += 4;
    var y = heap32[sp >> 2]; sp += 4;
    var width = heap32[sp >> 2]; sp += 4;
    var height = heap32[sp >> 2]; sp += 4;

    imandreel_gl.viewport(x,y,width,height);

}

function myglScissor(sp)
{
    var x = heap32[sp >> 2]; sp += 4;
    var y = heap32[sp >> 2]; sp += 4;
    var width = heap32[sp >> 2]; sp += 4;
    var height = heap32[sp >> 2]; sp += 4;

    imandreel_gl.scissor(x,y,width,height);
}



function myglClearColor(sp)
{
  var r = heapFloat[sp>>2];sp+=4;
  var g = heapFloat[sp>>2];sp+=4;
  var b = heapFloat[sp>>2];sp+=4;
  var a = heapFloat[sp>>2];sp+=4;

  imandreel_gl.clearColor(r,g,b,a);


}

function myglClearStencil(sp)
{
 var stencil = heap32[sp>>2];sp+=4;
 imandreel_gl.clearStencil(stencil);
}


function myglClearDepthf(sp)
{
 var depth = heapFloat[sp>>2];sp+=4;
 imandreel_gl.clearDepth(depth);
}

function myglClear(sp)
  {
  var mask = heap32[sp>>2];sp+=4;


  //dump('clear ' + mask + '\n');
 if (mandreel_draw_enable)
  imandreel_gl.clear(mask);
  }

  function myglGetError(sp)
  {
// r_g0 = imandreel_gl.getError();
 r_g0 = 0;
  }

  function myglGetProgramParameter(sp)
  {
 var program_id = heap32[sp>>2];sp+=4;
 var pname = heap32[sp>>2];sp+=4;

 r_g0 = imandreel_gl.getProgramParameter(array_ids_ogl[program_id], pname);
  }

  function myglGetActiveAttrib (sp)
  {
 var program_id = heap32[sp>>2];sp+=4;
 var index = heap32[sp>>2];sp+=4;
 var ptr = heap32[sp>>2];sp+=4;

  var result = imandreel_gl.getActiveAttrib(array_ids_ogl[program_id], index);

  if (result != null)
  {
  heap32[(ptr)>>2] = result.size;
  heap32[(ptr+4)>>2] = result.type;
  fill_ptr_from_string(ptr+8, result.name);
  r_g0 = 0;
 }
 else
    r_g0 = 1;
  }

    function myglGetActiveUniform (sp)
  {
 var program_id = heap32[sp>>2];sp+=4;
 var index = heap32[sp>>2];sp+=4;
 var ptr = heap32[sp>>2];sp+=4;

  var result = imandreel_gl.getActiveUniform(array_ids_ogl[program_id], index);

  if (result != null)
  {
  heap32[(ptr)>>2] = result.size;
  heap32[(ptr+4)>>2] = result.type;
  fill_ptr_from_string(ptr+8, result.name);
  r_g0 = 0;
 }
 else
    r_g0 = 1;
  }

  function myglTexParameterf (sp)
  {
 var target = heap32[sp>>2];sp+=4;
 var pname = heap32[sp>>2];sp+=4;
 var value = heapFloat[sp>>2];sp+=4;

 imandreel_gl.texParameterf(target,pname,value);
}

function myglTexParameteri (sp)
  {
 var target = heap32[sp>>2];sp+=4;
 var pname = heap32[sp>>2];sp+=4;
 var value = heap32[sp>>2];sp+=4;

 imandreel_gl.texParameteri(target,pname,value);
}

function myglCullFace (sp)
 {
 var mode = heap32[sp>>2];sp+=4;
 imandreel_gl.cullFace(mode);
 }

 function myglDepthMask (sp)
 {
 var flag = heap32[sp>>2];sp+=4;
 imandreel_gl.depthMask(flag);
 }

 function myglDepthRangef (sp)
 {
 var zNear = heapFloat[sp>>2];sp+=4;
 var zFar = heapFloat[sp>>2];sp+=4;
 imandreel_gl.depthRange(zNear, zFar);
 }

function myglFrontFace (sp)
 {
 var mode = heap32[sp>>2];sp+=4;
 imandreel_gl.frontFace(mode);
 }

 function myglBlendFunc (sp)
 {
 var sfactor = heap32[sp>>2];sp+=4;
 var dfactor = heap32[sp>>2];sp+=4;
 imandreel_gl.blendFunc(sfactor,dfactor);
 }

 function myglBlendColor(sp)
 {
 var red = heapFloat[sp>>2];sp+=4;
 var green = heapFloat[sp>>2];sp+=4;
 var blue = heapFloat[sp>>2];sp+=4;
 var alpha = heapFloat[sp>>2];sp+=4;
 imandreel_gl.blendColor(red,green,blue,alpha);
 }

 function myglBlendEquation(sp)
 {
 var mode = heap32[sp>>2];sp+=4;
 imandreel_gl.blendEquation(mode);
 }

 function myglBlendEquationSeparate(sp)
 {
 var modeRGB = heap32[sp>>2];sp+=4;
 var modeAlpha = heap32[sp>>2];sp+=4;
 imandreel_gl.blendEquationSeparate(modeRGB,modeAlpha);
 }

 function myglBlendFuncSeparate(sp)
 {
 var srcRGB = heap32[sp>>2];sp+=4;
 var dstRGB = heap32[sp>>2];sp+=4;
 var srcAlpha = heap32[sp>>2];sp+=4;
 var dstAlpha = heap32[sp>>2];sp+=4;

 imandreel_gl.blendFuncSeparate(srcRGB,dstRGB,srcAlpha,dstAlpha);
 }


 function myglColorMask (sp)
 {
 var red = heap32[sp>>2];sp+=4;
 var green = heap32[sp>>2];sp+=4;
 var blue = heap32[sp>>2];sp+=4;
 var alpha = heap32[sp>>2];sp+=4;
 imandreel_gl.colorMask(red,green,blue,alpha);
 }

 function removeByElement(arrayName,arrayElement)
 {
    for(var i=0; i<arrayName.length;i++ )
     {
        if(arrayName[i]==arrayElement)
  {
            arrayName.splice(i,1);
   return;
  }
      }
  }


 function mygetParameter(sp)
 {
 var pname = heap32[sp>>2];sp+=4;
 r_g0 = imandreel_gl.getParameter(pname);
 }


 function mygetProgramParameter(sp)
 {
  var program_id = heap32[sp>>2];sp+=4;
 var pname = heap32[sp>>2];sp+=4;
 r_g0 = imandreel_gl.getProgramParameter(array_ids_ogl[program_id], pname);
 }

 function mygetShaderParameter(sp)
 {
  var shader_id = heap32[sp>>2];sp+=4;
 var pname = heap32[sp>>2];sp+=4;
 r_g0 = imandreel_gl.getShaderParameter(array_ids_ogl[shader_id], pname);
 }

 function myglVertexAttrib1f(sp)
 {
 var index = heap32[sp>>2];sp+=4;
 var x = heapFloat[sp>>2];sp+=4;
 imandreel_gl.vertexAttrib1f(index,x);
 }

  function myglVertexAttrib2f(sp)
 {
 var index = heap32[sp>>2];sp+=4;
 var x = heapFloat[sp>>2];sp+=4;
 var y = heapFloat[sp>>2];sp+=4;
 imandreel_gl.vertexAttrib2f(index,x,y);
 }

  function myglVertexAttrib3f(sp)
 {
 var index = heap32[sp>>2];sp+=4;
 var x = heapFloat[sp>>2];sp+=4;
 var y = heapFloat[sp>>2];sp+=4;
 var z = heapFloat[sp>>2];sp+=4;
 imandreel_gl.vertexAttrib3f(index,x,y,z);
 }

  function myglVertexAttrib4f(sp)
 {
 var index = heap32[sp>>2];sp+=4;
 var x = heapFloat[sp>>2];sp+=4;
 var y = heapFloat[sp>>2];sp+=4;
 var z = heapFloat[sp>>2];sp+=4;
 var w = heapFloat[sp>>2];sp+=4;
 imandreel_gl.vertexAttrib4f(index,x,y,z,w);
 }

 function myglVertexAttrib1fv(sp)
 {
 var index = heap32[sp>>2];sp+=4;
 var ptr = heap32[sp>>2];sp+=4;
 var x = heap32[ptr>>2];ptr+=4;
 imandreel_gl.vertexAttrib1f(index,x);
 }

 function myglVertexAttrib2fv(sp)
 {
 var index = heap32[sp>>2];sp+=4;
 var ptr = heap32[sp>>2];sp+=4;
 var x = heap32[ptr>>2];ptr+=4;
 var y = heap32[ptr>>2];ptr+=4;

 imandreel_gl.vertexAttrib2f(index,x,y);
 }

 function myglVertexAttrib3fv(sp)
 {
 var index = heap32[sp>>2];sp+=4;
 var ptr = heap32[sp>>2];sp+=4;
 var x = heap32[ptr>>2];ptr+=4;
 var y = heap32[ptr>>2];ptr+=4;
 var z = heap32[ptr>>2];ptr+=4;

 imandreel_gl.vertexAttrib3f(index,x,y,z);
 }

 function myglVertexAttrib4fv(sp)
 {
 var index = heap32[sp>>2];sp+=4;
 var ptr = heap32[sp>>2];sp+=4;
 var x = heap32[ptr>>2];ptr+=4;
 var y = heap32[ptr>>2];ptr+=4;
 var z = heap32[ptr>>2];ptr+=4;
 var w = heap32[ptr>>2];ptr+=4;

 imandreel_gl.vertexAttrib4f(index,x,y,z,w);
 }


 function myglDeleteTexture (sp)
 {

 var texture_id = heap32[sp>>2];sp+=4;

 var texture = array_ids_ogl[texture_id];

 imandreel_gl.deleteTexture(texture);

 array_ids_ogl[texture_id] = null;

 myglFreeSlot(texture_id);
 }

 function myglDeleteBuffer (sp)
 {

 var buffer_id = heap32[sp>>2];sp+=4;

 var buffer = array_ids_ogl[buffer_id];

 imandreel_gl.deleteBuffer(buffer);

 array_ids_ogl[buffer_id] = null;

 myglFreeSlot(buffer_id);
 }

 function myglDeleteFrameBuffer (sp)
 {
 var framebuffer_id = heap32[sp>>2];sp+=4;

 var framebuffer = array_ids_ogl[framebuffer_id];

 imandreel_gl.deleteFramebuffer(framebuffer);

 array_ids_ogl[framebuffer_id] = null;

 myglFreeSlot(framebuffer_id);
 }


 function myglDeleteProgram (sp)
 {
 var program_id = heap32[sp>>2];sp+=4;

 var program = array_ids_ogl[program_id];

 imandreel_gl.deleteProgram(program);

 array_ids_ogl[program_id] = null;

 myglFreeSlot(program_id);
 }

 function myglDeleteRenderBuffer (sp)
 {
 var renderbuffer_id = heap32[sp>>2];sp+=4;

 var renderbuffer = array_ids_ogl[renderbuffer_id];

 imandreel_gl.deleteRenderbuffer(renderbuffer);

 array_ids_ogl[renderbuffer_id] = null;

 myglFreeSlot(renderbuffer_id);
 }

 function myglDeleteShader (sp)
 {
 var shader_id = heap32[sp>>2];sp+=4;

 var shader = array_ids_ogl[shader_id];

 imandreel_gl.deleteShader(shader);

 array_ids_ogl[shader_id] = null;

 myglFreeSlot(shader_id);
 }

 function myglInit(sp)
 {

 for (var i=0;i<max_ogl_id;++i)
 {
  array_ids_ogl_enable.push(i+1);
 }
 }

 function myglReadPixels(sp)
 {
  var x = heap32[sp>>2];sp+=4;
  var y = heap32[sp>>2];sp+=4;
  var width = heap32[sp>>2];sp+=4;
  var height = heap32[sp>>2];sp+=4;
  var format = heap32[sp>>2];sp+=4;
  var type = heap32[sp>>2];sp+=4;
  var pixels = heap32[sp>>2];sp+=4;

 var bufferView = new Uint8Array(heap,pixels,width*height*4);
  imandreel_gl.readPixels(x,y,width,height,format,type,bufferView);
}

function mandreel_internal_DrawSprite(sp)
{
 if ( imandreel_ctx_canvas == null )
 {
  console.log("Mandreel_2D_DrawSprite error: canvas context is null");
  return;
 }

 var hw_id = heap32[sp>>2]; sp+=4;
 var u0 = heapFloat[sp>>2]; sp+=4;
 var u1 = heapFloat[sp>>2]; sp+=4;
 var v0 = heapFloat[sp>>2]; sp+=4;
 var v1 = heapFloat[sp>>2]; sp+=4;
 //var x = heapFloat[sp>>2]; sp+=4;
 //var y = heapFloat[sp>>2]; sp+=4;
 var sx = heapFloat[sp>>2]; sp+=4;
 var sy = heapFloat[sp>>2]; sp+=4;
 //var rot = heapFloat[sp>>2]; sp+=4;
 var m11 = heapFloat[sp>>2]; sp+=4;
 var m12 = heapFloat[sp>>2]; sp+=4;
 var m21 = heapFloat[sp>>2]; sp+=4;
 var m22 = heapFloat[sp>>2]; sp+=4;
 var tx = heapFloat[sp>>2]; sp+=4;
 var ty = heapFloat[sp>>2]; sp+=4;
 var color = heap32[sp>>2]; sp+=4;

 //ctx_canvas.fillStyle="#FF0000";
 //ctx_canvas.fillRect(tx,ty,sx,sy);
 var texture = array_ids_ogl[hw_id];

 if ( texture == null )
 {
  console.log("Mandreel_2D_DrawSprite error: texture invalid ("+hw_id+") or loading yet...");
  return;
 }

 var width = (u1-u0)*texture.width;
 var height = (v1-v0)*texture.height;

 if (width == 0)
  return;
 if (height == 0)
  return;

 var x_offset = u0*texture.width;
 var y_offset = v0*texture.height;

 //dump(x_offset + ' ' + y_offset + ' ' + texture.width + ' ' + texture.height + ' ' + x + ' ' +y + ' ' + width + ' ' + height + '\n');

 x_offset = x_offset % texture.width;
 y_offset = y_offset % texture.height;

 var scale_x, scale_y;
 if (sx<0)
  scale_x = -1;
 else
  scale_x = 1;
 if (sy<0)
  scale_y = -1;
 else
  scale_y = 1;

 var simple_draw = false;//scale_x == 1 && scale_y == 1 && rot == 0;
 var x_pos = (0.5*sx + tx/* + 240*/);
 var y_pos = (/*320*/ + ((0.5*sy + ty) /*+ 160*/));
 var new_sx = sx;
 var new_sy = sy;

 imandreel_ctx_canvas.globalAlpha = (color>>>24)/255;

 if (!simple_draw)
 {
  imandreel_ctx_canvas.save()
  /*ctx_canvas.translate(x_pos + new_sx/2, y_pos + new_sy/2)
ctx_canvas.rotate(-rot*Math.PI/180);
ctx_canvas.scale(scale_x, scale_y);
ctx_canvas.translate(-(x_pos + new_sx/2), -(y_pos + new_sy/2))*/
  imandreel_ctx_canvas.setTransform(m11,m12,m21,m22,tx,ty);
 }

 /*if (x_offset<0 || y_offset<0 || (x_offset+width)>texture.width || (y_offset+height)>texture.height)
{
dump(x_offset + ' ' + y_offset + ' ' + texture.width + ' ' + texture.height + ' ' + x + ' ' +y + ' ' + width + ' ' + height + '\n');
}*/

 if (new_sx<0)
 {
  x_pos += new_sx;
  new_sx = -new_sx;
 }
 if (new_sy<0)
 {
  y_pos += new_sy;
  new_sy = -new_sy;
 }

 //ctx_canvas.drawImage(texture,x_offset,y_offset, width, height, x_pos, y_pos , new_sx, new_sy);
 imandreel_ctx_canvas.drawImage(texture,x_offset,y_offset, width, height, 0,0, 1,1);

 if (!simple_draw)
  imandreel_ctx_canvas.restore()
}

function mandreel_internal_UpdateTexture(sp)
{
 if ( imandreel_ctx_canvas == null )
 {
  console.log("Mandreel_2D_UpdateTexture error: canvas context is null");
  return;
 }

 var hw_id = heap32[sp>>2]; sp+=4;
 var dataptr = heap32[sp>>2]; sp+=4;
 var width = heap32[sp>>2]; sp+=4;
 var height = heap32[sp>>2]; sp+=4;

 var imageData = imandreel_ctx_canvas.getImageData(0,0,width,height);
 var data = imageData.data;
 for (var y = 0; y < (height*width*4); ++y)
 {
  data[y] = heapU8[dataptr + y];
 }
 imandreel_ctx_canvas.putImageData(imageData,0,0);

 var dataurl = imandreel_ctx_canvas.canvas.toDataURL();

 var image = new Image();
 image.onerror = function()
 {
  dump('error updating texture '+hw_id+'\n');
    }
 image.onload = function()
 {
  //dump('texture '+hw_id+' updated\n'+'width '+image.width+' height '+image.height);
  array_ids_ogl[hw_id] = image;
 }
 image.src = dataurl;
}

function mandreel_internal_WriteFramebuffer(sp)
{
 if ( imandreel_ctx_canvas == null )
 {
  console.log("Mandreel_2D_UpdateTexture error: canvas context is null");
  return;
 }

 var dataptr = heap32[sp>>2]; sp+=4;
 var width = heap32[sp>>2]; sp+=4;
 var height = heap32[sp>>2]; sp+=4;

 var imageData = imandreel_ctx_canvas.getImageData(0,0,width,height);
 if ( imageData != null )
 {
  var data = imageData.data;
  if ( data != null )
  {
   var size = (height*width*4);
   if ( typeof imageData.data.set != "undefined" )
   {
    var sub = heapU8.subarray(dataptr,dataptr+size);
    imageData.data.set(sub);
   }
   else
   {
    for (var y = 0; y < size; ++y)
    {
     data[y] = heapU8[dataptr + y];
    }
   }

   imandreel_ctx_canvas.putImageData(imageData,0,0);
  }
  else
  {
   dump("WriteFramebuffer canvas data null");
  }
 }
 else
 {
  dump("WriteFramebuffer canvas imageData null");
 }
}
var mandreel_audio_init = null_mandreel_audio;
var mandreel_audio_end = null_mandreel_audio;
var mandreel_audio_update = null_mandreel_audio;
var mandreel_audio_createBuffer = null_mandreel_audio;
var mandreel_audio_playChannel = null_mandreel_audio;
var mandreel_audio_stopChannel = null_mandreel_audio;
var mandreel_audio_setChannelVolume = null_mandreel_audio;
var mandreel_audio_setChannelPan = null_mandreel_audio;
var mandreel_audio_setChannelPitch = null_mandreel_audio;
var mandreel_audio_playMusic = null_mandreel_audio;
var mandreel_audio_stopMusic = null_mandreel_audio;
var mandreel_audio_useMusicFunctions = _mandreel_audio_useMusicFunctions;
var mandreel_audio_checkBuffersPending = null_mandreel_audio;
var mandreel_audio_setMusicVol = null_mandreel_audio;

var mandreel_audio_startedFunction = 0;

var MandreelAudioDriver = "null";

function mandreel_start_audio(audioServer, audioUrl,startedFunction)
{
 mandreel_audio_startedFunction = startedFunction;

 // Check audio driver data availability
 var webAudioDataAvailable = false;
 var flashAudioDataAvailable = false;
 var flashLiteAudioDataAvailable = false;
 var audiotagsDataAvailable = false;
 var FatLines = mandreelFatData.split('\n');
 for ( var i=0;i<FatLines.length;++i )
 {
  var params = FatLines[i].split(',');
  if ( params[0] == "audiodriver" )
  {
   var data = params[1];
   data = data.replace('\r','');
   if ( data == "webaudio" )
    webAudioDataAvailable = true;
   else if ( data == "flash" )
    flashAudioDataAvailable = true;
   else if ( data == "flashlite" )
    flashLiteAudioDataAvailable = true;
   else if ( data == "audiotag" )
    audiotagsDataAvailable = true;
  }
 }


 // Init audio driver
 {
  // webaudio
  if ( webAudioDataAvailable && MandreelAudioDriver == "null" )
  {
   try { webAudioContext = new webkitAudioContext(); } catch(err) { webAudioContext = 0; }
   if ( webAudioContext )
   {
    wa_MainAudioDriver();
    MandreelAudioDriver = "webAudio";
   }
  }
  // flash
  if ( flashAudioDataAvailable && MandreelAudioDriver == "null" )
  {
   MandreelAudioDriver = "flash";
   if ( audioServer == null )
   {
    audioServer = "";
    audioUrl = "";
   }
   fl_MainAudioDriver(audioServer,audioUrl);
  }
  // flashlite
  if ( flashLiteAudioDataAvailable && MandreelAudioDriver == "null" )
  {
   MandreelAudioDriver = "flashlite";
   mandreel_flashaudio_lite = true;
   fl_MainAudioDriver("","");
  }
  // audiotags
  if ( audiotagsDataAvailable && MandreelAudioDriver == "null" )
  {
   MandreelAudioDriver = "audiotag";
   at_MainAudioDriver();
  }
  // null
  if ( MandreelAudioDriver == "null" )
  {
   null_MainAudioDriver();
  }
 }
 dump("AudioDriver ("+MandreelAudioDriver+")");
}

function mandreel_audio_isLogEnabled(sp)
{
 r_g0 = 0;
}

function _mandreel_audio_useMusicFunctions(sp)
{
 r_g0 = 0;
}

function MandreelAudioStarted()
{
 setTimeout(mandreel_audio_startedFunction, 10);
}


function mandreel_audio_getAudioDriverName(sp)
{
 var name_ptr = heap32[sp>>2];sp+=4;
 fill_ptr_from_string(name_ptr, MandreelAudioDriver);
}
var webAudioUseMusicFunctions = true;

function wa_mandreel_audio_init(sp)
{
}

function wa_mandreel_audio_end(sp)
{
}

function wa_mandreel_audio_update(sp)
{
}

function wa_mandreel_audio_checkBuffersPending(sp)
{
 r_g0 = wa_imp_mandreel_audio_checkBuffersPending();
}

function wa_mandreel_audio_createBuffer(sp)
{
 var ptr_fileName = heap32[sp>>2];sp+=4;
 var maxChannels = heap32[sp>>2];sp+=4;
 var fileName = get_string_from_ptr(ptr_fileName).toLowerCase();
 wa_imp_mandreel_audio_createBuffer(fileName);

 r_g0 = 0;
}

function wa_mandreel_audio_playChannel(sp)
{
 var ptr_fileName = heap32[sp>>2];sp+=4;
 var channel = heap32[sp>>2];sp+=4;
 var vol = heapFloat[sp>>2];sp+=4;
 var loop = heap32[sp>>2];sp+=4;
 var pitch = heapFloat[sp>>2];sp+=4;
 var fileName = get_string_from_ptr(ptr_fileName).toLowerCase();
 wa_imp_mandreel_audio_playChannel(fileName,channel,vol,loop,pitch);
 r_g0 = 0;
}

function wa_mandreel_audio_stopChannel(sp)
{
 var ptr_fileName = heap32[sp>>2];sp+=4;
 var channel = heap32[sp>>2];sp+=4;
 var index = heapFloat[sp>>2];sp+=4;
 wa_imp_mandreel_audio_stopChannel(channel);
}

function wa_mandreel_audio_setChannelVolume(sp)
{
 var channel = heap32[sp>>2];sp+=4;
 var vol = heapFloat[sp>>2];sp+=4;
 wa_imp_mandreel_audio_setChannelVolume(channel,vol);
}

function wa_mandreel_audio_setChannelPan(sp)
{
 var channel = heap32[sp>>2];sp+=4;
 var pan = heapFloat[sp>>2];sp+=4;
 wa_imp_mandreel_audio_setChannelPan(channel,pan);
}

function wa_mandreel_audio_setChannelPitch(sp)
{
 var channel = heap32[sp>>2];sp+=4;
 var pitch = heapFloat[sp>>2];sp+=4;
 wa_imp_mandreel_audio_setChannelPitch(channel,pitch);
}

function wa_mandreel_audio_useMusicFunctions(sp)
{
 r_g0 = webAudioUseMusicFunctions ? 1 : 0;
}

function wa_mandreel_audio_playMusic(sp)
{
 var ptr_fileName = heap32[sp>>2];sp+=4;
 var fileName = get_string_from_ptr(ptr_fileName).toLowerCase();
 wa_imp_mandreel_audio_playMusic(fileName);
}

function wa_mandreel_audio_stopMusic(sp)
{
 wa_imp_mandreel_audio_stopMusic();
}

function wa_mandreel_audio_setMusicVol(sp)
{
 var vol = heapFloat[sp>>2];sp+=4;
 wa_imp_mandreel_audio_setMusicVol(vol);
}

function wa_MainAudioDriver()
{
 mandreel_audio_init = wa_mandreel_audio_init;
 mandreel_audio_end = wa_mandreel_audio_end;
 mandreel_audio_update = wa_mandreel_audio_update;
 mandreel_audio_createBuffer = wa_mandreel_audio_createBuffer;
 mandreel_audio_playChannel = wa_mandreel_audio_playChannel;
 mandreel_audio_stopChannel = wa_mandreel_audio_stopChannel;
 mandreel_audio_setChannelVolume = wa_mandreel_audio_setChannelVolume;
 mandreel_audio_setChannelPan = wa_mandreel_audio_setChannelPan;
 mandreel_audio_setChannelPitch = wa_mandreel_audio_setChannelPitch;
 mandreel_audio_useMusicFunctions = wa_mandreel_audio_useMusicFunctions;
 mandreel_audio_playMusic = wa_mandreel_audio_playMusic;
 mandreel_audio_stopMusic = wa_mandreel_audio_stopMusic;
 mandreel_audio_checkBuffersPending = wa_mandreel_audio_checkBuffersPending;
 mandreel_audio_setMusicVol = wa_mandreel_audio_setMusicVol;

 setTimeout("mandreel_webAudio_PreloadAssets()", 10);
}


var webAudioBuffers = new Array();
var webAudioChannels = new Array(32);
var webAudioGain = new Array(32);
var webAudioContext = 0;


function wa_initWebAudio()
{
 if ( preCreatedWebAudioContext != null )
 {
  webAudioContext = preCreatedWebAudioContext;
 }
 else
 {
  try { webAudioContext = new webkitAudioContext(); } catch(err) { webAudioContext = 0; }
 }
}

function wa_imp_callfunction(params)
{
 if ( params[0] == "#MandreelAudio" )
 {
  if ( params[1] == "playChannel" )
   wa_imp_mandreel_audio_playChannel(params[2],params[3],params[4],params[5],params[6],params[7]);
  else if ( params[1] == "stopChannel" )
   wa_imp_mandreel_audio_stopChannel(params[2]);
  else if ( params[1] == "setChannelVol" )
   wa_imp_mandreel_audio_setChannelVol(params[2],params[3]);
  else if ( params[1] == "setChannelPan" )
   wa_imp_mandreel_audio_setChannelPan(params[2],params[3]);
  else if ( params[1] == "playMusic" )
   wa_imp_mandreel_audio_playMusic(params[2]);
  else if ( params[1] == "stopMusic" )
   wa_imp_mandreel_audio_stopMusic(params[2]);
  else if ( params[1] == "setMusicVol" )
   wa_imp_mandreel_audio_setMusicVol(params[2]);

  return true;
 }
 return false;
}

function wa_getFileNameNoExt(fileName)
{
 var fileNameNoExt = fileName.toLowerCase();
 var indexDot = fileNameNoExt.lastIndexOf('.');
 if ( indexDot != -1 )
  fileNameNoExt = fileNameNoExt.substr(0,indexDot);
 fileNameNoExt = fileNameNoExt.replace(/\\/g,"/");
 if ( fileNameNoExt.length > 0 )
 {
  if ( fileNameNoExt.charAt(0) == "/" )
  {
   if (fileNameNoExt.length > 1 )
    fileNameNoExt = fileNameNoExt.substr(1,fileNameNoExt.length-1);
   else
    fileNameNoExt = "";
  }
 }
 return fileNameNoExt;
}

var wa_mandreel_cache_audio_files = false;
var wa_mandreel_cache_audio_files_path = '';

function mandreel_webAudio_reloadfile(fileName,callback)
{
 var fileNameNoExt = wa_getFileNameNoExt(fileName);
 var url = wa_mandreel_cache_audio_files_path+fileNameNoExt+".ogg";
 dump("webAudio: loading buffer ("+fileName+") url("+url+")");
 var request = new XMLHttpRequest();
 request.open("GET", url, true);
 request.responseType = "arraybuffer";
 request.onreadystatechange = function()
 {
  if (request.readyState == 4)
  {

   if (request.status == 404) callback(null);

   callback(request.response);

  }
 }
 request.send();
}

Mandreel_window.BlobBuilder = Mandreel_window.MozBlobBuilder || Mandreel_window.WebKitBlobBuilder || Mandreel_window.BlobBuilder;

function mandreel_webaudio_saveFile(name, my_arrayBuffer)
{
 dump('mandreel_webaudio_saveFile ' + name);
 g_mandreel_fs.root.getFile(name, {create: true}, function(fileEntry) {

    // Create a FileWriter object for our FileEntry (log.txt).
    fileEntry.createWriter(function(fileWriter) {

      fileWriter.onwriteend = function(e) {
        dump('Write completed.');
      };

      fileWriter.onerror = function(e) {
        dump('Write failed: ' + e.toString());
      };

   var bb = new Mandreel_window.BlobBuilder(); // Note: window.WebKitBlobBuilder in Chrome 12.
      bb.append(my_arrayBuffer);
      fileWriter.write(bb.getBlob('text/plain'));



    }, function(e) { dump('error 1 mandreel_webaudio_saveFile ' + name);MandreelFsErrorHandler(e) });

  }, function(e) { dump('error 2 mandreel_webaudio_saveFile ' + name);MandreelFsErrorHandler(e) });
}

function mandreel_webaudio_loadFile(name, callback, callback2)
{
 g_mandreel_fs.root.getFile(name, {}, function(fileEntry) {

 fileEntry.file(function(file) {

  var reader = new FileReader();


       reader.onloadend = function(e) {

    dump('mandreel_fs_loadFile ' + name);
    if (this.result.byteLength)
  callback(this.result);
    else
    callback2(this.result);

       };


     reader.readAsArrayBuffer(file);



 }, function(e) { dump('error 1 webaudio_loadFile ' + name);MandreelFsErrorHandler(e) } );

  }, function(e) { dump('error 2 webaudio_loadFile ' + name);MandreelFsErrorHandler(e) } );
}


function mandreel_webAudio_cacheFile(fileName, callback)
{
 if (!g_mandreel_fs)
 {
  mandreel_webAudio_reloadfile(fileName, callback);

  return;
 }
 fileName = fileName.toLowerCase();

 fileName = fileName.replace(/\\/g,"/");

 if (fileName[0] == '/')
  fileName = fileName.substring(1);

 dump('chanka name ' + fileName);

 g_mandreel_fs.root.getFile(fileName, {}, function(fileEntry) {

 fileEntry.getMetadata(function(metaData){
 var my_seconds = metaData.modificationTime.getTime()/1000;

 if (g_mandreel_timestamp_fs>my_seconds)
 {
  dump('mandreel_webAudio_cacheFile1 ');
  fileEntry.remove(function() {
    mandreel_webAudio_reloadfile(fileName, function(response) { callback(response); if (response) mandreel_webaudio_saveFile(fileName, response); } );
   }, function(e) { dump('error 1 mandreel_webAudio_cacheFile ' + fileName);MandreelFsErrorHandler(e); mandreel_webAudio_reloadfile(fileName, function(response) { callback(response); if (response) mandreel_webaudio_saveFile(fileName, response); } );});

 }
 else
 {
  //alert('mandreel_fscachefile2');
  dump('mandreel_webAudio_cacheFile2');
  mandreel_webaudio_loadFile(fileName, function(response) { callback(response);  } ,
  function() {
    mandreel_webAudio_reloadfile(fileName, function(response) { callback(response); if (response) mandreel_webaudio_saveFile(fileName, response); } );
   }
  );



 }


  }, function(e) { dump('error 2 mandreel_webAudio_cacheFile ' + fileName);MandreelFsErrorHandler(e) });


  }, function(error) {dump('mandreel_webAudio_cacheFile3'); mandreel_webAudio_reloadfile(fileName, function(response) { callback(response); if (response) mandreel_webaudio_saveFile(fileName, response); });});
}

function mandreel_webAudio_queueLoadBuffer(fileName, callback)
{
 //dump("mandreel_webAudio_queueLoadBuffer "+fileName);
 if ( webAudioContext )
 {
  var fileNameNoExt = wa_getFileNameNoExt(fileName);
  var buffer = webAudioBuffers[fileNameNoExt];
  if ( buffer == null && buffer != "invalid" )
  {
   if ( fileNameNoExt != "" )
   {
    if (wa_mandreel_cache_audio_files == true)
    {
     webAudioBuffers[fileNameNoExt] = "invalid";

     mandreel_webAudio_cacheFile(fileName, function(response) {

      if (callback != null)
       callback();

      if ( response != null )
       webAudioBuffers[fileNameNoExt] = webAudioContext.createBuffer(response, false);
      else
       webAudioBuffers[fileNameNoExt] = "invalid";
     } );
     return;
    }

    var url = g_mandreel_working_folder+fileNameNoExt+".ogg";
    dump("webAudio: loading buffer ("+fileName+") url("+url+")");
    webAudioBuffers[fileNameNoExt] = "invalid";
    var request = new XMLHttpRequest();
    request.open("GET", url, true);
    request.responseType = "arraybuffer";
    request.onreadystatechange = function()
    {
     if (request.readyState == 4)
     {
      if (callback != null)
       callback();

      if (request.status == 404) return;
      //dump("webAudio: loaded buffer "+request.status);
      if ( request.response != null )
       webAudioBuffers[fileNameNoExt] = webAudioContext.createBuffer(request.response, false);
      else
       webAudioBuffers[fileNameNoExt] = "invalid";
     }
    }
    request.send();
   }
   else
    webAudioBuffers[fileNameNoExt] = "invalid";
  }
 }
}

var webAudioPreloadAudioFiles = new Array();
var webAudioPreloadBytes = null;
var webAudioPreloadCurrentFile = 0;
var webAudioPreloadAsync = false;

function webAudioParsePreloadFile(response)
{
 var pos = 4;
 var bytes = new Uint8Array(response);
 var i = 0;
 if ( webAudioPreloadAsync )
  webAudioPreloadBytes = bytes;
 while ( pos < bytes.byteLength )
 {
  // filename
  var fileName = "";
  while ( bytes[pos] != 0 )
  {
   fileName += String.fromCharCode(bytes[pos]);
   pos++;
  }
  pos++;
  // filesize
  var filesize = bytes[pos] | (bytes[pos+1]<<8) | (bytes[pos+2]<<16) | (bytes[pos+3]<<24);
  pos += 4;

  // contents
  var fileNameNoExt = wa_getFileNameNoExt(fileName);
  if ( webAudioPreloadAsync )
  {
   var audioFile =
   {
    fileName : fileNameNoExt,
    fileSize : filesize,
    position : pos
   };
   webAudioPreloadAudioFiles[i] = audioFile;
  }
  else
  {
   var bufferdata = new Uint8Array(filesize);
   bufferdata.set(bytes.subarray(pos,pos+filesize));
   webAudioBuffers[fileNameNoExt] = webAudioContext.createBuffer(bufferdata.buffer, false);
   dump("preload audio file ("+fileName+")");
  }

  pos += filesize;
  i++;
 }
 if ( webAudioPreloadAsync )
 {
  dump("started preloading audio files async");
  setTimeout("mandreel_webAudio_preloadNextAudioFile()",10);
 }
}

function mandreel_webAudio_preloadNextAudioFile()
{
 if ( webAudioPreloadAudioFiles.length > webAudioPreloadCurrentFile )
 {
  var audioFile = webAudioPreloadAudioFiles[webAudioPreloadCurrentFile];
  if ( audioFile.fileName == null )
  {
   webAudioPreloadCurrentFile++;
   setTimeout("mandreel_webAudio_preloadNextAudioFile()",10);
  }
  else
  {
   var bufferdata = new Uint8Array(audioFile.fileSize);
   bufferdata.set(webAudioPreloadBytes.subarray(audioFile.position,audioFile.position+audioFile.fileSize));
   dump("async preload audio file ("+audioFile.fileName+")");
   webAudioContext.decodeAudioData(bufferdata.buffer,mandreel_webAudio_preloadNextAudioFileOK,mandreel_webAudio_preloadNextAudioFileError);
  }
 }
 else
 {
  webAudioPreloadAudioFiles = null;
  webAudioPreloadBytes = null;
  dump("finished preloading audio files async");
 }
}

function mandreel_webAudio_preloadNextAudioFileOK(audioBuffer)
{
 var audioFile = webAudioPreloadAudioFiles[webAudioPreloadCurrentFile];
 webAudioPreloadCurrentFile++;
 if ( audioFile.fileName != null )
 {
  webAudioBuffers[audioFile.fileName] = audioBuffer;
  setTimeout("mandreel_webAudio_preloadNextAudioFile()",10);
 }
}

function mandreel_webAudio_preloadNextAudioFileError()
{
 var audioFile = webAudioPreloadAudioFiles[webAudioPreloadCurrentFile];
 webAudioPreloadCurrentFile++;
 if ( audioFile.fileName != null )
  dump("FAILED async preload audio file ("+audioFile.fileName+")");
 setTimeout("mandreel_webAudio_preloadNextAudioFile()",10);
}

function mandreel_webAudio_queueLoadPackedBuffers(fileName, callback)
{
 if ( webAudioContext )
 {
  // TODO
  /*if (wa_mandreel_cache_audio_files == true)
{
webAudioBuffers[fileNameNoExt] = "invalid";

mandreel_webAudio_cacheFile(fileName, function(response) {

if (callback != null)
callback();

if ( response != null )
webAudioBuffers[fileNameNoExt] = webAudioContext.createBuffer(response, true);
else
webAudioBuffers[fileNameNoExt] = "invalid";
} );
return;
}*/

  mandreel_fs_load_binary(fileName, function mandreel_webAudio_queueLoadPackedBuffers_cb(data){

  if (data)
  {
   if (callback != null)
    callback();
   webAudioParsePreloadFile(data);
  }
  else
  {
   var url = g_mandreel_working_folder+fileName;
   dump("webAudio: loading preload buffers ("+fileName+") url("+url+")");
   var request = new XMLHttpRequest();
   request.open("GET", url, true);
   request.responseType = "arraybuffer";
   var last_loaded_size = 0;
   request.onreadystatechange = function()
   {
    if (request.readyState == 4)
    {
     if (callback != null)
      callback();

     if (request.status == 404)
      return;
     if ( request.response != null )
     {
      mandreel_fs_saveFile(fileName, request.response);
      webAudioParsePreloadFile(request.response);
     }
    }
   }
   request.onprogress = function(e)
   {
    var delta_size = e.loaded - last_loaded_size;
    last_loaded_size = e.loaded;

    imandreel_update_load(delta_size,0);

    var percentage = ((100*e.loaded)/mandreel_total_pogfile_size)|0;

    if (percentage>100)
     percentage = 100;

    if ( mandreelAppStartStateFunc )
     mandreelAppStartStateFunc("loadingAudioUpdate",percentage);
   }
   request.send();
  }
  });
 }
}



var wa_mandreel_audio_buffers_num = 0;
var wa_mandreel_audio_buffers_loaded = 0;

function wa_imp_mandreel_audio_checkBuffersPending()
{
 return wa_mandreel_audio_buffers_num - wa_mandreel_audio_buffers_loaded;
}

function wa_imp_mandreel_audio_createBuffer(fileName)
{
 if ( webAudioContext )
 {
  var fileNameNoExt = wa_getFileNameNoExt(fileName);
  var buffer = webAudioBuffers[fileNameNoExt];
  if ( buffer == null && buffer != "invalid" )
  {
   wa_mandreel_audio_buffers_num++;
   mandreel_webAudio_queueLoadBuffer(fileName, function () {wa_mandreel_audio_buffers_loaded++;});
  }
 }
}

function wa_imp_mandreel_audio_playChannel(fileName,channel,vol,loop,pitch)
{
 if ( webAudioContext )
 {
  var fileNameNoExt = wa_getFileNameNoExt(fileName);
  var buffer = webAudioBuffers[fileNameNoExt];
  if ( buffer == null || buffer == "invalid" )
  {
   if ( webAudioPreloadAudioFiles != null )
   {
    var i = 0;
    while ( i < webAudioPreloadAudioFiles.length )
    {
     var audioFile = webAudioPreloadAudioFiles[i];
     if ( audioFile.fileName == fileNameNoExt )
     {
      var bufferdata = new Uint8Array(audioFile.fileSize);
      bufferdata.set(webAudioPreloadBytes.subarray(audioFile.position,audioFile.position+audioFile.fileSize));
      webAudioBuffers[audioFile.fileName] = webAudioContext.createBuffer(bufferdata.buffer, false);
      dump("**** preload audio file ("+audioFile.fileName+"), forced by playChannel");
      audioFile.fileName = null;
      i = webAudioPreloadAudioFiles.length;
     }
     else
     {
      ++i;
     }
    }
   }
  }
  if ( buffer == null || buffer == "invalid" )
  {
   mandreel_webAudio_queueLoadBuffer(fileName);
   buffer = webAudioBuffers[fileNameNoExt];
  }
  if ( buffer != null && buffer != "invalid" )
  {
   var chn = webAudioContext.createBufferSource();
   var gain = webAudioContext.createGainNode();
   if ( chn && gain )
   {
    webAudioChannels[channel] = chn;
    webAudioGain[channel] = gain;
    chn.buffer = buffer;
    chn.connect(gain);
    gain.connect(webAudioContext.destination);
    var bLoop = loop != 0;
    chn.loop = bLoop;
    gain.gain.value = vol;
    chn.playbackRate.value = pitch;
    chn.noteOn(0);
    //dump("webAudio: PlayChannel "+channel+" "+fileName+" "+vol+" "+bLoop+" "+pitch);
   }
  }
 }
}

function wa_imp_mandreel_audio_stopChannel(channel)
{
 if ( webAudioContext )
 {
  var chn = webAudioChannels[channel];
  if ( chn != null )
  {
   //dump("webAudio: StopChannel "+channel);
   chn.noteOff(0);
   webAudioChannels[channel] = null;
   webAudioGain[channel] = null;
  }
 }
}

function wa_imp_mandreel_audio_setChannelVolume(channel,vol)
{
 if ( webAudioContext )
 {
  var gain = webAudioGain[channel];
  if ( gain != null )
   gain.gain.value = vol;
 }
}

function wa_imp_mandreel_audio_setChannelPan(channel,pan)
{
 if ( webAudioContext )
 {
 }
}

function wa_imp_mandreel_audio_setChannelPitch(channel,pitch)
{
 if ( webAudioContext )
 {
  var chn = webAudioChannels[channel];
  if ( chn != null )
  {
   chn.playbackRate.value = pitch;
  }
 }
}

var mwebAudioPreloadState = "start";
//var mwebAudioPreloadRequest = 0;
var mwebAudioPreloadAssets = 0;
var mwebAudioCurrentPreloadAsset = 0;
var mwebAudioAsyncFiles = '';
var mwebListAudioAsyncFiles ='';
var mwebListAudioAsyncFilesPos = 0;
var mwebTotalPreloadingFiles = 0;
var mwebCurrentPreloadingFiles = 0;
function mwebCallbackAsync()
{
 mwebListAudioAsyncFilesPos++;
 if ( mwebListAudioAsyncFilesPos >= mwebListAudioAsyncFiles.length )
 {
  mwebListAudioAsyncFiles = null;
  mwebAudioAsyncFiles = null;
  return;
 }

 setTimeout("mandreel_webAudio_queueLoadBuffer(mwebListAudioAsyncFiles[mwebListAudioAsyncFilesPos], mwebCallbackAsync);",10);
}

function mwebCallbackAsyncPreload()
{
 mwebCurrentPreloadingFiles++;
}

function mandreel_webAudio_PreloadAssets()
{
 /*if ( mwebAudioPreloadState == "start" )
{
//dump("webaudio start");
mwebAudioPreloadRequest = new XMLHttpRequest();
var url = g_mandreel_working_folder+"mandreel.fat.dat";
mwebAudioPreloadRequest.open("GET", url, true);
mwebAudioPreloadRequest.onreadystatechange = function()
{
if (mwebAudioPreloadRequest.readyState != 4) return;
if ( mwebAudioPreloadRequest.status != 404 && mwebAudioPreloadRequest.response != null )
mwebAudioPreloadState = "parseFat";
else
{
mwebAudioPreloadState = "done";
dump("error pre-loading audio assets, status("+mwebAudioPreloadRequest.status+")");
}
}
mwebAudioPreloadState = "loadingFat";
mwebAudioPreloadRequest.send();
}
else if ( mwebAudioPreloadState == "parseFat" )*/
 if ( mwebAudioPreloadState == "start" )
 {
  //mwebAudioPreloadAssets = mwebAudioPreloadRequest.response.split('\n');
  //mwebAudioPreloadRequest = 0;
  mwebAudioPreloadAssets = mandreelFatData.split('\n');
  mwebAudioCurrentPreloadAsset = 0;
  mwebAudioPreloadState = "preloading";
 }
 else if ( mwebAudioPreloadState == "preloading" )
 {
  //dump("webaudio preloading");
  var queued = false;
  while ( !queued && mwebAudioPreloadState != "done" )
  {
   if ( mwebAudioCurrentPreloadAsset < mwebAudioPreloadAssets.length )
   {
    var params = mwebAudioPreloadAssets[mwebAudioCurrentPreloadAsset].split(',');
    if ( params[0] == "audiofile" && params[1])
    {
     var sync_load = true;
     if (params[2] && (params[2]&1) == 0)
      sync_load = false;

     if (sync_load)
     {
      mandreel_webAudio_queueLoadBuffer(params[1],mwebCallbackAsyncPreload);
      mwebTotalPreloadingFiles++;
      queued = true;
     }

    }
    else if ( params[0] == "audiopreloadfile" )
    {
     mandreel_webAudio_queueLoadPackedBuffers(params[1],mwebCallbackAsyncPreload);
     var size_pog_file = parseInt(params[2], 10);
     mandreel_total_pogfile_size = size_pog_file;
     mwebTotalPreloadingFiles++;
     queued = true;
    }
    else if ( params[0] == "audiopreloadasync" )
    {
     webAudioPreloadAsync = true;
    }
    mwebAudioCurrentPreloadAsset++;
   }
   else
    queued = true;

   if ( mwebAudioCurrentPreloadAsset >= mwebAudioPreloadAssets.length )
   {
    if (mwebCurrentPreloadingFiles == mwebTotalPreloadingFiles)
    {
     mwebAudioPreloadState = "done";
     mwebAudioPreloadAssets = 0;
    }
   }
  }
 }

 if ( mwebAudioPreloadState == "done" )
 {
  if ( mandreelAppPlatform == "nacl" )
   setTimeout("MandreelAudioStartedNacl()", 10);
  else
   setTimeout("MandreelAudioStarted()", 10);
 }
 else
  setTimeout("mandreel_webAudio_PreloadAssets()", 10);
}

var wa_mandreelMusicElement = null;
var wa_mandreelMusicElementFilename = "";
var wa_mandreelMusicElementVolume = 1.0;
function wa_imp_mandreel_audio_playMusic(fileName)
{
 var fileNameNoExt = wa_getFileNameNoExt(fileName);
 var fileNameFull = g_mandreel_working_folder + fileNameNoExt + ".ogg";

 if ( wa_mandreelMusicElementFilename != fileNameFull )
 {
  wa_imp_mandreel_audio_stopMusic(0);
  var audio = document.createElement("audio");
  var type = fileNameFull.slice(fileNameFull.lastIndexOf(".")+1);
  switch(type){
   case "mp3" : type = "mpeg"; break;
   case "ogg" : type = "ogg"; break;
   case "wav" : type = "wav"; break;
   default : throw("'" + fileNameFull + "' is not a recognized audio file");
  }

  // set correct id for lookup, loading method and data types
  audio.setAttribute("type", "audio/" + type);
  var is_chrome = navigator.userAgent.toLowerCase().indexOf('chrome') > -1;
  if ( is_chrome )
   audio.setAttribute("loop", "loop");
  else
   audio.addEventListener('ended', function(){this.currentTime = 0;}, false);
  audio.volume = wa_mandreelMusicElementVolume;
  audio.setAttribute("autoplay", "true");
  audio.setAttribute("src", fileNameFull);


  // include into list and document
  document.body.appendChild(audio);
  wa_mandreelMusicElement = audio;
  wa_mandreelMusicElementFilename = fileNameFull;
 }
}

function wa_imp_mandreel_audio_stopMusic()
{
 if ( wa_mandreelMusicElement != null )
 {
  document.body.removeChild(wa_mandreelMusicElement);
  wa_mandreelMusicElement = null;
  wa_mandreelMusicElementFilename = "";
 }
}

function wa_imp_mandreel_audio_setMusicVol(vol)
{
 wa_mandreelMusicElementVolume = vol;
 if ( wa_mandreelMusicElement != null )
 {
  wa_mandreelMusicElement.volume = wa_mandreelMusicElementVolume;
 }
}

var mandreel_audio_stream_func_ptr = 0;
function mandreel_audio_stream_process(e)
{
 var l = e.outputBuffer.getChannelData(0);
 var l2 = e.outputBuffer.getChannelData(1);
 var n = e.outputBuffer.length;

 var offset2 = 0;
 var inc = 44.1 / 48.0;
 while ( n > 0 )
 {
  var n2 = ((n*inc)|0)/4;
  if ( n2 > 1024 )
   n2 = 1024;

  var sp = g_stack_pointer+100*1024;
  var ptr = g_stack_pointer+200*1024;
  var _sp = sp>>2;
  heap32[_sp]=ptr;
  heap32[_sp+1]=n2*4;
  __FUNCTION_TABLE__[(mandreel_audio_stream_func_ptr)>>2](sp);

  var offset = ptr>>2;
  var size = n2*4;
  /*for (var i=0;i<size;++i)
{
l[i+offset2] = heapFloat[offset+(i*2)];
l2[i+offset2] = heapFloat[offset+(i*2)+1];
}*/
  var i = 0;
  var j = 0;
  while ( i < size )
  {
   l[j+offset2] = heapFloat[offset+((i|0)*2)];
   l2[j+offset2] = heapFloat[offset+((i|0)*2)+1];
   i += inc;
   j++;
  }

  //offset2 += n2*4;
  //n -= n2*4;
  offset2 += j;
  n -= j;
 }
}

function mandreel_Audio_requestSoundData(soundData)
{
 var n = soundData.length/2;
 var offset2 = 0;
 while ( n > 0 )
 {
  var n2 = n;
  if ( n2 > 1024 )
   n2 = 1024;
  var sp = g_stack_pointer+100*1024;
  var ptr = g_stack_pointer+200*1024;
  var _sp = sp>>2;
  heap32[_sp]=ptr;
  heap32[_sp+1]=n2;
  __FUNCTION_TABLE__[(mandreel_audio_stream_func_ptr)>>2](sp);

  var offset = ptr>>2;
  var size = n2*2;
  var buf = heapFloat.subarray(offset,offset+size);
  soundData.set(buf,offset2);
  /*for (var i=0; i<size; i++)
  soundData[i+offset2] = heapFloat[offset+i];*/
  offset2 += n2*2;
  n -= n2;
 }
 }

var __Mandreel_Audio_CreateStream_created = false;
function Mandreel_Audio_CreateStream(sp)
{
 if ( !__Mandreel_Audio_CreateStream_created )
 {
  if (webAudioContext)
  {
   mandreel_audio_stream_func_ptr = heap32[sp>>2];
   var source =  webAudioContext.createJavaScriptNode(1024*4, 0, 2);
   source.connect(webAudioContext.destination);
   source.onaudioprocess = mandreel_audio_stream_process;
  }
  else
  {
   mandreel_audio_stream_func_ptr = heap32[sp>>2];
   AudioDataDestination(44100,mandreel_Audio_requestSoundData);
  }
  __Mandreel_Audio_CreateStream_created = true;
 }
}
function mandreel_webAudio_dummyStream()
{
 var sp = g_stack_pointer+100*1024;
 var ptr = g_stack_pointer+200*1024;
 var _sp = sp>>2;
 heap32[_sp]=ptr;
 heap32[_sp+1]=4096;
 __FUNCTION_TABLE__[(mandreel_audio_stream_func_ptr)>>2](sp);
 setTimeout("mandreel_webAudio_dummyStream()",10);
}

function AudioDataDestination(sampleRate, readFn)
{
 // Initialize the audio output.
 var audio = new Audio();
 if ( audio.mozSetup == null )
 {
  setTimeout("mandreel_webAudio_dummyStream()",10);
  return;
 }
 audio.mozSetup(2, sampleRate);

 var currentWritePosition = 0;
 var prebufferSize = sampleRate / 2; // buffer 500ms
 var tail = null, tailPosition;

 // The function called with regular interval to populate
 // the audio output buffer.
 setInterval(function() {
   var written;
   // Check if some data was not written in previous attempts.
   if(tail) {
  written = audio.mozWriteAudio(tail.subarray(tailPosition));
  currentWritePosition += written;
  tailPosition += written;
  if(tailPosition < tail.length) {
    // Not all the data was written, saving the tail...
    return; // ... and exit the function.
  }
  tail = null;
   }

   // Check if we need add some data to the audio output.
   var currentPosition = audio.mozCurrentSampleOffset();
   var available = currentPosition + prebufferSize - currentWritePosition;
   if(available > 0) {
  // Request some sound data from the callback function.
  var soundData = new Float32Array(available);
  readFn(soundData);

  // Writting the data.
  written = audio.mozWriteAudio(soundData);
  if(written < soundData.length) {
    // Not all the data was written, saving the tail.
    tail = soundData;
    tailPosition = written;
  }
  currentWritePosition += written;
   }
 }, 100);
}
var mandreel_flashaudio_server = "";
var mandreel_flashaudio_lite = false;
var mandreel_flashaudio_musicaudiotag = true;

function as3Error(str)
{
 var params = str.split(' ');
 if ( params[0] == "createdBuffer" )
  mandreel_audio_flash_lastBufferCreatedSwf = parseInt(params[1]);
 dump("as3Log: "+str);
}

function mandreel_audio_getFlashMovieObject(movieName)
{
 if (Mandreel_window.document[movieName])
 {
  return Mandreel_window.document[movieName];
 }
 if (navigator.appName.indexOf("Microsoft Internet")==-1)
 {
  if (document.embeds && document.embeds[movieName])
   return document.embeds[movieName];
 }
 else
 {
  return document.getElementById(movieName);
 }
}

function mandreel_sendmsg_flash(msg)
{
 if ( mandreel_flashaudio_server != "" )
 {
  var iframeWin = document.getElementById("ninja-iframe").contentWindow;
  iframeWin.postMessage(msg,mandreel_flashaudio_server);
 }
 else
 {
  var flashMovie=mandreel_audio_getFlashMovieObject("FlashDivAudio");
  if ( flashMovie != null )
   flashMovie.receiveMessage(msg);
  else
   dump("error: flashMovie not found");
 }
}

function fl_mandreel_audio_init(sp)
{
 mandreel_sendmsg_flash("init "+g_mandreel_working_folder);
}

function fl_mandreel_audio_end(sp)
{
}

function fl_mandreel_audio_update(sp)
{
}

function mandreel_flashaudiolite_createBuffer(fileName)
{
 mandreel_audio_flash_lastBufferCreated++;
 mandreel_sendmsg_flash("createBuffer "+wa_getFileNameNoExt(fileName)+" "+mandreel_audio_flash_lastBufferCreated);
}

var mandreel_audio_flash_lastBufferCreated = 0;
function fl_mandreel_audio_createBuffer(sp)
{
 var ptr_fileName = heap32[sp>>2];sp+=4;
 var fileName = get_string_from_ptr(ptr_fileName).toLowerCase();
 mandreel_flashaudiolite_createBuffer(fileName);
}

function fl_internal_mandreel_audio_checkBuffersPending()
{
 return mandreel_flashaudio_lite && (mandreel_audio_flash_lastBufferCreatedSwf != mandreel_audio_flash_lastBufferCreated);
}

var mandreel_audio_flash_lastBufferCreatedSwf = 0;
function fl_mandreel_audio_checkBuffersPending(sp)
{
 r_g0 = 0;
 if ( fl_internal_mandreel_audio_checkBuffersPending() )
  r_g0 = 1;
 dump("fl_mandreel_audio_checkBuffersPending ("+r_g0+") ("+mandreel_audio_flash_lastBufferCreatedSwf+") ("+mandreel_audio_flash_lastBufferCreated+")");
}


function fl_mandreel_audio_playChannel(sp)
{
 var ptr_fileName = heap32[sp>>2];sp+=4;
 var channel = heap32[sp>>2];sp+=4;
 var vol = heapFloat[sp>>2];sp+=4;
 var loop = heap32[sp>>2];sp+=4;
 var pitch = heapFloat[sp>>2];sp+=4;
 var fileName = get_string_from_ptr(ptr_fileName).toLowerCase();
 mandreel_sendmsg_flash("playChannel "+fileName+" "+channel+" "+loop+" "+vol+" "+pitch);
 r_g0 = 0;
}

function fl_mandreel_audio_stopChannel(sp)
{
 var ptr_fileName = heap32[sp>>2];sp+=4;
 var channel = heap32[sp>>2];sp+=4;
 var index = heapFloat[sp>>2];sp+=4;

 mandreel_sendmsg_flash("stopChannel "+channel);
}

function fl_mandreel_audio_setChannelVolume(sp)
{
 var channel = heap32[sp>>2];sp+=4;
 var vol = heapFloat[sp>>2];sp+=4;

 mandreel_sendmsg_flash("setChannelVolume "+channel+" "+vol);
}

function fl_mandreel_audio_setChannelPan(sp)
{
 var channel = heap32[sp>>2];sp+=4;
 var pan = heapFloat[sp>>2];sp+=4;
 mandreel_sendmsg_flash("setChannelPan "+channel+" "+pan);
}

function fl_mandreel_audio_setChannelPitch(sp)
{
 var channel = heap32[sp>>2];sp+=4;
 var pitch = heapFloat[sp>>2];sp+=4;
 mandreel_sendmsg_flash("setChannelPitch "+channel+" "+pitch);
}


function mandreel_audio_load_flash()
{
 var failed = "";


 try
 {
  var mandreelAudioSwf = g_mandreel_working_folder+"mandreelaudio.swf";
  if ( mandreel_flashaudio_lite )
   mandreelAudioSwf = g_mandreel_working_folder+"mandreelaudiolite.swf";
  var swf = swfobject.createSWF({ data:mandreelAudioSwf, width:"0", height:"0", allowScriptAccess:"always" }, { menu:"false" }, "FlashDivAudio");
  if ( !swf )
   failed  = "swfobject.js not avaiable or Unable to open "+mandreelAudioSwf;
 }
 catch(err)
 {
  failed  = err;
 }

 if (failed == "" && !swfobject.hasFlashPlayerVersion("9.0.0"))
  failed = "flash player not found";

 if ( failed != "" )
 {
  dump("Failed to create flash audio driver ("+failed+"). Null driver will be used.");
  MandreelAudioDriver = "null";
  null_MainAudioDriver();
 }
}

function fl_MainAudioDriver(audioServer, audioUrl)
{
 mandreel_flashaudio_server = audioServer;
 if ( mandreel_flashaudio_lite )
  mandreel_flashaudio_server = "";
 if ( mandreel_flashaudio_server != "" )
 {
  Mandreel_window.addEventListener("message", receiveMessage2, false);
  var el = document.createElement("iframe");
  el.setAttribute('id', 'ninja-iframe');
  el.setAttribute('width', '0');
  el.setAttribute('height', '0');
  el.setAttribute('frameborder', '0');
  document.body.appendChild(el);
  el.onerror = function(message) { alert(message); };
  el.setAttribute('src', audioServer+audioUrl+"/MandreelAudio.html");
  setTimeout("CheckNinjaFrameReady()", 1000);
 }
 else
 {
  setTimeout("mandreel_audio_load_flash()", 10);
 }
}
var ninjaLoaded = false;
function CheckNinjaFrameReady()
{
 try
 {
  mandreel_sendmsg_flash("loadFlash");
 }
 catch(err)
 {
 }
 if ( !ninjaLoaded )
  setTimeout("CheckNinjaFrameReady()", 1000);
}

function fl_map_mandreel_audio_functions()
{
 mandreel_audio_init = fl_mandreel_audio_init;
 mandreel_audio_end = fl_mandreel_audio_end;
 mandreel_audio_update = fl_mandreel_audio_update;
 mandreel_audio_createBuffer = fl_mandreel_audio_createBuffer;
 mandreel_audio_playChannel = fl_mandreel_audio_playChannel;
 mandreel_audio_stopChannel = fl_mandreel_audio_stopChannel;
 mandreel_audio_setChannelVolume = fl_mandreel_audio_setChannelVolume;
 mandreel_audio_setChannelPan = fl_mandreel_audio_setChannelPan;
 mandreel_audio_setChannelPitch = fl_mandreel_audio_setChannelPitch;
 if ( mandreel_flashaudio_musicaudiotag )
 {
  mandreel_audio_useMusicFunctions = wa_mandreel_audio_useMusicFunctions;
  mandreel_audio_playMusic = wa_mandreel_audio_playMusic;
  mandreel_audio_stopMusic = wa_mandreel_audio_stopMusic;
  mandreel_audio_setMusicVol = wa_mandreel_audio_setMusicVol;
 }
 else
  dump("WARNING: flash music functions not supported");
 mandreel_audio_checkBuffersPending = fl_mandreel_audio_checkBuffersPending;
}

function receiveMessage2(event)
{
 ninjaLoaded = true;
 fl_map_mandreel_audio_functions();
 setTimeout("MandreelAudioStarted()", 10);
}

function mandreel_flashlite_checkPreloadFinished()
{
 if ( !fl_internal_mandreel_audio_checkBuffersPending() )
  MandreelAudioStarted();
 else
  setTimeout("mandreel_flashlite_checkPreloadFinished()", 10);
}

function mandreel_flashlite_startPreload()
{
 mandreel_sendmsg_flash("init "+g_mandreel_working_folder);
 // preload sounds
 var FatLines = mandreelFatData.split('\n');
 for ( var i=0;i<FatLines.length;++i )
 {
  var params = FatLines[i].replace('\r','').split(',');
  if ( params[0] == "audiofile" && params[1] )
  {
   var sync_load = true;
   if (params[2] && (params[2]&1) == 0)
    sync_load = false;

   if (sync_load)
   {

    mandreel_flashaudiolite_createBuffer(params[1]);
   }
  }
 }
 setTimeout("mandreel_flashlite_checkPreloadFinished()", 10);
}

function flashReady()
{
 fl_map_mandreel_audio_functions();
 setTimeout("mandreel_flashlite_startPreload()",10);
}

function null_mandreel_audio(sp)
{
 r_g0 = 0;
}

function null_MainAudioDriver()
{
 mandreel_audio_init = null_mandreel_audio;
 mandreel_audio_end = null_mandreel_audio;
 mandreel_audio_update = null_mandreel_audio;
 mandreel_audio_createBuffer = null_mandreel_audio;
 mandreel_audio_playChannel = null_mandreel_audio;
 mandreel_audio_stopChannel = null_mandreel_audio;
 mandreel_audio_setChannelVolume = null_mandreel_audio;
 mandreel_audio_setChannelPan = null_mandreel_audio;
 mandreel_audio_setChannelPitch = null_mandreel_audio;
 mandreel_audio_useMusicFunctions = wa_mandreel_audio_useMusicFunctions;
 mandreel_audio_playMusic = wa_mandreel_audio_playMusic;
 mandreel_audio_stopMusic = wa_mandreel_audio_stopMusic;
 mandreel_audio_setMusicVol = wa_mandreel_audio_setMusicVol;
 setTimeout("MandreelAudioStarted()", 10);
}
function at_mandreel_audio_init(sp)
{
}

function at_mandreel_audio_end(sp)
{
}

function at_mandreel_audio_update(sp)
{
 for ( i = 0 ; i < 32 ; ++i )
 {
  var end = maudioChannelEnd[i];
  if ( end != null )
  {
   var sound = maudiotagChannels[i];
   if ( sound != null )
   {
    if ( sound.currentTime > end )
    {
     sound.pause();
     maudioChannelEnd[i] = null;
    }
   }
  }
 }
}

function at_mandreel_audio_checkBuffersPending(sp)
{
 r_g0 = 0;//wa_imp_mandreel_audio_checkBuffersPending();
}

function at_mandreel_audio_createBuffer(sp)
{
 var ptr_fileName = heap32[sp>>2];sp+=4;
 var maxChannels = heap32[sp>>2];sp+=4;
 var fileName = get_string_from_ptr(ptr_fileName).toLowerCase();
 //wa_imp_mandreel_audio_createBuffer(fileName);

 r_g0 = 0;
}

function at_mandreel_audio_playChannel(sp)
{
 var ptr_fileName = heap32[sp>>2];sp+=4;
 var channel = heap32[sp>>2];sp+=4;
 var vol = heapFloat[sp>>2];sp+=4;
 var loop = heap32[sp>>2];sp+=4;
 var pitch = heapFloat[sp>>2];sp+=4;
 var fileName = get_string_from_ptr(ptr_fileName).toLowerCase();
 at_imp_mandreel_audio_playChannel(fileName,channel,vol,loop,pitch);
 r_g0 = 0;
}

function at_mandreel_audio_stopChannel(sp)
{
 var ptr_fileName = heap32[sp>>2];sp+=4;
 var channel = heap32[sp>>2];sp+=4;
 var index = heapFloat[sp>>2];sp+=4;
 at_imp_mandreel_audio_stopChannel(channel);
}

function at_mandreel_audio_setChannelVolume(sp)
{
 var channel = heap32[sp>>2];sp+=4;
 var vol = heapFloat[sp>>2];sp+=4;
 //wa_imp_mandreel_audio_setChannelVolume(channel,vol);
}

function at_mandreel_audio_setChannelPan(sp)
{
 var channel = heap32[sp>>2];sp+=4;
 var pan = heapFloat[sp>>2];sp+=4;
 //wa_imp_mandreel_audio_setChannelPan(channel,pan);
}

function at_mandreel_audio_setChannelPitch(sp)
{
 var channel = heap32[sp>>2];sp+=4;
 var pitch = heapFloat[sp>>2];sp+=4;
 //wa_imp_mandreel_audio_setChannelPitch(channel,pitch);
}

function at_mandreel_audio_useMusicFunctions(sp)
{
 r_g0 = 1;
}

function at_MainAudioDriver()
{
 mandreel_audio_init = at_mandreel_audio_init;
 mandreel_audio_end = at_mandreel_audio_end;
 mandreel_audio_update = at_mandreel_audio_update;
 mandreel_audio_createBuffer = at_mandreel_audio_createBuffer;
 mandreel_audio_playChannel = at_mandreel_audio_playChannel;
 mandreel_audio_stopChannel = at_mandreel_audio_stopChannel;
 mandreel_audio_setChannelVolume = at_mandreel_audio_setChannelVolume;
 mandreel_audio_setChannelPan = at_mandreel_audio_setChannelPan;
 mandreel_audio_setChannelPitch = at_mandreel_audio_setChannelPitch;
 mandreel_audio_useMusicFunctions = at_mandreel_audio_useMusicFunctions;
 mandreel_audio_playMusic = wa_mandreel_audio_playMusic;
 mandreel_audio_stopMusic = wa_mandreel_audio_stopMusic;
 mandreel_audio_checkBuffersPending = at_mandreel_audio_checkBuffersPending;
 mandreel_audio_setMusicVol = wa_mandreel_audio_setMusicVol;

 setTimeout("mandreel_audiotag_PreloadAssets()", 10);
}

var maudiotagPreloadState = "start";
var maudiotagPreloadAssets = 0;
var maudiotagCurrentPreloadAsset = 0;
var maudiotagPreloadAsync = false;
var maudiotagDurations = Array();
var maudiotagChannelsCreated = 0;
var maudiotagChannels = Array();
var maudiotagChannelsLoaded = Array();
var maudiotagAudioSpriteFound = false;
var maudiotagAvailableChannels = new Array();
var maudioSecondsPos = new Array();
var maudioChannelEnd = new Array();

function mandreel_audiotag_PreloadAssets()
{
 if ( maudiotagPreloadState == "start" )
 {
  maudiotagPreloadAssets = mandreelFatData.split('\n');
  maudiotagCurrentPreloadAsset = 0;
  maudiotagPreloadState = "preloading";
 }
 else if ( maudiotagPreloadState == "preloading" )
 {
  var queued = false;
  while ( !queued && maudiotagPreloadState != "done" )
  {
   if ( maudiotagCurrentPreloadAsset < maudiotagPreloadAssets.length )
   {
    var params = maudiotagPreloadAssets[maudiotagCurrentPreloadAsset].split(',');
    if ( params[0] == "audiofile" && params[1])
    {
     var duration = params[3];
     var fileNameNoExt = wa_getFileNameNoExt(params[1]);
     maudiotagDurations[fileNameNoExt] = duration|0;
     dump("audiotag duration ("+params[1]+") "+duration);
    }
    else if ( params[0] == "audiotagfile" )
    {
     var type = params[1];
     var filesize = params[3];
     var numsounds = params[4];
     var at = new Audio();
     if ( !maudiotagAudioSpriteFound && at.canPlayType && at.canPlayType("audio/"+type) != "" )
     {
      maudiotagLoadPackFile(params[2],filesize,numsounds,type);
      maudiotagAudioSpriteFound = true;
      queued = true;
     }
    }
    else if ( params[0] == "audiopreloadasync" )
    {
     maudiotagPreloadAsync = true;
    }
    maudiotagCurrentPreloadAsset++;
   }
   else
    queued = true;

   if ( maudiotagCurrentPreloadAsset >= maudiotagPreloadAssets.length )
   {
    maudiotagPreloadState = "done";
    maudiotagPreloadAssets = 0;
   }
  }
 }

 if ( maudiotagPreloadState == "done" )
 {
  setTimeout("MandreelAudioStarted()", 10);
 }
 else
  setTimeout("mandreel_audiotag_PreloadAssets()", 10);
}

function maudiotagLoadPackFile(filename,filesize,numsounds,atype)
{
 dump("audiotag packfile ("+filename+") ("+filesize+") ("+numsounds+")");
 var url = g_mandreel_working_folder+filename;
 dump("audiotag: loading packed data ("+filename+") url("+url+")");
 var request = new XMLHttpRequest();
 request.open("GET", url, true);
 request.responseType = "arraybuffer";
 request.onreadystatechange = function()
 {
  if (request.readyState == 4)
  {
   if (request.status == 404)
    return;
   if ( request.response != null )
    audiotagParsePreloadFile(request.response,numsounds,atype);
  }
 }
 request.send();
}

function audiotagParsePreloadFile(response,numsounds,atype)
{
 var pos = 0;
 var bytes = new Uint8Array(response);
 var i = 0;
 if ( webAudioPreloadAsync )
  webAudioPreloadBytes = bytes;
 var secondsPos = 0.0;
 while ( pos < bytes.byteLength && i < numsounds)
 {
  // filename
  var fileName = "";
  while ( bytes[pos] != 0 )
  {
   fileName += String.fromCharCode(bytes[pos]);
   pos++;
  }
  pos++;
  // filesize
  var filesize = bytes[pos] | (bytes[pos+1]<<8) | (bytes[pos+2]<<16) | (bytes[pos+3]<<24);
  pos += 4;
  var fileNameNoExt = wa_getFileNameNoExt(fileName);
  var duration = maudiotagDurations[fileNameNoExt];
  dump("afile ("+fileName+") duration("+duration+") posseconds("+secondsPos+")");
  maudioSecondsPos[fileNameNoExt] = secondsPos;
  secondsPos += duration / 1000.0;
  secondsPos += 0.25;
  dump("second "+i+" "+secondsPos);

  i++;
 }

 // contents
 var contentSize = bytes.byteLength - pos;
 var bufferdata = new Uint8Array(contentSize);
 bufferdata.set(bytes.subarray(pos,pos+contentSize));
 var ascii = '';
 for (var i=0; i<bufferdata.length; i++)
  ascii += String.fromCharCode(bufferdata[i]);
 var base64 = btoa(ascii);
 audiotagAudioSprite = "data:audio/"+atype+";base64," + base64;

 if ( webAudioPreloadAsync )
 {
  dump("started preloading audio files async");
  setTimeout("mandreel_webAudio_preloadNextAudioFile()",10);
 }

 audiotagCreateChannel(0);
}

function audiotagCreateChannel(index)
{
 console.log("audiotagCreateChannel "+index);
 var sound = new Audio();
 sound.addEventListener("canplaythrough",function()
 {
  if ( maudiotagChannelsLoaded[index] == null )
  {
   maudiotagChannelsLoaded[index] = sound;
   maudiotagAvailableChannels.push(sound);
   console.log("************** loaded channel "+index);
   if ( index < 8 )
    setTimeout("audiotagCreateChannel("+index+"+1)", 10);
  }
 }, false);
 sound.addEventListener("error",function()
 {
  console.log("************** error loading channel "+index);
 }, false);
 //sound.src = "data:audio/mp3;base64,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";
 sound.src = audiotagAudioSprite;
 sound.load();
 console.log("--audiotagCreateChannel "+index);
}

function at_imp_mandreel_audio_playChannel(filename,channel,vol,loop,pitch)
{
 at_imp_mandreel_audio_stopChannel(channel);
 var fileNameNoExt = wa_getFileNameNoExt(filename);
 var time = maudioSecondsPos[fileNameNoExt];
 if ( time != null )
 {
  console.log("play "+fileNameNoExt+" "+time);
  if ( maudiotagAvailableChannels.length > 0 )
  {
   var sound = maudiotagAvailableChannels.pop();
   var duration = maudiotagDurations[fileNameNoExt];
   sound.currentTime = time;
   console.log("OK "+sound.currentTime);
   sound.play();
   maudiotagChannels[channel] = sound;
   maudioChannelEnd[channel] = time+(duration/1000.0);
  }
 }
 else
 {
  console.log("not found play "+fileNameNoExt);
 }
}

function at_imp_mandreel_audio_stopChannel(channel)
{
 var sound = maudiotagChannels[channel];
 if ( sound != null )
 {
  sound.pause();
  maudiotagAvailableChannels.push(sound);
  maudiotagChannels[channel] = null;
 }
}

var mandreel_flash_socket_callback = null

function mandreel_flash_sockets_load_flash(callback)
{
 mandreel_flash_socket_callback = callback;
 var failed = "";
 try
 {
  var mandreelSocketsSwf = g_mandreel_working_folder+"mandreelflashsockets.swf";
  var swf = swfobject.createSWF({ data:mandreelSocketsSwf, width:"0", height:"0", allowScriptAccess:"always" }, { menu:"false" }, "FlashDivSockets");
  if ( !swf )
   failed  = "Unable to open MandreelFlashSockets.swf";
 }
 catch(err)
 {
  failed  = err;
 }
}

var js_mandreel_flash_socket_swf_loaded = false;

function js_mandreel_flash_socket_ready()
{
 js_mandreel_flash_socket_swf_loaded = true;
 if (mandreel_flash_socket_callback)
  mandreel_flash_socket_callback();
}


function Mandreel_Socket_InitLibrary(sp)
{
 //mandreel_flash_sockets_load_flash();
}


function mandreel_flash_sockets_getFlashMovieObject(movieName)
{
 if (Mandreel_window.document[movieName])
 {
  return Mandreel_window.document[movieName];
 }
 if (navigator.appName.indexOf("Microsoft Internet")==-1)
 {
  if (document.embeds && document.embeds[movieName])
   return document.embeds[movieName];
 }
 else
 {
  return document.getElementById(movieName);
 }
}

function js_mandreel_flash_socket_onError(message)
{
 var id = parseInt(message);

 var sp = g_stack_pointer+512*1024;

 dump('on error ' + id);

 heap32[sp>>2] = id;
 mandreel_flash_tcp_onError(sp);

}
function js_mandreel_flash_socket_onConnect(message)
{
 var id = parseInt(message);

 var sp = g_stack_pointer+512*1024;

 dump('connected ' + id);

 heap32[sp>>2] = id;
 mandreel_flash_tcp_onConnect(sp);
}

function js_mandreel_flash_tcp_receive_callbak(message)
{
 var strings = message.split(' ');

 var id = parseInt(strings[0]);
 var data = strings[1];

 var sp = g_stack_pointer+512*1024;

 var data_ptr = sp + 1024;
 fill_ptr_from_string(data_ptr,data);

 heap32[sp>>2] = id;
 heap32[(sp+4)>>2] = data_ptr;
 mandreel_flash_tcp_receive_callbak(sp);
}

function js_mandreel_flash_tcp_update(sp)
{
 var id = heap32[sp>>2];sp+=4;
 var size = heap32[sp>>2];sp+=4;

 var flashMovie=mandreel_flash_sockets_getFlashMovieObject("FlashDivSockets");
 flashMovie.receiveMessage("receive " + id + " " + size);
}

function js_mandreel_flash_tcp_create(sp)
{
 var id = heap32[sp>>2];sp+=4;

 var flashMovie=mandreel_flash_sockets_getFlashMovieObject("FlashDivSockets");
 flashMovie.receiveMessage("create " + id);
}

function js_mandreel_flash_tcp_connectTo(sp)
{
 var id = heap32[sp>>2];sp+=4;
 var ptr_string = heap32[sp>>2];sp+=4;
 var port = heap32[sp>>2];sp+=4;

 var server_name = get_string_from_ptr(ptr_string);

 var flashMovie=mandreel_flash_sockets_getFlashMovieObject("FlashDivSockets");
 flashMovie.receiveMessage("connect " + id + " " + server_name + " " + port);
}

function js_mandreel_flash_tcp_close(sp)
{
 var id = heap32[sp>>2];sp+=4;


 var flashMovie=mandreel_flash_sockets_getFlashMovieObject("FlashDivSockets");
 flashMovie.receiveMessage("close " + id);
 dump("js_mandreel_flash_tcp_close " + id);
}
function js_mandreel_flash_tcp_write(sp)
{
 var id = heap32[sp>>2];sp+=4;
 var ptr = heap32[sp>>2];sp+=4;

 var message = get_string_from_ptr(ptr);

 dump('js_mandreel_flash_tcp_write ' + message);

 var flashMovie=mandreel_flash_sockets_getFlashMovieObject("FlashDivSockets");
 r_g0 = flashMovie.receiveMessage("send " + id + " " + message);
}



function js_mandreel_flash_tcp_dump(msg)
{
 dump(msg);
}

function _GLOBAL__I_Landscape02Vtx(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
var __label__ = 0;
 i7 = sp + -8;var g0 = i7>>2; // save stack
 r0 = _ZL10raycastBar;
 heap32[(g0)] = 8;
 r0 = r0 >> 2;
 _Znwj(i7);
 heap32[(r0+10006)] = r_g0;
 heap32[(g0)] = r_g0;
 heap32[(g0+1)] = 0;
 gettimeofday(i7);
 heap32[(r0+10001)] = 0;
 heap32[(r0+10005)] = 0;
 heap32[(r0+10004)] = 9999;
 heap32[(r0+10003)] = 0;
 heap32[(r0+10002)] = 0;
 return;
}

function _GLOBAL__D_Landscape02Vtx(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
var __label__ = 0;
 i7 = sp + -8;var g0 = i7>>2; // save stack
 r0 = _ZL10raycastBar;
 r0 = r0 >> 2;
 r0 = heap32[(r0+10006)];
 heap32[(g0)] = r0;
 _ZdlPv(i7);
 return;
}

function _ZN15DemoApplication6myinitEv(sp)
{
 var i7;
 var fp = sp>>2;
var __label__ = 0;
 i7 = sp + 0;var g0 = i7>>2; // save stack
 return;
}

function _ZN15DemoApplication16getDynamicsWorldEv(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
var __label__ = 0;
 i7 = sp + 0;var g0 = i7>>2; // save stack
 r0 = heap32[(fp)];
 r0 = r0 >> 2;
 r0 = heap32[(r0+1)];
 r_g0 = r0;
 return;
}

function _ZNK16btCollisionWorld17RayResultCallback14needsCollisionEP17btBroadphaseProxy(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
 var r1;
 var r2;
 var r3;
var __label__ = 0;
 i7 = sp + 0;var g0 = i7>>2; // save stack
 r0 = heap32[(fp)];
 r1 = heap32[(fp+1)];
 r2 = heapU16[(r0+14)>>1];
 r3 = heapU16[(r1+4)>>1];
 r2 = r2 & r3;
 r2 = r2 & 65535;
 if(r2 ==0) //_LBB4_2
{
 r0 = 0;
 r_g0 = r0;
 return;
}
else{
 r1 = heapU16[(r1+6)>>1];
 r0 = heapU16[(r0+12)>>1];
 r0 = r1 & r0;
 r0 = r0 & 65535;
 r1 = 0;
 r0 = r0 != r1;
 r0 = r0 & 1;
 r_g0 = r0;
 return;
}
}

function _ZN16btCollisionWorld24ClosestRayResultCallbackD1Ev(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
 var r1;
var __label__ = 0;
 i7 = sp + 0;var g0 = i7>>2; // save stack
 r0 = heap32[(fp)];
 r1 = _ZTVN16btCollisionWorld24ClosestRayResultCallbackE;
 r0 = r0 >> 2;
 r1 = (r1 + 8)|0;
 heap32[(r0)] = r1;
 return;
}

function _ZN16btCollisionWorld24ClosestRayResultCallbackD0Ev(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
 var r1;
 var r2;
var __label__ = 0;
 i7 = sp + -8;var g0 = i7>>2; // save stack
 r0 = heap32[(fp)];
 r1 = _ZTVN16btCollisionWorld24ClosestRayResultCallbackE;
 r2 = r0 >> 2;
 r1 = (r1 + 8)|0;
 heap32[(r2)] = r1;
 heap32[(g0)] = r0;
 _ZdlPv(i7);
 return;
}

function _ZN16btCollisionWorld24ClosestRayResultCallback15addSingleResultERNS_14LocalRayResultEb(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
 var r1;
 var r2;
 var r3;
 var f0;
 var f1;
 var f2;
 var f3;
 var f4;
 var f5;
 var f6;
 var f7;
 var f8;
 var f9;
 var f10;
 var f11;
var __label__ = 0;
 i7 = sp + -16;var g0 = i7>>2; // save stack
 r0 = heap32[(fp+1)];
 r0 = r0 >> 2;
 r1 = heap32[(fp)];
 f0 = heapFloat[(r0+6)];
 r1 = r1 >> 2;
 f1 = heapFloat[(r1+1)];
 if(f0 <=f1) //_LBB7_2
{
 r2 = heap32[(fp+2)];
 heapFloat[(r1+1)] = f0;
 r3 = heap32[(r0)];
 heap32[(r1+2)] = r3;
 if(r2 ==0) //_LBB7_4
{
 r2 = r3 >> 2;
 f0 = heapFloat[(r0+2)];
 f1 = heapFloat[(r2+1)];
 f2 = heapFloat[(r0+3)];
 f3 = heapFloat[(r2+2)];
 f4 = heapFloat[(r2+5)];
 f5 = heapFloat[(r2+6)];
 f1 = f1*f0;
 f3 = f3*f2;
 f6 = heapFloat[(r0+4)];
 f7 = heapFloat[(r2+3)];
 f8 = heapFloat[(r2+9)];
 f9 = heapFloat[(r2+10)];
 f10 = heapFloat[(r2+11)];
 f11 = heapFloat[(r2+7)];
 f4 = f4*f0;
 f5 = f5*f2;
 f1 = f1+f3;
 f3 = f7*f6;
 f0 = f8*f0;
 f2 = f9*f2;
 f4 = f4+f5;
 f5 = f11*f6;
 f1 = f1+f3;
 f0 = f0+f2;
 f2 = f10*f6;
 f3 = f4+f5;
 heapFloat[(r1+13)] = f1;
 f0 = f0+f2;
 heapFloat[(r1+14)] = f3;
 heapFloat[(r1+15)] = f0;
 heap32[(r1+16)] = 0;
}
else{
 heap32[(r1+13)] = heap32[(r0+2)];
 heap32[(r1+14)] = heap32[(r0+3)];
 heap32[(r1+15)] = heap32[(r0+4)];
 heap32[(r1+16)] = heap32[(r0+5)];
}
 f0 =                         1;
 f1 = heapFloat[(r0+6)];
 f2 = heapFloat[(r1+9)];
 f3 = heapFloat[(r1+5)];
 f0 = f0-f1;
 f3 = f3*f0;
 f2 = f2*f1;
 f2 = f3+f2;
 heapFloat[(r1+17)] = f2;
 f2 = heapFloat[(r1+6)];
 f3 = heapFloat[(r1+10)];
 f2 = f2*f0;
 f3 = f3*f1;
 f2 = f2+f3;
 heapFloat[(r1+18)] = f2;
 f2 = heapFloat[(r1+7)];
 f3 = heapFloat[(r1+11)];
 f0 = f2*f0;
 f1 = f3*f1;
 f0 = f0+f1;
 heapFloat[(r1+19)] = f0;
 f0 = heapFloat[(r0+6)];
 f_g0 = f0;
 return;
}
else{
 r0 = _2E_str3;
 r1 = _2E_str4;
 heap32[(g0)] = r0;
 heap32[(g0+1)] = r1;
 heap32[(g0+2)] = 250;
 _assert(i7);
}
}

function _ZN20btDefaultMotionStateD1Ev(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
 var r1;
var __label__ = 0;
 i7 = sp + 0;var g0 = i7>>2; // save stack
 r0 = heap32[(fp)];
 r1 = _ZTV20btDefaultMotionState;
 r0 = r0 >> 2;
 r1 = (r1 + 8)|0;
 heap32[(r0)] = r1;
 return;
}

function _ZN20btDefaultMotionStateD0Ev(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
 var r1;
 var r2;
var __label__ = 0;
 i7 = sp + -8;var g0 = i7>>2; // save stack
 r0 = heap32[(fp)];
 r1 = _ZTV20btDefaultMotionState;
 r2 = r0 >> 2;
 r1 = (r1 + 8)|0;
 heap32[(r2)] = r1;
 heap32[(g0)] = r0;
 _ZdlPv(i7);
 return;
}

function _ZNK20btDefaultMotionState17getWorldTransformER11btTransform(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
 var r1;
 var f0;
 var f1;
 var f2;
 var f3;
 var f4;
 var f5;
 var f6;
 var f7;
 var f8;
 var f9;
 var f10;
 var f11;
 var f12;
 var f13;
 var f14;
 var f15;
 var f16;
 var f17;
 var f18;
 var f19;
 var f20;
 var f21;
 var f22;
 var f23;
 var f24;
 var f25;
 var f26;
 var f27;
 var f28;
 var f29;
var __label__ = 0;
 i7 = sp + 0;var g0 = i7>>2; // save stack
 r0 = heap32[(fp)];
 r0 = r0 >> 2;
 f0 = heapFloat[(r0+17)];
 f1 = heapFloat[(r0+1)];
 f2 = heapFloat[(r0+21)];
 f3 = heapFloat[(r0+5)];
 f4 = heapFloat[(r0+2)];
 f5 = heapFloat[(r0+6)];
 f6 = f1*f0;
 f7 = f3*f2;
 f8 = heapFloat[(r0+25)];
 f9 = heapFloat[(r0+9)];
 f10 = heapFloat[(r0+18)];
 f11 = heapFloat[(r0+22)];
 f12 = heapFloat[(r0+19)];
 f13 = heapFloat[(r0+13)];
 f14 = heapFloat[(r0+3)];
 f15 = heapFloat[(r0+23)];
 f16 = heapFloat[(r0+30)];
 f17 = heapFloat[(r0+14)];
 f18 = heapFloat[(r0+7)];
 r1 = heap32[(fp+1)];
 f19 = heapFloat[(r0+26)];
 f20 = heapFloat[(r0+31)];
 f21 = heapFloat[(r0+27)];
 f22 = heapFloat[(r0+15)];
 f23 = heapFloat[(r0+11)];
 f24 = heapFloat[(r0+10)];
 f25 = heapFloat[(r0+29)];
 f26 = f4*f0;
 f27 = f5*f2;
 f6 = f6+f7;
 f7 = f9*f8;
 r0 = r1 >> 2;
 f28 = f14*f0;
 f29 = f18*f2;
 f26 = f26+f27;
 f27 = f24*f8;
 f6 = f6+f7;
 f7 = f28+f29;
 f28 = f23*f8;
 f26 = f26+f27;
 heapFloat[(r0)] = f6;
 f6 = f1*f10;
 f27 = f3*f11;
 f7 = f7+f28;
 heapFloat[(r0+1)] = f26;
 heapFloat[(r0+2)] = f7;
 f7 = f4*f10;
 f26 = f5*f11;
 f6 = f6+f27;
 f27 = f9*f19;
 f28 = f14*f10;
 f29 = f18*f11;
 f7 = f7+f26;
 f26 = f24*f19;
 f6 = f6+f27;
 heap32[(r0+3)] = 0;
 f27 = f28+f29;
 f28 = f23*f19;
 f7 = f7+f26;
 heapFloat[(r0+4)] = f6;
 f1 = f1*f12;
 f3 = f3*f15;
 f6 = f27+f28;
 heapFloat[(r0+5)] = f7;
 heapFloat[(r0+6)] = f6;
 f4 = f4*f12;
 f5 = f5*f15;
 f1 = f1+f3;
 f3 = f9*f21;
 f6 = -f25;
 f7 = f14*f12;
 f9 = f18*f15;
 f4 = f4+f5;
 f5 = f24*f21;
 f1 = f1+f3;
 heap32[(r0+7)] = 0;
 f3 = f0*f13;
 f14 = f2*f17;
 f0 = f0*f6;
 f2 = f2*f16;
 f7 = f7+f9;
 f9 = f23*f21;
 f4 = f4+f5;
 heapFloat[(r0+8)] = f1;
 f1 = f10*f13;
 f5 = f11*f17;
 f10 = f10*f6;
 f11 = f11*f16;
 f3 = f3+f14;
 f14 = f8*f22;
 f0 = f0-f2;
 f2 = f8*f20;
 f7 = f7+f9;
 heapFloat[(r0+9)] = f4;
 heapFloat[(r0+10)] = f7;
 f4 = f12*f13;
 f7 = f15*f17;
 f6 = f12*f6;
 f8 = f15*f16;
 f1 = f1+f5;
 f5 = f19*f22;
 f9 = f10-f11;
 f10 = f19*f20;
 f3 = f3+f14;
 f0 = f0-f2;
 f2 = f4+f7;
 f4 = f21*f22;
 f6 = f6-f8;
 f7 = f21*f20;
 f1 = f1+f5;
 f5 = f9-f10;
 f0 = f3+f0;
 heap32[(r0+11)] = 0;
 f2 = f2+f4;
 f3 = f6-f7;
 f1 = f1+f5;
 heapFloat[(r0+12)] = f0;
 f0 = f2+f3;
 heapFloat[(r0+13)] = f1;
 heapFloat[(r0+14)] = f0;
 heap32[(r0+15)] = 0;
 return;
}

function _ZN20btDefaultMotionState17setWorldTransformERK11btTransform(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
 var r1;
 var f0;
 var f1;
 var f2;
 var f3;
 var f4;
 var f5;
 var f6;
 var f7;
 var f8;
 var f9;
 var f10;
 var f11;
 var f12;
 var f13;
 var f14;
 var f15;
 var f16;
 var f17;
 var f18;
 var f19;
 var f20;
 var f21;
 var f22;
 var f23;
 var f24;
 var f25;
 var f26;
 var f27;
 var f28;
 var f29;
var __label__ = 0;
 i7 = sp + 0;var g0 = i7>>2; // save stack
 r0 = heap32[(fp)];
 r1 = heap32[(fp+1)];
 r0 = r0 >> 2;
 r1 = r1 >> 2;
 f0 = heapFloat[(r1)];
 f1 = heapFloat[(r0+17)];
 f2 = heapFloat[(r1+1)];
 f3 = heapFloat[(r0+21)];
 f4 = heapFloat[(r0+18)];
 f5 = heapFloat[(r0+22)];
 f6 = f1*f0;
 f7 = f3*f2;
 f8 = heapFloat[(r1+2)];
 f9 = heapFloat[(r0+25)];
 f10 = heapFloat[(r1+8)];
 f11 = heapFloat[(r0+29)];
 f12 = heapFloat[(r1+4)];
 f13 = heapFloat[(r0+19)];
 f14 = heapFloat[(r1+9)];
 f15 = heapFloat[(r0+30)];
 f16 = heapFloat[(r1+5)];
 f17 = heapFloat[(r0+23)];
 f18 = heapFloat[(r1+10)];
 f19 = heapFloat[(r0+31)];
 f20 = heapFloat[(r1+6)];
 f21 = heapFloat[(r0+27)];
 f22 = heapFloat[(r0+26)];
 f23 = f4*f0;
 f24 = f5*f2;
 f6 = f6+f7;
 f7 = f9*f8;
 f25 = heapFloat[(r1+14)];
 f26 = heapFloat[(r1+13)];
 f27 = heapFloat[(r1+12)];
 f28 = f13*f0;
 f29 = f17*f2;
 f23 = f23+f24;
 f24 = f22*f8;
 f6 = f6+f7;
 f7 = f28+f29;
 f28 = f21*f8;
 f23 = f23+f24;
 heapFloat[(r0+1)] = f6;
 f6 = f1*f12;
 f24 = f3*f16;
 f7 = f7+f28;
 heapFloat[(r0+2)] = f23;
 heapFloat[(r0+3)] = f7;
 f7 = f4*f12;
 f23 = f5*f16;
 f6 = f6+f24;
 f24 = f9*f20;
 f28 = f13*f12;
 f29 = f17*f16;
 f7 = f7+f23;
 f23 = f22*f20;
 f6 = f6+f24;
 heap32[(r0+4)] = 0;
 f24 = f28+f29;
 f28 = f21*f20;
 f7 = f7+f23;
 heapFloat[(r0+5)] = f6;
 f1 = f1*f10;
 f3 = f3*f14;
 f6 = f24+f28;
 heapFloat[(r0+6)] = f7;
 heapFloat[(r0+7)] = f6;
 f4 = f4*f10;
 f5 = f5*f14;
 f1 = f1+f3;
 f3 = f9*f18;
 f6 = f13*f10;
 f7 = f17*f14;
 f4 = f4+f5;
 f5 = f22*f18;
 f1 = f1+f3;
 heap32[(r0+8)] = 0;
 f0 = f0*f11;
 f2 = f2*f15;
 f3 = f6+f7;
 f6 = f21*f18;
 f4 = f4+f5;
 heapFloat[(r0+9)] = f1;
 f1 = f12*f11;
 f5 = f16*f15;
 f0 = f0+f2;
 f2 = f8*f19;
 f3 = f3+f6;
 heapFloat[(r0+10)] = f4;
 f0 = f0+f2;
 heapFloat[(r0+11)] = f3;
 f2 = f10*f11;
 f3 = f14*f15;
 f1 = f1+f5;
 f4 = f20*f19;
 f1 = f1+f4;
 f2 = f2+f3;
 f3 = f18*f19;
 f0 = f0+f27;
 heap32[(r0+12)] = 0;
 f2 = f2+f3;
 f1 = f1+f26;
 heapFloat[(r0+13)] = f0;
 f0 = f2+f25;
 heapFloat[(r0+14)] = f1;
 heapFloat[(r0+15)] = f0;
 heap32[(r0+16)] = 0;
 return;
}

function _ZN17btTypedConstraint21setupSolverConstraintER20btAlignedObjectArrayI18btSolverConstraintEiif(sp)
{
 var i7;
 var fp = sp>>2;
var __label__ = 0;
 i7 = sp + 0;var g0 = i7>>2; // save stack
 return;
}

function _ZN17btTypedConstraint23solveConstraintObsoleteER11btRigidBodyS1_f(sp)
{
 var i7;
 var fp = sp>>2;
var __label__ = 0;
 i7 = sp + 0;var g0 = i7>>2; // save stack
 return;
}

function _ZN13BenchmarkDemo15displayCallbackEv(sp)
{
 var i7;
 var fp = sp>>2;
var __label__ = 0;
 i7 = sp + 0;var g0 = i7>>2; // save stack
 return;
}

function _ZN13BenchmarkDemo11exitPhysicsEv(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
 var r1;
 var r2;
 var r3;
 var r4;
var __label__ = 0;
 i7 = sp + -8;var g0 = i7>>2; // save stack
 r0 = heap32[(fp)];
 r0 = r0 >> 2;
 r1 = heap32[(r0+9)];
if(!(r1 <1)) //_LBB15_5
{
 r1 = 0;
_3: while(true){
 r2 = heap32[(r0+11)];
 r3 = r1 << 2;
 r2 = (r2 + r3)|0;
 r2 = r2 >> 2;
 r2 = heap32[(r2)];
if(!(r2 ==0)) //_LBB15_4
{
 r3 = r2 >> 2;
 r3 = heap32[(r3)];
 r3 = r3 >> 2;
 r3 = heap32[(r3+1)];
 heap32[(g0)] = r2;
 __FUNCTION_TABLE__[(r3)>>2](i7);
}
 r1 = (r1 + 1)|0;
 r2 = heap32[(r0+9)];
 if(r2 >r1) //_LBB15_2
{
continue _3;
}
else{
break _3;
}
}
}
 r1 = heap32[(r0+1)];
 r2 = r1 >> 2;
 r2 = heap32[(r2+2)];
 r3 = (r2 + -1)|0;
_9: do {
if(!(r3 <0)) //_LBB15_16
{
 r3 = 1;
 r2 = (r3 - r2)|0;
_11: while(true){
 r3 = r1 >> 2;
 r3 = heap32[(r3+4)];
 r4 = r2 << 2;
 r3 = (r3 - r4)|0;
 r3 = r3 >> 2;
 r3 = heap32[(r3)];
 r4 = heapU8[r3+232];
 r4 = r4 & 2;
if(!(r4 ==0)) //_LBB15_9
{
 if(r3 !=0) //_LBB15_10
{
 r4 = r3 >> 2;
 r4 = heap32[(r4+118)];
if(!(r4 ==0)) //_LBB15_9
{
 r1 = r4 >> 2;
 r1 = heap32[(r1)];
 r1 = r1 >> 2;
 r1 = heap32[(r1+1)];
 heap32[(g0)] = r4;
 __FUNCTION_TABLE__[(r1)>>2](i7);
 r1 = heap32[(r0+1)];
}
}
}
 r4 = r1 >> 2;
 r4 = heap32[(r4)];
 r4 = r4 >> 2;
 r4 = heap32[(r4+9)];
 heap32[(g0)] = r1;
 heap32[(g0+1)] = r3;
 __FUNCTION_TABLE__[(r4)>>2](i7);
 if(r3 !=0) //_LBB15_15
{
 r1 = r3 >> 2;
 r1 = heap32[(r1)];
 r1 = r1 >> 2;
 r1 = heap32[(r1+2)];
 heap32[(g0)] = r3;
 __FUNCTION_TABLE__[(r1)>>2](i7);
}
 if(r2 ==0) //_LBB15_16
{
break _9;
}
else{
 r2 = (r2 + 1)|0;
 r1 = heap32[(r0+1)];
continue _11;
}
}
}
} while(0);
 r1 = heap32[(r0+4)];
_23: do {
if(!(r1 <1)) //_LBB15_21
{
 r1 = 0;
_25: while(true){
 r2 = heap32[(r0+6)];
 r3 = r1 << 2;
 r2 = (r2 + r3)|0;
 r2 = r2 >> 2;
 r2 = heap32[(r2)];
if(!(r2 ==0)) //_LBB15_20
{
 r3 = r2 >> 2;
 r3 = heap32[(r3)];
 r3 = r3 >> 2;
 r3 = heap32[(r3+1)];
 heap32[(g0)] = r2;
 __FUNCTION_TABLE__[(r3)>>2](i7);
}
 r1 = (r1 + 1)|0;
 r2 = heap32[(r0+4)];
 if(r2 >r1) //_LBB15_18
{
continue _25;
}
else{
break _23;
}
}
}
} while(0);
 r1 = heap32[(r0+1)];
if(!(r1 ==0)) //_LBB15_23
{
 r2 = r1 >> 2;
 r2 = heap32[(r2)];
 r2 = r2 >> 2;
 r2 = heap32[(r2+1)];
 heap32[(g0)] = r1;
 __FUNCTION_TABLE__[(r2)>>2](i7);
}
 r1 = heap32[(r0+15)];
if(!(r1 ==0)) //_LBB15_25
{
 r2 = r1 >> 2;
 r2 = heap32[(r2)];
 r2 = r2 >> 2;
 r2 = heap32[(r2+1)];
 heap32[(g0)] = r1;
 __FUNCTION_TABLE__[(r2)>>2](i7);
}
 r1 = heap32[(r0+13)];
if(!(r1 ==0)) //_LBB15_27
{
 r2 = r1 >> 2;
 r2 = heap32[(r2)];
 r2 = r2 >> 2;
 r2 = heap32[(r2+1)];
 heap32[(g0)] = r1;
 __FUNCTION_TABLE__[(r2)>>2](i7);
}
 r1 = heap32[(r0+14)];
if(!(r1 ==0)) //_LBB15_29
{
 r2 = r1 >> 2;
 r2 = heap32[(r2)];
 r2 = r2 >> 2;
 r2 = heap32[(r2+1)];
 heap32[(g0)] = r1;
 __FUNCTION_TABLE__[(r2)>>2](i7);
}
 r0 = heap32[(r0+16)];
if(!(r0 ==0)) //_LBB15_31
{
 r1 = r0 >> 2;
 r1 = heap32[(r1)];
 r1 = r1 >> 2;
 r1 = heap32[(r1+1)];
 heap32[(g0)] = r0;
 __FUNCTION_TABLE__[(r1)>>2](i7);
}
 return;
}

function _ZN7RagDollD0Ev(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
 var r1;
 var r2;
 var r3;
 var r4;
 var r5;
 var r6;
 var r7;
var __label__ = 0;
 i7 = sp + -8;var g0 = i7>>2; // save stack
 r0 = heap32[(fp)];
 r1 = _ZTV7RagDoll;
 r2 = 0;
 r3 = r0 >> 2;
 r1 = (r1 + 8)|0;
 heap32[(r3)] = r1;
 r1 = r2;
_1: while(true){
 r4 = heap32[(r3+1)];
 r5 = r1 << 2;
 r6 = r4 >> 2;
 r5 = (r0 - r5)|0;
 r6 = heap32[(r6)];
 r6 = r6 >> 2;
 r5 = r5 >> 2;
 r6 = heap32[(r6+14)];
 r7 = heap32[(r5+24)];
 heap32[(g0)] = r4;
 heap32[(g0+1)] = r7;
 __FUNCTION_TABLE__[(r6)>>2](i7);
 r4 = heap32[(r5+24)];
if(!(r4 ==0)) //_LBB16_3
{
 r5 = r4 >> 2;
 r5 = heap32[(r5)];
 r5 = r5 >> 2;
 r5 = heap32[(r5+1)];
 heap32[(g0)] = r4;
 __FUNCTION_TABLE__[(r5)>>2](i7);
}
 r4 = (r2 - r1)|0;
 r4 = r4 << 2;
 r4 = (r0 + r4)|0;
 r1 = (r1 + -1)|0;
 r4 = r4 >> 2;
 heap32[(r4+24)] = 0;
 if(r1 !=-10) //_LBB16_1
{
continue _1;
}
else{
break _1;
}
}
 r1 = 2;
_7: while(true){
 r2 = heap32[(r3+1)];
 r4 = r2 >> 2;
 r5 = r1 << 2;
 r4 = heap32[(r4)];
 r5 = (r0 + r5)|0;
 r4 = r4 >> 2;
 r5 = r5 >> 2;
 r4 = heap32[(r4+21)];
 r6 = heap32[(r5+11)];
 heap32[(g0)] = r2;
 heap32[(g0+1)] = r6;
 __FUNCTION_TABLE__[(r4)>>2](i7);
 r2 = heap32[(r5+11)];
 r4 = r2 >> 2;
 r4 = heap32[(r4+118)];
 if(r4 !=0) //_LBB16_7
{
 r2 = r4 >> 2;
 r2 = heap32[(r2)];
 r2 = r2 >> 2;
 r2 = heap32[(r2+1)];
 heap32[(g0)] = r4;
 __FUNCTION_TABLE__[(r2)>>2](i7);
 r2 = heap32[(r5+11)];
}
if(!(r2 ==0)) //_LBB16_10
{
 r4 = r2 >> 2;
 r4 = heap32[(r4)];
 r4 = r4 >> 2;
 r4 = heap32[(r4+2)];
 heap32[(g0)] = r2;
 __FUNCTION_TABLE__[(r4)>>2](i7);
}
 heap32[(r5+11)] = 0;
 r2 = heap32[(r5)];
if(!(r2 ==0)) //_LBB16_12
{
 r4 = r2 >> 2;
 r4 = heap32[(r4)];
 r4 = r4 >> 2;
 r4 = heap32[(r4+1)];
 heap32[(g0)] = r2;
 __FUNCTION_TABLE__[(r4)>>2](i7);
}
 r1 = (r1 + 1)|0;
 heap32[(r5)] = 0;
 if(r1 !=13) //_LBB16_5
{
continue _7;
}
else{
break _7;
}
}
 heap32[(g0)] = r0;
 _ZdlPv(i7);
 return;
}

function _ZN7RagDollD1Ev(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
 var r1;
 var r2;
 var r3;
 var r4;
 var r5;
 var r6;
 var r7;
var __label__ = 0;
 i7 = sp + -8;var g0 = i7>>2; // save stack
 r0 = heap32[(fp)];
 r1 = _ZTV7RagDoll;
 r2 = 0;
 r3 = r0 >> 2;
 r1 = (r1 + 8)|0;
 heap32[(r3)] = r1;
 r1 = r2;
_1: while(true){
 r4 = heap32[(r3+1)];
 r5 = r1 << 2;
 r6 = r4 >> 2;
 r5 = (r0 - r5)|0;
 r6 = heap32[(r6)];
 r6 = r6 >> 2;
 r5 = r5 >> 2;
 r6 = heap32[(r6+14)];
 r7 = heap32[(r5+24)];
 heap32[(g0)] = r4;
 heap32[(g0+1)] = r7;
 __FUNCTION_TABLE__[(r6)>>2](i7);
 r4 = heap32[(r5+24)];
if(!(r4 ==0)) //_LBB17_3
{
 r5 = r4 >> 2;
 r5 = heap32[(r5)];
 r5 = r5 >> 2;
 r5 = heap32[(r5+1)];
 heap32[(g0)] = r4;
 __FUNCTION_TABLE__[(r5)>>2](i7);
}
 r4 = (r2 - r1)|0;
 r4 = r4 << 2;
 r4 = (r0 + r4)|0;
 r1 = (r1 + -1)|0;
 r4 = r4 >> 2;
 heap32[(r4+24)] = 0;
 if(r1 !=-10) //_LBB17_1
{
continue _1;
}
else{
break _1;
}
}
 r1 = 2;
_7: while(true){
 r2 = heap32[(r3+1)];
 r4 = r2 >> 2;
 r5 = r1 << 2;
 r4 = heap32[(r4)];
 r5 = (r0 + r5)|0;
 r4 = r4 >> 2;
 r5 = r5 >> 2;
 r4 = heap32[(r4+21)];
 r6 = heap32[(r5+11)];
 heap32[(g0)] = r2;
 heap32[(g0+1)] = r6;
 __FUNCTION_TABLE__[(r4)>>2](i7);
 r2 = heap32[(r5+11)];
 r4 = r2 >> 2;
 r4 = heap32[(r4+118)];
 if(r4 !=0) //_LBB17_7
{
 r2 = r4 >> 2;
 r2 = heap32[(r2)];
 r2 = r2 >> 2;
 r2 = heap32[(r2+1)];
 heap32[(g0)] = r4;
 __FUNCTION_TABLE__[(r2)>>2](i7);
 r2 = heap32[(r5+11)];
}
if(!(r2 ==0)) //_LBB17_10
{
 r4 = r2 >> 2;
 r4 = heap32[(r4)];
 r4 = r4 >> 2;
 r4 = heap32[(r4+2)];
 heap32[(g0)] = r2;
 __FUNCTION_TABLE__[(r4)>>2](i7);
}
 heap32[(r5+11)] = 0;
 r2 = heap32[(r5)];
if(!(r2 ==0)) //_LBB17_12
{
 r4 = r2 >> 2;
 r4 = heap32[(r4)];
 r4 = r4 >> 2;
 r4 = heap32[(r4+1)];
 heap32[(g0)] = r2;
 __FUNCTION_TABLE__[(r4)>>2](i7);
}
 r1 = (r1 + 1)|0;
 heap32[(r5)] = 0;
 if(r1 !=13) //_LBB17_5
{
continue _7;
}
else{
break _7;
}
}
 return;
}

function _ZN13BenchmarkDemoD0Ev(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
 var r1;
 var r2;
 var r3;
 var r4;
 var r5;
var __label__ = 0;
 i7 = sp + -8;var g0 = i7>>2; // save stack
 r0 = heap32[(fp)];
 r1 = _ZTV13BenchmarkDemo;
 r2 = r0 >> 2;
 r1 = (r1 + 8)|0;
 heap32[(r2)] = r1;
 heap32[(g0)] = r0;
 _ZN13BenchmarkDemo11exitPhysicsEv(i7);
 r1 = heap32[(r2+11)];
if(!(r1 ==0)) //_LBB18_4
{
 r3 = heapU8[r0+48];
if(!(r3 ==0)) //_LBB18_3
{
 r3 = gNumAlignedFree;
 r3 = r3 >> 2;
 r4 = heap32[(r3)];
 r4 = (r4 + 1)|0;
 r1 = r1 >> 2;
 heap32[(r3)] = r4;
 r1 = heap32[(r1+-1)];
 heap32[(g0)] = r1;
 free(i7);
}
 heap32[(r2+11)] = 0;
}
 r1 = 1;
 heap8[r0+48] = r1;
 heap32[(r2+11)] = 0;
 heap32[(r2+9)] = 0;
 heap32[(r2+10)] = 0;
 r3 = heap32[(r2+6)];
if(!(r3 ==0)) //_LBB18_8
{
 r4 = heapU8[r0+28];
if(!(r4 ==0)) //_LBB18_7
{
 r4 = gNumAlignedFree;
 r4 = r4 >> 2;
 r5 = heap32[(r4)];
 r5 = (r5 + 1)|0;
 r3 = r3 >> 2;
 heap32[(r4)] = r5;
 r3 = heap32[(r3+-1)];
 heap32[(g0)] = r3;
 free(i7);
}
 heap32[(r2+6)] = 0;
}
 heap8[r0+28] = r1;
 heap32[(r2+6)] = 0;
 heap32[(r2+4)] = 0;
 heap32[(r2+5)] = 0;
 heap32[(g0)] = r0;
 _ZdlPv(i7);
 return;
}

function _ZN15DemoApplication20localCreateRigidBodyEfRK11btTransformP16btCollisionShape(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
 var r1;
 var r2;
 var r3;
 var r4;
 var r5;
 var r6;
 var r7;
 var f0;
 var f1;
var __label__ = 0;
 i7 = sp + -168;var g0 = i7>>2; // save stack
 r0 = heap32[(fp+3)];
if(!(r0 ==0)) //_LBB19_3
{
 r1 = r0 >> 2;
 r1 = heap32[(r1+1)];
if(!(r1 !=35)) //_LBB19_3
{
 r0 = _2E_str5;
 r1 = _2E_str6;
 heap32[(g0)] = r0;
 heap32[(g0+1)] = r1;
 heap32[(g0+2)] = 1297;
 _assert(i7);
}
}
 f0 = heapFloat[(fp+1)];
 r1 = sp + -152;
 r2 = r1 >> 2;
 heap32[(fp+-38)] = 0;
 heap32[(r2+1)] = 0;
 heap32[(r2+2)] = 0;
 f1 =                         0;
 heap32[(r2+3)] = 0;
if(!(f0 ==f1)) //_LBB19_5
{
 r3 = r0 >> 2;
 r3 = heap32[(r3)];
 r3 = r3 >> 2;
 r3 = heap32[(r3+8)];
 heap32[(g0)] = r0;
 heapFloat[(g0+1)] = f0;
 heap32[(g0+2)] = r1;
 __FUNCTION_TABLE__[(r3)>>2](i7);
}
 r1 = heap32[(fp)];
 r3 = heap32[(fp+2)];
 r4 = gNumAlignedAllocs;
 r4 = r4 >> 2;
 r5 = heap32[(r4)];
 r5 = (r5 + 1)|0;
 heap32[(r4)] = r5;
 heap32[(g0)] = 627;
 malloc(i7);
 r4 = r_g0;
 if(r4 !=0) //_LBB19_7
{
 r5 = 0;
 r6 = (r4 + 4)|0;
 r5 = (r5 - r6)|0;
 r5 = r5 & 15;
 r5 = (r4 + r5)|0;
 r6 = (r5 + 4)|0;
 r5 = r5 >> 2;
 heap32[(r5)] = r4;
 r4 = r6;
}
 r5 = r4 >> 2;
 heap32[(r5+41)] = 1065353216;
 heap32[(r5+42)] = 1065353216;
 heap32[(r5+43)] = 1065353216;
 heap32[(r5+44)] = 0;
 heap32[(r5+45)] = 0;
 heap32[(r5+46)] = 1566444395;
 heap32[(r5+47)] = 0;
 heap32[(r5+48)] = 0;
 heap32[(r5+49)] = 0;
 heap32[(r5+50)] = 0;
 heap32[(r5+51)] = 1;
 heap32[(r5+52)] = -1;
 heap32[(r5+53)] = -1;
 heap32[(r5+54)] = 1;
 heap32[(r5+55)] = 0;
 heap32[(r5+56)] = 1056964608;
 heap32[(r5+57)] = 0;
 heap32[(r5+58)] = 1;
 heap32[(r5+59)] = 0;
 heap32[(r5+60)] = 1065353216;
 heap32[(r5+61)] = 0;
 heap32[(r5+62)] = 0;
 heap32[(r5+63)] = 0;
 heap32[(r5+1)] = 1065353216;
 heap32[(r5+2)] = 0;
 heap32[(r5+3)] = 0;
 heap32[(r5+4)] = 0;
 heap32[(r5+5)] = 0;
 heap32[(r5+6)] = 1065353216;
 heap32[(r5+7)] = 0;
 heap32[(r5+8)] = 0;
 heap32[(r5+9)] = 0;
 heap32[(r5+10)] = 0;
 heap32[(r5+11)] = 1065353216;
 heap32[(r5+12)] = 0;
 heap32[(r5+13)] = 0;
 heap32[(r5+14)] = 0;
 r6 = _ZTV11btRigidBody;
 heap32[(r5+15)] = 0;
 r6 = (r6 + 8)|0;
 heap32[(r5+16)] = 0;
 r7 = 1;
 heap32[(r5)] = r6;
 heap8[r4+492] = r7;
 heap32[(r5+122)] = 0;
 heap32[(r5+120)] = 0;
 r6 = sp + -136;
 heap32[(r5+121)] = 0;
 r7 = r6 >> 2;
 heapFloat[(fp+-34)] = f0;
 heap32[(r7+1)] = 0;
 heap32[(r7+18)] = r0;
 heap32[(r7+19)] = heap32[(fp+-38)];
 heap32[(r7+20)] = heap32[(r2+1)];
 heap32[(r7+21)] = heap32[(r2+2)];
 heap32[(r7+22)] = heap32[(r2+3)];
 heap32[(r7+23)] = 0;
 heap32[(r7+24)] = 0;
 heap32[(r7+25)] = 1056964608;
 heap32[(r7+26)] = 0;
 heap32[(r7+27)] = 1061997773;
 r0 = 0;
 heap32[(r7+28)] = 1065353216;
 heap8[sp+-20] = r0;
 heap32[(r7+30)] = 1000593162;
 heap32[(r7+31)] = 1008981770;
 heap32[(r7+32)] = 1008981770;
 heap32[(r7+33)] = 1008981770;
 heap32[(r7+2)] = 1065353216;
 heap32[(r7+3)] = 0;
 heap32[(r7+4)] = 0;
 heap32[(r7+5)] = 0;
 heap32[(r7+6)] = 0;
 heap32[(r7+7)] = 1065353216;
 heap32[(r7+8)] = 0;
 heap32[(r7+9)] = 0;
 heap32[(r7+10)] = 0;
 heap32[(r7+11)] = 0;
 heap32[(r7+12)] = 1065353216;
 heap32[(r7+13)] = 0;
 heap32[(r7+14)] = 0;
 heap32[(r7+15)] = 0;
 heap32[(r7+16)] = 0;
 heap32[(r7+17)] = 0;
 heap32[(g0)] = r4;
 heap32[(g0+1)] = r6;
 _ZN11btRigidBody14setupRigidBodyERKNS_27btRigidBodyConstructionInfoE(i7);
 r0 = r3 >> 2;
 heap32[(r5+1)] = heap32[(r0)];
 heap32[(r5+2)] = heap32[(r0+1)];
 heap32[(r5+3)] = heap32[(r0+2)];
 heap32[(r5+4)] = heap32[(r0+3)];
 heap32[(r5+5)] = heap32[(r0+4)];
 heap32[(r5+6)] = heap32[(r0+5)];
 heap32[(r5+7)] = heap32[(r0+6)];
 heap32[(r5+8)] = heap32[(r0+7)];
 heap32[(r5+9)] = heap32[(r0+8)];
 heap32[(r5+10)] = heap32[(r0+9)];
 heap32[(r5+11)] = heap32[(r0+10)];
 heap32[(r5+12)] = heap32[(r0+11)];
 heap32[(r5+13)] = heap32[(r0+12)];
 heap32[(r5+14)] = heap32[(r0+13)];
 heap32[(r5+15)] = heap32[(r0+14)];
 r1 = r1 >> 2;
 heap32[(r5+16)] = heap32[(r0+15)];
 heap32[(r5+46)] = heap32[(r1+2)];
 r0 = heap32[(r1+1)];
 r1 = r0 >> 2;
 r1 = heap32[(r1)];
 r1 = r1 >> 2;
 r1 = heap32[(r1+20)];
 heap32[(g0)] = r0;
 heap32[(g0+1)] = r4;
 __FUNCTION_TABLE__[(r1)>>2](i7);
 r_g0 = r4;
 return;
}

function _ZN13BenchmarkDemoD1Ev(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
 var r1;
 var r2;
 var r3;
 var r4;
 var r5;
var __label__ = 0;
 i7 = sp + -8;var g0 = i7>>2; // save stack
 r0 = heap32[(fp)];
 r1 = _ZTV13BenchmarkDemo;
 r2 = r0 >> 2;
 r1 = (r1 + 8)|0;
 heap32[(r2)] = r1;
 heap32[(g0)] = r0;
 _ZN13BenchmarkDemo11exitPhysicsEv(i7);
 r1 = heap32[(r2+11)];
if(!(r1 ==0)) //_LBB20_4
{
 r3 = heapU8[r0+48];
if(!(r3 ==0)) //_LBB20_3
{
 r3 = gNumAlignedFree;
 r3 = r3 >> 2;
 r4 = heap32[(r3)];
 r4 = (r4 + 1)|0;
 r1 = r1 >> 2;
 heap32[(r3)] = r4;
 r1 = heap32[(r1+-1)];
 heap32[(g0)] = r1;
 free(i7);
}
 heap32[(r2+11)] = 0;
}
 r1 = 1;
 heap8[r0+48] = r1;
 heap32[(r2+11)] = 0;
 heap32[(r2+9)] = 0;
 heap32[(r2+10)] = 0;
 r3 = heap32[(r2+6)];
if(!(r3 ==0)) //_LBB20_8
{
 r4 = heapU8[r0+28];
if(!(r4 ==0)) //_LBB20_7
{
 r4 = gNumAlignedFree;
 r4 = r4 >> 2;
 r5 = heap32[(r4)];
 r5 = (r5 + 1)|0;
 r3 = r3 >> 2;
 heap32[(r4)] = r5;
 r3 = heap32[(r3+-1)];
 heap32[(g0)] = r3;
 free(i7);
}
 heap32[(r2+6)] = 0;
}
 heap8[r0+28] = r1;
 heap32[(r2+6)] = 0;
 heap32[(r2+4)] = 0;
 heap32[(r2+5)] = 0;
 return;
}

function _ZN13BenchmarkDemo20clientMoveAndDisplayEv(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
 var r1;
 var r2;
 var r3;
 var r4;
 var r5;
 var r6;
 var r7;
 var r8;
 var r9;
 var r10;
 var f0;
 var f1;
 var f2;
var __label__ = 0;
 i7 = sp + -128;var g0 = i7>>2; // save stack
 r0 = heap32[(fp)];
 r0 = r0 >> 2;
 r1 = heap32[(r0+1)];
if(!(r1 ==0)) //_LBB21_2
{
 r2 = r1 >> 2;
 r2 = heap32[(r2)];
 r2 = r2 >> 2;
 r2 = heap32[(r2+12)];
 heap32[(g0)] = r1;
 heap32[(g0+1)] = 1015580809;
 heap32[(g0+2)] = 1;
 heap32[(g0+3)] = 1015580809;
 __FUNCTION_TABLE__[(r2)>>2](i7);
 r1 = heap32[(r0+1)];
 r2 = r1 >> 2;
 r2 = heap32[(r2)];
 r2 = r2 >> 2;
 r2 = heap32[(r2+5)];
 heap32[(g0)] = r1;
 __FUNCTION_TABLE__[(r2)>>2](i7);
}
 r1 = heap32[(r0+17)];
if(!(r1 !=7)) //_LBB21_10
{
 r1 = _ZL10raycastBar;
 r2 = r1 >> 2;
 r0 = heap32[(r0+1)];
 r3 = heap32[(r2+10006)];
 heap32[(g0)] = r3;
 heap32[(g0+1)] = 0;
 r3 = 0;
 gettimeofday(i7);
_6: while(true){
 r4 = sp + -96;
 r5 = r4 >> 2;
 heap32[(r5+1)] = 1065353216;
 r6 = 1;
 heap32[(r5+2)] = 0;
 r7 = -1;
 heap16[(sp+-84)>>1] = r6;
 r6 = _ZTVN16btCollisionWorld24ClosestRayResultCallbackE;
 heap16[(sp+-82)>>1] = r7;
 r7 = (r1 + r3)|0;
 r6 = (r6 + 8)|0;
 heap32[(r5+4)] = 0;
 r8 = r7 >> 2;
 heap32[(fp+-24)] = r6;
 heap32[(r5+5)] = heap32[(r8)];
 heap32[(r5+6)] = heap32[(r8+1)];
 heap32[(r5+7)] = heap32[(r8+2)];
 heap32[(r5+8)] = heap32[(r8+3)];
 heap32[(r5+9)] = heap32[(r8+2000)];
 heap32[(r5+10)] = heap32[(r8+2001)];
 heap32[(r5+11)] = heap32[(r8+2002)];
 r9 = r0 >> 2;
 heap32[(r5+12)] = heap32[(r8+2003)];
 r9 = heap32[(r9)];
 r9 = r9 >> 2;
 r9 = heap32[(r9+7)];
 r10 = (r7 + 8000)|0;
 heap32[(g0)] = r0;
 heap32[(g0+1)] = r7;
 heap32[(g0+2)] = r10;
 heap32[(g0+3)] = r4;
 __FUNCTION_TABLE__[(r9)>>2](i7);
 r4 = heap32[(r5+2)];
 if(r4 ==0) //_LBB21_6
{
 r4 = r7 >> 2;
 r5 = r7 >> 2;
 r9 = r7 >> 2;
 r10 = r7 >> 2;
 heap32[(r4+6000)] = heap32[(r5+2000)];
 r4 = r7 >> 2;
 r5 = r7 >> 2;
 heap32[(r9+6001)] = heap32[(r10+2001)];
 r9 = r7 >> 2;
 r10 = r7 >> 2;
 heap32[(r4+6002)] = heap32[(r5+2002)];
 r4 = r7 >> 2;
 heap32[(r9+6003)] = heap32[(r10+2003)];
 r5 = r7 >> 2;
 heap32[(r4+8000)] = 1065353216;
 r4 = r7 >> 2;
 heap32[(r5+8001)] = 0;
 heap32[(r4+8002)] = 0;
 heap32[(r8+8003)] = 0;
}
else{
 r4 = r7 >> 2;
 r9 = r7 >> 2;
 heap32[(r4+6000)] = heap32[(r5+17)];
 r4 = r7 >> 2;
 heap32[(r9+6001)] = heap32[(r5+18)];
 r9 = r7 >> 2;
 heap32[(r4+6002)] = heap32[(r5+19)];
 heap32[(r9+6003)] = heap32[(r5+20)];
 f0 = heapFloat[(r5+13)];
 r4 = r7 >> 2;
 heapFloat[(r4+8000)] = f0;
 f1 = heapFloat[(r5+14)];
 r9 = r7 >> 2;
 heapFloat[(r9+8001)] = f1;
 f2 = heapFloat[(r5+15)];
 r7 = r7 >> 2;
 f0 = f0*f0;
 f1 = f1*f1;
 heapFloat[(r7+8002)] = f2;
 heap32[(r8+8003)] = heap32[(r5+16)];
 f0 = f0+f1;
 f1 = f2*f2;
 f0 = f0+f1;
 heapFloat[(g0)] = f0;
 sqrtf(i7);
 f1 =                         1;
 f0 = f1/f_g0;
 f1 = heapFloat[(r4+8000)];
 f1 = f1*f0;
 heapFloat[(r4+8000)] = f1;
 f1 = heapFloat[(r9+8001)];
 f1 = f1*f0;
 heapFloat[(r9+8001)] = f1;
 f1 = heapFloat[(r7+8002)];
 f0 = f1*f0;
 heapFloat[(r7+8002)] = f0;
}
 r3 = (r3 + 16)|0;
 heap32[(fp+-24)] = r6;
if(!(r3 !=8000)) //_LBB21_4
{
break _6;
}
}
 r0 = heap32[(r2+10001)];
 r1 = sp + -8;
 heap32[(g0)] = r1;
 heap32[(g0+1)] = 0;
 gettimeofday(i7);
 r3 = heap32[(r2+10006)];
 r3 = r3 >> 2;
 r1 = r1 >> 2;
 r4 = heap32[(fp+-2)];
 r5 = heap32[(r3)];
 r1 = heap32[(r1+1)];
 r3 = heap32[(r3+1)];
 r1 = (r1 - r3)|0;
 r3 = (r4 - r5)|0;
 r1 = (r1 / 1000)|0;
 r3 = (r3 * 1000)|0;
 r1 = (r1 + r3)|0;
 r0 = (r1 + r0)|0;
 heap32[(r2+10001)] = r0;
 r1 = heap32[(r2+10000)];
 r1 = (r1 + 1)|0;
 heap32[(r2+10000)] = r1;
if(!(r1 <51)) //_LBB21_10
{
 r3 = heap32[(r2+10004)];
 r3 = r0 < r3 ? r0 : r3;
 heap32[(r2+10004)] = r3;
 r4 = heap32[(r2+10005)];
 r4 = r0 > r4 ? r0 : r4;
 heap32[(r2+10005)] = r4;
 r5 = heap32[(r2+10002)];
 r5 = (r0 + r5)|0;
 heap32[(r2+10002)] = r5;
 r6 = heap32[(r2+10003)];
 r6 = (r6 + 1)|0;
 f0 = r5; //fitos r5, f0
 f1 = r6; //fitos r6, f1
 f0 = f0/f1;
 heap32[(r2+10003)] = r6;
 r5 = _2E_str7;
 r1 = (r1 * 500)|0;
 f0 = f0; //fstod f0, f0
 heap32[(g0)] = r5;
 heap32[(g0+1)] = r1;
 heap32[(g0+2)] = r0;
 heap32[(g0+3)] = r3;
 heap32[(g0+4)] = r4;
 llvm_writeDouble((i7+24),f0);
 printf(i7);
 heap32[(r2+10001)] = 0;
 heap32[(r2+10000)] = 0;
}
}
 return;
}

function _ZN13BenchmarkDemo10createWallERK9btVector3iS2_(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
 var r1;
 var r2;
 var r3;
 var r4;
 var r5;
 var r6;
 var r7;
 var f0;
 var f1;
 var f2;
 var f3;
 var f4;
 var f5;
 var f6;
 var f7;
 var f8;
 var f9;
var __label__ = 0;
 i7 = sp + -96;var g0 = i7>>2; // save stack
 r0 = heap32[(fp+1)];
 r1 = gNumAlignedAllocs;
 r0 = r0 >> 2;
 r1 = r1 >> 2;
 r2 = heap32[(r1)];
 f0 = heapFloat[(r0+2)];
 f1 = heapFloat[(r0+1)];
 f2 = heapFloat[(r0)];
 r2 = (r2 + 1)|0;
 heap32[(r1)] = r2;
 heap32[(g0)] = 71;
 malloc(i7);
 r1 = r_g0;
 r2 = heap32[(fp)];
 if(r1 !=0) //_LBB22_2
{
 r3 = 0;
 r4 = (r1 + 4)|0;
 r3 = (r3 - r4)|0;
 r3 = r3 & 15;
 r3 = (r1 + r3)|0;
 r4 = (r3 + 4)|0;
 r3 = r3 >> 2;
 heap32[(r3)] = r1;
 r1 = r4;
}
 r3 = r1 >> 2;
 heap32[(r3+2)] = 0;
 heap32[(r3+3)] = 1065353216;
 heap32[(r3+4)] = 1065353216;
 heap32[(r3+5)] = 1065353216;
 r4 = _ZTV10btBoxShape;
 heap32[(r3+6)] = 0;
 r4 = (r4 + 8)|0;
 heap32[(r3+11)] = 1025758986;
 heap32[(r3)] = r4;
 f3 =     -0.039999999105930328;
 f2 = f2+f3;
 heap32[(r3+1)] = 0;
 f1 = f1+f3;
 heapFloat[(r3+7)] = f2;
 f0 = f0+f3;
 heapFloat[(r3+8)] = f1;
 heapFloat[(r3+9)] = f0;
 r4 = sp + -16;
 heap32[(r3+10)] = 0;
 r3 = r4 >> 2;
 heap32[(fp+-4)] = 0;
 heap32[(r3+1)] = 0;
 heap32[(r3+2)] = 0;
 heap32[(r3+3)] = 0;
 heap32[(g0)] = r1;
 heap32[(g0+1)] = 1065353216;
 heap32[(g0+2)] = r4;
 _ZNK10btBoxShape21calculateLocalInertiaEfR9btVector3(i7);
 f4 = heapFloat[(r0+1)];
 f0 = heapFloat[(r0+2)];
 r0 = sp + -80;
 r3 = r0 >> 2;
 heap32[(fp+-20)] = 1065353216;
 heap32[(r3+1)] = 0;
 heap32[(r3+2)] = 0;
 heap32[(r3+3)] = 0;
 heap32[(r3+4)] = 0;
 heap32[(r3+5)] = 1065353216;
 heap32[(r3+6)] = 0;
 heap32[(r3+7)] = 0;
 heap32[(r3+8)] = 0;
 heap32[(r3+9)] = 0;
 heap32[(r3+10)] = 1065353216;
 heap32[(r3+11)] = 0;
 f1 = f0+f0;
 f2 =                       -12;
 heap32[(r3+12)] = 0;
 heap32[(r3+13)] = 0;
 f2 = f1*f2;
 f3 =                       0.5;
 f3 = f2*f3;
 f2 = f4+f4;
 r5 = 12;
 heap32[(r3+14)] = 0;
 heap32[(r3+15)] = 0;
_4: while(true){
if(!(r5 <1)) //_LBB22_4
{
 r4 = 0;
_8: while(true){
 r6 = r2 >> 2;
 f5 = r4; //fitos r4, f5
 f6 =                         0;
 f7 = heapFloat[(r6)];
 f8 = heapFloat[(r6+2)];
 f9 = heapFloat[(r6+1)];
 f5 = f5*f1;
 f6 = f7+f6;
 f5 = f5+f3;
 f7 = f9+f4;
 heapFloat[(r3+12)] = f6;
 f5 = f8+f5;
 heapFloat[(r3+13)] = f7;
 r6 = _ZL14benchmarkDemo4;
 heapFloat[(r3+14)] = f5;
 r7 = r6 >> 2;
 heap32[(r3+15)] = 0;
 r7 = heap32[(r7)];
 r7 = r7 >> 2;
 r7 = heap32[(r7+2)];
 heap32[(g0)] = r6;
 heap32[(g0+1)] = 1065353216;
 heap32[(g0+2)] = r0;
 heap32[(g0+3)] = r1;
 r4 = (r4 + 1)|0;
 __FUNCTION_TABLE__[(r7)>>2](i7);
 if(r5 !=r4) //_LBB22_3
{
continue _8;
}
else{
break _8;
}
}
}
 r5 = (r5 + -1)|0;
 f4 = f4+f2;
 f3 = f3+f0;
 if(r5 ==0) //_LBB22_8
{
break _4;
}
else{
continue _4;
}
}
 return;
}

function _ZN13BenchmarkDemo19createLargeMeshBodyEv(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
 var r1;
 var r2;
 var r3;
 var r4;
 var r5;
 var r6;
 var r7;
 var r8;
 var r9;
 var r10;
 var r11;
 var r12;
 var r13;
 var r14;
var __label__ = 0;
 i7 = sp + -80;var g0 = i7>>2; // save stack
 r0 = sp + -64;
 r1 = r0 >> 2;
 heap32[(fp+-16)] = 1065353216;
 heap32[(r1+1)] = 0;
 heap32[(r1+2)] = 0;
 heap32[(r1+3)] = 0;
 heap32[(r1+4)] = 0;
 heap32[(r1+5)] = 1065353216;
 heap32[(r1+6)] = 0;
 heap32[(r1+7)] = 0;
 heap32[(r1+8)] = 0;
 heap32[(r1+9)] = 0;
 heap32[(r1+10)] = 1065353216;
 heap32[(r1+11)] = 0;
 heap32[(r1+12)] = 0;
 heap32[(r1+13)] = 0;
 r2 = 0;
 heap32[(r1+14)] = 0;
 heap32[(r1+15)] = 0;
_1: while(true){
 r3 = gNumAlignedAllocs;
 r3 = r3 >> 2;
 r4 = heap32[(r3)];
 r5 = (r4 + 1)|0;
 heap32[(r3)] = r5;
 heap32[(g0)] = 103;
 malloc(i7);
 r5 = r_g0;
 if(r5 !=0) //_LBB23_3
{
 r6 = 0;
 r7 = (r5 + 4)|0;
 r6 = (r6 - r7)|0;
 r6 = r6 & 15;
 r6 = (r5 + r6)|0;
 r7 = (r6 + 4)|0;
 r6 = r6 >> 2;
 heap32[(r6)] = r5;
 r5 = r7;
}
 r6 = r5 >> 2;
 heap32[(r6+1)] = 1065353216;
 heap32[(r6+2)] = 1065353216;
 r7 = _ZTV26btTriangleIndexVertexArray;
 heap32[(r6+3)] = 1065353216;
 r7 = (r7 + 8)|0;
 heap32[(r6+4)] = 0;
 r8 = 1;
 heap32[(r6)] = r7;
 heap8[r5+36] = r8;
 heap32[(r6+8)] = 0;
 heap32[(r6+6)] = 0;
 r7 = LandscapeVtx;
 r9 = r2 << 2;
 r10 = LandscapeVtxCount;
 r11 = LandscapeIdx;
 r12 = LandscapeIdxCount;
 r7 = (r7 + r9)|0;
 r10 = (r10 + r9)|0;
 r11 = (r11 + r9)|0;
 r9 = (r12 + r9)|0;
 heap32[(r6+7)] = 0;
 r7 = r7 >> 2;
 heap32[(r6+12)] = 0;
 r10 = r10 >> 2;
 r11 = r11 >> 2;
 r9 = r9 >> 2;
 r7 = heap32[(r7)];
 r10 = heap32[(r10)];
 r11 = heap32[(r11)];
 r9 = heap32[(r9)];
 r12 = (r4 + 2)|0;
 heap32[(r3)] = r12;
 heap32[(g0)] = 51;
 malloc(i7);
 r12 = r_g0;
 r9 = (r9 / 3)|0;
 if(r12 !=0) //_LBB23_6
{
 r13 = 0;
 r14 = (r12 + 4)|0;
 r13 = (r13 - r14)|0;
 r13 = r13 & 15;
 r13 = (r12 + r13)|0;
 r14 = (r13 + 4)|0;
 r13 = r13 >> 2;
 heap32[(r13)] = r12;
 r12 = r14;
}
 heap8[r5+36] = r8;
 heap32[(r6+8)] = r12;
 heap32[(r6+7)] = 1;
 r13 = heap32[(r6+6)];
 r13 = r13 << 5;
 r12 = (r12 + r13)|0;
 r12 = r12 >> 2;
 heap32[(r12)] = r9;
 heap32[(r12+1)] = r11;
 heap32[(r12+2)] = 6;
 heap32[(r12+3)] = r10;
 heap32[(r12+4)] = r7;
 heap32[(r12+5)] = 12;
 heap32[(r12+6)] = 3;
 heap32[(r12+7)] = 0;
 r7 = heap32[(r6+6)];
 r9 = (r7 + 1)|0;
 heap32[(r6+6)] = r9;
 r7 = r7 << 5;
 r9 = heap32[(r6+8)];
 r7 = (r9 + r7)|0;
 r7 = r7 >> 2;
 r4 = (r4 + 3)|0;
 heap32[(r7+6)] = 3;
 heap32[(r3)] = r4;
 heap32[(g0)] = 95;
 malloc(i7);
 r3 = r_g0;
 if(r3 !=0) //_LBB23_9
{
 r4 = 0;
 r7 = (r3 + 4)|0;
 r4 = (r4 - r7)|0;
 r4 = r4 & 15;
 r4 = (r3 + r4)|0;
 r7 = (r4 + 4)|0;
 r4 = r4 >> 2;
 heap32[(r4)] = r3;
 r3 = r7;
}
 r4 = r3 >> 2;
 r7 = _ZTV19btTriangleMeshShape;
 heap32[(r4+2)] = 0;
 r7 = (r7 + 8)|0;
 heap32[(r4+3)] = 0;
 heap32[(r4)] = r7;
 heap32[(r4+12)] = r5;
 heap32[(r4+1)] = 21;
 r7 = heap32[(r6)];
 r7 = r7 >> 2;
 r7 = heap32[(r7+10)];
 heap32[(g0)] = r5;
 __FUNCTION_TABLE__[(r7)>>2](i7);
 r7 = r_g0;
 if(r7 ==0) //_LBB23_12
{
 heap32[(g0)] = r3;
 _ZN19btTriangleMeshShape15recalcLocalAabbEv(i7);
}
else{
 r6 = heap32[(r6)];
 r6 = r6 >> 2;
 r6 = heap32[(r6+12)];
 r7 = (r3 + 16)|0;
 r9 = (r3 + 32)|0;
 heap32[(g0)] = r5;
 heap32[(g0+1)] = r7;
 heap32[(g0+2)] = r9;
 __FUNCTION_TABLE__[(r6)>>2](i7);
}
 r5 = _ZTV22btBvhTriangleMeshShape;
 r5 = (r5 + 8)|0;
 heap32[(r4)] = r5;
 heap32[(r4+13)] = 0;
 heap32[(r4+14)] = 0;
 r5 = 0;
 heap8[r3+60] = r8;
 heap8[r3+61] = r5;
 heap32[(r4+1)] = 21;
 heap32[(g0)] = r3;
 _ZN22btBvhTriangleMeshShape17buildOptimizedBvhEv(i7);
 heap32[(r1+12)] = 0;
 heap32[(r1+13)] = -1043857408;
 r4 = _ZL14benchmarkDemo4;
 heap32[(r1+14)] = 0;
 r5 = r4 >> 2;
 heap32[(r1+15)] = 0;
 r5 = heap32[(r5)];
 r5 = r5 >> 2;
 r5 = heap32[(r5+2)];
 heap32[(g0)] = r4;
 heap32[(g0+1)] = 0;
 heap32[(g0+2)] = r0;
 heap32[(g0+3)] = r3;
 __FUNCTION_TABLE__[(r5)>>2](i7);
 r2 = (r2 + 1)|0;
 r3 = r_g0 >> 2;
 heap32[(r3+56)] = 1063675494;
 if(r2 !=8) //_LBB23_1
{
continue _1;
}
else{
break _1;
}
}
 return;
}

function _ZN13BenchmarkDemo11createTest6Ev(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
 var r1;
 var r2;
 var r3;
 var r4;
 var r5;
 var r6;
 var r7;
 var r8;
 var f0;
 var f1;
 var f2;
 var f3;
 var f4;
 var f5;
 var f6;
 var f7;
 var f8;
 var f9;
var __label__ = 0;
 i7 = sp + -112;var g0 = i7>>2; // save stack
 r0 = gNumAlignedAllocs;
 r0 = r0 >> 2;
 r1 = heap32[(r0)];
 r1 = (r1 + 1)|0;
 heap32[(r0)] = r1;
 heap32[(g0)] = 127;
 malloc(i7);
 r0 = r_g0;
 if(r0 !=0) //_LBB24_2
{
 r1 = 0;
 r2 = (r0 + 4)|0;
 r1 = (r1 - r2)|0;
 r1 = r1 & 15;
 r1 = (r0 + r1)|0;
 r2 = (r1 + 4)|0;
 r1 = r1 >> 2;
 heap32[(r1)] = r0;
 r0 = r2;
}
 heap32[(g0)] = r0;
 heap32[(g0+1)] = 0;
 heap32[(g0+2)] = 0;
 r1 = 0;
 _ZN17btConvexHullShapeC1EPKfii(i7);
_4: while(true){
 r2 = (r1 * -3)|0;
 r3 = _ZL7TaruVtx;
 r2 = r2 << 2;
 r2 = (r3 + r2)|0;
 r3 = sp + -96;
 r2 = r2 >> 2;
 r4 = r3 >> 2;
 heap32[(fp+-24)] = heap32[(r2)];
 heap32[(r4+1)] = heap32[(r2+1)];
 heap32[(r4+2)] = heap32[(r2+2)];
 heap32[(r4+3)] = 0;
 heap32[(g0)] = r0;
 heap32[(g0+1)] = r3;
 r1 = (r1 + -1)|0;
 _ZN17btConvexHullShape8addPointERK9btVector3(i7);
 if(r1 ==-43) //_LBB24_10
{
break _4;
}
else{
continue _4;
}
}
 r1 = sp + -64;
 r2 = r1 >> 2;
 heap32[(fp+-16)] = 1065353216;
 heap32[(r2+1)] = 0;
 heap32[(r2+2)] = 0;
 heap32[(r2+3)] = 0;
 heap32[(r2+4)] = 0;
 heap32[(r2+5)] = 1065353216;
 heap32[(r2+6)] = 0;
 heap32[(r2+7)] = 0;
 heap32[(r2+8)] = 0;
 heap32[(r2+9)] = 0;
 heap32[(r2+10)] = 1065353216;
 heap32[(r2+11)] = 0;
 heap32[(r2+12)] = 0;
 heap32[(r2+13)] = 0;
 heap32[(r2+14)] = 0;
 r3 = sp + -80;
 heap32[(r2+15)] = 0;
 r4 = r3 >> 2;
 heap32[(fp+-20)] = 0;
 heap32[(r4+1)] = 0;
 heap32[(r4+2)] = 0;
 r5 = r0 >> 2;
 heap32[(r4+3)] = 0;
 r4 = heap32[(r5)];
 r4 = r4 >> 2;
 r4 = heap32[(r4+8)];
 heap32[(g0)] = r0;
 heap32[(g0+1)] = 1065353216;
 heap32[(g0+2)] = r3;
 r3 = 10;
 f0 =                        20;
 f1 =                         2;
 f2 =                       -25;
 __FUNCTION_TABLE__[(r4)>>2](i7);
 r7 = _ZL14benchmarkDemo4;
_7: while(true){
 f3 =                         3;
 f4 =                        25;
 f5 = f1+f3;
 f4 = f0+f4;
 r4 = 0;
 r5 = r4;
_9: while(true){
 f6 = r5; //fitos r5, f6
 f6 = f6*f5;
 f6 = f6+f2;
 f7 =                         5;
 f6 = f6*f7;
 f8 =                         0;
 f6 = f6+f8;
 r6 = r4;
_11: while(true){
 f9 = r6; //fitos r6, f9
 f9 = f9*f5;
 f9 = f9+f2;
 f9 = f9*f7;
 f9 = f9+f8;
 heapFloat[(r2+12)] = f9;
 heapFloat[(r2+13)] = f4;
 heapFloat[(r2+14)] = f6;
 r8 = r7 >> 2;
 heap32[(r2+15)] = 0;
 r8 = heap32[(r8)];
 r8 = r8 >> 2;
 r8 = heap32[(r8+2)];
 heap32[(g0)] = r7;
 heap32[(g0+1)] = 1065353216;
 heap32[(g0+2)] = r1;
 heap32[(g0+3)] = r0;
 r6 = (r6 + 1)|0;
 __FUNCTION_TABLE__[(r8)>>2](i7);
 if(r6 !=10) //_LBB24_7
{
continue _11;
}
else{
break _11;
}
}
 r5 = (r5 + 1)|0;
 if(r5 !=10) //_LBB24_6
{
continue _9;
}
else{
break _9;
}
}
 f4 =        1.1000000238418579;
 f5 =      -0.05000000074505806;
 f4 = f1*f4;
 f1 = f1*f5;
 f5 =                         9;
 f3 = f4+f3;
 f1 = f1*f5;
 r3 = (r3 + -1)|0;
 f0 = f0+f3;
 f2 = f1+f2;
 f1 = f4;
 if(r3 ==0) //_LBB24_11
{
break _7;
}
else{
continue _7;
}
}
 _ZN13BenchmarkDemo19createLargeMeshBodyEv(i7);
 return;
}

function _ZN7RagDoll20localCreateRigidBodyEfRK11btTransformP16btCollisionShape(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
 var r1;
 var r2;
 var r3;
 var r4;
 var r5;
 var r6;
var __label__ = 0;
 i7 = sp + -168;var g0 = i7>>2; // save stack
 r0 = sp + -16;
 r1 = r0 >> 2;
 heap32[(fp+-4)] = 0;
 heap32[(r1+1)] = 0;
 r2 = heap32[(fp+2)];
 heap32[(r1+2)] = 0;
 r3 = r2 >> 2;
 heap32[(r1+3)] = 0;
 r3 = heap32[(r3)];
 r3 = r3 >> 2;
 r3 = heap32[(r3+8)];
 heap32[(g0)] = r2;
 heap32[(g0+1)] = 1065353216;
 heap32[(g0+2)] = r0;
 r0 = _ZGVZN11btTransform11getIdentityEvE17identityTransform;
 __FUNCTION_TABLE__[(r3)>>2](i7);
 r3 = heapU8[r0];
if(!(r3 !=0)) //_LBB25_4
{
 r3 = _ZGVZN11btMatrix3x311getIdentityEvE14identityMatrix;
 r4 = heapU8[r3];
if(!(r4 !=0)) //_LBB25_3
{
 r4 = _ZZN11btMatrix3x311getIdentityEvE14identityMatrix_2E_0_2E_0_2E_0_2E_0;
 r5 = _ZZN11btMatrix3x311getIdentityEvE14identityMatrix_2E_0_2E_1_2E_0_2E_1;
 r4 = r4 >> 2;
 r6 = _ZZN11btMatrix3x311getIdentityEvE14identityMatrix_2E_0_2E_2_2E_0_2E_2;
 r5 = r5 >> 2;
 heap32[(r4)] = 1065353216;
 r4 = r6 >> 2;
 heap32[(r5)] = 1065353216;
 r5 = 1;
 heap32[(r4)] = 1065353216;
 heap8[r3] = r5;
}
 r3 = _ZZN11btTransform11getIdentityEvE17identityTransform;
 r4 = _ZZN11btMatrix3x311getIdentityEvE14identityMatrix_2E_0_2E_0_2E_0_2E_0;
 r3 = r3 >> 2;
 r4 = r4 >> 2;
 heap32[(r3)] = heap32[(r4)];
 heap32[(r3+1)] = 0;
 heap32[(r3+2)] = 0;
 r4 = _ZZN11btMatrix3x311getIdentityEvE14identityMatrix_2E_0_2E_1_2E_0_2E_1;
 heap32[(r3+3)] = 0;
 r4 = r4 >> 2;
 heap32[(r3+4)] = 0;
 heap32[(r3+5)] = heap32[(r4)];
 heap32[(r3+6)] = 0;
 heap32[(r3+7)] = 0;
 r4 = _ZZN11btMatrix3x311getIdentityEvE14identityMatrix_2E_0_2E_2_2E_0_2E_2;
 heap32[(r3+8)] = 0;
 r4 = r4 >> 2;
 heap32[(r3+9)] = 0;
 heap32[(r3+10)] = heap32[(r4)];
 heap32[(r3+11)] = 0;
 heap32[(r3+12)] = 0;
 heap32[(r3+13)] = 0;
 heap32[(r3+14)] = 0;
 r4 = 1;
 heap32[(r3+15)] = 0;
 heap8[r0] = r4;
}
 r0 = heap32[(fp)];
 r3 = heap32[(fp+1)];
 heap32[(g0)] = 200;
 r4 = _ZTV20btDefaultMotionState;
 _Znwj(i7);
 r6 = r_g0 >> 2;
 r4 = (r4 + 8)|0;
 r3 = r3 >> 2;
 heap32[(r6)] = r4;
 heap32[(r6+1)] = heap32[(r3)];
 heap32[(r6+2)] = heap32[(r3+1)];
 heap32[(r6+3)] = heap32[(r3+2)];
 heap32[(r6+4)] = heap32[(r3+3)];
 heap32[(r6+5)] = heap32[(r3+4)];
 heap32[(r6+6)] = heap32[(r3+5)];
 heap32[(r6+7)] = heap32[(r3+6)];
 heap32[(r6+8)] = heap32[(r3+7)];
 heap32[(r6+9)] = heap32[(r3+8)];
 heap32[(r6+10)] = heap32[(r3+9)];
 heap32[(r6+11)] = heap32[(r3+10)];
 heap32[(r6+12)] = heap32[(r3+11)];
 heap32[(r6+13)] = heap32[(r3+12)];
 heap32[(r6+14)] = heap32[(r3+13)];
 r4 = _ZZN11btTransform11getIdentityEvE17identityTransform;
 heap32[(r6+15)] = heap32[(r3+14)];
 r4 = r4 >> 2;
 heap32[(r6+16)] = heap32[(r3+15)];
 heap32[(r6+17)] = heap32[(r4)];
 heap32[(r6+18)] = heap32[(r4+1)];
 heap32[(r6+19)] = heap32[(r4+2)];
 heap32[(r6+20)] = heap32[(r4+3)];
 heap32[(r6+21)] = heap32[(r4+4)];
 heap32[(r6+22)] = heap32[(r4+5)];
 heap32[(r6+23)] = heap32[(r4+6)];
 heap32[(r6+24)] = heap32[(r4+7)];
 heap32[(r6+25)] = heap32[(r4+8)];
 heap32[(r6+26)] = heap32[(r4+9)];
 heap32[(r6+27)] = heap32[(r4+10)];
 heap32[(r6+28)] = heap32[(r4+11)];
 heap32[(r6+29)] = heap32[(r4+12)];
 heap32[(r6+30)] = heap32[(r4+13)];
 heap32[(r6+31)] = heap32[(r4+14)];
 heap32[(r6+32)] = heap32[(r4+15)];
 heap32[(r6+33)] = heap32[(r3)];
 heap32[(r6+34)] = heap32[(r3+1)];
 heap32[(r6+35)] = heap32[(r3+2)];
 heap32[(r6+36)] = heap32[(r3+3)];
 heap32[(r6+37)] = heap32[(r3+4)];
 heap32[(r6+38)] = heap32[(r3+5)];
 heap32[(r6+39)] = heap32[(r3+6)];
 heap32[(r6+40)] = heap32[(r3+7)];
 heap32[(r6+41)] = heap32[(r3+8)];
 heap32[(r6+42)] = heap32[(r3+9)];
 heap32[(r6+43)] = heap32[(r3+10)];
 heap32[(r6+44)] = heap32[(r3+11)];
 heap32[(r6+45)] = heap32[(r3+12)];
 heap32[(r6+46)] = heap32[(r3+13)];
 heap32[(r6+47)] = heap32[(r3+14)];
 heap32[(r6+48)] = heap32[(r3+15)];
 r3 = sp + -152;
 heap32[(r6+49)] = 0;
 r4 = r3 >> 2;
 heap32[(fp+-38)] = 1065353216;
 heap32[(r4+1)] = r_g0;
 heap32[(r4+18)] = r2;
 heap32[(r4+19)] = heap32[(fp+-4)];
 heap32[(r4+20)] = heap32[(r1+1)];
 heap32[(r4+21)] = heap32[(r1+2)];
 heap32[(r4+22)] = heap32[(r1+3)];
 heap32[(r4+23)] = 0;
 heap32[(r4+24)] = 0;
 heap32[(r4+25)] = 1056964608;
 heap32[(r4+26)] = 0;
 heap32[(r4+27)] = 1061997773;
 r1 = 0;
 heap32[(r4+28)] = 1065353216;
 heap8[sp+-36] = r1;
 heap32[(r4+30)] = 1000593162;
 heap32[(r4+31)] = 1008981770;
 heap32[(r4+32)] = 1008981770;
 heap32[(r4+33)] = 1008981770;
 heap32[(r4+2)] = 1065353216;
 heap32[(r4+3)] = 0;
 heap32[(r4+4)] = 0;
 heap32[(r4+5)] = 0;
 heap32[(r4+6)] = 0;
 heap32[(r4+7)] = 1065353216;
 heap32[(r4+8)] = 0;
 heap32[(r4+9)] = 0;
 heap32[(r4+10)] = 0;
 heap32[(r4+11)] = 0;
 heap32[(r4+12)] = 1065353216;
 heap32[(r4+13)] = 0;
 heap32[(r4+14)] = 0;
 heap32[(r4+15)] = 0;
 r2 = gNumAlignedAllocs;
 heap32[(r4+16)] = 0;
 r2 = r2 >> 2;
 heap32[(r4+17)] = 0;
 r4 = heap32[(r2)];
 r4 = (r4 + 1)|0;
 heap32[(r2)] = r4;
 heap32[(g0)] = 627;
 malloc(i7);
 r2 = r_g0;
 if(r2 !=0) //_LBB25_6
{
 r4 = (r2 + 4)|0;
 r1 = (r1 - r4)|0;
 r1 = r1 & 15;
 r1 = (r2 + r1)|0;
 r4 = (r1 + 4)|0;
 r1 = r1 >> 2;
 heap32[(r1)] = r2;
 r2 = r4;
}
 r1 = r2 >> 2;
 heap32[(r1+41)] = 1065353216;
 heap32[(r1+42)] = 1065353216;
 heap32[(r1+43)] = 1065353216;
 heap32[(r1+44)] = 0;
 heap32[(r1+45)] = 0;
 heap32[(r1+46)] = 1566444395;
 heap32[(r1+47)] = 0;
 heap32[(r1+48)] = 0;
 heap32[(r1+49)] = 0;
 heap32[(r1+50)] = 0;
 heap32[(r1+51)] = 1;
 heap32[(r1+52)] = -1;
 heap32[(r1+53)] = -1;
 heap32[(r1+54)] = 1;
 heap32[(r1+55)] = 0;
 heap32[(r1+56)] = 1056964608;
 heap32[(r1+57)] = 0;
 heap32[(r1+58)] = 1;
 heap32[(r1+59)] = 0;
 heap32[(r1+60)] = 1065353216;
 heap32[(r1+61)] = 0;
 heap32[(r1+62)] = 0;
 heap32[(r1+63)] = 0;
 heap32[(r1+1)] = 1065353216;
 heap32[(r1+2)] = 0;
 heap32[(r1+3)] = 0;
 heap32[(r1+4)] = 0;
 heap32[(r1+5)] = 0;
 heap32[(r1+6)] = 1065353216;
 heap32[(r1+7)] = 0;
 heap32[(r1+8)] = 0;
 heap32[(r1+9)] = 0;
 heap32[(r1+10)] = 0;
 heap32[(r1+11)] = 1065353216;
 heap32[(r1+12)] = 0;
 heap32[(r1+13)] = 0;
 heap32[(r1+14)] = 0;
 r4 = _ZTV11btRigidBody;
 heap32[(r1+15)] = 0;
 r4 = (r4 + 8)|0;
 heap32[(r1+16)] = 0;
 r5 = 1;
 heap32[(r1)] = r4;
 heap8[r2+492] = r5;
 heap32[(r1+122)] = 0;
 heap32[(r1+120)] = 0;
 heap32[(r1+121)] = 0;
 heap32[(g0)] = r2;
 heap32[(g0+1)] = r3;
 _ZN11btRigidBody14setupRigidBodyERKNS_27btRigidBodyConstructionInfoE(i7);
 r0 = r0 >> 2;
 r0 = heap32[(r0+1)];
 r1 = r0 >> 2;
 r1 = heap32[(r1)];
 r1 = r1 >> 2;
 r1 = heap32[(r1+20)];
 heap32[(g0)] = r0;
 heap32[(g0+1)] = r2;
 __FUNCTION_TABLE__[(r1)>>2](i7);
 r_g0 = r2;
 return;
}

function _ZN13BenchmarkDemo11initPhysicsEv(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
 var r1;
 var r2;
 var r3;
 var r4;
 var r5;
 var r6;
 var r7;
 var r8;
 var r9;
 var r10;
 var r11;
 var r12;
 var r13;
 var r14;
 var r15;
 var f0;
 var f1;
 var f2;
 var f3;
 var f4;
 var f5;
 var f6;
 var f7;
 var f8;
 var f9;
 var f10;
 var f11;
 var f12;
 var f13;
 var f14;
 var f15;
 var f16;
 var f17;
 var f18;
 var f19;
 var f20;
 var f21;
var __label__ = 0;
 i7 = sp + -41432;var g0 = i7>>2; // save stack
 heap32[(g0)] = 88;
 _Znwj(i7);
 r0 = r_g0;
 r1 = _ZTV31btDefaultCollisionConfiguration;
 r2 = gNumAlignedAllocs;
 r3 = r0 >> 2;
 r1 = (r1 + 8)|0;
 r2 = r2 >> 2;
 heap32[(r3)] = r1;
 r1 = heap32[(r2)];
 r3 = (r1 + 1)|0;
 heap32[(r2)] = r3;
 heap32[(g0)] = 379;
 malloc(i7);
 r3 = r_g0;
 if(r3 !=0) //_LBB26_2
{
 r4 = 0;
 r5 = (r3 + 4)|0;
 r4 = (r4 - r5)|0;
 r4 = r4 & 15;
 r4 = (r3 + r4)|0;
 r5 = (r4 + 4)|0;
 r4 = r4 >> 2;
 heap32[(r4)] = r3;
 r3 = r5;
}
 r4 = r3 >> 2;
 heap32[(r4+77)] = 953267991;
 r4 = heapU8[r3+332];
 r4 = r4 & 240;
 r5 = r0 >> 2;
 heap8[r3+332] = r4;
 r4 = (r1 + 2)|0;
 heap32[(r5+8)] = r3;
 heap32[(r2)] = r4;
 heap32[(g0)] = 23;
 malloc(i7);
 r3 = r_g0;
 if(r3 !=0) //_LBB26_5
{
 r4 = 0;
 r6 = (r3 + 4)|0;
 r4 = (r4 - r6)|0;
 r4 = r4 & 15;
 r4 = (r3 + r4)|0;
 r6 = (r4 + 4)|0;
 r4 = r4 >> 2;
 heap32[(r4)] = r3;
 r3 = r6;
}
 r4 = _ZTV30btGjkEpaPenetrationDepthSolver;
 r6 = r3 >> 2;
 r4 = (r4 + 8)|0;
 heap32[(r6)] = r4;
 r4 = (r1 + 3)|0;
 heap32[(r5+9)] = r3;
 heap32[(r2)] = r4;
 heap32[(g0)] = 43;
 malloc(i7);
 r4 = r_g0;
 if(r4 !=0) //_LBB26_8
{
 r3 = 0;
 r6 = (r4 + 4)|0;
 r3 = (r3 - r6)|0;
 r3 = r3 & 15;
 r3 = (r4 + r3)|0;
 r6 = r3 >> 2;
 heap32[(r6)] = r4;
 r4 = (r3 + 4)|0;
 r3 = heap32[(r5+9)];
}
 r6 = _ZTVN23btConvexConvexAlgorithm10CreateFuncE;
 r7 = heap32[(r5+8)];
 r8 = 0;
 r9 = r4 >> 2;
 r6 = (r6 + 8)|0;
 heap8[r4+4] = r8;
 heap32[(r9)] = r6;
 heap32[(r9+4)] = 0;
 heap32[(r9+5)] = 3;
 heap32[(r9+3)] = r7;
 heap32[(r9+2)] = r3;
 r3 = (r1 + 4)|0;
 heap32[(r5+10)] = r4;
 heap32[(r2)] = r3;
 heap32[(g0)] = 27;
 malloc(i7);
 r3 = r_g0;
 if(r3 !=0) //_LBB26_11
{
 r4 = (r3 + 4)|0;
 r4 = (r8 - r4)|0;
 r4 = r4 & 15;
 r4 = (r3 + r4)|0;
 r6 = (r4 + 4)|0;
 r4 = r4 >> 2;
 heap32[(r4)] = r3;
 r3 = r6;
}
 r4 = _ZTVN33btConvexConcaveCollisionAlgorithm10CreateFuncE;
 r6 = r3 >> 2;
 r4 = (r4 + 8)|0;
 heap8[r3+4] = r8;
 heap32[(r6)] = r4;
 r4 = (r1 + 5)|0;
 heap32[(r5+11)] = r3;
 heap32[(r2)] = r4;
 heap32[(g0)] = 27;
 malloc(i7);
 r3 = r_g0;
 if(r3 !=0) //_LBB26_14
{
 r4 = (r3 + 4)|0;
 r4 = (r8 - r4)|0;
 r4 = r4 & 15;
 r4 = (r3 + r4)|0;
 r6 = (r4 + 4)|0;
 r4 = r4 >> 2;
 heap32[(r4)] = r3;
 r3 = r6;
}
 r4 = _ZTVN33btConvexConcaveCollisionAlgorithm17SwappedCreateFuncE;
 r6 = r3 >> 2;
 r4 = (r4 + 8)|0;
 heap8[r3+4] = r8;
 heap32[(r6)] = r4;
 r4 = (r1 + 6)|0;
 heap32[(r5+12)] = r3;
 heap32[(r2)] = r4;
 heap32[(g0)] = 27;
 malloc(i7);
 r3 = r_g0;
 if(r3 !=0) //_LBB26_17
{
 r4 = (r3 + 4)|0;
 r4 = (r8 - r4)|0;
 r4 = r4 & 15;
 r4 = (r3 + r4)|0;
 r6 = (r4 + 4)|0;
 r4 = r4 >> 2;
 heap32[(r4)] = r3;
 r3 = r6;
}
 r4 = _ZTVN28btCompoundCollisionAlgorithm10CreateFuncE;
 r6 = r3 >> 2;
 r4 = (r4 + 8)|0;
 heap8[r3+4] = r8;
 heap32[(r6)] = r4;
 r4 = (r1 + 7)|0;
 heap32[(r5+13)] = r3;
 heap32[(r2)] = r4;
 heap32[(g0)] = 27;
 malloc(i7);
 r3 = r_g0;
 if(r3 !=0) //_LBB26_20
{
 r4 = (r3 + 4)|0;
 r4 = (r8 - r4)|0;
 r4 = r4 & 15;
 r4 = (r3 + r4)|0;
 r6 = (r4 + 4)|0;
 r4 = r4 >> 2;
 heap32[(r4)] = r3;
 r3 = r6;
}
 r4 = _ZTVN28btCompoundCollisionAlgorithm17SwappedCreateFuncE;
 r6 = r3 >> 2;
 r4 = (r4 + 8)|0;
 heap8[r3+4] = r8;
 heap32[(r6)] = r4;
 r4 = (r1 + 8)|0;
 heap32[(r5+14)] = r3;
 heap32[(r2)] = r4;
 heap32[(g0)] = 27;
 malloc(i7);
 r3 = r_g0;
 if(r3 !=0) //_LBB26_23
{
 r4 = (r3 + 4)|0;
 r4 = (r8 - r4)|0;
 r4 = r4 & 15;
 r4 = (r3 + r4)|0;
 r6 = (r4 + 4)|0;
 r4 = r4 >> 2;
 heap32[(r4)] = r3;
 r3 = r6;
}
 r4 = _ZTVN16btEmptyAlgorithm10CreateFuncE;
 r6 = r3 >> 2;
 r4 = (r4 + 8)|0;
 heap8[r3+4] = r8;
 heap32[(r6)] = r4;
 r4 = (r1 + 9)|0;
 heap32[(r5+15)] = r3;
 heap32[(r2)] = r4;
 heap32[(g0)] = 27;
 malloc(i7);
 r3 = r_g0;
 if(r3 !=0) //_LBB26_26
{
 r4 = (r3 + 4)|0;
 r4 = (r8 - r4)|0;
 r4 = r4 & 15;
 r4 = (r3 + r4)|0;
 r6 = (r4 + 4)|0;
 r4 = r4 >> 2;
 heap32[(r4)] = r3;
 r3 = r6;
}
 r4 = _ZTVN32btSphereSphereCollisionAlgorithm10CreateFuncE;
 r6 = r3 >> 2;
 r4 = (r4 + 8)|0;
 heap8[r3+4] = r8;
 heap32[(r6)] = r4;
 r4 = (r1 + 10)|0;
 heap32[(r5+16)] = r3;
 heap32[(r2)] = r4;
 heap32[(g0)] = 27;
 malloc(i7);
 r3 = r_g0;
 if(r3 !=0) //_LBB26_29
{
 r4 = (r3 + 4)|0;
 r4 = (r8 - r4)|0;
 r4 = r4 & 15;
 r4 = (r3 + r4)|0;
 r6 = (r4 + 4)|0;
 r4 = r4 >> 2;
 heap32[(r4)] = r3;
 r3 = r6;
}
 r4 = _ZTVN34btSphereTriangleCollisionAlgorithm10CreateFuncE;
 r6 = r3 >> 2;
 r4 = (r4 + 8)|0;
 heap8[r3+4] = r8;
 heap32[(r6)] = r4;
 r6 = (r1 + 11)|0;
 heap32[(r5+18)] = r3;
 heap32[(r2)] = r6;
 heap32[(g0)] = 27;
 malloc(i7);
 r3 = r_g0;
 if(r3 !=0) //_LBB26_32
{
 r6 = (r3 + 4)|0;
 r6 = (r8 - r6)|0;
 r6 = r6 & 15;
 r6 = (r3 + r6)|0;
 r7 = (r6 + 4)|0;
 r6 = r6 >> 2;
 heap32[(r6)] = r3;
 r3 = r7;
}
 r6 = r3 >> 2;
 heap8[r3+4] = r8;
 heap32[(r6)] = r4;
 r4 = 1;
 heap32[(r5+19)] = r3;
 r6 = (r1 + 12)|0;
 heap8[r3+4] = r4;
 heap32[(r2)] = r6;
 heap32[(g0)] = 27;
 malloc(i7);
 r3 = r_g0;
 if(r3 !=0) //_LBB26_35
{
 r6 = (r3 + 4)|0;
 r6 = (r8 - r6)|0;
 r6 = r6 & 15;
 r6 = (r3 + r6)|0;
 r7 = (r6 + 4)|0;
 r6 = r6 >> 2;
 heap32[(r6)] = r3;
 r3 = r7;
}
 r6 = _ZTVN26btBoxBoxCollisionAlgorithm10CreateFuncE;
 r7 = r3 >> 2;
 r6 = (r6 + 8)|0;
 heap8[r3+4] = r8;
 heap32[(r7)] = r6;
 r6 = (r1 + 13)|0;
 heap32[(r5+17)] = r3;
 heap32[(r2)] = r6;
 heap32[(g0)] = 35;
 malloc(i7);
 r3 = r_g0;
 if(r3 !=0) //_LBB26_38
{
 r6 = (r3 + 4)|0;
 r6 = (r8 - r6)|0;
 r6 = r6 & 15;
 r6 = (r3 + r6)|0;
 r7 = (r6 + 4)|0;
 r6 = r6 >> 2;
 heap32[(r6)] = r3;
 r3 = r7;
}
 r6 = _ZTVN31btConvexPlaneCollisionAlgorithm10CreateFuncE;
 r7 = r3 >> 2;
 r6 = (r6 + 8)|0;
 heap8[r3+4] = r8;
 heap32[(r7)] = r6;
 heap32[(r7+2)] = 1;
 heap32[(r7+3)] = 1;
 r7 = (r1 + 14)|0;
 heap32[(r5+21)] = r3;
 heap32[(r2)] = r7;
 heap32[(g0)] = 35;
 malloc(i7);
 r3 = r_g0;
 if(r3 !=0) //_LBB26_41
{
 r7 = (r3 + 4)|0;
 r7 = (r8 - r7)|0;
 r7 = r7 & 15;
 r7 = (r3 + r7)|0;
 r9 = (r7 + 4)|0;
 r7 = r7 >> 2;
 heap32[(r7)] = r3;
 r3 = r9;
}
 r7 = r3 >> 2;
 heap8[r3+4] = r8;
 heap32[(r7)] = r6;
 heap32[(r7+2)] = 1;
 heap32[(r7+3)] = 1;
 heap32[(r5+20)] = r3;
 heap8[r3+4] = r4;
 r3 = (r1 + 15)|0;
 heap8[r0+12] = r4;
 heap32[(r2)] = r3;
 heap32[(g0)] = 39;
 malloc(i7);
 r3 = r_g0;
 if(r3 !=0) //_LBB26_44
{
 r6 = (r3 + 4)|0;
 r6 = (r8 - r6)|0;
 r6 = r6 & 15;
 r6 = (r3 + r6)|0;
 r7 = (r6 + 4)|0;
 r6 = r6 >> 2;
 heap32[(r6)] = r3;
 r3 = r7;
}
 r6 = r3 >> 2;
 heap32[(r6+1)] = 0;
 heap32[(r6+3)] = 0;
 heap8[r3+16] = r8;
 heap32[(r6)] = 0;
 r7 = (r1 + 16)|0;
 heap32[(r6+2)] = 0;
 heap32[(r2)] = r7;
 heap32[(g0)] = 19;
 malloc(i7);
 r7 = r_g0;
 if(r7 !=0) //_LBB26_47
{
 r9 = (r7 + 4)|0;
 r9 = (r8 - r9)|0;
 r9 = r9 & 15;
 r9 = (r7 + r9)|0;
 r10 = (r9 + 4)|0;
 r9 = r9 >> 2;
 heap32[(r9)] = r7;
 r7 = r10;
}
 heap32[(r6)] = r7;
 heap32[(r6+1)] = 0;
 heap32[(r5+2)] = r3;
 r3 = (r1 + 17)|0;
 heap8[r0+20] = r4;
 heap32[(r2)] = r3;
 heap32[(g0)] = 39;
 malloc(i7);
 r3 = r_g0;
 if(r3 !=0) //_LBB26_50
{
 r6 = (r3 + 4)|0;
 r6 = (r8 - r6)|0;
 r6 = r6 & 15;
 r6 = (r3 + r6)|0;
 r7 = (r6 + 4)|0;
 r6 = r6 >> 2;
 heap32[(r6)] = r3;
 r3 = r7;
}
 r6 = r3 >> 2;
 heap32[(r6)] = 1140;
 r7 = (r1 + 18)|0;
 heap32[(r6+1)] = 4096;
 heap32[(r2)] = r7;
 heap32[(g0)] = 4669459;
 malloc(i7);
 r7 = r_g0;
 if(r7 !=0) //_LBB26_53
{
 r9 = (r7 + 4)|0;
 r9 = (r8 - r9)|0;
 r9 = r9 & 15;
 r9 = (r7 + r9)|0;
 r10 = (r9 + 4)|0;
 r9 = r9 >> 2;
 heap32[(r9)] = r7;
 r7 = r10;
}
 heap32[(r6+4)] = r7;
 r9 = 4095;
 r10 = 1140;
 heap32[(r6+3)] = r7;
 heap32[(r6+2)] = 4096;
 r11 = r7;
_55: while(true){
 r7 = r7 >> 2;
 r10 = (r11 + r10)|0;
 heap32[(r7)] = r10;
 r10 = heap32[(r6)];
 r7 = (r11 + r10)|0;
 r9 = (r9 + -1)|0;
 r11 = r7;
 if(r9 !=0) //_LBB26_55
{
continue _55;
}
else{
break _55;
}
}
 r6 = r7 >> 2;
 heap32[(r6)] = 0;
 heap32[(r5+4)] = r3;
 r3 = (r1 + 19)|0;
 heap8[r0+28] = r4;
 heap32[(r2)] = r3;
 heap32[(g0)] = 39;
 malloc(i7);
 r3 = r_g0;
 if(r3 !=0) //_LBB26_58
{
 r6 = (r3 + 4)|0;
 r6 = (r8 - r6)|0;
 r6 = r6 & 15;
 r6 = (r3 + r6)|0;
 r7 = (r6 + 4)|0;
 r6 = r6 >> 2;
 heap32[(r6)] = r3;
 r3 = r7;
}
 r6 = r3 >> 2;
 heap32[(r6)] = 80;
 r1 = (r1 + 20)|0;
 heap32[(r6+1)] = 4096;
 heap32[(r2)] = r1;
 heap32[(g0)] = 327699;
 malloc(i7);
 r1 = r_g0;
 if(r1 !=0) //_LBB26_61
{
 r7 = (r1 + 4)|0;
 r7 = (r8 - r7)|0;
 r7 = r7 & 15;
 r7 = (r1 + r7)|0;
 r9 = (r7 + 4)|0;
 r7 = r7 >> 2;
 heap32[(r7)] = r1;
 r1 = r9;
}
 heap32[(r6+4)] = r1;
 r7 = 4095;
 r9 = 80;
 heap32[(r6+3)] = r1;
 heap32[(r6+2)] = 4096;
 r10 = r1;
_64: while(true){
 r1 = r1 >> 2;
 r9 = (r10 + r9)|0;
 heap32[(r1)] = r9;
 r9 = heap32[(r6)];
 r1 = (r10 + r9)|0;
 r7 = (r7 + -1)|0;
 r10 = r1;
 if(r7 !=0) //_LBB26_63
{
continue _64;
}
else{
break _64;
}
}
 r1 = r1 >> 2;
 r6 = _ZL14benchmarkDemo4;
 heap32[(r1)] = 0;
 r1 = r6 >> 2;
 heap32[(r5+6)] = r3;
 heap32[(r1+16)] = r0;
 heap32[(g0)] = 5388;
 _Znwj(i7);
 r0 = r_g0;
 r3 = _ZTV21btCollisionDispatcher;
 r5 = heap32[(r1+16)];
 r3 = (r3 + 8)|0;
 r7 = r0 >> 2;
 heap32[(r7)] = r3;
 heap32[(r7+1)] = 2;
 heap8[r0+24] = r4;
 heap32[(r7+5)] = 0;
 r3 = _ZTV16btManifoldResult;
 heap32[(r7+3)] = 0;
 r3 = (r3 + 8)|0;
 heap32[(r7+4)] = 0;
 heap32[(r7+7)] = r3;
 r3 = _ZN21btCollisionDispatcher19defaultNearCallbackER16btBroadphasePairRS_RK16btDispatcherInfo__index__;
 heap32[(r7+1346)] = r5;
 heap32[(r7+47)] = r3;
 r3 = r5 >> 2;
 r9 = heap32[(r3)];
 r9 = r9 >> 2;
 r9 = heap32[(r9+3)];
 heap32[(g0)] = r5;
 __FUNCTION_TABLE__[(r9)>>2](i7);
 heap32[(r7+48)] = r_g0;
 r3 = heap32[(r3)];
 r3 = r3 >> 2;
 r3 = heap32[(r3+2)];
 heap32[(g0)] = r5;
 __FUNCTION_TABLE__[(r3)>>2](i7);
 r5 = (r0 + 200)|0;
 heap32[(r7+49)] = r_g0;
_67: while(true){
 if(r8 >35) //_LBB26_72
{
__label__ = 52;
break _67;
}
else{
 r3 = 0;
_70: while(true){
 if(r3 <36) //_LBB26_65
{
 r7 = r0 >> 2;
 r7 = heap32[(r7+1346)];
 r9 = r7 >> 2;
 r9 = heap32[(r9)];
 r9 = r9 >> 2;
 r9 = heap32[(r9+5)];
 r10 = r3 << 2;
 heap32[(g0)] = r7;
 heap32[(g0+1)] = r8;
 heap32[(g0+2)] = r3;
 r7 = (r5 + r10)|0;
 r7 = r7 >> 2;
 __FUNCTION_TABLE__[(r9)>>2](i7);
 r9 = r_g0;
 heap32[(r7)] = r9;
 if(r9 !=0) //_LBB26_67
{
 r3 = (r3 + 1)|0;
}
else{
__label__ = 46;
break _67;
}
}
else{
break _70;
}
}
 r8 = (r8 + 1)|0;
 r5 = (r5 + 144)|0;
continue _67;
}
}
switch(__label__ ){//multiple entries
case 52:
 heap32[(r1+14)] = r0;
 heap32[(g0)] = 76;
 _Znwj(i7);
 r0 = r_g0;
 heap32[(g0)] = r0;
 _ZN28btHashedOverlappingPairCacheC1Ev(i7);
 r3 = heap32[(r2)];
 r5 = (r3 + 1)|0;
 heap32[(r2)] = r5;
 heap32[(g0)] = 135;
 malloc(i7);
 r7 = r_g0;
 if(r7 !=0) //_LBB26_74
{
 r8 = 0;
 r9 = (r7 + 4)|0;
 r8 = (r8 - r9)|0;
 r8 = r8 & 15;
 r8 = (r7 + r8)|0;
 r9 = (r8 + 4)|0;
 r8 = r8 >> 2;
 heap32[(r8)] = r7;
 r7 = r9;
}
 r8 = _ZTV20btAxisSweep3InternalItE;
 r9 = r7 >> 2;
 r8 = (r8 + 8)|0;
 r10 = -2;
 heap32[(r9)] = r8;
 r8 = -1;
 heap16[(r7+4)>>1] = r10;
 heap16[(r7+6)>>1] = r8;
 heap32[(r9+23)] = r0;
 r8 = 0;
 heap32[(r9+24)] = 0;
 heap8[r7+100] = r8;
 heap32[(r9+26)] = 0;
 heap32[(r9+27)] = 0;
 if(r0 ==0) //_LBB26_77
{
 r5 = (r3 + 2)|0;
 heap32[(r2)] = r5;
 heap32[(g0)] = 95;
 malloc(i7);
 r5 = r_g0;
 if(r5 !=0) //_LBB26_79
{
 r0 = 0;
 r3 = (r5 + 4)|0;
 r0 = (r0 - r3)|0;
 r0 = r0 & 15;
 r0 = (r5 + r0)|0;
 r3 = (r0 + 4)|0;
 r0 = r0 >> 2;
 heap32[(r0)] = r5;
 r5 = r3;
}
 heap32[(g0)] = r5;
 _ZN28btHashedOverlappingPairCacheC1Ev(i7);
 heap32[(r9+23)] = r5;
 heap8[r7+100] = r4;
 r5 = heap32[(r2)];
}
 r0 = (r5 + 1)|0;
 heap32[(r2)] = r0;
 heap32[(g0)] = 43;
 malloc(i7);
 r0 = r_g0;
 if(r0 !=0) //_LBB26_83
{
 r3 = (r0 + 4)|0;
 r3 = (r8 - r3)|0;
 r3 = r3 & 15;
 r3 = (r0 + r3)|0;
 r10 = (r3 + 4)|0;
 r3 = r3 >> 2;
 heap32[(r3)] = r0;
 r0 = r10;
}
 r3 = _ZTV15btNullPairCache;
 r10 = r0 >> 2;
 r3 = (r3 + 8)|0;
 heap32[(r10)] = r3;
 heap8[r0+20] = r4;
 heap32[(r10+4)] = 0;
 heap32[(r10+2)] = 0;
 heap32[(r10+3)] = 0;
 r3 = (r5 + 2)|0;
 heap32[(r9+28)] = r0;
 heap32[(r2)] = r3;
 heap32[(g0)] = 175;
 malloc(i7);
 r10 = r_g0;
 if(r10 !=0) //_LBB26_86
{
 r11 = (r10 + 4)|0;
 r11 = (r8 - r11)|0;
 r11 = r11 & 15;
 r11 = (r10 + r11)|0;
 r12 = (r11 + 4)|0;
 r11 = r11 >> 2;
 heap32[(r11)] = r10;
 r10 = r12;
}
 r11 = _ZTV16btDbvtBroadphase;
 r12 = r10 >> 2;
 r11 = (r11 + 8)|0;
 heap32[(r12)] = r11;
_92: while(true){
 r11 = (r10 + r8)|0;
 r13 = r11 >> 2;
 heap8[r11+40] = r4;
 heap32[(r13+9)] = 0;
 heap32[(r13+7)] = 0;
 heap32[(r13+8)] = 0;
 heap32[(r13+1)] = 0;
 heap32[(r13+2)] = 0;
 heap32[(r13+3)] = -1;
 r8 = (r8 + 40)|0;
 heap32[(r13+4)] = 0;
 heap32[(r13+5)] = 0;
 if(r8 !=80) //_LBB26_88
{
continue _92;
}
else{
break _92;
}
}
 r8 = 0;
 r11 = r0 == r8;
 heap8[r10+153] = r8;
 r11 = r11 & 1;
 heap8[r10+154] = r4;
 heap8[r10+152] = r11;
 heap32[(r12+25)] = 0;
 heap32[(r12+26)] = 0;
 heap32[(r12+31)] = 0;
 heap32[(r12+27)] = 1;
 heap32[(r12+28)] = 0;
 heap32[(r12+29)] = 10;
 heap32[(r12+30)] = 1;
 heap32[(r12+32)] = 0;
 heap32[(r12+33)] = 0;
 heap32[(r12+34)] = 0;
 if(r0 ==0) //_LBB26_91
{
 r0 = (r5 + 3)|0;
 heap32[(r2)] = r0;
 heap32[(g0)] = 95;
 malloc(i7);
 r0 = r_g0;
 if(r0 !=0) //_LBB26_93
{
 r3 = 0;
 r5 = (r0 + 4)|0;
 r3 = (r3 - r5)|0;
 r3 = r3 & 15;
 r3 = (r0 + r3)|0;
 r5 = (r3 + 4)|0;
 r3 = r3 >> 2;
 heap32[(r3)] = r0;
 r0 = r5;
}
 heap32[(g0)] = r0;
 _ZN28btHashedOverlappingPairCacheC1Ev(i7);
 r3 = heap32[(r2)];
}
 heap32[(r12+24)] = r0;
 heap32[(r12+37)] = 0;
 heap32[(r12+35)] = 0;
 heap32[(r12+36)] = 0;
 heap32[(r12+21)] = 0;
 heap32[(r12+22)] = 0;
 heap32[(r12+23)] = 0;
 heap32[(r9+27)] = r10;
 heap8[r10+153] = r4;
 heap32[(r9+2)] = -998637568;
 heap32[(r9+3)] = -998637568;
 heap32[(r9+4)] = -998637568;
 heap32[(r9+5)] = 0;
 heap32[(r9+6)] = 1148846080;
 heap32[(r9+7)] = 1148846080;
 heap32[(r9+8)] = 1148846080;
 heap32[(r9+9)] = 0;
 r0 = heapU16[(r7+6)>>1];
 f0 = uint(r0); //fuitos r0, f0
 f1 =                      2000;
 f0 = f0/f1;
 heapFloat[(r9+10)] = f0;
 heapFloat[(r9+11)] = f0;
 heapFloat[(r9+12)] = f0;
 r0 = (r3 + 1)|0;
 heap32[(r9+13)] = 0;
 heap32[(r2)] = r0;
 heap32[(g0)] = 224083;
 malloc(i7);
 r0 = r_g0;
 if(r0 !=0) //_LBB26_97
{
 r5 = (r0 + 4)|0;
 r5 = (r8 - r5)|0;
 r5 = r5 & 15;
 r5 = (r0 + r5)|0;
 r10 = (r5 + 4)|0;
 r5 = r5 >> 2;
 heap32[(r5)] = r0;
 r0 = r10;
}
_103: while(true){
 r5 = r8 << 6;
 r5 = (r0 - r5)|0;
 r5 = r5 >> 2;
 r8 = (r8 + -1)|0;
 heap32[(r5)] = 0;
 heap32[(r5+2)] = 0;
 if(r8 !=-3501) //_LBB26_98
{
continue _103;
}
else{
break _103;
}
}
 r5 = 3501;
 heap32[(r9+15)] = r0;
 r8 = 0;
 heap16[(r7+58)>>1] = r5;
 r5 = -112;
 r10 = 2;
 heap16[(r7+56)>>1] = r8;
 heap16[(r7+64)>>1] = r4;
_106: while(true){
 r0 = (r0 - r5)|0;
 heap16[(r0)>>1] = r10;
 r5 = (r5 + -64)|0;
 r0 = heap32[(r9+15)];
 r10 = (r10 + 1)|0;
 if(r5 !=-224112) //_LBB26_100
{
continue _106;
}
else{
break _106;
}
}
 r3 = (r3 + 2)|0;
 heap16[(r0+224048)>>1] = r8;
_109: while(true){
 r0 = (r3 + r8)|0;
 heap32[(r2)] = r0;
 heap32[(g0)] = 28027;
 malloc(i7);
 r0 = r_g0;
 if(r0 !=0) //_LBB26_104
{
 r5 = 0;
 r10 = (r0 + 4)|0;
 r5 = (r5 - r10)|0;
 r5 = r5 & 15;
 r5 = (r0 + r5)|0;
 r10 = (r5 + 4)|0;
 r5 = r5 >> 2;
 heap32[(r5)] = r0;
 r0 = r10;
}
 r5 = r8 << 2;
 r5 = (r7 + r5)|0;
 r5 = r5 >> 2;
 r8 = (r8 + 1)|0;
 heap32[(r5+20)] = r0;
 heap32[(r5+17)] = r0;
 if(r8 !=3) //_LBB26_102
{
continue _109;
}
else{
break _109;
}
}
 r0 = heap32[(r9+15)];
 r0 = r0 >> 2;
 heap32[(r0)] = 0;
 r0 = heap32[(r9+15)];
 r3 = 0;
 heap16[(r0+48)>>1] = r3;
 r0 = heap32[(r9+15)];
 heap16[(r0+54)>>1] = r4;
 r0 = heap32[(r9+17)];
 heap16[(r0)>>1] = r3;
 r0 = heap32[(r9+17)];
 heap16[(r0+2)>>1] = r3;
 r0 = heap32[(r9+17)];
 r5 = heapU16[(r7+6)>>1];
 heap16[(r0+4)>>1] = r5;
 r0 = heap32[(r9+17)];
 heap16[(r0+6)>>1] = r3;
 r0 = heap32[(r9+15)];
 heap16[(r0+50)>>1] = r3;
 r0 = heap32[(r9+15)];
 heap16[(r0+56)>>1] = r4;
 r0 = heap32[(r9+18)];
 heap16[(r0)>>1] = r3;
 r0 = heap32[(r9+18)];
 heap16[(r0+2)>>1] = r3;
 r0 = heap32[(r9+18)];
 r5 = heapU16[(r7+6)>>1];
 heap16[(r0+4)>>1] = r5;
 r0 = heap32[(r9+18)];
 heap16[(r0+6)>>1] = r3;
 r0 = heap32[(r9+15)];
 heap16[(r0+52)>>1] = r3;
 r0 = heap32[(r9+15)];
 heap16[(r0+58)>>1] = r4;
 r0 = heap32[(r9+19)];
 heap16[(r0)>>1] = r3;
 r0 = heap32[(r9+19)];
 heap16[(r0+2)>>1] = r3;
 r0 = heap32[(r9+19)];
 r5 = heapU16[(r7+6)>>1];
 heap16[(r0+4)>>1] = r5;
 r0 = heap32[(r9+19)];
 r5 = _ZTV12btAxisSweep3;
 r5 = (r5 + 8)|0;
 heap16[(r0+6)>>1] = r3;
 heap32[(r9)] = r5;
 heap32[(r1+13)] = r7;
 heap32[(g0)] = 128;
 r0 = _ZTV35btSequentialImpulseConstraintSolver;
 _Znwj(i7);
 r7 = r_g0 >> 2;
 r0 = (r0 + 8)|0;
 heap32[(r7)] = r0;
 heap8[r_g0+20] = r4;
 heap32[(r7+4)] = 0;
 heap32[(r7+2)] = 0;
 heap32[(r7+3)] = 0;
 heap8[r_g0+40] = r4;
 heap32[(r7+9)] = 0;
 heap32[(r7+7)] = 0;
 heap32[(r7+8)] = 0;
 heap8[r_g0+60] = r4;
 heap32[(r7+14)] = 0;
 heap32[(r7+12)] = 0;
 heap32[(r7+13)] = 0;
 heap8[r_g0+80] = r4;
 heap32[(r7+19)] = 0;
 heap32[(r7+17)] = 0;
 heap32[(r7+18)] = 0;
 heap8[r_g0+100] = r4;
 heap32[(r7+24)] = 0;
 heap32[(r7+22)] = 0;
 heap32[(r7+23)] = 0;
 heap8[r_g0+120] = r4;
 heap32[(r7+29)] = 0;
 heap32[(r7+27)] = 0;
 heap32[(r7+28)] = 0;
 heap32[(r7+31)] = 0;
 heap32[(r1+15)] = r_g0;
 heap32[(g0)] = 272;
 _Znwj(i7);
 r5 = r_g0;
 r7 = heap32[(r1+16)];
 r8 = _ZTV16btCollisionWorld;
 r9 = heap32[(r1+15)];
 r10 = heap32[(r1+13)];
 r11 = heap32[(r1+14)];
 r8 = (r8 + 8)|0;
 r12 = r5 >> 2;
 heap32[(r12)] = r8;
 heap8[r5+20] = r4;
 heap32[(r12+4)] = 0;
 heap32[(r12+2)] = 0;
 heap32[(r12+3)] = 0;
 heap32[(r12+6)] = r11;
 heap32[(r12+7)] = 0;
 heap32[(r12+8)] = 0;
 heap32[(r12+9)] = 1;
 heap32[(r12+10)] = 1065353216;
 heap8[r5+44] = r3;
 heap32[(r12+12)] = 0;
 heap8[r5+52] = r3;
 heap8[r5+53] = r4;
 heap8[r5+54] = r4;
 heap32[(r12+14)] = 1025758986;
 heap8[r5+60] = r3;
 heap32[(r12+16)] = 0;
 heap8[r5+68] = r3;
 heap32[(r12+18)] = 0;
 heap32[(r12+20)] = r10;
 heap32[(r12+21)] = 0;
 r8 = r7 >> 2;
 heap8[r5+88] = r4;
 r8 = heap32[(r8)];
 r8 = r8 >> 2;
 r8 = heap32[(r8+4)];
 heap32[(g0)] = r7;
 __FUNCTION_TABLE__[(r8)>>2](i7);
 heap32[(r12+19)] = r_g0;
 heap32[(r12+18)] = r_g0;
 heap32[(r12+23)] = 0;
 heap32[(r12+24)] = 0;
 heap32[(r12+25)] = 0;
 heap32[(r12+26)] = 1058642330;
 heap32[(r12+27)] = 1065353216;
 heap32[(r12+28)] = 1050253722;
 heap32[(r12+30)] = 0;
 heap32[(r12+32)] = 1101004800;
 heap32[(r12+31)] = 10;
 heap32[(r12+34)] = 1045220557;
 heap32[(r12+35)] = 1036831949;
 heap32[(r12+36)] = 0;
 heap32[(r12+33)] = 1065353216;
 heap32[(r12+37)] = 0;
 heap32[(r12+38)] = -1130113270;
 heap32[(r12+39)] = 0;
 heap32[(r12+40)] = 1062836634;
 heap32[(r12+41)] = 260;
 r7 = _ZTV23btDiscreteDynamicsWorld;
 heap32[(r12+42)] = 2;
 r7 = (r7 + 8)|0;
 heap32[(r12+43)] = 128;
 heap32[(r12)] = r7;
 heap32[(r12+44)] = r9;
 heap8[r5+200] = r4;
 heap32[(r12+49)] = 0;
 heap32[(r12+47)] = 0;
 heap32[(r12+48)] = 0;
 heap8[r5+220] = r4;
 heap32[(r12+54)] = 0;
 heap32[(r12+52)] = 0;
 heap32[(r12+53)] = 0;
 heap32[(r12+56)] = 0;
 heap32[(r12+57)] = -1054867456;
 heap32[(r12+58)] = 0;
 heap32[(r12+59)] = 0;
 heap32[(r12+60)] = 0;
 heap8[r5+246] = r3;
 heap8[r5+264] = r4;
 heap32[(r12+65)] = 0;
 heap32[(r12+63)] = 0;
 heap32[(r12+64)] = 0;
 heap32[(r12+67)] = 0;
 if(r9 !=0) //_LBB26_111
{
 heap8[r5+245] = r3;
 r7 = heap32[(r2)];
}
else{
 r7 = heap32[(r2)];
 r7 = (r7 + 1)|0;
 heap32[(r2)] = r7;
 heap32[(g0)] = 147;
 malloc(i7);
 r8 = r_g0;
 if(r8 !=0) //_LBB26_109
{
 r9 = 0;
 r10 = (r8 + 4)|0;
 r9 = (r9 - r10)|0;
 r9 = r9 & 15;
 r9 = (r8 + r9)|0;
 r10 = (r9 + 4)|0;
 r9 = r9 >> 2;
 heap32[(r9)] = r8;
 r8 = r10;
}
 r9 = r8 >> 2;
 heap32[(r9)] = r0;
 heap8[r8+20] = r4;
 heap32[(r9+4)] = 0;
 heap32[(r9+2)] = 0;
 heap32[(r9+3)] = 0;
 heap8[r8+40] = r4;
 heap32[(r9+9)] = 0;
 heap32[(r9+7)] = 0;
 heap32[(r9+8)] = 0;
 heap8[r8+60] = r4;
 heap32[(r9+14)] = 0;
 heap32[(r9+12)] = 0;
 heap32[(r9+13)] = 0;
 heap8[r8+80] = r4;
 heap32[(r9+19)] = 0;
 heap32[(r9+17)] = 0;
 heap32[(r9+18)] = 0;
 heap8[r8+100] = r4;
 heap32[(r9+24)] = 0;
 heap32[(r9+22)] = 0;
 heap32[(r9+23)] = 0;
 heap8[r8+120] = r4;
 heap32[(r9+29)] = 0;
 heap32[(r9+27)] = 0;
 heap32[(r9+28)] = 0;
 r0 = r5 >> 2;
 heap32[(r9+31)] = 0;
 heap32[(r0+44)] = r8;
 heap8[r5+245] = r4;
}
 r0 = (r7 + 1)|0;
 heap32[(r2)] = r0;
 heap32[(g0)] = 87;
 malloc(i7);
 r0 = r_g0;
 if(r0 !=0) //_LBB26_114
{
 r7 = (r0 + 4)|0;
 r7 = (r3 - r7)|0;
 r7 = r7 & 15;
 r7 = (r0 + r7)|0;
 r8 = (r7 + 4)|0;
 r7 = r7 >> 2;
 heap32[(r7)] = r0;
 r0 = r8;
}
 r7 = _ZTV25btSimulationIslandManager;
 r8 = r0 >> 2;
 r7 = (r7 + 8)|0;
 heap32[(r8)] = r7;
 heap8[r0+20] = r4;
 heap32[(r8+4)] = 0;
 heap32[(r8+2)] = 0;
 heap32[(r8+3)] = 0;
 heap8[r0+40] = r4;
 heap32[(r8+9)] = 0;
 heap32[(r8+7)] = 0;
 heap32[(r8+8)] = 0;
 heap8[r0+60] = r4;
 heap32[(r8+14)] = 0;
 heap32[(r8+12)] = 0;
 heap32[(r8+13)] = 0;
 r7 = r5 >> 2;
 heap8[r0+64] = r4;
 heap32[(r7+45)] = r0;
 heap8[r5+244] = r4;
 heap32[(r1+1)] = r5;
 r0 = heap32[(r7+41)];
 r0 = r0 | 32;
 heap32[(r7+41)] = r0;
 heap32[(r7+31)] = 5;
 heap32[(r1+2)] = 0;
 r0 = heap32[(r1+1)];
 r5 = r0 >> 2;
 r5 = heap32[(r5)];
 r5 = r5 >> 2;
 r5 = heap32[(r5+17)];
 r7 = sp + -41280;
 r8 = r7 >> 2;
 heap32[(fp+-10320)] = 0;
 heap32[(r8+1)] = -1054867456;
 heap32[(r8+2)] = 0;
 heap32[(r8+3)] = 0;
 heap32[(g0)] = r0;
 heap32[(g0+1)] = r7;
 __FUNCTION_TABLE__[(r5)>>2](i7);
 r0 = heap32[(r1+17)];
 if(r0 <5) //_LBB26_117
{
 r0 = heap32[(r2)];
 r5 = (r0 + 1)|0;
 heap32[(r2)] = r5;
 heap32[(g0)] = 71;
 malloc(i7);
 r5 = r_g0;
 if(r5 !=0) //_LBB26_119
{
 r7 = 0;
 r8 = (r5 + 4)|0;
 r7 = (r7 - r8)|0;
 r7 = r7 & 15;
 r7 = (r5 + r7)|0;
 r8 = (r7 + 4)|0;
 r7 = r7 >> 2;
 heap32[(r7)] = r5;
 r5 = r8;
}
 r7 = r5 >> 2;
 heap32[(r7+2)] = 0;
 heap32[(r7+3)] = 1065353216;
 heap32[(r7+4)] = 1065353216;
 heap32[(r7+5)] = 1065353216;
 r8 = _ZTV10btBoxShape;
 heap32[(r7+6)] = 0;
 r8 = (r8 + 8)|0;
 heap32[(r7+11)] = 1025758986;
 heap32[(r7)] = r8;
 heap32[(r7+1)] = 0;
 heap32[(r7+7)] = 1132066243;
 heap32[(r7+8)] = 1112004362;
 heap32[(r7+9)] = 1132066243;
 heap32[(r7+10)] = 0;
 r7 = heap32[(r1+5)];
 r8 = heap32[(r1+4)];
 if(r7 ==r8) //_LBB26_122
{
 r9 = r8 << 1;
 r9 = r8 == 0 ? r4 : r9;
if(!(r7 >=r9)) //_LBB26_121
{
 if(r9 !=0) //_LBB26_125
{
 r7 = r9 << 2;
 r0 = (r0 + 2)|0;
 r7 = r7 | 3;
 heap32[(r2)] = r0;
 r0 = (r7 + 16)|0;
 heap32[(g0)] = r0;
 malloc(i7);
 r0 = r_g0;
 if(r0 !=0) //_LBB26_127
{
 r7 = 0;
 r10 = (r0 + 4)|0;
 r7 = (r7 - r10)|0;
 r7 = r7 & 15;
 r7 = (r0 + r7)|0;
 r10 = (r7 + 4)|0;
 r7 = r7 >> 2;
 heap32[(r7)] = r0;
 r0 = r10;
}
}
else{
 r0 = 0;
}
_138: do {
 if(r8 <1) //_LBB26_130
{
 r10 = heap32[(r1+6)];
}
else{
 r7 = 0;
_141: while(true){
 r10 = heap32[(r1+6)];
 r11 = r7 << 2;
 r12 = (r10 + r11)|0;
 r12 = r12 >> 2;
 r11 = (r0 + r11)|0;
 r12 = heap32[(r12)];
 r7 = (r7 + 1)|0;
 r11 = r11 >> 2;
 heap32[(r11)] = r12;
if(!(r8 !=r7)) //_LBB26_131
{
break _138;
}
}
}
} while(0);
 if(r10 !=0) //_LBB26_134
{
 r7 = heapU8[r6+28];
 if(r7 !=0) //_LBB26_136
{
 r8 = gNumAlignedFree;
 r8 = r8 >> 2;
 r7 = heap32[(r8)];
 r7 = (r7 + 1)|0;
 r10 = r10 >> 2;
 heap32[(r8)] = r7;
 r8 = heap32[(r10+-1)];
 heap32[(g0)] = r8;
 free(i7);
 r8 = heap32[(r1+4)];
}
 heap32[(r1+6)] = 0;
}
 heap8[r6+28] = r4;
 heap32[(r1+6)] = r0;
 heap32[(r1+5)] = r9;
}
}
 r0 = r8 << 2;
 r7 = heap32[(r1+6)];
 r0 = (r7 + r0)|0;
 r0 = r0 >> 2;
 heap32[(r0)] = r5;
 r0 = heap32[(r1+4)];
 r0 = (r0 + 1)|0;
 r7 = _ZGVZN11btTransform11getIdentityEvE17identityTransform;
 heap32[(r1+4)] = r0;
 r0 = heapU8[r7];
if(!(r0 !=0)) //_LBB26_143
{
 r0 = _ZGVZN11btMatrix3x311getIdentityEvE14identityMatrix;
 r8 = heapU8[r0];
if(!(r8 !=0)) //_LBB26_142
{
 r8 = _ZZN11btMatrix3x311getIdentityEvE14identityMatrix_2E_0_2E_0_2E_0_2E_0;
 r9 = _ZZN11btMatrix3x311getIdentityEvE14identityMatrix_2E_0_2E_1_2E_0_2E_1;
 r8 = r8 >> 2;
 r10 = _ZZN11btMatrix3x311getIdentityEvE14identityMatrix_2E_0_2E_2_2E_0_2E_2;
 r9 = r9 >> 2;
 heap32[(r8)] = 1065353216;
 r8 = r10 >> 2;
 heap32[(r9)] = 1065353216;
 heap32[(r8)] = 1065353216;
 heap8[r0] = r4;
}
 r0 = _ZZN11btTransform11getIdentityEvE17identityTransform;
 r8 = _ZZN11btMatrix3x311getIdentityEvE14identityMatrix_2E_0_2E_0_2E_0_2E_0;
 r0 = r0 >> 2;
 r8 = r8 >> 2;
 heap32[(r0)] = heap32[(r8)];
 heap32[(r0+1)] = 0;
 heap32[(r0+2)] = 0;
 r8 = _ZZN11btMatrix3x311getIdentityEvE14identityMatrix_2E_0_2E_1_2E_0_2E_1;
 heap32[(r0+3)] = 0;
 r8 = r8 >> 2;
 heap32[(r0+4)] = 0;
 heap32[(r0+5)] = heap32[(r8)];
 heap32[(r0+6)] = 0;
 heap32[(r0+7)] = 0;
 r8 = _ZZN11btMatrix3x311getIdentityEvE14identityMatrix_2E_0_2E_2_2E_0_2E_2;
 heap32[(r0+8)] = 0;
 r8 = r8 >> 2;
 heap32[(r0+9)] = 0;
 heap32[(r0+10)] = heap32[(r8)];
 heap32[(r0+11)] = 0;
 heap32[(r0+12)] = 0;
 heap32[(r0+13)] = 0;
 heap32[(r0+14)] = 0;
 heap32[(r0+15)] = 0;
 heap8[r7] = r4;
}
 heap32[(g0)] = 200;
 r0 = _ZTV20btDefaultMotionState;
 _Znwj(i7);
 r8 = r_g0 >> 2;
 r0 = (r0 + 8)|0;
 heap32[(r8)] = r0;
 heap32[(r8+1)] = 1065353216;
 heap32[(r8+2)] = 0;
 heap32[(r8+3)] = 0;
 heap32[(r8+4)] = 0;
 heap32[(r8+5)] = 0;
 heap32[(r8+6)] = 1065353216;
 heap32[(r8+7)] = 0;
 heap32[(r8+8)] = 0;
 heap32[(r8+9)] = 0;
 heap32[(r8+10)] = 0;
 heap32[(r8+11)] = 1065353216;
 heap32[(r8+12)] = 0;
 heap32[(r8+13)] = 0;
 heap32[(r8+14)] = -1035468800;
 r0 = _ZZN11btTransform11getIdentityEvE17identityTransform;
 heap32[(r8+15)] = 0;
 r0 = r0 >> 2;
 heap32[(r8+16)] = 0;
 heap32[(r8+17)] = heap32[(r0)];
 heap32[(r8+18)] = heap32[(r0+1)];
 heap32[(r8+19)] = heap32[(r0+2)];
 heap32[(r8+20)] = heap32[(r0+3)];
 heap32[(r8+21)] = heap32[(r0+4)];
 heap32[(r8+22)] = heap32[(r0+5)];
 heap32[(r8+23)] = heap32[(r0+6)];
 heap32[(r8+24)] = heap32[(r0+7)];
 heap32[(r8+25)] = heap32[(r0+8)];
 heap32[(r8+26)] = heap32[(r0+9)];
 heap32[(r8+27)] = heap32[(r0+10)];
 heap32[(r8+28)] = heap32[(r0+11)];
 heap32[(r8+29)] = heap32[(r0+12)];
 heap32[(r8+30)] = heap32[(r0+13)];
 heap32[(r8+31)] = heap32[(r0+14)];
 heap32[(r8+32)] = heap32[(r0+15)];
 heap32[(r8+33)] = 1065353216;
 heap32[(r8+34)] = 0;
 heap32[(r8+35)] = 0;
 heap32[(r8+36)] = 0;
 heap32[(r8+37)] = 0;
 heap32[(r8+38)] = 1065353216;
 heap32[(r8+39)] = 0;
 heap32[(r8+40)] = 0;
 heap32[(r8+41)] = 0;
 heap32[(r8+42)] = 0;
 heap32[(r8+43)] = 1065353216;
 heap32[(r8+44)] = 0;
 heap32[(r8+45)] = 0;
 heap32[(r8+46)] = -1035468800;
 heap32[(r8+47)] = 0;
 heap32[(r8+48)] = 0;
 r0 = sp + -41416;
 heap32[(r8+49)] = 0;
 r8 = r0 >> 2;
 heap32[(fp+-10354)] = 0;
 heap32[(r8+1)] = r_g0;
 heap32[(r8+18)] = r5;
 heap32[(r8+19)] = 0;
 heap32[(r8+20)] = 0;
 heap32[(r8+21)] = 0;
 heap32[(r8+22)] = 0;
 heap32[(r8+23)] = 0;
 heap32[(r8+24)] = 0;
 heap32[(r8+25)] = 1056964608;
 heap32[(r8+26)] = 0;
 heap32[(r8+27)] = 1061997773;
 r5 = 0;
 heap32[(r8+28)] = 1065353216;
 heap8[sp+-41300] = r5;
 heap32[(r8+30)] = 1000593162;
 heap32[(r8+31)] = 1008981770;
 heap32[(r8+32)] = 1008981770;
 heap32[(r8+33)] = 1008981770;
 heap32[(r8+2)] = 1065353216;
 heap32[(r8+3)] = 0;
 heap32[(r8+4)] = 0;
 heap32[(r8+5)] = 0;
 heap32[(r8+6)] = 0;
 heap32[(r8+7)] = 1065353216;
 heap32[(r8+8)] = 0;
 heap32[(r8+9)] = 0;
 heap32[(r8+10)] = 0;
 heap32[(r8+11)] = 0;
 heap32[(r8+12)] = 1065353216;
 heap32[(r8+13)] = 0;
 heap32[(r8+14)] = 0;
 heap32[(r8+15)] = 0;
 heap32[(r8+16)] = 0;
 heap32[(r8+17)] = 0;
 r7 = heap32[(r2)];
 r7 = (r7 + 1)|0;
 heap32[(r2)] = r7;
 heap32[(g0)] = 627;
 malloc(i7);
 r7 = r_g0;
 if(r7 !=0) //_LBB26_145
{
 r8 = (r7 + 4)|0;
 r5 = (r5 - r8)|0;
 r5 = r5 & 15;
 r5 = (r7 + r5)|0;
 r8 = (r5 + 4)|0;
 r5 = r5 >> 2;
 heap32[(r5)] = r7;
 r7 = r8;
}
 r5 = r7 >> 2;
 heap32[(r5+41)] = 1065353216;
 heap32[(r5+42)] = 1065353216;
 heap32[(r5+43)] = 1065353216;
 heap32[(r5+44)] = 0;
 heap32[(r5+45)] = 0;
 heap32[(r5+46)] = 1566444395;
 heap32[(r5+47)] = 0;
 heap32[(r5+48)] = 0;
 heap32[(r5+49)] = 0;
 heap32[(r5+50)] = 0;
 heap32[(r5+51)] = 1;
 heap32[(r5+52)] = -1;
 heap32[(r5+53)] = -1;
 heap32[(r5+54)] = 1;
 heap32[(r5+55)] = 0;
 heap32[(r5+56)] = 1056964608;
 heap32[(r5+57)] = 0;
 heap32[(r5+58)] = 1;
 heap32[(r5+59)] = 0;
 heap32[(r5+60)] = 1065353216;
 heap32[(r5+61)] = 0;
 heap32[(r5+62)] = 0;
 heap32[(r5+63)] = 0;
 heap32[(r5+1)] = 1065353216;
 heap32[(r5+2)] = 0;
 heap32[(r5+3)] = 0;
 heap32[(r5+4)] = 0;
 heap32[(r5+5)] = 0;
 heap32[(r5+6)] = 1065353216;
 heap32[(r5+7)] = 0;
 heap32[(r5+8)] = 0;
 heap32[(r5+9)] = 0;
 heap32[(r5+10)] = 0;
 heap32[(r5+11)] = 1065353216;
 heap32[(r5+12)] = 0;
 heap32[(r5+13)] = 0;
 heap32[(r5+14)] = 0;
 r8 = _ZTV11btRigidBody;
 heap32[(r5+15)] = 0;
 r8 = (r8 + 8)|0;
 heap32[(r5+16)] = 0;
 heap32[(r5)] = r8;
 heap8[r7+492] = r4;
 heap32[(r5+122)] = 0;
 heap32[(r5+120)] = 0;
 heap32[(r5+121)] = 0;
 heap32[(g0)] = r7;
 heap32[(g0+1)] = r0;
 _ZN11btRigidBody14setupRigidBodyERKNS_27btRigidBodyConstructionInfoE(i7);
 r0 = heap32[(r1+1)];
 r5 = r0 >> 2;
 r5 = heap32[(r5)];
 r5 = r5 >> 2;
 r5 = heap32[(r5+20)];
 heap32[(g0)] = r0;
 heap32[(g0+1)] = r7;
 __FUNCTION_TABLE__[(r5)>>2](i7);
 r0 = heap32[(r1+17)];
}
_161: do {
 if(r0 >3) //_LBB26_151
{
 if(r0 >5) //_LBB26_154
{
 if(r0 ==6) //_LBB26_325
{
 _ZN13BenchmarkDemo11createTest6Ev(i7);
 return;
}
else{
 if(r0 ==7) //_LBB26_326
{
 _ZN13BenchmarkDemo11createTest6Ev(i7);
 r0 = sp + -41264;
 heap32[(g0)] = 8;
 r1 = r0 >> 2;
 _Znwj(i7);
 heap32[(r1+10006)] = r_g0;
 heap32[(g0)] = r_g0;
 heap32[(g0+1)] = 0;
 gettimeofday(i7);
 heap32[(r1+10000)] = 0;
 heap32[(r1+10001)] = 0;
 heap32[(r1+10005)] = 0;
 heap32[(r1+10004)] = 9999;
 heap32[(r1+10003)] = 0;
 heap32[(r1+10002)] = 0;
 heap32[(r1+10007)] = 1092616192;
 heap32[(r1+10008)] = 0;
 heap32[(r1+10009)] = 0;
 heap32[(r1+10010)] = 1112014848;
 heap32[(r1+10011)] = 1065353216;
 f3 =                         0;
_169: while(true){
 f0 = r3; //fitos r3, f0
 f1 =      0.025132741779088974;
 f0 = f0*f1;
 f1 =                       0.5;
 f0 = f0*f1;
 heapFloat[(g0)] = f0;
 sinf(i7);
 f2 =                         1;
 f1 = f_g0/f2;
 f2 = f1*f3;
 heapFloat[(g0)] = f0;
 cosf(i7);
 f4 = -f2;
 f5 = f_g0*f3;
 f6 = f2*f3;
 f7 = f4-f2;
 f8 = f_g0+f2;
 f8 = f8-f6;
 f7 = f7-f6;
 f9 = f5+f2;
 f9 = f9-f6;
 f5 = f5+f6;
 f6 = f7*f4;
 f10 = f8*f_g0;
 f5 = f5-f1;
 f11 = f9*f_g0;
 f7 = f7*f1;
 f10 = f6+f10;
 f4 = f9*f4;
 r2 = r3 << 4;
 f0 = f5*f_g0;
 f7 = f11-f7;
 f9 = f5*f2;
 f10 = f10+f4;
 f5 = f5*f1;
 r2 = (r0 + r2)|0;
 f0 = f6+f0;
 f1 = f8*f1;
 f6 = f7-f9;
 f2 = f8*f2;
 f5 = f10+f5;
 f7 =                      2500;
 f0 = f0-f1;
 f1 = f6+f2;
 r2 = r2 >> 2;
 f2 = f5*f7;
 f0 = f0-f4;
 f1 = f1*f7;
 heapFloat[(r2+4000)] = f2;
 f0 = f0*f7;
 heapFloat[(r2+4001)] = f1;
 heapFloat[(r2+4002)] = f0;
 heap32[(r2+4003)] = 0;
 f1 = heapFloat[(r1+10008)];
 heapFloat[(r2)] = f1;
 heap32[(r2+1)] = 1112014848;
 heap32[(r2+2)] = 0;
 f1 = f1+f2;
 heap32[(r2+3)] = 0;
 f0 = f0+f3;
 heapFloat[(r2+2000)] = f1;
 heapFloat[(r2+2002)] = f0;
 heap32[(r2+2003)] = 0;
 heap32[(r2+2001)] = -998637568;
 heap32[(r2+8000)] = 1065353216;
 heap32[(r2+8001)] = 0;
 r3 = (r3 + 1)|0;
 heap32[(r2+8002)] = 0;
 heap32[(r2+8003)] = 0;
if(!(r3 !=500)) //_LBB26_327
{
break _169;
}
}
 r2 = _ZL10raycastBar;
 heap32[(g0)] = r2;
 heap32[(g0+1)] = r0;
 heap32[(g0+2)] = 8000;
 memcpy(i7);
 r3 = (r2 + 8000)|0;
 r4 = (r0 + 8000)|0;
 heap32[(g0)] = r3;
 heap32[(g0+1)] = r4;
 heap32[(g0+2)] = 8000;
 memcpy(i7);
 r3 = (r2 + 16000)|0;
 r4 = (r0 + 16000)|0;
 heap32[(g0)] = r3;
 heap32[(g0+1)] = r4;
 heap32[(g0+2)] = 8000;
 memcpy(i7);
 r3 = (r2 + 24000)|0;
 r4 = (r0 + 24000)|0;
 heap32[(g0)] = r3;
 heap32[(g0+1)] = r4;
 heap32[(g0+2)] = 8000;
 memcpy(i7);
 r3 = (r2 + 32000)|0;
 r0 = (r0 + 32000)|0;
 heap32[(g0)] = r3;
 heap32[(g0+1)] = r0;
 heap32[(g0+2)] = 8000;
 memcpy(i7);
 r0 = r2 >> 2;
 r2 = heap32[(r1+10000)];
 heap32[(r0+10000)] = r2;
 r2 = heap32[(r1+10001)];
 heap32[(r0+10001)] = r2;
 r2 = heap32[(r1+10002)];
 heap32[(r0+10002)] = r2;
 r2 = heap32[(r1+10003)];
 heap32[(r0+10003)] = r2;
 r2 = heap32[(r1+10004)];
 heap32[(r0+10004)] = r2;
 r2 = heap32[(r1+10005)];
 heap32[(r0+10005)] = r2;
 r2 = heap32[(r1+10006)];
 r2 = r2 >> 2;
 r3 = heap32[(r0+10006)];
 r4 = heap32[(r2+1)];
 r2 = heap32[(r2)];
 r3 = r3 >> 2;
 heap32[(r3)] = r2;
 heap32[(r3+1)] = r4;
 heap32[(r0+10007)] = heap32[(r1+10007)];
 heap32[(r0+10008)] = heap32[(r1+10008)];
 heap32[(r0+10009)] = heap32[(r1+10009)];
 heap32[(r0+10010)] = heap32[(r1+10010)];
 heap32[(r0+10011)] = heap32[(r1+10011)];
 r0 = heap32[(r1+10006)];
 heap32[(g0)] = r0;
 _ZdlPv(i7);
 return;
}
else{
break _161;
}
}
}
else{
 if(r0 ==4) //_LBB26_291
{
 r3 = heap32[(r2)];
 r3 = (r3 + 1)|0;
 heap32[(r2)] = r3;
 heap32[(g0)] = 127;
 malloc(i7);
 r2 = r_g0;
 if(r2 !=0) //_LBB26_293
{
 r3 = 0;
 r4 = (r2 + 4)|0;
 r3 = (r3 - r4)|0;
 r3 = r3 & 15;
 r3 = (r2 + r3)|0;
 r4 = (r3 + 4)|0;
 r3 = r3 >> 2;
 heap32[(r3)] = r2;
 r2 = r4;
}
 heap32[(g0)] = r2;
 heap32[(g0+1)] = 0;
 heap32[(g0+2)] = 0;
 r3 = r2 >> 2;
 _ZN17btConvexHullShapeC1EPKfii(i7);
 r4 = heap32[(r3)];
 r4 = r4 >> 2;
 r4 = heap32[(r4+6)];
 r0 = sp + -96;
 r5 = r0 >> 2;
 heap32[(fp+-24)] = 1065353216;
 heap32[(r5+1)] = 1065353216;
 heap32[(r5+2)] = 1065353216;
 heap32[(r5+3)] = 0;
 heap32[(g0)] = r2;
 heap32[(g0+1)] = r0;
 r0 = 0;
 __FUNCTION_TABLE__[(r4)>>2](i7);
_178: while(true){
 r4 = (r0 * -3)|0;
 r5 = _ZL7TaruVtx;
 r4 = r4 << 2;
 r4 = (r5 + r4)|0;
 r5 = sp + -80;
 r4 = r4 >> 2;
 r7 = r5 >> 2;
 heap32[(fp+-20)] = heap32[(r4)];
 heap32[(r7+1)] = heap32[(r4+1)];
 heap32[(r7+2)] = heap32[(r4+2)];
 heap32[(r7+3)] = 0;
 heap32[(g0)] = r2;
 heap32[(g0+1)] = r5;
 r0 = (r0 + -1)|0;
 _ZN17btConvexHullShape8addPointERK9btVector3(i7);
 if(r0 ==-43) //_LBB26_301
{
break _178;
}
}
 r4 = sp + -160;
 r0 = r4 >> 2;
 heap32[(fp+-40)] = 1065353216;
 heap32[(r0+1)] = 0;
 heap32[(r0+2)] = 0;
 heap32[(r0+3)] = 0;
 heap32[(r0+4)] = 0;
 heap32[(r0+5)] = 1065353216;
 heap32[(r0+6)] = 0;
 heap32[(r0+7)] = 0;
 heap32[(r0+8)] = 0;
 heap32[(r0+9)] = 0;
 heap32[(r0+10)] = 1065353216;
 heap32[(r0+11)] = 0;
 heap32[(r0+12)] = 0;
 heap32[(r0+13)] = 0;
 heap32[(r0+14)] = 0;
 r5 = sp + -176;
 heap32[(r0+15)] = 0;
 r7 = r5 >> 2;
 heap32[(fp+-44)] = 0;
 heap32[(r7+1)] = 0;
 heap32[(r7+2)] = 0;
 heap32[(r7+3)] = 0;
 r3 = heap32[(r3)];
 r3 = r3 >> 2;
 r7 = heap32[(r3+8)];
 heap32[(g0)] = r2;
 heap32[(g0+1)] = 1065353216;
 heap32[(g0+2)] = r5;
 r3 = 15;
 f0 =                         3;
 f2 =                       -18;
 f3 =                       1.5;
 __FUNCTION_TABLE__[(r7)>>2](i7);
 f1 = f0;
_181: while(true){
 f4 = f3+f0;
 r5 = 0;
 r7 = r5;
_183: while(true){
 f5 = r7; //fitos r7, f5
 f5 = f5*f4;
 f5 = f5+f2;
 r8 = r5;
_185: while(true){
 f6 = r8; //fitos r8, f6
 f6 = f6*f4;
 f6 = f6+f2;
 heapFloat[(r0+12)] = f6;
 heapFloat[(r0+13)] = f1;
 heapFloat[(r0+14)] = f5;
 heap32[(r0+15)] = 0;
 r9 = heap32[(r1)];
 r9 = r9 >> 2;
 r9 = heap32[(r9+2)];
 heap32[(g0)] = r6;
 heap32[(g0+1)] = 1065353216;
 heap32[(g0+2)] = r4;
 heap32[(g0+3)] = r2;
 r8 = (r8 + 1)|0;
 __FUNCTION_TABLE__[(r9)>>2](i7);
if(!(r8 !=8)) //_LBB26_298
{
break _185;
}
}
 r7 = (r7 + 1)|0;
if(!(r7 !=8)) //_LBB26_297
{
break _183;
}
}
 f4 =        1.0099999904632568;
 f5 =      -0.05000000074505806;
 f4 = f3*f4;
 f6 =                         3;
 f3 = f3*f5;
 f5 =                         7;
 f6 = f4+f6;
 f3 = f3*f5;
 r3 = (r3 + -1)|0;
 f1 = f1+f6;
 f2 = f3+f2;
 f3 = f4;
 if(r3 ==0) //_LBB26_165
{
break _161;
}
else{
continue _181;
}
}
}
else{
 if(r0 ==5) //_LBB26_302
{
 r3 = 10;
 f0 =                        20;
 f1 =                         2;
 f2 =                       -25;
_191: while(true){
 f3 =                         3;
 f4 =                        25;
 f5 = f1+f3;
 f4 = f0+f4;
 r0 = 0;
 r5 = r0;
_193: while(true){
 f6 = r5; //fitos r5, f6
 f6 = f6*f5;
 f6 = f6+f2;
 f7 =                         5;
 f6 = f6*f7;
 f8 =                         0;
 f6 = f6+f8;
 r7 = r0;
_195: while(true){
 r8 = _ZL8nextRand;
 r8 = r8 >> 2;
 r9 = heap32[(r8)];
 r9 = (r9 * 214013)|0;
 r9 = (r9 + 2531011)|0;
 r10 = sp + -64;
 heap32[(r8)] = r9;
 r8 = r10 >> 2;
 heap32[(fp+-16)] = 1065353216;
 heap32[(r8+1)] = 0;
 heap32[(r8+2)] = 0;
 heap32[(r8+3)] = 0;
 heap32[(r8+4)] = 0;
 heap32[(r8+5)] = 1065353216;
 heap32[(r8+6)] = 0;
 heap32[(r8+7)] = 0;
 f9 = r7; //fitos r7, f9
 heap32[(r8+8)] = 0;
 f9 = f9*f5;
 heap32[(r8+9)] = 0;
 f9 = f9+f2;
 heap32[(r8+10)] = 1065353216;
 f9 = f9*f7;
 f9 = f9+f8;
 heap32[(r8+11)] = 0;
 r9 = r9 >>> 16;
 heapFloat[(r8+12)] = f9;
 r9 = r9 & 32767;
 heapFloat[(r8+13)] = f4;
 r9 = Math.floor(uint(r9) % uint(9));
 heapFloat[(r8+14)] = f6;
 heap32[(r8+15)] = 0;
if(!(uint(r9) >uint(8))) //_LBB26_321
{
 r8 = r4 << r9;
 r11 = r8 & 7;
 if(r11 !=0) //_LBB26_309
{
 r8 = heap32[(r2)];
 r8 = (r8 + 1)|0;
 heap32[(r2)] = r8;
 r9 = (r9 + 1)|0;
 f9 = r9; //fitos r9, f9
 f10 =                       0.5;
 heap32[(g0)] = 71;
 f9 = f9*f10;
 f10 =                       1.5;
 malloc(i7);
 r9 = r_g0;
 f10 = f9*f10;
 if(r9 !=0) //_LBB26_311
{
 r8 = 0;
 r11 = (r9 + 4)|0;
 r8 = (r8 - r11)|0;
 r8 = r8 & 15;
 r8 = (r9 + r8)|0;
 r11 = (r8 + 4)|0;
 r8 = r8 >> 2;
 heap32[(r8)] = r9;
 r9 = r11;
}
 r8 = r9 >> 2;
 heap32[(r8+2)] = 0;
 heap32[(r8+3)] = 1065353216;
 heap32[(r8+4)] = 1065353216;
 heap32[(r8+5)] = 1065353216;
 r11 = _ZTV10btBoxShape;
 heap32[(r8+6)] = 0;
 r11 = (r11 + 8)|0;
 heap32[(r8+11)] = 1025758986;
 heap32[(r8)] = r11;
 f11 =     -0.039999999105930328;
 f10 = f10+f11;
 heap32[(r8+1)] = 0;
 heapFloat[(r8+7)] = f10;
 heapFloat[(r8+8)] = f10;
 heapFloat[(r8+9)] = f10;
 heap32[(r8+10)] = 0;
 r8 = heap32[(r1)];
 r8 = r8 >> 2;
 r8 = heap32[(r8+2)];
 heap32[(g0)] = r6;
 heapFloat[(g0+1)] = f9;
 heap32[(g0+2)] = r10;
 heap32[(g0+3)] = r9;
 __FUNCTION_TABLE__[(r8)>>2](i7);
}
else{
 r11 = r8 & 56;
 if(r11 !=0) //_LBB26_313
{
 r8 = heap32[(r2)];
 r8 = (r8 + 1)|0;
 heap32[(r2)] = r8;
 r9 = (r9 + -2)|0;
 heap32[(g0)] = 71;
 f9 = r9; //fitos r9, f9
 f10 =                       0.5;
 malloc(i7);
 r9 = r_g0;
 f9 = f9*f10;
 if(r9 !=0) //_LBB26_315
{
 r8 = 0;
 r11 = (r9 + 4)|0;
 r8 = (r8 - r11)|0;
 r8 = r8 & 15;
 r8 = (r9 + r8)|0;
 r11 = (r8 + 4)|0;
 r8 = r8 >> 2;
 heap32[(r8)] = r9;
 r9 = r11;
}
 r8 = r9 >> 2;
 heap32[(r8+2)] = 0;
 heap32[(r8+3)] = 1065353216;
 heap32[(r8+4)] = 1065353216;
 r11 = _ZTV13btSphereShape;
 heap32[(r8+5)] = 1065353216;
 r11 = (r11 + 8)|0;
 heap32[(r8+6)] = 0;
 heap32[(r8)] = r11;
 f10 =                       1.5;
 f10 = f9*f10;
 heap32[(r8+1)] = 8;
 heapFloat[(r8+7)] = f10;
 heapFloat[(r8+11)] = f10;
 r8 = heap32[(r1)];
 r8 = r8 >> 2;
 r8 = heap32[(r8+2)];
 heap32[(g0)] = r6;
 heapFloat[(g0+1)] = f9;
 heap32[(g0+2)] = r10;
 heap32[(g0+3)] = r9;
 __FUNCTION_TABLE__[(r8)>>2](i7);
}
else{
 r8 = r8 & 448;
 if(r8 !=0) //_LBB26_317
{
 r8 = heap32[(r2)];
 r8 = (r8 + 1)|0;
 heap32[(r2)] = r8;
 r8 = (r9 + -5)|0;
 heap32[(g0)] = 75;
 f9 = r8; //fitos r8, f9
 f10 =                       0.5;
 malloc(i7);
 r8 = r_g0;
 f9 = f9*f10;
 if(r8 !=0) //_LBB26_319
{
 r9 = 0;
 r11 = (r8 + 4)|0;
 r9 = (r9 - r11)|0;
 r9 = r9 & 15;
 r9 = (r8 + r9)|0;
 r11 = (r9 + 4)|0;
 r9 = r9 >> 2;
 heap32[(r9)] = r8;
 r8 = r11;
}
 r9 = r8 >> 2;
 heap32[(r9+2)] = 0;
 heap32[(r9+3)] = 1065353216;
 heap32[(r9+4)] = 1065353216;
 heap32[(r9+5)] = 1065353216;
 r11 = _ZTV14btCapsuleShape;
 heap32[(r9+6)] = 0;
 r11 = (r11 + 8)|0;
 heap32[(r9+11)] = 1025758986;
 heap32[(r9)] = r11;
 heap32[(r9+1)] = 10;
 heap32[(r9+13)] = 1;
 f11 = f9+f9;
 f10 = f11*f10;
 heapFloat[(r9+7)] = f9;
 heapFloat[(r9+8)] = f10;
 heapFloat[(r9+9)] = f9;
 heap32[(r9+10)] = 0;
 r9 = heap32[(r1)];
 r9 = r9 >> 2;
 r9 = heap32[(r9+2)];
 heap32[(g0)] = r6;
 heapFloat[(g0+1)] = f9;
 heap32[(g0+2)] = r10;
 heap32[(g0+3)] = r8;
 __FUNCTION_TABLE__[(r9)>>2](i7);
}
}
}
}
 r7 = (r7 + 1)|0;
if(!(r7 !=10)) //_LBB26_305
{
break _195;
}
}
 r5 = (r5 + 1)|0;
if(!(r5 !=10)) //_LBB26_304
{
break _193;
}
}
 f4 =        1.1000000238418579;
 f5 =      -0.05000000074505806;
 f4 = f1*f4;
 f1 = f1*f5;
 f5 =                         9;
 f3 = f4+f3;
 f1 = f1*f5;
 r3 = (r3 + -1)|0;
 f0 = f0+f3;
 f2 = f1+f2;
 f1 = f4;
if(!(r3 !=0)) //_LBB26_303
{
break _191;
}
}
 _ZN13BenchmarkDemo19createLargeMeshBodyEv(i7);
 return;
}
else{
break _161;
}
}
}
}
else{
 if(r0 ==1) //_LBB26_156
{
 r3 = heap32[(r2)];
 r3 = (r3 + 1)|0;
 heap32[(r2)] = r3;
 heap32[(g0)] = 71;
 malloc(i7);
 r2 = r_g0;
 if(r2 !=0) //_LBB26_158
{
 r3 = 0;
 r4 = (r2 + 4)|0;
 r3 = (r3 - r4)|0;
 r3 = r3 & 15;
 r3 = (r2 + r3)|0;
 r4 = (r3 + 4)|0;
 r3 = r3 >> 2;
 heap32[(r3)] = r2;
 r2 = r4;
}
 r3 = r2 >> 2;
 heap32[(r3+2)] = 0;
 heap32[(r3+3)] = 1065353216;
 heap32[(r3+4)] = 1065353216;
 heap32[(r3+5)] = 1065353216;
 r4 = _ZTV10btBoxShape;
 heap32[(r3+6)] = 0;
 r4 = (r4 + 8)|0;
 heap32[(r3+11)] = 1025758986;
 heap32[(r3)] = r4;
 heap32[(r3+1)] = 0;
 heap32[(r3+7)] = 1064682127;
 heap32[(r3+8)] = 1064682127;
 heap32[(r3+9)] = 1064682127;
 r4 = sp + -1152;
 heap32[(r3+10)] = 0;
 r3 = r4 >> 2;
 heap32[(fp+-288)] = 0;
 heap32[(r3+1)] = 0;
 heap32[(r3+2)] = 0;
 heap32[(r3+3)] = 0;
 heap32[(g0)] = r2;
 heap32[(g0+1)] = 1073741824;
 heap32[(g0+2)] = r4;
 _ZNK10btBoxShape21calculateLocalInertiaEfR9btVector3(i7);
 r3 = sp + -1216;
 r4 = r3 >> 2;
 heap32[(fp+-304)] = 1065353216;
 heap32[(r4+1)] = 0;
 heap32[(r4+2)] = 0;
 heap32[(r4+3)] = 0;
 heap32[(r4+4)] = 0;
 heap32[(r4+5)] = 1065353216;
 heap32[(r4+6)] = 0;
 heap32[(r4+7)] = 0;
 heap32[(r4+8)] = 0;
 heap32[(r4+9)] = 0;
 heap32[(r4+10)] = 1065353216;
 heap32[(r4+11)] = 0;
 heap32[(r4+12)] = 0;
 heap32[(r4+13)] = 0;
 r0 = 47;
 f0 =                       -12;
 f1 =                         2;
 heap32[(r4+14)] = 0;
 heap32[(r4+15)] = 0;
_225: while(true){
 r5 = 0;
 r7 = r5;
_227: while(true){
 f2 = r7; //fitos r7, f2
 f3 =                         3;
 f2 = f2*f3;
 f2 = f2+f0;
 r8 = r5;
_229: while(true){
 f4 = r8; //fitos r8, f4
 f4 = f4*f3;
 f4 = f4+f0;
 heapFloat[(r4+12)] = f4;
 heapFloat[(r4+13)] = f1;
 heapFloat[(r4+14)] = f2;
 heap32[(r4+15)] = 0;
 r9 = heap32[(r1)];
 r9 = r9 >> 2;
 r9 = heap32[(r9+2)];
 heap32[(g0)] = r6;
 heap32[(g0+1)] = 1073741824;
 heap32[(g0+2)] = r3;
 heap32[(g0+3)] = r2;
 r8 = (r8 + 1)|0;
 __FUNCTION_TABLE__[(r9)>>2](i7);
if(!(r8 !=8)) //_LBB26_161
{
break _229;
}
}
 r7 = (r7 + 1)|0;
if(!(r7 !=8)) //_LBB26_160
{
break _227;
}
}
 f2 =      -0.34999999403953552;
 r0 = (r0 + -1)|0;
 f1 = f1+f3;
 f0 = f0+f2;
 if(r0 ==0) //_LBB26_165
{
break _161;
}
else{
continue _225;
}
}
}
else{
 if(r0 ==2) //_LBB26_166
{
 r3 = heap32[(r2)];
 r3 = (r3 + 1)|0;
 heap32[(r2)] = r3;
 heap32[(g0)] = 71;
 malloc(i7);
 r3 = r_g0;
 if(r3 !=0) //_LBB26_168
{
 r4 = 0;
 r0 = (r3 + 4)|0;
 r4 = (r4 - r0)|0;
 r4 = r4 & 15;
 r4 = (r3 + r4)|0;
 r0 = (r4 + 4)|0;
 r4 = r4 >> 2;
 heap32[(r4)] = r3;
 r3 = r0;
}
 r4 = r3 >> 2;
 heap32[(r4+2)] = 0;
 heap32[(r4+3)] = 1065353216;
 heap32[(r4+4)] = 1065353216;
 heap32[(r4+5)] = 1065353216;
 r0 = _ZTV10btBoxShape;
 heap32[(r4+6)] = 0;
 r0 = (r0 + 8)|0;
 heap32[(r4+11)] = 1025758986;
 heap32[(r4)] = r0;
 heap32[(r4+1)] = 0;
 heap32[(r4+7)] = 1064682127;
 heap32[(r4+8)] = 1064682127;
 heap32[(r4+9)] = 1064682127;
 r5 = sp + -1024;
 heap32[(r4+10)] = 0;
 r4 = r5 >> 2;
 heap32[(fp+-256)] = 1065353216;
 heap32[(r4+1)] = 0;
 heap32[(r4+2)] = 0;
 heap32[(r4+3)] = 0;
 heap32[(r4+4)] = 0;
 heap32[(r4+5)] = 1065353216;
 heap32[(r4+6)] = 0;
 heap32[(r4+7)] = 0;
 heap32[(r4+8)] = 0;
 heap32[(r4+9)] = 0;
 heap32[(r4+10)] = 1065353216;
 heap32[(r4+11)] = 0;
 heap32[(r4+12)] = 0;
 heap32[(r4+13)] = 0;
 heap32[(r4+14)] = 0;
 r7 = sp + -1040;
 heap32[(r4+15)] = 0;
 r8 = r7 >> 2;
 heap32[(fp+-260)] = 0;
 heap32[(r8+1)] = 0;
 heap32[(r8+2)] = 0;
 heap32[(r8+3)] = 0;
 heap32[(g0)] = r3;
 heap32[(g0+1)] = 1065353216;
 heap32[(g0+2)] = r7;
 r7 = 12;
 f0 =       -12.240598678588867;
 f1 =                         1;
 _ZNK10btBoxShape21calculateLocalInertiaEfR9btVector3(i7);
 f2 = f0;
 f8 =                       -20;
_239: while(true){
if(!(r7 <1)) //_LBB26_173
{
 f4 =                         0;
 f3 = f1+f4;
 r8 = 0;
 r9 = r8;
_243: while(true){
 f5 = r9; //fitos r9, f5
 f6 =        2.0400998592376709;
 f5 = f5*f6;
 f5 = f5+f0;
 f5 = f5+f4;
 r10 = r8;
_245: while(true){
 f7 = r10; //fitos r10, f7
 f7 = f7*f6;
 f7 = f7+f2;
 f7 = f7+f8;
 heapFloat[(r4+12)] = f7;
 heapFloat[(r4+13)] = f3;
 heapFloat[(r4+14)] = f5;
 heap32[(r4+15)] = 0;
 r11 = heap32[(r1)];
 r11 = r11 >> 2;
 r11 = heap32[(r11+2)];
 heap32[(g0)] = r6;
 heap32[(g0+1)] = 1065353216;
 heap32[(g0+2)] = r5;
 heap32[(g0+3)] = r3;
 r10 = (r10 + 1)|0;
 __FUNCTION_TABLE__[(r11)>>2](i7);
if(!(r7 !=r10)) //_LBB26_171
{
break _245;
}
}
 r9 = (r9 + 1)|0;
if(!(r7 !=r9)) //_LBB26_170
{
break _243;
}
}
}
 f3 =        2.0400998592376709;
 f4 =        1.0199999809265137;
 r7 = (r7 + -1)|0;
 f1 = f1+f3;
 f0 = f0+f4;
 f2 = f2+f4;
 if(r7 ==0) //_LBB26_176
{
break _239;
}
}
 r3 = sp + -1136;
 r4 = r3 >> 2;
 heap32[(fp+-284)] = 1065353216;
 heap32[(r4+1)] = 1065353216;
 heap32[(r4+2)] = 1065353216;
 r5 = sp + -1120;
 heap32[(r4+3)] = 0;
 r4 = r5 >> 2;
 heap32[(fp+-280)] = -1073741824;
 heap32[(r4+1)] = 0;
 heap32[(r4+2)] = 0;
 heap32[(r4+3)] = 0;
 heap32[(g0)] = r5;
 heap32[(g0+1)] = r3;
 r3 = sp + -1104;
 _ZN13BenchmarkDemo10createWallERK9btVector3iS2_(i7);
 r4 = r3 >> 2;
 heap32[(fp+-276)] = 1065353216;
 heap32[(r4+1)] = 1065353216;
 heap32[(r4+2)] = 1065353216;
 r5 = sp + -1088;
 heap32[(r4+3)] = 0;
 r4 = r5 >> 2;
 heap32[(fp+-272)] = 1082130432;
 heap32[(r4+1)] = 0;
 heap32[(r4+2)] = 0;
 heap32[(r4+3)] = 0;
 heap32[(g0)] = r5;
 heap32[(g0+1)] = r3;
 r3 = sp + -1072;
 _ZN13BenchmarkDemo10createWallERK9btVector3iS2_(i7);
 r4 = r3 >> 2;
 heap32[(fp+-268)] = 1065353216;
 heap32[(r4+1)] = 1065353216;
 heap32[(r4+2)] = 1065353216;
 r5 = sp + -1056;
 heap32[(r4+3)] = 0;
 r4 = r5 >> 2;
 heap32[(fp+-264)] = 1092616192;
 heap32[(r4+1)] = 0;
 heap32[(r4+2)] = 0;
 heap32[(r4+3)] = 0;
 heap32[(g0)] = r5;
 heap32[(g0+1)] = r3;
 _ZN13BenchmarkDemo10createWallERK9btVector3iS2_(i7);
 r3 = heap32[(r2)];
 r3 = (r3 + 1)|0;
 heap32[(r2)] = r3;
 heap32[(g0)] = 71;
 malloc(i7);
 r2 = r_g0;
 if(r2 !=0) //_LBB26_178
{
 r3 = 0;
 r4 = (r2 + 4)|0;
 r3 = (r3 - r4)|0;
 r3 = r3 & 15;
 r3 = (r2 + r3)|0;
 r4 = (r3 + 4)|0;
 r3 = r3 >> 2;
 heap32[(r3)] = r2;
 r2 = r4;
}
 r3 = r2 >> 2;
 heap32[(r3+2)] = 0;
 heap32[(r3+3)] = 1065353216;
 heap32[(r3+4)] = 1065353216;
 heap32[(r3+5)] = 1065353216;
 heap32[(r3+6)] = 0;
 heap32[(r3+11)] = 1025758986;
 heap32[(r3)] = r0;
 heap32[(r3+1)] = 0;
 heap32[(r3+7)] = 1064682127;
 heap32[(r3+8)] = 1064682127;
 heap32[(r3+9)] = 1064682127;
 r4 = sp + -944;
 heap32[(r3+10)] = 0;
 r3 = r4 >> 2;
 heap32[(fp+-236)] = 1065353216;
 heap32[(r3+1)] = 0;
 heap32[(r3+2)] = 0;
 heap32[(r3+3)] = 0;
 heap32[(r3+4)] = 0;
 heap32[(r3+5)] = 1065353216;
 heap32[(r3+6)] = 0;
 heap32[(r3+7)] = 0;
 heap32[(r3+8)] = 0;
 heap32[(r3+9)] = 0;
 heap32[(r3+10)] = 1065353216;
 heap32[(r3+11)] = 0;
 heap32[(r3+12)] = 0;
 heap32[(r3+13)] = 0;
 heap32[(r3+14)] = 0;
 r0 = sp + -960;
 heap32[(r3+15)] = 0;
 r5 = r0 >> 2;
 heap32[(fp+-240)] = 0;
 heap32[(r5+1)] = 0;
 heap32[(r5+2)] = 0;
 heap32[(r5+3)] = 0;
 heap32[(g0)] = r2;
 heap32[(g0+1)] = 1065353216;
 heap32[(g0+2)] = r0;
 r0 = 8;
 f0 =                         1;
 f1 =                         0;
 _ZNK10btBoxShape21calculateLocalInertiaEfR9btVector3(i7);
 f2 = f1;
 f3 = f0;
 f4 = f1;
_253: while(true){
 r5 = 24;
_255: while(true){
 f5 =        9.9312677383422852;
 f6 =                         0;
 f7 = f3*f0;
 f8 = f4*f6;
 f9 = f3*f5;
 f10 = f1*f6;
 f7 = f8+f7;
 f11 = f2*f5;
 f9 = f10+f9;
 f12 = f2*f0;
 f13 = f1*f0;
 f14 = f2*f6;
 f7 = f7+f11;
 f9 = f9-f12;
 f11 = f13+f14;
 f12 = f4*f5;
 f5 = f1*f5;
 f13 = f4*f0;
 f11 = f11-f12;
 f12 = f4*f4;
 f15 = f3*f3;
 f16 = f4*f7;
 f17 = f1*f9;
 f5 = f5+f13;
 f13 = f3*f6;
 f5 = f5-f13;
 f12 = f12+f15;
 f15 = f2*f2;
 f18 = f3*f7;
 f19 = f1*f11;
 f16 = f16+f17;
 f17 = f2*f11;
 f12 = f12+f15;
 f15 = f1*f1;
 f7 = f2*f7;
 f20 = f1*f5;
 f18 = f18+f19;
 f19 = f4*f5;
 f16 = f16-f17;
 f5 = f3*f5;
 f17 =                         2;
 f12 = f12+f15;
 f7 = f7+f20;
 f15 = f3*f9;
 f18 = f18-f19;
 f9 = f2*f9;
 f5 = f16+f5;
 f16 =                        25;
 f12 = f17/f12;
 f9 = f18+f9;
 f5 = f5+f16;
 f7 = f7-f15;
 f11 = f4*f11;
 f15 = f2*f12;
 f16 = f3*f12;
 f7 = f7+f11;
 f9 = f9+f6;
 heapFloat[(r3+12)] = f5;
 f5 = f3*f16;
 f11 = f2*f15;
 f7 = f7+f6;
 heapFloat[(r3+13)] = f9;
 heapFloat[(r3+14)] = f7;
 f7 =                         1;
 f9 = f5+f11;
 f18 = f4*f16;
 f19 = f1*f15;
 f9 = f7-f9;
 heap32[(r3+15)] = 0;
 f20 = f4*f15;
 f16 = f1*f16;
 f21 = f18-f19;
 heapFloat[(fp+-236)] = f9;
 f9 = f4*f12;
 f12 = f20+f16;
 heapFloat[(r3+1)] = f21;
 f21 = f4*f9;
 heapFloat[(r3+2)] = f12;
 f11 = f21+f11;
 f12 = f18+f19;
 heap32[(r3+3)] = 0;
 f15 = f3*f15;
 f9 = f1*f9;
 f11 = f7-f11;
 heapFloat[(r3+4)] = f12;
 f12 = f15-f9;
 heapFloat[(r3+5)] = f11;
 heapFloat[(r3+6)] = f12;
 f11 = f20-f16;
 heap32[(r3+7)] = 0;
 f5 = f21+f5;
 f9 = f15+f9;
 heapFloat[(r3+8)] = f11;
 f5 = f7-f5;
 heapFloat[(r3+9)] = f9;
 heapFloat[(r3+10)] = f5;
 heap32[(r3+11)] = 0;
 r7 = heap32[(r1)];
 r7 = r7 >> 2;
 f5 =       0.99144488573074341;
 f7 =       0.13052619993686676;
 r7 = heap32[(r7+2)];
 f9 = f1*f5;
 f11 = f2*f5;
 f12 = f4*f5;
 f1 = f1*f7;
 f5 = f3*f5;
 f1 = f1+f5;
 f5 = f10+f12;
 f9 = f9-f8;
 f3 = f3*f7;
 f10 = f10+f11;
 f4 = f4*f7;
 f3 = f9-f3;
 f4 = f10+f4;
 f9 = f1+f14;
 heap32[(g0)] = r6;
 heap32[(g0+1)] = 1065353216;
 heap32[(g0+2)] = r4;
 heap32[(g0+3)] = r2;
 f5 = f5+f13;
 f7 = f2*f7;
 r5 = (r5 + -1)|0;
 f1 = f3-f14;
 f2 = f4-f13;
 f3 = f9-f8;
 f4 = f5-f7;
 __FUNCTION_TABLE__[(r7)>>2](i7);
if(!(r5 !=0)) //_LBB26_180
{
break _255;
}
}
 f5 =       0.99785894155502319;
 f7 =      0.065403133630752563;
 f8 = f4*f5;
 f9 = f1*f6;
 f10 = f2*f5;
 f11 = f1*f7;
 f12 = f3*f5;
 f1 = f1*f5;
 f5 = f4*f6;
 f8 = f9+f8;
 f13 = f3*f6;
 f11 = f11+f12;
 f6 = f2*f6;
 f9 = f9+f10;
 f4 = f4*f7;
 f1 = f1-f5;
 f3 = f3*f7;
 f10 = f11+f6;
 f9 = f9+f4;
 f1 = f1-f3;
 f3 = f8+f13;
 f2 = f2*f7;
 r0 = (r0 + -1)|0;
 f4 = f3-f2;
 f3 = f10-f5;
 f2 = f9-f13;
 f1 = f1-f6;
 f0 = f0+f17;
 if(r0 ==0) //_LBB26_165
{
break _161;
}
else{
continue _253;
}
}
}
else{
 if(r0 ==3) //_LBB26_183
{
 r3 = -16;
 r0 = 16;
 f0 =                         0;
 f1 =                         1;
 f2 = f0;
_260: while(true){
 f3 = r3; //fitos r3, f3
 f4 =                         6;
 f3 = f3*f4;
 f5 =                       0.5;
 f6 =                       3.5;
 f7 =        4.2000002861022949;
 f8 =        5.5999999046325684;
 f9 =        2.2749998569488525;
 f10 =       0.69999998807907104;
 f11 =        5.0750002861022949;
 f3 = f3*f5;
 f5 = f2+f0;
 f6 = f1+f6;
 f7 = f1+f7;
 f8 = f1+f8;
 f9 = f1+f9;
 f10 = f1+f10;
 f11 = f1+f11;
 r5 = 0;
_262: while(true){
 heap32[(g0)] = 136;
 _Znwj(i7);
 r7 = r_g0;
 r8 = _ZTV7RagDoll;
 r9 = r7 >> 2;
 r10 = heap32[(r1+1)];
 r8 = (r8 + 8)|0;
 heap32[(r9)] = r8;
 heap32[(r9+1)] = r10;
 r8 = heap32[(r2)];
 r9 = (r8 + 1)|0;
 heap32[(r2)] = r9;
 f12 = r5; //fitos r5, f12
 heap32[(g0)] = 75;
 f12 = f12*f4;
 malloc(i7);
 r9 = r_g0;
 f12 = f12+f3;
 if(r9 !=0) //_LBB26_187
{
 r10 = 0;
 r11 = (r9 + 4)|0;
 r10 = (r10 - r11)|0;
 r10 = r10 & 15;
 r10 = (r9 + r10)|0;
 r11 = (r10 + 4)|0;
 r10 = r10 >> 2;
 heap32[(r10)] = r9;
 r9 = r11;
}
 r10 = r9 >> 2;
 heap32[(r10+2)] = 0;
 heap32[(r10+3)] = 1065353216;
 heap32[(r10+4)] = 1065353216;
 heap32[(r10+5)] = 1065353216;
 r11 = _ZTV14btCapsuleShape;
 heap32[(r10+6)] = 0;
 r11 = (r11 + 8)|0;
 heap32[(r10+11)] = 1025758986;
 heap32[(r10)] = r11;
 heap32[(r10+1)] = 10;
 heap32[(r10+13)] = 1;
 heap32[(r10+7)] = 1057384039;
 heap32[(r10+8)] = 1051931443;
 heap32[(r10+9)] = 1057384039;
 r12 = r7 >> 2;
 heap32[(r10+10)] = 0;
 r10 = (r8 + 2)|0;
 heap32[(r12+2)] = r9;
 heap32[(r2)] = r10;
 heap32[(g0)] = 75;
 malloc(i7);
 r9 = r_g0;
 if(r9 !=0) //_LBB26_190
{
 r10 = 0;
 r13 = (r9 + 4)|0;
 r10 = (r10 - r13)|0;
 r10 = r10 & 15;
 r10 = (r9 + r10)|0;
 r13 = (r10 + 4)|0;
 r10 = r10 >> 2;
 heap32[(r10)] = r9;
 r9 = r13;
}
 r10 = r9 >> 2;
 heap32[(r10+2)] = 0;
 heap32[(r10+3)] = 1065353216;
 heap32[(r10+4)] = 1065353216;
 heap32[(r10+5)] = 1065353216;
 heap32[(r10+6)] = 0;
 heap32[(r10+11)] = 1025758986;
 heap32[(r10)] = r11;
 heap32[(r10+1)] = 10;
 heap32[(r10+13)] = 1;
 heap32[(r10+7)] = 1057384039;
 heap32[(r10+8)] = 1056629064;
 heap32[(r10+9)] = 1057384039;
 heap32[(r10+10)] = 0;
 r10 = (r8 + 3)|0;
 heap32[(r12+3)] = r9;
 heap32[(r2)] = r10;
 heap32[(g0)] = 75;
 malloc(i7);
 r9 = r_g0;
 if(r9 !=0) //_LBB26_193
{
 r10 = 0;
 r13 = (r9 + 4)|0;
 r10 = (r10 - r13)|0;
 r10 = r10 & 15;
 r10 = (r9 + r10)|0;
 r13 = (r10 + 4)|0;
 r10 = r10 >> 2;
 heap32[(r10)] = r9;
 r9 = r13;
}
 r10 = r9 >> 2;
 heap32[(r10+2)] = 0;
 heap32[(r10+3)] = 1065353216;
 heap32[(r10+4)] = 1065353216;
 heap32[(r10+5)] = 1065353216;
 heap32[(r10+6)] = 0;
 heap32[(r10+11)] = 1025758986;
 heap32[(r10)] = r11;
 heap32[(r10+1)] = 10;
 heap32[(r10+13)] = 1;
 heap32[(r10+7)] = 1051931443;
 heap32[(r10+8)] = 1035154227;
 heap32[(r10+9)] = 1051931443;
 heap32[(r10+10)] = 0;
 r10 = (r8 + 4)|0;
 heap32[(r12+4)] = r9;
 heap32[(r2)] = r10;
 heap32[(g0)] = 75;
 malloc(i7);
 r9 = r_g0;
 if(r9 !=0) //_LBB26_196
{
 r10 = 0;
 r13 = (r9 + 4)|0;
 r10 = (r10 - r13)|0;
 r10 = r10 & 15;
 r10 = (r9 + r10)|0;
 r13 = (r10 + 4)|0;
 r10 = r10 >> 2;
 heap32[(r10)] = r9;
 r9 = r13;
}
 r10 = r9 >> 2;
 heap32[(r10+2)] = 0;
 heap32[(r10+3)] = 1065353216;
 heap32[(r10+4)] = 1065353216;
 heap32[(r10+5)] = 1065353216;
 heap32[(r10+6)] = 0;
 heap32[(r10+11)] = 1025758986;
 heap32[(r10)] = r11;
 heap32[(r10+1)] = 10;
 heap32[(r10+13)] = 1;
 heap32[(r10+7)] = 1048240456;
 heap32[(r10+8)] = 1061788057;
 heap32[(r10+9)] = 1048240456;
 heap32[(r10+10)] = 0;
 r10 = (r8 + 5)|0;
 heap32[(r12+5)] = r9;
 heap32[(r2)] = r10;
 heap32[(g0)] = 75;
 malloc(i7);
 r9 = r_g0;
 if(r9 !=0) //_LBB26_199
{
 r10 = 0;
 r13 = (r9 + 4)|0;
 r10 = (r10 - r13)|0;
 r10 = r10 & 15;
 r10 = (r9 + r10)|0;
 r13 = (r10 + 4)|0;
 r10 = r10 >> 2;
 heap32[(r10)] = r9;
 r9 = r13;
}
 r10 = r9 >> 2;
 heap32[(r10+2)] = 0;
 heap32[(r10+3)] = 1065353216;
 heap32[(r10+4)] = 1065353216;
 heap32[(r10+5)] = 1065353216;
 heap32[(r10+6)] = 0;
 heap32[(r10+11)] = 1025758986;
 heap32[(r10)] = r11;
 heap32[(r10+1)] = 10;
 heap32[(r10+13)] = 1;
 heap32[(r10+7)] = 1043542835;
 heap32[(r10+8)] = 1059439248;
 heap32[(r10+9)] = 1043542835;
 heap32[(r10+10)] = 0;
 r10 = (r8 + 6)|0;
 heap32[(r12+6)] = r9;
 heap32[(r2)] = r10;
 heap32[(g0)] = 75;
 malloc(i7);
 r9 = r_g0;
 if(r9 !=0) //_LBB26_202
{
 r10 = 0;
 r13 = (r9 + 4)|0;
 r10 = (r10 - r13)|0;
 r10 = r10 & 15;
 r10 = (r9 + r10)|0;
 r13 = (r10 + 4)|0;
 r10 = r10 >> 2;
 heap32[(r10)] = r9;
 r9 = r13;
}
 r10 = r9 >> 2;
 heap32[(r10+2)] = 0;
 heap32[(r10+3)] = 1065353216;
 heap32[(r10+4)] = 1065353216;
 heap32[(r10+5)] = 1065353216;
 heap32[(r10+6)] = 0;
 heap32[(r10+11)] = 1025758986;
 heap32[(r10)] = r11;
 heap32[(r10+1)] = 10;
 heap32[(r10+13)] = 1;
 heap32[(r10+7)] = 1048240456;
 heap32[(r10+8)] = 1061788057;
 heap32[(r10+9)] = 1048240456;
 heap32[(r10+10)] = 0;
 r10 = (r8 + 7)|0;
 heap32[(r12+7)] = r9;
 heap32[(r2)] = r10;
 heap32[(g0)] = 75;
 malloc(i7);
 r9 = r_g0;
 if(r9 !=0) //_LBB26_205
{
 r10 = 0;
 r13 = (r9 + 4)|0;
 r10 = (r10 - r13)|0;
 r10 = r10 & 15;
 r10 = (r9 + r10)|0;
 r13 = (r10 + 4)|0;
 r10 = r10 >> 2;
 heap32[(r10)] = r9;
 r9 = r13;
}
 r10 = r9 >> 2;
 heap32[(r10+2)] = 0;
 heap32[(r10+3)] = 1065353216;
 heap32[(r10+4)] = 1065353216;
 heap32[(r10+5)] = 1065353216;
 heap32[(r10+6)] = 0;
 heap32[(r10+11)] = 1025758986;
 heap32[(r10)] = r11;
 heap32[(r10+1)] = 10;
 heap32[(r10+13)] = 1;
 heap32[(r10+7)] = 1043542835;
 heap32[(r10+8)] = 1059439248;
 heap32[(r10+9)] = 1043542835;
 heap32[(r10+10)] = 0;
 r10 = (r8 + 8)|0;
 heap32[(r12+8)] = r9;
 heap32[(r2)] = r10;
 heap32[(g0)] = 75;
 malloc(i7);
 r9 = r_g0;
 if(r9 !=0) //_LBB26_208
{
 r10 = 0;
 r13 = (r9 + 4)|0;
 r10 = (r10 - r13)|0;
 r10 = r10 & 15;
 r10 = (r9 + r10)|0;
 r13 = (r10 + 4)|0;
 r10 = r10 >> 2;
 heap32[(r10)] = r9;
 r9 = r13;
}
 r10 = r9 >> 2;
 heap32[(r10+2)] = 0;
 heap32[(r10+3)] = 1065353216;
 heap32[(r10+4)] = 1065353216;
 heap32[(r10+5)] = 1065353216;
 heap32[(r10+6)] = 0;
 heap32[(r10+11)] = 1025758986;
 heap32[(r10)] = r11;
 heap32[(r10+1)] = 10;
 heap32[(r10+13)] = 1;
 heap32[(r10+7)] = 1043542835;
 heap32[(r10+8)] = 1058264843;
 heap32[(r10+9)] = 1043542835;
 heap32[(r10+10)] = 0;
 r10 = (r8 + 9)|0;
 heap32[(r12+9)] = r9;
 heap32[(r2)] = r10;
 heap32[(g0)] = 75;
 malloc(i7);
 r9 = r_g0;
 if(r9 !=0) //_LBB26_211
{
 r10 = 0;
 r13 = (r9 + 4)|0;
 r10 = (r10 - r13)|0;
 r10 = r10 & 15;
 r10 = (r9 + r10)|0;
 r13 = (r10 + 4)|0;
 r10 = r10 >> 2;
 heap32[(r10)] = r9;
 r9 = r13;
}
 r10 = r9 >> 2;
 heap32[(r10+2)] = 0;
 heap32[(r10+3)] = 1065353216;
 heap32[(r10+4)] = 1065353216;
 heap32[(r10+5)] = 1065353216;
 heap32[(r10+6)] = 0;
 heap32[(r10+11)] = 1025758986;
 heap32[(r10)] = r11;
 heap32[(r10+1)] = 10;
 heap32[(r10+13)] = 1;
 heap32[(r10+7)] = 1041194025;
 heap32[(r10+8)] = 1054867456;
 heap32[(r10+9)] = 1041194025;
 heap32[(r10+10)] = 0;
 r10 = (r8 + 10)|0;
 heap32[(r12+10)] = r9;
 heap32[(r2)] = r10;
 heap32[(g0)] = 75;
 malloc(i7);
 r9 = r_g0;
 if(r9 !=0) //_LBB26_214
{
 r10 = 0;
 r13 = (r9 + 4)|0;
 r10 = (r10 - r13)|0;
 r10 = r10 & 15;
 r10 = (r9 + r10)|0;
 r13 = (r10 + 4)|0;
 r10 = r10 >> 2;
 heap32[(r10)] = r9;
 r9 = r13;
}
 r10 = r9 >> 2;
 heap32[(r10+2)] = 0;
 heap32[(r10+3)] = 1065353216;
 heap32[(r10+4)] = 1065353216;
 heap32[(r10+5)] = 1065353216;
 heap32[(r10+6)] = 0;
 heap32[(r10+11)] = 1025758986;
 heap32[(r10)] = r11;
 heap32[(r10+1)] = 10;
 heap32[(r10+13)] = 1;
 heap32[(r10+7)] = 1043542835;
 heap32[(r10+8)] = 1058264843;
 heap32[(r10+9)] = 1043542835;
 heap32[(r10+10)] = 0;
 r8 = (r8 + 11)|0;
 heap32[(r12+11)] = r9;
 heap32[(r2)] = r8;
 heap32[(g0)] = 75;
 malloc(i7);
 r8 = r_g0;
 if(r8 !=0) //_LBB26_217
{
 r9 = 0;
 r10 = (r8 + 4)|0;
 r9 = (r9 - r10)|0;
 r9 = r9 & 15;
 r9 = (r8 + r9)|0;
 r10 = (r9 + 4)|0;
 r9 = r9 >> 2;
 heap32[(r9)] = r8;
 r8 = r10;
}
 r9 = r8 >> 2;
 heap32[(r9+2)] = 0;
 heap32[(r9+3)] = 1065353216;
 heap32[(r9+4)] = 1065353216;
 heap32[(r9+5)] = 1065353216;
 heap32[(r9+6)] = 0;
 heap32[(r9+11)] = 1025758986;
 heap32[(r9)] = r11;
 heap32[(r9+1)] = 10;
 heap32[(r9+13)] = 1;
 heap32[(r9+7)] = 1041194025;
 heap32[(r9+8)] = 1054867456;
 heap32[(r9+9)] = 1041194025;
 heap32[(r9+10)] = 0;
 heap32[(r12+12)] = r8;
 r8 = heap32[(r12+2)];
 r9 = sp + -880;
 r10 = r9 >> 2;
 heap32[(fp+-220)] = 1065353216;
 heap32[(r10+1)] = 0;
 heap32[(r10+2)] = 0;
 heap32[(r10+3)] = 0;
 heap32[(r10+4)] = 0;
 heap32[(r10+5)] = 1065353216;
 heap32[(r10+6)] = 0;
 heap32[(r10+7)] = 0;
 heap32[(r10+8)] = 0;
 heap32[(r10+9)] = 0;
 heap32[(r10+10)] = 1065353216;
 f13 =                         0;
 f13 = f12+f13;
 heap32[(r10+11)] = 0;
 heapFloat[(r10+12)] = f13;
 heapFloat[(r10+13)] = f6;
 heapFloat[(r10+14)] = f5;
 heap32[(r10+15)] = 0;
 heap32[(g0)] = r7;
 heap32[(g0+1)] = r9;
 heap32[(g0+2)] = r8;
 _ZN7RagDoll20localCreateRigidBodyEfRK11btTransformP16btCollisionShape(i7);
 heap32[(r12+13)] = r_g0;
 r8 = heap32[(r12+3)];
 r9 = sp + -816;
 r10 = r9 >> 2;
 heap32[(fp+-204)] = 1065353216;
 heap32[(r10+1)] = 0;
 heap32[(r10+2)] = 0;
 heap32[(r10+3)] = 0;
 heap32[(r10+4)] = 0;
 heap32[(r10+5)] = 1065353216;
 heap32[(r10+6)] = 0;
 heap32[(r10+7)] = 0;
 heap32[(r10+8)] = 0;
 heap32[(r10+9)] = 0;
 heap32[(r10+10)] = 1065353216;
 heap32[(r10+11)] = 0;
 heapFloat[(r10+12)] = f13;
 heapFloat[(r10+13)] = f7;
 heapFloat[(r10+14)] = f5;
 heap32[(r10+15)] = 0;
 heap32[(g0)] = r7;
 heap32[(g0+1)] = r9;
 heap32[(g0+2)] = r8;
 _ZN7RagDoll20localCreateRigidBodyEfRK11btTransformP16btCollisionShape(i7);
 heap32[(r12+14)] = r_g0;
 r8 = heap32[(r12+4)];
 r9 = sp + -752;
 r10 = r9 >> 2;
 heap32[(fp+-188)] = 1065353216;
 heap32[(r10+1)] = 0;
 heap32[(r10+2)] = 0;
 heap32[(r10+3)] = 0;
 heap32[(r10+4)] = 0;
 heap32[(r10+5)] = 1065353216;
 heap32[(r10+6)] = 0;
 heap32[(r10+7)] = 0;
 heap32[(r10+8)] = 0;
 heap32[(r10+9)] = 0;
 heap32[(r10+10)] = 1065353216;
 heap32[(r10+11)] = 0;
 heapFloat[(r10+12)] = f13;
 heapFloat[(r10+13)] = f8;
 heapFloat[(r10+14)] = f5;
 heap32[(r10+15)] = 0;
 heap32[(g0)] = r7;
 heap32[(g0+1)] = r9;
 heap32[(g0+2)] = r8;
 _ZN7RagDoll20localCreateRigidBodyEfRK11btTransformP16btCollisionShape(i7);
 heap32[(r12+15)] = r_g0;
 r8 = heap32[(r12+5)];
 r9 = sp + -688;
 r10 = r9 >> 2;
 heap32[(fp+-172)] = 1065353216;
 heap32[(r10+1)] = 0;
 heap32[(r10+2)] = 0;
 heap32[(r10+3)] = 0;
 heap32[(r10+4)] = 0;
 heap32[(r10+5)] = 1065353216;
 heap32[(r10+6)] = 0;
 heap32[(r10+7)] = 0;
 heap32[(r10+8)] = 0;
 heap32[(r10+9)] = 0;
 f13 =      -0.62999999523162842;
 heap32[(r10+10)] = 1065353216;
 f13 = f12+f13;
 heap32[(r10+11)] = 0;
 heapFloat[(r10+12)] = f13;
 heapFloat[(r10+13)] = f9;
 heapFloat[(r10+14)] = f5;
 heap32[(r10+15)] = 0;
 heap32[(g0)] = r7;
 heap32[(g0+1)] = r9;
 heap32[(g0+2)] = r8;
 _ZN7RagDoll20localCreateRigidBodyEfRK11btTransformP16btCollisionShape(i7);
 heap32[(r12+16)] = r_g0;
 r8 = heap32[(r12+6)];
 r9 = sp + -624;
 r10 = r9 >> 2;
 heap32[(fp+-156)] = 1065353216;
 heap32[(r10+1)] = 0;
 heap32[(r10+2)] = 0;
 heap32[(r10+3)] = 0;
 heap32[(r10+4)] = 0;
 heap32[(r10+5)] = 1065353216;
 heap32[(r10+6)] = 0;
 heap32[(r10+7)] = 0;
 heap32[(r10+8)] = 0;
 heap32[(r10+9)] = 0;
 heap32[(r10+10)] = 1065353216;
 heap32[(r10+11)] = 0;
 heapFloat[(r10+12)] = f13;
 heapFloat[(r10+13)] = f10;
 heapFloat[(r10+14)] = f5;
 heap32[(r10+15)] = 0;
 heap32[(g0)] = r7;
 heap32[(g0+1)] = r9;
 heap32[(g0+2)] = r8;
 _ZN7RagDoll20localCreateRigidBodyEfRK11btTransformP16btCollisionShape(i7);
 heap32[(r12+17)] = r_g0;
 r8 = heap32[(r12+7)];
 r9 = sp + -560;
 r10 = r9 >> 2;
 heap32[(fp+-140)] = 1065353216;
 heap32[(r10+1)] = 0;
 heap32[(r10+2)] = 0;
 heap32[(r10+3)] = 0;
 heap32[(r10+4)] = 0;
 heap32[(r10+5)] = 1065353216;
 heap32[(r10+6)] = 0;
 heap32[(r10+7)] = 0;
 heap32[(r10+8)] = 0;
 heap32[(r10+9)] = 0;
 f13 =       0.62999999523162842;
 heap32[(r10+10)] = 1065353216;
 f13 = f12+f13;
 heap32[(r10+11)] = 0;
 heapFloat[(r10+12)] = f13;
 heapFloat[(r10+13)] = f9;
 heapFloat[(r10+14)] = f5;
 heap32[(r10+15)] = 0;
 heap32[(g0)] = r7;
 heap32[(g0+1)] = r9;
 heap32[(g0+2)] = r8;
 _ZN7RagDoll20localCreateRigidBodyEfRK11btTransformP16btCollisionShape(i7);
 heap32[(r12+18)] = r_g0;
 r8 = heap32[(r12+8)];
 r9 = sp + -496;
 r10 = r9 >> 2;
 heap32[(fp+-124)] = 1065353216;
 heap32[(r10+1)] = 0;
 heap32[(r10+2)] = 0;
 heap32[(r10+3)] = 0;
 heap32[(r10+4)] = 0;
 heap32[(r10+5)] = 1065353216;
 heap32[(r10+6)] = 0;
 heap32[(r10+7)] = 0;
 heap32[(r10+8)] = 0;
 heap32[(r10+9)] = 0;
 heap32[(r10+10)] = 1065353216;
 heap32[(r10+11)] = 0;
 heapFloat[(r10+12)] = f13;
 heapFloat[(r10+13)] = f10;
 heapFloat[(r10+14)] = f5;
 heap32[(r10+15)] = 0;
 heap32[(g0)] = r7;
 heap32[(g0+1)] = r9;
 heap32[(g0+2)] = r8;
 _ZN7RagDoll20localCreateRigidBodyEfRK11btTransformP16btCollisionShape(i7);
 heap32[(r12+19)] = r_g0;
 r8 = heap32[(r12+9)];
 r9 = sp + -432;
 r10 = r9 >> 2;
 heap32[(fp+-108)] = -1287930578;
 heap32[(r10+1)] = -1082130432;
 heap32[(r10+2)] = 0;
 heap32[(r10+3)] = 0;
 heap32[(r10+4)] = 1065353216;
 heap32[(r10+5)] = -1287930578;
 heap32[(r10+6)] = 0;
 heap32[(r10+7)] = 0;
 heap32[(r10+8)] = 0;
 heap32[(r10+9)] = 0;
 f13 =       -1.2250000238418579;
 heap32[(r10+10)] = 1065353216;
 f13 = f12+f13;
 heap32[(r10+11)] = 0;
 heapFloat[(r10+12)] = f13;
 heapFloat[(r10+13)] = f11;
 heapFloat[(r10+14)] = f5;
 heap32[(r10+15)] = 0;
 heap32[(g0)] = r7;
 heap32[(g0+1)] = r9;
 heap32[(g0+2)] = r8;
 _ZN7RagDoll20localCreateRigidBodyEfRK11btTransformP16btCollisionShape(i7);
 heap32[(r12+20)] = r_g0;
 r8 = heap32[(r12+10)];
 r9 = sp + -368;
 r10 = r9 >> 2;
 heap32[(fp+-92)] = -1287930578;
 heap32[(r10+1)] = -1082130432;
 heap32[(r10+2)] = 0;
 heap32[(r10+3)] = 0;
 heap32[(r10+4)] = 1065353216;
 heap32[(r10+5)] = -1287930578;
 heap32[(r10+6)] = 0;
 heap32[(r10+7)] = 0;
 heap32[(r10+8)] = 0;
 heap32[(r10+9)] = 0;
 f13 =       -2.4500000476837158;
 heap32[(r10+10)] = 1065353216;
 f13 = f12+f13;
 heap32[(r10+11)] = 0;
 heapFloat[(r10+12)] = f13;
 heapFloat[(r10+13)] = f11;
 heapFloat[(r10+14)] = f5;
 heap32[(r10+15)] = 0;
 heap32[(g0)] = r7;
 heap32[(g0+1)] = r9;
 heap32[(g0+2)] = r8;
 _ZN7RagDoll20localCreateRigidBodyEfRK11btTransformP16btCollisionShape(i7);
 heap32[(r12+21)] = r_g0;
 r8 = heap32[(r12+11)];
 r9 = sp + -304;
 r10 = r9 >> 2;
 heap32[(fp+-76)] = -1287930578;
 heap32[(r10+1)] = 1065353216;
 heap32[(r10+2)] = 0;
 heap32[(r10+3)] = 0;
 heap32[(r10+4)] = -1082130432;
 heap32[(r10+5)] = -1287930578;
 heap32[(r10+6)] = 0;
 heap32[(r10+7)] = 0;
 heap32[(r10+8)] = -2147483648;
 heap32[(r10+9)] = 0;
 f13 =        1.2250000238418579;
 heap32[(r10+10)] = 1065353216;
 f13 = f12+f13;
 heap32[(r10+11)] = 0;
 heapFloat[(r10+12)] = f13;
 heapFloat[(r10+13)] = f11;
 heapFloat[(r10+14)] = f5;
 heap32[(r10+15)] = 0;
 heap32[(g0)] = r7;
 heap32[(g0+1)] = r9;
 heap32[(g0+2)] = r8;
 _ZN7RagDoll20localCreateRigidBodyEfRK11btTransformP16btCollisionShape(i7);
 heap32[(r12+22)] = r_g0;
 r8 = heap32[(r12+12)];
 r9 = sp + -240;
 r10 = r9 >> 2;
 heap32[(fp+-60)] = -1287930578;
 heap32[(r10+1)] = 1065353216;
 heap32[(r10+2)] = 0;
 heap32[(r10+3)] = 0;
 heap32[(r10+4)] = -1082130432;
 heap32[(r10+5)] = -1287930578;
 heap32[(r10+6)] = 0;
 heap32[(r10+7)] = 0;
 heap32[(r10+8)] = -2147483648;
 heap32[(r10+9)] = 0;
 f13 =        2.4500000476837158;
 heap32[(r10+10)] = 1065353216;
 f12 = f12+f13;
 heap32[(r10+11)] = 0;
 heapFloat[(r10+12)] = f12;
 heapFloat[(r10+13)] = f11;
 heapFloat[(r10+14)] = f5;
 heap32[(r10+15)] = 0;
 heap32[(g0)] = r7;
 heap32[(g0+1)] = r9;
 heap32[(g0+2)] = r8;
 _ZN7RagDoll20localCreateRigidBodyEfRK11btTransformP16btCollisionShape(i7);
 r9 = 0;
 heap32[(r12+23)] = r_g0;
_297: while(true){
 r8 = r9 << 2;
 r8 = (r7 - r8)|0;
 r8 = r8 >> 2;
 r10 = heap32[(r8+13)];
 r10 = r10 >> 2;
 heap32[(r10+109)] = 1028443341;
 heap32[(r10+110)] = 1062836634;
 r10 = heap32[(r8+13)];
 r10 = r10 >> 2;
 heap32[(r10+55)] = 1061997773;
 r8 = heap32[(r8+13)];
 r8 = r8 >> 2;
 r9 = (r9 + -1)|0;
 heap32[(r8+116)] = 1070386381;
 heap32[(r8+117)] = 1075838976;
if(!(r9 !=-11)) //_LBB26_219
{
break _297;
}
}
 heap32[(g0)] = 748;
 _Znwj(i7);
 r8 = r_g0;
 r9 = heap32[(r12+14)];
 r10 = heap32[(r12+13)];
 r11 = r8 >> 2;
 heap32[(r11+1)] = 4;
 heap32[(r11+2)] = -1;
 r13 = 0;
 heap32[(r11+3)] = -1;
 heap8[r8+16] = r13;
 heap32[(r11+5)] = r10;
 heap32[(r11+6)] = r9;
 r9 = _ZTV17btHingeConstraint;
 heap32[(r11+7)] = 0;
 r9 = (r9 + 8)|0;
 heap32[(r11+8)] = 1050253722;
 heap32[(r11)] = r9;
 heap32[(r11+135)] = -1287930578;
 heap32[(r11+136)] = 0;
 heap32[(r11+137)] = 1065353216;
 heap32[(r11+138)] = 0;
 heap32[(r11+139)] = -2147483648;
 heap32[(r11+140)] = 1065353216;
 heap32[(r11+141)] = 0;
 heap32[(r11+142)] = 0;
 heap32[(r11+143)] = -1082130432;
 heap32[(r11+144)] = -2147483648;
 heap32[(r11+145)] = -1287930578;
 heap32[(r11+146)] = 0;
 heap32[(r11+147)] = 0;
 heap32[(r11+148)] = 1057384039;
 heap32[(r11+149)] = 0;
 heap32[(r11+150)] = 0;
 heap32[(r11+151)] = -1287930578;
 heap32[(r11+152)] = 0;
 heap32[(r11+153)] = 1065353216;
 heap32[(r11+154)] = 0;
 heap32[(r11+155)] = -2147483648;
 heap32[(r11+156)] = 1065353216;
 heap32[(r11+157)] = 0;
 heap32[(r11+158)] = 0;
 heap32[(r11+159)] = -1082130432;
 heap32[(r11+160)] = -2147483648;
 heap32[(r11+161)] = -1287930578;
 heap32[(r11+162)] = 0;
 heap32[(r11+163)] = 0;
 heap32[(r11+164)] = -1090099609;
 heap32[(r11+165)] = 0;
 heap32[(r11+166)] = 0;
 heap8[r8+720] = r13;
 heap8[r8+721] = r13;
 heap8[r8+723] = r13;
 heap8[r8+724] = r4;
 heap8[r8+725] = r13;
 heap32[(r11+183)] = 0;
 heap32[(r11+172)] = 1065353216;
 heap32[(r11+173)] = -1082130432;
 heap32[(r11+170)] = 1050253722;
 heap32[(r11+171)] = 1065353216;
 heap32[(r11+169)] = 1063675494;
 heap8[r8+722] = r13;
 heap32[(r11+179)] = 1065353216;
 heap32[(g0)] = -1085730853;
 heap32[(g0+1)] = 1086918619;
 fmodf(i7);
 f12 = f_g0;
 f13 =       -3.1415927410125732;
 if(f12 >=f13) //_LBB26_222
{
 f14 =        3.1415927410125732;
 if(f12 >f14) //_LBB26_224
{
 f14 =       -6.2831854820251465;
 f12 = f12+f14;
}
}
else{
 f14 =        6.2831854820251465;
 f12 = f12+f14;
}
 r10 = r8 >> 2;
 heapFloat[(r10+172)] = f12;
 heap32[(g0)] = 1070141403;
 heap32[(g0+1)] = 1086918619;
 fmodf(i7);
 f12 = f_g0;
 if(f12 >=f13) //_LBB26_227
{
 f14 =        3.1415927410125732;
 if(f12 >f14) //_LBB26_229
{
 f14 =       -6.2831854820251465;
 f12 = f12+f14;
}
}
else{
 f14 =        6.2831854820251465;
 f12 = f12+f14;
}
 heapFloat[(r10+173)] = f12;
 heap32[(r10+169)] = 1063675494;
 heap32[(r10+170)] = 1050253722;
 heap32[(r10+171)] = 1065353216;
 heap32[(r12+24)] = r8;
 r10 = heap32[(r12+1)];
 r11 = r10 >> 2;
 r11 = heap32[(r11)];
 r11 = r11 >> 2;
 r11 = heap32[(r11+13)];
 heap32[(g0)] = r10;
 heap32[(g0+1)] = r8;
 heap32[(g0+2)] = 1;
 __FUNCTION_TABLE__[(r11)>>2](i7);
 heap32[(g0)] = 596;
 _Znwj(i7);
 r10 = heap32[(r12+15)];
 r11 = heap32[(r12+14)];
 r14 = r_g0 >> 2;
 heap32[(r14+1)] = 5;
 heap32[(r14+2)] = -1;
 heap32[(r14+3)] = -1;
 heap8[r_g0+16] = r13;
 heap32[(r14+5)] = r11;
 heap32[(r14+6)] = r10;
 heap32[(r14+7)] = 0;
 r10 = _ZTV21btConeTwistConstraint;
 heap32[(r14+8)] = 1050253722;
 r10 = (r10 + 8)|0;
 heap32[(r14)] = r10;
 heap32[(r14+72)] = -1287930578;
 heap32[(r14+73)] = -1082130432;
 heap32[(r14+74)] = 0;
 heap32[(r14+75)] = 0;
 heap32[(r14+76)] = 1065353216;
 heap32[(r14+77)] = -1287930578;
 heap32[(r14+78)] = 0;
 heap32[(r14+79)] = 0;
 heap32[(r14+80)] = -2147483648;
 heap32[(r14+81)] = 0;
 heap32[(r14+82)] = 1065353216;
 heap32[(r14+83)] = 0;
 heap32[(r14+84)] = 0;
 heap32[(r14+85)] = 1065772647;
 heap32[(r14+86)] = 0;
 heap32[(r14+87)] = 0;
 heap32[(r14+88)] = -1287930578;
 heap32[(r14+89)] = -1082130432;
 heap32[(r14+90)] = 0;
 heap32[(r14+91)] = 0;
 heap32[(r14+92)] = 1065353216;
 heap32[(r14+93)] = -1287930578;
 heap32[(r14+94)] = 0;
 heap32[(r14+95)] = 0;
 heap32[(r14+96)] = -2147483648;
 heap32[(r14+97)] = 0;
 heap32[(r14+98)] = 1065353216;
 heap32[(r14+99)] = 0;
 heap32[(r14+100)] = 0;
 heap32[(r14+101)] = -1090854584;
 heap32[(r14+102)] = 0;
 heap32[(r14+103)] = 0;
 heap8[r_g0+540] = r13;
 heap32[(r14+128)] = 0;
 heap32[(r14+140)] = -1082130432;
 heap32[(r14+107)] = 1008981770;
 heap32[(r14+111)] = 1028443341;
 heap32[(r14+145)] = 0;
 heap32[(r14+146)] = 0;
 heap32[(r14+147)] = 1060320051;
 heap32[(r14+148)] = 0;
 heap32[(r14+108)] = 1061752795;
 heap32[(r14+109)] = 1061752795;
 heap32[(r14+110)] = 1070141403;
 heap32[(r14+104)] = 1065353216;
 heap32[(r14+105)] = 1050253722;
 heap32[(r14+106)] = 1065353216;
 heap32[(r12+25)] = r_g0;
 r11 = heap32[(r12+1)];
 r14 = r11 >> 2;
 r14 = heap32[(r14)];
 r14 = r14 >> 2;
 r14 = heap32[(r14+13)];
 heap32[(g0)] = r11;
 heap32[(g0+1)] = r_g0;
 heap32[(g0+2)] = 1;
 __FUNCTION_TABLE__[(r14)>>2](i7);
 heap32[(g0)] = 596;
 _Znwj(i7);
 r11 = heap32[(r12+16)];
 r14 = heap32[(r12+13)];
 r15 = r_g0 >> 2;
 heap32[(r15+1)] = 5;
 heap32[(r15+2)] = -1;
 heap32[(r15+3)] = -1;
 heap8[r_g0+16] = r13;
 heap32[(r15+5)] = r14;
 heap32[(r15+6)] = r11;
 heap32[(r15+7)] = 0;
 heap32[(r15+8)] = 1050253722;
 heap32[(r15)] = r10;
 heap32[(r15+72)] = -1087044364;
 heap32[(r15+73)] = -1087044366;
 heap32[(r15+74)] = 0;
 heap32[(r15+75)] = 0;
 heap32[(r15+76)] = 1060439282;
 heap32[(r15+77)] = -1087044364;
 heap32[(r15+78)] = 0;
 heap32[(r15+79)] = 0;
 heap32[(r15+80)] = -2147483648;
 heap32[(r15+81)] = 0;
 heap32[(r15+82)] = 1065353216;
 heap32[(r15+83)] = 0;
 heap32[(r15+84)] = -1088338002;
 heap32[(r15+85)] = -1095552205;
 heap32[(r15+86)] = 0;
 heap32[(r15+87)] = 0;
 heap32[(r15+88)] = -1087044364;
 heap32[(r15+89)] = -1087044366;
 heap32[(r15+90)] = 0;
 heap32[(r15+91)] = 0;
 heap32[(r15+92)] = 1060439282;
 heap32[(r15+93)] = -1087044364;
 heap32[(r15+94)] = 0;
 heap32[(r15+95)] = 0;
 heap32[(r15+96)] = -2147483648;
 heap32[(r15+97)] = 0;
 heap32[(r15+98)] = 1065353216;
 heap32[(r15+99)] = 0;
 heap32[(r15+100)] = 0;
 heap32[(r15+101)] = 1061788057;
 heap32[(r15+102)] = 0;
 heap32[(r15+103)] = 0;
 heap8[r_g0+540] = r13;
 heap32[(r15+128)] = 0;
 heap32[(r15+140)] = -1082130432;
 heap32[(r15+107)] = 1008981770;
 heap32[(r15+111)] = 1028443341;
 heap32[(r15+145)] = 0;
 heap32[(r15+146)] = 0;
 heap32[(r15+147)] = 1060320051;
 heap32[(r15+148)] = 0;
 heap32[(r15+108)] = 1061752795;
 heap32[(r15+109)] = 1061752795;
 heap32[(r15+110)] = 0;
 heap32[(r15+104)] = 1065353216;
 heap32[(r15+105)] = 1050253722;
 heap32[(r15+106)] = 1065353216;
 heap32[(r12+26)] = r_g0;
 r11 = heap32[(r12+1)];
 r14 = r11 >> 2;
 r14 = heap32[(r14)];
 r14 = r14 >> 2;
 r14 = heap32[(r14+13)];
 heap32[(g0)] = r11;
 heap32[(g0+1)] = r_g0;
 heap32[(g0+2)] = 1;
 __FUNCTION_TABLE__[(r14)>>2](i7);
 heap32[(g0)] = 748;
 _Znwj(i7);
 r8 = r_g0;
 r11 = heap32[(r12+17)];
 r14 = heap32[(r12+16)];
 r15 = r8 >> 2;
 heap32[(r15+1)] = 4;
 heap32[(r15+2)] = -1;
 heap32[(r15+3)] = -1;
 heap8[r8+16] = r13;
 heap32[(r15+5)] = r14;
 heap32[(r15+6)] = r11;
 heap32[(r15+7)] = 0;
 heap32[(r15+8)] = 1050253722;
 heap32[(r15)] = r9;
 heap32[(r15+135)] = -1287930578;
 heap32[(r15+136)] = 0;
 heap32[(r15+137)] = 1065353216;
 heap32[(r15+138)] = 0;
 heap32[(r15+139)] = -2147483648;
 heap32[(r15+140)] = 1065353216;
 heap32[(r15+141)] = 0;
 heap32[(r15+142)] = 0;
 heap32[(r15+143)] = -1082130432;
 heap32[(r15+144)] = -2147483648;
 heap32[(r15+145)] = -1287930578;
 heap32[(r15+146)] = 0;
 heap32[(r15+147)] = 0;
 heap32[(r15+148)] = -1085695591;
 heap32[(r15+149)] = 0;
 heap32[(r15+150)] = 0;
 heap32[(r15+151)] = -1287930578;
 heap32[(r15+152)] = 0;
 heap32[(r15+153)] = 1065353216;
 heap32[(r15+154)] = 0;
 heap32[(r15+155)] = -2147483648;
 heap32[(r15+156)] = 1065353216;
 heap32[(r15+157)] = 0;
 heap32[(r15+158)] = 0;
 heap32[(r15+159)] = -1082130432;
 heap32[(r15+160)] = -2147483648;
 heap32[(r15+161)] = -1287930578;
 heap32[(r15+162)] = 0;
 heap32[(r15+163)] = 0;
 heap32[(r15+164)] = 1059439248;
 heap32[(r15+165)] = 0;
 heap32[(r15+166)] = 0;
 heap8[r8+720] = r13;
 heap8[r8+721] = r13;
 heap8[r8+723] = r13;
 heap8[r8+724] = r4;
 heap8[r8+725] = r13;
 heap32[(r15+183)] = 0;
 heap32[(r15+172)] = 1065353216;
 heap32[(r15+173)] = -1082130432;
 heap32[(r15+170)] = 1050253722;
 heap32[(r15+171)] = 1065353216;
 heap32[(r15+169)] = 1063675494;
 heap8[r8+722] = r13;
 heap32[(r15+179)] = 1065353216;
 heap32[(g0)] = 0;
 heap32[(g0+1)] = 1086918619;
 fmodf(i7);
 f12 = f_g0;
 if(f12 >=f13) //_LBB26_232
{
 f14 =        3.1415927410125732;
 if(f12 >f14) //_LBB26_234
{
 f14 =       -6.2831854820251465;
 f12 = f12+f14;
}
}
else{
 f14 =        6.2831854820251465;
 f12 = f12+f14;
}
 r11 = r8 >> 2;
 heapFloat[(r11+172)] = f12;
 heap32[(g0)] = 1070141403;
 heap32[(g0+1)] = 1086918619;
 fmodf(i7);
 f12 = f_g0;
 if(f12 >=f13) //_LBB26_237
{
 f14 =        3.1415927410125732;
 if(f12 >f14) //_LBB26_239
{
 f14 =       -6.2831854820251465;
 f12 = f12+f14;
}
}
else{
 f14 =        6.2831854820251465;
 f12 = f12+f14;
}
 heapFloat[(r11+173)] = f12;
 heap32[(r11+169)] = 1063675494;
 heap32[(r11+170)] = 1050253722;
 heap32[(r11+171)] = 1065353216;
 heap32[(r12+27)] = r8;
 r11 = heap32[(r12+1)];
 r14 = r11 >> 2;
 r14 = heap32[(r14)];
 r14 = r14 >> 2;
 r14 = heap32[(r14+13)];
 heap32[(g0)] = r11;
 heap32[(g0+1)] = r8;
 heap32[(g0+2)] = 1;
 __FUNCTION_TABLE__[(r14)>>2](i7);
 heap32[(g0)] = 596;
 _Znwj(i7);
 r11 = heap32[(r12+18)];
 r14 = heap32[(r12+13)];
 r15 = r_g0 >> 2;
 heap32[(r15+1)] = 5;
 heap32[(r15+2)] = -1;
 heap32[(r15+3)] = -1;
 heap8[r_g0+16] = r13;
 heap32[(r15+5)] = r14;
 heap32[(r15+6)] = r11;
 heap32[(r15+7)] = 0;
 heap32[(r15+8)] = 1050253722;
 heap32[(r15)] = r10;
 heap32[(r15+72)] = 1060439283;
 heap32[(r15+73)] = -1087044365;
 heap32[(r15+74)] = 0;
 heap32[(r15+75)] = 0;
 heap32[(r15+76)] = 1060439283;
 heap32[(r15+77)] = 1060439283;
 heap32[(r15+78)] = 0;
 heap32[(r15+79)] = 0;
 heap32[(r15+80)] = -2147483648;
 heap32[(r15+81)] = 0;
 heap32[(r15+82)] = 1065353216;
 heap32[(r15+83)] = 0;
 heap32[(r15+84)] = 1059145646;
 heap32[(r15+85)] = -1095552205;
 heap32[(r15+86)] = 0;
 heap32[(r15+87)] = 0;
 heap32[(r15+88)] = 1060439283;
 heap32[(r15+89)] = -1087044365;
 heap32[(r15+90)] = 0;
 heap32[(r15+91)] = 0;
 heap32[(r15+92)] = 1060439283;
 heap32[(r15+93)] = 1060439283;
 heap32[(r15+94)] = 0;
 heap32[(r15+95)] = 0;
 heap32[(r15+96)] = -2147483648;
 heap32[(r15+97)] = 0;
 heap32[(r15+98)] = 1065353216;
 heap32[(r15+99)] = 0;
 heap32[(r15+100)] = 0;
 heap32[(r15+101)] = 1061788057;
 heap32[(r15+102)] = 0;
 heap32[(r15+103)] = 0;
 heap8[r_g0+540] = r13;
 heap32[(r15+128)] = 0;
 heap32[(r15+140)] = -1082130432;
 heap32[(r15+107)] = 1008981770;
 heap32[(r15+111)] = 1028443341;
 heap32[(r15+145)] = 0;
 heap32[(r15+146)] = 0;
 heap32[(r15+147)] = 1060320051;
 heap32[(r15+148)] = 0;
 heap32[(r15+108)] = 1061752795;
 heap32[(r15+109)] = 1061752795;
 heap32[(r15+110)] = 0;
 heap32[(r15+104)] = 1065353216;
 heap32[(r15+105)] = 1050253722;
 heap32[(r15+106)] = 1065353216;
 heap32[(r12+28)] = r_g0;
 r11 = heap32[(r12+1)];
 r14 = r11 >> 2;
 r14 = heap32[(r14)];
 r14 = r14 >> 2;
 r14 = heap32[(r14+13)];
 heap32[(g0)] = r11;
 heap32[(g0+1)] = r_g0;
 heap32[(g0+2)] = 1;
 __FUNCTION_TABLE__[(r14)>>2](i7);
 heap32[(g0)] = 748;
 _Znwj(i7);
 r8 = r_g0;
 r11 = heap32[(r12+19)];
 r14 = heap32[(r12+18)];
 r15 = r8 >> 2;
 heap32[(r15+1)] = 4;
 heap32[(r15+2)] = -1;
 heap32[(r15+3)] = -1;
 heap8[r8+16] = r13;
 heap32[(r15+5)] = r14;
 heap32[(r15+6)] = r11;
 heap32[(r15+7)] = 0;
 heap32[(r15+8)] = 1050253722;
 heap32[(r15)] = r9;
 heap32[(r15+135)] = -1287930578;
 heap32[(r15+136)] = 0;
 heap32[(r15+137)] = 1065353216;
 heap32[(r15+138)] = 0;
 heap32[(r15+139)] = -2147483648;
 heap32[(r15+140)] = 1065353216;
 heap32[(r15+141)] = 0;
 heap32[(r15+142)] = 0;
 heap32[(r15+143)] = -1082130432;
 heap32[(r15+144)] = -2147483648;
 heap32[(r15+145)] = -1287930578;
 heap32[(r15+146)] = 0;
 heap32[(r15+147)] = 0;
 heap32[(r15+148)] = -1085695591;
 heap32[(r15+149)] = 0;
 heap32[(r15+150)] = 0;
 heap32[(r15+151)] = -1287930578;
 heap32[(r15+152)] = 0;
 heap32[(r15+153)] = 1065353216;
 heap32[(r15+154)] = 0;
 heap32[(r15+155)] = -2147483648;
 heap32[(r15+156)] = 1065353216;
 heap32[(r15+157)] = 0;
 heap32[(r15+158)] = 0;
 heap32[(r15+159)] = -1082130432;
 heap32[(r15+160)] = -2147483648;
 heap32[(r15+161)] = -1287930578;
 heap32[(r15+162)] = 0;
 heap32[(r15+163)] = 0;
 heap32[(r15+164)] = 1059439248;
 heap32[(r15+165)] = 0;
 heap32[(r15+166)] = 0;
 heap8[r8+720] = r13;
 heap8[r8+721] = r13;
 heap8[r8+723] = r13;
 heap8[r8+724] = r4;
 heap8[r8+725] = r13;
 heap32[(r15+183)] = 0;
 heap32[(r15+172)] = 1065353216;
 heap32[(r15+173)] = -1082130432;
 heap32[(r15+170)] = 1050253722;
 heap32[(r15+171)] = 1065353216;
 heap32[(r15+169)] = 1063675494;
 heap8[r8+722] = r13;
 heap32[(r15+179)] = 1065353216;
 heap32[(g0)] = 0;
 heap32[(g0+1)] = 1086918619;
 fmodf(i7);
 f12 = f_g0;
 if(f12 >=f13) //_LBB26_242
{
 f14 =        3.1415927410125732;
 if(f12 >f14) //_LBB26_244
{
 f14 =       -6.2831854820251465;
 f12 = f12+f14;
}
}
else{
 f14 =        6.2831854820251465;
 f12 = f12+f14;
}
 r11 = r8 >> 2;
 heapFloat[(r11+172)] = f12;
 heap32[(g0)] = 1070141403;
 heap32[(g0+1)] = 1086918619;
 fmodf(i7);
 f12 = f_g0;
 if(f12 >=f13) //_LBB26_247
{
 f14 =        3.1415927410125732;
 if(f12 >f14) //_LBB26_249
{
 f14 =       -6.2831854820251465;
 f12 = f12+f14;
}
}
else{
 f14 =        6.2831854820251465;
 f12 = f12+f14;
}
 heapFloat[(r11+173)] = f12;
 heap32[(r11+169)] = 1063675494;
 heap32[(r11+170)] = 1050253722;
 heap32[(r11+171)] = 1065353216;
 heap32[(r12+29)] = r8;
 r11 = heap32[(r12+1)];
 r14 = r11 >> 2;
 r14 = heap32[(r14)];
 r14 = r14 >> 2;
 r14 = heap32[(r14+13)];
 heap32[(g0)] = r11;
 heap32[(g0+1)] = r8;
 heap32[(g0+2)] = 1;
 __FUNCTION_TABLE__[(r14)>>2](i7);
 heap32[(g0)] = 596;
 _Znwj(i7);
 r11 = heap32[(r12+20)];
 r14 = heap32[(r12+14)];
 r15 = r_g0 >> 2;
 heap32[(r15+1)] = 5;
 heap32[(r15+2)] = -1;
 heap32[(r15+3)] = -1;
 heap8[r_g0+16] = r13;
 heap32[(r15+5)] = r14;
 heap32[(r15+6)] = r11;
 heap32[(r15+7)] = 0;
 heap32[(r15+8)] = 1050253722;
 heap32[(r15)] = r10;
 heap32[(r15+72)] = -1082130432;
 heap32[(r15+73)] = 867941678;
 heap32[(r15+74)] = -2147483648;
 heap32[(r15+75)] = 0;
 heap32[(r15+76)] = -1279541970;
 heap32[(r15+77)] = -1082130432;
 heap32[(r15+78)] = 0;
 heap32[(r15+79)] = 0;
 heap32[(r15+80)] = -2147483648;
 heap32[(r15+81)] = 0;
 heap32[(r15+82)] = 1065353216;
 heap32[(r15+83)] = 0;
 heap32[(r15+84)] = -1087163597;
 heap32[(r15+85)] = 1057384039;
 heap32[(r15+86)] = 0;
 heap32[(r15+87)] = 0;
 heap32[(r15+88)] = -1287930578;
 heap32[(r15+89)] = -1082130432;
 heap32[(r15+90)] = 0;
 heap32[(r15+91)] = 0;
 heap32[(r15+92)] = 1065353216;
 heap32[(r15+93)] = -1287930578;
 heap32[(r15+94)] = 0;
 heap32[(r15+95)] = 0;
 heap32[(r15+96)] = -2147483648;
 heap32[(r15+97)] = 0;
 heap32[(r15+98)] = 1065353216;
 heap32[(r15+99)] = 0;
 heap32[(r15+100)] = 0;
 heap32[(r15+101)] = -1088338002;
 heap32[(r15+102)] = 0;
 heap32[(r15+103)] = 0;
 heap8[r_g0+540] = r13;
 heap32[(r15+128)] = 0;
 heap32[(r15+140)] = -1082130432;
 heap32[(r15+107)] = 1008981770;
 heap32[(r15+111)] = 1028443341;
 heap32[(r15+145)] = 0;
 heap32[(r15+146)] = 0;
 heap32[(r15+147)] = 1060320051;
 heap32[(r15+148)] = 0;
 heap32[(r15+108)] = 1070141403;
 heap32[(r15+109)] = 1070141403;
 heap32[(r15+110)] = 0;
 heap32[(r15+104)] = 1065353216;
 heap32[(r15+105)] = 1050253722;
 heap32[(r15+106)] = 1065353216;
 heap32[(r12+30)] = r_g0;
 r11 = heap32[(r12+1)];
 r14 = r11 >> 2;
 r14 = heap32[(r14)];
 r14 = r14 >> 2;
 r14 = heap32[(r14+13)];
 heap32[(g0)] = r11;
 heap32[(g0+1)] = r_g0;
 heap32[(g0+2)] = 1;
 __FUNCTION_TABLE__[(r14)>>2](i7);
 heap32[(g0)] = 748;
 _Znwj(i7);
 r8 = r_g0;
 r11 = heap32[(r12+21)];
 r14 = heap32[(r12+20)];
 r15 = r8 >> 2;
 heap32[(r15+1)] = 4;
 heap32[(r15+2)] = -1;
 heap32[(r15+3)] = -1;
 heap8[r8+16] = r13;
 heap32[(r15+5)] = r14;
 heap32[(r15+6)] = r11;
 heap32[(r15+7)] = 0;
 heap32[(r15+8)] = 1050253722;
 heap32[(r15)] = r9;
 heap32[(r15+135)] = -1287930578;
 heap32[(r15+136)] = 0;
 heap32[(r15+137)] = 1065353216;
 heap32[(r15+138)] = 0;
 heap32[(r15+139)] = -2147483648;
 heap32[(r15+140)] = 1065353216;
 heap32[(r15+141)] = 0;
 heap32[(r15+142)] = 0;
 heap32[(r15+143)] = -1082130432;
 heap32[(r15+144)] = -2147483648;
 heap32[(r15+145)] = -1287930578;
 heap32[(r15+146)] = 0;
 heap32[(r15+147)] = 0;
 heap32[(r15+148)] = 1059145646;
 heap32[(r15+149)] = 0;
 heap32[(r15+150)] = 0;
 heap32[(r15+151)] = -1287930578;
 heap32[(r15+152)] = 0;
 heap32[(r15+153)] = 1065353216;
 heap32[(r15+154)] = 0;
 heap32[(r15+155)] = -2147483648;
 heap32[(r15+156)] = 1065353216;
 heap32[(r15+157)] = 0;
 heap32[(r15+158)] = 0;
 heap32[(r15+159)] = -1082130432;
 heap32[(r15+160)] = -2147483648;
 heap32[(r15+161)] = -1287930578;
 heap32[(r15+162)] = 0;
 heap32[(r15+163)] = 0;
 heap32[(r15+164)] = -1090854584;
 heap32[(r15+165)] = 0;
 heap32[(r15+166)] = 0;
 heap8[r8+720] = r13;
 heap8[r8+721] = r13;
 heap8[r8+723] = r13;
 heap8[r8+724] = r4;
 heap8[r8+725] = r13;
 heap32[(r15+183)] = 0;
 heap32[(r15+172)] = 1065353216;
 heap32[(r15+173)] = -1082130432;
 heap32[(r15+170)] = 1050253722;
 heap32[(r15+171)] = 1065353216;
 heap32[(r15+169)] = 1063675494;
 heap8[r8+722] = r13;
 heap32[(r15+179)] = 1065353216;
 heap32[(g0)] = -1077342245;
 heap32[(g0+1)] = 1086918619;
 fmodf(i7);
 f12 = f_g0;
 if(f12 >=f13) //_LBB26_252
{
 f14 =        3.1415927410125732;
 if(f12 >f14) //_LBB26_254
{
 f14 =       -6.2831854820251465;
 f12 = f12+f14;
}
}
else{
 f14 =        6.2831854820251465;
 f12 = f12+f14;
}
 r11 = r8 >> 2;
 heapFloat[(r11+172)] = f12;
 heap32[(g0)] = 0;
 heap32[(g0+1)] = 1086918619;
 fmodf(i7);
 f12 = f_g0;
 if(f12 >=f13) //_LBB26_257
{
 f14 =        3.1415927410125732;
 if(f12 >f14) //_LBB26_259
{
 f14 =       -6.2831854820251465;
 f12 = f12+f14;
}
}
else{
 f14 =        6.2831854820251465;
 f12 = f12+f14;
}
 heapFloat[(r11+173)] = f12;
 heap32[(r11+169)] = 1063675494;
 heap32[(r11+170)] = 1050253722;
 heap32[(r11+171)] = 1065353216;
 heap32[(r12+31)] = r8;
 r11 = heap32[(r12+1)];
 r14 = r11 >> 2;
 r14 = heap32[(r14)];
 r14 = r14 >> 2;
 r14 = heap32[(r14+13)];
 heap32[(g0)] = r11;
 heap32[(g0+1)] = r8;
 heap32[(g0+2)] = 1;
 __FUNCTION_TABLE__[(r14)>>2](i7);
 heap32[(g0)] = 596;
 _Znwj(i7);
 r11 = heap32[(r12+22)];
 r14 = heap32[(r12+14)];
 r15 = r_g0 >> 2;
 heap32[(r15+1)] = 5;
 heap32[(r15+2)] = -1;
 heap32[(r15+3)] = -1;
 heap8[r_g0+16] = r13;
 heap32[(r15+5)] = r14;
 heap32[(r15+6)] = r11;
 heap32[(r15+7)] = 0;
 heap32[(r15+8)] = 1050253722;
 heap32[(r15)] = r10;
 heap32[(r15+72)] = 1065353216;
 heap32[(r15+73)] = 0;
 heap32[(r15+74)] = 0;
 heap32[(r15+75)] = 0;
 heap32[(r15+76)] = 0;
 heap32[(r15+77)] = 1065353216;
 heap32[(r15+78)] = 0;
 heap32[(r15+79)] = 0;
 heap32[(r15+80)] = -2147483648;
 heap32[(r15+81)] = 0;
 heap32[(r15+82)] = 1065353216;
 heap32[(r15+83)] = 0;
 heap32[(r15+84)] = 1060320051;
 heap32[(r15+85)] = 1057384039;
 heap32[(r15+86)] = 0;
 heap32[(r15+87)] = 0;
 heap32[(r15+88)] = -1287930578;
 heap32[(r15+89)] = -1082130432;
 heap32[(r15+90)] = 0;
 heap32[(r15+91)] = 0;
 heap32[(r15+92)] = 1065353216;
 heap32[(r15+93)] = -1287930578;
 heap32[(r15+94)] = 0;
 heap32[(r15+95)] = 0;
 heap32[(r15+96)] = -2147483648;
 heap32[(r15+97)] = 0;
 heap32[(r15+98)] = 1065353216;
 heap32[(r15+99)] = 0;
 heap32[(r15+100)] = 0;
 heap32[(r15+101)] = -1088338002;
 heap32[(r15+102)] = 0;
 heap32[(r15+103)] = 0;
 heap8[r_g0+540] = r13;
 heap32[(r15+128)] = 0;
 heap32[(r15+140)] = -1082130432;
 heap32[(r15+107)] = 1008981770;
 heap32[(r15+111)] = 1028443341;
 heap32[(r15+145)] = 0;
 heap32[(r15+146)] = 0;
 heap32[(r15+147)] = 1060320051;
 heap32[(r15+148)] = 0;
 heap32[(r15+108)] = 1070141403;
 heap32[(r15+109)] = 1070141403;
 heap32[(r15+110)] = 0;
 heap32[(r15+104)] = 1065353216;
 heap32[(r15+105)] = 1050253722;
 heap32[(r15+106)] = 1065353216;
 heap32[(r12+32)] = r_g0;
 r10 = heap32[(r12+1)];
 r11 = r10 >> 2;
 r11 = heap32[(r11)];
 r11 = r11 >> 2;
 r11 = heap32[(r11+13)];
 heap32[(g0)] = r10;
 heap32[(g0+1)] = r_g0;
 heap32[(g0+2)] = 1;
 __FUNCTION_TABLE__[(r11)>>2](i7);
 heap32[(g0)] = 748;
 _Znwj(i7);
 r8 = r_g0;
 r10 = heap32[(r12+23)];
 r11 = heap32[(r12+22)];
 r14 = r8 >> 2;
 heap32[(r14+1)] = 4;
 heap32[(r14+2)] = -1;
 heap32[(r14+3)] = -1;
 heap8[r8+16] = r13;
 heap32[(r14+5)] = r11;
 heap32[(r14+6)] = r10;
 heap32[(r14+7)] = 0;
 heap32[(r14+8)] = 1050253722;
 heap32[(r14)] = r9;
 heap32[(r14+135)] = -1287930578;
 heap32[(r14+136)] = 0;
 heap32[(r14+137)] = 1065353216;
 heap32[(r14+138)] = 0;
 heap32[(r14+139)] = -2147483648;
 heap32[(r14+140)] = 1065353216;
 heap32[(r14+141)] = 0;
 heap32[(r14+142)] = 0;
 heap32[(r14+143)] = -1082130432;
 heap32[(r14+144)] = -2147483648;
 heap32[(r14+145)] = -1287930578;
 heap32[(r14+146)] = 0;
 heap32[(r14+147)] = 0;
 heap32[(r14+148)] = 1059145646;
 heap32[(r14+149)] = 0;
 heap32[(r14+150)] = 0;
 heap32[(r14+151)] = -1287930578;
 heap32[(r14+152)] = 0;
 heap32[(r14+153)] = 1065353216;
 heap32[(r14+154)] = 0;
 heap32[(r14+155)] = -2147483648;
 heap32[(r14+156)] = 1065353216;
 heap32[(r14+157)] = 0;
 heap32[(r14+158)] = 0;
 heap32[(r14+159)] = -1082130432;
 heap32[(r14+160)] = -2147483648;
 heap32[(r14+161)] = -1287930578;
 heap32[(r14+162)] = 0;
 heap32[(r14+163)] = 0;
 heap32[(r14+164)] = -1090854584;
 heap32[(r14+165)] = 0;
 heap32[(r14+166)] = 0;
 heap8[r8+720] = r13;
 heap8[r8+721] = r13;
 heap8[r8+723] = r13;
 heap8[r8+724] = r4;
 heap8[r8+725] = r13;
 heap32[(r14+183)] = 0;
 heap32[(r14+172)] = 1065353216;
 heap32[(r14+173)] = -1082130432;
 heap32[(r14+170)] = 1050253722;
 heap32[(r14+171)] = 1065353216;
 heap32[(r14+169)] = 1063675494;
 heap8[r8+722] = r13;
 heap32[(r14+179)] = 1065353216;
 heap32[(g0)] = -1077342245;
 heap32[(g0+1)] = 1086918619;
 fmodf(i7);
 f12 = f_g0;
 if(f12 >=f13) //_LBB26_262
{
 f14 =        3.1415927410125732;
 if(f12 >f14) //_LBB26_264
{
 f14 =       -6.2831854820251465;
 f12 = f12+f14;
}
}
else{
 f14 =        6.2831854820251465;
 f12 = f12+f14;
}
 r9 = r8 >> 2;
 heapFloat[(r9+172)] = f12;
 heap32[(g0)] = 0;
 heap32[(g0+1)] = 1086918619;
 fmodf(i7);
 f12 = f_g0;
 if(f12 >=f13) //_LBB26_267
{
 f13 =        3.1415927410125732;
 if(f12 >f13) //_LBB26_269
{
 f13 =       -6.2831854820251465;
 f12 = f12+f13;
}
}
else{
 f13 =        6.2831854820251465;
 f12 = f12+f13;
}
 heapFloat[(r9+173)] = f12;
 heap32[(r9+169)] = 1063675494;
 heap32[(r9+170)] = 1050253722;
 heap32[(r9+171)] = 1065353216;
 heap32[(r12+33)] = r8;
 r9 = heap32[(r12+1)];
 r10 = r9 >> 2;
 r10 = heap32[(r10)];
 r10 = r10 >> 2;
 r10 = heap32[(r10+13)];
 heap32[(g0)] = r9;
 heap32[(g0+1)] = r8;
 heap32[(g0+2)] = 1;
 __FUNCTION_TABLE__[(r10)>>2](i7);
 r8 = heap32[(r1+10)];
 r9 = heap32[(r1+9)];
 if(r8 ==r9) //_LBB26_272
{
 r10 = r9 << 1;
 r10 = r9 == 0 ? r4 : r10;
if(!(r8 >=r10)) //_LBB26_271
{
 if(r10 !=0) //_LBB26_275
{
 r8 = heap32[(r2)];
 r11 = r10 << 2;
 r8 = (r8 + 1)|0;
 r11 = r11 | 3;
 heap32[(r2)] = r8;
 r8 = (r11 + 16)|0;
 heap32[(g0)] = r8;
 malloc(i7);
 r8 = r_g0;
 if(r8 !=0) //_LBB26_277
{
 r11 = (r8 + 4)|0;
 r11 = (r13 - r11)|0;
 r11 = r11 & 15;
 r11 = (r8 + r11)|0;
 r12 = (r11 + 4)|0;
 r11 = r11 >> 2;
 heap32[(r11)] = r8;
 r8 = r12;
}
}
else{
 r8 = 0;
}
_358: do {
 if(r9 <1) //_LBB26_280
{
 r11 = heap32[(r1+11)];
}
else{
_360: while(true){
 r11 = heap32[(r1+11)];
 r12 = r13 << 2;
 r14 = (r11 + r12)|0;
 r14 = r14 >> 2;
 r12 = (r8 + r12)|0;
 r14 = heap32[(r14)];
 r13 = (r13 + 1)|0;
 r12 = r12 >> 2;
 heap32[(r12)] = r14;
if(!(r9 !=r13)) //_LBB26_281
{
break _358;
}
}
}
} while(0);
 if(r11 !=0) //_LBB26_284
{
 r12 = heapU8[r6+48];
 if(r12 !=0) //_LBB26_286
{
 r9 = gNumAlignedFree;
 r9 = r9 >> 2;
 r12 = heap32[(r9)];
 r12 = (r12 + 1)|0;
 r11 = r11 >> 2;
 heap32[(r9)] = r12;
 r9 = heap32[(r11+-1)];
 heap32[(g0)] = r9;
 free(i7);
 r9 = heap32[(r1+9)];
}
 heap32[(r1+11)] = 0;
}
 heap8[r6+48] = r4;
 heap32[(r1+11)] = r8;
 heap32[(r1+10)] = r10;
}
}
 r8 = r9 << 2;
 r9 = heap32[(r1+11)];
 r8 = (r9 + r8)|0;
 r8 = r8 >> 2;
 heap32[(r8)] = r7;
 r7 = heap32[(r1+9)];
 r5 = (r5 + 1)|0;
 r7 = (r7 + 1)|0;
 heap32[(r1+9)] = r7;
if(!(r0 !=r5)) //_LBB26_185
{
break _262;
}
}
 f3 =                         7;
 f4 =                        -2;
 r0 = (r0 + -1)|0;
 f1 = f1+f3;
 f2 = f2+f4;
 r3 = (r3 + 1)|0;
 if(r0 ==0) //_LBB26_165
{
break _161;
}
else{
continue _260;
}
}
}
}
}
}
} while(0);
 return;
break;
case 46:
 r0 = _2E_str674;
 r1 = _2E_str573;
 heap32[(g0)] = r0;
 heap32[(g0+1)] = r1;
 heap32[(g0+2)] = 53;
 _assert(i7);
break;
}
}

function _GLOBAL__D__Z6mymainiPPc(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
 var r1;
 var r2;
 var r3;
 var r4;
 var r5;
var __label__ = 0;
 i7 = sp + -8;var g0 = i7>>2; // save stack
 r0 = _ZL14benchmarkDemo4;
 r1 = _ZTV13BenchmarkDemo;
 r2 = r0 >> 2;
 r1 = (r1 + 8)|0;
 heap32[(r2)] = r1;
 heap32[(g0)] = r0;
 _ZN13BenchmarkDemo11exitPhysicsEv(i7);
 r1 = heap32[(r2+11)];
if(!(r1 ==0)) //_LBB27_4
{
 r3 = heapU8[r0+48];
if(!(r3 ==0)) //_LBB27_3
{
 r3 = gNumAlignedFree;
 r3 = r3 >> 2;
 r4 = heap32[(r3)];
 r4 = (r4 + 1)|0;
 r1 = r1 >> 2;
 heap32[(r3)] = r4;
 r1 = heap32[(r1+-1)];
 heap32[(g0)] = r1;
 free(i7);
}
 heap32[(r2+11)] = 0;
}
 r1 = 1;
 heap8[r0+48] = r1;
 heap32[(r2+11)] = 0;
 heap32[(r2+9)] = 0;
 heap32[(r2+10)] = 0;
 r3 = heap32[(r2+6)];
if(!(r3 ==0)) //_LBB27_8
{
 r4 = heapU8[r0+28];
if(!(r4 ==0)) //_LBB27_7
{
 r4 = gNumAlignedFree;
 r4 = r4 >> 2;
 r5 = heap32[(r4)];
 r5 = (r5 + 1)|0;
 r3 = r3 >> 2;
 heap32[(r4)] = r5;
 r3 = heap32[(r3+-1)];
 heap32[(g0)] = r3;
 free(i7);
}
 heap32[(r2+6)] = 0;
}
 heap8[r0+28] = r1;
 heap32[(r2+6)] = 0;
 heap32[(r2+4)] = 0;
 heap32[(r2+5)] = 0;
 return;
}

function _ZN14BenchmarkDemo4D1Ev(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
 var r1;
 var r2;
var __label__ = 0;
 i7 = sp + -8;var g0 = i7>>2; // save stack
 r0 = heap32[(fp)];
 r1 = _ZTV14BenchmarkDemo4;
 r2 = r0 >> 2;
 r1 = (r1 + 8)|0;
 heap32[(r2)] = r1;
 heap32[(g0)] = r0;
 _ZN13BenchmarkDemoD2Ev(i7);
 return;
}

function _ZN14BenchmarkDemo4D0Ev(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
 var r1;
 var r2;
var __label__ = 0;
 i7 = sp + -8;var g0 = i7>>2; // save stack
 r0 = heap32[(fp)];
 r1 = _ZTV14BenchmarkDemo4;
 r2 = r0 >> 2;
 r1 = (r1 + 8)|0;
 heap32[(r2)] = r1;
 heap32[(g0)] = r0;
 _ZN13BenchmarkDemoD2Ev(i7);
 heap32[(g0)] = r0;
 _ZdlPv(i7);
 return;
}

function __draw(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
var __label__ = 0;
 i7 = sp + -8;var g0 = i7>>2; // save stack
 r0 = _ZL14benchmarkDemo4;
 heap32[(g0)] = r0;
 _ZN13BenchmarkDemo20clientMoveAndDisplayEv(i7);
 return;
}

function _ZN13BenchmarkDemoD2Ev(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
 var r1;
 var r2;
 var r3;
 var r4;
 var r5;
var __label__ = 0;
 i7 = sp + -8;var g0 = i7>>2; // save stack
 r0 = heap32[(fp)];
 r1 = _ZTV13BenchmarkDemo;
 r2 = r0 >> 2;
 r1 = (r1 + 8)|0;
 heap32[(r2)] = r1;
 heap32[(g0)] = r0;
 _ZN13BenchmarkDemo11exitPhysicsEv(i7);
 r1 = heap32[(r2+11)];
if(!(r1 ==0)) //_LBB31_4
{
 r3 = heapU8[r0+48];
if(!(r3 ==0)) //_LBB31_3
{
 r3 = gNumAlignedFree;
 r3 = r3 >> 2;
 r4 = heap32[(r3)];
 r4 = (r4 + 1)|0;
 r1 = r1 >> 2;
 heap32[(r3)] = r4;
 r1 = heap32[(r1+-1)];
 heap32[(g0)] = r1;
 free(i7);
}
 heap32[(r2+11)] = 0;
}
 r1 = 1;
 heap8[r0+48] = r1;
 heap32[(r2+11)] = 0;
 heap32[(r2+9)] = 0;
 heap32[(r2+10)] = 0;
 r3 = heap32[(r2+6)];
if(!(r3 ==0)) //_LBB31_8
{
 r4 = heapU8[r0+28];
if(!(r4 ==0)) //_LBB31_7
{
 r4 = gNumAlignedFree;
 r4 = r4 >> 2;
 r5 = heap32[(r4)];
 r5 = (r5 + 1)|0;
 r3 = r3 >> 2;
 heap32[(r4)] = r5;
 r3 = heap32[(r3+-1)];
 heap32[(g0)] = r3;
 free(i7);
}
 heap32[(r2+6)] = 0;
}
 heap8[r0+28] = r1;
 heap32[(r2+6)] = 0;
 heap32[(r2+4)] = 0;
 heap32[(r2+5)] = 0;
 return;
}

function __init(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
 var r1;
var __label__ = 0;
 i7 = sp + 0;var g0 = i7>>2; // save stack
 r0 = gDisableDeactivation;
 r1 = 1;
 heap8[r0] = r1;
 _ZN13BenchmarkDemo11initPhysicsEv(i7);
 return;
}

function _ZN15btNullPairCache23getOverlappingPairArrayEv(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
var __label__ = 0;
 i7 = sp + 0;var g0 = i7>>2; // save stack
 r0 = heap32[(fp)];
 r0 = (r0 + 4)|0;
 r_g0 = r0;
 return;
}

function _ZN15btNullPairCache20cleanOverlappingPairER16btBroadphasePairP12btDispatcher(sp)
{
 var i7;
 var fp = sp>>2;
var __label__ = 0;
 i7 = sp + 0;var g0 = i7>>2; // save stack
 return;
}

function _ZNK15btNullPairCache22getNumOverlappingPairsEv(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
var __label__ = 0;
 i7 = sp + 0;var g0 = i7>>2; // save stack
 r0 = 0;
 r_g0 = r0;
 return;
}

function _ZN15btNullPairCache19cleanProxyFromPairsEP17btBroadphaseProxyP12btDispatcher(sp)
{
 var i7;
 var fp = sp>>2;
var __label__ = 0;
 i7 = sp + 0;var g0 = i7>>2; // save stack
 return;
}

function _ZN15btNullPairCache24setOverlapFilterCallbackEP23btOverlapFilterCallback(sp)
{
 var i7;
 var fp = sp>>2;
var __label__ = 0;
 i7 = sp + 0;var g0 = i7>>2; // save stack
 return;
}

function _ZN15btNullPairCache26processAllOverlappingPairsEP17btOverlapCallbackP12btDispatcher(sp)
{
 var i7;
 var fp = sp>>2;
var __label__ = 0;
 i7 = sp + 0;var g0 = i7>>2; // save stack
 return;
}

function _ZN15btNullPairCache8findPairEP17btBroadphaseProxyS1_(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
var __label__ = 0;
 i7 = sp + 0;var g0 = i7>>2; // save stack
 r0 = 0;
 r_g0 = r0;
 return;
}

function _ZN15btNullPairCache18hasDeferredRemovalEv(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
var __label__ = 0;
 i7 = sp + 0;var g0 = i7>>2; // save stack
 r0 = 1;
 r_g0 = r0;
 return;
}

function _ZN15btNullPairCache28setInternalGhostPairCallbackEP25btOverlappingPairCallback(sp)
{
 var i7;
 var fp = sp>>2;
var __label__ = 0;
 i7 = sp + 0;var g0 = i7>>2; // save stack
 return;
}

function _ZN15btNullPairCache18addOverlappingPairEP17btBroadphaseProxyS1_(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
var __label__ = 0;
 i7 = sp + 0;var g0 = i7>>2; // save stack
 r0 = 0;
 r_g0 = r0;
 return;
}

function _ZN15btNullPairCache21removeOverlappingPairEP17btBroadphaseProxyS1_P12btDispatcher(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
var __label__ = 0;
 i7 = sp + 0;var g0 = i7>>2; // save stack
 r0 = 0;
 r_g0 = r0;
 return;
}

function _ZN15btNullPairCache37removeOverlappingPairsContainingProxyEP17btBroadphaseProxyP12btDispatcher(sp)
{
 var i7;
 var fp = sp>>2;
var __label__ = 0;
 i7 = sp + 0;var g0 = i7>>2; // save stack
 return;
}

function _ZN15btNullPairCache20sortOverlappingPairsEP12btDispatcher(sp)
{
 var i7;
 var fp = sp>>2;
var __label__ = 0;
 i7 = sp + 0;var g0 = i7>>2; // save stack
 return;
}

function _ZN15btNullPairCache26getOverlappingPairArrayPtrEv(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
var __label__ = 0;
 i7 = sp + 0;var g0 = i7>>2; // save stack
 r0 = heap32[(fp)];
 r0 = r0 >> 2;
 r0 = heap32[(r0+4)];
 r_g0 = r0;
 return;
}

function _ZNK15btNullPairCache26getOverlappingPairArrayPtrEv(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
var __label__ = 0;
 i7 = sp + 0;var g0 = i7>>2; // save stack
 r0 = heap32[(fp)];
 r0 = r0 >> 2;
 r0 = heap32[(r0+4)];
 r_g0 = r0;
 return;
}

function _ZN15btNullPairCacheD1Ev(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
 var r1;
 var r2;
 var r3;
 var r4;
var __label__ = 0;
 i7 = sp + -8;var g0 = i7>>2; // save stack
 r0 = heap32[(fp)];
 r1 = _ZTV15btNullPairCache;
 r2 = r0 >> 2;
 r1 = (r1 + 8)|0;
 heap32[(r2)] = r1;
 r1 = heap32[(r2+4)];
if(!(r1 ==0)) //_LBB48_4
{
 r3 = heapU8[r0+20];
if(!(r3 ==0)) //_LBB48_3
{
 r3 = gNumAlignedFree;
 r3 = r3 >> 2;
 r4 = heap32[(r3)];
 r4 = (r4 + 1)|0;
 r1 = r1 >> 2;
 heap32[(r3)] = r4;
 r1 = heap32[(r1+-1)];
 heap32[(g0)] = r1;
 free(i7);
}
 heap32[(r2+4)] = 0;
}
 r1 = 1;
 heap8[r0+20] = r1;
 heap32[(r2+4)] = 0;
 heap32[(r2+2)] = 0;
 heap32[(r2+3)] = 0;
 return;
}

function _ZN15btNullPairCacheD0Ev(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
 var r1;
 var r2;
 var r3;
 var r4;
var __label__ = 0;
 i7 = sp + -8;var g0 = i7>>2; // save stack
 r0 = heap32[(fp)];
 r1 = _ZTV15btNullPairCache;
 r2 = r0 >> 2;
 r1 = (r1 + 8)|0;
 heap32[(r2)] = r1;
 r1 = heap32[(r2+4)];
if(!(r1 ==0)) //_LBB49_4
{
 r3 = heapU8[r0+20];
if(!(r3 ==0)) //_LBB49_3
{
 r3 = gNumAlignedFree;
 r3 = r3 >> 2;
 r4 = heap32[(r3)];
 r4 = (r4 + 1)|0;
 r1 = r1 >> 2;
 heap32[(r3)] = r4;
 r1 = heap32[(r1+-1)];
 heap32[(g0)] = r1;
 free(i7);
}
 heap32[(r2+4)] = 0;
}
 r1 = 1;
 heap8[r0+20] = r1;
 heap32[(r2+4)] = 0;
 heap32[(r2+2)] = 0;
 heap32[(r2+3)] = 0;
 heap32[(g0)] = r0;
 _ZdlPv(i7);
 return;
}

function _ZNK20btAxisSweep3InternalItE7getAabbEP17btBroadphaseProxyR9btVector3S4_(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
 var r1;
 var r2;
var __label__ = 0;
 i7 = sp + 0;var g0 = i7>>2; // save stack
 r0 = heap32[(fp+1)];
 r1 = heap32[(fp+2)];
 r0 = r0 >> 2;
 r1 = r1 >> 2;
 heap32[(r1)] = heap32[(r0+4)];
 heap32[(r1+1)] = heap32[(r0+5)];
 r2 = heap32[(fp+3)];
 heap32[(r1+2)] = heap32[(r0+6)];
 r2 = r2 >> 2;
 heap32[(r1+3)] = heap32[(r0+7)];
 heap32[(r2)] = heap32[(r0+8)];
 heap32[(r2+1)] = heap32[(r0+9)];
 heap32[(r2+2)] = heap32[(r0+10)];
 heap32[(r2+3)] = heap32[(r0+11)];
 return;
}

function _ZN20btAxisSweep3InternalItE23getOverlappingPairCacheEv(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
var __label__ = 0;
 i7 = sp + 0;var g0 = i7>>2; // save stack
 r0 = heap32[(fp)];
 r0 = r0 >> 2;
 r0 = heap32[(r0+23)];
 r_g0 = r0;
 return;
}

function _ZNK20btAxisSweep3InternalItE23getOverlappingPairCacheEv(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
var __label__ = 0;
 i7 = sp + 0;var g0 = i7>>2; // save stack
 r0 = heap32[(fp)];
 r0 = r0 >> 2;
 r0 = heap32[(r0+23)];
 r_g0 = r0;
 return;
}

function _ZNK20btAxisSweep3InternalItE17getBroadphaseAabbER9btVector3S2_(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
 var r1;
 var r2;
var __label__ = 0;
 i7 = sp + 0;var g0 = i7>>2; // save stack
 r0 = heap32[(fp)];
 r1 = heap32[(fp+1)];
 r0 = r0 >> 2;
 r1 = r1 >> 2;
 heap32[(r1)] = heap32[(r0+2)];
 heap32[(r1+1)] = heap32[(r0+3)];
 r2 = heap32[(fp+2)];
 heap32[(r1+2)] = heap32[(r0+4)];
 r2 = r2 >> 2;
 heap32[(r1+3)] = heap32[(r0+5)];
 heap32[(r2)] = heap32[(r0+6)];
 heap32[(r2+1)] = heap32[(r0+7)];
 heap32[(r2+2)] = heap32[(r0+8)];
 heap32[(r2+3)] = heap32[(r0+9)];
 return;
}

function _ZN20btAxisSweep3InternalItE9resetPoolEP12btDispatcher(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
 var r1;
 var r2;
 var r3;
 var r4;
var __label__ = 0;
 i7 = sp + 0;var g0 = i7>>2; // save stack
 r0 = heap32[(fp)];
 r1 = heapU16[(r0+56)>>1];
if(!(r1 !=0)) //_LBB54_6
{
 r1 = 1;
 heap16[(r0+64)>>1] = r1;
 r2 = heapU16[(r0+58)>>1];
 if(uint(r2) >uint(1)) //_LBB54_3
{
 r3 = 2;
_5: while(true){
 r2 = r1 & 65535;
 r4 = r0 >> 2;
 r2 = r2 << 6;
 r4 = heap32[(r4+15)];
 r2 = (r4 + r2)|0;
 heap16[(r2+48)>>1] = r3;
 r1 = (r1 + 1)|0;
 r2 = heapU16[(r0+58)>>1];
 r3 = (r3 + 1)|0;
 r4 = r1 & 65535;
if(!(uint(r2) >uint(r4))) //_LBB54_4
{
break _5;
}
}
}
 r1 = r2 & 65535;
 r0 = r0 >> 2;
 r1 = r1 << 6;
 r0 = heap32[(r0+15)];
 r0 = (r1 + r0)|0;
 r1 = 0;
 heap16[(r0+-16)>>1] = r1;
}
 return;
}

function _ZN20btAxisSweep3InternalItE10printStatsEv(sp)
{
 var i7;
 var fp = sp>>2;
var __label__ = 0;
 i7 = sp + 0;var g0 = i7>>2; // save stack
 return;
}

function _ZN20btAxisSweep3InternalItE8aabbTestERK9btVector3S3_R24btBroadphaseAabbCallback(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
 var r1;
 var r2;
 var r3;
 var r4;
 var r5;
 var r6;
 var r7;
 var r8;
 var r9;
 var r10;
 var r11;
 var f0;
 var f1;
var __label__ = 0;
 i7 = sp + -16;var g0 = i7>>2; // save stack
 r0 = heap32[(fp)];
 r1 = r0 >> 2;
 r2 = heap32[(r1+27)];
 r3 = heap32[(fp+1)];
 r4 = heap32[(fp+2)];
 r5 = heap32[(fp+3)];
 if(r2 !=0) //_LBB56_2
{
 r0 = r2 >> 2;
 r0 = heap32[(r0)];
 r0 = r0 >> 2;
 r0 = heap32[(r0+7)];
 heap32[(g0)] = r2;
 heap32[(g0+1)] = r3;
 heap32[(g0+2)] = r4;
 heap32[(g0+3)] = r5;
 __FUNCTION_TABLE__[(r0)>>2](i7);
 return;
}
else{
 r2 = heapU16[(r0+56)>>1];
 r2 = r2 << 1;
 r2 = r2 | 1;
if(!(r2 ==1)) //_LBB56_18
{
 r2 = 1;
 r6 = 2;
_6: while(true){
 r7 = r6;
 r6 = r2 & 65535;
 r8 = heap32[(r1+17)];
 r6 = r6 << 2;
 r9 = heapU8[r8+r6];
 r9 = r9 & 1;
if(!(r9 ==0)) //_LBB56_17
{
 r6 = (r8 + r6)|0;
 r6 = heapU16[(r6+2)>>1];
 r8 = heap32[(r1+15)];
 r6 = r6 << 6;
 r6 = (r8 + r6)|0;
 r8 = r3 >> 2;
 r9 = r6 >> 2;
 f0 = heapFloat[(r8)];
 f1 = heapFloat[(r9+8)];
 if(f0 >f1) //_LBB56_8
{
__label__ = 8;
}
else{
 r10 = r4 >> 2;
 f0 = heapFloat[(r10)];
 f1 = heapFloat[(r9+4)];
 if(f0 <f1) //_LBB56_8
{
__label__ = 8;
}
else{
 r10 = 1;
__label__ = 9;
}
}
if (__label__ == 8){
 r10 = 0;
}
 f0 = heapFloat[(r8+2)];
 f1 = heapFloat[(r9+10)];
 if(f0 >f1) //_LBB56_12
{
__label__ = 11;
}
else{
 r11 = r4 >> 2;
 f0 = heapFloat[(r11+2)];
 f1 = heapFloat[(r9+6)];
 if(f0 <f1) //_LBB56_12
{
__label__ = 11;
}
else{
__label__ = 12;
}
}
if (__label__ == 11){
 r10 = 0;
}
 f0 = heapFloat[(r8+1)];
 f1 = heapFloat[(r9+9)];
if(!(f0 >f1)) //_LBB56_17
{
 r8 = r4 >> 2;
 f0 = heapFloat[(r8+1)];
 f1 = heapFloat[(r9+5)];
if(!(f0 <f1)) //_LBB56_17
{
 r8 = r10 & 255;
if(!(r8 ==0)) //_LBB56_17
{
 r8 = r5 >> 2;
 r8 = heap32[(r8)];
 r8 = r8 >> 2;
 r8 = heap32[(r8+2)];
 heap32[(g0)] = r5;
 heap32[(g0+1)] = r6;
 __FUNCTION_TABLE__[(r8)>>2](i7);
}
}
}
}
 r8 = heapU16[(r0+56)>>1];
 r6 = (r7 + 1)|0;
 r2 = (r2 + 1)|0;
 r8 = r8 << 1;
 r7 = r7 & 65535;
 r8 = r8 | 1;
if(!(uint(r7) <uint(r8))) //_LBB56_4
{
break _6;
}
}
}
 return;
}
}

function _ZN20btAxisSweep3InternalItE7rayTestERK9btVector3S3_R23btBroadphaseRayCallbackS3_S3_(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
 var r1;
 var r2;
 var r3;
 var r4;
 var r5;
 var r6;
 var r7;
var __label__ = 0;
 i7 = sp + -24;var g0 = i7>>2; // save stack
 r0 = heap32[(fp)];
 r1 = r0 >> 2;
 r2 = heap32[(r1+27)];
 r3 = heap32[(fp+3)];
 if(r2 !=0) //_LBB57_2
{
 r0 = heap32[(fp+1)];
 r1 = heap32[(fp+2)];
 r4 = heap32[(fp+4)];
 r5 = heap32[(fp+5)];
 r6 = r2 >> 2;
 r6 = heap32[(r6)];
 r6 = r6 >> 2;
 r6 = heap32[(r6+6)];
 heap32[(g0)] = r2;
 heap32[(g0+1)] = r0;
 heap32[(g0+2)] = r1;
 heap32[(g0+3)] = r3;
 heap32[(g0+4)] = r4;
 heap32[(g0+5)] = r5;
 __FUNCTION_TABLE__[(r6)>>2](i7);
 return;
}
else{
 r2 = heapU16[(r0+56)>>1];
 r2 = r2 << 1;
 r2 = r2 | 1;
if(!(r2 ==1)) //_LBB57_7
{
 r2 = 1;
 r4 = 2;
_6: while(true){
 r5 = r2 & 65535;
 r6 = heap32[(r1+17)];
 r5 = r5 << 2;
 r7 = heapU8[r6+r5];
 r7 = r7 & 1;
if(!(r7 ==0)) //_LBB57_6
{
 r7 = r3 >> 2;
 r7 = heap32[(r7)];
 r7 = r7 >> 2;
 r5 = (r6 + r5)|0;
 r5 = heapU16[(r5+2)>>1];
 r6 = heap32[(r7+2)];
 r7 = heap32[(r1+15)];
 r5 = r5 << 6;
 r5 = (r7 + r5)|0;
 heap32[(g0)] = r3;
 heap32[(g0+1)] = r5;
 __FUNCTION_TABLE__[(r6)>>2](i7);
}
 r5 = heapU16[(r0+56)>>1];
 r6 = (r4 + 1)|0;
 r2 = (r2 + 1)|0;
 r5 = r5 << 1;
 r7 = r4 & 65535;
 r5 = r5 | 1;
 r4 = r6;
if(!(uint(r7) <uint(r5))) //_LBB57_4
{
break _6;
}
}
}
 return;
}
}

function _ZNK20btAxisSweep3InternalItE8quantizeEPtRK9btVector3i(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
 var r1;
 var r2;
 var r3;
 var r4;
 var f0;
 var f1;
 var f2;
 var f3;
 var f4;
 var f5;
var __label__ = 0;
 i7 = sp + 0;var g0 = i7>>2; // save stack
 r0 = heap32[(fp)];
 r1 = r0 >> 2;
 f0 = heapFloat[(fp+2)];
 f1 = heapFloat[(r1+2)];
 f2 = heapFloat[(fp+4)];
 f3 = heapFloat[(r1+4)];
 f4 = heapFloat[(fp+3)];
 f5 = heapFloat[(r1+3)];
 f0 = f0-f1;
 f1 = heapFloat[(r1+10)];
 f2 = f2-f3;
 f3 = heapFloat[(r1+12)];
 f4 = f4-f5;
 f5 = heapFloat[(r1+11)];
 f0 = f0*f1;
 r1 = heap32[(fp+1)];
 r2 = heap32[(fp+5)];
 f1 = f2*f3;
 f2 = f4*f5;
 f3 =                         0;
 if(f0 >f3) //_LBB58_2
{
 r3 = heapU16[(r0+6)>>1];
 f4 = r3; //fitos r3, f4
 if(f0 <f4) //_LBB58_4
{
 r3 = heapU16[(r0+4)>>1];
 r4 = Math.floor(f0);
 r3 = r3 & r4;
 r3 = r3 | r2;
}
else{
 r4 = heapU16[(r0+4)>>1];
 r3 = r4 & r3;
 r3 = r3 | r2;
}
}
else{
 r3 = r2;
}
 heap16[(r1)>>1] = r3;
 if(f2 >f3) //_LBB58_7
{
 r3 = heapU16[(r0+6)>>1];
 f0 = r3; //fitos r3, f0
 if(f2 <f0) //_LBB58_9
{
 r3 = heapU16[(r0+4)>>1];
 r4 = Math.floor(f2);
 r3 = r3 & r4;
 r3 = r3 | r2;
}
else{
 r4 = heapU16[(r0+4)>>1];
 r3 = r4 & r3;
 r3 = r3 | r2;
}
}
else{
 r3 = r2;
}
 heap16[(r1+2)>>1] = r3;
 if(f1 >f3) //_LBB58_12
{
 r3 = heapU16[(r0+6)>>1];
 f0 = r3; //fitos r3, f0
 if(f1 <f0) //_LBB58_14
{
 r0 = heapU16[(r0+4)>>1];
 r3 = Math.floor(f1);
 r0 = r0 & r3;
 r2 = r0 | r2;
}
else{
 r0 = heapU16[(r0+4)>>1];
 r0 = r0 & r3;
 r2 = r0 | r2;
}
}
 heap16[(r1+4)>>1] = r2;
 return;
}

function _ZN20btAlignedObjectArrayI16btBroadphasePairE17quickSortInternalI29btBroadphasePairSortPredicateEEvT_ii(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
 var r1;
 var r2;
 var r3;
 var r4;
 var r5;
 var r6;
 var r7;
 var r8;
 var r9;
 var r10;
 var r11;
 var r12;
 var r13;
 var r14;
 var r15;
 var r16;
 var r17;
 var r18;
 var r19;
 var r20;
 var r21;
 var r22;
 var r23;
 var r24;
 var r25;
var __label__ = 0;
 i7 = sp + -16;var g0 = i7>>2; // save stack
 r0 = heap32[(fp+2)];
 r1 = heap32[(fp+1)];
 r2 = (r0 + r1)|0;
 r3 = r2 >>> 31;
 r4 = heap32[(fp)];
 r2 = (r2 + r3)|0;
 r3 = r4 >> 2;
 r2 = r2 & 536870910;
 r5 = heap32[(r3+3)];
 r2 = r2 << 3;
 r2 = (r5 + r2)|0;
 r2 = r2 >> 2;
 r5 = heap32[(r2)];
 r6 = heap32[(r2+1)];
 r2 = heap32[(r2+2)];
 r7 = r1;
 r8 = r0;
_1: while(true){
 r9 = heap32[(r3+3)];
 r10 = r7 << 4;
 r10 = (r9 + r10)|0;
 r11 = 0;
_3: while(true){
 r12 = r11 << 4;
 r12 = (r10 + r12)|0;
 r12 = r12 >> 2;
 r13 = r11 << 2;
 r14 = heap32[(r12)];
 if(r14 !=0) //_LBB59_5
{
 r15 = r14 >> 2;
 r15 = heap32[(r15+3)];
}
else{
 r15 = -1;
}
 if(r5 !=0) //_LBB59_8
{
 r16 = r5 >> 2;
 r16 = heap32[(r16+3)];
}
else{
 r16 = -1;
}
 r17 = r13 << 2;
 r17 = (r10 + r17)|0;
 r17 = r17 >> 2;
 r17 = heap32[(r17+1)];
 if(r17 !=0) //_LBB59_11
{
 r18 = r17 >> 2;
 r18 = heap32[(r18+3)];
}
else{
 r18 = -1;
}
 if(r6 !=0) //_LBB59_14
{
 r19 = r6 >> 2;
 r19 = heap32[(r19+3)];
}
else{
 r19 = -1;
}
_21: do {
if(!(r15 >r16)) //_LBB59_2
{
if(!(r14 !=r5)) //_LBB59_18
{
 if(r18 >r19) //_LBB59_2
{
break _21;
}
}
 if(r14 !=r5) //_LBB59_22
{
break _3;
}
else{
 if(r17 !=r6) //_LBB59_22
{
break _3;
}
else{
 r15 = r13 << 2;
 r15 = (r10 + r15)|0;
 r15 = r15 >> 2;
 r15 = heap32[(r15+2)];
if(!(uint(r15) >uint(r2))) //_LBB59_2
{
break _3;
}
}
}
}
} while(0);
 r11 = (r11 + 1)|0;
continue _3;
}
 r18 = r8 << 4;
 r15 = (r7 + r11)|0;
 r9 = (r9 + r18)|0;
 r16 = 0;
_30: while(true){
 r19 = r16 << 2;
 if(r5 !=0) //_LBB59_25
{
 r20 = r5 >> 2;
 r20 = heap32[(r20+3)];
}
else{
 r20 = -1;
}
 r21 = r19 << 2;
 r21 = (r9 + r21)|0;
 r21 = r21 >> 2;
 r21 = heap32[(r21)];
 if(r21 !=0) //_LBB59_28
{
 r22 = r21 >> 2;
 r22 = heap32[(r22+3)];
}
else{
 r22 = -1;
}
 if(r6 !=0) //_LBB59_31
{
 r23 = r6 >> 2;
 r23 = heap32[(r23+3)];
}
else{
 r23 = -1;
}
 r24 = r19 << 2;
 r24 = (r9 + r24)|0;
 r24 = r24 >> 2;
 r24 = heap32[(r24+1)];
 if(r24 !=0) //_LBB59_34
{
 r25 = r24 >> 2;
 r25 = heap32[(r25+3)];
}
else{
 r25 = -1;
}
_48: do {
if(!(r20 >r22)) //_LBB59_21
{
if(!(r5 !=r21)) //_LBB59_38
{
 if(r23 >r25) //_LBB59_21
{
break _48;
}
}
 if(r5 !=r21) //_LBB59_41
{
break _30;
}
else{
 if(r6 !=r24) //_LBB59_41
{
break _30;
}
else{
 r20 = r19 << 2;
 r20 = (r9 + r20)|0;
 r20 = r20 >> 2;
 r20 = heap32[(r20+2)];
if(!(uint(r2) >uint(r20))) //_LBB59_21
{
break _30;
}
}
}
}
} while(0);
 r16 = (r16 + -1)|0;
continue _30;
}
 r20 = (r8 + r16)|0;
 if(r15 <=r20) //_LBB59_43
{
 r13 = r13 << 2;
 r10 = (r10 + r13)|0;
 r10 = r10 >> 2;
 r13 = heap32[(r12+3)];
 r15 = heap32[(r10+2)];
 r19 = r19 << 2;
 r19 = (r9 + r19)|0;
 heap32[(r10)] = r21;
 r20 = r16 << 4;
 r19 = r19 >> 2;
 heap32[(r10+1)] = r24;
 r19 = heap32[(r19+2)];
 r9 = (r9 + r20)|0;
 r9 = r9 >> 2;
 heap32[(r10+2)] = r19;
 r9 = heap32[(r9+3)];
 heap32[(r12+3)] = r9;
 r9 = heap32[(r3+3)];
 r9 = (r9 + r18)|0;
 r9 = (r9 + r20)|0;
 r9 = r9 >> 2;
 heap32[(r9)] = r14;
 r7 = (r7 + r11)|0;
 r8 = (r8 + r16)|0;
 heap32[(r9+1)] = r17;
 r7 = (r7 + 1)|0;
 r8 = (r8 + -1)|0;
 heap32[(r9+2)] = r15;
 heap32[(r9+3)] = r13;
}
else{
 r7 = r15;
 r8 = r20;
}
 if(r7 <=r8) //_LBB59_1
{
continue _1;
}
else{
break _1;
}
}
if(!(r8 <=r1)) //_LBB59_47
{
 heap32[(g0)] = r4;
 heap32[(g0+1)] = r1;
 heap32[(g0+2)] = r8;
 _ZN20btAlignedObjectArrayI16btBroadphasePairE17quickSortInternalI29btBroadphasePairSortPredicateEEvT_ii(i7);
}
if(!(r7 >=r0)) //_LBB59_49
{
 heap32[(g0)] = r4;
 heap32[(g0+1)] = r7;
 heap32[(g0+2)] = r0;
 _ZN20btAlignedObjectArrayI16btBroadphasePairE17quickSortInternalI29btBroadphasePairSortPredicateEEvT_ii(i7);
}
 return;
}

function _ZN20btAxisSweep3InternalItE11sortMinDownEitP12btDispatcherb(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
 var r1;
 var r2;
 var r3;
 var r4;
 var r5;
 var r6;
 var r7;
 var r8;
 var r9;
 var r10;
 var r11;
 var r12;
 var r13;
 var r14;
 var r15;
 var r16;
 var r17;
var __label__ = 0;
 i7 = sp + -16;var g0 = i7>>2; // save stack
 r0 = heap32[(fp+1)];
 r1 = heap32[(fp)];
 r2 = r0 << 2;
 r2 = (r1 + r2)|0;
 r3 = heap32[(fp+2)];
 r2 = r2 >> 2;
 r2 = heap32[(r2+17)];
 r3 = r3 << 2;
 r4 = (r2 + r3)|0;
 r2 = heapU16[(r2+r3)>>1];
 r3 = heapU16[(r4+-4)>>1];
if(!(uint(r2) >=uint(r3))) //_LBB60_14
{
 r1 = r1 >> 2;
 r2 = heap32[(fp+3)];
 r3 = heap32[(r1+15)];
 r5 = heapU16[(r4+2)>>1];
 r6 = 1;
 r7 = r6 << r0;
 r7 = r7 & 3;
 r6 = r6 << r7;
 r5 = r5 << 6;
 r5 = (r3 + r5)|0;
 r6 = r6 & 3;
 r0 = r0 << 1;
 r8 = (r5 + 48)|0;
 r7 = r7 << 1;
 r9 = (r5 + 54)|0;
 r6 = r6 << 1;
 r10 = (r8 + r0)|0;
 r11 = (r9 + r7)|0;
 r12 = (r8 + r7)|0;
 r9 = (r9 + r6)|0;
 r8 = (r8 + r6)|0;
 r4 = (r4 + 2)|0;
_3: while(true){
 r13 = heapU8[r4+-6];
 r14 = heapU16[(r4+-4)>>1];
 r13 = r13 & 1;
 if(r13 ==0) //_LBB60_11
{
 r13 = r14 << 6;
 r3 = (r3 + r13)|0;
 r3 = (r3 + r0)|0;
 r13 = heapU16[(r3+48)>>1];
 r13 = (r13 + 1)|0;
 heap16[(r3+48)>>1] = r13;
}
else{
if(!(r2 ==0)) //_LBB60_10
{
 r13 = r14 << 6;
 r13 = (r3 + r13)|0;
 r15 = (r13 + r7)|0;
 r16 = heapU16[(r11)>>1];
 r17 = heapU16[(r15+48)>>1];
if(!(uint(r16) <uint(r17))) //_LBB60_10
{
 r15 = heapU16[(r15+54)>>1];
 r16 = heapU16[(r12)>>1];
if(!(uint(r15) <uint(r16))) //_LBB60_10
{
 r15 = (r13 + r6)|0;
 r16 = heapU16[(r9)>>1];
 r17 = heapU16[(r15+48)>>1];
if(!(uint(r16) <uint(r17))) //_LBB60_10
{
 r15 = heapU16[(r15+54)>>1];
 r16 = heapU16[(r8)>>1];
if(!(uint(r15) <uint(r16))) //_LBB60_10
{
 r15 = heap32[(r1+23)];
 r16 = r15 >> 2;
 r16 = heap32[(r16)];
 r16 = r16 >> 2;
 r16 = heap32[(r16+2)];
 heap32[(g0)] = r15;
 heap32[(g0+1)] = r5;
 heap32[(g0+2)] = r13;
 __FUNCTION_TABLE__[(r16)>>2](i7);
 r15 = heap32[(r1+24)];
if(!(r15 ==0)) //_LBB60_10
{
 r16 = r15 >> 2;
 r16 = heap32[(r16)];
 r16 = r16 >> 2;
 r16 = heap32[(r16+2)];
 heap32[(g0)] = r15;
 heap32[(g0+1)] = r5;
 heap32[(g0+2)] = r13;
 __FUNCTION_TABLE__[(r16)>>2](i7);
}
}
}
}
}
}
 r14 = r14 << 6;
 r3 = (r3 + r14)|0;
 r3 = (r3 + r0)|0;
 r14 = heapU16[(r3+54)>>1];
 r14 = (r14 + 1)|0;
 heap16[(r3+54)>>1] = r14;
}
 r3 = heapU16[(r10)>>1];
 r3 = (r3 + -1)|0;
 heap16[(r10)>>1] = r3;
 r3 = heapU16[(r4+-2)>>1];
 r13 = heapU16[(r4)>>1];
 r14 = heapU16[(r4+-4)>>1];
 r15 = heapU16[(r4+-6)>>1];
 heap16[(r4+-2)>>1] = r15;
 heap16[(r4)>>1] = r14;
 heap16[(r4+-6)>>1] = r3;
 heap16[(r4+-4)>>1] = r13;
 r13 = heapU16[(r4+-10)>>1];
 if(uint(r3) >=uint(r13)) //_LBB60_14
{
break _3;
}
else{
 r3 = heap32[(r1+15)];
 r4 = (r4 + -4)|0;
continue _3;
}
}
}
 return;
}

function _ZN20btAxisSweep3InternalItE9sortMaxUpEitP12btDispatcherb(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
 var r1;
 var r2;
 var r3;
 var r4;
 var r5;
 var r6;
 var r7;
 var r8;
 var r9;
 var r10;
 var r11;
 var r12;
 var r13;
 var r14;
 var r15;
 var r16;
var __label__ = 0;
 i7 = sp + -16;var g0 = i7>>2; // save stack
 r0 = heap32[(fp+1)];
 r1 = heap32[(fp)];
 r2 = r0 << 2;
 r2 = (r1 + r2)|0;
 r2 = r2 >> 2;
 r3 = heap32[(fp+2)];
 r4 = 1;
 r2 = heap32[(r2+17)];
 r3 = r3 << 2;
 r2 = (r2 + r3)|0;
 r3 = r4 << r0;
 r3 = r3 & 3;
 r1 = r1 >> 2;
 r5 = heapU16[(r2+2)>>1];
 r4 = r4 << r3;
 r6 = heap32[(r1+15)];
 r5 = r5 << 6;
 r4 = r4 & 3;
 r5 = (r6 + r5)|0;
 r3 = r3 << 1;
 r6 = (r5 + 48)|0;
 r4 = r4 << 1;
 r5 = (r5 + 54)|0;
 r0 = r0 << 1;
 r7 = heap32[(fp+3)];
 r8 = (r5 + r3)|0;
 r9 = (r6 + r3)|0;
 r10 = (r5 + r4)|0;
 r6 = (r6 + r4)|0;
 r5 = (r5 + r0)|0;
 r2 = (r2 + 4)|0;
_1: while(true){
 r11 = heapU16[(r2+2)>>1];
 if(r11 ==0) //_LBB61_14
{
break _1;
}
else{
 r12 = heapU16[(r2)>>1];
 r13 = heapU16[(r2+-4)>>1];
 if(uint(r13) >=uint(r12)) //_LBB61_1
{
 r13 = heap32[(r1+15)];
 r11 = r11 & 65535;
 r12 = r12 & 1;
 if(r12 != 0) //_LBB61_10
{
 r11 = r11 << 6;
 r11 = (r13 + r11)|0;
 r11 = (r11 + r0)|0;
 r12 = heapU16[(r11+54)>>1];
 r12 = (r12 + -1)|0;
 heap16[(r11+54)>>1] = r12;
}
else{
if(!(r7 ==0)) //_LBB61_9
{
 r12 = r11 << 6;
 r12 = (r13 + r12)|0;
 r14 = (r12 + r3)|0;
 r15 = heapU16[(r8)>>1];
 r16 = heapU16[(r14+48)>>1];
if(!(uint(r15) <uint(r16))) //_LBB61_9
{
 r14 = heapU16[(r14+54)>>1];
 r15 = heapU16[(r9)>>1];
if(!(uint(r14) <uint(r15))) //_LBB61_9
{
 r14 = (r12 + r4)|0;
 r15 = heapU16[(r10)>>1];
 r16 = heapU16[(r14+48)>>1];
if(!(uint(r15) <uint(r16))) //_LBB61_9
{
 r14 = heapU16[(r14+54)>>1];
 r15 = heapU16[(r6)>>1];
if(!(uint(r14) <uint(r15))) //_LBB61_9
{
 r14 = heap32[(r1+23)];
 r15 = r14 >> 2;
 r15 = heap32[(r15)];
 r15 = r15 >> 2;
 r16 = heapU16[(r2+-2)>>1];
 r15 = heap32[(r15+2)];
 r16 = r16 << 6;
 r16 = (r13 + r16)|0;
 heap32[(g0)] = r14;
 heap32[(g0+1)] = r16;
 heap32[(g0+2)] = r12;
 __FUNCTION_TABLE__[(r15)>>2](i7);
 r14 = heap32[(r1+24)];
if(!(r14 ==0)) //_LBB61_9
{
 r15 = r14 >> 2;
 r15 = heap32[(r15)];
 r15 = r15 >> 2;
 r15 = heap32[(r15+2)];
 heap32[(g0)] = r14;
 heap32[(g0+1)] = r16;
 heap32[(g0+2)] = r12;
 __FUNCTION_TABLE__[(r15)>>2](i7);
}
}
}
}
}
}
 r11 = r11 << 6;
 r11 = (r13 + r11)|0;
 r11 = (r11 + r0)|0;
 r12 = heapU16[(r11+48)>>1];
 r12 = (r12 + -1)|0;
 heap16[(r11+48)>>1] = r12;
}
 r11 = heapU16[(r5)>>1];
 r11 = (r11 + 1)|0;
 heap16[(r5)>>1] = r11;
 r11 = heapU16[(r2+-2)>>1];
 r12 = heapU16[(r2+-4)>>1];
 r13 = heapU16[(r2+2)>>1];
 r14 = heapU16[(r2)>>1];
 heap16[(r2+-4)>>1] = r14;
 heap16[(r2+-2)>>1] = r13;
 r13 = (r2 + 4)|0;
 heap16[(r2)>>1] = r12;
 heap16[(r2+2)>>1] = r11;
 r2 = r13;
continue _1;
}
else{
break _1;
}
}
}
 return;
}

function _ZN20btAxisSweep3InternalItE9sortMinUpEitP12btDispatcherb(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
 var r1;
 var r2;
 var r3;
 var r4;
 var r5;
 var r6;
 var r7;
 var r8;
 var r9;
 var r10;
 var r11;
 var r12;
 var r13;
 var r14;
 var r15;
var __label__ = 0;
 i7 = sp + -16;var g0 = i7>>2; // save stack
 r0 = heap32[(fp+1)];
 r1 = heap32[(fp)];
 r2 = r0 << 2;
 r2 = (r1 + r2)|0;
 r2 = r2 >> 2;
 r3 = heap32[(fp+2)];
 r2 = heap32[(r2+17)];
 r3 = r3 << 2;
 r2 = (r2 + r3)|0;
 r1 = r1 >> 2;
 r3 = heapU16[(r2+2)>>1];
 r4 = 1;
 r5 = r4 << r0;
 r6 = heap32[(r1+15)];
 r3 = r3 << 6;
 r5 = r5 & 3;
 r3 = (r6 + r3)|0;
 r0 = r0 << 1;
 r3 = (r3 + r0)|0;
 r4 = r4 << r5;
 r6 = heap32[(fp+3)];
 r7 = heap32[(fp+4)];
 r3 = (r3 + 48)|0;
 r4 = r4 & 3;
 r2 = (r2 + 4)|0;
_1: while(true){
 r8 = heapU16[(r2+2)>>1];
 if(r8 ==0) //_LBB62_14
{
break _1;
}
else{
 r9 = heapU16[(r2)>>1];
 r10 = heapU16[(r2+-4)>>1];
 if(uint(r10) >=uint(r9)) //_LBB62_1
{
 r10 = heap32[(r1+15)];
 r8 = r8 & 65535;
 r9 = r9 & 1;
 if(r9 ==0) //_LBB62_10
{
 r8 = r8 << 6;
 r8 = (r10 + r8)|0;
 r8 = (r8 + r0)|0;
 r9 = heapU16[(r8+48)>>1];
 r9 = (r9 + -1)|0;
 heap16[(r8+48)>>1] = r9;
}
else{
if(!(r7 ==0)) //_LBB62_9
{
 r9 = heapU16[(r2+-2)>>1];
 r9 = r9 << 6;
 r11 = r8 << 6;
 r9 = (r10 + r9)|0;
 r12 = r5 << 1;
 r11 = (r10 + r11)|0;
 r13 = (r9 + r12)|0;
 r12 = (r11 + r12)|0;
 r14 = heapU16[(r13+54)>>1];
 r15 = heapU16[(r12+48)>>1];
if(!(uint(r14) <uint(r15))) //_LBB62_9
{
 r12 = heapU16[(r12+54)>>1];
 r13 = heapU16[(r13+48)>>1];
if(!(uint(r12) <uint(r13))) //_LBB62_9
{
 r12 = r4 << 1;
 r13 = (r9 + r12)|0;
 r12 = (r11 + r12)|0;
 r14 = heapU16[(r13+54)>>1];
 r15 = heapU16[(r12+48)>>1];
if(!(uint(r14) <uint(r15))) //_LBB62_9
{
 r12 = heapU16[(r12+54)>>1];
 r13 = heapU16[(r13+48)>>1];
if(!(uint(r12) <uint(r13))) //_LBB62_9
{
 r12 = heap32[(r1+23)];
 r13 = r12 >> 2;
 r13 = heap32[(r13)];
 r13 = r13 >> 2;
 r13 = heap32[(r13+3)];
 heap32[(g0)] = r12;
 heap32[(g0+1)] = r9;
 heap32[(g0+2)] = r11;
 heap32[(g0+3)] = r6;
 __FUNCTION_TABLE__[(r13)>>2](i7);
 r12 = heap32[(r1+24)];
if(!(r12 ==0)) //_LBB62_9
{
 r13 = r12 >> 2;
 r13 = heap32[(r13)];
 r13 = r13 >> 2;
 r13 = heap32[(r13+3)];
 heap32[(g0)] = r12;
 heap32[(g0+1)] = r9;
 heap32[(g0+2)] = r11;
 heap32[(g0+3)] = r6;
 __FUNCTION_TABLE__[(r13)>>2](i7);
}
}
}
}
}
}
 r8 = r8 << 6;
 r8 = (r10 + r8)|0;
 r8 = (r8 + r0)|0;
 r9 = heapU16[(r8+54)>>1];
 r9 = (r9 + -1)|0;
 heap16[(r8+54)>>1] = r9;
}
 r8 = heapU16[(r3)>>1];
 r8 = (r8 + 1)|0;
 heap16[(r3)>>1] = r8;
 r8 = heapU16[(r2+-2)>>1];
 r9 = heapU16[(r2+-4)>>1];
 r10 = heapU16[(r2+2)>>1];
 r11 = heapU16[(r2)>>1];
 heap16[(r2+-4)>>1] = r11;
 heap16[(r2+-2)>>1] = r10;
 r10 = (r2 + 4)|0;
 heap16[(r2)>>1] = r9;
 heap16[(r2+2)>>1] = r8;
 r2 = r10;
continue _1;
}
else{
break _1;
}
}
}
 return;
}

function _ZN20btAxisSweep3InternalItE11sortMaxDownEitP12btDispatcherb(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
 var r1;
 var r2;
 var r3;
 var r4;
 var r5;
 var r6;
 var r7;
 var r8;
 var r9;
 var r10;
 var r11;
 var r12;
 var r13;
 var r14;
 var r15;
var __label__ = 0;
 i7 = sp + -16;var g0 = i7>>2; // save stack
 r0 = heap32[(fp+1)];
 r1 = heap32[(fp)];
 r2 = r0 << 2;
 r2 = (r1 + r2)|0;
 r3 = heap32[(fp+2)];
 r2 = r2 >> 2;
 r2 = heap32[(r2+17)];
 r4 = r3 << 2;
 r5 = (r2 + r4)|0;
 r4 = heapU16[(r2+r4)>>1];
 r6 = heapU16[(r5+-4)>>1];
if(!(uint(r4) >=uint(r6))) //_LBB63_14
{
 r1 = r1 >> 2;
 r4 = heap32[(fp+3)];
 r6 = heap32[(fp+4)];
 r7 = heap32[(r1+15)];
 r3 = r3 << 2;
 r2 = (r2 + r3)|0;
 r2 = heapU16[(r2+2)>>1];
 r3 = 1;
 r8 = r3 << r0;
 r2 = r2 << 6;
 r8 = r8 & 3;
 r2 = (r7 + r2)|0;
 r0 = r0 << 1;
 r3 = r3 << r8;
 r2 = (r2 + r0)|0;
 r3 = r3 & 3;
 r2 = (r2 + 54)|0;
 r5 = (r5 + 2)|0;
_3: while(true){
 r9 = heapU8[r5+-6];
 r10 = heapU16[(r5+-4)>>1];
 r9 = r9 & 1;
 if(r9 != 0) //_LBB63_11
{
 r9 = r10 << 6;
 r7 = (r7 + r9)|0;
 r7 = (r7 + r0)|0;
 r9 = heapU16[(r7+54)>>1];
 r9 = (r9 + 1)|0;
 heap16[(r7+54)>>1] = r9;
}
else{
if(!(r6 ==0)) //_LBB63_10
{
 r9 = heapU16[(r5)>>1];
 r9 = r9 << 6;
 r11 = r10 << 6;
 r9 = (r7 + r9)|0;
 r12 = r8 << 1;
 r11 = (r7 + r11)|0;
 r13 = (r9 + r12)|0;
 r12 = (r11 + r12)|0;
 r14 = heapU16[(r13+54)>>1];
 r15 = heapU16[(r12+48)>>1];
if(!(uint(r14) <uint(r15))) //_LBB63_10
{
 r12 = heapU16[(r12+54)>>1];
 r13 = heapU16[(r13+48)>>1];
if(!(uint(r12) <uint(r13))) //_LBB63_10
{
 r12 = r3 << 1;
 r13 = (r9 + r12)|0;
 r12 = (r11 + r12)|0;
 r14 = heapU16[(r13+54)>>1];
 r15 = heapU16[(r12+48)>>1];
if(!(uint(r14) <uint(r15))) //_LBB63_10
{
 r12 = heapU16[(r12+54)>>1];
 r13 = heapU16[(r13+48)>>1];
if(!(uint(r12) <uint(r13))) //_LBB63_10
{
 r12 = heap32[(r1+23)];
 r13 = r12 >> 2;
 r13 = heap32[(r13)];
 r13 = r13 >> 2;
 r13 = heap32[(r13+3)];
 heap32[(g0)] = r12;
 heap32[(g0+1)] = r9;
 heap32[(g0+2)] = r11;
 heap32[(g0+3)] = r4;
 __FUNCTION_TABLE__[(r13)>>2](i7);
 r12 = heap32[(r1+24)];
if(!(r12 ==0)) //_LBB63_10
{
 r13 = r12 >> 2;
 r13 = heap32[(r13)];
 r13 = r13 >> 2;
 r13 = heap32[(r13+3)];
 heap32[(g0)] = r12;
 heap32[(g0+1)] = r9;
 heap32[(g0+2)] = r11;
 heap32[(g0+3)] = r4;
 __FUNCTION_TABLE__[(r13)>>2](i7);
}
}
}
}
}
}
 r10 = r10 << 6;
 r7 = (r7 + r10)|0;
 r7 = (r7 + r0)|0;
 r10 = heapU16[(r7+48)>>1];
 r10 = (r10 + 1)|0;
 heap16[(r7+48)>>1] = r10;
}
 r7 = heapU16[(r2)>>1];
 r7 = (r7 + -1)|0;
 heap16[(r2)>>1] = r7;
 r7 = heapU16[(r5+-2)>>1];
 r9 = heapU16[(r5)>>1];
 r10 = heapU16[(r5+-4)>>1];
 r11 = heapU16[(r5+-6)>>1];
 heap16[(r5+-2)>>1] = r11;
 heap16[(r5)>>1] = r10;
 heap16[(r5+-6)>>1] = r7;
 heap16[(r5+-4)>>1] = r9;
 r9 = heapU16[(r5+-10)>>1];
 if(uint(r7) >=uint(r9)) //_LBB63_14
{
break _3;
}
else{
 r7 = heap32[(r1+15)];
 r5 = (r5 + -4)|0;
continue _3;
}
}
}
 return;
}

function _ZN20btAxisSweep3InternalItE7setAabbEP17btBroadphaseProxyRK9btVector3S5_P12btDispatcher(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
 var r1;
 var r2;
 var r3;
 var r4;
 var r5;
 var r6;
 var r7;
 var r8;
 var r9;
 var r10;
 var r11;
 var r12;
 var r13;
 var r14;
 var r15;
 var r16;
 var r17;
 var r18;
 var r19;
 var r20;
 var f0;
 var f1;
 var f2;
var __label__ = 0;
 i7 = sp + -40;var g0 = i7>>2; // save stack
 r0 = heap32[(fp+2)];
 r1 = heap32[(fp+1)];
 r2 = r0 >> 2;
 r3 = r1 >> 2;
 heap32[(r3+4)] = heap32[(r2)];
 heap32[(r3+5)] = heap32[(r2+1)];
 r4 = heap32[(fp+3)];
 heap32[(r3+6)] = heap32[(r2+2)];
 heap32[(r3+7)] = heap32[(r2+3)];
 r5 = r4 >> 2;
 heap32[(r3+8)] = heap32[(r5)];
 heap32[(r3+9)] = heap32[(r5+1)];
 r6 = heap32[(fp)];
 heap32[(r3+10)] = heap32[(r5+2)];
 heap32[(r3+11)] = heap32[(r5+3)];
 r7 = r6 >> 2;
 r1 = heapU16[(r1+12)>>1];
 r8 = heap32[(r7+15)];
 f0 = heapFloat[(r2)];
 f1 = heapFloat[(r2+1)];
 f2 = heapFloat[(r2+2)];
 r2 = sp + -6;
 heap32[(g0)] = r6;
 heap32[(g0+1)] = r2;
 heapFloat[(g0+2)] = f0;
 heapFloat[(g0+3)] = f1;
 heapFloat[(g0+4)] = f2;
 heap32[(g0+5)] = 0;
 _ZNK20btAxisSweep3InternalItE8quantizeEPtRK9btVector3i(i7);
 f0 = heapFloat[(r5)];
 f1 = heapFloat[(r5+1)];
 f2 = heapFloat[(r5+2)];
 r1 = r1 << 6;
 r5 = sp + -12;
 r1 = (r8 + r1)|0;
 heap32[(g0)] = r6;
 heap32[(g0+1)] = r5;
 heapFloat[(g0+2)] = f0;
 heapFloat[(g0+3)] = f1;
 heapFloat[(g0+4)] = f2;
 heap32[(g0+5)] = 1;
 r8 = heap32[(fp+4)];
 r1 = (r1 + 48)|0;
 r9 = 0;
 _ZNK20btAxisSweep3InternalItE8quantizeEPtRK9btVector3i(i7);
 r10 = r9;
_1: while(true){
 r11 = r9 << 2;
 r12 = r9 << 1;
 r13 = (r1 - r12)|0;
 r11 = (r6 - r11)|0;
 r14 = heapU16[(r13)>>1];
 r13 = heapU16[(r13+6)>>1];
 r11 = r11 >> 2;
 r15 = (r2 - r12)|0;
 r12 = (r5 - r12)|0;
 r16 = heap32[(r11+17)];
 r17 = r14 << 2;
 r18 = r13 << 2;
 r15 = heapU16[(r15)>>1];
 r19 = heapU16[(r16+r17)>>1];
 r20 = heapU16[(r16+r18)>>1];
 r12 = heapU16[(r12)>>1];
 heap16[(r16+r17)>>1] = r15;
 r11 = heap32[(r11+17)];
 r15 = (r15 - r19)|0;
 heap16[(r11+r18)>>1] = r12;
if(!(r15 >-1)) //_LBB64_3
{
 heap32[(g0)] = r6;
 heap32[(g0+1)] = r10;
 heap32[(g0+2)] = r14;
 heap32[(g0+3)] = 1;
 _ZN20btAxisSweep3InternalItE11sortMinDownEitP12btDispatcherb(i7);
}
 r11 = (r12 - r20)|0;
if(!(r11 <1)) //_LBB64_5
{
 heap32[(g0)] = r6;
 heap32[(g0+1)] = r10;
 heap32[(g0+2)] = r13;
 heap32[(g0+3)] = 1;
 _ZN20btAxisSweep3InternalItE9sortMaxUpEitP12btDispatcherb(i7);
}
if(!(r15 <1)) //_LBB64_7
{
 heap32[(g0)] = r6;
 heap32[(g0+1)] = r10;
 heap32[(g0+2)] = r14;
 heap32[(g0+3)] = r8;
 heap32[(g0+4)] = 1;
 _ZN20btAxisSweep3InternalItE9sortMinUpEitP12btDispatcherb(i7);
}
if(!(r11 >-1)) //_LBB64_9
{
 heap32[(g0)] = r6;
 heap32[(g0+1)] = r10;
 heap32[(g0+2)] = r13;
 heap32[(g0+3)] = r8;
 heap32[(g0+4)] = 1;
 _ZN20btAxisSweep3InternalItE11sortMaxDownEitP12btDispatcherb(i7);
}
 r9 = (r9 + -1)|0;
 r10 = (r10 + 1)|0;
 if(r9 !=-3) //_LBB64_1
{
continue _1;
}
else{
break _1;
}
}
 r1 = heap32[(r7+27)];
if(!(r1 ==0)) //_LBB64_12
{
 r2 = r1 >> 2;
 r2 = heap32[(r2)];
 r2 = r2 >> 2;
 r2 = heap32[(r2+4)];
 r3 = heap32[(r3+15)];
 heap32[(g0)] = r1;
 heap32[(g0+1)] = r3;
 heap32[(g0+2)] = r0;
 heap32[(g0+3)] = r4;
 heap32[(g0+4)] = r8;
 __FUNCTION_TABLE__[(r2)>>2](i7);
}
 return;
}

function _ZN20btAxisSweep3InternalItE12destroyProxyEP17btBroadphaseProxyP12btDispatcher(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
 var r1;
 var r2;
 var r3;
 var r4;
 var r5;
 var r6;
 var r7;
 var r8;
 var r9;
 var r10;
 var r11;
 var r12;
 var r13;
var __label__ = 0;
 i7 = sp + -24;var g0 = i7>>2; // save stack
 r0 = heap32[(fp)];
 r1 = r0 >> 2;
 r2 = heap32[(r1+27)];
 r3 = heap32[(fp+1)];
 r4 = heap32[(fp+2)];
if(!(r2 ==0)) //_LBB65_2
{
 r5 = r2 >> 2;
 r5 = heap32[(r5)];
 r5 = r5 >> 2;
 r6 = r3 >> 2;
 r5 = heap32[(r5+3)];
 r6 = heap32[(r6+15)];
 heap32[(g0)] = r2;
 heap32[(g0+1)] = r6;
 heap32[(g0+2)] = r4;
 __FUNCTION_TABLE__[(r5)>>2](i7);
}
 r2 = heap32[(r1+23)];
 r5 = r2 >> 2;
 r5 = heap32[(r5)];
 r5 = r5 >> 2;
 r3 = r3 >> 2;
 r3 = heap32[(r3+3)];
 r6 = heap32[(r1+15)];
 r5 = heap32[(r5+14)];
 heap32[(g0)] = r2;
 __FUNCTION_TABLE__[(r5)>>2](i7);
 r2 = r_g0;
if(!(r2 !=0)) //_LBB65_4
{
 r2 = heap32[(r1+23)];
 r5 = r2 >> 2;
 r5 = heap32[(r5)];
 r5 = r5 >> 2;
 r5 = heap32[(r5+4)];
 r7 = r3 & 65535;
 r7 = r7 << 6;
 r7 = (r6 + r7)|0;
 heap32[(g0)] = r2;
 heap32[(g0+1)] = r7;
 heap32[(g0+2)] = r4;
 __FUNCTION_TABLE__[(r5)>>2](i7);
}
 r2 = heap32[(r1+15)];
 r5 = heapU16[(r0+56)>>1];
 r7 = heapU16[(r2+54)>>1];
 r7 = (r7 + -2)|0;
 heap16[(r2+54)>>1] = r7;
 r2 = heap32[(r1+15)];
 r7 = heapU16[(r2+56)>>1];
 r7 = (r7 + -2)|0;
 r8 = r3 & 65535;
 heap16[(r2+56)>>1] = r7;
 r2 = heap32[(r1+15)];
 r7 = r8 << 6;
 r9 = heapU16[(r2+58)>>1];
 r6 = (r6 + r7)|0;
 r5 = r5 << 1;
 r6 = (r6 + 54)|0;
 r10 = 0;
 r9 = (r9 + -2)|0;
 heap16[(r2+58)>>1] = r9;
 r2 = r10;
_7: while(true){
 r9 = r2 << 2;
 r9 = (r0 + r9)|0;
 r9 = r9 >> 2;
 r11 = heapU16[(r6)>>1];
 r12 = heapU16[(r0+6)>>1];
 r9 = heap32[(r9+17)];
 r13 = r11 << 2;
 heap16[(r9+r13)>>1] = r12;
 heap32[(g0)] = r0;
 heap32[(g0+1)] = r2;
 heap32[(g0+2)] = r11;
 heap32[(g0+3)] = 0;
 _ZN20btAxisSweep3InternalItE9sortMaxUpEitP12btDispatcherb(i7);
 r11 = heapU16[(r6+-6)>>1];
 r12 = heapU16[(r0+6)>>1];
 r13 = r11 << 2;
 heap16[(r9+r13)>>1] = r12;
 heap32[(g0)] = r0;
 heap32[(g0+1)] = r2;
 heap32[(g0+2)] = r11;
 heap32[(g0+3)] = r4;
 heap32[(g0+4)] = 0;
 r11 = r5 << 2;
 _ZN20btAxisSweep3InternalItE9sortMinUpEitP12btDispatcherb(i7);
 r9 = (r9 + r11)|0;
 heap16[(r9+-2)>>1] = r10;
 r11 = heapU16[(r0+6)>>1];
 r2 = (r2 + 1)|0;
 r6 = (r6 + 2)|0;
 heap16[(r9+-4)>>1] = r11;
 if(r2 !=3) //_LBB65_5
{
continue _7;
}
else{
break _7;
}
}
if(!(r8 ==0)) //_LBB65_8
{
 r2 = heapU16[(r0+58)>>1];
 if(uint(r2) >uint(r8)) //_LBB65_9
{
 r1 = heap32[(r1+15)];
 r2 = heapU16[(r0+64)>>1];
 r1 = (r1 + r7)|0;
 heap16[(r1+48)>>1] = r2;
 heap16[(r0+64)>>1] = r3;
 r1 = heapU16[(r0+56)>>1];
 r1 = (r1 + -1)|0;
 heap16[(r0+56)>>1] = r1;
 return;
}
}
 r0 = _2E_str11;
 r1 = _2E_str112;
 heap32[(g0)] = r0;
 heap32[(g0+1)] = r1;
 heap32[(g0+2)] = 495;
 _assert(i7);
}

function _ZN20btAxisSweep3InternalItE11createProxyERK9btVector3S3_iPvssP12btDispatcherS4_(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
 var r1;
 var r2;
 var r3;
 var r4;
 var r5;
 var r6;
 var r7;
 var r8;
 var r9;
 var r10;
 var r11;
 var r12;
 var r13;
 var r14;
 var r15;
 var r16;
 var r17;
 var r18;
 var f0;
 var f1;
 var f2;
var __label__ = 0;
 i7 = sp + -56;var g0 = i7>>2; // save stack
 r0 = heap32[(fp+1)];
 r1 = r0 >> 2;
 f0 = heapFloat[(r1)];
 f1 = heapFloat[(r1+1)];
 f2 = heapFloat[(r1+2)];
 r1 = heap32[(fp)];
 r2 = sp + -6;
 heap32[(g0)] = r1;
 heap32[(g0+1)] = r2;
 heapFloat[(g0+2)] = f0;
 heapFloat[(g0+3)] = f1;
 heapFloat[(g0+4)] = f2;
 heap32[(g0+5)] = 0;
 r2 = heap32[(fp+2)];
 _ZNK20btAxisSweep3InternalItE8quantizeEPtRK9btVector3i(i7);
 r3 = r2 >> 2;
 f0 = heapFloat[(r3)];
 f1 = heapFloat[(r3+1)];
 f2 = heapFloat[(r3+2)];
 r3 = sp + -12;
 heap32[(g0)] = r1;
 heap32[(g0+1)] = r3;
 heapFloat[(g0+2)] = f0;
 heapFloat[(g0+3)] = f1;
 heapFloat[(g0+4)] = f2;
 heap32[(g0+5)] = 1;
 _ZNK20btAxisSweep3InternalItE8quantizeEPtRK9btVector3i(i7);
 r3 = heapU16[(r1+64)>>1];
 if(r3 !=0) //_LBB66_2
{
 r4 = heap32[(fp+4)];
 r5 = heap32[(fp+5)];
 r6 = heap32[(fp+6)];
 r7 = heap32[(fp+7)];
 r8 = heap32[(fp+8)];
 r9 = r1 >> 2;
 r10 = r3 << 6;
 r11 = heap32[(r9+15)];
 r10 = (r11 + r10)|0;
 r11 = heapU16[(r10+48)>>1];
 heap16[(r1+64)>>1] = r11;
 r11 = heapU16[(r1+56)>>1];
 r11 = (r11 + 1)|0;
 r12 = r10 >> 2;
 heap16[(r1+56)>>1] = r11;
 heap32[(r12+3)] = r3;
 heap32[(r12)] = r4;
 heap16[(r10+4)>>1] = r5;
 heap16[(r10+6)>>1] = r6;
 heap32[(r12+2)] = r8;
 r8 = heap32[(r9+15)];
 r11 = heapU16[(r1+56)>>1];
 r11 = r11 << 1;
 r12 = heapU16[(r8+54)>>1];
 r13 = r11 & 65534;
 r12 = (r12 + 2)|0;
 r14 = (r13 + -1)|0;
 heap16[(r8+54)>>1] = r12;
 r8 = r14 << 2;
 r12 = heap32[(r9+17)];
 r14 = (r12 + r8)|0;
 r15 = r13 | 1;
 r14 = heapU16[(r14+2)>>1];
 r16 = heapU16[(r12+r8)>>1];
 r15 = r15 << 2;
 r17 = (r12 + r15)|0;
 heap16[(r12+r15)>>1] = r16;
 heap16[(r17+2)>>1] = r14;
 r12 = heap32[(r9+17)];
 r14 = heapU16[(sp+-6)>>1];
 heap16[(r12+r8)>>1] = r14;
 r12 = heap32[(r9+17)];
 r12 = (r12 + r8)|0;
 heap16[(r12+2)>>1] = r3;
 r12 = heap32[(r9+17)];
 r14 = heapU16[(sp+-12)>>1];
 r13 = r13 << 2;
 heap16[(r12+r13)>>1] = r14;
 r12 = heap32[(r9+17)];
 r12 = (r12 + r13)|0;
 r14 = (r11 + -1)|0;
 heap16[(r12+2)>>1] = r3;
 heap16[(r10+48)>>1] = r14;
 heap16[(r10+54)>>1] = r11;
 r12 = heap32[(r9+15)];
 r16 = heapU16[(r12+56)>>1];
 r16 = (r16 + 2)|0;
 heap16[(r12+56)>>1] = r16;
 r12 = heap32[(r9+18)];
 r16 = (r12 + r8)|0;
 r16 = heapU16[(r16+2)>>1];
 r17 = heapU16[(r12+r8)>>1];
 r18 = (r12 + r15)|0;
 heap16[(r12+r15)>>1] = r17;
 heap16[(r18+2)>>1] = r16;
 r12 = heap32[(r9+18)];
 r16 = heapU16[(sp+-4)>>1];
 heap16[(r12+r8)>>1] = r16;
 r12 = heap32[(r9+18)];
 r12 = (r12 + r8)|0;
 heap16[(r12+2)>>1] = r3;
 r12 = heap32[(r9+18)];
 r16 = heapU16[(sp+-10)>>1];
 heap16[(r12+r13)>>1] = r16;
 r12 = heap32[(r9+18)];
 r12 = (r12 + r13)|0;
 heap16[(r12+2)>>1] = r3;
 heap16[(r10+50)>>1] = r14;
 heap16[(r10+56)>>1] = r11;
 r12 = heap32[(r9+15)];
 r16 = heapU16[(r12+58)>>1];
 r16 = (r16 + 2)|0;
 heap16[(r12+58)>>1] = r16;
 r12 = heap32[(r9+19)];
 r16 = (r12 + r8)|0;
 r16 = heapU16[(r16+2)>>1];
 r17 = heapU16[(r12+r8)>>1];
 r18 = (r12 + r15)|0;
 heap16[(r12+r15)>>1] = r17;
 heap16[(r18+2)>>1] = r16;
 r12 = heap32[(r9+19)];
 r15 = heapU16[(sp+-2)>>1];
 heap16[(r12+r8)>>1] = r15;
 r12 = heap32[(r9+19)];
 r8 = (r12 + r8)|0;
 heap16[(r8+2)>>1] = r3;
 r8 = heap32[(r9+19)];
 r12 = heapU16[(sp+-8)>>1];
 heap16[(r8+r13)>>1] = r12;
 r8 = heap32[(r9+19)];
 r8 = (r8 + r13)|0;
 heap16[(r8+2)>>1] = r3;
 heap16[(r10+52)>>1] = r14;
 heap16[(r10+58)>>1] = r11;
 r8 = heapU16[(r10+48)>>1];
 heap32[(g0)] = r1;
 heap32[(g0+1)] = 0;
 heap32[(g0+2)] = r8;
 heap32[(g0+3)] = 0;
 _ZN20btAxisSweep3InternalItE11sortMinDownEitP12btDispatcherb(i7);
 r8 = heapU16[(r10+54)>>1];
 heap32[(g0)] = r1;
 heap32[(g0+1)] = 0;
 heap32[(g0+2)] = r8;
 heap32[(g0+3)] = r7;
 heap32[(g0+4)] = 0;
 _ZN20btAxisSweep3InternalItE11sortMaxDownEitP12btDispatcherb(i7);
 r8 = heapU16[(r10+50)>>1];
 heap32[(g0)] = r1;
 heap32[(g0+1)] = 1;
 heap32[(g0+2)] = r8;
 heap32[(g0+3)] = 0;
 _ZN20btAxisSweep3InternalItE11sortMinDownEitP12btDispatcherb(i7);
 r8 = heapU16[(r10+56)>>1];
 heap32[(g0)] = r1;
 heap32[(g0+1)] = 1;
 heap32[(g0+2)] = r8;
 heap32[(g0+3)] = r7;
 heap32[(g0+4)] = 0;
 _ZN20btAxisSweep3InternalItE11sortMaxDownEitP12btDispatcherb(i7);
 r8 = heapU16[(r10+52)>>1];
 heap32[(g0)] = r1;
 heap32[(g0+1)] = 2;
 heap32[(g0+2)] = r8;
 heap32[(g0+3)] = 1;
 _ZN20btAxisSweep3InternalItE11sortMinDownEitP12btDispatcherb(i7);
 r8 = heapU16[(r10+58)>>1];
 heap32[(g0)] = r1;
 heap32[(g0+1)] = 2;
 heap32[(g0+2)] = r8;
 heap32[(g0+3)] = r7;
 heap32[(g0+4)] = 1;
 _ZN20btAxisSweep3InternalItE11sortMaxDownEitP12btDispatcherb(i7);
        updateMandreelStats(performance.now());
 r1 = heap32[(r9+27)];
 r8 = heap32[(r9+15)];
if(!(r1 ==0)) //_LBB66_4
{
 r9 = heap32[(fp+3)];
 r10 = r1 >> 2;
 r10 = heap32[(r10)];
 r10 = r10 >> 2;
 r10 = heap32[(r10+2)];
 r11 = r3 << 6;
 heap32[(g0)] = r1;
 heap32[(g0+1)] = r0;
 heap32[(g0+2)] = r2;
 heap32[(g0+3)] = r9;
 heap32[(g0+4)] = r4;
 heap32[(g0+5)] = r5;
 heap32[(g0+6)] = r6;
 heap32[(g0+7)] = r7;
 heap32[(g0+8)] = 0;
 r0 = (r8 + r11)|0;
 r0 = r0 >> 2;
 __FUNCTION_TABLE__[(r10)>>2](i7);
 heap32[(r0+15)] = r_g0;
}
 r0 = r3 << 6;
 r0 = (r8 + r0)|0;
 r_g0 = r0;
 return;
}
else{
 r0 = _2E_str213;
 r1 = _2E_str112;
 heap32[(g0)] = r0;
 heap32[(g0+1)] = r1;
 heap32[(g0+2)] = 483;
 _assert(i7);
}
}

function _ZN20btAlignedObjectArrayI16btBroadphasePairE6resizeEiRKS0_(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
 var r1;
 var r2;
 var r3;
 var r4;
 var r5;
 var r6;
 var r7;
 var r8;
 var r9;
 var r10;
 var r11;
var __label__ = 0;
 i7 = sp + -8;var g0 = i7>>2; // save stack
 r0 = heap32[(fp)];
 r1 = r0 >> 2;
 r2 = heap32[(r1+1)];
 r3 = heap32[(fp+1)];
_1: do {
if(!(r2 >r3)) //_LBB67_20
{
if(!(r2 >=r3)) //_LBB67_20
{
 r4 = heap32[(r1+2)];
if(!(r4 >=r3)) //_LBB67_18
{
 if(r3 !=0) //_LBB67_5
{
 r4 = gNumAlignedAllocs;
 r4 = r4 >> 2;
 r5 = heap32[(r4)];
 r6 = r3 << 4;
 r5 = (r5 + 1)|0;
 r6 = r6 | 3;
 heap32[(r4)] = r5;
 r4 = (r6 + 16)|0;
 heap32[(g0)] = r4;
 malloc(i7);
 r4 = r_g0;
 if(r4 !=0) //_LBB67_7
{
 r5 = 0;
 r6 = (r4 + 4)|0;
 r5 = (r5 - r6)|0;
 r5 = r5 & 15;
 r5 = (r4 + r5)|0;
 r6 = (r5 + 4)|0;
 r5 = r5 >> 2;
 heap32[(r5)] = r4;
 r4 = r6;
}
}
else{
 r4 = 0;
}
 r5 = (r0 + 12)|0;
 if(r2 <1) //_LBB67_10
{
 r6 = r5 >> 2;
 r8 = heap32[(r6)];
}
else{
 r6 = 0;
 r7 = (r6 - r2)|0;
_14: while(true){
 r8 = r5 >> 2;
 r8 = heap32[(r8)];
 r9 = r6 << 4;
 r10 = (r8 - r9)|0;
 r10 = r10 >> 2;
 r9 = (r4 - r9)|0;
 r11 = heap32[(r10)];
 r9 = r9 >> 2;
 heap32[(r9)] = r11;
 r11 = heap32[(r10+1)];
 heap32[(r9+1)] = r11;
 r11 = heap32[(r10+2)];
 heap32[(r9+2)] = r11;
 r10 = heap32[(r10+3)];
 r6 = (r6 + -1)|0;
 heap32[(r9+3)] = r10;
if(!(r7 !=r6)) //_LBB67_11
{
break _14;
}
}
 r5 = (r0 + 12)|0;
}
if(!(r8 ==0)) //_LBB67_17
{
 r6 = heapU8[r0+16];
if(!(r6 ==0)) //_LBB67_16
{
 r6 = gNumAlignedFree;
 r6 = r6 >> 2;
 r7 = heap32[(r6)];
 r7 = (r7 + 1)|0;
 r8 = r8 >> 2;
 heap32[(r6)] = r7;
 r6 = heap32[(r8+-1)];
 heap32[(g0)] = r6;
 free(i7);
}
 r6 = r5 >> 2;
 heap32[(r6)] = 0;
}
 r6 = 1;
 r5 = r5 >> 2;
 heap8[r0+16] = r6;
 heap32[(r5)] = r4;
 heap32[(r1+2)] = r3;
 if(r2 >=r3) //_LBB67_20
{
break _1;
}
}
 r0 = heap32[(fp+2)];
_25: while(true){
 r4 = r0 >> 2;
 r5 = r2 << 4;
 r6 = heap32[(r1+3)];
 r5 = (r6 + r5)|0;
 r6 = heap32[(r4)];
 r5 = r5 >> 2;
 heap32[(r5)] = r6;
 r6 = heap32[(r4+1)];
 heap32[(r5+1)] = r6;
 r6 = heap32[(r4+2)];
 heap32[(r5+2)] = r6;
 r4 = heap32[(r4+3)];
 r2 = (r2 + 1)|0;
 heap32[(r5+3)] = r4;
 if(r3 !=r2) //_LBB67_19
{
continue _25;
}
else{
break _1;
}
}
}
}
} while(0);
 heap32[(r1+1)] = r3;
 return;
}

function _ZN20btAxisSweep3InternalItE25calculateOverlappingPairsEP12btDispatcher(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
 var r1;
 var r2;
 var r3;
 var r4;
 var r5;
 var r6;
 var r7;
 var r8;
 var r9;
 var r10;
 var r11;
 var r12;
 var r13;
 var r14;
var __label__ = 0;
 i7 = sp + -48;var g0 = i7>>2; // save stack
 r0 = heap32[(fp)];
 r0 = r0 >> 2;
 r1 = heap32[(r0+23)];
 r2 = r1 >> 2;
 r2 = heap32[(r2)];
 r2 = r2 >> 2;
 r2 = heap32[(r2+14)];
 heap32[(g0)] = r1;
 __FUNCTION_TABLE__[(r2)>>2](i7);
 r1 = r_g0;
if(!(r1 ==0)) //_LBB68_22
{
 r1 = heap32[(fp+1)];
 r2 = heap32[(r0+23)];
 r3 = r2 >> 2;
 r3 = heap32[(r3)];
 r3 = r3 >> 2;
 r3 = heap32[(r3+7)];
 heap32[(g0)] = r2;
 __FUNCTION_TABLE__[(r3)>>2](i7);
 r2 = r_g0;
 r3 = r2 >> 2;
 r3 = heap32[(r3+1)];
 if(r3 >1) //_LBB68_3
{
 r3 = (r3 + -1)|0;
 heap32[(g0)] = r2;
 heap32[(g0+1)] = 0;
 heap32[(g0+2)] = r3;
 r3 = r2 >> 2;
 _ZN20btAlignedObjectArrayI16btBroadphasePairE17quickSortInternalI29btBroadphasePairSortPredicateEEvT_ii(i7);
 r3 = heap32[(r3+1)];
}
 r4 = sp + -32;
 r5 = r4 >> 2;
 heap32[(fp+-8)] = 0;
 heap32[(r5+1)] = 0;
 heap32[(r5+2)] = 0;
 heap32[(r5+3)] = 0;
 r5 = heap32[(r0+26)];
 r3 = (r3 - r5)|0;
 heap32[(g0)] = r2;
 heap32[(g0+1)] = r3;
 heap32[(g0+2)] = r4;
 r3 = 0;
 _ZN20btAlignedObjectArrayI16btBroadphasePairE6resizeEiRKS0_(i7);
 heap32[(r0+26)] = 0;
 r4 = r3;
 r5 = r3;
 r6 = r3;
 r7 = r3;
_6: while(true){
 r8 = r2 >> 2;
 r9 = heap32[(r8+1)];
 if(r9 >r7) //_LBB68_5
{
 r8 = heap32[(r8+3)];
 r9 = r7 << 4;
 r9 = (r8 + r9)|0;
 r9 = r9 >> 2;
 r10 = heap32[(r9)];
 r11 = r7 << 2;
 r12 = heap32[(r9+1)];
 if(r10 !=r5) //_LBB68_7
{
__label__ = 6;
}
else{
 if(r12 ==r6) //_LBB68_13
{
 r4 = heap32[(r9+2)];
 if(r4 ==0) //_LBB68_15
{
__label__ = 13;
}
else{
__label__ = 12;
break _6;
}
}
else{
__label__ = 6;
}
}
if (__label__ == 6){
 r5 = (r12 + 54)|0;
 r6 = (r10 + 48)|0;
 r9 = 0;
_14: while(true){
 if(r9 <3) //_LBB68_8
{
 r13 = heapU16[(r6+6)>>1];
 r14 = heapU16[(r5+-6)>>1];
 if(uint(r13) <uint(r14)) //_LBB68_15
{
__label__ = 13;
break _14;
}
else{
 r13 = heapU16[(r5)>>1];
 r14 = heapU16[(r6)>>1];
 if(uint(r13) <uint(r14)) //_LBB68_15
{
__label__ = 13;
break _14;
}
else{
 r9 = (r9 + 1)|0;
 r5 = (r5 + 2)|0;
 r6 = (r6 + 2)|0;
}
}
}
else{
__label__ = 14;
break _14;
}
}
}
if (__label__ == 13){
 r4 = heap32[(r0+23)];
 r5 = r4 >> 2;
 r5 = heap32[(r5)];
 r5 = r5 >> 2;
 r5 = heap32[(r5+8)];
 r6 = (r8 + r3)|0;
 r9 = r11 << 2;
 heap32[(g0)] = r4;
 heap32[(g0+1)] = r6;
 heap32[(g0+2)] = r1;
 r4 = (r8 + r9)|0;
 r4 = r4 >> 2;
 __FUNCTION_TABLE__[(r5)>>2](i7);
 heap32[(r4)] = 0;
 heap32[(r4+1)] = 0;
 r4 = heap32[(r0+26)];
 r4 = (r4 + 1)|0;
 r5 = gOverlappingPairs;
 r5 = r5 >> 2;
 heap32[(r0+26)] = r4;
 r6 = heap32[(r5)];
 r6 = (r6 + -1)|0;
 heap32[(r5)] = r6;
}
 r7 = (r7 + 1)|0;
 r3 = (r3 + 16)|0;
 r5 = r10;
 r6 = r12;
}
else{
__label__ = 16;
break _6;
}
}
switch(__label__ ){//multiple entries
case 16:
 if(r9 >1) //_LBB68_20
{
 r4 = (r9 + -1)|0;
 heap32[(g0)] = r2;
 heap32[(g0+1)] = 0;
 heap32[(g0+2)] = r4;
 _ZN20btAlignedObjectArrayI16btBroadphasePairE17quickSortInternalI29btBroadphasePairSortPredicateEEvT_ii(i7);
 r9 = heap32[(r8+1)];
 r4 = heap32[(r0+26)];
}
 r1 = sp + -16;
 r3 = r1 >> 2;
 heap32[(fp+-4)] = 0;
 heap32[(r3+1)] = 0;
 heap32[(r3+2)] = 0;
 heap32[(r3+3)] = 0;
 r3 = (r9 - r4)|0;
 heap32[(g0)] = r2;
 heap32[(g0+1)] = r3;
 heap32[(g0+2)] = r1;
 _ZN20btAlignedObjectArrayI16btBroadphasePairE6resizeEiRKS0_(i7);
 heap32[(r0+26)] = 0;
break;
case 12:
 r8 = _2E_str314;
 r0 = _2E_str112;
 heap32[(g0)] = r8;
 heap32[(g0+1)] = r0;
 heap32[(g0+2)] = 687;
 _assert(i7);
break;
}
}
 return;
}

function _ZN20btAxisSweep3InternalItED2Ev(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
 var r1;
 var r2;
 var r3;
 var r4;
 var r5;
var __label__ = 0;
 i7 = sp + -8;var g0 = i7>>2; // save stack
 r0 = heap32[(fp)];
 r1 = _ZTV20btAxisSweep3InternalItE;
 r2 = r0 >> 2;
 r1 = (r1 + 8)|0;
 heap32[(r2)] = r1;
 r1 = heap32[(r2+27)];
if(!(r1 ==0)) //_LBB69_5
{
 r1 = heap32[(r2+28)];
 r3 = r1 >> 2;
 r3 = heap32[(r3)];
 r3 = r3 >> 2;
 r3 = heap32[(r3)];
 heap32[(g0)] = r1;
 __FUNCTION_TABLE__[(r3)>>2](i7);
 r1 = heap32[(r2+28)];
if(!(r1 ==0)) //_LBB69_3
{
 r3 = gNumAlignedFree;
 r3 = r3 >> 2;
 r4 = heap32[(r3)];
 r4 = (r4 + 1)|0;
 r1 = r1 >> 2;
 heap32[(r3)] = r4;
 r1 = heap32[(r1+-1)];
 heap32[(g0)] = r1;
 free(i7);
}
 r1 = heap32[(r2+27)];
 r3 = r1 >> 2;
 r3 = heap32[(r3)];
 r3 = r3 >> 2;
 r3 = heap32[(r3)];
 heap32[(g0)] = r1;
 __FUNCTION_TABLE__[(r3)>>2](i7);
 r1 = heap32[(r2+27)];
if(!(r1 ==0)) //_LBB69_5
{
 r3 = gNumAlignedFree;
 r3 = r3 >> 2;
 r4 = heap32[(r3)];
 r4 = (r4 + 1)|0;
 r1 = r1 >> 2;
 heap32[(r3)] = r4;
 r1 = heap32[(r1+-1)];
 heap32[(g0)] = r1;
 free(i7);
}
}
 r1 = 0;
_8: while(true){
 r3 = r1 << 2;
 r3 = (r0 + r3)|0;
 r3 = r3 >> 2;
 r3 = heap32[(r3+22)];
if(!(r3 ==0)) //_LBB69_8
{
 r4 = gNumAlignedFree;
 r4 = r4 >> 2;
 r5 = heap32[(r4)];
 r5 = (r5 + 1)|0;
 r3 = r3 >> 2;
 heap32[(r4)] = r5;
 r3 = heap32[(r3+-1)];
 heap32[(g0)] = r3;
 free(i7);
}
 r1 = (r1 + -1)|0;
 if(r1 !=-3) //_LBB69_6
{
continue _8;
}
else{
break _8;
}
}
 r1 = heap32[(r2+15)];
if(!(r1 ==0)) //_LBB69_11
{
 r3 = gNumAlignedFree;
 r3 = r3 >> 2;
 r4 = heap32[(r3)];
 r4 = (r4 + 1)|0;
 r1 = r1 >> 2;
 heap32[(r3)] = r4;
 r1 = heap32[(r1+-1)];
 heap32[(g0)] = r1;
 free(i7);
}
 r0 = heapU8[r0+100];
if(!(r0 ==0)) //_LBB69_14
{
 r0 = heap32[(r2+23)];
 r1 = r0 >> 2;
 r1 = heap32[(r1)];
 r1 = r1 >> 2;
 r1 = heap32[(r1)];
 heap32[(g0)] = r0;
 __FUNCTION_TABLE__[(r1)>>2](i7);
 r0 = heap32[(r2+23)];
if(!(r0 ==0)) //_LBB69_14
{
 r1 = gNumAlignedFree;
 r1 = r1 >> 2;
 r2 = heap32[(r1)];
 r2 = (r2 + 1)|0;
 r0 = r0 >> 2;
 heap32[(r1)] = r2;
 r0 = heap32[(r0+-1)];
 heap32[(g0)] = r0;
 free(i7);
}
}
 return;
}

function _ZN20btAxisSweep3InternalItED1Ev(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
var __label__ = 0;
 i7 = sp + -8;var g0 = i7>>2; // save stack
 r0 = heap32[(fp)];
 heap32[(g0)] = r0;
 _ZN20btAxisSweep3InternalItED2Ev(i7);
 return;
}

function _ZN20btAxisSweep3InternalItED0Ev(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
 var r1;
 var r2;
 var r3;
 var r4;
 var r5;
var __label__ = 0;
 i7 = sp + -8;var g0 = i7>>2; // save stack
 r0 = heap32[(fp)];
 r1 = _ZTV20btAxisSweep3InternalItE;
 r2 = r0 >> 2;
 r1 = (r1 + 8)|0;
 heap32[(r2)] = r1;
 r1 = heap32[(r2+27)];
if(!(r1 ==0)) //_LBB71_5
{
 r1 = heap32[(r2+28)];
 r3 = r1 >> 2;
 r3 = heap32[(r3)];
 r3 = r3 >> 2;
 r3 = heap32[(r3)];
 heap32[(g0)] = r1;
 __FUNCTION_TABLE__[(r3)>>2](i7);
 r1 = heap32[(r2+28)];
if(!(r1 ==0)) //_LBB71_3
{
 r3 = gNumAlignedFree;
 r3 = r3 >> 2;
 r4 = heap32[(r3)];
 r4 = (r4 + 1)|0;
 r1 = r1 >> 2;
 heap32[(r3)] = r4;
 r1 = heap32[(r1+-1)];
 heap32[(g0)] = r1;
 free(i7);
}
 r1 = heap32[(r2+27)];
 r3 = r1 >> 2;
 r3 = heap32[(r3)];
 r3 = r3 >> 2;
 r3 = heap32[(r3)];
 heap32[(g0)] = r1;
 __FUNCTION_TABLE__[(r3)>>2](i7);
 r1 = heap32[(r2+27)];
if(!(r1 ==0)) //_LBB71_5
{
 r3 = gNumAlignedFree;
 r3 = r3 >> 2;
 r4 = heap32[(r3)];
 r4 = (r4 + 1)|0;
 r1 = r1 >> 2;
 heap32[(r3)] = r4;
 r1 = heap32[(r1+-1)];
 heap32[(g0)] = r1;
 free(i7);
}
}
 r1 = 0;
_8: while(true){
 r3 = r1 << 2;
 r3 = (r0 + r3)|0;
 r3 = r3 >> 2;
 r3 = heap32[(r3+22)];
if(!(r3 ==0)) //_LBB71_8
{
 r4 = gNumAlignedFree;
 r4 = r4 >> 2;
 r5 = heap32[(r4)];
 r5 = (r5 + 1)|0;
 r3 = r3 >> 2;
 heap32[(r4)] = r5;
 r3 = heap32[(r3+-1)];
 heap32[(g0)] = r3;
 free(i7);
}
 r1 = (r1 + -1)|0;
 if(r1 !=-3) //_LBB71_6
{
continue _8;
}
else{
break _8;
}
}
 r1 = heap32[(r2+15)];
if(!(r1 ==0)) //_LBB71_11
{
 r3 = gNumAlignedFree;
 r3 = r3 >> 2;
 r4 = heap32[(r3)];
 r4 = (r4 + 1)|0;
 r1 = r1 >> 2;
 heap32[(r3)] = r4;
 r1 = heap32[(r1+-1)];
 heap32[(g0)] = r1;
 free(i7);
}
 r0 = heapU8[r0+100];
if(!(r0 ==0)) //_LBB71_14
{
 r0 = heap32[(r2+23)];
 r1 = r0 >> 2;
 r1 = heap32[(r1)];
 r1 = r1 >> 2;
 r1 = heap32[(r1)];
 heap32[(g0)] = r0;
 __FUNCTION_TABLE__[(r1)>>2](i7);
 r0 = heap32[(r2+23)];
if(!(r0 ==0)) //_LBB71_14
{
 r1 = gNumAlignedFree;
 r1 = r1 >> 2;
 r3 = heap32[(r1)];
 r3 = (r3 + 1)|0;
 r0 = r0 >> 2;
 heap32[(r1)] = r3;
 r0 = heap32[(r0+-1)];
 heap32[(g0)] = r0;
 free(i7);
}
}
 r0 = gNumAlignedFree;
 r0 = r0 >> 2;
 r1 = heap32[(r0)];
 r1 = (r1 + 1)|0;
 heap32[(r0)] = r1;
 r0 = heap32[(r2+-1)];
 heap32[(g0)] = r0;
 free(i7);
 return;
}

function _ZN12btAxisSweep3D0Ev(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
 var r1;
 var r2;
var __label__ = 0;
 i7 = sp + -8;var g0 = i7>>2; // save stack
 r0 = heap32[(fp)];
 r1 = _ZTV12btAxisSweep3;
 r2 = r0 >> 2;
 r1 = (r1 + 8)|0;
 heap32[(r2)] = r1;
 heap32[(g0)] = r0;
 _ZN20btAxisSweep3InternalItED2Ev(i7);
if(!(r0 ==0)) //_LBB72_2
{
 r0 = gNumAlignedFree;
 r0 = r0 >> 2;
 r1 = heap32[(r0)];
 r1 = (r1 + 1)|0;
 heap32[(r0)] = r1;
 r0 = heap32[(r2+-1)];
 heap32[(g0)] = r0;
 free(i7);
}
 return;
}

function _ZN12btAxisSweep3D1Ev(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
 var r1;
 var r2;
var __label__ = 0;
 i7 = sp + -8;var g0 = i7>>2; // save stack
 r0 = heap32[(fp)];
 r1 = _ZTV12btAxisSweep3;
 r2 = r0 >> 2;
 r1 = (r1 + 8)|0;
 heap32[(r2)] = r1;
 heap32[(g0)] = r0;
 _ZN20btAxisSweep3InternalItED2Ev(i7);
 return;
}

function _ZN20btCollisionAlgorithmD1Ev(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
 var r1;
var __label__ = 0;
 i7 = sp + 0;var g0 = i7>>2; // save stack
 r0 = heap32[(fp)];
 r1 = _ZTV20btCollisionAlgorithm;
 r0 = r0 >> 2;
 r1 = (r1 + 8)|0;
 heap32[(r0)] = r1;
 return;
}

function _ZN20btCollisionAlgorithmD0Ev(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
 var r1;
 var r2;
var __label__ = 0;
 i7 = sp + -8;var g0 = i7>>2; // save stack
 r0 = heap32[(fp)];
 r1 = _ZTV20btCollisionAlgorithm;
 r2 = r0 >> 2;
 r1 = (r1 + 8)|0;
 heap32[(r2)] = r1;
 heap32[(g0)] = r0;
 _ZdlPv(i7);
 return;
}

function _ZN6btDbvt8ICollide7ProcessEPK10btDbvtNodeS3_(sp)
{
 var i7;
 var fp = sp>>2;
var __label__ = 0;
 i7 = sp + 0;var g0 = i7>>2; // save stack
 return;
}

function _ZN6btDbvt8ICollide7ProcessEPK10btDbvtNodef(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
 var r1;
 var r2;
var __label__ = 0;
 i7 = sp + -8;var g0 = i7>>2; // save stack
 r0 = heap32[(fp)];
 r1 = r0 >> 2;
 r1 = heap32[(r1)];
 r1 = r1 >> 2;
 r1 = heap32[(r1+3)];
 r2 = heap32[(fp+1)];
 heap32[(g0)] = r0;
 heap32[(g0+1)] = r2;
 __FUNCTION_TABLE__[(r1)>>2](i7);
 return;
}

function _ZN6btDbvt8ICollide7DescentEPK10btDbvtNode(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
var __label__ = 0;
 i7 = sp + 0;var g0 = i7>>2; // save stack
 r0 = 1;
 r_g0 = r0;
 return;
}

function _ZN6btDbvt8ICollide9AllLeavesEPK10btDbvtNode(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
var __label__ = 0;
 i7 = sp + 0;var g0 = i7>>2; // save stack
 r0 = 1;
 r_g0 = r0;
 return;
}

function _ZL10insertleafP6btDbvtP10btDbvtNodeS2_(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
 var r1;
 var r2;
 var r3;
 var r4;
 var r5;
 var r6;
 var r7;
 var f0;
 var f1;
 var f2;
 var f3;
 var f4;
 var f5;
 var f6;
 var f7;
 var f8;
 var f9;
 var f10;
 var f11;
var __label__ = 0;
 i7 = sp + -8;var g0 = i7>>2; // save stack
 r0 = heap32[(fp)];
 r1 = heap32[(fp+2)];
 r0 = r0 >> 2;
 r2 = heap32[(r0)];
 if(r2 !=0) //_LBB80_2
{
 r2 = heap32[(fp+1)];
 r3 = r2 >> 2;
 r3 = heap32[(r3+10)];
 if(r3 !=0) //_LBB80_4
{
 r4 = r1 >> 2;
 f0 = heapFloat[(r4+2)];
 f1 = heapFloat[(r4+6)];
 f2 = heapFloat[(r4+1)];
 f3 = heapFloat[(r4+5)];
 f4 = heapFloat[(r4)];
 f5 = heapFloat[(r4+4)];
 f0 = f0+f1;
 f1 = f2+f3;
 f2 = f4+f5;
_5: while(true){
 r4 = r2 >> 2;
 r4 = heap32[(r4+9)];
 r4 = r4 >> 2;
 f3 = heapFloat[(r4)];
 f4 = heapFloat[(r4+4)];
 f5 = heapFloat[(r4+2)];
 f6 = heapFloat[(r4+6)];
 f7 = heapFloat[(r4+1)];
 f8 = heapFloat[(r4+5)];
 f3 = f3+f4;
 f4 = f5+f6;
 f5 = f7+f8;
 f3 = f2-f3;
 f4 = f0-f4;
 f5 = f1-f5;
 f6 =                         0;
 if(f3 <f6) //_LBB80_7
{
 f3 = -f3;
}
 if(f5 <f6) //_LBB80_10
{
 f5 = -f5;
}
 f3 = f3+f5;
 if(f4 <f6) //_LBB80_13
{
 f4 = -f4;
}
 r3 = r3 >> 2;
 f5 = heapFloat[(r3)];
 f7 = heapFloat[(r3+4)];
 f8 = heapFloat[(r3+2)];
 f9 = heapFloat[(r3+6)];
 f10 = heapFloat[(r3+1)];
 f11 = heapFloat[(r3+5)];
 f5 = f5+f7;
 f7 = f8+f9;
 f8 = f10+f11;
 f5 = f2-f5;
 f3 = f3+f4;
 f4 = f0-f7;
 f7 = f1-f8;
 if(f5 <f6) //_LBB80_16
{
 f5 = -f5;
}
 if(f7 <f6) //_LBB80_19
{
 f7 = -f7;
}
 f5 = f5+f7;
 if(f4 <f6) //_LBB80_22
{
 f4 = -f4;
}
 f4 = f5+f4;
 r3 = f3 >= f4;
 r3 = r3 & 1;
 r3 = r3 << 2;
 r2 = (r2 + r3)|0;
 r2 = r2 >> 2;
 r2 = heap32[(r2+9)];
 r3 = r2 >> 2;
 r3 = heap32[(r3+10)];
if(!(r3 !=0)) //_LBB80_5
{
break _5;
}
}
}
 r3 = r2 >> 2;
 r4 = heap32[(r0+1)];
 r5 = heap32[(r3+8)];
 if(r4 ==0) //_LBB80_26
{
 r4 = gNumAlignedAllocs;
 r4 = r4 >> 2;
 r6 = heap32[(r4)];
 r6 = (r6 + 1)|0;
 heap32[(r4)] = r6;
 heap32[(g0)] = 63;
 malloc(i7);
 r4 = r_g0;
 if(r4 !=0) //_LBB80_28
{
 r6 = 0;
 r7 = (r4 + 4)|0;
 r6 = (r6 - r7)|0;
 r6 = r6 & 15;
 r6 = (r4 + r6)|0;
 r7 = (r6 + 4)|0;
 r6 = r6 >> 2;
 heap32[(r6)] = r4;
 r4 = r7;
}
}
else{
 heap32[(r0+1)] = 0;
}
 r6 = r4 >> 2;
 heap32[(r6+8)] = r5;
 heap32[(r6+9)] = 0;
 heap32[(r6+10)] = 0;
 r7 = r1 >> 2;
 f0 = heapFloat[(r7)];
 f1 = heapFloat[(r3)];
 f0 = f0 < f1 ? f0 : f1;
 heapFloat[(r6)] = f0;
 f0 = heapFloat[(r7+4)];
 f1 = heapFloat[(r3+4)];
 f0 = f0 > f1 ? f0 : f1;
 heapFloat[(r6+4)] = f0;
 f0 = heapFloat[(r7+1)];
 f1 = heapFloat[(r3+1)];
 f0 = f0 < f1 ? f0 : f1;
 heapFloat[(r6+1)] = f0;
 f0 = heapFloat[(r7+5)];
 f1 = heapFloat[(r3+5)];
 f0 = f0 > f1 ? f0 : f1;
 heapFloat[(r6+5)] = f0;
 f0 = heapFloat[(r7+2)];
 f1 = heapFloat[(r3+2)];
 f0 = f0 < f1 ? f0 : f1;
 heapFloat[(r6+2)] = f0;
 f0 = heapFloat[(r7+6)];
 f1 = heapFloat[(r3+6)];
 f0 = f0 > f1 ? f0 : f1;
 heapFloat[(r6+6)] = f0;
_31: do {
 if(r5 ==0) //_LBB80_38
{
 heap32[(r6+9)] = r2;
 heap32[(r3+8)] = r4;
 heap32[(r6+10)] = r1;
 heap32[(r7+8)] = r4;
 heap32[(r0)] = r4;
}
else{
 r0 = heap32[(r3+8)];
 r0 = r0 >> 2;
 r0 = heap32[(r0+10)];
 r0 = r0 == r2;
 r0 = r0 & 1;
 r0 = r0 << 2;
 r0 = (r5 + r0)|0;
 r0 = r0 >> 2;
 heap32[(r0+9)] = r4;
 heap32[(r6+9)] = r2;
 heap32[(r3+8)] = r4;
 heap32[(r6+10)] = r1;
 heap32[(r7+8)] = r4;
 f0 = heapFloat[(r6)];
_34: while(true){
 r0 = r5;
 r1 = r0 >> 2;
 f1 = heapFloat[(r1)];
if(!(f1 >f0)) //_LBB80_37
{
 r2 = r4 >> 2;
 f0 = heapFloat[(r1+1)];
 f1 = heapFloat[(r2+1)];
if(!(f0 >f1)) //_LBB80_37
{
 f0 = heapFloat[(r1+2)];
 f1 = heapFloat[(r2+2)];
if(!(f0 >f1)) //_LBB80_37
{
 f0 = heapFloat[(r1+4)];
 f1 = heapFloat[(r2+4)];
if(!(f0 <f1)) //_LBB80_37
{
 f0 = heapFloat[(r1+5)];
 f1 = heapFloat[(r2+5)];
if(!(f0 <f1)) //_LBB80_37
{
 f0 = heapFloat[(r1+6)];
 f1 = heapFloat[(r2+6)];
 if(f0 >=f1) //_LBB80_39
{
break _31;
}
}
}
}
}
}
 r2 = heap32[(r1+10)];
 r3 = heap32[(r1+9)];
 r2 = r2 >> 2;
 r3 = r3 >> 2;
 f0 = heapFloat[(r3)];
 f1 = heapFloat[(r2)];
 f0 = f0 < f1 ? f0 : f1;
 heapFloat[(r1)] = f0;
 f1 = heapFloat[(r3+4)];
 f2 = heapFloat[(r2+4)];
 f1 = f1 > f2 ? f1 : f2;
 heapFloat[(r1+4)] = f1;
 f1 = heapFloat[(r3+1)];
 f2 = heapFloat[(r2+1)];
 f1 = f1 < f2 ? f1 : f2;
 heapFloat[(r1+1)] = f1;
 f1 = heapFloat[(r3+5)];
 f2 = heapFloat[(r2+5)];
 f1 = f1 > f2 ? f1 : f2;
 heapFloat[(r1+5)] = f1;
 f1 = heapFloat[(r3+2)];
 f2 = heapFloat[(r2+2)];
 f1 = f1 < f2 ? f1 : f2;
 heapFloat[(r1+2)] = f1;
 f1 = heapFloat[(r3+6)];
 f2 = heapFloat[(r2+6)];
 f1 = f1 > f2 ? f1 : f2;
 heapFloat[(r1+6)] = f1;
 r5 = heap32[(r1+8)];
 r4 = r0;
 if(r5 ==0) //_LBB80_39
{
break _31;
}
}
}
} while(0);
 return;
}
else{
 r2 = r1 >> 2;
 heap32[(r0)] = r1;
 heap32[(r2+8)] = 0;
 return;
}
}

function _ZL10removeleafP6btDbvtP10btDbvtNode(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
 var r1;
 var r2;
 var r3;
 var r4;
 var r5;
 var f0;
 var f1;
 var f2;
 var f3;
 var f4;
 var f5;
 var f6;
 var f7;
 var f8;
 var f9;
 var f10;
 var f11;
 var f12;
var __label__ = 0;
 i7 = sp + -8;var g0 = i7>>2; // save stack
 r0 = heap32[(fp)];
 r1 = heap32[(fp+1)];
 r0 = r0 >> 2;
 r2 = heap32[(r0)];
 if(r2 !=r1) //_LBB81_2
{
 r2 = r1 >> 2;
 r2 = heap32[(r2+8)];
 r3 = r2 >> 2;
 r4 = heap32[(r3+10)];
 r1 = r4 != r1;
 r1 = r1 & 1;
 r1 = r1 << 2;
 r1 = (r2 + r1)|0;
 r1 = r1 >> 2;
 r3 = heap32[(r3+8)];
 r1 = heap32[(r1+9)];
_3: do {
 if(r3 ==0) //_LBB81_11
{
 r3 = r1 >> 2;
 heap32[(r0)] = r1;
 heap32[(r3+8)] = 0;
 r3 = heap32[(r0+1)];
if(!(r3 ==0)) //_LBB81_13
{
 r1 = gNumAlignedFree;
 r1 = r1 >> 2;
 r4 = heap32[(r1)];
 r4 = (r4 + 1)|0;
 r3 = r3 >> 2;
 heap32[(r1)] = r4;
 r3 = heap32[(r3+-1)];
 heap32[(g0)] = r3;
 free(i7);
}
 heap32[(r0+1)] = r2;
 r3 = heap32[(r0)];
}
else{
 r4 = r3 >> 2;
 r4 = heap32[(r4+10)];
 r4 = r4 == r2;
 r4 = r4 & 1;
 r4 = r4 << 2;
 r4 = (r3 + r4)|0;
 r4 = r4 >> 2;
 r5 = r1 >> 2;
 heap32[(r4+9)] = r1;
 heap32[(r5+8)] = r3;
 r1 = heap32[(r0+1)];
if(!(r1 ==0)) //_LBB81_5
{
 r4 = gNumAlignedFree;
 r4 = r4 >> 2;
 r5 = heap32[(r4)];
 r5 = (r5 + 1)|0;
 r1 = r1 >> 2;
 heap32[(r4)] = r5;
 r1 = heap32[(r1+-1)];
 heap32[(g0)] = r1;
 free(i7);
}
 heap32[(r0+1)] = r2;
_12: while(true){
 if(r3 !=0) //_LBB81_6
{
 r1 = r3 >> 2;
 r2 = heap32[(r1+10)];
 r4 = heap32[(r1+9)];
 r2 = r2 >> 2;
 r4 = r4 >> 2;
 f0 = heapFloat[(r1+6)];
 f1 = heapFloat[(r1)];
 f2 = heapFloat[(r1+1)];
 f3 = heapFloat[(r1+2)];
 f4 = heapFloat[(r1+4)];
 f5 = heapFloat[(r1+5)];
 f6 = heapFloat[(r4)];
 f7 = heapFloat[(r2)];
 f6 = f6 < f7 ? f6 : f7;
 heapFloat[(r1)] = f6;
 f7 = heapFloat[(r4+4)];
 f8 = heapFloat[(r2+4)];
 f7 = f7 > f8 ? f7 : f8;
 heapFloat[(r1+4)] = f7;
 f8 = heapFloat[(r4+1)];
 f9 = heapFloat[(r2+1)];
 f8 = f8 < f9 ? f8 : f9;
 heapFloat[(r1+1)] = f8;
 f9 = heapFloat[(r4+5)];
 f10 = heapFloat[(r2+5)];
 f9 = f9 > f10 ? f9 : f10;
 heapFloat[(r1+5)] = f9;
 f10 = heapFloat[(r4+2)];
 f11 = heapFloat[(r2+2)];
 f10 = f10 < f11 ? f10 : f11;
 heapFloat[(r1+2)] = f10;
 f11 = heapFloat[(r4+6)];
 f12 = heapFloat[(r2+6)];
 f11 = f11 > f12 ? f11 : f12;
 heapFloat[(r1+6)] = f11;
if(!(f0 !=f11)) //_LBB81_8
{
 r2 = f1 == f6;
 r4 = f2 == f8;
 r2 = r2 & r4;
 r4 = f3 == f10;
 r2 = r2 & r4;
 r4 = f4 == f7;
 r2 = r2 & r4;
 r4 = f5 == f9;
 r2 = r2 & r4;
 if(r2 != 0) //_LBB81_14
{
break _3;
}
}
 r3 = heap32[(r1+8)];
}
else{
break _12;
}
}
 r0 = heap32[(r0)];
 r_g0 = r0;
 return;
}
} while(0);
 r_g0 = r3;
 return;
}
else{
 heap32[(r0)] = 0;
 r0 = 0;
 r_g0 = r0;
 return;
}
}

function _ZN6btDbvt6updateEP10btDbvtNodeR12btDbvtAabbMmRK9btVector3f(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
 var r1;
 var r2;
 var r3;
 var r4;
 var r5;
 var r6;
 var r7;
 var f0;
 var f1;
 var f2;
 var f3;
 var f4;
 var f5;
 var f6;
 var f7;
var __label__ = 0;
 i7 = sp + -16;var g0 = i7>>2; // save stack
 r0 = heap32[(fp+2)];
 r0 = r0 >> 2;
 r1 = heap32[(fp+1)];
 f0 = heapFloat[(r0)];
 r2 = heap32[(fp)];
 r3 = heap32[(fp+3)];
 f1 = heapFloat[(fp+4)];
 r4 = r1 >> 2;
 f2 = heapFloat[(r4)];
 if(f2 <=f0) //_LBB82_2
{
 f2 = heapFloat[(r0+1)];
 f3 = heapFloat[(r4+1)];
 if(f3 <=f2) //_LBB82_4
{
 f3 = heapFloat[(r4+2)];
 f4 = heapFloat[(r0+2)];
if(!(f3 >f4)) //_LBB82_3
{
 f3 = heapFloat[(r4+4)];
 f4 = heapFloat[(r0+4)];
if(!(f3 <f4)) //_LBB82_3
{
 f3 = heapFloat[(r4+5)];
 f4 = heapFloat[(r0+5)];
if(!(f3 <f4)) //_LBB82_3
{
 f3 = heapFloat[(r4+6)];
 f4 = heapFloat[(r0+6)];
if(!(f3 <f4)) //_LBB82_3
{
 r0 = 0;
 r_g0 = r0;
 return;
}
}
}
}
}
}
else{
 f2 = heapFloat[(r0+1)];
}
 f0 = f0-f1;
 f2 = f2-f1;
 heapFloat[(r0)] = f0;
 heapFloat[(r0+1)] = f2;
 f3 = heapFloat[(r0+2)];
 f3 = f3-f1;
 heapFloat[(r0+2)] = f3;
 f4 = heapFloat[(r0+4)];
 f4 = f4+f1;
 heapFloat[(r0+4)] = f4;
 f5 = heapFloat[(r0+5)];
 f5 = f5+f1;
 heapFloat[(r0+5)] = f5;
 f6 = heapFloat[(r0+6)];
 f1 = f6+f1;
 r3 = r3 >> 2;
 heapFloat[(r0+6)] = f1;
 f6 = heapFloat[(r3)];
 f7 =                         0;
 if(f6 <=f7) //_LBB82_10
{
 f0 = f0+f6;
 heapFloat[(r0)] = f0;
}
else{
 f0 = f4+f6;
 heapFloat[(r0+4)] = f0;
}
 f0 = heapFloat[(r3+1)];
 if(f0 <=f7) //_LBB82_13
{
 f0 = f2+f0;
 heapFloat[(r0+1)] = f0;
}
else{
 f0 = f5+f0;
 heapFloat[(r0+5)] = f0;
}
 f0 = heapFloat[(r3+2)];
 if(f0 <=f7) //_LBB82_16
{
 f0 = f3+f0;
 heapFloat[(r0+2)] = f0;
}
else{
 f0 = f1+f0;
 heapFloat[(r0+6)] = f0;
}
 heap32[(g0)] = r2;
 heap32[(g0+1)] = r1;
 _ZL10removeleafP6btDbvtP10btDbvtNode(i7);
 r3 = r_g0;
_22: do {
 if(r3 !=0) //_LBB82_19
{
 r5 = r2 >> 2;
 r6 = heap32[(r5+2)];
 if(r6 <0) //_LBB82_24
{
 r5 = heap32[(r5)];
}
else{
 r7 = -1;
_27: while(true){
 r5 = r3;
 r7 = (r7 + 1)|0;
 if(r6 >r7) //_LBB82_23
{
 r3 = r5 >> 2;
 r3 = heap32[(r3+8)];
 if(r3 ==0) //_LBB82_22
{
break _22;
}
else{
continue _27;
}
}
else{
break _22;
}
}
}
}
else{
 r5 = 0;
}
} while(0);
 heap32[(r4)] = heap32[(r0)];
 heap32[(r4+1)] = heap32[(r0+1)];
 heap32[(r4+2)] = heap32[(r0+2)];
 heap32[(r4+3)] = heap32[(r0+3)];
 heap32[(r4+4)] = heap32[(r0+4)];
 heap32[(r4+5)] = heap32[(r0+5)];
 heap32[(r4+6)] = heap32[(r0+6)];
 heap32[(r4+7)] = heap32[(r0+7)];
 heap32[(g0)] = r2;
 heap32[(g0+1)] = r5;
 heap32[(g0+2)] = r1;
 _ZL10insertleafP6btDbvtP10btDbvtNodeS2_(i7);
 r0 = 1;
 r_g0 = r0;
 return;
}

function _ZL17recursedeletenodeP6btDbvtP10btDbvtNode(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
 var r1;
 var r2;
 var r3;
 var r4;
var __label__ = 0;
 i7 = sp + -8;var g0 = i7>>2; // save stack
 r0 = heap32[(fp+1)];
 r1 = heap32[(fp)];
 r2 = r0 >> 2;
 r3 = heap32[(r2+10)];
if(!(r3 ==0)) //_LBB83_2
{
 r3 = heap32[(r2+9)];
 heap32[(g0)] = r1;
 heap32[(g0+1)] = r3;
 _ZL17recursedeletenodeP6btDbvtP10btDbvtNode(i7);
 r2 = heap32[(r2+10)];
 heap32[(g0)] = r1;
 heap32[(g0+1)] = r2;
 _ZL17recursedeletenodeP6btDbvtP10btDbvtNode(i7);
}
 r1 = r1 >> 2;
 r2 = heap32[(r1)];
if(!(r2 !=r0)) //_LBB83_4
{
 heap32[(r1)] = 0;
}
 r2 = heap32[(r1+1)];
if(!(r2 ==0)) //_LBB83_6
{
 r3 = gNumAlignedFree;
 r3 = r3 >> 2;
 r4 = heap32[(r3)];
 r4 = (r4 + 1)|0;
 r2 = r2 >> 2;
 heap32[(r3)] = r4;
 r2 = heap32[(r2+-1)];
 heap32[(g0)] = r2;
 free(i7);
}
 heap32[(r1+1)] = r0;
 return;
}

function _ZN6btDbvt19optimizeIncrementalEi(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
 var r1;
 var r2;
 var r3;
 var r4;
 var r5;
 var r6;
 var r7;
 var r8;
 var r9;
 var r10;
 var r11;
 var r12;
 var f0;
 var f1;
 var f2;
 var f3;
 var f4;
 var f5;
 var f6;
 var f7;
var __label__ = 0;
 i7 = sp + -16;var g0 = i7>>2; // save stack
 r0 = heap32[(fp+1)];
 r1 = heap32[(fp)];
 if(r0 <0) //_LBB84_2
{
 r0 = r1 >> 2;
 r0 = heap32[(r0+3)];
}
 r2 = r1 >> 2;
 r3 = heap32[(r2)];
_4: do {
if(!(r3 ==0)) //_LBB84_20
{
if(!(r0 <1)) //_LBB84_20
{
_6: while(true){
 r3 = 0;
 r4 = r1;
_8: while(true){
 r4 = r4 >> 2;
 r4 = heap32[(r4)];
 r5 = r4 >> 2;
 r6 = heap32[(r5+10)];
 if(r6 !=0) //_LBB84_6
{
 r6 = heap32[(r5+8)];
 if(uint(r6) >uint(r4)) //_LBB84_8
{
 r7 = r6 >> 2;
 r8 = heap32[(r7+10)];
 r8 = r8 == r4;
 r8 = r8 & 1;
 r9 = (r6 + 36)|0;
 r10 = r8 << 2;
 r11 = (r9 + r10)|0;
 r11 = r11 >> 2;
 r11 = heap32[(r11)];
 if(r11 ==r4) //_LBB84_10
{
 r8 = r8 ^ 1;
 r8 = r8 << 2;
 r9 = (r9 + r8)|0;
 r9 = r9 >> 2;
 r9 = heap32[(r9)];
 r11 = heap32[(r7+8)];
 if(r11 ==0) //_LBB84_12
{
 heap32[(r2)] = r4;
}
else{
 r12 = r11 >> 2;
 r12 = heap32[(r12+10)];
 r12 = r12 == r6;
 r12 = r12 & 1;
 r12 = r12 << 2;
 r12 = (r11 + r12)|0;
 r12 = r12 >> 2;
 heap32[(r12+9)] = r4;
}
 r12 = r9 >> 2;
 heap32[(r12+8)] = r4;
 heap32[(r7+8)] = r4;
 heap32[(r5+8)] = r11;
 r11 = heap32[(r5+9)];
 heap32[(r7+9)] = r11;
 r11 = heap32[(r5+10)];
 heap32[(r7+10)] = r11;
 r11 = heap32[(r5+9)];
 r11 = r11 >> 2;
 heap32[(r11+8)] = r6;
 r11 = heap32[(r5+10)];
 r4 = (r4 + 36)|0;
 r10 = (r4 + r10)|0;
 r11 = r11 >> 2;
 r4 = (r4 + r8)|0;
 r8 = r10 >> 2;
 heap32[(r11+8)] = r6;
 r4 = r4 >> 2;
 heap32[(r8)] = r6;
 heap32[(r4)] = r9;
 f0 = heapFloat[(r7+7)];
 f1 = heapFloat[(r7+6)];
 f2 = heapFloat[(r7+5)];
 f3 = heapFloat[(r7+4)];
 f4 = heapFloat[(r7+3)];
 f5 = heapFloat[(r7+2)];
 f6 = heapFloat[(r7+1)];
 f7 = heapFloat[(r7)];
 heap32[(r7)] = heap32[(r5)];
 heap32[(r7+1)] = heap32[(r5+1)];
 heap32[(r7+2)] = heap32[(r5+2)];
 heap32[(r7+3)] = heap32[(r5+3)];
 heap32[(r7+4)] = heap32[(r5+4)];
 heap32[(r7+5)] = heap32[(r5+5)];
 heap32[(r7+6)] = heap32[(r5+6)];
 heap32[(r7+7)] = heap32[(r5+7)];
 heapFloat[(r5)] = f7;
 heapFloat[(r5+1)] = f6;
 heapFloat[(r5+2)] = f5;
 heapFloat[(r5+3)] = f4;
 heapFloat[(r5+4)] = f3;
 heapFloat[(r5+5)] = f2;
 heapFloat[(r5+6)] = f1;
 heapFloat[(r5+7)] = f0;
}
else{
break _6;
}
}
else{
 r6 = r4;
}
 r4 = heap32[(r2+4)];
 r4 = r4 >>> r3;
 r4 = r4 & 1;
 r4 = r4 << 2;
 r4 = (r6 + r4)|0;
 r3 = (r3 + 1)|0;
 r4 = (r4 + 36)|0;
 r3 = r3 & 31;
}
else{
break _8;
}
}
 heap32[(g0)] = r1;
 heap32[(g0+1)] = r4;
 _ZL10removeleafP6btDbvtP10btDbvtNode(i7);
 r3 = r_g0;
 if(r3 !=0) //_LBB84_18
{
 r3 = heap32[(r2)];
}
else{
 r3 = 0;
}
 heap32[(g0)] = r1;
 heap32[(g0+1)] = r3;
 heap32[(g0+2)] = r4;
 _ZL10insertleafP6btDbvtP10btDbvtNodeS2_(i7);
 r3 = heap32[(r2+4)];
 r0 = (r0 + -1)|0;
 r3 = (r3 + 1)|0;
 heap32[(r2+4)] = r3;
if(!(r0 !=0)) //_LBB84_5
{
break _4;
}
}
 r4 = _2E_str22;
 r0 = _2E_str1118;
 heap32[(g0)] = r4;
 heap32[(g0+1)] = r0;
 heap32[(g0+2)] = 379;
 _assert(i7);
}
}
} while(0);
 return;
}

function _ZN18btDbvtTreeColliderD1Ev(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
 var r1;
var __label__ = 0;
 i7 = sp + 0;var g0 = i7>>2; // save stack
 r0 = heap32[(fp)];
 r1 = _ZTV18btDbvtTreeCollider;
 r0 = r0 >> 2;
 r1 = (r1 + 8)|0;
 heap32[(r0)] = r1;
 return;
}

function _ZN18btDbvtTreeColliderD0Ev(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
 var r1;
 var r2;
var __label__ = 0;
 i7 = sp + -8;var g0 = i7>>2; // save stack
 r0 = heap32[(fp)];
 r1 = _ZTV18btDbvtTreeCollider;
 r2 = r0 >> 2;
 r1 = (r1 + 8)|0;
 heap32[(r2)] = r1;
 heap32[(g0)] = r0;
 _ZdlPv(i7);
 return;
}

function _ZN18btDbvtTreeCollider7ProcessEPK10btDbvtNodeS2_(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
 var r1;
 var r2;
 var r3;
 var r4;
var __label__ = 0;
 i7 = sp + -16;var g0 = i7>>2; // save stack
 r0 = heap32[(fp+1)];
 r1 = heap32[(fp+2)];
if(!(r0 ==r1)) //_LBB87_2
{
 r2 = heap32[(fp)];
 r2 = r2 >> 2;
 r3 = heap32[(r2+1)];
 r3 = r3 >> 2;
 r3 = heap32[(r3+24)];
 r4 = r3 >> 2;
 r4 = heap32[(r4)];
 r4 = r4 >> 2;
 r1 = r1 >> 2;
 r0 = r0 >> 2;
 r4 = heap32[(r4+2)];
 r1 = heap32[(r1+9)];
 r0 = heap32[(r0+9)];
 heap32[(g0)] = r3;
 heap32[(g0+1)] = r0;
 heap32[(g0+2)] = r1;
 __FUNCTION_TABLE__[(r4)>>2](i7);
 r0 = heap32[(r2+1)];
 r0 = r0 >> 2;
 r1 = heap32[(r0+30)];
 r1 = (r1 + 1)|0;
 heap32[(r0+30)] = r1;
}
 return;
}

function _ZN18btDbvtTreeCollider7ProcessEPK10btDbvtNode(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
 var r1;
 var r2;
 var r3;
var __label__ = 0;
 i7 = sp + -16;var g0 = i7>>2; // save stack
 r0 = heap32[(fp)];
 r1 = r0 >> 2;
 r2 = heap32[(r1)];
 r1 = heap32[(r1+2)];
 r2 = r2 >> 2;
 r1 = r1 >> 2;
 r2 = heap32[(r2+2)];
 r1 = heap32[(r1+12)];
 r3 = heap32[(fp+1)];
 heap32[(g0)] = r0;
 heap32[(g0+1)] = r3;
 heap32[(g0+2)] = r1;
 __FUNCTION_TABLE__[(r2)>>2](i7);
 return;
}

function _ZNK16btDbvtBroadphase7getAabbEP17btBroadphaseProxyR9btVector3S3_(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
 var r1;
 var r2;
var __label__ = 0;
 i7 = sp + 0;var g0 = i7>>2; // save stack
 r0 = heap32[(fp+1)];
 r1 = heap32[(fp+2)];
 r0 = r0 >> 2;
 r1 = r1 >> 2;
 heap32[(r1)] = heap32[(r0+4)];
 heap32[(r1+1)] = heap32[(r0+5)];
 r2 = heap32[(fp+3)];
 heap32[(r1+2)] = heap32[(r0+6)];
 r2 = r2 >> 2;
 heap32[(r1+3)] = heap32[(r0+7)];
 heap32[(r2)] = heap32[(r0+8)];
 heap32[(r2+1)] = heap32[(r0+9)];
 heap32[(r2+2)] = heap32[(r0+10)];
 heap32[(r2+3)] = heap32[(r0+11)];
 return;
}

function _ZN19BroadphaseRayTesterD1Ev(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
 var r1;
var __label__ = 0;
 i7 = sp + 0;var g0 = i7>>2; // save stack
 r0 = heap32[(fp)];
 r1 = _ZTV19BroadphaseRayTester;
 r0 = r0 >> 2;
 r1 = (r1 + 8)|0;
 heap32[(r0)] = r1;
 return;
}

function _ZN19BroadphaseRayTesterD0Ev(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
 var r1;
 var r2;
var __label__ = 0;
 i7 = sp + -8;var g0 = i7>>2; // save stack
 r0 = heap32[(fp)];
 r1 = _ZTV19BroadphaseRayTester;
 r2 = r0 >> 2;
 r1 = (r1 + 8)|0;
 heap32[(r2)] = r1;
 heap32[(g0)] = r0;
 _ZdlPv(i7);
 return;
}

function _ZN19BroadphaseRayTester7ProcessEPK10btDbvtNode(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
 var r1;
 var r2;
var __label__ = 0;
 i7 = sp + -8;var g0 = i7>>2; // save stack
 r0 = heap32[(fp)];
 r0 = r0 >> 2;
 r0 = heap32[(r0+1)];
 r1 = r0 >> 2;
 r2 = heap32[(fp+1)];
 r1 = heap32[(r1)];
 r1 = r1 >> 2;
 r2 = r2 >> 2;
 r1 = heap32[(r1+2)];
 r2 = heap32[(r2+9)];
 heap32[(g0)] = r0;
 heap32[(g0+1)] = r2;
 __FUNCTION_TABLE__[(r1)>>2](i7);
 return;
}

function _ZN20BroadphaseAabbTesterD1Ev(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
 var r1;
var __label__ = 0;
 i7 = sp + 0;var g0 = i7>>2; // save stack
 r0 = heap32[(fp)];
 r1 = _ZTV20BroadphaseAabbTester;
 r0 = r0 >> 2;
 r1 = (r1 + 8)|0;
 heap32[(r0)] = r1;
 return;
}

function _ZN20BroadphaseAabbTesterD0Ev(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
 var r1;
 var r2;
var __label__ = 0;
 i7 = sp + -8;var g0 = i7>>2; // save stack
 r0 = heap32[(fp)];
 r1 = _ZTV20BroadphaseAabbTester;
 r2 = r0 >> 2;
 r1 = (r1 + 8)|0;
 heap32[(r2)] = r1;
 heap32[(g0)] = r0;
 _ZdlPv(i7);
 return;
}

function _ZN20BroadphaseAabbTester7ProcessEPK10btDbvtNode(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
 var r1;
 var r2;
var __label__ = 0;
 i7 = sp + -8;var g0 = i7>>2; // save stack
 r0 = heap32[(fp)];
 r0 = r0 >> 2;
 r0 = heap32[(r0+1)];
 r1 = r0 >> 2;
 r2 = heap32[(fp+1)];
 r1 = heap32[(r1)];
 r1 = r1 >> 2;
 r2 = r2 >> 2;
 r1 = heap32[(r1+2)];
 r2 = heap32[(r2+9)];
 heap32[(g0)] = r0;
 heap32[(g0+1)] = r2;
 __FUNCTION_TABLE__[(r1)>>2](i7);
 return;
}

function _ZN16btDbvtBroadphase23getOverlappingPairCacheEv(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
var __label__ = 0;
 i7 = sp + 0;var g0 = i7>>2; // save stack
 r0 = heap32[(fp)];
 r0 = r0 >> 2;
 r0 = heap32[(r0+24)];
 r_g0 = r0;
 return;
}

function _ZNK16btDbvtBroadphase23getOverlappingPairCacheEv(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
var __label__ = 0;
 i7 = sp + 0;var g0 = i7>>2; // save stack
 r0 = heap32[(fp)];
 r0 = r0 >> 2;
 r0 = heap32[(r0+24)];
 r_g0 = r0;
 return;
}

function _ZNK16btDbvtBroadphase17getBroadphaseAabbER9btVector3S1_(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
 var r1;
 var r2;
 var r3;
 var f0;
 var f1;
 var f2;
 var f3;
 var f4;
 var f5;
 var f6;
 var f7;
 var f8;
 var f9;
 var f10;
 var f11;
var __label__ = 0;
 i7 = sp + 0;var g0 = i7>>2; // save stack
 r0 = heap32[(fp)];
 r0 = r0 >> 2;
 r1 = heap32[(r0+1)];
 r2 = heap32[(fp+1)];
 r3 = heap32[(fp+2)];
 r0 = heap32[(r0+11)];
 if(r1 ==0) //_LBB98_4
{
 if(r0 !=0) //_LBB98_6
{
 r0 = r0 >> 2;
 f0 = heapFloat[(r0)];
 f2 = heapFloat[(r0+1)];
 f4 = heapFloat[(r0+2)];
 f6 = heapFloat[(r0+3)];
 f1 = heapFloat[(r0+4)];
 f3 = heapFloat[(r0+5)];
 f5 = heapFloat[(r0+6)];
 f7 = heapFloat[(r0+7)];
}
else{
 f6 =                         0;
 f4 = f6;
 f2 = f6;
 f0 = f6;
 f1 = f6;
 f3 = f6;
 f5 = f6;
 f7 = f6;
}
}
else{
 if(r0 ==0) //_LBB98_3
{
 r0 = r1 >> 2;
 f0 = heapFloat[(r0)];
 f2 = heapFloat[(r0+1)];
 f4 = heapFloat[(r0+2)];
 f6 = heapFloat[(r0+3)];
 f1 = heapFloat[(r0+4)];
 f3 = heapFloat[(r0+5)];
 f5 = heapFloat[(r0+6)];
 f7 = heapFloat[(r0+7)];
}
else{
 r1 = r1 >> 2;
 r0 = r0 >> 2;
 f0 = heapFloat[(r1)];
 f1 = heapFloat[(r0)];
 f2 = heapFloat[(r1+4)];
 f3 = heapFloat[(r0+4)];
 f4 = heapFloat[(r1+1)];
 f5 = heapFloat[(r0+1)];
 f6 = heapFloat[(r1+5)];
 f7 = heapFloat[(r0+5)];
 f8 = heapFloat[(r1+2)];
 f9 = heapFloat[(r0+2)];
 f10 = heapFloat[(r1+6)];
 f11 = heapFloat[(r0+6)];
 f0 = f0 < f1 ? f0 : f1;
 f1 = f2 > f3 ? f2 : f3;
 f2 = f4 < f5 ? f4 : f5;
 f3 = f6 > f7 ? f6 : f7;
 f4 = f8 < f9 ? f8 : f9;
 f5 = f10 > f11 ? f10 : f11;
}
}
 r0 = r2 >> 2;
 heapFloat[(r0)] = f0;
 heapFloat[(r0+1)] = f2;
 heapFloat[(r0+2)] = f4;
 r1 = r3 >> 2;
 heapFloat[(r0+3)] = f6;
 heapFloat[(r1)] = f1;
 heapFloat[(r1+1)] = f3;
 heapFloat[(r1+2)] = f5;
 heapFloat[(r1+3)] = f7;
 return;
}

function _ZN16btDbvtBroadphase10printStatsEv(sp)
{
 var i7;
 var fp = sp>>2;
var __label__ = 0;
 i7 = sp + 0;var g0 = i7>>2; // save stack
 return;
}

function _ZN16btDbvtBroadphase9resetPoolEP12btDispatcher(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
 var r1;
 var r2;
 var r3;
 var r4;
 var r5;
 var r6;
var __label__ = 0;
 i7 = sp + -8;var g0 = i7>>2; // save stack
 r0 = heap32[(fp)];
 r1 = r0 >> 2;
 r2 = 0;
 r3 = heap32[(r1+14)];
 r4 = heap32[(r1+4)];
 r3 = (r2 - r3)|0;
if(!(r4 !=r3)) //_LBB100_18
{
 r3 = heap32[(r1+1)];
if(!(r3 ==0)) //_LBB100_3
{
 r4 = (r0 + 4)|0;
 heap32[(g0)] = r4;
 heap32[(g0+1)] = r3;
 _ZL17recursedeletenodeP6btDbvtP10btDbvtNode(i7);
}
 r3 = heap32[(r1+2)];
if(!(r3 ==0)) //_LBB100_5
{
 r4 = gNumAlignedFree;
 r4 = r4 >> 2;
 r5 = heap32[(r4)];
 r5 = (r5 + 1)|0;
 r3 = r3 >> 2;
 heap32[(r4)] = r5;
 r3 = heap32[(r3+-1)];
 heap32[(g0)] = r3;
 free(i7);
}
 heap32[(r1+2)] = 0;
 heap32[(r1+3)] = -1;
 r3 = heap32[(r1+9)];
if(!(r3 ==0)) //_LBB100_9
{
 r4 = heapU8[r0+40];
if(!(r4 ==0)) //_LBB100_8
{
 r4 = gNumAlignedFree;
 r4 = r4 >> 2;
 r5 = heap32[(r4)];
 r5 = (r5 + 1)|0;
 r3 = r3 >> 2;
 heap32[(r4)] = r5;
 r3 = heap32[(r3+-1)];
 heap32[(g0)] = r3;
 free(i7);
}
 heap32[(r1+9)] = 0;
}
 r3 = 1;
 heap8[r0+40] = r3;
 heap32[(r1+9)] = 0;
 heap32[(r1+7)] = 0;
 heap32[(r1+8)] = 0;
 heap32[(r1+5)] = 0;
 r4 = heap32[(r1+11)];
if(!(r4 ==0)) //_LBB100_11
{
 r5 = (r0 + 44)|0;
 heap32[(g0)] = r5;
 heap32[(g0+1)] = r4;
 _ZL17recursedeletenodeP6btDbvtP10btDbvtNode(i7);
}
 r4 = heap32[(r1+12)];
if(!(r4 ==0)) //_LBB100_13
{
 r5 = gNumAlignedFree;
 r5 = r5 >> 2;
 r6 = heap32[(r5)];
 r6 = (r6 + 1)|0;
 r4 = r4 >> 2;
 heap32[(r5)] = r6;
 r4 = heap32[(r4+-1)];
 heap32[(g0)] = r4;
 free(i7);
}
 heap32[(r1+12)] = 0;
 heap32[(r1+13)] = -1;
 r4 = heap32[(r1+19)];
if(!(r4 ==0)) //_LBB100_17
{
 r5 = heapU8[r0+80];
if(!(r5 ==0)) //_LBB100_16
{
 r5 = gNumAlignedFree;
 r5 = r5 >> 2;
 r6 = heap32[(r5)];
 r6 = (r6 + 1)|0;
 r4 = r4 >> 2;
 heap32[(r5)] = r6;
 r4 = heap32[(r4+-1)];
 heap32[(g0)] = r4;
 free(i7);
}
 heap32[(r1+19)] = 0;
}
 heap8[r0+80] = r3;
 heap32[(r1+19)] = 0;
 heap32[(r1+17)] = 0;
 heap32[(r1+18)] = 0;
 heap32[(r1+15)] = 0;
 heap8[r0+153] = r2;
 heap8[r0+154] = r3;
 heap32[(r1+26)] = 0;
 heap32[(r1+31)] = 0;
 heap32[(r1+27)] = 1;
 heap32[(r1+28)] = 0;
 heap32[(r1+29)] = 10;
 heap32[(r1+30)] = 1;
 heap32[(r1+32)] = 0;
 heap32[(r1+33)] = 0;
 heap32[(r1+34)] = 0;
 heap32[(r1+37)] = 0;
 heap32[(r1+35)] = 0;
 heap32[(r1+36)] = 0;
 heap32[(r1+21)] = 0;
 heap32[(r1+22)] = 0;
 heap32[(r1+23)] = 0;
}
 return;
}

function _ZN6btDbvt24collideTTpersistentStackEPK10btDbvtNodeS2_RNS_8ICollideE(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
 var r1;
 var r2;
 var r3;
 var r4;
 var r5;
 var r6;
 var r7;
 var r8;
 var r9;
 var r10;
 var r11;
 var r12;
 var r13;
 var r14;
 var r15;
 var r16;
 var f0;
 var f1;
var __label__ = 0;
 i7 = sp + -16;var g0 = i7>>2; // save stack
 r0 = heap32[(fp+1)];
_1: do {
if(!(r0 ==0)) //_LBB101_57
{
 r1 = heap32[(fp+2)];
if(!(r1 ==0)) //_LBB101_57
{
 r2 = heap32[(fp)];
 r3 = r2 >> 2;
 r4 = heap32[(r3+6)];
if(!(r4 >127)) //_LBB101_17
{
 r5 = heap32[(r3+7)];
if(!(r5 >127)) //_LBB101_17
{
 r5 = gNumAlignedAllocs;
 r5 = r5 >> 2;
 r6 = heap32[(r5)];
 r6 = (r6 + 1)|0;
 heap32[(r5)] = r6;
 heap32[(g0)] = 1043;
 malloc(i7);
 r5 = r_g0;
 if(r5 !=0) //_LBB101_6
{
 r6 = 0;
 r7 = (r5 + 4)|0;
 r6 = (r6 - r7)|0;
 r6 = r6 & 15;
 r6 = (r5 + r6)|0;
 r7 = (r6 + 4)|0;
 r6 = r6 >> 2;
 heap32[(r6)] = r5;
 r5 = r7;
}
 r6 = (r2 + 32)|0;
 if(r4 <1) //_LBB101_9
{
 r4 = r6 >> 2;
 r8 = heap32[(r4)];
}
else{
 r7 = 0;
_13: while(true){
 r8 = r6 >> 2;
 r8 = heap32[(r8)];
 r9 = r7 << 3;
 r10 = (r8 + r9)|0;
 r10 = r10 >> 2;
 r9 = (r5 + r9)|0;
 r11 = heap32[(r10+1)];
 r10 = heap32[(r10)];
 r9 = r9 >> 2;
 r7 = (r7 + 1)|0;
 heap32[(r9)] = r10;
 heap32[(r9+1)] = r11;
if(!(r4 !=r7)) //_LBB101_10
{
break _13;
}
}
 r6 = (r2 + 32)|0;
}
if(!(r8 ==0)) //_LBB101_16
{
 r4 = heapU8[r2+36];
if(!(r4 ==0)) //_LBB101_15
{
 r4 = gNumAlignedFree;
 r4 = r4 >> 2;
 r7 = heap32[(r4)];
 r7 = (r7 + 1)|0;
 r8 = r8 >> 2;
 heap32[(r4)] = r7;
 r4 = heap32[(r8+-1)];
 heap32[(g0)] = r4;
 free(i7);
}
 r4 = r6 >> 2;
 heap32[(r4)] = 0;
}
 r4 = 1;
 r6 = r6 >> 2;
 heap8[r2+36] = r4;
 heap32[(r6)] = r5;
 heap32[(r3+7)] = 128;
}
}
 r4 = heap32[(fp+3)];
 heap32[(r3+6)] = 128;
 r5 = heap32[(r3+8)];
 r5 = r5 >> 2;
 r6 = 1;
 r7 = 124;
 heap32[(r5)] = r0;
 heap32[(r5+1)] = r1;
_24: while(true){
 r0 = r6;
 r6 = (r0 + -1)|0;
 r1 = heap32[(r3+8)];
 r5 = r6 << 3;
 r5 = (r1 + r5)|0;
 r5 = r5 >> 2;
 r8 = heap32[(r5)];
 r5 = heap32[(r5+1)];
 if(r6 >r7) //_LBB101_20
{
 r7 = heap32[(r3+6)];
 r9 = r7 << 1;
_28: do {
if(!(r7 >r9)) //_LBB101_38
{
if(!(r7 >=r9)) //_LBB101_38
{
 r10 = heap32[(r3+7)];
 if(r10 <r9) //_LBB101_24
{
 if(r9 !=0) //_LBB101_26
{
 r10 = gNumAlignedAllocs;
 r10 = r10 >> 2;
 r11 = heap32[(r10)];
 r12 = r7 << 4;
 r11 = (r11 + 1)|0;
 r12 = r12 | 3;
 heap32[(r10)] = r11;
 r10 = (r12 + 16)|0;
 heap32[(g0)] = r10;
 malloc(i7);
 r10 = r_g0;
 if(r10 !=0) //_LBB101_28
{
 r11 = 0;
 r12 = (r10 + 4)|0;
 r11 = (r11 - r12)|0;
 r11 = r11 & 15;
 r11 = (r10 + r11)|0;
 r12 = (r11 + 4)|0;
 r11 = r11 >> 2;
 heap32[(r11)] = r10;
 r10 = r12;
}
}
else{
 r10 = 0;
}
if(!(r7 <1)) //_LBB101_32
{
 r11 = (r1 + 4)|0;
 r12 = (r10 + 4)|0;
 r13 = r7;
_40: while(true){
 r14 = r11 >> 2;
 r15 = heap32[(r14)];
 r14 = heap32[(r14+-1)];
 r16 = r12 >> 2;
 r13 = (r13 + -1)|0;
 r11 = (r11 + 8)|0;
 r12 = (r12 + 8)|0;
 heap32[(r16+-1)] = r14;
 heap32[(r16)] = r15;
if(!(r13 !=0)) //_LBB101_31
{
break _40;
}
}
}
if(!(r1 ==0)) //_LBB101_36
{
 r11 = heapU8[r2+36];
if(!(r11 ==0)) //_LBB101_35
{
 r11 = gNumAlignedFree;
 r11 = r11 >> 2;
 r12 = heap32[(r11)];
 r12 = (r12 + 1)|0;
 r1 = r1 >> 2;
 heap32[(r11)] = r12;
 r1 = heap32[(r1+-1)];
 heap32[(g0)] = r1;
 free(i7);
}
 heap32[(r3+8)] = 0;
}
 r1 = 1;
 heap8[r2+36] = r1;
 heap32[(r3+8)] = r10;
 heap32[(r3+7)] = r9;
if(!(r7 <r9)) //_LBB101_23
{
break _28;
}
}
_49: while(true){
 r7 = (r7 + -1)|0;
if(!(r7 !=0)) //_LBB101_37
{
break _28;
}
}
}
}
} while(0);
 r7 = (r9 + -4)|0;
 heap32[(r3+6)] = r9;
}
 if(r8 !=r5) //_LBB101_43
{
 r1 = r8 >> 2;
 r9 = r5 >> 2;
 f0 = heapFloat[(r1)];
 f1 = heapFloat[(r9+4)];
if(!(f0 >f1)) //_LBB101_41
{
 f0 = heapFloat[(r1+4)];
 f1 = heapFloat[(r9)];
if(!(f0 <f1)) //_LBB101_41
{
 f0 = heapFloat[(r1+1)];
 f1 = heapFloat[(r9+5)];
if(!(f0 >f1)) //_LBB101_41
{
 f0 = heapFloat[(r1+5)];
 f1 = heapFloat[(r9+1)];
if(!(f0 <f1)) //_LBB101_41
{
 f0 = heapFloat[(r1+2)];
 f1 = heapFloat[(r9+6)];
if(!(f0 >f1)) //_LBB101_41
{
 f0 = heapFloat[(r1+6)];
 f1 = heapFloat[(r9+2)];
if(!(f0 <f1)) //_LBB101_41
{
 r10 = heap32[(r9+10)];
 r11 = heap32[(r1+10)];
 if(r11 ==0) //_LBB101_53
{
 if(r10 ==0) //_LBB101_55
{
 r0 = r4 >> 2;
 r0 = heap32[(r0)];
 r0 = r0 >> 2;
 r0 = heap32[(r0+2)];
 heap32[(g0)] = r4;
 heap32[(g0+1)] = r8;
 heap32[(g0+2)] = r5;
 __FUNCTION_TABLE__[(r0)>>2](i7);
}
else{
 r5 = r0 << 3;
 r6 = heap32[(r3+8)];
 r6 = (r6 + r5)|0;
 r1 = heap32[(r9+9)];
 r6 = r6 >> 2;
 heap32[(r6+-2)] = r8;
 heap32[(r6+-1)] = r1;
 r6 = heap32[(r3+8)];
 r5 = (r6 + r5)|0;
 r1 = heap32[(r9+10)];
 r5 = r5 >> 2;
 r6 = (r0 + 1)|0;
 heap32[(r5)] = r8;
 heap32[(r5+1)] = r1;
}
}
else{
 r6 = heap32[(r3+8)];
 if(r10 ==0) //_LBB101_52
{
 r8 = r0 << 3;
 r6 = (r6 + r8)|0;
 r6 = r6 >> 2;
 r9 = heap32[(r1+9)];
 heap32[(r6+-2)] = r9;
 heap32[(r6+-1)] = r5;
 r6 = heap32[(r3+8)];
 r6 = (r6 + r8)|0;
 r8 = heap32[(r1+10)];
 r9 = r6 >> 2;
 r6 = (r0 + 1)|0;
 heap32[(r9)] = r8;
 heap32[(r9+1)] = r5;
}
else{
 r5 = r0 << 3;
 r6 = (r6 + r5)|0;
 r8 = heap32[(r9+9)];
 r10 = heap32[(r1+9)];
 r6 = r6 >> 2;
 heap32[(r6+-2)] = r10;
 heap32[(r6+-1)] = r8;
 r6 = heap32[(r3+8)];
 r6 = (r6 + r5)|0;
 r8 = heap32[(r9+9)];
 r10 = heap32[(r1+10)];
 r6 = r6 >> 2;
 heap32[(r6)] = r10;
 heap32[(r6+1)] = r8;
 r6 = heap32[(r3+8)];
 r6 = (r5 + r6)|0;
 r8 = heap32[(r9+10)];
 r10 = heap32[(r1+9)];
 r6 = r6 >> 2;
 heap32[(r6+2)] = r10;
 heap32[(r6+3)] = r8;
 r6 = heap32[(r3+8)];
 r6 = (r5 + r6)|0;
 r5 = heap32[(r9+10)];
 r1 = heap32[(r1+10)];
 r8 = r6 >> 2;
 r6 = (r0 + 3)|0;
 heap32[(r8+4)] = r1;
 heap32[(r8+5)] = r5;
}
}
}
}
}
}
}
}
}
else{
 r5 = r8 >> 2;
 r8 = heap32[(r5+10)];
 if(r8 !=0) //_LBB101_42
{
 r6 = r0 << 3;
 r8 = heap32[(r3+8)];
 r8 = (r8 + r6)|0;
 r1 = heap32[(r5+9)];
 r8 = r8 >> 2;
 heap32[(r8+-2)] = r1;
 heap32[(r8+-1)] = r1;
 r8 = heap32[(r3+8)];
 r8 = (r8 + r6)|0;
 r1 = heap32[(r5+10)];
 r8 = r8 >> 2;
 heap32[(r8)] = r1;
 heap32[(r8+1)] = r1;
 r8 = heap32[(r3+8)];
 r6 = (r6 + r8)|0;
 r8 = heap32[(r5+10)];
 r5 = heap32[(r5+9)];
 r1 = r6 >> 2;
 r6 = (r0 + 2)|0;
 heap32[(r1+2)] = r5;
 heap32[(r1+3)] = r8;
}
}
 if(r6 !=0) //_LBB101_18
{
continue _24;
}
else{
break _1;
}
}
}
}
} while(0);
 return;
}

function _ZN6btDbvt9collideTVEPK10btDbvtNodeRK12btDbvtAabbMmRNS_8ICollideE(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
 var r1;
 var r2;
 var r3;
 var r4;
 var r5;
 var r6;
 var r7;
 var r8;
 var r9;
 var r10;
 var r11;
 var r12;
 var f0;
 var f1;
 var f2;
 var f3;
 var f4;
 var f5;
 var f6;
var __label__ = 0;
 i7 = sp + -8;var g0 = i7>>2; // save stack
 r0 = heap32[(fp)];
if(!(r0 ==0)) //_LBB102_46
{
 r1 = heap32[(fp+1)];
 r2 = heap32[(fp+2)];
 r3 = gNumAlignedAllocs;
 r1 = r1 >> 2;
 r3 = r3 >> 2;
 r4 = heap32[(r3)];
 f0 = heapFloat[(r1)];
 f1 = heapFloat[(r1+1)];
 f2 = heapFloat[(r1+2)];
 f3 = heapFloat[(r1+4)];
 f4 = heapFloat[(r1+5)];
 f5 = heapFloat[(r1+6)];
 r1 = (r4 + 1)|0;
 heap32[(r3)] = r1;
 heap32[(g0)] = 275;
 malloc(i7);
 r1 = r_g0;
 if(r1 !=0) //_LBB102_3
{
 r4 = 0;
 r5 = (r1 + 4)|0;
 r4 = (r4 - r5)|0;
 r4 = r4 & 15;
 r4 = (r1 + r4)|0;
 r5 = (r4 + 4)|0;
 r4 = r4 >> 2;
 heap32[(r4)] = r1;
 r1 = r5;
}
 r4 = 1;
 r5 = 64;
 r6 = r1 >> 2;
 heap32[(r6)] = r0;
_6: while(true){
 r0 = r4;
 r4 = (r0 + -1)|0;
 r6 = r4 << 2;
 r6 = (r1 + r6)|0;
 r6 = r6 >> 2;
 r6 = heap32[(r6)];
 r7 = r6 >> 2;
 f6 = heapFloat[(r7)];
 if(f6 <=f3) //_LBB102_7
{
 f6 = heapFloat[(r7+4)];
if(!(f6 <f0)) //_LBB102_6
{
 f6 = heapFloat[(r7+1)];
if(!(f6 >f4)) //_LBB102_6
{
 f6 = heapFloat[(r7+5)];
if(!(f6 <f1)) //_LBB102_6
{
 f6 = heapFloat[(r7+2)];
if(!(f6 >f5)) //_LBB102_6
{
 f6 = heapFloat[(r7+6)];
if(!(f6 <f2)) //_LBB102_6
{
 r8 = heap32[(r7+10)];
 if(r8 ==0) //_LBB102_42
{
 r0 = r2 >> 2;
 r0 = heap32[(r0)];
 r0 = r0 >> 2;
 r0 = heap32[(r0+3)];
 heap32[(g0)] = r2;
 heap32[(g0+1)] = r6;
 __FUNCTION_TABLE__[(r0)>>2](i7);
}
else{
 r6 = heap32[(r7+9)];
 if(r5 ==r4) //_LBB102_15
{
 r8 = 1;
 r9 = r4 << 1;
 r8 = r4 == 0 ? r8 : r9;
if(!(r5 >=r8)) //_LBB102_14
{
 if(r8 !=0) //_LBB102_18
{
 r5 = heap32[(r3)];
 r9 = r8 << 2;
 r5 = (r5 + 1)|0;
 r9 = r9 | 3;
 heap32[(r3)] = r5;
 r5 = (r9 + 16)|0;
 heap32[(g0)] = r5;
 malloc(i7);
 r9 = r_g0;
 if(r9 !=0) //_LBB102_20
{
 r5 = 0;
 r10 = (r9 + 4)|0;
 r5 = (r5 - r10)|0;
 r5 = r5 & 15;
 r5 = (r9 + r5)|0;
 r10 = (r5 + 4)|0;
 r5 = r5 >> 2;
 heap32[(r5)] = r9;
 r9 = r10;
}
}
else{
 r9 = 0;
}
if(!(r4 <1)) //_LBB102_24
{
 r4 = (r0 + -1)|0;
 r5 = r1;
 r10 = r9;
_28: while(true){
 r11 = r5 >> 2;
 r4 = (r4 + -1)|0;
 r12 = (r10 + 4)|0;
 r5 = (r5 + 4)|0;
 r10 = r10 >> 2;
 r11 = heap32[(r11)];
 heap32[(r10)] = r11;
 r10 = r12;
if(!(r4 !=0)) //_LBB102_23
{
break _28;
}
}
}
 if(r1 !=0) //_LBB102_26
{
 r4 = gNumAlignedFree;
 r4 = r4 >> 2;
 r5 = heap32[(r4)];
 r5 = (r5 + 1)|0;
 r1 = r1 >> 2;
 heap32[(r4)] = r5;
 r1 = heap32[(r1+-1)];
 heap32[(g0)] = r1;
 free(i7);
 r5 = r8;
 r1 = r9;
}
else{
 r5 = r8;
 r1 = r9;
}
}
}
 r4 = r0 << 2;
 r8 = (r1 + r4)|0;
 r8 = r8 >> 2;
 heap32[(r8+-1)] = r6;
 r6 = heap32[(r7+10)];
 if(r5 ==r0) //_LBB102_29
{
 r7 = 1;
 r8 = r0 << 1;
 r7 = r0 == 0 ? r7 : r8;
if(!(r5 >=r7)) //_LBB102_28
{
 if(r7 !=0) //_LBB102_32
{
 r5 = heap32[(r3)];
 r8 = r7 << 2;
 r5 = (r5 + 1)|0;
 r8 = r8 | 3;
 heap32[(r3)] = r5;
 r5 = (r8 + 16)|0;
 heap32[(g0)] = r5;
 malloc(i7);
 r8 = r_g0;
 if(r8 !=0) //_LBB102_34
{
 r5 = 0;
 r9 = (r8 + 4)|0;
 r5 = (r5 - r9)|0;
 r5 = r5 & 15;
 r5 = (r8 + r5)|0;
 r9 = (r5 + 4)|0;
 r5 = r5 >> 2;
 heap32[(r5)] = r8;
 r8 = r9;
}
}
else{
 r8 = 0;
}
_43: do {
if(!(r0 <1)) //_LBB102_38
{
 r5 = r1;
 r9 = r8;
 r10 = r0;
_45: while(true){
 r11 = r5 >> 2;
 r10 = (r10 + -1)|0;
 r12 = (r9 + 4)|0;
 r5 = (r5 + 4)|0;
 r9 = r9 >> 2;
 r11 = heap32[(r11)];
 heap32[(r9)] = r11;
 r9 = r12;
if(!(r10 !=0)) //_LBB102_37
{
break _43;
}
}
}
} while(0);
 if(r1 !=0) //_LBB102_40
{
 r5 = gNumAlignedFree;
 r5 = r5 >> 2;
 r9 = heap32[(r5)];
 r9 = (r9 + 1)|0;
 r1 = r1 >> 2;
 heap32[(r5)] = r9;
 r1 = heap32[(r1+-1)];
 heap32[(g0)] = r1;
 free(i7);
 r5 = r7;
 r1 = r8;
}
else{
 r5 = r7;
 r1 = r8;
}
}
}
 r7 = (r1 + r4)|0;
 r4 = (r0 + 1)|0;
 r0 = r7 >> 2;
 heap32[(r0)] = r6;
}
}
}
}
}
}
}
if(!(r4 >0)) //_LBB102_5
{
break _6;
}
}
if(!(r1 ==0)) //_LBB102_46
{
 r0 = gNumAlignedFree;
 r0 = r0 >> 2;
 r2 = heap32[(r0)];
 r2 = (r2 + 1)|0;
 r1 = r1 >> 2;
 heap32[(r0)] = r2;
 r0 = heap32[(r1+-1)];
 heap32[(g0)] = r0;
 free(i7);
}
}
 return;
}

function _ZN16btDbvtBroadphase8aabbTestERK9btVector3S2_R24btBroadphaseAabbCallback(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
 var r1;
 var r2;
 var r3;
 var r4;
var __label__ = 0;
 i7 = sp + -56;var g0 = i7>>2; // save stack
 r0 = _ZTV20BroadphaseAabbTester;
 r1 = sp + -8;
 r0 = (r0 + 8)|0;
 r2 = heap32[(fp+1)];
 r3 = r1 >> 2;
 r4 = heap32[(fp+3)];
 heap32[(fp+-2)] = r0;
 r0 = sp + -40;
 r2 = r2 >> 2;
 heap32[(r3+1)] = r4;
 r3 = r0 >> 2;
 heap32[(fp+-10)] = heap32[(r2)];
 heap32[(r3+1)] = heap32[(r2+1)];
 r4 = heap32[(fp+2)];
 heap32[(r3+2)] = heap32[(r2+2)];
 r4 = r4 >> 2;
 heap32[(r3+3)] = heap32[(r2+3)];
 heap32[(r3+4)] = heap32[(r4)];
 heap32[(r3+5)] = heap32[(r4+1)];
 r2 = heap32[(fp)];
 heap32[(r3+6)] = heap32[(r4+2)];
 r2 = r2 >> 2;
 heap32[(r3+7)] = heap32[(r4+3)];
 r3 = heap32[(r2+1)];
 heap32[(g0)] = r3;
 heap32[(g0+1)] = r0;
 heap32[(g0+2)] = r1;
 _ZN6btDbvt9collideTVEPK10btDbvtNodeRK12btDbvtAabbMmRNS_8ICollideE(i7);
 r2 = heap32[(r2+11)];
 heap32[(g0)] = r2;
 heap32[(g0+1)] = r0;
 heap32[(g0+2)] = r1;
 _ZN6btDbvt9collideTVEPK10btDbvtNodeRK12btDbvtAabbMmRNS_8ICollideE(i7);
 return;
}

function _ZN16btDbvtBroadphase11createProxyERK9btVector3S2_iPvssP12btDispatcherS3_(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
 var r1;
 var r2;
 var r3;
 var r4;
 var r5;
 var r6;
 var r7;
 var r8;
 var r9;
 var r10;
 var f0;
 var f1;
 var f2;
 var f3;
 var f4;
 var f5;
 var f6;
 var f7;
var __label__ = 0;
 i7 = sp + -64;var g0 = i7>>2; // save stack
 r0 = gNumAlignedAllocs;
 r0 = r0 >> 2;
 r1 = heap32[(r0)];
 r2 = (r1 + 1)|0;
 heap32[(r0)] = r2;
 heap32[(g0)] = 83;
 malloc(i7);
 r2 = r_g0;
 r3 = heap32[(fp)];
 r4 = heap32[(fp+1)];
 r5 = heap32[(fp+2)];
 r6 = heap32[(fp+4)];
 r7 = heap32[(fp+5)];
 r8 = heap32[(fp+6)];
 if(r2 !=0) //_LBB104_2
{
 r9 = 0;
 r10 = (r2 + 4)|0;
 r9 = (r9 - r10)|0;
 r9 = r9 & 15;
 r9 = (r2 + r9)|0;
 r10 = (r9 + 4)|0;
 r9 = r9 >> 2;
 heap32[(r9)] = r2;
 r2 = r10;
}
 r9 = r2 >> 2;
 heap32[(r9)] = r6;
 heap16[(r2+4)>>1] = r7;
 r4 = r4 >> 2;
 heap16[(r2+6)>>1] = r8;
 f0 = heapFloat[(r4)];
 heapFloat[(r9+4)] = f0;
 f1 = heapFloat[(r4+1)];
 heapFloat[(r9+5)] = f1;
 f2 = heapFloat[(r4+2)];
 heapFloat[(r9+6)] = f2;
 f3 = heapFloat[(r4+3)];
 r4 = r5 >> 2;
 heapFloat[(r9+7)] = f3;
 f4 = heapFloat[(r4)];
 heapFloat[(r9+8)] = f4;
 f5 = heapFloat[(r4+1)];
 heapFloat[(r9+9)] = f5;
 f6 = heapFloat[(r4+2)];
 heapFloat[(r9+10)] = f6;
 f7 = heapFloat[(r4+3)];
 heapFloat[(r9+11)] = f7;
 heap32[(r9+2)] = 0;
 heap32[(r9+14)] = 0;
 r4 = sp + -32;
 heap32[(r9+13)] = 0;
 r5 = r4 >> 2;
 heapFloat[(fp+-8)] = f0;
 heapFloat[(r5+1)] = f1;
 heapFloat[(r5+2)] = f2;
 heapFloat[(r5+3)] = f3;
 heapFloat[(r5+4)] = f4;
 heapFloat[(r5+5)] = f5;
 heapFloat[(r5+6)] = f6;
 r6 = r3 >> 2;
 heapFloat[(r5+7)] = f7;
 r5 = heap32[(r6+26)];
 heap32[(r9+15)] = r5;
 r5 = heap32[(r6+37)];
 r5 = (r5 + 1)|0;
 heap32[(r6+37)] = r5;
 heap32[(r9+3)] = r5;
 r5 = heap32[(r6+2)];
 r7 = (r3 + 4)|0;
 if(r5 ==0) //_LBB104_5
{
 r5 = (r1 + 2)|0;
 heap32[(r0)] = r5;
 heap32[(g0)] = 63;
 malloc(i7);
 r5 = r_g0;
 if(r5 !=0) //_LBB104_7
{
 r0 = 0;
 r1 = (r5 + 4)|0;
 r0 = (r0 - r1)|0;
 r0 = r0 & 15;
 r0 = (r5 + r0)|0;
 r1 = (r0 + 4)|0;
 r0 = r0 >> 2;
 heap32[(r0)] = r5;
 r5 = r1;
}
}
else{
 heap32[(r6+2)] = 0;
}
 r0 = r5 >> 2;
 heap32[(r0+8)] = 0;
 heap32[(r0+9)] = r2;
 heap32[(r0+10)] = 0;
 heapFloat[(r0)] = f0;
 heapFloat[(r0+1)] = f1;
 heapFloat[(r0+2)] = f2;
 heapFloat[(r0+3)] = f3;
 heapFloat[(r0+4)] = f4;
 heapFloat[(r0+5)] = f5;
 heapFloat[(r0+6)] = f6;
 heapFloat[(r0+7)] = f7;
 r0 = heap32[(r6+1)];
 heap32[(g0)] = r7;
 heap32[(g0+1)] = r0;
 heap32[(g0+2)] = r5;
 _ZL10insertleafP6btDbvtP10btDbvtNodeS2_(i7);
 r0 = heap32[(r6+4)];
 r0 = (r0 + 1)|0;
 heap32[(r6+4)] = r0;
 heap32[(r9+12)] = r5;
 r0 = heap32[(r6+26)];
 r0 = r0 << 2;
 r0 = (r3 + r0)|0;
 r0 = r0 >> 2;
 heap32[(r9+13)] = 0;
 r1 = heap32[(r0+21)];
 heap32[(r9+14)] = r1;
if(!(r1 ==0)) //_LBB104_10
{
 r1 = r1 >> 2;
 heap32[(r1+13)] = r2;
}
 heap32[(r0+21)] = r2;
 r0 = heapU8[r3+153];
if(!(r0 !=0)) //_LBB104_12
{
 r0 = _ZTV18btDbvtTreeCollider;
 r0 = (r0 + 8)|0;
 r1 = sp + -48;
 r5 = r1 >> 2;
 heap32[(fp+-12)] = r0;
 heap32[(r5+1)] = r3;
 heap32[(r5+2)] = r2;
 r3 = heap32[(r6+1)];
 heap32[(g0)] = r3;
 heap32[(g0+1)] = r4;
 heap32[(g0+2)] = r1;
 _ZN6btDbvt9collideTVEPK10btDbvtNodeRK12btDbvtAabbMmRNS_8ICollideE(i7);
 r3 = heap32[(r6+11)];
 heap32[(g0)] = r3;
 heap32[(g0+1)] = r4;
 heap32[(g0+2)] = r1;
 _ZN6btDbvt9collideTVEPK10btDbvtNodeRK12btDbvtAabbMmRNS_8ICollideE(i7);
 heap32[(fp+-12)] = r0;
}
 r_g0 = r2;
 return;
}

function _ZNK6btDbvt15rayTestInternalEPK10btDbvtNodeRK9btVector3S5_S5_PjfS5_S5_RNS_8ICollideE(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
 var r1;
 var r2;
 var r3;
 var r4;
 var r5;
 var r6;
 var r7;
 var r8;
 var r9;
 var r10;
 var r11;
 var r12;
 var r13;
 var r14;
 var r15;
 var r16;
 var r17;
 var r18;
 var r19;
 var r20;
 var r21;
 var r22;
 var r23;
 var f0;
 var f1;
 var f2;
 var f3;
 var f4;
 var f5;
 var f6;
 var f7;
 var f8;
var __label__ = 0;
 i7 = sp + -40;var g0 = i7>>2; // save stack
 r0 = heap32[(fp)];
if(!(r0 ==0)) //_LBB105_43
{
 r1 = heap32[(fp+1)];
 r2 = heap32[(fp+2)];
 r3 = heap32[(fp+3)];
 f0 = heapFloat[(fp+4)];
 r4 = heap32[(fp+5)];
 r5 = heap32[(fp+6)];
 r6 = heap32[(fp+7)];
 r7 = gNumAlignedAllocs;
 r7 = r7 >> 2;
 r8 = heap32[(r7)];
 r8 = (r8 + 1)|0;
 heap32[(r7)] = r8;
 heap32[(g0)] = 531;
 malloc(i7);
 r8 = r_g0;
 if(r8 !=0) //_LBB105_3
{
 r9 = 0;
 r10 = (r8 + 4)|0;
 r9 = (r9 - r10)|0;
 r9 = r9 & 15;
 r9 = (r8 + r9)|0;
 r10 = (r9 + 4)|0;
 r9 = r9 >> 2;
 heap32[(r9)] = r8;
 r8 = r10;
}
 r9 = 0;
_6: while(true){
 r10 = r9 << 2;
 r10 = (r8 + r10)|0;
 r9 = (r9 + 1)|0;
 r10 = r10 >> 2;
 heap32[(r10)] = 0;
if(!(r9 !=128)) //_LBB105_5
{
break _6;
}
}
 r9 = 128;
 r10 = 1;
 r11 = 126;
 r12 = r8 >> 2;
 heap32[(r12)] = r0;
 r0 = r9;
 r12 = r10;
_9: while(true){
 r13 = r12;
 r12 = (r13 + -1)|0;
 r14 = r12 << 2;
 r14 = (r8 + r14)|0;
 r14 = r14 >> 2;
 r14 = heap32[(r14)];
 r15 = r14 >> 2;
 r16 = r5 >> 2;
 f1 = heapFloat[(r15+2)];
 f2 = heapFloat[(r16+2)];
 f3 = heapFloat[(r15+1)];
 f4 = heapFloat[(r16+1)];
 f5 = heapFloat[(r15)];
 f6 = heapFloat[(r16)];
 r16 = sp + -32;
 f5 = f5-f6;
 r17 = r16 >> 2;
 f3 = f3-f4;
 heapFloat[(fp+-8)] = f5;
 f1 = f1-f2;
 heapFloat[(r17+1)] = f3;
 heapFloat[(r17+2)] = f1;
 heap32[(r17+3)] = 0;
 r18 = r4 >> 2;
 f1 = heapFloat[(r15+6)];
 f2 = heapFloat[(r18+2)];
 f3 = heapFloat[(r15+5)];
 f4 = heapFloat[(r18+1)];
 f5 = heapFloat[(r15+4)];
 f6 = heapFloat[(r18)];
 f5 = f5-f6;
 f3 = f3-f4;
 heapFloat[(r17+4)] = f5;
 f1 = f1-f2;
 heapFloat[(r17+5)] = f3;
 heapFloat[(r17+6)] = f1;
 r18 = r3 >> 2;
 heap32[(r17+7)] = 0;
 r17 = heap32[(r18)];
 r19 = heap32[(r18+1)];
 r20 = (r10 - r19)|0;
 r21 = r17 << 4;
 r20 = r20 << 4;
 r21 = (r16 + r21)|0;
 r20 = (r16 + r20)|0;
 r22 = r1 >> 2;
 r21 = r21 >> 2;
 r20 = r20 >> 2;
 r23 = r2 >> 2;
 f1 = heapFloat[(r21)];
 f2 = heapFloat[(r22)];
 f3 = heapFloat[(r20+1)];
 f4 = heapFloat[(r22+1)];
 f1 = f1-f2;
 f5 = heapFloat[(r23)];
 f3 = f3-f4;
 f6 = heapFloat[(r23+1)];
 f1 = f1*f5;
 f3 = f3*f6;
if(!(f1 >f3)) //_LBB105_9
{
 r17 = (r10 - r17)|0;
 r17 = r17 << 4;
 r19 = r19 << 4;
 r17 = (r16 + r17)|0;
 r19 = (r16 + r19)|0;
 r17 = r17 >> 2;
 r19 = r19 >> 2;
 f7 = heapFloat[(r17)];
 f8 = heapFloat[(r19+1)];
 f2 = f7-f2;
 f4 = f8-f4;
 f2 = f2*f5;
 f4 = f4*f6;
 if(f4 <=f2) //_LBB105_10
{
 r17 = heap32[(r18+2)];
 r18 = 1;
 r18 = (r18 - r17)|0;
 r18 = r18 << 4;
 r18 = (r16 + r18)|0;
 r18 = r18 >> 2;
 f5 = heapFloat[(r18+2)];
 f6 = heapFloat[(r22+2)];
 f5 = f5-f6;
 f7 = heapFloat[(r23+2)];
 f1 = f1 < f4 ? f4 : f1;
 f4 = f5*f7;
if(!(f1 >f4)) //_LBB105_9
{
 r17 = r17 << 4;
 r16 = (r16 + r17)|0;
 r16 = r16 >> 2;
 f5 = heapFloat[(r16+2)];
 f5 = f5-f6;
 f2 = f3 < f2 ? f3 : f2;
 f3 = f5*f7;
if(!(f3 >f2)) //_LBB105_9
{
 f1 = f1 < f3 ? f3 : f1;
if(!(f1 >=f0)) //_LBB105_9
{
 f1 = f4 < f2 ? f4 : f2;
 f2 =                         0;
if(!(f1 <=f2)) //_LBB105_9
{
 r16 = heap32[(r15+10)];
 if(r16 ==0) //_LBB105_39
{
 r13 = r6 >> 2;
 r13 = heap32[(r13)];
 r13 = r13 >> 2;
 r13 = heap32[(r13+3)];
 heap32[(g0)] = r6;
 heap32[(g0+1)] = r14;
 __FUNCTION_TABLE__[(r13)>>2](i7);
}
else{
 if(r12 >r11) //_LBB105_17
{
 r14 = r0 << 1;
_23: do {
 if(r0 <=r14) //_LBB105_19
{
if(!(r0 >=r14)) //_LBB105_18
{
 if(r9 <r14) //_LBB105_22
{
 if(r14 !=0) //_LBB105_24
{
 r9 = heap32[(r7)];
 r11 = r0 << 3;
 r9 = (r9 + 1)|0;
 r11 = r11 | 3;
 heap32[(r7)] = r9;
 r9 = (r11 + 16)|0;
 heap32[(g0)] = r9;
 malloc(i7);
 r9 = r_g0;
 if(r9 !=0) //_LBB105_26
{
 r11 = 0;
 r12 = (r9 + 4)|0;
 r11 = (r11 - r12)|0;
 r11 = r11 & 15;
 r11 = (r9 + r11)|0;
 r12 = (r11 + 4)|0;
 r11 = r11 >> 2;
 heap32[(r11)] = r9;
 r9 = r12;
}
}
else{
 r9 = 0;
}
if(!(r0 <1)) //_LBB105_30
{
 r11 = r8;
 r12 = r9;
 r16 = r0;
_35: while(true){
 r17 = r11 >> 2;
 r16 = (r16 + -1)|0;
 r18 = (r12 + 4)|0;
 r11 = (r11 + 4)|0;
 r12 = r12 >> 2;
 r17 = heap32[(r17)];
 heap32[(r12)] = r17;
 r12 = r18;
if(!(r16 !=0)) //_LBB105_29
{
break _35;
}
}
}
if(!(r8 ==0)) //_LBB105_32
{
 r11 = gNumAlignedFree;
 r11 = r11 >> 2;
 r12 = heap32[(r11)];
 r12 = (r12 + 1)|0;
 r8 = r8 >> 2;
 heap32[(r11)] = r12;
 r8 = heap32[(r8+-1)];
 heap32[(g0)] = r8;
 free(i7);
}
 if(r0 <r14) //_LBB105_34
{
 r8 = r9;
 r9 = r14;
}
else{
 r8 = r9;
 r9 = r14;
break _23;
}
}
 r11 = r0;
_45: while(true){
 r12 = r0 << 2;
 r12 = (r8 + r12)|0;
 r11 = (r11 + -1)|0;
 r0 = (r0 + 1)|0;
 r12 = r12 >> 2;
 heap32[(r12)] = 0;
if(!(r11 !=0)) //_LBB105_36
{
break _23;
}
}
}
}
} while(0);
 r11 = (r14 + -2)|0;
}
else{
 r14 = r0;
}
 r0 = r13 << 2;
 r0 = (r8 + r0)|0;
 r0 = r0 >> 2;
 r12 = heap32[(r15+9)];
 heap32[(r0+-1)] = r12;
 r15 = heap32[(r15+10)];
 r12 = (r13 + 1)|0;
 heap32[(r0)] = r15;
 r0 = r14;
}
}
}
}
}
}
}
if(!(r12 !=0)) //_LBB105_7
{
break _9;
}
}
if(!(r8 ==0)) //_LBB105_43
{
 r0 = gNumAlignedFree;
 r0 = r0 >> 2;
 r1 = heap32[(r0)];
 r1 = (r1 + 1)|0;
 r2 = r8 >> 2;
 heap32[(r0)] = r1;
 r0 = heap32[(r2+-1)];
 heap32[(g0)] = r0;
 free(i7);
}
}
 return;
}

function _ZN16btDbvtBroadphase7rayTestERK9btVector3S2_R23btBroadphaseRayCallbackS2_S2_(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
 var r1;
 var r2;
 var r3;
 var r4;
 var r5;
 var r6;
 var r7;
 var r8;
 var f0;
var __label__ = 0;
 i7 = sp + -40;var g0 = i7>>2; // save stack
 r0 = _ZTV19BroadphaseRayTester;
 r1 = sp + -8;
 r0 = (r0 + 8)|0;
 r2 = heap32[(fp+3)];
 r3 = heap32[(fp)];
 r4 = r1 >> 2;
 heap32[(fp+-2)] = r0;
 heap32[(r4+1)] = r2;
 r0 = r2 >> 2;
 r3 = r3 >> 2;
 f0 = heapFloat[(r0+8)];
 r4 = heap32[(r3+1)];
 r5 = heap32[(fp+1)];
 r6 = (r2 + 4)|0;
 r2 = (r2 + 20)|0;
 r7 = heap32[(fp+4)];
 r8 = heap32[(fp+5)];
 heap32[(g0)] = r4;
 heap32[(g0+1)] = r5;
 heap32[(g0+2)] = r6;
 heap32[(g0+3)] = r2;
 heapFloat[(g0+4)] = f0;
 heap32[(g0+5)] = r7;
 heap32[(g0+6)] = r8;
 heap32[(g0+7)] = r1;
 _ZNK6btDbvt15rayTestInternalEPK10btDbvtNodeRK9btVector3S5_S5_PjfS5_S5_RNS_8ICollideE(i7);
 f0 = heapFloat[(r0+8)];
 r0 = heap32[(r3+11)];
 heap32[(g0)] = r0;
 heap32[(g0+1)] = r5;
 heap32[(g0+2)] = r6;
 heap32[(g0+3)] = r2;
 heapFloat[(g0+4)] = f0;
 heap32[(g0+5)] = r7;
 heap32[(g0+6)] = r8;
 heap32[(g0+7)] = r1;
 _ZNK6btDbvt15rayTestInternalEPK10btDbvtNodeRK9btVector3S5_S5_PjfS5_S5_RNS_8ICollideE(i7);
 return;
}

function _ZN16btDbvtBroadphase12destroyProxyEP17btBroadphaseProxyP12btDispatcher(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
 var r1;
 var r2;
 var r3;
 var r4;
 var r5;
 var r6;
 var r7;
 var r8;
var __label__ = 0;
 i7 = sp + -16;var g0 = i7>>2; // save stack
 r0 = heap32[(fp+1)];
 r1 = r0 >> 2;
 r2 = heap32[(fp)];
 r3 = heap32[(fp+2)];
 r4 = heap32[(r1+12)];
 r5 = heap32[(r1+15)];
 if(r5 !=2) //_LBB107_4
{
 r5 = (r2 + 4)|0;
 heap32[(g0)] = r5;
 heap32[(g0+1)] = r4;
 r5 = r2 >> 2;
 _ZL10removeleafP6btDbvtP10btDbvtNode(i7);
 r6 = heap32[(r5+2)];
if(!(r6 ==0)) //_LBB107_6
{
 r7 = gNumAlignedFree;
 r7 = r7 >> 2;
 r8 = heap32[(r7)];
 r8 = (r8 + 1)|0;
 r6 = r6 >> 2;
 heap32[(r7)] = r8;
 r6 = heap32[(r6+-1)];
 heap32[(g0)] = r6;
 free(i7);
}
 heap32[(r5+2)] = r4;
 r4 = heap32[(r5+4)];
 r4 = (r4 + -1)|0;
 heap32[(r5+4)] = r4;
}
else{
 r5 = (r2 + 44)|0;
 heap32[(g0)] = r5;
 heap32[(g0+1)] = r4;
 r5 = r2 >> 2;
 _ZL10removeleafP6btDbvtP10btDbvtNode(i7);
 r6 = heap32[(r5+12)];
if(!(r6 ==0)) //_LBB107_3
{
 r7 = gNumAlignedFree;
 r7 = r7 >> 2;
 r8 = heap32[(r7)];
 r8 = (r8 + 1)|0;
 r6 = r6 >> 2;
 heap32[(r7)] = r8;
 r6 = heap32[(r6+-1)];
 heap32[(g0)] = r6;
 free(i7);
}
 heap32[(r5+12)] = r4;
 r4 = heap32[(r5+14)];
 r4 = (r4 + -1)|0;
 heap32[(r5+14)] = r4;
}
 r4 = heap32[(r1+13)];
 r5 = heap32[(r1+14)];
 if(r4 ==0) //_LBB107_9
{
 r4 = heap32[(r1+15)];
 r4 = r4 << 2;
 r4 = (r2 + r4)|0;
 r4 = r4 >> 2;
 heap32[(r4+21)] = r5;
}
else{
 r4 = r4 >> 2;
 heap32[(r4+14)] = r5;
}
 r4 = heap32[(r1+14)];
if(!(r4 ==0)) //_LBB107_12
{
 r4 = r4 >> 2;
 r5 = heap32[(r1+13)];
 heap32[(r4+13)] = r5;
}
 r4 = r2 >> 2;
 r4 = heap32[(r4+24)];
 r5 = r4 >> 2;
 r5 = heap32[(r5)];
 r5 = r5 >> 2;
 r5 = heap32[(r5+4)];
 heap32[(g0)] = r4;
 heap32[(g0+1)] = r0;
 heap32[(g0+2)] = r3;
 __FUNCTION_TABLE__[(r5)>>2](i7);
if(!(r0 ==0)) //_LBB107_14
{
 r0 = gNumAlignedFree;
 r0 = r0 >> 2;
 r3 = heap32[(r0)];
 r3 = (r3 + 1)|0;
 heap32[(r0)] = r3;
 r0 = heap32[(r1+-1)];
 heap32[(g0)] = r0;
 free(i7);
}
 r0 = 1;
 heap8[r2+154] = r0;
 return;
}

function _ZN16btDbvtBroadphase25calculateOverlappingPairsEP12btDispatcher(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
 var r1;
 var r2;
 var r3;
 var r4;
 var r5;
 var r6;
 var r7;
 var r8;
 var r9;
 var r10;
 var r11;
 var r12;
 var f0;
 var f1;
 var f2;
 var f3;
 var f4;
 var f5;
 var f6;
 var f7;
var __label__ = 0;
 i7 = sp + -48;var g0 = i7>>2; // save stack
 r0 = heap32[(fp)];
 r1 = r0 >> 2;
 r2 = heap32[(r1+4)];
 r3 = heap32[(r1+28)];
 r2 = (r3 * r2)|0;
 r2 = (r2 / 100)|0;
 r3 = (r0 + 4)|0;
 r2 = (r2 + 1)|0;
 heap32[(g0)] = r3;
 heap32[(g0+1)] = r2;
 _ZN6btDbvt19optimizeIncrementalEi(i7);
 r2 = heap32[(r1+31)];
if(!(r2 ==0)) //_LBB108_2
{
 r2 = heap32[(r1+14)];
 r4 = heap32[(r1+27)];
 r2 = (r4 * r2)|0;
 r4 = (r2 / 100)|0;
 r5 = (r0 + 44)|0;
 r4 = (r4 + 1)|0;
 heap32[(g0)] = r5;
 heap32[(g0+1)] = r4;
 _ZN6btDbvt19optimizeIncrementalEi(i7);
 r2 = (r2 / -100)|0;
 r4 = heap32[(r1+31)];
 r2 = (r2 + r4)|0;
 r2 = (r2 + -1)|0;
 r4 = 0;
 r2 = r2 < 0 ? r4 : r2;
 heap32[(r1+31)] = r2;
}
 r2 = heap32[(r1+26)];
 r2 = (r2 + 1)|0;
 r4 = r2 >>> 31;
 r4 = (r2 + r4)|0;
 r4 = r4 & -2;
 r2 = (r2 - r4)|0;
 r4 = r2 << 2;
 r4 = (r0 + r4)|0;
 r4 = r4 >> 2;
 heap32[(r1+26)] = r2;
 r2 = heap32[(r4+21)];
if(!(r2 ==0)) //_LBB108_20
{
 r4 = (r0 + 44)|0;
_6: while(true){
 r5 = r2 >> 2;
 r6 = heap32[(r5+13)];
 r7 = heap32[(r5+14)];
 if(r6 ==0) //_LBB108_6
{
 r6 = heap32[(r5+15)];
 r6 = r6 << 2;
 r6 = (r0 + r6)|0;
 r6 = r6 >> 2;
 heap32[(r6+21)] = r7;
}
else{
 r6 = r6 >> 2;
 heap32[(r6+14)] = r7;
}
 r6 = heap32[(r5+14)];
if(!(r6 ==0)) //_LBB108_9
{
 r6 = r6 >> 2;
 r8 = heap32[(r5+13)];
 heap32[(r6+13)] = r8;
}
 heap32[(r5+13)] = 0;
 r6 = heap32[(r1+23)];
 heap32[(r5+14)] = r6;
 r6 = heap32[(r1+23)];
if(!(r6 ==0)) //_LBB108_11
{
 r6 = r6 >> 2;
 heap32[(r6+13)] = r2;
}
 heap32[(r1+23)] = r2;
 r6 = heap32[(r5+12)];
 heap32[(g0)] = r3;
 heap32[(g0+1)] = r6;
 _ZL10removeleafP6btDbvtP10btDbvtNode(i7);
 r8 = heap32[(r1+2)];
if(!(r8 ==0)) //_LBB108_13
{
 r9 = gNumAlignedFree;
 r9 = r9 >> 2;
 r10 = heap32[(r9)];
 r10 = (r10 + 1)|0;
 r8 = r8 >> 2;
 heap32[(r9)] = r10;
 r8 = heap32[(r8+-1)];
 heap32[(g0)] = r8;
 free(i7);
}
 heap32[(r1+2)] = r6;
 r6 = heap32[(r1+4)];
 r6 = (r6 + -1)|0;
 heap32[(r1+4)] = r6;
 r6 = heap32[(r1+12)];
 f0 = heapFloat[(r5+4)];
 f1 = heapFloat[(r5+5)];
 f2 = heapFloat[(r5+6)];
 f3 = heapFloat[(r5+7)];
 f4 = heapFloat[(r5+8)];
 f5 = heapFloat[(r5+9)];
 f6 = heapFloat[(r5+10)];
 f7 = heapFloat[(r5+11)];
 if(r6 ==0) //_LBB108_15
{
 r6 = gNumAlignedAllocs;
 r6 = r6 >> 2;
 r8 = heap32[(r6)];
 r8 = (r8 + 1)|0;
 heap32[(r6)] = r8;
 heap32[(g0)] = 63;
 malloc(i7);
 r6 = r_g0;
 if(r6 !=0) //_LBB108_17
{
 r8 = 0;
 r9 = (r6 + 4)|0;
 r8 = (r8 - r9)|0;
 r8 = r8 & 15;
 r8 = (r6 + r8)|0;
 r9 = (r8 + 4)|0;
 r8 = r8 >> 2;
 heap32[(r8)] = r6;
 r6 = r9;
}
}
else{
 heap32[(r1+12)] = 0;
}
 r8 = r6 >> 2;
 heap32[(r8+8)] = 0;
 heap32[(r8+9)] = r2;
 heap32[(r8+10)] = 0;
 heapFloat[(r8)] = f0;
 heapFloat[(r8+1)] = f1;
 heapFloat[(r8+2)] = f2;
 heapFloat[(r8+3)] = f3;
 heapFloat[(r8+4)] = f4;
 heapFloat[(r8+5)] = f5;
 heapFloat[(r8+6)] = f6;
 heapFloat[(r8+7)] = f7;
 r2 = heap32[(r1+11)];
 heap32[(g0)] = r4;
 heap32[(g0+1)] = r2;
 heap32[(g0+2)] = r6;
 _ZL10insertleafP6btDbvtP10btDbvtNodeS2_(i7);
 r2 = heap32[(r1+14)];
 r2 = (r2 + 1)|0;
 heap32[(r1+14)] = r2;
 heap32[(r5+12)] = r6;
 heap32[(r5+15)] = 2;
 r2 = r7;
if(!(r7 !=0)) //_LBB108_4
{
break _6;
}
}
 r2 = heap32[(r1+14)];
 r4 = 1;
 heap32[(r1+31)] = r2;
 heap8[r0+154] = r4;
}
 r2 = _ZTV18btDbvtTreeCollider;
 r4 = sp + -32;
 r2 = (r2 + 8)|0;
 r5 = r4 >> 2;
 heap32[(fp+-8)] = r2;
 heap32[(r5+1)] = r0;
 r5 = heapU8[r0+153];
if(!(r5 ==0)) //_LBB108_23
{
 r5 = heap32[(r1+11)];
 r6 = heap32[(r1+1)];
 heap32[(g0)] = r3;
 heap32[(g0+1)] = r6;
 heap32[(g0+2)] = r5;
 heap32[(g0+3)] = r4;
 _ZN6btDbvt24collideTTpersistentStackEPK10btDbvtNodeS2_RNS_8ICollideE(i7);
 r5 = heapU8[r0+153];
if(!(r5 ==0)) //_LBB108_23
{
 r5 = heap32[(r1+1)];
 heap32[(g0)] = r3;
 heap32[(g0+1)] = r5;
 heap32[(g0+2)] = r5;
 heap32[(g0+3)] = r4;
 _ZN6btDbvt24collideTTpersistentStackEPK10btDbvtNodeS2_RNS_8ICollideE(i7);
}
}
 r3 = heap32[(fp+1)];
 heap32[(fp+-8)] = r2;
 r2 = heapU8[r0+154];
_32: do {
if(!(r2 ==0)) //_LBB108_40
{
 r2 = heap32[(r1+24)];
 r4 = r2 >> 2;
 r4 = heap32[(r4)];
 r4 = r4 >> 2;
 r4 = heap32[(r4+7)];
 heap32[(g0)] = r2;
 __FUNCTION_TABLE__[(r4)>>2](i7);
 r2 = r_g0;
 r4 = r2 >> 2;
 r4 = heap32[(r4+1)];
if(!(r4 <1)) //_LBB108_40
{
 r5 = heap32[(r1+29)];
 r5 = (r5 * r4)|0;
 r6 = heap32[(r1+30)];
 r5 = (r5 / 100)|0;
 r5 = r6 > r5 ? r6 : r5;
 r5 = r4 < r5 ? r4 : r5;
 if(r5 >0) //_LBB108_27
{
 r4 = 0;
_37: while(true){
 r6 = r2 >> 2;
 r7 = heap32[(r1+36)];
 r7 = (r7 + r4)|0;
 r8 = heap32[(r6+1)];
 r7 = (r7 % r8)|0;
 r8 = heap32[(r6+3)];
 r7 = r7 << 4;
 r7 = (r8 + r7)|0;
 r7 = r7 >> 2;
 r8 = heap32[(r7+1)];
 r7 = heap32[(r7)];
 r9 = r8 >> 2;
 r10 = r7 >> 2;
 r9 = heap32[(r9+12)];
 r10 = heap32[(r10+12)];
 r10 = r10 >> 2;
 r9 = r9 >> 2;
 f0 = heapFloat[(r10)];
 f1 = heapFloat[(r9+4)];
 if(f0 >f1) //_LBB108_35
{
__label__ = 32;
}
else{
 f0 = heapFloat[(r10+4)];
 f1 = heapFloat[(r9)];
 if(f0 <f1) //_LBB108_35
{
__label__ = 32;
}
else{
 f0 = heapFloat[(r10+1)];
 f1 = heapFloat[(r9+5)];
 if(f0 >f1) //_LBB108_35
{
__label__ = 32;
}
else{
 f0 = heapFloat[(r10+5)];
 f1 = heapFloat[(r9+1)];
 if(f0 <f1) //_LBB108_35
{
__label__ = 32;
}
else{
 f0 = heapFloat[(r10+2)];
 f1 = heapFloat[(r9+6)];
 if(f0 >f1) //_LBB108_35
{
__label__ = 32;
}
else{
 f0 = heapFloat[(r10+6)];
 f1 = heapFloat[(r9+2)];
 if(f0 <f1) //_LBB108_35
{
__label__ = 32;
}
else{
__label__ = 33;
}
}
}
}
}
}
if (__label__ == 32){
 r9 = heap32[(r1+24)];
 r10 = r9 >> 2;
 r10 = heap32[(r10)];
 r10 = r10 >> 2;
 r10 = heap32[(r10+3)];
 heap32[(g0)] = r9;
 heap32[(g0+1)] = r7;
 heap32[(g0+2)] = r8;
 heap32[(g0+3)] = r3;
 r5 = (r5 + -1)|0;
 r4 = (r4 + -1)|0;
 __FUNCTION_TABLE__[(r10)>>2](i7);
}
 r4 = (r4 + 1)|0;
if(!(r4 <r5)) //_LBB108_28
{
break _37;
}
}
 r4 = heap32[(r6+1)];
 if(r4 <1) //_LBB108_39
{
 heap32[(r1+36)] = 0;
break _32;
}
}
 r2 = heap32[(r1+36)];
 r2 = (r2 + r5)|0;
 r2 = (r2 % r4)|0;
 heap32[(r1+36)] = r2;
}
}
} while(0);
 r2 = heap32[(r1+35)];
 r2 = (r2 + 1)|0;
 heap32[(r1+35)] = r2;
 r2 = 0;
 heap32[(r1+30)] = 1;
 heap8[r0+154] = r2;
 r0 = heap32[(r1+32)];
 if(r0 ==0) //_LBB108_42
{
 heap32[(r1+34)] = 0;
 r4 = heap32[(r1+33)];
}
else{
 r4 = heap32[(r1+33)];
 f0 = uint(r4); //fuitos r4, f0
 f1 = uint(r0); //fuitos r0, f1
 f0 = f0/f1;
 heapFloat[(r1+34)] = f0;
}
 r4 = r4 >>> 1;
 r0 = r0 >>> 1;
 heap32[(r1+33)] = r4;
 heap32[(r1+32)] = r0;
 r0 = heap32[(r1+24)];
 r4 = r0 >> 2;
 r4 = heap32[(r4)];
 r4 = r4 >> 2;
 r4 = heap32[(r4+14)];
 heap32[(g0)] = r0;
 __FUNCTION_TABLE__[(r4)>>2](i7);
 r0 = r_g0;
if(!(r0 ==0)) //_LBB108_65
{
 r0 = heap32[(r1+24)];
 r4 = r0 >> 2;
 r4 = heap32[(r4)];
 r4 = r4 >> 2;
 r4 = heap32[(r4+7)];
 heap32[(g0)] = r0;
 __FUNCTION_TABLE__[(r4)>>2](i7);
 r0 = r_g0;
 r4 = r0 >> 2;
 r4 = heap32[(r4+1)];
if(!(r4 <2)) //_LBB108_46
{
 r4 = (r4 + -1)|0;
 heap32[(g0)] = r0;
 heap32[(g0+1)] = 0;
 heap32[(g0+2)] = r4;
 _ZN20btAlignedObjectArrayI16btBroadphasePairE17quickSortInternalI29btBroadphasePairSortPredicateEEvT_ii(i7);
}
 r4 = r2;
 r5 = r2;
 r6 = r2;
 r7 = r2;
_61: while(true){
 r8 = r0 >> 2;
 r9 = heap32[(r8+1)];
 if(r9 >r7) //_LBB108_47
{
 r8 = heap32[(r8+3)];
 r9 = r7 << 4;
 r9 = (r8 + r9)|0;
 r9 = r9 >> 2;
 r10 = heap32[(r9)];
 r11 = r7 << 2;
 r12 = heap32[(r9+1)];
 if(r10 !=r4) //_LBB108_49
{
__label__ = 46;
}
else{
 if(r12 ==r5) //_LBB108_56
{
 r4 = heap32[(r9+2)];
 if(r4 ==0) //_LBB108_58
{
__label__ = 54;
}
else{
__label__ = 53;
break _61;
}
}
else{
__label__ = 46;
}
}
if (__label__ == 46){
 r4 = r12 >> 2;
 r5 = r10 >> 2;
 r4 = heap32[(r4+12)];
 r5 = heap32[(r5+12)];
 r5 = r5 >> 2;
 r4 = r4 >> 2;
 f0 = heapFloat[(r5)];
 f1 = heapFloat[(r4+4)];
 if(f0 >f1) //_LBB108_58
{
__label__ = 54;
}
else{
 f0 = heapFloat[(r5+4)];
 f1 = heapFloat[(r4)];
 if(f0 <f1) //_LBB108_58
{
__label__ = 54;
}
else{
 f0 = heapFloat[(r5+1)];
 f1 = heapFloat[(r4+5)];
 if(f0 >f1) //_LBB108_58
{
__label__ = 54;
}
else{
 f0 = heapFloat[(r5+5)];
 f1 = heapFloat[(r4+1)];
 if(f0 <f1) //_LBB108_58
{
__label__ = 54;
}
else{
 f0 = heapFloat[(r5+2)];
 f1 = heapFloat[(r4+6)];
 if(f0 >f1) //_LBB108_58
{
__label__ = 54;
}
else{
 f0 = heapFloat[(r5+6)];
 f1 = heapFloat[(r4+2)];
 if(f0 <f1) //_LBB108_58
{
__label__ = 54;
}
else{
__label__ = 55;
}
}
}
}
}
}
}
if (__label__ == 54){
 r4 = heap32[(r1+24)];
 r5 = r4 >> 2;
 r5 = heap32[(r5)];
 r5 = r5 >> 2;
 r5 = heap32[(r5+8)];
 r9 = (r8 + r2)|0;
 r11 = r11 << 2;
 heap32[(g0)] = r4;
 heap32[(g0+1)] = r9;
 heap32[(g0+2)] = r3;
 r4 = (r8 + r11)|0;
 r4 = r4 >> 2;
 __FUNCTION_TABLE__[(r5)>>2](i7);
 r6 = (r6 + 1)|0;
 heap32[(r4)] = 0;
 heap32[(r4+1)] = 0;
}
 r7 = (r7 + 1)|0;
 r2 = (r2 + 16)|0;
 r4 = r10;
 r5 = r12;
}
else{
__label__ = 57;
break _61;
}
}
switch(__label__ ){//multiple entries
case 57:
 if(r9 >1) //_LBB108_63
{
 r9 = (r9 + -1)|0;
 heap32[(g0)] = r0;
 heap32[(g0+1)] = 0;
 heap32[(g0+2)] = r9;
 _ZN20btAlignedObjectArrayI16btBroadphasePairE17quickSortInternalI29btBroadphasePairSortPredicateEEvT_ii(i7);
 r9 = heap32[(r8+1)];
}
 r1 = sp + -16;
 r2 = r1 >> 2;
 heap32[(fp+-4)] = 0;
 heap32[(r2+1)] = 0;
 heap32[(r2+2)] = 0;
 heap32[(r2+3)] = 0;
 r2 = (r9 - r6)|0;
 heap32[(g0)] = r0;
 heap32[(g0+1)] = r2;
 heap32[(g0+2)] = r1;
 _ZN20btAlignedObjectArrayI16btBroadphasePairE6resizeEiRKS0_(i7);
break;
case 53:
 r8 = _2E_str314;
 r0 = _2E_str18;
 heap32[(g0)] = r8;
 heap32[(g0+1)] = r0;
 heap32[(g0+2)] = 469;
 _assert(i7);
break;
}
}
 return;
}

function _ZN16btDbvtBroadphase7setAabbEP17btBroadphaseProxyRK9btVector3S4_P12btDispatcher(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
 var r1;
 var r2;
 var r3;
 var r4;
 var r5;
 var r6;
 var r7;
 var r8;
 var r9;
 var r10;
 var r11;
 var r12;
 var f0;
 var f1;
 var f2;
 var f3;
 var f4;
 var f5;
 var f6;
 var f7;
 var f8;
 var f9;
 var f10;
var __label__ = 0;
 i7 = sp + -88;var g0 = i7>>2; // save stack
 r0 = heap32[(fp+2)];
 r0 = r0 >> 2;
 f0 = heapFloat[(r0)];
 r1 = sp + -32;
 heapFloat[(fp+-8)] = f0;
 f1 = heapFloat[(r0+1)];
 r2 = r1 >> 2;
 heapFloat[(r2+1)] = f1;
 f2 = heapFloat[(r0+2)];
 heapFloat[(r2+2)] = f2;
 f3 = heapFloat[(r0+3)];
 r3 = heap32[(fp+3)];
 r3 = r3 >> 2;
 heapFloat[(r2+3)] = f3;
 f4 = heapFloat[(r3)];
 heapFloat[(r2+4)] = f4;
 f5 = heapFloat[(r3+1)];
 heapFloat[(r2+5)] = f5;
 f6 = heapFloat[(r3+2)];
 heapFloat[(r2+6)] = f6;
 f7 = heapFloat[(r3+3)];
 r4 = heap32[(fp+1)];
 r5 = heap32[(fp)];
 r6 = r4 >> 2;
 heapFloat[(r2+7)] = f7;
 r7 = heap32[(r6+15)];
_1: do {
 if(r7 !=2) //_LBB109_9
{
 r2 = r5 >> 2;
 r8 = heap32[(r2+32)];
 r8 = (r8 + 1)|0;
 heap32[(r2+32)] = r8;
 r8 = heap32[(r6+12)];
 r7 = r8 >> 2;
 f8 = heapFloat[(r7)];
if(!(f8 >f4)) //_LBB109_24
{
 f8 = heapFloat[(r7+4)];
if(!(f8 <f0)) //_LBB109_24
{
 f8 = heapFloat[(r7+1)];
if(!(f8 >f5)) //_LBB109_24
{
 f8 = heapFloat[(r7+5)];
if(!(f8 <f1)) //_LBB109_24
{
 f8 = heapFloat[(r7+2)];
if(!(f8 >f6)) //_LBB109_24
{
 f8 = heapFloat[(r7+6)];
if(!(f8 <f2)) //_LBB109_24
{
 f0 = heapFloat[(r6+4)];
 f1 = heapFloat[(r6+8)];
 f1 = f1-f0;
 f2 =                       0.5;
 f3 = heapFloat[(r6+5)];
 f4 = heapFloat[(r6+9)];
 f4 = f4-f3;
 f5 = heapFloat[(r0+1)];
 f6 = heapFloat[(r0)];
 f1 = f1*f2;
 f7 = heapFloat[(r2+25)];
 f8 = heapFloat[(r0+2)];
 f9 = heapFloat[(r6+6)];
 f10 = heapFloat[(r6+10)];
 r7 = sp + -48;
 f10 = f10-f9;
 f4 = f4*f2;
 f1 = f1*f7;
 f2 = f10*f2;
 f4 = f4*f7;
 r9 = r7 >> 2;
 heapFloat[(fp+-12)] = f1;
 f2 = f2*f7;
 heapFloat[(r9+1)] = f4;
 heapFloat[(r9+2)] = f2;
 heap32[(r9+3)] = 0;
 f0 = f6-f0;
 f6 =                         0;
if(!(f0 >=f6)) //_LBB109_17
{
 f0 = -f1;
 heapFloat[(fp+-12)] = f0;
}
 f0 = f5-f3;
if(!(f0 >=f6)) //_LBB109_19
{
 f0 = -f4;
 heapFloat[(r9+1)] = f0;
}
 f0 = f8-f9;
if(!(f0 >=f6)) //_LBB109_21
{
 f0 = -f2;
 heapFloat[(r9+2)] = f0;
}
 r9 = (r5 + 4)|0;
 heap32[(g0)] = r9;
 heap32[(g0+1)] = r8;
 heap32[(g0+2)] = r1;
 heap32[(g0+3)] = r7;
 heap32[(g0+4)] = 1028443341;
 _ZN6btDbvt6updateEP10btDbvtNodeR12btDbvtAabbMmRK9btVector3f(i7);
 r8 = r_g0;
 if(r8 !=0) //_LBB109_23
{
 r7 = heap32[(r2+33)];
 r8 = 1;
 r7 = (r7 + 1)|0;
 heap32[(r2+33)] = r7;
break _1;
}
else{
 r8 = 0;
break _1;
}
}
}
}
}
}
}
 r1 = (r5 + 4)|0;
 heap32[(g0)] = r1;
 heap32[(g0+1)] = r8;
 _ZL10removeleafP6btDbvtP10btDbvtNode(i7);
 r9 = r_g0;
_23: do {
 if(r9 !=0) //_LBB109_26
{
 r11 = heap32[(r2+3)];
 if(r11 <0) //_LBB109_31
{
 r10 = heap32[(r2+1)];
}
else{
 r12 = -1;
_28: while(true){
 r10 = r9;
 r12 = (r12 + 1)|0;
 if(r11 >r12) //_LBB109_30
{
 r9 = r10 >> 2;
 r9 = heap32[(r9+8)];
 if(r9 ==0) //_LBB109_29
{
break _23;
}
}
else{
break _23;
}
}
}
}
else{
 r10 = 0;
}
} while(0);
 heapFloat[(r7)] = f0;
 heapFloat[(r7+1)] = f1;
 heapFloat[(r7+2)] = f2;
 heapFloat[(r7+3)] = f3;
 heapFloat[(r7+4)] = f4;
 heapFloat[(r7+5)] = f5;
 heapFloat[(r7+6)] = f6;
 heapFloat[(r7+7)] = f7;
 heap32[(g0)] = r1;
 heap32[(g0+1)] = r10;
 heap32[(g0+2)] = r8;
 _ZL10insertleafP6btDbvtP10btDbvtNodeS2_(i7);
 r1 = heap32[(r2+33)];
 r8 = 1;
 r1 = (r1 + 1)|0;
 heap32[(r2+33)] = r1;
}
else{
 r1 = heap32[(r6+12)];
 r7 = (r5 + 44)|0;
 heap32[(g0)] = r7;
 heap32[(g0+1)] = r1;
 r7 = r5 >> 2;
 _ZL10removeleafP6btDbvtP10btDbvtNode(i7);
 r8 = heap32[(r7+12)];
if(!(r8 ==0)) //_LBB109_3
{
 r9 = gNumAlignedFree;
 r9 = r9 >> 2;
 r10 = heap32[(r9)];
 r10 = (r10 + 1)|0;
 r8 = r8 >> 2;
 heap32[(r9)] = r10;
 r8 = heap32[(r8+-1)];
 heap32[(g0)] = r8;
 free(i7);
}
 heap32[(r7+12)] = r1;
 r1 = heap32[(r7+14)];
 r1 = (r1 + -1)|0;
 heap32[(r7+14)] = r1;
 r1 = heap32[(r7+2)];
 r8 = (r5 + 4)|0;
 if(r1 ==0) //_LBB109_5
{
 r1 = gNumAlignedAllocs;
 r1 = r1 >> 2;
 r9 = heap32[(r1)];
 r9 = (r9 + 1)|0;
 heap32[(r1)] = r9;
 heap32[(g0)] = 63;
 malloc(i7);
 r1 = r_g0;
 if(r1 !=0) //_LBB109_7
{
 r9 = 0;
 r10 = (r1 + 4)|0;
 r9 = (r9 - r10)|0;
 r9 = r9 & 15;
 r9 = (r1 + r9)|0;
 r10 = (r9 + 4)|0;
 r9 = r9 >> 2;
 heap32[(r9)] = r1;
 r1 = r10;
}
}
else{
 heap32[(r7+2)] = 0;
}
 r9 = r1 >> 2;
 heap32[(r9+8)] = 0;
 heap32[(r9+9)] = r4;
 heap32[(r9+10)] = 0;
 heap32[(r9)] = heap32[(fp+-8)];
 heap32[(r9+1)] = heap32[(r2+1)];
 heap32[(r9+2)] = heap32[(r2+2)];
 heap32[(r9+3)] = heap32[(r2+3)];
 heapFloat[(r9+4)] = f4;
 heapFloat[(r9+5)] = f5;
 heapFloat[(r9+6)] = f6;
 heapFloat[(r9+7)] = f7;
 r2 = heap32[(r7+1)];
 heap32[(g0)] = r8;
 heap32[(g0+1)] = r2;
 heap32[(g0+2)] = r1;
 _ZL10insertleafP6btDbvtP10btDbvtNodeS2_(i7);
 r2 = heap32[(r7+4)];
 r2 = (r2 + 1)|0;
 r8 = 1;
 heap32[(r7+4)] = r2;
 heap32[(r6+12)] = r1;
}
} while(0);
 r1 = heap32[(r6+13)];
 r2 = heap32[(r6+14)];
 if(r1 ==0) //_LBB109_35
{
 r1 = heap32[(r6+15)];
 r1 = r1 << 2;
 r1 = (r5 + r1)|0;
 r1 = r1 >> 2;
 heap32[(r1+21)] = r2;
}
else{
 r1 = r1 >> 2;
 heap32[(r1+14)] = r2;
}
 r1 = heap32[(r6+14)];
if(!(r1 ==0)) //_LBB109_38
{
 r1 = r1 >> 2;
 r2 = heap32[(r6+13)];
 heap32[(r1+13)] = r2;
}
 heap32[(r6+4)] = heap32[(r0)];
 heap32[(r6+5)] = heap32[(r0+1)];
 heap32[(r6+6)] = heap32[(r0+2)];
 heap32[(r6+7)] = heap32[(r0+3)];
 heap32[(r6+8)] = heap32[(r3)];
 heap32[(r6+9)] = heap32[(r3+1)];
 heap32[(r6+10)] = heap32[(r3+2)];
 r0 = r5 >> 2;
 heap32[(r6+11)] = heap32[(r3+3)];
 r1 = heap32[(r0+26)];
 heap32[(r6+15)] = r1;
 r1 = heap32[(r0+26)];
 r1 = r1 << 2;
 r1 = (r5 + r1)|0;
 r1 = r1 >> 2;
 heap32[(r6+13)] = 0;
 r2 = heap32[(r1+21)];
 heap32[(r6+14)] = r2;
 r2 = heap32[(r1+21)];
if(!(r2 ==0)) //_LBB109_40
{
 r2 = r2 >> 2;
 heap32[(r2+13)] = r4;
}
 r2 = r8 & 1;
 heap32[(r1+21)] = r4;
if(!(r2 ==0)) //_LBB109_43
{
 r1 = 1;
 heap8[r5+154] = r1;
 r1 = heapU8[r5+153];
if(!(r1 !=0)) //_LBB109_43
{
 r1 = _ZTV18btDbvtTreeCollider;
 r2 = sp + -64;
 r1 = (r1 + 8)|0;
 r3 = r2 >> 2;
 heap32[(fp+-16)] = r1;
 heap32[(r3+1)] = r5;
 r1 = heap32[(r6+12)];
 r3 = heap32[(r0+11)];
 r4 = (r5 + 44)|0;
 heap32[(g0)] = r4;
 heap32[(g0+1)] = r3;
 heap32[(g0+2)] = r1;
 heap32[(g0+3)] = r2;
 _ZN6btDbvt24collideTTpersistentStackEPK10btDbvtNodeS2_RNS_8ICollideE(i7);
 r1 = heap32[(r6+12)];
 r0 = heap32[(r0+1)];
 r3 = (r5 + 4)|0;
 heap32[(g0)] = r3;
 heap32[(g0+1)] = r0;
 heap32[(g0+2)] = r1;
 heap32[(g0+3)] = r2;
 _ZN6btDbvt24collideTTpersistentStackEPK10btDbvtNodeS2_RNS_8ICollideE(i7);
}
}
 return;
}

function _ZN16btDbvtBroadphaseD0Ev(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
 var r1;
 var r2;
 var r3;
 var r4;
 var r5;
 var r6;
 var r7;
var __label__ = 0;
 i7 = sp + -8;var g0 = i7>>2; // save stack
 r0 = heap32[(fp)];
 r1 = _ZTV16btDbvtBroadphase;
 r2 = r0 >> 2;
 r1 = (r1 + 8)|0;
 heap32[(r2)] = r1;
 r1 = heapU8[r0+152];
if(!(r1 ==0)) //_LBB110_3
{
 r1 = heap32[(r2+24)];
 r3 = r1 >> 2;
 r3 = heap32[(r3)];
 r3 = r3 >> 2;
 r3 = heap32[(r3)];
 heap32[(g0)] = r1;
 __FUNCTION_TABLE__[(r3)>>2](i7);
 r1 = heap32[(r2+24)];
if(!(r1 ==0)) //_LBB110_3
{
 r2 = gNumAlignedFree;
 r2 = r2 >> 2;
 r3 = heap32[(r2)];
 r3 = (r3 + 1)|0;
 r1 = r1 >> 2;
 heap32[(r2)] = r3;
 r1 = heap32[(r1+-1)];
 heap32[(g0)] = r1;
 free(i7);
}
}
 r1 = (r0 + 4)|0;
if(!(r1 ==0)) //_LBB110_15
{
 r2 = (r1 + 80)|0;
if(!(r2 ==r1)) //_LBB110_15
{
 r1 = (r0 + 44)|0;
 r2 = 0;
_8: while(true){
 r3 = (r0 + r2)|0;
 r4 = r3 >> 2;
 r5 = heap32[(r4+11)];
if(!(r5 ==0)) //_LBB110_8
{
 r6 = (r1 + r2)|0;
 heap32[(g0)] = r6;
 heap32[(g0+1)] = r5;
 _ZL17recursedeletenodeP6btDbvtP10btDbvtNode(i7);
}
 r5 = heap32[(r4+12)];
if(!(r5 ==0)) //_LBB110_10
{
 r6 = gNumAlignedFree;
 r6 = r6 >> 2;
 r7 = heap32[(r6)];
 r7 = (r7 + 1)|0;
 r5 = r5 >> 2;
 heap32[(r6)] = r7;
 r5 = heap32[(r5+-1)];
 heap32[(g0)] = r5;
 free(i7);
}
 heap32[(r4+12)] = 0;
 heap32[(r4+13)] = -1;
 r5 = heap32[(r4+19)];
if(!(r5 ==0)) //_LBB110_14
{
 r6 = heapU8[r3+80];
if(!(r6 ==0)) //_LBB110_13
{
 r6 = gNumAlignedFree;
 r6 = r6 >> 2;
 r7 = heap32[(r6)];
 r7 = (r7 + 1)|0;
 r5 = r5 >> 2;
 heap32[(r6)] = r7;
 r5 = heap32[(r5+-1)];
 heap32[(g0)] = r5;
 free(i7);
}
 heap32[(r4+19)] = 0;
}
 r5 = 1;
 heap32[(r4+15)] = 0;
 heap8[r3+80] = r5;
 heap32[(r4+19)] = 0;
 r2 = (r2 + -40)|0;
 heap32[(r4+17)] = 0;
 heap32[(r4+18)] = 0;
 if(r2 !=-80) //_LBB110_6
{
continue _8;
}
else{
break _8;
}
}
}
}
 heap32[(g0)] = r0;
 _ZdlPv(i7);
 return;
}

function _ZN16btDbvtBroadphaseD1Ev(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
 var r1;
 var r2;
 var r3;
 var r4;
 var r5;
 var r6;
 var r7;
var __label__ = 0;
 i7 = sp + -8;var g0 = i7>>2; // save stack
 r0 = heap32[(fp)];
 r1 = _ZTV16btDbvtBroadphase;
 r2 = r0 >> 2;
 r1 = (r1 + 8)|0;
 heap32[(r2)] = r1;
 r1 = heapU8[r0+152];
if(!(r1 ==0)) //_LBB111_3
{
 r1 = heap32[(r2+24)];
 r3 = r1 >> 2;
 r3 = heap32[(r3)];
 r3 = r3 >> 2;
 r3 = heap32[(r3)];
 heap32[(g0)] = r1;
 __FUNCTION_TABLE__[(r3)>>2](i7);
 r1 = heap32[(r2+24)];
if(!(r1 ==0)) //_LBB111_3
{
 r2 = gNumAlignedFree;
 r2 = r2 >> 2;
 r3 = heap32[(r2)];
 r3 = (r3 + 1)|0;
 r1 = r1 >> 2;
 heap32[(r2)] = r3;
 r1 = heap32[(r1+-1)];
 heap32[(g0)] = r1;
 free(i7);
}
}
 r1 = (r0 + 4)|0;
if(!(r1 ==0)) //_LBB111_15
{
 r2 = (r1 + 80)|0;
if(!(r2 ==r1)) //_LBB111_15
{
 r1 = (r0 + 44)|0;
 r2 = 0;
_8: while(true){
 r3 = (r0 + r2)|0;
 r4 = r3 >> 2;
 r5 = heap32[(r4+11)];
if(!(r5 ==0)) //_LBB111_8
{
 r6 = (r1 + r2)|0;
 heap32[(g0)] = r6;
 heap32[(g0+1)] = r5;
 _ZL17recursedeletenodeP6btDbvtP10btDbvtNode(i7);
}
 r5 = heap32[(r4+12)];
if(!(r5 ==0)) //_LBB111_10
{
 r6 = gNumAlignedFree;
 r6 = r6 >> 2;
 r7 = heap32[(r6)];
 r7 = (r7 + 1)|0;
 r5 = r5 >> 2;
 heap32[(r6)] = r7;
 r5 = heap32[(r5+-1)];
 heap32[(g0)] = r5;
 free(i7);
}
 heap32[(r4+12)] = 0;
 heap32[(r4+13)] = -1;
 r5 = heap32[(r4+19)];
if(!(r5 ==0)) //_LBB111_14
{
 r6 = heapU8[r3+80];
if(!(r6 ==0)) //_LBB111_13
{
 r6 = gNumAlignedFree;
 r6 = r6 >> 2;
 r7 = heap32[(r6)];
 r7 = (r7 + 1)|0;
 r5 = r5 >> 2;
 heap32[(r6)] = r7;
 r5 = heap32[(r5+-1)];
 heap32[(g0)] = r5;
 free(i7);
}
 heap32[(r4+19)] = 0;
}
 r5 = 1;
 heap32[(r4+15)] = 0;
 heap8[r3+80] = r5;
 heap32[(r4+19)] = 0;
 r2 = (r2 + -40)|0;
 heap32[(r4+17)] = 0;
 heap32[(r4+18)] = 0;
 if(r2 !=-80) //_LBB111_6
{
continue _8;
}
else{
break _8;
}
}
}
}
 return;
}

function _ZN12btDispatcherD0Ev(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
 var r1;
 var r2;
var __label__ = 0;
 i7 = sp + -8;var g0 = i7>>2; // save stack
 r0 = heap32[(fp)];
 r1 = _ZTV12btDispatcher;
 r2 = r0 >> 2;
 r1 = (r1 + 8)|0;
 heap32[(r2)] = r1;
 heap32[(g0)] = r0;
 _ZdlPv(i7);
 return;
}

function _ZN12btDispatcherD1Ev(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
 var r1;
var __label__ = 0;
 i7 = sp + 0;var g0 = i7>>2; // save stack
 r0 = heap32[(fp)];
 r1 = _ZTV12btDispatcher;
 r0 = r0 >> 2;
 r1 = (r1 + 8)|0;
 heap32[(r0)] = r1;
 return;
}

function _ZNK14btQuantizedBvh8quantizeEPtRK9btVector3i(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
 var r1;
 var r2;
 var r3;
 var f0;
 var f1;
 var f2;
 var f3;
 var f4;
 var f5;
var __label__ = 0;
 i7 = sp + -16;var g0 = i7>>2; // save stack
 r0 = heap32[(fp)];
 r1 = heapU8[r0+60];
 if(r1 !=0) //_LBB114_2
{
 r1 = heap32[(fp+2)];
 r1 = r1 >> 2;
 f0 = heapFloat[(r1)];
 r0 = r0 >> 2;
 f1 = heapFloat[(r0+5)];
 if(f0 <=f1) //_LBB114_4
{
 f1 = heapFloat[(r1+1)];
 f2 = heapFloat[(r0+6)];
 if(f1 <=f2) //_LBB114_6
{
 f2 = heapFloat[(r1+2)];
 f3 = heapFloat[(r0+7)];
 if(f2 <=f3) //_LBB114_8
{
 f3 = heapFloat[(r0+1)];
 if(f0 >=f3) //_LBB114_10
{
 f4 = heapFloat[(r0+2)];
 if(f1 >=f4) //_LBB114_12
{
 f5 = heapFloat[(r0+3)];
 if(f2 >=f5) //_LBB114_14
{
 r1 = heap32[(fp+1)];
 r2 = heap32[(fp+3)];
 f2 = f2-f5;
 f5 = heapFloat[(r0+11)];
 f1 = f1-f4;
 f4 = heapFloat[(r0+10)];
 f0 = f0-f3;
 f3 = heapFloat[(r0+9)];
 f2 = f2*f5;
 f1 = f1*f4;
 f0 = f0*f3;
 if(r2 ==0) //_LBB114_16
{
 r0 = Math.floor(f0);
 r2 = Math.floor(f1);
 r0 = r0 & 65534;
 r3 = Math.floor(f2);
 r2 = r2 & 65534;
 heap16[(r1)>>1] = r0;
 r0 = r3 & 65534;
}
else{
 f3 =                         1;
 f0 = f0+f3;
 f1 = f1+f3;
 r0 = Math.floor(f0);
 f0 = f2+f3;
 r2 = Math.floor(f1);
 r0 = r0 | 1;
 r3 = Math.floor(f0);
 r2 = r2 | 1;
 heap16[(r1)>>1] = r0;
 r0 = r3 | 1;
}
 heap16[(r1+2)>>1] = r2;
 heap16[(r1+4)>>1] = r0;
 return;
}
else{
 r0 = _2E_str9;
 r1 = _2E_str313;
 heap32[(g0)] = r0;
 heap32[(g0+1)] = r1;
 heap32[(g0+2)] = 361;
 _assert(i7);
}
}
else{
 r0 = _2E_str820;
 r1 = _2E_str313;
 heap32[(g0)] = r0;
 heap32[(g0+1)] = r1;
 heap32[(g0+2)] = 360;
 _assert(i7);
}
}
else{
 r0 = _2E_str717;
 r1 = _2E_str313;
 heap32[(g0)] = r0;
 heap32[(g0+1)] = r1;
 heap32[(g0+2)] = 359;
 _assert(i7);
}
}
else{
 r0 = _2E_str616;
 r1 = _2E_str313;
 heap32[(g0)] = r0;
 heap32[(g0+1)] = r1;
 heap32[(g0+2)] = 357;
 _assert(i7);
}
}
else{
 r0 = _2E_str515;
 r1 = _2E_str313;
 heap32[(g0)] = r0;
 heap32[(g0+1)] = r1;
 heap32[(g0+2)] = 356;
 _assert(i7);
}
}
else{
 r0 = _2E_str414;
 r1 = _2E_str313;
 heap32[(g0)] = r0;
 heap32[(g0+1)] = r1;
 heap32[(g0+2)] = 355;
 _assert(i7);
}
}
else{
 r0 = _2E_str212;
 r1 = _2E_str313;
 heap32[(g0)] = r0;
 heap32[(g0+1)] = r1;
 heap32[(g0+2)] = 353;
 _assert(i7);
}
}

function _ZN20btAlignedObjectArrayI18btQuantizedBvhNodeE7reserveEi(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
 var r1;
 var r2;
 var r3;
 var r4;
 var r5;
 var r6;
 var r7;
 var r8;
 var r9;
 var r10;
var __label__ = 0;
 i7 = sp + -8;var g0 = i7>>2; // save stack
 r0 = heap32[(fp)];
 r1 = heap32[(fp+1)];
 r2 = r0 >> 2;
 r3 = heap32[(r2+2)];
if(!(r3 >=r1)) //_LBB115_16
{
 if(r1 !=0) //_LBB115_3
{
 r3 = gNumAlignedAllocs;
 r3 = r3 >> 2;
 r4 = heap32[(r3)];
 r5 = r1 << 4;
 r4 = (r4 + 1)|0;
 r5 = r5 | 3;
 heap32[(r3)] = r4;
 r3 = (r5 + 16)|0;
 heap32[(g0)] = r3;
 malloc(i7);
 r3 = r_g0;
 if(r3 !=0) //_LBB115_5
{
 r4 = 0;
 r5 = (r3 + 4)|0;
 r4 = (r4 - r5)|0;
 r4 = r4 & 15;
 r4 = (r3 + r4)|0;
 r5 = (r4 + 4)|0;
 r4 = r4 >> 2;
 heap32[(r4)] = r3;
 r3 = r5;
}
}
else{
 r3 = 0;
}
 r4 = heap32[(r2+1)];
 r5 = (r0 + 12)|0;
 if(r4 <1) //_LBB115_8
{
 r4 = r5 >> 2;
 r7 = heap32[(r4)];
}
else{
 r6 = 0;
_11: while(true){
 r7 = r5 >> 2;
 r7 = heap32[(r7)];
 r8 = r6 << 4;
 r9 = heapU16[(r7+r8)>>1];
 r10 = (r7 + r8)|0;
 heap16[(r3+r8)>>1] = r9;
 r8 = (r3 + r8)|0;
 r9 = heapU16[(r10+2)>>1];
 heap16[(r8+2)>>1] = r9;
 r9 = heapU16[(r10+4)>>1];
 heap16[(r8+4)>>1] = r9;
 r9 = heapU16[(r10+6)>>1];
 heap16[(r8+6)>>1] = r9;
 r9 = heapU16[(r10+8)>>1];
 heap16[(r8+8)>>1] = r9;
 r9 = heapU16[(r10+10)>>1];
 r10 = r10 >> 2;
 heap16[(r8+10)>>1] = r9;
 r6 = (r6 + 1)|0;
 r8 = r8 >> 2;
 r9 = heap32[(r10+3)];
 heap32[(r8+3)] = r9;
if(!(r4 !=r6)) //_LBB115_9
{
break _11;
}
}
 r5 = (r0 + 12)|0;
}
if(!(r7 ==0)) //_LBB115_15
{
 r4 = heapU8[r0+16];
if(!(r4 ==0)) //_LBB115_14
{
 r4 = gNumAlignedFree;
 r4 = r4 >> 2;
 r6 = heap32[(r4)];
 r6 = (r6 + 1)|0;
 r7 = r7 >> 2;
 heap32[(r4)] = r6;
 r4 = heap32[(r7+-1)];
 heap32[(g0)] = r4;
 free(i7);
}
 r4 = r5 >> 2;
 heap32[(r4)] = 0;
}
 r4 = 1;
 r5 = r5 >> 2;
 heap8[r0+16] = r4;
 heap32[(r5)] = r3;
 heap32[(r2+2)] = r1;
}
 return;
}

function _ZN28btHashedOverlappingPairCache23getOverlappingPairArrayEv(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
var __label__ = 0;
 i7 = sp + 0;var g0 = i7>>2; // save stack
 r0 = heap32[(fp)];
 r0 = (r0 + 4)|0;
 r_g0 = r0;
 return;
}

function _ZN28btHashedOverlappingPairCache24setOverlapFilterCallbackEP23btOverlapFilterCallback(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
 var r1;
var __label__ = 0;
 i7 = sp + 0;var g0 = i7>>2; // save stack
 r0 = heap32[(fp)];
 r0 = r0 >> 2;
 r1 = heap32[(fp+1)];
 heap32[(r0+6)] = r1;
 return;
}

function _ZN28btHashedOverlappingPairCache18hasDeferredRemovalEv(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
var __label__ = 0;
 i7 = sp + 0;var g0 = i7>>2; // save stack
 r0 = 0;
 r_g0 = r0;
 return;
}

function _ZN28btHashedOverlappingPairCache28setInternalGhostPairCallbackEP25btOverlappingPairCallback(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
 var r1;
var __label__ = 0;
 i7 = sp + 0;var g0 = i7>>2; // save stack
 r0 = heap32[(fp)];
 r0 = r0 >> 2;
 r1 = heap32[(fp+1)];
 heap32[(r0+18)] = r1;
 return;
}

function _ZN28btHashedOverlappingPairCache20cleanOverlappingPairER16btBroadphasePairP12btDispatcher(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
 var r1;
 var r2;
 var r3;
var __label__ = 0;
 i7 = sp + -8;var g0 = i7>>2; // save stack
 r0 = heap32[(fp+1)];
 r0 = r0 >> 2;
 r1 = heap32[(r0+2)];
if(!(r1 ==0)) //_LBB120_2
{
 r2 = heap32[(fp+2)];
 r3 = r1 >> 2;
 r3 = heap32[(r3)];
 r3 = r3 >> 2;
 r3 = heap32[(r3)];
 heap32[(g0)] = r1;
 __FUNCTION_TABLE__[(r3)>>2](i7);
 r1 = r2 >> 2;
 r1 = heap32[(r1)];
 r1 = r1 >> 2;
 r1 = heap32[(r1+13)];
 r3 = heap32[(r0+2)];
 heap32[(g0)] = r2;
 heap32[(g0+1)] = r3;
 __FUNCTION_TABLE__[(r1)>>2](i7);
 heap32[(r0+2)] = 0;
}
 return;
}

function _ZZN28btHashedOverlappingPairCache19cleanProxyFromPairsEP17btBroadphaseProxyP12btDispatcherEN17CleanPairCallbackD1Ev(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
 var r1;
var __label__ = 0;
 i7 = sp + 0;var g0 = i7>>2; // save stack
 r0 = heap32[(fp)];
 r1 = _ZTVZN28btHashedOverlappingPairCache19cleanProxyFromPairsEP17btBroadphaseProxyP12btDispatcherE17CleanPairCallback;
 r0 = r0 >> 2;
 r1 = (r1 + 8)|0;
 heap32[(r0)] = r1;
 return;
}

function _ZZN28btHashedOverlappingPairCache19cleanProxyFromPairsEP17btBroadphaseProxyP12btDispatcherEN17CleanPairCallbackD0Ev(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
 var r1;
 var r2;
var __label__ = 0;
 i7 = sp + -8;var g0 = i7>>2; // save stack
 r0 = heap32[(fp)];
 r1 = _ZTVZN28btHashedOverlappingPairCache19cleanProxyFromPairsEP17btBroadphaseProxyP12btDispatcherE17CleanPairCallback;
 r2 = r0 >> 2;
 r1 = (r1 + 8)|0;
 heap32[(r2)] = r1;
 heap32[(g0)] = r0;
 _ZdlPv(i7);
 return;
}

function _ZZN28btHashedOverlappingPairCache19cleanProxyFromPairsEP17btBroadphaseProxyP12btDispatcherEN17CleanPairCallback14processOverlapER16btBroadphasePair(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
 var r1;
 var r2;
 var r3;
 var r4;
var __label__ = 0;
 i7 = sp + -16;var g0 = i7>>2; // save stack
 r0 = heap32[(fp)];
 r0 = r0 >> 2;
 r1 = heap32[(fp+1)];
 r2 = heap32[(r0+1)];
 r3 = r1 >> 2;
 r4 = heap32[(r3)];
 if(r4 ==r2) //_LBB123_2
{
__label__ = 2;
}
else{
 r3 = heap32[(r3+1)];
 if(r3 !=r2) //_LBB123_3
{
__label__ = 3;
}
else{
__label__ = 2;
}
}
if (__label__ == 2){
 r2 = heap32[(r0+2)];
 r3 = r2 >> 2;
 r3 = heap32[(r3)];
 r3 = r3 >> 2;
 r3 = heap32[(r3+8)];
 r0 = heap32[(r0+3)];
 heap32[(g0)] = r2;
 heap32[(g0+1)] = r1;
 heap32[(g0+2)] = r0;
 __FUNCTION_TABLE__[(r3)>>2](i7);
}
 r0 = 0;
 r_g0 = r0;
 return;
}

function _ZZN28btHashedOverlappingPairCache37removeOverlappingPairsContainingProxyEP17btBroadphaseProxyP12btDispatcherEN18RemovePairCallbackD1Ev(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
 var r1;
var __label__ = 0;
 i7 = sp + 0;var g0 = i7>>2; // save stack
 r0 = heap32[(fp)];
 r1 = _ZTVZN28btHashedOverlappingPairCache37removeOverlappingPairsContainingProxyEP17btBroadphaseProxyP12btDispatcherE18RemovePairCallback;
 r0 = r0 >> 2;
 r1 = (r1 + 8)|0;
 heap32[(r0)] = r1;
 return;
}

function _ZZN28btHashedOverlappingPairCache37removeOverlappingPairsContainingProxyEP17btBroadphaseProxyP12btDispatcherEN18RemovePairCallbackD0Ev(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
 var r1;
 var r2;
var __label__ = 0;
 i7 = sp + -8;var g0 = i7>>2; // save stack
 r0 = heap32[(fp)];
 r1 = _ZTVZN28btHashedOverlappingPairCache37removeOverlappingPairsContainingProxyEP17btBroadphaseProxyP12btDispatcherE18RemovePairCallback;
 r2 = r0 >> 2;
 r1 = (r1 + 8)|0;
 heap32[(r2)] = r1;
 heap32[(g0)] = r0;
 _ZdlPv(i7);
 return;
}

function _ZZN28btHashedOverlappingPairCache37removeOverlappingPairsContainingProxyEP17btBroadphaseProxyP12btDispatcherEN18RemovePairCallback14processOverlapER16btBroadphasePair(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
 var r1;
 var r2;
var __label__ = 0;
 i7 = sp + 0;var g0 = i7>>2; // save stack
 r0 = heap32[(fp)];
 r0 = r0 >> 2;
 r1 = heap32[(fp+1)];
 r0 = heap32[(r0+1)];
 r1 = r1 >> 2;
 r2 = heap32[(r1)];
 if(r2 ==r0) //_LBB126_2
{
 r0 = 1;
 r_g0 = r0;
 return;
}
else{
 r1 = heap32[(r1+1)];
 r0 = r1 == r0;
 r0 = r0 & 1;
 r_g0 = r0;
 return;
}
}

function _ZN28btHashedOverlappingPairCache26getOverlappingPairArrayPtrEv(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
var __label__ = 0;
 i7 = sp + 0;var g0 = i7>>2; // save stack
 r0 = heap32[(fp)];
 r0 = r0 >> 2;
 r0 = heap32[(r0+4)];
 r_g0 = r0;
 return;
}

function _ZNK28btHashedOverlappingPairCache26getOverlappingPairArrayPtrEv(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
var __label__ = 0;
 i7 = sp + 0;var g0 = i7>>2; // save stack
 r0 = heap32[(fp)];
 r0 = r0 >> 2;
 r0 = heap32[(r0+4)];
 r_g0 = r0;
 return;
}

function _ZNK28btHashedOverlappingPairCache22getNumOverlappingPairsEv(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
var __label__ = 0;
 i7 = sp + 0;var g0 = i7>>2; // save stack
 r0 = heap32[(fp)];
 r0 = r0 >> 2;
 r0 = heap32[(r0+2)];
 r_g0 = r0;
 return;
}

function _ZN28btHashedOverlappingPairCache26processAllOverlappingPairsEP17btOverlapCallbackP12btDispatcher(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
 var r1;
 var r2;
 var r3;
 var r4;
 var r5;
 var r6;
 var r7;
 var r8;
 var r9;
var __label__ = 0;
 i7 = sp + -16;var g0 = i7>>2; // save stack
 r0 = heap32[(fp)];
 r1 = heap32[(fp+1)];
 r2 = heap32[(fp+2)];
 r3 = 0;
 r4 = r3;
_1: while(true){
 r5 = r4 << 2;
_3: while(true){
 r6 = r0 >> 2;
 r7 = heap32[(r6+2)];
 if(r7 >r4) //_LBB130_1
{
 r7 = r1 >> 2;
 r7 = heap32[(r7)];
 r7 = r7 >> 2;
 r8 = heap32[(r6+4)];
 r7 = heap32[(r7+2)];
 r9 = (r8 + r3)|0;
 heap32[(g0)] = r1;
 heap32[(g0+1)] = r9;
 __FUNCTION_TABLE__[(r7)>>2](i7);
 r7 = r_g0;
 if(r7 ==0) //_LBB130_3
{
break _3;
}
else{
 r7 = r5 << 2;
 r6 = heap32[(r6)];
 r7 = (r8 + r7)|0;
 r7 = r7 >> 2;
 r6 = r6 >> 2;
 r6 = heap32[(r6+3)];
 r8 = heap32[(r7+1)];
 r7 = heap32[(r7)];
 heap32[(g0)] = r0;
 heap32[(g0+1)] = r7;
 heap32[(g0+2)] = r8;
 heap32[(g0+3)] = r2;
 r7 = gOverlappingPairs;
 r7 = r7 >> 2;
 __FUNCTION_TABLE__[(r6)>>2](i7);
 r6 = heap32[(r7)];
 r6 = (r6 + -1)|0;
 heap32[(r7)] = r6;
continue _3;
}
}
else{
break _1;
}
}
 r4 = (r4 + 1)|0;
 r3 = (r3 + 16)|0;
continue _1;
}
 return;
}

function _ZN28btHashedOverlappingPairCache37removeOverlappingPairsContainingProxyEP17btBroadphaseProxyP12btDispatcher(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
 var r1;
 var r2;
 var r3;
 var r4;
var __label__ = 0;
 i7 = sp + -24;var g0 = i7>>2; // save stack
 r0 = _ZTVZN28btHashedOverlappingPairCache37removeOverlappingPairsContainingProxyEP17btBroadphaseProxyP12btDispatcherE18RemovePairCallback;
 r1 = sp + -8;
 r0 = (r0 + 8)|0;
 r2 = heap32[(fp)];
 r3 = r1 >> 2;
 r4 = heap32[(fp+1)];
 heap32[(fp+-2)] = r0;
 r0 = r2 >> 2;
 heap32[(r3+1)] = r4;
 r0 = heap32[(r0)];
 r0 = r0 >> 2;
 r0 = heap32[(r0+12)];
 r3 = heap32[(fp+2)];
 heap32[(g0)] = r2;
 heap32[(g0+1)] = r1;
 heap32[(g0+2)] = r3;
 __FUNCTION_TABLE__[(r0)>>2](i7);
 return;
}

function _ZN28btHashedOverlappingPairCache19cleanProxyFromPairsEP17btBroadphaseProxyP12btDispatcher(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
 var r1;
 var r2;
 var r3;
 var r4;
var __label__ = 0;
 i7 = sp + -32;var g0 = i7>>2; // save stack
 r0 = _ZTVZN28btHashedOverlappingPairCache19cleanProxyFromPairsEP17btBroadphaseProxyP12btDispatcherE17CleanPairCallback;
 r1 = sp + -16;
 r0 = (r0 + 8)|0;
 r2 = r1 >> 2;
 r3 = heap32[(fp+1)];
 heap32[(fp+-4)] = r0;
 r0 = heap32[(fp)];
 heap32[(r2+1)] = r3;
 r3 = heap32[(fp+2)];
 heap32[(r2+2)] = r0;
 r4 = r0 >> 2;
 heap32[(r2+3)] = r3;
 r2 = heap32[(r4)];
 r2 = r2 >> 2;
 r2 = heap32[(r2+12)];
 heap32[(g0)] = r0;
 heap32[(g0+1)] = r1;
 heap32[(g0+2)] = r3;
 __FUNCTION_TABLE__[(r2)>>2](i7);
 return;
}

function _ZN28btHashedOverlappingPairCacheD0Ev(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
 var r1;
 var r2;
 var r3;
 var r4;
 var r5;
var __label__ = 0;
 i7 = sp + -8;var g0 = i7>>2; // save stack
 r0 = heap32[(fp)];
 r1 = _ZTV28btHashedOverlappingPairCache;
 r2 = r0 >> 2;
 r1 = (r1 + 8)|0;
 heap32[(r2)] = r1;
 r1 = heap32[(r2+16)];
if(!(r1 ==0)) //_LBB133_4
{
 r3 = heapU8[r0+68];
if(!(r3 ==0)) //_LBB133_3
{
 r3 = gNumAlignedFree;
 r3 = r3 >> 2;
 r4 = heap32[(r3)];
 r4 = (r4 + 1)|0;
 r1 = r1 >> 2;
 heap32[(r3)] = r4;
 r1 = heap32[(r1+-1)];
 heap32[(g0)] = r1;
 free(i7);
}
 heap32[(r2+16)] = 0;
}
 r1 = 1;
 heap8[r0+68] = r1;
 heap32[(r2+16)] = 0;
 heap32[(r2+14)] = 0;
 heap32[(r2+15)] = 0;
 r3 = heap32[(r2+11)];
if(!(r3 ==0)) //_LBB133_8
{
 r4 = heapU8[r0+48];
if(!(r4 ==0)) //_LBB133_7
{
 r4 = gNumAlignedFree;
 r4 = r4 >> 2;
 r5 = heap32[(r4)];
 r5 = (r5 + 1)|0;
 r3 = r3 >> 2;
 heap32[(r4)] = r5;
 r3 = heap32[(r3+-1)];
 heap32[(g0)] = r3;
 free(i7);
}
 heap32[(r2+11)] = 0;
}
 heap8[r0+48] = r1;
 heap32[(r2+11)] = 0;
 heap32[(r2+9)] = 0;
 heap32[(r2+10)] = 0;
 r3 = heap32[(r2+4)];
if(!(r3 ==0)) //_LBB133_12
{
 r4 = heapU8[r0+20];
if(!(r4 ==0)) //_LBB133_11
{
 r4 = gNumAlignedFree;
 r4 = r4 >> 2;
 r5 = heap32[(r4)];
 r5 = (r5 + 1)|0;
 r3 = r3 >> 2;
 heap32[(r4)] = r5;
 r3 = heap32[(r3+-1)];
 heap32[(g0)] = r3;
 free(i7);
}
 heap32[(r2+4)] = 0;
}
 heap8[r0+20] = r1;
 heap32[(r2+4)] = 0;
 heap32[(r2+2)] = 0;
 heap32[(r2+3)] = 0;
 heap32[(g0)] = r0;
 _ZdlPv(i7);
 return;
}

function _ZN28btHashedOverlappingPairCacheD1Ev(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
 var r1;
 var r2;
 var r3;
 var r4;
 var r5;
var __label__ = 0;
 i7 = sp + -8;var g0 = i7>>2; // save stack
 r0 = heap32[(fp)];
 r1 = _ZTV28btHashedOverlappingPairCache;
 r2 = r0 >> 2;
 r1 = (r1 + 8)|0;
 heap32[(r2)] = r1;
 r1 = heap32[(r2+16)];
if(!(r1 ==0)) //_LBB134_4
{
 r3 = heapU8[r0+68];
if(!(r3 ==0)) //_LBB134_3
{
 r3 = gNumAlignedFree;
 r3 = r3 >> 2;
 r4 = heap32[(r3)];
 r4 = (r4 + 1)|0;
 r1 = r1 >> 2;
 heap32[(r3)] = r4;
 r1 = heap32[(r1+-1)];
 heap32[(g0)] = r1;
 free(i7);
}
 heap32[(r2+16)] = 0;
}
 r1 = 1;
 heap8[r0+68] = r1;
 heap32[(r2+16)] = 0;
 heap32[(r2+14)] = 0;
 heap32[(r2+15)] = 0;
 r3 = heap32[(r2+11)];
if(!(r3 ==0)) //_LBB134_8
{
 r4 = heapU8[r0+48];
if(!(r4 ==0)) //_LBB134_7
{
 r4 = gNumAlignedFree;
 r4 = r4 >> 2;
 r5 = heap32[(r4)];
 r5 = (r5 + 1)|0;
 r3 = r3 >> 2;
 heap32[(r4)] = r5;
 r3 = heap32[(r3+-1)];
 heap32[(g0)] = r3;
 free(i7);
}
 heap32[(r2+11)] = 0;
}
 heap8[r0+48] = r1;
 heap32[(r2+11)] = 0;
 heap32[(r2+9)] = 0;
 heap32[(r2+10)] = 0;
 r3 = heap32[(r2+4)];
if(!(r3 ==0)) //_LBB134_12
{
 r4 = heapU8[r0+20];
if(!(r4 ==0)) //_LBB134_11
{
 r4 = gNumAlignedFree;
 r4 = r4 >> 2;
 r5 = heap32[(r4)];
 r5 = (r5 + 1)|0;
 r3 = r3 >> 2;
 heap32[(r4)] = r5;
 r3 = heap32[(r3+-1)];
 heap32[(g0)] = r3;
 free(i7);
}
 heap32[(r2+4)] = 0;
}
 heap8[r0+20] = r1;
 heap32[(r2+4)] = 0;
 heap32[(r2+2)] = 0;
 heap32[(r2+3)] = 0;
 return;
}

function _ZN28btHashedOverlappingPairCache18addOverlappingPairEP17btBroadphaseProxyS1_(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
 var r1;
 var r2;
 var r3;
 var r4;
 var r5;
 var r6;
 var r7;
 var r8;
 var r9;
 var r10;
 var r11;
 var r12;
 var r13;
 var r14;
var __label__ = 0;
 i7 = sp + -16;var g0 = i7>>2; // save stack
 r0 = gAddedPairs;
 r0 = r0 >> 2;
 r1 = heap32[(r0)];
 r2 = heap32[(fp)];
 r1 = (r1 + 1)|0;
 r3 = r2 >> 2;
 heap32[(r0)] = r1;
 r0 = heap32[(r3+6)];
 r1 = heap32[(fp+1)];
 r4 = heap32[(fp+2)];
 if(r0 ==0) //_LBB135_2
{
 r0 = heapU16[(r4+6)>>1];
 r5 = heapU16[(r1+4)>>1];
 r0 = r0 & r5;
 r0 = r0 & 65535;
 if(r0 ==0) //_LBB135_25
{
__label__ = 23;
}
else{
 r0 = heapU16[(r1+6)>>1];
 r5 = heapU16[(r4+4)>>1];
 r0 = r0 & r5;
 r0 = r0 & 65535;
 r5 = 0;
 r0 = r0 != r5;
 r0 = r0 & 1;
__label__ = 4;
}
}
else{
 r5 = r0 >> 2;
 r5 = heap32[(r5)];
 r5 = r5 >> 2;
 r5 = heap32[(r5+2)];
 heap32[(g0)] = r0;
 heap32[(g0+1)] = r1;
 heap32[(g0+2)] = r4;
 __FUNCTION_TABLE__[(r5)>>2](i7);
 r0 = r_g0;
__label__ = 4;
}
if (__label__ == 4){
 r0 = r0 & 255;
if(!(r0 ==0)) //_LBB135_25
{
 r0 = r1 >> 2;
 r5 = r4 >> 2;
 r0 = heap32[(r0+3)];
 r5 = heap32[(r5+3)];
 r6 = r0 > r5 ? r1 : r4;
 r0 = r0 > r5 ? r4 : r1;
 r1 = r6 >> 2;
 r4 = heap32[(r1+3)];
 r5 = r0 >> 2;
 r7 = heap32[(r5+3)];
 r8 = r4 << 16;
 r8 = r8 | r7;
 r9 = r8 << 15;
 r9 = r9 ^ -1;
 r8 = (r8 + r9)|0;
 r9 = r8 >> 10;
 r8 = r9 ^ r8;
 r8 = (r8 * 9)|0;
 r9 = r8 >> 6;
 r8 = r9 ^ r8;
 r9 = r8 << 11;
 r9 = r9 ^ -1;
 r8 = (r8 + r9)|0;
 r9 = heap32[(r3+3)];
 r10 = r8 >> 16;
 r8 = r10 ^ r8;
 r10 = (r9 + -1)|0;
 r10 = r8 & r10;
 r11 = heap32[(r3+11)];
 r12 = r10 << 2;
 r11 = (r11 + r12)|0;
_8: while(true){
 r11 = r11 >> 2;
 r11 = heap32[(r11)];
 if(r11 ==-1) //_LBB135_14
{
__label__ = 13;
break _8;
}
else{
 r12 = heap32[(r3+4)];
 r13 = r11 << 4;
 r12 = (r12 + r13)|0;
 r13 = r12 >> 2;
 r14 = heap32[(r13)];
 r14 = r14 >> 2;
 r14 = heap32[(r14+3)];
if(!(r14 !=r7)) //_LBB135_6
{
 r13 = heap32[(r13+1)];
 r13 = r13 >> 2;
 r13 = heap32[(r13+3)];
if(!(r13 !=r4)) //_LBB135_6
{
__label__ = 10;
break _8;
}
}
 r12 = heap32[(r3+16)];
 r11 = r11 << 2;
 r11 = (r12 + r11)|0;
}
}
_14: do {
switch(__label__ ){//multiple entries
case 13:
 r4 = heap32[(r3+2)];
__label__ = 14;
break _14;
break;
case 10:
 r4 = heap32[(r3+2)];
 if(r4 >r11) //_LBB135_12
{
 if(r12 !=0) //_LBB135_24
{
__label__ = 22;
}
else{
__label__ = 14;
}
}
else{
 r0 = _2E_str222;
 r1 = _2E_str323;
 heap32[(g0)] = r0;
 heap32[(g0+1)] = r1;
 heap32[(g0+2)] = 250;
 _assert(i7);
}
break;
}
} while(0);
if (__label__ == 14){
 r12 = (r2 + 4)|0;
 heap32[(g0)] = r12;
 _ZN20btAlignedObjectArrayI16btBroadphasePairE21expandNonInitializingEv(i7);
 r12 = r_g0;
 r7 = heap32[(r3+18)];
if(!(r7 ==0)) //_LBB135_17
{
 r11 = r7 >> 2;
 r11 = heap32[(r11)];
 r11 = r11 >> 2;
 r11 = heap32[(r11+2)];
 heap32[(g0)] = r7;
 heap32[(g0+1)] = r0;
 heap32[(g0+2)] = r6;
 __FUNCTION_TABLE__[(r11)>>2](i7);
}
 r7 = heap32[(r3+3)];
 if(r9 <r7) //_LBB135_19
{
 heap32[(g0)] = r2;
 _ZN28btHashedOverlappingPairCache10growTablesEv(i7);
 r10 = heap32[(r3+3)];
 r10 = (r10 + -1)|0;
 r10 = r10 & r8;
}
 r2 = heap32[(r5+3)];
 r1 = heap32[(r1+3)];
 if(r2 >=r1) //_LBB135_22
{
 r1 = r12 >> 2;
 heap32[(r1)] = r6;
 heap32[(r1+1)] = r0;
}
else{
 r1 = r12 >> 2;
 heap32[(r1)] = r0;
 heap32[(r1+1)] = r6;
}
 r0 = r12 >> 2;
 heap32[(r0+2)] = 0;
 heap32[(r0+3)] = 0;
 r0 = r10 << 2;
 r1 = heap32[(r3+11)];
 r1 = (r1 + r0)|0;
 r1 = r1 >> 2;
 r2 = r4 << 2;
 r5 = heap32[(r3+16)];
 r2 = (r5 + r2)|0;
 r1 = heap32[(r1)];
 r2 = r2 >> 2;
 heap32[(r2)] = r1;
 r1 = heap32[(r3+11)];
 r0 = (r1 + r0)|0;
 r0 = r0 >> 2;
 heap32[(r0)] = r4;
}
 r_g0 = r12;
 return;
}
}
 r0 = 0;
 r_g0 = r0;
 return;
}

function _ZN28btHashedOverlappingPairCache21removeOverlappingPairEP17btBroadphaseProxyS1_P12btDispatcher(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
 var r1;
 var r2;
 var r3;
 var r4;
 var r5;
 var r6;
 var r7;
 var r8;
 var r9;
 var r10;
 var r11;
var __label__ = 0;
 i7 = sp + -16;var g0 = i7>>2; // save stack
 r0 = gRemovePairs;
 r0 = r0 >> 2;
 r1 = heap32[(r0)];
 r2 = heap32[(fp+2)];
 r3 = heap32[(fp+1)];
 r1 = (r1 + 1)|0;
 r4 = r3 >> 2;
 heap32[(r0)] = r1;
 r0 = r2 >> 2;
 r1 = heap32[(r4+3)];
 r0 = heap32[(r0+3)];
 r4 = r1 > r0 ? r3 : r2;
 r0 = r1 > r0 ? r2 : r3;
 r1 = r4 >> 2;
 r1 = heap32[(r1+3)];
 r2 = r0 >> 2;
 r2 = heap32[(r2+3)];
 r3 = r1 << 16;
 r3 = r3 | r2;
 r5 = r3 << 15;
 r5 = r5 ^ -1;
 r3 = (r3 + r5)|0;
 r5 = r3 >> 10;
 r3 = r5 ^ r3;
 r3 = (r3 * 9)|0;
 r5 = r3 >> 6;
 r3 = r5 ^ r3;
 r5 = r3 << 11;
 r6 = heap32[(fp)];
 r5 = r5 ^ -1;
 r7 = r6 >> 2;
 r3 = (r3 + r5)|0;
 r5 = r3 >> 16;
 r8 = heap32[(r7+3)];
 r3 = r5 ^ r3;
 r5 = (r8 + -1)|0;
 r3 = r3 & r5;
 r5 = heap32[(r7+11)];
 r3 = r3 << 2;
 r8 = heap32[(fp+3)];
 r5 = (r5 + r3)|0;
_1: while(true){
 r5 = r5 >> 2;
 r5 = heap32[(r5)];
 if(r5 ==-1) //_LBB136_35
{
__label__ = 33;
break _1;
}
else{
 r9 = heap32[(r7+4)];
 r10 = r5 << 4;
 r9 = (r9 + r10)|0;
 r10 = r9 >> 2;
 r11 = heap32[(r10)];
 r11 = r11 >> 2;
 r11 = heap32[(r11+3)];
if(!(r11 !=r2)) //_LBB136_1
{
 r11 = heap32[(r10+1)];
 r11 = r11 >> 2;
 r11 = heap32[(r11+3)];
if(!(r11 !=r1)) //_LBB136_1
{
__label__ = 5;
break _1;
}
}
 r9 = heap32[(r7+16)];
 r5 = r5 << 2;
 r5 = (r9 + r5)|0;
continue _1;
}
}
if (__label__ == 5){
 r11 = heap32[(r7+2)];
 if(r11 >r5) //_LBB136_7
{
if(!(r9 ==0)) //_LBB136_35
{
 r5 = heap32[(r7)];
 r5 = r5 >> 2;
 r5 = heap32[(r5+8)];
 heap32[(g0)] = r6;
 heap32[(g0+1)] = r9;
 heap32[(g0+2)] = r8;
 __FUNCTION_TABLE__[(r5)>>2](i7);
 r5 = heap32[(r10)];
 r5 = r5 >> 2;
 r5 = heap32[(r5+3)];
 if(r5 ==r2) //_LBB136_10
{
 r2 = heap32[(r10+1)];
 r2 = r2 >> 2;
 r2 = heap32[(r2+3)];
 if(r2 ==r1) //_LBB136_12
{
 r1 = heap32[(r7+4)];
 r1 = (r9 - r1)|0;
 r1 = r1 >> 4;
 r2 = heap32[(r7+2)];
 if(r2 >r1) //_LBB136_14
{
 r2 = heap32[(r7+11)];
 r2 = (r2 + r3)|0;
 r2 = r2 >> 2;
 r3 = heap32[(r2)];
 if(r3 ==-1) //_LBB136_17
{
 r0 = _2E_str727;
 r1 = _2E_str121;
 heap32[(g0)] = r0;
 heap32[(g0+1)] = r1;
 heap32[(g0+2)] = 304;
 _assert(i7);
}
else{
 r5 = heap32[(r10+3)];
 r6 = heap32[(r7+16)];
 if(r3 ==r1) //_LBB136_21
{
__label__ = 20;
}
else{
_22: while(true){
 r9 = r3;
 r3 = r9 << 2;
 r3 = (r6 + r3)|0;
 r10 = r3 >> 2;
 r3 = heap32[(r10)];
if(!(r3 !=r1)) //_LBB136_18
{
break _22;
}
}
 if(r9 ==-1) //_LBB136_21
{
__label__ = 20;
}
else{
 r2 = r1 << 2;
 r2 = (r6 + r2)|0;
 r2 = r2 >> 2;
 r2 = heap32[(r2)];
 heap32[(r10)] = r2;
__label__ = 21;
}
}
if (__label__ == 20){
 r3 = r1 << 2;
 r3 = (r6 + r3)|0;
 r3 = r3 >> 2;
 r3 = heap32[(r3)];
 heap32[(r2)] = r3;
}
 r2 = heap32[(r7+2)];
 r3 = heap32[(r7+18)];
if(!(r3 ==0)) //_LBB136_24
{
 r6 = r3 >> 2;
 r6 = heap32[(r6)];
 r6 = r6 >> 2;
 r6 = heap32[(r6+3)];
 heap32[(g0)] = r3;
 heap32[(g0+1)] = r0;
 heap32[(g0+2)] = r4;
 heap32[(g0+3)] = r8;
 __FUNCTION_TABLE__[(r6)>>2](i7);
}
 r0 = (r2 + -1)|0;
 if(r0 !=r1) //_LBB136_26
{
 r3 = heap32[(r7+4)];
 r4 = r2 << 4;
 r3 = (r3 + r4)|0;
 r3 = r3 >> 2;
 r6 = heap32[(r3+-3)];
 r3 = heap32[(r3+-4)];
 r6 = r6 >> 2;
 r3 = r3 >> 2;
 r6 = heap32[(r6+3)];
 r3 = heap32[(r3+3)];
 r6 = r6 << 16;
 r3 = r3 | r6;
 r6 = r3 << 15;
 r6 = r6 ^ -1;
 r3 = (r3 + r6)|0;
 r6 = r3 >> 10;
 r3 = r6 ^ r3;
 r3 = (r3 * 9)|0;
 r6 = r3 >> 6;
 r3 = r6 ^ r3;
 r6 = r3 << 11;
 r6 = r6 ^ -1;
 r3 = (r3 + r6)|0;
 r6 = r3 >> 16;
 r8 = heap32[(r7+3)];
 r3 = r6 ^ r3;
 r6 = (r8 + -1)|0;
 r3 = r3 & r6;
 r6 = heap32[(r7+11)];
 r3 = r3 << 2;
 r6 = (r6 + r3)|0;
 r6 = r6 >> 2;
 r8 = heap32[(r6)];
 if(r8 ==-1) //_LBB136_29
{
 r0 = _2E_str727;
 r1 = _2E_str121;
 heap32[(g0)] = r0;
 heap32[(g0+1)] = r1;
 heap32[(g0+2)] = 345;
 _assert(i7);
}
else{
 r9 = heap32[(r7+16)];
 if(r8 ==r0) //_LBB136_33
{
__label__ = 31;
}
else{
_38: while(true){
 r10 = r8;
 r8 = r10 << 2;
 r8 = (r9 + r8)|0;
 r11 = r8 >> 2;
 r8 = heap32[(r11)];
if(!(r8 !=r0)) //_LBB136_30
{
break _38;
}
}
 if(r10 ==-1) //_LBB136_33
{
__label__ = 31;
}
else{
 r2 = r2 << 2;
 r2 = (r9 + r2)|0;
 r2 = r2 >> 2;
 r2 = heap32[(r2+-1)];
 heap32[(r11)] = r2;
__label__ = 32;
}
}
if (__label__ == 31){
 r0 = r2 << 2;
 r0 = (r9 + r0)|0;
 r0 = r0 >> 2;
 r0 = heap32[(r0+-1)];
 heap32[(r6)] = r0;
}
 r0 = heap32[(r7+4)];
 r2 = (r0 + r4)|0;
 r4 = r1 << 4;
 r2 = r2 >> 2;
 r0 = (r0 + r4)|0;
 r4 = heap32[(r2+-4)];
 r0 = r0 >> 2;
 heap32[(r0)] = r4;
 r4 = heap32[(r2+-3)];
 heap32[(r0+1)] = r4;
 r4 = heap32[(r2+-2)];
 heap32[(r0+2)] = r4;
 r2 = heap32[(r2+-1)];
 heap32[(r0+3)] = r2;
 r0 = heap32[(r7+11)];
 r0 = (r0 + r3)|0;
 r0 = r0 >> 2;
 r2 = r1 << 2;
 r4 = heap32[(r7+16)];
 r2 = (r4 + r2)|0;
 r0 = heap32[(r0)];
 r2 = r2 >> 2;
 heap32[(r2)] = r0;
 r0 = heap32[(r7+11)];
 r0 = (r0 + r3)|0;
 r0 = r0 >> 2;
 heap32[(r0)] = r1;
}
}
 r0 = heap32[(r7+2)];
 r0 = (r0 + -1)|0;
 heap32[(r7+2)] = r0;
 r_g0 = r5;
 return;
}
}
else{
 r0 = _2E_str626;
 r1 = _2E_str121;
 heap32[(g0)] = r0;
 heap32[(g0+1)] = r1;
 heap32[(g0+2)] = 300;
 _assert(i7);
}
}
else{
 r0 = _2E_str525;
 r3 = _2E_str121;
 heap32[(g0)] = r0;
 heap32[(g0+1)] = r3;
 heap32[(g0+2)] = 297;
 _assert(i7);
}
}
else{
 r0 = _2E_str424;
 r1 = _2E_str121;
 heap32[(g0)] = r0;
 heap32[(g0+1)] = r1;
 heap32[(g0+2)] = 296;
 _assert(i7);
}
}
}
else{
 r0 = _2E_str222;
 r1 = _2E_str323;
 heap32[(g0)] = r0;
 heap32[(g0+1)] = r1;
 heap32[(g0+2)] = 250;
 _assert(i7);
}
}
 r0 = 0;
 r_g0 = r0;
 return;
}

function _ZN28btHashedOverlappingPairCache8findPairEP17btBroadphaseProxyS1_(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
 var r1;
 var r2;
 var r3;
 var r4;
 var r5;
 var r6;
var __label__ = 0;
 i7 = sp + -16;var g0 = i7>>2; // save stack
 r0 = gFindPairs;
 r0 = r0 >> 2;
 r1 = heap32[(r0)];
 r2 = heap32[(fp+1)];
 r3 = heap32[(fp+2)];
 r1 = (r1 + 1)|0;
 r4 = r2 >> 2;
 heap32[(r0)] = r1;
 r0 = r3 >> 2;
 r1 = heap32[(r4+3)];
 r0 = heap32[(r0+3)];
 r4 = r1 > r0 ? r2 : r3;
 r0 = r1 > r0 ? r3 : r2;
 r1 = r4 >> 2;
 r1 = heap32[(r1+3)];
 r0 = r0 >> 2;
 r0 = heap32[(r0+3)];
 r2 = r1 << 16;
 r2 = r2 | r0;
 r3 = r2 << 15;
 r3 = r3 ^ -1;
 r2 = (r2 + r3)|0;
 r3 = r2 >> 10;
 r2 = r3 ^ r2;
 r2 = (r2 * 9)|0;
 r3 = r2 >> 6;
 r2 = r3 ^ r2;
 r3 = r2 << 11;
 r4 = heap32[(fp)];
 r3 = r3 ^ -1;
 r4 = r4 >> 2;
 r2 = (r2 + r3)|0;
 r3 = r2 >> 16;
 r5 = heap32[(r4+3)];
 r2 = r3 ^ r2;
 r3 = (r5 + -1)|0;
 r2 = r2 & r3;
 r3 = heap32[(r4+9)];
_1: do {
if(!(r3 <=r2)) //_LBB137_9
{
 r3 = heap32[(r4+11)];
 r2 = r2 << 2;
 r2 = (r3 + r2)|0;
_3: while(true){
 r2 = r2 >> 2;
 r2 = heap32[(r2)];
 if(r2 ==-1) //_LBB137_9
{
break _1;
}
else{
 r3 = heap32[(r4+4)];
 r5 = r2 << 4;
 r3 = (r3 + r5)|0;
 r5 = r3 >> 2;
 r6 = heap32[(r5)];
 r6 = r6 >> 2;
 r6 = heap32[(r6+3)];
if(!(r6 !=r0)) //_LBB137_2
{
 r5 = heap32[(r5+1)];
 r5 = r5 >> 2;
 r5 = heap32[(r5+3)];
if(!(r5 !=r1)) //_LBB137_2
{
break _3;
}
}
 r3 = heap32[(r4+16)];
 r2 = r2 << 2;
 r2 = (r3 + r2)|0;
}
}
 r0 = heap32[(r4+2)];
 if(r0 >r2) //_LBB137_8
{
 r_g0 = r3;
 return;
}
else{
 r3 = _2E_str222;
 r0 = _2E_str121;
 heap32[(g0)] = r3;
 heap32[(g0+1)] = r0;
 heap32[(g0+2)] = 165;
 _assert(i7);
}
}
} while(0);
 r0 = 0;
 r_g0 = r0;
 return;
}

function _ZN28btHashedOverlappingPairCache20sortOverlappingPairsEP12btDispatcher(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
 var r1;
 var r2;
 var r3;
 var r4;
 var r5;
 var r6;
 var r7;
 var r8;
 var r9;
 var r10;
 var r11;
 var r12;
 var r13;
 var r14;
 var r15;
 var r16;
var __label__ = 0;
 i7 = sp + -40;var g0 = i7>>2; // save stack
 r0 = sp + -24;
 r1 = 1;
 r2 = r0 >> 2;
 heap8[sp+-8] = r1;
 heap32[(r2+3)] = 0;
 r3 = heap32[(fp)];
 heap32[(r2+1)] = 0;
 r4 = r3 >> 2;
 heap32[(r2+2)] = 0;
 r5 = heap32[(r4+2)];
_1: do {
 if(r5 >0) //_LBB138_2
{
 r6 = heap32[(fp+1)];
 r7 = 0;
 r5 = r7;
_3: while(true){
 r8 = heap32[(r4+4)];
 if(r7 ==r5) //_LBB138_5
{
 r9 = 1;
 r10 = r5 << 1;
 r10 = r5 == 0 ? r9 : r10;
if(!(r7 >=r10)) //_LBB138_4
{
 if(r10 !=0) //_LBB138_8
{
 r7 = gNumAlignedAllocs;
 r7 = r7 >> 2;
 r11 = heap32[(r7)];
 r12 = r10 << 4;
 r11 = (r11 + 1)|0;
 r12 = r12 | 3;
 heap32[(r7)] = r11;
 r7 = (r12 + 16)|0;
 heap32[(g0)] = r7;
 malloc(i7);
 r7 = r_g0;
 if(r7 !=0) //_LBB138_10
{
 r11 = 0;
 r12 = (r7 + 4)|0;
 r11 = (r11 - r12)|0;
 r11 = r11 & 15;
 r11 = (r7 + r11)|0;
 r12 = (r11 + 4)|0;
 r11 = r11 >> 2;
 heap32[(r11)] = r7;
 r7 = r12;
}
}
else{
 r7 = 0;
}
 if(r5 <1) //_LBB138_13
{
 r13 = heap32[(r2+3)];
}
else{
 r11 = 0;
 r12 = (r11 - r5)|0;
_16: while(true){
 r13 = heap32[(r2+3)];
 r14 = r11 << 4;
 r15 = (r13 - r14)|0;
 r15 = r15 >> 2;
 r14 = (r7 - r14)|0;
 r16 = heap32[(r15)];
 r14 = r14 >> 2;
 heap32[(r14)] = r16;
 r16 = heap32[(r15+1)];
 heap32[(r14+1)] = r16;
 r16 = heap32[(r15+2)];
 heap32[(r14+2)] = r16;
 r15 = heap32[(r15+3)];
 r11 = (r11 + -1)|0;
 heap32[(r14+3)] = r15;
if(!(r12 !=r11)) //_LBB138_14
{
break _16;
}
}
}
 if(r13 !=0) //_LBB138_17
{
 r11 = heapU8[sp+-8];
 if(r11 !=0) //_LBB138_19
{
 r5 = gNumAlignedFree;
 r5 = r5 >> 2;
 r11 = heap32[(r5)];
 r11 = (r11 + 1)|0;
 r12 = r13 >> 2;
 heap32[(r5)] = r11;
 r5 = heap32[(r12+-1)];
 heap32[(g0)] = r5;
 free(i7);
 r5 = heap32[(r2+1)];
}
 heap32[(r2+3)] = 0;
}
 heap8[sp+-8] = r9;
 heap32[(r2+3)] = r7;
 heap32[(r2+2)] = r10;
}
}
 r7 = r1 << 4;
 r7 = (r8 + r7)|0;
 r7 = r7 >> 2;
 r5 = r5 << 4;
 r8 = heap32[(r2+3)];
 r5 = (r8 + r5)|0;
 r8 = heap32[(r7+-4)];
 r5 = r5 >> 2;
 heap32[(r5)] = r8;
 r8 = heap32[(r7+-3)];
 heap32[(r5+1)] = r8;
 r8 = heap32[(r7+-2)];
 heap32[(r5+2)] = r8;
 r7 = heap32[(r7+-1)];
 heap32[(r5+3)] = r7;
 r5 = heap32[(r2+1)];
 r5 = (r5 + 1)|0;
 heap32[(r2+1)] = r5;
 r7 = heap32[(r4+2)];
 if(r7 <=r1) //_LBB138_24
{
break _3;
}
else{
 r7 = heap32[(r2+2)];
 r1 = (r1 + 1)|0;
}
}
 if(r5 >0) //_LBB138_26
{
 r1 = 0;
_29: while(true){
 r5 = heap32[(r2+3)];
 r7 = r1 << 4;
 r8 = heap32[(r4)];
 r5 = (r5 + r7)|0;
 r5 = r5 >> 2;
 r7 = r8 >> 2;
 r7 = heap32[(r7+3)];
 r8 = heap32[(r5+1)];
 r5 = heap32[(r5)];
 heap32[(g0)] = r3;
 heap32[(g0+1)] = r5;
 heap32[(g0+2)] = r8;
 heap32[(g0+3)] = r6;
 __FUNCTION_TABLE__[(r7)>>2](i7);
 r5 = heap32[(r2+1)];
 r1 = (r1 + 1)|0;
 if(r5 >r1) //_LBB138_27
{
continue _29;
}
else{
break _1;
}
}
}
}
else{
 r5 = 0;
}
} while(0);
 r1 = heap32[(r4+14)];
 if(r1 >0) //_LBB138_30
{
 r5 = 0;
_35: while(true){
 r1 = r5 << 2;
 r6 = heap32[(r4+16)];
 r1 = (r6 + r1)|0;
 r5 = (r5 + 1)|0;
 r1 = r1 >> 2;
 heap32[(r1)] = -1;
 r1 = heap32[(r4+14)];
if(!(r1 >r5)) //_LBB138_31
{
break _35;
}
}
 r5 = heap32[(r2+1)];
}
 if(r5 >1) //_LBB138_35
{
 r5 = (r5 + -1)|0;
 heap32[(g0)] = r0;
 heap32[(g0+1)] = 0;
 heap32[(g0+2)] = r5;
 _ZN20btAlignedObjectArrayI16btBroadphasePairE17quickSortInternalI29btBroadphasePairSortPredicateEEvT_ii(i7);
 r5 = heap32[(r2+1)];
}
_42: do {
if(!(r5 <1)) //_LBB138_39
{
 r0 = 0;
_44: while(true){
 r1 = heap32[(r2+3)];
 r5 = r0 << 4;
 r6 = heap32[(r4)];
 r1 = (r1 + r5)|0;
 r1 = r1 >> 2;
 r5 = r6 >> 2;
 r5 = heap32[(r5+2)];
 r6 = heap32[(r1+1)];
 r1 = heap32[(r1)];
 heap32[(g0)] = r3;
 heap32[(g0+1)] = r1;
 heap32[(g0+2)] = r6;
 r0 = (r0 + 1)|0;
 __FUNCTION_TABLE__[(r5)>>2](i7);
 r1 = heap32[(r2+1)];
 if(r1 >r0) //_LBB138_38
{
continue _44;
}
else{
break _42;
}
}
}
} while(0);
 r0 = heap32[(r2+3)];
if(!(r0 ==0)) //_LBB138_42
{
 r1 = heapU8[sp+-8];
if(!(r1 ==0)) //_LBB138_42
{
 r1 = gNumAlignedFree;
 r1 = r1 >> 2;
 r2 = heap32[(r1)];
 r2 = (r2 + 1)|0;
 r0 = r0 >> 2;
 heap32[(r1)] = r2;
 r0 = heap32[(r0+-1)];
 heap32[(g0)] = r0;
 free(i7);
}
}
 return;
}

function _ZN20btAlignedObjectArrayI16btBroadphasePairE21expandNonInitializingEv(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
 var r1;
 var r2;
 var r3;
 var r4;
 var r5;
 var r6;
 var r7;
 var r8;
 var r9;
 var r10;
 var r11;
 var r12;
var __label__ = 0;
 i7 = sp + -8;var g0 = i7>>2; // save stack
 r0 = heap32[(fp)];
 r1 = r0 >> 2;
 r2 = heap32[(r1+2)];
 r3 = heap32[(r1+1)];
 if(r2 ==r3) //_LBB139_2
{
 r4 = 1;
 r5 = r3 << 1;
 r5 = r3 == 0 ? r4 : r5;
 if(r2 >=r5) //_LBB139_1
{
__label__ = 1;
}
else{
 if(r5 !=0) //_LBB139_5
{
 r2 = gNumAlignedAllocs;
 r2 = r2 >> 2;
 r6 = heap32[(r2)];
 r7 = r5 << 4;
 r6 = (r6 + 1)|0;
 r7 = r7 | 3;
 heap32[(r2)] = r6;
 r2 = (r7 + 16)|0;
 heap32[(g0)] = r2;
 malloc(i7);
 r6 = r_g0;
 if(r6 !=0) //_LBB139_7
{
 r2 = 0;
 r7 = (r6 + 4)|0;
 r2 = (r2 - r7)|0;
 r2 = r2 & 15;
 r2 = (r6 + r2)|0;
 r7 = (r2 + 4)|0;
 r2 = r2 >> 2;
 heap32[(r2)] = r6;
 r6 = r7;
}
}
else{
 r6 = 0;
}
 r7 = (r0 + 12)|0;
 if(r3 <1) //_LBB139_10
{
 r2 = r7 >> 2;
 r9 = heap32[(r2)];
}
else{
 r2 = 0;
 r8 = (r2 - r3)|0;
_12: while(true){
 r9 = r7 >> 2;
 r9 = heap32[(r9)];
 r10 = r2 << 4;
 r11 = (r9 - r10)|0;
 r11 = r11 >> 2;
 r10 = (r6 - r10)|0;
 r12 = heap32[(r11)];
 r10 = r10 >> 2;
 heap32[(r10)] = r12;
 r12 = heap32[(r11+1)];
 heap32[(r10+1)] = r12;
 r12 = heap32[(r11+2)];
 heap32[(r10+2)] = r12;
 r11 = heap32[(r11+3)];
 r2 = (r2 + -1)|0;
 heap32[(r10+3)] = r11;
if(!(r8 !=r2)) //_LBB139_11
{
break _12;
}
}
 r7 = (r0 + 12)|0;
}
 if(r9 !=0) //_LBB139_15
{
 r2 = heapU8[r0+16];
 if(r2 !=0) //_LBB139_17
{
 r2 = gNumAlignedFree;
 r2 = r2 >> 2;
 r8 = heap32[(r2)];
 r8 = (r8 + 1)|0;
 r9 = r9 >> 2;
 heap32[(r2)] = r8;
 r2 = heap32[(r9+-1)];
 heap32[(g0)] = r2;
 free(i7);
 r2 = heap32[(r1+1)];
}
else{
 r2 = r3;
}
 r8 = r7 >> 2;
 heap32[(r8)] = 0;
}
else{
 r2 = r3;
}
 r7 = r7 >> 2;
 heap8[r0+16] = r4;
 heap32[(r7)] = r6;
 heap32[(r1+2)] = r5;
__label__ = 19;
}
}
else{
__label__ = 1;
}
if (__label__ == 1){
 r2 = r3;
}
 r0 = (r2 + 1)|0;
 heap32[(r1+1)] = r0;
 r0 = heap32[(r1+3)];
 r1 = r3 << 4;
 r0 = (r0 + r1)|0;
 r_g0 = r0;
 return;
}

function _ZN28btHashedOverlappingPairCache10growTablesEv(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
 var r1;
 var r2;
 var r3;
 var r4;
 var r5;
 var r6;
 var r7;
 var r8;
 var r9;
 var r10;
var __label__ = 0;
 i7 = sp + -8;var g0 = i7>>2; // save stack
 r0 = heap32[(fp)];
 r1 = r0 >> 2;
 r2 = heap32[(r1+9)];
 r3 = heap32[(r1+3)];
_1: do {
if(!(r2 >=r3)) //_LBB140_48
{
_3: do {
if(!(r2 >r3)) //_LBB140_20
{
 r4 = heap32[(r1+10)];
if(!(r4 >=r3)) //_LBB140_18
{
 if(r3 !=0) //_LBB140_5
{
 r4 = gNumAlignedAllocs;
 r4 = r4 >> 2;
 r5 = heap32[(r4)];
 r6 = r3 << 2;
 r5 = (r5 + 1)|0;
 r6 = r6 | 3;
 heap32[(r4)] = r5;
 r4 = (r6 + 16)|0;
 heap32[(g0)] = r4;
 malloc(i7);
 r4 = r_g0;
 if(r4 !=0) //_LBB140_7
{
 r5 = 0;
 r6 = (r4 + 4)|0;
 r5 = (r5 - r6)|0;
 r5 = r5 & 15;
 r5 = (r4 + r5)|0;
 r6 = (r5 + 4)|0;
 r5 = r5 >> 2;
 heap32[(r5)] = r4;
 r4 = r6;
}
}
else{
 r4 = 0;
}
 r5 = (r0 + 44)|0;
 if(r2 <1) //_LBB140_10
{
 r6 = r5 >> 2;
 r7 = heap32[(r6)];
}
else{
 r6 = 0;
_15: while(true){
 r7 = r5 >> 2;
 r7 = heap32[(r7)];
 r8 = r6 << 2;
 r9 = (r7 + r8)|0;
 r9 = r9 >> 2;
 r8 = (r4 + r8)|0;
 r9 = heap32[(r9)];
 r6 = (r6 + 1)|0;
 r8 = r8 >> 2;
 heap32[(r8)] = r9;
if(!(r2 !=r6)) //_LBB140_11
{
break _15;
}
}
 r5 = (r0 + 44)|0;
}
if(!(r7 ==0)) //_LBB140_17
{
 r6 = heapU8[r0+48];
if(!(r6 ==0)) //_LBB140_16
{
 r6 = gNumAlignedFree;
 r6 = r6 >> 2;
 r8 = heap32[(r6)];
 r8 = (r8 + 1)|0;
 r7 = r7 >> 2;
 heap32[(r6)] = r8;
 r6 = heap32[(r7+-1)];
 heap32[(g0)] = r6;
 free(i7);
}
 r6 = r5 >> 2;
 heap32[(r6)] = 0;
}
 r6 = 1;
 r5 = r5 >> 2;
 heap8[r0+48] = r6;
 heap32[(r5)] = r4;
 heap32[(r1+10)] = r3;
}
 r4 = r2;
_26: while(true){
 r5 = r4 << 2;
 r6 = heap32[(r1+11)];
 r5 = (r6 + r5)|0;
 r4 = (r4 + 1)|0;
 r5 = r5 >> 2;
 heap32[(r5)] = 0;
if(!(r3 !=r4)) //_LBB140_19
{
break _3;
}
}
}
} while(0);
 heap32[(r1+9)] = r3;
 r4 = heap32[(r1+14)];
_29: do {
if(!(r4 >r3)) //_LBB140_39
{
if(!(r4 >=r3)) //_LBB140_39
{
 r5 = heap32[(r1+15)];
if(!(r5 >=r3)) //_LBB140_38
{
 if(r3 !=0) //_LBB140_25
{
 r5 = gNumAlignedAllocs;
 r5 = r5 >> 2;
 r6 = heap32[(r5)];
 r7 = r3 << 2;
 r6 = (r6 + 1)|0;
 r7 = r7 | 3;
 heap32[(r5)] = r6;
 r5 = (r7 + 16)|0;
 heap32[(g0)] = r5;
 malloc(i7);
 r5 = r_g0;
 if(r5 !=0) //_LBB140_27
{
 r6 = 0;
 r7 = (r5 + 4)|0;
 r6 = (r6 - r7)|0;
 r6 = r6 & 15;
 r6 = (r5 + r6)|0;
 r7 = (r6 + 4)|0;
 r6 = r6 >> 2;
 heap32[(r6)] = r5;
 r5 = r7;
}
}
else{
 r5 = 0;
}
 r6 = (r0 + 64)|0;
 if(r4 <1) //_LBB140_30
{
 r7 = r6 >> 2;
 r8 = heap32[(r7)];
}
else{
 r7 = 0;
_42: while(true){
 r8 = r6 >> 2;
 r8 = heap32[(r8)];
 r9 = r7 << 2;
 r10 = (r8 + r9)|0;
 r10 = r10 >> 2;
 r9 = (r5 + r9)|0;
 r10 = heap32[(r10)];
 r7 = (r7 + 1)|0;
 r9 = r9 >> 2;
 heap32[(r9)] = r10;
if(!(r4 !=r7)) //_LBB140_31
{
break _42;
}
}
 r6 = (r0 + 64)|0;
}
if(!(r8 ==0)) //_LBB140_37
{
 r7 = heapU8[r0+68];
if(!(r7 ==0)) //_LBB140_36
{
 r7 = gNumAlignedFree;
 r7 = r7 >> 2;
 r9 = heap32[(r7)];
 r9 = (r9 + 1)|0;
 r8 = r8 >> 2;
 heap32[(r7)] = r9;
 r7 = heap32[(r8+-1)];
 heap32[(g0)] = r7;
 free(i7);
}
 r7 = r6 >> 2;
 heap32[(r7)] = 0;
}
 r7 = 1;
 r6 = r6 >> 2;
 heap8[r0+68] = r7;
 heap32[(r6)] = r5;
 heap32[(r1+15)] = r3;
 if(r4 >=r3) //_LBB140_39
{
break _29;
}
}
_52: while(true){
 r0 = r4 << 2;
 r5 = heap32[(r1+16)];
 r0 = (r5 + r0)|0;
 r4 = (r4 + 1)|0;
 r0 = r0 >> 2;
 heap32[(r0)] = 0;
if(!(r3 !=r4)) //_LBB140_38
{
break _29;
}
}
}
}
} while(0);
 heap32[(r1+14)] = r3;
_55: do {
if(!(r3 <1)) //_LBB140_45
{
 r0 = 0;
_57: while(true){
 r4 = r0 << 2;
 r5 = heap32[(r1+11)];
 r4 = (r5 + r4)|0;
 r0 = (r0 + 1)|0;
 r4 = r4 >> 2;
 heap32[(r4)] = -1;
if(!(r3 !=r0)) //_LBB140_41
{
break _57;
}
}
if(!(r3 <1)) //_LBB140_45
{
 r0 = 0;
_61: while(true){
 r4 = r0 << 2;
 r5 = heap32[(r1+16)];
 r4 = (r5 + r4)|0;
 r0 = (r0 + 1)|0;
 r4 = r4 >> 2;
 heap32[(r4)] = -1;
if(!(r3 !=r0)) //_LBB140_44
{
break _55;
}
}
}
}
} while(0);
if(!(r2 <1)) //_LBB140_48
{
 r0 = 0;
_65: while(true){
 r3 = heap32[(r1+4)];
 r4 = r0 << 4;
 r3 = (r3 + r4)|0;
 r3 = r3 >> 2;
 r4 = heap32[(r3+1)];
 r3 = heap32[(r3)];
 r4 = r4 >> 2;
 r3 = r3 >> 2;
 r4 = heap32[(r4+3)];
 r4 = r4 << 16;
 r3 = heap32[(r3+3)];
 r3 = r4 | r3;
 r4 = r3 << 15;
 r4 = r4 ^ -1;
 r3 = (r3 + r4)|0;
 r4 = r3 >> 10;
 r3 = r4 ^ r3;
 r3 = (r3 * 9)|0;
 r4 = r3 >> 6;
 r3 = r4 ^ r3;
 r4 = r3 << 11;
 r4 = r4 ^ -1;
 r3 = (r3 + r4)|0;
 r4 = r3 >> 16;
 r5 = heap32[(r1+3)];
 r3 = r4 ^ r3;
 r4 = (r5 + -1)|0;
 r3 = r3 & r4;
 r3 = r3 << 2;
 r4 = heap32[(r1+11)];
 r4 = (r4 + r3)|0;
 r4 = r4 >> 2;
 r5 = r0 << 2;
 r6 = heap32[(r1+16)];
 r5 = (r6 + r5)|0;
 r4 = heap32[(r4)];
 r5 = r5 >> 2;
 heap32[(r5)] = r4;
 r4 = heap32[(r1+11)];
 r3 = (r4 + r3)|0;
 r4 = (r0 + 1)|0;
 r3 = r3 >> 2;
 heap32[(r3)] = r0;
 r0 = r4;
 if(r2 !=r4) //_LBB140_47
{
continue _65;
}
else{
break _1;
}
}
}
}
} while(0);
 return;
}

function _ZN28btHashedOverlappingPairCacheC1Ev(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
 var r1;
 var r2;
 var r3;
 var r4;
 var r5;
var __label__ = 0;
 i7 = sp + -8;var g0 = i7>>2; // save stack
 r0 = heap32[(fp)];
 r1 = _ZTV28btHashedOverlappingPairCache;
 r2 = r0 >> 2;
 r1 = (r1 + 8)|0;
 r3 = 1;
 heap32[(r2)] = r1;
 heap8[r0+20] = r3;
 heap32[(r2+4)] = 0;
 heap32[(r2+2)] = 0;
 heap32[(r2+3)] = 0;
 r1 = 0;
 heap32[(r2+6)] = 0;
 heap8[r0+28] = r1;
 heap8[r0+48] = r3;
 heap32[(r2+11)] = 0;
 heap32[(r2+9)] = 0;
 heap32[(r2+10)] = 0;
 heap8[r0+68] = r3;
 heap32[(r2+16)] = 0;
 heap32[(r2+14)] = 0;
 r4 = gNumAlignedAllocs;
 heap32[(r2+15)] = 0;
 r4 = r4 >> 2;
 heap32[(r2+18)] = 0;
 r5 = heap32[(r4)];
 r5 = (r5 + 1)|0;
 heap32[(r4)] = r5;
 heap32[(g0)] = 51;
 malloc(i7);
 r4 = r_g0;
 if(r4 !=0) //_LBB141_2
{
 r5 = (r4 + 4)|0;
 r1 = (r1 - r5)|0;
 r1 = r1 & 15;
 r1 = (r4 + r1)|0;
 r5 = (r1 + 4)|0;
 r1 = r1 >> 2;
 heap32[(r1)] = r4;
 r4 = r5;
}
 heap8[r0+20] = r3;
 heap32[(r2+4)] = r4;
 heap32[(r2+3)] = 2;
 heap32[(g0)] = r0;
 _ZN28btHashedOverlappingPairCache10growTablesEv(i7);
 return;
}

function _ZNK14btQuantizedBvh31calculateSerializeBufferSizeNewEv(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
var __label__ = 0;
 i7 = sp + 0;var g0 = i7>>2; // save stack
 r0 = 84;
 r_g0 = r0;
 return;
}

function _ZNK14btQuantizedBvh9serializeEPvP12btSerializer(sp)
{
 var i7;
 var fp = sp>>2;
 var r0;
 var r1;
 var r2;
 var r3;
 var r4;
 var r5;
 var r6;
 var r7;
 var r8;
 var r9;
 var r10;
 var r11;
var __label__ = 0;
 i7 = sp + -24;var g0 = i7>>2; // save stack
 r0 = heap32[(fp+1)];
 r1 = heap32[(fp)];
 r0 = r0 >> 2;
 r2 = r1 >> 2;
 heap32[(r0+4)] = heap32[(r2+5)];
 heap32[(r0+5)] = heap32[(r2+6)];
 heap32[(r0+6)] = heap32[(r2+7)];
 heap32[(r0+7)] = heap32[(r2+8)];
 heap32[(r0)] = heap32[(r2+1)];
 heap32[(r0+1)] = heap32[(r2+2)];
 heap32[(r0+2)] = heap32[(r2+3)];
 heap32[(r0+3)] = heap32[(r2+4)];
 heap32[(r0+8)] = heap32[(r2+9)];
 heap32[(r0+9)] = heap32[(r2+10)];
 heap32[(r0+10)] = heap32[(r2+11)];
 heap32[(r0+11)] = heap32[(r2+12)];
 r3 = heap32[(r2+14)];
 heap32[(r0+12)] = r3;
 r1 = heapU8[r1+60];
 heap32[(r0+13)] = r1;
 r1 = heap32[(r2+22)];
 r3 = heap32[(fp+2)];
 heap32[(r0+14)] = r1;
 r1 = heap32[(r2+22)];
 if(r1 !=0) //_LBB143_2
{
 r1 = r3 >> 2;
 r4 = heap32[(r1)];
 r4 = r4 >> 2;
 r4 = heap32[(r4+7)];
 r5 = heap32[(r2+24)];
 heap32[(g0)] = r3;
 heap32[(g0+1)] = r5;
 __FUNCTION_TABLE__[(r4)>>2](i7);
 r4 = r_g0;
 heap32[(r0+16)] = r4;
if(!(r4 ==0)) //_LBB143_7
{
 r4 = heap32[(r1)];
 r4 = r4 >> 2;
 r5 = heap32[(r2+22)];
 r4 = heap32[(r4+4)];
 heap32[(g0)] = r3;
 heap32[(g0+1)] = 48;
 heap32[(g0+2)] = r5;
 __FUNCTION_TABLE__[(r4)>>2](i7);
 r4 = r_g0;
if(!(r5 <1)) //_LBB143_6
{
 r6 = r4 >> 2;
 r7 = 0;
 r6 = heap32[(r6+2)];
 r5 = (r7 - r5)|0;
_6: while(true){
 r8 = (r7 * -12)|0;
 r8 = r8 << 2;
 r9 = r7 << 6;
 r10 = heap32[(r2+24)];
 r8 = (r6 + r8)|0;
 r10 = (r10 - r9)|0;
 r8 = r8 >> 2;
 r10 = r10 >> 2;
 heap32[(r8+4)] = heap32[(r10+4)];
 heap32[(r8+5)] = heap32[(r10+5)];
--> --------------------

--> maximum size reached

--> --------------------