old-apl.js

//usr/bin/env node "$0" $@ ; exit $?
// Generated by CoffeeScript 1.6.3
(function() {
  var A, ADVERB, Beta, CON, CONJUNCTION, DYA, EMB, GET, JEQ, LAM, LDC, MON, NOUN, POP, Proc, RET, SET, SPL, VEC, VERB, Z, addVocabulary, adverb, all, apl, aplError, aplify, approx, arrayEquals, bool, compileAST, complexify, conjunction, contains, cps, deal, depthOf, domainError, enlist, eq, exec, exp, extend, first, format, getAxisList, grade, indexAtSingleAxis, indexError, innerProduct, lengthError, lnΓ, match, negInt, nonceError, numApprox, numeric, outerProduct, parse, pervasive, prelude, prod, rankError, readline, reduce, repeat, repr, reversed, roll, rotate, scanOrExpand, simplify, smallFactorials, squish, strideForShape, syntaxError, take, tokenDefs, tokenize, valueError, vm, vocabulary, withIdentity, Γ, _base, _ref, _ref1, _ref2,
    __slice = [].slice,
    __indexOf = [].indexOf || function(item) { for (var i = 0, l = this.length; i < l; i++) { if (i in this && this[i] === item) return i; } return -1; };



  prod = function(xs) {
    var r, x, _i, _len;
    r = 1;
    for (_i = 0, _len = xs.length; _i < _len; _i++) {
      x = xs[_i];
      r *= x;
    }
    return r;
  };
  all = function(xs) {
    var x, _i, _len;
    for (_i = 0, _len = xs.length; _i < _len; _i++) {
      x = xs[_i];
      if (!x) {
        return false;
      }
    }
    return true;
  };
  repeat = function(a, n) {
    var m, t0;
    if (!(a.length != null)) {
      throw Error("\"assert a.length?\" at src/helpers.coffee:19");
    }
    if (!((t0 = (n)) === ~~t0 && (0) <= t0)) {
      throw Error("\"assert isInt n, 0\" at src/helpers.coffee:20");
    }
    if (!n) {
      return a.slice(0, 0);
    }
    m = n * a.length;
    while (a.length * 2 < m) {
      a = a.concat(a);
    }
    return a.concat(a.slice(0, m - a.length));
  };
  extend = function(x, y) {
    var k;
    for (k in y) {
      x[k] = y[k];
    }
    return x;
  };
  if (this.Uint8Array == null) {
    this.Uint8Array = Array;
  }
  if (this.Uint16Array == null) {
    this.Uint16Array = Array;
  }
  if (this.Uint32Array == null) {
    this.Uint32Array = Array;
  }
  if (this.Int8Array == null) {
    this.Int8Array = Array;
  }
  if (this.Int16Array == null) {
    this.Int16Array = Array;
  }
  if (this.Int32Array == null) {
    this.Int32Array = Array;
  }
  if ((_base = Array.prototype).set == null) {
    _base.set = function(a, offset) {
      var i, _i, _ref;
      for (i = _i = 0, _ref = a.length; _i < _ref; i = _i += 1) {
        this[offset + i] = a[i];
      }
    };
  }
  arrayEquals = function(a, b) {
    var i, x, _i, _len;
    if (!(a.length != null)) {
      throw Error("\"assert a.length?\" at src/helpers.coffee:70");
    }
    if (!(b.length != null)) {
      throw Error("\"assert b.length?\" at src/helpers.coffee:71");
    }
    if (a.length !== b.length) {
      return false;
    }
    for (i = _i = 0, _len = a.length; _i < _len; i = ++_i) {
      x = a[i];
      if (x !== b[i]) {
        return false;
      }
    }
    return true;
  };
  reversed = function(a) {
    var b, h, i, j;
    if (a instanceof Array) {
      return a.slice(0).reverse();
    } else {
      b = new a.constructor(a.length);
      b.set(a);
      i = -1;
      j = a.length;
      while (++i < --j) {
        h = b[i];
        b[i] = b[j];
        b[j] = h;
      }
      return b;
    }
  };

  aplError = function(name, message, opts) {
    var a, aplCode, col, e, file, k, line, offset, v, _ref;
    if (message == null) {
      message = '';
    }
    if (!(typeof name === 'string')) {
      throw Error("\"assert typeof name is 'string'\" at src/errors.coffee:2");
    }
    if (!(typeof message === 'string')) {
      throw Error("\"assert typeof message is 'string'\" at src/errors.coffee:3");
    }
    if (opts != null) {
      aplCode = opts.aplCode, offset = opts.offset, file = opts.file;
      if ((aplCode != null) && (offset != null)) {
        if (!(typeof aplCode === 'string')) {
          throw Error("\"assert typeof aplCode is 'string'\" at src/errors.coffee:7");
        }
        if (!(typeof offset === 'number')) {
          throw Error("\"assert typeof offset is 'number'\" at src/errors.coffee:8");
        }
        if (!((_ref = typeof file) === 'string' || _ref === 'undefined')) {
          throw Error("\"assert typeof file in ['string', 'undefined']\" at src/errors.coffee:9");
        }
        a = aplCode.slice(0, offset).split('\n');
        line = a.length;
        col = 1 + (a[a.length - 1] || '').length;
        message += "\n" + (file || '-') + ":" + line + ":" + col + "\n" + (aplCode.split('\n')[line - 1]) + "\n" + (repeat('_', col - 1)) + "^";
      }
    }
    e = Error(message);
    e.name = name;
    for (k in opts) {
      v = opts[k];
      e[k] = v;
    }
    throw e;
  };
  syntaxError = function() {
    var a;
    a = 1 <= arguments.length ? __slice.call(arguments, 0) : [];
    return aplError.apply(null, ['SYNTAX ERROR'].concat(__slice.call(a)));
  };
  domainError = function() {
    var a;
    a = 1 <= arguments.length ? __slice.call(arguments, 0) : [];
    return aplError.apply(null, ['DOMAIN ERROR'].concat(__slice.call(a)));
  };
  lengthError = function() {
    var a;
    a = 1 <= arguments.length ? __slice.call(arguments, 0) : [];
    return aplError.apply(null, ['LENGTH ERROR'].concat(__slice.call(a)));
  };
  rankError = function() {
    var a;
    a = 1 <= arguments.length ? __slice.call(arguments, 0) : [];
    return aplError.apply(null, ['RANK ERROR'].concat(__slice.call(a)));
  };
  indexError = function() {
    var a;
    a = 1 <= arguments.length ? __slice.call(arguments, 0) : [];
    return aplError.apply(null, ['INDEX ERROR'].concat(__slice.call(a)));
  };
  nonceError = function() {
    var a;
    a = 1 <= arguments.length ? __slice.call(arguments, 0) : [];
    return aplError.apply(null, ['NONCE ERROR'].concat(__slice.call(a)));
  };
  valueError = function() {
    var a;
    a = 1 <= arguments.length ? __slice.call(arguments, 0) : [];
    return aplError.apply(null, ['VALUE ERROR'].concat(__slice.call(a)));
  };

  A = (function() {
    function A(data, shape, stride, offset) {
      var i, t1, t2, t3, x, _i, _j, _len, _len1, _ref, _ref1, _ref2, _ref3;
      this.data = data;
      this.shape = shape;
      this.stride = stride;
      this.offset = offset != null ? offset : 0;
      if (this.shape == null) {
        this.shape = [this.data.length];
      }
      if (this.stride == null) {
        this.stride = strideForShape(this.shape);
      }
      if (!(this.data.length != null)) {
        throw Error("\"assert @data.length?\" at src/array.coffee:95");
      }
      if (!(this.shape.length != null)) {
        throw Error("\"assert @shape.length?\" at src/array.coffee:96");
      }
      if (!(this.stride.length != null)) {
        throw Error("\"assert @stride.length?\" at src/array.coffee:97");
      }
      if (!(this.data.length === 0 || ((t1 = this.offset) === ~~t1 && ((0) <= (_ref = t1) && _ref < this.data.length)))) {
        throw Error("\"assert @data.length is 0 or isInt @offset, 0, @data.length\" at src/array.coffee:98");
      }
      if (!(this.stride.length === this.shape.length)) {
        throw Error("\"assert @stride.length is ⍴⍴ @\" at src/array.coffee:99");
      }
      _ref1 = this.shape;
      for (_i = 0, _len = _ref1.length; _i < _len; _i++) {
        x = _ref1[_i];
        if (!((t2 = (x)) === ~~t2 && (0) <= t2)) {
          throw Error("\"for x in @shape then assert isInt x, 0\" at src/array.coffee:100");
        }
      }
      if (this.data.length) {
        _ref2 = this.stride;
        for (i = _j = 0, _len1 = _ref2.length; _j < _len1; i = ++_j) {
          x = _ref2[i];
          if (!((t3 = (x)) === ~~t3 && ((-this.data.length) <= (_ref3 = t3) && _ref3 < (this.data.length + 1)))) {
            throw Error("\"for x, i in @stride then assert isInt x, -@data.length, @data.length + 1\" at src/array.coffee:102");
          }
        }
      }
    }

    A.prototype.empty = function() {
      var d, _i, _len, _ref;
      _ref = this.shape;
      for (_i = 0, _len = _ref.length; _i < _len; _i++) {
        d = _ref[_i];
        if (!d) {
          return true;
        }
      }
      return false;
    };

    A.prototype.map = function(f) {
      var data, indices, t10, t4, t5, t6, t7, t8, t9, x;
      if (!(typeof f === 'function')) {
        throw Error("\"assert typeof f is 'function'\" at src/array.coffee:109");
      }
      data = [];
      t4 = this;
      if (!t4.empty()) {
        t6 = t4.data;
        t7 = t4.shape;
        t8 = t4.stride;
        t9 = t7.length - 1;
        t10 = t4.offset;
        indices = [];
        t5 = t7.length;
        while (--t5 >= 0) {
          indices.push(0);
        }
        while (true) {
          x = t6[t10];
          data.push(f(x, indices));
          t5 = t9;
          while (t5 >= 0 && indices[t5] + 1 === t7[t5]) {
            t10 -= indices[t5] * t8[t5];
            indices[t5--] = 0;
          }
          if (t5 < 0) {
            break;
          }
          indices[t5]++;
          t10 += t8[t5];
        }
      }
      return new A(data, this.shape);
    };

    A.prototype.map2 = function(a, f) {
      var data, indices, t11, t12, t13, t14, t15, t16, t17, t18, t19, t20, t21, t22, x, y;
      if (!(a instanceof A)) {
        throw Error("\"assert a instanceof A\" at src/array.coffee:115");
      }
      if (!(typeof f === 'function')) {
        throw Error("\"assert typeof f is 'function'\" at src/array.coffee:116");
      }
      data = [];
      t11 = this;
      t16 = t11.data;
      t18 = t11.shape;
      t20 = t11.stride;
      t12 = a;
      t17 = t12.data;
      t19 = t12.shape;
      t21 = t12.stride;
      if (t18.length !== t19.length) {
        rankError();
      }
      t15 = t18.length;
      while (--t15 >= 0) {
        if (t18[t15] !== t19[t15]) {
          lengthError();
        }
      }
      if (!t11.empty()) {
        t22 = t18.length - 1;
        t13 = t11.offset;
        t14 = t12.offset;
        indices = Array((t15 = t18.length));
        while (--t15 >= 0) {
          indices[t15] = 0;
        }
        while (true) {
          x = t16[t13];
          y = t17[t14];
          data.push(f(x, y, indices));
          t15 = t22;
          while (t15 >= 0 && indices[t15] + 1 === t18[t15]) {
            t13 -= indices[t15] * t20[t15];
            t14 -= indices[t15] * t21[t15];
            indices[t15--] = 0;
          }
          if (t15 < 0) {
            break;
          }
          indices[t15]++;
          t13 += t20[t15];
          t14 += t21[t15];
        }
      }
      return new A(data, this.shape);
    };

    A.prototype.toArray = function() {
      var r, t23, t24, t25, t26, t27, t28, t29, t30, x;
      r = [];
      t23 = this;
      if (!t23.empty()) {
        t25 = t23.data;
        t26 = t23.shape;
        t27 = t23.stride;
        t28 = t26.length - 1;
        t30 = t23.offset;
        t29 = [];
        t24 = t26.length;
        while (--t24 >= 0) {
          t29.push(0);
        }
        while (true) {
          x = t25[t30];
          r.push(x);
          t24 = t28;
          while (t24 >= 0 && t29[t24] + 1 === t26[t24]) {
            t30 -= t29[t24] * t27[t24];
            t29[t24--] = 0;
          }
          if (t24 < 0) {
            break;
          }
          t29[t24]++;
          t30 += t27[t24];
        }
      }
      return r;
    };

    A.prototype.toInt = function(start, end) {
      var r;
      if (start == null) {
        start = -Infinity;
      }
      if (end == null) {
        end = Infinity;
      }
      r = this.unwrap();
      if (typeof r !== 'number' || r !== ~~r || !((start <= r && r < end))) {
        return domainError();
      } else {
        return r;
      }
    };

    A.prototype.toBool = function() {
      return this.toInt(0, 2);
    };

    A.prototype.toSimpleString = function() {
      var a, x, _i, _len;
      if (this.shape.length > 1) {
        rankError();
      }
      if (typeof this.data === 'string') {
        if (!this.shape.length) {
          return this.data[this.offset];
        }
        if (this.shape[0] === 0) {
          return '';
        }
        if (this.stride[0] === 1) {
          return this.data.slice(this.offset, this.offset + this.shape[0]);
        }
        return this.toArray().join('');
      } else {
        a = this.toArray();
        for (_i = 0, _len = a.length; _i < _len; _i++) {
          x = a[_i];
          if (typeof x !== 'string') {
            domainError();
          }
        }
        return a.join('');
      }
    };

    A.prototype.isSingleton = function() {
      var n, _i, _len, _ref;
      _ref = this.shape;
      for (_i = 0, _len = _ref.length; _i < _len; _i++) {
        n = _ref[_i];
        if (n !== 1) {
          return false;
        }
      }
      return true;
    };

    A.prototype.isSimple = function() {
      return this.shape.length === 0 && !(this.data[this.offset] instanceof A);
    };

    A.prototype.unwrap = function() {
      if (prod(this.shape) === 1) {
        return this.data[this.offset];
      } else {
        return lengthError();
      }
    };

    A.prototype.getPrototype = function() {
      if (this.empty() || typeof this.data[this.offset] !== 'string') {
        return 0;
      } else {
        return ' ';
      }
    };

    A.prototype.toString = function() {
      return format(this).join('\n');
    };

    A.prototype.repr = function() {
      return "new A(" + (repr(this.data)) + "," + (repr(this.shape)) + "," + (repr(this.stride)) + "," + (repr(this.offset)) + ")";
    };

    return A;

  })();
  strideForShape = function(shape) {
    var i, r, t31, _i, _ref;
    if (!(shape.length != null)) {
      throw Error("\"assert shape.length?\" at src/array.coffee:155");
    }
    if (shape.length === 0) {
      return [];
    }
    r = Array(shape.length);
    r[r.length - 1] = 1;
    for (i = _i = _ref = r.length - 2; _i >= 0; i = _i += -1) {
      if (!((t31 = shape[i]) === ~~t31 && (0) <= t31)) {
        throw Error("\"assert isInt shape[i], 0\" at src/array.coffee:160");
      }
      r[i] = r[i + 1] * shape[i + 1];
    }
    return r;
  };
  A.zero = new A([0], []);
  A.one = new A([1], []);
  A.zilde = new A([], [0]);
  A.scalar = function(x) {
    return new A([x], []);
  };
  A.bool = [A.zero, A.one];

  complexify = function(x) {
    if (typeof x === 'number') {
      return new Z(x, 0);
    } else if (x instanceof Z) {
      return x;
    } else {
      return domainError();
    }
  };
  simplify = function(re, im) {
    if (im !== 0) {
      return new Z(re, im);
    } else {
      return re;
    }
  };
  Z = (function() {
    var acos, add, asin, atan, cosh, direction, divide, exp, firstquadrant, floor, gcd, iszero, itimes, log, multiply, negate, negitimes, pow, residue, sinh, sqrt, subtract, tanh;

    function Z(re, im) {
      this.re = re;
      this.im = im != null ? im : 0;
      if (!(typeof this.re === 'number')) {
        throw Error("\"assert typeof @re is 'number'\" at src/complex.coffee:20");
      }
      if (!(typeof this.im === 'number')) {
        throw Error("\"assert typeof @im is 'number'\" at src/complex.coffee:21");
      }
      if (isNaN(this.re) || isNaN(this.im)) {
        domainError('NaN');
      }
    }

    Z.prototype.toString = function() {
      return "" + (('' + this.re).replace('Infinity', '∞').replace(/-/g, '¯')) + "J" + (('' + this.im).replace('Infinity', '∞').replace(/-/g, '¯'));
    };

    Z.prototype.repr = function() {
      return "new Z(" + (repr(this.re)) + "," + (repr(this.im)) + ")";
    };

    Z.exp = exp = function(x) {
      var r;
      x = complexify(x);
      r = Math.exp(x.re);
      return simplify(r * Math.cos(x.im), r * Math.sin(x.im));
    };

    Z.log = log = function(x) {
      if (typeof x === 'number' && x > 0) {
        return Math.log(x);
      } else {
        x = complexify(x);
        return simplify(Math.log(Math.sqrt(x.re * x.re + x.im * x.im)), direction(x));
      }
    };

    Z.conjugate = function(x) {
      return new Z(x.re, -x.im);
    };

    Z.negate = negate = function(x) {
      return new Z(-x.re, -x.im);
    };

    Z.itimes = itimes = function(x) {
      x = complexify(x);
      return simplify(-x.im, x.re);
    };

    Z.negitimes = negitimes = function(x) {
      x = complexify(x);
      return simplify(x.im, -x.re);
    };

    Z.add = add = function(x, y) {
      x = complexify(x);
      y = complexify(y);
      return simplify(x.re + y.re, x.im + y.im);
    };

    Z.subtract = subtract = function(x, y) {
      x = complexify(x);
      y = complexify(y);
      return simplify(x.re - y.re, x.im - y.im);
    };

    Z.multiply = multiply = function(x, y) {
      x = complexify(x);
      y = complexify(y);
      return simplify(x.re * y.re - x.im * y.im, x.re * y.im + x.im * y.re);
    };

    Z.divide = divide = function(x, y) {
      var d;
      x = complexify(x);
      y = complexify(y);
      d = y.re * y.re + y.im * y.im;
      return simplify((x.re * y.re + x.im * y.im) / d, (y.re * x.im - y.im * x.re) / d);
    };

    Z.pow = pow = function(x, y) {
      var r, t32, t33, _ref;
      if ((typeof x === (_ref = typeof y) && _ref === 'number') && (x >= 0 || ((t32 = (y)) === ~~t32))) {
        return Math.pow(x, y);
      } else if (typeof y === 'number' && ((t33 = (y)) === ~~t33 && (0) <= t33)) {
        r = 1;
        while (y) {
          if (y & 1) {
            r = multiply(r, x);
          }
          x = multiply(x, x);
          y >>= 1;
        }
        return r;
      } else {
        return exp(multiply(y, log(x)));
      }
    };

    Z.sqrt = sqrt = function(x) {
      if (typeof x === 'number' && x >= 0) {
        return Math.sqrt(x);
      } else {
        return pow(x, 0.5);
      }
    };

    Z.magnitude = function(x) {
      return Math.sqrt(x.re * x.re + x.im * x.im);
    };

    Z.direction = direction = function(x) {
      return Math.atan2(x.im, x.re);
    };

    Z.sin = function(x) {
      return negitimes(sinh(itimes(x)));
    };

    Z.cos = function(x) {
      return cosh(itimes(x));
    };

    Z.tan = function(x) {
      return negitimes(tanh(itimes(x)));
    };

    Z.asin = asin = function(x) {
      x = complexify(x);
      return negitimes(log(add(itimes(x), sqrt(subtract(1, pow(x, 2))))));
    };

    Z.acos = acos = function(x) {
      var r;
      x = complexify(x);
      r = negitimes(log(add(x, sqrt(subtract(pow(x, 2), 1)))));
      if (r instanceof Z && (r.re < 0 || (r.re === 0 && r.im < 0))) {
        return negate(r);
      } else {
        return r;
      }
    };

    Z.atan = atan = function(x) {
      var ix;
      x = complexify(x);
      ix = itimes(x);
      return multiply(new Z(0, .5), subtract(log(subtract(1, ix)), log(add(1, ix))));
    };

    Z.sinh = sinh = function(x) {
      var a;
      a = exp(x);
      return multiply(0.5, subtract(a, divide(1, a)));
    };

    Z.cosh = cosh = function(x) {
      var a;
      a = exp(x);
      return multiply(0.5, add(a, divide(1, a)));
    };

    Z.tanh = tanh = function(x) {
      var a, b;
      a = exp(x);
      b = divide(1, a);
      return divide(subtract(a, b), add(a, b));
    };

    Z.asinh = function(x) {
      return itimes(asin(negitimes(x)));
    };

    Z.acosh = function(x) {
      var sign;
      x = complexify(x);
      sign = x.im > 0 || (x.im === 0 && x.re <= 1) ? 1 : -1;
      return multiply(new Z(0, sign), acos(x));
    };

    Z.atanh = function(x) {
      return itimes(atan(negitimes(x)));
    };

    Z.floor = floor = function(x) {
      var i, im, r, re, _ref, _ref1;
      if (typeof x === 'number') {
        return Math.floor(x);
      } else {
        x = complexify(x);
        _ref = [Math.floor(x.re), Math.floor(x.im)], re = _ref[0], im = _ref[1];
        _ref1 = [x.re - re, x.im - im], r = _ref1[0], i = _ref1[1];
        if (r + i >= 1) {
          if (r >= i) {
            re++;
          } else {
            im++;
          }
        }
        return simplify(re, im);
      }
    };

    Z.ceil = function(x) {
      var i, im, r, re, _ref, _ref1;
      if (typeof x === 'number') {
        return Math.ceil(x);
      } else {
        x = complexify(x);
        _ref = [Math.ceil(x.re), Math.ceil(x.im)], re = _ref[0], im = _ref[1];
        _ref1 = [re - x.re, im - x.im], r = _ref1[0], i = _ref1[1];
        if (r + i >= 1) {
          if (r >= i) {
            re--;
          } else {
            im--;
          }
        }
        return simplify(re, im);
      }
    };

    iszero = function(x) {
      return x === 0 || (x instanceof Z && x.re === 0 && x.im === 0);
    };

    Z.residue = residue = function(x, y) {
      var _ref;
      if ((typeof x === (_ref = typeof y) && _ref === 'number')) {
        if (x === 0) {
          return y;
        } else {
          return y - x * Math.floor(y / x);
        }
      } else {
        if (iszero(x)) {
          return y;
        } else {
          return subtract(y, multiply(x, floor(divide(y, x))));
        }
      }
    };

    Z.isint = function(x) {
      if (typeof x === 'number') {
        return x === Math.floor(x);
      } else {
        return (x.re === Math.floor(x.re)) && (x.im === Math.floor(x.im));
      }
    };

    firstquadrant = function(x) {
      if (typeof x === 'number') {
        return Math.abs(x);
      } else {
        if (x.re < 0) {
          x = negate(x);
        }
        if (x.im < 0) {
          x = itimes(x);
        }
        if (x.re === 0) {
          x = x.im;
        }
        return x;
      }
    };

    Z.gcd = gcd = function(x, y) {
      var _ref, _ref1, _ref2;
      if ((typeof x === (_ref = typeof y) && _ref === 'number')) {
        while (y) {
          _ref1 = [y, x % y], x = _ref1[0], y = _ref1[1];
        }
        return Math.abs(x);
      } else {
        while (!iszero(y)) {
          _ref2 = [y, residue(y, x)], x = _ref2[0], y = _ref2[1];
        }
        return firstquadrant(x);
      }
    };

    Z.lcm = function(x, y) {
      var p;
      p = multiply(x, y);
      if (iszero(p)) {
        return p;
      } else {
        return divide(p, gcd(x, y));
      }
    };

    return Z;

  })();

  _ref = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13], LDC = _ref[0], VEC = _ref[1], GET = _ref[2], SET = _ref[3], MON = _ref[4], DYA = _ref[5], LAM = _ref[6], RET = _ref[7], POP = _ref[8], SPL = _ref[9], JEQ = _ref[10], EMB = _ref[11], CON = _ref[12];
  Proc = (function() {
    function Proc(code, addr, size, env) {
      this.code = code;
      this.addr = addr;
      this.size = size;
      this.env = env;
    }

    Proc.prototype.toFunction = function() {
      return (function(_this) {
        return function(x, y) {
          return vm({
            code: _this.code,
            env: _this.env.concat([[x, _this, y, null]]),
            pc: _this.addr
          });
        };
      })(this);
    };

    Proc.prototype.toString = function() {
      return '#procedure';
    };

    return Proc;

  })();
  vm = function(_arg) {
    var a, bp, code, env, f, frame, n, pc, size, stack, w, x, _i, _j, _len, _len1, _ref1, _ref2, _ref3, _ref4, _ref5;
    code = _arg.code, env = _arg.env, stack = _arg.stack, pc = _arg.pc;
    if (!(code instanceof Array)) {
      throw Error("\"assert code instanceof Array\" at src/vm.coffee:9");
    }
    if (!(env instanceof Array)) {
      throw Error("\"assert env instanceof Array\" at src/vm.coffee:10");
    }
    for (_i = 0, _len = env.length; _i < _len; _i++) {
      frame = env[_i];
      if (!(frame instanceof Array)) {
        throw Error("\"for frame in env then assert frame instanceof Array\" at src/vm.coffee:11");
      }
    }
    if (stack == null) {
      stack = [];
    }
    if (pc == null) {
      pc = 0;
    }
    while (true) {
      switch (code[pc++]) {
        case LDC:
          stack.push(code[pc++]);
          break;
        case VEC:
          a = [];
          _ref1 = stack.splice(stack.length - code[pc++]);
          for (_j = 0, _len1 = _ref1.length; _j < _len1; _j++) {
            x = _ref1[_j];
            a.push(x.isSimple() ? x.unwrap() : x);
          }
          stack.push(new A(a));
          break;
        case GET:
          stack.push((_ref2 = env[code[pc++]][code[pc++]]) != null ? _ref2 : valueError());
          break;
        case SET:
          env[code[pc++]][code[pc++]] = stack[stack.length - 1];
          break;
        case MON:
          _ref3 = stack.splice(-2), w = _ref3[0], f = _ref3[1];
          if (typeof f === 'function') {
            if (w instanceof Proc) {
              w = w.toFunction();
            }
            if (f.cps) {
              f(w, void 0, void 0, function(r) {
                stack.push(r);
                vm({
                  code: code,
                  env: env,
                  stack: stack,
                  pc: pc
                });
              });
              return;
            } else {
              stack.push(f(w));
            }
          } else {
            bp = stack.length;
            stack.push(code, pc, env);
            code = f.code;
            pc = f.addr;
            env = f.env.concat([[w, f, null, bp]]);
          }
          break;
        case DYA:
          _ref4 = stack.splice(-3), w = _ref4[0], f = _ref4[1], a = _ref4[2];
          if (typeof f === 'function') {
            if (w instanceof Proc) {
              w = w.toFunction();
            }
            if (a instanceof Proc) {
              a = a.toFunction();
            }
            if (f.cps) {
              f(w, a, void 0, function(r) {
                stack.push(r);
                vm({
                  code: code,
                  env: env,
                  stack: stack,
                  pc: pc
                });
              });
              return;
            } else {
              stack.push(f(w, a));
            }
          } else {
            bp = stack.length;
            stack.push(code, pc, env);
            code = f.code;
            pc = f.addr;
            env = f.env.concat([[w, f, a, bp]]);
          }
          break;
        case LAM:
          size = code[pc++];
          stack.push(new Proc(code, pc, size, env));
          pc += size;
          break;
        case RET:
          if (stack.length === 1) {
            return stack[0];
          }
          _ref5 = stack.splice(-4, 3), code = _ref5[0], pc = _ref5[1], env = _ref5[2];
          break;
        case POP:
          stack.pop();
          break;
        case SPL:
          n = code[pc++];
          a = stack[stack.length - 1].toArray().reverse();
          a = (function() {
            var _k, _len2, _results;
            _results = [];
            for (_k = 0, _len2 = a.length; _k < _len2; _k++) {
              x = a[_k];
              _results.push(x instanceof A ? x : new A([x], []));
            }
            return _results;
          })();
          if (a.length === 1) {
            a = repeat(a, n);
          } else if (a.length !== n) {
            lengthError();
          }
          stack.push.apply(stack, a);
          break;
        case JEQ:
          n = code[pc++];
          if (!stack[stack.length - 1].toBool()) {
            pc += n;
          }
          break;
        case EMB:
          frame = env[env.length - 1];
          stack.push(code[pc++](frame[0], frame[2]));
          break;
        case CON:
          frame = env[env.length - 1];
          (function() {
            var cont;
            cont = {
              code: code,
              env: (function() {
                var _k, _len2, _results;
                _results = [];
                for (_k = 0, _len2 = env.length; _k < _len2; _k++) {
                  x = env[_k];
                  _results.push(x.slice(0));
                }
                return _results;
              })(),
              stack: stack.slice(0, frame[3]),
              pc: frame[1].addr + frame[1].size - 1
            };
            if (!(code[cont.pc] === RET)) {
              throw Error("\"assert code[cont.pc] is RET\" at src/vm.coffee:87");
            }
            return stack.push(function(r) {
              code = cont.code, env = cont.env, stack = cont.stack, pc = cont.pc;
              return stack.push(r);
            });
          })();
          break;
        default:
          aplError('Unrecognized instruction: ' + code[pc - 1] + ', pc:' + pc);
      }
    }
  };

  tokenDefs = [['-', /^(?:[ \t]+|[⍝\#].*)+/], ['L', /^[\n\r]+/], ['⋄', /^[◇⋄]/], ['N', /^¯?(?:0x[\da-f]+|\d*\.?\d+(?:e[+¯]?\d+)?|¯|∞)(?:j¯?(?:0x[\da-f]+|\d*\.?\d+(?:e[+¯]?\d+)?|¯|∞))?/i], ['S', /^(?:'[^']*')+|^(?:"[^"]*")+/], ['.', /^[\(\)\[\]\{\}:;←]/], ['J', /^«[^»]*»/], ['X', /^(?:⎕?[a-z_]\w*|⍺⍺|⍵⍵|∇∇|[^¯'":«»])/i]];
  tokenize = function(s, opts) {
    var m, ns, offset, re, stack, t, tokens, type, value, _i, _len, _ref1;
    if (opts == null) {
      opts = {};
    }
    offset = 0;
    stack = ['{'];
    tokens = [];
    ns = s.length;
    while (offset < ns) {
      type = null;
      for (_i = 0, _len = tokenDefs.length; _i < _len; _i++) {
        _ref1 = tokenDefs[_i], t = _ref1[0], re = _ref1[1];
        if (!(m = s.slice(offset).match(re))) {
          continue;
        }
        value = m[0];
        type = t === '.' ? value : t;
        break;
      }
      if (!type) {
        syntaxError('Unrecognized token', {
          file: opts.file,
          offset: offset,
          s: opts.s
        });
      }
      if (type !== '-') {
        if (__indexOf.call('([{', type) >= 0) {
          stack.push(type);
        } else if (__indexOf.call(')]}', type) >= 0) {
          stack.pop();
        }
        if (type !== 'L' || stack[stack.length - 1] === '{') {
          tokens.push({
            type: type,
            value: value,
            offset: offset,
            aplCode: s
          });
        }
      }
      offset += value.length;
    }
    tokens.push({
      type: '$',
      value: '',
      offset: offset,
      aplCode: s
    });
    return tokens;
  };

  parse = function(aplCode, opts) {
    var i, parseBody, parseExpr, parserError, result, token, tokens;
    if (opts == null) {
      opts = {};
    }
    tokens = tokenize(aplCode);
    i = 0;
    token = tokens[i++];
    parserError = function(message) {
      return syntaxError(message, {
        file: opts.file,
        offset: token.offset,
        aplCode: aplCode
      });
    };
    parseBody = function() {
      var body, expr, _ref1, _ref2, _ref3, _ref4;
      body = ['B'];
      while (true) {
        if (_ref1 = token.type, __indexOf.call('$};', _ref1) >= 0) {
          return body;
        }
        while (((_ref2 = token.type) === "⋄" || _ref2 === "L" ? token = tokens[i++] : void 0)) {}
        if (_ref3 = token.type, __indexOf.call('$};', _ref3) >= 0) {
          return body;
        }
        expr = parseExpr();
        if (((_ref4 = token.type) === ":" ? token = tokens[i++] : void 0)) {
          expr = [':', expr, parseExpr()];
        }
        body.push(expr);
      }
    };
    parseExpr = function() {
      var expr, item, t, _ref1, _ref2, _ref3, _ref4, _ref5, _ref6, _ref7, _ref8, _ref9;
      expr = ['.'];
      while (true) {
        t = token;
        if (((_ref1 = token.type) === "N" || _ref1 === "S" || _ref1 === "X" || _ref1 === "J" ? token = tokens[i++] : void 0)) {
          item = [t.type, t.value];
        } else if (((_ref2 = token.type) === "(" ? token = tokens[i++] : void 0)) {
          if (((_ref3 = token.type) === ")" ? token = tokens[i++] : void 0)) {
            item = ['⍬'];
          } else {
            item = parseExpr();
            if (token.type === ')') {
              token = tokens[i++];
            } else {
              parserError("Expected token of type '" + ')' + "' but got '" + token.type + "'");
            }
          }
        } else if (((_ref4 = token.type) === "{" ? token = tokens[i++] : void 0)) {
          item = ['{', parseBody()];
          while (((_ref5 = token.type) === ";" ? token = tokens[i++] : void 0)) {
            item.push(parseBody());
          }
          if (token.type === '}') {
            token = tokens[i++];
          } else {
            parserError("Expected token of type '" + '}' + "' but got '" + token.type + "'");
          }
        } else {
          parserError("Encountered unexpected token of type '" + token.type + "'");
        }
        if (((_ref6 = token.type) === "[" ? token = tokens[i++] : void 0)) {
          item = ['[', item];
          while (true) {
            if (((_ref7 = token.type) === ";" ? token = tokens[i++] : void 0)) {
              item.push(null);
            } else if (token.type === ']') {
              item.push(null);
              break;
            } else {
              item.push(parseExpr());
              if (token.type === ']') {
                break;
              } else {
                if (token.type === ';') {
                  token = tokens[i++];
                } else {
                  parserError("Expected token of type '" + ';' + "' but got '" + token.type + "'");
                }
              }
            }
          }
          if (token.type === ']') {
            token = tokens[i++];
          } else {
            parserError("Expected token of type '" + ']' + "' but got '" + token.type + "'");
          }
        }
        if (((_ref8 = token.type) === "←" ? token = tokens[i++] : void 0)) {
          return expr.concat([['←', item, parseExpr()]]);
        }
        expr.push(item);
        if (_ref9 = token.type, __indexOf.call(')]}:;⋄L$', _ref9) >= 0) {
          return expr;
        }
      }
    };
    result = parseBody();
    if (token.type === '$') {
      token = tokens[i++];
    } else {
      parserError("Expected token of type '" + '$' + "' but got '" + token.type + "'");
    }
    return result;
  };

  vocabulary = {};

  addVocabulary = function(h) {
    var k, v;
    for (k in h) {
      v = h[k];
      vocabulary[k] = v;
    }
  };

  pervasive = function(_arg) {
    var dyad, monad, pervadeDyadic, pervadeMonadic;
    monad = _arg.monad, dyad = _arg.dyad;
    pervadeMonadic = monad ? function(x) {
      var r;
      if (x instanceof A) {
        return x.map(pervadeMonadic);
      } else {
        r = monad(x);
        if (typeof r === 'number' && isNaN(r)) {
          domainError('NaN');
        }
        return r;
      }
    } : nonceError;
    pervadeDyadic = dyad ? function(x, y) {
      var axis, r, tx, ty, xi, yi, _i, _ref1;
      tx = x instanceof A ? (x.isSingleton() ? 1 : 2) : 0;
      ty = y instanceof A ? (y.isSingleton() ? 1 : 2) : 0;
      switch (16 * tx + ty) {
        case 0x00:
          r = dyad(x, y);
          if (typeof r === 'number' && isNaN(r)) {
            domainError('NaN');
          }
          return r;
        case 0x01:
        case 0x02:
          return y.map(function(yi) {
            return pervadeDyadic(x, yi);
          });
        case 0x10:
        case 0x20:
          return x.map(function(xi) {
            return pervadeDyadic(xi, y);
          });
        case 0x12:
          xi = x.data[x.offset];
          return y.map(function(yi) {
            return pervadeDyadic(xi, yi);
          });
        case 0x21:
        case 0x11:
          yi = y.data[y.offset];
          return x.map(function(xi) {
            return pervadeDyadic(xi, yi);
          });
        case 0x22:
          if (x.shape.length !== y.shape.length) {
            rankError();
          }
          for (axis = _i = 0, _ref1 = x.shape.length; _i < _ref1; axis = _i += 1) {
            if (x.shape[axis] !== y.shape[axis]) {
              lengthError();
            }
          }
          return x.map2(y, pervadeDyadic);
        default:
          if (!(0)) {
            throw Error("\"else assert 0\" at src/vocabulary/vhelpers.coffee:40");
          }
      }
    } : nonceError;
    return function(omega, alpha) {
      if (!(omega instanceof A)) {
        throw Error("\"assert ⍵ instanceof A\" at src/vocabulary/vhelpers.coffee:44");
      }
      if (!(alpha instanceof A || (alpha == null))) {
        throw Error("\"assert ⍺ instanceof A or !⍺?\" at src/vocabulary/vhelpers.coffee:45");
      }
      return (alpha != null ? pervadeDyadic : pervadeMonadic)(omega, alpha);
    };
  };
  numeric = function(f, g) {
    return function(x, y, axis) {
      if (typeof x === 'number' && ((y == null) || typeof y === 'number')) {
        return f(x, y, axis);
      } else {
        x = complexify(x);
        if (y != null) {
          y = complexify(y);
        }
        return g(x, y, axis);
      }
    };
  };
  match = function(x, y) {
    var axis, r, t34, t35, t36, t37, t38, t39, t40, t41, t42, t43, t44, t45, t46, xi, yi, _i, _ref1;
    if (x instanceof A) {
      if (!(y instanceof A)) {
        return false;
      } else {
        if (x.shape.length !== y.shape.length) {
          return false;
        }
        for (axis = _i = 0, _ref1 = x.shape.length; _i < _ref1; axis = _i += 1) {
          if (x.shape[axis] !== y.shape[axis]) {
            return false;
          }
        }
        r = true;
        t34 = x;
        t39 = t34.data;
        t41 = t34.shape;
        t43 = t34.stride;
        t35 = y;
        t40 = t35.data;
        t42 = t35.shape;
        t44 = t35.stride;
        if (t41.length !== t42.length) {
          rankError();
        }
        t38 = t41.length;
        while (--t38 >= 0) {
          if (t41[t38] !== t42[t38]) {
            lengthError();
          }
        }
        if (!t34.empty()) {
          t45 = t41.length - 1;
          t36 = t34.offset;
          t37 = t35.offset;
          t46 = Array((t38 = t41.length));
          while (--t38 >= 0) {
            t46[t38] = 0;
          }
          while (true) {
            xi = t39[t36];
            yi = t40[t37];
            if (!match(xi, yi)) {
              r = false;
            }
            t38 = t45;
            while (t38 >= 0 && t46[t38] + 1 === t41[t38]) {
              t36 -= t46[t38] * t43[t38];
              t37 -= t46[t38] * t44[t38];
              t46[t38--] = 0;
            }
            if (t38 < 0) {
              break;
            }
            t46[t38]++;
            t36 += t43[t38];
            t37 += t44[t38];
          }
        }
        return r;
      }
    } else {
      if (y instanceof A) {
        return false;
      } else {
        if (x instanceof Z && y instanceof Z) {
          return x.re === y.re && x.im === y.im;
        } else {
          return x === y;
        }
      }
    }
  };
  numApprox = function(x, y) {
    return x === y || Math.abs(x - y) < 1e-11;
  };
  approx = function(x, y) {
    var axis, r, t47, t48, t49, t50, t51, t52, t53, t54, t55, t56, t57, t58, t59, xi, yi, _i, _ref1;
    if (x instanceof A) {
      if (!(y instanceof A)) {
        return false;
      } else {
        if (x.shape.length !== y.shape.length) {
          return false;
        }
        for (axis = _i = 0, _ref1 = x.shape.length; _i < _ref1; axis = _i += 1) {
          if (x.shape[axis] !== y.shape[axis]) {
            return false;
          }
        }
        r = true;
        t47 = x;
        t52 = t47.data;
        t54 = t47.shape;
        t56 = t47.stride;
        t48 = y;
        t53 = t48.data;
        t55 = t48.shape;
        t57 = t48.stride;
        if (t54.length !== t55.length) {
          rankError();
        }
        t51 = t54.length;
        while (--t51 >= 0) {
          if (t54[t51] !== t55[t51]) {
            lengthError();
          }
        }
        if (!t47.empty()) {
          t58 = t54.length - 1;
          t49 = t47.offset;
          t50 = t48.offset;
          t59 = Array((t51 = t54.length));
          while (--t51 >= 0) {
            t59[t51] = 0;
          }
          while (true) {
            xi = t52[t49];
            yi = t53[t50];
            if (!approx(xi, yi)) {
              r = false;
            }
            t51 = t58;
            while (t51 >= 0 && t59[t51] + 1 === t54[t51]) {
              t49 -= t59[t51] * t56[t51];
              t50 -= t59[t51] * t57[t51];
              t59[t51--] = 0;
            }
            if (t51 < 0) {
              break;
            }
            t59[t51]++;
            t49 += t56[t51];
            t50 += t57[t51];
          }
        }
        return r;
      }
    } else {
      if (y instanceof A) {
        return false;
      } else if (!((x != null) && (y != null))) {
        return false;
      } else {
        if (typeof x === 'number') {
          x = new Z(x);
        }
        if (typeof y === 'number') {
          y = new Z(y);
        }
        if (x instanceof Z) {
          return y instanceof Z && numApprox(x.re, y.re) && numApprox(x.im, y.im);
        } else {
          return x === y;
        }
      }
    }
  };
  bool = function(x) {
    if (x !== 0 && x !== 1) {
      return domainError();
    } else {
      return x;
    }
  };
  getAxisList = function(axes, rank) {
    var a, i, t60, t61, t62, x, _i, _len, _ref1, _ref2;
    if (!((t60 = (rank)) === ~~t60 && (0) <= t60)) {
      throw Error("\"assert isInt rank, 0\" at src/vocabulary/vhelpers.coffee:118");
    }
    if (axes == null) {
      return [];
    }
    if (!(axes instanceof A)) {
      throw Error("\"assert axes instanceof A\" at src/vocabulary/vhelpers.coffee:120");
    }
    if (axes.shape.length !== 1 || axes.shape[0] !== 1) {
      syntaxError();
    }
    a = axes.unwrap();
    if (a instanceof A) {
      a = a.toArray();
      for (i = _i = 0, _len = a.length; _i < _len; i = ++_i) {
        x = a[i];
        if (!((t61 = (x)) === ~~t61 && ((0) <= (_ref1 = t61) && _ref1 < (rank)))) {
          domainError();
        }
        if (__indexOf.call(a.slice(0, i), x) >= 0) {
          domainError('Non-unique axes');
        }
      }
      return a;
    } else if ((t62 = (a)) === ~~t62 && ((0) <= (_ref2 = t62) && _ref2 < (rank))) {
      return [a];
    } else {
      return domainError();
    }
  };
  withIdentity = function(x, f) {
    f.identity = x instanceof A ? x : A.scalar(x);
    return f;
  };
  adverb = function(f) {
    f.isAdverb = true;
    return f;
  };
  conjunction = function(f) {
    f.isConjunction = true;
    return f;
  };
  cps = function(f) {
    f.cps = true;
    return f;
  };
  addVocabulary({
    '+': withIdentity(0, pervasive({
      monad: numeric((function(x) {
        return x;
      }), Z.conjugate),
      dyad: numeric((function(y, x) {
        return x + y;
      }), function(y, x) {
        return Z.add(x, y);
      })
    })),
    '-': withIdentity(0, pervasive({
      monad: numeric((function(x) {
        return -x;
      }), Z.negate),
      dyad: numeric((function(y, x) {
        return x - y;
      }), function(y, x) {
        return Z.subtract(x, y);
      })
    })),
    '×': withIdentity(1, pervasive({
      monad: numeric((function(x) {
        return (x > 0) - (x < 0);
      }), function(x) {
        var d;
        d = Math.sqrt(x.re * x.re + x.im * x.im);
        return simplify(x.re / d, x.im / d);
      }),
      dyad: numeric((function(y, x) {
        return x * y;
      }), function(y, x) {
        return Z.multiply(x, y);
      })
    })),
    '÷': withIdentity(1, pervasive({
      monad: numeric((function(x) {
        return 1 / x;
      }), function(x) {
        var d;
        d = x.re * x.re + x.im * x.im;
        return simplify(x.re / d, -x.im / d);
      }),
      dyad: numeric((function(y, x) {
        return x / y;
      }), function(y, x) {
        return Z.divide(x, y);
      })
    })),
    '*': withIdentity(1, pervasive({
      monad: exp = numeric(Math.exp, Z.exp),
      dyad: function(y, x) {
        return Z.pow(x, y);
      }
    })),
    '⍟': pervasive({
      monad: Z.log,
      dyad: function(y, x) {
        var _ref1;
        if ((typeof x === (_ref1 = typeof y) && _ref1 === 'number') && x > 0 && y > 0) {
          return Math.log(y) / Math.log(x);
        } else {
          return Z.divide(Z.log(y), Z.log(x));
        }
      }
    }),
    '|': withIdentity(0, pervasive({
      monad: numeric((function(x) {
        return Math.abs(x);
      }), Z.magnitude),
      dyad: function(y, x) {
        return Z.residue(x, y);
      }
    }))
  });
  addVocabulary({
    '⍀': adverb(function(omega, alpha, axis) {
      if (axis == null) {
        axis = A.zero;
      }
      return scanOrExpand(omega, alpha, axis);
    }),
    '\\': scanOrExpand = adverb(function(omega, alpha, axis) {
      var a, b, data, f, filler, i, indices, p, shape, t63, x, _i, _len, _ref1;
      if (typeof omega === 'function') {
        if (!(typeof alpha === 'undefined')) {
          throw Error("\"assert typeof ⍺ is 'undefined'\" at src/vocabulary/backslash.coffee:30");
        }
        f = omega;
        return function(omega, alpha) {
          if (!(alpha == null)) {
            throw Error("\"assert !⍺?\" at src/vocabulary/backslash.coffee:33");
          }
          if (!omega.shape.length) {
            return omega;
          }
          axis = axis ? axis.toInt(0, omega.shape.length) : omega.shape.length - 1;
          return omega.map(function(x, indices) {
            var a, index, j, p, y, _i, _j, _len, _ref1;
            p = omega.offset;
            for (a = _i = 0, _len = indices.length; _i < _len; a = ++_i) {
              index = indices[a];
              p += index * omega.stride[a];
            }
            if (!(x instanceof A)) {
              x = A.scalar(x);
            }
            for (j = _j = 0, _ref1 = indices[axis]; _j < _ref1; j = _j += 1) {
              p -= omega.stride[axis];
              y = omega.data[p];
              if (!(y instanceof A)) {
                y = A.scalar(y);
              }
              x = f(x, y);
            }
            if (!x.shape.length) {
              x = x.unwrap();
            }
            return x;
          });
        };
      } else {
        if (!omega.shape.length) {
          nonceError('Expand of scalar not implemented');
        }
        axis = axis ? axis.toInt(0, omega.shape.length) : omega.shape.length - 1;
        if (alpha.shape.length > 1) {
          rankError();
        }
        a = alpha.toArray();
        shape = omega.shape.slice(0);
        shape[axis] = a.length;
        b = [];
        i = 0;
        for (_i = 0, _len = a.length; _i < _len; _i++) {
          x = a[_i];
          if (!((t63 = (x)) === ~~t63 && ((0) <= (_ref1 = t63) && _ref1 < (2)))) {
            domainError();
          }
          b.push(x > 0 ? i++ : null);
        }
        if (i !== omega.shape[axis]) {
          lengthError();
        }
        data = [];
        if (shape[axis] !== 0 && !omega.empty()) {
          filler = omega.getPrototype();
          p = omega.offset;
          indices = repeat([0], shape.length);
          while (true) {
            x = b[indices[axis]] != null ? omega.data[p + b[indices[axis]] * omega.stride[axis]] : filler;
            data.push(x);
            i = shape.length - 1;
            while (i >= 0 && indices[i] + 1 === shape[i]) {
              if (i !== axis) {
                p -= omega.stride[i] * indices[i];
              }
              indices[i--] = 0;
            }
            if (i < 0) {
              break;
            }
            if (i !== axis) {
              p += omega.stride[i];
            }
            indices[i]++;
          }
        }
        return new A(data, shape);
      }
    })
  });
  addVocabulary({
    '○': pervasive({
      monad: numeric((function(x) {
        return Math.PI * x;
      }), function(x) {
        return new Z(Math.PI * x.re, Math.PI * x.im);
      }),
      dyad: function(x, i) {
        var a, b, t;
        if (typeof x === 'number') {
          switch (i) {
            case -12:
              return Z.exp(simplify(0, x));
            case -11:
              return simplify(0, x);
            case -10:
              return x;
            case -9:
              return x;
            case -8:
              return simplify(0, -Math.sqrt(1 + x * x));
            case -7:
              return Z.atanh(x);
            case -6:
              return Z.acosh(x);
            case -5:
              return Z.asinh(x);
            case -4:
              t = Z.sqrt(x * x - 1);
              if (x < -1) {
                return -t;
              } else {
                return t;
              }
              break;
            case -3:
              return Z.atan(x);
            case -2:
              return Z.acos(x);
            case -1:
              return Z.asin(x);
            case 0:
              return Z.sqrt(1 - x * x);
            case 1:
              return Math.sin(x);
            case 2:
              return Math.cos(x);
            case 3:
              return Math.tan(x);
            case 4:
              return Math.sqrt(1 + x * x);
            case 5:
              a = Math.exp(x);
              b = 1 / a;
              return 0.5 * (a - b);
            case 6:
              a = Math.exp(x);
              b = 1 / a;
              return 0.5 * (a + b);
            case 7:
              a = Math.exp(x);
              b = 1 / a;
              return (a - b) / (a + b);
            case 8:
              return Z.sqrt(-1 - x * x);
            case 9:
              return x;
            case 10:
              return Math.abs(x);
            case 11:
              return 0;
            case 12:
              return 0;
            default:
              return domainError('Unknown circular or hyperbolic function ' + i);
          }
        } else if (x instanceof Z) {
          switch (i) {
            case -12:
              return Z.exp(simplify(-x.im, x.re));
            case -11:
              return Z.itimes(x);
            case -10:
              return Z.conjugate(x);
            case -9:
              return x;
            case -8:
              t = Z.subtract(-1, Z.multiply(x, x));
              return Z.negate(Z.sqrt(t));
            case -7:
              return Z.atanh(x);
            case -6:
              return Z.acosh(x);
            case -5:
              return Z.asinh(x);
            case -4:
              if (x.re === -1 && x.im === 0) {
                return 0;
              } else {
                a = Z.add(x, 1);
                b = Z.subtract(x, 1);
                return Z.multiply(a, Z.sqrt(Z.divide(b, a)));
              }
              break;
            case -3:
              return Z.atan(x);
            case -2:
              return Z.acos(x);
            case -1:
              return Z.asin(x);
            case 0:
              return Z.sqrt(Z.subtract(1, Z.multiply(x, x)));
            case 1:
              return Z.sin(x);
            case 2:
              return Z.cos(x);
            case 3:
              return Z.tan(x);
            case 4:
              return Z.sqrt(Z.add(1, Z.multiply(x, x)));
            case 5:
              return Z.sinh(x);
            case 6:
              return Z.cosh(x);
            case 7:
              return Z.tanh(x);
            case 8:
              return Z.sqrt(Z.subtract(-1, Z.multiply(x, x)));
            case 9:
              return x.re;
            case 10:
              return Z.magnitude(x);
            case 11:
              return x.im;
            case 12:
              return Z.direction(x);
            default:
              return domainError('Unknown circular or hyperbolic function ' + i);
          }
        } else {
          return domainError();
        }
      }
    })
  });
  addVocabulary({
    ',': function(omega, alpha, axis) {
      var a, data, i, nAxes, p, pIndices, q, r, rStride, s, shape, stride, t64, t65, t66, t67, t68, t69, t70, _i, _j, _ref1, _ref2, _ref3;
      if (alpha) {
        nAxes = Math.max(alpha.shape.length, omega.shape.length);
        if (axis) {
          axis = axis.unwrap();
          if (typeof axis !== 'number') {
            domainError();
          }
          if (nAxes && !((-1 < axis && axis < nAxes))) {
            rankError();
          }
        } else {
          axis = nAxes - 1;
        }
        if ((alpha.shape.length === (_ref1 = omega.shape.length) && _ref1 === 0)) {
          return new A([alpha.unwrap(), omega.unwrap()]);
        } else if (!alpha.shape.length) {
          s = omega.shape.slice(0);
          if ((t64 = (axis)) === ~~t64) {
            s[axis] = 1;
          }
          alpha = new A([alpha.unwrap()], s, repeat([0], omega.shape.length));
        } else if (!omega.shape.length) {
          s = alpha.shape.slice(0);
          if ((t65 = (axis)) === ~~t65) {
            s[axis] = 1;
          }
          omega = new A([omega.unwrap()], s, repeat([0], alpha.shape.length));
        } else if (alpha.shape.length + 1 === omega.shape.length) {
          if (!((t66 = (axis)) === ~~t66)) {
            rankError();
          }
          shape = alpha.shape.slice(0);
          shape.splice(axis, 0, 1);
          stride = alpha.stride.slice(0);
          stride.splice(axis, 0, 0);
          alpha = new A(alpha.data, shape, stride, alpha.offset);
        } else if (alpha.shape.length === omega.shape.length + 1) {
          if (!((t67 = (axis)) === ~~t67)) {
            rankError();
          }
          shape = omega.shape.slice(0);
          shape.splice(axis, 0, 1);
          stride = omega.stride.slice(0);
          stride.splice(axis, 0, 0);
          omega = new A(omega.data, shape, stride, omega.offset);
        } else if (alpha.shape.length !== omega.shape.length) {
          rankError();
        }
        if (!(alpha.shape.length === omega.shape.length)) {
          throw Error("\"assert ⍴⍴(⍺) is ⍴⍴(⍵)\" at src/vocabulary/comma.coffee:56");
        }
        for (i = _i = 0, _ref2 = alpha.shape.length; _i < _ref2; i = _i += 1) {
          if (i !== axis && alpha.shape[i] !== omega.shape[i]) {
            lengthError();
          }
        }
        shape = alpha.shape.slice(0);
        if ((t68 = (axis)) === ~~t68) {
          shape[axis] += omega.shape[axis];
        } else {
          shape.splice(Math.ceil(axis), 0, 2);
        }
        data = Array(prod(shape));
        stride = Array(shape.length);
        stride[shape.length - 1] = 1;
        for (i = _j = _ref3 = shape.length - 2; _j >= 0; i = _j += -1) {
          stride[i] = stride[i + 1] * shape[i + 1];
        }
        if ((t69 = (axis)) === ~~t69) {
          rStride = stride;
        } else {
          rStride = stride.slice(0);
          rStride.splice(Math.ceil(axis), 1);
        }
        if (!alpha.empty()) {
          r = 0;
          p = alpha.offset;
          pIndices = repeat([0], alpha.shape.length);
          while (true) {
            data[r] = alpha.data[p];
            a = pIndices.length - 1;
            while (a >= 0 && pIndices[a] + 1 === alpha.shape[a]) {
              p -= pIndices[a] * alpha.stride[a];
              r -= pIndices[a] * rStride[a];
              pIndices[a--] = 0;
            }
            if (a < 0) {
              break;
            }
            p += alpha.stride[a];
            r += rStride[a];
            pIndices[a]++;
          }
        }
        if (!omega.empty()) {
          r = (t70 = (axis)) === ~~t70 ? stride[axis] * alpha.shape[axis] : stride[Math.ceil(axis)];
          q = omega.offset;
          pIndices = repeat([0], omega.shape.length);
          while (true) {
            data[r] = omega.data[q];
            a = pIndices.length - 1;
            while (a >= 0 && pIndices[a] + 1 === omega.shape[a]) {
              q -= pIndices[a] * omega.stride[a];
              r -= pIndices[a] * rStride[a];
              pIndices[a--] = 0;
            }
            if (a < 0) {
              break;
            }
            q += omega.stride[a];
            r += rStride[a];
            pIndices[a]++;
          }
        }
        return new A(data, shape, stride);
      } else {
        if (!(0)) {
          throw Error("\"assert 0\" at src/vocabulary/comma.coffee:117");
        }
      }
    }
  });
  addVocabulary({
    '=': withIdentity(1, pervasive({
      dyad: eq = function(y, x) {
        if (x instanceof Z && y instanceof Z) {
          return +(x.re === y.re && x.im === y.im);
        } else {
          return +(x === y);
        }
      }
    })),
    '≠': withIdentity(0, pervasive({
      dyad: function(y, x) {
        return 1 - eq(y, x);
      }
    })),
    '<': withIdentity(0, pervasive({
      dyad: function(y, x, t71) {
        if (typeof y === 'number' && ((x == null) || typeof x === 'number')) {
          return +(x < y);
        } else {
          return domainError();
        }
      }
    })),
    '>': withIdentity(0, pervasive({
      dyad: function(y, x, t72) {
        if (typeof y === 'number' && ((x == null) || typeof x === 'number')) {
          return +(x > y);
        } else {
          return domainError();
        }
      }
    })),
    '≤': withIdentity(1, pervasive({
      dyad: function(y, x, t73) {
        if (typeof y === 'number' && ((x == null) || typeof x === 'number')) {
          return +(x <= y);
        } else {
          return domainError();
        }
      }
    })),
    '≥': withIdentity(1, pervasive({
      dyad: function(y, x, t74) {
        if (typeof y === 'number' && ((x == null) || typeof x === 'number')) {
          return +(x >= y);
        } else {
          return domainError();
        }
      }
    })),
    '≡': function(omega, alpha) {
      if (alpha) {
        return A.bool[+match(omega, alpha)];
      } else {
        return new A([depthOf(omega)], []);
      }
    }
  });
  depthOf = function(x) {
    var r, t75, t76, t77, t78, t79, t80, t81, t82, y;
    if (x instanceof A) {
      if ((!x.shape.length) && (!(x.data[0] instanceof A))) {
        return 0;
      }
      r = 0;
      t75 = x;
      if (!t75.empty()) {
        t77 = t75.data;
        t78 = t75.shape;
        t79 = t75.stride;
        t80 = t78.length - 1;
        t82 = t75.offset;
        t81 = [];
        t76 = t78.length;
        while (--t76 >= 0) {
          t81.push(0);
        }
        while (true) {
          y = t77[t82];
          r = Math.max(r, depthOf(y));
          t76 = t80;
          while (t76 >= 0 && t81[t76] + 1 === t78[t76]) {
            t82 -= t81[t76] * t79[t76];
            t81[t76--] = 0;
          }
          if (t76 < 0) {
            break;
          }
          t81[t76]++;
          t82 += t79[t76];
        }
      }
      return r + 1;
    } else {
      return 0;
    }
  };
  addVocabulary({
    '∘': conjunction(function(g, f) {
      if (typeof f === 'function') {
        if (typeof g === 'function') {
          return function(omega, alpha) {
            return f(g(omega), alpha);
          };
        } else {
          return function(omega, alpha) {
            if (!(alpha == null)) {
              throw Error("\"assert !⍺?\" at src/vocabulary/compose.coffee:18");
            }
            return f(g, omega);
          };
        }
      } else {
        if (!(typeof g === 'function')) {
          throw Error("\"assert typeof g is 'function'\" at src/vocabulary/compose.coffee:21");
        }
        return function(omega, alpha) {
          if (!(alpha == null)) {
            throw Error("\"assert !⍺?\" at src/vocabulary/compose.coffee:23");
          }
          return g(omega, f);
        };
      }
    })
  });
  addVocabulary({
    '∪': function(omega, alpha) {
      var a, data, t83, t84, t85, t86, t87, t88, t89, t90, t91, t92, t93, t94, t95, t96, t97, t98, x, _i, _len, _ref1;
      if (alpha) {
        data = [];
        _ref1 = [alpha, omega];
        for (_i = 0, _len = _ref1.length; _i < _len; _i++) {
          a = _ref1[_i];
          if (a.shape.length > 1) {
            rankError();
          }
          t83 = a;
          if (!t83.empty()) {
            t85 = t83.data;
            t86 = t83.shape;
            t87 = t83.stride;
            t88 = t86.length - 1;
            t90 = t83.offset;
            t89 = [];
            t84 = t86.length;
            while (--t84 >= 0) {
              t89.push(0);
            }
            while (true) {
              x = t85[t90];
              if (!contains(data, x)) {
                data.push(x);
              }
              t84 = t88;
              while (t84 >= 0 && t89[t84] + 1 === t86[t84]) {
                t90 -= t89[t84] * t87[t84];
                t89[t84--] = 0;
              }
              if (t84 < 0) {
                break;
              }
              t89[t84]++;
              t90 += t87[t84];
            }
          }
        }
        return new A(data);
      } else {
        data = [];
        t91 = omega;
        if (!t91.empty()) {
          t93 = t91.data;
          t94 = t91.shape;
          t95 = t91.stride;
          t96 = t94.length - 1;
          t98 = t91.offset;
          t97 = [];
          t92 = t94.length;
          while (--t92 >= 0) {
            t97.push(0);
          }
          while (true) {
            x = t93[t98];
            if (!contains(data, x)) {
              data.push(x);
            }
            t92 = t96;
            while (t92 >= 0 && t97[t92] + 1 === t94[t92]) {
              t98 -= t97[t92] * t95[t92];
              t97[t92--] = 0;
            }
            if (t92 < 0) {
              break;
            }
            t97[t92]++;
            t98 += t95[t92];
          }
        }
        return new A(data);
      }
    },
    '∩': function(omega, alpha) {
      var b, data, x, _i, _len, _ref1;
      if (alpha) {
        data = [];
        b = omega.toArray();
        _ref1 = alpha.toArray();
        for (_i = 0, _len = _ref1.length; _i < _len; _i++) {
          x = _ref1[_i];
          if (contains(b, x)) {
            data.push(x);
          }
        }
        return new A(data);
      } else {
        return nonceError();
      }
    }
  });
  contains = function(a, x) {
    var y, _i, _len;
    if (!(a.length != null)) {
      throw Error("\"assert a.length?\" at src/vocabulary/cupcap.coffee:43");
    }
    for (_i = 0, _len = a.length; _i < _len; _i++) {
      y = a[_i];
      if (match(x, y)) {
        return true;
      }
    }
    return false;
  };
  addVocabulary({
    '⊥': function(omega, alpha) {
      var a, b, data, firstDimB, i, j, k, lastDimA, x, y, z, _i, _j, _k, _ref1, _ref2, _ref3;
      if (!alpha) {
        throw Error("\"assert ⍺\" at src/vocabulary/decode.coffee:41");
      }
      if (!alpha.shape.length) {
        alpha = new A([alpha.unwrap()]);
      }
      if (!omega.shape.length) {
        omega = new A([omega.unwrap()]);
      }
      lastDimA = alpha.shape[alpha.shape.length - 1];
      firstDimB = omega.shape[0];
      if (lastDimA !== 1 && firstDimB !== 1 && lastDimA !== firstDimB) {
        lengthError();
      }
      a = alpha.toArray();
      b = omega.toArray();
      data = [];
      for (i = _i = 0, _ref1 = a.length / lastDimA; _i < _ref1; i = _i += 1) {
        for (j = _j = 0, _ref2 = b.length / firstDimB; _j < _ref2; j = _j += 1) {
          x = a.slice(i * lastDimA, (i + 1) * lastDimA);
          y = (function() {
            var _k, _results;
            _results = [];
            for (k = _k = 0; _k < firstDimB; k = _k += 1) {
              _results.push(b[j + k * (b.length / firstDimB)]);
            }
            return _results;
          })();
          if (x.length === 1) {
            x = (function() {
              var _k, _ref3, _results;
              _results = [];
              for (_k = 0, _ref3 = y.length; 0 <= _ref3 ? _k < _ref3 : _k > _ref3; 0 <= _ref3 ? _k++ : _k--) {
                _results.push(x[0]);
              }
              return _results;
            })();
          }
          if (y.length === 1) {
            y = (function() {
              var _k, _ref3, _results;
              _results = [];
              for (_k = 0, _ref3 = x.length; 0 <= _ref3 ? _k < _ref3 : _k > _ref3; 0 <= _ref3 ? _k++ : _k--) {
                _results.push(y[0]);
              }
              return _results;
            })();
          }
          z = y[0];
          for (k = _k = 1, _ref3 = y.length; _k < _ref3; k = _k += 1) {
            z = z * x[k] + y[k];
          }
          data.push(z);
        }
      }
      return new A(data, alpha.shape.slice(0, -1).concat(omega.shape.slice(1)));
    }
  });
  addVocabulary({
    '.': conjunction(function(g, f) {
      if (f === vocabulary['∘']) {
        return outerProduct(g);
      } else {
        return innerProduct(g, f);
      }
    })
  });
  outerProduct = function(f) {
    if (!(typeof f === 'function')) {
      throw Error("\"assert typeof f is 'function'\" at src/vocabulary/dot.coffee:29");
    }
    return function(omega, alpha) {
      var a, b, data, x, y, z, _i, _j, _len, _len1;
      if (!alpha) {
        syntaxError('Adverb ∘. (Outer product) can be applied to dyadic verbs only');
      }
      a = alpha.toArray();
      b = omega.toArray();
      data = [];
      for (_i = 0, _len = a.length; _i < _len; _i++) {
        x = a[_i];
        for (_j = 0, _len1 = b.length; _j < _len1; _j++) {
          y = b[_j];
          if (!(x instanceof A)) {
            x = A.scalar(x);
          }
          if (!(y instanceof A)) {
            y = A.scalar(y);
          }
          z = f(y, x);
          if (!z.shape.length) {
            z = z.unwrap();
          }
          data.push(z);
        }
      }
      return new A(data, alpha.shape.concat(omega.shape));
    };
  };
  innerProduct = function(g, f) {
    var F, G;
    F = vocabulary['¨'](reduce(f));
    G = outerProduct(g);
    return function(omega, alpha) {
      if (!alpha.shape.length) {
        alpha = new A([alpha.unwrap()]);
      }
      if (!omega.shape.length) {
        omega = new A([omega.unwrap()]);
      }
      return F(G(vocabulary['⊂'](omega, void 0, new A([0])), vocabulary['⊂'](alpha, void 0, new A([alpha.shape.length - 1]))));
    };
  };
  addVocabulary({
    '¨': adverb(function(f, g) {
      if (!(typeof f === 'function')) {
        throw Error("\"assert typeof f is 'function'\" at src/vocabulary/each.coffee:15");
      }
      if (!(typeof g === 'undefined')) {
        throw Error("\"assert typeof g is 'undefined'\" at src/vocabulary/each.coffee:16");
      }
      return function(omega, alpha) {
        var x, y;
        if (!alpha) {
          return omega.map(function(x) {
            var r;
            if (!(x instanceof A)) {
              x = new A([x], []);
            }
            r = f(x);
            if (!(r instanceof A)) {
              throw Error("\"assert r instanceof A\" at src/vocabulary/each.coffee:22");
            }
            if (r.shape.length) {
              return r;
            } else {
              return r.unwrap();
            }
          });
        } else if (arrayEquals(alpha.shape, omega.shape)) {
          return omega.map2(alpha, function(x, y) {
            var r;
            if (!(x instanceof A)) {
              x = new A([x], []);
            }
            if (!(y instanceof A)) {
              y = new A([y], []);
            }
            r = f(x, y);
            if (!(r instanceof A)) {
              throw Error("\"assert r instanceof A\" at src/vocabulary/each.coffee:29");
            }
            if (r.shape.length) {
              return r;
            } else {
              return r.unwrap();
            }
          });
        } else if (alpha.isSingleton()) {
          y = alpha.data[0] instanceof A ? alpha.unwrap() : alpha;
          return omega.map(function(x) {
            var r;
            if (!(x instanceof A)) {
              x = new A([x], []);
            }
            r = f(x, y);
            if (!(r instanceof A)) {
              throw Error("\"assert r instanceof A\" at src/vocabulary/each.coffee:36");
            }
            if (r.shape.length) {
              return r;
            } else {
              return r.unwrap();
            }
          });
        } else if (omega.isSingleton()) {
          x = omega.data[0] instanceof A ? omega.unwrap() : omega;
          return alpha.map(function(y) {
            var r;
            if (!(y instanceof A)) {
              y = new A([y], []);
            }
            r = f(x, y);
            if (!(r instanceof A)) {
              throw Error("\"assert r instanceof A\" at src/vocabulary/each.coffee:43");
            }
            if (r.shape.length) {
              return r;
            } else {
              return r.unwrap();
            }
          });
        } else {
          return lengthError();
        }
      };
    })
  });
  addVocabulary({
    '⊤': function(omega, alpha) {
      var a, b, data, i, isNeg, j, k, m, n, shape, x, y, _i, _j, _k, _len, _ref1;
      if (!alpha) {
        throw Error("\"assert ⍺\" at src/vocabulary/encode.coffee:35");
      }
      a = alpha.toArray();
      b = omega.toArray();
      shape = alpha.shape.concat(omega.shape);
      data = Array(prod(shape));
      n = alpha.shape.length ? alpha.shape[0] : 1;
      m = a.length / n;
      for (i = _i = 0; _i < m; i = _i += 1) {
        for (j = _j = 0, _len = b.length; _j < _len; j = ++_j) {
          y = b[j];
          if (isNeg = y < 0) {
            y = -y;
          }
          for (k = _k = _ref1 = n - 1; _k >= 0; k = _k += -1) {
            x = a[k * m + i];
            if (x === 0) {
              data[(k * m + i) * b.length + j] = y;
              y = 0;
            } else {
              data[(k * m + i) * b.length + j] = y % x;
              y = Math.round((y - (y % x)) / x);
            }
          }
        }
      }
      return new A(data, shape);
    }
  });
  addVocabulary({
    '∊': function(omega, alpha) {
      var a, data;
      if (alpha) {
        a = omega.toArray();
        return alpha.map(function(x) {
          var y, _i, _len;
          for (_i = 0, _len = a.length; _i < _len; _i++) {
            y = a[_i];
            if (match(x, y)) {
              return 1;
            }
          }
          return 0;
        });
      } else {
        data = [];
        enlist(omega, data);
        return new A(data);
      }
    }
  });
  enlist = function(x, r) {
    var t100, t101, t102, t103, t104, t105, t106, t99, y, _results;
    if (x instanceof A) {
      t99 = x;
      if (!t99.empty()) {
        t101 = t99.data;
        t102 = t99.shape;
        t103 = t99.stride;
        t104 = t102.length - 1;
        t106 = t99.offset;
        t105 = [];
        t100 = t102.length;
        while (--t100 >= 0) {
          t105.push(0);
        }
        _results = [];
        while (true) {
          y = t101[t106];
          enlist(y, r);
          t100 = t104;
          while (t100 >= 0 && t105[t100] + 1 === t102[t100]) {
            t106 -= t105[t100] * t103[t100];
            t105[t100--] = 0;
          }
          if (t100 < 0) {
            break;
          }
          t105[t100]++;
          _results.push(t106 += t103[t100]);
        }
        return _results;
      }
    } else {
      return r.push(x);
    }
  };
  addVocabulary({
    '!': withIdentity(1, pervasive({
      monad: function(x, t108, t109) {
        var t107;
        if (typeof x === 'number' && ((t108 == null) || typeof t108 === 'number')) {
          if (!((t107 = (x)) === ~~t107)) {
            return Γ(x + 1);
          } else if (x < 0) {
            return domainError();
          } else if (x < smallFactorials.length) {
            return smallFactorials[x];
          } else {
            return Math.round(Γ(x + 1));
          }
        } else {
          return domainError();
        }
      },
      dyad: Beta = function(n, k, t112) {
        var r, t110, t111;
        if (typeof n === 'number' && ((k == null) || typeof k === 'number')) {
          r = (function() {
            switch (4 * negInt(k) + 2 * negInt(n) + negInt(n - k)) {
              case 0x0:
                return Math.exp(lnΓ(n + 1) - lnΓ(k + 1) - lnΓ(n - k + 1));
              case 0x1:
                return 0;
              case 0x2:
                return domainError();
              case 0x3:
                return Math.pow(-1, k) * Beta(k - n - 1, k);
              case 0x4:
                return 0;
              case 0x5:
                break;
              case 0x6:
                return Math.pow(-1, n - k) * Beta(Math.abs(k + 1), Math.abs(n + 1));
              case 0x7:
                return 0;
            }
          })();
          if (((t110 = (n)) === ~~t110) && ((t111 = (k)) === ~~t111)) {
            return Math.round(r);
          } else {
            return r;
          }
        } else {
          return domainError();
        }
      }
    }))
  });
  negInt = function(x) {
    var t113;
    return ((t113 = (x)) === ~~t113) && x < 0;
  };
  smallFactorials = (function() {
    var i, x;
    return [x = 1].concat((function() {
      var _i, _results;
      _results = [];
      for (i = _i = 1; _i <= 25; i = ++_i) {
        _results.push(x *= i);
      }
      return _results;
    })());
  })();
  _ref1 = (function() {
    var g, g_ln, p, p_ln;
    g = 7;
    p = [0.99999999999980993, 676.5203681218851, -1259.1392167224028, 771.32342877765313, -176.61502916214059, 12.507343278686905, -0.13857109526572012, 9.9843695780195716e-6, 1.5056327351493116e-7];
    g_ln = 607 / 128;
    p_ln = [0.99999999999999709182, 57.156235665862923517, -59.597960355475491248, 14.136097974741747174, -0.49191381609762019978, 0.33994649984811888699e-4, 0.46523628927048575665e-4, -0.98374475304879564677e-4, 0.15808870322491248884e-3, -0.21026444172410488319e-3, 0.21743961811521264320e-3, -0.16431810653676389022e-3, 0.84418223983852743293e-4, -0.26190838401581408670e-4, 0.36899182659531622704e-5];
    return {
      lnΓ: function(z) {
        var i, t, x, _i, _ref1;
        if (z < 0) {
          return NaN;
        }
        x = p_ln[0];
        for (i = _i = _ref1 = p_ln.length - 1; _i > 0; i = _i += -1) {
          x += p_ln[i] / (z + i);
        }
        t = z + g_ln + .5;
        return .5 * Math.log(2 * Math.PI) + (z + .5) * Math.log(t) - t + Math.log(x) - Math.log(z);
      },
      Γ: function(z) {
        var i, t, x, _i, _ref1;
        if (z < 0.5) {
          return Math.PI / (Math.sin(Math.PI * z) * Γ(1 - z));
        } else if (z > 100) {
          return Math.exp(lnΓ(z));
        } else {
          z--;
          x = p[0];
          for (i = _i = 1, _ref1 = g + 2; _i < _ref1; i = _i += 1) {
            x += p[i] / (z + i);
          }
          t = z + g + .5;
          return Math.sqrt(2 * Math.PI) * Math.pow(t, z + 0.5) * Math.exp(-t) * x;
        }
      }
    };
  })(), Γ = _ref1.Γ, lnΓ = _ref1.lnΓ;
  addVocabulary({
    '⍎': function(omega, alpha) {
      if (alpha) {
        return nonceError();
      } else {
        return exec(omega.toSimpleString());
      }
    }
  });
  addVocabulary({
    '⍷': function(omega, alpha) {
      var a, d, data, findShape, i, indices, p, q, stride, _i, _ref2;
      if (alpha) {
        if (alpha.shape.length > omega.shape.length) {
          return new A([0], omega.shape, repeat([0], omega.shape.length));
        }
        if (alpha.shape.length < omega.shape.length) {
          alpha = new A(alpha.data, repeat([1], omega.shape.length - alpha.shape.length).concat(alpha.shape), repeat([0], omega.shape.length - alpha.shape.length).concat(alpha.stride), alpha.offset);
        }
        if (prod(alpha.shape) === 0) {
          return new A([1], omega.shape, repeat([0], omega.shape.length));
        }
        findShape = [];
        for (i = _i = 0, _ref2 = omega.shape.length; _i < _ref2; i = _i += 1) {
          d = omega.shape[i] - alpha.shape[i] + 1;
          if (d <= 0) {
            return new A([0], omega.shape, repeat([0], omega.shape.length));
          }
          findShape.push(d);
        }
        stride = strideForShape(omega.shape);
        data = repeat([0], prod(omega.shape));
        p = omega.offset;
        q = 0;
        indices = repeat([0], findShape.length);
        while (true) {
          data[q] = +match(alpha, new A(omega.data, alpha.shape, omega.stride, p));
          a = findShape.length - 1;
          while (a >= 0 && indices[a] + 1 === findShape[a]) {
            p -= indices[a] * omega.stride[a];
            q -= indices[a] * stride[a];
            indices[a--] = 0;
          }
          if (a < 0) {
            break;
          }
          p += omega.stride[a];
          q += stride[a];
          indices[a]++;
        }
        return new A(data, omega.shape);
      } else {
        return nonceError();
      }
    }
  });
  addVocabulary({
    '⌊': withIdentity(Infinity, pervasive({
      monad: Z.floor,
      dyad: function(y, x, t114) {
        if (typeof y === 'number' && ((x == null) || typeof x === 'number')) {
          return Math.min(y, x);
        } else {
          return domainError();
        }
      }
    })),
    '⌈': withIdentity(-Infinity, pervasive({
      monad: Z.ceil,
      dyad: function(y, x, t115) {
        if (typeof y === 'number' && ((x == null) || typeof x === 'number')) {
          return Math.max(y, x);
        } else {
          return domainError();
        }
      }
    }))
  });
  addVocabulary({
    _fork1: function(h, g) {
      if (!(typeof h === 'function')) {
        throw Error("\"assert typeof h is 'function'\" at src/vocabulary/fork.coffee:14");
      }
      if (!(typeof g === 'function')) {
        throw Error("\"assert typeof g is 'function'\" at src/vocabulary/fork.coffee:15");
      }
      return [h, g];
    },
    _fork2: function(_arg, f) {
      var g, h;
      h = _arg[0], g = _arg[1];
      if (!(typeof h === 'function')) {
        throw Error("\"assert typeof h is 'function'\" at src/vocabulary/fork.coffee:19");
      }
      return function(b, a) {
        return g(h(b, a), f(b, a));
      };
    }
  });
  addVocabulary({
    '⍕': function(omega, alpha) {
      var t;
      if (alpha) {
        return nonceError();
      } else {
        t = format(omega);
        return new A(t.join(''), [t.length, t[0].length]);
      }
    }
  });
  format = function(a) {
    var bottom, box, c, cols, d, grid, i, j, k, left, nCols, nRows, r, result, right, rows, sa, step, t, x, _i, _j, _k, _l, _len, _len1, _len2, _m, _n, _o, _p, _ref2, _ref3, _ref4, _ref5, _ref6, _ref7, _ref8, _ref9;
    if (typeof a === 'undefined') {
      return ['undefined'];
    } else if (a === null) {
      return ['null'];
    } else if (typeof a === 'string') {
      return [a];
    } else if (typeof a === 'number') {
      r = [('' + a).replace('Infinity', '∞').replace(/-/g, '¯')];
      r.align = 'right';
      return r;
    } else if (typeof a === 'function') {
      return ['#procedure'];
    } else if (!(a instanceof A)) {
      return ['' + a];
    } else if (prod(a.shape) === 0) {
      return [''];
    } else {
      sa = a.shape;
      a = a.toArray();
      if (!sa.length) {
        return format(a[0]);
      }
      nRows = prod(sa.slice(0, sa.length - 1));
      nCols = sa[sa.length - 1];
      rows = (function() {
        var _i, _results;
        _results = [];
        for (_i = 0; 0 <= nRows ? _i < nRows : _i > nRows; 0 <= nRows ? _i++ : _i--) {
          _results.push({
            height: 0,
            bottomMargin: 0
          });
        }
        return _results;
      })();
      cols = (function() {
        var _i, _results;
        _results = [];
        for (_i = 0; 0 <= nCols ? _i < nCols : _i > nCols; 0 <= nCols ? _i++ : _i--) {
          _results.push({
            type: 0,
            width: 0,
            leftMargin: 0,
            rightMargin: 0
          });
        }
        return _results;
      })();
      grid = (function() {
        var _i, _len, _results;
        _results = [];
        for (i = _i = 0, _len = rows.length; _i < _len; i = ++_i) {
          r = rows[i];
          _results.push((function() {
            var _j, _len1, _results1;
            _results1 = [];
            for (j = _j = 0, _len1 = cols.length; _j < _len1; j = ++_j) {
              c = cols[j];
              x = a[nCols * i + j];
              box = format(x);
              r.height = Math.max(r.height, box.length);
              c.width = Math.max(c.width, box[0].length);
              c.type = Math.max(c.type, typeof x === 'string' && x.length === 1 ? 0 : !(x instanceof A) ? 1 : 2);
              _results1.push(box);
            }
            return _results1;
          })());
        }
        return _results;
      })();
      step = 1;
      for (d = _i = _ref2 = sa.length - 2; _i >= 1; d = _i += -1) {
        step *= sa[d];
        for (i = _j = _ref3 = step - 1, _ref4 = nRows - 1; step > 0 ? _j < _ref4 : _j > _ref4; i = _j += step) {
          rows[i].bottomMargin++;
        }
      }
      for (j = _k = 0, _len = cols.length; _k < _len; j = ++_k) {
        c = cols[j];
        if (j !== nCols - 1 && !((c.type === (_ref5 = cols[j + 1].type) && _ref5 === 0))) {
          c.rightMargin++;
        }
        if (c.type === 2) {
          c.leftMargin++;
          c.rightMargin++;
        }
      }
      result = [];
      for (i = _l = 0, _len1 = rows.length; _l < _len1; i = ++_l) {
        r = rows[i];
        for (j = _m = 0, _len2 = cols.length; _m < _len2; j = ++_m) {
          c = cols[j];
          t = grid[i][j];
          if (t.align === 'right') {
            left = repeat(' ', c.leftMargin + c.width - t[0].length);
            right = repeat(' ', c.rightMargin);
          } else {
            left = repeat(' ', c.leftMargin);
            right = repeat(' ', c.rightMargin + c.width - t[0].length);
          }
          for (k = _n = 0, _ref6 = t.length; _n < _ref6; k = _n += 1) {
            t[k] = left + t[k] + right;
          }
          bottom = repeat(' ', t[0].length);
          for (_o = _ref7 = t.length, _ref8 = r.height + r.bottomMargin; _ref7 <= _ref8 ? _o < _ref8 : _o > _ref8; _ref7 <= _ref8 ? _o++ : _o--) {
            t.push(bottom);
          }
        }
        for (k = _p = 0, _ref9 = r.height + r.bottomMargin; _p < _ref9; k = _p += 1) {
          result.push(((function() {
            var _q, _results;
            _results = [];
            for (j = _q = 0; _q < nCols; j = _q += 1) {
              _results.push(grid[i][j][k]);
            }
            return _results;
          })()).join(''));
        }
      }
      return result;
    }
  };
  addVocabulary({
    '⍋': function(omega, alpha) {
      return grade(omega, alpha, 1);
    },
    '⍒': function(omega, alpha) {
      return grade(omega, alpha, -1);
    }
  });
  grade = function(omega, alpha, direction) {
    var h, indices, t116, t117, t118, t119, t120, t121, t122, x, _i, _ref2, _results;
    h = {};
    if (alpha) {
      if (!alpha.shape.length) {
        rankError();
      }
      h = {};
      t116 = alpha;
      if (!t116.empty()) {
        t118 = t116.data;
        t119 = t116.shape;
        t120 = t116.stride;
        t121 = t119.length - 1;
        t122 = t116.offset;
        indices = [];
        t117 = t119.length;
        while (--t117 >= 0) {
          indices.push(0);
        }
        while (true) {
          x = t118[t122];
          if (typeof x !== 'string') {
            domainError();
          }
          h[x] = indices[indices.length - 1];
          t117 = t121;
          while (t117 >= 0 && indices[t117] + 1 === t119[t117]) {
            t122 -= indices[t117] * t120[t117];
            indices[t117--] = 0;
          }
          if (t117 < 0) {
            break;
          }
          indices[t117]++;
          t122 += t120[t117];
        }
      }
    }
    if (!omega.shape.length) {
      rankError();
    }
    return new A((function() {
      _results = [];
      for (var _i = 0, _ref2 = omega.shape[0]; 0 <= _ref2 ? _i < _ref2 : _i > _ref2; 0 <= _ref2 ? _i++ : _i--){ _results.push(_i); }
      return _results;
    }).apply(this).sort(function(i, j) {
      var a, p, tx, ty, y;
      p = omega.offset;
      indices = repeat([0], omega.shape.length);
      while (true) {
        x = omega.data[p + i * omega.stride[0]];
        y = omega.data[p + j * omega.stride[0]];
        tx = typeof x;
        ty = typeof y;
        if (tx < ty) {
          return -direction;
        }
        if (tx > ty) {
          return direction;
        }
        if (h[x] != null) {
          x = h[x];
        }
        if (h[y] != null) {
          y = h[y];
        }
        if (x < y) {
          return -direction;
        }
        if (x > y) {
          return direction;
        }
        a = indices.length - 1;
        while (a > 0 && indices[a] + 1 === omega.shape[a]) {
          p -= omega.stride[a] * indices[a];
          indices[a--] = 0;
        }
        if (a <= 0) {
          break;
        }
        p += omega.stride[a];
        indices[a]++;
      }
      return (i > j) - (i < j);
    }));
  };
  addVocabulary({
    '⍁': conjunction(function(f, x) {
      var _ref2;
      if (f instanceof A) {
        _ref2 = [x, f], f = _ref2[0], x = _ref2[1];
      }
      if (!(typeof f === 'function')) {
        throw Error("\"assert typeof f is 'function'\" at src/vocabulary/identity.coffee:10");
      }
      if (!(x instanceof A)) {
        throw Error("\"assert x instanceof A\" at src/vocabulary/identity.coffee:11");
      }
      if (!x.isSingleton()) {
        rankError();
      }
      if (x.shape.length) {
        x = A.scalar(x.unwrap());
      }
      return withIdentity(x, function(omega, alpha, axis) {
        return f(omega, alpha, axis);
      });
    })
  });
  addVocabulary({
    '⍳': function(omega, alpha) {
      var a, ctor, d, data, i, itemData, itemShape, itemStride, j, m, n, p, t130, t131, t132, t133, t134, t135, t136, t137, t138, u, _i, _j, _k, _l, _len, _m, _n, _o, _ref2, _ref3, _ref4, _ref5, _ref6, _ref7;
      if (alpha) {
        if (alpha.shape.length !== 1) {
          rankError();
        }
        return omega.map(function(x) {
          var e, indices, rank, t123, t124, t125, t126, t127, t128, t129, y;
          try {
            rank = alpha.shape;
            t123 = alpha;
            if (!t123.empty()) {
              t125 = t123.data;
              t126 = t123.shape;
              t127 = t123.stride;
              t128 = t126.length - 1;
              t129 = t123.offset;
              indices = [];
              t124 = t126.length;
              while (--t124 >= 0) {
                indices.push(0);
              }
              while (true) {
                y = t125[t129];
                if (match(x, y)) {
                  rank = indices;
                  throw 'break';
                }
                t124 = t128;
                while (t124 >= 0 && indices[t124] + 1 === t126[t124]) {
                  t129 -= indices[t124] * t127[t124];
                  indices[t124--] = 0;
                }
                if (t124 < 0) {
                  break;
                }
                indices[t124]++;
                t129 += t127[t124];
              }
            }
          } catch (_error) {
            e = _error;
            if (e !== 'break') {
              throw e;
            }
          }
          if (rank.length === 1) {
            return rank[0];
          } else {
            return new A(rank);
          }
        });
      } else {
        if (omega.shape.length > 1) {
          rankError();
        }
        a = omega.toArray();
        for (_i = 0, _len = a.length; _i < _len; _i++) {
          d = a[_i];
          if (!((t130 = (d)) === ~~t130 && (0) <= t130)) {
            domainError();
          }
        }
        n = prod(a);
        if (!n) {
          data = [];
        } else if (a.length === 1) {
          data = n <= 0x100 ? new Uint8Array(n) : n <= 0x10000 ? new Uint16Array(n) : n <= 0x100000000 ? new Uint32Array(n) : domainError();
          for (i = _j = 0; _j < n; i = _j += 1) {
            data[i] = i;
          }
        } else {
          m = Math.max.apply(Math, a);
          ctor = m <= 0x100 ? Uint8Array : m <= 0x10000 ? Uint16Array : m <= 0x100000000 ? Uint32Array : domainError();
          itemData = new ctor(n * a.length);
          u = n;
          for (i = _k = 0, _ref2 = a.length; _k < _ref2; i = _k += 1) {
            u /= a[i];
            p = n * i;
            for (j = _l = 0, _ref3 = a[i]; _l < _ref3; j = _l += 1) {
              itemData[p] = j;
              t131 = itemData;
              t132 = p;
              t133 = 1;
              t134 = u;
              if (t131 instanceof Array) {
                for (j = _m = _ref4 = t133, _ref5 = t134; _m < _ref5; j = _m += 1) {
                  t131[t132 + j] = t131[t132 + j % t133];
                }
              } else {
                t131 = t131.subarray(t132, t132 + t134);
                while (2 * t133 < t134) {
                  t131.set(t131.subarray(0, t133), t133);
                  t133 *= 2;
                }
                t131.set(t131.subarray(0, t134 - t133), t133);
              }
              p += u;
            }
            t135 = itemData;
            t136 = n * i;
            t137 = a[i] * u;
            t138 = n;
            if (t135 instanceof Array) {
              for (j = _n = _ref6 = t137, _ref7 = t138; _n < _ref7; j = _n += 1) {
                t135[t136 + j] = t135[t136 + j % t137];
              }
            } else {
              t135 = t135.subarray(t136, t136 + t138);
              while (2 * t137 < t138) {
                t135.set(t135.subarray(0, t137), t137);
                t137 *= 2;
              }
              t135.set(t135.subarray(0, t138 - t137), t137);
            }
          }
          data = [];
          itemShape = [a.length];
          itemStride = [n];
          for (i = _o = 0; _o < n; i = _o += 1) {
            data.push(new A(itemData, itemShape, itemStride, i));
          }
        }
        return new A(data, a);
      }
    }
  });
  addVocabulary({
    '⊂': function(omega, alpha, axes) {
      var data, i, indices, p, resultAxes, shape, stride, t139, t140, t141, t142, t143, t144, unitShape, unitStride, x, _i, _ref2, _results;
      if (!(!alpha)) {
        throw Error("\"assert !⍺\" at src/vocabulary/leftshoe.coffee:12");
      }
      axes = axes != null ? getAxisList(axes, omega.shape.length) : (function() {
        _results = [];
        for (var _i = 0, _ref2 = omega.shape.length; 0 <= _ref2 ? _i < _ref2 : _i > _ref2; 0 <= _ref2 ? _i++ : _i--){ _results.push(_i); }
        return _results;
      }).apply(this);
      if (omega.isSimple()) {
        return omega;
      }
      unitShape = (function() {
        var _j, _len, _results1;
        _results1 = [];
        for (_j = 0, _len = axes.length; _j < _len; _j++) {
          i = axes[_j];
          _results1.push(omega.shape[i]);
        }
        return _results1;
      })();
      unitStride = (function() {
        var _j, _len, _results1;
        _results1 = [];
        for (_j = 0, _len = axes.length; _j < _len; _j++) {
          i = axes[_j];
          _results1.push(omega.stride[i]);
        }
        return _results1;
      })();
      resultAxes = (function() {
        var _j, _ref3, _results1;
        _results1 = [];
        for (i = _j = 0, _ref3 = omega.shape.length; _j < _ref3; i = _j += 1) {
          if (__indexOf.call(axes, i) < 0) {
            _results1.push(i);
          }
        }
        return _results1;
      })();
      shape = (function() {
        var _j, _len, _results1;
        _results1 = [];
        for (_j = 0, _len = resultAxes.length; _j < _len; _j++) {
          i = resultAxes[_j];
          _results1.push(omega.shape[i]);
        }
        return _results1;
      })();
      stride = (function() {
        var _j, _len, _results1;
        _results1 = [];
        for (_j = 0, _len = resultAxes.length; _j < _len; _j++) {
          i = resultAxes[_j];
          _results1.push(omega.stride[i]);
        }
        return _results1;
      })();
      data = [];
      t139 = new A(omega.data, shape, stride, omega.offset);
      if (!t139.empty()) {
        t141 = t139.data;
        t142 = t139.shape;
        t143 = t139.stride;
        t144 = t142.length - 1;
        p = t139.offset;
        indices = [];
        t140 = t142.length;
        while (--t140 >= 0) {
          indices.push(0);
        }
        while (true) {
          x = t141[p];
          data.push(new A(omega.data, unitShape, unitStride, p));
          t140 = t144;
          while (t140 >= 0 && indices[t140] + 1 === t142[t140]) {
            p -= indices[t140] * t143[t140];
            indices[t140--] = 0;
          }
          if (t140 < 0) {
            break;
          }
          indices[t140]++;
          p += t143[t140];
        }
      }
      return new A(data, shape);
    }
  });
  addVocabulary({
    '~': pervasive({
      monad: function(x) {
        return +(!bool(x));
      }
    }),
    '∨': withIdentity(0, pervasive({
      dyad: function(y, x) {
        if ((!Z.isint(x)) || (!Z.isint(y))) {
          domainError('∨ is implemented only for Gaussian integers');
        }
        return Z.gcd(x, y);
      }
    })),
    '∧': withIdentity(1, pervasive({
      dyad: function(y, x) {
        if ((!Z.isint(x)) || (!Z.isint(y))) {
          domainError('∧ is implemented only for Gaussian integers');
        }
        return Z.lcm(x, y);
      }
    })),
    '⍱': pervasive({
      dyad: function(y, x, t145) {
        if (typeof y === 'number' && ((x == null) || typeof x === 'number')) {
          return +(!(bool(x) | bool(y)));
        } else {
          return domainError();
        }
      }
    }),
    '⍲': pervasive({
      dyad: function(y, x, t146) {
        if (typeof y === 'number' && ((x == null) || typeof x === 'number')) {
          return +(!(bool(x) & bool(y)));
        } else {
          return domainError();
        }
      }
    })
  });
  addVocabulary({
    '⍣': conjunction(function(g, f) {
      var h, n;
      if (f instanceof A && typeof g === 'function') {
        h = f;
        f = g;
        g = h;
      } else {
        if (!(typeof f === 'function')) {
          throw Error("\"assert typeof f is 'function'\" at src/vocabulary/poweroperator.coffee:12");
        }
      }
      if (typeof g === 'function') {
        return function(omega, alpha) {
          var omega1;
          while (true) {
            omega1 = f(omega, alpha);
            if (g(omega, omega1).toBool()) {
              return omega;
            }
            omega = omega1;
          }
        };
      } else {
        n = g.toInt(0);
        return function(omega, alpha) {
          var _i;
          for (_i = 0; 0 <= n ? _i < n : _i > n; 0 <= n ? _i++ : _i--) {
            omega = f(omega, alpha);
          }
          return omega;
        };
      }
    })
  });
  addVocabulary({
    'get_⎕': function() {
      if (typeof (typeof window !== "undefined" && window !== null ? window.prompt : void 0) === 'function') {
        return new A(prompt('⎕:') || '');
      } else {
        return nonceError('Reading from ⎕ is not implemented.');
      }
    },
    'set_⎕': function(x) {
      var s;
      s = format(x).join('\n') + '\n';
      if (typeof (typeof window !== "undefined" && window !== null ? window.alert : void 0) === 'function') {
        window.alert(s);
      } else {
        process.stdout.write(s);
      }
      return x;
    },
    'get_⍞': cps(function(_, _1, _2, callback) {
      if (typeof (typeof window !== "undefined" && window !== null ? window.prompt : void 0) === 'function') {
        return setTimeout((function() {
          return callback(new A(prompt('') || ''));
        }), 0);
      } else {
        return readline('', function(line) {
          return callback(new A(line));
        });
      }
    }),
    'set_⍞': function(x) {
      var s;
      s = format(x).join('\n');
      if (typeof (typeof window !== "undefined" && window !== null ? window.alert : void 0) === 'function') {
        window.alert(s);
      } else {
        process.stdout.write(s);
      }
      return x;
    },
    'get_⎕IO': function() {
      return A.zero;
    },
    'set_⎕IO': function(x) {
      if (match(x, A.zero)) {
        return x;
      } else {
        return domainError('The index origin (⎕IO) is fixed at 0');
      }
    },
    '⎕DL': cps(function(omega, alpha, _, callback) {
      var t0;
      t0 = +(new Date);
      setTimeout((function() {
        return callback(new A([new Date - t0]));
      }), omega.unwrap());
    }),
    '⎕RE': function(omega, alpha) {
      var e, m, r, re, u, x, y, _i, _len;
      x = alpha.toSimpleString();
      y = omega.toSimpleString();
      try {
        re = new RegExp(x);
      } catch (_error) {
        e = _error;
        domainError(e.toString());
      }
      if (m = re.exec(y)) {
        r = [m.index];
        for (_i = 0, _len = m.length; _i < _len; _i++) {
          u = m[_i];
          r.push(new A(u || ''));
        }
        return new A(r);
      } else {
        return A.zilde;
      }
    },
    '⎕UCS': function(omega, alpha) {
      if (alpha != null) {
        nonceError();
      }
      return omega.map(function(x) {
        var t147, y, _ref2;
        if ((t147 = (x)) === ~~t147 && ((0) <= (_ref2 = t147) && _ref2 < (0x10000))) {
          return y = String.fromCharCode(x);
        } else if (typeof x === 'string') {
          return y = x.charCodeAt(0);
        } else {
          return domainError();
        }
      });
    }
  });
  addVocabulary({
    '?': function(omega, alpha) {
      if (alpha) {
        return deal(omega, alpha);
      } else {
        return roll(omega);
      }
    }
  });
  roll = pervasive({
    monad: function(omega) {
      var t148;
      if (!((t148 = omega) === ~~t148 && (1) <= t148)) {
        domainError();
      }
      return Math.floor(Math.random() * omega);
    }
  });
  deal = function(omega, alpha) {
    var h, i, j, r, t149, t150, _i, _j, _ref2, _results;
    alpha = alpha.unwrap();
    omega = omega.unwrap();
    if (!(((t149 = omega) === ~~t149 && (0) <= t149) && ((t150 = alpha) === ~~t150 && ((0) <= (_ref2 = t150) && _ref2 < (omega + 1))))) {
      domainError();
    }
    r = (function() {
      _results = [];
      for (var _i = 0; 0 <= omega ? _i < omega : _i > omega; 0 <= omega ? _i++ : _i--){ _results.push(_i); }
      return _results;
    }).apply(this);
    for (i = _j = 0; _j < alpha; i = _j += 1) {
      j = i + Math.floor(Math.random() * (omega - i));
      h = r[i];
      r[i] = r[j];
      r[j] = h;
    }
    return new A(r.slice(0, alpha));
  };
  addVocabulary({
    '↗': function(omega) {
      return aplError(omega.toString());
    }
  });
  addVocabulary({
    '⍴': function(omega, alpha) {
      var a, data, e, n, t151, t152, t153, t154, t155, t156, t157, t158, t159, x, _i, _len;
      if (alpha) {
        if (alpha.shape.length > 1) {
          rankError();
        }
        a = alpha.toArray();
        for (_i = 0, _len = a.length; _i < _len; _i++) {
          x = a[_i];
          if (!((t151 = (x)) === ~~t151 && (0) <= t151)) {
            domainError();
          }
        }
        n = prod(a);
        if (!n) {
          return new A([], a);
        } else if ((a.length >= omega.shape.length) && arrayEquals(omega.shape, a.slice(a.length - omega.shape.length))) {
          return new A(omega.data, a, repeat([0], a.length - omega.shape.length).concat(omega.stride), omega.offset);
        } else {
          data = [];
          try {
            t152 = omega;
            if (!t152.empty()) {
              t154 = t152.data;
              t155 = t152.shape;
              t156 = t152.stride;
              t157 = t155.length - 1;
              t159 = t152.offset;
              t158 = [];
              t153 = t155.length;
              while (--t153 >= 0) {
                t158.push(0);
              }
              while (true) {
                x = t154[t159];
                if (data.length >= n) {
                  throw 'break';
                }
                data.push(x);
                t153 = t157;
                while (t153 >= 0 && t158[t153] + 1 === t155[t153]) {
                  t159 -= t158[t153] * t156[t153];
                  t158[t153--] = 0;
                }
                if (t153 < 0) {
                  break;
                }
                t158[t153]++;
                t159 += t156[t153];
              }
            }
          } catch (_error) {
            e = _error;
            if (e !== 'break') {
              throw e;
            }
          }
          if (data.length) {
            while (2 * data.length < n) {
              data = data.concat(data);
            }
            if (data.length !== n) {
              data = data.concat(data.slice(0, n - data.length));
            }
          } else {
            data = repeat([omega.getPrototype()], n);
          }
          return new A(data, a);
        }
      } else {
        return new A(omega.shape);
      }
    }
  });
  addVocabulary({
    '⌽': rotate = function(omega, alpha, axis) {
      var a, data, indices, n, offset, p, shape, step, stride, t160, t161, t162;
      if (!(typeof axis === 'undefined' || axis instanceof A)) {
        throw Error("\"assert typeof axis is 'undefined' or axis instanceof A\" at src/vocabulary/rotate.coffee:3");
      }
      if (alpha) {
        axis = !axis ? omega.shape.length - 1 : axis.unwrap();
        if (!((t160 = (axis)) === ~~t160)) {
          domainError();
        }
        if (omega.shape.length && !((0 <= axis && axis < omega.shape.length))) {
          indexError();
        }
        step = alpha.unwrap();
        if (!((t161 = (step)) === ~~t161)) {
          domainError();
        }
        if (!step) {
          return omega;
        }
        n = omega.shape[axis];
        step = (n + (step % n)) % n;
        if (omega.empty() || step === 0) {
          return omega;
        }
        data = [];
        shape = omega.shape, stride = omega.stride;
        p = omega.offset;
        indices = repeat([0], shape.length);
        while (true) {
          data.push(omega.data[p + ((indices[axis] + step) % shape[axis] - indices[axis]) * stride[axis]]);
          a = shape.length - 1;
          while (a >= 0 && indices[a] + 1 === shape[a]) {
            p -= indices[a] * stride[a];
            indices[a--] = 0;
          }
          if (a < 0) {
            break;
          }
          indices[a]++;
          p += stride[a];
        }
        return new A(data, shape);
      } else {
        if (axis) {
          if (!axis.isSingleton()) {
            lengthError();
          }
          axis = axis.unwrap();
          if (!((t162 = (axis)) === ~~t162)) {
            domainError();
          }
          if (!((0 <= axis && axis < omega.shape.length))) {
            indexError();
          }
        } else {
          axis = [omega.shape.length - 1];
        }
        if (omega.shape.length === 0) {
          return omega;
        }
        stride = omega.stride.slice(0);
        stride[axis] = -stride[axis];
        offset = omega.offset + (omega.shape[axis] - 1) * omega.stride[axis];
        return new A(omega.data, omega.shape, stride, offset);
      }
    },
    '⊖': function(omega, alpha, axis) {
      if (axis == null) {
        axis = A.zero;
      }
      return rotate(omega, alpha, axis);
    }
  });
  addVocabulary({
    '⌿': adverb(function(omega, alpha, axis) {
      if (axis == null) {
        axis = A.zero;
      }
      return reduce(omega, alpha, axis);
    }),
    '/': reduce = adverb(function(omega, alpha, axis) {
      var a, axis0, b, data, f, filler, g, i, indices, n, p, shape, t163, x, _i, _j, _len, _ref2;
      if (typeof omega === 'function') {
        f = omega;
        g = alpha;
        axis0 = axis;
        if (!(typeof f === 'function')) {
          throw Error("\"assert typeof f is 'function'\" at src/vocabulary/slash.coffee:20");
        }
        if (!(typeof g === 'undefined')) {
          throw Error("\"assert typeof g is 'undefined'\" at src/vocabulary/slash.coffee:21");
        }
        if (!(typeof axis0 === 'undefined' || axis0 instanceof A)) {
          throw Error("\"assert(typeof axis0 is 'undefined' or axis0 instanceof A)\" at src/vocabulary/slash.coffee:22");
        }
        return function(omega, alpha) {
          var a, data, i, indices, isBackwards, isNWise, n, p, rShape, shape, x, y, z, _i, _j, _ref2;
          if (!omega.shape.length) {
            omega = new A([omega.unwrap()]);
          }
          axis = axis0 != null ? axis0.toInt() : omega.shape.length - 1;
          if (!((0 <= axis && axis < omega.shape.length))) {
            rankError();
          }
          if (alpha) {
            isNWise = true;
            n = alpha.toInt();
            if (n < 0) {
              isBackwards = true;
              n = -n;
            }
          } else {
            n = omega.shape[axis];
          }
          shape = omega.shape.slice(0);
          shape[axis] = omega.shape[axis] - n + 1;
          rShape = shape;
          if (isNWise) {
            if (shape[axis] === 0) {
              return new A([], rShape);
            }
            if (shape[axis] < 0) {
              lengthError();
            }
          } else {
            rShape = rShape.slice(0);
            rShape.splice(axis, 1);
          }
          if (omega.empty()) {
            if ((z = f.identity) != null) {
              if (!(!z.shape.length)) {
                throw Error("\"assert !⍴⍴ z\" at src/vocabulary/slash.coffee:49");
              }
              return new A(z.data, rShape, repeat([0], rShape.length), z.offset);
            } else {
              domainError();
            }
          }
          data = [];
          indices = repeat([0], shape.length);
          p = omega.offset;
          while (true) {
            if (isBackwards) {
              x = omega.data[p];
              x = x instanceof A ? x : A.scalar(x);
              for (i = _i = 1; _i < n; i = _i += 1) {
                y = omega.data[p + i * omega.stride[axis]];
                y = y instanceof A ? y : A.scalar(y);
                x = f(x, y);
              }
            } else {
              x = omega.data[p + (n - 1) * omega.stride[axis]];
              x = x instanceof A ? x : A.scalar(x);
              for (i = _j = _ref2 = n - 2; _j >= 0; i = _j += -1) {
                y = omega.data[p + i * omega.stride[axis]];
                y = y instanceof A ? y : A.scalar(y);
                x = f(x, y);
              }
            }
            if (!x.shape.length) {
              x = x.unwrap();
            }
            data.push(x);
            a = indices.length - 1;
            while (a >= 0 && indices[a] + 1 === shape[a]) {
              p -= indices[a] * omega.stride[a];
              indices[a--] = 0;
            }
            if (a < 0) {
              break;
            }
            p += omega.stride[a];
            indices[a]++;
          }
          return new A(data, rShape);
        };
      } else {
        if (!omega.shape.length) {
          omega = new A([omega.unwrap()]);
        }
        axis = axis ? axis.toInt(0, omega.shape.length) : omega.shape.length - 1;
        if (alpha.shape.length > 1) {
          rankError();
        }
        a = alpha.toArray();
        n = omega.shape[axis];
        if (a.length === 1) {
          a = repeat(a, n);
        }
        if (n !== 1 && n !== a.length) {
          lengthError();
        }
        shape = omega.shape.slice(0);
        shape[axis] = 0;
        b = [];
        for (i = _i = 0, _len = a.length; _i < _len; i = ++_i) {
          x = a[i];
          if (!((t163 = (x)) === ~~t163)) {
            domainError();
          }
          shape[axis] += Math.abs(x);
          for (_j = 0, _ref2 = Math.abs(x); 0 <= _ref2 ? _j < _ref2 : _j > _ref2; 0 <= _ref2 ? _j++ : _j--) {
            b.push(x > 0 ? i : null);
          }
        }
        if (n === 1) {
          b = (function() {
            var _k, _len1, _results;
            _results = [];
            for (_k = 0, _len1 = b.length; _k < _len1; _k++) {
              x = b[_k];
              _results.push(x != null ? 0 : x);
            }
            return _results;
          })();
        }
        data = [];
        if (shape[axis] !== 0 && !omega.empty()) {
          filler = omega.getPrototype();
          p = omega.offset;
          indices = repeat([0], shape.length);
          while (true) {
            x = b[indices[axis]] != null ? omega.data[p + b[indices[axis]] * omega.stride[axis]] : filler;
            data.push(x);
            i = shape.length - 1;
            while (i >= 0 && indices[i] + 1 === shape[i]) {
              if (i !== axis) {
                p -= omega.stride[i] * indices[i];
              }
              indices[i--] = 0;
            }
            if (i < 0) {
              break;
            }
            if (i !== axis) {
              p += omega.stride[i];
            }
            indices[i]++;
          }
        }
        return new A(data, shape);
      }
    })
  });
  addVocabulary({
    '⌷': squish = function(omega, alpha, axes) {
      var a, axis, h, i, r, t164, u, _i, _j, _k, _len, _ref2, _ref3, _results;
      if (typeof omega === 'function') {
        return function(x, y) {
          return omega(x, y, alpha);
        };
      }
      if (!alpha) {
        nonceError();
      }
      if (1 < alpha.shape.length) {
        rankError();
      }
      a = alpha.toArray();
      if (a.length > omega.shape.length) {
        lengthError();
      }
      if (axes) {
        axes = axes.toArray();
        if (a.length !== axes.length) {
          lengthError();
        }
        h = Array(omega.shape.length);
        for (_i = 0, _len = axes.length; _i < _len; _i++) {
          axis = axes[_i];
          if (!((t164 = (axis)) === ~~t164)) {
            domainError();
          }
          if (!((0 <= axis && axis < omega.shape.length))) {
            rankError();
          }
          if (h[axis]) {
            rankError('Duplicate axis');
          }
          h[axis] = 1;
        }
      } else {
        axes = (function() {
          _results = [];
          for (var _j = 0, _ref2 = a.length; 0 <= _ref2 ? _j < _ref2 : _j > _ref2; 0 <= _ref2 ? _j++ : _j--){ _results.push(_j); }
          return _results;
        }).apply(this);
      }
      r = omega;
      for (i = _k = _ref3 = a.length - 1; _k >= 0; i = _k += -1) {
        u = a[i] instanceof A ? a[i] : new A([a[i]], []);
        r = indexAtSingleAxis(r, u, axes[i]);
      }
      return r;
    },
    _index: function(alphaAndAxes, omega) {
      var alpha, axes, _ref2;
      _ref2 = alphaAndAxes.toArray(), alpha = _ref2[0], axes = _ref2[1];
      return squish(omega, alpha, axes);
    },
    _substitute: function(args) {
      var a, alpha, axes, data, i, omega, p, stride, subs, t165, t166, t167, t168, t169, t170, t171, t172, t173, t174, t175, t176, t177, u, v, value, x, _i, _j, _len, _ref2, _ref3, _ref4, _results;
      _ref2 = (function() {
        var _i, _len, _ref2, _results;
        _ref2 = args.toArray();
        _results = [];
        for (_i = 0, _len = _ref2.length; _i < _len; _i++) {
          x = _ref2[_i];
          if (x instanceof A) {
            _results.push(x);
          } else {
            _results.push(new A([x], []));
          }
        }
        return _results;
      })(), value = _ref2[0], alpha = _ref2[1], omega = _ref2[2], axes = _ref2[3];
      if (1 < alpha.shape.length) {
        rankError();
      }
      a = alpha.toArray();
      if (a.length > omega.shape.length) {
        lengthError();
      }
      if (axes) {
        if (1 < axes.shape.length) {
          rankError();
        }
        axes = axes.toArray();
        if (a.length !== axes.length) {
          lengthError();
        }
      } else {
        axes = (function() {
          _results = [];
          for (var _i = 0, _ref3 = a.length; 0 <= _ref3 ? _i < _ref3 : _i > _ref3; 0 <= _ref3 ? _i++ : _i--){ _results.push(_i); }
          return _results;
        }).apply(this);
      }
      subs = squish(vocabulary['⍳'](new A(omega.shape)), alpha, new A(axes));
      if (value.isSingleton()) {
        value = new A([value], subs.shape, repeat([0], subs.shape.length));
      }
      data = omega.toArray();
      stride = strideForShape(omega.shape);
      t165 = subs;
      t170 = t165.data;
      t172 = t165.shape;
      t174 = t165.stride;
      t166 = value;
      t171 = t166.data;
      t173 = t166.shape;
      t175 = t166.stride;
      if (t172.length !== t173.length) {
        rankError();
      }
      t169 = t172.length;
      while (--t169 >= 0) {
        if (t172[t169] !== t173[t169]) {
          lengthError();
        }
      }
      if (!t165.empty()) {
        t176 = t172.length - 1;
        t167 = t165.offset;
        t168 = t166.offset;
        t177 = Array((t169 = t172.length));
        while (--t169 >= 0) {
          t177[t169] = 0;
        }
        while (true) {
          u = t170[t167];
          v = t171[t168];
          if (v instanceof A && !v.shape.length) {
            v = v.unwrap();
          }
          if (u instanceof A) {
            p = 0;
            _ref4 = u.toArray();
            for (i = _j = 0, _len = _ref4.length; _j < _len; i = ++_j) {
              x = _ref4[i];
              p += x * stride[i];
            }
            data[p] = v;
          } else {
            data[u] = v;
          }
          t169 = t176;
          while (t169 >= 0 && t177[t169] + 1 === t172[t169]) {
            t167 -= t177[t169] * t174[t169];
            t168 -= t177[t169] * t175[t169];
            t177[t169--] = 0;
          }
          if (t169 < 0) {
            break;
          }
          t177[t169]++;
          t167 += t174[t169];
          t168 += t175[t169];
        }
      }
      return new A(data, omega.shape);
    }
  });
  indexAtSingleAxis = function(omega, sub, ax) {
    var chunk, d, data, i, isUniform, k, n, offset, shape, shape1, stride, stride1, subStride, t178, t179, t180, t181, t182, t183, t184, t185, t186, t187, u, x, _i, _j, _k, _l, _len, _len1, _ref2, _ref3;
    if (!(omega instanceof A)) {
      throw Error("\"assert ⍵ instanceof A\" at src/vocabulary/squish.coffee:119");
    }
    if (!(sub instanceof A)) {
      throw Error("\"assert sub instanceof A\" at src/vocabulary/squish.coffee:120");
    }
    if (!((t178 = (ax)) === ~~t178)) {
      throw Error("\"assert isInt ax\" at src/vocabulary/squish.coffee:121");
    }
    if (!((0 <= ax && ax < omega.shape.length))) {
      throw Error("\"assert 0 <= ax < ⍴⍴ ⍵\" at src/vocabulary/squish.coffee:122");
    }
    u = sub.toArray();
    n = omega.shape[ax];
    for (_i = 0, _len = u.length; _i < _len; _i++) {
      x = u[_i];
      if (!((t179 = (x)) === ~~t179)) {
        domainError();
      }
      if (!((0 <= x && x < n))) {
        indexError();
      }
    }
    isUniform = false;
    if (u.length >= 2) {
      isUniform = true;
      d = u[1] - u[0];
      for (i = _j = 2, _ref2 = u.length; _j < _ref2; i = _j += 1) {
        if (u[i] - u[i - 1] !== d) {
          isUniform = false;
          break;
        }
      }
    }
    if (isUniform) {
      shape = omega.shape.slice(0);
      shape.splice.apply(shape, [ax, 1].concat(__slice.call(sub.shape)));
      stride = omega.stride.slice(0);
      subStride = strideForShape(sub.shape);
      for (i = _k = 0, _len1 = subStride.length; _k < _len1; i = ++_k) {
        x = subStride[i];
        subStride[i] = x * d * omega.stride[ax];
      }
      stride.splice.apply(stride, [ax, 1].concat(__slice.call(subStride)));
      offset = omega.offset + u[0] * omega.stride[ax];
      return new A(omega.data, shape, stride, offset);
    } else {
      shape1 = omega.shape.slice(0);
      shape1.splice(ax, 1);
      stride1 = omega.stride.slice(0);
      stride1.splice(ax, 1);
      data = [];
      t180 = sub;
      if (!t180.empty()) {
        t182 = t180.data;
        t183 = t180.shape;
        t184 = t180.stride;
        t185 = t183.length - 1;
        t187 = t180.offset;
        t186 = [];
        t181 = t183.length;
        while (--t181 >= 0) {
          t186.push(0);
        }
        while (true) {
          x = t182[t187];
          chunk = new A(omega.data, shape1, stride1, omega.offset + x * omega.stride[ax]);
          data.push.apply(data, chunk.toArray());
          t181 = t185;
          while (t181 >= 0 && t186[t181] + 1 === t183[t181]) {
            t187 -= t186[t181] * t184[t181];
            t186[t181--] = 0;
          }
          if (t181 < 0) {
            break;
          }
          t186[t181]++;
          t187 += t184[t181];
        }
      }
      shape = shape1.slice(0);
      stride = strideForShape(shape);
      shape.splice.apply(shape, [ax, 0].concat(__slice.call(sub.shape)));
      subStride = strideForShape(sub.shape);
      k = prod(shape1);
      for (i = _l = 0, _ref3 = subStride.length; _l < _ref3; i = _l += 1) {
        subStride[i] *= k;
      }
      stride.splice.apply(stride, [ax, 0].concat(__slice.call(subStride)));
      return new A(data, shape, stride);
    }
  };
  addVocabulary({
    '↑': function(omega, alpha) {
      if (alpha) {
        return take(omega, alpha);
      } else {
        return first(omega);
      }
    }
  });
  take = function(omega, alpha) {
    var a, axis, copyIndices, copyShape, data, i, mustCopy, offset, p, q, shape, stride, x, _i, _j, _k, _l, _len, _len1, _len2, _len3, _m, _ref2;
    if (alpha.shape.length > 1) {
      rankError();
    }
    if (!omega.shape.length) {
      omega = new A([omega.unwrap()], (!alpha.shape.length ? [1] : repeat([1], alpha.shape[0])));
    }
    a = alpha.toArray();
    if (a.length > omega.shape.length) {
      rankError();
    }
    for (_i = 0, _len = a.length; _i < _len; _i++) {
      x = a[_i];
      if (typeof x !== 'number' || x !== Math.floor(x)) {
        domainError();
      }
    }
    mustCopy = false;
    shape = omega.shape.slice(0);
    for (i = _j = 0, _len1 = a.length; _j < _len1; i = ++_j) {
      x = a[i];
      shape[i] = Math.abs(x);
      if (shape[i] > omega.shape[i]) {
        mustCopy = true;
      }
    }
    if (mustCopy) {
      stride = Array(shape.length);
      stride[stride.length - 1] = 1;
      for (i = _k = _ref2 = stride.length - 2; _k >= 0; i = _k += -1) {
        stride[i] = stride[i + 1] * shape[i + 1];
      }
      data = repeat([omega.getPrototype()], prod(shape));
      copyShape = shape.slice(0);
      p = omega.offset;
      q = 0;
      for (i = _l = 0, _len2 = a.length; _l < _len2; i = ++_l) {
        x = a[i];
        copyShape[i] = Math.min(omega.shape[i], Math.abs(x));
        if (x < 0) {
          if (x < -omega.shape[i]) {
            q -= (x + omega.shape[i]) * stride[i];
          } else {
            p += (x + omega.shape[i]) * omega.stride[i];
          }
        }
      }
      if (prod(copyShape)) {
        copyIndices = repeat([0], copyShape.length);
        while (true) {
          data[q] = omega.data[p];
          axis = copyShape.length - 1;
          while (axis >= 0 && copyIndices[axis] + 1 === copyShape[axis]) {
            p -= copyIndices[axis] * omega.stride[axis];
            q -= copyIndices[axis] * stride[axis];
            copyIndices[axis--] = 0;
          }
          if (axis < 0) {
            break;
          }
          p += omega.stride[axis];
          q += stride[axis];
          copyIndices[axis]++;
        }
      }
      return new A(data, shape, stride);
    } else {
      offset = omega.offset;
      for (i = _m = 0, _len3 = a.length; _m < _len3; i = ++_m) {
        x = a[i];
        if (x < 0) {
          offset += (omega.shape[i] + x) * omega.stride[i];
        }
      }
      return new A(omega.data, shape, omega.stride, offset);
    }
  };
  first = function(omega) {
    var x;
    x = omega.empty() ? omega.getPrototype() : omega.data[omega.offset];
    if (x instanceof A) {
      return x;
    } else {
      return new A([x], []);
    }
  };
  addVocabulary({
    '⍉': function(omega, alpha) {
      var i, n, shape, stride, t188, u, x, _i, _j, _len, _len1, _ref2;
      if (alpha) {
        if (alpha.shape.length > 1) {
          rankError();
        }
        if (!alpha.shape.length) {
          alpha = new A([alpha.unwrap()]);
        }
        n = omega.shape.length;
        if (alpha.shape[0] !== n) {
          lengthError();
        }
        shape = [];
        stride = [];
        _ref2 = alpha.toArray();
        for (i = _i = 0, _len = _ref2.length; _i < _len; i = ++_i) {
          x = _ref2[i];
          if (!((t188 = (x)) === ~~t188 && (0) <= t188)) {
            domainError();
          }
          if (x >= n) {
            rankError();
          }
          if (shape[x] != null) {
            shape[x] = Math.min(shape[x], omega.shape[i]);
            stride[x] += omega.stride[i];
          } else {
            shape[x] = omega.shape[i];
            stride[x] = omega.stride[i];
          }
        }
        for (_j = 0, _len1 = shape.length; _j < _len1; _j++) {
          u = shape[_j];
          if (u == null) {
            rankError();
          }
        }
        return new A(omega.data, shape, stride, omega.offset);
      } else {
        return new A(omega.data, reversed(omega.shape), reversed(omega.stride), omega.offset);
      }
    }
  });
  addVocabulary({
    '⍠': conjunction(function(f, g) {
      if (!(typeof f === 'function')) {
        throw Error("\"assert typeof f is 'function'\" at src/vocabulary/variant.coffee:5");
      }
      if (!(typeof g === 'function')) {
        throw Error("\"assert typeof g is 'function'\" at src/vocabulary/variant.coffee:6");
      }
      return function(omega, alpha, axis) {
        return (alpha != null ? f : g)(omega, alpha, axis);
      };
    })
  });
  _ref2 = [1, 2, 3, 4], NOUN = _ref2[0], VERB = _ref2[1], ADVERB = _ref2[2], CONJUNCTION = _ref2[3];
  exec = function(aplCode, opts) {
    var ast, code, env, k, result, v, x, _ref3, _ref4;
    if (opts == null) {
      opts = {};
    }
    ast = parse(aplCode, opts);
    code = compileAST(ast, opts);
    env = [prelude.env[0].slice(0)];
    _ref3 = ast.vars;
    for (k in _ref3) {
      v = _ref3[k];
      env[0][v.slot] = opts.ctx[k];
    }
    result = vm({
      code: code,
      env: env
    });
    _ref4 = ast.vars;
    for (k in _ref4) {
      v = _ref4[k];
      x = opts.ctx[k] = env[0][v.slot];
      if (v.category === ADVERB) {
        x.isAdverb = true;
      }
      if (v.category === CONJUNCTION) {
        x.isConjunction = true;
      }
    }
    return result;
  };
  repr = function(x) {
    var k, v, y, _ref3;
    if (x === null || ((_ref3 = typeof x) === 'string' || _ref3 === 'number' || _ref3 === 'boolean')) {
      return JSON.stringify(x);
    } else if (x instanceof Array) {
      return "[" + (((function() {
        var _i, _len, _results;
        _results = [];
        for (_i = 0, _len = x.length; _i < _len; _i++) {
          y = x[_i];
          _results.push(repr(y));
        }
        return _results;
      })()).join(',')) + "]";
    } else if (x.repr) {
      return x.repr();
    } else {
      return "{" + (((function() {
        var _results;
        _results = [];
        for (k in x) {
          v = x[k];
          _results.push("" + (repr(k)) + ":" + (repr(v)));
        }
        return _results;
      })()).join(',')) + "}";
    }
  };
  compileAST = function(ast, opts) {
    var categorizeLambdas, err, i, key, queue, render, renderLHS, scopeNode, value, varInfo, vars, visit, visitLHS, _i, _ref3, _ref4;
    if (opts == null) {
      opts = {};
    }
    ast.scopeDepth = 0;
    ast.nSlots = prelude.nSlots;
    ast.vars = Object.create(prelude.vars);
    if (opts.ctx == null) {
      opts.ctx = Object.create(vocabulary);
    }
    _ref3 = opts.ctx;
    for (key in _ref3) {
      value = _ref3[key];
      if (!(!ast.vars[key])) {
        continue;
      }
      ast.vars[key] = varInfo = {
        category: NOUN,
        slot: ast.nSlots++,
        scopeDepth: ast.scopeDepth
      };
      if (typeof value === 'function' || value instanceof Proc) {
        varInfo.category = value.isAdverb ? ADVERB : value.isConjunction ? CONJUNCTION : VERB;
        if (/^[gs]et_.*/.test(key)) {
          ast.vars[key.slice(4)] = {
            category: NOUN
          };
        }
      }
    }
    err = function(node, message) {
      return syntaxError(message, {
        file: opts.file,
        offset: node.offset,
        aplCode: opts.aplCode
      });
    };
    if (!((VERB < ADVERB && ADVERB < CONJUNCTION))) {
      throw Error("\"assert VERB < ADVERB < CONJUNCTION # we are relying on this ordering below\" at src/compiler.coffee:35");
    }
    (categorizeLambdas = function(node) {
      var i, r, _i, _ref4;
      switch (node[0]) {
        case 'B':
        case ':':
        case '←':
        case '[':
        case '{':
        case '.':
        case '⍬':
          r = VERB;
          for (i = _i = 1, _ref4 = node.length; _i < _ref4; i = _i += 1) {
            if (node[i]) {
              r = Math.max(r, categorizeLambdas(node[i]));
            }
          }
          if (node[0] === '{') {
            node.category = r;
            return VERB;
          } else {
            return r;
          }
          break;
        case 'S':
        case 'N':
        case 'J':
          return 0;
        case 'X':
          switch (node[1]) {
            case '⍺⍺':
            case '⍶':
            case '∇∇':
              return ADVERB;
            case '⍵⍵':
            case '⍹':
              return CONJUNCTION;
            default:
              return VERB;
          }
          break;
        default:
          if (!(0)) {
            throw Error("\"else assert 0\" at src/compiler.coffee:48");
          }
      }
    })(ast);
    queue = [ast];
    while (queue.length) {
      vars = (scopeNode = queue.shift()).vars;
      visit = function(node) {
        var a, body, d, h, i, j, name, r, v, x, _i, _j, _k, _ref10, _ref11, _ref12, _ref13, _ref14, _ref15, _ref16, _ref4, _ref5, _ref6, _ref7, _ref8, _ref9;
        node.scopeNode = scopeNode;
        switch (node[0]) {
          case ':':
            r = visit(node[1]);
            visit(node[2]);
            return r;
          case '←':
            return visitLHS(node[1], visit(node[2]));
          case 'X':
            name = node[1];
            if (((_ref4 = (v = vars["get_" + name])) != null ? _ref4.category : void 0) === VERB) {
              return NOUN;
            } else {
              return ((_ref5 = vars[name]) != null ? _ref5.category : void 0) || valueError("Symbol '" + name + "' is referenced before assignment.", {
                file: opts.file,
                offset: node.offset,
                aplCode: opts.aplCode
              });
            }
            break;
          case '{':
            for (i = _i = 1, _ref6 = node.length; _i < _ref6; i = _i += 1) {
              queue.push(extend((body = node[i]), {
                scopeNode: scopeNode,
                scopeDepth: d = scopeNode.scopeDepth + 1 + (node.category !== VERB),
                nSlots: 4,
                vars: v = extend(Object.create(vars), {
                  '⍵': {
                    slot: 0,
                    scopeDepth: d,
                    category: NOUN
                  },
                  '∇': {
                    slot: 1,
                    scopeDepth: d,
                    category: VERB
                  },
                  '⍺': {
                    slot: 2,
                    scopeDepth: d,
                    category: NOUN
                  },
                  '⍫': {
                    scopeDepth: d,
                    category: VERB
                  }
                })
              }));
              if (node.category === CONJUNCTION) {
                v['⍵⍵'] = v['⍹'] = {
                  slot: 0,
                  scopeDepth: d - 1,
                  category: VERB
                };
                v['∇∇'] = {
                  slot: 1,
                  scopeDepth: d - 1,
                  category: CONJUNCTION
                };
                v['⍺⍺'] = v['⍶'] = {
                  slot: 2,
                  scopeDepth: d - 1,
                  category: VERB
                };
              } else if (node.category === ADVERB) {
                v['⍺⍺'] = v['⍶'] = {
                  slot: 0,
                  scopeDepth: d - 1,
                  category: VERB
                };
                v['∇∇'] = {
                  slot: 1,
                  scopeDepth: d - 1,
                  category: ADVERB
                };
              }
            }
            return (_ref7 = node.category) != null ? _ref7 : VERB;
          case 'S':
          case 'N':
          case 'J':
          case '⍬':
            return NOUN;
          case '[':
            for (i = _j = 2, _ref8 = node.length; _j < _ref8; i = _j += 1) {
              if (node[i] && visit(node[i]) !== NOUN) {
                err(node, 'Indices must be nouns.');
              }
            }
            return visit(node[1]);
          case '.':
            a = node.slice(1);
            h = Array(a.length);
            for (i = _k = _ref9 = a.length - 1; _k >= 0; i = _k += -1) {
              h[i] = visit(a[i]);
            }
            i = 0;
            while (i < a.length - 1) {
              if ((h[i] === (_ref10 = h[i + 1]) && _ref10 === NOUN)) {
                j = i + 2;
                while (j < a.length && h[j] === NOUN) {
                  j++;
                }
                [].splice.apply(a, [i, j - i].concat(_ref11 = [['V'].concat(a.slice(i, j))])), _ref11;
                [].splice.apply(h, [i, j - i].concat(NOUN)), NOUN;
              } else {
                i++;
              }
            }
            i = a.length - 2;
            while (--i >= 0) {
              if (h[i + 1] === CONJUNCTION && (h[i] !== NOUN || h[i + 2] !== NOUN)) {
                [].splice.apply(a, [i, (i + 3) - i].concat(_ref12 = [['C'].concat(a.slice(i, i + 3))])), _ref12;
                [].splice.apply(h, [i, (i + 3) - i].concat(VERB)), VERB;
                i--;
              }
            }
            i = 0;
            while (i < a.length - 1) {
              if (h[i] !== NOUN && h[i + 1] === ADVERB) {
                [].splice.apply(a, [i, (i + 2) - i].concat(_ref13 = [['A'].concat(a.slice(i, i + 2))])), _ref13;
                [].splice.apply(h, [i, (i + 2) - i].concat(VERB)), VERB;
              } else {
                i++;
              }
            }
            if (h.length === 2 && h[0] !== NOUN && h[1] !== NOUN) {
              a = [['H'].concat(a)];
              h = [VERB];
            }
            if (h.length >= 3 && h.length % 2 === 1 && all((function() {
              var _l, _len, _results;
              _results = [];
              for (_l = 0, _len = h.length; _l < _len; _l++) {
                x = h[_l];
                _results.push(x !== NOUN);
              }
              return _results;
            })())) {
              a = [['F'].concat(a)];
              h = [VERB];
            }
            if (h[h.length - 1] !== NOUN) {
              if (h.length > 1) {
                err(a[h.length - 1], 'Trailing function in expression');
              }
            } else {
              while (h.length > 1) {
                if (h.length === 2 || h[h.length - 3] !== NOUN) {
                  [].splice.apply(a, [-2, 9e9].concat(_ref14 = [['M'].concat(a.slice(-2))])), _ref14;
                  [].splice.apply(h, [-2, 9e9].concat(NOUN)), NOUN;
                } else {
                  [].splice.apply(a, [-3, 9e9].concat(_ref15 = [['D'].concat(a.slice(-3))])), _ref15;
                  [].splice.apply(h, [-3, 9e9].concat(NOUN)), NOUN;
                }
              }
            }
            [].splice.apply(node, [0, 9e9].concat(_ref16 = a[0])), _ref16;
            extend(node, a[0]);
            return h[0];
          default:
            if (!(0)) {
              throw Error("\"assert 0\" at src/compiler.coffee:145");
            }
        }
      };
      visitLHS = function(node, rhsCategory) {
        var c, i, name, _i, _j, _ref4, _ref5;
        node.scopeNode = scopeNode;
        switch (node[0]) {
          case 'X':
            name = node[1];
            if (__indexOf.call('∇⍫', name) >= 0) {
              err(node, "Assignment to " + name + " is not allowed.");
            }
            if (vars[name]) {
              if (vars[name].category !== rhsCategory) {
                err(node, "Inconsistent usage of symbol '" + name + "', it is assigned both nouns and verbs.");
              }
            } else {
              vars[name] = {
                scopeDepth: scopeNode.scopeDepth,
                slot: scopeNode.nSlots++,
                category: rhsCategory
              };
            }
            break;
          case '.':
            rhsCategory === NOUN || err(node, 'Strand assignment can be used only for nouns.');
            for (i = _i = 1, _ref4 = node.length; _i < _ref4; i = _i += 1) {
              visitLHS(node[i], rhsCategory);
            }
            break;
          case '[':
            rhsCategory === NOUN || err(node, 'Index assignment can be used only for nouns.');
            visitLHS(node[1], rhsCategory);
            for (i = _j = 2, _ref5 = node.length; _j < _ref5; i = _j += 1) {
              if (c = node[i]) {
                visit(c);
              }
            }
            break;
          default:
            err(node, "Invalid LHS node type: " + (JSON.stringify(node[0])));
        }
        return rhsCategory;
      };
      for (i = _i = 1, _ref4 = scopeNode.length; _i < _ref4; i = _i += 1) {
        visit(scopeNode[i]);
      }
    }
    render = function(node) {
      var a, axes, c, d, f, fragments, lx, ly, name, r, s, u, v, w, x, y, _j, _k, _ref5, _ref6, _ref7, _ref8;
      switch (node[0]) {
        case 'B':
          if (node.length === 1) {
            return [LDC, A.zilde, RET];
          } else {
            a = [];
            for (i = _j = 1, _ref5 = node.length; _j < _ref5; i = _j += 1) {
              a.push.apply(a, render(node[i]));
              a.push(POP);
            }
            a[a.length - 1] = RET;
            return a;
          }
          break;
        case ':':
          x = render(node[1]);
          y = render(node[2]);
          return x.concat(JEQ, y.length + 2, POP, y, RET);
        case '←':
          return render(node[2]).concat(renderLHS(node[1]));
        case 'X':
          name = node[1];
          vars = node.scopeNode.vars;
          if (name === '⍫') {
            return [CON];
          } else if (((_ref6 = (v = vars["get_" + name])) != null ? _ref6.category : void 0) === VERB) {
            return [LDC, A.zero, GET, v.scopeDepth, v.slot, MON];
          } else {
            v = vars[name];
            return [GET, v.scopeDepth, v.slot];
          }
          break;
        case '{':
          x = render(node[1]);
          lx = [LAM, x.length].concat(x);
          f = (function() {
            switch (node.length) {
              case 2:
                return lx;
              case 3:
                y = render(node[2]);
                ly = [LAM, y.length].concat(y);
                v = node.scopeNode.vars['⍠'];
                return ly.concat(GET, v.scopeDepth, v.slot, lx, DYA);
              default:
                return err(node);
            }
          })();
          if (node.category !== VERB) {
            return [LAM, f.length + 1].concat(f, RET);
          } else {
            return f;
          }
          break;
        case 'S':
          d = node[1][0];
          s = node[1].slice(1, -1).replace(RegExp("" + (d + d), "g"), d);
          return [LDC, new A(s, s.length === 1 ? [] : void 0)];
        case 'N':
          a = (function() {
            var _k, _len, _ref7, _results;
            _ref7 = node[1].replace(/[¯∞]/g, '-').split(/j/i);
            _results = [];
            for (_k = 0, _len = _ref7.length; _k < _len; _k++) {
              x = _ref7[_k];
              if (x === '-') {
                _results.push(Infinity);
              } else if (x === '--') {
                _results.push(-Infinity);
              } else if (x.match(/^-?0x/i)) {
                _results.push(parseInt(x, 16));
              } else {
                _results.push(parseFloat(x));
              }
            }
            return _results;
          })();
          v = a[1] ? new Z(a[0], a[1]) : a[0];
          return [LDC, new A([v], [])];
        case 'J':
          f = Function("return function(_w,_a){return(" + (node[1].replace(/^«|»$/g, '')) + ")};")();
          return [
            EMB, function(_w, _a) {
              return aplify(f(_w, _a));
            }
          ];
        case '[':
          v = node.scopeNode.vars._index;
          axes = [];
          a = [];
          for (i = _k = 2, _ref7 = node.length; _k < _ref7; i = _k += 1) {
            if (!(c = node[i])) {
              continue;
            }
            axes.push(i - 2);
            a.push.apply(a, render(c));
          }
          a.push(VEC, axes.length, LDC, new A(axes), VEC, 2, GET, v.scopeDepth, v.slot);
          a.push.apply(a, render(node[1]));
          a.push(DYA);
          return a;
        case 'V':
          fragments = (function() {
            var _l, _ref8, _results;
            _results = [];
            for (i = _l = 1, _ref8 = node.length; _l < _ref8; i = _l += 1) {
              _results.push(render(node[i]));
            }
            return _results;
          })();
          if (all((function() {
            var _l, _len, _results;
            _results = [];
            for (_l = 0, _len = fragments.length; _l < _len; _l++) {
              f = fragments[_l];
              _results.push(f.length === 2 && f[0] === LDC);
            }
            return _results;
          })())) {
            return [
              LDC, new A((function() {
                var _l, _len, _results;
                _results = [];
                for (_l = 0, _len = fragments.length; _l < _len; _l++) {
                  f = fragments[_l];
                  _results.push((x = f[1]).isSimple() ? x.unwrap() : x);
                }
                return _results;
              })())
            ];
          } else {
            return (_ref8 = []).concat.apply(_ref8, __slice.call(fragments).concat([VEC], [node.length - 1]));
          }
          break;
        case '⍬':
          return [LDC, A.zilde];
        case 'M':
          return render(node[2]).concat(render(node[1]), MON);
        case 'A':
          return render(node[1]).concat(render(node[2]), MON);
        case 'D':
        case 'C':
          return render(node[3]).concat(render(node[2]), render(node[1]), DYA);
        case 'H':
          v = node.scopeNode.vars._hook;
          return render(node[2]).concat(GET, v.scopeDepth, v.slot, render(node[1]), DYA);
        case 'F':
          u = node.scopeNode.vars._hook;
          v = node.scopeNode.vars._fork1;
          w = node.scopeNode.vars._fork2;
          i = node.length - 1;
          r = render(node[i--]);
          while (i >= 2) {
            r = r.concat(GET, v.scopeDepth, v.slot, render(node[i--]), DYA, GET, w.scopeDepth, w.slot, render(node[i--]), DYA);
          }
          if (i) {
            return r.concat(render(node[1]), GET, u.scopeDepth, u.slot, DYA);
          } else {
            return r;
          }
          break;
        default:
          if (!(0)) {
            throw Error("\"else assert 0\" at src/compiler.coffee:305");
          }
      }
    };
    renderLHS = function(node) {
      var a, axes, c, n, name, v, _j, _k, _ref5, _ref6, _ref7;
      switch (node[0]) {
        case 'X':
          name = node[1];
          vars = node.scopeNode.vars;
          if (((_ref5 = (v = vars["set_" + name])) != null ? _ref5.category : void 0) === VERB) {
            return [GET, v.scopeDepth, v.slot, MON];
          } else {
            v = vars[name];
            return [SET, v.scopeDepth, v.slot];
          }
          break;
        case '.':
          n = node.length - 1;
          a = [SPL, n];
          for (i = _j = 1, _ref6 = node.length; _j < _ref6; i = _j += 1) {
            a.push.apply(a, renderLHS(node[i]));
            a.push(POP);
          }
          return a;
        case '[':
          v = node.scopeNode.vars._substitute;
          axes = [];
          a = [];
          for (i = _k = 2, _ref7 = node.length; _k < _ref7; i = _k += 1) {
            if (!(c = node[i])) {
              continue;
            }
            axes.push(i - 2);
            a.push.apply(a, render(c));
          }
          a.push(VEC, axes.length);
          a.push.apply(a, render(node[1]));
          a.push(LDC, new A(axes), VEC, 4, GET, v.scopeDepth, v.slot, MON);
          a.push.apply(a, renderLHS(node[1]));
          return a;
        default:
          if (!(0)) {
            throw Error("\"assert 0\" at src/compiler.coffee:340");
          }
      }
    };
    return render(ast);
  };
  prelude = (function() {
    var code, env, k, nSlots, v, vars, _ref3;
    _ref3 = {"code":[1,new A([],[0],[1],0),4,0,73,9,7,22,3,1,2,3,0,65,3,1,0,3,0,29,3,1,2,6,3,0,44,5,6,8,3,0,72,3,0,44,6,4,0,44,9,7,39,7,15,3,2,0,3,1,0,5,3,1,2,3,2,2,6,8,3,0,72,7,15,3,2,0,3,1,0,5,3,1,2,3,2,0,6,8,6,8,4,0,74,9,7,173,3,1,2,3,0,62,5,3,0,62,5,3,0,16,1,new A([1],[],[],0),6,11,8,9,1,new A("RANK ERROR",[10],[1],0),3,0,61,5,8,9,3,1,0,4,1,4,9,3,1,2,7,123,3,2,0,3,0,62,5,3,0,62,5,3,0,16,1,new A([1],[],[],0),6,11,8,9,1,new A("RANK ERROR",[10],[1],0),3,0,61,5,8,9,3,2,0,3,0,13,5,4,2,0,9,3,1,4,3,0,62,5,3,0,62,5,3,0,15,3,2,0,3,0,62,5,6,11,8,9,1,new A("RANK ERROR",[10],[1],0),3,0,61,5,8,9,3,1,4,3,0,62,5,3,0,19,3,2,0,6,3,0,45,3,0,65,5,5,11,8,9,1,new A("INDEX ERROR",[11],[1],0),3,0,61,5,8,9,3,1,4,3,0,67,3,2,0,6,3,0,75,5,4,1,4,8,3,0,27,5,5,9,3,1,4,8,3,0,72,7,229,3,1,0,3,0,62,5,3,0,62,5,3,0,14,1,new A([0],[],[],0),6,11,9,9,3,1,0,3,0,70,5,8,9,3,1,0,3,0,62,5,3,0,3,3,0,65,5,5,3,0,14,1,new A([0],[],[],0),6,11,5,9,3,1,0,8,9,3,1,0,3,0,62,5,4,1,4,9,3,1,0,3,0,13,5,4,1,0,9,3,1,0,3,0,62,3,0,27,5,5,4,1,5,3,0,79,3,0,27,5,5,3,0,35,3,0,65,5,5,4,1,6,9,3,1,5,3,0,13,3,0,21,1,new A([1],[],[],0),3,0,62,3,1,6,6,6,3,0,36,3,0,26,6,3,0,37,3,0,62,6,3,0,27,5,5,4,1,5,3,0,35,3,0,65,5,5,3,0,70,5,4,1,7,9,3,1,0,7,18,3,2,0,3,0,62,3,2,2,6,3,0,70,3,1,7,6,8,3,0,27,5,3,1,5,6,3,0,76,3,0,65,5,5,3,0,70,5,3,0,62,3,1,7,3,0,13,3,1,4,6,6,8,6,4,0,75,9,7,335,3,1,2,3,0,62,5,3,0,62,5,3,0,16,1,new A([1],[],[],0),6,11,8,9,1,new A("RANK ERROR",[10],[1],0),3,0,61,5,8,9,3,1,0,3,0,62,5,3,0,62,5,3,0,15,1,new A([1],[],[],0),6,11,8,9,1,new A("NONCE ERROR",[11],[1],0),3,0,61,5,8,9,1,new A([0],[],[],0),3,0,14,3,1,2,6,3,0,13,5,4,1,2,9,3,1,2,3,0,33,1,new A([1,1],[2],[1],0),6,3,0,44,5,4,1,4,9,3,1,2,3,0,65,3,1,4,6,4,1,5,9,3,1,0,3,0,65,3,1,4,6,4,1,6,9,3,0,73,7,52,3,1,5,3,0,70,1,new A([1],[],[],0),6,3,0,14,1,new A([1],[],[],0),6,11,34,9,3,0,73,7,26,3,1,5,3,0,26,1,new A([1],[],[],0),6,4,1,5,9,3,1,6,3,0,26,1,new A([1],[],[],0),6,4,1,6,8,5,8,8,5,9,3,0,73,7,52,3,1,5,3,0,70,1,new A([-1],[],[],0),6,3,0,14,1,new A([1],[],[],0),6,11,34,9,3,0,73,7,26,3,1,5,3,0,26,1,new A([-1],[],[],0),6,4,1,5,9,3,1,6,3,0,26,1,new A([-1],[],[],0),6,4,1,6,8,5,8,8,5,9,3,1,5,3,0,62,5,3,0,42,5,3,0,65,3,1,5,6,3,0,13,3,0,81,5,3,1,5,3,0,62,5,6,4,1,5,9,1,new A([0],[],[],0),4,1,7,9,3,1,6,3,0,43,5,7,38,3,2,0,3,0,70,3,2,2,6,3,0,26,3,1,7,6,4,2,4,9,1,new A([1],[],[],0),3,0,0,3,2,2,6,4,1,7,9,3,2,4,8,3,0,27,5,3,1,5,6,8,3,0,72,3,0,43,6,4,0,43,9,7,235,3,1,2,3,0,62,5,3,0,62,5,3,0,16,1,new A([1],[],[],0),6,11,8,9,1,new A("RANK ERROR",[10],[1],0),3,0,61,5,8,9,3,1,2,3,0,13,5,4,1,4,9,3,1,0,7,46,3,2,0,3,0,62,5,3,0,62,5,3,0,14,1,new A([0],[],[],0),6,11,22,9,3,2,0,3,0,62,1,new A([1],[],[],0),3,0,62,3,1,4,3,0,62,5,6,6,8,9,3,2,0,8,5,4,1,0,9,3,1,0,3,0,62,5,3,0,62,5,3,0,17,3,1,4,3,0,62,5,6,11,8,9,1,new A("RANK ERROR",[10],[1],0),3,0,61,5,8,9,3,1,4,3,0,70,3,1,0,3,0,62,5,3,0,62,5,6,4,1,4,9,3,1,0,3,0,62,5,3,0,0,3,1,4,6,3,0,35,1,new A([0],[],[],0),6,3,0,3,1,new A([0],[],[],0),3,0,18,3,1,4,6,6,3,0,0,3,1,0,3,0,62,5,3,0,1,3,1,4,6,3,0,34,1,new A([0],[],[],0),6,3,0,3,1,new A([0],[],[],0),3,0,17,3,1,4,6,6,6,4,1,4,9,3,1,0,3,0,70,3,1,4,6,8,3,0,72,7,60,3,1,0,3,0,62,5,3,0,62,5,3,0,14,1,new A([0],[],[],0),6,11,5,9,3,1,0,8,9,3,1,0,3,1,0,3,0,62,5,3,0,62,5,3,0,0,1,new A([-1],[],[],0),6,2,1,1,new A([0],[1],[1],0),2,2,3,0,68,3,0,43,6,5,8,6,4,0,26,9,7,23,3,1,0,1,new A([0],[],[],0),2,1,1,new A([0],[1],[1],0),2,2,3,0,68,3,0,13,6,3,1,2,6,8,3,0,72,7,38,3,1,0,3,0,62,3,1,0,3,0,79,5,3,1,0,3,0,62,5,3,0,26,1,new A([1],[],[],0),6,3,0,3,3,0,65,5,5,2,2,6,8,6,4,0,76,9,7,4,3,1,0,8,4,0,77,9,7,4,3,1,2,8,3,0,72,7,3,1,new A([],[0],[1],0),8,6,4,0,78,9,7,15,3,1,0,3,0,20,3,1,2,6,3,0,44,5,8,3,0,72,7,21,1,new A([1],[],[],0),3,0,13,3,1,0,3,0,62,5,6,3,0,62,3,0,73,6,8,6,4,0,79,9,3,0,13,3,0,72,7,23,3,1,0,3,0,62,3,1,0,3,0,62,5,3,0,3,3,0,65,5,5,6,8,6,4,0,13,9,7,22,3,1,2,3,0,3,3,0,25,3,0,0,6,3,1,0,3,0,80,5,6,8,3,0,72,7,724,7,28,1,new A([0.5],[],[],0),3,0,5,3,2,0,3,0,0,5,3,0,3,3,0,25,3,0,0,6,3,2,0,6,6,8,4,1,4,9,7,290,1,new A([1],[],[],0),2,1,1,new A([0],[1],[1],0),2,2,3,0,68,3,2,0,3,0,62,5,6,4,2,4,9,3,2,4,3,0,19,1,new A([1],[],[],0),6,11,43,9,3,2,0,7,35,3,3,0,3,0,13,5,3,1,4,5,4,3,4,9,3,3,4,3,0,4,3,3,0,6,3,3,4,3,0,76,5,2,2,8,5,8,9,1,new A([2],[],[],0),3,0,4,3,2,4,6,3,0,35,5,4,2,5,9,3,2,0,3,0,70,3,2,5,3,0,13,3,2,0,3,0,62,5,3,0,70,1,new A([1],[],[],0),6,6,6,4,2,6,9,3,2,0,3,0,26,3,2,5,3,0,13,1,new A([0],[],[],0),6,6,4,2,7,9,3,2,6,3,2,1,5,10,2,4,2,8,9,4,2,9,9,9,3,2,7,3,0,3,3,0,25,3,0,0,6,3,2,8,3,0,71,5,3,0,0,5,6,4,2,10,9,3,2,10,3,0,3,3,0,25,3,0,0,6,3,2,8,6,3,0,1,3,2,7,6,3,2,1,5,10,2,4,2,11,9,4,2,12,9,9,3,2,11,3,0,13,3,2,8,6,3,2,12,3,0,70,3,2,4,3,0,1,5,3,0,13,1,new A([2],[],[],0),3,0,4,3,2,4,6,3,0,34,5,6,6,3,0,76,3,2,10,3,0,13,3,2,9,6,6,2,2,8,4,1,5,9,7,214,3,2,0,3,0,62,5,3,0,70,1,new A([1],[],[],0),6,4,2,4,3,0,14,1,new A([1],[],[],0),6,11,9,9,3,2,0,3,0,4,5,8,9,1,new A([2],[],[],0),3,0,4,3,2,4,6,3,0,35,5,4,2,5,9,3,2,0,3,0,70,3,2,5,3,0,13,3,2,5,6,6,3,2,1,5,4,2,6,9,3,2,0,3,0,26,3,2,5,3,0,13,3,2,5,6,6,3,2,1,5,4,2,7,9,3,2,0,3,0,70,3,2,4,3,0,1,3,2,5,6,3,0,13,3,2,5,6,6,4,2,8,9,3,2,7,3,0,3,3,0,25,3,0,0,6,3,2,8,6,3,0,3,3,0,25,3,0,0,6,3,2,6,6,3,0,1,5,4,2,9,9,3,2,7,3,0,70,3,2,4,3,0,1,5,3,0,13,1,new A([2],[],[],0),3,0,4,3,2,4,6,3,0,34,5,6,6,3,0,76,3,2,9,3,0,13,3,2,6,6,6,8,4,1,6,9,3,1,0,3,0,62,5,3,0,62,5,3,0,14,1,new A([0],[],[],0),6,11,9,9,3,1,0,3,0,4,5,8,9,3,1,0,3,0,62,5,3,0,62,5,3,0,14,1,new A([1],[],[],0),6,11,17,9,3,1,0,3,0,76,5,3,1,1,5,3,0,13,5,8,9,3,1,0,3,0,62,5,3,0,62,5,3,0,15,1,new A([2],[],[],0),6,11,8,9,1,new A("RANK ERROR",[10],[1],0),3,0,61,5,8,9,3,1,0,3,0,62,5,3,0,19,3,0,65,5,5,3,0,29,1,new A([0],[],[],0),6,11,8,9,1,new A("LENGTH ERROR",[12],[1],0),3,0,61,5,8,9,3,1,0,3,1,5,5,10,2,4,1,7,9,4,1,8,9,9,3,1,7,3,0,71,5,3,0,0,5,3,0,3,3,0,25,3,0,0,6,3,1,8,3,1,6,5,6,8,6,4,0,80,9,7,31,7,11,3,2,2,3,1,0,3,2,0,6,8,3,0,72,7,11,3,2,0,3,1,0,3,2,0,6,8,6,8,4,0,81,9,3,0,1,4,0,2,9,3,0,5,4,0,6,9,3,0,8,4,0,9,9,3,0,46,4,0,47,9,3,0,29,4,0,30,8],"nSlots":82,"vars":{"+":{"category":2,"slot":0,"scopeDepth":0},"-":{"category":2,"slot":1,"scopeDepth":0},"−":{"category":2,"slot":2,"scopeDepth":0},"×":{"category":2,"slot":3,"scopeDepth":0},"÷":{"category":2,"slot":4,"scopeDepth":0},"*":{"category":2,"slot":5,"scopeDepth":0},"⋆":{"category":2,"slot":6,"scopeDepth":0},"⍟":{"category":2,"slot":7,"scopeDepth":0},"|":{"category":2,"slot":8,"scopeDepth":0},"∣":{"category":2,"slot":9,"scopeDepth":0},"\\":{"category":3,"slot":10,"scopeDepth":0},"⍀":{"category":3,"slot":11,"scopeDepth":0},"○":{"category":2,"slot":12,"scopeDepth":0},",":{"category":2,"slot":13,"scopeDepth":0},"=":{"category":2,"slot":14,"scopeDepth":0},"≠":{"category":2,"slot":15,"scopeDepth":0},"<":{"category":2,"slot":16,"scopeDepth":0},">":{"category":2,"slot":17,"scopeDepth":0},"≤":{"category":2,"slot":18,"scopeDepth":0},"≥":{"category":2,"slot":19,"scopeDepth":0},"≡":{"category":2,"slot":20,"scopeDepth":0},"∘":{"category":4,"slot":21,"scopeDepth":0},"∪":{"category":2,"slot":22,"scopeDepth":0},"∩":{"category":2,"slot":23,"scopeDepth":0},"⊥":{"category":2,"slot":24,"scopeDepth":0},".":{"category":4,"slot":25,"scopeDepth":0},"↓":{"category":2,"slot":26,"scopeDepth":0},"¨":{"category":3,"slot":27,"scopeDepth":0},"⊤":{"category":2,"slot":28,"scopeDepth":0},"∊":{"category":2,"slot":29,"scopeDepth":0},"∈":{"category":2,"slot":30,"scopeDepth":0},"!":{"category":2,"slot":31,"scopeDepth":0},"⍎":{"category":2,"slot":32,"scopeDepth":0},"⍷":{"category":2,"slot":33,"scopeDepth":0},"⌊":{"category":2,"slot":34,"scopeDepth":0},"⌈":{"category":2,"slot":35,"scopeDepth":0},"_fork1":{"category":2,"slot":36,"scopeDepth":0},"_fork2":{"category":2,"slot":37,"scopeDepth":0},"⍕":{"category":2,"slot":38,"scopeDepth":0},"⍋":{"category":2,"slot":39,"scopeDepth":0},"⍒":{"category":2,"slot":40,"scopeDepth":0},"⍁":{"category":4,"slot":41,"scopeDepth":0},"⍳":{"category":2,"slot":42,"scopeDepth":0},"⊂":{"category":2,"slot":43,"scopeDepth":0},"~":{"category":2,"slot":44,"scopeDepth":0},"∨":{"category":2,"slot":45,"scopeDepth":0},"∧":{"category":2,"slot":46,"scopeDepth":0},"^":{"category":2,"slot":47,"scopeDepth":0},"⍱":{"category":2,"slot":48,"scopeDepth":0},"⍲":{"category":2,"slot":49,"scopeDepth":0},"⍣":{"category":4,"slot":50,"scopeDepth":0},"get_⎕":{"category":2,"slot":51,"scopeDepth":0},"⎕":{"category":1},"set_⎕":{"category":2,"slot":52,"scopeDepth":0},"get_⍞":{"category":2,"slot":53,"scopeDepth":0},"⍞":{"category":1},"set_⍞":{"category":2,"slot":54,"scopeDepth":0},"get_⎕IO":{"category":2,"slot":55,"scopeDepth":0},"⎕IO":{"category":1},"set_⎕IO":{"category":2,"slot":56,"scopeDepth":0},"⎕DL":{"category":2,"slot":57,"scopeDepth":0},"⎕RE":{"category":2,"slot":58,"scopeDepth":0},"⎕UCS":{"category":2,"slot":59,"scopeDepth":0},"?":{"category":2,"slot":60,"scopeDepth":0},"↗":{"category":2,"slot":61,"scopeDepth":0},"⍴":{"category":2,"slot":62,"scopeDepth":0},"⌽":{"category":2,"slot":63,"scopeDepth":0},"⊖":{"category":2,"slot":64,"scopeDepth":0},"/":{"category":3,"slot":65,"scopeDepth":0},"⌿":{"category":3,"slot":66,"scopeDepth":0},"⌷":{"category":2,"slot":67,"scopeDepth":0},"_index":{"category":2,"slot":68,"scopeDepth":0},"_substitute":{"category":2,"slot":69,"scopeDepth":0},"↑":{"category":2,"slot":70,"scopeDepth":0},"⍉":{"category":2,"slot":71,"scopeDepth":0},"⍠":{"category":4,"slot":72,"scopeDepth":0},"⍬":{"scopeDepth":0,"slot":73,"category":1},"_hook":{"scopeDepth":0,"slot":74,"category":4},"⊃":{"scopeDepth":0,"slot":75,"category":2},"⍪":{"scopeDepth":0,"slot":76,"category":2},"⊢":{"scopeDepth":0,"slot":77,"category":2},"⊣":{"scopeDepth":0,"slot":78,"category":2},"≢":{"scopeDepth":0,"slot":79,"category":2},"⌹":{"scopeDepth":0,"slot":80,"category":2},"⍨":{"scopeDepth":0,"slot":81,"category":3}}}, code = _ref3.code, nSlots = _ref3.nSlots, vars = _ref3.vars;
    env = [[]];
    for (k in vars) {
      v = vars[k];
      env[0][v.slot] = vocabulary[k];
    }
    vm({
      code: code,
      env: env
    });
    for (k in vars) {
      v = vars[k];
      vocabulary[k] = env[0][v.slot];
    }
    return {
      nSlots: nSlots,
      vars: vars,
      env: env
    };
  })();
  aplify = function(x) {
    var y;
    if (typeof x === 'string') {
      if (x.length === 1) {
        return A.scalar(x);
      } else {
        return new A(x);
      }
    } else if (typeof x === 'number') {
      return A.scalar(x);
    } else if (x instanceof Array) {
      return new A((function() {
        var _i, _len, _results;
        _results = [];
        for (_i = 0, _len = x.length; _i < _len; _i++) {
          y = x[_i];
          _results.push((y = aplify(y), y.shape.length ? y : y.unwrap()));
        }
        return _results;
      })());
    } else if (x instanceof A) {
      return x;
    } else {
      return aplError('Cannot aplify object ' + x);
    }
  };

  this.apl = apl = function(aplCode, opts) {
    return (apl.ws(opts))(aplCode);
  };

  extend(apl, {
    format: format,
    approx: approx,
    parse: parse,
    compileAST: compileAST,
    repr: repr
  });

  apl.ws = function(opts) {
    var ctx;
    if (opts == null) {
      opts = {};
    }
    ctx = Object.create(vocabulary);
    if (opts["in"]) {
      ctx['get_⎕'] = ctx['get_⍞'] = function() {
        var s;
        s = opts["in"]();
        if (!(typeof s === 'string')) {
          throw Error("\"if opts.in then ctx['get_⎕'] = ctx['get_⍞'] = -> s = opts.in(); assert typeof s is 'string'; new A s\" at /home/nick/gh/apl/src/apl.coffee:70");
        }
        return new A(s);
      };
    }
    if (opts.out) {
      ctx['set_⎕'] = ctx['set_⍞'] = function(x) {
        return opts.out(format(x).join('\n') + '\n');
      };
    }
    return function(aplCode) {
      return exec(aplCode, {
        ctx: ctx
      });
    };
  };

  readline = function(prompt, f) {
    var rl;
    (readline.requesters != null ? readline.requesters : readline.requesters = []).push(f);
    if (!(rl = readline.rl)) {
      rl = readline.rl = require('readline').createInterface(process.stdin, process.stdout);
      rl.on('line', function(line) {
        var _base1;
        return typeof (_base1 = readline.requesters.pop()) === "function" ? _base1(line) : void 0;
      });
      rl.on('close', function() {
        process.stdout.write('\n');
        return process.exit(0);
      });
    }
    rl.setPrompt(prompt);
    return rl.prompt();
  };

  if (typeof module !== "undefined" && module !== null) {
    module.exports = apl;
    if (module === (typeof require !== "undefined" && require !== null ? require.main : void 0)) {
      (function() {
        var arg, b, f, file, k, usage, ws, _i, _len, _ref3;
        usage = 'Usage: apl.js filename.apl\n';
        file = null;
        _ref3 = process.argv.slice(2);
        for (_i = 0, _len = _ref3.length; _i < _len; _i++) {
          arg = _ref3[_i];
          if (arg === '-h' || arg === '--help') {
            process.stderr.write(usage);
            process.exit(0);
          } else if (/^-/.test(arg)) {
            process.stderr.write("unrecognized option: " + arg + "\n" + usage);
            process.exit(1);
          } else if (file != null) {
            process.stderr.write(usage);
            process.exit(1);
          } else {
            file = arg;
          }
        }
        if (file != null) {
          exec(require('fs').readFileSync(file, 'utf8'));
        } else if (!require('tty').isatty()) {
          exec(Buffer.concat((function() {
            var _results;
            _results = [];
            while (true) {
              b = new Buffer(1024);
              if (!(k = require('fs').readSync(0, b, 0, b.length, null))) {
                break;
              }
              _results.push(b.slice(0, k));
            }
            return _results;
          })()).toString('utf8'));
        } else {
          ws = apl.ws();
          readline('      ', f = function(line) {
            var e;
            try {
              if (!line.match(/^[\ \t\f\r\n]*$/)) {
                process.stdout.write(format(ws(line)).join('\n') + '\n');
              }
            } catch (_error) {
              e = _error;
              process.stdout.write(e + '\n');
            }
            readline('      ', f);
          });
        }
      })();
    }
  }

}).call(this);