1.patch

From f26e6ec81a999b09c626e5138f04b59abb1f5025 Mon Sep 17 00:00:00 2001
From: Alexey Kudinkin <alexey.kudinkin@gmail.com>
Date: Tue, 9 Dec 2014 04:27:17 +0300
Subject: [PATCH 01/12] First scratches FFT

---
 lib/bn.js | 269 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 266 insertions(+), 3 deletions(-)

diff --git a/lib/bn.js b/lib/bn.js
index 2e990f6..9b9b857 100644
--- a/lib/bn.js
+++ b/lib/bn.js
@@ -883,15 +883,270 @@ BN.prototype._bigMulTo = function _bigMulTo(num, out) {
   return out.strip();
 };
 
+
+function Complex(r, i) {
+  this.r = r;
+  this.i = i;
+
+  //this._norm();
+}
+
+// private
+function _iaddC(rhs) {
+  this.r += rhs.r;
+  this.i += rhs.i;
+
+  //this._norm();
+
+  return this;
+}
+
+function _addC(rhs) {
+  var t = new Complex(this.r, this.i);
+  t.iadd(rhs);
+  return t;
+}
+
+function _isubC(rhs) {
+  this.r -= rhs.r;
+  this.i -= rhs.i
+
+  //this._norm();
+
+  return this;
+}
+
+function _subC(rhs) {
+  var t = new Complex(this.r, this.i);
+  t.isub(rhs);
+  return t;
+}
+
+function _iconjC() {
+  this.i *= -1;
+  return this;
+}
+
+function _imulC(rhs) {
+  var r = this.r * rhs.r - this.i * rhs.i,
+      i = this.r * rhs.i + this.i * rhs.r;
+
+  this.r = r;
+  this.i = i;
+
+  //this._norm();
+
+  return this;
+}
+
+function _mulC(rhs) {
+  var t = new Complex(this.r, this.i);
+  t.imul(rhs);
+  return t;
+}
+
+function _cloneC() {
+  return new Complex(this.r, this.i);
+}
+
+Complex.prototype.mul   = _mulC;
+Complex.prototype.imul  = _imulC;
+Complex.prototype.add   = _addC;
+Complex.prototype.iadd  = _iaddC;
+Complex.prototype.sub   = _subC;
+Complex.prototype.isub  = _isubC;
+Complex.prototype.iconj = _iconjC;
+Complex.prototype.clone = _cloneC;
+
+Complex.prototype._isZero = function (v) {
+  return Math.abs(v) < 1.e-12;
+}
+
+Complex.prototype._norm = function () {
+  //if (this._isZero(this.r)) this.r = 0;
+  //if (this._isZero(this.i)) this.i = 0;
+}
+
+Complex.ZERO = new Complex(0, 0);
+
+// _FFT(this.words, thisWFT, w, N, 0);
+function _FFT(ws, p, s, tws, tp, r, N) {
+  if (N === 1) {
+    tws[tp] = ws[p];
+    //console.log("p/tp/ws/tws :", p, tp, ws, tws);
+  } else {
+    var hN = N / 2 >> 0;
+
+    var rr = r.mul(r);
+
+    var s_ = 2 * s + 1;
+
+    //console.log("-- FFT -- # ", N);
+    //console.log("-- R -- ", r);
+
+    //console.log("-- RR -- # ", rr);
+
+    _FFT(ws, p,         s_, tws, tp,      rr, hN);  // even
+    _FFT(ws, p + s + 1, s_, tws, tp + hN, rr, hN);  // odd
+
+    var r_ = r.clone();
+
+    for (var i = 0; i < hN; ++i) {
+      var e = tws[tp + i];
+      var o = tws[tp + i + hN].clone();
+
+      //console.log("tp + i, tp + i + hN, tws | ", tp + i, tp + i + hN, tws)
+      //console.log("r_, o, e, (o * r_)", r_, o, e, o.mul(r_));
+
+      o.imul(r_);
+
+      tws[tp + i]      = e.add(o);
+      tws[tp + i + hN] = e.sub(o);
+
+      r_.imul(r);
+
+      //console.log("tws | ", tws)
+    }
+  }
+}
+
+var π = 3.14159265359;
+
+function _guess(n, m) {
+  var N = (n < m ? n : m) | 1, odd = N & 1;
+  var i = 0;
+  for (; N; N = N / 2 >> 0) {
+    i++;
+  }
+
+  return (1 << i + odd)
+}
+
+function _iconjugate(ws, N) {
+  if (N > 1) {
+    for (var i = 0; i < N / 2; ++i) {
+      var t = ws[i];
+      ws[i] = ws[N - i - 1];
+      ws[N - i - 1] = t;
+
+      ws[i].i         *= -1;
+      ws[N - i - 1].i *= -1;
+    }
+  }
+
+  return ws;
+}
+
+function _inormalize(ws, N) {
+  var carry = 0;
+  for (var i = 0; i < N / 2; ++i) {
+
+    //var n = (((ws[2 * i + 1].r  / N + .5) >> 0) << 13)
+    //      +  ((ws[2 * i].r      / N + .5) >> 0)
+    //      +  carry;
+
+    //if ((Math.round(ws[2 * i + 1].r  / N) << 13) !== (Math.round(ws[2 * i + 1].r  / N) * 0x2000)) {
+    //  console.log(1 << 13, 1 * 0x2000);
+    //  console.log(Math.round(ws[2 * i + 1].r  / N), ((Math.round(ws[2 * i + 1].r  / N)) << 7), (Math.round(ws[2 * i + 1].r  / N) * 0x2000));
+    //  assert((Math.round(ws[2 * i + 1].r / N) << 13) === (Math.round(ws[2 * i + 1].r / N) * 0x2000), "WAAAAAT");
+    //}
+
+
+    //assert(Math.abs(ws[2 * i].i) < N && Math.abs(ws[2 * i + 1].i) < N)
+
+    var n = (Math.round(ws[2 * i + 1].r  / N) * 0x2000)
+          +  Math.round(ws[2 * i].r      / N)
+          +  carry;
+
+    //console.log(
+    //    n.toString(16),
+    //    carry.toString(16),
+    //    (n & 0x3ffffff).toString(16)
+    //  );
+
+    ws[i] = n & 0x3ffffff;
+
+    if (n < 0x4000000) {
+      carry = 0;
+    } else {
+      carry = Math.floor(n / 0x4000000);
+    }
+  }
+
+  return ws;
+}
+
+function _iconvertToC(ws, N) {
+  var cws = new Array(N);
+  for (var i = 0; i < N / 2; i++) {
+    var w = ws[i] || 0;
+
+    cws[2 * i]      = new Complex(w & 0x1fff, 0);
+    cws[2 * i + 1]  = new Complex(w >>> 13,   0);
+  }
+  return cws;
+}
+
 BN.prototype.mulTo = function mulTo(num, out) {
   var res;
-  if (this.length + num.length < 63)
-    res = this._smallMulTo(num, out);
-  else
+  //if (this.length + num.length < 63)
+  //  res = this._smallMulTo(num, out);
+  //else
     res = this._bigMulTo(num, out);
+  //  res = this._bigMulToF(num, out);
   return res;
 };
 
+BN.prototype.mulToF = function mulToF(num, out) {
+  var res;
+  //if (this.length + num.length < 63)
+  //  res = this._smallMulTo(num, out);
+  //else
+    res = this._bigMulToF(num, out);
+  return res;
+};
+
+BN.prototype._bigMulToF = function _bigMulToF(num, out) {
+  out.sign = num.sign !== this.sign;
+  out.length = this.length + num.length;
+
+  var N = 2 * _guess(this.length, num.length);
+
+  var w = new Complex(Math.cos(2 * π / N), Math.sin(2 * π / N));
+
+  //console.log("-- W -- ", w);
+
+  var thisWFT  = new Array(N),
+      numWFT   = new Array(N),
+      //multWFT  = new Array(N),
+      multW    = new Array(N);
+
+  //console.log("A, B: ", this, num);
+
+  _FFT(_iconvertToC(this.words, N), 0, 0, thisWFT, 0, w, N);
+  _FFT(_iconvertToC(num.words,  N), 0, 0, numWFT,  0, w, N);
+
+  for (var i = 0; i < N; ++i) {
+    //multWFT[i] = thisWFT[i].mul(numWFT[i]);
+    thisWFT[i].imul(numWFT[i]);
+  }
+
+  //console.log("-- MULF -- ", multWFT);
+
+  //_FFT(_iconjugate(multWFT, N), 0, 0, multW, 0, w, N);
+  _FFT(_iconjugate(thisWFT, N), 0, 0, multW, 0, w, N);
+
+  //console.log(multW);
+
+  multW = _inormalize(_iconjugate(multW, N), N);
+
+  out.words = multW;
+
+  //console.log("-- MUL -- ", multW);
+
+  return out.strip();
+};
+
 // Multiply `this` by `num`
 BN.prototype.mul = function mul(num) {
   var out = new BN(null);
@@ -899,6 +1154,14 @@ BN.prototype.mul = function mul(num) {
   return this.mulTo(num, out);
 };
 
+// Multiply employing FFT
+BN.prototype.mulf = function mulf(num) {
+  var out = new BN(null);
+  //out.words = new Array(this.length + num.length);
+  out.words = null;
+  return this.mulToF(num, out);
+};
+
 // In-place Multiplication
 BN.prototype.imul = function imul(num) {
   if (this.cmpn(0) === 0 || num.cmpn(0) === 0) {

From 21f40777824dfdc61c93a009e82c25c30d0615ed Mon Sep 17 00:00:00 2001
From: Alexey Kudinkin <alexey.kudinkin@gmail.com>
Date: Fri, 12 Dec 2014 00:25:08 +0300
Subject: [PATCH 02/12] Continuous probing

---
 benchmarks/index.js |  78 +++++++++++
 lib/bn.js           | 378 ++++++++++++++++++++++++++++++++++++++++++++++++++--
 test/_fft.js        |  43 ++++++
 3 files changed, 486 insertions(+), 13 deletions(-)
 create mode 100644 test/_fft.js

diff --git a/benchmarks/index.js b/benchmarks/index.js
index b8cb23d..64b61d9 100644
--- a/benchmarks/index.js
+++ b/benchmarks/index.js
@@ -59,6 +59,72 @@ if (/fast/i.test(process.argv[3])) {
 var a1 = new bn('012345678901234567890123456789012345678901234567890', 10);
 var b1 = new bn('213509123601923760129376102397651203958123402314875', 10);
 
+var a1x = new bn( 'a899c59999bf877d96442d284359783bdc64b5f878b688fe' +
+                  '51407f0526e616553ad0aaaac4d5bed3046f10a1faaf42bb' +
+                  '2342dc4b7908eea0c46e4c4576897675c2bfdc4467870d3d' +
+                  'cd90adaed4359237a4bc6924bfb99aa6bf5f5ede15b574ea' +
+                  'e977eac096f3c67d09bda574c6306c6123fa89d2f086b8dc' +
+                  'ff92bc570c18d83fe6c810ccfd22ce4c749ef5e6ead3fffe' +
+                  'c63d95e0e3fde1df9db6a35fa1d107058f37e41957769199' +
+                  'd945dd7a373622c65f0af3fd9eb1ddc5c764bbfaf7a3dc37' +
+                  '2548e683b970dac4aa4b9869080d2376c9adecebb84e172c' +
+                  '09aeeb25fb8df23e60033260c4f8aac6b8b98ab894b1fb84' +
+                  'ebb83c0fb2081c3f3eee07f44e24d8fabf76f19ed167b0d7' +
+                  'ff971565aa4efa3625fce5a43ceeaa3eebb3ce88a00f597f' +
+                  '048c69292b38dba2103ecdd5ec4ccfe3b2d87fa6202f334b' +
+                  'c1cab83b608dfc875b650b69f2c7e23c0b2b4adf149a6100' +
+                  'db1b6dbad4679ecb1ea95eafaba3bd00db11c2134f5a8686' +
+                  '358b8b2ab49a1b2e85e1e45caeac5cd4dc0b3b5fffba8871' +
+                  '1c6baf399edd48dad5e5c313702737a6dbdcede80ca358e5' +
+                  '1d1c4fe42e8948a084403f61baed38aa9a1a5ce2918e9f33' +
+                  '100050a430b47bc592995606440272a4994677577a6aaa1b' +
+                  'a101045dbec5a4e9566dab5445d1af3ed19519f07ac4e2a8' +
+                  'bd0a84b01978f203a9125a0be020f71fab56c2c9e344d4f4' +
+                  '12d53d3cd8eb74ca5122002e931e3cb0bd4b7492436be17a' +
+                  'd7ebe27148671f59432c36d8c56eb762655711cfc8471f70' +
+                  '83a8b7283bcb3b1b1d47d37c23d030288cfcef05fbdb4e16' +
+                  '652ee03ee7b77056a808cd700bc3d9ef826eca9a59be959c' +
+                  '947c865d6b372a1ca2d503d7df6d7611b12111665438475a' +
+                  '1c64145849b3da8c2d343410df892d958db232617f9896f1' +
+                  'de95b8b5a47132be80dd65298c7f2047858409bf762dbc05' +
+                  'a62ca392ac40cfb8201a0607a2cae07d99a307625f2b2d04' +
+                  'fe83fbd3ab53602263410f143b73d5b46fc761882e78c782' +
+                  'd2c36e716a770a7aefaf7f76cea872db7bffefdbc4c2f9e0' +
+                  '39c19adac915e7a63dcb8c8c78c113f29a3e0bc10e100ce0', 16);
+
+var b1x = new bn( '3bf836229c7dd874fe37c1790d201e82ed8e192ed61571ca' +
+                  '7285264974eb2a0171f3747b2fc23969a916cbd21e14f7e2' +
+                  'f0d72dcd2247affba926f9e7bb99944cb5609aed85e71b89' +
+                  'e89d2651550cb5bd8281bd3144066af78f194032aa777739' +
+                  'cccb7862a1af401f99f7e5c693f25ddce2dedd9686633820' +
+                  'd28d0f5ed0c6b5a094f5fe6170b8e2cbc9dff118398baee6' +
+                  'e895a6301cb6e881b3cae749a5bdf5c56fc897ff68bc73f2' +
+                  '4811bb108b882872bade1f147d886a415cda2b93dd90190c' +
+                  'be5c2dd53fe78add5960e97f58ff2506afe437f4cf4c912a' +
+                  '397c1a2139ac6207d3ab76e6b7ffd23bb6866dd7f87a9ae5' +
+                  '578789084ff2d06ea0d30156d7a10496e8ebe094f5703539' +
+                  '730f5fdbebc066de417be82c99c7da59953071f49da7878d' +
+                  'a588775ff2a7f0084de390f009f372af75cdeba292b08ea8' +
+                  '4bd13a87e1ca678f9ad148145f7cef3620d69a891be46fbb' +
+                  'cad858e2401ec0fd72abdea2f643e6d0197b7646fbb83220' +
+                  '0f4cf7a7f6a7559f9fb0d0f1680822af9dbd8dec4cd1b5e1' +
+                  '7bc799e902d9fe746ddf41da3b7020350d3600347398999a' +
+                  'baf75d53e03ad2ee17de8a2032f1008c6c2e6618b62f225b' +
+                  'a2f350179445debe68500fcbb6cae970a9920e321b468b74' +
+                  '5fb524fb88abbcacdca121d737c44d30724227a99745c209' +
+                  'b970d1ff93bbc9f28b01b4e714d6c9cbd9ea032d4e964d8e' +
+                  '8fff01db095160c20b7646d9fcd314c4bc11bcc232aeccc0' +
+                  'fbedccbc786951025597522eef283e3f56b44561a0765783' +
+                  '420128638c257e54b972a76e4261892d81222b3e2039c61a' +
+                  'ab8408fcaac3d634f848ab3ee65ea1bd13c6cd75d2e78060' +
+                  'e13cf67fbef8de66d2049e26c0541c679fff3e6afc290efe' +
+                  '875c213df9678e4a7ec484bc87dae5f0a1c26d7583e38941' +
+                  'b7c68b004d4df8b004b666f9448aac1cc3ea21461f41ea5d' +
+                  'd0f7a9e6161cfe0f58bcfd304bdc11d78c2e9d542e86c0b5' +
+                  '6985cc83f693f686eaac17411a8247bf62f5ccc7782349b5' +
+                  'cc1f20e312fa2acc0197154d1bfee507e8db77e8f2732f2d' +
+                  '641440ccf248e8643b2bd1e1f9e8239356ab91098fcb431d', 16);
+
 var a2 = new bignum('012345678901234567890123456789012345678901234567890', 10);
 var b2 = new bignum('213509123601923760129376102397651203958123402314875', 10);
 
@@ -205,6 +271,9 @@ add('mul', {
   'bn.js': function() {
     a1.mul(b1);
   },
+  'bn.js[FFT]': function() {
+    a1.mulf(b1);
+  }
   'bignum': function() {
     a2.mul(b2);
   },
@@ -222,6 +291,15 @@ add('mul', {
   }
 });
 
+add('mul-jumbo', {
+  'bn.js': function() {
+    a1x.mul(b1x);
+  },
+  'bn.js[FFT]': function() {
+    a1x.mulf(b1x);
+  }
+});
+
 add('sqr', {
   'bn.js': function() {
     a1.mul(a1);
diff --git a/lib/bn.js b/lib/bn.js
index 9b9b857..c803573 100644
--- a/lib/bn.js
+++ b/lib/bn.js
@@ -958,16 +958,14 @@ Complex.prototype.isub  = _isubC;
 Complex.prototype.iconj = _iconjC;
 Complex.prototype.clone = _cloneC;
 
-Complex.prototype._isZero = function (v) {
-  return Math.abs(v) < 1.e-12;
-}
+//Complex.prototype._isZero = function (v) {
+//  return Math.abs(v) < 1.e-12;
+//}
 
-Complex.prototype._norm = function () {
+//Complex.prototype._norm = function () {
   //if (this._isZero(this.r)) this.r = 0;
   //if (this._isZero(this.i)) this.i = 0;
-}
-
-Complex.ZERO = new Complex(0, 0);
+//}
 
 // _FFT(this.words, thisWFT, w, N, 0);
 function _FFT(ws, p, s, tws, tp, r, N) {
@@ -1003,6 +1001,11 @@ function _FFT(ws, p, s, tws, tp, r, N) {
       tws[tp + i]      = e.add(o);
       tws[tp + i + hN] = e.sub(o);
 
+      //console.log(tws);
+
+      assert(tws[tp + i].r < (0x4000000 * 0x4000000 * 2))
+      assert(tws[tp + i + hN].r < (0x4000000 * 0x4000000 * 2))
+
       r_.imul(r);
 
       //console.log("tws | ", tws)
@@ -1010,6 +1013,63 @@ function _FFT(ws, p, s, tws, tp, r, N) {
   }
 }
 
+
+function _FFTL(ws, p, s, tws, tp, r, N) {
+  //if (N === 1) {
+  //  tws[tp] = ws[p];
+  //  //console.log("p/tp/ws/tws :", p, tp, ws, tws);
+  //} else {
+  //  var hN = N / 2 >> 0;
+  //
+  //  var rr = r.mul(r);
+  //
+  //  var s_ = 2 * s + 1;
+  //
+  //  //console.log("-- FFT -- # ", N);
+  //  //console.log("-- R -- ", r);
+  //
+  //  //console.log("-- RR -- # ", rr);
+  //
+  //  _FFT(ws, p,         s_, tws, tp,      rr, hN);  // even
+  //  _FFT(ws, p + s + 1, s_, tws, tp + hN, rr, hN);  // odd
+  //
+  //  var r_ = r.clone();
+  //
+  //  for (var i = 0; i < hN; ++i) {
+  //    var e = tws[tp + i];
+  //    var o = tws[tp + i + hN].clone();
+  //
+  //    //console.log("tp + i, tp + i + hN, tws | ", tp + i, tp + i + hN, tws)
+  //    //console.log("r_, o, e, (o * r_)", r_, o, e, o.mul(r_));
+  //
+  //    o.imul(r_);
+  //
+  //    tws[tp + i]      = e.add(o);
+  //    tws[tp + i + hN] = e.sub(o);
+  //
+  //    r_.imul(r);
+  //
+  //    //console.log("tws | ", tws)
+  //  }
+  //}
+
+  var hN = N / 2 >> 0;
+
+  for (var i = 0; i < hN; i++) {
+    tws[2 * i]      = ws[i];
+    tws[2 * i + 1]  = ws[i + hN];
+  }
+
+  var p = 0;
+
+  for (var l = 1; l < N + 1; l << 1, p = 0) {
+    for (var j = p; j < p + l; ++j, p += l) {
+      var e = tws[j];
+      var o = tws[j + l].clone();
+    }
+  }
+}
+
 var π = 3.14159265359;
 
 function _guess(n, m) {
@@ -1037,7 +1097,7 @@ function _iconjugate(ws, N) {
   return ws;
 }
 
-function _inormalize(ws, N) {
+function _inormalize13(ws, N) {
   var carry = 0;
   for (var i = 0; i < N / 2; ++i) {
 
@@ -1051,8 +1111,11 @@ function _inormalize(ws, N) {
     //  assert((Math.round(ws[2 * i + 1].r / N) << 13) === (Math.round(ws[2 * i + 1].r / N) * 0x2000), "WAAAAAT");
     //}
 
-
     //assert(Math.abs(ws[2 * i].i) < N && Math.abs(ws[2 * i + 1].i) < N)
+    //
+    //var n = (Math.round(ws[2 * i + 1].r  / N) * 0x2000)
+    //      +  Math.round(ws[2 * i].r      / N)
+    //      +  carry;
 
     var n = (Math.round(ws[2 * i + 1].r  / N) * 0x2000)
           +  Math.round(ws[2 * i].r      / N)
@@ -1076,7 +1139,170 @@ function _inormalize(ws, N) {
   return ws;
 }
 
-function _iconvertToC(ws, N) {
+function _inormalize20(ws, N) {
+
+  var carry = 0;
+  var seek = 0;
+
+  for (var j = 0; j < N; ++j) {
+    ws[j] = Math.round(ws[j].r / N);
+  }
+
+  for (var i = 0; i < N; ++i) {
+    //var w = (((ws[2 * i + 1].r  / N + .5) >> 0) << 13)
+    //      +  ((ws[2 * i].r      / N + .5) >> 0)
+    //      +  carry;
+
+    //if ((Math.round(ws[2 * i + 1].r  / N) << 13) !== (Math.round(ws[2 * i + 1].r  / N) * 0x2000)) {
+    //  console.log(1 << 13, 1 * 0x2000);
+    //  console.log(Math.round(ws[2 * i + 1].r  / N), ((Math.round(ws[2 * i + 1].r  / N)) << 7), (Math.round(ws[2 * i + 1].r  / N) * 0x2000));
+    //  assert((Math.round(ws[2 * i + 1].r / N) << 13) === (Math.round(ws[2 * i + 1].r / N) * 0x2000), "WAAAAAT");
+    //}
+
+    //assert(Math.abs(ws[2 * i].i) < N && Math.abs(ws[2 * i + 1].i) < N)
+
+    //var w = ws[i];
+    //
+    //assert(w < (0x4000000 * 0x4000000))
+    //
+    //console.log("Before ", w, w & 0x3ffffff, carry);
+    //
+    //if (i + 1 < N) {
+    //  w += ((ws[i + 1] + 0.5) & 0x3ffffff) * 0x100000;
+    //
+    //  ws[i + 1] &= 0x4000000;
+    //}
+    //
+    //w += carry;
+    //
+    //ws[i] = w & 0x3ffffff;
+    //
+    //carry = Math.floor(w / 0x4000000);
+    //
+    //console.log("After ", w, w & 0x3ffffff, carry);
+
+    var w = ws[i];
+
+    //console.log(w, carry, (w & 0x3ffffff));
+
+    var j = i;
+
+    //if (w < 0x4000000)
+    {
+      var pseek = seek;
+      seek += 26 - 20;
+
+      if (seek > 20) {
+        if (i < N - 1) {
+          w += ws[i + 1] * 0x100000 / (1 << pseek)
+
+          // !!!
+          ++i;
+
+          seek -= 20;
+
+          var d = 1 << seek;
+
+          w += (ws[i + 1] & (d - 1)) * (1 << 26 - seek);
+          ws[i + 1] /= d;
+        }
+      }
+      else
+      {
+        var pd  = 1 << (pseek);
+        var d   = 1 << (seek);
+
+        //console.log("D, W, WS[i+1]x ", d, w, (ws[i + 1] & (d - 1)) * 0x100000 / pd)
+
+        w += (ws[i + 1] & (d - 1)) * 0x100000 / pd;
+        ws[i + 1] /= d;
+      }
+    }
+
+    //console.log(w, w & 0x3ffffff, carry)
+
+    assert(w      < 0x4000000 * 0x4000000)
+    assert(carry  < 0x4000000 * 0x4000000)
+
+    w += carry;
+
+    //console.log(w, w & 0x3ffffff, carry)
+
+    ws[j] = w & 0x3ffffff;
+
+    carry = Math.floor(w / 0x4000000);
+  }
+
+  return ws;
+}
+
+function _inormalize18(ws, N) {
+
+  var carry = 0;
+  var seek = 0;
+
+  for (var j = 0; j < N; ++j) {
+    ws[j] = Math.round(ws[j].r / N);
+  }
+
+  for (var i = 0; i < N; ++i) {
+    var w = ws[i];
+
+    //console.log(w, carry, (w & 0x3ffffff));
+
+    var j = i;
+
+    //if (w < 0x4000000)
+    {
+      var pseek = seek;
+      seek += 26 - 18;
+
+      if (seek > 18) {
+        if (i < N - 1) {
+          w += ws[i + 1] * 0x40000 / (1 << pseek)
+
+          // !!!
+          ++i;
+
+          seek -= 18;
+
+          var d = 1 << seek;
+
+          w += (ws[i + 1] & (d - 1)) * (1 << 26 - seek);
+          ws[i + 1] /= d;
+        }
+      }
+      else
+      {
+        var pd  = 1 << (pseek);
+        var d   = 1 << (seek);
+
+        //console.log("D, W, WS[i+1]x ", d, w, (ws[i + 1] & (d - 1)) * 0x100000 / pd)
+
+        w += (ws[i + 1] & (d - 1)) * 0x40000 / pd;
+        ws[i + 1] /= d;
+      }
+    }
+
+    //console.log(w, w & 0x3ffffff, carry)
+
+    assert(w      < 0x4000000 * 0x4000000)
+    assert(carry  < 0x4000000 * 0x4000000)
+
+    w += carry;
+
+    //console.log(w, w & 0x3ffffff, carry)
+
+    ws[j] = w & 0x3ffffff;
+
+    carry = Math.floor(w / 0x4000000);
+  }
+
+  return ws;
+}
+
+
+function _iconvertToC13(ws, N) {
   var cws = new Array(N);
   for (var i = 0; i < N / 2; i++) {
     var w = ws[i] || 0;
@@ -1087,6 +1313,125 @@ function _iconvertToC(ws, N) {
   return cws;
 }
 
+function _iconvertToC20(ws, N) {
+  var cws = new Array(N);
+
+  for (var i = 0, j = 0, seek = 20; i < N; ++i) {
+    var w = ws[i] || 0;
+    var l = 26;
+
+    while (l > 0) {
+      cws[j] = cws[j] || 0;
+
+      if (seek >= l) {
+        cws[j] += w << (20 - seek);
+
+        seek -= l;
+        if (seek === 0) seek = 20;
+        l = 0;
+      } else {
+        cws[j] += (w & ((1 << seek) - 1)) << (20 - seek);
+        w /= 1 << seek;
+
+        ++j;
+        l -= seek;
+        seek = 20;
+      }
+    }
+  }
+
+  for (i = 0; i < N; ++i) {
+    cws[i] = new Complex(cws[i], 0);
+  }
+
+  return cws;
+}
+
+function _iconvertToC18(ws, N) {
+  var cws = new Array(N);
+
+  for (var i = 0, j = 0, seek = 18; i < N; ++i) {
+    var w = ws[i] || 0;
+    var l = 26;
+
+    while (l > 0) {
+      cws[j] = cws[j] || 0;
+
+      if (seek >= l) {
+        cws[j] += w << (18 - seek);
+
+        seek -= l;
+        if (seek === 0) seek = 18;
+        l = 0;
+      } else {
+        cws[j] += (w & ((1 << seek) - 1)) << (18 - seek);
+        w /= 1 << seek;
+
+        ++j;
+        l -= seek;
+        seek = 18;
+      }
+    }
+  }
+
+  for (i = 0; i < N; ++i) {
+    cws[i] = new Complex(cws[i], 0);
+  }
+
+  return cws;
+}
+
+function _iconvertTo13(ws, N) {
+  var cws = new Array(N);
+  var carry = 0;
+
+  var i = 0;
+  for (i = 0; i < N; ++i) {
+    ws[i] = Math.round(ws[i].r / N);
+  }
+
+  i = 0;
+  for (var j = 0; true; ++j) {
+
+    if (carry < 0x2000) {
+      if (i === N)
+        break;
+
+      carry += ws[i];
+      i++;
+    }
+
+    var lo = carry & 0x1fff;  // Here we don't care about overflow, since
+                              // since overflow may only "screw" (trim) high-order
+                              // bits, while we're particularly interested in low-order ones
+
+    //console.log(carry, lo)
+
+    carry = carry / 0x2000;   // Since shift would trigger conversion from
+                              // float (64) to int (32)
+
+    cws[j] = lo;
+  }
+
+  //for (var i = 0; i < N; i++) {
+  //  carry += Math.round(ws[i].r / N);
+  //
+  //
+  //  var lo = carry & 0x1fff;  // Here we don't care about overflow, since
+  //                            // since overflow may only "screw" (trim) high-order
+  //                            // bits, while we're particularly interested in low-order ones
+  //
+  //  console.log(carry, lo)
+  //
+  //  carry = carry / 0x2000;   // Since shift would trigger conversion from
+  //                            // float (64) to int (32)
+  //
+  //  cws[i] = lo;
+  //}
+
+  return cws;
+}
+
 BN.prototype.mulTo = function mulTo(num, out) {
   var res;
   //if (this.length + num.length < 63)
@@ -1111,6 +1456,7 @@ BN.prototype._bigMulToF = function _bigMulToF(num, out) {
   out.length = this.length + num.length;
 
   var N = 2 * _guess(this.length, num.length);
+  //var N = _guess(this.length * 1.3, num.length * 1.3);
 
   var w = new Complex(Math.cos(2 * π / N), Math.sin(2 * π / N));
 
@@ -1123,8 +1469,12 @@ BN.prototype._bigMulToF = function _bigMulToF(num, out) {
 
   //console.log("A, B: ", this, num);
 
-  _FFT(_iconvertToC(this.words, N), 0, 0, thisWFT, 0, w, N);
-  _FFT(_iconvertToC(num.words,  N), 0, 0, numWFT,  0, w, N);
+  _FFT(_iconvertToC13(this.words, N), 0, 0, thisWFT, 0, w, N);
+  _FFT(_iconvertToC13(num.words,  N), 0, 0, numWFT,  0, w, N);
+  //_FFT(_iconvertToC20(this.words, N), 0, 0, thisWFT, 0, w, N);
+  //_FFT(_iconvertToC20(num.words,  N), 0, 0, numWFT,  0, w, N);
+  //_FFT(_iconvertToC18(this.words, N), 0, 0, thisWFT, 0, w, N);
+  //_FFT(_iconvertToC18(num.words,  N), 0, 0, numWFT,  0, w, N);
 
   for (var i = 0; i < N; ++i) {
     //multWFT[i] = thisWFT[i].mul(numWFT[i]);
@@ -1138,7 +1488,9 @@ BN.prototype._bigMulToF = function _bigMulToF(num, out) {
 
   //console.log(multW);
 
-  multW = _inormalize(_iconjugate(multW, N), N);
+  multW = _inormalize13(_iconjugate(multW, N), N);
+  //multW = _inormalize20(_iconjugate(multW, N), N);
+  //multW = _inormalize18(_iconjugate(multW, N), N);
 
   out.words = multW;
 
diff --git a/test/_fft.js b/test/_fft.js
new file mode 100644
index 0000000..78c5233
--- /dev/null
+++ b/test/_fft.js
@@ -0,0 +1,43 @@
+var BN = require("../lib/bn.js").BN
+var fixtures = require("./fixtures.js")
+
+//var a = new BN("1");
+//var b = new BN("1");
+
+//var a = new BN("123");
+//var b = new BN("123");
+
+//var a = new BN("123456");
+//var b = new BN("123456");
+
+//var a = new BN("12345690");
+//var b = new BN("1234560");
+
+//var a = new BN("123456900");
+//var b = new BN("12345601");
+
+//var a = new BN("123456789");
+//var b = new BN("123456780");
+
+//var a = new BN("123456789");
+//var b = new BN("123456789");
+
+//var a = new BN(
+//                '13f29a3e0bc10e100ce0', 16);
+//var b = a.clone();
+
+
+var a = new BN(fixtures.dhGroups.p17.q, 16);
+var b = a.clone();
+var qs = fixtures.dhGroups.p17.qs;
+
+var c   = a.mulf(b);
+var c_  = a.mul(b);
+
+//console.log(c.words);
+console.log(c);
+console.log("------")
+//console.log(c_.words);
+console.log(c_);
+
+//assert(c === new BN(2))

From 47297ab0ccfc9e66b37dd53a86b7fcb09c17db63 Mon Sep 17 00:00:00 2001
From: Alexey Kudinkin <alexey.kudinkin@gmail.com>
Date: Sun, 14 Dec 2014 19:51:28 +0300
Subject: [PATCH 03/12] Unrolled recursion

---
 lib/bn.js    | 141 +++++++++++++++++++++++++++++++++++------------------------
 test/_fft.js |  10 ++++-
 2 files changed, 93 insertions(+), 58 deletions(-)

diff --git a/lib/bn.js b/lib/bn.js
index c803573..d173a6d 100644
--- a/lib/bn.js
+++ b/lib/bn.js
@@ -1003,8 +1003,8 @@ function _FFT(ws, p, s, tws, tp, r, N) {
 
       //console.log(tws);
 
-      assert(tws[tp + i].r < (0x4000000 * 0x4000000 * 2))
-      assert(tws[tp + i + hN].r < (0x4000000 * 0x4000000 * 2))
+      //assert(tws[tp + i].r < (0x4000000 * 0x4000000 * 2))
+      //assert(tws[tp + i + hN].r < (0x4000000 * 0x4000000 * 2))
 
       r_.imul(r);
 
@@ -1013,73 +1013,98 @@ function _FFT(ws, p, s, tws, tp, r, N) {
   }
 }
 
+var π = 3.14159265359;
 
-function _FFTL(ws, p, s, tws, tp, r, N) {
-  //if (N === 1) {
-  //  tws[tp] = ws[p];
-  //  //console.log("p/tp/ws/tws :", p, tp, ws, tws);
-  //} else {
-  //  var hN = N / 2 >> 0;
-  //
-  //  var rr = r.mul(r);
-  //
-  //  var s_ = 2 * s + 1;
-  //
-  //  //console.log("-- FFT -- # ", N);
-  //  //console.log("-- R -- ", r);
-  //
-  //  //console.log("-- RR -- # ", rr);
-  //
-  //  _FFT(ws, p,         s_, tws, tp,      rr, hN);  // even
-  //  _FFT(ws, p + s + 1, s_, tws, tp + hN, rr, hN);  // odd
-  //
-  //  var r_ = r.clone();
-  //
-  //  for (var i = 0; i < hN; ++i) {
-  //    var e = tws[tp + i];
-  //    var o = tws[tp + i + hN].clone();
-  //
-  //    //console.log("tp + i, tp + i + hN, tws | ", tp + i, tp + i + hN, tws)
-  //    //console.log("r_, o, e, (o * r_)", r_, o, e, o.mul(r_));
-  //
-  //    o.imul(r_);
-  //
-  //    tws[tp + i]      = e.add(o);
-  //    tws[tp + i + hN] = e.sub(o);
-  //
-  //    r_.imul(r);
-  //
-  //    //console.log("tws | ", tws)
-  //  }
+
+function _FFTL(ws, _, __, tws, ___, ____, N, rbt) {
+  //var hN = N / 2 >> 0;
+
+  //for (var j = 0;                         j < 2;    ++j)
+  //for (var i = 0, hhN = hN >> 1, dN = hN; i < hhN;  ++i, dN >>= 1) {
+  //  tws[2 * i]      = ws[dN + j];
+  //  tws[2 * i + 1]  = ws[dN + j + ];
   //}
 
-  var hN = N / 2 >> 0;
+  //console.log("XXXXX")
+  //console.log("WS, TWS", ws, tws)
 
-  for (var i = 0; i < hN; i++) {
-    tws[2 * i]      = ws[i];
-    tws[2 * i + 1]  = ws[i + hN];
-  }
+  _permuteTo(rbt, ws, tws, N);
+
+  var hN  = N >>> 1;
+
+  for (var s = 1; s < N; s <<= 1) {
+    var l   = s << 1;
+    var r   = new Complex(Math.cos(2 * π / l), Math.sin(2 * π / l));
+
+    for (var p = 0; p < N; p += l) {
+      var r_  = r.clone();
+
+      for (var j = 0; j < s; ++j) {
+        var e = tws[p + j];
+        var o = tws[p + j + s].clone();
+
+        o.imul(r_);
 
-  var p = 0;
+        tws[p + j]      = e.add(o);
+        tws[p + j + s]  = e.sub(o)
 
-  for (var l = 1; l < N + 1; l << 1, p = 0) {
-    for (var j = p; j < p + l; ++j, p += l) {
-      var e = tws[j];
-      var o = tws[j + l].clone();
+        //assert(tws[p + j].r     < (0x4000000 * 0x4000000 * 2))
+        //assert(tws[p + j + s].r < (0x4000000 * 0x4000000 * 2))
+
+        if (j !== l) r_.imul(r);
+      }
     }
+
+    //console.log(tws)
   }
 }
 
-var π = 3.14159265359;
+function _makeRBT(N) {
+  var t = new Array(N);
+  var l = (Math.log(N) / Math.log(2)) >> 0;
+  for (var i = 0; i < N; ++i) {
+    t[i] = _revbin(i, l, N);
+  }
+
+  return t;
+}
+
+function _permuteTo(rbt, ws, tws, N) {
+  //var l = (Math.log(N) / Math.log(2)) >> 0;
+  for (var i = 0; i < N; ++i) {
+    //var r = _revbin(i, l, N);
+    //console.log("REVBIN: ", i, r)
+    //if (r > i) {
+    //  var t = ws[i];
+    //  ws[i] = ws[r];
+    //  ws[r] = t;
+    //}
+    tws[i] = ws[rbt[i]];
+  }
+}
+
+function _revbin(x, l, N) {
+  if (x === 0 || x === N - 1)
+    return x;
+
+  var rb = 0;
+  for (var i = 0; i < l; ++i) {
+    rb |= (x & 1) << (l - i - 1);
+    x >>= 1;
+  }
+
+  return rb;
+}
+
 
 function _guess(n, m) {
-  var N = (n < m ? n : m) | 1, odd = N & 1;
+  var N = Math.max(m, n) | 1, odd = N & 1;
   var i = 0;
-  for (; N; N = N / 2 >> 0) {
+  while (N = N / 2 >> 0) {
     i++;
   }
 
-  return (1 << i + odd)
+  return (1 << i + 1 + odd)
 }
 
 function _iconjugate(ws, N) {
@@ -1469,8 +1494,12 @@ BN.prototype._bigMulToF = function _bigMulToF(num, out) {
 
   //console.log("A, B: ", this, num);
 
-  _FFT(_iconvertToC13(this.words, N), 0, 0, thisWFT, 0, w, N);
-  _FFT(_iconvertToC13(num.words,  N), 0, 0, numWFT,  0, w, N);
+  var rbt = _makeRBT(N);
+
+  //_FFT(_iconvertToC13(this.words, N), 0, 0, thisWFT, 0, w, N);
+  //_FFT(_iconvertToC13(num.words,  N), 0, 0, numWFT,  0, w, N);
+  _FFTL(_iconvertToC13(this.words, N), 0, 0, thisWFT, 0, w, N, rbt);
+  _FFTL(_iconvertToC13(num.words,  N), 0, 0, numWFT,  0, w, N, rbt);
   //_FFT(_iconvertToC20(this.words, N), 0, 0, thisWFT, 0, w, N);
   //_FFT(_iconvertToC20(num.words,  N), 0, 0, numWFT,  0, w, N);
   //_FFT(_iconvertToC18(this.words, N), 0, 0, thisWFT, 0, w, N);
@@ -1484,7 +1513,7 @@ BN.prototype._bigMulToF = function _bigMulToF(num, out) {
   //console.log("-- MULF -- ", multWFT);
 
   //_FFT(_iconjugate(multWFT, N), 0, 0, multW, 0, w, N);
-  _FFT(_iconjugate(thisWFT, N), 0, 0, multW, 0, w, N);
+  _FFTL(_iconjugate(thisWFT, N), 0, 0, multW, 0, w, N, rbt);
 
   //console.log(multW);
 
diff --git a/test/_fft.js b/test/_fft.js
index 78c5233..40237ed 100644
--- a/test/_fft.js
+++ b/test/_fft.js
@@ -4,9 +4,15 @@ var fixtures = require("./fixtures.js")
 //var a = new BN("1");
 //var b = new BN("1");
 
+//var a = new BN("2");
+//var b = new BN("13");
+
 //var a = new BN("123");
 //var b = new BN("123");
 
+//var a = new BN("12345");
+//var b = new BN("1");
+
 //var a = new BN("123456");
 //var b = new BN("123456");
 
@@ -16,8 +22,8 @@ var fixtures = require("./fixtures.js")
 //var a = new BN("123456900");
 //var b = new BN("12345601");
 
-//var a = new BN("123456789");
-//var b = new BN("123456780");
+//var a = new BN("0x2000", 16);
+//var b = new BN("12345678");
 
 //var a = new BN("123456789");
 //var b = new BN("123456789");

From c5570b41d7b8b4b72439ea4a5e1100b715b55d2e Mon Sep 17 00:00:00 2001
From: Alexey Kudinkin <alexey.kudinkin@gmail.com>
Date: Sun, 14 Dec 2014 21:04:28 +0300
Subject: [PATCH 04/12] Remastered FFT to purge any object creation (except
 arrays)

---
 lib/bn.js | 299 ++++++++++++++++++++++++++++++++++++++++++++++----------------
 1 file changed, 221 insertions(+), 78 deletions(-)

diff --git a/lib/bn.js b/lib/bn.js
index d173a6d..460a3bd 100644
--- a/lib/bn.js
+++ b/lib/bn.js
@@ -1016,7 +1016,7 @@ function _FFT(ws, p, s, tws, tp, r, N) {
 var π = 3.14159265359;
 
 
-function _FFTL(ws, _, __, tws, ___, ____, N, rbt) {
+function _FFTL(rws, iws,  _, __, rtws, itws, ___, ____, N, rbt) {
   //var hN = N / 2 >> 0;
 
   //for (var j = 0;                         j < 2;    ++j)
@@ -1028,30 +1028,57 @@ function _FFTL(ws, _, __, tws, ___, ____, N, rbt) {
   //console.log("XXXXX")
   //console.log("WS, TWS", ws, tws)
 
-  _permuteTo(rbt, ws, tws, N);
-
-  var hN  = N >>> 1;
+  _permuteTo(rbt, rws, iws, rtws, itws, N);
 
   for (var s = 1; s < N; s <<= 1) {
     var l   = s << 1;
-    var r   = new Complex(Math.cos(2 * π / l), Math.sin(2 * π / l));
+
+    var rtwdf = Math.cos(2 * π / l);
+    var itwdf = Math.sin(2 * π / l);
 
     for (var p = 0; p < N; p += l) {
-      var r_  = r.clone();
+      var rtwdf_ = rtwdf;
+      var itwdf_ = itwdf;
 
       for (var j = 0; j < s; ++j) {
-        var e = tws[p + j];
-        var o = tws[p + j + s].clone();
 
-        o.imul(r_);
+        //var e = tws[p + j];
+
+        var re = rtws[p + j];
+        var ie = itws[p + j];
+
+        //var o = tws[p + j + s].clone();
+
+        var ro = rtws[p + j + s];
+        var io = itws[p + j + s];
+
+        //o.imul(r_);
+
+        var rx = rtwdf_ * ro - itwdf_ * io;
+
+        io = rtwdf_ * io + itwdf_ * ro;
+        ro = rx;
 
-        tws[p + j]      = e.add(o);
-        tws[p + j + s]  = e.sub(o)
+        //tws[p + j]      = e.add(o);
+
+        rtws[p + j] = re + ro;
+        itws[p + j] = ie + io;
+
+        //tws[p + j + s]  = e.sub(o)
+
+        rtws[p + j + s] = re - ro;
+        itws[p + j + s] = ie - io;
 
         //assert(tws[p + j].r     < (0x4000000 * 0x4000000 * 2))
         //assert(tws[p + j + s].r < (0x4000000 * 0x4000000 * 2))
 
-        if (j !== l) r_.imul(r);
+        if (j !== l) {
+          //r_.imul(r);
+          var rx = rtwdf * rtwdf_ - itwdf * itwdf_;
+
+          itwdf_ = rtwdf * itwdf_ + itwdf * rtwdf_;
+          rtwdf_ = rx;
+        }
       }
     }
 
@@ -1060,7 +1087,7 @@ function _FFTL(ws, _, __, tws, ___, ____, N, rbt) {
 }
 
 function _makeRBT(N) {
-  var t = new Array(N);
+  var t = new Int32Array(N);
   var l = (Math.log(N) / Math.log(2)) >> 0;
   for (var i = 0; i < N; ++i) {
     t[i] = _revbin(i, l, N);
@@ -1069,7 +1096,7 @@ function _makeRBT(N) {
   return t;
 }
 
-function _permuteTo(rbt, ws, tws, N) {
+function _permuteTo(rbt, rws, iws, rtws, itws, N) {
   //var l = (Math.log(N) / Math.log(2)) >> 0;
   for (var i = 0; i < N; ++i) {
     //var r = _revbin(i, l, N);
@@ -1079,7 +1106,8 @@ function _permuteTo(rbt, ws, tws, N) {
     //  ws[i] = ws[r];
     //  ws[r] = t;
     //}
-    tws[i] = ws[rbt[i]];
+    rtws[i] = rws[rbt[i]];
+    itws[i] = iws[rbt[i]];
   }
 }
 
@@ -1122,6 +1150,22 @@ function _iconjugate(ws, N) {
   return ws;
 }
 
+function _iconjugateX(rws, iws, N) {
+  if (N > 1) {
+    for (var i = 0; i < N / 2; ++i) {
+      var t = rws[i];
+
+      rws[i]          = rws[N - i - 1];
+      rws[N - i - 1]  = t;
+
+      t = iws[i];
+
+      iws[i]          = -iws[N - i - 1];
+      iws[N - i - 1]  = -t;
+    }
+  }
+}
+
 function _inormalize13(ws, N) {
   var carry = 0;
   for (var i = 0; i < N / 2; ++i) {
@@ -1164,6 +1208,49 @@ function _inormalize13(ws, N) {
   return ws;
 }
 
+
+function _inormalize13X(ws, N) {
+  var carry = 0;
+  for (var i = 0; i < N / 2; ++i) {
+
+    //var n = (((ws[2 * i + 1].r  / N + .5) >> 0) << 13)
+    //      +  ((ws[2 * i].r      / N + .5) >> 0)
+    //      +  carry;
+
+    //if ((Math.round(ws[2 * i + 1].r  / N) << 13) !== (Math.round(ws[2 * i + 1].r  / N) * 0x2000)) {
+    //  console.log(1 << 13, 1 * 0x2000);
+    //  console.log(Math.round(ws[2 * i + 1].r  / N), ((Math.round(ws[2 * i + 1].r  / N)) << 7), (Math.round(ws[2 * i + 1].r  / N) * 0x2000));
+    //  assert((Math.round(ws[2 * i + 1].r / N) << 13) === (Math.round(ws[2 * i + 1].r / N) * 0x2000), "WAAAAAT");
+    //}
+
+    //assert(Math.abs(ws[2 * i].i) < N && Math.abs(ws[2 * i + 1].i) < N)
+    //
+    //var n = (Math.round(ws[2 * i + 1].r  / N) * 0x2000)
+    //      +  Math.round(ws[2 * i].r      / N)
+    //      +  carry;
+
+    var n = (Math.round(ws[2 * i + 1] / N) * 0x2000)
+          +  Math.round(ws[2 * i] / N)
+          +  carry;
+
+    //console.log(
+    //    n.toString(16),
+    //    carry.toString(16),
+    //    (n & 0x3ffffff).toString(16)
+    //  );
+
+    ws[i] = n & 0x3ffffff;
+
+    if (n < 0x4000000) {
+      carry = 0;
+    } else {
+      carry = Math.floor(n / 0x4000000);
+    }
+  }
+
+  return ws;
+}
+
 function _inormalize20(ws, N) {
 
   var carry = 0;
@@ -1338,6 +1425,18 @@ function _iconvertToC13(ws, N) {
   return cws;
 }
 
+function _iconvertTo13(ws, rws, iws, N) {
+  for (var i = 0; i < N / 2; i++) {
+    var w = ws[i] | 0;
+
+    rws[2 * i] = w & 0x1fff;
+    iws[2 * i] = 0;
+
+    rws[2 * i + 1] = w >>> 13;
+    iws[2 * i + 1] = 0;
+  }
+}
+
 function _iconvertToC20(ws, N) {
   var cws = new Array(N);
 
@@ -1406,56 +1505,56 @@ function _iconvertToC18(ws, N) {
   return cws;
 }
 
-function _iconvertTo13(ws, N) {
-  var cws = new Array(N);
-  var carry = 0;
-
-  var i = 0;
-  for (i = 0; i < N; ++i) {
-    ws[i] = Math.round(ws[i].r / N);
-  }
-
-  i = 0;
-  for (var j = 0; true; ++j) {
-
-    if (carry < 0x2000) {
-      if (i === N)
-        break;
-
-      carry += ws[i];
-      i++;
-    }
-
-    var lo = carry & 0x1fff;  // Here we don't care about overflow, since
-                              // since overflow may only "screw" (trim) high-order
-                              // bits, while we're particularly interested in low-order ones
-
-    //console.log(carry, lo)
-
-    carry = carry / 0x2000;   // Since shift would trigger conversion from
-                              // float (64) to int (32)
-
-    cws[j] = lo;
-  }
-
-  //for (var i = 0; i < N; i++) {
-  //  carry += Math.round(ws[i].r / N);
-  //
-  //
-  //  var lo = carry & 0x1fff;  // Here we don't care about overflow, since
-  //                            // since overflow may only "screw" (trim) high-order
-  //                            // bits, while we're particularly interested in low-order ones
-  //
-  //  console.log(carry, lo)
-  //
-  //  carry = carry / 0x2000;   // Since shift would trigger conversion from
-  //                            // float (64) to int (32)
-  //
-  //  cws[i] = lo;
-  //}
-
-  return cws;
-}
+//function _iconvertTo13(ws, N) {
+//  var cws = new Array(N);
+//  var carry = 0;
+//
+//  var i = 0;
+//  for (i = 0; i < N; ++i) {
+//    ws[i] = Math.round(ws[i].r / N);
+//  }
+//
+//  i = 0;
+//  for (var j = 0; true; ++j) {
+//
+//    if (carry < 0x2000) {
+//      if (i === N)
+//        break;
+//
+//      carry += ws[i];
+//      i++;
+//    }
+//
+//    var lo = carry & 0x1fff;  // Here we don't care about overflow, since
+//                              // since overflow may only "screw" (trim) high-order
+//                              // bits, while we're particularly interested in low-order ones
+//
+//    //console.log(carry, lo)
+//
+//    carry = carry / 0x2000;   // Since shift would trigger conversion from
+//                              // float (64) to int (32)
+//
+//    cws[j] = lo;
+//  }
+//
+//  //for (var i = 0; i < N; i++) {
+//  //  carry += Math.round(ws[i].r / N);
+//  //
+//  //
+//  //  var lo = carry & 0x1fff;  // Here we don't care about overflow, since
+//  //                            // since overflow may only "screw" (trim) high-order
+//  //                            // bits, while we're particularly interested in low-order ones
+//  //
+//  //  console.log(carry, lo)
+//  //
+//  //  carry = carry / 0x2000;   // Since shift would trigger conversion from
+//  //                            // float (64) to int (32)
+//  //
+//  //  cws[i] = lo;
+//  //}
+//
+//  return cws;
+//}
 
 BN.prototype.mulTo = function mulTo(num, out) {
   var res;
@@ -1483,14 +1582,14 @@ BN.prototype._bigMulToF = function _bigMulToF(num, out) {
   var N = 2 * _guess(this.length, num.length);
   //var N = _guess(this.length * 1.3, num.length * 1.3);
 
-  var w = new Complex(Math.cos(2 * π / N), Math.sin(2 * π / N));
+  //var w = new Complex(Math.cos(2 * π / N), Math.sin(2 * π / N));
 
   //console.log("-- W -- ", w);
 
-  var thisWFT  = new Array(N),
-      numWFT   = new Array(N),
-      //multWFT  = new Array(N),
-      multW    = new Array(N);
+  //var thisWFT  = new Array(N),
+  //    numWFT   = new Array(N),
+  //    //multWFT  = new Array(N),
+  //    multW    = new Array(N);
 
   //console.log("A, B: ", this, num);
 
@@ -1498,36 +1597,80 @@ BN.prototype._bigMulToF = function _bigMulToF(num, out) {
 
   //_FFT(_iconvertToC13(this.words, N), 0, 0, thisWFT, 0, w, N);
   //_FFT(_iconvertToC13(num.words,  N), 0, 0, numWFT,  0, w, N);
-  _FFTL(_iconvertToC13(this.words, N), 0, 0, thisWFT, 0, w, N, rbt);
-  _FFTL(_iconvertToC13(num.words,  N), 0, 0, numWFT,  0, w, N, rbt);
   //_FFT(_iconvertToC20(this.words, N), 0, 0, thisWFT, 0, w, N);
   //_FFT(_iconvertToC20(num.words,  N), 0, 0, numWFT,  0, w, N);
   //_FFT(_iconvertToC18(this.words, N), 0, 0, thisWFT, 0, w, N);
   //_FFT(_iconvertToC18(num.words,  N), 0, 0, numWFT,  0, w, N);
 
+  var rThisWs   = new Array(N),
+      iThisWs   = new Array(N),
+      rThisWsT  = new Array(N),  // T for Transformed
+      iThisWsT  = new Array(N),
+
+      rNumWs    = new Array(N),
+      iNumWs    = new Array(N),
+      rNumWsT   = new Array(N),
+      iNumWsT   = new Array(N),
+
+      rMultWs   = new Array(N),
+      iMultWs   = new Array(N);
+
+  _iconvertTo13(this.words, rThisWs,  iThisWs,  N);
+  _iconvertTo13(num.words,  rNumWs,   iNumWs,   N);
+
+  _FFTL(rThisWs,  iThisWs,  0, 0, rThisWsT, iThisWsT, 0, 0, N, rbt);
+
+  //console.log("X[R/I] Vanilla",     _toArray(rThisWs), _toArray(iThisWs))
+  //console.log("X[R/I] Transformed", _toArray(rThisWsT), _toArray(iThisWsT))
+
+  _FFTL(rNumWs,   iNumWs,   0, 0, rNumWsT,  iNumWsT,  0, 0, N, rbt);
+
+  //console.log("Y[R/I] Vanilla",     _toArray(rNumWs), _toArray(iNumWs))
+  //console.log("Y[R/I] Transformed", _toArray(rNumWsT), _toArray(iNumWsT))
+
   for (var i = 0; i < N; ++i) {
-    //multWFT[i] = thisWFT[i].mul(numWFT[i]);
-    thisWFT[i].imul(numWFT[i]);
+    //thisWFT[i].imul(numWFT[i]);
+    var rx = rThisWsT[i] * rNumWsT[i] - iThisWsT[i] * iNumWsT[i];
+
+    iThisWsT[i] = rThisWsT[i] * iNumWsT[i] + iThisWsT[i] * rNumWsT[i]
+    rThisWsT[i] = rx;
   }
 
+  //console.log("X * Y[R/I] Transformed", _toArray(rThisWsT), _toArray(iThisWsT))
+
   //console.log("-- MULF -- ", multWFT);
 
   //_FFT(_iconjugate(multWFT, N), 0, 0, multW, 0, w, N);
-  _FFTL(_iconjugate(thisWFT, N), 0, 0, multW, 0, w, N, rbt);
 
-  //console.log(multW);
+  _iconjugateX(rThisWsT, iThisWsT, N);
+
+  //console.log("X * Y[R/I] Transformed Conjugated", _toArray(rThisWsT), _toArray(iThisWsT))
+
+  _FFTL(rThisWsT, iThisWsT, 0, 0, rMultWs, iMultWs, 0, 0, N, rbt);
+
+  //console.log("X * Y[R/I] Inverse FFT", _toArray(rMultWs), _toArray(iMultWs))
+
+  _iconjugateX(rMultWs, iMultWs, N);
+
+  _inormalize13X(rMultWs, N);
+
+  //console.log("X * Y[R/I] Conjugated Normalized", _toArray(rMultWs), _toArray(iMultWs))
 
-  multW = _inormalize13(_iconjugate(multW, N), N);
   //multW = _inormalize20(_iconjugate(multW, N), N);
   //multW = _inormalize18(_iconjugate(multW, N), N);
 
-  out.words = multW;
+  out.words = _toArray(rMultWs);
 
   //console.log("-- MUL -- ", multW);
 
   return out.strip();
 };
 
+function _toArray(f64a) {
+  return [].slice.call(f64a);
+}
+
+
 // Multiply `this` by `num`
 BN.prototype.mul = function mul(num) {
   var out = new BN(null);

From 6dde038bb6100b4aa972c1ab22825dfefbfa1a3e Mon Sep 17 00:00:00 2001
From: Alexey Kudinkin <alexey.kudinkin@gmail.com>
Date: Sun, 14 Dec 2014 22:23:59 +0300
Subject: [PATCH 05/12] Vanished some more absurd

---
 lib/bn.js | 39 +++++++++++++++++----------------------
 1 file changed, 17 insertions(+), 22 deletions(-)

diff --git a/lib/bn.js b/lib/bn.js
index 460a3bd..36beb6d 100644
--- a/lib/bn.js
+++ b/lib/bn.js
@@ -1087,7 +1087,7 @@ function _FFTL(rws, iws,  _, __, rtws, itws, ___, ____, N, rbt) {
 }
 
 function _makeRBT(N) {
-  var t = new Int32Array(N);
+  var t = new Array(N);
   var l = (Math.log(N) / Math.log(2)) >> 0;
   for (var i = 0; i < N; ++i) {
     t[i] = _revbin(i, l, N);
@@ -1125,7 +1125,7 @@ function _revbin(x, l, N) {
 }
 
 
-function _guess(n, m) {
+function _guess13(n, m) {
   var N = Math.max(m, n) | 1, odd = N & 1;
   var i = 0;
   while (N = N / 2 >> 0) {
@@ -1425,15 +1425,12 @@ function _iconvertToC13(ws, N) {
   return cws;
 }
 
-function _iconvertTo13(ws, rws, iws, N) {
+function _iconvertTo13(ws, rws, N) {
   for (var i = 0; i < N / 2; i++) {
     var w = ws[i] | 0;
 
-    rws[2 * i] = w & 0x1fff;
-    iws[2 * i] = 0;
-
-    rws[2 * i + 1] = w >>> 13;
-    iws[2 * i + 1] = 0;
+    rws[2 * i]      = w & 0x1fff;
+    rws[2 * i + 1]  = w >>> 13;
   }
 }
 
@@ -1579,8 +1576,8 @@ BN.prototype._bigMulToF = function _bigMulToF(num, out) {
   out.sign = num.sign !== this.sign;
   out.length = this.length + num.length;
 
-  var N = 2 * _guess(this.length, num.length);
-  //var N = _guess(this.length * 1.3, num.length * 1.3);
+  var N = 2 * _guess13(this.length, num.length);
+  //var N = _guess13(this.length * 1.3, num.length * 1.3);
 
   //var w = new Complex(Math.cos(2 * π / N), Math.sin(2 * π / N));
 
@@ -1602,28 +1599,30 @@ BN.prototype._bigMulToF = function _bigMulToF(num, out) {
   //_FFT(_iconvertToC18(this.words, N), 0, 0, thisWFT, 0, w, N);
   //_FFT(_iconvertToC18(num.words,  N), 0, 0, numWFT,  0, w, N);
 
-  var rThisWs   = new Array(N),
-      iThisWs   = new Array(N),
+  var zeroes    = new Array(N),
+      rThisWs   = new Array(N),
       rThisWsT  = new Array(N),  // T for Transformed
       iThisWsT  = new Array(N),
 
       rNumWs    = new Array(N),
-      iNumWs    = new Array(N),
       rNumWsT   = new Array(N),
       iNumWsT   = new Array(N),
 
       rMultWs   = new Array(N),
       iMultWs   = new Array(N);
 
-  _iconvertTo13(this.words, rThisWs,  iThisWs,  N);
-  _iconvertTo13(num.words,  rNumWs,   iNumWs,   N);
+  for (var i = 0; i < N; ++i)
+    zeroes[i] = 0;
+
+  _iconvertTo13(this.words, rThisWs,  N);
+  _iconvertTo13(num.words,  rNumWs,   N);
 
-  _FFTL(rThisWs,  iThisWs,  0, 0, rThisWsT, iThisWsT, 0, 0, N, rbt);
+  _FFTL(rThisWs,  zeroes,  0, 0, rThisWsT, iThisWsT, 0, 0, N, rbt);
 
   //console.log("X[R/I] Vanilla",     _toArray(rThisWs), _toArray(iThisWs))
   //console.log("X[R/I] Transformed", _toArray(rThisWsT), _toArray(iThisWsT))
 
-  _FFTL(rNumWs,   iNumWs,   0, 0, rNumWsT,  iNumWsT,  0, 0, N, rbt);
+  _FFTL(rNumWs,   zeroes,   0, 0, rNumWsT,  iNumWsT,  0, 0, N, rbt);
 
   //console.log("Y[R/I] Vanilla",     _toArray(rNumWs), _toArray(iNumWs))
   //console.log("Y[R/I] Transformed", _toArray(rNumWsT), _toArray(iNumWsT))
@@ -1659,17 +1658,13 @@ BN.prototype._bigMulToF = function _bigMulToF(num, out) {
   //multW = _inormalize20(_iconjugate(multW, N), N);
   //multW = _inormalize18(_iconjugate(multW, N), N);
 
-  out.words = _toArray(rMultWs);
+  out.words = rMultWs;
 
   //console.log("-- MUL -- ", multW);
 
   return out.strip();
 };
 
-function _toArray(f64a) {
-  return [].slice.call(f64a);
-}
-
 
 // Multiply `this` by `num`
 BN.prototype.mul = function mul(num) {

From 4af09f26ad1d4904496d9b92e1b207971ca6d819 Mon Sep 17 00:00:00 2001
From: Alexey Kudinkin <alexey.kudinkin@gmail.com>
Date: Sun, 14 Dec 2014 22:43:01 +0300
Subject: [PATCH 06/12] Vapourized yet another array

---
 lib/bn.js | 26 ++++++++++++++++----------
 1 file changed, 16 insertions(+), 10 deletions(-)

diff --git a/lib/bn.js b/lib/bn.js
index 36beb6d..60953fc 100644
--- a/lib/bn.js
+++ b/lib/bn.js
@@ -1572,6 +1572,7 @@ BN.prototype.mulToF = function mulToF(num, out) {
   return res;
 };
 
+
 BN.prototype._bigMulToF = function _bigMulToF(num, out) {
   out.sign = num.sign !== this.sign;
   out.length = this.length + num.length;
@@ -1599,7 +1600,8 @@ BN.prototype._bigMulToF = function _bigMulToF(num, out) {
   //_FFT(_iconvertToC18(this.words, N), 0, 0, thisWFT, 0, w, N);
   //_FFT(_iconvertToC18(num.words,  N), 0, 0, numWFT,  0, w, N);
 
-  var zeroes    = new Array(N),
+  var ph        = _makePlaceHolderA(N),
+
       rThisWs   = new Array(N),
       rThisWsT  = new Array(N),  // T for Transformed
       iThisWsT  = new Array(N),
@@ -1608,21 +1610,17 @@ BN.prototype._bigMulToF = function _bigMulToF(num, out) {
       rNumWsT   = new Array(N),
       iNumWsT   = new Array(N),
 
-      rMultWs   = new Array(N),
-      iMultWs   = new Array(N);
-
-  for (var i = 0; i < N; ++i)
-    zeroes[i] = 0;
+      rMultWs   = new Array(N);
 
   _iconvertTo13(this.words, rThisWs,  N);
   _iconvertTo13(num.words,  rNumWs,   N);
 
-  _FFTL(rThisWs,  zeroes,  0, 0, rThisWsT, iThisWsT, 0, 0, N, rbt);
+  _FFTL(rThisWs,  ph,  0, 0, rThisWsT, iThisWsT, 0, 0, N, rbt);
 
   //console.log("X[R/I] Vanilla",     _toArray(rThisWs), _toArray(iThisWs))
   //console.log("X[R/I] Transformed", _toArray(rThisWsT), _toArray(iThisWsT))
 
-  _FFTL(rNumWs,   zeroes,   0, 0, rNumWsT,  iNumWsT,  0, 0, N, rbt);
+  _FFTL(rNumWs,   ph,   0, 0, rNumWsT,  iNumWsT,  0, 0, N, rbt);
 
   //console.log("Y[R/I] Vanilla",     _toArray(rNumWs), _toArray(iNumWs))
   //console.log("Y[R/I] Transformed", _toArray(rNumWsT), _toArray(iNumWsT))
@@ -1645,11 +1643,11 @@ BN.prototype._bigMulToF = function _bigMulToF(num, out) {
 
   //console.log("X * Y[R/I] Transformed Conjugated", _toArray(rThisWsT), _toArray(iThisWsT))
 
-  _FFTL(rThisWsT, iThisWsT, 0, 0, rMultWs, iMultWs, 0, 0, N, rbt);
+  _FFTL(rThisWsT, iThisWsT, 0, 0, rMultWs, ph, 0, 0, N, rbt);
 
   //console.log("X * Y[R/I] Inverse FFT", _toArray(rMultWs), _toArray(iMultWs))
 
-  _iconjugateX(rMultWs, iMultWs, N);
+  _iconjugateX(rMultWs, ph, N);
 
   _inormalize13X(rMultWs, N);
 
@@ -1665,6 +1663,14 @@ BN.prototype._bigMulToF = function _bigMulToF(num, out) {
   return out.strip();
 };
 
+function _makePlaceHolderA(N) {
+  var ph = new Array(N);
+  for (var i = 0; i < N; ++i)
+    ph[i] = 0;
+
+  return ph;
+}
+
 
 // Multiply `this` by `num`
 BN.prototype.mul = function mul(num) {

From 393e6b3d41b4b260de8354937c1061de822aee47 Mon Sep 17 00:00:00 2001
From: Alexey Kudinkin <alexey.kudinkin@gmail.com>
Date: Sun, 14 Dec 2014 22:46:07 +0300
Subject: [PATCH 07/12] Cleaned up

---
 benchmarks/index.js | 181 +++++++++------
 lib/bn.js           | 639 +++-------------------------------------------------
 test/_fft.js        |  49 ----
 3 files changed, 143 insertions(+), 726 deletions(-)
 delete mode 100644 test/_fft.js

diff --git a/benchmarks/index.js b/benchmarks/index.js
index 64b61d9..75e0f0c 100644
--- a/benchmarks/index.js
+++ b/benchmarks/index.js
@@ -56,90 +56,120 @@ if (/fast/i.test(process.argv[3])) {
   benchmark.options.minTime = 1;
 }
 
+var aj =  'a899c59999bf877d96442d284359783bdc64b5f878b688fe' +
+          '51407f0526e616553ad0aaaac4d5bed3046f10a1faaf42bb' +
+          '2342dc4b7908eea0c46e4c4576897675c2bfdc4467870d3d' +
+          'cd90adaed4359237a4bc6924bfb99aa6bf5f5ede15b574ea' +
+          'e977eac096f3c67d09bda574c6306c6123fa89d2f086b8dc' +
+          'ff92bc570c18d83fe6c810ccfd22ce4c749ef5e6ead3fffe' +
+          'c63d95e0e3fde1df9db6a35fa1d107058f37e41957769199' +
+          'd945dd7a373622c65f0af3fd9eb1ddc5c764bbfaf7a3dc37' +
+          '2548e683b970dac4aa4b9869080d2376c9adecebb84e172c' +
+          '09aeeb25fb8df23e60033260c4f8aac6b8b98ab894b1fb84' +
+          'ebb83c0fb2081c3f3eee07f44e24d8fabf76f19ed167b0d7' +
+          'ff971565aa4efa3625fce5a43ceeaa3eebb3ce88a00f597f' +
+          '048c69292b38dba2103ecdd5ec4ccfe3b2d87fa6202f334b' +
+          'c1cab83b608dfc875b650b69f2c7e23c0b2b4adf149a6100' +
+          'db1b6dbad4679ecb1ea95eafaba3bd00db11c2134f5a8686' +
+          '358b8b2ab49a1b2e85e1e45caeac5cd4dc0b3b5fffba8871' +
+          '1c6baf399edd48dad5e5c313702737a6dbdcede80ca358e5' +
+          '1d1c4fe42e8948a084403f61baed38aa9a1a5ce2918e9f33' +
+          '100050a430b47bc592995606440272a4994677577a6aaa1b' +
+          'a101045dbec5a4e9566dab5445d1af3ed19519f07ac4e2a8' +
+          'bd0a84b01978f203a9125a0be020f71fab56c2c9e344d4f4' +
+          '12d53d3cd8eb74ca5122002e931e3cb0bd4b7492436be17a' +
+          'd7ebe27148671f59432c36d8c56eb762655711cfc8471f70' +
+          '83a8b7283bcb3b1b1d47d37c23d030288cfcef05fbdb4e16' +
+          '652ee03ee7b77056a808cd700bc3d9ef826eca9a59be959c' +
+          '947c865d6b372a1ca2d503d7df6d7611b12111665438475a' +
+          '1c64145849b3da8c2d343410df892d958db232617f9896f1' +
+          'de95b8b5a47132be80dd65298c7f2047858409bf762dbc05' +
+          'a62ca392ac40cfb8201a0607a2cae07d99a307625f2b2d04' +
+          'fe83fbd3ab53602263410f143b73d5b46fc761882e78c782' +
+          'd2c36e716a770a7aefaf7f76cea872db7bffefdbc4c2f9e0' +
+            '39c19adac915e7a63dcb8c8c78c113f29a3e0bc10e100ce0';
+
+var bj =  '3bf836229c7dd874fe37c1790d201e82ed8e192ed61571ca' +
+          '7285264974eb2a0171f3747b2fc23969a916cbd21e14f7e2' +
+          'f0d72dcd2247affba926f9e7bb99944cb5609aed85e71b89' +
+          'e89d2651550cb5bd8281bd3144066af78f194032aa777739' +
+          'cccb7862a1af401f99f7e5c693f25ddce2dedd9686633820' +
+          'd28d0f5ed0c6b5a094f5fe6170b8e2cbc9dff118398baee6' +
+          'e895a6301cb6e881b3cae749a5bdf5c56fc897ff68bc73f2' +
+          '4811bb108b882872bade1f147d886a415cda2b93dd90190c' +
+          'be5c2dd53fe78add5960e97f58ff2506afe437f4cf4c912a' +
+          '397c1a2139ac6207d3ab76e6b7ffd23bb6866dd7f87a9ae5' +
+          '578789084ff2d06ea0d30156d7a10496e8ebe094f5703539' +
+          '730f5fdbebc066de417be82c99c7da59953071f49da7878d' +
+          'a588775ff2a7f0084de390f009f372af75cdeba292b08ea8' +
+          '4bd13a87e1ca678f9ad148145f7cef3620d69a891be46fbb' +
+          'cad858e2401ec0fd72abdea2f643e6d0197b7646fbb83220' +
+          '0f4cf7a7f6a7559f9fb0d0f1680822af9dbd8dec4cd1b5e1' +
+          '7bc799e902d9fe746ddf41da3b7020350d3600347398999a' +
+          'baf75d53e03ad2ee17de8a2032f1008c6c2e6618b62f225b' +
+          'a2f350179445debe68500fcbb6cae970a9920e321b468b74' +
+          '5fb524fb88abbcacdca121d737c44d30724227a99745c209' +
+          'b970d1ff93bbc9f28b01b4e714d6c9cbd9ea032d4e964d8e' +
+          '8fff01db095160c20b7646d9fcd314c4bc11bcc232aeccc0' +
+          'fbedccbc786951025597522eef283e3f56b44561a0765783' +
+          '420128638c257e54b972a76e4261892d81222b3e2039c61a' +
+          'ab8408fcaac3d634f848ab3ee65ea1bd13c6cd75d2e78060' +
+          'e13cf67fbef8de66d2049e26c0541c679fff3e6afc290efe' +
+          '875c213df9678e4a7ec484bc87dae5f0a1c26d7583e38941' +
+          'b7c68b004d4df8b004b666f9448aac1cc3ea21461f41ea5d' +
+          'd0f7a9e6161cfe0f58bcfd304bdc11d78c2e9d542e86c0b5' +
+          '6985cc83f693f686eaac17411a8247bf62f5ccc7782349b5' +
+          'cc1f20e312fa2acc0197154d1bfee507e8db77e8f2732f2d' +
+          '641440ccf248e8643b2bd1e1f9e8239356ab91098fcb431d';
+
+// BN
+
 var a1 = new bn('012345678901234567890123456789012345678901234567890', 10);
 var b1 = new bn('213509123601923760129376102397651203958123402314875', 10);
 
-var a1x = new bn( 'a899c59999bf877d96442d284359783bdc64b5f878b688fe' +
-                  '51407f0526e616553ad0aaaac4d5bed3046f10a1faaf42bb' +
-                  '2342dc4b7908eea0c46e4c4576897675c2bfdc4467870d3d' +
-                  'cd90adaed4359237a4bc6924bfb99aa6bf5f5ede15b574ea' +
-                  'e977eac096f3c67d09bda574c6306c6123fa89d2f086b8dc' +
-                  'ff92bc570c18d83fe6c810ccfd22ce4c749ef5e6ead3fffe' +
-                  'c63d95e0e3fde1df9db6a35fa1d107058f37e41957769199' +
-                  'd945dd7a373622c65f0af3fd9eb1ddc5c764bbfaf7a3dc37' +
-                  '2548e683b970dac4aa4b9869080d2376c9adecebb84e172c' +
-                  '09aeeb25fb8df23e60033260c4f8aac6b8b98ab894b1fb84' +
-                  'ebb83c0fb2081c3f3eee07f44e24d8fabf76f19ed167b0d7' +
-                  'ff971565aa4efa3625fce5a43ceeaa3eebb3ce88a00f597f' +
-                  '048c69292b38dba2103ecdd5ec4ccfe3b2d87fa6202f334b' +
-                  'c1cab83b608dfc875b650b69f2c7e23c0b2b4adf149a6100' +
-                  'db1b6dbad4679ecb1ea95eafaba3bd00db11c2134f5a8686' +
-                  '358b8b2ab49a1b2e85e1e45caeac5cd4dc0b3b5fffba8871' +
-                  '1c6baf399edd48dad5e5c313702737a6dbdcede80ca358e5' +
-                  '1d1c4fe42e8948a084403f61baed38aa9a1a5ce2918e9f33' +
-                  '100050a430b47bc592995606440272a4994677577a6aaa1b' +
-                  'a101045dbec5a4e9566dab5445d1af3ed19519f07ac4e2a8' +
-                  'bd0a84b01978f203a9125a0be020f71fab56c2c9e344d4f4' +
-                  '12d53d3cd8eb74ca5122002e931e3cb0bd4b7492436be17a' +
-                  'd7ebe27148671f59432c36d8c56eb762655711cfc8471f70' +
-                  '83a8b7283bcb3b1b1d47d37c23d030288cfcef05fbdb4e16' +
-                  '652ee03ee7b77056a808cd700bc3d9ef826eca9a59be959c' +
-                  '947c865d6b372a1ca2d503d7df6d7611b12111665438475a' +
-                  '1c64145849b3da8c2d343410df892d958db232617f9896f1' +
-                  'de95b8b5a47132be80dd65298c7f2047858409bf762dbc05' +
-                  'a62ca392ac40cfb8201a0607a2cae07d99a307625f2b2d04' +
-                  'fe83fbd3ab53602263410f143b73d5b46fc761882e78c782' +
-                  'd2c36e716a770a7aefaf7f76cea872db7bffefdbc4c2f9e0' +
-                  '39c19adac915e7a63dcb8c8c78c113f29a3e0bc10e100ce0', 16);
-
-var b1x = new bn( '3bf836229c7dd874fe37c1790d201e82ed8e192ed61571ca' +
-                  '7285264974eb2a0171f3747b2fc23969a916cbd21e14f7e2' +
-                  'f0d72dcd2247affba926f9e7bb99944cb5609aed85e71b89' +
-                  'e89d2651550cb5bd8281bd3144066af78f194032aa777739' +
-                  'cccb7862a1af401f99f7e5c693f25ddce2dedd9686633820' +
-                  'd28d0f5ed0c6b5a094f5fe6170b8e2cbc9dff118398baee6' +
-                  'e895a6301cb6e881b3cae749a5bdf5c56fc897ff68bc73f2' +
-                  '4811bb108b882872bade1f147d886a415cda2b93dd90190c' +
-                  'be5c2dd53fe78add5960e97f58ff2506afe437f4cf4c912a' +
-                  '397c1a2139ac6207d3ab76e6b7ffd23bb6866dd7f87a9ae5' +
-                  '578789084ff2d06ea0d30156d7a10496e8ebe094f5703539' +
-                  '730f5fdbebc066de417be82c99c7da59953071f49da7878d' +
-                  'a588775ff2a7f0084de390f009f372af75cdeba292b08ea8' +
-                  '4bd13a87e1ca678f9ad148145f7cef3620d69a891be46fbb' +
-                  'cad858e2401ec0fd72abdea2f643e6d0197b7646fbb83220' +
-                  '0f4cf7a7f6a7559f9fb0d0f1680822af9dbd8dec4cd1b5e1' +
-                  '7bc799e902d9fe746ddf41da3b7020350d3600347398999a' +
-                  'baf75d53e03ad2ee17de8a2032f1008c6c2e6618b62f225b' +
-                  'a2f350179445debe68500fcbb6cae970a9920e321b468b74' +
-                  '5fb524fb88abbcacdca121d737c44d30724227a99745c209' +
-                  'b970d1ff93bbc9f28b01b4e714d6c9cbd9ea032d4e964d8e' +
-                  '8fff01db095160c20b7646d9fcd314c4bc11bcc232aeccc0' +
-                  'fbedccbc786951025597522eef283e3f56b44561a0765783' +
-                  '420128638c257e54b972a76e4261892d81222b3e2039c61a' +
-                  'ab8408fcaac3d634f848ab3ee65ea1bd13c6cd75d2e78060' +
-                  'e13cf67fbef8de66d2049e26c0541c679fff3e6afc290efe' +
-                  '875c213df9678e4a7ec484bc87dae5f0a1c26d7583e38941' +
-                  'b7c68b004d4df8b004b666f9448aac1cc3ea21461f41ea5d' +
-                  'd0f7a9e6161cfe0f58bcfd304bdc11d78c2e9d542e86c0b5' +
-                  '6985cc83f693f686eaac17411a8247bf62f5ccc7782349b5' +
-                  'cc1f20e312fa2acc0197154d1bfee507e8db77e8f2732f2d' +
-                  '641440ccf248e8643b2bd1e1f9e8239356ab91098fcb431d', 16);
+var a1j = new bn(aj, 16);
+var b1j = new bn(bj, 16);
+
+// bignum
 
 var a2 = new bignum('012345678901234567890123456789012345678901234567890', 10);
 var b2 = new bignum('213509123601923760129376102397651203958123402314875', 10);
 
+var a2j = new bignum(aj, 16);
+var b2j = new bignum(bj, 16);
+
+// bigi
+
 var a4 = new bigi('012345678901234567890123456789012345678901234567890', 10);
 var b4 = new bigi('213509123601923760129376102397651203958123402314875', 10);
 
+var a4j = new bigi(aj, 16);
+var b4j = new bigi(bj, 16);
+
+// sjcl
+
 var a5 = new sjcl(a1.toString(16));
 var b5 = new sjcl(b1.toString(16));
 
+var a5j = new sjcl(aj);
+var b5j = new sjcl(bj);
+
+// BigInteger
+
 var a6 = new BigInteger('012345678901234567890123456789012345678901234567890', 10);
 var b6 = new BigInteger('213509123601923760129376102397651203958123402314875', 10);
 
+var a6j = new BigInteger(aj, 16);
+var b6j = new BigInteger(bj, 16);
+
+// SilentMattBigInteger
+
 var a8 = SilentMattBigInteger.parse('012345678901234567890123456789012345678901234567890', 10);
 var b8 = SilentMattBigInteger.parse('213509123601923760129376102397651203958123402314875', 10);
 
+var a8j = SilentMattBigInteger.parse(aj, 16);
+var b8j = SilentMattBigInteger.parse(aj, 16);
+
 var as1 = a1.mul(a1).iaddn(0x2adbeef);
 var as2 = a2.mul(a2).add(0x2adbeef);
 var as4 = a4.multiply(a4).add(bigi.valueOf(0x2adbeef));
@@ -273,7 +303,7 @@ add('mul', {
   },
   'bn.js[FFT]': function() {
     a1.mulf(b1);
-  }
+  },
   'bignum': function() {
     a2.mul(b2);
   },
@@ -293,10 +323,25 @@ add('mul', {
 
 add('mul-jumbo', {
   'bn.js': function() {
-    a1x.mul(b1x);
+    a1j.mul(b1j);
   },
   'bn.js[FFT]': function() {
-    a1x.mulf(b1x);
+    a1j.mulf(b1j);
+  },
+  'bignum': function() {
+    a2j.mul(b2j);
+  },
+  'bigi': function() {
+    a4j.multiply(b4j);
+  },
+  'sjcl': function() {
+    a5j.mul(b5j);
+  },
+  'yaffle': function() {
+    a6j.multiply(b6j);
+  },
+  'silentmatt-biginteger': function() {
+    a8j.multiply(b8j);
   }
 });
 
diff --git a/lib/bn.js b/lib/bn.js
index 60953fc..c1aaedd 100644
--- a/lib/bn.js
+++ b/lib/bn.js
@@ -883,151 +883,24 @@ BN.prototype._bigMulTo = function _bigMulTo(num, out) {
   return out.strip();
 };
 
+BN.prototype.mulTo = function mulTo(num, out) {
+  var res;
+  var len = this.length + num.length;
+  if (len < 63)
+    res = this._smallMulTo(num, out);
+  else if (len < 1024)
+    res = this._bigMulTo(num, out);
+  else
+    res = this._bigMulToF(num, out);
+  return res;
+};
 
-function Complex(r, i) {
-  this.r = r;
-  this.i = i;
-
-  //this._norm();
-}
-
-// private
-function _iaddC(rhs) {
-  this.r += rhs.r;
-  this.i += rhs.i;
-
-  //this._norm();
-
-  return this;
-}
-
-function _addC(rhs) {
-  var t = new Complex(this.r, this.i);
-  t.iadd(rhs);
-  return t;
-}
-
-function _isubC(rhs) {
-  this.r -= rhs.r;
-  this.i -= rhs.i
-
-  //this._norm();
-
-  return this;
-}
-
-function _subC(rhs) {
-  var t = new Complex(this.r, this.i);
-  t.isub(rhs);
-  return t;
-}
-
-function _iconjC() {
-  this.i *= -1;
-  return this;
-}
-
-function _imulC(rhs) {
-  var r = this.r * rhs.r - this.i * rhs.i,
-      i = this.r * rhs.i + this.i * rhs.r;
-
-  this.r = r;
-  this.i = i;
-
-  //this._norm();
-
-  return this;
-}
-
-function _mulC(rhs) {
-  var t = new Complex(this.r, this.i);
-  t.imul(rhs);
-  return t;
-}
-
-function _cloneC() {
-  return new Complex(this.r, this.i);
-}
-
-Complex.prototype.mul   = _mulC;
-Complex.prototype.imul  = _imulC;
-Complex.prototype.add   = _addC;
-Complex.prototype.iadd  = _iaddC;
-Complex.prototype.sub   = _subC;
-Complex.prototype.isub  = _isubC;
-Complex.prototype.iconj = _iconjC;
-Complex.prototype.clone = _cloneC;
-
-//Complex.prototype._isZero = function (v) {
-//  return Math.abs(v) < 1.e-12;
-//}
-
-//Complex.prototype._norm = function () {
-  //if (this._isZero(this.r)) this.r = 0;
-  //if (this._isZero(this.i)) this.i = 0;
-//}
-
-// _FFT(this.words, thisWFT, w, N, 0);
-function _FFT(ws, p, s, tws, tp, r, N) {
-  if (N === 1) {
-    tws[tp] = ws[p];
-    //console.log("p/tp/ws/tws :", p, tp, ws, tws);
-  } else {
-    var hN = N / 2 >> 0;
-
-    var rr = r.mul(r);
-
-    var s_ = 2 * s + 1;
-
-    //console.log("-- FFT -- # ", N);
-    //console.log("-- R -- ", r);
-
-    //console.log("-- RR -- # ", rr);
-
-    _FFT(ws, p,         s_, tws, tp,      rr, hN);  // even
-    _FFT(ws, p + s + 1, s_, tws, tp + hN, rr, hN);  // odd
-
-    var r_ = r.clone();
-
-    for (var i = 0; i < hN; ++i) {
-      var e = tws[tp + i];
-      var o = tws[tp + i + hN].clone();
-
-      //console.log("tp + i, tp + i + hN, tws | ", tp + i, tp + i + hN, tws)
-      //console.log("r_, o, e, (o * r_)", r_, o, e, o.mul(r_));
-
-      o.imul(r_);
-
-      tws[tp + i]      = e.add(o);
-      tws[tp + i + hN] = e.sub(o);
-
-      //console.log(tws);
-
-      //assert(tws[tp + i].r < (0x4000000 * 0x4000000 * 2))
-      //assert(tws[tp + i + hN].r < (0x4000000 * 0x4000000 * 2))
-
-      r_.imul(r);
 
-      //console.log("tws | ", tws)
-    }
-  }
-}
+// Private
 
 var π = 3.14159265359;
 
-
-function _FFTL(rws, iws,  _, __, rtws, itws, ___, ____, N, rbt) {
-  //var hN = N / 2 >> 0;
-
-  //for (var j = 0;                         j < 2;    ++j)
-  //for (var i = 0, hhN = hN >> 1, dN = hN; i < hhN;  ++i, dN >>= 1) {
-  //  tws[2 * i]      = ws[dN + j];
-  //  tws[2 * i + 1]  = ws[dN + j + ];
-  //}
-
-  //console.log("XXXXX")
-  //console.log("WS, TWS", ws, tws)
-
+function _FFTL(rws, iws,  rtws, itws, N, rbt) {
   _permuteTo(rbt, rws, iws, rtws, itws, N);
 
   for (var s = 1; s < N; s <<= 1) {
@@ -1042,38 +915,24 @@ function _FFTL(rws, iws,  _, __, rtws, itws, ___, ____, N, rbt) {
 
       for (var j = 0; j < s; ++j) {
 
-        //var e = tws[p + j];
-
         var re = rtws[p + j];
         var ie = itws[p + j];
 
-        //var o = tws[p + j + s].clone();
-
         var ro = rtws[p + j + s];
         var io = itws[p + j + s];
 
-        //o.imul(r_);
-
         var rx = rtwdf_ * ro - itwdf_ * io;
 
         io = rtwdf_ * io + itwdf_ * ro;
         ro = rx;
 
-        //tws[p + j]      = e.add(o);
-
         rtws[p + j] = re + ro;
         itws[p + j] = ie + io;
 
-        //tws[p + j + s]  = e.sub(o)
-
         rtws[p + j + s] = re - ro;
         itws[p + j + s] = ie - io;
 
-        //assert(tws[p + j].r     < (0x4000000 * 0x4000000 * 2))
-        //assert(tws[p + j + s].r < (0x4000000 * 0x4000000 * 2))
-
         if (j !== l) {
-          //r_.imul(r);
           var rx = rtwdf * rtwdf_ - itwdf * itwdf_;
 
           itwdf_ = rtwdf * itwdf_ + itwdf * rtwdf_;
@@ -1081,8 +940,6 @@ function _FFTL(rws, iws,  _, __, rtws, itws, ___, ____, N, rbt) {
         }
       }
     }
-
-    //console.log(tws)
   }
 }
 
@@ -1097,15 +954,7 @@ function _makeRBT(N) {
 }
 
 function _permuteTo(rbt, rws, iws, rtws, itws, N) {
-  //var l = (Math.log(N) / Math.log(2)) >> 0;
   for (var i = 0; i < N; ++i) {
-    //var r = _revbin(i, l, N);
-    //console.log("REVBIN: ", i, r)
-    //if (r > i) {
-    //  var t = ws[i];
-    //  ws[i] = ws[r];
-    //  ws[r] = t;
-    //}
     rtws[i] = rws[rbt[i]];
     itws[i] = iws[rbt[i]];
   }
@@ -1135,22 +984,7 @@ function _guess13(n, m) {
   return (1 << i + 1 + odd)
 }
 
-function _iconjugate(ws, N) {
-  if (N > 1) {
-    for (var i = 0; i < N / 2; ++i) {
-      var t = ws[i];
-      ws[i] = ws[N - i - 1];
-      ws[N - i - 1] = t;
-
-      ws[i].i         *= -1;
-      ws[N - i - 1].i *= -1;
-    }
-  }
-
-  return ws;
-}
-
-function _iconjugateX(rws, iws, N) {
+function _iconjugate(rws, iws, N) {
   if (N > 1) {
     for (var i = 0; i < N / 2; ++i) {
       var t = rws[i];
@@ -1169,262 +1003,22 @@ function _iconjugateX(rws, iws, N) {
 function _inormalize13(ws, N) {
   var carry = 0;
   for (var i = 0; i < N / 2; ++i) {
-
-    //var n = (((ws[2 * i + 1].r  / N + .5) >> 0) << 13)
-    //      +  ((ws[2 * i].r      / N + .5) >> 0)
-    //      +  carry;
-
-    //if ((Math.round(ws[2 * i + 1].r  / N) << 13) !== (Math.round(ws[2 * i + 1].r  / N) * 0x2000)) {
-    //  console.log(1 << 13, 1 * 0x2000);
-    //  console.log(Math.round(ws[2 * i + 1].r  / N), ((Math.round(ws[2 * i + 1].r  / N)) << 7), (Math.round(ws[2 * i + 1].r  / N) * 0x2000));
-    //  assert((Math.round(ws[2 * i + 1].r / N) << 13) === (Math.round(ws[2 * i + 1].r / N) * 0x2000), "WAAAAAT");
-    //}
-
-    //assert(Math.abs(ws[2 * i].i) < N && Math.abs(ws[2 * i + 1].i) < N)
-    //
-    //var n = (Math.round(ws[2 * i + 1].r  / N) * 0x2000)
-    //      +  Math.round(ws[2 * i].r      / N)
-    //      +  carry;
-
-    var n = (Math.round(ws[2 * i + 1].r  / N) * 0x2000)
-          +  Math.round(ws[2 * i].r      / N)
-          +  carry;
-
-    //console.log(
-    //    n.toString(16),
-    //    carry.toString(16),
-    //    (n & 0x3ffffff).toString(16)
-    //  );
-
-    ws[i] = n & 0x3ffffff;
-
-    if (n < 0x4000000) {
-      carry = 0;
-    } else {
-      carry = Math.floor(n / 0x4000000);
-    }
-  }
-
-  return ws;
-}
-
-
-function _inormalize13X(ws, N) {
-  var carry = 0;
-  for (var i = 0; i < N / 2; ++i) {
-
-    //var n = (((ws[2 * i + 1].r  / N + .5) >> 0) << 13)
-    //      +  ((ws[2 * i].r      / N + .5) >> 0)
-    //      +  carry;
-
-    //if ((Math.round(ws[2 * i + 1].r  / N) << 13) !== (Math.round(ws[2 * i + 1].r  / N) * 0x2000)) {
-    //  console.log(1 << 13, 1 * 0x2000);
-    //  console.log(Math.round(ws[2 * i + 1].r  / N), ((Math.round(ws[2 * i + 1].r  / N)) << 7), (Math.round(ws[2 * i + 1].r  / N) * 0x2000));
-    //  assert((Math.round(ws[2 * i + 1].r / N) << 13) === (Math.round(ws[2 * i + 1].r / N) * 0x2000), "WAAAAAT");
-    //}
-
-    //assert(Math.abs(ws[2 * i].i) < N && Math.abs(ws[2 * i + 1].i) < N)
-    //
-    //var n = (Math.round(ws[2 * i + 1].r  / N) * 0x2000)
-    //      +  Math.round(ws[2 * i].r      / N)
-    //      +  carry;
-
-    var n = (Math.round(ws[2 * i + 1] / N) * 0x2000)
+    var w = (Math.round(ws[2 * i + 1] / N) * 0x2000)
           +  Math.round(ws[2 * i] / N)
           +  carry;
 
-    //console.log(
-    //    n.toString(16),
-    //    carry.toString(16),
-    //    (n & 0x3ffffff).toString(16)
-    //  );
+    ws[i] = w & 0x3ffffff;
 
-    ws[i] = n & 0x3ffffff;
-
-    if (n < 0x4000000) {
+    if (w < 0x4000000) {
       carry = 0;
     } else {
-      carry = Math.floor(n / 0x4000000);
+      carry = Math.floor(w / 0x4000000);
     }
   }
 
   return ws;
 }
 
-function _inormalize20(ws, N) {
-
-  var carry = 0;
-  var seek = 0;
-
-  for (var j = 0; j < N; ++j) {
-    ws[j] = Math.round(ws[j].r / N);
-  }
-
-  for (var i = 0; i < N; ++i) {
-    //var w = (((ws[2 * i + 1].r  / N + .5) >> 0) << 13)
-    //      +  ((ws[2 * i].r      / N + .5) >> 0)
-    //      +  carry;
-
-    //if ((Math.round(ws[2 * i + 1].r  / N) << 13) !== (Math.round(ws[2 * i + 1].r  / N) * 0x2000)) {
-    //  console.log(1 << 13, 1 * 0x2000);
-    //  console.log(Math.round(ws[2 * i + 1].r  / N), ((Math.round(ws[2 * i + 1].r  / N)) << 7), (Math.round(ws[2 * i + 1].r  / N) * 0x2000));
-    //  assert((Math.round(ws[2 * i + 1].r / N) << 13) === (Math.round(ws[2 * i + 1].r / N) * 0x2000), "WAAAAAT");
-    //}
-
-    //assert(Math.abs(ws[2 * i].i) < N && Math.abs(ws[2 * i + 1].i) < N)
-
-    //var w = ws[i];
-    //
-    //assert(w < (0x4000000 * 0x4000000))
-    //
-    //console.log("Before ", w, w & 0x3ffffff, carry);
-    //
-    //if (i + 1 < N) {
-    //  w += ((ws[i + 1] + 0.5) & 0x3ffffff) * 0x100000;
-    //
-    //  ws[i + 1] &= 0x4000000;
-    //}
-    //
-    //w += carry;
-    //
-    //ws[i] = w & 0x3ffffff;
-    //
-    //carry = Math.floor(w / 0x4000000);
-    //
-    //console.log("After ", w, w & 0x3ffffff, carry);
-
-    var w = ws[i];
-
-    //console.log(w, carry, (w & 0x3ffffff));
-
-    var j = i;
-
-    //if (w < 0x4000000)
-    {
-      var pseek = seek;
-      seek += 26 - 20;
-
-      if (seek > 20) {
-        if (i < N - 1) {
-          w += ws[i + 1] * 0x100000 / (1 << pseek)
-
-          // !!!
-          ++i;
-
-          seek -= 20;
-
-          var d = 1 << seek;
-
-          w += (ws[i + 1] & (d - 1)) * (1 << 26 - seek);
-          ws[i + 1] /= d;
-        }
-      }
-      else
-      {
-        var pd  = 1 << (pseek);
-        var d   = 1 << (seek);
-
-        //console.log("D, W, WS[i+1]x ", d, w, (ws[i + 1] & (d - 1)) * 0x100000 / pd)
-
-        w += (ws[i + 1] & (d - 1)) * 0x100000 / pd;
-        ws[i + 1] /= d;
-      }
-    }
-
-    //console.log(w, w & 0x3ffffff, carry)
-
-    assert(w      < 0x4000000 * 0x4000000)
-    assert(carry  < 0x4000000 * 0x4000000)
-
-    w += carry;
-
-    //console.log(w, w & 0x3ffffff, carry)
-
-    ws[j] = w & 0x3ffffff;
-
-    carry = Math.floor(w / 0x4000000);
-  }
-
-  return ws;
-}
-
-function _inormalize18(ws, N) {
-
-  var carry = 0;
-  var seek = 0;
-
-  for (var j = 0; j < N; ++j) {
-    ws[j] = Math.round(ws[j].r / N);
-  }
-
-  for (var i = 0; i < N; ++i) {
-    var w = ws[i];
-
-    //console.log(w, carry, (w & 0x3ffffff));
-
-    var j = i;
-
-    //if (w < 0x4000000)
-    {
-      var pseek = seek;
-      seek += 26 - 18;
-
-      if (seek > 18) {
-        if (i < N - 1) {
-          w += ws[i + 1] * 0x40000 / (1 << pseek)
-
-          // !!!
-          ++i;
-
-          seek -= 18;
-
-          var d = 1 << seek;
-
-          w += (ws[i + 1] & (d - 1)) * (1 << 26 - seek);
-          ws[i + 1] /= d;
-        }
-      }
-      else
-      {
-        var pd  = 1 << (pseek);
-        var d   = 1 << (seek);
-
-        //console.log("D, W, WS[i+1]x ", d, w, (ws[i + 1] & (d - 1)) * 0x100000 / pd)
-
-        w += (ws[i + 1] & (d - 1)) * 0x40000 / pd;
-        ws[i + 1] /= d;
-      }
-    }
-
-    //console.log(w, w & 0x3ffffff, carry)
-
-    assert(w      < 0x4000000 * 0x4000000)
-    assert(carry  < 0x4000000 * 0x4000000)
-
-    w += carry;
-
-    //console.log(w, w & 0x3ffffff, carry)
-
-    ws[j] = w & 0x3ffffff;
-
-    carry = Math.floor(w / 0x4000000);
-  }
-
-  return ws;
-}
-
-
-function _iconvertToC13(ws, N) {
-  var cws = new Array(N);
-  for (var i = 0; i < N / 2; i++) {
-    var w = ws[i] || 0;
-
-    cws[2 * i]      = new Complex(w & 0x1fff, 0);
-    cws[2 * i + 1]  = new Complex(w >>> 13,   0);
-  }
-  return cws;
-}
-
 function _iconvertTo13(ws, rws, N) {
   for (var i = 0; i < N / 2; i++) {
     var w = ws[i] | 0;
@@ -1434,135 +1028,14 @@ function _iconvertTo13(ws, rws, N) {
   }
 }
 
-function _iconvertToC20(ws, N) {
-  var cws = new Array(N);
-
-  for (var i = 0, j = 0, seek = 20; i < N; ++i) {
-    var w = ws[i] || 0;
-    var l = 26;
-
-    while (l > 0) {
-      cws[j] = cws[j] || 0;
-
-      if (seek >= l) {
-        cws[j] += w << (20 - seek);
-
-        seek -= l;
-        if (seek === 0) seek = 20;
-        l = 0;
-      } else {
-        cws[j] += (w & ((1 << seek) - 1)) << (20 - seek);
-        w /= 1 << seek;
-
-        ++j;
-        l -= seek;
-        seek = 20;
-      }
-    }
-  }
-
-  for (i = 0; i < N; ++i) {
-    cws[i] = new Complex(cws[i], 0);
-  }
-
-  return cws;
-}
-
-function _iconvertToC18(ws, N) {
-  var cws = new Array(N);
-
-  for (var i = 0, j = 0, seek = 18; i < N; ++i) {
-    var w = ws[i] || 0;
-    var l = 26;
-
-    while (l > 0) {
-      cws[j] = cws[j] || 0;
-
-      if (seek >= l) {
-        cws[j] += w << (18 - seek);
-
-        seek -= l;
-        if (seek === 0) seek = 18;
-        l = 0;
-      } else {
-        cws[j] += (w & ((1 << seek) - 1)) << (18 - seek);
-        w /= 1 << seek;
-
-        ++j;
-        l -= seek;
-        seek = 18;
-      }
-    }
-  }
-
-  for (i = 0; i < N; ++i) {
-    cws[i] = new Complex(cws[i], 0);
-  }
+function _makePlaceHolderA(N) {
+  var ph = new Array(N);
+  for (var i = 0; i < N; ++i)
+    ph[i] = 0;
 
-  return cws;
+  return ph;
 }
 
-//function _iconvertTo13(ws, N) {
-//  var cws = new Array(N);
-//  var carry = 0;
-//
-//  var i = 0;
-//  for (i = 0; i < N; ++i) {
-//    ws[i] = Math.round(ws[i].r / N);
-//  }
-//
-//  i = 0;
-//  for (var j = 0; true; ++j) {
-//
-//    if (carry < 0x2000) {
-//      if (i === N)
-//        break;
-//
-//      carry += ws[i];
-//      i++;
-//    }
-//
-//    var lo = carry & 0x1fff;  // Here we don't care about overflow, since
-//                              // since overflow may only "screw" (trim) high-order
-//                              // bits, while we're particularly interested in low-order ones
-//
-//    //console.log(carry, lo)
-//
-//    carry = carry / 0x2000;   // Since shift would trigger conversion from
-//                              // float (64) to int (32)
-//
-//    cws[j] = lo;
-//  }
-//
-//  //for (var i = 0; i < N; i++) {
-//  //  carry += Math.round(ws[i].r / N);
-//  //
-//  //
-//  //  var lo = carry & 0x1fff;  // Here we don't care about overflow, since
-//  //                            // since overflow may only "screw" (trim) high-order
-//  //                            // bits, while we're particularly interested in low-order ones
-//  //
-//  //  console.log(carry, lo)
-//  //
-//  //  carry = carry / 0x2000;   // Since shift would trigger conversion from
-//  //                            // float (64) to int (32)
-//  //
-//  //  cws[i] = lo;
-//  //}
-//
-//  return cws;
-//}
-
-BN.prototype.mulTo = function mulTo(num, out) {
-  var res;
-  //if (this.length + num.length < 63)
-  //  res = this._smallMulTo(num, out);
-  //else
-    res = this._bigMulTo(num, out);
-  //  res = this._bigMulToF(num, out);
-  return res;
-};
-
 BN.prototype.mulToF = function mulToF(num, out) {
   var res;
   //if (this.length + num.length < 63)
@@ -1578,29 +1051,10 @@ BN.prototype._bigMulToF = function _bigMulToF(num, out) {
   out.length = this.length + num.length;
 
   var N = 2 * _guess13(this.length, num.length);
-  //var N = _guess13(this.length * 1.3, num.length * 1.3);
-
-  //var w = new Complex(Math.cos(2 * π / N), Math.sin(2 * π / N));
-
-  //console.log("-- W -- ", w);
-
-  //var thisWFT  = new Array(N),
-  //    numWFT   = new Array(N),
-  //    //multWFT  = new Array(N),
-  //    multW    = new Array(N);
-
-  //console.log("A, B: ", this, num);
 
   var rbt = _makeRBT(N);
 
-  //_FFT(_iconvertToC13(this.words, N), 0, 0, thisWFT, 0, w, N);
-  //_FFT(_iconvertToC13(num.words,  N), 0, 0, numWFT,  0, w, N);
-  //_FFT(_iconvertToC20(this.words, N), 0, 0, thisWFT, 0, w, N);
-  //_FFT(_iconvertToC20(num.words,  N), 0, 0, numWFT,  0, w, N);
-  //_FFT(_iconvertToC18(this.words, N), 0, 0, thisWFT, 0, w, N);
-  //_FFT(_iconvertToC18(num.words,  N), 0, 0, numWFT,  0, w, N);
-
-  var ph        = _makePlaceHolderA(N),
+  var _         = _makePlaceHolderA(N),
 
       rThisWs   = new Array(N),
       rThisWsT  = new Array(N),  // T for Transformed
@@ -1615,62 +1069,29 @@ BN.prototype._bigMulToF = function _bigMulToF(num, out) {
   _iconvertTo13(this.words, rThisWs,  N);
   _iconvertTo13(num.words,  rNumWs,   N);
 
-  _FFTL(rThisWs,  ph,  0, 0, rThisWsT, iThisWsT, 0, 0, N, rbt);
-
-  //console.log("X[R/I] Vanilla",     _toArray(rThisWs), _toArray(iThisWs))
-  //console.log("X[R/I] Transformed", _toArray(rThisWsT), _toArray(iThisWsT))
-
-  _FFTL(rNumWs,   ph,   0, 0, rNumWsT,  iNumWsT,  0, 0, N, rbt);
-
-  //console.log("Y[R/I] Vanilla",     _toArray(rNumWs), _toArray(iNumWs))
-  //console.log("Y[R/I] Transformed", _toArray(rNumWsT), _toArray(iNumWsT))
+  _FFTL(rThisWs,  _, rThisWsT, iThisWsT, N, rbt);
+  _FFTL(rNumWs,   _, rNumWsT,  iNumWsT,  N, rbt);
 
   for (var i = 0; i < N; ++i) {
-    //thisWFT[i].imul(numWFT[i]);
     var rx = rThisWsT[i] * rNumWsT[i] - iThisWsT[i] * iNumWsT[i];
 
     iThisWsT[i] = rThisWsT[i] * iNumWsT[i] + iThisWsT[i] * rNumWsT[i]
     rThisWsT[i] = rx;
   }
 
-  //console.log("X * Y[R/I] Transformed", _toArray(rThisWsT), _toArray(iThisWsT))
-
-  //console.log("-- MULF -- ", multWFT);
-
-  //_FFT(_iconjugate(multWFT, N), 0, 0, multW, 0, w, N);
+  _iconjugate(rThisWsT, iThisWsT, N);
 
-  _iconjugateX(rThisWsT, iThisWsT, N);
+  _FFTL(rThisWsT, iThisWsT, rMultWs, _, N, rbt);
 
-  //console.log("X * Y[R/I] Transformed Conjugated", _toArray(rThisWsT), _toArray(iThisWsT))
+  _iconjugate(rMultWs, _, N);
 
-  _FFTL(rThisWsT, iThisWsT, 0, 0, rMultWs, ph, 0, 0, N, rbt);
-
-  //console.log("X * Y[R/I] Inverse FFT", _toArray(rMultWs), _toArray(iMultWs))
-
-  _iconjugateX(rMultWs, ph, N);
-
-  _inormalize13X(rMultWs, N);
-
-  //console.log("X * Y[R/I] Conjugated Normalized", _toArray(rMultWs), _toArray(iMultWs))
-
-  //multW = _inormalize20(_iconjugate(multW, N), N);
-  //multW = _inormalize18(_iconjugate(multW, N), N);
+  _inormalize13(rMultWs, N);
 
   out.words = rMultWs;
 
-  //console.log("-- MUL -- ", multW);
-
   return out.strip();
 };
 
-function _makePlaceHolderA(N) {
-  var ph = new Array(N);
-  for (var i = 0; i < N; ++i)
-    ph[i] = 0;
-
-  return ph;
-}
-
 
 // Multiply `this` by `num`
 BN.prototype.mul = function mul(num) {
diff --git a/test/_fft.js b/test/_fft.js
deleted file mode 100644
index 40237ed..0000000
--- a/test/_fft.js
+++ /dev/null
@@ -1,49 +0,0 @@
-var BN = require("../lib/bn.js").BN
-var fixtures = require("./fixtures.js")
-
-//var a = new BN("1");
-//var b = new BN("1");
-
-//var a = new BN("2");
-//var b = new BN("13");
-
-//var a = new BN("123");
-//var b = new BN("123");
-
-//var a = new BN("12345");
-//var b = new BN("1");
-
-//var a = new BN("123456");
-//var b = new BN("123456");
-
-//var a = new BN("12345690");
-//var b = new BN("1234560");
-
-//var a = new BN("123456900");
-//var b = new BN("12345601");
-
-//var a = new BN("0x2000", 16);
-//var b = new BN("12345678");
-
-//var a = new BN("123456789");
-//var b = new BN("123456789");
-
-//var a = new BN(
-//                '13f29a3e0bc10e100ce0', 16);
-//var b = a.clone();
-
-
-var a = new BN(fixtures.dhGroups.p17.q, 16);
-var b = a.clone();
-var qs = fixtures.dhGroups.p17.qs;
-
-var c   = a.mulf(b);
-var c_  = a.mul(b);
-
-//console.log(c.words);
-console.log(c);
-console.log("------")
-//console.log(c_.words);
-console.log(c_);
-
-//assert(c === new BN(2))

From 955d90d26efa344490afa0daabf582c1517037da Mon Sep 17 00:00:00 2001
From: Alexey Kudinkin <alexey.kudinkin@gmail.com>
Date: Tue, 16 Dec 2014 02:26:35 +0300
Subject: [PATCH 08/12] Tidying up

---
 lib/bn.js | 65 +++++++++++++++++++++++++++++----------------------------------
 1 file changed, 30 insertions(+), 35 deletions(-)

diff --git a/lib/bn.js b/lib/bn.js
index c1aaedd..745641c 100644
--- a/lib/bn.js
+++ b/lib/bn.js
@@ -898,22 +898,20 @@ BN.prototype.mulTo = function mulTo(num, out) {
 
 // Private
 
-var π = 3.14159265359;
-
 function _FFTL(rws, iws,  rtws, itws, N, rbt) {
   _permuteTo(rbt, rws, iws, rtws, itws, N);
 
   for (var s = 1; s < N; s <<= 1) {
-    var l   = s << 1;
+    var l = s << 1;
 
-    var rtwdf = Math.cos(2 * π / l);
-    var itwdf = Math.sin(2 * π / l);
+    var rtwdf = Math.cos(2 * Math.PI / l);
+    var itwdf = Math.sin(2 * Math.PI / l);
 
     for (var p = 0; p < N; p += l) {
       var rtwdf_ = rtwdf;
       var itwdf_ = itwdf;
 
-      for (var j = 0; j < s; ++j) {
+      for (var j = 0; j < s; j++) {
 
         var re = rtws[p + j];
         var ie = itws[p + j];
@@ -946,7 +944,7 @@ function _FFTL(rws, iws,  rtws, itws, N, rbt) {
 function _makeRBT(N) {
   var t = new Array(N);
   var l = (Math.log(N) / Math.log(2)) >> 0;
-  for (var i = 0; i < N; ++i) {
+  for (var i = 0; i < N; i++) {
     t[i] = _revbin(i, l, N);
   }
 
@@ -954,7 +952,7 @@ function _makeRBT(N) {
 }
 
 function _permuteTo(rbt, rws, iws, rtws, itws, N) {
-  for (var i = 0; i < N; ++i) {
+  for (var i = 0; i < N; i++) {
     rtws[i] = rws[rbt[i]];
     itws[i] = iws[rbt[i]];
   }
@@ -965,7 +963,7 @@ function _revbin(x, l, N) {
     return x;
 
   var rb = 0;
-  for (var i = 0; i < l; ++i) {
+  for (var i = 0; i < l; i++) {
     rb |= (x & 1) << (l - i - 1);
     x >>= 1;
   }
@@ -986,33 +984,33 @@ function _guess13(n, m) {
 
 function _iconjugate(rws, iws, N) {
   if (N > 1) {
-    for (var i = 0; i < N / 2; ++i) {
+    for (var i = 0; i < N / 2; i++) {
       var t = rws[i];
 
-      rws[i]          = rws[N - i - 1];
-      rws[N - i - 1]  = t;
+      rws[i] = rws[N - i - 1];
+      rws[N - i - 1] = t;
 
       t = iws[i];
 
-      iws[i]          = -iws[N - i - 1];
-      iws[N - i - 1]  = -t;
+      iws[i] = -iws[N - i - 1];
+      iws[N - i - 1] = -t;
     }
   }
 }
 
 function _inormalize13(ws, N) {
   var carry = 0;
-  for (var i = 0; i < N / 2; ++i) {
-    var w = (Math.round(ws[2 * i + 1] / N) * 0x2000)
-          +  Math.round(ws[2 * i] / N)
-          +  carry;
+  for (var i = 0; i < N / 2; i++) {
+    var w = Math.round(ws[2 * i + 1] / N) * 0x2000 +
+            Math.round(ws[2 * i] / N) +
+            carry;
 
     ws[i] = w & 0x3ffffff;
 
     if (w < 0x4000000) {
       carry = 0;
     } else {
-      carry = Math.floor(w / 0x4000000);
+      carry = w / 0x4000000 | 0;
     }
   }
 
@@ -1023,14 +1021,14 @@ function _iconvertTo13(ws, rws, N) {
   for (var i = 0; i < N / 2; i++) {
     var w = ws[i] | 0;
 
-    rws[2 * i]      = w & 0x1fff;
-    rws[2 * i + 1]  = w >>> 13;
+    rws[2 * i] = w & 0x1fff;
+    rws[2 * i + 1] = w >>> 13;
   }
 }
 
 function _makePlaceHolderA(N) {
   var ph = new Array(N);
-  for (var i = 0; i < N; ++i)
+  for (var i = 0; i < N; i++)
     ph[i] = 0;
 
   return ph;
@@ -1038,10 +1036,7 @@ function _makePlaceHolderA(N) {
 
 BN.prototype.mulToF = function mulToF(num, out) {
   var res;
-  //if (this.length + num.length < 63)
-  //  res = this._smallMulTo(num, out);
-  //else
-    res = this._bigMulToF(num, out);
+  res = this._bigMulToF(num, out);
   return res;
 };
 
@@ -1054,17 +1049,17 @@ BN.prototype._bigMulToF = function _bigMulToF(num, out) {
 
   var rbt = _makeRBT(N);
 
-  var _         = _makePlaceHolderA(N),
+  var _ = _makePlaceHolderA(N),
 
-      rThisWs   = new Array(N),
-      rThisWsT  = new Array(N),  // T for Transformed
-      iThisWsT  = new Array(N),
+      rThisWs = new Array(N),
+      rThisWsT = new Array(N),  // T for Transformed
+      iThisWsT = new Array(N),
 
-      rNumWs    = new Array(N),
-      rNumWsT   = new Array(N),
-      iNumWsT   = new Array(N),
+      rNumWs = new Array(N),
+      rNumWsT = new Array(N),
+      iNumWsT = new Array(N),
 
-      rMultWs   = new Array(N);
+      rMultWs = new Array(N);
 
   _iconvertTo13(this.words, rThisWs,  N);
   _iconvertTo13(num.words,  rNumWs,   N);
@@ -1072,7 +1067,7 @@ BN.prototype._bigMulToF = function _bigMulToF(num, out) {
   _FFTL(rThisWs,  _, rThisWsT, iThisWsT, N, rbt);
   _FFTL(rNumWs,   _, rNumWsT,  iNumWsT,  N, rbt);
 
-  for (var i = 0; i < N; ++i) {
+  for (var i = 0; i < N; i++) {
     var rx = rThisWsT[i] * rNumWsT[i] - iThisWsT[i] * iNumWsT[i];
 
     iThisWsT[i] = rThisWsT[i] * iNumWsT[i] + iThisWsT[i] * rNumWsT[i]

From 22f4a713b509e7166d05ee800de5dff863a3bd7c Mon Sep 17 00:00:00 2001
From: Alexey Kudinkin <alexey.kudinkin@gmail.com>
Date: Fri, 19 Dec 2014 20:48:02 +0300
Subject: [PATCH 09/12] Extracted FFT multiplier as class; Minor cosmetic fixes

---
 lib/bn.js | 158 ++++++++++++++++++++++++++++++++------------------------------
 1 file changed, 81 insertions(+), 77 deletions(-)

diff --git a/lib/bn.js b/lib/bn.js
index 745641c..285a08d 100644
--- a/lib/bn.js
+++ b/lib/bn.js
@@ -898,8 +898,43 @@ BN.prototype.mulTo = function mulTo(num, out) {
 
 // Private
 
-function _FFTL(rws, iws,  rtws, itws, N, rbt) {
-  _permuteTo(rbt, rws, iws, rtws, itws, N);
+var FFTM = function (x, y) {
+  this.x = x;
+  this.y = y;
+}
+
+FFTM.prototype.make_rbt = function (N) {
+  var t = new Array(N);
+  var l = (Math.log(N) / Math.log(2)) >> 0;
+  for (var i = 0; i < N; i++) {
+    t[i] = this.revbin(i, l, N);
+  }
+
+  return t;
+}
+
+FFTM.prototype.revbin = function (x, l, N) {
+  if (x === 0 || x === N - 1)
+    return x;
+
+  var rb = 0;
+  for (var i = 0; i < l; i++) {
+    rb |= (x & 1) << (l - i - 1);
+    x >>= 1;
+  }
+
+  return rb;
+}
+
+FFTM.prototype.permute = function (rbt, rws, iws, rtws, itws, N) {
+  for (var i = 0; i < N; i++) {
+    rtws[i] = rws[rbt[i]];
+    itws[i] = iws[rbt[i]];
+  }
+}
+
+FFTM.prototype.transform = function (rws, iws, rtws, itws, N, rbt) {
+  this.permute(rbt, rws, iws, rtws, itws, N);
 
   for (var s = 1; s < N; s <<= 1) {
     var l = s << 1;
@@ -931,7 +966,7 @@ function _FFTL(rws, iws,  rtws, itws, N, rbt) {
         itws[p + j + s] = ie - io;
 
         if (j !== l) {
-          var rx = rtwdf * rtwdf_ - itwdf * itwdf_;
+          rx = rtwdf * rtwdf_ - itwdf * itwdf_;
 
           itwdf_ = rtwdf * itwdf_ + itwdf * rtwdf_;
           rtwdf_ = rx;
@@ -941,48 +976,18 @@ function _FFTL(rws, iws,  rtws, itws, N, rbt) {
   }
 }
 
-function _makeRBT(N) {
-  var t = new Array(N);
-  var l = (Math.log(N) / Math.log(2)) >> 0;
-  for (var i = 0; i < N; i++) {
-    t[i] = _revbin(i, l, N);
-  }
-
-  return t;
-}
-
-function _permuteTo(rbt, rws, iws, rtws, itws, N) {
-  for (var i = 0; i < N; i++) {
-    rtws[i] = rws[rbt[i]];
-    itws[i] = iws[rbt[i]];
-  }
-}
-
-function _revbin(x, l, N) {
-  if (x === 0 || x === N - 1)
-    return x;
-
-  var rb = 0;
-  for (var i = 0; i < l; i++) {
-    rb |= (x & 1) << (l - i - 1);
-    x >>= 1;
-  }
-
-  return rb;
-}
-
-
-function _guess13(n, m) {
-  var N = Math.max(m, n) | 1, odd = N & 1;
+FFTM.prototype.guess_len_13b = function (n, m) {
+  var N = Math.max(m, n) | 1;
+  var odd = N & 1;
   var i = 0;
   while (N = N / 2 >> 0) {
     i++;
   }
 
-  return (1 << i + 1 + odd)
+  return 1 << i + 1 + odd;
 }
 
-function _iconjugate(rws, iws, N) {
+FFTM.prototype.conjugate = function (rws, iws, N) {
   if (N > 1) {
     for (var i = 0; i < N / 2; i++) {
       var t = rws[i];
@@ -998,7 +1003,7 @@ function _iconjugate(rws, iws, N) {
   }
 }
 
-function _inormalize13(ws, N) {
+FFTM.prototype.normalize_13b = function (ws, N) {
   var carry = 0;
   for (var i = 0; i < N / 2; i++) {
     var w = Math.round(ws[2 * i + 1] / N) * 0x2000 +
@@ -1017,7 +1022,7 @@ function _inormalize13(ws, N) {
   return ws;
 }
 
-function _iconvertTo13(ws, rws, N) {
+FFTM.prototype.convert_13b = function (ws, rws, N) {
   for (var i = 0; i < N / 2; i++) {
     var w = ws[i] | 0;
 
@@ -1026,46 +1031,39 @@ function _iconvertTo13(ws, rws, N) {
   }
 }
 
-function _makePlaceHolderA(N) {
-  var ph = new Array(N);
-  for (var i = 0; i < N; i++)
-    ph[i] = 0;
+FFTM.prototype.mulp = function () {
+  function stub(N) {
+    var ph = new Array(N);
+    for (var i = 0; i < N; i++)
+      ph[i] = 0;
 
-  return ph;
-}
+    return ph;
+  }
 
-BN.prototype.mulToF = function mulToF(num, out) {
-  var res;
-  res = this._bigMulToF(num, out);
-  return res;
-};
+  var x = this.x;
+  var y = this.y;
 
+  var N = 2 * this.guess_len_13b(x.length, y.length);
 
-BN.prototype._bigMulToF = function _bigMulToF(num, out) {
-  out.sign = num.sign !== this.sign;
-  out.length = this.length + num.length;
+  var rbt = this.make_rbt(N);
 
-  var N = 2 * _guess13(this.length, num.length);
+  var _ = stub(N),
 
-  var rbt = _makeRBT(N);
+    rThisWs = new Array(N),
+    rThisWsT = new Array(N),  // T for Transformed
+    iThisWsT = new Array(N),
 
-  var _ = _makePlaceHolderA(N),
+    rNumWs = new Array(N),
+    rNumWsT = new Array(N),
+    iNumWsT = new Array(N),
 
-      rThisWs = new Array(N),
-      rThisWsT = new Array(N),  // T for Transformed
-      iThisWsT = new Array(N),
+    rMultWs = new Array(N);
 
-      rNumWs = new Array(N),
-      rNumWsT = new Array(N),
-      iNumWsT = new Array(N),
+  this.convert_13b(x.words, rThisWs, N);
+  this.convert_13b(y.words, rNumWs, N);
 
-      rMultWs = new Array(N);
-
-  _iconvertTo13(this.words, rThisWs,  N);
-  _iconvertTo13(num.words,  rNumWs,   N);
-
-  _FFTL(rThisWs,  _, rThisWsT, iThisWsT, N, rbt);
-  _FFTL(rNumWs,   _, rNumWsT,  iNumWsT,  N, rbt);
+  this.transform(rThisWs, _, rThisWsT, iThisWsT, N, rbt);
+  this.transform(rNumWs, _, rNumWsT, iNumWsT, N, rbt);
 
   for (var i = 0; i < N; i++) {
     var rx = rThisWsT[i] * rNumWsT[i] - iThisWsT[i] * iNumWsT[i];
@@ -1074,15 +1072,22 @@ BN.prototype._bigMulToF = function _bigMulToF(num, out) {
     rThisWsT[i] = rx;
   }
 
-  _iconjugate(rThisWsT, iThisWsT, N);
+  this.conjugate(rThisWsT, iThisWsT, N);
+
+  this.transform(rThisWsT, iThisWsT, rMultWs, _, N, rbt);
+
+  this.conjugate(rMultWs, _, N);
 
-  _FFTL(rThisWsT, iThisWsT, rMultWs, _, N, rbt);
+  this.normalize_13b(rMultWs, N);
 
-  _iconjugate(rMultWs, _, N);
+  return rMultWs;
+}
 
-  _inormalize13(rMultWs, N);
+BN.prototype._bigMulToF = function _bigMulToF(num, out) {
+  out.sign = num.sign !== this.sign;
+  out.length = this.length + num.length;
 
-  out.words = rMultWs;
+  out.words = (new FFTM(this, num)).mulp();
 
   return out.strip();
 };
@@ -1098,9 +1103,8 @@ BN.prototype.mul = function mul(num) {
 // Multiply employing FFT
 BN.prototype.mulf = function mulf(num) {
   var out = new BN(null);
-  //out.words = new Array(this.length + num.length);
   out.words = null;
-  return this.mulToF(num, out);
+  return this._bigMulToF(num, out);
 };
 
 // In-place Multiplication

From c51b380a9acb25b1c09cb805ec708e836e921a00 Mon Sep 17 00:00:00 2001
From: Alexey Kudinkin <alexey.kudinkin@gmail.com>
Date: Sun, 11 Jan 2015 06:12:05 +0300
Subject: [PATCH 10/12] Minor style fixes

---
 lib/bn.js | 36 ++++++++++++++++++------------------
 1 file changed, 18 insertions(+), 18 deletions(-)

diff --git a/lib/bn.js b/lib/bn.js
index 285a08d..7705741 100644
--- a/lib/bn.js
+++ b/lib/bn.js
@@ -898,12 +898,12 @@ BN.prototype.mulTo = function mulTo(num, out) {
 
 // Private
 
-var FFTM = function (x, y) {
+function FFTM(x, y) {
   this.x = x;
   this.y = y;
 }
 
-FFTM.prototype.make_rbt = function (N) {
+FFTM.prototype.makeRBT = function makeRBT(N) {
   var t = new Array(N);
   var l = (Math.log(N) / Math.log(2)) >> 0;
   for (var i = 0; i < N; i++) {
@@ -913,7 +913,7 @@ FFTM.prototype.make_rbt = function (N) {
   return t;
 }
 
-FFTM.prototype.revbin = function (x, l, N) {
+FFTM.prototype.revbin = function revbin(x, l, N) {
   if (x === 0 || x === N - 1)
     return x;
 
@@ -926,14 +926,14 @@ FFTM.prototype.revbin = function (x, l, N) {
   return rb;
 }
 
-FFTM.prototype.permute = function (rbt, rws, iws, rtws, itws, N) {
+FFTM.prototype.permute = function permute(rbt, rws, iws, rtws, itws, N) {
   for (var i = 0; i < N; i++) {
     rtws[i] = rws[rbt[i]];
     itws[i] = iws[rbt[i]];
   }
 }
 
-FFTM.prototype.transform = function (rws, iws, rtws, itws, N, rbt) {
+FFTM.prototype.transform = function transform(rws, iws, rtws, itws, N, rbt) {
   this.permute(rbt, rws, iws, rtws, itws, N);
 
   for (var s = 1; s < N; s <<= 1) {
@@ -947,7 +947,6 @@ FFTM.prototype.transform = function (rws, iws, rtws, itws, N, rbt) {
       var itwdf_ = itwdf;
 
       for (var j = 0; j < s; j++) {
-
         var re = rtws[p + j];
         var ie = itws[p + j];
 
@@ -976,7 +975,7 @@ FFTM.prototype.transform = function (rws, iws, rtws, itws, N, rbt) {
   }
 }
 
-FFTM.prototype.guess_len_13b = function (n, m) {
+FFTM.prototype.guessLen13b = function guessLen13b(n, m) {
   var N = Math.max(m, n) | 1;
   var odd = N & 1;
   var i = 0;
@@ -988,18 +987,19 @@ FFTM.prototype.guess_len_13b = function (n, m) {
 }
 
 FFTM.prototype.conjugate = function (rws, iws, N) {
-  if (N > 1) {
-    for (var i = 0; i < N / 2; i++) {
-      var t = rws[i];
+  if (N <= 1)
+    return;
 
-      rws[i] = rws[N - i - 1];
-      rws[N - i - 1] = t;
+  for (var i = 0; i < N / 2; i++) {
+    var t = rws[i];
 
-      t = iws[i];
+    rws[i] = rws[N - i - 1];
+    rws[N - i - 1] = t;
 
-      iws[i] = -iws[N - i - 1];
-      iws[N - i - 1] = -t;
-    }
+    t = iws[i];
+
+    iws[i] = -iws[N - i - 1];
+    iws[N - i - 1] = -t;
   }
 }
 
@@ -1043,9 +1043,9 @@ FFTM.prototype.mulp = function () {
   var x = this.x;
   var y = this.y;
 
-  var N = 2 * this.guess_len_13b(x.length, y.length);
+  var N = 2 * this.guessLen13b(x.length, y.length);
 
-  var rbt = this.make_rbt(N);
+  var rbt = this.makeRBT(N);
 
   var _ = stub(N),
 

From 72f5498499baec7b4052550892ca52caff33d21c Mon Sep 17 00:00:00 2001
From: Alexey Kudinkin <alexey.kudinkin@gmail.com>
Date: Mon, 12 Jan 2015 17:21:43 +0300
Subject: [PATCH 11/12] Continuous style fixes

---
 lib/bn.js | 16 +++++++---------
 1 file changed, 7 insertions(+), 9 deletions(-)

diff --git a/lib/bn.js b/lib/bn.js
index 7705741..7081948 100644
--- a/lib/bn.js
+++ b/lib/bn.js
@@ -905,7 +905,7 @@ function FFTM(x, y) {
 
 FFTM.prototype.makeRBT = function makeRBT(N) {
   var t = new Array(N);
-  var l = (Math.log(N) / Math.log(2)) >> 0;
+  var l = (Math.log(N) / Math.log(2)) | 0;
   for (var i = 0; i < N; i++) {
     t[i] = this.revbin(i, l, N);
   }
@@ -979,7 +979,7 @@ FFTM.prototype.guessLen13b = function guessLen13b(n, m) {
   var N = Math.max(m, n) | 1;
   var odd = N & 1;
   var i = 0;
-  while (N = N / 2 >> 0) {
+  while (N = N / 2 | 0) {
     i++;
   }
 
@@ -1003,7 +1003,7 @@ FFTM.prototype.conjugate = function (rws, iws, N) {
   }
 }
 
-FFTM.prototype.normalize_13b = function (ws, N) {
+FFTM.prototype.normalize13b = function (ws, N) {
   var carry = 0;
   for (var i = 0; i < N / 2; i++) {
     var w = Math.round(ws[2 * i + 1] / N) * 0x2000 +
@@ -1022,7 +1022,7 @@ FFTM.prototype.normalize_13b = function (ws, N) {
   return ws;
 }
 
-FFTM.prototype.convert_13b = function (ws, rws, N) {
+FFTM.prototype.convert13b = function (ws, rws, N) {
   for (var i = 0; i < N / 2; i++) {
     var w = ws[i] | 0;
 
@@ -1059,8 +1059,8 @@ FFTM.prototype.mulp = function () {
 
     rMultWs = new Array(N);
 
-  this.convert_13b(x.words, rThisWs, N);
-  this.convert_13b(y.words, rNumWs, N);
+  this.convert13b(x.words, rThisWs, N);
+  this.convert13b(y.words, rNumWs, N);
 
   this.transform(rThisWs, _, rThisWsT, iThisWsT, N, rbt);
   this.transform(rNumWs, _, rNumWsT, iNumWsT, N, rbt);
@@ -1078,7 +1078,7 @@ FFTM.prototype.mulp = function () {
 
   this.conjugate(rMultWs, _, N);
 
-  this.normalize_13b(rMultWs, N);
+  this.normalize13b(rMultWs, N);
 
   return rMultWs;
 }
@@ -1086,7 +1086,6 @@ FFTM.prototype.mulp = function () {
 BN.prototype._bigMulToF = function _bigMulToF(num, out) {
   out.sign = num.sign !== this.sign;
   out.length = this.length + num.length;
-
   out.words = (new FFTM(this, num)).mulp();
 
   return out.strip();
@@ -1103,7 +1102,6 @@ BN.prototype.mul = function mul(num) {
 // Multiply employing FFT
 BN.prototype.mulf = function mulf(num) {
   var out = new BN(null);
-  out.words = null;
   return this._bigMulToF(num, out);
 };
 

From b3b5d959b6cb9dd2f8fc270fe8a64b9a54151d1c Mon Sep 17 00:00:00 2001
From: Alexey Kudinkin <alexey.kudinkin@gmail.com>
Date: Mon, 9 Feb 2015 23:43:13 +0300
Subject: [PATCH 12/12] Sligthly refurbished overall style; Fixed lint issues

---
 lib/bn.js | 63 +++++++++++++++++++++++++++++++--------------------------------
 1 file changed, 31 insertions(+), 32 deletions(-)

diff --git a/lib/bn.js b/lib/bn.js
index 7081948..5b553e4 100644
--- a/lib/bn.js
+++ b/lib/bn.js
@@ -911,7 +911,7 @@ FFTM.prototype.makeRBT = function makeRBT(N) {
   }
 
   return t;
-}
+};
 
 FFTM.prototype.revbin = function revbin(x, l, N) {
   if (x === 0 || x === N - 1)
@@ -924,14 +924,14 @@ FFTM.prototype.revbin = function revbin(x, l, N) {
   }
 
   return rb;
-}
+};
 
 FFTM.prototype.permute = function permute(rbt, rws, iws, rtws, itws, N) {
   for (var i = 0; i < N; i++) {
     rtws[i] = rws[rbt[i]];
     itws[i] = iws[rbt[i]];
   }
-}
+};
 
 FFTM.prototype.transform = function transform(rws, iws, rtws, itws, N, rbt) {
   this.permute(rbt, rws, iws, rtws, itws, N);
@@ -964,6 +964,7 @@ FFTM.prototype.transform = function transform(rws, iws, rtws, itws, N, rbt) {
         rtws[p + j + s] = re - ro;
         itws[p + j + s] = ie - io;
 
+        /* jshint maxdepth : false */
         if (j !== l) {
           rx = rtwdf * rtwdf_ - itwdf * itwdf_;
 
@@ -973,18 +974,18 @@ FFTM.prototype.transform = function transform(rws, iws, rtws, itws, N, rbt) {
       }
     }
   }
-}
+};
 
 FFTM.prototype.guessLen13b = function guessLen13b(n, m) {
   var N = Math.max(m, n) | 1;
   var odd = N & 1;
   var i = 0;
-  while (N = N / 2 | 0) {
+  for (N = N / 2 | 0; N; N = N / 2 | 0) {
     i++;
   }
 
   return 1 << i + 1 + odd;
-}
+};
 
 FFTM.prototype.conjugate = function (rws, iws, N) {
   if (N <= 1)
@@ -1001,7 +1002,7 @@ FFTM.prototype.conjugate = function (rws, iws, N) {
     iws[i] = -iws[N - i - 1];
     iws[N - i - 1] = -t;
   }
-}
+};
 
 FFTM.prototype.normalize13b = function (ws, N) {
   var carry = 0;
@@ -1020,7 +1021,7 @@ FFTM.prototype.normalize13b = function (ws, N) {
   }
 
   return ws;
-}
+};
 
 FFTM.prototype.convert13b = function (ws, rws, N) {
   for (var i = 0; i < N / 2; i++) {
@@ -1029,7 +1030,7 @@ FFTM.prototype.convert13b = function (ws, rws, N) {
     rws[2 * i] = w & 0x1fff;
     rws[2 * i + 1] = w >>> 13;
   }
-}
+};
 
 FFTM.prototype.mulp = function () {
   function stub(N) {
@@ -1047,47 +1048,45 @@ FFTM.prototype.mulp = function () {
 
   var rbt = this.makeRBT(N);
 
-  var _ = stub(N),
+  var _ = stub(N);
 
-    rThisWs = new Array(N),
-    rThisWsT = new Array(N),  // T for Transformed
-    iThisWsT = new Array(N),
+  var rws   = new Array(N);
+  var rwst  = new Array(N);
+  var iwst  = new Array(N);
 
-    rNumWs = new Array(N),
-    rNumWsT = new Array(N),
-    iNumWsT = new Array(N),
+  var nrws  = new Array(N);
+  var nrwst = new Array(N);
+  var niwst = new Array(N);
 
-    rMultWs = new Array(N);
+  var rmws = new Array(N);
 
-  this.convert13b(x.words, rThisWs, N);
-  this.convert13b(y.words, rNumWs, N);
+  this.convert13b(x.words, rws, N);
+  this.convert13b(y.words, nrws, N);
 
-  this.transform(rThisWs, _, rThisWsT, iThisWsT, N, rbt);
-  this.transform(rNumWs, _, rNumWsT, iNumWsT, N, rbt);
+  this.transform(rws, _, rwst, iwst, N, rbt);
+  this.transform(nrws, _, nrwst, niwst, N, rbt);
 
   for (var i = 0; i < N; i++) {
-    var rx = rThisWsT[i] * rNumWsT[i] - iThisWsT[i] * iNumWsT[i];
-
-    iThisWsT[i] = rThisWsT[i] * iNumWsT[i] + iThisWsT[i] * rNumWsT[i]
-    rThisWsT[i] = rx;
+    var rx = rwst[i] * nrwst[i] - iwst[i] * niwst[i];
+    iwst[i] = rwst[i] * niwst[i] + iwst[i] * nrwst[i];
+    rwst[i] = rx;
   }
 
-  this.conjugate(rThisWsT, iThisWsT, N);
+  this.conjugate(rwst, iwst, N);
 
-  this.transform(rThisWsT, iThisWsT, rMultWs, _, N, rbt);
+  this.transform(rwst, iwst, rmws, _, N, rbt);
 
-  this.conjugate(rMultWs, _, N);
+  this.conjugate(rmws, _, N);
 
-  this.normalize13b(rMultWs, N);
+  this.normalize13b(rmws, N);
 
-  return rMultWs;
-}
+  return rmws;
+};
 
 BN.prototype._bigMulToF = function _bigMulToF(num, out) {
   out.sign = num.sign !== this.sign;
   out.length = this.length + num.length;
   out.words = (new FFTM(this, num)).mulp();
-
   return out.strip();
 };