remove unneeded emscripten optimizer.cpp file

1 files changed, 0 insertions, 3851 deletions

diff --git a/src/emscripten-optimizer/optimizer.cpp b/src/emscripten-optimizer/optimizer.cpp
deleted file mode 100644
index d569fb928..000000000
--- a/src/emscripten-optimizer/optimizer.cpp
+++ /dev/null
@@ -1,3851 +0,0 @@
-#include <cstdint>
-#include <cstdio>
-#include <cmath>
-#include <string>
-#include <algorithm>
-#include <map>
-
-#include "simple_ast.h"
-#include "optimizer.h"
-
-#include "optimizer-shared.cpp"
-
-typedef std::vector<IString> StringVec;
-
-//==================
-// Globals
-//==================
-
-Ref extraInfo;
-
-//==================
-// Infrastructure
-//==================
-
-template<class T, class V>
-int indexOf(T list, V value) {
-  for (size_t i = 0; i < list.size(); i++) {
-    if (list[i] == value) return i;
-  }
-  return -1;
-}
-
-int jsD2I(double x) {
-  return (int)((int64_t)x);
-}
-
-char *strdupe(const char *str) {
-  char *ret = (char *)malloc(strlen(str)+1); // leaked!
-  strcpy(ret, str);
-  return ret;
-}
-
-IString getHeapStr(int x, bool unsign) {
-  switch (x) {
-    case 8: return unsign ? HEAPU8 : HEAP8;
-    case 16: return unsign ? HEAPU16 : HEAP16;
-    case 32: return unsign ? HEAPU32 : HEAP32;
-  }
-  assert(0);
-  return ":(";
-}
-
-Ref deStat(Ref node) {
-  if (node[0] == STAT) return node[1];
-  return node;
-}
-
-Ref getStatements(Ref node) {
-  if (node[0] == DEFUN) {
-    return node[3];
-  } else if (node[0] == BLOCK) {
-    return node->size() > 1 ? node[1] : nullptr;
-  } else {
-    return arena.alloc();
-  }
-}
-
-// Types
-
-AsmType intToAsmType(int type) {
-  if (type >= 0 && type <= ASM_NONE) return (AsmType)type;
-  else {
-    assert(0);
-    return ASM_NONE;
-  }
-}
-
-// forward decls
-Ref makeEmpty();
-bool isEmpty(Ref node);
-Ref makeAsmVarDef(const IString& v, AsmType type);
-Ref makeArray(int size_hint);
-Ref makeBool(bool b);
-Ref makeNum(double x);
-Ref makeName(IString str);
-Ref makeAsmCoercion(Ref node, AsmType type);
-Ref make1(IString type, Ref a);
-Ref make3(IString type, Ref a, Ref b, Ref c);
-
-AsmData::AsmData(Ref f) {
-  func = f;
-
-  // process initial params
-  Ref stats = func[3];
-  size_t i = 0;
-  while (i < stats->size()) {
-    Ref node = stats[i];
-    if (node[0] != STAT || node[1][0] != ASSIGN || node[1][2][0] != NAME) break;
-    node = node[1];
-    Ref name = node[2][1];
-    int index = func[2]->indexOf(name);
-    if (index < 0) break; // not an assign into a parameter, but a global
-    IString& str = name->getIString();
-    if (locals.count(str) > 0) break; // already done that param, must be starting function body
-    locals[str] = Local(detectType(node[3]), true);
-    params.push_back(str);
-    stats[i] = makeEmpty();
-    i++;
-  }
-  // process initial variable definitions and remove '= 0' etc parts - these
-  // are not actually assignments in asm.js
-  while (i < stats->size()) {
-    Ref node = stats[i];
-    if (node[0] != VAR) break;
-    for (size_t j = 0; j < node[1]->size(); j++) {
-      Ref v = node[1][j];
-      IString& name = v[0]->getIString();
-      Ref value = v[1];
-      if (locals.count(name) == 0) {
-        locals[name] = Local(detectType(value, nullptr, true), false);
-        vars.push_back(name);
-        v->setSize(1); // make an un-assigning var
-      } else {
-        assert(j == 0); // cannot break in the middle
-        goto outside;
-      }
-    }
-    i++;
-  }
-  outside:
-  // look for other var definitions and collect them
-  while (i < stats->size()) {
-    traversePre(stats[i], [&](Ref node) {
-      Ref type = node[0];
-      if (type == VAR) {
-        dump("bad, seeing a var in need of fixing", func);
-        abort(); //, 'should be no vars to fix! ' + func[1] + ' : ' + JSON.stringify(node));
-      }
-    });
-    i++;
-  }
-  // look for final RETURN statement to get return type.
-  Ref retStmt = stats->back();
-  if (!!retStmt && retStmt[0] == RETURN && !!retStmt[1]) {
-    ret = detectType(retStmt[1]);
-  } else {
-    ret = ASM_NONE;
-  }
-}
-
-void AsmData::denormalize() {
-  Ref stats = func[3];
-  // Remove var definitions, if any
-  for (size_t i = 0; i < stats->size(); i++) {
-    if (stats[i][0] == VAR) {
-      stats[i] = makeEmpty();
-    } else {
-      if (!isEmpty(stats[i])) break;
-    }
-  }
-  // calculate variable definitions
-  Ref varDefs = makeArray(vars.size());
-  for (auto v : vars) {
-    varDefs->push_back(makeAsmVarDef(v, locals[v].type));
-  }
-  // each param needs a line; reuse emptyNodes as much as we can
-  size_t numParams = params.size();
-  size_t emptyNodes = 0;
-  while (emptyNodes < stats->size()) {
-    if (!isEmpty(stats[emptyNodes])) break;
-    emptyNodes++;
-  }
-  size_t neededEmptyNodes = numParams + (varDefs->size() ? 1 : 0); // params plus one big var if there are vars
-  if (neededEmptyNodes > emptyNodes) {
-    stats->insert(0, neededEmptyNodes - emptyNodes);
-  } else if (neededEmptyNodes < emptyNodes) {
-    stats->splice(0, emptyNodes - neededEmptyNodes);
-  }
-  // add param coercions
-  int next = 0;
-  for (auto param : func[2]->getArray()) {
-    IString str = param->getIString();
-    assert(locals.count(str) > 0);
-    stats[next++] = make1(STAT, make3(ASSIGN, makeBool(true), makeName(str.c_str()), makeAsmCoercion(makeName(str.c_str()), locals[str].type)));
-  }
-  if (varDefs->size()) {
-    stats[next] = make1(VAR, varDefs);
-  }
-  /*
-  if (inlines->size() > 0) {
-    var i = 0;
-    traverse(func, function(node, type) {
-      if (type == CALL && node[1][0] == NAME && node[1][1] == 'inlinejs') {
-        node[1] = inlines[i++]; // swap back in the body
-      }
-    });
-  }
-  */
-  // ensure that there's a final RETURN statement if needed.
-  if (ret != ASM_NONE) {
-    Ref retStmt = stats->back();
-    if (!retStmt || retStmt[0] != RETURN) {
-      Ref retVal = makeNum(0);
-      if (ret != ASM_INT) {
-        retVal = makeAsmCoercion(retVal, ret);
-      }
-      stats->push_back(make1(RETURN, retVal));
-    }
-  }
-  //printErr('denormalized \n\n' + astToSrc(func) + '\n\n');
-}
-
-// Constructions TODO: share common constructions, and assert they remain frozen
-
-Ref makeArray(int size_hint=0) {
-  return &arena.alloc()->setArray(size_hint);
-}
-
-Ref makeBool(bool b) {
-  return &arena.alloc()->setBool(b);
-}
-
-Ref makeString(const IString& s) {
-  return &arena.alloc()->setString(s);
-}
-
-Ref makeEmpty() {
-  return ValueBuilder::makeToplevel();
-}
-
-Ref makeNum(double x) {
-  return ValueBuilder::makeDouble(x);
-}
-
-Ref makeName(IString str) {
-  return ValueBuilder::makeName(str);
-}
-
-Ref makeBlock() {
-  return ValueBuilder::makeBlock();
-}
-
-Ref make1(IString s1, Ref a) {
-  Ref ret(makeArray(2));
-  ret->push_back(makeString(s1));
-  ret->push_back(a);
-  return ret;
-}
-
-Ref make2(IString s1, IString s2, Ref a) {
-  Ref ret(makeArray(2));
-  ret->push_back(makeString(s1));
-  ret->push_back(makeString(s2));
-  ret->push_back(a);
-  return ret;
-}
-
-Ref make2(IString s1, Ref a, Ref b) {
-  Ref ret(makeArray(3));
-  ret->push_back(makeString(s1));
-  ret->push_back(a);
-  ret->push_back(b);
-  return ret;
-}
-
-Ref make3(IString type, IString a, Ref b, Ref c) {
-  Ref ret(makeArray(4));
-  ret->push_back(makeString(type));
-  ret->push_back(makeString(a));
-  ret->push_back(b);
-  ret->push_back(c);
-  return ret;
-}
-
-Ref make3(IString type, Ref a, Ref b, Ref c) {
-  Ref ret(makeArray(4));
-  ret->push_back(makeString(type));
-  ret->push_back(a);
-  ret->push_back(b);
-  ret->push_back(c);
-  return ret;
-}
-
-Ref makeAsmVarDef(const IString& v, AsmType type) {
-  Ref val;
-  switch (type) {
-    case ASM_INT: val = makeNum(0); break;
-    case ASM_DOUBLE: val = make2(UNARY_PREFIX, PLUS, makeNum(0)); break;
-    case ASM_FLOAT: {
-      if (!ASM_FLOAT_ZERO.isNull()) {
-        val = makeName(ASM_FLOAT_ZERO);
-      } else {
-        val = make2(CALL, makeName(MATH_FROUND), &(makeArray(1))->push_back(makeNum(0)));
-      }
-      break;
-    }
-    case ASM_FLOAT32X4: {
-      val = make2(CALL, makeName(SIMD_FLOAT32X4), &(makeArray(4))->push_back(makeNum(0)).push_back(makeNum(0)).push_back(makeNum(0)).push_back(makeNum(0)));
-      break;
-    }
-    case ASM_FLOAT64X2: {
-      val = make2(CALL, makeName(SIMD_FLOAT64X2), &(makeArray(2))->push_back(makeNum(0)).push_back(makeNum(0)));
-      break;
-    }
-    case ASM_INT8X16: {
-      val = make2(CALL, makeName(SIMD_INT8X16), &(makeArray(16))->push_back(makeNum(0)).push_back(makeNum(0)).push_back(makeNum(0)).push_back(makeNum(0)).push_back(makeNum(0)).push_back(makeNum(0)).push_back(makeNum(0)).push_back(makeNum(0)).push_back(makeNum(0)).push_back(makeNum(0)).push_back(makeNum(0)).push_back(makeNum(0)).push_back(makeNum(0)).push_back(makeNum(0)).push_back(makeNum(0)).push_back(makeNum(0)));
-      break;
-    }
-    case ASM_INT16X8: {
-      val = make2(CALL, makeName(SIMD_INT16X8), &(makeArray(8))->push_back(makeNum(0)).push_back(makeNum(0)).push_back(makeNum(0)).push_back(makeNum(0)).push_back(makeNum(0)).push_back(makeNum(0)).push_back(makeNum(0)).push_back(makeNum(0)));
-      break;
-    }
-    case ASM_INT32X4: {
-      val = make2(CALL, makeName(SIMD_INT32X4), &(makeArray(4))->push_back(makeNum(0)).push_back(makeNum(0)).push_back(makeNum(0)).push_back(makeNum(0)));
-      break;
-    }
-    default: assert(0);
-  }
-  return make1(v, val);
-}
-
-Ref makeAsmCoercion(Ref node, AsmType type) {
-  switch (type) {
-    case ASM_INT: return make3(BINARY, OR, node, makeNum(0));
-    case ASM_DOUBLE: return make2(UNARY_PREFIX, PLUS, node);
-    case ASM_FLOAT: return make2(CALL, makeName(MATH_FROUND), &(makeArray(1))->push_back(node));
-    case ASM_FLOAT32X4: return make2(CALL, makeName(SIMD_FLOAT32X4_CHECK), &(makeArray(1))->push_back(node));
-    case ASM_FLOAT64X2: return make2(CALL, makeName(SIMD_FLOAT64X2_CHECK), &(makeArray(1))->push_back(node));
-    case ASM_INT8X16: return make2(CALL, makeName(SIMD_INT8X16_CHECK), &(makeArray(1))->push_back(node));
-    case ASM_INT16X8: return make2(CALL, makeName(SIMD_INT16X8_CHECK), &(makeArray(1))->push_back(node));
-    case ASM_INT32X4: return make2(CALL, makeName(SIMD_INT32X4_CHECK), &(makeArray(1))->push_back(node));
-    case ASM_NONE:
-    default: return node; // non-validating code, emit nothing XXX this is dangerous, we should only allow this when we know we are not validating
-  }
-}
-
-// Checks
-
-bool isEmpty(Ref node) {
-  return (node->size() == 2 && node[0] == TOPLEVEL && node[1]->size() == 0) ||
-          (node->size() > 0 && node[0] == BLOCK && (!node[1] || node[1]->size() == 0));
-}
-
-bool commable(Ref node) { // TODO: hashing
-  IString type = node[0]->getIString();
-  if (type == ASSIGN || type == BINARY || type == UNARY_PREFIX || type == NAME || type == NUM || type == CALL || type == SEQ || type == CONDITIONAL || type == SUB) return true;
-  return false;
-}
-
-bool isMathFunc(const char *name) {
-  static const char *Math_ = "Math_";
-  static unsigned size = strlen(Math_);
-  return strncmp(name, Math_, size) == 0;
-}
-
-bool isMathFunc(Ref value) {
-  return value->isString() && isMathFunc(value->getCString());
-}
-
-bool callHasSideEffects(Ref node) { // checks if the call itself (not the args) has side effects (or is not statically known)
-  return !(node[1][0] == NAME && isMathFunc(node[1][1]));
-}
-
-bool hasSideEffects(Ref node) { // this is 99% incomplete!
-  IString type = node[0]->getIString();
-  switch (type[0]) {
-    case 'n':
-      if (type == NUM || type == NAME) return false;
-      break;
-    case 's':
-      if (type == STRING) return false;
-      if (type == SUB) return hasSideEffects(node[1]) || hasSideEffects(node[2]);
-      break;
-    case 'u':
-      if (type == UNARY_PREFIX) return hasSideEffects(node[2]);
-      break;
-    case 'b':
-      if (type == BINARY) return hasSideEffects(node[2]) || hasSideEffects(node[3]);
-      break;
-    case 'c':
-      if (type == CALL) {
-        if (callHasSideEffects(node)) return true;
-        // This is a statically known call, with no side effects. only args can side effect us
-        for (auto arg : node[2]->getArray()) {
-          if (hasSideEffects(arg)) return true;
-        }
-        return false;
-      } else if (type == CONDITIONAL) return hasSideEffects(node[1]) || hasSideEffects(node[2]) || hasSideEffects(node[3]); 
-      break;
-  }
-  return true;
-}
-
-// checks if a node has just basic operations, nothing with side effects nor that can notice side effects, which
-// implies we can move it around in the code
-bool triviallySafeToMove(Ref node, AsmData& asmData) {
-  bool ok = true;
-  traversePre(node, [&](Ref node) {
-    Ref type = node[0];
-    if (type == STAT || type == BINARY || type == UNARY_PREFIX || type == ASSIGN || type == NUM) return;
-    else if (type == NAME) {
-      if (!asmData.isLocal(node[1]->getIString())) ok = false;
-    } else if (type == CALL) {
-      if (callHasSideEffects(node)) ok = false;
-    } else {
-      ok = false;
-    }  
-  });
-  return ok;
-}
-
-// Transforms
-
-// We often have branchings that are simplified so one end vanishes, and
-// we then get
-//   if (!(x < 5))
-// or such. Simplifying these saves space and time.
-Ref simplifyNotCompsDirect(Ref node) {
-  if (node[0] == UNARY_PREFIX && node[1] == L_NOT) {
-    // de-morgan's laws do not work on floats, due to nans >:(
-    if (node[2][0] == BINARY && (detectType(node[2][2]) == ASM_INT && detectType(node[2][3]) == ASM_INT)) {
-      Ref op = node[2][1];
-      switch(op->getCString()[0]) {
-        case '<': {
-          if (op == LT)  { op->setString(GE); break; }
-          if (op == LE) { op->setString(GT); break; }
-          return node;
-        }
-        case '>': {
-          if (op == GT)  { op->setString(LE); break; }
-          if (op == GE) { op->setString(LT); break; }
-          return node;
-        }
-        case '=': {
-          if (op == EQ) { op->setString(NE); break; }
-          return node;
-        }
-        case '!': {
-          if (op == NE) { op->setString(EQ); break; }
-          return node;
-        }
-        default: return node;
-      }
-      return make3(BINARY, op, node[2][2], node[2][3]);
-    } else if (node[2][0] == UNARY_PREFIX && node[2][1] == L_NOT) {
-      return node[2][2];
-    }
-  }
-  return node;
-}
-
-Ref flipCondition(Ref cond) {
-  return simplifyNotCompsDirect(make2(UNARY_PREFIX, L_NOT, cond));
-}
-
-void safeCopy(Ref target, Ref source) { // safely copy source onto target, even if source is a subnode of target
-  Ref temp = source; // hold on to source
-  *target = *temp;
-}
-
-void clearEmptyNodes(Ref arr) {
-  int skip = 0;
-  for (size_t i = 0; i < arr->size(); i++) {
-    if (skip) {
-      arr[i-skip] = arr[i];
-    }
-    if (isEmpty(deStat(arr[i]))) {
-      skip++;
-    }
-  }
-  if (skip) arr->setSize(arr->size() - skip);
-}
-void clearUselessNodes(Ref arr) {
-  int skip = 0;
-  for (size_t i = 0; i < arr->size(); i++) {
-    Ref curr = arr[i];
-    if (skip) {
-      arr[i-skip] = curr;
-    }
-    if (isEmpty(deStat(curr)) || (curr[0] == STAT && !hasSideEffects(curr[1]))) {
-      skip++;
-    }
-  }
-  if (skip) arr->setSize(arr->size() - skip);
-}
-
-void removeAllEmptySubNodes(Ref ast) {
-  traversePre(ast, [](Ref node) {
-    if (node[0] == DEFUN) {
-      clearEmptyNodes(node[3]);
-    } else if (node[0] == BLOCK && node->size() > 1 && !!node[1]) {
-      clearEmptyNodes(node[1]);
-    } else if (node[0] == SEQ && isEmpty(node[1])) {
-      safeCopy(node, node[2]);
-    }
-  });
-}
-void removeAllUselessSubNodes(Ref ast) {
-  traversePrePost(ast, [](Ref node) {
-    Ref type = node[0];
-    if (type == DEFUN) {
-      clearUselessNodes(node[3]);
-    } else if (type == BLOCK && node->size() > 1 && !!node[1]) {
-      clearUselessNodes(node[1]);
-    } else if (type == SEQ && isEmpty(node[1])) {
-      safeCopy(node, node[2]);
-    }
-  }, [](Ref node) {
-    Ref type = node[0];
-    if (type == IF) {
-      bool empty2 = isEmpty(node[2]), has3 = node->size() == 4 && !!node[3], empty3 = !has3 || isEmpty(node[3]);
-      if (!empty2 && empty3 && has3) { // empty else clauses
-        node->setSize(3);
-      } else if (empty2 && !empty3) { // empty if blocks
-        safeCopy(node, make2(IF, make2(UNARY_PREFIX, L_NOT, node[1]), node[3]));
-      } else if (empty2 && empty3) {
-        if (hasSideEffects(node[1])) {
-          safeCopy(node, make1(STAT, node[1]));
-        } else {
-          safeCopy(node, makeEmpty());
-        }
-      }
-    }
-  });
-}
-
-Ref unVarify(Ref vars) { // transform var x=1, y=2 etc. into (x=1, y=2), i.e., the same assigns, but without a var definition
-  Ref ret = makeArray(1);
-  ret->push_back(makeString(STAT));
-  if (vars->size() == 1) {
-    ret->push_back(make3(ASSIGN, makeBool(true), makeName(vars[0][0]->getIString()), vars[0][1]));
-  } else {
-    ret->push_back(makeArray(vars->size()-1));
-    Ref curr = ret[1];
-    for (size_t i = 0; i+1 < vars->size(); i++) {
-      curr->push_back(makeString(SEQ));
-      curr->push_back(make3(ASSIGN, makeBool(true), makeName(vars[i][0]->getIString()), vars[i][1]));
-      if (i != vars->size()-2) {
-        curr->push_back(makeArray());
-        curr = curr[2];
-      }
-    }
-    curr->push_back(make3(ASSIGN, makeBool(true), makeName(vars->back()[0]->getIString()), vars->back()[1]));
-  }
-  return ret;
-}
-
-// Calculations
-
-int measureCost(Ref ast) {
-  int size = 0;
-  traversePre(ast, [&size](Ref node) {
-    Ref type = node[0];
-    if (type == NUM || type == UNARY_PREFIX) size--;
-    else if (type == BINARY) {
-      if (node[3][0] == NUM && node[3][1]->getNumber() == 0) size--;
-      else if (node[1] == DIV || node[1] == MOD) size += 2;
-    }
-    else if (type == CALL && !callHasSideEffects(node)) size -= 2;
-    else if (type == SUB) size++;
-    size++;
-  });
-  return size;
-}
-
-//==================
-// Params
-//==================
-
-bool preciseF32 = false,
-     receiveJSON = false,
-     emitJSON = false,
-     minifyWhitespace = false,
-     last = false;
-
-//=====================
-// Optimization passes
-//=====================
-
-#define HASES \
-  bool has(const IString& str) { \
-    return count(str) > 0; \
-  } \
-  bool has(Ref node) { \
-    return node->isString() && count(node->getIString()) > 0; \
-  }
-
-class StringSet : public cashew::IStringSet {
-public:
-  StringSet() {}
-  StringSet(const char *str) : IStringSet(str) {}
-
-  HASES
-
-  void dump() {
-    err("===");
-    for (auto str : *this) {
-      errv("%s", str.c_str());
-    }
-    err("===");
-  }
-};
-
-StringSet USEFUL_BINARY_OPS("<< >> | & ^"),
-          COMPARE_OPS("< <= > >= == == != !=="),
-          BITWISE("| & ^"),
-          SAFE_BINARY_OPS("+ -"), // division is unsafe as it creates non-ints in JS; mod is unsafe as signs matter so we can't remove |0's; mul does not nest with +,- in asm
-          COERCION_REQUIRING_OPS("sub unary-prefix"), // ops that in asm must be coerced right away
-          COERCION_REQUIRING_BINARIES("* / %"); // binary ops that in asm must be coerced
-
-StringSet ASSOCIATIVE_BINARIES("+ * | & ^"),
-          CONTROL_FLOW("do while for if switch"),
-          LOOP("do while for"),
-          NAME_OR_NUM("name num"),
-          CONDITION_CHECKERS("if do while switch"),
-          SAFE_TO_DROP_COERCION("unary-prefix name num");
-
-StringSet BREAK_CAPTURERS("do while for switch"),
-          CONTINUE_CAPTURERS("do while for"),
-          FUNCTIONS_THAT_ALWAYS_THROW("abort ___resumeException ___cxa_throw ___cxa_rethrow");
-
-bool isFunctionTable(const char *name) {
-  static const char *functionTable = "FUNCTION_TABLE";
-  static unsigned size = strlen(functionTable);
-  return strncmp(name, functionTable, size) == 0;
-}
-
-bool isFunctionTable(Ref value) {
-  return value->isString() && isFunctionTable(value->getCString());
-}
-
-// Internal utilities
-
-bool canDropCoercion(Ref node) {
-  if (SAFE_TO_DROP_COERCION.has(node[0])) return true;
-  if (node[0] == BINARY) {
-    switch (node[1]->getCString()[0]) {
-      case '>': return node[1] == RSHIFT || node[1] == TRSHIFT;
-      case '<': return node[1] == LSHIFT;
-      case '|': case '^': case '&': return true;
-    }
-  }
-  return false;
-}
-
-Ref simplifyCondition(Ref node) {
-  node = simplifyNotCompsDirect(node);
-  // on integers, if (x == 0) is the same as if (x), and if (x != 0) as if (!x)
-  if (node[0] == BINARY && (node[1] == EQ || node[1] == NE)) {
-    Ref target;
-    if (detectType(node[2]) == ASM_INT && node[3][0] == NUM && node[3][1]->getNumber() == 0) {
-      target = node[2];
-    } else if (detectType(node[3]) == ASM_INT && node[2][0] == NUM && node[2][1]->getNumber() == 0) {
-      target = node[3];
-    }
-    if (!!target) {
-      if (target[0] == BINARY && (target[1] == OR || target[1] == TRSHIFT) && target[3][0] == NUM && target[3][1]->getNumber() == 0 &&
-          canDropCoercion(target[2])) {
-        target = target[2]; // drop the coercion, in a condition it is ok to do if (x)
-      }
-      if (node[1] == EQ) {
-        return make2(UNARY_PREFIX, L_NOT, target);
-      } else {
-        return target;
-      }
-    }
-  }
-  return node;
-}
-
-// Passes
-
-// Eliminator aka Expressionizer
-//
-// The goal of this pass is to eliminate unneeded variables (which represent one of the infinite registers in the LLVM
-// model) and thus to generate complex expressions where possible, for example
-//
-//  var x = a(10);
-//  var y = HEAP[20];
-//  print(x+y);
-//
-// can be transformed into
-//
-//  print(a(10)+HEAP[20]);
-//
-// The basic principle is to scan along the code in the order of parsing/execution, and keep a list of tracked
-// variables that are current contenders for elimination. We must untrack when we see something that we cannot
-// cross, for example, a write to memory means we must invalidate variables that depend on reading from
-// memory, since if we change the order then we do not preserve the computation.
-//
-// We rely on some assumptions about emscripten-generated code here, which means we can do a lot more than
-// a general JS optimization can. For example, we assume that SUB nodes (indexing like HEAP[..]) are
-// memory accesses or FUNCTION_TABLE accesses, and in both cases that the symbol cannot be replaced although
-// the contents can. So we assume FUNCTION_TABLE might have its contents changed but not be pointed to
-// a different object, which allows
-//
-//  var x = f();
-//  FUNCTION_TABLE[x]();
-//
-// to be optimized (f could replace FUNCTION_TABLE, so in general JS eliminating x is not valid).
-//
-// In memSafe mode, we are more careful and assume functions can replace HEAP and FUNCTION_TABLE, which
-// can happen in ALLOW_MEMORY_GROWTH mode
-
-StringSet ELIMINATION_SAFE_NODES("assign call if toplevel do return label switch binary unary-prefix"); // do is checked carefully, however
-StringSet IGNORABLE_ELIMINATOR_SCAN_NODES("num toplevel string break continue dot"); // dot can only be STRING_TABLE.*
-StringSet ABORTING_ELIMINATOR_SCAN_NODES("new object function defun for while array throw"); // we could handle some of these, TODO, but nontrivial (e.g. for while, the condition is hit multiple times after the body)
-StringSet HEAP_NAMES("HEAP8 HEAP16 HEAP32 HEAPU8 HEAPU16 HEAPU32 HEAPF32 HEAPF64");
-
-bool isTempDoublePtrAccess(Ref node) { // these are used in bitcasts; they are not really affecting memory, and should cause no invalidation
-  assert(node[0] == SUB);
-  return (node[2][0] == NAME && node[2][1] == TEMP_DOUBLE_PTR) ||
-         (node[2][0] == BINARY && ((node[2][2][0] == NAME && node[2][2][1] == TEMP_DOUBLE_PTR) ||
-                                     (node[2][3][0] == NAME && node[2][3][1] == TEMP_DOUBLE_PTR)));
-}
-
-class StringIntMap : public std::unordered_map<IString, int> {
-public:
-  HASES
-};
-
-class StringStringMap : public std::unordered_map<IString, IString> {
-public:
-  HASES
-};
-
-class StringRefMap : public std::unordered_map<IString, Ref> {
-public:
-  HASES
-};
-
-class StringTypeMap : public std::unordered_map<IString, AsmType> {
-public:
-  HASES
-};
-
-void eliminate(Ref ast, bool memSafe) {
-#ifdef PROFILING
-  clock_t tasmdata = 0;
-  clock_t tfnexamine = 0;
-  clock_t tvarcheck = 0;
-  clock_t tstmtelim = 0;
-  clock_t tstmtscan = 0;
-  clock_t tcleanvars = 0;
-  clock_t treconstruct = 0;
-#endif
-
-  // Find variables that have a single use, and if they can be eliminated, do so
-  traverseFunctions(ast, [&](Ref func) {
-
-#ifdef PROFILING
-    clock_t start = clock();
-#endif
-
-    AsmData asmData(func);
-
-#ifdef PROFILING
-    tasmdata += clock() - start;
-    start = clock();
-#endif
-
-    // First, find the potentially eliminatable functions: that have one definition and one use
-
-    StringIntMap definitions;
-    StringIntMap uses;
-    StringIntMap namings;
-    StringRefMap values;
-    StringIntMap varsToRemove; // variables being removed, that we can eliminate all 'var x;' of (this refers to VAR nodes we should remove)
-                            // 1 means we should remove it, 2 means we successfully removed it
-    StringSet varsToTryToRemove; // variables that have 0 uses, but have side effects - when we scan we can try to remove them
-
-    // examine body and note locals
-    traversePre(func, [&](Ref node) {
-      Ref type = node[0];
-      if (type == NAME) {
-        IString& name = node[1]->getIString();
-        uses[name]++;
-        namings[name]++;
-      } else if (type == ASSIGN) {
-        Ref target = node[2];
-        if (target[0] == NAME) {
-          IString& name = target[1]->getIString();
-          // values is only used if definitions is 1
-          if (definitions[name]++ == 0) {
-            values[name] = node[3];
-          }
-          assert(node[1]->isBool(true)); // not +=, -= etc., just =
-          uses[name]--; // because the name node will show up by itself in the previous case
-        }
-      }
-    });
-
-#ifdef PROFILING
-    tfnexamine += clock() - start;
-    start = clock();
-#endif
-
-    StringSet potentials; // local variables with 1 definition and 1 use
-    StringSet sideEffectFree; // whether a local variable has no side effects in its definition. Only relevant when there are no uses
-
-    auto unprocessVariable = [&](IString name) {
-      potentials.erase(name);
-      varsToRemove.erase(name);
-      sideEffectFree.erase(name);
-      varsToTryToRemove.erase(name);
-    };
-    std::function<void (IString)> processVariable = [&](IString name) {
-      if (definitions[name] == 1 && uses[name] == 1) {
-        potentials.insert(name);
-      } else if (uses[name] == 0 && definitions[name] <= 1) { // no uses, no def or 1 def (cannot operate on phis, and the llvm optimizer will remove unneeded phis anyhow) (no definition means it is a function parameter, or a local with just |var x;| but no defining assignment)
-        bool sideEffects = false;
-        auto val = values.find(name);
-        Ref value;
-        if (val != values.end()) {
-          value = val->second;
-          // TODO: merge with other side effect code
-          // First, pattern-match
-          //  (HEAP32[((tempDoublePtr)>>2)]=((HEAP32[(($_sroa_0_0__idx1)>>2)])|0),HEAP32[(((tempDoublePtr)+(4))>>2)]=((HEAP32[((($_sroa_0_0__idx1)+(4))>>2)])|0),(+(HEAPF64[(tempDoublePtr)>>3])))
-          // which has no side effects and is the special form of converting double to i64.
-          if (!(value[0] == SEQ && value[1][0] == ASSIGN && value[1][2][0] == SUB && value[1][2][2][0] == BINARY && value[1][2][2][1] == RSHIFT &&
-                value[1][2][2][2][0] == NAME && value[1][2][2][2][1] == TEMP_DOUBLE_PTR)) {
-            // If not that, then traverse and scan normally.
-            sideEffects = hasSideEffects(value);
-          }
-        }
-        if (!sideEffects) {
-          varsToRemove[name] = !definitions[name] ? 2 : 1; // remove it normally
-          sideEffectFree.insert(name);
-          // Each time we remove a variable with 0 uses, if its value has no
-          // side effects and vanishes too, then we can remove a use from variables
-          // appearing in it, and possibly eliminate again
-          if (!!value) {
-            traversePre(value, [&](Ref node) {
-              if (node[0] == NAME) {
-                IString name = node[1]->getIString();
-                node[1]->setString(EMPTY); // we can remove this - it will never be shown, and should not be left to confuse us as we traverse
-                if (asmData.isLocal(name)) {
-                  uses[name]--; // cannot be infinite recursion since we descend an energy function
-                  assert(uses[name] >= 0);
-                  unprocessVariable(name);
-                  processVariable(name);
-                }
-              } else if (node[0] == CALL) {
-                // no side effects, so this must be a Math.* call or such. We can just ignore it and all children
-                node[0]->setString(NAME);
-                node[1]->setString(EMPTY);
-              }
-            });
-          }
-        } else {
-          varsToTryToRemove.insert(name); // try to remove it later during scanning
-        }
-      }
-    };
-    for (auto name : asmData.locals) {
-      processVariable(name.first);
-    }
-
-#ifdef PROFILING
-    tvarcheck += clock() - start;
-    start = clock();
-#endif
-
-    //printErr('defs: ' + JSON.stringify(definitions));
-    //printErr('uses: ' + JSON.stringify(uses));
-    //printErr('values: ' + JSON.stringify(values));
-    //printErr('locals: ' + JSON.stringify(locals));
-    //printErr('varsToRemove: ' + JSON.stringify(varsToRemove));
-    //printErr('varsToTryToRemove: ' + JSON.stringify(varsToTryToRemove));
-    values.clear();
-    //printErr('potentials: ' + JSON.stringify(potentials));
-    // We can now proceed through the function. In each list of statements, we try to eliminate
-    struct Tracking {
-      bool usesGlobals, usesMemory, hasDeps;
-      Ref defNode;
-      bool doesCall;
-    };
-    class Tracked : public std::unordered_map<IString, Tracking> {
-    public:
-      HASES
-    };
-    Tracked tracked;
-    #define dumpTracked() { errv("tracking %d", tracked.size()); for (auto t : tracked) errv("... %s", t.first.c_str()); }
-    // Although a set would be more appropriate, it would also be slower
-    std::unordered_map<IString, StringVec> depMap;
-
-    bool globalsInvalidated = false; // do not repeat invalidations, until we track something new
-    bool memoryInvalidated = false;
-    bool callsInvalidated = false;
-    auto track = [&](IString name, Ref value, Ref defNode) { // add a potential that has just been defined to the tracked list, we hope to eliminate it
-      Tracking& track = tracked[name];
-      track.usesGlobals = false;
-      track.usesMemory = false;
-      track.hasDeps = false;
-      track.defNode = defNode;
-      track.doesCall = false;
-      bool ignoreName = false; // one-time ignorings of names, as first op in sub and call
-      traversePre(value, [&](Ref node) {
-        Ref type = node[0];
-        if (type == NAME) {
-          if (!ignoreName) {
-            IString depName = node[1]->getIString();
-            if (!asmData.isLocal(depName)) {
-              track.usesGlobals = true;
-            }
-            if (!potentials.has(depName)) { // deps do not matter for potentials - they are defined once, so no complexity
-              depMap[depName].push_back(name);
-              track.hasDeps = true;
-            }
-          } else {
-            ignoreName = false;
-          }
-        } else if (type == SUB) {
-          track.usesMemory = true;
-          ignoreName = true;
-        } else if (type == CALL) {
-          track.usesGlobals = true;
-          track.usesMemory = true;
-          track.doesCall = true;
-          ignoreName = true;
-        } else {
-          ignoreName = false;
-        }
-      });
-      if (track.usesGlobals) globalsInvalidated = false;
-      if (track.usesMemory) memoryInvalidated = false;
-      if (track.doesCall) callsInvalidated = false;
-    };
-
-    // TODO: invalidate using a sequence number for each type (if you were tracked before the last invalidation, you are cancelled). remove for.in loops
-    #define INVALIDATE(what, check) \
-    auto invalidate##what = [&]() { \
-      std::vector<IString> temp; \
-      for (auto t : tracked) { \
-        IString name = t.first; \
-        Tracking& info = tracked[name]; \
-        if (check) { \
-          temp.push_back(name); \
-        } \
-      } \
-      for (size_t i = 0; i < temp.size(); i++) { \
-        tracked.erase(temp[i]); \
-      } \
-    };
-    INVALIDATE(Globals, info.usesGlobals);
-    INVALIDATE(Memory, info.usesMemory);
-    INVALIDATE(Calls, info.doesCall);
-
-    auto invalidateByDep = [&](IString dep) {
-      for (auto name : depMap[dep]) {
-        tracked.erase(name);
-      }
-      depMap.erase(dep);
-    };
-
-    std::function<void (IString name, Ref node)> doEliminate;
-
-    // Generate the sequence of execution. This determines what is executed before what, so we know what can be reordered. Using
-    // that, performs invalidations and eliminations
-    auto scan = [&](Ref node) {
-      bool abort = false;
-      bool allowTracking = true; // false inside an if; also prevents recursing in an if
-      std::function<void (Ref, bool)> traverseInOrder = [&](Ref node, bool ignoreSub) {
-        if (abort) return;
-        Ref type = node[0];
-        if (type == ASSIGN) {
-          Ref target = node[2];
-          Ref value = node[3];
-          bool nameTarget = target[0] == NAME;
-          // If this is an assign to a name, handle it below rather than
-          // traversing and treating as a read
-          if (!nameTarget) {
-            traverseInOrder(target, true); // evaluate left
-          }
-          traverseInOrder(value,  false); // evaluate right
-          // do the actual assignment
-          if (nameTarget) {
-            IString name = target[1]->getIString();
-            if (potentials.has(name) && allowTracking) {
-              track(name, node[3], node);
-            } else if (varsToTryToRemove.has(name)) {
-              // replace it in-place
-              safeCopy(node, value);
-              varsToRemove[name] = 2;
-            } else {
-              // expensive check for invalidating specific tracked vars. This list is generally quite short though, because of
-              // how we just eliminate in short spans and abort when control flow happens TODO: history numbers instead
-              invalidateByDep(name); // can happen more than once per dep..
-              if (!asmData.isLocal(name) && !globalsInvalidated) {
-                invalidateGlobals();
-                globalsInvalidated = true;
-              }
-              // if we can track this name (that we assign into), and it has 0 uses and we want to remove its VAR
-              // definition - then remove it right now, there is no later chance
-              if (allowTracking && varsToRemove.has(name) && uses[name] == 0) {
-                track(name, node[3], node);
-                doEliminate(name, node);
-              }
-            }
-          } else if (target[0] == SUB) {
-            if (isTempDoublePtrAccess(target)) {
-              if (!globalsInvalidated) {
-                invalidateGlobals();
-                globalsInvalidated = true;
-              }
-            } else if (!memoryInvalidated) {
-              invalidateMemory();
-              memoryInvalidated = true;
-            }
-          }
-        } else if (type == SUB) {
-          // Only keep track of the global array names in memsafe mode i.e.
-          // when they may change underneath us due to resizing
-          if (node[1][0] != NAME || memSafe) {
-            traverseInOrder(node[1], false); // evaluate inner
-          }
-          traverseInOrder(node[2], false); // evaluate outer
-          // ignoreSub means we are a write (happening later), not a read
-          if (!ignoreSub && !isTempDoublePtrAccess(node)) {
-            // do the memory access
-            if (!callsInvalidated) {
-              invalidateCalls();
-              callsInvalidated = true;
-            }
-          }
-        } else if (type == BINARY) {
-          bool flipped = false;
-          if (ASSOCIATIVE_BINARIES.has(node[1]) && !NAME_OR_NUM.has(node[2][0]) && NAME_OR_NUM.has(node[3][0])) { // TODO recurse here?
-            // associatives like + and * can be reordered in the simple case of one of the sides being a name, since we assume they are all just numbers
-            Ref temp = node[2];
-            node[2] = node[3];
-            node[3] = temp;
-            flipped = true;
-          }
-          traverseInOrder(node[2], false);
-          traverseInOrder(node[3], false);
-          if (flipped && NAME_OR_NUM.has(node[2][0])) { // dunno if we optimized, but safe to flip back - and keeps the code closer to the original and more readable
-            Ref temp = node[2];
-            node[2] = node[3];
-            node[3] = temp;
-          }
-        } else if (type == NAME) {
-          IString name = node[1]->getIString();
-          if (tracked.has(name)) {
-            doEliminate(name, node);
-          } else if (!asmData.isLocal(name) && !callsInvalidated && (memSafe || !HEAP_NAMES.has(name))) { // ignore HEAP8 etc when not memory safe, these are ok to
-                                                                                                          // access, e.g. SIMD_Int32x4_load(HEAP8, ...)
-            invalidateCalls();
-            callsInvalidated = true;
-          }
-        } else if (type == UNARY_PREFIX || type == UNARY_POSTFIX) {
-          traverseInOrder(node[2], false);
-        } else if (IGNORABLE_ELIMINATOR_SCAN_NODES.has(type)) {
-        } else if (type == CALL) {
-          // Named functions never change and are therefore safe to not track
-          if (node[1][0] != NAME) {
-            traverseInOrder(node[1], false);
-          }
-          Ref args = node[2];
-          for (size_t i = 0; i < args->size(); i++) {
-            traverseInOrder(args[i], false);
-          }
-          if (callHasSideEffects(node)) {
-            // these two invalidations will also invalidate calls
-            if (!globalsInvalidated) {
-              invalidateGlobals();
-              globalsInvalidated = true;
-            }
-            if (!memoryInvalidated) {
-              invalidateMemory();
-              memoryInvalidated = true;
-            }
-          }
-        } else if (type == IF) {
-          if (allowTracking) {
-            traverseInOrder(node[1], false); // can eliminate into condition, but nowhere else
-            if (!callsInvalidated) { // invalidate calls, since we cannot eliminate them into an if that may not execute!
-              invalidateCalls();
-              callsInvalidated = true;
-            }
-            allowTracking = false;
-            traverseInOrder(node[2], false); // 2 and 3 could be 'parallel', really..
-            if (!!node[3]) traverseInOrder(node[3], false);
-            allowTracking = true;
-          } else {
-            tracked.clear();
-          }
-        } else if (type == BLOCK) {
-          Ref stats = getStatements(node);
-          if (!!stats) {
-            for (size_t i = 0; i < stats->size(); i++) {
-              traverseInOrder(stats[i], false);
-            }
-          }
-        } else if (type == STAT) {
-          traverseInOrder(node[1], false);
-        } else if (type == LABEL) {
-          traverseInOrder(node[2], false);
-        } else if (type == SEQ) {
-          traverseInOrder(node[1], false);
-          traverseInOrder(node[2], false);
-        } else if (type == DO) {
-          if (node[1][0] == NUM && node[1][1]->getNumber() == 0) { // one-time loop
-            traverseInOrder(node[2], false);
-          } else {
-            tracked.clear();
-          }
-        } else if (type == RETURN) {
-          if (!!node[1]) traverseInOrder(node[1], false);
-        } else if (type == CONDITIONAL) {
-          if (!callsInvalidated) { // invalidate calls, since we cannot eliminate them into a branch of an LLVM select/JS conditional that does not execute
-            invalidateCalls();
-            callsInvalidated = true;
-          }
-          traverseInOrder(node[1], false);
-          traverseInOrder(node[2], false);
-          traverseInOrder(node[3], false);
-        } else if (type == SWITCH) {
-          traverseInOrder(node[1], false);
-          Tracked originalTracked = tracked;
-          Ref cases = node[2];
-          for (size_t i = 0; i < cases->size(); i++) {
-            Ref c = cases[i];
-            assert(c[0]->isNull() || c[0][0] == NUM || (c[0][0] == UNARY_PREFIX && c[0][2][0] == NUM));
-            Ref stats = c[1];
-            for (size_t j = 0; j < stats->size(); j++) {
-              traverseInOrder(stats[j], false);
-            }
-            // We cannot track from one switch case into another if there are external dependencies, undo all new trackings
-            // Otherwise we can track, e.g. a var used in a case before assignment in another case is UB in asm.js, so no need for the assignment
-            // TODO: general framework here, use in if-else as well
-            std::vector<IString> toDelete;
-            for (auto t : tracked) {
-              if (!originalTracked.has(t.first)) {
-                Tracking& info = tracked[t.first];
-                if (info.usesGlobals || info.usesMemory || info.hasDeps) {
-                  toDelete.push_back(t.first);
-                }
-              }
-            }
-            for (auto t : toDelete) {
-              tracked.erase(t);
-            }
-          }
-          tracked.clear(); // do not track from inside the switch to outside
-        } else {
-          assert(ABORTING_ELIMINATOR_SCAN_NODES.has(type));
-          tracked.clear();
-          abort = true;
-        }
-      };
-      traverseInOrder(node, false);
-    };
-    //var eliminationLimit = 0; // used to debugging purposes
-    doEliminate = [&](IString name, Ref node) {
-      //if (eliminationLimit == 0) return;
-      //eliminationLimit--;
-      //printErr('elim!!!!! ' + name);
-      // yes, eliminate!
-      varsToRemove[name] = 2; // both assign and var definitions can have other vars we must clean up
-      assert(tracked.has(name));
-      Tracking& info = tracked[name];
-      Ref defNode = info.defNode;
-      assert(!!defNode);
-      if (!sideEffectFree.has(name)) {
-        assert(defNode[0] != VAR);
-        // assign
-        Ref value = defNode[3];
-        // wipe out the assign
-        safeCopy(defNode, makeEmpty());
-        // replace this node in-place
-        safeCopy(node, value);
-      } else {
-        // This has no side effects and no uses, empty it out in-place
-        safeCopy(node, makeEmpty());
-      }
-      tracked.erase(name);
-    };
-    traversePre(func, [&](Ref block) {
-      // Look for statements, including while-switch pattern
-      Ref stats = getStatements(block);
-      if (!stats && (block[0] == WHILE && block[2][0] == SWITCH)) {
-        stats = &(makeArray(1)->push_back(block[2]));
-      }
-      if (!stats) return;
-      tracked.clear();
-      for (size_t i = 0; i < stats->size(); i++) {
-        Ref node = deStat(stats[i]);
-        Ref type = node[0];
-        if (type == RETURN && i+1 < stats->size()) {
-          stats->setSize(i+1); // remove any code after a return
-        }
-        // Check for things that affect elimination
-        if (ELIMINATION_SAFE_NODES.has(type)) {
-#ifdef PROFILING
-          tstmtelim += clock() - start;
-          start = clock();
-#endif
-          scan(node);
-#ifdef PROFILING
-          tstmtscan += clock() - start;
-          start = clock();
-#endif
-        } else if (type == VAR) {
-          continue; // asm normalisation has reduced 'var' to just the names
-        } else {
-          tracked.clear(); // not a var or assign, break all potential elimination so far
-        }
-      }
-    });
-
-#ifdef PROFILING
-    tstmtelim += clock() - start;
-    start = clock();
-#endif
-
-    StringIntMap seenUses;
-    StringStringMap helperReplacements; // for looper-helper optimization
-
-    // clean up vars, and loop variable elimination
-    traversePrePost(func, [&](Ref node) {
-      // pre
-      Ref type = node[0];
-      /*if (type == VAR) {
-        node[1] = node[1].filter(function(pair) { return !varsToRemove[pair[0]] });
-        if (node[1]->size() == 0) {
-          // wipe out an empty |var;|
-          node[0] = TOPLEVEL;
-          node[1] = [];
-        }
-      } else */
-      if (type == ASSIGN && node[1]->isBool(true) && node[2][0] == NAME && node[3][0] == NAME && node[2][1] == node[3][1]) {
-        // elimination led to X = X, which we can just remove
-        safeCopy(node, makeEmpty());
-      }
-    }, [&](Ref node) {
-      // post
-      Ref type = node[0];
-      if (type == NAME) {
-        IString name = node[1]->getIString();
-        if (helperReplacements.has(name)) {
-          node[1]->setString(helperReplacements[name]);
-          return; // no need to track this anymore, we can't loop-optimize more than once
-        }
-        // track how many uses we saw. we need to know when a variable is no longer used (hence we run this in the post)
-        seenUses[name]++;
-      } else if (type == WHILE) {
-        // try to remove loop helper variables specifically
-        Ref stats = node[2][1];
-        Ref last = stats->back();
-        if (!!last && last[0] == IF && last[2][0] == BLOCK && !!last[3] && last[3][0] == BLOCK) {
-          Ref ifTrue = last[2];
-          Ref ifFalse = last[3];
-          clearEmptyNodes(ifTrue[1]);
-          clearEmptyNodes(ifFalse[1]);
-          bool flip = false;
-          if (ifFalse[1]->size() > 0 && !!ifFalse[1][0] && !!ifFalse[1]->back() && ifFalse[1]->back()[0] == BREAK) { // canonicalize break in the if-true
-            Ref temp = ifFalse;
-            ifFalse = ifTrue;
-            ifTrue = temp;
-            flip = true;
-          }
-          if (ifTrue[1]->size() > 0 && !!ifTrue[1][0] && !!ifTrue[1]->back() && ifTrue[1]->back()[0] == BREAK) {
-            Ref assigns = ifFalse[1];
-            clearEmptyNodes(assigns);
-            std::vector<IString> loopers, helpers;
-            for (size_t i = 0; i < assigns->size(); i++) {
-              if (assigns[i][0] == STAT && assigns[i][1][0] == ASSIGN) {
-                Ref assign = assigns[i][1];
-                if (assign[1]->isBool(true) && assign[2][0] == NAME && assign[3][0] == NAME) {
-                  IString looper = assign[2][1]->getIString();
-                  IString helper = assign[3][1]->getIString();
-                  if (definitions[helper] == 1 && seenUses[looper] == namings[looper] &&
-                      !helperReplacements.has(helper) && !helperReplacements.has(looper)) {
-                    loopers.push_back(looper);
-                    helpers.push_back(helper);
-                  }
-                }
-              }
-            }
-            // remove loop vars that are used in the rest of the else
-            for (size_t i = 0; i < assigns->size(); i++) {
-              if (assigns[i][0] == STAT && assigns[i][1][0] == ASSIGN) {
-                Ref assign = assigns[i][1];
-                if (!(assign[1]->isBool(true) && assign[2][0] == NAME && assign[3][0] == NAME) || indexOf(loopers, assign[2][1]->getIString()) < 0) {
-                  // this is not one of the loop assigns
-                  traversePre(assign, [&](Ref node) {
-                    if (node[0] == NAME) {
-                      int index = indexOf(loopers, node[1]->getIString());
-                      if (index < 0) index = indexOf(helpers, node[1]->getIString());
-                      if (index >= 0) {
-                        loopers.erase(loopers.begin() + index);
-                        helpers.erase(helpers.begin() + index);
-                      }
-                    }
-                  });
-                }
-              }
-            }
-            // remove loop vars that are used in the if
-            traversePre(ifTrue, [&](Ref node) {
-              if (node[0] == NAME) {
-                int index = indexOf(loopers, node[1]->getIString());
-                if (index < 0) index = indexOf(helpers, node[1]->getIString());
-                if (index >= 0) {
-                  loopers.erase(loopers.begin() + index);
-                  helpers.erase(helpers.begin() + index);
-                }
-              }
-            });
-            if (loopers.size() == 0) return;
-            for (size_t l = 0; l < loopers.size(); l++) {
-              IString looper = loopers[l];
-              IString helper = helpers[l];
-              // the remaining issue is whether loopers are used after the assignment to helper and before the last line (where we assign to it)
-              int found = -1;
-              for (int i = (int)stats->size()-2; i >= 0; i--) {
-                Ref curr = stats[i];
-                if (curr[0] == STAT && curr[1][0] == ASSIGN) {
-                  Ref currAssign = curr[1];
-                  if (currAssign[1]->isBool(true) && currAssign[2][0] == NAME) {
-                    IString to = currAssign[2][1]->getIString();
-                    if (to == helper) {
-                      found = i;
-                      break;
-                    }
-                  }
-                }
-              }
-              if (found < 0) return;
-              // if a loop variable is used after we assigned to the helper, we must save its value and use that.
-              // (note that this can happen due to elimination, if we eliminate an expression containing the
-              // loop var far down, past the assignment!)
-              // first, see if the looper and helpers overlap. Note that we check for this looper, compared to
-              // *ALL* the helpers. Helpers will be replaced by loopers as we eliminate them, potentially
-              // causing conflicts, so any helper is a concern.
-              int firstLooperUsage = -1;
-              int lastLooperUsage = -1;
-              int firstHelperUsage = -1;
-              for (int i = found+1; i < (int)stats->size(); i++) {
-                Ref curr = i < (int)stats->size()-1 ? stats[i] : last[1]; // on the last line, just look in the condition
-                traversePre(curr, [&](Ref node) {
-                  if (node[0] == NAME) {
-                    if (node[1] == looper) {
-                      if (firstLooperUsage < 0) firstLooperUsage = i;
-                      lastLooperUsage = i;
-                    } else if (indexOf(helpers, node[1]->getIString()) >= 0) {
-                      if (firstHelperUsage < 0) firstHelperUsage = i;
-                    }
-                  }
-                });
-              }
-              if (firstLooperUsage >= 0) {
-                // the looper is used, we cannot simply merge the two variables
-                if ((firstHelperUsage < 0 || firstHelperUsage > lastLooperUsage) && lastLooperUsage+1 < (int)stats->size() && triviallySafeToMove(stats[found], asmData) &&
-                    seenUses[helper] == namings[helper]) {
-                  // the helper is not used, or it is used after the last use of the looper, so they do not overlap,
-                  // and the last looper usage is not on the last line (where we could not append after it), and the
-                  // helper is not used outside of the loop.
-                  // just move the looper definition to after the looper's last use
-                  stats->insert(lastLooperUsage+1, stats[found]);
-                  stats->splice(found, 1);
-                } else {
-                  // they overlap, we can still proceed with the loop optimization, but we must introduce a
-                  // loop temp helper variable
-                  IString temp(strdupe((std::string(looper.c_str()) + "$looptemp").c_str()));
-                  assert(!asmData.isLocal(temp));
-                  for (int i = firstLooperUsage; i <= lastLooperUsage; i++) {
-                    Ref curr = i < (int)stats->size()-1 ? stats[i] : last[1]; // on the last line, just look in the condition
-
-                    std::function<bool (Ref)> looperToLooptemp = [&](Ref node) {
-                      if (node[0] == NAME) {
-                        if (node[1] == looper) {
-                          node[1]->setString(temp);
-                        }
-                      } else if (node[0] == ASSIGN && node[2][0] == NAME) {
-                        // do not traverse the assignment target, phi assignments to the loop variable must remain
-                        traversePrePostConditional(node[3], looperToLooptemp, [](Ref node){});
-                        return false;
-                      }
-                      return true;
-                    };
-                    traversePrePostConditional(curr, looperToLooptemp, [](Ref node){});
-                  }
-                  asmData.addVar(temp, asmData.getType(looper));
-                  stats->insert(found, make1(STAT, make3(ASSIGN, makeBool(true), makeName(temp), makeName(looper))));
-                }
-              }
-            }
-            for (size_t l = 0; l < helpers.size(); l++) {
-              for (size_t k = 0; k < helpers.size(); k++) {
-                if (l != k && helpers[l] == helpers[k]) return; // it is complicated to handle a shared helper, abort
-              }
-            }
-            // hurrah! this is safe to do
-            for (size_t l = 0; l < loopers.size(); l++) {
-              IString looper = loopers[l];
-              IString helper = helpers[l];
-              varsToRemove[helper] = 2;
-              traversePre(node, [&](Ref node) { // replace all appearances of helper with looper
-                if (node[0] == NAME && node[1] == helper) node[1]->setString(looper);
-              });
-              helperReplacements[helper] = looper; // replace all future appearances of helper with looper
-              helperReplacements[looper] = looper; // avoid any further attempts to optimize looper in this manner (seenUses is wrong anyhow, too)
-            }
-            // simplify the if. we remove the if branch, leaving only the else
-            if (flip) {
-              last[1] = simplifyNotCompsDirect(make2(UNARY_PREFIX, L_NOT, last[1]));
-              Ref temp = last[2];
-              last[2] = last[3];
-              last[3] = temp;
-            }
-            if (loopers.size() == assigns->size()) {
-              last->pop_back();
-            } else {
-              Ref elseStats = getStatements(last[3]);
-              for (size_t i = 0; i < elseStats->size(); i++) {
-                Ref stat = deStat(elseStats[i]);
-                if (stat[0] == ASSIGN && stat[2][0] == NAME) {
-                  if (indexOf(loopers, stat[2][1]->getIString()) >= 0) {
-                    elseStats[i] = makeEmpty();
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    });
-
-#ifdef PROFILING
-    tcleanvars += clock() - start;
-    start = clock();
-#endif
-
-    for (auto v : varsToRemove) {
-      if (v.second == 2 && asmData.isVar(v.first)) asmData.deleteVar(v.first);
-    }
-
-    asmData.denormalize();
-
-#ifdef PROFILING
-    treconstruct += clock() - start;
-    start = clock();
-#endif
-
-  });
-
-  removeAllEmptySubNodes(ast);
-
-#ifdef PROFILING
-  errv("    EL stages: a:%li fe:%li vc:%li se:%li (ss:%li) cv:%li r:%li",
-    tasmdata, tfnexamine, tvarcheck, tstmtelim, tstmtscan, tcleanvars, treconstruct);
-#endif
-}
-
-void eliminateMemSafe(Ref ast) {
-  eliminate(ast, true);
-}
-
-void simplifyExpressions(Ref ast) {
-  // Simplify common expressions used to perform integer conversion operations
-  // in cases where no conversion is needed.
-  auto simplifyIntegerConversions = [](Ref ast) {
-    traversePre(ast, [](Ref node) {
-      Ref type = node[0];
-      if (type == BINARY       && node[1]    == RSHIFT && node[3][0] == NUM &&
-          node[2][0] == BINARY && node[2][1] == LSHIFT && node[2][3][0] == NUM && node[3][1]->getNumber() == node[2][3][1]->getNumber()) {
-        // Transform (x&A)<<B>>B to X&A.
-        Ref innerNode = node[2][2];
-        double shifts = node[3][1]->getNumber();
-        if (innerNode[0] == BINARY && innerNode[1] == AND && innerNode[3][0] == NUM) {
-          double mask = innerNode[3][1]->getNumber();
-          if (isInteger32(mask) && isInteger32(shifts) && ((jsD2I(mask) << jsD2I(shifts)) >> jsD2I(shifts)) == jsD2I(mask)) {
-            safeCopy(node, innerNode);
-            return;
-          }
-        }
-      } else if (type == BINARY && BITWISE.has(node[1])) {
-        for (int i = 2; i <= 3; i++) {
-          Ref subNode = node[i];
-          if (subNode[0] == BINARY && subNode[1] == AND && subNode[3][0] == NUM && subNode[3][1]->getNumber() == 1) {
-            // Rewrite (X < Y) & 1 to X < Y , when it is going into a bitwise operator. We could
-            // remove even more (just replace &1 with |0, then subsequent passes could remove the |0)
-            // but v8 issue #2513 means the code would then run very slowly in chrome.
-            Ref input = subNode[2];
-            if (input[0] == BINARY && COMPARE_OPS.has(input[1])) {
-              safeCopy(node[i], input);
-            }
-          }
-        }
-      }
-    });
-  };
-
-  // When there is a bunch of math like (((8+5)|0)+12)|0, only the external |0 is needed, one correction is enough.
-  // At each node, ((X|0)+Y)|0 can be transformed into (X+Y): The inner corrections are not needed
-  // TODO: Is the same is true for 0xff, 0xffff?
-  // Likewise, if we have |0 inside a block that will be >>'d, then the |0 is unnecessary because some
-  // 'useful' mathops already |0 anyhow.
-
-  auto simplifyOps = [](Ref ast) {
-    auto removeMultipleOrZero = [&ast] {
-      bool rerun = true;
-      while (rerun) {
-        rerun = false;
-        std::vector<int> stack;
-        std::function<void (Ref)> process = [&stack, &rerun, &process, &ast](Ref node) {
-          Ref type = node[0];
-          if (type == BINARY && node[1] == OR) {
-            if (node[2][0] == NUM && node[3][0] == NUM) {
-              node[2][1]->setNumber(jsD2I(node[2][1]->getNumber()) | jsD2I(node[3][1]->getNumber()));
-              stack.push_back(0);
-              safeCopy(node, node[2]);
-              return;
-            }
-            bool go = false;
-            if (node[2][0] == NUM && node[2][1]->getNumber() == 0) {
-              // canonicalize order
-              Ref temp = node[3];
-              node[3] = node[2];
-              node[2] = temp;
-              go = true;
-            } else if (node[3][0] == NUM && node[3][1]->getNumber() == 0) {
-              go = true;
-            }
-            if (!go) {
-              stack.push_back(1);
-              return;
-            }
-            // We might be able to remove this correction
-            for (int i = stack.size()-1; i >= 0; i--) {
-              if (stack[i] >= 1) {
-                if (stack.back() < 2 && node[2][0] == CALL) break; // we can only remove multiple |0s on these
-                if (stack.back() < 1 && (COERCION_REQUIRING_OPS.has(node[2][0]) ||
-                                                 (node[2][0] == BINARY && COERCION_REQUIRING_BINARIES.has(node[2][1])))) break; // we can remove |0 or >>2
-                // we will replace ourselves with the non-zero side. Recursively process that node.
-                Ref result = node[2][0] == NUM && node[2][1]->getNumber() == 0 ? node[3] : node[2], other;
-                // replace node in-place
-                safeCopy(node, result);
-                rerun = true;
-                process(result);
-                return;
-              } else if (stack[i] == -1) {
-                break; // Too bad, we can't
-              }
-            }
-            stack.push_back(2); // From here on up, no need for this kind of correction, it's done at the top
-                           // (Add this at the end, so it is only added if we did not remove it)
-          } else if (type == BINARY && USEFUL_BINARY_OPS.has(node[1])) {
-            stack.push_back(1);
-          } else if ((type == BINARY && SAFE_BINARY_OPS.has(node[1])) || type == NUM || type == NAME) {
-            stack.push_back(0); // This node is safe in that it does not interfere with this optimization
-          } else if (type == UNARY_PREFIX && node[1] == B_NOT) {
-            stack.push_back(1);
-          } else {
-            stack.push_back(-1); // This node is dangerous! Give up if you see this before you see '1'
-          }
-        };
-
-        traversePrePost(ast, process, [&stack](Ref node) {
-          assert(!stack.empty());
-          stack.pop_back();
-        });
-      }
-    };
-
-    removeMultipleOrZero();
-
-    // & and heap-related optimizations
-
-    bool hasTempDoublePtr = false, rerunOrZeroPass = false;
-
-    traversePrePostConditional(ast, [](Ref node) {
-      // Detect trees which should not
-      // be simplified.
-      if (node[0] == SUB && node[1][0] == NAME && isFunctionTable(node[1][1])) {
-        return false; // do not traverse subchildren here, we should not collapse 55 & 126.
-      }
-      return true;
-    }, [&hasTempDoublePtr, &rerunOrZeroPass](Ref node) {
-      // Simplifications are done now so
-      // that we simplify a node's operands before the node itself. This allows
-      // optimizations to cascade.
-      Ref type = node[0];
-      if (type == NAME) {
-        if (node[1] == TEMP_DOUBLE_PTR) hasTempDoublePtr = true;
-      } else if (type == BINARY && node[1] == AND && node[3][0] == NUM) {
-        if (node[2][0] == NUM) {
-          safeCopy(node, makeNum(jsD2I(node[2][1]->getNumber()) & jsD2I(node[3][1]->getNumber())));
-          return;
-        }
-        Ref input = node[2];
-        double amount = node[3][1]->getNumber();
-        if (input[0] == BINARY && input[1] == AND && input[3][0] == NUM) {
-          // Collapse X & 255 & 1
-          node[3][1]->setNumber(jsD2I(amount) & jsD2I(input[3][1]->getNumber()));
-          node[2] = input[2];
-        } else if (input[0] == SUB && input[1][0] == NAME) {
-          // HEAP8[..] & 255 => HEAPU8[..]
-          HeapInfo hi = parseHeap(input[1][1]->getCString());
-          if (hi.valid) {
-            if (isInteger32(amount) && amount == powl(2, hi.bits)-1) {
-              if (!hi.unsign) {
-                input[1][1]->setString(getHeapStr(hi.bits, true)); // make unsigned
-              }
-              // we cannot return HEAPU8 without a coercion, but at least we do HEAP8 & 255 => HEAPU8 | 0
-              node[1]->setString(OR);
-              node[3][1]->setNumber(0);
-              return;
-            }
-          }
-        } else if (input[0] == BINARY && input[1] == RSHIFT &&
-                   input[2][0] == BINARY && input[2][1] == LSHIFT &&
-                   input[2][3][0] == NUM && input[3][0] == NUM &&
-                   input[2][3][1]->getInteger() == input[3][1]->getInteger() &&
-                   (~(0xFFFFFFFFu >> input[3][1]->getInteger()) & jsD2I(amount)) == 0) {
-            // x << 24 >> 24 & 255 => x & 255
-            return safeCopy(node, make3(BINARY, AND, input[2][2], node[3]));
-        }
-      } else if (type == BINARY && node[1] == XOR) {
-        // LLVM represents bitwise not as xor with -1. Translate it back to an actual bitwise not.
-        if (node[3][0] == UNARY_PREFIX && node[3][1] == MINUS && node[3][2][0] == NUM &&
-            node[3][2][1]->getNumber() == 1 &&
-            !(node[2][0] == UNARY_PREFIX && node[2][1] == B_NOT)) { // avoid creating ~~~ which is confusing for asm given the role of ~~
-          safeCopy(node, make2(UNARY_PREFIX, B_NOT, node[2]));
-          return;
-        }
-      } else if (type       == BINARY && node[1]    == RSHIFT && node[3][0]    == NUM &&
-                 node[2][0] == BINARY && node[2][1] == LSHIFT && node[2][3][0] == NUM &&
-                 node[2][2][0] == SUB && node[2][2][1][0] == NAME) {
-        // collapse HEAPU?8[..] << 24 >> 24 etc. into HEAP8[..] | 0
-        double amount = node[3][1]->getNumber();
-        if (amount == node[2][3][1]->getNumber()) {
-          HeapInfo hi = parseHeap(node[2][2][1][1]->getCString());
-          if (hi.valid && hi.bits == 32 - amount) {
-            node[2][2][1][1]->setString(getHeapStr(hi.bits, false));
-            node[1]->setString(OR);
-            node[2] = node[2][2];
-            node[3][1]->setNumber(0);
-            rerunOrZeroPass = true;
-            return;
-          }
-        }
-      } else if (type == ASSIGN) {
-        // optimizations for assigning into HEAP32 specifically
-        if (node[1]->isBool(true) && node[2][0] == SUB && node[2][1][0] == NAME) {
-          if (node[2][1][1] == HEAP32) {
-            // HEAP32[..] = x | 0 does not need the | 0 (unless it is a mandatory |0 of a call)
-            if (node[3][0] == BINARY && node[3][1] == OR) {
-              if (node[3][2][0] == NUM && node[3][2][1]->getNumber() == 0 && node[3][3][0] != CALL) {
-                node[3] = node[3][3];
-              } else if (node[3][3][0] == NUM && node[3][3][1]->getNumber() == 0 && node[3][2][0] != CALL) {
-                node[3] = node[3][2];
-              }
-            }
-          } else if (node[2][1][1] == HEAP8) {
-            // HEAP8[..] = x & 0xff does not need the & 0xff
-            if (node[3][0] == BINARY && node[3][1] == AND && node[3][3][0] == NUM && node[3][3][1]->getNumber() == 0xff) {
-              node[3] = node[3][2];
-            }
-          } else if (node[2][1][1] == HEAP16) {
-            // HEAP16[..] = x & 0xffff does not need the & 0xffff
-            if (node[3][0] == BINARY && node[3][1] == AND && node[3][3][0] == NUM && node[3][3][1]->getNumber() == 0xffff) {
-              node[3] = node[3][2];
-            }
-          }
-        }
-        Ref value = node[3];
-        if (value[0] == BINARY && value[1] == OR) {
-          // canonicalize order of |0 to end
-          if (value[2][0] == NUM && value[2][1]->getNumber() == 0) {
-            Ref temp = value[2];
-            value[2] = value[3];
-            value[3] = temp;
-          }
-          // if a seq ends in an |0, remove an external |0
-          // note that it is only safe to do this in assigns, like we are doing here (return (x, y|0); is not valid)
-          if (value[2][0] == SEQ && value[2][2][0] == BINARY && USEFUL_BINARY_OPS.has(value[2][2][1])) {
-            node[3] = value[2];
-          }
-        }
-      } else if (type == BINARY && node[1] == RSHIFT && node[2][0] == NUM && node[3][0] == NUM) {
-        // optimize num >> num, in asm we need this since we do not optimize shifts in asm.js
-        node[0]->setString(NUM);
-        node[1]->setNumber(jsD2I(node[2][1]->getNumber()) >> jsD2I(node[3][1]->getNumber()));
-        node->setSize(2);
-        return;
-      } else if (type == BINARY && node[1] == PLUS) {
-        // The most common mathop is addition, e.g. in getelementptr done repeatedly. We can join all of those,
-        // by doing (num+num) ==> newnum.
-        if (node[2][0] == NUM && node[3][0] == NUM) {
-          node[2][1]->setNumber(jsD2I(node[2][1]->getNumber()) + jsD2I(node[3][1]->getNumber()));
-          safeCopy(node, node[2]);
-          return;
-        }
-      }
-    });
-
-    if (rerunOrZeroPass) removeMultipleOrZero();
-
-    if (hasTempDoublePtr) {
-      AsmData asmData(ast);
-      traversePre(ast, [](Ref node) {
-        Ref type = node[0];
-        if (type == ASSIGN) {
-          if (node[1]->isBool(true) && node[2][0] == SUB && node[2][1][0] == NAME && node[2][1][1] == HEAP32) {
-            // remove bitcasts that are now obviously pointless, e.g.
-            // HEAP32[$45 >> 2] = HEAPF32[tempDoublePtr >> 2] = ($14 < $28 ? $14 : $28) - $42, HEAP32[tempDoublePtr >> 2] | 0;
-            Ref value = node[3];
-            if (value[0] == SEQ && value[1][0] == ASSIGN && value[1][2][0] == SUB && value[1][2][1][0] == NAME && value[1][2][1][1] == HEAPF32 &&
-                value[1][2][2][0] == BINARY && value[1][2][2][2][0] == NAME && value[1][2][2][2][1] == TEMP_DOUBLE_PTR) {
-              // transform to HEAPF32[$45 >> 2] = ($14 < $28 ? $14 : $28) - $42;
-              node[2][1][1]->setString(HEAPF32);
-              node[3] = value[1][3];
-            }
-          }
-        } else if (type == SEQ) {
-          // (HEAP32[tempDoublePtr >> 2] = HEAP32[$37 >> 2], +HEAPF32[tempDoublePtr >> 2])
-          //   ==>
-          // +HEAPF32[$37 >> 2]
-          if (node[0] == SEQ && node[1][0] == ASSIGN && node[1][2][0] == SUB && node[1][2][1][0] == NAME &&
-              (node[1][2][1][1] == HEAP32 || node[1][2][1][1] == HEAPF32) &&
-              node[1][2][2][0] == BINARY && node[1][2][2][2][0] == NAME && node[1][2][2][2][1] == TEMP_DOUBLE_PTR &&
-              node[1][3][0] == SUB && node[1][3][1][0] == NAME && (node[1][3][1][1] == HEAP32 || node[1][3][1][1] == HEAPF32) &&
-              node[2][0] != SEQ) { // avoid (x, y, z) which can be used for tempDoublePtr on doubles for alignment fixes
-            if (node[1][2][1][1] == HEAP32) {
-              node[1][3][1][1]->setString(HEAPF32);
-              safeCopy(node, makeAsmCoercion(node[1][3], detectType(node[2])));
-              return;
-            } else {
-              node[1][3][1][1]->setString(HEAP32);
-              safeCopy(node, make3(BINARY, OR, node[1][3], makeNum(0)));
-              return;
-            }
-          }
-        }
-      });
-
-      // finally, wipe out remaining ones by finding cases where all assignments to X are bitcasts, and all uses are writes to
-      // the other heap type, then eliminate the bitcast
-      struct BitcastData {
-        int define_HEAP32, define_HEAPF32, use_HEAP32, use_HEAPF32, namings;
-        bool ok;
-        std::vector<Ref> defines, uses;
-
-        BitcastData() : define_HEAP32(0), define_HEAPF32(0), use_HEAP32(0), use_HEAPF32(0), namings(0), ok(false) {}
-      };
-      std::unordered_map<IString, BitcastData> bitcastVars;
-      traversePre(ast, [&bitcastVars](Ref node) {
-        if (node[0] == ASSIGN && node[1]->isBool(true) && node[2][0] == NAME) {
-          Ref value = node[3];
-          if (value[0] == SEQ && value[1][0] == ASSIGN && value[1][2][0] == SUB && value[1][2][1][0] == NAME &&
-              (value[1][2][1][1] == HEAP32 || value[1][2][1][1] == HEAPF32) &&
-              value[1][2][2][0] == BINARY && value[1][2][2][2][0] == NAME && value[1][2][2][2][1] == TEMP_DOUBLE_PTR) {
-            IString name = node[2][1]->getIString();
-            IString heap = value[1][2][1][1]->getIString();
-            if (heap == HEAP32) {
-              bitcastVars[name].define_HEAP32++;
-            } else {
-              assert(heap == HEAPF32);
-              bitcastVars[name].define_HEAPF32++;
-            }
-            bitcastVars[name].defines.push_back(node);
-            bitcastVars[name].ok = true;
-          }
-        }
-      });
-      traversePre(ast, [&bitcastVars](Ref node) {
-        Ref type = node[0];
-        if (type == NAME && bitcastVars[node[1]->getCString()].ok) {
-          bitcastVars[node[1]->getCString()].namings++;
-        } else if (type == ASSIGN && node[1]->isBool(true)) {
-          Ref value = node[3];
-          if (value[0] == NAME) {
-            IString name = value[1]->getIString();
-            if (bitcastVars[name].ok) {
-              Ref target = node[2];
-              if (target[0] == SUB && target[1][0] == NAME && (target[1][1] == HEAP32 || target[1][1] == HEAPF32)) {
-                if (target[1][1] == HEAP32) {
-                  bitcastVars[name].use_HEAP32++;
-                } else {
-                  bitcastVars[name].use_HEAPF32++;
-                }
-                bitcastVars[name].uses.push_back(node);
-              }
-            }
-          }
-        }
-      });
-      for (auto iter : bitcastVars) {
-        const IString& v = iter.first;
-        BitcastData& info = iter.second;
-        // good variables define only one type, use only one type, have definitions and uses, and define as a different type than they use
-        if (info.define_HEAP32*info.define_HEAPF32 == 0 && info.use_HEAP32*info.use_HEAPF32 == 0 &&
-            info.define_HEAP32+info.define_HEAPF32 > 0  && info.use_HEAP32+info.use_HEAPF32 > 0 &&
-            info.define_HEAP32*info.use_HEAP32 == 0 && info.define_HEAPF32*info.use_HEAPF32 == 0 &&
-            asmData.isLocal(v.c_str()) && info.namings == info.define_HEAP32+info.define_HEAPF32+info.use_HEAP32+info.use_HEAPF32) {
-          IString& correct = info.use_HEAP32 ? HEAPF32 : HEAP32;
-          for (auto define : info.defines) {
-            define[3] = define[3][1][3];
-            if (correct == HEAP32) {
-              define[3] = make3(BINARY, OR, define[3], makeNum(0));
-            } else {
-              assert(correct == HEAPF32);
-              define[3] = makeAsmCoercion(define[3], preciseF32 ? ASM_FLOAT : ASM_DOUBLE);
-            }
-            // do we want a simplifybitops on the new values here?
-          }
-          for (auto use : info.uses) {
-            use[2][1][1]->setString(correct.c_str());
-          }
-          AsmType correctType;
-          switch(asmData.getType(v.c_str())) {
-            case ASM_INT: correctType = preciseF32 ? ASM_FLOAT : ASM_DOUBLE; break;
-            case ASM_FLOAT: case ASM_DOUBLE: correctType = ASM_INT; break;
-            default: assert(0);
-          }
-          asmData.setType(v.c_str(), correctType);
-        }
-      }
-      asmData.denormalize();
-    }
-  };
-
-  std::function<bool (Ref)> emitsBoolean = [&emitsBoolean](Ref node) {
-    Ref type = node[0];
-    if (type == NUM) {
-      return node[1]->getNumber() == 0 || node[1]->getNumber() == 1;
-    }
-    if (type == BINARY) return COMPARE_OPS.has(node[1]);
-    if (type == UNARY_PREFIX) return node[1] == L_NOT;
-    if (type == CONDITIONAL) return emitsBoolean(node[2]) && emitsBoolean(node[3]);
-    return false;
-  };
-
-  //   expensive | expensive can be turned into expensive ? 1 : expensive, and
-  //   expensive | cheap     can be turned into cheap     ? 1 : expensive,
-  // so that we can avoid the expensive computation, if it has no side effects.
-  auto conditionalize = [&emitsBoolean](Ref ast) {
-    traversePre(ast, [&emitsBoolean](Ref node) {
-        const int MIN_COST = 7;
-        if (node[0] == BINARY && (node[1] == OR || node[1] == AND) && node[3][0] != NUM && node[2][0] != NUM) {
-        // logical operator on two non-numerical values
-        Ref left = node[2];
-        Ref right = node[3];
-        if (!emitsBoolean(left) || !emitsBoolean(right)) return;
-        bool leftEffects = hasSideEffects(left);
-        bool rightEffects = hasSideEffects(right);
-        if (leftEffects && rightEffects) return; // both must execute
-        // canonicalize with side effects, if any, happening on the left
-        if (rightEffects) {
-          if (measureCost(left) < MIN_COST) return; // avoidable code is too cheap
-          Ref temp = left;
-          left = right;
-          right = temp;
-        } else if (leftEffects) {
-          if (measureCost(right) < MIN_COST) return; // avoidable code is too cheap
-        } else {
-          // no side effects, reorder based on cost estimation
-          int leftCost = measureCost(left);
-          int rightCost = measureCost(right);
-          if (std::max(leftCost, rightCost) < MIN_COST) return; // avoidable code is too cheap
-          // canonicalize with expensive code on the right
-          if (leftCost > rightCost) {
-            Ref temp = left;
-            left = right;
-            right = temp;
-          }
-        }
-        // worth it, perform conditionalization
-        Ref ret;
-        if (node[1] == OR) {
-          ret = make3(CONDITIONAL, left, makeNum(1), right);
-        } else { // &
-          ret = make3(CONDITIONAL, left, right, makeNum(0));
-        }
-        if (left[0] == UNARY_PREFIX && left[1] == L_NOT) {
-          ret[1] = flipCondition(left);
-          Ref temp = ret[2];
-          ret[2] = ret[3];
-          ret[3] = temp;
-        }
-        safeCopy(node, ret);
-        return;
-      }
-    });
-  };
-
-  traverseFunctions(ast, [&](Ref func) {
-    simplifyIntegerConversions(func);
-    simplifyOps(func);
-    traversePre(func, [](Ref node) {
-      Ref ret = simplifyNotCompsDirect(node);
-      if (ret.get() != node.get()) { // if we received a different pointer in return, then we need to copy the new value
-        safeCopy(node, ret);
-      }
-    });
-    conditionalize(func);
-  });
-}
-
-void simplifyIfs(Ref ast) {
-  traverseFunctions(ast, [](Ref func) {
-    bool simplifiedAnElse = false;
-
-    traversePre(func, [&simplifiedAnElse](Ref node) {
-      // simplify   if (x) { if (y) { .. } }   to   if (x ? y : 0) { .. }
-      if (node[0] == IF) {
-        Ref body = node[2];
-        // recurse to handle chains
-        while (body[0] == BLOCK) {
-          Ref stats = body[1];
-          if (stats->size() == 0) break;
-          Ref other = stats->back();
-          if (other[0] != IF) {
-            // our if block does not end with an if. perhaps if have an else we can flip
-            if (node->size() > 3 && !!node[3] && node[3][0] == BLOCK) {
-              stats = node[3][1];
-              if (stats->size() == 0) break;
-              other = stats->back();
-              if (other[0] == IF) {
-                // flip node
-                node[1] = flipCondition(node[1]);
-                node[2] = node[3];
-                node[3] = body;
-                body = node[2];
-              } else break;
-            } else break;
-          }
-          // we can handle elses, but must be fully identical
-          if (!!node[3] || !!other[3]) {
-            if (!node[3]) break;
-            if (!node[3]->deepCompare(other[3])) {
-              // the elses are different, but perhaps if we flipped a condition we can do better
-              if (node[3]->deepCompare(other[2])) {
-                // flip other. note that other may not have had an else! add one if so; we will eliminate such things later
-                if (!other[3]) other[3] = makeBlock();
-                other[1] = flipCondition(other[1]);
-                Ref temp = other[2];
-                other[2] = other[3];
-                other[3] = temp;
-              } else break;
-            }
-          }
-          if (stats->size() > 1) {
-            // try to commaify - turn everything between the ifs into a comma operator inside the second if
-            bool ok = true;
-            for (size_t i = 0; i+1 < stats->size(); i++) {
-              Ref curr = deStat(stats[i]);
-              if (!commable(curr)) ok = false;
-            }
-            if (!ok) break;
-            for (int i = stats->size()-2; i >= 0; i--) {
-              Ref curr = deStat(stats[i]);
-              other[1] = make2(SEQ, curr, other[1]);
-            }
-            Ref temp = makeArray(1);
-            temp->push_back(other);
-            stats = body[1] = temp;
-          }
-          if (stats->size() != 1) break;
-          if (!!node[3]) simplifiedAnElse = true;
-          node[1] = make3(CONDITIONAL, node[1], other[1], makeNum(0));
-          body = node[2] = other[2];
-        }
-      }
-    });
-
-    if (simplifiedAnElse) {
-      // there may be fusing opportunities
-
-      // we can only fuse if we remove all uses of the label. if there are
-      // other ones - if the label check can be reached from elsewhere -
-      // we must leave it
-      bool abort = false;
-
-      std::unordered_map<int, int> labelAssigns;
-
-      traversePre(func, [&labelAssigns, &abort](Ref node) {
-        if (node[0] == ASSIGN && node[2][0] == NAME && node[2][1] == LABEL) {
-          if (node[3][0] == NUM) {
-            int value = node[3][1]->getInteger();
-            labelAssigns[value] = labelAssigns[value] + 1;
-          } else {
-            // label is assigned a dynamic value (like from indirectbr), we cannot do anything
-            abort = true;
-          }
-        }
-      });
-      if (abort) return;
-
-      std::unordered_map<int, int> labelChecks;
-
-      traversePre(func, [&labelChecks, &abort](Ref node) {
-        if (node[0] == BINARY && node[1] == EQ && node[2][0] == BINARY && node[2][1] == OR &&
-            node[2][2][0] == NAME && node[2][2][1] == LABEL) {
-          if (node[3][0] == NUM) {
-            int value = node[3][1]->getInteger();
-            labelChecks[value] = labelChecks[value] + 1;
-          } else {
-            // label is checked vs a dynamic value (like from indirectbr), we cannot do anything
-            abort = true;
-          }
-        }
-      });
-      if (abort) return;
-
-      int inLoop = 0; // when in a loop, we do not emit   label = 0;   in the relooper as there is no need
-      traversePrePost(func, [&inLoop, &labelAssigns, &labelChecks](Ref node) {
-        if (node[0] == WHILE) inLoop++;
-        Ref stats = getStatements(node);
-        if (!!stats && stats->size() > 0) {
-          for (int i = 0; i < (int)stats->size()-1; i++) {
-            Ref pre = stats[i];
-            Ref post = stats[i+1];
-            if (pre[0] == IF && pre->size() > 3 && !!pre[3] && post[0] == IF && (post->size() <= 3 || !post[3])) {
-              Ref postCond = post[1];
-              if (postCond[0] == BINARY && postCond[1] == EQ &&
-                  postCond[2][0] == BINARY && postCond[2][1] == OR &&
-                  postCond[2][2][0] == NAME && postCond[2][2][1] == LABEL &&
-                  postCond[2][3][0] == NUM && postCond[2][3][1]->getNumber() == 0 &&
-                  postCond[3][0] == NUM) {
-                int postValue = postCond[3][1]->getInteger();
-                Ref preElse = pre[3];
-                if (labelAssigns[postValue] == 1 && labelChecks[postValue] == 1 && preElse[0] == BLOCK && preElse->size() >= 2 && preElse[1]->size() == 1) {
-                  Ref preStat = preElse[1][0];
-                  if (preStat[0] == STAT && preStat[1][0] == ASSIGN &&
-                      preStat[1][1]->isBool(true) && preStat[1][2][0] == NAME && preStat[1][2][1] == LABEL &&
-                      preStat[1][3][0] == NUM && preStat[1][3][1]->getNumber() == postValue) {
-                    // Conditions match, just need to make sure the post clears label
-                    if (post[2][0] == BLOCK && post[2]->size() >= 2 && post[2][1]->size() > 0) {
-                      Ref postStat = post[2][1][0];
-                      bool haveClear =
-                        postStat[0] == STAT && postStat[1][0] == ASSIGN &&
-                        postStat[1][1]->isBool(true) && postStat[1][2][0] == NAME && postStat[1][2][1] == LABEL &&
-                        postStat[1][3][0] == NUM && postStat[1][3][1]->getNumber() == 0;
-                      if (!inLoop || haveClear) {
-                        // Everything lines up, do it
-                        pre[3] = post[2];
-                        if (haveClear) pre[3][1]->splice(0, 1); // remove the label clearing
-                        stats->splice(i+1, 1); // remove the post entirely
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }, [&inLoop](Ref node) {
-        if (node[0] == WHILE) inLoop--;
-      });
-      assert(inLoop == 0);
-    }
-  });
-}
-
-void optimizeFrounds(Ref ast) {
-  // collapse fround(fround(..)), which can happen due to elimination
-  // also emit f0 instead of fround(0) (except in returns)
-  int inReturn = 0;
-  traversePrePost(ast, [&](Ref node) {
-    if (node[0] == RETURN) {
-      inReturn++;
-    }
-  }, [&](Ref node) {
-    if (node[0] == RETURN) {
-      inReturn--;
-    }
-    if (node[0] == CALL && node[1][0] == NAME && node[1][1] == MATH_FROUND) {
-      Ref arg = node[2][0];
-      if (arg[0] == NUM) {
-        if (!inReturn && arg[1]->getInteger() == 0) {
-          safeCopy(node, makeName(F0));
-        }
-      } else if (arg[0] == CALL && arg[1][0] == NAME && arg[1][1] == MATH_FROUND) {
-        safeCopy(node, arg);
-      }
-    }
-  });
-}
-
-// Very simple 'registerization', coalescing of variables into a smaller number.
-
-const char* getRegPrefix(AsmType type) {
-  switch (type) {
-    case ASM_INT:       return "i"; break;
-    case ASM_DOUBLE:    return "d"; break;
-    case ASM_FLOAT:     return "f"; break;
-    case ASM_FLOAT32X4: return "F4"; break;
-    case ASM_FLOAT64X2: return "F2"; break;
-    case ASM_INT8X16:   return "I16"; break;
-    case ASM_INT16X8:   return "I8"; break;
-    case ASM_INT32X4:   return "I4"; break;
-    case ASM_NONE:      return "Z"; break;
-    default: assert(0); // type doesn't have a name yet
-  }
-  return nullptr;
-}
-
-IString getRegName(AsmType type, int num) {
-  const char* str = getRegPrefix(type);
-  const int size = 256;
-  char temp[size];
-  int written = sprintf(temp, "%s%d", str, num);
-  assert(written < size);
-  temp[written] = 0;
-  IString ret;
-  ret.set(temp, false);
-  return ret;
-}
-
-void registerize(Ref ast) {
-  traverseFunctions(ast, [](Ref fun) {
-    AsmData asmData(fun);
-    // Add parameters as a first (fake) var (with assignment), so they get taken into consideration
-    // note: params are special, they can never share a register between them (see later)
-    Ref fake;
-    if (!!fun[2] && fun[2]->size()) {
-      Ref assign = makeNum(0);
-      // TODO: will be an isEmpty here, can reuse it.
-      fun[3]->insert(0, make1(VAR, fun[2]->map([&assign](Ref param) {
-        return &(makeArray(2)->push_back(param).push_back(assign));
-      })));
-    }
-    // Replace all var definitions with assignments; we will add var definitions at the top after we registerize
-    StringSet allVars;
-    traversePre(fun, [&](Ref node) {
-      Ref type = node[0];
-      if (type == VAR) {
-        Ref vars = node[1]->filter([](Ref varr) { return varr->size() > 1; });
-        if (vars->size() >= 1) {
-          safeCopy(node, unVarify(vars));
-        } else {
-          safeCopy(node, makeEmpty());
-        }
-      } else if (type == NAME) {
-        allVars.insert(node[1]->getIString());
-      }
-    });
-    removeAllUselessSubNodes(fun); // vacuum?
-    StringTypeMap regTypes; // reg name -> type
-    auto getNewRegName = [&](int num, IString name) {
-      AsmType type = asmData.getType(name);
-      IString ret = getRegName(type, num);
-      assert(!allVars.has(ret) || asmData.isLocal(ret)); // register must not shadow non-local name
-      regTypes[ret] = type;
-      return ret;
-    };
-    // Find the # of uses of each variable.
-    // While doing so, check if all a variable's uses are dominated in a simple
-    // way by a simple assign, if so, then we can assign its register to it
-    // just for its definition to its last use, and not to the entire toplevel loop,
-    // we call such variables "optimizable"
-    StringIntMap varUses;
-    int level = 1;
-    std::unordered_map<int, StringSet> levelDominations; // level => set of dominated variables XXX vector?
-    StringIntMap varLevels;
-    StringSet possibles;
-    StringSet unoptimizables;
-    auto purgeLevel = [&]() {
-      // Invalidate all dominating on this level, further users make it unoptimizable
-      for (auto name : levelDominations[level]) {
-        varLevels[name] = 0;
-      }
-      levelDominations[level].clear();
-      level--;
-    };
-    std::function<bool (Ref node)> possibilifier = [&](Ref node) {
-      Ref type = node[0];
-      if (type == NAME) {
-        IString name = node[1]->getIString();
-        if (asmData.isLocal(name)) {
-          varUses[name]++;
-          if (possibles.has(name) && !varLevels[name]) unoptimizables.insert(name); // used outside of simple domination
-        }
-      } else if (type == ASSIGN && node[1]->isBool(true)) {
-        if (!!node[2] && node[2][0] == NAME) {
-          IString name = node[2][1]->getIString();
-          // if local and not yet used, this might be optimizable if we dominate
-          // all other uses
-          if (asmData.isLocal(name) && !varUses[name] && !varLevels[name]) {
-            possibles.insert(name);
-            varLevels[name] = level;
-            levelDominations[level].insert(name);
-          }
-        }
-      } else if (CONTROL_FLOW.has(type)) {
-        // recurse children, in the context of a loop
-        if (type == WHILE || type == DO) {
-          traversePrePostConditional(node[1], possibilifier, [](Ref node){});
-          level++;
-          traversePrePostConditional(node[2], possibilifier, [](Ref node){});
-          purgeLevel();
-        } else if (type == FOR) {
-          traversePrePostConditional(node[1], possibilifier, [](Ref node){});
-          for (int i = 2; i <= 4; i++) {
-            level++;
-            traversePrePostConditional(node[i], possibilifier, [](Ref node){});
-            purgeLevel();
-          }
-        } else if (type == IF) {
-          traversePrePostConditional(node[1], possibilifier, [](Ref node){});
-          level++;
-          traversePrePostConditional(node[2], possibilifier, [](Ref node){});
-          purgeLevel();
-          if (node->size() > 3 && !!node[3]) {
-            level++;
-            traversePrePostConditional(node[3], possibilifier, [](Ref node){});
-            purgeLevel();
-          }
-        } else if (type == SWITCH) {
-          traversePrePostConditional(node[1], possibilifier, [](Ref node){});
-          Ref cases = node[2];
-          for (size_t i = 0; i < cases->size(); i++) {
-            level++;
-            traversePrePostConditional(cases[i][1], possibilifier, [](Ref node){});
-            purgeLevel();
-          }
-        } else assert(0);;
-        return false; // prevent recursion into children, which we already did
-      }
-      return true;
-    };
-    traversePrePostConditional(fun, possibilifier, [](Ref node){});
-
-    StringSet optimizables;
-    for (auto possible : possibles) {
-      if (!unoptimizables.has(possible)) optimizables.insert(possible);
-    }
-
-    // Go through the function's code, assigning 'registers'.
-    // The only tricky bit is to keep variables locked on a register through loops,
-    // since they can potentially be returned to. Optimizable variables lock onto
-    // loops that they enter, unoptimizable variables lock in a conservative way
-    // into the topmost loop.
-    // Note that we cannot lock onto a variable in a loop if it was used and free'd
-    // before! (then they could overwrite us in the early part of the loop). For now
-    // we just use a fresh register to make sure we avoid this, but it could be
-    // optimized to check for safe registers (free, and not used in this loop level).
-    StringStringMap varRegs; // maps variables to the register they will use all their life
-    std::vector<StringVec> freeRegsClasses;
-    freeRegsClasses.resize(ASM_NONE);
-    int nextReg = 1;
-    StringVec fullNames;
-    fullNames.push_back(EMPTY); // names start at 1
-    std::vector<StringVec> loopRegs; // for each loop nesting level, the list of bound variables
-    int loops = 0; // 0 is toplevel, 1 is first loop, etc
-    StringSet activeOptimizables;
-    StringIntMap optimizableLoops;
-    StringSet paramRegs; // true if the register is used by a parameter (and so needs no def at start of function; also cannot
-                         // be shared with another param, each needs its own)
-    auto decUse = [&](IString name) {
-      if (!varUses[name]) return false; // no uses left, or not a relevant variable
-      if (optimizables.has(name)) activeOptimizables.insert(name);
-      IString reg = varRegs[name];
-      assert(asmData.isLocal(name));
-      StringVec& freeRegs = freeRegsClasses[asmData.getType(name)];
-      if (!reg) {
-        // acquire register
-        if (optimizables.has(name) && freeRegs.size() > 0 &&
-            !(asmData.isParam(name) && paramRegs.has(freeRegs.back()))) { // do not share registers between parameters
-          reg = freeRegs.back();
-          freeRegs.pop_back();
-        } else {
-          assert(fullNames.size() == nextReg);
-          reg = getNewRegName(nextReg++, name);
-          fullNames.push_back(reg);
-          if (asmData.isParam(name)) paramRegs.insert(reg);
-        }
-        varRegs[name] = reg;
-      }
-      varUses[name]--;
-      assert(varUses[name] >= 0);
-      if (varUses[name] == 0) {
-        if (optimizables.has(name)) activeOptimizables.erase(name);
-        // If we are not in a loop, or we are optimizable and not bound to a loop
-        // (we might have been in one but left it), we can free the register now.
-        if (loops == 0 || (optimizables.has(name) && !optimizableLoops.has(name))) {
-          // free register
-          freeRegs.push_back(reg);
-        } else {
-          // when the relevant loop is exited, we will free the register
-          int relevantLoop = optimizables.has(name) ? (optimizableLoops[name] ? optimizableLoops[name] : 1) : 1;
-          if ((int)loopRegs.size() <= relevantLoop+1) loopRegs.resize(relevantLoop+1);
-          loopRegs[relevantLoop].push_back(reg);
-        }
-      }
-      return true;
-    };
-    traversePrePost(fun, [&](Ref node) { // XXX we rely on traversal order being the same as execution order here
-      Ref type = node[0];
-      if (type == NAME) {
-        IString name = node[1]->getIString();
-        if (decUse(name)) {
-          node[1]->setString(varRegs[name]);
-        }
-      } else if (LOOP.has(type)) {
-        loops++;
-        // Active optimizables lock onto this loop, if not locked onto one that encloses this one
-        for (auto name : activeOptimizables) {
-          if (!optimizableLoops[name]) {
-            optimizableLoops[name] = loops;
-          }
-        }
-      }
-    }, [&](Ref node) {
-      Ref type = node[0];
-      if (LOOP.has(type)) {
-        // Free registers that were locked to this loop
-        if ((int)loopRegs.size() > loops && loopRegs[loops].size() > 0) {
-          for (auto loopReg : loopRegs[loops]) {
-            freeRegsClasses[regTypes[loopReg]].push_back(loopReg);
-          }
-          loopRegs[loops].clear();
-        }
-        loops--;
-      }
-    });
-    if (!!fun[2] && fun[2]->size()) {
-      fun[2]->setSize(0); // clear params, we will fill with registers
-      fun[3]->splice(0, 1); // remove fake initial var
-    }
-
-    asmData.locals.clear();
-    asmData.params.clear();
-    asmData.vars.clear();
-    for (int i = 1; i < nextReg; i++) {
-      IString reg = fullNames[i];
-      AsmType type = regTypes[reg];
-      if (!paramRegs.has(reg)) {
-        asmData.addVar(reg, type);
-      } else {
-        asmData.addParam(reg, type);
-        fun[2]->push_back(makeString(reg));
-      }
-    }
-    asmData.denormalize();
-  });
-}
-
-// Assign variables to 'registers', coalescing them onto a smaller number of shared
-// variables.
-//
-// This does the same job as 'registerize' above, but burns a lot more cycles trying
-// to reduce the total number of register variables.  Key points about the operation:
-//
-//   * we decompose the AST into a flow graph and perform a full liveness
-//     analysis, to determine which variables are live at each point.
-//
-//   * variables that are live concurrently are assigned to different registers.
-//
-//   * variables that are linked via 'x=y' style statements are assigned the same
-//     register if possible, so that the redundant assignment can be removed.
-//     (e.g. assignments used to pass state around through loops).
-//
-//   * any code that cannot be reached through the flow-graph is removed.
-//     (e.g. redundant break statements like 'break L123; break;').
-//
-//   * any assignments that we can prove are not subsequently used are removed.
-//     (e.g. unnecessary assignments to the 'label' variable).
-//
-void registerizeHarder(Ref ast) {
-#ifdef PROFILING
-  clock_t tasmdata = 0;
-  clock_t tflowgraph = 0;
-  clock_t tlabelfix = 0;
-  clock_t tbackflow = 0;
-  clock_t tjuncvaruniqassign = 0;
-  clock_t tjuncvarsort = 0;
-  clock_t tregassign = 0;
-  clock_t tblockproc = 0;
-  clock_t treconstruct = 0;
-#endif
-
-  traverseFunctions(ast, [&](Ref fun) {
-
-#ifdef PROFILING
-    clock_t start = clock();
-#endif
-
-    // Do not try to process non-validating methods, like the heap replacer
-    bool abort = false;
-    traversePre(fun, [&abort](Ref node) {
-      if (node[0] == NEW) abort = true;
-    });
-    if (abort) return;
-
-    AsmData asmData(fun);
-
-#ifdef PROFILING
-    tasmdata += clock() - start;
-    start = clock();
-#endif
-
-    // Utilities for allocating register variables.
-    // We need distinct register pools for each type of variable.
-
-    typedef std::map<int, IString> IntStringMap;
-    std::vector<IntStringMap> allRegsByType;
-    allRegsByType.resize(ASM_NONE+1);
-    int nextReg = 1;
-
-    auto createReg = [&](IString forName) {
-      // Create a new register of type suitable for the given variable name.
-      AsmType type = asmData.getType(forName);
-      IntStringMap& allRegs = allRegsByType[type];
-      int reg = nextReg++;
-      allRegs[reg] = getRegName(type, reg);
-      return reg;
-    };
-
-    // Traverse the tree in execution order and synthesize a basic flow-graph.
-    // It's convenient to build a kind of "dual" graph where the nodes identify
-    // the junctions between blocks at which control-flow may branch, and each
-    // basic block is an edge connecting two such junctions.
-    // For each junction we store:
-    //    * set of blocks that originate at the junction
-    //    * set of blocks that terminate at the junction
-    // For each block we store:
-    //    * a single entry junction
-    //    * a single exit junction
-    //    * a 'use' and 'kill' set of names for the block
-    //    * full sequence of NAME and ASSIGN nodes in the block
-    //    * whether each such node appears as part of a larger expression
-    //      (and therefore cannot be safely eliminated)
-    //    * set of labels that can be used to jump to this block
-
-    struct Junction {
-      int id;
-      std::set<int> inblocks, outblocks;
-      IOrderedStringSet live;
-      Junction(int id_) : id(id_) {}
-    };
-    struct Node {
-    };
-    struct Block {
-      int id, entry, exit;
-      std::set<int> labels;
-      std::vector<Ref> nodes;
-      std::vector<bool> isexpr;
-      StringIntMap use;
-      StringSet kill;
-      StringStringMap link;
-      StringIntMap lastUseLoc;
-      StringIntMap firstDeadLoc;
-      StringIntMap firstKillLoc;
-      StringIntMap lastKillLoc;
-
-      Block() : id(-1), entry(-1), exit(-1) {}
-    };
-    struct ContinueBreak {
-      int co, br;
-      ContinueBreak() : co(-1), br(-1) {}
-      ContinueBreak(int co_, int br_) : co(co_), br(br_) {}
-    };
-    typedef std::unordered_map<IString, ContinueBreak> LabelState;
-
-    std::vector<Junction> junctions;
-    std::vector<Block*> blocks;
-    int currEntryJunction = -1;
-    Block* nextBasicBlock = nullptr;
-    int isInExpr = 0;
-    std::vector<LabelState> activeLabels;
-    activeLabels.resize(1);
-    IString nextLoopLabel;
-
-    const int ENTRY_JUNCTION = 0;
-    const int EXIT_JUNCTION = 1;
-    const int ENTRY_BLOCK = 0;
-
-    auto addJunction = [&]() {
-      // Create a new junction, without inserting it into the graph.
-      // This is useful for e.g. pre-allocating an exit node.
-      int id = junctions.size();
-      junctions.push_back(Junction(id));
-      return id;
-    };
-
-    std::function<int (int, bool)> joinJunction;
-
-    auto markJunction = [&](int id) {
-      // Mark current traversal location as a junction.
-      // This makes a new basic block exiting at this position.
-      if (id < 0) {
-        id = addJunction();
-      }
-      joinJunction(id, true);
-      return id;
-    };
-
-    auto setJunction = [&](int id, bool force) {
-      // Set the next entry junction to the given id.
-      // This can be used to enter at a previously-declared point.
-      // You can't return to a junction with no incoming blocks
-      // unless the 'force' parameter is specified.
-      assert(nextBasicBlock->nodes.size() == 0); // refusing to abandon an in-progress basic block
-      if (force || junctions[id].inblocks.size() > 0) {
-        currEntryJunction = id;
-      } else {
-        currEntryJunction = -1;
-      }
-    };
-
-    joinJunction = [&](int id, bool force) {
-      // Complete the pending basic block by exiting at this position.
-      // This can be used to exit at a previously-declared point.
-      if (currEntryJunction >= 0) {
-        assert(nextBasicBlock);
-        nextBasicBlock->id = blocks.size();
-        nextBasicBlock->entry = currEntryJunction;
-        nextBasicBlock->exit = id;
-        junctions[currEntryJunction].outblocks.insert(nextBasicBlock->id);
-        junctions[id].inblocks.insert(nextBasicBlock->id);
-        blocks.push_back(nextBasicBlock);
-      } 
-      nextBasicBlock = new Block();
-      setJunction(id, force);
-      return id;
-    };
-
-    auto pushActiveLabels = [&](int onContinue, int onBreak) {
-      // Push the target junctions for continuing/breaking a loop.
-      // This should be called before traversing into a loop.
-      assert(activeLabels.size() > 0);
-      LabelState& prevLabels = activeLabels.back();
-      LabelState newLabels = prevLabels;
-      newLabels[EMPTY] = ContinueBreak(onContinue, onBreak);
-      if (!!nextLoopLabel) {
-        newLabels[nextLoopLabel] = ContinueBreak(onContinue, onBreak);
-        nextLoopLabel = EMPTY;
-      }
-      // An unlabelled CONTINUE should jump to innermost loop,
-      // ignoring any nested SWITCH statements.
-      if (onContinue < 0 && prevLabels.count(EMPTY) > 0) {
-        newLabels[EMPTY].co = prevLabels[EMPTY].co;
-      }
-      activeLabels.push_back(newLabels);
-    };
-
-    auto popActiveLabels = [&]() {
-      // Pop the target junctions for continuing/breaking a loop.
-      // This should be called after traversing into a loop.
-      activeLabels.pop_back();
-    };
-
-    auto markNonLocalJump = [&](IString type, IString label) {
-      // Complete a block via RETURN, BREAK or CONTINUE.
-      // This joins the targetted junction and then sets the current junction to null.
-      // Any code traversed before we get back to an existing junction is dead code.
-      if (type == RETURN) {
-        joinJunction(EXIT_JUNCTION, false);
-      } else {
-        assert(activeLabels.size() > 0);
-        assert(activeLabels.back().count(label) > 0); // 'jump to unknown label');
-        auto targets = activeLabels.back()[label];
-        if (type == CONTINUE) {
-          joinJunction(targets.co, false);
-        } else if (type == BREAK) {
-          joinJunction(targets.br, false);
-        } else {
-          assert(0); // 'unknown jump node type');
-        }
-      }
-      currEntryJunction = -1;
-    };
-
-    auto addUseNode = [&](Ref node) {
-      // Mark a use of the given name node in the current basic block.
-      assert(node[0] == NAME); // 'not a use node');
-      IString name = node[1]->getIString();
-      if (asmData.isLocal(name)) {
-        nextBasicBlock->nodes.push_back(node);
-        nextBasicBlock->isexpr.push_back(isInExpr != 0);
-        if (nextBasicBlock->kill.count(name) == 0) {
-          nextBasicBlock->use[name] = 1;
-        }
-      }
-    };
-
-    auto addKillNode = [&](Ref node) {
-      // Mark an assignment to the given name node in the current basic block.
-      assert(node[0] == ASSIGN); //, 'not a kill node');
-      assert(node[1]->isBool(true)); // 'not a kill node');
-      assert(node[2][0] == NAME); //, 'not a kill node');
-      IString name = node[2][1]->getIString();
-      if (asmData.isLocal(name)) {
-        nextBasicBlock->nodes.push_back(node);
-        nextBasicBlock->isexpr.push_back(isInExpr != 0);
-        nextBasicBlock->kill.insert(name);
-      }
-    };
-
-    std::function<Ref (Ref)> lookThroughCasts = [&](Ref node) {
-      // Look through value-preserving casts, like "x | 0" => "x"
-      if (node[0] == BINARY && node[1] == OR) {
-        if (node[3][0] == NUM && node[3][1]->getNumber() == 0) {
-          return lookThroughCasts(node[2]);
-        }
-      }
-      return node;
-    };
-
-    auto addBlockLabel = [&](Ref node) {
-      assert(nextBasicBlock->nodes.size() == 0); // 'cant add label to an in-progress basic block')
-      if (node[0] == NUM) {
-        nextBasicBlock->labels.insert(node[1]->getInteger());
-      }
-    };
-
-    auto isTrueNode = [&](Ref node) {
-      // Check if the given node is statically truthy.
-      return (node[0] == NUM && node[1]->getNumber() != 0);
-    };
-
-    auto isFalseNode = [&](Ref node) {
-      // Check if the given node is statically falsy.
-      return (node[0] == NUM && node[1]->getNumber() == 0);
-    };
-
-    std::function<void (Ref)> buildFlowGraph = [&](Ref node) {
-      // Recursive function to build up the flow-graph.
-      // It walks the tree in execution order, calling the above state-management
-      // functions at appropriate points in the traversal.
-      Ref type = node[0];
-  
-      // Any code traversed without an active entry junction must be dead,
-      // as the resulting block could never be entered. Let's remove it.
-      if (currEntryJunction < 0 && junctions.size() > 0) {
-        safeCopy(node, makeEmpty());
-        return;
-      }
- 
-      // Traverse each node type according to its particular control-flow semantics.
-      // TODO: switchify this
-      if (type == DEFUN) {
-        int jEntry = markJunction(-1);
-        assert(jEntry == ENTRY_JUNCTION);
-        int jExit = addJunction();
-        assert(jExit == EXIT_JUNCTION);
-        for (size_t i = 0; i < node[3]->size(); i++) {
-          buildFlowGraph(node[3][i]);
-        }
-        joinJunction(jExit, false);
-      } else if (type == IF) {
-        isInExpr++;
-        buildFlowGraph(node[1]);
-        isInExpr--;
-        int jEnter = markJunction(-1);
-        int jExit = addJunction();
-        if (!!node[2]) {
-          // Detect and mark "if (label == N) { <labelled block> }".
-          if (node[1][0] == BINARY && node[1][1] == EQ) {
-            Ref lhs = lookThroughCasts(node[1][2]);
-            if (lhs[0] == NAME && lhs[1] == LABEL) {
-              addBlockLabel(lookThroughCasts(node[1][3]));
-            }
-          }
-          buildFlowGraph(node[2]);
-        }
-        joinJunction(jExit, false);
-        setJunction(jEnter, false);
-        if (node->size() > 3 && !!node[3]) {
-          buildFlowGraph(node[3]);
-        }
-        joinJunction(jExit, false);
-      } else if (type == CONDITIONAL) {
-        isInExpr++;
-        // If the conditional has no side-effects, we can treat it as a single
-        // block, which might open up opportunities to remove it entirely.
-        if (!hasSideEffects(node)) {
-          buildFlowGraph(node[1]);
-          if (!!node[2]) {
-            buildFlowGraph(node[2]);
-          }
-          if (!!node[3]) {
-            buildFlowGraph(node[3]);
-          }
-        } else {
-          buildFlowGraph(node[1]);
-          int jEnter = markJunction(-1);
-          int jExit = addJunction();
-          if (!!node[2]) {
-            buildFlowGraph(node[2]);
-          }
-          joinJunction(jExit, false);
-          setJunction(jEnter, false);
-          if (!!node[3]) {
-            buildFlowGraph(node[3]);
-          }
-          joinJunction(jExit, false);
-        }
-        isInExpr--;
-      } else if (type == WHILE) {
-        // Special-case "while (1) {}" to use fewer junctions,
-        // since emscripten generates a lot of these.
-        if (isTrueNode(node[1])) {
-          int jLoop = markJunction(-1);
-          int jExit = addJunction();
-          pushActiveLabels(jLoop, jExit);
-          buildFlowGraph(node[2]);
-          popActiveLabels();
-          joinJunction(jLoop, false);
-          setJunction(jExit, false);
-        } else {
-          int jCond = markJunction(-1);
-          int jLoop = addJunction();
-          int jExit = addJunction();
-          isInExpr++;
-          buildFlowGraph(node[1]);
-          isInExpr--;
-          joinJunction(jLoop, false);
-          pushActiveLabels(jCond, jExit);
-          buildFlowGraph(node[2]);
-          popActiveLabels();
-          joinJunction(jCond, false);
-          // An empty basic-block linking condition exit to loop exit.
-          setJunction(jLoop, false);
-          joinJunction(jExit, false);
-        }
-      } else if (type == DO) {
-        // Special-case "do {} while (1)" and "do {} while (0)" to use
-        // fewer junctions, since emscripten generates a lot of these.
-        if (isFalseNode(node[1])) {
-          int jExit = addJunction();
-          pushActiveLabels(jExit, jExit);
-          buildFlowGraph(node[2]);
-          popActiveLabels();
-          joinJunction(jExit, false);
-        } else if (isTrueNode(node[1])) {
-          int jLoop = markJunction(-1);
-          int jExit = addJunction();
-          pushActiveLabels(jLoop, jExit);
-          buildFlowGraph(node[2]);
-          popActiveLabels();
-          joinJunction(jLoop, false);
-          setJunction(jExit, false);
-        } else {
-          int jLoop = markJunction(-1);
-          int jCond = addJunction();
-          int jCondExit = addJunction();
-          int jExit = addJunction();
-          pushActiveLabels(jCond, jExit);
-          buildFlowGraph(node[2]);
-          popActiveLabels();
-          joinJunction(jCond, false);
-          isInExpr++;
-          buildFlowGraph(node[1]);
-          isInExpr--;
-          joinJunction(jCondExit, false);
-          joinJunction(jLoop, false);
-          setJunction(jCondExit, false);
-          joinJunction(jExit, false);
-        }
-      } else if (type == FOR) {
-        int jTest = addJunction();
-        int jBody = addJunction();
-        int jStep = addJunction();
-        int jExit = addJunction();
-        buildFlowGraph(node[1]);
-        joinJunction(jTest, false);
-        isInExpr++;
-        buildFlowGraph(node[2]);
-        isInExpr--;
-        joinJunction(jBody, false);
-        pushActiveLabels(jStep, jExit);
-        buildFlowGraph(node[4]);
-        popActiveLabels();
-        joinJunction(jStep, false);
-        buildFlowGraph(node[3]);
-        joinJunction(jTest, false);
-        setJunction(jBody, false);
-        joinJunction(jExit, false);
-      } else if (type == LABEL) {
-        assert(BREAK_CAPTURERS.has(node[2][0])); // 'label on non-loop, non-switch statement')
-        nextLoopLabel = node[1]->getIString();
-        buildFlowGraph(node[2]);
-      } else if (type == SWITCH) {
-        // Emscripten generates switch statements of a very limited
-        // form: all case clauses are numeric literals, and all
-        // case bodies end with a (maybe implicit) break.  So it's
-        // basically equivalent to a multi-way IF statement.
-        isInExpr++;
-        buildFlowGraph(node[1]);
-        isInExpr--;
-        Ref condition = lookThroughCasts(node[1]);
-        int jCheckExit = markJunction(-1);
-        int jExit = addJunction();
-        pushActiveLabels(-1, jExit);
-        bool hasDefault = false;
-        for (size_t i = 0; i < node[2]->size(); i++) {
-          setJunction(jCheckExit, false);
-          // All case clauses are either 'default' or a numeric literal.
-          if (!node[2][i][0]) {
-            hasDefault = true;
-          } else {
-            // Detect switches dispatching to labelled blocks.
-            if (condition[0] == NAME && condition[1] == LABEL) {
-              addBlockLabel(lookThroughCasts(node[2][i][0]));
-            }
-          }
-          for (size_t j = 0; j < node[2][i][1]->size(); j++) {
-            buildFlowGraph(node[2][i][1][j]);
-          }
-          // Control flow will never actually reach the end of the case body.
-          // If there's live code here, assume it jumps to case exit.
-          if (currEntryJunction >= 0 && nextBasicBlock->nodes.size() > 0) {
-            if (!!node[2][i][0]) {
-              markNonLocalJump(RETURN, EMPTY);
-            } else {
-              joinJunction(jExit, false);
-            }
-          }
-        }
-        // If there was no default case, we also need an empty block
-        // linking straight from the test evaluation to the exit.
-        if (!hasDefault) {
-          setJunction(jCheckExit, false);
-        }
-        joinJunction(jExit, false);
-        popActiveLabels();
-      } else if (type == RETURN) {
-        if (!!node[1]) {
-          isInExpr++;
-          buildFlowGraph(node[1]);
-          isInExpr--;
-        }
-        markNonLocalJump(type->getIString(), EMPTY);
-      } else if (type == BREAK || type == CONTINUE) {
-        markNonLocalJump(type->getIString(), !!node[1] ? node[1]->getIString() : EMPTY);
-      } else if (type == ASSIGN) {
-        isInExpr++;
-        buildFlowGraph(node[3]);
-        isInExpr--;
-        if (node[1]->isBool(true) && node[2][0] == NAME) {
-          addKillNode(node);
-        } else {
-          buildFlowGraph(node[2]);
-        }
-      } else if (type == NAME) {
-        addUseNode(node);
-      } else if (type == BLOCK || type == TOPLEVEL) {
-        if (!!node[1]) {
-          for (size_t i = 0; i < node[1]->size(); i++) {
-            buildFlowGraph(node[1][i]);
-          }
-        }
-      } else if (type == STAT) {
-        buildFlowGraph(node[1]);
-      } else if (type == UNARY_PREFIX || type == UNARY_POSTFIX) {
-        isInExpr++;
-        buildFlowGraph(node[2]);
-        isInExpr--;
-      } else if (type == BINARY) {
-        isInExpr++;
-        buildFlowGraph(node[2]);
-        buildFlowGraph(node[3]);
-        isInExpr--;
-      } else if (type == CALL) {
-        isInExpr++;
-        buildFlowGraph(node[1]);
-        if (!!node[2]) {
-          for (size_t i = 0; i < node[2]->size(); i++) {
-            buildFlowGraph(node[2][i]);
-          }
-        }
-        isInExpr--;
-        // If the call is statically known to throw,
-        // treat it as a jump to function exit.
-        if (!isInExpr && node[1][0] == NAME) {
-          if (FUNCTIONS_THAT_ALWAYS_THROW.has(node[1][1])) {
-            markNonLocalJump(RETURN, EMPTY);
-          }
-        }
-      } else if (type == SEQ || type == SUB) {
-        isInExpr++;
-        buildFlowGraph(node[1]);
-        buildFlowGraph(node[2]);
-        isInExpr--;
-      } else if (type == DOT || type == THROW) {
-        isInExpr++;
-        buildFlowGraph(node[1]);
-        isInExpr--;
-      } else if (type == NUM || type == STRING || type == VAR) {
-        // nada
-      } else {
-        assert(0); // 'unsupported node type: ' + type);
-      }
-    };
-
-    buildFlowGraph(fun);
-
-#ifdef PROFILING
-    tflowgraph += clock() - start;
-    start = clock();
-#endif
-
-    assert(junctions[ENTRY_JUNCTION].inblocks.size() == 0); // 'function entry must have no incoming blocks');
-    assert(junctions[EXIT_JUNCTION].outblocks.size() == 0); // 'function exit must have no outgoing blocks');
-    assert(blocks[ENTRY_BLOCK]->entry == ENTRY_JUNCTION); //, 'block zero must be the initial block');
-
-    // Fix up implicit jumps done by assigning to the LABEL variable.
-    // If a block ends with an assignment to LABEL and there's another block
-    // with that value of LABEL as precondition, we tweak the flow graph so
-    // that the former jumps straight to the later.
-
-    std::map<int, Block*> labelledBlocks;
-    typedef std::pair<Ref, Block*> Jump;
-    std::vector<Jump> labelledJumps;
-
-    for (size_t i = 0; i < blocks.size(); i++) {
-      Block* block = blocks[i];
-      // Does it have any labels as preconditions to its entry?
-      for (auto labelVal : block->labels) {
-        // If there are multiple blocks with the same label, all bets are off.
-        // This seems to happen sometimes for short blocks that end with a return.
-        // TODO: it should be safe to merge the duplicates if they're identical.
-        if (labelledBlocks.count(labelVal) > 0) {
-          labelledBlocks.clear();
-          labelledJumps.clear();
-          goto AFTER_FINDLABELLEDBLOCKS;
-        }
-        labelledBlocks[labelVal] = block;
-      }
-      // Does it assign a specific label value at exit?
-      if (block->kill.has(LABEL)) {
-        Ref finalNode = block->nodes.back();
-        if (finalNode[0] == ASSIGN && finalNode[2][1] == LABEL) {
-          // If labels are computed dynamically then all bets are off.
-          // This can happen due to indirect branching in llvm output.
-          if (finalNode[3][0] != NUM) {
-            labelledBlocks.clear();
-            labelledJumps.clear();
-            goto AFTER_FINDLABELLEDBLOCKS;
-          }
-          labelledJumps.push_back(Jump(finalNode[3][1], block));
-        } else { 
-          // If label is assigned a non-zero value elsewhere in the block
-          // then all bets are off.  This can happen e.g. due to outlining
-          // saving/restoring label to the stack.
-          for (size_t j = 0; j < block->nodes.size() - 1; j++) {
-            if (block->nodes[j][0] == ASSIGN && block->nodes[j][2][1] == LABEL) {
-              if (block->nodes[j][3][0] != NUM || block->nodes[j][3][1]->getNumber() != 0) {
-                labelledBlocks.clear();
-                labelledJumps.clear();
-                goto AFTER_FINDLABELLEDBLOCKS;
-              }
-            }
-          }
-        }
-      }
-    }
-
-    AFTER_FINDLABELLEDBLOCKS:
-
-    for (auto labelVal : labelledBlocks) {
-      Block* block = labelVal.second;
-      // Disconnect it from the graph, and create a
-      // new junction for jumps targetting this label.
-      junctions[block->entry].outblocks.erase(block->id);
-      block->entry = addJunction();
-      junctions[block->entry].outblocks.insert(block->id);
-      // Add a fake use of LABEL to keep it alive in predecessor.
-      block->use[LABEL] = 1;
-      block->nodes.insert(block->nodes.begin(), makeName(LABEL));
-      block->isexpr.insert(block->isexpr.begin(), 1);
-    }
-    for (size_t i = 0; i < labelledJumps.size(); i++) {
-      auto labelVal = labelledJumps[i].first;
-      auto block = labelledJumps[i].second;
-      Block* targetBlock = labelledBlocks[labelVal->getInteger()];
-      if (targetBlock) {
-        // Redirect its exit to entry of the target block.
-        junctions[block->exit].inblocks.erase(block->id);
-        block->exit = targetBlock->entry;
-        junctions[block->exit].inblocks.insert(block->id);
-      }
-    }
-
-#ifdef PROFILING
-    tlabelfix += clock() - start;
-    start = clock();
-#endif
-
-    // Do a backwards data-flow analysis to determine the set of live
-    // variables at each junction, and to use this information to eliminate
-    // any unused assignments.
-    // We run two nested phases.  The inner phase builds the live set for each
-    // junction.  The outer phase uses this to try to eliminate redundant
-    // stores in each basic block, which might in turn affect liveness info.
-
-    auto analyzeJunction = [&](Junction& junc) {
-      // Update the live set for this junction.
-      IOrderedStringSet live;
-      for (auto b : junc.outblocks) {
-        Block* block = blocks[b];
-        IOrderedStringSet& liveSucc = junctions[block->exit].live;
-        for (auto name : liveSucc) {
-          if (!block->kill.has(name)) {
-            live.insert(name);
-          }
-        }
-        for (auto name : block->use) {
-          live.insert(name.first);
-        }
-      }
-      junc.live = live;
-    };
-
-    auto analyzeBlock = [&](Block* block) {
-      // Update information about the behaviour of the block.
-      // This includes the standard 'use' and 'kill' information,
-      // plus a 'link' set naming values that flow through from entry
-      // to exit, possibly changing names via simple 'x=y' assignments.
-      // As we go, we eliminate assignments if the variable is not
-      // subsequently used.
-      auto live = junctions[block->exit].live;
-      StringIntMap use;
-      StringSet kill;
-      StringStringMap link;
-      StringIntMap lastUseLoc;
-      StringIntMap firstDeadLoc;
-      StringIntMap firstKillLoc;
-      StringIntMap lastKillLoc;
-      for (auto name : live) {
-        link[name] = name;
-        lastUseLoc[name] = block->nodes.size();
-        firstDeadLoc[name] = block->nodes.size();
-      }
-      for (int j = block->nodes.size() - 1; j >= 0 ; j--) {
-        Ref node = block->nodes[j];
-        if (node[0] == NAME) {
-          IString name = node[1]->getIString();
-          live.insert(name);
-          use[name] = j;
-          if (lastUseLoc.count(name) == 0) {
-            lastUseLoc[name] = j;
-            firstDeadLoc[name] = j;
-          }
-        } else {
-          IString name = node[2][1]->getIString();
-          // We only keep assignments if they will be subsequently used.
-          if (live.has(name)) {
-            kill.insert(name);
-            use.erase(name);
-            live.erase(name);
-            firstDeadLoc[name] = j;
-            firstKillLoc[name] = j;
-            if (lastUseLoc.count(name) == 0) {
-              lastUseLoc[name] = j;
-            }
-            if (lastKillLoc.count(name) == 0) {
-              lastKillLoc[name] = j;
-            }
-            // If it's an "x=y" and "y" is not live, then we can create a
-            // flow-through link from "y" to "x".  If not then there's no
-            // flow-through link for "x".
-            if (link.has(name)) {
-              IString oldLink = link[name];
-              link.erase(name);
-              if (node[3][0] == NAME) {
-                if (asmData.isLocal(node[3][1]->getIString())) {
-                  link[node[3][1]->getIString()] = oldLink;
-                }
-              }
-            }
-          } else {
-            // The result of this assignment is never used, so delete it.
-            // We may need to keep the RHS for its value or its side-effects.
-            auto removeUnusedNodes = [&](int j, int n) {
-              for (auto pair : lastUseLoc) {
-                pair.second -= n;
-              }
-              for (auto pair : firstKillLoc) {
-                pair.second -= n;
-              }
-              for (auto pair : lastKillLoc) {
-                pair.second -= n;
-              }
-              for (auto pair : firstDeadLoc) {
-                pair.second -= n;
-              }
-              block->nodes.erase(block->nodes.begin() + j, block->nodes.begin() + j + n);
-              block->isexpr.erase(block->isexpr.begin() + j, block->isexpr.begin() + j + n);
-            };
-            if (block->isexpr[j] || hasSideEffects(node[3])) {
-              safeCopy(node, node[3]);
-              removeUnusedNodes(j, 1);
-            } else {
-              int numUsesInExpr = 0;
-              traversePre(node[3], [&](Ref node) {
-                if (node[0] == NAME && asmData.isLocal(node[1]->getIString())) {
-                  numUsesInExpr++;
-                }
-              });
-              safeCopy(node, makeEmpty());
-              j = j - numUsesInExpr;
-              removeUnusedNodes(j, 1 + numUsesInExpr);
-            }
-          }
-        }
-      }
-      // XXX efficiency
-      block->use = use;
-      block->kill = kill;
-      block->link = link;
-      block->lastUseLoc = lastUseLoc;
-      block->firstDeadLoc = firstDeadLoc;
-      block->firstKillLoc = firstKillLoc;
-      block->lastKillLoc = lastKillLoc;
-    };
-
-    // Ordered map to work in approximate reverse order of junction appearance
-    std::set<int> jWorkSet;
-    std::set<int> bWorkSet;
-
-    // Be sure to visit every junction at least once.
-    // This avoids missing some vars because we disconnected them
-    // when processing the labelled jumps.
-    for (size_t i = EXIT_JUNCTION; i < junctions.size(); i++) {
-      jWorkSet.insert(i);
-      for (auto b : junctions[i].inblocks) {
-        bWorkSet.insert(b);
-      }
-    }
-    // Exit junction never has any live variable changes to propagate
-    jWorkSet.erase(EXIT_JUNCTION);
-
-    do {
-      // Iterate on just the junctions until we get stable live sets.
-      // The first run of this loop will grow the live sets to their maximal size.
-      // Subsequent runs will shrink them based on eliminated in-block uses.
-      while (jWorkSet.size() > 0) {
-        auto last = jWorkSet.end();
-        --last;
-        Junction& junc = junctions[*last];
-        jWorkSet.erase(last);
-        IOrderedStringSet oldLive = junc.live; // copy it here, to check for changes later
-        analyzeJunction(junc);
-        if (oldLive != junc.live) {
-          // Live set changed, updated predecessor blocks and junctions.
-          for (auto b : junc.inblocks) {
-            bWorkSet.insert(b);
-            jWorkSet.insert(blocks[b]->entry);
-          }
-        }
-      }
-      // Now update the blocks based on the calculated live sets.
-      while (bWorkSet.size() > 0) {
-        auto last = bWorkSet.end();
-        --last;
-        Block* block = blocks[*last];
-        bWorkSet.erase(last);
-        auto oldUse = block->use;
-        analyzeBlock(block);
-        if (oldUse != block->use) {
-          // The use set changed, re-process the entry junction.
-          jWorkSet.insert(block->entry);
-        }
-      }
-    } while (jWorkSet.size() > 0);
-
-#ifdef PROFILING
-    tbackflow += clock() - start;
-    start = clock();
-#endif
-
-    // Insist that all function parameters are alive at function entry.
-    // This ensures they will be assigned independent registers, even
-    // if they happen to be unused.
-
-    for (auto name : asmData.params) {
-      junctions[ENTRY_JUNCTION].live.insert(name);
-    }
-
-    // For variables that are live at one or more junctions, we assign them
-    // a consistent register for the entire scope of the function.  Find pairs
-    // of variable that cannot use the same register (the "conflicts") as well
-    // as pairs of variables that we'd like to have share the same register
-    // (the "links").
-
-    struct JuncVar {
-      std::vector<bool> conf;
-      IOrderedStringSet link;
-      std::unordered_set<int> excl;
-      int reg;
-      bool used;
-      JuncVar() : reg(-1), used(false) {}
-    };
-    size_t numLocals = asmData.locals.size();
-    std::unordered_map<IString, size_t> nameToNum;
-    std::vector<IString> numToName;
-    nameToNum.reserve(numLocals);
-    numToName.reserve(numLocals);
-    for (auto kv : asmData.locals) {
-      nameToNum[kv.first] = numToName.size();
-      numToName.push_back(kv.first);
-    }
-
-    std::vector<JuncVar> juncVars(numLocals);
-    for (Junction& junc : junctions) {
-      for (IString name : junc.live) {
-        JuncVar& jVar = juncVars[nameToNum[name]];
-        jVar.used = true;
-        jVar.conf.assign(numLocals, false);
-      }
-    }
-    std::map<IString, std::vector<Block*>> possibleBlockConflictsMap;
-    std::vector<std::pair<size_t, std::vector<Block*>>> possibleBlockConflicts;
-    std::unordered_map<IString, std::vector<Block*>> possibleBlockLinks;
-    possibleBlockConflicts.reserve(numLocals);
-    possibleBlockLinks.reserve(numLocals);
-
-    for (Junction& junc : junctions) {
-      // Pre-compute the possible conflicts and links for each block rather
-      // than checking potentially impossible options for each var
-      possibleBlockConflictsMap.clear();
-      possibleBlockConflicts.clear();
-      possibleBlockLinks.clear();
-      for (auto b : junc.outblocks) {
-        Block* block = blocks[b];
-        Junction& jSucc = junctions[block->exit];
-        for (auto name : jSucc.live) {
-          possibleBlockConflictsMap[name].push_back(block);
-        }
-        for (auto name_linkname : block->link) {
-          if (name_linkname.first != name_linkname.second) {
-            possibleBlockLinks[name_linkname.first].push_back(block);
-          }
-        }
-      }
-      // Find the live variables in this block, mark them as unnecessary to
-      // check for conflicts (we mark all live vars as conflicting later)
-      std::vector<size_t> liveJVarNums;
-      liveJVarNums.reserve(junc.live.size());
-      for (auto name : junc.live) {
-        size_t jVarNum = nameToNum[name];
-        liveJVarNums.push_back(jVarNum);
-        possibleBlockConflictsMap.erase(name);
-      }
-      // Extract just the variables we might want to check for conflicts
-      for (auto kv : possibleBlockConflictsMap) {
-        possibleBlockConflicts.push_back(std::make_pair(nameToNum[kv.first], kv.second));
-      }
-
-      for (size_t jVarNum : liveJVarNums) {
-        JuncVar& jvar = juncVars[jVarNum];
-        IString name = numToName[jVarNum];
-        // It conflicts with all other names live at this junction.
-        for (size_t liveJVarNum : liveJVarNums) {
-          jvar.conf[liveJVarNum] = true;
-        }
-        jvar.conf[jVarNum] = false; // except for itself, of course
-
-        // It conflicts with any output vars of successor blocks,
-        // if they're assigned before it goes dead in that block.
-        for (auto jvarnum_blocks : possibleBlockConflicts) {
-          size_t otherJVarNum = jvarnum_blocks.first;
-          IString otherName = numToName[otherJVarNum];
-          for (auto block : jvarnum_blocks.second) {
-            if (block->lastKillLoc[otherName] < block->firstDeadLoc[name]) {
-              jvar.conf[otherJVarNum] = true;
-              juncVars[otherJVarNum].conf[jVarNum] = true;
-              break;
-            }
-          }
-        }
-
-        // It links with any linkages in the outgoing blocks.
-        for (auto block: possibleBlockLinks[name]) {
-          IString linkName = block->link[name];
-          jvar.link.insert(linkName);
-          juncVars[nameToNum[linkName]].link.insert(name);
-        }
-      }
-    }
-
-#ifdef PROFILING
-    tjuncvaruniqassign += clock() - start;
-    start = clock();
-#endif
-
-    // Attempt to sort the junction variables to heuristically reduce conflicts.
-    // Simple starting point: handle the most-conflicted variables first.
-    // This seems to work pretty well.
-
-    std::vector<size_t> sortedJVarNums;
-    sortedJVarNums.reserve(juncVars.size());
-    std::vector<size_t> jVarConfCounts(numLocals);
-    for (size_t jVarNum = 0; jVarNum < juncVars.size(); jVarNum++) {
-      JuncVar& jVar = juncVars[jVarNum];
-      if (!jVar.used) continue;
-      jVarConfCounts[jVarNum] = std::count(jVar.conf.begin(), jVar.conf.end(), true);
-      sortedJVarNums.push_back(jVarNum);
-    }
-    std::sort(sortedJVarNums.begin(), sortedJVarNums.end(), [&](const size_t vi1, const size_t vi2) {
-      // sort by # of conflicts
-      if (jVarConfCounts[vi1] < jVarConfCounts[vi2]) return true;
-      if (jVarConfCounts[vi1] == jVarConfCounts[vi2]) return numToName[vi1] < numToName[vi2];
-      return false;
-    });
-
-#ifdef PROFILING
-    tjuncvarsort += clock() - start;
-    start = clock();
-#endif
-
-    // We can now assign a register to each junction variable.
-    // Process them in order, trying available registers until we find
-    // one that works, and propagating the choice to linked/conflicted
-    // variables as we go.
-
-    std::function<bool (IString, int)> tryAssignRegister = [&](IString name, int reg) {
-      // Try to assign the given register to the given variable,
-      // and propagate that choice throughout the graph.
-      // Returns true if successful, false if there was a conflict.
-      JuncVar& jv = juncVars[nameToNum[name]];
-      if (jv.reg > 0) {
-        return jv.reg == reg;
-      }
-      if (jv.excl.count(reg) > 0) {
-        return false;
-      }
-      jv.reg = reg;
-      // Exclude use of this register at all conflicting variables.
-      for (size_t confNameNum = 0; confNameNum < jv.conf.size(); confNameNum++) {
-        if (jv.conf[confNameNum]) {
-          juncVars[confNameNum].excl.insert(reg);
-        }
-      }
-      // Try to propagate it into linked variables.
-      // It's not an error if we can't.
-      for (auto linkName : jv.link) {
-        tryAssignRegister(linkName, reg);
-      }
-      return true;
-    };
-    for (size_t jVarNum : sortedJVarNums) {
-      // It may already be assigned due to linked-variable propagation.
-      if (juncVars[jVarNum].reg > 0) {
-        continue;
-      }
-      IString name = numToName[jVarNum];
-      // Try to use existing registers first.
-      auto& allRegs = allRegsByType[asmData.getType(name)];
-      bool moar = false;
-      for (auto reg : allRegs) {
-        if (tryAssignRegister(name, reg.first)) {
-          moar = true;
-          break;
-        }
-      }
-      if (moar) continue;
-      // They're all taken, create a new one.
-      tryAssignRegister(name, createReg(name));
-    }
-
-#ifdef PROFILING
-    tregassign += clock() - start;
-    start = clock();
-#endif
-
-    // Each basic block can now be processed in turn.
-    // There may be internal-use-only variables that still need a register
-    // assigned, but they can be treated just for this block.  We know
-    // that all inter-block variables are in a good state thanks to
-    // junction variable consistency.
-
-    for (size_t i = 0; i < blocks.size(); i++) {
-      Block* block = blocks[i];
-      if (block->nodes.size() == 0) continue;
-      Junction& jEnter = junctions[block->entry];
-      Junction& jExit = junctions[block->exit];
-      // Mark the point at which each input reg becomes dead.
-      // Variables alive before this point must not be assigned
-      // to that register.
-      StringSet inputVars;
-      std::unordered_map<int, int> inputDeadLoc;
-      std::unordered_map<int, IString> inputVarsByReg;
-      for (auto name : jExit.live) {
-        if (!block->kill.has(name)) {
-          inputVars.insert(name);
-          int reg = juncVars[nameToNum[name]].reg;
-          assert(reg > 0); // 'input variable doesnt have a register');
-          inputDeadLoc[reg] = block->firstDeadLoc[name];
-          inputVarsByReg[reg] = name;
-        }
-      }
-      for (auto pair : block->use) {
-        IString name = pair.first;
-        if (!inputVars.has(name)) {
-          inputVars.insert(name);
-          int reg = juncVars[nameToNum[name]].reg;
-          assert(reg > 0); // 'input variable doesnt have a register');
-          inputDeadLoc[reg] = block->firstDeadLoc[name];
-          inputVarsByReg[reg] = name;
-        }
-      }
-      // TODO assert(setSize(setSub(inputVars, jEnter.live)) == 0);
-      // Scan through backwards, allocating registers on demand.
-      // Be careful to avoid conflicts with the input registers.
-      // We consume free registers in last-used order, which helps to
-      // eliminate "x=y" assignments that are the last use of "y".
-      StringIntMap assignedRegs;
-      auto freeRegsByTypePre = allRegsByType; // XXX copy
-      // Begin with all live vars assigned per the exit junction.
-      for (auto name : jExit.live) {
-        int reg = juncVars[nameToNum[name]].reg;
-        assert(reg > 0); // 'output variable doesnt have a register');
-        assignedRegs[name] = reg;
-        freeRegsByTypePre[asmData.getType(name)].erase(reg); // XXX assert?
-      }
-      std::vector<std::vector<int>> freeRegsByType;
-      freeRegsByType.resize(freeRegsByTypePre.size());
-      for (size_t j = 0; j < freeRegsByTypePre.size(); j++) {
-        for (auto pair : freeRegsByTypePre[j]) {
-          freeRegsByType[j].push_back(pair.first);
-        }
-      }
-      // Scan through the nodes in sequence, modifying each node in-place
-      // and grabbing/freeing registers as needed.
-      std::vector<std::pair<int, Ref>> maybeRemoveNodes;
-      for (int j = block->nodes.size() - 1; j >= 0; j--) {
-        Ref node = block->nodes[j];
-        IString name = (node[0] == ASSIGN ? node[2][1] : node[1])->getIString();
-        IntStringMap& allRegs = allRegsByType[asmData.getType(name)];
-        std::vector<int>& freeRegs = freeRegsByType[asmData.getType(name)];
-        int reg = assignedRegs[name]; // XXX may insert a zero
-        if (node[0] == NAME) {
-          // A use.  Grab a register if it doesn't have one.
-          if (reg <= 0) {
-            if (inputVars.has(name) && j <= block->firstDeadLoc[name]) {
-              // Assignment to an input variable, must use pre-assigned reg.
-              reg = juncVars[nameToNum[name]].reg;
-              assignedRegs[name] = reg;
-              for (int k = freeRegs.size() - 1; k >= 0; k--) {
-                if (freeRegs[k] == reg) {
-                  freeRegs.erase(freeRegs.begin() + k);
-                  break;
-                }
-              }
-            } else {
-              // Try to use one of the existing free registers.
-              // It must not conflict with an input register.
-              for (int k = freeRegs.size() - 1; k >= 0; k--) {
-                reg = freeRegs[k];
-                // Check for conflict with input registers.
-                if (inputDeadLoc.count(reg) > 0) {
-                  if (block->firstKillLoc[name] <= inputDeadLoc[reg]) {
-                    if (name != inputVarsByReg[reg]) {
-                      continue;
-                    }
-                  }
-                }
-                // Found one!
-                assignedRegs[name] = reg;
-                assert(reg > 0);
-                freeRegs.erase(freeRegs.begin() + k);
-                break;
-              }
-              // If we didn't find a suitable register, create a new one.
-              if (assignedRegs[name] <= 0) {
-                reg = createReg(name);
-                assignedRegs[name] = reg;
-              }
-            }
-          }
-          node[1]->setString(allRegs[reg]);
-        } else {
-          // A kill. This frees the assigned register.
-          assert(reg > 0); //, 'live variable doesnt have a reg?')
-          node[2][1]->setString(allRegs[reg]);
-          freeRegs.push_back(reg);
-          assignedRegs.erase(name);
-          if (node[3][0] == NAME && asmData.isLocal(node[3][1]->getIString())) {
-            maybeRemoveNodes.push_back(std::pair<int, Ref>(j, node));
-          }
-        }
-      }
-      // If we managed to create any "x=x" assignments, remove them.
-      for (size_t j = 0; j < maybeRemoveNodes.size(); j++) {
-        Ref node = maybeRemoveNodes[j].second;
-        if (node[2][1] == node[3][1]) {
-          if (block->isexpr[maybeRemoveNodes[j].first]) {
-            safeCopy(node, node[2]);
-          } else {
-            safeCopy(node, makeEmpty());
-          }
-        }
-      }
-    }
-
-#ifdef PROFILING
-    tblockproc += clock() - start;
-    start = clock();
-#endif
-
-    // Assign registers to function params based on entry junction
-
-    StringSet paramRegs;
-    if (!!fun[2]) {
-      for (size_t i = 0; i < fun[2]->size(); i++) {
-        auto& allRegs = allRegsByType[asmData.getType(fun[2][i]->getIString())];
-        fun[2][i]->setString(allRegs[juncVars[nameToNum[fun[2][i]->getIString()]].reg]);
-        paramRegs.insert(fun[2][i]->getIString());
-      }
-    }
-
-    // That's it!
-    // Re-construct the function with appropriate variable definitions.
-
-    asmData.locals.clear();
-    asmData.params.clear();
-    asmData.vars.clear();
-    for (int i = 1; i < nextReg; i++) {
-      for (size_t type = 0; type < allRegsByType.size(); type++) {
-        if (allRegsByType[type].count(i) > 0) {
-          IString reg = allRegsByType[type][i];
-          if (!paramRegs.has(reg)) {
-            asmData.addVar(reg, intToAsmType(type));
-          } else {
-            asmData.addParam(reg, intToAsmType(type));
-          }
-          break;
-        }
-      }
-    }
-    asmData.denormalize();
-
-    removeAllUselessSubNodes(fun); // XXX vacuum?    vacuum(fun);
-
-#ifdef PROFILING
-    treconstruct += clock() - start;
-    start = clock();
-#endif
-
-  });
-#ifdef PROFILING
-  errv("    RH stages: a:%li fl:%li lf:%li bf:%li jvua:%li jvs:%li jra:%li bp:%li r:%li",
-    tasmdata, tflowgraph, tlabelfix, tbackflow, tjuncvaruniqassign, tjuncvarsort, tregassign, tblockproc, treconstruct);
-#endif
-}
-// end registerizeHarder
-
-// minified names generation
-StringSet RESERVED("do if in for new try var env let");
-const char *VALID_MIN_INITS = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_$";
-const char *VALID_MIN_LATERS = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_$0123456789";
-
-StringVec minifiedNames;
-std::vector<int> minifiedState;
-
-void ensureMinifiedNames(int n) { // make sure the nth index in minifiedNames exists. done 100% deterministically
-  static int VALID_MIN_INITS_LEN = strlen(VALID_MIN_INITS);
-  static int VALID_MIN_LATERS_LEN = strlen(VALID_MIN_LATERS);
-
-  while ((int)minifiedNames.size() < n+1) {
-    // generate the current name
-    std::string name;
-    name += VALID_MIN_INITS[minifiedState[0]];
-    for (size_t i = 1; i < minifiedState.size(); i++) {
-      name += VALID_MIN_LATERS[minifiedState[i]];
-    }
-    IString str(strdupe(name.c_str())); // leaked!
-    if (!RESERVED.has(str)) minifiedNames.push_back(str);
-    // increment the state
-    size_t i = 0;
-    while (1) {
-      minifiedState[i]++;
-      if (minifiedState[i] < (i == 0 ? VALID_MIN_INITS_LEN : VALID_MIN_LATERS_LEN)) break;
-      // overflow
-      minifiedState[i] = 0;
-      i++;
-      if (i == minifiedState.size()) minifiedState.push_back(-1); // will become 0 after increment in next loop head
-    }
-  }
-}
-
-void minifyLocals(Ref ast) {
-  assert(!!extraInfo);
-  IString GLOBALS("globals");
-  assert(extraInfo->has(GLOBALS));
-  Ref globals = extraInfo[GLOBALS];
-
-  if (minifiedState.size() == 0) minifiedState.push_back(0);
-
-  traverseFunctions(ast, [&globals](Ref fun) {
-    // Analyse the asmjs to figure out local variable names,
-    // but operate on the original source tree so that we don't
-    // miss any global names in e.g. variable initializers.
-    AsmData asmData(fun);
-    asmData.denormalize(); // TODO: we can avoid modifying at all here - we just need a list of local vars+params
-
-    StringStringMap newNames;
-    StringSet usedNames;
-
-    // Find all the globals that we need to minify using
-    // pre-assigned names.  Don't actually minify them yet
-    // as that might interfere with local variable names.
-    traversePre(fun, [&](Ref node) {
-      if (node[0] == NAME) {
-        IString name = node[1]->getIString();
-        if (!asmData.isLocal(name)) {
-          if (globals->has(name)) {
-            IString minified = globals[name]->getIString();
-            assert(!!minified);
-            newNames[name] = minified;
-            usedNames.insert(minified);
-          }
-        }
-      }
-    });
-
-    // The first time we encounter a local name, we assign it a
-    // minified name that's not currently in use.  Allocating on
-    // demand means they're processed in a predictable order,
-    // which is very handy for testing/debugging purposes.
-    int nextMinifiedName = 0;
-    auto getNextMinifiedName = [&]() {
-      IString minified;
-      while (1) {
-        ensureMinifiedNames(nextMinifiedName);
-        minified = minifiedNames[nextMinifiedName++];
-        // TODO: we can probably remove !isLocalName here
-        if (!usedNames.has(minified) && !asmData.isLocal(minified)) {
-          return minified;
-        }
-      }
-    };
-
-    // We can also minify loop labels, using a separate namespace
-    // to the variable declarations.
-    StringStringMap newLabels;
-    int nextMinifiedLabel = 0;
-    auto getNextMinifiedLabel = [&]() {
-      ensureMinifiedNames(nextMinifiedLabel);
-      return minifiedNames[nextMinifiedLabel++];
-    };
-
-    // Traverse and minify all names.
-    if (globals->has(fun[1]->getIString())) {
-      fun[1]->setString(globals[fun[1]->getIString()]->getIString());
-      assert(!!fun[1]);
-    }
-    if (!!fun[2]) {
-      for (size_t i = 0; i < fun[2]->size(); i++) {
-        IString minified = getNextMinifiedName();
-        newNames[fun[2][i]->getIString()] = minified;
-        fun[2][i]->setString(minified);
-      }
-    }
-    traversePre(fun[3], [&](Ref node) {
-      Ref type = node[0];
-      if (type == NAME) {
-        IString name = node[1]->getIString();
-        IString minified = newNames[name];
-        if (!!minified) {
-          node[1]->setString(minified);
-        } else if (asmData.isLocal(name)) {
-          minified = getNextMinifiedName();
-          newNames[name] = minified;
-          node[1]->setString(minified);
-        }
-      } else if (type == VAR) {
-        for (size_t i = 0; i < node[1]->size(); i++) {
-          Ref defn = node[1][i];
-          IString name = defn[0]->getIString();
-          if (!(newNames.has(name))) {
-            newNames[name] = getNextMinifiedName();
-          }
-          defn[0]->setString(newNames[name]);
-        }
-      } else if (type == LABEL) {
-        IString name = node[1]->getIString();
-        if (!newLabels.has(name)) {
-          newLabels[name] = getNextMinifiedLabel();
-        }
-        node[1]->setString(newLabels[name]);
-      } else if (type == BREAK || type == CONTINUE) {
-        if (node->size() > 1 && !!node[1]) {
-          node[1]->setString(newLabels[node[1]->getIString()]);
-        }
-      }
-    });
-  });
-}
-
-void asmLastOpts(Ref ast) {
-  std::vector<Ref> statsStack;
-  traverseFunctions(ast, [&](Ref fun) {
-    traversePrePost(fun, [&](Ref node) {
-      Ref type = node[0];
-      Ref stats = getStatements(node);
-      if (!!stats) statsStack.push_back(stats);
-      if (CONDITION_CHECKERS.has(type)) {
-        node[1] = simplifyCondition(node[1]);
-      }
-      if (type == WHILE && node[1][0] == NUM && node[1][1]->getNumber() == 1 && node[2][0] == BLOCK && node[2]->size() == 2) {
-        // This is at the end of the pipeline, we can assume all other optimizations are done, and we modify loops
-        // into shapes that might confuse other passes
-
-        // while (1) { .. if (..) { break } } ==> do { .. } while(..)
-        Ref stats = node[2][1];
-        Ref last = stats->back();
-        if (!!last && last[0] == IF && (last->size() < 4 || !last[3]) && last[2][0] == BLOCK && !!last[2][1][0]) {
-          Ref lastStats = last[2][1];
-          int lastNum = lastStats->size();
-          Ref lastLast = lastStats[lastNum-1];
-          if (!(lastLast[0] == BREAK && !lastLast[1])) return;// if not a simple break, dangerous
-          for (int i = 0; i < lastNum; i++) {
-            if (lastStats[i][0] != STAT && lastStats[i][0] != BREAK) return; // something dangerous
-          }
-          // ok, a bunch of statements ending in a break
-          bool abort = false;
-          int stack = 0;
-          int breaks = 0;
-          traversePrePost(stats, [&](Ref node) {
-            Ref type = node[0];
-            if (type == CONTINUE) {
-              if (stack == 0 || !!node[1]) { // abort if labeled (we do not analyze labels here yet), or a continue directly on us
-                abort = true;
-              }
-            } else if (type == BREAK) {
-              if (stack == 0 || !!node[1]) { // relevant if labeled (we do not analyze labels here yet), or a break directly on us
-                breaks++;
-              }
-            } else if (LOOP.has(type)) {
-              stack++;
-            }
-          }, [&](Ref node) {
-            if (LOOP.has(node[0])) {
-              stack--;
-            }
-          });
-          if (abort) return;
-          assert(breaks > 0);
-          if (lastStats->size() > 1 && breaks != 1) return; // if we have code aside from the break, we can only move it out if there is just one break
-          if (statsStack.size() < 1) return; // no chance we have this stats on hand
-          // start to optimize
-          if (lastStats->size() > 1) {
-            Ref parent = statsStack.back();
-            int me = parent->indexOf(node);
-            if (me < 0) return; // not always directly on a stats, could be in a label for example
-            parent->insert(me+1, lastStats->size()-1);
-            for (size_t i = 0; i+1 < lastStats->size(); i++) {
-              parent[me+1+i] = lastStats[i];
-            }
-          }
-          Ref conditionToBreak = last[1];
-          stats->pop_back();
-          node[0]->setString(DO);
-          node[1] = simplifyNotCompsDirect(make2(UNARY_PREFIX, L_NOT, conditionToBreak));
-        }
-      } else if (type == BINARY) {
-        if (node[1] == AND) {
-          if (node[3][0] == UNARY_PREFIX && node[3][1] == MINUS && node[3][2][0] == NUM && node[3][2][1]->getNumber() == 1) {
-            // Change &-1 into |0, at this point the hint is no longer needed
-            node[1]->setString(OR);
-            node[3] = node[3][2];
-            node[3][1]->setNumber(0);
-          }
-        } else if (node[1] == MINUS && node[3][0] == UNARY_PREFIX) {
-          // avoid X - (-Y) because some minifiers buggily emit X--Y which is invalid as -- can be a unary. Transform to
-          //        X + Y
-          if (node[3][1] == MINUS) { // integer
-            node[1]->setString(PLUS);
-            node[3] = node[3][2];
-          } else if (node[3][1] == PLUS) { // float
-            if (node[3][2][0] == UNARY_PREFIX && node[3][2][1] == MINUS) {
-              node[1]->setString(PLUS);
-              node[3][2] = node[3][2][2];
-            }
-          }
-        }
-      }
-    }, [&](Ref node) {
-      if (statsStack.size() > 0) {
-        Ref stats = getStatements(node);
-        if (!!stats) statsStack.pop_back();
-      }
-    });
-    // convert  { singleton }  into  singleton
-    traversePre(fun, [](Ref node) {
-      if (node[0] == BLOCK && !!getStatements(node) && node[1]->size() == 1) {
-        safeCopy(node, node[1][0]);
-      }
-    });
-    // convert L: do { .. } while(0) into L: { .. }
-    traversePre(fun, [](Ref node) {
-      if (node[0] == LABEL && node[1]->isString() /* careful of var label = 5 */ &&
-          node[2][0] == DO && node[2][1][0] == NUM && node[2][1][1]->getNumber() == 0 && node[2][2][0] == BLOCK) {
-        // there shouldn't be any continues on this, not direct break or continue
-        IString label = node[1]->getIString();
-        bool abort = false;
-        int breakCaptured = 0, continueCaptured = 0;
-        traversePrePost(node[2][2], [&](Ref node) {
-          if (node[0] == CONTINUE) {
-            if (!node[1] && !continueCaptured) {
-              abort = true;
-            } else if (node[1]->isString() && node[1]->getIString() == label) {
-              abort = true;
-            }
-          }
-          if (node[0] == BREAK && !node[1] && !breakCaptured) {
-            abort = true;
-          }
-          if (BREAK_CAPTURERS.has(node[0])) {
-            breakCaptured++;
-          }
-          if (CONTINUE_CAPTURERS.has(node[0])) {
-            continueCaptured++;
-          }
-        }, [&](Ref node) {
-          if (BREAK_CAPTURERS.has(node[0])) {
-            breakCaptured--;
-          }
-          if (CONTINUE_CAPTURERS.has(node[0])) {
-            continueCaptured--;
-          }
-        });
-        if (abort) return;
-        safeCopy(node[2], node[2][2]);
-      }
-    });
-  });
-}
-
-// Contrary to the name this does not eliminate actual dead functions, only
-// those marked as such with DEAD_FUNCTIONS
-void eliminateDeadFuncs(Ref ast) {
-  assert(!!extraInfo);
-  IString DEAD_FUNCTIONS("dead_functions");
-  IString ABORT("abort");
-  assert(extraInfo->has(DEAD_FUNCTIONS));
-  StringSet deadFunctions;
-  for (size_t i = 0; i < extraInfo[DEAD_FUNCTIONS]->size(); i++) {
-    deadFunctions.insert(extraInfo[DEAD_FUNCTIONS][i]->getIString());
-  }
-  traverseFunctions(ast, [&](Ref fun) {
-    if (!deadFunctions.has(fun[1].get()->getIString())) {
-      return;
-    }
-    AsmData asmData(fun);
-    fun[3]->setSize(1);
-    fun[3][0] = make1(STAT, make2(CALL, makeName(ABORT), &(makeArray(1))->push_back(makeNum(-1))));
-    asmData.vars.clear();
-    asmData.denormalize();
-  });
-}
-