(function (GLOBAL) { //lib v1.4.2b

'use strict';

/* Utility Libraries required for Standard operations

* All credits for these codes belong to their respective creators, moderators and owners.

* For more info (including license and terms of use), please visit respective source.

*/

GLOBAL.cryptocoin = (typeof floGlobals === 'undefined' ? null : floGlobals.blockchain) || 'FLO';

const getRandomBytes = (function () {

if (typeof require === 'function') {

const crypto = require('crypto');

return function (buf) {

var bytes = crypto.randomBytes(buf.length);

buf.set(bytes);

return buf;

}

} else if (GLOBAL.crypto && GLOBAL.crypto.getRandomValues) {

return function (buf) {

return GLOBAL.crypto.getRandomValues(buf);

}

} else

throw Error('Unable to define getRandomBytes');

})();

GLOBAL.securedMathRandom = (function () {

if (typeof require === 'function') {

const crypto = require('crypto');

return function () {

return crypto.randomBytes(4).readUInt32LE() / 0xffffffff;

}

} else if (GLOBAL.crypto && GLOBAL.crypto.getRandomValues) {

return function () {

return (GLOBAL.crypto.getRandomValues(new Uint32Array(1))[0] / 0xffffffff);

}

} else

throw Error('Unable to define securedMathRandom');

})();

//Crypto.js

(function () {

// Global Crypto object

var Crypto = GLOBAL.Crypto = {};

/*!

* Crypto-JS v2.5.4 Crypto.js

* http://code.google.com/p/crypto-js/

* Copyright (c) 2009-2013, Jeff Mott. All rights reserved.

* http://code.google.com/p/crypto-js/wiki/License

*/

(function () {

var base64map = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";

// Crypto utilities

var util = Crypto.util = {

// Bit-wise rotate left

rotl: function (n, b) {

return (n << b) | (n >>> (32 - b));

},

// Bit-wise rotate right

rotr: function (n, b) {

return (n << (32 - b)) | (n >>> b);

},

// Swap big-endian to little-endian and vice versa

endian: function (n) {

// If number given, swap endian

if (n.constructor == Number) {

return util.rotl(n, 8) & 0x00FF00FF |

util.rotl(n, 24) & 0xFF00FF00;

}

// Else, assume array and swap all items

for (var i = 0; i < n.length; i++)

n[i] = util.endian(n[i]);

return n;

},

// Generate an array of any length of random bytes

randomBytes: function (n) {

for (var bytes = []; n > 0; n--)

bytes.push(Math.floor(securedMathRandom() * 256));

return bytes;

},

// Convert a byte array to big-endian 32-bit words

bytesToWords: function (bytes) {

for (var words = [], i = 0, b = 0; i < bytes.length; i++, b += 8)

words[b >>> 5] |= (bytes[i] & 0xFF) << (24 - b % 32);

return words;

},

// Convert big-endian 32-bit words to a byte array

wordsToBytes: function (words) {

for (var bytes = [], b = 0; b < words.length * 32; b += 8)

bytes.push((words[b >>> 5] >>> (24 - b % 32)) & 0xFF);

return bytes;

},

// Convert a byte array to a hex string

bytesToHex: function (bytes) {

for (var hex = [], i = 0; i < bytes.length; i++) {

hex.push((bytes[i] >>> 4).toString(16));

hex.push((bytes[i] & 0xF).toString(16));

}

return hex.join("");

},

// Convert a hex string to a byte array

hexToBytes: function (hex) {

for (var bytes = [], c = 0; c < hex.length; c += 2)

bytes.push(parseInt(hex.substr(c, 2), 16));

return bytes;

},

// Convert a byte array to a base-64 string

bytesToBase64: function (bytes) {

for (var base64 = [], i = 0; i < bytes.length; i += 3) {

var triplet = (bytes[i] << 16) | (bytes[i + 1] << 8) | bytes[i + 2];

for (var j = 0; j < 4; j++) {

if (i * 8 + j * 6 <= bytes.length * 8)

base64.push(base64map.charAt((triplet >>> 6 * (3 - j)) & 0x3F));

else base64.push("=");

}

}

return base64.join("");

},

// Convert a base-64 string to a byte array

base64ToBytes: function (base64) {

// Remove non-base-64 characters

base64 = base64.replace(/[^A-Z0-9+\/]/ig, "");

for (var bytes = [], i = 0, imod4 = 0; i < base64.length; imod4 = ++i % 4) {

if (imod4 == 0) continue;

bytes.push(((base64map.indexOf(base64.charAt(i - 1)) & (Math.pow(2, -2 * imod4 + 8) - 1)) << (imod4 * 2)) |

(base64map.indexOf(base64.charAt(i)) >>> (6 - imod4 * 2)));

}

return bytes;

}

};

// Crypto character encodings

var charenc = Crypto.charenc = {};

// UTF-8 encoding

var UTF8 = charenc.UTF8 = {

// Convert a string to a byte array

stringToBytes: function (str) {

return Binary.stringToBytes(unescape(encodeURIComponent(str)));

},

// Convert a byte array to a string

bytesToString: function (bytes) {

return decodeURIComponent(escape(Binary.bytesToString(bytes)));

}

};

// Binary encoding

var Binary = charenc.Binary = {

// Convert a string to a byte array

stringToBytes: function (str) {

for (var bytes = [], i = 0; i < str.length; i++)

bytes.push(str.charCodeAt(i) & 0xFF);

return bytes;

},

// Convert a byte array to a string

bytesToString: function (bytes) {

for (var str = [], i = 0; i < bytes.length; i++)

str.push(String.fromCharCode(bytes[i]));

return str.join("");

}

};

})();

//Adding SHA1 to fix basic PKBDF2

/*

* Crypto-JS v2.5.4

* http://code.google.com/p/crypto-js/

* (c) 2009-2012 by Jeff Mott. All rights reserved.

* http://code.google.com/p/crypto-js/wiki/License

*/

(function () {

// Shortcuts

var C = Crypto,

util = C.util,

charenc = C.charenc,

UTF8 = charenc.UTF8,

Binary = charenc.Binary;

// Public API

var SHA1 = C.SHA1 = function (message, options) {

var digestbytes = util.wordsToBytes(SHA1._sha1(message));

return options && options.asBytes ? digestbytes :

options && options.asString ? Binary.bytesToString(digestbytes) :

util.bytesToHex(digestbytes);

};

// The core

SHA1._sha1 = function (message) {

// Convert to byte array

if (message.constructor == String) message = UTF8.stringToBytes(message);

/* else, assume byte array already */

var m = util.bytesToWords(message),

l = message.length * 8,

w = [],

H0 = 1732584193,

H1 = -271733879,

H2 = -1732584194,

H3 = 271733878,

H4 = -1009589776;

// Padding

m[l >> 5] |= 0x80 << (24 - l % 32);

m[((l + 64 >>> 9) << 4) + 15] = l;

for (var i = 0; i < m.length; i += 16) {

var a = H0,

b = H1,

c = H2,

d = H3,

e = H4;

for (var j = 0; j < 80; j++) {

if (j < 16) w[j] = m[i + j];

else {

var n = w[j - 3] ^ w[j - 8] ^ w[j - 14] ^ w[j - 16];

w[j] = (n << 1) | (n >>> 31);

}

var t = ((H0 << 5) | (H0 >>> 27)) + H4 + (w[j] >>> 0) + (

j < 20 ? (H1 & H2 | ~H1 & H3) + 1518500249 :

j < 40 ? (H1 ^ H2 ^ H3) + 1859775393 :

j < 60 ? (H1 & H2 | H1 & H3 | H2 & H3) - 1894007588 :

(H1 ^ H2 ^ H3) - 899497514);

H4 = H3;

H3 = H2;

H2 = (H1 << 30) | (H1 >>> 2);

H1 = H0;

H0 = t;

}

H0 += a;

H1 += b;

H2 += c;

H3 += d;

H4 += e;

}

return [H0, H1, H2, H3, H4];

};

// Package private blocksize

SHA1._blocksize = 16;

SHA1._digestsize = 20;

})();

//Added to make PKBDF2 work

/*

* Crypto-JS v2.5.4

* http://code.google.com/p/crypto-js/

* (c) 2009-2012 by Jeff Mott. All rights reserved.

* http://code.google.com/p/crypto-js/wiki/License

*/

(function () {

// Shortcuts

var C = Crypto,

util = C.util,

charenc = C.charenc,

UTF8 = charenc.UTF8,

Binary = charenc.Binary;

C.HMAC = function (hasher, message, key, options) {

// Convert to byte arrays

if (message.constructor == String) message = UTF8.stringToBytes(message);

if (key.constructor == String) key = UTF8.stringToBytes(key);

/* else, assume byte arrays already */

// Allow arbitrary length keys

if (key.length > hasher._blocksize * 4)

key = hasher(key, {

asBytes: true

});

// XOR keys with pad constants

var okey = key.slice(0),

ikey = key.slice(0);

for (var i = 0; i < hasher._blocksize * 4; i++) {

okey[i] ^= 0x5C;

ikey[i] ^= 0x36;

}

var hmacbytes = hasher(okey.concat(hasher(ikey.concat(message), {

asBytes: true

})), {

asBytes: true

});

return options && options.asBytes ? hmacbytes :

options && options.asString ? Binary.bytesToString(hmacbytes) :

util.bytesToHex(hmacbytes);

};

})();

//crypto-sha256-hmac.js

/*

* Crypto-JS v2.5.4

* http://code.google.com/p/crypto-js/

* (c) 2009-2012 by Jeff Mott. All rights reserved.

* http://code.google.com/p/crypto-js/wiki/License

*/

(function () {

var d = Crypto,

k = d.util,

g = d.charenc,

b = g.UTF8,

a = g.Binary,

c = [1116352408, 1899447441, 3049323471, 3921009573, 961987163, 1508970993, 2453635748, 2870763221,

3624381080, 310598401, 607225278, 1426881987, 1925078388, 2162078206, 2614888103, 3248222580,

3835390401, 4022224774, 264347078, 604807628, 770255983, 1249150122, 1555081692, 1996064986,

2554220882, 2821834349, 2952996808, 3210313671, 3336571891, 3584528711, 113926993, 338241895,

666307205, 773529912, 1294757372, 1396182291, 1695183700, 1986661051, 2177026350, 2456956037,

2730485921,

2820302411, 3259730800, 3345764771, 3516065817, 3600352804, 4094571909, 275423344, 430227734,

506948616, 659060556, 883997877, 958139571, 1322822218, 1537002063, 1747873779, 1955562222,

2024104815, 2227730452, 2361852424, 2428436474, 2756734187, 3204031479, 3329325298

],

e = d.SHA256 = function (b, c) {

var f = k.wordsToBytes(e._sha256(b));

return c && c.asBytes ? f : c && c.asString ? a.bytesToString(f) : k.bytesToHex(f)

};

e._sha256 = function (a) {

a.constructor == String && (a = b.stringToBytes(a));

var e = k.bytesToWords(a),

f = a.length * 8,

a = [1779033703, 3144134277,

1013904242, 2773480762, 1359893119, 2600822924, 528734635, 1541459225

],

d = [],

g, m, r, i, n, o, s, t, h, l, j;

e[f >> 5] |= 128 << 24 - f % 32;

e[(f + 64 >> 9 << 4) + 15] = f;

for (t = 0; t < e.length; t += 16) {

f = a[0];

g = a[1];

m = a[2];

r = a[3];

i = a[4];

n = a[5];

o = a[6];

s = a[7];

for (h = 0; h < 64; h++) {

h < 16 ? d[h] = e[h + t] : (l = d[h - 15], j = d[h - 2], d[h] = ((l << 25 | l >>> 7) ^

(l << 14 | l >>> 18) ^ l >>> 3) + (d[h - 7] >>> 0) + ((j << 15 | j >>> 17) ^

(j << 13 | j >>> 19) ^ j >>> 10) + (d[h - 16] >>> 0));

j = f & g ^ f & m ^ g & m;

var u = (f << 30 | f >>> 2) ^ (f << 19 | f >>> 13) ^ (f << 10 | f >>> 22);

l = (s >>> 0) + ((i << 26 | i >>> 6) ^ (i << 21 | i >>> 11) ^ (i << 7 | i >>> 25)) +

(i & n ^ ~i & o) + c[h] + (d[h] >>> 0);

j = u + j;

s = o;

o = n;

n = i;

i = r + l >>> 0;

r = m;

m = g;

g = f;

f = l + j >>> 0

}

a[0] += f;

a[1] += g;

a[2] += m;

a[3] += r;

a[4] += i;

a[5] += n;

a[6] += o;

a[7] += s

}

return a

};

e._blocksize = 16;

e._digestsize = 32

})();

(function () {

var d = Crypto,

k = d.util,

g = d.charenc,

b = g.UTF8,

a = g.Binary;

d.HMAC = function (c, e, d, g) {

e.constructor == String && (e = b.stringToBytes(e));

d.constructor == String && (d = b.stringToBytes(d));

d.length > c._blocksize * 4 && (d = c(d, {

asBytes: !0

}));

for (var f = d.slice(0), d = d.slice(0), q = 0; q < c._blocksize * 4; q++) f[q] ^= 92, d[q] ^=

54;

c = c(f.concat(c(d.concat(e), {

asBytes: !0

})), {

asBytes: !0

});

return g && g.asBytes ? c : g && g.asString ? a.bytesToString(c) : k.bytesToHex(c)

}

})();

})();

//SecureRandom.js

(function () {

/*!

* Random number generator with ArcFour PRNG

*

* NOTE: For best results, put code like

* <body onclick='SecureRandom.seedTime();' onkeypress='SecureRandom.seedTime();'>

* in your main HTML document.

*

* Copyright Tom Wu, bitaddress.org BSD License.

* http://www-cs-students.stanford.edu/~tjw/jsbn/LICENSE

*/

// Constructor function of Global SecureRandom object

var sr = GLOBAL.SecureRandom = function () { };

// Properties

sr.state;

sr.pool;

sr.pptr;

sr.poolCopyOnInit;

// Pool size must be a multiple of 4 and greater than 32.

// An array of bytes the size of the pool will be passed to init()

sr.poolSize = 256;

// --- object methods ---

// public method

// ba: byte array

sr.prototype.nextBytes = function (ba) {

var i;

if (getRandomBytes && GLOBAL.Uint8Array) {

try {

var rvBytes = new Uint8Array(ba.length);

getRandomBytes(rvBytes);

for (i = 0; i < ba.length; ++i)

ba[i] = sr.getByte() ^ rvBytes[i];

return;

} catch (e) {

alert(e);

}

}

for (i = 0; i < ba.length; ++i) ba[i] = sr.getByte();

};

// --- static methods ---

// Mix in the current time (w/milliseconds) into the pool

// NOTE: this method should be called from body click/keypress event handlers to increase entropy

sr.seedTime = function () {

sr.seedInt(new Date().getTime());

}

sr.getByte = function () {

if (sr.state == null) {

sr.seedTime();

sr.state = sr.ArcFour(); // Plug in your RNG constructor here

sr.state.init(sr.pool);

sr.poolCopyOnInit = [];

for (sr.pptr = 0; sr.pptr < sr.pool.length; ++sr.pptr)

sr.poolCopyOnInit[sr.pptr] = sr.pool[sr.pptr];

sr.pptr = 0;

}

// TODO: allow reseeding after first request

return sr.state.next();

}

// Mix in a 32-bit integer into the pool

sr.seedInt = function (x) {

sr.seedInt8(x);

sr.seedInt8((x >> 8));

sr.seedInt8((x >> 16));

sr.seedInt8((x >> 24));

}

// Mix in a 16-bit integer into the pool

sr.seedInt16 = function (x) {

sr.seedInt8(x);

sr.seedInt8((x >> 8));

}

// Mix in a 8-bit integer into the pool

sr.seedInt8 = function (x) {

sr.pool[sr.pptr++] ^= x & 255;

if (sr.pptr >= sr.poolSize) sr.pptr -= sr.poolSize;

}

// Arcfour is a PRNG

sr.ArcFour = function () {

function Arcfour() {

this.i = 0;

this.j = 0;

this.S = new Array();

}

// Initialize arcfour context from key, an array of ints, each from [0..255]

function ARC4init(key) {

var i, j, t;

for (i = 0; i < 256; ++i)

this.S[i] = i;

j = 0;

for (i = 0; i < 256; ++i) {

j = (j + this.S[i] + key[i % key.length]) & 255;

t = this.S[i];

this.S[i] = this.S[j];

this.S[j] = t;

}

this.i = 0;

this.j = 0;

}

function ARC4next() {

var t;

this.i = (this.i + 1) & 255;

this.j = (this.j + this.S[this.i]) & 255;

t = this.S[this.i];

this.S[this.i] = this.S[this.j];

this.S[this.j] = t;

return this.S[(t + this.S[this.i]) & 255];

}

Arcfour.prototype.init = ARC4init;

Arcfour.prototype.next = ARC4next;

return new Arcfour();

};

// Initialize the pool with junk if needed.

if (sr.pool == null) {

sr.pool = new Array();

sr.pptr = 0;

var t;

if (getRandomBytes && GLOBAL.Uint8Array) {

try {

// Use webcrypto if available

var ua = new Uint8Array(sr.poolSize);

getRandomBytes(ua);

for (t = 0; t < sr.poolSize; ++t)

sr.pool[sr.pptr++] = ua[t];

} catch (e) {

alert(e);

}

}

while (sr.pptr < sr.poolSize) { // extract some randomness from securedMathRandom()

t = Math.floor(65536 * securedMathRandom());

sr.pool[sr.pptr++] = t >>> 8;

sr.pool[sr.pptr++] = t & 255;

}

sr.pptr = Math.floor(sr.poolSize * securedMathRandom());

sr.seedTime();

// entropy

var entropyStr = "";

// screen size and color depth: ~4.8 to ~5.4 bits

entropyStr += (GLOBAL.screen.height * GLOBAL.screen.width * GLOBAL.screen.colorDepth);

entropyStr += (GLOBAL.screen.availHeight * GLOBAL.screen.availWidth * GLOBAL.screen.pixelDepth);

// time zone offset: ~4 bits

var dateObj = new Date();

var timeZoneOffset = dateObj.getTimezoneOffset();

entropyStr += timeZoneOffset;

// user agent: ~8.3 to ~11.6 bits

entropyStr += navigator.userAgent;

// browser plugin details: ~16.2 to ~21.8 bits

var pluginsStr = "";

for (var i = 0; i < navigator.plugins.length; i++) {

pluginsStr += navigator.plugins[i].name + " " + navigator.plugins[i].filename + " " + navigator.plugins[i].description + " " + navigator.plugins[i].version + ", ";

}

var mimeTypesStr = "";

for (var i = 0; i < navigator.mimeTypes.length; i++) {

mimeTypesStr += navigator.mimeTypes[i].description + " " + navigator.mimeTypes[i].type + " " + navigator.mimeTypes[i].suffixes + ", ";

}

entropyStr += pluginsStr + mimeTypesStr;

// cookies and storage: 1 bit

entropyStr += navigator.cookieEnabled + typeof (sessionStorage) + typeof (localStorage);

// language: ~7 bit

entropyStr += navigator.language;

// history: ~2 bit

entropyStr += GLOBAL.history.length;

// location

entropyStr += GLOBAL.location;

var entropyBytes = Crypto.SHA256(entropyStr, {

asBytes: true

});

for (var i = 0; i < entropyBytes.length; i++) {

sr.seedInt8(entropyBytes[i]);

}

}

})();

//ripemd160.js

(function () {

/*

CryptoJS v3.1.2

code.google.com/p/crypto-js

(c) 2009-2013 by Jeff Mott. All rights reserved.

code.google.com/p/crypto-js/wiki/License

*/

/** @preserve

(c) 2012 by Cédric Mesnil. All rights reserved.

Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

- Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.

- Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

*/

// Constants table

var zl = [

0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,

7, 4, 13, 1, 10, 6, 15, 3, 12, 0, 9, 5, 2, 14, 11, 8,

3, 10, 14, 4, 9, 15, 8, 1, 2, 7, 0, 6, 13, 11, 5, 12,

1, 9, 11, 10, 0, 8, 12, 4, 13, 3, 7, 15, 14, 5, 6, 2,

4, 0, 5, 9, 7, 12, 2, 10, 14, 1, 3, 8, 11, 6, 15, 13

];

var zr = [

5, 14, 7, 0, 9, 2, 11, 4, 13, 6, 15, 8, 1, 10, 3, 12,

6, 11, 3, 7, 0, 13, 5, 10, 14, 15, 8, 12, 4, 9, 1, 2,

15, 5, 1, 3, 7, 14, 6, 9, 11, 8, 12, 2, 10, 0, 4, 13,

8, 6, 4, 1, 3, 11, 15, 0, 5, 12, 2, 13, 9, 7, 10, 14,

12, 15, 10, 4, 1, 5, 8, 7, 6, 2, 13, 14, 0, 3, 9, 11

];

var sl = [

11, 14, 15, 12, 5, 8, 7, 9, 11, 13, 14, 15, 6, 7, 9, 8,

7, 6, 8, 13, 11, 9, 7, 15, 7, 12, 15, 9, 11, 7, 13, 12,

11, 13, 6, 7, 14, 9, 13, 15, 14, 8, 13, 6, 5, 12, 7, 5,

11, 12, 14, 15, 14, 15, 9, 8, 9, 14, 5, 6, 8, 6, 5, 12,

9, 15, 5, 11, 6, 8, 13, 12, 5, 12, 13, 14, 11, 8, 5, 6

];

var sr = [

8, 9, 9, 11, 13, 15, 15, 5, 7, 7, 8, 11, 14, 14, 12, 6,

9, 13, 15, 7, 12, 8, 9, 11, 7, 7, 12, 7, 6, 15, 13, 11,

9, 7, 15, 11, 8, 6, 6, 14, 12, 13, 5, 14, 13, 13, 7, 5,

15, 5, 8, 11, 14, 14, 6, 14, 6, 9, 12, 9, 12, 5, 15, 8,

8, 5, 12, 9, 12, 5, 14, 6, 8, 13, 6, 5, 15, 13, 11, 11

];

var hl = [0x00000000, 0x5A827999, 0x6ED9EBA1, 0x8F1BBCDC, 0xA953FD4E];

var hr = [0x50A28BE6, 0x5C4DD124, 0x6D703EF3, 0x7A6D76E9, 0x00000000];

var bytesToWords = function (bytes) {

var words = [];

for (var i = 0, b = 0; i < bytes.length; i++, b += 8) {

words[b >>> 5] |= bytes[i] << (24 - b % 32);

}

return words;

};

var wordsToBytes = function (words) {

var bytes = [];

for (var b = 0; b < words.length * 32; b += 8) {

bytes.push((words[b >>> 5] >>> (24 - b % 32)) & 0xFF);

}

return bytes;

};

var processBlock = function (H, M, offset) {

// Swap endian

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

var offset_i = offset + i;

var M_offset_i = M[offset_i];

// Swap

M[offset_i] = (

(((M_offset_i << 8) | (M_offset_i >>> 24)) & 0x00ff00ff) |

(((M_offset_i << 24) | (M_offset_i >>> 8)) & 0xff00ff00)

);

}

// Working variables

var al, bl, cl, dl, el;

var ar, br, cr, dr, er;

ar = al = H[0];

br = bl = H[1];

cr = cl = H[2];

dr = dl = H[3];

er = el = H[4];

// Computation

var t;

for (var i = 0; i < 80; i += 1) {

t = (al + M[offset + zl[i]]) | 0;

if (i < 16) {

t += f1(bl, cl, dl) + hl[0];

} else if (i < 32) {

t += f2(bl, cl, dl) + hl[1];

} else if (i < 48) {

t += f3(bl, cl, dl) + hl[2];

} else if (i < 64) {

t += f4(bl, cl, dl) + hl[3];

} else { // if (i<80) {

t += f5(bl, cl, dl) + hl[4];

}

t = t | 0;

t = rotl(t, sl[i]);

t = (t + el) | 0;

al = el;

el = dl;

dl = rotl(cl, 10);

cl = bl;

bl = t;

t = (ar + M[offset + zr[i]]) | 0;

if (i < 16) {

t += f5(br, cr, dr) + hr[0];

} else if (i < 32) {

t += f4(br, cr, dr) + hr[1];

} else if (i < 48) {

t += f3(br, cr, dr) + hr[2];

} else if (i < 64) {

t += f2(br, cr, dr) + hr[3];

} else { // if (i<80) {

t += f1(br, cr, dr) + hr[4];

}

t = t | 0;

t = rotl(t, sr[i]);

t = (t + er) | 0;

ar = er;

er = dr;

dr = rotl(cr, 10);

cr = br;

br = t;

}

// Intermediate hash value

t = (H[1] + cl + dr) | 0;

H[1] = (H[2] + dl + er) | 0;

H[2] = (H[3] + el + ar) | 0;

H[3] = (H[4] + al + br) | 0;

H[4] = (H[0] + bl + cr) | 0;

H[0] = t;

};

function f1(x, y, z) {

return ((x) ^ (y) ^ (z));

}

function f2(x, y, z) {

return (((x) & (y)) | ((~x) & (z)));

}

function f3(x, y, z) {

return (((x) | (~(y))) ^ (z));

}

function f4(x, y, z) {

return (((x) & (z)) | ((y) & (~(z))));

}

function f5(x, y, z) {

return ((x) ^ ((y) | (~(z))));

}

function rotl(x, n) {

return (x << n) | (x >>> (32 - n));

}

GLOBAL.ripemd160 = function ripemd160(message) {

var H = [0x67452301, 0xEFCDAB89, 0x98BADCFE, 0x10325476, 0xC3D2E1F0];

var m = bytesToWords(message);

var nBitsLeft = message.length * 8;

var nBitsTotal = message.length * 8;

// Add padding

m[nBitsLeft >>> 5] |= 0x80 << (24 - nBitsLeft % 32);

m[(((nBitsLeft + 64) >>> 9) << 4) + 14] = (

(((nBitsTotal << 8) | (nBitsTotal >>> 24)) & 0x00ff00ff) |

(((nBitsTotal << 24) | (nBitsTotal >>> 8)) & 0xff00ff00)

);

for (var i = 0; i < m.length; i += 16) {

processBlock(H, m, i);

}

// Swap endian

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

// Shortcut

var H_i = H[i];

// Swap

H[i] = (((H_i << 8) | (H_i >>> 24)) & 0x00ff00ff) |

(((H_i << 24) | (H_i >>> 8)) & 0xff00ff00);

}

var digestbytes = wordsToBytes(H);

return digestbytes;

}

})();

//BigInteger.js

(function () {

// Upstream 'BigInteger' here:

// Original Author: http://www-cs-students.stanford.edu/~tjw/jsbn/

// Follows 'jsbn' on Github: https://github.com/jasondavies/jsbn

// Review and Testing: https://github.com/cryptocoinjs/bigi/

/*!

* Basic JavaScript BN library - subset useful for RSA encryption. v1.4

*

* Copyright (c) 2005 Tom Wu

* All Rights Reserved.

* BSD License

* http://www-cs-students.stanford.edu/~tjw/jsbn/LICENSE

*

* Copyright Stephan Thomas

* Copyright pointbiz

*/

// (public) Constructor function of Global BigInteger object

var BigInteger = GLOBAL.BigInteger = function BigInteger(a, b, c) {

if (!(this instanceof BigInteger))

return new BigInteger(a, b, c);

if (a != null)

if ("number" == typeof a) this.fromNumber(a, b, c);

else if (b == null && "string" != typeof a) this.fromString(a, 256);

else this.fromString(a, b);

};

// Bits per digit

var dbits;

// JavaScript engine analysis

var canary = 0xdeadbeefcafe;

var j_lm = ((canary & 0xffffff) == 0xefcafe);

// return new, unset BigInteger

function nbi() {

return new BigInteger(null);

}

// am: Compute w_j += (x*this_i), propagate carries,

// c is initial carry, returns final carry.

// c < 3*dvalue, x < 2*dvalue, this_i < dvalue

// We need to select the fastest one that works in this environment.

// am1: use a single mult and divide to get the high bits,

// max digit bits should be 26 because

// max internal value = 2*dvalue^2-2*dvalue (< 2^53)

function am1(i, x, w, j, c, n) {

while (--n >= 0) {

var v = x * this[i++] + w[j] + c;

c = Math.floor(v / 0x4000000);

w[j++] = v & 0x3ffffff;

}

return c;

}

// am2 avoids a big mult-and-extract completely.

// Max digit bits should be <= 30 because we do bitwise ops

// on values up to 2*hdvalue^2-hdvalue-1 (< 2^31)

function am2(i, x, w, j, c, n) {

var xl = x & 0x7fff,

xh = x >> 15;

while (--n >= 0) {

var l = this[i] & 0x7fff;

var h = this[i++] >> 15;

var m = xh * l + h * xl;

l = xl * l + ((m & 0x7fff) << 15) + w[j] + (c & 0x3fffffff);

c = (l >>> 30) + (m >>> 15) + xh * h + (c >>> 30);

w[j++] = l & 0x3fffffff;

}

return c;

}

// Alternately, set max digit bits to 28 since some

// browsers slow down when dealing with 32-bit numbers.

function am3(i, x, w, j, c, n) {

var xl = x & 0x3fff,

xh = x >> 14;

while (--n >= 0) {

var l = this[i] & 0x3fff;

var h = this[i++] >> 14;

var m = xh * l + h * xl;

l = xl * l + ((m & 0x3fff) << 14) + w[j] + c;

c = (l >> 28) + (m >> 14) + xh * h;

w[j++] = l & 0xfffffff;

}

return c;

}

if (j_lm && (navigator.appName == "Microsoft Internet Explorer")) {

BigInteger.prototype.am = am2;

dbits = 30;

} else if (j_lm && (navigator.appName != "Netscape")) {

BigInteger.prototype.am = am1;

dbits = 26;

} else { // Mozilla/Netscape seems to prefer am3

BigInteger.prototype.am = am3;

dbits = 28;

}

BigInteger.prototype.DB = dbits;

BigInteger.prototype.DM = ((1 << dbits) - 1);

BigInteger.prototype.DV = (1 << dbits);

var BI_FP = 52;

BigInteger.prototype.FV = Math.pow(2, BI_FP);

BigInteger.prototype.F1 = BI_FP - dbits;

BigInteger.prototype.F2 = 2 * dbits - BI_FP;

// Digit conversions

var BI_RM = "0123456789abcdefghijklmnopqrstuvwxyz";

var BI_RC = new Array();

var rr, vv;

rr = "0".charCodeAt(0);

for (vv = 0; vv <= 9; ++vv) BI_RC[rr++] = vv;

rr = "a".charCodeAt(0);

for (vv = 10; vv < 36; ++vv) BI_RC[rr++] = vv;

rr = "A".charCodeAt(0);

for (vv = 10; vv < 36; ++vv) BI_RC[rr++] = vv;

function int2char(n) {

return BI_RM.charAt(n);

}

function intAt(s, i) {

var c = BI_RC[s.charCodeAt(i)];

return (c == null) ? -1 : c;

}

// return bigint initialized to value

function nbv(i) {

var r = nbi();

r.fromInt(i);

return r;

}

// returns bit length of the integer x

function nbits(x) {

var r = 1,

t;

if ((t = x >>> 16) != 0) {

x = t;

r += 16;

}

if ((t = x >> 8) != 0) {

x = t;

r += 8;

}

if ((t = x >> 4) != 0) {

x = t;

r += 4;

}

if ((t = x >> 2) != 0) {

x = t;

r += 2;

}

if ((t = x >> 1) != 0) {

x = t;

r += 1;

}

return r;

}