(function(f){if(typeof exports==="object"&&typeof module!

=="undefined")
{[Link]=f()}else if(typeof define==="function"&&[Link])
{define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof
global!=="undefined"){g=global}else if(typeof self!=="undefined")
{g=self}else{g=this}[Link] = f()}})(function(){var define,module,exports;return
(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof
require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new
Error("Cannot find module '"+o+"'");throw [Link]="MODULE_NOT_FOUND",f}var
l=n[o]={exports:{}};t[o][0].call([Link],function(e){var n=t[o][1][e];return s(n?
n:e)},l,[Link],e,t,n,r)}return n[o].exports}var i=typeof
require=="function"&&require;for(var o=0;o<[Link];o++)s(r[o]);return s})({1:
[function(require,module,exports){
// base-x encoding
// Forked from [Link]
// Originally written by Mike Hearn for BitcoinJ
// Copyright (c) 2011 Google Inc
// Ported to JavaScript by Stefan Thomas
// Merged Buffer refactorings from base58-native by Stephen Pair
// Copyright (c) 2013 BitPay Inc

var Buffer = require('safe-buffer').Buffer

[Link] = function base (ALPHABET) {

var ALPHABET_MAP = {}
var BASE = [Link]
var LEADER = [Link](0)

// pre-compute lookup table

for (var z = 0; z < [Link]; z++) {
var x = [Link](z)

if (ALPHABET_MAP[x] !== undefined) throw new TypeError(x + ' is ambiguous')

ALPHABET_MAP[x] = z
}

function encode (source) {

if ([Link] === 0) return ''

var digits = [0]

for (var i = 0; i < [Link]; ++i) {
for (var j = 0, carry = source[i]; j < [Link]; ++j) {
carry += digits[j] << 8
digits[j] = carry % BASE
carry = (carry / BASE) | 0
}

while (carry > 0) {

[Link](carry % BASE)
carry = (carry / BASE) | 0
}
}

var string = ''

// deal with leading zeros

for (var k = 0; source[k] === 0 && k < [Link] - 1; ++k) string += LEADER
// convert digits to a string
for (var q = [Link] - 1; q >= 0; --q) string += ALPHABET[digits[q]]
 return string
}

function decodeUnsafe (string) {

if (typeof string !== 'string') throw new TypeError('Expected String')
if ([Link] === 0) return [Link](0)

var bytes = [0]

for (var i = 0; i < [Link]; i++) {
var value = ALPHABET_MAP[string[i]]
if (value === undefined) return

for (var j = 0, carry = value; j < [Link]; ++j) {

carry += bytes[j] * BASE
bytes[j] = carry & 0xff
carry >>= 8
}

while (carry > 0) {

[Link](carry & 0xff)
carry >>= 8
}
}

// deal with leading zeros

for (var k = 0; string[k] === LEADER && k < [Link] - 1; ++k) {
[Link](0)
}

return [Link]([Link]())
}

function decode (string) {

var buffer = decodeUnsafe(string)
if (buffer) return buffer

throw new Error('Non-base' + BASE + ' character')

}

return {
encode: encode,
decodeUnsafe: decodeUnsafe,
decode: decode
}
}

},{"safe-buffer":30}],2:[function(require,module,exports){
'use strict'
var ALPHABET = 'qpzry9x8gf2tvdw0s3jn54khce6mua7l'

// pre-compute lookup table

var ALPHABET_MAP = {}
for (var z = 0; z < [Link]; z++) {
var x = [Link](z)

if (ALPHABET_MAP[x] !== undefined) throw new TypeError(x + ' is ambiguous')

ALPHABET_MAP[x] = z
}
function polymodStep (pre) {
var b = pre >> 25
return ((pre & 0x1FFFFFF) << 5) ^
(-((b >> 0) & 1) & 0x3b6a57b2) ^
(-((b >> 1) & 1) & 0x26508e6d) ^
(-((b >> 2) & 1) & 0x1ea119fa) ^
(-((b >> 3) & 1) & 0x3d4233dd) ^
(-((b >> 4) & 1) & 0x2a1462b3)
}

function prefixChk (prefix) {

var chk = 1
for (var i = 0; i < [Link]; ++i) {
var c = [Link](i)
if (c < 33 || c > 126) throw new Error('Invalid prefix (' + prefix + ')')

chk = polymodStep(chk) ^ (c >> 5)

}
chk = polymodStep(chk)

for (i = 0; i < [Link]; ++i) {

var v = [Link](i)
chk = polymodStep(chk) ^ (v & 0x1f)
}
return chk
}

function encode (prefix, words, LIMIT) {

LIMIT = LIMIT || 90
if (([Link] + 7 + [Link]) > LIMIT) throw new TypeError('Exceeds
length limit')

prefix = [Link]()

// determine chk mod

var chk = prefixChk(prefix)
var result = prefix + '1'
for (var i = 0; i < [Link]; ++i) {
var x = words[i]
if ((x >> 5) !== 0) throw new Error('Non 5-bit word')

chk = polymodStep(chk) ^ x
result += [Link](x)
}

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

chk = polymodStep(chk)
}
chk ^= 1

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

var v = (chk >> ((5 - i) * 5)) & 0x1f
result += [Link](v)
}

return result
}

function decode (str, LIMIT) {

 LIMIT = LIMIT || 90
if ([Link] < 8) throw new TypeError(str + ' too short')
if ([Link] > LIMIT) throw new TypeError('Exceeds length limit')

// don't allow mixed case

var lowered = [Link]()
var uppered = [Link]()
if (str !== lowered && str !== uppered) throw new Error('Mixed-case string ' +
str)
str = lowered

var split = [Link]('1')

if (split === -1) throw new Error('No separator character for ' + str)
if (split === 0) throw new Error('Missing prefix for ' + str)

var prefix = [Link](0, split)

var wordChars = [Link](split + 1)
if ([Link] < 6) throw new Error('Data too short')

var chk = prefixChk(prefix)

var words = []
for (var i = 0; i < [Link]; ++i) {
var c = [Link](i)
var v = ALPHABET_MAP[c]
if (v === undefined) throw new Error('Unknown character ' + c)
chk = polymodStep(chk) ^ v

// not in the checksum?

if (i + 6 >= [Link]) continue
[Link](v)
}

if (chk !== 1) throw new Error('Invalid checksum for ' + str)

return { prefix: prefix, words: words }
}

function convert (data, inBits, outBits, pad) {

var value = 0
var bits = 0
var maxV = (1 << outBits) - 1

var result = []
for (var i = 0; i < [Link]; ++i) {
value = (value << inBits) | data[i]
bits += inBits

while (bits >= outBits) {

bits -= outBits
[Link]((value >> bits) & maxV)
}
}

if (pad) {
if (bits > 0) {
[Link]((value << (outBits - bits)) & maxV)
}
} else {
if (bits >= inBits) throw new Error('Excess padding')
if ((value << (outBits - bits)) & maxV) throw new Error('Non-zero padding')
 }

return result
}

function toWords (bytes) {

return convert(bytes, 8, 5, true)
}

function fromWords (words) {

return convert(words, 5, 8, false)
}

[Link] = {
decode: decode,
encode: encode,
toWords: toWords,
fromWords: fromWords
}

},{}],3:[function(require,module,exports){
// (public) Constructor
function BigInteger(a, b, c) {
if (!(this instanceof BigInteger))
return new BigInteger(a, b, c)

if (a != null) {
if ("number" == typeof a) [Link](a, b, c)
else if (b == null && "string" != typeof a) [Link](a, 256)
else [Link](a, b)
}
}

var proto = [Link]

// duck-typed isBigInteger
proto.__bigi = require('../[Link]').version
[Link] = function (obj, check_ver) {
return obj && obj.__bigi && (!check_ver || obj.__bigi === proto.__bigi)
}

// Bits per digit

var dbits

// 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 = [Link](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
}

// wtf?
[Link] = am1
dbits = 26

[Link] = dbits
[Link] = ((1 << dbits) - 1)
var DV = [Link] = (1 << dbits)

var BI_FP = 52
[Link] = [Link](2, BI_FP)
[Link].F1 = BI_FP - dbits
[Link].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[[Link](i)]
return (c == null) ? -1 : c
}

// (protected) copy this to r

function bnpCopyTo(r) {
for (var i = this.t - 1; i >= 0; --i) r[i] = this[i]
r.t = this.t
r.s = this.s
}

// (protected) set from integer value x, -DV <= x < DV

function bnpFromInt(x) {
this.t = 1
this.s = (x < 0) ? -1 : 0
if (x > 0) this[0] = x
else if (x < -1) this[0] = x + DV
else this.t = 0
}

// return bigint initialized to value

function nbv(i) {
var r = new BigInteger()
[Link](i)
return r
}

// (protected) set from string and radix

function bnpFromString(s, b) {
var self = this

var k
if (b == 16) k = 4
else if (b == 8) k = 3
else if (b == 256) k = 8; // byte array
else if (b == 2) k = 1
else if (b == 32) k = 5
else if (b == 4) k = 2
else {
[Link](s, b)
return
}
self.t = 0
self.s = 0
var i = [Link],
mi = false,
sh = 0
while (--i >= 0) {
var x = (k == 8) ? s[i] & 0xff : intAt(s, i)
if (x < 0) {
if ([Link](i) == "-") mi = true
continue
}
mi = false
if (sh == 0)
self[self.t++] = x
 else if (sh + k > [Link]) {
self[self.t - 1] |= (x & ((1 << ([Link] - sh)) - 1)) << sh
self[self.t++] = (x >> ([Link] - sh))
} else
self[self.t - 1] |= x << sh
sh += k
if (sh >= [Link]) sh -= [Link]
}
if (k == 8 && (s[0] & 0x80) != 0) {
self.s = -1
if (sh > 0) self[self.t - 1] |= ((1 << ([Link] - sh)) - 1) << sh
}
[Link]()
if (mi) [Link](self, self)
}

// (protected) clamp off excess high words

function bnpClamp() {
var c = this.s & [Link]
while (this.t > 0 && this[this.t - 1] == c)--this.t
}

// (public) return string representation in given radix

function bnToString(b) {
var self = this
if (self.s < 0) return "-" + [Link]()
.toString(b)
var k
if (b == 16) k = 4
else if (b == 8) k = 3
else if (b == 2) k = 1
else if (b == 32) k = 5
else if (b == 4) k = 2
else return [Link](b)
var km = (1 << k) - 1,
d, m = false,
r = "",
i = self.t
var p = [Link] - (i * [Link]) % k
if (i-- > 0) {
if (p < [Link] && (d = self[i] >> p) > 0) {
m = true
r = int2char(d)
}
while (i >= 0) {
if (p < k) {
d = (self[i] & ((1 << p) - 1)) << (k - p)
d |= self[--i] >> (p += [Link] - k)
} else {
d = (self[i] >> (p -= k)) & km
if (p <= 0) {
p += [Link]
--i
}
}
if (d > 0) m = true
if (m) r += int2char(d)
}
}
 return m ? r : "0"
}

// (public) -this
function bnNegate() {
var r = new BigInteger()
[Link](this, r)
return r
}

// (public) |this|
function bnAbs() {
return (this.s < 0) ? [Link]() : this
}

// (public) return + if this > a, - if this < a, 0 if equal

function bnCompareTo(a) {
var r = this.s - a.s
if (r != 0) return r
var i = this.t
r = i - a.t
if (r != 0) return (this.s < 0) ? -r : r
while (--i >= 0)
if ((r = this[i] - a[i]) != 0) return r
return 0
}

// 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
}

// (public) return the number of bits in "this"

function bnBitLength() {
if (this.t <= 0) return 0
return [Link] * (this.t - 1) + nbits(this[this.t - 1] ^ (this.s & [Link]))
}
// (public) return the number of bytes in "this"
function bnByteLength() {
return [Link]() >> 3
}

// (protected) r = this << n*DB

function bnpDLShiftTo(n, r) {
var i
for (i = this.t - 1; i >= 0; --i) r[i + n] = this[i]
for (i = n - 1; i >= 0; --i) r[i] = 0
r.t = this.t + n
r.s = this.s
}

// (protected) r = this >> n*DB

function bnpDRShiftTo(n, r) {
for (var i = n; i < this.t; ++i) r[i - n] = this[i]
r.t = [Link](this.t - n, 0)
r.s = this.s
}

// (protected) r = this << n

function bnpLShiftTo(n, r) {
var self = this
var bs = n % [Link]
var cbs = [Link] - bs
var bm = (1 << cbs) - 1
var ds = [Link](n / [Link]),
c = (self.s << bs) & [Link],
i
for (i = self.t - 1; i >= 0; --i) {
r[i + ds + 1] = (self[i] >> cbs) | c
c = (self[i] & bm) << bs
}
for (i = ds - 1; i >= 0; --i) r[i] = 0
r[ds] = c
r.t = self.t + ds + 1
r.s = self.s
[Link]()
}

// (protected) r = this >> n

function bnpRShiftTo(n, r) {
var self = this
r.s = self.s
var ds = [Link](n / [Link])
if (ds >= self.t) {
r.t = 0
return
}
var bs = n % [Link]
var cbs = [Link] - bs
var bm = (1 << bs) - 1
r[0] = self[ds] >> bs
for (var i = ds + 1; i < self.t; ++i) {
r[i - ds - 1] |= (self[i] & bm) << cbs
r[i - ds] = self[i] >> bs
}
 if (bs > 0) r[self.t - ds - 1] |= (self.s & bm) << cbs
r.t = self.t - ds
[Link]()
}

// (protected) r = this - a
function bnpSubTo(a, r) {
var self = this
var i = 0,
c = 0,
m = [Link](a.t, self.t)
while (i < m) {
c += self[i] - a[i]
r[i++] = c & [Link]
c >>= [Link]
}
if (a.t < self.t) {
c -= a.s
while (i < self.t) {
c += self[i]
r[i++] = c & [Link]
c >>= [Link]
}
c += self.s
} else {
c += self.s
while (i < a.t) {
c -= a[i]
r[i++] = c & [Link]
c >>= [Link]
}
c -= a.s
}
r.s = (c < 0) ? -1 : 0
if (c < -1) r[i++] = [Link] + c
else if (c > 0) r[i++] = c
r.t = i
[Link]()
}

// (protected) r = this * a, r != this,a (HAC 14.12)

// "this" should be the larger one if appropriate.
function bnpMultiplyTo(a, r) {
var x = [Link](),
y = [Link]()
var i = x.t
r.t = i + y.t
while (--i >= 0) r[i] = 0
for (i = 0; i < y.t; ++i) r[i + x.t] = [Link](0, y[i], r, i, 0, x.t)
r.s = 0
[Link]()
if (this.s != a.s) [Link](r, r)
}

// (protected) r = this^2, r != this (HAC 14.16)

function bnpSquareTo(r) {
var x = [Link]()
var i = r.t = 2 * x.t
while (--i >= 0) r[i] = 0
 for (i = 0; i < x.t - 1; ++i) {
var c = [Link](i, x[i], r, 2 * i, 0, 1)
if ((r[i + x.t] += [Link](i + 1, 2 * x[i], r, 2 * i + 1, c, x.t - i - 1)) >=
[Link]) {
r[i + x.t] -= [Link]
r[i + x.t + 1] = 1
}
}
if (r.t > 0) r[r.t - 1] += [Link](i, x[i], r, 2 * i, 0, 1)
r.s = 0
[Link]()
}

// (protected) divide this by m, quotient and remainder to q, r (HAC 14.20)

// r != q, this != m. q or r may be null.
function bnpDivRemTo(m, q, r) {
var self = this
var pm = [Link]()
if (pm.t <= 0) return
var pt = [Link]()
if (pt.t < pm.t) {
if (q != null) [Link](0)
if (r != null) [Link](r)
return
}
if (r == null) r = new BigInteger()
var y = new BigInteger(),
ts = self.s,
ms = m.s
var nsh = [Link] - nbits(pm[pm.t - 1]); // normalize modulus
if (nsh > 0) {
[Link](nsh, y)
[Link](nsh, r)
} else {
[Link](y)
[Link](r)
}
var ys = y.t
var y0 = y[ys - 1]
if (y0 == 0) return
var yt = y0 * (1 << self.F1) + ((ys > 1) ? y[ys - 2] >> self.F2 : 0)
var d1 = [Link] / yt,
d2 = (1 << self.F1) / yt,
e = 1 << self.F2
var i = r.t,
j = i - ys,
t = (q == null) ? new BigInteger() : q
[Link](j, t)
if ([Link](t) >= 0) {
r[r.t++] = 1
[Link](t, r)
}
[Link](ys, t)
[Link](y, y); // "negative" y so we can replace sub with am later
while (y.t < ys) y[y.t++] = 0
while (--j >= 0) {
// Estimate quotient digit
var qd = (r[--i] == y0) ? [Link] : [Link](r[i] * d1 + (r[i - 1] + e) * d2)
if ((r[i] += [Link](0, qd, r, j, 0, ys)) < qd) { // Try it out
 [Link](j, t)
[Link](t, r)
while (r[i] < --qd) [Link](t, r)
}
}
if (q != null) {
[Link](ys, q)
if (ts != ms) [Link](q, q)
}
r.t = ys
[Link]()
if (nsh > 0) [Link](nsh, r); // Denormalize remainder
if (ts < 0) [Link](r, r)
}

// (public) this mod a

function bnMod(a) {
var r = new BigInteger()
[Link]()
.divRemTo(a, null, r)
if (this.s < 0 && [Link]([Link]) > 0) [Link](r, r)
return r
}

// Modular reduction using "classic" algorithm

function Classic(m) {
this.m = m
}

function cConvert(x) {
if (x.s < 0 || [Link](this.m) >= 0) return [Link](this.m)
else return x
}

function cRevert(x) {
return x
}

function cReduce(x) {
[Link](this.m, null, x)
}

function cMulTo(x, y, r) {
[Link](y, r)
[Link](r)
}

function cSqrTo(x, r) {
[Link](r)
[Link](r)
}

[Link] = cConvert
[Link] = cRevert
[Link] = cReduce
[Link] = cMulTo
[Link] = cSqrTo

// (protected) return "-1/this % 2^DB"; useful for Mont. reduction

// justification:
// xy == 1 (mod m)
// xy = 1+km
// xy(2-xy) = (1+km)(1-km)
// x[y(2-xy)] = 1-k^2m^2
// x[y(2-xy)] == 1 (mod m^2)
// if y is 1/x mod m, then y(2-xy) is 1/x mod m^2
// should reduce x and y(2-xy) by m^2 at each step to keep size bounded.
// JS multiply "overflows" differently from C/C++, so care is needed here.
function bnpInvDigit() {
if (this.t < 1) return 0
var x = this[0]
if ((x & 1) == 0) return 0
var y = x & 3; // y == 1/x mod 2^2
y = (y * (2 - (x & 0xf) * y)) & 0xf; // y == 1/x mod 2^4
y = (y * (2 - (x & 0xff) * y)) & 0xff; // y == 1/x mod 2^8
y = (y * (2 - (((x & 0xffff) * y) & 0xffff))) & 0xffff; // y == 1/x mod 2^16
// last step - calculate inverse mod DV directly
// assumes 16 < DB <= 32 and assumes ability to handle 48-bit ints
y = (y * (2 - x * y % [Link])) % [Link]; // y == 1/x mod 2^dbits
// we really want the negative inverse, and -DV < y < DV
return (y > 0) ? [Link] - y : -y
}

// Montgomery reduction
function Montgomery(m) {
this.m = m
[Link] = [Link]()
[Link] = [Link] & 0x7fff
[Link] = [Link] >> 15
[Link] = (1 << ([Link] - 15)) - 1
this.mt2 = 2 * m.t
}

// xR mod m
function montConvert(x) {
var r = new BigInteger()
[Link]()
.dlShiftTo(this.m.t, r)
[Link](this.m, null, r)
if (x.s < 0 && [Link]([Link]) > 0) [Link](r, r)
return r
}

// x/R mod m
function montRevert(x) {
var r = new BigInteger()
[Link](r)
[Link](r)
return r
}

// x = x/R mod m (HAC 14.32)

function montReduce(x) {
while (x.t <= this.mt2) // pad x so am has enough room later
x[x.t++] = 0
for (var i = 0; i < this.m.t; ++i) {
// faster way of calculating u0 = x[i]*mp mod DV
var j = x[i] & 0x7fff
 var u0 = (j * [Link] + (((j * [Link] + (x[i] >> 15) * [Link]) & [Link])
<< 15)) & [Link]
// use am to combine the multiply-shift-add into one call
j = i + this.m.t
x[j] += [Link](0, u0, x, i, 0, this.m.t)
// propagate carry
while (x[j] >= [Link]) {
x[j] -= [Link]
x[++j]++
}
}
[Link]()
[Link](this.m.t, x)
if ([Link](this.m) >= 0) [Link](this.m, x)
}

// r = "x^2/R mod m"; x != r

function montSqrTo(x, r) {
[Link](r)
[Link](r)
}

// r = "xy/R mod m"; x,y != r

function montMulTo(x, y, r) {
[Link](y, r)
[Link](r)
}

[Link] = montConvert
[Link] = montRevert
[Link] = montReduce
[Link] = montMulTo
[Link] = montSqrTo

// (protected) true iff this is even

function bnpIsEven() {
return ((this.t > 0) ? (this[0] & 1) : this.s) == 0
}

// (protected) this^e, e < 2^32, doing sqr and mul with "r" (HAC 14.79)
function bnpExp(e, z) {
if (e > 0xffffffff || e < 1) return [Link]
var r = new BigInteger(),
r2 = new BigInteger(),
g = [Link](this),
i = nbits(e) - 1
[Link](r)
while (--i >= 0) {
[Link](r, r2)
if ((e & (1 << i)) > 0) [Link](r2, g, r)
else {
var t = r
r = r2
r2 = t
}
}
return [Link](r)
}
// (public) this^e % m, 0 <= e < 2^32
function bnModPowInt(e, m) {
var z
if (e < 256 || [Link]()) z = new Classic(m)
else z = new Montgomery(m)
return [Link](e, z)
}

// protected
[Link] = bnpCopyTo
[Link] = bnpFromInt
[Link] = bnpFromString
[Link] = bnpClamp
[Link] = bnpDLShiftTo
[Link] = bnpDRShiftTo
[Link] = bnpLShiftTo
[Link] = bnpRShiftTo
[Link] = bnpSubTo
[Link] = bnpMultiplyTo
[Link] = bnpSquareTo
[Link] = bnpDivRemTo
[Link] = bnpInvDigit
[Link] = bnpIsEven
[Link] = bnpExp

// public
[Link] = bnToString
[Link] = bnNegate
[Link] = bnAbs
[Link] = bnCompareTo
[Link] = bnBitLength
[Link] = bnByteLength
[Link] = bnMod
[Link] = bnModPowInt

// (public)
function bnClone() {
var r = new BigInteger()
[Link](r)
return r
}

// (public) return value as integer

function bnIntValue() {
if (this.s < 0) {
if (this.t == 1) return this[0] - [Link]
else if (this.t == 0) return -1
} else if (this.t == 1) return this[0]
else if (this.t == 0) return 0
// assumes 16 < DB < 32
return ((this[1] & ((1 << (32 - [Link])) - 1)) << [Link]) | this[0]
}

// (public) return value as byte

function bnByteValue() {
return (this.t == 0) ? this.s : (this[0] << 24) >> 24
}

// (public) return value as short (assumes DB>=16)

function bnShortValue() {
return (this.t == 0) ? this.s : (this[0] << 16) >> 16
}

// (protected) return x s.t. r^x < DV

function bnpChunkSize(r) {
return [Link](Math.LN2 * [Link] / [Link](r))
}

// (public) 0 if this == 0, 1 if this > 0

function bnSigNum() {
if (this.s < 0) return -1
else if (this.t <= 0 || (this.t == 1 && this[0] <= 0)) return 0
else return 1
}

// (protected) convert to radix string

function bnpToRadix(b) {
if (b == null) b = 10
if ([Link]() == 0 || b < 2 || b > 36) return "0"
var cs = [Link](b)
var a = [Link](b, cs)
var d = nbv(a),
y = new BigInteger(),
z = new BigInteger(),
r = ""
[Link](d, y, z)
while ([Link]() > 0) {
r = (a + [Link]())
.toString(b)
.substr(1) + r
[Link](d, y, z)
}
return [Link]()
.toString(b) + r
}

// (protected) convert from radix string

function bnpFromRadix(s, b) {
var self = this
[Link](0)
if (b == null) b = 10
var cs = [Link](b)
var d = [Link](b, cs),
mi = false,
j = 0,
w = 0
for (var i = 0; i < [Link]; ++i) {
var x = intAt(s, i)
if (x < 0) {
if ([Link](i) == "-" && [Link]() == 0) mi = true
continue
}
w = b * w + x
if (++j >= cs) {
[Link](d)
[Link](w, 0)
j = 0
w = 0
 }
}
if (j > 0) {
[Link]([Link](b, j))
[Link](w, 0)
}
if (mi) [Link](self, self)
}

// (protected) alternate constructor

function bnpFromNumber(a, b, c) {
var self = this
if ("number" == typeof b) {
// new BigInteger(int,int,RNG)
if (a < 2) [Link](1)
else {
[Link](a, c)
if () // force MSB set
[Link]([Link](a - 1), op_or, self)
if ([Link]()) [Link](1, 0); // force odd
while () {
[Link](2, 0)
if ([Link]() > a) [Link]([Link](a - 1), self)
}
}
} else {
// new BigInteger(int,RNG)
var x = new Array(),
t = a & 7
[Link] = (a >> 3) + 1
[Link](x)
if (t > 0) x[0] &= ((1 << t) - 1)
else x[0] = 0
[Link](x, 256)
}
}

// (public) convert to bigendian byte array

function bnToByteArray() {
var self = this
var i = self.t,
r = new Array()
r[0] = self.s
var p = [Link] - (i * [Link]) % 8,
d, k = 0
if (i-- > 0) {
if (p < [Link] && (d = self[i] >> p) != (self.s & [Link]) >> p)
r[k++] = d | (self.s << ([Link] - p))
while (i >= 0) {
if (p < 8) {
d = (self[i] & ((1 << p) - 1)) << (8 - p)
d |= self[--i] >> (p += [Link] - 8)
} else {
d = (self[i] >> (p -= 8)) & 0xff
if (p <= 0) {
p += [Link]
--i
}
}
 if ((d & 0x80) != 0) d |= -256
if (k === 0 && (self.s & 0x80) != (d & 0x80))++k
if (k > 0 || d != self.s) r[k++] = d
}
}
return r
}

function bnEquals(a) {
return ([Link](a) == 0)
}

function bnMin(a) {
return ([Link](a) < 0) ? this : a
}

function bnMax(a) {
return ([Link](a) > 0) ? this : a
}

// (protected) r = this op a (bitwise)

function bnpBitwiseTo(a, op, r) {
var self = this
var i, f, m = [Link](a.t, self.t)
for (i = 0; i < m; ++i) r[i] = op(self[i], a[i])
if (a.t < self.t) {
f = a.s & [Link]
for (i = m; i < self.t; ++i) r[i] = op(self[i], f)
r.t = self.t
} else {
f = self.s & [Link]
for (i = m; i < a.t; ++i) r[i] = op(f, a[i])
r.t = a.t
}
r.s = op(self.s, a.s)
[Link]()
}

// (public) this & a

function op_and(x, y) {
return x & y
}

function bnAnd(a) {
var r = new BigInteger()
[Link](a, op_and, r)
return r
}

// (public) this | a
function op_or(x, y) {
return x | y
}

function bnOr(a) {
var r = new BigInteger()
[Link](a, op_or, r)
return r
}
// (public) this ^ a
function op_xor(x, y) {
return x ^ y
}

function bnXor(a) {
var r = new BigInteger()
[Link](a, op_xor, r)
return r
}

// (public) this & ~a

function op_andnot(x, y) {
return x & ~y
}

function bnAndNot(a) {
var r = new BigInteger()
[Link](a, op_andnot, r)
return r
}

// (public) ~this
function bnNot() {
var r = new BigInteger()
for (var i = 0; i < this.t; ++i) r[i] = [Link] & ~this[i]
r.t = this.t
r.s = ~this.s
return r
}

// (public) this << n

function bnShiftLeft(n) {
var r = new BigInteger()
if (n < 0) [Link](-n, r)
else [Link](n, r)
return r
}

// (public) this >> n

function bnShiftRight(n) {
var r = new BigInteger()
if (n < 0) [Link](-n, r)
else [Link](n, r)
return r
}

// return index of lowest 1-bit in x, x < 2^31

function lbit(x) {
if (x == 0) return -1
var r = 0
if ((x & 0xffff) == 0) {
x >>= 16
r += 16
}
if ((x & 0xff) == 0) {
x >>= 8
r += 8
 }
if ((x & 0xf) == 0) {
x >>= 4
r += 4
}
if ((x & 3) == 0) {
x >>= 2
r += 2
}
if ((x & 1) == 0)++r
return r
}

// (public) returns index of lowest 1-bit (or -1 if none)

function bnGetLowestSetBit() {
for (var i = 0; i < this.t; ++i)
if (this[i] != 0) return i * [Link] + lbit(this[i])
if (this.s < 0) return this.t * [Link]
return -1
}

// return number of 1 bits in x

function cbit(x) {
var r = 0
while (x != 0) {
x &= x - 1
++r
}
return r
}

// (public) return number of set bits

function bnBitCount() {
var r = 0,
x = this.s & [Link]
for (var i = 0; i < this.t; ++i) r += cbit(this[i] ^ x)
return r
}

// (public) true iff nth bit is set

function bnTestBit(n) {
var j = [Link](n / [Link])
if (j >= this.t) return (this.s != 0)
return ((this[j] & (1 << (n % [Link]))) != 0)
}

// (protected) this op (1<<n)

function bnpChangeBit(n, op) {
var r = [Link](n)
[Link](r, op, r)
return r
}

// (public) this | (1<<n)

function bnSetBit(n) {
return [Link](n, op_or)
}

// (public) this & ~(1<<n)

function bnClearBit(n) {
return [Link](n, op_andnot)
}

// (public) this ^ (1<<n)

function bnFlipBit(n) {
return [Link](n, op_xor)
}

// (protected) r = this + a
function bnpAddTo(a, r) {
var self = this

var i = 0,
c = 0,
m = [Link](a.t, self.t)
while (i < m) {
c += self[i] + a[i]
r[i++] = c & [Link]
c >>= [Link]
}
if (a.t < self.t) {
c += a.s
while (i < self.t) {
c += self[i]
r[i++] = c & [Link]
c >>= [Link]
}
c += self.s
} else {
c += self.s
while (i < a.t) {
c += a[i]
r[i++] = c & [Link]
c >>= [Link]
}
c += a.s
}
r.s = (c < 0) ? -1 : 0
if (c > 0) r[i++] = c
else if (c < -1) r[i++] = [Link] + c
r.t = i
[Link]()
}

// (public) this + a
function bnAdd(a) {
var r = new BigInteger()
[Link](a, r)
return r
}

// (public) this - a
function bnSubtract(a) {
var r = new BigInteger()
[Link](a, r)
return r
}
// (public) this * a
function bnMultiply(a) {
var r = new BigInteger()
[Link](a, r)
return r
}

// (public) this^2
function bnSquare() {
var r = new BigInteger()
[Link](r)
return r
}

// (public) this / a
function bnDivide(a) {
var r = new BigInteger()
[Link](a, r, null)
return r
}

// (public) this % a
function bnRemainder(a) {
var r = new BigInteger()
[Link](a, null, r)
return r
}

// (public) [this/a,this%a]
function bnDivideAndRemainder(a) {
var q = new BigInteger(),
r = new BigInteger()
[Link](a, q, r)
return new Array(q, r)
}

// (protected) this *= n, this >= 0, 1 < n < DV

function bnpDMultiply(n) {
this[this.t] = [Link](0, n - 1, this, 0, 0, this.t)
++this.t
[Link]()
}

// (protected) this += n << w words, this >= 0

function bnpDAddOffset(n, w) {
if (n == 0) return
while (this.t <= w) this[this.t++] = 0
this[w] += n
while (this[w] >= [Link]) {
this[w] -= [Link]
if (++w >= this.t) this[this.t++] = 0
++this[w]
}
}

// A "null" reducer
function NullExp() {}

function nNop(x) {
 return x
}

function nMulTo(x, y, r) {
[Link](y, r)
}

function nSqrTo(x, r) {
[Link](r)
}

[Link] = nNop
[Link] = nNop
[Link] = nMulTo
[Link] = nSqrTo

// (public) this^e
function bnPow(e) {
return [Link](e, new NullExp())
}

// (protected) r = lower n words of "this * a", a.t <= n

// "this" should be the larger one if appropriate.
function bnpMultiplyLowerTo(a, n, r) {
var i = [Link](this.t + a.t, n)
r.s = 0; // assumes a,this >= 0
r.t = i
while (i > 0) r[--i] = 0
var j
for (j = r.t - this.t; i < j; ++i) r[i + this.t] = [Link](0, a[i], r, i, 0,
this.t)
for (j = [Link](a.t, n); i < j; ++i) [Link](0, a[i], r, i, 0, n - i)
[Link]()
}

// (protected) r = "this * a" without lower n words, n > 0

// "this" should be the larger one if appropriate.
function bnpMultiplyUpperTo(a, n, r) {
--n
var i = r.t = this.t + a.t - n
r.s = 0; // assumes a,this >= 0
while (--i >= 0) r[i] = 0
for (i = [Link](n - this.t, 0); i < a.t; ++i)
r[this.t + i - n] = [Link](n - i, a[i], r, 0, 0, this.t + i - n)
[Link]()
[Link](1, r)
}

// Barrett modular reduction

function Barrett(m) {
// setup Barrett
this.r2 = new BigInteger()
this.q3 = new BigInteger()
[Link](2 * m.t, this.r2)
[Link] = [Link](m)
this.m = m
}

function barrettConvert(x) {
 if (x.s < 0 || x.t > 2 * this.m.t) return [Link](this.m)
else if ([Link](this.m) < 0) return x
else {
var r = new BigInteger()
[Link](r)
[Link](r)
return r
}
}

function barrettRevert(x) {
return x
}

// x = x mod m (HAC 14.42)

function barrettReduce(x) {
var self = this
[Link](self.m.t - 1, self.r2)
if (x.t > self.m.t + 1) {
x.t = self.m.t + 1
[Link]()
}
[Link](self.r2, self.m.t + 1, self.q3)
[Link](self.q3, self.m.t + 1, self.r2)
while ([Link](self.r2) < 0) [Link](1, self.m.t + 1)
[Link](self.r2, x)
while ([Link](self.m) >= 0) [Link](self.m, x)
}

// r = x^2 mod m; x != r
function barrettSqrTo(x, r) {
[Link](r)
[Link](r)
}

// r = x*y mod m; x,y != r

function barrettMulTo(x, y, r) {
[Link](y, r)
[Link](r)
}

[Link] = barrettConvert
[Link] = barrettRevert
[Link] = barrettReduce
[Link] = barrettMulTo
[Link] = barrettSqrTo

// (public) this^e % m (HAC 14.85)

function bnModPow(e, m) {
var i = [Link](),
k, r = nbv(1),
z
if (i <= 0) return r
else if (i < 18) k = 1
else if (i < 48) k = 3
else if (i < 144) k = 4
else if (i < 768) k = 5
else k = 6
if (i < 8)
 z = new Classic(m)
else if ([Link]())
z = new Barrett(m)
else
z = new Montgomery(m)

// precomputation
var g = new Array(),
n = 3,
k1 = k - 1,
km = (1 << k) - 1
g[1] = [Link](this)
if (k > 1) {
var g2 = new BigInteger()
[Link](g[1], g2)
while (n <= km) {
g[n] = new BigInteger()
[Link](g2, g[n - 2], g[n])
n += 2
}
}

var j = e.t - 1,
w, is1 = true,
r2 = new BigInteger(),
t
i = nbits(e[j]) - 1
while (j >= 0) {
if (i >= k1) w = (e[j] >> (i - k1)) & km
else {
w = (e[j] & ((1 << (i + 1)) - 1)) << (k1 - i)
if (j > 0) w |= e[j - 1] >> ([Link] + i - k1)
}

n = k
while ((w & 1) == 0) {
w >>= 1
--n
}
if ((i -= n) < 0) {
i += [Link]
--j
}
if (is1) { // ret == 1, don't bother squaring or multiplying it
g[w].copyTo(r)
is1 = false
} else {
while (n > 1) {
[Link](r, r2)
[Link](r2, r)
n -= 2
}
if (n > 0) [Link](r, r2)
else {
t = r
r = r2
r2 = t
}
[Link](r2, g[w], r)
 }

while (j >= 0 && (e[j] & (1 << i)) == 0) {

[Link](r, r2)
t = r
r = r2
r2 = t
if (--i < 0) {
i = [Link] - 1
--j
}
}
}
return [Link](r)
}

// (public) gcd(this,a) (HAC 14.54)

function bnGCD(a) {
var x = (this.s < 0) ? [Link]() : [Link]()
var y = (a.s < 0) ? [Link]() : [Link]()
if ([Link](y) < 0) {
var t = x
x = y
y = t
}
var i = [Link](),
g = [Link]()
if (g < 0) return x
if (i < g) g = i
if (g > 0) {
[Link](g, x)
[Link](g, y)
}
while ([Link]() > 0) {
if ((i = [Link]()) > 0) [Link](i, x)
if ((i = [Link]()) > 0) [Link](i, y)
if ([Link](y) >= 0) {
[Link](y, x)
[Link](1, x)
} else {
[Link](x, y)
[Link](1, y)
}
}
if (g > 0) [Link](g, y)
return y
}

// (protected) this % n, n < 2^26

function bnpModInt(n) {
if (n <= 0) return 0
var d = [Link] % n,
r = (this.s < 0) ? n - 1 : 0
if (this.t > 0)
if (d == 0) r = this[0] % n
else
for (var i = this.t - 1; i >= 0; --i) r = (d * r + this[i]) % n
return r
}
// (public) 1/this % m (HAC 14.61)
function bnModInverse(m) {
var ac = [Link]()
if ([Link]() === 0) throw new Error('division by zero')
if (([Link]() && ac) || [Link]() == 0) return [Link]
var u = [Link](),
v = [Link]()
var a = nbv(1),
b = nbv(0),
c = nbv(0),
d = nbv(1)
while ([Link]() != 0) {
while ([Link]()) {
[Link](1, u)
if (ac) {
if (![Link]() || ![Link]()) {
[Link](this, a)
[Link](m, b)
}
[Link](1, a)
} else if (![Link]()) [Link](m, b)
[Link](1, b)
}
while ([Link]()) {
[Link](1, v)
if (ac) {
if (![Link]() || ![Link]()) {
[Link](this, c)
[Link](m, d)
}
[Link](1, c)
} else if (![Link]()) [Link](m, d)
[Link](1, d)
}
if ([Link](v) >= 0) {
[Link](v, u)
if (ac) [Link](c, a)
[Link](d, b)
} else {
[Link](u, v)
if (ac) [Link](a, c)
[Link](b, d)
}
}
if ([Link]([Link]) != 0) return [Link]
while ([Link](m) >= 0) [Link](m, d)
while ([Link]() < 0) [Link](m, d)
return d
}

var lowprimes = [
2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71,
73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151,
157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233,
239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317,
331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389, 397, 401, 409, 419,
421, 431, 433, 439, 443, 449, 457, 461, 463, 467, 479, 487, 491, 499, 503,
509, 521, 523, 541, 547, 557, 563, 569, 571, 577, 587, 593, 599, 601, 607,
 613, 617, 619, 631, 641, 643, 647, 653, 659, 661, 673, 677, 683, 691, 701,
709, 719, 727, 733, 739, 743, 751, 757, 761, 769, 773, 787, 797, 809, 811,
821, 823, 827, 829, 839, 853, 857, 859, 863, 877, 881, 883, 887, 907, 911,
919, 929, 937, 941, 947, 953, 967, 971, 977, 983, 991, 997
]

var lplim = (1 << 26) / lowprimes[[Link] - 1]

// (public) test primality with certainty >= 1-.5^t

function bnIsProbablePrime(t) {
var i, x = [Link]()
if (x.t == 1 && x[0] <= lowprimes[[Link] - 1]) {
for (i = 0; i < [Link]; ++i)
if (x[0] == lowprimes[i]) return true
return false
}
if ([Link]()) return false
i = 1
while (i < [Link]) {
var m = lowprimes[i],
j = i + 1
while (j < [Link] && m < lplim) m *= lowprimes[j++]
m = [Link](m)
while (i < j) if (m % lowprimes[i++] == 0) return false
}
return [Link](t)
}

// (protected) true if probably prime (HAC 4.24, Miller-Rabin)

function bnpMillerRabin(t) {
var n1 = [Link]([Link])
var k = [Link]()
if (k <= 0) return false
var r = [Link](k)
t = (t + 1) >> 1
if (t > [Link]) t = [Link]
var a = new BigInteger(null)
var j, bases = []
for (var i = 0; i < t; ++i) {
for (;;) {
j = lowprimes[[Link]([Link]() * [Link])]
if ([Link](j) == -1) break
}
[Link](j)
[Link](j)
var y = [Link](r, this)
if ([Link]([Link]) != 0 && [Link](n1) != 0) {
var j = 1
while (j++ < k && [Link](n1) != 0) {
y = [Link](2, this)
if ([Link]([Link]) == 0) return false
}
if ([Link](n1) != 0) return false
}
}
return true
}

// protected
[Link] = bnpChunkSize
[Link] = bnpToRadix
[Link] = bnpFromRadix
[Link] = bnpFromNumber
[Link] = bnpBitwiseTo
[Link] = bnpChangeBit
[Link] = bnpAddTo
[Link] = bnpDMultiply
[Link] = bnpDAddOffset
[Link] = bnpMultiplyLowerTo
[Link] = bnpMultiplyUpperTo
[Link] = bnpModInt
[Link] = bnpMillerRabin

// public
[Link] = bnClone
[Link] = bnIntValue
[Link] = bnByteValue
[Link] = bnShortValue
[Link] = bnSigNum
[Link] = bnToByteArray
[Link] = bnEquals
[Link] = bnMin
[Link] = bnMax
[Link] = bnAnd
[Link] = bnOr
[Link] = bnXor
[Link] = bnAndNot
[Link] = bnNot
[Link] = bnShiftLeft
[Link] = bnShiftRight
[Link] = bnGetLowestSetBit
[Link] = bnBitCount
[Link] = bnTestBit
[Link] = bnSetBit
[Link] = bnClearBit
[Link] = bnFlipBit
[Link] = bnAdd
[Link] = bnSubtract
[Link] = bnMultiply
[Link] = bnDivide
[Link] = bnRemainder
[Link] = bnDivideAndRemainder
[Link] = bnModPow
[Link] = bnModInverse
[Link] = bnPow
[Link] = bnGCD
[Link] = bnIsProbablePrime

// JSBN-specific extension
[Link] = bnSquare

// constants
[Link] = nbv(0)
[Link] = nbv(1)
[Link] = nbv

[Link] = BigInteger
},{"../[Link]":6}],4:[function(require,module,exports){
(function (Buffer){
// FIXME: Kind of a weird way to throw exceptions, consider removing
var assert = require('assert')
var BigInteger = require('./bigi')

/**
* Turns a byte array into a big integer.
*
* This function will interpret a byte array as a big integer in big
* endian notation.
*/
[Link] = function(byteArray) {
// BigInteger expects a DER integer conformant byte array
if (byteArray[0] & 0x80) {
return new BigInteger([0].concat(byteArray))
}

return new BigInteger(byteArray)

}

/**
* Returns a byte array representation of the big integer.
*
* This returns the absolute of the contained value in big endian
* form. A value of zero results in an empty array.
*/
[Link] = function() {
var byteArray = [Link]()
return byteArray[0] === 0 ? [Link](1) : byteArray
}

[Link] = function(byteArray) {
return new BigInteger(byteArray)
}

/*
* Converts BigInteger to a DER integer representation.
*
* The format for this value uses the most significant bit as a sign
* bit. If the most significant bit is already set and the integer is
* positive, a 0x00 is prepended.
*
* Examples:
*
* 0 => 0x00
* 1 => 0x01
* -1 => 0xff
* 127 => 0x7f
* -127 => 0x81
* 128 => 0x0080
* -128 => 0x80
* 255 => 0x00ff
* -255 => 0xff01
* 16300 => 0x3fac
* -16300 => 0xc054
* 62300 => 0x00f35c
* -62300 => 0xff0ca4
*/
[Link] = [Link]

[Link] = function(buffer) {
// BigInteger expects a DER integer conformant byte array
if (buffer[0] & 0x80) {
var byteArray = [Link](buffer)

return new BigInteger([0].concat(byteArray))

}

return new BigInteger(buffer)

}

[Link] = function(hex) {
if (hex === '') return [Link]

[Link](hex, [Link](/^[A-Fa-f0-9]+/), 'Invalid hex string')

[Link]([Link] % 2, 0, 'Incomplete hex')
return new BigInteger(hex, 16)
}

[Link] = function(size) {
var byteArray = [Link]()
var zeros = []

var padding = size - [Link]

while ([Link] < padding) [Link](0)

return new Buffer([Link](byteArray))

}

[Link] = function(size) {
return [Link](size).toString('hex')
}

}).call(this,require("buffer").Buffer)
},{"./bigi":3,"assert":82,"buffer":84}],5:[function(require,module,exports){
var BigInteger = require('./bigi')

//addons
require('./convert')

[Link] = BigInteger
},{"./bigi":3,"./convert":4}],6:[function(require,module,exports){
[Link]={
"_from": "bigi@^1.4.0",
"_id": "bigi@1.4.2",
"_inBundle": false,
"_integrity": "sha1-nGZalfiLiwj8Bc/XMfVhhZ1yWCU=",
"_location": "/bigi",
"_phantomChildren": {},
"_requested": {
"type": "range",
"registry": true,
"raw": "bigi@^1.4.0",
"name": "bigi",
"escapedName": "bigi",
"rawSpec": "^1.4.0",
"saveSpec": null,
 "fetchSpec": "^1.4.0"
},
"_requiredBy": [
"/",
"/ecurve"
],
"_resolved": "[Link]
"_shasum": "9c665a95f88b8b08fc05cfd731f561859d725825",
"_spec": "bigi@^1.4.0",
"_where": "/home/anazir/bitcoinjs-lib",
"bugs": {
"url": "[Link]
},
"bundleDependencies": false,
"dependencies": {},
"deprecated": false,
"description": "Big integers.",
"devDependencies": {
"coveralls": "^2.11.2",
"istanbul": "^0.3.5",
"jshint": "^2.5.1",
"mocha": "^2.1.0",
"mochify": "^2.1.0"
},
"homepage": "[Link]
"keywords": [
"cryptography",
"math",
"bitcoin",
"arbitrary",
"precision",
"arithmetic",
"big",
"integer",
"int",
"number",
"biginteger",
"bigint",
"bignumber",
"decimal",
"float"
],
"main": "./lib/[Link]",
"name": "bigi",
"repository": {
"url": "git+[Link]
"type": "git"
},
"scripts": {
"browser-test": "mochify --wd -R spec",
"coverage": "istanbul cover ./node_modules/.bin/_mocha -- --reporter list
test/*.js",
"coveralls": "npm run-script coverage && node ./node_modules/.bin/coveralls <
coverage/[Link]",
"jshint": "jshint --config [Link] lib/*.js ; true",
"test": "_mocha -- test/*.js",
"unit": "mocha"
},
"testling": {
 "files": "test/*.js",
"harness": "mocha",
"browsers": [
"ie/9..latest",
"firefox/latest",
"chrome/latest",
"safari/6.0..latest",
"iphone/6.0..latest",
"android-browser/4.2..latest"
]
},
"version": "1.4.2"
}

},{}],7:[function(require,module,exports){
// Reference [Link]
// Format: 0x30 [total-length] 0x02 [R-length] [R] 0x02 [S-length] [S]
// NOTE: SIGHASH byte ignored AND restricted, truncate before use

var Buffer = require('safe-buffer').Buffer

function check (buffer) {

if ([Link] < 8) return false
if ([Link] > 72) return false
if (buffer[0] !== 0x30) return false
if (buffer[1] !== [Link] - 2) return false
if (buffer[2] !== 0x02) return false

var lenR = buffer[3]

if (lenR === 0) return false
if (5 + lenR >= [Link]) return false
if (buffer[4 + lenR] !== 0x02) return false

var lenS = buffer[5 + lenR]

if (lenS === 0) return false
if ((6 + lenR + lenS) !== [Link]) return false

if (buffer[4] & 0x80) return false

if (lenR > 1 && (buffer[4] === 0x00) && !(buffer[5] & 0x80)) return false

if (buffer[lenR + 6] & 0x80) return false

if (lenS > 1 && (buffer[lenR + 6] === 0x00) && !(buffer[lenR + 7] & 0x80)) return
false
return true
}

function decode (buffer) {

if ([Link] < 8) throw new Error('DER sequence length is too short')
if ([Link] > 72) throw new Error('DER sequence length is too long')
if (buffer[0] !== 0x30) throw new Error('Expected DER sequence')
if (buffer[1] !== [Link] - 2) throw new Error('DER sequence length is
invalid')
if (buffer[2] !== 0x02) throw new Error('Expected DER integer')

var lenR = buffer[3]

if (lenR === 0) throw new Error('R length is zero')
if (5 + lenR >= [Link]) throw new Error('R length is too long')
if (buffer[4 + lenR] !== 0x02) throw new Error('Expected DER integer (2)')
 var lenS = buffer[5 + lenR]
if (lenS === 0) throw new Error('S length is zero')
if ((6 + lenR + lenS) !== [Link]) throw new Error('S length is invalid')

if (buffer[4] & 0x80) throw new Error('R value is negative')

if (lenR > 1 && (buffer[4] === 0x00) && !(buffer[5] & 0x80)) throw new Error('R
value excessively padded')

if (buffer[lenR + 6] & 0x80) throw new Error('S value is negative')

if (lenS > 1 && (buffer[lenR + 6] === 0x00) && !(buffer[lenR + 7] & 0x80)) throw
new Error('S value excessively padded')

// non-BIP66 - extract R, S values

return {
r: [Link](4, 4 + lenR),
s: [Link](6 + lenR)
}
}

/*
* Expects r and s to be positive DER integers.
*
* The DER format uses the most significant bit as a sign bit (& 0x80).
* If the significant bit is set AND the integer is positive, a 0x00 is prepended.
*
* Examples:
*
* 0 => 0x00
* 1 => 0x01
* -1 => 0xff
* 127 => 0x7f
* -127 => 0x81
* 128 => 0x0080
* -128 => 0x80
* 255 => 0x00ff
* -255 => 0xff01
* 16300 => 0x3fac
* -16300 => 0xc054
* 62300 => 0x00f35c
* -62300 => 0xff0ca4
*/
function encode (r, s) {
var lenR = [Link]
var lenS = [Link]
if (lenR === 0) throw new Error('R length is zero')
if (lenS === 0) throw new Error('S length is zero')
if (lenR > 33) throw new Error('R length is too long')
if (lenS > 33) throw new Error('S length is too long')
if (r[0] & 0x80) throw new Error('R value is negative')
if (s[0] & 0x80) throw new Error('S value is negative')
if (lenR > 1 && (r[0] === 0x00) && !(r[1] & 0x80)) throw new Error('R value
excessively padded')
if (lenS > 1 && (s[0] === 0x00) && !(s[1] & 0x80)) throw new Error('S value
excessively padded')

var signature = [Link](6 + lenR + lenS)

// 0x30 [total-length] 0x02 [R-length] [R] 0x02 [S-length] [S]

signature[0] = 0x30
 signature[1] = [Link] - 2
signature[2] = 0x02
signature[3] = [Link]
[Link](signature, 4)
signature[4 + lenR] = 0x02
signature[5 + lenR] = [Link]
[Link](signature, 6 + lenR)

return signature
}

[Link] = {
check: check,
decode: decode,
encode: encode
}

},{"safe-buffer":30}],8:[function(require,module,exports){
[Link]={
"OP_FALSE": 0,
"OP_0": 0,
"OP_PUSHDATA1": 76,
"OP_PUSHDATA2": 77,
"OP_PUSHDATA4": 78,
"OP_1NEGATE": 79,
"OP_RESERVED": 80,
"OP_TRUE": 81,
"OP_1": 81,
"OP_2": 82,
"OP_3": 83,
"OP_4": 84,
"OP_5": 85,
"OP_6": 86,
"OP_7": 87,
"OP_8": 88,
"OP_9": 89,
"OP_10": 90,
"OP_11": 91,
"OP_12": 92,
"OP_13": 93,
"OP_14": 94,
"OP_15": 95,
"OP_16": 96,

"OP_NOP": 97,
"OP_VER": 98,
"OP_IF": 99,
"OP_NOTIF": 100,
"OP_VERIF": 101,
"OP_VERNOTIF": 102,
"OP_ELSE": 103,
"OP_ENDIF": 104,
"OP_VERIFY": 105,
"OP_RETURN": 106,

"OP_TOALTSTACK": 107,
"OP_FROMALTSTACK": 108,
"OP_2DROP": 109,
"OP_2DUP": 110,
"OP_3DUP": 111,
"OP_2OVER": 112,
"OP_2ROT": 113,
"OP_2SWAP": 114,
"OP_IFDUP": 115,
"OP_DEPTH": 116,
"OP_DROP": 117,
"OP_DUP": 118,
"OP_NIP": 119,
"OP_OVER": 120,
"OP_PICK": 121,
"OP_ROLL": 122,
"OP_ROT": 123,
"OP_SWAP": 124,
"OP_TUCK": 125,

"OP_CAT": 126,
"OP_SUBSTR": 127,
"OP_LEFT": 128,
"OP_RIGHT": 129,
"OP_SIZE": 130,

"OP_INVERT": 131,
"OP_AND": 132,
"OP_OR": 133,
"OP_XOR": 134,
"OP_EQUAL": 135,
"OP_EQUALVERIFY": 136,
"OP_RESERVED1": 137,
"OP_RESERVED2": 138,

"OP_1ADD": 139,
"OP_1SUB": 140,
"OP_2MUL": 141,
"OP_2DIV": 142,
"OP_NEGATE": 143,
"OP_ABS": 144,
"OP_NOT": 145,
"OP_0NOTEQUAL": 146,
"OP_ADD": 147,
"OP_SUB": 148,
"OP_MUL": 149,
"OP_DIV": 150,
"OP_MOD": 151,
"OP_LSHIFT": 152,
"OP_RSHIFT": 153,

"OP_BOOLAND": 154,
"OP_BOOLOR": 155,
"OP_NUMEQUAL": 156,
"OP_NUMEQUALVERIFY": 157,
"OP_NUMNOTEQUAL": 158,
"OP_LESSTHAN": 159,
"OP_GREATERTHAN": 160,
"OP_LESSTHANOREQUAL": 161,
"OP_GREATERTHANOREQUAL": 162,
"OP_MIN": 163,
"OP_MAX": 164,
 "OP_WITHIN": 165,

"OP_RIPEMD160": 166,
"OP_SHA1": 167,
"OP_SHA256": 168,
"OP_HASH160": 169,
"OP_HASH256": 170,
"OP_CODESEPARATOR": 171,
"OP_CHECKSIG": 172,
"OP_CHECKSIGVERIFY": 173,
"OP_CHECKMULTISIG": 174,
"OP_CHECKMULTISIGVERIFY": 175,

"OP_NOP1": 176,

"OP_NOP2": 177,
"OP_CHECKLOCKTIMEVERIFY": 177,

"OP_NOP3": 178,
"OP_CHECKSEQUENCEVERIFY": 178,

"OP_NOP4": 179,
"OP_NOP5": 180,
"OP_NOP6": 181,
"OP_NOP7": 182,
"OP_NOP8": 183,
"OP_NOP9": 184,
"OP_NOP10": 185,

"OP_PUBKEYHASH": 253,
"OP_PUBKEY": 254,
"OP_INVALIDOPCODE": 255
}

},{}],9:[function(require,module,exports){
var OPS = require('./[Link]')

var map = {}
for (var op in OPS) {
var code = OPS[op]
map[code] = op
}

[Link] = map

},{"./[Link]":8}],10:[function(require,module,exports){
var basex = require('base-x')
var ALPHABET = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'

[Link] = basex(ALPHABET)

},{"base-x":1}],11:[function(require,module,exports){
'use strict'

var base58 = require('bs58')

var Buffer = require('safe-buffer').Buffer

[Link] = function (checksumFn) {

// Encode a buffer as a base58-check encoded string
 function encode (payload) {
var checksum = checksumFn(payload)

return [Link]([Link]([
payload,
checksum
], [Link] + 4))
}

function decodeRaw (buffer) {

var payload = [Link](0, -4)
var checksum = [Link](-4)
var newChecksum = checksumFn(payload)

if (checksum[0] ^ newChecksum[0] |
checksum[1] ^ newChecksum[1] |
checksum[2] ^ newChecksum[2] |
checksum[3] ^ newChecksum[3]) return

return payload
}

// Decode a base58-check encoded string to a buffer, no result if checksum is

wrong
function decodeUnsafe (string) {
var buffer = [Link](string)
if (!buffer) return

return decodeRaw(buffer)
}

function decode (string) {

var buffer = [Link](string)
var payload = decodeRaw(buffer, checksumFn)
if (!payload) throw new Error('Invalid checksum')
return payload
}

return {
encode: encode,
decode: decode,
decodeUnsafe: decodeUnsafe
}
}

},{"bs58":10,"safe-buffer":30}],12:[function(require,module,exports){
'use strict'

var createHash = require('create-hash')

var bs58checkBase = require('./base')

// SHA256(SHA256(buffer))
function sha256x2 (buffer) {
var tmp = createHash('sha256').update(buffer).digest()
return createHash('sha256').update(tmp).digest()
}

[Link] = bs58checkBase(sha256x2)
},{"./base":11,"create-hash":14}],13:[function(require,module,exports){
var Buffer = require('safe-buffer').Buffer
var Transform = require('stream').Transform
var StringDecoder = require('string_decoder').StringDecoder
var inherits = require('inherits')

function CipherBase (hashMode) {

[Link](this)
[Link] = typeof hashMode === 'string'
if ([Link]) {
this[hashMode] = this._finalOrDigest
} else {
[Link] = this._finalOrDigest
}
if (this._final) {
this.__final = this._final
this._final = null
}
this._decoder = null
this._encoding = null
}
inherits(CipherBase, Transform)

[Link] = function (data, inputEnc, outputEnc) {

if (typeof data === 'string') {
data = [Link](data, inputEnc)
}

var outData = this._update(data)

if ([Link]) return this

if (outputEnc) {
outData = this._toString(outData, outputEnc)
}

return outData
}

[Link] = function () {}
[Link] = function () {
throw new Error('trying to get auth tag in unsupported state')
}

[Link] = function () {
throw new Error('trying to set auth tag in unsupported state')
}

[Link] = function () {
throw new Error('trying to set aad in unsupported state')
}

[Link]._transform = function (data, _, next) {

var err
try {
if ([Link]) {
this._update(data)
} else {
[Link](this._update(data))
}
 } catch (e) {
err = e
} finally {
next(err)
}
}
[Link]._flush = function (done) {
var err
try {
[Link](this.__final())
} catch (e) {
err = e
}

done(err)
}
[Link]._finalOrDigest = function (outputEnc) {
var outData = this.__final() || [Link](0)
if (outputEnc) {
outData = this._toString(outData, outputEnc, true)
}
return outData
}

[Link]._toString = function (value, enc, fin) {

if (!this._decoder) {
this._decoder = new StringDecoder(enc)
this._encoding = enc
}

if (this._encoding !== enc) throw new Error('can\'t switch encodings')

var out = this._decoder.write(value)

if (fin) {
out += this._decoder.end()
}

return out
}

[Link] = CipherBase

},{"inherits":24,"safe-buffer":30,"stream":103,"string_decoder":104}],14:
[function(require,module,exports){
'use strict'
var inherits = require('inherits')
var MD5 = require('[Link]')
var RIPEMD160 = require('ripemd160')
var sha = require('[Link]')
var Base = require('cipher-base')

function Hash (hash) {

[Link](this, 'digest')

this._hash = hash
}

inherits(Hash, Base)
[Link]._update = function (data) {
this._hash.update(data)
}

[Link]._final = function () {
return this._hash.digest()
}

[Link] = function createHash (alg) {

alg = [Link]()
if (alg === 'md5') return new MD5()
if (alg === 'rmd160' || alg === 'ripemd160') return new RIPEMD160()

return new Hash(sha(alg))

}

},{"cipher-base":13,"inherits":24,"[Link]":25,"ripemd160":29,"[Link]":32}],15:
[function(require,module,exports){
var MD5 = require('[Link]')

[Link] = function (buffer) {

return new MD5().update(buffer).digest()
}

},{"[Link]":25}],16:[function(require,module,exports){
'use strict'
var inherits = require('inherits')
var Legacy = require('./legacy')
var Base = require('cipher-base')
var Buffer = require('safe-buffer').Buffer
var md5 = require('create-hash/md5')
var RIPEMD160 = require('ripemd160')

var sha = require('[Link]')

var ZEROS = [Link](128)

function Hmac (alg, key) {

[Link](this, 'digest')
if (typeof key === 'string') {
key = [Link](key)
}

var blocksize = (alg === 'sha512' || alg === 'sha384') ? 128 : 64

this._alg = alg
this._key = key
if ([Link] > blocksize) {
var hash = alg === 'rmd160' ? new RIPEMD160() : sha(alg)
key = [Link](key).digest()
} else if ([Link] < blocksize) {
key = [Link]([key, ZEROS], blocksize)
}

var ipad = this._ipad = [Link](blocksize)

var opad = this._opad = [Link](blocksize)

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

ipad[i] = key[i] ^ 0x36
 opad[i] = key[i] ^ 0x5C
}
this._hash = alg === 'rmd160' ? new RIPEMD160() : sha(alg)
this._hash.update(ipad)
}

inherits(Hmac, Base)

[Link]._update = function (data) {

this._hash.update(data)
}

[Link]._final = function () {
var h = this._hash.digest()
var hash = this._alg === 'rmd160' ? new RIPEMD160() : sha(this._alg)
return [Link](this._opad).update(h).digest()
}

[Link] = function createHmac (alg, key) {

alg = [Link]()
if (alg === 'rmd160' || alg === 'ripemd160') {
return new Hmac('rmd160', key)
}
if (alg === 'md5') {
return new Legacy(md5, key)
}
return new Hmac(alg, key)
}

},{"./legacy":17,"cipher-base":13,"create-hash/
md5":15,"inherits":24,"ripemd160":29,"safe-buffer":30,"[Link]":32}],17:
[function(require,module,exports){
'use strict'
var inherits = require('inherits')
var Buffer = require('safe-buffer').Buffer

var Base = require('cipher-base')

var ZEROS = [Link](128)

var blocksize = 64

function Hmac (alg, key) {

[Link](this, 'digest')
if (typeof key === 'string') {
key = [Link](key)
}

this._alg = alg
this._key = key

if ([Link] > blocksize) {

key = alg(key)
} else if ([Link] < blocksize) {
key = [Link]([key, ZEROS], blocksize)
}

var ipad = this._ipad = [Link](blocksize)

var opad = this._opad = [Link](blocksize)
 for (var i = 0; i < blocksize; i++) {
ipad[i] = key[i] ^ 0x36
opad[i] = key[i] ^ 0x5C
}

this._hash = [ipad]
}

inherits(Hmac, Base)

[Link]._update = function (data) {

this._hash.push(data)
}

[Link]._final = function () {
var h = this._alg([Link](this._hash))
return this._alg([Link]([this._opad, h]))
}
[Link] = Hmac

},{"cipher-base":13,"inherits":24,"safe-buffer":30}],18:
[function(require,module,exports){
var assert = require('assert')
var BigInteger = require('bigi')

var Point = require('./point')

function Curve (p, a, b, Gx, Gy, n, h) {

this.p = p
this.a = a
this.b = b
this.G = [Link](this, Gx, Gy)
this.n = n
this.h = h

[Link] = new Point(this, null, null, [Link])

// result caching
[Link] = [Link]([Link]).shiftRight(2)

// determine size of p in bytes

[Link] = [Link](([Link]() + 7) / 8)
}

[Link] = function (isOdd, x) {

var alpha = [Link](3).add([Link](x)).add(this.b).mod(this.p)
var beta = [Link]([Link], this.p) // XXX: not compatible with all
curves

var y = beta
if ([Link]() ^ !isOdd) {
y = [Link](y) // -y % p
}

return [Link](this, x, y)
}

[Link] = function (Q) {

if (Q === [Link]) return true
 return [Link]() === 0 && [Link]() !== 0
}

[Link] = function (Q) {

if ([Link](Q)) return true

var x = [Link]
var y = [Link]
var a = this.a
var b = this.b
var p = this.p

// Check that xQ and yQ are integers in the interval [0, p - 1]

if ([Link]() < 0 || [Link](p) >= 0) return false
if ([Link]() < 0 || [Link](p) >= 0) return false

// and check that y^2 = x^3 + ax + b (mod p)

var lhs = [Link]().mod(p)
var rhs = [Link](3).add([Link](x)).add(b).mod(p)
return [Link](rhs)
}

/**
* Validate an elliptic curve point.
*
* See SEC 1, section [Link]: Elliptic Curve Public Key Validation Primitive
*/
[Link] = function (Q) {
// Check Q != O
assert(, 'Point is at infinity')
assert([Link](Q), 'Point is not on the curve')

// Check nQ = O (where Q is a scalar multiple of G)

var nQ = [Link](this.n)
assert([Link](nQ), 'Point is not a scalar multiple of G')

return true
}

[Link] = Curve

},{"./point":22,"assert":82,"bigi":5}],19:[function(require,module,exports){
[Link]={
"secp128r1": {
"p": "fffffffdffffffffffffffffffffffff",
"a": "fffffffdfffffffffffffffffffffffc",
"b": "e87579c11079f43dd824993c2cee5ed3",
"n": "fffffffe0000000075a30d1b9038a115",
"h": "01",
"Gx": "161ff7528b899b2d0c28607ca52c5b86",
"Gy": "cf5ac8395bafeb13c02da292dded7a83"
},
"secp160k1": {
"p": "fffffffffffffffffffffffffffffffeffffac73",
"a": "00",
"b": "07",
"n": "0100000000000000000001b8fa16dfab9aca16b6b3",
"h": "01",
 "Gx": "3b4c382ce37aa192a4019e763036f4f5dd4d7ebb",
"Gy": "938cf935318fdced6bc28286531733c3f03c4fee"
},
"secp160r1": {
"p": "ffffffffffffffffffffffffffffffff7fffffff",
"a": "ffffffffffffffffffffffffffffffff7ffffffc",
"b": "1c97befc54bd7a8b65acf89f81d4d4adc565fa45",
"n": "0100000000000000000001f4c8f927aed3ca752257",
"h": "01",
"Gx": "4a96b5688ef573284664698968c38bb913cbfc82",
"Gy": "23a628553168947d59dcc912042351377ac5fb32"
},
"secp192k1": {
"p": "fffffffffffffffffffffffffffffffffffffffeffffee37",
"a": "00",
"b": "03",
"n": "fffffffffffffffffffffffe26f2fc170f69466a74defd8d",
"h": "01",
"Gx": "db4ff10ec057e9ae26b07d0280b7f4341da5d1b1eae06c7d",
"Gy": "9b2f2f6d9c5628a7844163d015be86344082aa88d95e2f9d"
},
"secp192r1": {
"p": "fffffffffffffffffffffffffffffffeffffffffffffffff",
"a": "fffffffffffffffffffffffffffffffefffffffffffffffc",
"b": "64210519e59c80e70fa7e9ab72243049feb8deecc146b9b1",
"n": "ffffffffffffffffffffffff99def836146bc9b1b4d22831",
"h": "01",
"Gx": "188da80eb03090f67cbf20eb43a18800f4ff0afd82ff1012",
"Gy": "07192b95ffc8da78631011ed6b24cdd573f977a11e794811"
},
"secp256k1": {
"p": "fffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f",
"a": "00",
"b": "07",
"n": "fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141",
"h": "01",
"Gx": "79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798",
"Gy": "483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8"
},
"secp256r1": {
"p": "ffffffff00000001000000000000000000000000ffffffffffffffffffffffff",
"a": "ffffffff00000001000000000000000000000000fffffffffffffffffffffffc",
"b": "5ac635d8aa3a93e7b3ebbd55769886bc651d06b0cc53b0f63bce3c3e27d2604b",
"n": "ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551",
"h": "01",
"Gx": "6b17d1f2e12c4247f8bce6e563a440f277037d812deb33a0f4a13945d898c296",
"Gy": "4fe342e2fe1a7f9b8ee7eb4a7c0f9e162bce33576b315ececbb6406837bf51f5"
}
}

},{}],20:[function(require,module,exports){
var Point = require('./point')
var Curve = require('./curve')

var getCurveByName = require('./names')

[Link] = {
Curve: Curve,
Point: Point,
 getCurveByName: getCurveByName
}

},{"./curve":18,"./names":21,"./point":22}],21:[function(require,module,exports){
var BigInteger = require('bigi')

var curves = require('./[Link]')

var Curve = require('./curve')

function getCurveByName (name) {

var curve = curves[name]
if (!curve) return null

var p = new BigInteger(curve.p, 16)

var a = new BigInteger(curve.a, 16)
var b = new BigInteger(curve.b, 16)
var n = new BigInteger(curve.n, 16)
var h = new BigInteger(curve.h, 16)
var Gx = new BigInteger([Link], 16)
var Gy = new BigInteger([Link], 16)

return new Curve(p, a, b, Gx, Gy, n, h)

}

[Link] = getCurveByName

},{"./curve":18,"./[Link]":19,"bigi":5}],22:[function(require,module,exports){
var assert = require('assert')
var Buffer = require('safe-buffer').Buffer
var BigInteger = require('bigi')

var THREE = [Link](3)

function Point (curve, x, y, z) {

[Link](z, undefined, 'Missing Z coordinate')

[Link] = curve
this.x = x
this.y = y
this.z = z
this._zInv = null

[Link] = true
}

[Link]([Link], 'zInv', {
get: function () {
if (this._zInv === null) {
this._zInv = [Link]([Link].p)
}

return this._zInv
}
})

[Link]([Link], 'affineX', {
get: function () {
return [Link]([Link]).mod([Link].p)
}
})

[Link]([Link], 'affineY', {
get: function () {
return [Link]([Link]).mod([Link].p)
}
})

[Link] = function (curve, x, y) {

return new Point(curve, x, y, [Link])
}

[Link] = function (other) {

if (other === this) return true
if ([Link](this)) return [Link](other)
if ([Link](other)) return [Link](this)

// u = Y2 * Z1 - Y1 * Z2
var u =
[Link](this.z).subtract([Link](other.z)).mod([Link].p)

if ([Link]() !== 0) return false

// v = X2 * Z1 - X1 * Z2
var v =
[Link](this.z).subtract([Link](other.z)).mod([Link].p)

return [Link]() === 0

}

[Link] = function () {
var y = [Link](this.y)

return new Point([Link], this.x, y, this.z)

}

[Link] = function (b) {

if ([Link](this)) return b
if ([Link](b)) return this

var x1 = this.x
var y1 = this.y
var x2 = b.x
var y2 = b.y

// u = Y2 * Z1 - Y1 * Z2
var u = [Link](this.z).subtract([Link](b.z)).mod([Link].p)
// v = X2 * Z1 - X1 * Z2
var v = [Link](this.z).subtract([Link](b.z)).mod([Link].p)

if ([Link]() === 0) {
if ([Link]() === 0) {
return [Link]() // this == b, so double
}

return [Link] // this = -b, so infinity

}

var v2 = [Link]()
 var v3 = [Link](v)
var x1v2 = [Link](v2)
var zu2 = [Link]().multiply(this.z)

// x3 = v * (z2 * (z1 * u^2 - 2 * x1 * v^2) - v^3)

var x3 =
[Link]([Link](1)).multiply(b.z).subtract(v3).multiply(v).mod([Link]
ve.p)
// y3 = z2 * (3 * x1 * u * v^2 - y1 * v^3 - z1 * u^3) + u * v^3
var y3 =
[Link](THREE).multiply(u).subtract([Link](v3)).subtract([Link](u)
).multiply(b.z).add([Link](v3)).mod([Link].p)
// z3 = v^3 * z1 * z2
var z3 = [Link](this.z).multiply(b.z).mod([Link].p)

return new Point([Link], x3, y3, z3)

}

[Link] = function () {
if ([Link](this)) return this
if ([Link]() === 0) return [Link]

var x1 = this.x
var y1 = this.y

var y1z1 = [Link](this.z).mod([Link].p)

var y1sqz1 = [Link](y1).mod([Link].p)
var a = [Link].a

// w = 3 * x1^2 + a * z1^2
var w = [Link]().multiply(THREE)

if ([Link]() !== 0) {
w = [Link]([Link]().multiply(a))
}

w = [Link]([Link].p)
// x3 = 2 * y1 * z1 * (w^2 - 8 * x1 * y1^2 * z1)
var x3 =
[Link]().subtract([Link](3).multiply(y1sqz1)).shiftLeft(1).multiply(y1z1).m
od([Link].p)
// y3 = 4 * y1^2 * z1 * (3 * w * x1 - 2 * y1^2 * z1) - w^3
var y3 =
[Link](THREE).multiply(x1).subtract([Link](1)).shiftLeft(2).multiply(
y1sqz1).subtract([Link](3)).mod([Link].p)
// z3 = 8 * (y1 * z1)^3
var z3 = [Link](3).shiftLeft(3).mod([Link].p)

return new Point([Link], x3, y3, z3)

}

// Simple NAF (Non-Adjacent Form) multiplication algorithm

// TODO: modularize the multiplication algorithm
[Link] = function (k) {
if ([Link](this)) return this
if ([Link]() === 0) return [Link]

var e = k
var h = [Link](THREE)
 var neg = [Link]()
var R = this

for (var i = [Link]() - 2; i > 0; --i) {

var hBit = [Link](i)
var eBit = [Link](i)

R = [Link]()

if (hBit !== eBit) {

R = [Link](hBit ? this : neg)
}
}

return R
}

// Compute this*j + x*k (simultaneous multiplication)

[Link] = function (j, x, k) {
var i = [Link]([Link](), [Link]()) - 1
var R = [Link]
var both = [Link](x)

while (i >= 0) {
var jBit = [Link](i)
var kBit = [Link](i)

R = [Link]()

if (jBit) {
if (kBit) {
R = [Link](both)
} else {
R = [Link](this)
}
} else if (kBit) {
R = [Link](x)
}
--i
}

return R
}

[Link] = function (compressed) {

if (compressed == null) compressed = [Link]
if ([Link](this)) return [Link](1, 0) // Infinity point
encoded is simply '00'

var x = [Link]
var y = [Link]
var byteLength = [Link]
var buffer

// 0x02/0x03 | X
if (compressed) {
buffer = [Link](1 + byteLength)
buffer.writeUInt8([Link]() ? 0x02 : 0x03, 0)
 // 0x04 | X | Y
} else {
buffer = [Link](1 + byteLength + byteLength)
buffer.writeUInt8(0x04, 0)

[Link](byteLength).copy(buffer, 1 + byteLength)
}

[Link](byteLength).copy(buffer, 1)

return buffer
}

[Link] = function (curve, buffer) {

var type = buffer.readUInt8(0)
var compressed = (type !== 4)

var byteLength = [Link](([Link]() + 7) / 8)

var x = [Link]([Link](1, 1 + byteLength))

var Q
if (compressed) {
[Link]([Link], byteLength + 1, 'Invalid sequence length')
assert(type === 0x02 || type === 0x03, 'Invalid sequence tag')

var isOdd = (type === 0x03)

Q = [Link](isOdd, x)
} else {
[Link]([Link], 1 + byteLength + byteLength, 'Invalid sequence
length')

var y = [Link]([Link](1 + byteLength))

Q = [Link](curve, x, y)
}

[Link] = compressed
return Q
}

[Link] = function () {
if ([Link](this)) return '(INFINITY)'

return '(' + [Link]() + ',' + [Link]() + ')'

}

[Link] = Point

},{"assert":82,"bigi":5,"safe-buffer":30}],23:[function(require,module,exports){
'use strict'
var Buffer = require('safe-buffer').Buffer
var Transform = require('stream').Transform
var inherits = require('inherits')

function throwIfNotStringOrBuffer (val, prefix) {

if ( && typeof val !== 'string') {
throw new TypeError(prefix + ' must be a string or a buffer')
}
}
function HashBase (blockSize) {
[Link](this)

this._block = [Link](blockSize)
this._blockSize = blockSize
this._blockOffset = 0
this._length = [0, 0, 0, 0]

this._finalized = false
}

inherits(HashBase, Transform)

[Link]._transform = function (chunk, encoding, callback) {

var error = null
try {
[Link](chunk, encoding)
} catch (err) {
error = err
}

callback(error)
}

[Link]._flush = function (callback) {

var error = null
try {
[Link]([Link]())
} catch (err) {
error = err
}

callback(error)
}

[Link] = function (data, encoding) {

throwIfNotStringOrBuffer(data, 'Data')
if (this._finalized) throw new Error('Digest already called')
if () data = [Link](data, encoding)

// consume data
var block = this._block
var offset = 0
while (this._blockOffset + [Link] - offset >= this._blockSize) {
for (var i = this._blockOffset; i < this._blockSize;) block[i++] = data[offset+
+]
this._update()
this._blockOffset = 0
}
while (offset < [Link]) block[this._blockOffset++] = data[offset++]

// update length
for (var j = 0, carry = [Link] * 8; carry > 0; ++j) {
this._length[j] += carry
carry = (this._length[j] / 0x0100000000) | 0
if (carry > 0) this._length[j] -= 0x0100000000 * carry
}
 return this
}

[Link]._update = function () {
throw new Error('_update is not implemented')
}

[Link] = function (encoding) {

if (this._finalized) throw new Error('Digest already called')
this._finalized = true

var digest = this._digest()

if (encoding !== undefined) digest = [Link](encoding)

// reset state
this._block.fill(0)
this._blockOffset = 0
for (var i = 0; i < 4; ++i) this._length[i] = 0

return digest
}

[Link]._digest = function () {
throw new Error('_digest is not implemented')
}

[Link] = HashBase

},{"inherits":24,"safe-buffer":30,"stream":103}],24:
[function(require,module,exports){
if (typeof [Link] === 'function') {
// implementation from standard [Link] 'util' module
[Link] = function inherits(ctor, superCtor) {
ctor.super_ = superCtor
[Link] = [Link]([Link], {
constructor: {
value: ctor,
enumerable: false,
writable: true,
configurable: true
}
});
};
} else {
// old school shim for old browsers
[Link] = function inherits(ctor, superCtor) {
ctor.super_ = superCtor
var TempCtor = function () {}
[Link] = [Link]
[Link] = new TempCtor()
[Link] = ctor
}
}

},{}],25:[function(require,module,exports){
(function (Buffer){
'use strict'
var inherits = require('inherits')
var HashBase = require('hash-base')
var ARRAY16 = new Array(16)

function MD5 () {
[Link](this, 64)

// state
this._a = 0x67452301
this._b = 0xefcdab89
this._c = 0x98badcfe
this._d = 0x10325476
}

inherits(MD5, HashBase)

[Link]._update = function () {
var M = ARRAY16
for (var i = 0; i < 16; ++i) M[i] = this._block.readInt32LE(i * 4)

var a = this._a
var b = this._b
var c = this._c
var d = this._d

a = fnF(a, b, c, d, M[0], 0xd76aa478, 7)

d = fnF(d, a, b, c, M[1], 0xe8c7b756, 12)
c = fnF(c, d, a, b, M[2], 0x242070db, 17)
b = fnF(b, c, d, a, M[3], 0xc1bdceee, 22)
a = fnF(a, b, c, d, M[4], 0xf57c0faf, 7)
d = fnF(d, a, b, c, M[5], 0x4787c62a, 12)
c = fnF(c, d, a, b, M[6], 0xa8304613, 17)
b = fnF(b, c, d, a, M[7], 0xfd469501, 22)
a = fnF(a, b, c, d, M[8], 0x698098d8, 7)
d = fnF(d, a, b, c, M[9], 0x8b44f7af, 12)
c = fnF(c, d, a, b, M[10], 0xffff5bb1, 17)
b = fnF(b, c, d, a, M[11], 0x895cd7be, 22)
a = fnF(a, b, c, d, M[12], 0x6b901122, 7)
d = fnF(d, a, b, c, M[13], 0xfd987193, 12)
c = fnF(c, d, a, b, M[14], 0xa679438e, 17)
b = fnF(b, c, d, a, M[15], 0x49b40821, 22)

a = fnG(a, b, c, d, M[1], 0xf61e2562, 5)

d = fnG(d, a, b, c, M[6], 0xc040b340, 9)
c = fnG(c, d, a, b, M[11], 0x265e5a51, 14)
b = fnG(b, c, d, a, M[0], 0xe9b6c7aa, 20)
a = fnG(a, b, c, d, M[5], 0xd62f105d, 5)
d = fnG(d, a, b, c, M[10], 0x02441453, 9)
c = fnG(c, d, a, b, M[15], 0xd8a1e681, 14)
b = fnG(b, c, d, a, M[4], 0xe7d3fbc8, 20)
a = fnG(a, b, c, d, M[9], 0x21e1cde6, 5)
d = fnG(d, a, b, c, M[14], 0xc33707d6, 9)
c = fnG(c, d, a, b, M[3], 0xf4d50d87, 14)
b = fnG(b, c, d, a, M[8], 0x455a14ed, 20)
a = fnG(a, b, c, d, M[13], 0xa9e3e905, 5)
d = fnG(d, a, b, c, M[2], 0xfcefa3f8, 9)
c = fnG(c, d, a, b, M[7], 0x676f02d9, 14)
b = fnG(b, c, d, a, M[12], 0x8d2a4c8a, 20)

a = fnH(a, b, c, d, M[5], 0xfffa3942, 4)

 d = fnH(d, a, b, c, M[8], 0x8771f681, 11)
c = fnH(c, d, a, b, M[11], 0x6d9d6122, 16)
b = fnH(b, c, d, a, M[14], 0xfde5380c, 23)
a = fnH(a, b, c, d, M[1], 0xa4beea44, 4)
d = fnH(d, a, b, c, M[4], 0x4bdecfa9, 11)
c = fnH(c, d, a, b, M[7], 0xf6bb4b60, 16)
b = fnH(b, c, d, a, M[10], 0xbebfbc70, 23)
a = fnH(a, b, c, d, M[13], 0x289b7ec6, 4)
d = fnH(d, a, b, c, M[0], 0xeaa127fa, 11)
c = fnH(c, d, a, b, M[3], 0xd4ef3085, 16)
b = fnH(b, c, d, a, M[6], 0x04881d05, 23)
a = fnH(a, b, c, d, M[9], 0xd9d4d039, 4)
d = fnH(d, a, b, c, M[12], 0xe6db99e5, 11)
c = fnH(c, d, a, b, M[15], 0x1fa27cf8, 16)
b = fnH(b, c, d, a, M[2], 0xc4ac5665, 23)

a = fnI(a, b, c, d, M[0], 0xf4292244, 6)

d = fnI(d, a, b, c, M[7], 0x432aff97, 10)
c = fnI(c, d, a, b, M[14], 0xab9423a7, 15)
b = fnI(b, c, d, a, M[5], 0xfc93a039, 21)
a = fnI(a, b, c, d, M[12], 0x655b59c3, 6)
d = fnI(d, a, b, c, M[3], 0x8f0ccc92, 10)
c = fnI(c, d, a, b, M[10], 0xffeff47d, 15)
b = fnI(b, c, d, a, M[1], 0x85845dd1, 21)
a = fnI(a, b, c, d, M[8], 0x6fa87e4f, 6)
d = fnI(d, a, b, c, M[15], 0xfe2ce6e0, 10)
c = fnI(c, d, a, b, M[6], 0xa3014314, 15)
b = fnI(b, c, d, a, M[13], 0x4e0811a1, 21)
a = fnI(a, b, c, d, M[4], 0xf7537e82, 6)
d = fnI(d, a, b, c, M[11], 0xbd3af235, 10)
c = fnI(c, d, a, b, M[2], 0x2ad7d2bb, 15)
b = fnI(b, c, d, a, M[9], 0xeb86d391, 21)

this._a = (this._a + a) | 0
this._b = (this._b + b) | 0
this._c = (this._c + c) | 0
this._d = (this._d + d) | 0
}

[Link]._digest = function () {
// create padding and handle blocks
this._block[this._blockOffset++] = 0x80
if (this._blockOffset > 56) {
this._block.fill(0, this._blockOffset, 64)
this._update()
this._blockOffset = 0
}

this._block.fill(0, this._blockOffset, 56)

this._block.writeUInt32LE(this._length[0], 56)
this._block.writeUInt32LE(this._length[1], 60)
this._update()

// produce result
var buffer = new Buffer(16)
buffer.writeInt32LE(this._a, 0)
buffer.writeInt32LE(this._b, 4)
buffer.writeInt32LE(this._c, 8)
buffer.writeInt32LE(this._d, 12)
 return buffer
}

function rotl (x, n) {

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

function fnF (a, b, c, d, m, k, s) {

return (rotl((a + ((b & c) | ((~b) & d)) + m + k) | 0, s) + b) | 0
}

function fnG (a, b, c, d, m, k, s) {

return (rotl((a + ((b & d) | (c & (~d))) + m + k) | 0, s) + b) | 0
}

function fnH (a, b, c, d, m, k, s) {

return (rotl((a + (b ^ c ^ d) + m + k) | 0, s) + b) | 0
}

function fnI (a, b, c, d, m, k, s) {

return (rotl((a + ((c ^ (b | (~d)))) + m + k) | 0, s) + b) | 0
}

[Link] = MD5

}).call(this,require("buffer").Buffer)
},{"buffer":84,"hash-base":23,"inherits":24}],26:[function(require,module,exports){
(function (Buffer){
// constant-space merkle root calculation algorithm
[Link] = function fastRoot (values, digestFn) {
if () throw TypeError('Expected values Array')
if (typeof digestFn !== 'function') throw TypeError('Expected digest Function')

var length = [Link]

var results = [Link]()

while (length > 1) {

var j = 0

for (var i = 0; i < length; i += 2, ++j) {

var left = results[i]
var right = i + 1 === length ? left : results[i + 1]
var data = [Link]([left, right])

results[j] = digestFn(data)
}

length = j
}

return results[0]
}

}).call(this,require("buffer").Buffer)
},{"buffer":84}],27:[function(require,module,exports){
var OPS = require('bitcoin-ops')

function encodingLength (i) {

return i < OPS.OP_PUSHDATA1 ? 1
 : i <= 0xff ? 2
: i <= 0xffff ? 3
: 5
}

function encode (buffer, number, offset) {

var size = encodingLength(number)

// ~6 bit
if (size === 1) {
buffer.writeUInt8(number, offset)

// 8 bit
} else if (size === 2) {
buffer.writeUInt8(OPS.OP_PUSHDATA1, offset)
buffer.writeUInt8(number, offset + 1)

// 16 bit
} else if (size === 3) {
buffer.writeUInt8(OPS.OP_PUSHDATA2, offset)
buffer.writeUInt16LE(number, offset + 1)

// 32 bit
} else {
buffer.writeUInt8(OPS.OP_PUSHDATA4, offset)
buffer.writeUInt32LE(number, offset + 1)
}

return size
}

function decode (buffer, offset) {

var opcode = buffer.readUInt8(offset)
var number, size

// ~6 bit
if (opcode < OPS.OP_PUSHDATA1) {
number = opcode
size = 1

// 8 bit
} else if (opcode === OPS.OP_PUSHDATA1) {
if (offset + 2 > [Link]) return null
number = buffer.readUInt8(offset + 1)
size = 2

// 16 bit
} else if (opcode === OPS.OP_PUSHDATA2) {
if (offset + 3 > [Link]) return null
number = buffer.readUInt16LE(offset + 1)
size = 3

// 32 bit
} else {
if (offset + 5 > [Link]) return null
if (opcode !== OPS.OP_PUSHDATA4) throw new Error('Unexpected opcode')

number = buffer.readUInt32LE(offset + 1)
size = 5
 }

return {
opcode: opcode,
number: number,
size: size
}
}

[Link] = {
encodingLength: encodingLength,
encode: encode,
decode: decode
}

},{"bitcoin-ops":8}],28:[function(require,module,exports){
(function (process,global){
'use strict'

function oldBrowser () {
throw new Error('Secure random number generation is not supported by this
browser.\nUse Chrome, Firefox or Internet Explorer 11')
}

var Buffer = require('safe-buffer').Buffer

var crypto = [Link] || [Link]

if (crypto && [Link]) {

[Link] = randomBytes
} else {
[Link] = oldBrowser
}

function randomBytes (size, cb) {

// phantomjs needs to throw
if (size > 65536) throw new Error('requested too many random bytes')
// in case browserify isn't using the Uint8Array version
var rawBytes = new global.Uint8Array(size)

// This will not work in older browsers.

// See
[Link]
if (size > 0) { // getRandomValues fails on IE if size == 0
[Link](rawBytes)
}

// XXX: phantomjs doesn't like a buffer being passed here

var bytes = [Link]([Link])

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

return [Link](function () {
cb(null, bytes)
})
}

return bytes
}

}).call(this,require('_process'),typeof global !== "undefined" ? global : typeof

self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
},{"_process":91,"safe-buffer":30}],29:[function(require,module,exports){
'use strict'
var Buffer = require('buffer').Buffer
var inherits = require('inherits')
var HashBase = require('hash-base')

var ARRAY16 = new Array(16)

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]

function RIPEMD160 () {
[Link](this, 64)

// state
this._a = 0x67452301
this._b = 0xefcdab89
this._c = 0x98badcfe
this._d = 0x10325476
this._e = 0xc3d2e1f0
}

inherits(RIPEMD160, HashBase)

[Link]._update = function () {
var words = ARRAY16
 for (var j = 0; j < 16; ++j) words[j] = this._block.readInt32LE(j * 4)

var al = this._a | 0
var bl = this._b | 0
var cl = this._c | 0
var dl = this._d | 0
var el = this._e | 0

var ar = this._a | 0
var br = this._b | 0
var cr = this._c | 0
var dr = this._d | 0
var er = this._e | 0

// computation
for (var i = 0; i < 80; i += 1) {
var tl
var tr
if (i < 16) {
tl = fn1(al, bl, cl, dl, el, words[zl[i]], hl[0], sl[i])
tr = fn5(ar, br, cr, dr, er, words[zr[i]], hr[0], sr[i])
} else if (i < 32) {
tl = fn2(al, bl, cl, dl, el, words[zl[i]], hl[1], sl[i])
tr = fn4(ar, br, cr, dr, er, words[zr[i]], hr[1], sr[i])
} else if (i < 48) {
tl = fn3(al, bl, cl, dl, el, words[zl[i]], hl[2], sl[i])
tr = fn3(ar, br, cr, dr, er, words[zr[i]], hr[2], sr[i])
} else if (i < 64) {
tl = fn4(al, bl, cl, dl, el, words[zl[i]], hl[3], sl[i])
tr = fn2(ar, br, cr, dr, er, words[zr[i]], hr[3], sr[i])
} else { // if (i<80) {
tl = fn5(al, bl, cl, dl, el, words[zl[i]], hl[4], sl[i])
tr = fn1(ar, br, cr, dr, er, words[zr[i]], hr[4], sr[i])
}

al = el
el = dl
dl = rotl(cl, 10)
cl = bl
bl = tl

ar = er
er = dr
dr = rotl(cr, 10)
cr = br
br = tr
}

// update state
var t = (this._b + cl + dr) | 0
this._b = (this._c + dl + er) | 0
this._c = (this._d + el + ar) | 0
this._d = (this._e + al + br) | 0
this._e = (this._a + bl + cr) | 0
this._a = t
}

[Link]._digest = function () {
// create padding and handle blocks
 this._block[this._blockOffset++] = 0x80
if (this._blockOffset > 56) {
this._block.fill(0, this._blockOffset, 64)
this._update()
this._blockOffset = 0
}

this._block.fill(0, this._blockOffset, 56)

this._block.writeUInt32LE(this._length[0], 56)
this._block.writeUInt32LE(this._length[1], 60)
this._update()

// produce result
var buffer = [Link] ? [Link](20) : new Buffer(20)
buffer.writeInt32LE(this._a, 0)
buffer.writeInt32LE(this._b, 4)
buffer.writeInt32LE(this._c, 8)
buffer.writeInt32LE(this._d, 12)
buffer.writeInt32LE(this._e, 16)
return buffer
}

function rotl (x, n) {

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

function fn1 (a, b, c, d, e, m, k, s) {

return (rotl((a + (b ^ c ^ d) + m + k) | 0, s) + e) | 0
}

function fn2 (a, b, c, d, e, m, k, s) {

return (rotl((a + ((b & c) | ((~b) & d)) + m + k) | 0, s) + e) | 0
}

function fn3 (a, b, c, d, e, m, k, s) {

return (rotl((a + ((b | (~c)) ^ d) + m + k) | 0, s) + e) | 0
}

function fn4 (a, b, c, d, e, m, k, s) {

return (rotl((a + ((b & d) | (c & (~d))) + m + k) | 0, s) + e) | 0
}

function fn5 (a, b, c, d, e, m, k, s) {

return (rotl((a + (b ^ (c | (~d))) + m + k) | 0, s) + e) | 0
}

[Link] = RIPEMD160

},{"buffer":84,"hash-base":23,"inherits":24}],30:[function(require,module,exports){
/* eslint-disable node/no-deprecated-api */
var buffer = require('buffer')
var Buffer = [Link]

// alternative to using [Link] for old browsers

function copyProps (src, dst) {
for (var key in src) {
dst[key] = src[key]
}
}
if ([Link] && [Link] && [Link] && [Link]) {
[Link] = buffer
} else {
// Copy properties from require('buffer')
copyProps(buffer, exports)
[Link] = SafeBuffer
}

function SafeBuffer (arg, encodingOrOffset, length) {

return Buffer(arg, encodingOrOffset, length)
}

// Copy static methods from Buffer

copyProps(Buffer, SafeBuffer)

[Link] = function (arg, encodingOrOffset, length) {

if (typeof arg === 'number') {
throw new TypeError('Argument must not be a number')
}
return Buffer(arg, encodingOrOffset, length)
}

[Link] = function (size, fill, encoding) {

if (typeof size !== 'number') {
throw new TypeError('Argument must be a number')
}
var buf = Buffer(size)
if (fill !== undefined) {
if (typeof encoding === 'string') {
[Link](fill, encoding)
} else {
[Link](fill)
}
} else {
[Link](0)
}
return buf
}

[Link] = function (size) {

if (typeof size !== 'number') {
throw new TypeError('Argument must be a number')
}
return Buffer(size)
}

[Link] = function (size) {

if (typeof size !== 'number') {
throw new TypeError('Argument must be a number')
}
return [Link](size)
}

},{"buffer":84}],31:[function(require,module,exports){
var Buffer = require('safe-buffer').Buffer

// prototype class for hash functions

function Hash (blockSize, finalSize) {
this._block = [Link](blockSize)
 this._finalSize = finalSize
this._blockSize = blockSize
this._len = 0
}

[Link] = function (data, enc) {

if (typeof data === 'string') {
enc = enc || 'utf8'
data = [Link](data, enc)
}

var block = this._block

var blockSize = this._blockSize
var length = [Link]
var accum = this._len

for (var offset = 0; offset < length;) {

var assigned = accum % blockSize
var remainder = [Link](length - offset, blockSize - assigned)

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

block[assigned + i] = data[offset + i]
}

accum += remainder
offset += remainder

if ((accum % blockSize) === 0) {

this._update(block)
}
}

this._len += length
return this
}

[Link] = function (enc) {

var rem = this._len % this._blockSize

this._block[rem] = 0x80

// zero (rem + 1) trailing bits, where (rem + 1) is the smallest

// non-negative solution to the equation (length + 1 + (rem + 1)) === finalSize
mod blockSize
this._block.fill(0, rem + 1)

if (rem >= this._finalSize) {

this._update(this._block)
this._block.fill(0)
}

var bits = this._len * 8

// uint32
if (bits <= 0xffffffff) {
this._block.writeUInt32BE(bits, this._blockSize - 4)

// uint64
} else {
 var lowBits = (bits & 0xffffffff) >>> 0
var highBits = (bits - lowBits) / 0x100000000

this._block.writeUInt32BE(highBits, this._blockSize - 8)
this._block.writeUInt32BE(lowBits, this._blockSize - 4)
}

this._update(this._block)
var hash = this._hash()

return enc ? [Link](enc) : hash

}

[Link]._update = function () {
throw new Error('_update must be implemented by subclass')
}

[Link] = Hash

},{"safe-buffer":30}],32:[function(require,module,exports){
var exports = [Link] = function SHA (algorithm) {
algorithm = [Link]()

var Algorithm = exports[algorithm]

if (!Algorithm) throw new Error(algorithm + ' is not supported (we accept pull
requests)')

return new Algorithm()

}

[Link] = require('./sha')
exports.sha1 = require('./sha1')
exports.sha224 = require('./sha224')
exports.sha256 = require('./sha256')
exports.sha384 = require('./sha384')
exports.sha512 = require('./sha512')

},{"./sha":33,"./sha1":34,"./sha224":35,"./sha256":36,"./sha384":37,"./
sha512":38}],33:[function(require,module,exports){
/*
* A JavaScript implementation of the Secure Hash Algorithm, SHA-0, as defined
* in FIPS PUB 180-1
* This source code is derived from [Link] of the same repository.
* The difference between SHA-0 and SHA-1 is just a bitwise rotate left
* operation was added.
*/

var inherits = require('inherits')

var Hash = require('./hash')
var Buffer = require('safe-buffer').Buffer

var K = [
0x5a827999, 0x6ed9eba1, 0x8f1bbcdc | 0, 0xca62c1d6 | 0
]

var W = new Array(80)

function Sha () {
[Link]()
 this._w = W

[Link](this, 64, 56)

}

inherits(Sha, Hash)

[Link] = function () {
this._a = 0x67452301
this._b = 0xefcdab89
this._c = 0x98badcfe
this._d = 0x10325476
this._e = 0xc3d2e1f0

return this
}

function rotl5 (num) {

return (num << 5) | (num >>> 27)
}

function rotl30 (num) {

return (num << 30) | (num >>> 2)
}

function ft (s, b, c, d) {
if (s === 0) return (b & c) | ((~b) & d)
if (s === 2) return (b & c) | (b & d) | (c & d)
return b ^ c ^ d
}

[Link]._update = function (M) {

var W = this._w

var a = this._a | 0
var b = this._b | 0
var c = this._c | 0
var d = this._d | 0
var e = this._e | 0

for (var i = 0; i < 16; ++i) W[i] = M.readInt32BE(i * 4)

for (; i < 80; ++i) W[i] = W[i - 3] ^ W[i - 8] ^ W[i - 14] ^ W[i - 16]

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

var s = ~~(j / 20)
var t = (rotl5(a) + ft(s, b, c, d) + e + W[j] + K[s]) | 0

e = d
d = c
c = rotl30(b)
b = a
a = t
}

this._a = (a + this._a) | 0
this._b = (b + this._b) | 0
this._c = (c + this._c) | 0
this._d = (d + this._d) | 0
this._e = (e + this._e) | 0
}

[Link]._hash = function () {
var H = [Link](20)

H.writeInt32BE(this._a | 0, 0)
H.writeInt32BE(this._b | 0, 4)
H.writeInt32BE(this._c | 0, 8)
H.writeInt32BE(this._d | 0, 12)
H.writeInt32BE(this._e | 0, 16)

return H
}

[Link] = Sha

},{"./hash":31,"inherits":24,"safe-buffer":30}],34:
[function(require,module,exports){
/*
* A JavaScript implementation of the Secure Hash Algorithm, SHA-1, as defined
* in FIPS PUB 180-1
* Version 2.1a Copyright Paul Johnston 2000 - 2002.
* Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet
* Distributed under the BSD License
* See [Link] for details.
*/

var inherits = require('inherits')

var Hash = require('./hash')
var Buffer = require('safe-buffer').Buffer

var K = [
0x5a827999, 0x6ed9eba1, 0x8f1bbcdc | 0, 0xca62c1d6 | 0
]

var W = new Array(80)

function Sha1 () {
[Link]()
this._w = W

[Link](this, 64, 56)

}

inherits(Sha1, Hash)

[Link] = function () {
this._a = 0x67452301
this._b = 0xefcdab89
this._c = 0x98badcfe
this._d = 0x10325476
this._e = 0xc3d2e1f0

return this
}

function rotl1 (num) {

return (num << 1) | (num >>> 31)
}
function rotl5 (num) {
return (num << 5) | (num >>> 27)
}

function rotl30 (num) {

return (num << 30) | (num >>> 2)
}

function ft (s, b, c, d) {
if (s === 0) return (b & c) | ((~b) & d)
if (s === 2) return (b & c) | (b & d) | (c & d)
return b ^ c ^ d
}

[Link]._update = function (M) {

var W = this._w

var a = this._a | 0
var b = this._b | 0
var c = this._c | 0
var d = this._d | 0
var e = this._e | 0

for (var i = 0; i < 16; ++i) W[i] = M.readInt32BE(i * 4)

for (; i < 80; ++i) W[i] = rotl1(W[i - 3] ^ W[i - 8] ^ W[i - 14] ^ W[i - 16])

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

var s = ~~(j / 20)
var t = (rotl5(a) + ft(s, b, c, d) + e + W[j] + K[s]) | 0

e = d
d = c
c = rotl30(b)
b = a
a = t
}

this._a = (a + this._a) | 0
this._b = (b + this._b) | 0
this._c = (c + this._c) | 0
this._d = (d + this._d) | 0
this._e = (e + this._e) | 0
}

[Link]._hash = function () {
var H = [Link](20)

H.writeInt32BE(this._a | 0, 0)
H.writeInt32BE(this._b | 0, 4)
H.writeInt32BE(this._c | 0, 8)
H.writeInt32BE(this._d | 0, 12)
H.writeInt32BE(this._e | 0, 16)

return H
}

[Link] = Sha1
},{"./hash":31,"inherits":24,"safe-buffer":30}],35:
[function(require,module,exports){
/**
* A JavaScript implementation of the Secure Hash Algorithm, SHA-256, as defined
* in FIPS 180-2
* Version 2.2-beta Copyright Angel Marin, Paul Johnston 2000 - 2009.
* Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet
*
*/

var inherits = require('inherits')

var Sha256 = require('./sha256')
var Hash = require('./hash')
var Buffer = require('safe-buffer').Buffer

var W = new Array(64)

function Sha224 () {
[Link]()

this._w = W // new Array(64)

[Link](this, 64, 56)

}

inherits(Sha224, Sha256)

[Link] = function () {
this._a = 0xc1059ed8
this._b = 0x367cd507
this._c = 0x3070dd17
this._d = 0xf70e5939
this._e = 0xffc00b31
this._f = 0x68581511
this._g = 0x64f98fa7
this._h = 0xbefa4fa4

return this
}

[Link]._hash = function () {
var H = [Link](28)

H.writeInt32BE(this._a, 0)
H.writeInt32BE(this._b, 4)
H.writeInt32BE(this._c, 8)
H.writeInt32BE(this._d, 12)
H.writeInt32BE(this._e, 16)
H.writeInt32BE(this._f, 20)
H.writeInt32BE(this._g, 24)

return H
}

[Link] = Sha224

},{"./hash":31,"./sha256":36,"inherits":24,"safe-buffer":30}],36:
[function(require,module,exports){
/**
 * A JavaScript implementation of the Secure Hash Algorithm, SHA-256, as defined
* in FIPS 180-2
* Version 2.2-beta Copyright Angel Marin, Paul Johnston 2000 - 2009.
* Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet
*
*/

var inherits = require('inherits')

var Hash = require('./hash')
var Buffer = require('safe-buffer').Buffer

var K = [
0x428A2F98, 0x71374491, 0xB5C0FBCF, 0xE9B5DBA5,
0x3956C25B, 0x59F111F1, 0x923F82A4, 0xAB1C5ED5,
0xD807AA98, 0x12835B01, 0x243185BE, 0x550C7DC3,
0x72BE5D74, 0x80DEB1FE, 0x9BDC06A7, 0xC19BF174,
0xE49B69C1, 0xEFBE4786, 0x0FC19DC6, 0x240CA1CC,
0x2DE92C6F, 0x4A7484AA, 0x5CB0A9DC, 0x76F988DA,
0x983E5152, 0xA831C66D, 0xB00327C8, 0xBF597FC7,
0xC6E00BF3, 0xD5A79147, 0x06CA6351, 0x14292967,
0x27B70A85, 0x2E1B2138, 0x4D2C6DFC, 0x53380D13,
0x650A7354, 0x766A0ABB, 0x81C2C92E, 0x92722C85,
0xA2BFE8A1, 0xA81A664B, 0xC24B8B70, 0xC76C51A3,
0xD192E819, 0xD6990624, 0xF40E3585, 0x106AA070,
0x19A4C116, 0x1E376C08, 0x2748774C, 0x34B0BCB5,
0x391C0CB3, 0x4ED8AA4A, 0x5B9CCA4F, 0x682E6FF3,
0x748F82EE, 0x78A5636F, 0x84C87814, 0x8CC70208,
0x90BEFFFA, 0xA4506CEB, 0xBEF9A3F7, 0xC67178F2
]

var W = new Array(64)

function Sha256 () {
[Link]()

this._w = W // new Array(64)

[Link](this, 64, 56)

}

inherits(Sha256, Hash)

[Link] = function () {
this._a = 0x6a09e667
this._b = 0xbb67ae85
this._c = 0x3c6ef372
this._d = 0xa54ff53a
this._e = 0x510e527f
this._f = 0x9b05688c
this._g = 0x1f83d9ab
this._h = 0x5be0cd19

return this
}

function ch (x, y, z) {
return z ^ (x & (y ^ z))
}
function maj (x, y, z) {
return (x & y) | (z & (x | y))
}

function sigma0 (x) {

return (x >>> 2 | x << 30) ^ (x >>> 13 | x << 19) ^ (x >>> 22 | x << 10)
}

function sigma1 (x) {

return (x >>> 6 | x << 26) ^ (x >>> 11 | x << 21) ^ (x >>> 25 | x << 7)
}

function gamma0 (x) {

return (x >>> 7 | x << 25) ^ (x >>> 18 | x << 14) ^ (x >>> 3)
}

function gamma1 (x) {

return (x >>> 17 | x << 15) ^ (x >>> 19 | x << 13) ^ (x >>> 10)
}

[Link]._update = function (M) {

var W = this._w

var a = this._a | 0
var b = this._b | 0
var c = this._c | 0
var d = this._d | 0
var e = this._e | 0
var f = this._f | 0
var g = this._g | 0
var h = this._h | 0

for (var i = 0; i < 16; ++i) W[i] = M.readInt32BE(i * 4)

for (; i < 64; ++i) W[i] = (gamma1(W[i - 2]) + W[i - 7] + gamma0(W[i - 15]) + W[i
- 16]) | 0

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

var T1 = (h + sigma1(e) + ch(e, f, g) + K[j] + W[j]) | 0
var T2 = (sigma0(a) + maj(a, b, c)) | 0

h = g
g = f
f = e
e = (d + T1) | 0
d = c
c = b
b = a
a = (T1 + T2) | 0
}

this._a = (a + this._a) | 0
this._b = (b + this._b) | 0
this._c = (c + this._c) | 0
this._d = (d + this._d) | 0
this._e = (e + this._e) | 0
this._f = (f + this._f) | 0
this._g = (g + this._g) | 0
this._h = (h + this._h) | 0
}
[Link]._hash = function () {
var H = [Link](32)

H.writeInt32BE(this._a, 0)
H.writeInt32BE(this._b, 4)
H.writeInt32BE(this._c, 8)
H.writeInt32BE(this._d, 12)
H.writeInt32BE(this._e, 16)
H.writeInt32BE(this._f, 20)
H.writeInt32BE(this._g, 24)
H.writeInt32BE(this._h, 28)

return H
}

[Link] = Sha256

},{"./hash":31,"inherits":24,"safe-buffer":30}],37:
[function(require,module,exports){
var inherits = require('inherits')
var SHA512 = require('./sha512')
var Hash = require('./hash')
var Buffer = require('safe-buffer').Buffer

var W = new Array(160)

function Sha384 () {
[Link]()
this._w = W

[Link](this, 128, 112)

}

inherits(Sha384, SHA512)

[Link] = function () {
this._ah = 0xcbbb9d5d
this._bh = 0x629a292a
this._ch = 0x9159015a
this._dh = 0x152fecd8
this._eh = 0x67332667
this._fh = 0x8eb44a87
this._gh = 0xdb0c2e0d
this._hh = 0x47b5481d

this._al = 0xc1059ed8
this._bl = 0x367cd507
this._cl = 0x3070dd17
this._dl = 0xf70e5939
this._el = 0xffc00b31
this._fl = 0x68581511
this._gl = 0x64f98fa7
this._hl = 0xbefa4fa4

return this
}

[Link]._hash = function () {
 var H = [Link](48)

function writeInt64BE (h, l, offset) {

H.writeInt32BE(h, offset)
H.writeInt32BE(l, offset + 4)
}

writeInt64BE(this._ah, this._al, 0)
writeInt64BE(this._bh, this._bl, 8)
writeInt64BE(this._ch, this._cl, 16)
writeInt64BE(this._dh, this._dl, 24)
writeInt64BE(this._eh, this._el, 32)
writeInt64BE(this._fh, this._fl, 40)

return H
}

[Link] = Sha384

},{"./hash":31,"./sha512":38,"inherits":24,"safe-buffer":30}],38:
[function(require,module,exports){
var inherits = require('inherits')
var Hash = require('./hash')
var Buffer = require('safe-buffer').Buffer

var K = [
0x428a2f98, 0xd728ae22, 0x71374491, 0x23ef65cd,
0xb5c0fbcf, 0xec4d3b2f, 0xe9b5dba5, 0x8189dbbc,
0x3956c25b, 0xf348b538, 0x59f111f1, 0xb605d019,
0x923f82a4, 0xaf194f9b, 0xab1c5ed5, 0xda6d8118,
0xd807aa98, 0xa3030242, 0x12835b01, 0x45706fbe,
0x243185be, 0x4ee4b28c, 0x550c7dc3, 0xd5ffb4e2,
0x72be5d74, 0xf27b896f, 0x80deb1fe, 0x3b1696b1,
0x9bdc06a7, 0x25c71235, 0xc19bf174, 0xcf692694,
0xe49b69c1, 0x9ef14ad2, 0xefbe4786, 0x384f25e3,
0x0fc19dc6, 0x8b8cd5b5, 0x240ca1cc, 0x77ac9c65,
0x2de92c6f, 0x592b0275, 0x4a7484aa, 0x6ea6e483,
0x5cb0a9dc, 0xbd41fbd4, 0x76f988da, 0x831153b5,
0x983e5152, 0xee66dfab, 0xa831c66d, 0x2db43210,
0xb00327c8, 0x98fb213f, 0xbf597fc7, 0xbeef0ee4,
0xc6e00bf3, 0x3da88fc2, 0xd5a79147, 0x930aa725,
0x06ca6351, 0xe003826f, 0x14292967, 0x0a0e6e70,
0x27b70a85, 0x46d22ffc, 0x2e1b2138, 0x5c26c926,
0x4d2c6dfc, 0x5ac42aed, 0x53380d13, 0x9d95b3df,
0x650a7354, 0x8baf63de, 0x766a0abb, 0x3c77b2a8,
0x81c2c92e, 0x47edaee6, 0x92722c85, 0x1482353b,
0xa2bfe8a1, 0x4cf10364, 0xa81a664b, 0xbc423001,
0xc24b8b70, 0xd0f89791, 0xc76c51a3, 0x0654be30,
0xd192e819, 0xd6ef5218, 0xd6990624, 0x5565a910,
0xf40e3585, 0x5771202a, 0x106aa070, 0x32bbd1b8,
0x19a4c116, 0xb8d2d0c8, 0x1e376c08, 0x5141ab53,
0x2748774c, 0xdf8eeb99, 0x34b0bcb5, 0xe19b48a8,
0x391c0cb3, 0xc5c95a63, 0x4ed8aa4a, 0xe3418acb,
0x5b9cca4f, 0x7763e373, 0x682e6ff3, 0xd6b2b8a3,
0x748f82ee, 0x5defb2fc, 0x78a5636f, 0x43172f60,
0x84c87814, 0xa1f0ab72, 0x8cc70208, 0x1a6439ec,
0x90befffa, 0x23631e28, 0xa4506ceb, 0xde82bde9,
0xbef9a3f7, 0xb2c67915, 0xc67178f2, 0xe372532b,
0xca273ece, 0xea26619c, 0xd186b8c7, 0x21c0c207,
 0xeada7dd6, 0xcde0eb1e, 0xf57d4f7f, 0xee6ed178,
0x06f067aa, 0x72176fba, 0x0a637dc5, 0xa2c898a6,
0x113f9804, 0xbef90dae, 0x1b710b35, 0x131c471b,
0x28db77f5, 0x23047d84, 0x32caab7b, 0x40c72493,
0x3c9ebe0a, 0x15c9bebc, 0x431d67c4, 0x9c100d4c,
0x4cc5d4be, 0xcb3e42b6, 0x597f299c, 0xfc657e2a,
0x5fcb6fab, 0x3ad6faec, 0x6c44198c, 0x4a475817
]

var W = new Array(160)

function Sha512 () {
[Link]()
this._w = W

[Link](this, 128, 112)

}

inherits(Sha512, Hash)

[Link] = function () {
this._ah = 0x6a09e667
this._bh = 0xbb67ae85
this._ch = 0x3c6ef372
this._dh = 0xa54ff53a
this._eh = 0x510e527f
this._fh = 0x9b05688c
this._gh = 0x1f83d9ab
this._hh = 0x5be0cd19

this._al = 0xf3bcc908
this._bl = 0x84caa73b
this._cl = 0xfe94f82b
this._dl = 0x5f1d36f1
this._el = 0xade682d1
this._fl = 0x2b3e6c1f
this._gl = 0xfb41bd6b
this._hl = 0x137e2179

return this
}

function Ch (x, y, z) {
return z ^ (x & (y ^ z))
}

function maj (x, y, z) {

return (x & y) | (z & (x | y))
}

function sigma0 (x, xl) {

return (x >>> 28 | xl << 4) ^ (xl >>> 2 | x << 30) ^ (xl >>> 7 | x << 25)
}

function sigma1 (x, xl) {

return (x >>> 14 | xl << 18) ^ (x >>> 18 | xl << 14) ^ (xl >>> 9 | x << 23)
}

function Gamma0 (x, xl) {

 return (x >>> 1 | xl << 31) ^ (x >>> 8 | xl << 24) ^ (x >>> 7)
}

function Gamma0l (x, xl) {

return (x >>> 1 | xl << 31) ^ (x >>> 8 | xl << 24) ^ (x >>> 7 | xl << 25)
}

function Gamma1 (x, xl) {

return (x >>> 19 | xl << 13) ^ (xl >>> 29 | x << 3) ^ (x >>> 6)
}

function Gamma1l (x, xl) {

return (x >>> 19 | xl << 13) ^ (xl >>> 29 | x << 3) ^ (x >>> 6 | xl << 26)
}

function getCarry (a, b) {

return (a >>> 0) < (b >>> 0) ? 1 : 0
}

[Link]._update = function (M) {

var W = this._w

var ah = this._ah | 0
var bh = this._bh | 0
var ch = this._ch | 0
var dh = this._dh | 0
var eh = this._eh | 0
var fh = this._fh | 0
var gh = this._gh | 0
var hh = this._hh | 0

var al = this._al | 0
var bl = this._bl | 0
var cl = this._cl | 0
var dl = this._dl | 0
var el = this._el | 0
var fl = this._fl | 0
var gl = this._gl | 0
var hl = this._hl | 0

for (var i = 0; i < 32; i += 2) {

W[i] = M.readInt32BE(i * 4)
W[i + 1] = M.readInt32BE(i * 4 + 4)
}
for (; i < 160; i += 2) {
var xh = W[i - 15 * 2]
var xl = W[i - 15 * 2 + 1]
var gamma0 = Gamma0(xh, xl)
var gamma0l = Gamma0l(xl, xh)

xh = W[i - 2 * 2]
xl = W[i - 2 * 2 + 1]
var gamma1 = Gamma1(xh, xl)
var gamma1l = Gamma1l(xl, xh)

// W[i] = gamma0 + W[i - 7] + gamma1 + W[i - 16]

var Wi7h = W[i - 7 * 2]
var Wi7l = W[i - 7 * 2 + 1]
 var Wi16h = W[i - 16 * 2]
var Wi16l = W[i - 16 * 2 + 1]

var Wil = (gamma0l + Wi7l) | 0

var Wih = (gamma0 + Wi7h + getCarry(Wil, gamma0l)) | 0
Wil = (Wil + gamma1l) | 0
Wih = (Wih + gamma1 + getCarry(Wil, gamma1l)) | 0
Wil = (Wil + Wi16l) | 0
Wih = (Wih + Wi16h + getCarry(Wil, Wi16l)) | 0

W[i] = Wih
W[i + 1] = Wil
}

for (var j = 0; j < 160; j += 2) {

Wih = W[j]
Wil = W[j + 1]

var majh = maj(ah, bh, ch)

var majl = maj(al, bl, cl)

var sigma0h = sigma0(ah, al)

var sigma0l = sigma0(al, ah)
var sigma1h = sigma1(eh, el)
var sigma1l = sigma1(el, eh)

// t1 = h + sigma1 + ch + K[j] + W[j]

var Kih = K[j]
var Kil = K[j + 1]

var chh = Ch(eh, fh, gh)

var chl = Ch(el, fl, gl)

var t1l = (hl + sigma1l) | 0

var t1h = (hh + sigma1h + getCarry(t1l, hl)) | 0
t1l = (t1l + chl) | 0
t1h = (t1h + chh + getCarry(t1l, chl)) | 0
t1l = (t1l + Kil) | 0
t1h = (t1h + Kih + getCarry(t1l, Kil)) | 0
t1l = (t1l + Wil) | 0
t1h = (t1h + Wih + getCarry(t1l, Wil)) | 0

// t2 = sigma0 + maj
var t2l = (sigma0l + majl) | 0
var t2h = (sigma0h + majh + getCarry(t2l, sigma0l)) | 0

hh = gh
hl = gl
gh = fh
gl = fl
fh = eh
fl = el
el = (dl + t1l) | 0
eh = (dh + t1h + getCarry(el, dl)) | 0
dh = ch
dl = cl
ch = bh
cl = bl
bh = ah
 bl = al
al = (t1l + t2l) | 0
ah = (t1h + t2h + getCarry(al, t1l)) | 0
}

this._al = (this._al + al) | 0

this._bl = (this._bl + bl) | 0
this._cl = (this._cl + cl) | 0
this._dl = (this._dl + dl) | 0
this._el = (this._el + el) | 0
this._fl = (this._fl + fl) | 0
this._gl = (this._gl + gl) | 0
this._hl = (this._hl + hl) | 0

this._ah = (this._ah + ah + getCarry(this._al, al)) | 0

this._bh = (this._bh + bh + getCarry(this._bl, bl)) | 0
this._ch = (this._ch + ch + getCarry(this._cl, cl)) | 0
this._dh = (this._dh + dh + getCarry(this._dl, dl)) | 0
this._eh = (this._eh + eh + getCarry(this._el, el)) | 0
this._fh = (this._fh + fh + getCarry(this._fl, fl)) | 0
this._gh = (this._gh + gh + getCarry(this._gl, gl)) | 0
this._hh = (this._hh + hh + getCarry(this._hl, hl)) | 0
}

[Link]._hash = function () {
var H = [Link](64)

function writeInt64BE (h, l, offset) {

H.writeInt32BE(h, offset)
H.writeInt32BE(l, offset + 4)
}

writeInt64BE(this._ah, this._al, 0)
writeInt64BE(this._bh, this._bl, 8)
writeInt64BE(this._ch, this._cl, 16)
writeInt64BE(this._dh, this._dl, 24)
writeInt64BE(this._eh, this._el, 32)
writeInt64BE(this._fh, this._fl, 40)
writeInt64BE(this._gh, this._gl, 48)
writeInt64BE(this._hh, this._hl, 56)

return H
}

[Link] = Sha512

},{"./hash":31,"inherits":24,"safe-buffer":30}],39:
[function(require,module,exports){
var native = require('./native')

function getTypeName (fn) {

return [Link] || [Link]().match(/function (.*?)\s*\(/)[1]
}

function getValueTypeName (value) {

return [Link](value) ? '' : getTypeName([Link])
}

function getValue (value) {

 if ([Link](value)) return ''
if ([Link](value)) return [Link](value)
if (value && [Link](value)) return ''
return value
}

function tfJSON (type) {

if ([Link](type)) return [Link] ? [Link]() : getTypeName(type)
if ([Link](type)) return 'Array'
if (type && [Link](type)) return 'Object'

return type !== undefined ? type : ''

}

function tfErrorString (type, value, valueTypeName) {

var valueJson = getValue(value)

return 'Expected ' + tfJSON(type) + ', got' +

(valueTypeName !== '' ? ' ' + valueTypeName : '') +
(valueJson !== '' ? ' ' + valueJson : '')
}

function TfTypeError (type, value, valueTypeName) {

valueTypeName = valueTypeName || getValueTypeName(value)
[Link] = tfErrorString(type, value, valueTypeName)

[Link](this, TfTypeError)
this.__type = type
this.__value = value
this.__valueTypeName = valueTypeName
}

[Link] = [Link]([Link])
[Link] = TfTypeError

function tfPropertyErrorString (type, label, name, value, valueTypeName) {

var description = '" of type '
if (label === 'key') description = '" with key type '

return tfErrorString('property "' + tfJSON(name) + description + tfJSON(type),

value, valueTypeName)
}

function TfPropertyTypeError (type, property, label, value, valueTypeName) {

if (type) {
valueTypeName = valueTypeName || getValueTypeName(value)
[Link] = tfPropertyErrorString(type, label, property, value,
valueTypeName)
} else {
[Link] = 'Unexpected property "' + property + '"'
}

[Link](this, TfTypeError)
this.__label = label
this.__property = property
this.__type = type
this.__value = value
this.__valueTypeName = valueTypeName
}
[Link] = [Link]([Link])
[Link] = TfTypeError

function tfCustomError (expected, actual) {

return new TfTypeError(expected, {}, actual)
}

function tfSubError (e, property, label) {

// sub child?
if (e instanceof TfPropertyTypeError) {
property = property + '.' + e.__property

e = new TfPropertyTypeError(
e.__type, property, e.__label, e.__value, e.__valueTypeName
)

// child?
} else if (e instanceof TfTypeError) {
e = new TfPropertyTypeError(
e.__type, property, label, e.__value, e.__valueTypeName
)
}

[Link](e)
return e
}

[Link] = {
TfTypeError: TfTypeError,
TfPropertyTypeError: TfPropertyTypeError,
tfCustomError: tfCustomError,
tfSubError: tfSubError,
tfJSON: tfJSON,
getValueTypeName: getValueTypeName
}

},{"./native":42}],40:[function(require,module,exports){
(function (Buffer){
var NATIVE = require('./native')
var ERRORS = require('./errors')

function _Buffer (value) {

return [Link](value)
}

function Hex (value) {

return typeof value === 'string' && /^([0-9a-f]{2})+$/[Link](value)
}

function _LengthN (type, length) {

var name = [Link]()

function Length (value) {

if (!type(value)) return false
if ([Link] === length) return true

throw [Link](name + '(Length: ' + length + ')', name + '(Length:

' + [Link] + ')')
 }
[Link] = function () { return name }

return Length
}

var _ArrayN = _LengthN.bind(null, [Link])

var _BufferN = _LengthN.bind(null, _Buffer)
var _HexN = _LengthN.bind(null, Hex)
var _StringN = _LengthN.bind(null, [Link])

var UINT53_MAX = [Link](2, 53) - 1

function Finite (value) {

return typeof value === 'number' && isFinite(value)
}
function Int8 (value) { return ((value << 24) >> 24) === value }
function Int16 (value) { return ((value << 16) >> 16) === value }
function Int32 (value) { return (value | 0) === value }
function UInt8 (value) { return (value & 0xff) === value }
function UInt16 (value) { return (value & 0xffff) === value }
function UInt32 (value) { return (value >>> 0) === value }
function UInt53 (value) {
return typeof value === 'number' &&
value >= 0 &&
value <= UINT53_MAX &&
[Link](value) === value
}

var types = {
ArrayN: _ArrayN,
Buffer: _Buffer,
BufferN: _BufferN,
Finite: Finite,
Hex: Hex,
HexN: _HexN,
Int8: Int8,
Int16: Int16,
Int32: Int32,
StringN: _StringN,
UInt8: UInt8,
UInt16: UInt16,
UInt32: UInt32,
UInt53: UInt53
}

for (var typeName in types) {

types[typeName].toJSON = function (t) {
return t
}.bind(null, typeName)
}

[Link] = types

}).call(this,require("buffer").Buffer)
},{"./errors":39,"./native":42,"buffer":84}],41:[function(require,module,exports){
var ERRORS = require('./errors')
var NATIVE = require('./native')
// short-hand
var tfJSON = [Link]
var TfTypeError = [Link]
var TfPropertyTypeError = [Link]
var tfSubError = [Link]
var getValueTypeName = [Link]

var TYPES = {
arrayOf: function arrayOf (type) {
type = compile(type)

function _arrayOf (array, strict) {

if () return false
if ([Link](array)) return false

return [Link](function (value, i) {

try {
return typeforce(type, value, strict)
} catch (e) {
throw tfSubError(e, i)
}
})
}
_arrayOf.toJSON = function () { return '[' + tfJSON(type) + ']' }

return _arrayOf
},

maybe: function maybe (type) {

type = compile(type)

function _maybe (value, strict) {

return [Link](value) || type(value, strict, maybe)
}
_maybe.toJSON = function () { return '?' + tfJSON(type) }

return _maybe
},

map: function map (propertyType, propertyKeyType) {

propertyType = compile(propertyType)
if (propertyKeyType) propertyKeyType = compile(propertyKeyType)

function _map (value, strict) {

if () return false
if ([Link](value)) return false

for (var propertyName in value) {

try {
if (propertyKeyType) {
typeforce(propertyKeyType, propertyName, strict)
}
} catch (e) {
throw tfSubError(e, propertyName, 'key')
}

try {
var propertyValue = value[propertyName]
typeforce(propertyType, propertyValue, strict)
 } catch (e) {
throw tfSubError(e, propertyName)
}
}

return true
}

if (propertyKeyType) {
_map.toJSON = function () {
return '{' + tfJSON(propertyKeyType) + ': ' + tfJSON(propertyType) + '}'
}
} else {
_map.toJSON = function () { return '{' + tfJSON(propertyType) + '}' }
}

return _map
},

object: function object (uncompiled) {

var type = {}

for (var typePropertyName in uncompiled) {

type[typePropertyName] = compile(uncompiled[typePropertyName])
}

function _object (value, strict) {

if () return false
if ([Link](value)) return false

var propertyName

try {
for (propertyName in type) {
var propertyType = type[propertyName]
var propertyValue = value[propertyName]

typeforce(propertyType, propertyValue, strict)

}
} catch (e) {
throw tfSubError(e, propertyName)
}

if (strict) {
for (propertyName in value) {
if (type[propertyName]) continue

throw new TfPropertyTypeError(undefined, propertyName)

}
}

return true
}
_object.toJSON = function () { return tfJSON(type) }

return _object
},

oneOf: function oneOf () {

 var types = [].[Link](arguments).map(compile)

function _oneOf (value, strict) {

return [Link](function (type) {
try {
return typeforce(type, value, strict)
} catch (e) {
return false
}
})
}
_oneOf.toJSON = function () { return [Link](tfJSON).join('|') }

return _oneOf
},

quacksLike: function quacksLike (type) {

function _quacksLike (value) {
return type === getValueTypeName(value)
}
_quacksLike.toJSON = function () { return type }

return _quacksLike
},

tuple: function tuple () {

var types = [].[Link](arguments).map(compile)

function _tuple (values, strict) {

if ([Link](values)) return false
if ([Link]([Link])) return false
if (strict && ([Link] !== [Link])) return false

return [Link](function (type, i) {

try {
return typeforce(type, values[i], strict)
} catch (e) {
throw tfSubError(e, i)
}
})
}
_tuple.toJSON = function () { return '(' + [Link](tfJSON).join(', ') + ')' }

return _tuple
},

value: function value (expected) {

function _value (actual) {
return actual === expected
}
_value.toJSON = function () { return expected }

return _value
}
}

function compile (type) {

if ([Link](type)) {
if (type[0] === '?') return [Link]([Link](1))
 return NATIVE[type] || [Link](type)
} else if (type && [Link](type)) {
if ([Link](type)) return [Link](type[0])

return [Link](type)
} else if ([Link](type)) {
return type
}

return [Link](type)
}

function typeforce (type, value, strict, surrogate) {

if ([Link](type)) {
if (type(value, strict)) return true

throw new TfTypeError(surrogate || type, value)

}

// JIT
return typeforce(compile(type), value, strict)
}

// assign types to typeforce function

for (var typeName in NATIVE) {
typeforce[typeName] = NATIVE[typeName]
}

for (typeName in TYPES) {

typeforce[typeName] = TYPES[typeName]
}

var EXTRA = require('./extra')

for (typeName in EXTRA) {
typeforce[typeName] = EXTRA[typeName]
}

// async wrapper
function __async (type, value, strict, callback) {
// default to falsy strict if using shorthand overload
if (typeof strict === 'function') return __async(type, value, false, strict)

try {
typeforce(type, value, strict)
} catch (e) {
return callback(e)
}

callback()
}

[Link] = __async
[Link] = compile
[Link] = TfTypeError
[Link] = TfPropertyTypeError

[Link] = typeforce
},{"./errors":39,"./extra":40,"./native":42}],42:[function(require,module,exports){
var types = {
Array: function (value) { return value !== null && value !== undefined &&
[Link] === Array },
Boolean: function (value) { return typeof value === 'boolean' },
Function: function (value) { return typeof value === 'function' },
Nil: function (value) { return value === undefined || value === null },
Number: function (value) { return typeof value === 'number' },
Object: function (value) { return typeof value === 'object' },
String: function (value) { return typeof value === 'string' },
'': function () { return true }
}

// TODO: deprecate
[Link] = [Link]

for (var typeName in types) {

types[typeName].toJSON = function (t) {
return t
}.bind(null, typeName)
}

[Link] = types

},{}],43:[function(require,module,exports){
'use strict'
var Buffer = require('safe-buffer').Buffer

// Number.MAX_SAFE_INTEGER
var MAX_SAFE_INTEGER = 9007199254740991

function checkUInt53 (n) {

if (n < 0 || n > MAX_SAFE_INTEGER || n % 1 !== 0) throw new RangeError('value out
of range')
}

function encode (number, buffer, offset) {

checkUInt53(number)

if (!buffer) buffer = [Link](encodingLength(number))

if () throw new TypeError('buffer must be a Buffer
instance')
if (!offset) offset = 0

// 8 bit
if (number < 0xfd) {
buffer.writeUInt8(number, offset)
[Link] = 1

// 16 bit
} else if (number <= 0xffff) {
buffer.writeUInt8(0xfd, offset)
buffer.writeUInt16LE(number, offset + 1)
[Link] = 3

// 32 bit
} else if (number <= 0xffffffff) {
buffer.writeUInt8(0xfe, offset)
buffer.writeUInt32LE(number, offset + 1)
 [Link] = 5

// 64 bit
} else {
buffer.writeUInt8(0xff, offset)
buffer.writeUInt32LE(number >>> 0, offset + 1)
buffer.writeUInt32LE((number / 0x100000000) | 0, offset + 5)
[Link] = 9
}

return buffer
}

function decode (buffer, offset) {

if () throw new TypeError('buffer must be a Buffer
instance')
if (!offset) offset = 0

var first = buffer.readUInt8(offset)

// 8 bit
if (first < 0xfd) {
[Link] = 1
return first

// 16 bit
} else if (first === 0xfd) {
[Link] = 3
return buffer.readUInt16LE(offset + 1)

// 32 bit
} else if (first === 0xfe) {
[Link] = 5
return buffer.readUInt32LE(offset + 1)

// 64 bit
} else {
[Link] = 9
var lo = buffer.readUInt32LE(offset + 1)
var hi = buffer.readUInt32LE(offset + 5)
var number = hi * 0x0100000000 + lo
checkUInt53(number)

return number
}
}

function encodingLength (number) {

checkUInt53(number)

return (
number < 0xfd ? 1
: number <= 0xffff ? 3
: number <= 0xffffffff ? 5
: 9
)
}

[Link] = { encode: encode, decode: decode, encodingLength: encodingLength }

},{"safe-buffer":30}],44:[function(require,module,exports){
(function (Buffer){
var bs58check = require('bs58check')

function decodeRaw (buffer, version) {

// check version only if defined
if (version !== undefined && buffer[0] !== version) throw new Error('Invalid
network version')

// uncompressed
if ([Link] === 33) {
return {
version: buffer[0],
privateKey: [Link](1, 33),
compressed: false
}
}

// invalid length
if ([Link] !== 34) throw new Error('Invalid WIF length')

// invalid compression flag

if (buffer[33] !== 0x01) throw new Error('Invalid compression flag')

return {
version: buffer[0],
privateKey: [Link](1, 33),
compressed: true
}
}

function encodeRaw (version, privateKey, compressed) {

var result = new Buffer(compressed ? 34 : 33)

result.writeUInt8(version, 0)
[Link](result, 1)

if (compressed) {
result[33] = 0x01
}

return result
}

function decode (string, version) {

return decodeRaw([Link](string), version)
}

function encode (version, privateKey, compressed) {

if (typeof version === 'number') return [Link](encodeRaw(version,
privateKey, compressed))

return [Link](
encodeRaw(
[Link],
[Link],
[Link]
)
 )
}

[Link] = {
decode: decode,
decodeRaw: decodeRaw,
encode: encode,
encodeRaw: encodeRaw
}

}).call(this,require("buffer").Buffer)
},{"bs58check":12,"buffer":84}],45:[function(require,module,exports){
var Buffer = require('safe-buffer').Buffer
var bech32 = require('bech32')
var bs58check = require('bs58check')
var bscript = require('./script')
var btemplates = require('./templates')
var networks = require('./networks')
var typeforce = require('typeforce')
var types = require('./types')

function fromBase58Check (address) {

var payload = [Link](address)

// TODO: 4.0.0, move to "toOutputScript"

if ([Link] < 21) throw new TypeError(address + ' is too short')
if ([Link] > 21) throw new TypeError(address + ' is too long')

var version = payload.readUInt8(0)

var hash = [Link](1)

return { version: version, hash: hash }

}

function fromBech32 (address) {

var result = [Link](address)
var data = [Link]([Link](1))

return {
version: [Link][0],
prefix: [Link],
data: [Link](data)
}
}

function toBase58Check (hash, version) {

typeforce([Link](types.Hash160bit, types.UInt8), arguments)

var payload = [Link](21)

payload.writeUInt8(version, 0)
[Link](payload, 1)

return [Link](payload)
}

function toBech32 (data, version, prefix) {

var words = [Link](data)
[Link](version)
 return [Link](prefix, words)
}

function fromOutputScript (outputScript, network) {

network = network || [Link]

if ([Link](outputScript)) return
toBase58Check([Link](outputScript).slice(3, 23), [Link])
if ([Link](outputScript)) return
toBase58Check([Link](outputScript).slice(2, 22), [Link])
if ([Link](outputScript)) return
toBech32([Link](outputScript).slice(2, 22), 0, network.bech32)
if ([Link](outputScript)) return
toBech32([Link](outputScript).slice(2, 34), 0, network.bech32)

throw new Error([Link](outputScript) + ' has no matching Address')

}

function toOutputScript (address, network) {

network = network || [Link]

var decode
try {
decode = fromBase58Check(address)
} catch (e) {}

if (decode) {
if ([Link] === [Link]) return
[Link]([Link])
if ([Link] === [Link]) return
[Link]([Link])
} else {
try {
decode = fromBech32(address)
} catch (e) {}

if (decode) {
if ([Link] !== network.bech32) throw new Error(address + ' has an
invalid prefix')
if ([Link] === 0) {
if ([Link] === 20) return
[Link]([Link])
if ([Link] === 32) return
[Link]([Link])
}
}
}

throw new Error(address + ' has no matching Script')

}

[Link] = {
fromBase58Check: fromBase58Check,
fromBech32: fromBech32,
fromOutputScript: fromOutputScript,
toBase58Check: toBase58Check,
toBech32: toBech32,
toOutputScript: toOutputScript
}
},{"./networks":54,"./script":55,"./templates":57,"./
types":81,"bech32":2,"bs58check":12,"safe-buffer":30,"typeforce":41}],46:
[function(require,module,exports){
var Buffer = require('safe-buffer').Buffer
var bcrypto = require('./crypto')
var fastMerkleRoot = require('merkle-lib/fastRoot')
var typeforce = require('typeforce')
var types = require('./types')
var varuint = require('varuint-bitcoin')

var Transaction = require('./transaction')

function Block () {
[Link] = 1
[Link] = null
[Link] = null
[Link] = 0
[Link] = 0
[Link] = 0
}

[Link] = function (buffer) {

if ([Link] < 80) throw new Error('Buffer too small (< 80 bytes)')

var offset = 0
function readSlice (n) {
offset += n
return [Link](offset - n, offset)
}

function readUInt32 () {
var i = buffer.readUInt32LE(offset)
offset += 4
return i
}

function readInt32 () {
var i = buffer.readInt32LE(offset)
offset += 4
return i
}

var block = new Block()

[Link] = readInt32()
[Link] = readSlice(32)
[Link] = readSlice(32)
[Link] = readUInt32()
[Link] = readUInt32()
[Link] = readUInt32()

if ([Link] === 80) return block

function readVarInt () {
var vi = [Link](buffer, offset)
offset += [Link]
return vi
}
 function readTransaction () {
var tx = [Link]([Link](offset), true)
offset += [Link]()
return tx
}

var nTransactions = readVarInt()

[Link] = []

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

var tx = readTransaction()
[Link](tx)
}

return block
}

[Link] = function (headersOnly) {

if (headersOnly || ![Link]) return 80

return 80 + [Link]([Link]) +
[Link](function (a, x) {
return a + [Link]()
}, 0)
}

[Link] = function (hex) {

return [Link]([Link](hex, 'hex'))
}

[Link] = function () {
return bcrypto.hash256([Link](true))
}

[Link] = function () {
return [Link]().reverse().toString('hex')
}

[Link] = function () {
var date = new Date(0) // epoch
[Link]([Link])

return date
}

// TODO: buffer, offset compatibility

[Link] = function (headersOnly) {
var buffer = [Link]([Link](headersOnly))

var offset = 0
function writeSlice (slice) {
[Link](buffer, offset)
offset += [Link]
}

function writeInt32 (i) {

buffer.writeInt32LE(i, offset)
offset += 4
}
 function writeUInt32 (i) {
buffer.writeUInt32LE(i, offset)
offset += 4
}

writeInt32([Link])
writeSlice([Link])
writeSlice([Link])
writeUInt32([Link])
writeUInt32([Link])
writeUInt32([Link])

if (headersOnly || ![Link]) return buffer

[Link]([Link], buffer, offset)

offset += [Link]

[Link](function (tx) {
var txSize = [Link]() // TODO: extract from toBuffer?
[Link](buffer, offset)
offset += txSize
})

return buffer
}

[Link] = function (headersOnly) {

return [Link](headersOnly).toString('hex')
}

[Link] = function (bits) {

var exponent = ((bits & 0xff000000) >> 24) - 3
var mantissa = bits & 0x007fffff
var target = [Link](32, 0)
target.writeUInt32BE(mantissa, 28 - exponent)
return target
}

[Link] = function (transactions) {

typeforce([{ getHash: [Link] }], transactions)
if ([Link] === 0) throw TypeError('Cannot compute merkle root for
zero transactions')

var hashes = [Link](function (transaction) {

return [Link]()
})

return fastMerkleRoot(hashes, bcrypto.hash256)

}

[Link] = function () {
if (![Link]) return false

var actualMerkleRoot = [Link]([Link])

return [Link](actualMerkleRoot) === 0
}

[Link] = function () {
var hash = [Link]().reverse()
 var target = [Link]([Link])

return [Link](target) <= 0

}

[Link] = Block

},{"./crypto":48,"./transaction":79,"./types":81,"merkle-lib/fastRoot":26,"safe-
buffer":30,"typeforce":41,"varuint-bitcoin":43}],47:
[function(require,module,exports){
var pushdata = require('pushdata-bitcoin')
var varuint = require('varuint-bitcoin')

// [Link]
function verifuint (value, max) {
if (typeof value !== 'number') throw new Error('cannot write a non-number as a
number')
if (value < 0) throw new Error('specified a negative value for writing an
unsigned value')
if (value > max) throw new Error('RangeError: value out of range')
if ([Link](value) !== value) throw new Error('value has a fractional
component')
}

function readUInt64LE (buffer, offset) {

var a = buffer.readUInt32LE(offset)
var b = buffer.readUInt32LE(offset + 4)
b *= 0x100000000

verifuint(b + a, 0x001fffffffffffff)

return b + a
}

function writeUInt64LE (buffer, value, offset) {

verifuint(value, 0x001fffffffffffff)

buffer.writeInt32LE(value & -1, offset)

buffer.writeUInt32LE([Link](value / 0x100000000), offset + 4)
return offset + 8
}

// TODO: remove in 4.0.0?

function readVarInt (buffer, offset) {
var result = [Link](buffer, offset)

return {
number: result,
size: [Link]
}
}

// TODO: remove in 4.0.0?

function writeVarInt (buffer, number, offset) {
[Link](number, buffer, offset)
return [Link]
}

[Link] = {
 pushDataSize: [Link],
readPushDataInt: [Link],
readUInt64LE: readUInt64LE,
readVarInt: readVarInt,
varIntBuffer: [Link],
varIntSize: [Link],
writePushDataInt: [Link],
writeUInt64LE: writeUInt64LE,
writeVarInt: writeVarInt
}

},{"pushdata-bitcoin":27,"varuint-bitcoin":43}],48:
[function(require,module,exports){
var createHash = require('create-hash')

function ripemd160 (buffer) {

return createHash('rmd160').update(buffer).digest()
}

function sha1 (buffer) {

return createHash('sha1').update(buffer).digest()
}

function sha256 (buffer) {

return createHash('sha256').update(buffer).digest()
}

function hash160 (buffer) {

return ripemd160(sha256(buffer))
}

function hash256 (buffer) {

return sha256(sha256(buffer))
}

[Link] = {
hash160: hash160,
hash256: hash256,
ripemd160: ripemd160,
sha1: sha1,
sha256: sha256
}

},{"create-hash":14}],49:[function(require,module,exports){
var Buffer = require('safe-buffer').Buffer
var createHmac = require('create-hmac')
var typeforce = require('typeforce')
var types = require('./types')

var BigInteger = require('bigi')

var ECSignature = require('./ecsignature')

var ZERO = [Link](1, 0)

var ONE = [Link](1, 1)

var ecurve = require('ecurve')

var secp256k1 = [Link]('secp256k1')

// [Link]
function deterministicGenerateK (hash, x, checkSig) {
typeforce([Link](
types.Hash256bit,
types.Buffer256bit,
[Link]
), arguments)

// Step A, ignored as hash already provided

// Step B
// Step C
var k = [Link](32, 0)
var v = [Link](32, 1)

// Step D
k = createHmac('sha256', k)
.update(v)
.update(ZERO)
.update(x)
.update(hash)
.digest()

// Step E
v = createHmac('sha256', k).update(v).digest()

// Step F
k = createHmac('sha256', k)
.update(v)
.update(ONE)
.update(x)
.update(hash)
.digest()

// Step G
v = createHmac('sha256', k).update(v).digest()

// Step H1/H2a, ignored as tlen === qlen (256 bit)

// Step H2b
v = createHmac('sha256', k).update(v).digest()

var T = [Link](v)

// Step H3, repeat until T is within the interval [1, n - 1] and is suitable for
ECDSA
while ([Link]() <= 0 || [Link](secp256k1.n) >= 0 || !checkSig(T)) {
k = createHmac('sha256', k)
.update(v)
.update(ZERO)
.digest()

v = createHmac('sha256', k).update(v).digest()

// Step H1/H2a, again, ignored as tlen === qlen (256 bit)

// Step H2b again
v = createHmac('sha256', k).update(v).digest()
T = [Link](v)
}

return T
}
var N_OVER_TWO = [Link](1)

function sign (hash, d) {

typeforce([Link](types.Hash256bit, [Link]), arguments)

var x = [Link](32)
var e = [Link](hash)
var n = secp256k1.n
var G = secp256k1.G

var r, s
deterministicGenerateK(hash, x, function (k) {
var Q = [Link](k)

if ([Link](Q)) return false

r = [Link](n)
if ([Link]() === 0) return false

s = [Link](n).multiply([Link]([Link](r))).mod(n)
if ([Link]() === 0) return false

return true
})

// enforce low S values, see bip62: 'low s values in signatures'

if ([Link](N_OVER_TWO) > 0) {
s = [Link](s)
}

return new ECSignature(r, s)

}

function verify (hash, signature, Q) {

typeforce([Link](
types.Hash256bit,
[Link],
[Link]
), arguments)

var n = secp256k1.n
var G = secp256k1.G

var r = signature.r
var s = signature.s

// 1.4.1 Enforce r and s are both integers in the interval [1, n − 1]

if ([Link]() <= 0 || [Link](n) >= 0) return false
if ([Link]() <= 0 || [Link](n) >= 0) return false

// 1.4.2 H = Hash(M), already done by the user

// 1.4.3 e = H
var e = [Link](hash)

// Compute s^-1
var sInv = [Link](n)

// 1.4.4 Compute u1 = es^−1 mod n

 // u2 = rs^−1 mod n
var u1 = [Link](sInv).mod(n)
var u2 = [Link](sInv).mod(n)

// 1.4.5 Compute R = (xR, yR)

// R = u1G + u2Q
var R = [Link](u1, Q, u2)

// 1.4.5 (cont.) Enforce R is not at infinity

if ([Link](R)) return false

// 1.4.6 Convert the field element R.x to an integer

var xR = [Link]

// 1.4.7 Set v = xR mod n

var v = [Link](n)

// 1.4.8 If v = r, output "valid", and if v != r, output "invalid"

return [Link](r)
}

[Link] = {
deterministicGenerateK: deterministicGenerateK,
sign: sign,
verify: verify,

// TODO: remove
__curve: secp256k1
}

},{"./ecsignature":51,"./types":81,"bigi":5,"create-hmac":16,"ecurve":20,"safe-
buffer":30,"typeforce":41}],50:[function(require,module,exports){
var baddress = require('./address')
var bcrypto = require('./crypto')
var ecdsa = require('./ecdsa')
var randomBytes = require('randombytes')
var typeforce = require('typeforce')
var types = require('./types')
var wif = require('wif')

var NETWORKS = require('./networks')

var BigInteger = require('bigi')

var ecurve = require('ecurve')

var secp256k1 = ecdsa.__curve
var Buffer = require('safe-buffer').Buffer

function ECPair (d, Q, options) {

if (options) {
typeforce({
compressed: [Link]([Link]),
network: [Link]([Link])
}, options)
}

options = options || {}

if (d) {
if ([Link]() <= 0) throw new Error('Private key must be greater than 0')
 if ([Link](secp256k1.n) >= 0) throw new Error('Private key must be less
than the curve order')
if (Q) throw new TypeError('Unexpected publicKey parameter')

this.d = d
} else {
typeforce([Link], Q)

this.__Q = Q
}

[Link] = [Link] === undefined ? true : [Link]

[Link] = [Link] || [Link]
}

[Link]([Link], 'Q', {
get: function () {
if (!this.__Q && this.d) {
this.__Q = [Link](this.d)
}

return this.__Q
}
})

[Link] = function (buffer, network) {

var Q = [Link](secp256k1, buffer)

return new ECPair(null, Q, {

compressed: [Link],
network: network
})
}

[Link] = function (string, network) {

var decoded = [Link](string)
var version = [Link]

// list of networks?
if ([Link](network)) {
network = [Link](function (x) {
return version === [Link]
}).pop()

if (!network) throw new Error('Unknown network version')

// otherwise, assume a network object (or default to bitcoin)

} else {
network = network || [Link]

if (version !== [Link]) throw new Error('Invalid network version')

}

var d = [Link]([Link])

return new ECPair(d, null, {

compressed: [Link],
network: network
})
}

[Link] = function (passphrase, options) {

var buffer = new Buffer(passphrase, 'hex')
options = options || {}
buffer = bcrypto.sha256(buffer)
var d = [Link](buffer).mod(secp256k1.n)
return new ECPair(d, null, {compressed: true, network: [Link] ||
[Link]})
}

[Link] = function (options) {

options = options || {}

var rng = [Link] || randomBytes

var d
do {
var buffer = rng(32)
typeforce(types.Buffer256bit, buffer)

d = [Link](buffer)
} while ([Link]() <= 0 || [Link](secp256k1.n) >= 0)

return new ECPair(d, null, options)

}

[Link] = function () {
return baddress.toBase58Check(bcrypto.hash160([Link]()),
[Link]().pubKeyHash)
}

[Link] = function () {
return [Link]
}

[Link] = function () {
return [Link]([Link])
}

[Link] = function (hash) {

if (!this.d) throw new Error('Missing private key')

return [Link](hash, this.d)

}

[Link] = function (hash) {

var b = new Buffer(hash, 'hex');
return [Link](b).toDER().toString('hex')
}

[Link] = function () {
if (!this.d) throw new Error('Missing private key')

return [Link]([Link], [Link](32), [Link])

}

[Link] = function (hash, signature) {

return [Link](hash, signature, this.Q)
}

[Link] = ECPair

},{"./address":45,"./crypto":48,"./ecdsa":49,"./networks":54,"./
types":81,"bigi":5,"ecurve":20,"randombytes":28,"safe-
buffer":30,"typeforce":41,"wif":44}],51:[function(require,module,exports){
var bip66 = require('bip66')
var typeforce = require('typeforce')
var types = require('./types')

var BigInteger = require('bigi')

var Buffer = require('safe-buffer').Buffer

function ECSignature (r, s) {

typeforce([Link]([Link], [Link]), arguments)

this.r = r
this.s = s
}

[Link] = function (buffer) {

typeforce([Link](65), buffer)

var flagByte = buffer.readUInt8(0) - 27

if (flagByte !== (flagByte & 7)) throw new Error('Invalid signature parameter')

var compressed = !!(flagByte & 4)

var recoveryParam = flagByte & 3
var signature = [Link]([Link](1))

return {
compressed: compressed,
i: recoveryParam,
signature: signature
}
}

[Link] = function (buffer) {

typeforce([Link](64), buffer)

var r = [Link]([Link](0, 32))

var s = [Link]([Link](32, 64))
return new ECSignature(r, s)
}

[Link] = function (buffer) {

var decode = [Link](buffer)
var r = [Link](decode.r)
var s = [Link](decode.s)

return new ECSignature(r, s)

}

// BIP62: 1 byte hashType flag (only 0x01, 0x02, 0x03, 0x81, 0x82 and 0x83 are
allowed)
[Link] = function (buffer) {
var hashType = buffer.readUInt8([Link] - 1)
var hashTypeMod = hashType & ~0x80
 if (hashTypeMod <= 0x00 || hashTypeMod >= 0x04) throw new Error('Invalid hashType
' + hashType)

return {
signature: [Link]([Link](0, -1)),
hashType: hashType
}
}

[Link] = function (i, compressed) {

if (compressed) {
i += 4
}

i += 27

var buffer = [Link](65)

buffer.writeUInt8(i, 0)
[Link](buffer, 1)
return buffer
}

[Link] = function () {
var r = [Link]([Link]())
var s = [Link]([Link]())

return [Link](r, s)
}

[Link] = function (buffer, offset) {

buffer = buffer || [Link](64)
[Link](32).copy(buffer, offset)
[Link](32).copy(buffer, offset + 32)
return buffer
}

[Link] = function (hashType) {

var hashTypeMod = hashType & ~0x80
if (hashTypeMod <= 0 || hashTypeMod >= 4) throw new Error('Invalid hashType ' +
hashType)

var hashTypeBuffer = [Link](1)

hashTypeBuffer.writeUInt8(hashType, 0)

return [Link]([[Link](), hashTypeBuffer])

}

[Link] = ECSignature

},{"./types":81,"bigi":5,"bip66":7,"safe-buffer":30,"typeforce":41}],52:
[function(require,module,exports){
var Buffer = require('safe-buffer').Buffer
var base58check = require('bs58check')
var bcrypto = require('./crypto')
var createHmac = require('create-hmac')
var typeforce = require('typeforce')
var types = require('./types')
var NETWORKS = require('./networks')
var BigInteger = require('bigi')
var ECPair = require('./ecpair')

var ecurve = require('ecurve')

var curve = [Link]('secp256k1')

function HDNode (keyPair, chainCode) {

typeforce([Link]('ECPair', types.Buffer256bit), arguments)

if (![Link]) throw new TypeError('BIP32 only allows compressed

keyPairs')

[Link] = keyPair
[Link] = chainCode
[Link] = 0
[Link] = 0
[Link] = 0x00000000
}

HDNode.HIGHEST_BIT = 0x80000000
[Link] = 78
HDNode.MASTER_SECRET = [Link]('Bitcoin seed', 'utf8')

[Link] = function (seed, network) {

typeforce([Link]([Link], [Link]([Link])), arguments)

if ([Link] < 16) throw new TypeError('Seed should be at least 128 bits')
if ([Link] > 64) throw new TypeError('Seed should be at most 512 bits')

var I = createHmac('sha512', HDNode.MASTER_SECRET).update(seed).digest()

var IL = [Link](0, 32)
var IR = [Link](32)

// In case IL is 0 or >= n, the master key is invalid

// This is handled by the ECPair constructor
var pIL = [Link](IL)
var keyPair = new ECPair(pIL, null, {
network: network
})

return new HDNode(keyPair, IR)

}

[Link] = function (hex, network) {

return [Link]([Link](hex, 'hex'), network)
}

HDNode.fromBase58 = function (string, networks) {

var buffer = [Link](string)
if ([Link] !== 78) throw new Error('Invalid buffer length')

// 4 bytes: version bytes

var version = buffer.readUInt32BE(0)
var network

// list of networks?
if ([Link](networks)) {
network = [Link](function (x) {
 return version === [Link] ||
version === [Link]
}).pop()

if (!network) throw new Error('Unknown network version')

// otherwise, assume a network object (or default to bitcoin)

} else {
network = networks || [Link]
}

if (version !== [Link] &&

version !== [Link]) throw new Error('Invalid network version')

// 1 byte: depth: 0x00 for master nodes, 0x01 for level-1 descendants, ...
var depth = buffer[4]

// 4 bytes: the fingerprint of the parent's key (0x00000000 if master key)

var parentFingerprint = buffer.readUInt32BE(5)
if (depth === 0) {
if (parentFingerprint !== 0x00000000) throw new Error('Invalid parent
fingerprint')
}

// 4 bytes: child number. This is the number i in xi = xpar/i, with xi the key
being serialized.
// This is encoded in MSB order. (0x00000000 if master key)
var index = buffer.readUInt32BE(9)
if (depth === 0 && index !== 0) throw new Error('Invalid index')

// 32 bytes: the chain code

var chainCode = [Link](13, 45)
var keyPair

// 33 bytes: private key data (0x00 + k)

if (version === [Link]) {
if (buffer.readUInt8(45) !== 0x00) throw new Error('Invalid private key')

var d = [Link]([Link](46, 78))

keyPair = new ECPair(d, null, { network: network })

// 33 bytes: public key data (0x02 + X or 0x03 + X)

} else {
var Q = [Link](curve, [Link](45, 78))
// [Link] is assumed, if somehow this assumption is broken, `new HDNode`
will throw

// Verify that the X coordinate in the public point corresponds to a point on

the curve.
// If not, the extended public key is invalid.
[Link](Q)

keyPair = new ECPair(null, Q, { network: network })

}

var hd = new HDNode(keyPair, chainCode)

[Link] = depth
[Link] = index
[Link] = parentFingerprint
 return hd
}

[Link] = function () {
return [Link]()
}

[Link] = function () {
return bcrypto.hash160([Link]())
}

[Link] = function () {
return [Link]().slice(0, 4)
}

[Link] = function () {
return [Link]()
}

[Link] = function () {
return [Link]()
}

[Link] = function () {
var neuteredKeyPair = new ECPair(null, [Link].Q, {
network: [Link]
})

var neutered = new HDNode(neuteredKeyPair, [Link])

[Link] = [Link]
[Link] = [Link]
[Link] = [Link]

return neutered
}

[Link] = function (hash) {

return [Link](hash)
}

[Link] = function (hash, signature) {

return [Link](hash, signature)
}

[Link].toBase58 = function (__isPrivate) {

if (__isPrivate !== undefined) throw new TypeError('Unsupported argument in
2.0.0')

// Version
var network = [Link]
var version = (![Link]()) ? [Link] : [Link]
var buffer = [Link](78)

// 4 bytes: version bytes

buffer.writeUInt32BE(version, 0)

// 1 byte: depth: 0x00 for master nodes, 0x01 for level-1 descendants, ....
buffer.writeUInt8([Link], 4)
 // 4 bytes: the fingerprint of the parent's key (0x00000000 if master key)
buffer.writeUInt32BE([Link], 5)

// 4 bytes: child number. This is the number i in xi = xpar/i, with xi the key
being serialized.
// This is encoded in big endian. (0x00000000 if master key)
buffer.writeUInt32BE([Link], 9)

// 32 bytes: the chain code

[Link](buffer, 13)

// 33 bytes: the public key or private key data

if (![Link]()) {
// 0x00 + k for private keys
buffer.writeUInt8(0, 45)
[Link](32).copy(buffer, 46)

// 33 bytes: the public key

} else {
// X9.62 encoding for public keys
[Link]().copy(buffer, 45)
}

return [Link](buffer)
}

// [Link]
derivation-ckd-functions
[Link] = function (index) {
typeforce(types.UInt32, index)

var isHardened = index >= HDNode.HIGHEST_BIT

var data = [Link](37)

// Hardened child
if (isHardened) {
if ([Link]()) throw new TypeError('Could not derive hardened child
key')

// data = 0x00 || ser256(kpar) || ser32(index)

data[0] = 0x00
[Link](32).copy(data, 1)
data.writeUInt32BE(index, 33)

// Normal child
} else {
// data = serP(point(kpar)) || ser32(index)
// = serP(Kpar) || ser32(index)
[Link]().copy(data, 0)
data.writeUInt32BE(index, 33)
}

var I = createHmac('sha512', [Link]).update(data).digest()

var IL = [Link](0, 32)
var IR = [Link](32)

var pIL = [Link](IL)

 // In case parse256(IL) >= n, proceed with the next value for i
if ([Link](curve.n) >= 0) {
return [Link](index + 1)
}

// Private parent key -> private child key

var derivedKeyPair
if (![Link]()) {
// ki = parse256(IL) + kpar (mod n)
var ki = [Link]([Link].d).mod(curve.n)

// In case ki == 0, proceed with the next value for i

if ([Link]() === 0) {
return [Link](index + 1)
}

derivedKeyPair = new ECPair(ki, null, {

network: [Link]
})

// Public parent key -> public child key

} else {
// Ki = point(parse256(IL)) + Kpar
// = G*IL + Kpar
var Ki = [Link](pIL).add([Link].Q)

// In case Ki is the point at infinity, proceed with the next value for i
if ([Link](Ki)) {
return [Link](index + 1)
}

derivedKeyPair = new ECPair(null, Ki, {

network: [Link]
})
}

var hd = new HDNode(derivedKeyPair, IR)

[Link] = [Link] + 1
[Link] = index
[Link] = [Link]().readUInt32BE(0)

return hd
}

[Link] = function (index) {

typeforce(types.UInt31, index)

// Only derives hardened private keys by default

return [Link](index + HDNode.HIGHEST_BIT)
}

// Private === not neutered

// Public === neutered
[Link] = function () {
return !([Link].d)
}

[Link] = function (path) {

typeforce(types.BIP32Path, path)
 var splitPath = [Link]('/')
if (splitPath[0] === 'm') {
if ([Link]) {
throw new Error('Not a master node')
}

splitPath = [Link](1)
}

return [Link](function (prevHd, indexStr) {

var index
if ([Link](-1) === "'") {
index = parseInt([Link](0, -1), 10)
return [Link](index)
} else {
index = parseInt(indexStr, 10)
return [Link](index)
}
}, this)
}

[Link] = HDNode

},{"./crypto":48,"./ecpair":50,"./networks":54,"./
types":81,"bigi":5,"bs58check":12,"create-hmac":16,"ecurve":20,"safe-
buffer":30,"typeforce":41}],53:[function(require,module,exports){
var script = require('./script')

var templates = require('./templates')

for (var key in templates) {
script[key] = templates[key]
}

[Link] = {
bufferutils: require('./bufferutils'), // TODO: remove in 4.0.0

Block: require('./block'),
ECPair: require('./ecpair'),
ECSignature: require('./ecsignature'),
HDNode: require('./hdnode'),
Transaction: require('./transaction'),
TransactionBuilder: require('./transaction_builder'),

address: require('./address'),
crypto: require('./crypto'),
networks: require('./networks'),
opcodes: require('bitcoin-ops'),
script: script
}

},{"./address":45,"./block":46,"./bufferutils":47,"./crypto":48,"./ecpair":50,"./
ecsignature":51,"./hdnode":52,"./networks":54,"./script":55,"./templates":57,"./
transaction":79,"./transaction_builder":80,"bitcoin-ops":8}],54:
[function(require,module,exports){
// [Link]
// Dogecoin BIP32 is a proposed standard: [Link]
topic=409731
[Link] = {
bitcoin: {
messagePrefix: '\x18Bitcoin Signed Message:\n',
bech32: 'bc',
bip32: {
public: 0x0488b21e,
private: 0x0488ade4
},
pubKeyHash: 0x00,
scriptHash: 0x05,
wif: 0x80
},
litecoin: {
messagePrefix: '\x19Litecoin Signed Message:\n',
bech32: 'ltc',
bip32: {
public: 0x019da462,
private: 0x019d9cfe
},
pubKeyHash: 0x30,
scriptHash: 0x32,
wif: 0xb0
},
dogecoin: {
messagePrefix: '\x19Dogecoin Signed Message:\n',
bech32: undefined,
bip32: {
public: 0x02facafd,
private: 0x02fac398
},
pubKeyHash: 0x1e,
scriptHash: 0x16,
wif: 0x9e
},
bitcoin_testnet: {
messagePrefix: '\x18Bitcoin Signed Message:\n',
bech32: 'tb',
bip32: {
public: 0x043587cf,
private: 0x04358394
},
pubKeyHash: 0x6f,
scriptHash: 0xc4,
wif: 0xef
},
dogecoin_testnet: {
messagePrefix: '\x18Dogecoin Signed Message:\n',
bech32: undefined,
bip32: {
public: 0x0432a9a8,
private: 0x0432a243
},
pubKeyHash: 0x71,
scriptHash: 0xc4,
wif: 0xf1
},
litecoin_testnet: {
messagePrefix: '\x18Litecoin Signed Message:\n',
bech32: 'tltc',
 bip32: {
public: 0x0436ef7d,
private: 0x0436f6e1
},
pubKeyHash: 0x6f,
scriptHash: 0xc4,
wif: 0xef
}
}

},{}],55:[function(require,module,exports){
var Buffer = require('safe-buffer').Buffer
var bip66 = require('bip66')
var pushdata = require('pushdata-bitcoin')
var typeforce = require('typeforce')
var types = require('./types')
var scriptNumber = require('./script_number')

var OPS = require('bitcoin-ops')

var REVERSE_OPS = require('bitcoin-ops/map')
var OP_INT_BASE = OPS.OP_RESERVED // OP_1 - 1

function isOPInt (value) {

return [Link](value) &&
((value === OPS.OP_0) ||
(value >= OPS.OP_1 && value <= OPS.OP_16) ||
(value === OPS.OP_1NEGATE))
}

function isPushOnlyChunk (value) {

return [Link](value) || isOPInt(value)
}

function isPushOnly (value) {

return [Link](value) && [Link](isPushOnlyChunk)
}

function asMinimalOP (buffer) {

if ([Link] === 0) return OPS.OP_0
if ([Link] !== 1) return
if (buffer[0] >= 1 && buffer[0] <= 16) return OP_INT_BASE + buffer[0]
if (buffer[0] === 0x81) return OPS.OP_1NEGATE
}

function compile (chunks) {

// TODO: remove me
if ([Link](chunks)) return chunks

typeforce([Link], chunks)

var bufferSize = [Link](function (accum, chunk) {

// data chunk
if ([Link](chunk)) {
// adhere to BIP62.3, minimal push policy
if ([Link] === 1 && asMinimalOP(chunk) !== undefined) {
return accum + 1
}

return accum + [Link]([Link]) + [Link]

 }

// opcode
return accum + 1
}, 0.0)

var buffer = [Link](bufferSize)

var offset = 0

[Link](function (chunk) {
// data chunk
if ([Link](chunk)) {
// adhere to BIP62.3, minimal push policy
var opcode = asMinimalOP(chunk)
if (opcode !== undefined) {
buffer.writeUInt8(opcode, offset)
offset += 1
return
}

offset += [Link](buffer, [Link], offset)

[Link](buffer, offset)
offset += [Link]

// opcode
} else {
buffer.writeUInt8(chunk, offset)
offset += 1
}
})

if (offset !== [Link]) throw new Error('Could not decode chunks')

return buffer
}

function decompile (buffer) {

// TODO: remove me
if ([Link](buffer)) return buffer

typeforce([Link], buffer)

var chunks = []
var i = 0

while (i < [Link]) {

var opcode = buffer[i]

// data chunk
if ((opcode > OPS.OP_0) && (opcode <= OPS.OP_PUSHDATA4)) {
var d = [Link](buffer, i)

// did reading a pushDataInt fail? empty script

if (d === null) return []
i += [Link]

// attempt to read too much data? empty script

if (i + [Link] > [Link]) return []

var data = [Link](i, i + [Link])

 i += [Link]

// decompile minimally
var op = asMinimalOP(data)
if (op !== undefined) {
[Link](op)
} else {
[Link](data)
}

// opcode
} else {
[Link](opcode)

i += 1
}
}

return chunks
}

function toASM (chunks) {

if ([Link](chunks)) {
chunks = decompile(chunks)
}

return [Link](function (chunk) {

// data?
if ([Link](chunk)) {
var op = asMinimalOP(chunk)
if (op === undefined) return [Link]('hex')
chunk = op
}

// opcode!
return REVERSE_OPS[chunk]
}).join(' ')
}

function fromASM (asm) {

typeforce([Link], asm)

return compile([Link](' ').map(function (chunkStr) {

// opcode?
if (OPS[chunkStr] !== undefined) return OPS[chunkStr]
typeforce([Link], chunkStr)

// data!
return [Link](chunkStr, 'hex')
}))
}

function toStack (chunks) {

chunks = decompile(chunks)
typeforce(isPushOnly, chunks)

return [Link](function (op) {

if ([Link](op)) return op
if (op === OPS.OP_0) return [Link](0)
 return [Link](op - OP_INT_BASE)
})
}

function isCanonicalPubKey (buffer) {

if () return false
if ([Link] < 33) return false

switch (buffer[0]) {
case 0x02:
case 0x03:
return [Link] === 33
case 0x04:
return [Link] === 65
}

return false
}

function isDefinedHashType (hashType) {

var hashTypeMod = hashType & ~0x80

// return hashTypeMod > SIGHASH_ALL && hashTypeMod < SIGHASH_SINGLE

return hashTypeMod > 0x00 && hashTypeMod < 0x04
}

function isCanonicalSignature (buffer) {

if () return false
if (!isDefinedHashType(buffer[[Link] - 1])) return false

return [Link]([Link](0, -1))

}

[Link] = {
compile: compile,
decompile: decompile,
fromASM: fromASM,
toASM: toASM,
toStack: toStack,

number: require('./script_number'),

isCanonicalPubKey: isCanonicalPubKey,
isCanonicalSignature: isCanonicalSignature,
isPushOnly: isPushOnly,
isDefinedHashType: isDefinedHashType
}

},{"./script_number":56,"./types":81,"bip66":7,"bitcoin-ops":8,"bitcoin-ops/
map":9,"pushdata-bitcoin":27,"safe-buffer":30,"typeforce":41}],56:
[function(require,module,exports){
var Buffer = require('safe-buffer').Buffer

function decode (buffer, maxLength, minimal) {

maxLength = maxLength || 4
minimal = minimal === undefined ? true : minimal

var length = [Link]

 if (length === 0) return 0
if (length > maxLength) throw new TypeError('Script number overflow')
if (minimal) {
if ((buffer[length - 1] & 0x7f) === 0) {
if (length <= 1 || (buffer[length - 2] & 0x80) === 0) throw new Error('Non-
minimally encoded script number')
}
}

// 40-bit
if (length === 5) {
var a = buffer.readUInt32LE(0)
var b = buffer.readUInt8(4)

if (b & 0x80) return -(((b & ~0x80) * 0x100000000) + a)

return (b * 0x100000000) + a
}

var result = 0

// 32-bit / 24-bit / 16-bit / 8-bit

for (var i = 0; i < length; ++i) {
result |= buffer[i] << (8 * i)
}

if (buffer[length - 1] & 0x80) return -(result & ~(0x80 << (8 * (length - 1))))
return result
}

function scriptNumSize (i) {

return i > 0x7fffffff ? 5
: i > 0x7fffff ? 4
: i > 0x7fff ? 3
: i > 0x7f ? 2
: i > 0x00 ? 1
: 0
}

function encode (number) {

var value = [Link](number)
var size = scriptNumSize(value)
var buffer = [Link](size)
var negative = number < 0

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

buffer.writeUInt8(value & 0xff, i)
value >>= 8
}

if (buffer[size - 1] & 0x80) {

buffer.writeUInt8(negative ? 0x80 : 0x00, size - 1)
} else if (negative) {
buffer[size - 1] |= 0x80
}

return buffer
}

[Link] = {
 decode: decode,
encode: encode
}

},{"safe-buffer":30}],57:[function(require,module,exports){
var decompile = require('../script').decompile
var multisig = require('./multisig')
var nullData = require('./nulldata')
var pubKey = require('./pubkey')
var pubKeyHash = require('./pubkeyhash')
var scriptHash = require('./scripthash')
var witnessPubKeyHash = require('./witnesspubkeyhash')
var witnessScriptHash = require('./witnessscripthash')
var witnessCommitment = require('./witnesscommitment')

var types = {
MULTISIG: 'multisig',
NONSTANDARD: 'nonstandard',
NULLDATA: 'nulldata',
P2PK: 'pubkey',
P2PKH: 'pubkeyhash',
P2SH: 'scripthash',
P2WPKH: 'witnesspubkeyhash',
P2WSH: 'witnessscripthash',
WITNESS_COMMITMENT: 'witnesscommitment'
}

function classifyOutput (script) {

if ([Link](script)) return types.P2WPKH
if ([Link](script)) return types.P2WSH
if ([Link](script)) return types.P2PKH
if ([Link](script)) return types.P2SH

// XXX: optimization, below functions .decompile before use

var chunks = decompile(script)
if ([Link](chunks)) return [Link]
if ([Link](chunks)) return types.P2PK
if ([Link](chunks)) return types.WITNESS_COMMITMENT
if ([Link](chunks)) return [Link]

return [Link]
}

function classifyInput (script, allowIncomplete) {

// XXX: optimization, below functions .decompile before use
var chunks = decompile(script)

if ([Link](chunks)) return types.P2PKH

if ([Link](chunks, allowIncomplete)) return types.P2SH
if ([Link](chunks, allowIncomplete)) return [Link]
if ([Link](chunks)) return types.P2PK

return [Link]
}

function classifyWitness (script, allowIncomplete) {

// XXX: optimization, below functions .decompile before use
var chunks = decompile(script)
 if ([Link](chunks)) return types.P2WPKH
if ([Link](chunks, allowIncomplete)) return types.P2WSH

return [Link]
}

[Link] = {
classifyInput: classifyInput,
classifyOutput: classifyOutput,
classifyWitness: classifyWitness,
multisig: multisig,
nullData: nullData,
pubKey: pubKey,
pubKeyHash: pubKeyHash,
scriptHash: scriptHash,
witnessPubKeyHash: witnessPubKeyHash,
witnessScriptHash: witnessScriptHash,
witnessCommitment: witnessCommitment,
types: types
}

},{"../script":55,"./multisig":58,"./nulldata":61,"./pubkey":62,"./
pubkeyhash":65,"./scripthash":68,"./witnesscommitment":71,"./
witnesspubkeyhash":73,"./witnessscripthash":76}],58:
[function(require,module,exports){
[Link] = {
input: require('./input'),
output: require('./output')
}

},{"./input":59,"./output":60}],59:[function(require,module,exports){
// OP_0 [signatures ...]

var Buffer = require('safe-buffer').Buffer

var bscript = require('../../script')
var p2mso = require('./output')
var typeforce = require('typeforce')
var OPS = require('bitcoin-ops')

function partialSignature (value) {

return value === OPS.OP_0 || [Link](value)
}

function check (script, allowIncomplete) {

var chunks = [Link](script)
if ([Link] < 2) return false
if (chunks[0] !== OPS.OP_0) return false

if (allowIncomplete) {
return [Link](1).every(partialSignature)
}

return [Link](1).every([Link])
}
[Link] = function () { return 'multisig input' }

var EMPTY_BUFFER = [Link](0)

function encodeStack (signatures, scriptPubKey) {

 typeforce([partialSignature], signatures)

if (scriptPubKey) {
var scriptData = [Link](scriptPubKey)

if ([Link] < scriptData.m) {

throw new TypeError('Not enough signatures provided')
}

if ([Link] > [Link]) {

throw new TypeError('Too many signatures provided')
}
}

return [].concat(EMPTY_BUFFER, [Link](function (sig) {

if (sig === OPS.OP_0) {
return EMPTY_BUFFER
}
return sig
}))
}

function encode (signatures, scriptPubKey) {

return [Link](encodeStack(signatures, scriptPubKey))
}

function decodeStack (stack, allowIncomplete) {

typeforce([Link], stack)
typeforce(check, stack, allowIncomplete)
return [Link](1)
}

function decode (buffer, allowIncomplete) {

var stack = [Link](buffer)
return decodeStack(stack, allowIncomplete)
}

[Link] = {
check: check,
decode: decode,
decodeStack: decodeStack,
encode: encode,
encodeStack: encodeStack
}

},{"../../script":55,"./output":60,"bitcoin-ops":8,"safe-
buffer":30,"typeforce":41}],60:[function(require,module,exports){
// m [pubKeys ...] n OP_CHECKMULTISIG

var bscript = require('../../script')

var types = require('../../types')
var typeforce = require('typeforce')
var OPS = require('bitcoin-ops')
var OP_INT_BASE = OPS.OP_RESERVED // OP_1 - 1

function check (script, allowIncomplete) {

var chunks = [Link](script)

if ([Link] < 4) return false

 if (chunks[[Link] - 1] !== OPS.OP_CHECKMULTISIG) return false
if () return false
if () return false
var m = chunks[0] - OP_INT_BASE
var n = chunks[[Link] - 2] - OP_INT_BASE

if (m <= 0) return false

if (n > 16) return false
if (m > n) return false
if (n !== [Link] - 3) return false
if (allowIncomplete) return true

var keys = [Link](1, -2)

return [Link]([Link])
}
[Link] = function () { return 'multi-sig output' }

function encode (m, pubKeys) {

typeforce({
m: [Link],
pubKeys: [[Link]]
}, {
m: m,
pubKeys: pubKeys
})

var n = [Link]
if (n < m) throw new TypeError('Not enough pubKeys provided')

return [Link]([].concat(
OP_INT_BASE + m,
pubKeys,
OP_INT_BASE + n,
OPS.OP_CHECKMULTISIG
))
}

function decode (buffer, allowIncomplete) {

var chunks = [Link](buffer)
typeforce(check, chunks, allowIncomplete)

return {
m: chunks[0] - OP_INT_BASE,
pubKeys: [Link](1, -2)
}
}

[Link] = {
check: check,
decode: decode,
encode: encode
}

},{"../../script":55,"../../types":81,"bitcoin-ops":8,"typeforce":41}],61:
[function(require,module,exports){
// OP_RETURN {data}

var bscript = require('../script')

var types = require('../types')
var typeforce = require('typeforce')
var OPS = require('bitcoin-ops')

function check (script) {

var buffer = [Link](script)

return [Link] > 1 &&

buffer[0] === OPS.OP_RETURN
}
[Link] = function () { return 'null data output' }

function encode (data) {

typeforce([Link], data)

return [Link]([OPS.OP_RETURN, data])

}

function decode (buffer) {

typeforce(check, buffer)

return [Link](2)
}

[Link] = {
output: {
check: check,
decode: decode,
encode: encode
}
}

},{"../script":55,"../types":81,"bitcoin-ops":8,"typeforce":41}],62:
[function(require,module,exports){
arguments[4][58][0].apply(exports,arguments)
},{"./input":63,"./output":64,"dup":58}],63:[function(require,module,exports){
// {signature}

var bscript = require('../../script')

var typeforce = require('typeforce')

function check (script) {

var chunks = [Link](script)

return [Link] === 1 &&

[Link](chunks[0])
}
[Link] = function () { return 'pubKey input' }

function encodeStack (signature) {

typeforce([Link], signature)
return [signature]
}

function encode (signature) {

return [Link](encodeStack(signature))
}

function decodeStack (stack) {

typeforce([Link], stack)
 typeforce(check, stack)
return stack[0]
}

function decode (buffer) {

var stack = [Link](buffer)
return decodeStack(stack)
}

[Link] = {
check: check,
decode: decode,
decodeStack: decodeStack,
encode: encode,
encodeStack: encodeStack
}

},{"../../script":55,"typeforce":41}],64:[function(require,module,exports){
// {pubKey} OP_CHECKSIG

var bscript = require('../../script')

var typeforce = require('typeforce')
var OPS = require('bitcoin-ops')

function check (script) {

var chunks = [Link](script)

return [Link] === 2 &&

[Link](chunks[0]) &&
chunks[1] === OPS.OP_CHECKSIG
}
[Link] = function () { return 'pubKey output' }

function encode (pubKey) {

typeforce([Link], pubKey)

return [Link]([pubKey, OPS.OP_CHECKSIG])

}

function decode (buffer) {

var chunks = [Link](buffer)
typeforce(check, chunks)

return chunks[0]
}

[Link] = {
check: check,
decode: decode,
encode: encode
}

},{"../../script":55,"bitcoin-ops":8,"typeforce":41}],65:
[function(require,module,exports){
arguments[4][58][0].apply(exports,arguments)
},{"./input":66,"./output":67,"dup":58}],66:[function(require,module,exports){
// {signature} {pubKey}

var bscript = require('../../script')

var typeforce = require('typeforce')

function check (script) {

var chunks = [Link](script)

return [Link] === 2 &&

[Link](chunks[0]) &&
[Link](chunks[1])
}
[Link] = function () { return 'pubKeyHash input' }

function encodeStack (signature, pubKey) {

typeforce({
signature: [Link],
pubKey: [Link]
}, {
signature: signature,
pubKey: pubKey
})

return [signature, pubKey]

}

function encode (signature, pubKey) {

return [Link](encodeStack(signature, pubKey))
}

function decodeStack (stack) {

typeforce([Link], stack)
typeforce(check, stack)

return {
signature: stack[0],
pubKey: stack[1]
}
}

function decode (buffer) {

var stack = [Link](buffer)
return decodeStack(stack)
}

[Link] = {
check: check,
decode: decode,
decodeStack: decodeStack,
encode: encode,
encodeStack: encodeStack
}

},{"../../script":55,"typeforce":41}],67:[function(require,module,exports){
// OP_DUP OP_HASH160 {pubKeyHash} OP_EQUALVERIFY OP_CHECKSIG

var bscript = require('../../script')

var types = require('../../types')
var typeforce = require('typeforce')
var OPS = require('bitcoin-ops')

function check (script) {

 var buffer = [Link](script)

return [Link] === 25 &&

buffer[0] === OPS.OP_DUP &&
buffer[1] === OPS.OP_HASH160 &&
buffer[2] === 0x14 &&
buffer[23] === OPS.OP_EQUALVERIFY &&
buffer[24] === OPS.OP_CHECKSIG
}
[Link] = function () { return 'pubKeyHash output' }

function encode (pubKeyHash) {

typeforce(types.Hash160bit, pubKeyHash)

return [Link]([
OPS.OP_DUP,
OPS.OP_HASH160,
pubKeyHash,
OPS.OP_EQUALVERIFY,
OPS.OP_CHECKSIG
])
}

function decode (buffer) {

typeforce(check, buffer)

return [Link](3, 23)

}

[Link] = {
check: check,
decode: decode,
encode: encode
}

},{"../../script":55,"../../types":81,"bitcoin-ops":8,"typeforce":41}],68:
[function(require,module,exports){
arguments[4][58][0].apply(exports,arguments)
},{"./input":69,"./output":70,"dup":58}],69:[function(require,module,exports){
// <scriptSig> {serialized scriptPubKey script}

var Buffer = require('safe-buffer').Buffer

var bscript = require('../../script')
var typeforce = require('typeforce')

var p2ms = require('../multisig/')

var p2pk = require('../pubkey/')
var p2pkh = require('../pubkeyhash/')
var p2wpkho = require('../witnesspubkeyhash/output')
var p2wsho = require('../witnessscripthash/output')

function check (script, allowIncomplete) {

var chunks = [Link](script)
if ([Link] < 1) return false

var lastChunk = chunks[[Link] - 1]

if () return false

var scriptSigChunks = [Link]([Link]([Link](0, -1)))

 var redeemScriptChunks = [Link](lastChunk)

// is redeemScript a valid script?

if ([Link] === 0) return false

// is redeemScriptSig push only?

if () return false

// is witness?
if ([Link] === 1) {
return [Link](redeemScriptChunks) ||
[Link](redeemScriptChunks)
}

// match types
if ([Link](scriptSigChunks) &&
[Link](redeemScriptChunks)) return true

if ([Link](scriptSigChunks, allowIncomplete) &&

[Link](redeemScriptChunks)) return true

if ([Link](scriptSigChunks) &&
[Link](redeemScriptChunks)) return true

return false
}
[Link] = function () { return 'scriptHash input' }

function encodeStack (redeemScriptStack, redeemScript) {

var serializedScriptPubKey = [Link](redeemScript)

return [].concat(redeemScriptStack, serializedScriptPubKey)

}

function encode (redeemScriptSig, redeemScript) {

var redeemScriptStack = [Link](redeemScriptSig)

return [Link](encodeStack(redeemScriptStack, redeemScript))

}

function decodeStack (stack) {

typeforce([Link], stack)
typeforce(check, stack)

return {
redeemScriptStack: [Link](0, -1),
redeemScript: stack[[Link] - 1]
}
}

function decode (buffer) {

var stack = [Link](buffer)
var result = decodeStack(stack)
[Link] = [Link]([Link])
delete [Link]
return result
}

[Link] = {
 check: check,
decode: decode,
decodeStack: decodeStack,
encode: encode,
encodeStack: encodeStack
}

},{"../../script":55,"../multisig/":58,"../pubkey/":62,"../pubkeyhash/":65,"../
witnesspubkeyhash/output":75,"../witnessscripthash/output":78,"safe-
buffer":30,"typeforce":41}],70:[function(require,module,exports){
// OP_HASH160 {scriptHash} OP_EQUAL

var bscript = require('../../script')

var types = require('../../types')
var typeforce = require('typeforce')
var OPS = require('bitcoin-ops')

function check (script) {

var buffer = [Link](script)

return [Link] === 23 &&

buffer[0] === OPS.OP_HASH160 &&
buffer[1] === 0x14 &&
buffer[22] === OPS.OP_EQUAL
}
[Link] = function () { return 'scriptHash output' }

function encode (scriptHash) {

typeforce(types.Hash160bit, scriptHash)

return [Link]([OPS.OP_HASH160, scriptHash, OPS.OP_EQUAL])

}

function decode (buffer) {

typeforce(check, buffer)

return [Link](2, 22)

}

[Link] = {
check: check,
decode: decode,
encode: encode
}

},{"../../script":55,"../../types":81,"bitcoin-ops":8,"typeforce":41}],71:
[function(require,module,exports){
[Link] = {
output: require('./output')
}

},{"./output":72}],72:[function(require,module,exports){
// OP_RETURN {aa21a9ed} {commitment}

var Buffer = require('safe-buffer').Buffer

var bscript = require('../../script')
var types = require('../../types')
var typeforce = require('typeforce')
var OPS = require('bitcoin-ops')
var HEADER = [Link]('aa21a9ed', 'hex')

function check (script) {

var buffer = [Link](script)

return [Link] > 37 &&

buffer[0] === OPS.OP_RETURN &&
buffer[1] === 0x24 &&
[Link](2, 6).equals(HEADER)
}

[Link] = function () { return 'Witness commitment output' }

function encode (commitment) {

typeforce(types.Hash256bit, commitment)

var buffer = [Link](36)

[Link](buffer, 0)
[Link](buffer, 4)

return [Link]([OPS.OP_RETURN, buffer])

}

function decode (buffer) {

typeforce(check, buffer)

return [Link](buffer)[1].slice(4, 36)

}

[Link] = {
check: check,
decode: decode,
encode: encode
}

},{"../../script":55,"../../types":81,"bitcoin-ops":8,"safe-
buffer":30,"typeforce":41}],73:[function(require,module,exports){
arguments[4][58][0].apply(exports,arguments)
},{"./input":74,"./output":75,"dup":58}],74:[function(require,module,exports){
// {signature} {pubKey}

var bscript = require('../../script')

var typeforce = require('typeforce')

function isCompressedCanonicalPubKey (pubKey) {

return [Link](pubKey) && [Link] === 33
}

function check (script) {

var chunks = [Link](script)

return [Link] === 2 &&

[Link](chunks[0]) &&
isCompressedCanonicalPubKey(chunks[1])
}
[Link] = function () { return 'witnessPubKeyHash input' }

function encodeStack (signature, pubKey) {

 typeforce({
signature: [Link],
pubKey: isCompressedCanonicalPubKey
}, {
signature: signature,
pubKey: pubKey
})

return [signature, pubKey]

}

function decodeStack (stack) {

typeforce([Link], stack)
typeforce(check, stack)

return {
signature: stack[0],
pubKey: stack[1]
}
}

[Link] = {
check: check,
decodeStack: decodeStack,
encodeStack: encodeStack
}

},{"../../script":55,"typeforce":41}],75:[function(require,module,exports){
// OP_0 {pubKeyHash}

var bscript = require('../../script')

var types = require('../../types')
var typeforce = require('typeforce')
var OPS = require('bitcoin-ops')

function check (script) {

var buffer = [Link](script)

return [Link] === 22 &&

buffer[0] === OPS.OP_0 &&
buffer[1] === 0x14
}
[Link] = function () { return 'Witness pubKeyHash output' }

function encode (pubKeyHash) {

typeforce(types.Hash160bit, pubKeyHash)

return [Link]([OPS.OP_0, pubKeyHash])

}

function decode (buffer) {

typeforce(check, buffer)

return [Link](2)
}

[Link] = {
check: check,
decode: decode,
 encode: encode
}

},{"../../script":55,"../../types":81,"bitcoin-ops":8,"typeforce":41}],76:
[function(require,module,exports){
arguments[4][58][0].apply(exports,arguments)
},{"./input":77,"./output":78,"dup":58}],77:[function(require,module,exports){
(function (Buffer){
// <scriptSig> {serialized scriptPubKey script}

var bscript = require('../../script')

var types = require('../../types')
var typeforce = require('typeforce')

var p2ms = require('../multisig/')

var p2pk = require('../pubkey/')
var p2pkh = require('../pubkeyhash/')

function check (chunks, allowIncomplete) {

typeforce([Link], chunks)
if ([Link] < 1) return false

var witnessScript = chunks[[Link] - 1]

if () return false

var witnessScriptChunks = [Link](witnessScript)

// is witnessScript a valid script?

if ([Link] === 0) return false

var witnessRawScriptSig = [Link]([Link](0, -1))

// match types
if ([Link](witnessRawScriptSig) &&
[Link](witnessScriptChunks)) return true

if ([Link](witnessRawScriptSig, allowIncomplete) &&

[Link](witnessScriptChunks)) return true

if ([Link](witnessRawScriptSig) &&
[Link](witnessScriptChunks)) return true

return false
}
[Link] = function () { return 'witnessScriptHash input' }

function encodeStack (witnessData, witnessScript) {

typeforce({
witnessData: [[Link]],
witnessScript: [Link]
}, {
witnessData: witnessData,
witnessScript: witnessScript
})

return [].concat(witnessData, witnessScript)

}

function decodeStack (stack) {

 typeforce([Link], stack)
typeforce(check, stack)
return {
witnessData: [Link](0, -1),
witnessScript: stack[[Link] - 1]
}
}

[Link] = {
check: check,
decodeStack: decodeStack,
encodeStack: encodeStack
}

}).call(this,require("buffer").Buffer)
},{"../../script":55,"../../types":81,"../multisig/":58,"../pubkey/":62,"../
pubkeyhash/":65,"buffer":84,"typeforce":41}],78:[function(require,module,exports){
// OP_0 {scriptHash}

var bscript = require('../../script')

var types = require('../../types')
var typeforce = require('typeforce')
var OPS = require('bitcoin-ops')

function check (script) {

var buffer = [Link](script)

return [Link] === 34 &&

buffer[0] === OPS.OP_0 &&
buffer[1] === 0x20
}
[Link] = function () { return 'Witness scriptHash output' }

function encode (scriptHash) {

typeforce(types.Hash256bit, scriptHash)

return [Link]([OPS.OP_0, scriptHash])

}

function decode (buffer) {

typeforce(check, buffer)

return [Link](2)
}

[Link] = {
check: check,
decode: decode,
encode: encode
}

},{"../../script":55,"../../types":81,"bitcoin-ops":8,"typeforce":41}],79:
[function(require,module,exports){
var Buffer = require('safe-buffer').Buffer
var bcrypto = require('./crypto')
var bscript = require('./script')
var bufferutils = require('./bufferutils')
var opcodes = require('bitcoin-ops')
var typeforce = require('typeforce')
var types = require('./types')
var varuint = require('varuint-bitcoin')

function varSliceSize (someScript) {

var length = [Link]

return [Link](length) + length

}

function vectorSize (someVector) {

var length = [Link]

return [Link](length) + [Link](function (sum, witness)

{
return sum + varSliceSize(witness)
}, 0)
}

function Transaction () {
[Link] = 1
[Link] = 0
[Link] = []
[Link] = []
}

Transaction.DEFAULT_SEQUENCE = 0xffffffff
Transaction.SIGHASH_ALL = 0x01
Transaction.SIGHASH_NONE = 0x02
Transaction.SIGHASH_SINGLE = 0x03
Transaction.SIGHASH_ANYONECANPAY = 0x80
Transaction.ADVANCED_TRANSACTION_MARKER = 0x00
Transaction.ADVANCED_TRANSACTION_FLAG = 0x01

var EMPTY_SCRIPT = [Link](0)

var EMPTY_WITNESS = []
var ZERO =
[Link]('0000000000000000000000000000000000000000000000000000000000000000',
'hex')
var ONE =
[Link]('0000000000000000000000000000000000000000000000000000000000000001',
'hex')
var VALUE_UINT64_MAX = [Link]('ffffffffffffffff', 'hex')
var BLANK_OUTPUT = {
script: EMPTY_SCRIPT,
valueBuffer: VALUE_UINT64_MAX
}

[Link] = function (buffer, __noStrict) {

var offset = 0
function readSlice (n) {
offset += n
return [Link](offset - n, offset)
}

function readUInt32 () {
var i = buffer.readUInt32LE(offset)
offset += 4
return i
}
function readInt32 () {
var i = buffer.readInt32LE(offset)
offset += 4
return i
}

function readUInt64 () {
var i = bufferutils.readUInt64LE(buffer, offset)
offset += 8
return i
}

function readVarInt () {
var vi = [Link](buffer, offset)
offset += [Link]
return vi
}

function readVarSlice () {
return readSlice(readVarInt())
}

function readVector () {
var count = readVarInt()
var vector = []
for (var i = 0; i < count; i++) [Link](readVarSlice())
return vector
}

var tx = new Transaction()

[Link] = readInt32()

var marker = buffer.readUInt8(offset)

var flag = buffer.readUInt8(offset + 1)

var hasWitnesses = false

if (marker === Transaction.ADVANCED_TRANSACTION_MARKER &&
flag === Transaction.ADVANCED_TRANSACTION_FLAG) {
offset += 2
hasWitnesses = true
}

var vinLen = readVarInt()

for (var i = 0; i < vinLen; ++i) {
[Link]({
hash: readSlice(32),
index: readUInt32(),
script: readVarSlice(),
sequence: readUInt32(),
witness: EMPTY_WITNESS
})
}

var voutLen = readVarInt()

for (i = 0; i < voutLen; ++i) {
[Link]({
value: readUInt64(),
script: readVarSlice()
 })
}

if (hasWitnesses) {
for (i = 0; i < vinLen; ++i) {
[Link][i].witness = readVector()
}

// was this pointless?

if (![Link]()) throw new Error('Transaction has superfluous witness
data')
}

[Link] = readUInt32()

if (__noStrict) return tx
if (offset !== [Link]) throw new Error('Transaction has unexpected data')

return tx
}

[Link] = function (hex) {

return [Link]([Link](hex, 'hex'))
}

[Link] = function (buffer) {

typeforce(types.Hash256bit, buffer)
for (var i = 0; i < 32; ++i) {
if (buffer[i] !== 0) return false
}
return true
}

[Link] = function () {
return [Link] === 1 && [Link]([Link][0].hash)
}

[Link] = function (hash, index, sequence, scriptSig) {

typeforce([Link](
types.Hash256bit,
types.UInt32,
[Link](types.UInt32),
[Link]([Link])
), arguments)

if ([Link](sequence)) {
sequence = Transaction.DEFAULT_SEQUENCE
}

// Add the input and return the input's index

return ([Link]({
hash: hash,
index: index,
script: scriptSig || EMPTY_SCRIPT,
sequence: sequence,
witness: EMPTY_WITNESS
}) - 1)
}
[Link] = function (scriptPubKey, value) {
typeforce([Link]([Link], [Link]), arguments)

// Add the output and return the output's index

return ([Link]({
script: scriptPubKey,
value: value
}) - 1)
}

[Link] = function () {
return [Link](function (x) {
return [Link] !== 0
})
}

[Link] = function () {
var base = this.__byteLength(false)
var total = this.__byteLength(true)
return base * 3 + total
}

[Link] = function () {
return [Link]([Link]() / 4)
}

[Link] = function () {
return this.__byteLength(true)
}

[Link].__byteLength = function (__allowWitness) {

var hasWitnesses = __allowWitness && [Link]()

return (
(hasWitnesses ? 10 : 8) +
[Link]([Link]) +
[Link]([Link]) +
[Link](function (sum, input) { return sum + 40 +
varSliceSize([Link]) }, 0) +
[Link](function (sum, output) { return sum + 8 +
varSliceSize([Link]) }, 0) +
(hasWitnesses ? [Link](function (sum, input) { return sum +
vectorSize([Link]) }, 0) : 0)
)
}

[Link] = function () {
var newTx = new Transaction()
[Link] = [Link]
[Link] = [Link]

[Link] = [Link](function (txIn) {

return {
hash: [Link],
index: [Link],
script: [Link],
sequence: [Link],
witness: [Link]
}
 })

[Link] = [Link](function (txOut) {

return {
script: [Link],
value: [Link]
}
})

return newTx
}

/**
* Hash transaction for signing a specific input.
*
* Bitcoin uses a different hash for each signed transaction input.
* This method copies the transaction, makes the necessary changes based on the
* hashType, and then hashes the result.
* This hash can then be used to sign the provided transaction input.
*/
[Link] = function (inIndex, prevOutScript,
hashType) {
typeforce([Link](types.UInt32, [Link], /* types.UInt8 */
[Link]), arguments)

// [Link]
if (inIndex >= [Link]) return ONE

// ignore OP_CODESEPARATOR
var ourScript = [Link]([Link](prevOutScript).filter(function
(x) {
return x !== opcodes.OP_CODESEPARATOR
}))

var txTmp = [Link]()

// SIGHASH_NONE: ignore all outputs? (wildcard payee)

if ((hashType & 0x1f) === Transaction.SIGHASH_NONE) {
[Link] = []

// ignore sequence numbers (except at inIndex)

[Link](function (input, i) {
if (i === inIndex) return

[Link] = 0
})

// SIGHASH_SINGLE: ignore all outputs, except at the same index?

} else if ((hashType & 0x1f) === Transaction.SIGHASH_SINGLE) {
//
[Link]
if (inIndex >= [Link]) return ONE

// truncate outputs after

[Link] = inIndex + 1

// "blank" outputs before

for (var i = 0; i < inIndex; i++) {
[Link][i] = BLANK_OUTPUT
 }

// ignore sequence numbers (except at inIndex)

[Link](function (input, y) {
if (y === inIndex) return

[Link] = 0
})
}

// SIGHASH_ANYONECANPAY: ignore inputs entirely?

if (hashType & Transaction.SIGHASH_ANYONECANPAY) {
[Link] = [[Link][inIndex]]
[Link][0].script = ourScript

// SIGHASH_ALL: only ignore input scripts

} else {
// "blank" others input scripts
[Link](function (input) { [Link] = EMPTY_SCRIPT })
[Link][inIndex].script = ourScript
}

// serialize and hash

var buffer = [Link](txTmp.__byteLength(false) + 4)
buffer.writeInt32LE(hashType, [Link] - 4)
txTmp.__toBuffer(buffer, 0, false)

return bcrypto.hash256(buffer)
}

[Link].hashForWitnessV0 = function (inIndex, prevOutScript, value,

hashType) {
typeforce([Link](types.UInt32, [Link], [Link], types.UInt32),
arguments)

var tbuffer, toffset

function writeSlice (slice) { toffset += [Link](tbuffer, toffset) }
function writeUInt32 (i) { toffset = tbuffer.writeUInt32LE(i, toffset) }
function writeUInt64 (i) { toffset = bufferutils.writeUInt64LE(tbuffer, i,
toffset) }
function writeVarInt (i) {
[Link](i, tbuffer, toffset)
toffset += [Link]
}
function writeVarSlice (slice) { writeVarInt([Link]); writeSlice(slice) }

var hashOutputs = ZERO

var hashPrevouts = ZERO
var hashSequence = ZERO

if (!(hashType & Transaction.SIGHASH_ANYONECANPAY)) {

tbuffer = [Link](36 * [Link])
toffset = 0

[Link](function (txIn) {
writeSlice([Link])
writeUInt32([Link])
})
 hashPrevouts = bcrypto.hash256(tbuffer)
}

if (!(hashType & Transaction.SIGHASH_ANYONECANPAY) &&

(hashType & 0x1f) !== Transaction.SIGHASH_SINGLE &&
(hashType & 0x1f) !== Transaction.SIGHASH_NONE) {
tbuffer = [Link](4 * [Link])
toffset = 0

[Link](function (txIn) {
writeUInt32([Link])
})

hashSequence = bcrypto.hash256(tbuffer)
}

if ((hashType & 0x1f) !== Transaction.SIGHASH_SINGLE &&

(hashType & 0x1f) !== Transaction.SIGHASH_NONE) {
var txOutsSize = [Link](function (sum, output) {
return sum + 8 + varSliceSize([Link])
}, 0)

tbuffer = [Link](txOutsSize)
toffset = 0

[Link](function (out) {
writeUInt64([Link])
writeVarSlice([Link])
})

hashOutputs = bcrypto.hash256(tbuffer)
} else if ((hashType & 0x1f) === Transaction.SIGHASH_SINGLE && inIndex <
[Link]) {
var output = [Link][inIndex]

tbuffer = [Link](8 + varSliceSize([Link]))

toffset = 0
writeUInt64([Link])
writeVarSlice([Link])

hashOutputs = bcrypto.hash256(tbuffer)
}

tbuffer = [Link](156 + varSliceSize(prevOutScript))

toffset = 0

var input = [Link][inIndex]

writeUInt32([Link])
writeSlice(hashPrevouts)
writeSlice(hashSequence)
writeSlice([Link])
writeUInt32([Link])
writeVarSlice(prevOutScript)
writeUInt64(value)
writeUInt32([Link])
writeSlice(hashOutputs)
writeUInt32([Link])
writeUInt32(hashType)
return bcrypto.hash256(tbuffer)
}

[Link] = function () {
return bcrypto.hash256(this.__toBuffer(undefined, undefined, false))
}

[Link] = function () {
// transaction hash's are displayed in reverse order
return [Link]().reverse().toString('hex')
}

[Link] = function (buffer, initialOffset) {

return this.__toBuffer(buffer, initialOffset, true)
}

[Link].__toBuffer = function (buffer, initialOffset, __allowWitness)

{
if (!buffer) buffer = [Link](this.__byteLength(__allowWitness))

var offset = initialOffset || 0

function writeSlice (slice) { offset += [Link](buffer, offset) }
function writeUInt8 (i) { offset = buffer.writeUInt8(i, offset) }
function writeUInt32 (i) { offset = buffer.writeUInt32LE(i, offset) }
function writeInt32 (i) { offset = buffer.writeInt32LE(i, offset) }
function writeUInt64 (i) { offset = bufferutils.writeUInt64LE(buffer, i,
offset) }
function writeVarInt (i) {
[Link](i, buffer, offset)
offset += [Link]
}
function writeVarSlice (slice) { writeVarInt([Link]); writeSlice(slice) }
function writeVector (vector) { writeVarInt([Link]);
[Link](writeVarSlice) }

writeInt32([Link])

var hasWitnesses = __allowWitness && [Link]()

if (hasWitnesses) {
writeUInt8(Transaction.ADVANCED_TRANSACTION_MARKER)
writeUInt8(Transaction.ADVANCED_TRANSACTION_FLAG)
}

writeVarInt([Link])

[Link](function (txIn) {
writeSlice([Link])
writeUInt32([Link])
writeVarSlice([Link])
writeUInt32([Link])
})

writeVarInt([Link])
[Link](function (txOut) {
if (![Link]) {
writeUInt64([Link])
} else {
writeSlice([Link])
}
 writeVarSlice([Link])
})

if (hasWitnesses) {
[Link](function (input) {
writeVector([Link])
})
}

writeUInt32([Link])

// avoid slicing unless necessary

if (initialOffset !== undefined) return [Link](initialOffset, offset)
return buffer
}

[Link] = function () {
return [Link]().toString('hex')
}

[Link] = function (index, scriptSig) {

typeforce([Link]([Link], [Link]), arguments)

[Link][index].script = scriptSig
}

[Link] = function (index, witness) {

typeforce([Link]([Link], [[Link]]), arguments)

[Link][index].witness = witness
}

[Link] = Transaction

},{"./bufferutils":47,"./crypto":48,"./script":55,"./types":81,"bitcoin-
ops":8,"safe-buffer":30,"typeforce":41,"varuint-bitcoin":43}],80:
[function(require,module,exports){
var Buffer = require('safe-buffer').Buffer
var baddress = require('./address')
var bcrypto = require('./crypto')
var bscript = require('./script')
var btemplates = require('./templates')
var networks = require('./networks')
var ops = require('bitcoin-ops')
var typeforce = require('typeforce')
var types = require('./types')
var scriptTypes = [Link]
var SIGNABLE = [[Link].P2PKH, [Link].P2PK,
[Link]]
var P2SH = [Link]([[Link].P2WPKH, [Link].P2WSH])

var ECPair = require('./ecpair')

var ECSignature = require('./ecsignature')
var Transaction = require('./transaction')

function supportedType (type) {

return [Link](type) !== -1
}
function supportedP2SHType (type) {
return [Link](type) !== -1
}

function extractChunks (type, chunks, script) {

var pubKeys = []
var signatures = []
switch (type) {
case scriptTypes.P2PKH:
// if (redeemScript) throw new Error('Nonstandard... P2SH(P2PKH)')
pubKeys = [Link](1)
signatures = [Link](0, 1)
break

case scriptTypes.P2PK:
pubKeys[0] = script ? [Link](script) : undefined
signatures = [Link](0, 1)
break

case [Link]:
if (script) {
var multisig = [Link](script)
pubKeys = [Link]
}

signatures = [Link](1).map(function (chunk) {

return [Link] === 0 ? undefined : chunk
})
break
}

return {
pubKeys: pubKeys,
signatures: signatures
}
}
function expandInput (scriptSig, witnessStack) {
if ([Link] === 0 && [Link] === 0) return {}

var prevOutScript
var prevOutType
var scriptType
var script
var redeemScript
var witnessScript
var witnessScriptType
var redeemScriptType
var witness = false
var p2wsh = false
var p2sh = false
var witnessProgram
var chunks

var scriptSigChunks = [Link](scriptSig)

var sigType = [Link](scriptSigChunks, true)
if (sigType === scriptTypes.P2SH) {
p2sh = true
redeemScript = scriptSigChunks[[Link] - 1]
 redeemScriptType = [Link](redeemScript)
prevOutScript =
[Link](bcrypto.hash160(redeemScript))
prevOutType = scriptTypes.P2SH
script = redeemScript
}

var classifyWitness = [Link](witnessStack, true)

if (classifyWitness === scriptTypes.P2WSH) {
witnessScript = witnessStack[[Link] - 1]
witnessScriptType = [Link](witnessScript)
p2wsh = true
witness = true
if ([Link] === 0) {
prevOutScript =
[Link](bcrypto.sha256(witnessScript))
prevOutType = scriptTypes.P2WSH
if (redeemScript !== undefined) {
throw new Error('Redeem script given when unnecessary')
}
// bare witness
} else {
if (!redeemScript) {
throw new Error('No redeemScript provided for P2WSH, but scriptSig non-
empty')
}
witnessProgram =
[Link](bcrypto.sha256(witnessScript))
if () {
throw new Error('Redeem script didn\'t match witnessScript')
}
}

if (!supportedType([Link](witnessScript))) {
throw new Error('unsupported witness script')
}

script = witnessScript
scriptType = witnessScriptType
chunks = [Link](0, -1)
} else if (classifyWitness === scriptTypes.P2WPKH) {
witness = true
var key = witnessStack[[Link] - 1]
var keyHash = bcrypto.hash160(key)
if ([Link] === 0) {
prevOutScript = [Link](keyHash)
prevOutType = scriptTypes.P2WPKH
if (typeof redeemScript !== 'undefined') {
throw new Error('Redeem script given when unnecessary')
}
} else {
if (!redeemScript) {
throw new Error('No redeemScript provided for P2WPKH, but scriptSig wasn\'t
empty')
}
witnessProgram = [Link](keyHash)
if () {
throw new Error('Redeem script did not have the right witness program')
}
 }

scriptType = scriptTypes.P2PKH
chunks = witnessStack
} else if (redeemScript) {
if (!supportedP2SHType(redeemScriptType)) {
throw new Error('Bad redeemscript!')
}

script = redeemScript
scriptType = redeemScriptType
chunks = [Link](0, -1)
} else {
prevOutType = scriptType = [Link](scriptSig)
chunks = scriptSigChunks
}

var expanded = extractChunks(scriptType, chunks, script)

var result = {
pubKeys: [Link],
signatures: [Link],
prevOutScript: prevOutScript,
prevOutType: prevOutType,
signType: scriptType,
signScript: script,
witness: Boolean(witness)
}

if (p2sh) {
[Link] = redeemScript
[Link] = redeemScriptType
}

if (p2wsh) {
[Link] = witnessScript
[Link] = witnessScriptType
}

return result
}

// could be done in expandInput, but requires the original Transaction for

hashForSignature
function fixMultisigOrder (input, transaction, vin) {
if ([Link] !== [Link] || ![Link])
return
if ([Link] === [Link]) return

var unmatched = [Link]()

[Link] = [Link](function (pubKey) {

var keyPair = [Link](pubKey)
var match

// check for a signature

[Link](function (signature, i) {
// skip if undefined || OP_0
if (!signature) return false
 // TODO: avoid O(n) hashForSignature
var parsed = [Link](signature)
var hash = [Link](vin, [Link],
[Link])

// skip if signature does not match pubKey

if () return false

// remove matched signature from unmatched

unmatched[i] = undefined
match = signature

return true
})

return match
})
}

function expandOutput (script, scriptType, ourPubKey) {

typeforce([Link], script)

var scriptChunks = [Link](script)

if (!scriptType) {
scriptType = [Link](script)
}

var pubKeys = []

switch (scriptType) {
// does our hash160(pubKey) match the output scripts?
case scriptTypes.P2PKH:
if (!ourPubKey) break

var pkh1 = scriptChunks[2]

var pkh2 = bcrypto.hash160(ourPubKey)
if ([Link](pkh2)) pubKeys = [ourPubKey]
break

// does our hash160(pubKey) match the output scripts?

case scriptTypes.P2WPKH:
if (!ourPubKey) break

var wpkh1 = scriptChunks[1]

var wpkh2 = bcrypto.hash160(ourPubKey)
if ([Link](wpkh2)) pubKeys = [ourPubKey]
break

case scriptTypes.P2PK:
pubKeys = [Link](0, 1)
break

case [Link]:
pubKeys = [Link](1, -2)
break

default: return { scriptType: scriptType }

}
 return {
pubKeys: pubKeys,
scriptType: scriptType,
signatures: [Link](function () { return undefined })
}
}

function checkP2SHInput (input, redeemScriptHash) {

if ([Link]) {
if ([Link] !== scriptTypes.P2SH) throw new Error('PrevOutScript must
be P2SH')

var prevOutScriptScriptHash = [Link]([Link])[1]

if () throw new
Error('Inconsistent hash160(RedeemScript)')
}
}

function checkP2WSHInput (input, witnessScriptHash) {

if ([Link]) {
if ([Link] !== scriptTypes.P2WSH) throw new Error('PrevOutScript
must be P2WSH')

var scriptHash = [Link]([Link])[1]

if () throw new Error('Inconsistent
sha25(WitnessScript)')
}
}

function prepareInput (input, kpPubKey, redeemScript, witnessValue, witnessScript)

{
var expanded
var prevOutType
var prevOutScript

var p2sh = false

var p2shType
var redeemScriptHash

var witness = false

var p2wsh = false
var witnessType
var witnessScriptHash

var signType
var signScript

if (redeemScript && witnessScript) {

redeemScriptHash = bcrypto.hash160(redeemScript)
witnessScriptHash = bcrypto.sha256(witnessScript)
checkP2SHInput(input, redeemScriptHash)

if (!
[Link]([Link](witnessScriptHash)))
throw new Error('Witness script inconsistent with redeem script')

expanded = expandOutput(witnessScript, undefined, kpPubKey)

if (![Link]) throw new Error('WitnessScript not supported "' +
[Link](redeemScript) + '"')

prevOutType = [Link].P2SH
prevOutScript = [Link](redeemScriptHash)
p2sh = witness = p2wsh = true
p2shType = [Link].P2WSH
signType = witnessType = [Link]
signScript = witnessScript
} else if (redeemScript) {
redeemScriptHash = bcrypto.hash160(redeemScript)
checkP2SHInput(input, redeemScriptHash)

expanded = expandOutput(redeemScript, undefined, kpPubKey)

if (![Link]) throw new Error('RedeemScript not supported "' +
[Link](redeemScript) + '"')

prevOutType = [Link].P2SH
prevOutScript = [Link](redeemScriptHash)
p2sh = true
signType = p2shType = [Link]
signScript = redeemScript
witness = signType === [Link].P2WPKH
} else if (witnessScript) {
witnessScriptHash = bcrypto.sha256(witnessScript)
checkP2WSHInput(input, witnessScriptHash)

expanded = expandOutput(witnessScript, undefined, kpPubKey)

if (![Link]) throw new Error('WitnessScript not supported "' +
[Link](redeemScript) + '"')

prevOutType = [Link].P2WSH
prevOutScript = [Link](witnessScriptHash)
witness = p2wsh = true
signType = witnessType = [Link]
signScript = witnessScript
} else if ([Link]) {
// embedded scripts are not possible without a redeemScript
if ([Link] === scriptTypes.P2SH ||
[Link] === scriptTypes.P2WSH) {
throw new Error('PrevOutScript is ' + [Link] + ', requires
redeemScript')
}

prevOutType = [Link]
prevOutScript = [Link]
expanded = expandOutput([Link], [Link], kpPubKey)
if (![Link]) return

witness = ([Link] === scriptTypes.P2WPKH)

signType = prevOutType
signScript = prevOutScript
} else {
prevOutScript = [Link](bcrypto.hash160(kpPubKey))
expanded = expandOutput(prevOutScript, scriptTypes.P2PKH, kpPubKey)

prevOutType = scriptTypes.P2PKH
witness = false
signType = prevOutType
signScript = prevOutScript
 }

if (signType === scriptTypes.P2WPKH) {

signScript =
[Link]([Link](sign
Script))
}

if (p2sh) {
[Link] = redeemScript
[Link] = p2shType
}

if (p2wsh) {
[Link] = witnessScript
[Link] = witnessType
}

[Link] = [Link]
[Link] = [Link]
[Link] = signScript
[Link] = signType
[Link] = prevOutScript
[Link] = prevOutType
[Link] = witness
}

function buildStack (type, signatures, pubKeys, allowIncomplete) {

if (type === scriptTypes.P2PKH) {
if ([Link] === 1 && [Link](signatures[0]) && [Link]
=== 1) return [Link](signatures[0], pubKeys[0])
} else if (type === scriptTypes.P2PK) {
if ([Link] === 1 && [Link](signatures[0])) return
[Link](signatures[0])
} else if (type === [Link]) {
if ([Link] > 0) {
signatures = [Link](function (signature) {
return signature || ops.OP_0
})
if (!allowIncomplete) {
// remove blank signatures
signatures = [Link](function (x) { return x !== ops.OP_0 })
}

return [Link](signatures)
}
} else {
throw new Error('Not yet supported')
}

if (!allowIncomplete) throw new Error('Not enough signatures provided')

return []
}

function buildInput (input, allowIncomplete) {

var scriptType = [Link]
var sig = []
var witness = []
 if (supportedType(scriptType)) {
sig = buildStack(scriptType, [Link], [Link], allowIncomplete)
}

var p2sh = false

if (scriptType === [Link].P2SH) {
// We can remove this error later when we have a guarantee prepareInput
// rejects unsignable scripts - it MUST be signable at this point.
if (!allowIncomplete && !supportedP2SHType([Link])) {
throw new Error('Impossible to sign this type')
}

if (supportedType([Link])) {
sig = buildStack([Link], [Link], [Link],
allowIncomplete)
}

// If it wasn't SIGNABLE, it's witness, defer to that

if ([Link]) {
p2sh = true
scriptType = [Link]
}
}

switch (scriptType) {
// P2WPKH is a special case of P2PKH
case [Link].P2WPKH:
witness = buildStack([Link].P2PKH, [Link], [Link],
allowIncomplete)
break

case [Link].P2WSH:
// We can remove this check later
if (!allowIncomplete && !supportedType([Link])) {
throw new Error('Impossible to sign this type')
}

if (supportedType([Link])) {
witness = buildStack([Link], [Link],
[Link], allowIncomplete)
[Link]([Link])
scriptType = [Link]
}

break
}

// append redeemScript if necessary

if (p2sh) {
[Link]([Link])
}

return {
type: scriptType,
script: [Link](sig),
witness: witness
}
}
function TransactionBuilder (network, maximumFeeRate) {
[Link] = {}
[Link] = network || [Link]

// WARNING: This is __NOT__ to be relied on, its just another potential safety
mechanism (safety in-depth)
[Link] = maximumFeeRate || 2500

[Link] = []
[Link] = new Transaction()
}

[Link] = function (locktime) {

typeforce(types.UInt32, locktime)

// if any signatures exist, throw

if ([Link](function (input) {
if (![Link]) return false

return [Link](function (s) { return s })

})) {
throw new Error('No, this would invalidate signatures')
}

[Link] = locktime
}

[Link] = function (version) {

typeforce(types.UInt32, version)

// XXX: this might eventually become more complex depending on what the versions
represent
[Link] = version
}

[Link] = function (transaction, network) {

var txb = new TransactionBuilder(network)

// Copy transaction fields

[Link]([Link])
[Link]([Link])

// Copy outputs (done first to avoid signature invalidation)

[Link](function (txOut) {
[Link]([Link], [Link])
})

// Copy inputs
[Link](function (txIn) {
txb.__addInputUnsafe([Link], [Link], {
sequence: [Link],
script: [Link],
witness: [Link]
})
})

// fix some things not possible through the public API

[Link](function (input, i) {
fixMultisigOrder(input, transaction, i)
 })

return txb
}

[Link] = function (txHash, vout, sequence,

prevOutScript) {
if (!this.__canModifyInputs()) {
throw new Error('No, this would invalidate signatures')
}

var value

// is it a hex string?
if (typeof txHash === 'string') {
// transaction hashs's are displayed in reverse order, un-reverse it
txHash = [Link](txHash, 'hex').reverse()

// is it a Transaction object?
} else if (txHash instanceof Transaction) {
var txOut = [Link][vout]
prevOutScript = [Link]
value = [Link]

txHash = [Link]()
}

return this.__addInputUnsafe(txHash, vout, {

sequence: sequence,
prevOutScript: prevOutScript,
value: value
})
}

[Link].__addInputUnsafe = function (txHash, vout, options) {

if ([Link](txHash)) {
throw new Error('coinbase inputs not supported')
}

var prevTxOut = [Link]('hex') + ':' + vout

if ([Link][prevTxOut] !== undefined) throw new Error('Duplicate TxOut: '
+ prevTxOut)

var input = {}

// derive what we can from the scriptSig

if ([Link] !== undefined) {
input = expandInput([Link], [Link] || [])
}

// if an input value was given, retain it

if ([Link] !== undefined) {
[Link] = [Link]
}

// derive what we can from the previous transactions output script

if (![Link] && [Link]) {
var prevOutType
 if (![Link] && ![Link]) {
var expanded = expandOutput([Link])

if ([Link]) {
[Link] = [Link]
[Link] = [Link]
}

prevOutType = [Link]
}

[Link] = [Link]
[Link] = prevOutType ||
[Link]([Link])
}

var vin = [Link](txHash, vout, [Link], [Link])

[Link][vin] = input
[Link][prevTxOut] = vin
return vin
}

[Link] = function (scriptPubKey, value) {

if (!this.__canModifyOutputs()) {
throw new Error('No, this would invalidate signatures')
}

// Attempt to get a script if it's a base58 address string

if (typeof scriptPubKey === 'string') {
scriptPubKey = [Link](scriptPubKey, [Link])
}

return [Link](scriptPubKey, value)

}

[Link] = function () {
return this.__build(false)
}
[Link] = function () {
return this.__build(true)
}

[Link].__build = function (allowIncomplete) {

if (!allowIncomplete) {
if (![Link]) throw new Error('Transaction has no inputs')
if (![Link]) throw new Error('Transaction has no outputs')
}

var tx = [Link]()
// Create script signatures from inputs
[Link](function (input, i) {
var scriptType = [Link] || [Link] ||
[Link]
if (!scriptType && !allowIncomplete) throw new Error('Transaction is not
complete')
var result = buildInput(input, allowIncomplete)

// skip if no result
if (!allowIncomplete) {
 if (!supportedType([Link]) && [Link] !== [Link].P2WPKH) {
throw new Error([Link] + ' not supported')
}
}

[Link](i, [Link])
[Link](i, [Link])
})

if (!allowIncomplete) {
// do not rely on this, its merely a last resort
if (this.__overMaximumFees([Link]())) {
throw new Error('Transaction has absurd fees')
}
}

return tx
}

function canSign (input) {

return [Link] !== undefined &&
[Link] !== undefined &&
[Link] !== undefined &&
[Link] !== undefined &&
[Link] === [Link] &&
[Link] > 0 &&
(
[Link] === false ||
([Link] === true && [Link] !== undefined)
)
}

[Link] = function (vin, keyPair, redeemScript, hashType,

witnessValue, witnessScript) {
// TODO: remove [Link] matching in 4.0.0
if ([Link] && [Link] !== [Link]) throw new
TypeError('Inconsistent network')
if (![Link][vin]) throw new Error('No input at index: ' + vin)
hashType = hashType || Transaction.SIGHASH_ALL

var input = [Link][vin]

// if redeemScript was previously provided, enforce consistency

if ([Link] !== undefined &&
redeemScript &&
) {
throw new Error('Inconsistent redeemScript')
}

var kpPubKey = [Link] || [Link]()

if (!canSign(input)) {
if (witnessValue !== undefined) {
if ([Link] !== undefined && [Link] !== witnessValue) throw new
Error('Input didn\'t match witnessValue')
typeforce([Link], witnessValue)
[Link] = witnessValue
}

if (!canSign(input)) prepareInput(input, kpPubKey, redeemScript, witnessValue,

witnessScript)
if (!canSign(input)) throw Error([Link] + ' not supported')
}

// ready to sign
var signatureHash
if ([Link]) {
signatureHash = [Link].hashForWitnessV0(vin, [Link], [Link],
hashType)
} else {
signatureHash = [Link](vin, [Link], hashType)
}

// enforce in order signing of public keys

var signed = [Link](function (pubKey, i) {
if () return false
if ([Link][i]) throw new Error('Signature already exists')
if ([Link] !== 33 &&
[Link] === scriptTypes.P2WPKH) throw new Error('BIP143 rejects
uncompressed public keys in P2WPKH or P2WSH')

var signature = [Link](signatureHash)

if ([Link](signature)) signature = [Link](signature)

[Link][i] = [Link](hashType)
return true
})

if (!signed) throw new Error('Key pair cannot sign for this input')
}

function signatureHashType (buffer) {

return buffer.readUInt8([Link] - 1)
}

[Link].__canModifyInputs = function () {
return [Link](function (input) {
// any signatures?
if ([Link] === undefined) return true

return [Link](function (signature) {

if (!signature) return true
var hashType = signatureHashType(signature)

// if SIGHASH_ANYONECANPAY is set, signatures would not

// be invalidated by more inputs
return hashType & Transaction.SIGHASH_ANYONECANPAY
})
})
}

[Link].__canModifyOutputs = function () {
var nInputs = [Link]
var nOutputs = [Link]

return [Link](function (input) {

if ([Link] === undefined) return true

return [Link](function (signature) {

 if (!signature) return true
var hashType = signatureHashType(signature)

var hashTypeMod = hashType & 0x1f

if (hashTypeMod === Transaction.SIGHASH_NONE) return true
if (hashTypeMod === Transaction.SIGHASH_SINGLE) {
// if SIGHASH_SINGLE is set, and nInputs > nOutputs
// some signatures would be invalidated by the addition
// of more outputs
return nInputs <= nOutputs
}
})
})
}

[Link].__overMaximumFees = function (bytes) {

// not all inputs will have .value defined
var incoming = [Link](function (a, x) { return a + ([Link] >>> 0) },
0)

// but all outputs do, and if we have any input value

// we can immediately determine if the outputs are too small
var outgoing = [Link](function (a, x) { return a + [Link] }, 0)
var fee = incoming - outgoing
var feeRate = fee / bytes

return feeRate > [Link]

}

[Link] = TransactionBuilder

},{"./address":45,"./crypto":48,"./ecpair":50,"./ecsignature":51,"./
networks":54,"./script":55,"./templates":57,"./transaction":79,"./
types":81,"bitcoin-ops":8,"safe-buffer":30,"typeforce":41}],81:
[function(require,module,exports){
var typeforce = require('typeforce')

var UINT31_MAX = [Link](2, 31) - 1

function UInt31 (value) {
return typeforce.UInt32(value) && value <= UINT31_MAX
}

function BIP32Path (value) {

return [Link](value) && [Link](/^(m\/)?(\d+'?\/)*\d+'?$/)
}
[Link] = function () { return 'BIP32 derivation path' }

var SATOSHI_MAX = 21 * 1e14

function Satoshi (value) {
return typeforce.UInt53(value) && value <= SATOSHI_MAX
}

// external dependent types

var BigInt = [Link]('BigInteger')
var ECPoint = [Link]('Point')

// exposed, external API

var ECSignature = [Link]({ r: BigInt, s: BigInt })
var Network = [Link]({
 messagePrefix: [Link]([Link], [Link]),
bip32: {
public: typeforce.UInt32,
private: typeforce.UInt32
},
pubKeyHash: typeforce.UInt8,
scriptHash: typeforce.UInt8,
wif: typeforce.UInt8
})

// extend typeforce types with ours

var types = {
BigInt: BigInt,
BIP32Path: BIP32Path,
Buffer256bit: [Link](32),
ECPoint: ECPoint,
ECSignature: ECSignature,
Hash160bit: [Link](20),
Hash256bit: [Link](32),
Network: Network,
Satoshi: Satoshi,
UInt31: UInt31
}

for (var typeName in typeforce) {

types[typeName] = typeforce[typeName]
}

[Link] = types

},{"typeforce":41}],82:[function(require,module,exports){
// [Link]
//
// THIS IS NOT TESTED NOR LIKELY TO WORK OUTSIDE V8!
//
// Originally from [Link] ([Link]
// Copyright (c) 2009 Thomas Robinson <[Link]>
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the 'Software'), to
// deal in the Software without restriction, including without limitation the
// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
// sell copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

// when used in node, this will actually load the util module we depend on
// versus loading the builtin util module as happens otherwise
// this is a bug in node module loading as far as I am concerned
var util = require('util/');
var pSlice = [Link];
var hasOwn = [Link];

// 1. The assert module provides functions that throw

// AssertionError's when particular conditions are not met. The
// assert module must conform to the following interface.

var assert = [Link] = ok;

// 2. The AssertionError is defined in assert.

// new [Link]({ message: message,
// actual: actual,
// expected: expected })

[Link] = function AssertionError(options) {

[Link] = 'AssertionError';
[Link] = [Link];
[Link] = [Link];
[Link] = [Link];
if ([Link]) {
[Link] = [Link];
[Link] = false;
} else {
[Link] = getMessage(this);
[Link] = true;
}
var stackStartFunction = [Link] || fail;

if ([Link]) {
[Link](this, stackStartFunction);
}
else {
// non v8 browsers so we can have a stacktrace
var err = new Error();
if ([Link]) {
var out = [Link];

// try to strip useless frames

var fn_name = [Link];
var idx = [Link]('\n' + fn_name);
if (idx >= 0) {
// once we have located the function frame
// we need to strip out everything before it (and its line)
var next_line = [Link]('\n', idx + 1);
out = [Link](next_line + 1);
}

[Link] = out;
}
}
};

// [Link] instanceof Error

[Link]([Link], Error);

function replacer(key, value) {

if ([Link](value)) {
return '' + value;
 }
if ([Link](value) && !isFinite(value)) {
return [Link]();
}
if ([Link](value) || [Link](value)) {
return [Link]();
}
return value;
}

function truncate(s, n) {
if ([Link](s)) {
return [Link] < n ? s : [Link](0, n);
} else {
return s;
}
}

function getMessage(self) {
return truncate([Link]([Link], replacer), 128) + ' ' +
[Link] + ' ' +
truncate([Link]([Link], replacer), 128);
}

// At present only the three keys mentioned above are used and
// understood by the spec. Implementations or sub modules can pass
// other keys to the AssertionError's constructor - they will be
// ignored.

// 3. All of the following functions must throw an AssertionError

// when a corresponding condition is not met, with a message that
// may be undefined if not provided. All assertion methods provide
// both the actual and expected values to the assertion error for
// display purposes.

function fail(actual, expected, message, operator, stackStartFunction) {

throw new [Link]({
message: message,
actual: actual,
expected: expected,
operator: operator,
stackStartFunction: stackStartFunction
});
}

// EXTENSION! allows for well behaved errors defined elsewhere.

[Link] = fail;

// 4. Pure assertion tests whether a value is truthy, as determined

// by !!guard.
// [Link](guard, message_opt);
// This statement is equivalent to [Link](true, !!guard,
// message_opt);. To test strictly for the value true, use
// [Link](true, guard, message_opt);.

function ok(value, message) {

if (!value) fail(value, true, message, '==', [Link]);
}
[Link] = ok;
// 5. The equality assertion tests shallow, coercive equality with
// ==.
// [Link](actual, expected, message_opt);

[Link] = function equal(actual, expected, message) {

if (actual != expected) fail(actual, expected, message, '==', [Link]);
};

// 6. The non-equality assertion tests for whether two objects are not equal
// with != [Link](actual, expected, message_opt);

[Link] = function notEqual(actual, expected, message) {

if (actual == expected) {
fail(actual, expected, message, '!=', [Link]);
}
};

// 7. The equivalence assertion tests a deep equality relation.

// [Link](actual, expected, message_opt);

[Link] = function deepEqual(actual, expected, message) {

if (!_deepEqual(actual, expected)) {
fail(actual, expected, message, 'deepEqual', [Link]);
}
};

function _deepEqual(actual, expected) {

// 7.1. All identical values are equivalent, as determined by ===.
if (actual === expected) {
return true;

} else if ([Link](actual) && [Link](expected)) {

if ([Link] != [Link]) return false;

for (var i = 0; i < [Link]; i++) {

if (actual[i] !== expected[i]) return false;
}

return true;

// 7.2. If the expected value is a Date object, the actual value is

// equivalent if it is also a Date object that refers to the same time.
} else if ([Link](actual) && [Link](expected)) {
return [Link]() === [Link]();

// 7.3 If the expected value is a RegExp object, the actual value is

// equivalent if it is also a RegExp object with the same source and
// properties (`global`, `multiline`, `lastIndex`, `ignoreCase`).
} else if ([Link](actual) && [Link](expected)) {
return [Link] === [Link] &&
[Link] === [Link] &&
[Link] === [Link] &&
[Link] === [Link] &&
[Link] === [Link];

// 7.4. Other pairs that do not both pass typeof value == 'object',
// equivalence is determined by ==.
} else if ( && ) {
 return actual == expected;

// 7.5 For all other Object pairs, including Array objects, equivalence is
// determined by having the same number of owned properties (as verified
// with [Link]), the same set of keys
// (although not necessarily the same order), equivalent values for every
// corresponding key, and an identical 'prototype' property. Note: this
// accounts for both named and indexed properties on Arrays.
} else {
return objEquiv(actual, expected);
}
}

function isArguments(object) {
return [Link](object) == '[object Arguments]';
}

function objEquiv(a, b) {
if ([Link](a) || [Link](b))
return false;
// an identical 'prototype' property.
if ([Link] !== [Link]) return false;
// if one is a primitive, the other must be same
if ([Link](a) || [Link](b)) {
return a === b;
}
var aIsArgs = isArguments(a),
bIsArgs = isArguments(b);
if ((aIsArgs && !bIsArgs) || (!aIsArgs && bIsArgs))
return false;
if (aIsArgs) {
a = [Link](a);
b = [Link](b);
return _deepEqual(a, b);
}
var ka = objectKeys(a),
kb = objectKeys(b),
key, i;
// having the same number of owned properties (keys incorporates
// hasOwnProperty)
if ([Link] != [Link])
return false;
//the same set of keys (although not necessarily the same order),
[Link]();
[Link]();
//~~~cheap key test
for (i = [Link] - 1; i >= 0; i--) {
if (ka[i] != kb[i])
return false;
}
//equivalent values for every corresponding key, and
//~~~possibly expensive deep test
for (i = [Link] - 1; i >= 0; i--) {
key = ka[i];
if (!_deepEqual(a[key], b[key])) return false;
}
return true;
}
// 8. The non-equivalence assertion tests for any deep inequality.
// [Link](actual, expected, message_opt);

[Link] = function notDeepEqual(actual, expected, message) {

if (_deepEqual(actual, expected)) {
fail(actual, expected, message, 'notDeepEqual', [Link]);
}
};

// 9. The strict equality assertion tests strict equality, as determined by ===.

// [Link](actual, expected, message_opt);

[Link] = function strictEqual(actual, expected, message) {

if (actual !== expected) {
fail(actual, expected, message, '===', [Link]);
}
};

// 10. The strict non-equality assertion tests for strict inequality, as

// determined by !==. [Link](actual, expected, message_opt);

[Link] = function notStrictEqual(actual, expected, message) {

if (actual === expected) {
fail(actual, expected, message, '!==', [Link]);
}
};

function expectedException(actual, expected) {

if (!actual || !expected) {
return false;
}

if ([Link](expected) == '[object RegExp]') {

return [Link](actual);
} else if (actual instanceof expected) {
return true;
} else if ([Link]({}, actual) === true) {
return true;
}

return false;
}

function _throws(shouldThrow, block, expected, message) {

var actual;

if ([Link](expected)) {
message = expected;
expected = null;
}

try {
block();
} catch (e) {
actual = e;
}

message = (expected && [Link] ? ' (' + [Link] + ').' : '.') +

(message ? ' ' + message : '.');
 if (shouldThrow && !actual) {
fail(actual, expected, 'Missing expected exception' + message);
}

if (!shouldThrow && expectedException(actual, expected)) {

fail(actual, expected, 'Got unwanted exception' + message);
}

if ((shouldThrow && actual && expected &&

!expectedException(actual, expected)) || (!shouldThrow && actual)) {
throw actual;
}
}

// 11. Expected to throw an error:

// [Link](block, Error_opt, message_opt);

[Link] = function(block, /*optional*/error, /*optional*/message) {

_throws.apply(this, [true].concat([Link](arguments)));
};

// EXTENSION! This is annoying to write outside this module.

[Link] = function(block, /*optional*/message) {
_throws.apply(this, [false].concat([Link](arguments)));
};

[Link] = function(err) { if (err) {throw err;}};

var objectKeys = [Link] || function (obj) {

var keys = [];
for (var key in obj) {
if ([Link](obj, key)) [Link](key);
}
return keys;
};

},{"util/":106}],83:[function(require,module,exports){

},{}],84:[function(require,module,exports){
/*!
* The buffer module from [Link], for the browser.
*
* @author Feross Aboukhadijeh <feross@[Link]> <[Link]
* @license MIT
*/

var base64 = require('base64-js')

var ieee754 = require('ieee754')
var isArray = require('is-array')

[Link] = Buffer
[Link] = SlowBuffer
exports.INSPECT_MAX_BYTES = 50
[Link] = 8192 // not used by this implementation

var kMaxLength = 0x3fffffff

var rootParent = {}
/**
* If `Buffer.TYPED_ARRAY_SUPPORT`:
* === true Use Uint8Array implementation (fastest)
* === false Use Object implementation (most compatible, even IE6)
*
* Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari
5.1+,
* Opera 11.6+, iOS 4.2+.
*
* Note:
*
* - Implementation must support adding new properties to `Uint8Array` instances.
* Firefox 4-29 lacked support, fixed in Firefox 30+.
* See: [Link]
*
* - Chrome 9-10 is missing the `[Link]` function.
*
* - IE10 has a broken `[Link]` function which returns
arrays of
* incorrect length in some situations.
*
* We detect these buggy browsers and set `Buffer.TYPED_ARRAY_SUPPORT` to `false`
so they will
* get the Object implementation, which is slower but will work correctly.
*/
Buffer.TYPED_ARRAY_SUPPORT = (function () {
try {
var buf = new ArrayBuffer(0)
var arr = new Uint8Array(buf)
[Link] = function () { return 42 }
return [Link]() === 42 && // typed array instances can be augmented
typeof [Link] === 'function' && // chrome 9-10 lack `subarray`
new Uint8Array(1).subarray(1, 1).byteLength === 0 // ie10 has broken
`subarray`
} catch (e) {
return false
}
})()

/**
* Class: Buffer
* =============
*
* The Buffer constructor returns instances of `Uint8Array` that are augmented
* with function properties for all the node `Buffer` API functions. We use
* `Uint8Array` so that square bracket notation works as expected -- it returns
* a single octet.
*
* By augmenting the instances, we can avoid modifying the `Uint8Array`
* prototype.
*/
function Buffer (subject, encoding, noZero) {
if (!(this instanceof Buffer))
return new Buffer(subject, encoding, noZero)

var type = typeof subject

// Find the length

var length
 if (type === 'number') {
length = +subject
} else if (type === 'string') {
length = [Link](subject, encoding)
} else if (type === 'object' && subject !== null) { // assume object is array-
like
if ([Link] === 'Buffer' && isArray([Link]))
subject = [Link]
length = +[Link]
} else {
throw new TypeError('must start with number, buffer, array or string')
}

if (length > kMaxLength)

throw new RangeError('Attempt to allocate Buffer larger than maximum ' +
'size: 0x' + [Link](16) + ' bytes')

if (length < 0)
length = 0
else
length >>>= 0 // Coerce to uint32.

var self = this

if (Buffer.TYPED_ARRAY_SUPPORT) {
// Preferred: Return an augmented `Uint8Array` instance for best performance
/*eslint-disable consistent-this */
self = Buffer._augment(new Uint8Array(length))
/*eslint-enable consistent-this */
} else {
// Fallback: Return THIS instance of Buffer (created by `new`)
[Link] = length
self._isBuffer = true
}

var i
if (Buffer.TYPED_ARRAY_SUPPORT && typeof [Link] === 'number') {
// Speed optimization -- use set if we're copying from a typed array
self._set(subject)
} else if (isArrayish(subject)) {
// Treat array-ish objects as a byte array
if ([Link](subject)) {
for (i = 0; i < length; i++)
self[i] = subject.readUInt8(i)
} else {
for (i = 0; i < length; i++)
self[i] = ((subject[i] % 256) + 256) % 256
}
} else if (type === 'string') {
[Link](subject, 0, encoding)
} else if (type === 'number' && !Buffer.TYPED_ARRAY_SUPPORT && !noZero) {
for (i = 0; i < length; i++) {
self[i] = 0
}
}

if (length > 0 && length <= [Link])

[Link] = rootParent

return self
}

function SlowBuffer (subject, encoding, noZero) {

if (!(this instanceof SlowBuffer))
return new SlowBuffer(subject, encoding, noZero)

var buf = new Buffer(subject, encoding, noZero)

delete [Link]
return buf
}

[Link] = function (b) {

return !!(b != null && b._isBuffer)
}

[Link] = function (a, b) {

if ( || )
throw new TypeError('Arguments must be Buffers')

if (a === b) return 0

var x = [Link]
var y = [Link]
for (var i = 0, len = [Link](x, y); i < len && a[i] === b[i]; i++) {}
if (i !== len) {
x = a[i]
y = b[i]
}
if (x < y) return -1
if (y < x) return 1
return 0
}

[Link] = function (encoding) {

switch (String(encoding).toLowerCase()) {
case 'hex':
case 'utf8':
case 'utf-8':
case 'ascii':
case 'binary':
case 'base64':
case 'raw':
case 'ucs2':
case 'ucs-2':
case 'utf16le':
case 'utf-16le':
return true
default:
return false
}
}

[Link] = function (list, totalLength) {

if (!isArray(list)) throw new TypeError('Usage: [Link](list[, length])')

if ([Link] === 0) {
return new Buffer(0)
} else if ([Link] === 1) {
return list[0]
 }

var i
if (totalLength === undefined) {
totalLength = 0
for (i = 0; i < [Link]; i++) {
totalLength += list[i].length
}
}

var buf = new Buffer(totalLength)

var pos = 0
for (i = 0; i < [Link]; i++) {
var item = list[i]
[Link](buf, pos)
pos += [Link]
}
return buf
}

[Link] = function (str, encoding) {

var ret
str = str + ''
switch (encoding || 'utf8') {
case 'ascii':
case 'binary':
case 'raw':
ret = [Link]
break
case 'ucs2':
case 'ucs-2':
case 'utf16le':
case 'utf-16le':
ret = [Link] * 2
break
case 'hex':
ret = [Link] >>> 1
break
case 'utf8':
case 'utf-8':
ret = utf8ToBytes(str).length
break
case 'base64':
ret = base64ToBytes(str).length
break
default:
ret = [Link]
}
return ret
}

// pre-set for values that may exist in the future

[Link] = undefined
[Link] = undefined

// toString(encoding, start=0, end=[Link])

[Link] = function (encoding, start, end) {
var loweredCase = false
 start = start >>> 0
end = end === undefined || end === Infinity ? [Link] : end >>> 0

if (!encoding) encoding = 'utf8'

if (start < 0) start = 0
if (end > [Link]) end = [Link]
if (end <= start) return ''

while (true) {
switch (encoding) {
case 'hex':
return hexSlice(this, start, end)

case 'utf8':
case 'utf-8':
return utf8Slice(this, start, end)

case 'ascii':
return asciiSlice(this, start, end)

case 'binary':
return binarySlice(this, start, end)

case 'base64':
return base64Slice(this, start, end)

case 'ucs2':
case 'ucs-2':
case 'utf16le':
case 'utf-16le':
return utf16leSlice(this, start, end)

default:
if (loweredCase)
throw new TypeError('Unknown encoding: ' + encoding)
encoding = (encoding + '').toLowerCase()
loweredCase = true
}
}
}

[Link] = function (b) {

if () throw new TypeError('Argument must be a Buffer')
if (this === b) return true
return [Link](this, b) === 0
}

[Link] = function () {
var str = ''
var max = exports.INSPECT_MAX_BYTES
if ([Link] > 0) {
str = [Link]('hex', 0, max).match(/.{2}/g).join(' ')
if ([Link] > max)
str += ' ... '
}
return '<Buffer ' + str + '>'
}

[Link] = function (b) {

 if () throw new TypeError('Argument must be a Buffer')
if (this === b) return 0
return [Link](this, b)
}

// `get` will be removed in Node 0.13+

[Link] = function (offset) {
[Link]('.get() is deprecated. Access using array indexes instead.')
return this.readUInt8(offset)
}

// `set` will be removed in Node 0.13+

[Link] = function (v, offset) {
[Link]('.set() is deprecated. Access using array indexes instead.')
return this.writeUInt8(v, offset)
}

function hexWrite (buf, string, offset, length) {

offset = Number(offset) || 0
var remaining = [Link] - offset
if (!length) {
length = remaining
} else {
length = Number(length)
if (length > remaining) {
length = remaining
}
}

// must be an even number of digits

var strLen = [Link]
if (strLen % 2 !== 0) throw new Error('Invalid hex string')

if (length > strLen / 2) {

length = strLen / 2
}
for (var i = 0; i < length; i++) {
var byte = parseInt([Link](i * 2, 2), 16)
if (isNaN(byte)) throw new Error('Invalid hex string')
buf[offset + i] = byte
}
return i
}

function utf8Write (buf, string, offset, length) {

var charsWritten = blitBuffer(utf8ToBytes(string, [Link] - offset), buf,
offset, length)
return charsWritten
}

function asciiWrite (buf, string, offset, length) {

var charsWritten = blitBuffer(asciiToBytes(string), buf, offset, length)
return charsWritten
}

function binaryWrite (buf, string, offset, length) {

return asciiWrite(buf, string, offset, length)
}
function base64Write (buf, string, offset, length) {
var charsWritten = blitBuffer(base64ToBytes(string), buf, offset, length)
return charsWritten
}

function utf16leWrite (buf, string, offset, length) {

var charsWritten = blitBuffer(utf16leToBytes(string, [Link] - offset), buf,
offset, length)
return charsWritten
}

[Link] = function (string, offset, length, encoding) {

// Support both (string, offset, length, encoding)
// and the legacy (string, encoding, offset, length)
if (isFinite(offset)) {
if (!isFinite(length)) {
encoding = length
length = undefined
}
} else { // legacy
var swap = encoding
encoding = offset
offset = length
length = swap
}

offset = Number(offset) || 0

if (length < 0 || offset < 0 || offset > [Link])

throw new RangeError('attempt to write outside buffer bounds')

var remaining = [Link] - offset

if (!length) {
length = remaining
} else {
length = Number(length)
if (length > remaining) {
length = remaining
}
}
encoding = String(encoding || 'utf8').toLowerCase()

var ret
switch (encoding) {
case 'hex':
ret = hexWrite(this, string, offset, length)
break
case 'utf8':
case 'utf-8':
ret = utf8Write(this, string, offset, length)
break
case 'ascii':
ret = asciiWrite(this, string, offset, length)
break
case 'binary':
ret = binaryWrite(this, string, offset, length)
break
case 'base64':
ret = base64Write(this, string, offset, length)
 break
case 'ucs2':
case 'ucs-2':
case 'utf16le':
case 'utf-16le':
ret = utf16leWrite(this, string, offset, length)
break
default:
throw new TypeError('Unknown encoding: ' + encoding)
}
return ret
}

[Link] = function () {
return {
type: 'Buffer',
data: [Link](this._arr || this, 0)
}
}

function base64Slice (buf, start, end) {

if (start === 0 && end === [Link]) {
return [Link](buf)
} else {
return [Link]([Link](start, end))
}
}

function utf8Slice (buf, start, end) {

var res = ''
var tmp = ''
end = [Link]([Link], end)

for (var i = start; i < end; i++) {

if (buf[i] <= 0x7F) {
res += decodeUtf8Char(tmp) + [Link](buf[i])
tmp = ''
} else {
tmp += '%' + buf[i].toString(16)
}
}

return res + decodeUtf8Char(tmp)

}

function asciiSlice (buf, start, end) {

var ret = ''
end = [Link]([Link], end)

for (var i = start; i < end; i++) {

ret += [Link](buf[i] & 0x7F)
}
return ret
}

function binarySlice (buf, start, end) {

var ret = ''
end = [Link]([Link], end)
 for (var i = start; i < end; i++) {
ret += [Link](buf[i])
}
return ret
}

function hexSlice (buf, start, end) {

var len = [Link]

if (!start || start < 0) start = 0

if (!end || end < 0 || end > len) end = len

var out = ''

for (var i = start; i < end; i++) {
out += toHex(buf[i])
}
return out
}

function utf16leSlice (buf, start, end) {

var bytes = [Link](start, end)
var res = ''
for (var i = 0; i < [Link]; i += 2) {
res += [Link](bytes[i] + bytes[i + 1] * 256)
}
return res
}

[Link] = function (start, end) {

var len = [Link]
start = ~~start
end = end === undefined ? len : ~~end

if (start < 0) {
start += len
if (start < 0)
start = 0
} else if (start > len) {
start = len
}

if (end < 0) {
end += len
if (end < 0)
end = 0
} else if (end > len) {
end = len
}

if (end < start)

end = start

var newBuf
if (Buffer.TYPED_ARRAY_SUPPORT) {
newBuf = Buffer._augment([Link](start, end))
} else {
var sliceLen = end - start
newBuf = new Buffer(sliceLen, undefined, true)
for (var i = 0; i < sliceLen; i++) {
 newBuf[i] = this[i + start]
}
}

if ([Link])
[Link] = [Link] || this

return newBuf
}

/*
* Need to make sure that buffer isn't trying to write out of bounds.
*/
function checkOffset (offset, ext, length) {
if ((offset % 1) !== 0 || offset < 0)
throw new RangeError('offset is not uint')
if (offset + ext > length)
throw new RangeError('Trying to access beyond buffer length')
}

[Link] = function (offset, byteLength, noAssert) {

offset = offset >>> 0
byteLength = byteLength >>> 0
if (!noAssert)
checkOffset(offset, byteLength, [Link])

var val = this[offset]

var mul = 1
var i = 0
while (++i < byteLength && (mul *= 0x100))
val += this[offset + i] * mul

return val
}

[Link] = function (offset, byteLength, noAssert) {

offset = offset >>> 0
byteLength = byteLength >>> 0
if (!noAssert)
checkOffset(offset, byteLength, [Link])

var val = this[offset + --byteLength]

var mul = 1
while (byteLength > 0 && (mul *= 0x100))
val += this[offset + --byteLength] * mul

return val
}

[Link].readUInt8 = function (offset, noAssert) {

if (!noAssert)
checkOffset(offset, 1, [Link])
return this[offset]
}

[Link].readUInt16LE = function (offset, noAssert) {

if (!noAssert)
checkOffset(offset, 2, [Link])
return this[offset] | (this[offset + 1] << 8)
}

[Link].readUInt16BE = function (offset, noAssert) {

if (!noAssert)
checkOffset(offset, 2, [Link])
return (this[offset] << 8) | this[offset + 1]
}

[Link].readUInt32LE = function (offset, noAssert) {

if (!noAssert)
checkOffset(offset, 4, [Link])

return ((this[offset]) |
(this[offset + 1] << 8) |
(this[offset + 2] << 16)) +
(this[offset + 3] * 0x1000000)
}

[Link].readUInt32BE = function (offset, noAssert) {

if (!noAssert)
checkOffset(offset, 4, [Link])

return (this[offset] * 0x1000000) +

((this[offset + 1] << 16) |
(this[offset + 2] << 8) |
this[offset + 3])
}

[Link] = function (offset, byteLength, noAssert) {

offset = offset >>> 0
byteLength = byteLength >>> 0
if (!noAssert)
checkOffset(offset, byteLength, [Link])

var val = this[offset]

var mul = 1
var i = 0
while (++i < byteLength && (mul *= 0x100))
val += this[offset + i] * mul
mul *= 0x80

if (val >= mul)

val -= [Link](2, 8 * byteLength)

return val
}

[Link] = function (offset, byteLength, noAssert) {

offset = offset >>> 0
byteLength = byteLength >>> 0
if (!noAssert)
checkOffset(offset, byteLength, [Link])

var i = byteLength
var mul = 1
var val = this[offset + --i]
while (i > 0 && (mul *= 0x100))
val += this[offset + --i] * mul
mul *= 0x80
 if (val >= mul)
val -= [Link](2, 8 * byteLength)

return val
}

[Link].readInt8 = function (offset, noAssert) {

if (!noAssert)
checkOffset(offset, 1, [Link])
if (!(this[offset] & 0x80))
return (this[offset])
return ((0xff - this[offset] + 1) * -1)
}

[Link].readInt16LE = function (offset, noAssert) {

if (!noAssert)
checkOffset(offset, 2, [Link])
var val = this[offset] | (this[offset + 1] << 8)
return (val & 0x8000) ? val | 0xFFFF0000 : val
}

[Link].readInt16BE = function (offset, noAssert) {

if (!noAssert)
checkOffset(offset, 2, [Link])
var val = this[offset + 1] | (this[offset] << 8)
return (val & 0x8000) ? val | 0xFFFF0000 : val
}

[Link].readInt32LE = function (offset, noAssert) {

if (!noAssert)
checkOffset(offset, 4, [Link])

return (this[offset]) |
(this[offset + 1] << 8) |
(this[offset + 2] << 16) |
(this[offset + 3] << 24)
}

[Link].readInt32BE = function (offset, noAssert) {

if (!noAssert)
checkOffset(offset, 4, [Link])

return (this[offset] << 24) |

(this[offset + 1] << 16) |
(this[offset + 2] << 8) |
(this[offset + 3])
}

[Link] = function (offset, noAssert) {

if (!noAssert)
checkOffset(offset, 4, [Link])
return [Link](this, offset, true, 23, 4)
}

[Link] = function (offset, noAssert) {

if (!noAssert)
checkOffset(offset, 4, [Link])
return [Link](this, offset, false, 23, 4)
}

[Link] = function (offset, noAssert) {

if (!noAssert)
checkOffset(offset, 8, [Link])
return [Link](this, offset, true, 52, 8)
}

[Link] = function (offset, noAssert) {

if (!noAssert)
checkOffset(offset, 8, [Link])
return [Link](this, offset, false, 52, 8)
}

function checkInt (buf, value, offset, ext, max, min) {

if () throw new TypeError('buffer must be a Buffer
instance')
if (value > max || value < min) throw new RangeError('value is out of bounds')
if (offset + ext > [Link]) throw new RangeError('index out of range')
}

[Link] = function (value, offset, byteLength, noAssert) {

value = +value
offset = offset >>> 0
byteLength = byteLength >>> 0
if (!noAssert)
checkInt(this, value, offset, byteLength, [Link](2, 8 * byteLength), 0)

var mul = 1
var i = 0
this[offset] = value & 0xFF
while (++i < byteLength && (mul *= 0x100))
this[offset + i] = (value / mul) >>> 0 & 0xFF

return offset + byteLength

}

[Link] = function (value, offset, byteLength, noAssert) {

value = +value
offset = offset >>> 0
byteLength = byteLength >>> 0
if (!noAssert)
checkInt(this, value, offset, byteLength, [Link](2, 8 * byteLength), 0)

var i = byteLength - 1
var mul = 1
this[offset + i] = value & 0xFF
while (--i >= 0 && (mul *= 0x100))
this[offset + i] = (value / mul) >>> 0 & 0xFF

return offset + byteLength

}

[Link].writeUInt8 = function (value, offset, noAssert) {

value = +value
offset = offset >>> 0
if (!noAssert)
checkInt(this, value, offset, 1, 0xff, 0)
if (!Buffer.TYPED_ARRAY_SUPPORT) value = [Link](value)
 this[offset] = value
return offset + 1
}

function objectWriteUInt16 (buf, value, offset, littleEndian) {

if (value < 0) value = 0xffff + value + 1
for (var i = 0, j = [Link]([Link] - offset, 2); i < j; i++) {
buf[offset + i] = (value & (0xff << (8 * (littleEndian ? i : 1 - i)))) >>>
(littleEndian ? i : 1 - i) * 8
}
}

[Link].writeUInt16LE = function (value, offset, noAssert) {

value = +value
offset = offset >>> 0
if (!noAssert)
checkInt(this, value, offset, 2, 0xffff, 0)
if (Buffer.TYPED_ARRAY_SUPPORT) {
this[offset] = value
this[offset + 1] = (value >>> 8)
} else objectWriteUInt16(this, value, offset, true)
return offset + 2
}

[Link].writeUInt16BE = function (value, offset, noAssert) {

value = +value
offset = offset >>> 0
if (!noAssert)
checkInt(this, value, offset, 2, 0xffff, 0)
if (Buffer.TYPED_ARRAY_SUPPORT) {
this[offset] = (value >>> 8)
this[offset + 1] = value
} else objectWriteUInt16(this, value, offset, false)
return offset + 2
}

function objectWriteUInt32 (buf, value, offset, littleEndian) {

if (value < 0) value = 0xffffffff + value + 1
for (var i = 0, j = [Link]([Link] - offset, 4); i < j; i++) {
buf[offset + i] = (value >>> (littleEndian ? i : 3 - i) * 8) & 0xff
}
}

[Link].writeUInt32LE = function (value, offset, noAssert) {

value = +value
offset = offset >>> 0
if (!noAssert)
checkInt(this, value, offset, 4, 0xffffffff, 0)
if (Buffer.TYPED_ARRAY_SUPPORT) {
this[offset + 3] = (value >>> 24)
this[offset + 2] = (value >>> 16)
this[offset + 1] = (value >>> 8)
this[offset] = value
} else objectWriteUInt32(this, value, offset, true)
return offset + 4
}

[Link].writeUInt32BE = function (value, offset, noAssert) {

value = +value
 offset = offset >>> 0
if (!noAssert)
checkInt(this, value, offset, 4, 0xffffffff, 0)
if (Buffer.TYPED_ARRAY_SUPPORT) {
this[offset] = (value >>> 24)
this[offset + 1] = (value >>> 16)
this[offset + 2] = (value >>> 8)
this[offset + 3] = value
} else objectWriteUInt32(this, value, offset, false)
return offset + 4
}

[Link] = function (value, offset, byteLength, noAssert) {

value = +value
offset = offset >>> 0
if (!noAssert) {
checkInt(this,
value,
offset,
byteLength,
[Link](2, 8 * byteLength - 1) - 1,
-[Link](2, 8 * byteLength - 1))
}

var i = 0
var mul = 1
var sub = value < 0 ? 1 : 0
this[offset] = value & 0xFF
while (++i < byteLength && (mul *= 0x100))
this[offset + i] = ((value / mul) >> 0) - sub & 0xFF

return offset + byteLength

}

[Link] = function (value, offset, byteLength, noAssert) {

value = +value
offset = offset >>> 0
if (!noAssert) {
checkInt(this,
value,
offset,
byteLength,
[Link](2, 8 * byteLength - 1) - 1,
-[Link](2, 8 * byteLength - 1))
}

var i = byteLength - 1
var mul = 1
var sub = value < 0 ? 1 : 0
this[offset + i] = value & 0xFF
while (--i >= 0 && (mul *= 0x100))
this[offset + i] = ((value / mul) >> 0) - sub & 0xFF

return offset + byteLength

}

[Link].writeInt8 = function (value, offset, noAssert) {

value = +value
offset = offset >>> 0
 if (!noAssert)
checkInt(this, value, offset, 1, 0x7f, -0x80)
if (!Buffer.TYPED_ARRAY_SUPPORT) value = [Link](value)
if (value < 0) value = 0xff + value + 1
this[offset] = value
return offset + 1
}

[Link].writeInt16LE = function (value, offset, noAssert) {

value = +value
offset = offset >>> 0
if (!noAssert)
checkInt(this, value, offset, 2, 0x7fff, -0x8000)
if (Buffer.TYPED_ARRAY_SUPPORT) {
this[offset] = value
this[offset + 1] = (value >>> 8)
} else objectWriteUInt16(this, value, offset, true)
return offset + 2
}

[Link].writeInt16BE = function (value, offset, noAssert) {

value = +value
offset = offset >>> 0
if (!noAssert)
checkInt(this, value, offset, 2, 0x7fff, -0x8000)
if (Buffer.TYPED_ARRAY_SUPPORT) {
this[offset] = (value >>> 8)
this[offset + 1] = value
} else objectWriteUInt16(this, value, offset, false)
return offset + 2
}

[Link].writeInt32LE = function (value, offset, noAssert) {

value = +value
offset = offset >>> 0
if (!noAssert)
checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)
if (Buffer.TYPED_ARRAY_SUPPORT) {
this[offset] = value
this[offset + 1] = (value >>> 8)
this[offset + 2] = (value >>> 16)
this[offset + 3] = (value >>> 24)
} else objectWriteUInt32(this, value, offset, true)
return offset + 4
}

[Link].writeInt32BE = function (value, offset, noAssert) {

value = +value
offset = offset >>> 0
if (!noAssert)
checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)
if (value < 0) value = 0xffffffff + value + 1
if (Buffer.TYPED_ARRAY_SUPPORT) {
this[offset] = (value >>> 24)
this[offset + 1] = (value >>> 16)
this[offset + 2] = (value >>> 8)
this[offset + 3] = value
} else objectWriteUInt32(this, value, offset, false)
return offset + 4
}

function checkIEEE754 (buf, value, offset, ext, max, min) {

if (value > max || value < min) throw new RangeError('value is out of bounds')
if (offset + ext > [Link]) throw new RangeError('index out of range')
if (offset < 0) throw new RangeError('index out of range')
}

function writeFloat (buf, value, offset, littleEndian, noAssert) {

if (!noAssert)
checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -
3.4028234663852886e+38)
[Link](buf, value, offset, littleEndian, 23, 4)
return offset + 4
}

[Link] = function (value, offset, noAssert) {

return writeFloat(this, value, offset, true, noAssert)
}

[Link] = function (value, offset, noAssert) {

return writeFloat(this, value, offset, false, noAssert)
}

function writeDouble (buf, value, offset, littleEndian, noAssert) {

if (!noAssert)
checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -
1.7976931348623157E+308)
[Link](buf, value, offset, littleEndian, 52, 8)
return offset + 8
}

[Link] = function (value, offset, noAssert) {

return writeDouble(this, value, offset, true, noAssert)
}

[Link] = function (value, offset, noAssert) {

return writeDouble(this, value, offset, false, noAssert)
}

// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=[Link])

[Link] = function (target, target_start, start, end) {
var self = this // source

if (!start) start = 0
if (!end && end !== 0) end = [Link]
if (target_start >= [Link]) target_start = [Link]
if (!target_start) target_start = 0
if (end > 0 && end < start) end = start

// Copy 0 bytes; we're done

if (end === start) return 0
if ([Link] === 0 || [Link] === 0) return 0

// Fatal error conditions

if (target_start < 0)
throw new RangeError('targetStart out of bounds')
if (start < 0 || start >= [Link]) throw new RangeError('sourceStart out of
bounds')
 if (end < 0) throw new RangeError('sourceEnd out of bounds')

// Are we oob?
if (end > [Link])
end = [Link]
if ([Link] - target_start < end - start)
end = [Link] - target_start + start

var len = end - start

if (len < 1000 || !Buffer.TYPED_ARRAY_SUPPORT) {

for (var i = 0; i < len; i++) {
target[i + target_start] = this[i + start]
}
} else {
target._set([Link](start, start + len), target_start)
}

return len
}

// fill(value, start=0, end=[Link])

[Link] = function (value, start, end) {
if (!value) value = 0
if (!start) start = 0
if (!end) end = [Link]

if (end < start) throw new RangeError('end < start')

// Fill 0 bytes; we're done

if (end === start) return
if ([Link] === 0) return

if (start < 0 || start >= [Link]) throw new RangeError('start out of

bounds')
if (end < 0 || end > [Link]) throw new RangeError('end out of bounds')

var i
if (typeof value === 'number') {
for (i = start; i < end; i++) {
this[i] = value
}
} else {
var bytes = utf8ToBytes([Link]())
var len = [Link]
for (i = start; i < end; i++) {
this[i] = bytes[i % len]
}
}

return this
}

/**
* Creates a new `ArrayBuffer` with the *copied* memory of the buffer instance.
* Added in Node 0.12. Only available in browsers that support ArrayBuffer.
*/
[Link] = function () {
if (typeof Uint8Array !== 'undefined') {
 if (Buffer.TYPED_ARRAY_SUPPORT) {
return (new Buffer(this)).buffer
} else {
var buf = new Uint8Array([Link])
for (var i = 0, len = [Link]; i < len; i += 1) {
buf[i] = this[i]
}
return [Link]
}
} else {
throw new TypeError('[Link] not supported in this browser')
}
}

// HELPER FUNCTIONS
// ================

var BP = [Link]

/**
* Augment a Uint8Array *instance* (not the Uint8Array class!) with Buffer methods
*/
Buffer._augment = function (arr) {
[Link] = Buffer
arr._isBuffer = true

// save reference to original Uint8Array get/set methods before overwriting

arr._get = [Link]
arr._set = [Link]

// deprecated, will be removed in node 0.13+

[Link] = [Link]
[Link] = [Link]

[Link] = [Link]
[Link] = [Link]
[Link] = [Link]
[Link] = [Link]
[Link] = [Link]
[Link] = [Link]
[Link] = [Link]
[Link] = [Link]
[Link] = [Link]
[Link] = [Link]
arr.readUInt8 = BP.readUInt8
arr.readUInt16LE = BP.readUInt16LE
arr.readUInt16BE = BP.readUInt16BE
arr.readUInt32LE = BP.readUInt32LE
arr.readUInt32BE = BP.readUInt32BE
[Link] = [Link]
[Link] = [Link]
arr.readInt8 = BP.readInt8
arr.readInt16LE = BP.readInt16LE
arr.readInt16BE = BP.readInt16BE
arr.readInt32LE = BP.readInt32LE
arr.readInt32BE = BP.readInt32BE
[Link] = [Link]
[Link] = [Link]
[Link] = [Link]
 [Link] = [Link]
arr.writeUInt8 = BP.writeUInt8
[Link] = [Link]
[Link] = [Link]
arr.writeUInt16LE = BP.writeUInt16LE
arr.writeUInt16BE = BP.writeUInt16BE
arr.writeUInt32LE = BP.writeUInt32LE
arr.writeUInt32BE = BP.writeUInt32BE
[Link] = [Link]
[Link] = [Link]
arr.writeInt8 = BP.writeInt8
arr.writeInt16LE = BP.writeInt16LE
arr.writeInt16BE = BP.writeInt16BE
arr.writeInt32LE = BP.writeInt32LE
arr.writeInt32BE = BP.writeInt32BE
[Link] = [Link]
[Link] = [Link]
[Link] = [Link]
[Link] = [Link]
[Link] = [Link]
[Link] = [Link]
[Link] = [Link]

return arr
}

var INVALID_BASE64_RE = /[^+\/0-9A-z\-]/g

function base64clean (str) {

// Node strips out invalid characters like \n and \t from the string, base64-js
does not
str = stringtrim(str).replace(INVALID_BASE64_RE, '')
// Node converts strings with length < 2 to ''
if ([Link] < 2) return ''
// Node allows for non-padded base64 strings (missing trailing ===), base64-js
does not
while ([Link] % 4 !== 0) {
str = str + '='
}
return str
}

function stringtrim (str) {

if ([Link]) return [Link]()
return [Link](/^\s+|\s+$/g, '')
}

function isArrayish (subject) {

return isArray(subject) || [Link](subject) ||
subject && typeof subject === 'object' &&
typeof [Link] === 'number'
}

function toHex (n) {

if (n < 16) return '0' + [Link](16)
return [Link](16)
}

function utf8ToBytes (string, units) {

units = units || Infinity
var codePoint
var length = [Link]
var leadSurrogate = null
var bytes = []
var i = 0

for (; i < length; i++) {

codePoint = [Link](i)

// is surrogate component
if (codePoint > 0xD7FF && codePoint < 0xE000) {
// last char was a lead
if (leadSurrogate) {
// 2 leads in a row
if (codePoint < 0xDC00) {
if ((units -= 3) > -1) [Link](0xEF, 0xBF, 0xBD)
leadSurrogate = codePoint
continue
} else {
// valid surrogate pair
codePoint = leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00 | 0x10000
leadSurrogate = null
}
} else {
// no lead yet

if (codePoint > 0xDBFF) {

// unexpected trail
if ((units -= 3) > -1) [Link](0xEF, 0xBF, 0xBD)
continue
} else if (i + 1 === length) {
// unpaired lead
if ((units -= 3) > -1) [Link](0xEF, 0xBF, 0xBD)
continue
} else {
// valid lead
leadSurrogate = codePoint
continue
}
}
} else if (leadSurrogate) {
// valid bmp char, but last char was a lead
if ((units -= 3) > -1) [Link](0xEF, 0xBF, 0xBD)
leadSurrogate = null
}

// encode utf8
if (codePoint < 0x80) {
if ((units -= 1) < 0) break
[Link](codePoint)
} else if (codePoint < 0x800) {
if ((units -= 2) < 0) break
[Link](
codePoint >> 0x6 | 0xC0,
codePoint & 0x3F | 0x80
)
} else if (codePoint < 0x10000) {
if ((units -= 3) < 0) break
 [Link](
codePoint >> 0xC | 0xE0,
codePoint >> 0x6 & 0x3F | 0x80,
codePoint & 0x3F | 0x80
)
} else if (codePoint < 0x200000) {
if ((units -= 4) < 0) break
[Link](
codePoint >> 0x12 | 0xF0,
codePoint >> 0xC & 0x3F | 0x80,
codePoint >> 0x6 & 0x3F | 0x80,
codePoint & 0x3F | 0x80
)
} else {
throw new Error('Invalid code point')
}
}

return bytes
}

function asciiToBytes (str) {

var byteArray = []
for (var i = 0; i < [Link]; i++) {
// Node's code seems to be doing this and not & 0x7F..
[Link]([Link](i) & 0xFF)
}
return byteArray
}

function utf16leToBytes (str, units) {

var c, hi, lo
var byteArray = []
for (var i = 0; i < [Link]; i++) {
if ((units -= 2) < 0) break

c = [Link](i)
hi = c >> 8
lo = c % 256
[Link](lo)
[Link](hi)
}

return byteArray
}

function base64ToBytes (str) {

return [Link](base64clean(str))
}

function blitBuffer (src, dst, offset, length) {

for (var i = 0; i < length; i++) {
if ((i + offset >= [Link]) || (i >= [Link]))
break
dst[i + offset] = src[i]
}
return i
}
function decodeUtf8Char (str) {
try {
return decodeURIComponent(str)
} catch (err) {
return [Link](0xFFFD) // UTF 8 invalid char
}
}

},{"base64-js":85,"ieee754":86,"is-array":87}],85:[function(require,module,exports)
{
var lookup = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';

;(function (exports) {
'use strict';

var Arr = (typeof Uint8Array !== 'undefined')

? Uint8Array
: Array

var PLUS = '+'.charCodeAt(0)

var SLASH = '/'.charCodeAt(0)
var NUMBER = '0'.charCodeAt(0)
var LOWER = 'a'.charCodeAt(0)
var UPPER = 'A'.charCodeAt(0)
var PLUS_URL_SAFE = '-'.charCodeAt(0)
var SLASH_URL_SAFE = '_'.charCodeAt(0)

function decode (elt) {

var code = [Link](0)
if (code === PLUS ||
code === PLUS_URL_SAFE)
return 62 // '+'
if (code === SLASH ||
code === SLASH_URL_SAFE)
return 63 // '/'
if (code < NUMBER)
return -1 //no match
if (code < NUMBER + 10)
return code - NUMBER + 26 + 26
if (code < UPPER + 26)
return code - UPPER
if (code < LOWER + 26)
return code - LOWER + 26
}

function b64ToByteArray (b64) {

var i, j, l, tmp, placeHolders, arr

if ([Link] % 4 > 0) {
throw new Error('Invalid string. Length must be a multiple of 4')
}

// the number of equal signs (place holders)

// if there are two placeholders, than the two characters before it
// represent one byte
// if there is only one, then the three characters before it represent
2 bytes
// this is just a cheap hack to not do indexOf twice
var len = [Link]
 placeHolders = '=' === [Link](len - 2) ? 2 : '=' === [Link](len
- 1) ? 1 : 0

// base64 is 4/3 + up to two characters of the original data

arr = new Arr([Link] * 3 / 4 - placeHolders)

// if there are placeholders, only get up to the last complete 4 chars

l = placeHolders > 0 ? [Link] - 4 : [Link]

var L = 0

function push (v) {

arr[L++] = v
}

for (i = 0, j = 0; i < l; i += 4, j += 3) {
tmp = (decode([Link](i)) << 18) | (decode([Link](i + 1))
<< 12) | (decode([Link](i + 2)) << 6) | decode([Link](i + 3))
push((tmp & 0xFF0000) >> 16)
push((tmp & 0xFF00) >> 8)
push(tmp & 0xFF)
}

if (placeHolders === 2) {
tmp = (decode([Link](i)) << 2) | (decode([Link](i + 1))
>> 4)
push(tmp & 0xFF)
} else if (placeHolders === 1) {
tmp = (decode([Link](i)) << 10) | (decode([Link](i + 1))
<< 4) | (decode([Link](i + 2)) >> 2)
push((tmp >> 8) & 0xFF)
push(tmp & 0xFF)
}

return arr
}

function uint8ToBase64 (uint8) {

var i,
extraBytes = [Link] % 3, // if we have 1 byte left, pad 2
bytes
output = "",
temp, length

function encode (num) {

return [Link](num)
}

function tripletToBase64 (num) {

return encode(num >> 18 & 0x3F) + encode(num >> 12 & 0x3F) +
encode(num >> 6 & 0x3F) + encode(num & 0x3F)
}

// go through the array every three bytes, we'll deal with trailing
stuff later
for (i = 0, length = [Link] - extraBytes; i < length; i += 3) {
temp = (uint8[i] << 16) + (uint8[i + 1] << 8) + (uint8[i + 2])
output += tripletToBase64(temp)
}
 // pad the end with zeros, but make sure to not forget the extra bytes
switch (extraBytes) {
case 1:
temp = uint8[[Link] - 1]
output += encode(temp >> 2)
output += encode((temp << 4) & 0x3F)
output += '=='
break
case 2:
temp = (uint8[[Link] - 2] << 8) + (uint8[[Link]
- 1])
output += encode(temp >> 10)
output += encode((temp >> 4) & 0x3F)
output += encode((temp << 2) & 0x3F)
output += '='
break
}

return output
}

[Link] = b64ToByteArray
[Link] = uint8ToBase64
}(typeof exports === 'undefined' ? (this.base64js = {}) : exports))

},{}],86:[function(require,module,exports){
[Link] = function(buffer, offset, isLE, mLen, nBytes) {
var e, m,
eLen = nBytes * 8 - mLen - 1,
eMax = (1 << eLen) - 1,
eBias = eMax >> 1,
nBits = -7,
i = isLE ? (nBytes - 1) : 0,
d = isLE ? -1 : 1,
s = buffer[offset + i];

i += d;

e = s & ((1 << (-nBits)) - 1);

s >>= (-nBits);
nBits += eLen;
for (; nBits > 0; e = e * 256 + buffer[offset + i], i += d, nBits -= 8);

m = e & ((1 << (-nBits)) - 1);

e >>= (-nBits);
nBits += mLen;
for (; nBits > 0; m = m * 256 + buffer[offset + i], i += d, nBits -= 8);

if (e === 0) {
e = 1 - eBias;
} else if (e === eMax) {
return m ? NaN : ((s ? -1 : 1) * Infinity);
} else {
m = m + [Link](2, mLen);
e = e - eBias;
}
return (s ? -1 : 1) * m * [Link](2, e - mLen);
};
[Link] = function(buffer, value, offset, isLE, mLen, nBytes) {
var e, m, c,
eLen = nBytes * 8 - mLen - 1,
eMax = (1 << eLen) - 1,
eBias = eMax >> 1,
rt = (mLen === 23 ? [Link](2, -24) - [Link](2, -77) : 0),
i = isLE ? 0 : (nBytes - 1),
d = isLE ? 1 : -1,
s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0;

value = [Link](value);

if (isNaN(value) || value === Infinity) {

m = isNaN(value) ? 1 : 0;
e = eMax;
} else {
e = [Link]([Link](value) / Math.LN2);
if (value * (c = [Link](2, -e)) < 1) {
e--;
c *= 2;
}
if (e + eBias >= 1) {
value += rt / c;
} else {
value += rt * [Link](2, 1 - eBias);
}
if (value * c >= 2) {
e++;
c /= 2;
}

if (e + eBias >= eMax) {

m = 0;
e = eMax;
} else if (e + eBias >= 1) {
m = (value * c - 1) * [Link](2, mLen);
e = e + eBias;
} else {
m = value * [Link](2, eBias - 1) * [Link](2, mLen);
e = 0;
}
}

for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8);

e = (e << mLen) | m;
eLen += mLen;
for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8);

buffer[offset + i - d] |= s * 128;
};

},{}],87:[function(require,module,exports){

/**
* isArray
*/
var isArray = [Link];

/**
* toString
*/

var str = [Link];

/**
* Whether or not the given `val`
* is an array.
*
* example:
*
* isArray([]);
* // > true
* isArray(arguments);
* // > false
* isArray('');
* // > false
*
* @param {mixed} val
* @return {bool}
*/

[Link] = isArray || function (val) {

return !! val && '[object Array]' == [Link](val);
};

},{}],88:[function(require,module,exports){
// Copyright Joyent, Inc. and other Node contributors.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to permit
// persons to whom the Software is furnished to do so, subject to the
// following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
// USE OR OTHER DEALINGS IN THE SOFTWARE.

function EventEmitter() {
this._events = this._events || {};
this._maxListeners = this._maxListeners || undefined;
}
[Link] = EventEmitter;

// Backwards-compat with node 0.10.x

[Link] = EventEmitter;
[Link]._events = undefined;
[Link]._maxListeners = undefined;

// By default EventEmitters will print a warning if more than 10 listeners are

// added to it. This is a useful default which helps finding memory leaks.
[Link] = 10;

// Obviously not all Emitters should be limited to 10. This function allows
// that to be increased. Set to zero for unlimited.
[Link] = function(n) {
if (!isNumber(n) || n < 0 || isNaN(n))
throw TypeError('n must be a positive number');
this._maxListeners = n;
return this;
};

[Link] = function(type) {
var er, handler, len, args, i, listeners;

if (!this._events)
this._events = {};

// If there is no 'error' event listener then throw.

if (type === 'error') {
if (!this._events.error ||
(isObject(this._events.error) && !this._events.[Link])) {
er = arguments[1];
if (er instanceof Error) {
throw er; // Unhandled 'error' event
}
throw TypeError('Uncaught, unspecified "error" event.');
}
}

handler = this._events[type];

if (isUndefined(handler))
return false;

if (isFunction(handler)) {
switch ([Link]) {
// fast cases
case 1:
[Link](this);
break;
case 2:
[Link](this, arguments[1]);
break;
case 3:
[Link](this, arguments[1], arguments[2]);
break;
// slower
default:
len = [Link];
args = new Array(len - 1);
for (i = 1; i < len; i++)
args[i - 1] = arguments[i];
[Link](this, args);
 }
} else if (isObject(handler)) {
len = [Link];
args = new Array(len - 1);
for (i = 1; i < len; i++)
args[i - 1] = arguments[i];

listeners = [Link]();
len = [Link];
for (i = 0; i < len; i++)
listeners[i].apply(this, args);
}

return true;
};

[Link] = function(type, listener) {

var m;

if (!isFunction(listener))
throw TypeError('listener must be a function');

if (!this._events)
this._events = {};

// To avoid recursion in the case that type === "newListener"! Before

// adding it to the listeners, first emit "newListener".
if (this._events.newListener)
[Link]('newListener', type,
isFunction([Link]) ?
[Link] : listener);

if (!this._events[type])
// Optimize the case of one listener. Don't need the extra array object.
this._events[type] = listener;
else if (isObject(this._events[type]))
// If we've already got an array, just append.
this._events[type].push(listener);
else
// Adding the second element, need to change to array.
this._events[type] = [this._events[type], listener];

// Check for listener leak

if (isObject(this._events[type]) && !this._events[type].warned) {
var m;
if (!isUndefined(this._maxListeners)) {
m = this._maxListeners;
} else {
m = [Link];
}

if (m && m > 0 && this._events[type].length > m) {

this._events[type].warned = true;
[Link]('(node) warning: possible EventEmitter memory ' +
'leak detected. %d listeners added. ' +
'Use [Link]() to increase limit.',
this._events[type].length);
if (typeof [Link] === 'function') {
// not supported in IE 10
 [Link]();
}
}
}

return this;
};

[Link] = [Link];

[Link] = function(type, listener) {

if (!isFunction(listener))
throw TypeError('listener must be a function');

var fired = false;

function g() {
[Link](type, g);

if (!fired) {
fired = true;
[Link](this, arguments);
}
}

[Link] = listener;
[Link](type, g);

return this;
};

// emits a 'removeListener' event iff the listener was removed

[Link] = function(type, listener) {
var list, position, length, i;

if (!isFunction(listener))
throw TypeError('listener must be a function');

if (!this._events || !this._events[type])
return this;

list = this._events[type];
length = [Link];
position = -1;

if (list === listener ||

(isFunction([Link]) && [Link] === listener)) {
delete this._events[type];
if (this._events.removeListener)
[Link]('removeListener', type, listener);

} else if (isObject(list)) {
for (i = length; i-- > 0;) {
if (list[i] === listener ||
(list[i].listener && list[i].listener === listener)) {
position = i;
break;
}
}
 if (position < 0)
return this;

if ([Link] === 1) {
[Link] = 0;
delete this._events[type];
} else {
[Link](position, 1);
}

if (this._events.removeListener)
[Link]('removeListener', type, listener);
}

return this;
};

[Link] = function(type) {
var key, listeners;

if (!this._events)
return this;

// not listening for removeListener, no need to emit

if (!this._events.removeListener) {
if ([Link] === 0)
this._events = {};
else if (this._events[type])
delete this._events[type];
return this;
}

// emit removeListener for all listeners on all events

if ([Link] === 0) {
for (key in this._events) {
if (key === 'removeListener') continue;
[Link](key);
}
[Link]('removeListener');
this._events = {};
return this;
}

listeners = this._events[type];

if (isFunction(listeners)) {
[Link](type, listeners);
} else {
// LIFO order
while ([Link])
[Link](type, listeners[[Link] - 1]);
}
delete this._events[type];

return this;
};

[Link] = function(type) {
 var ret;
if (!this._events || !this._events[type])
ret = [];
else if (isFunction(this._events[type]))
ret = [this._events[type]];
else
ret = this._events[type].slice();
return ret;
};

[Link] = function(emitter, type) {

var ret;
if (!emitter._events || !emitter._events[type])
ret = 0;
else if (isFunction(emitter._events[type]))
ret = 1;
else
ret = emitter._events[type].length;
return ret;
};

function isFunction(arg) {
return typeof arg === 'function';
}

function isNumber(arg) {
return typeof arg === 'number';
}

function isObject(arg) {
return typeof arg === 'object' && arg !== null;
}

function isUndefined(arg) {
return arg === void 0;
}

},{}],89:[function(require,module,exports){
arguments[4][24][0].apply(exports,arguments)
},{"dup":24}],90:[function(require,module,exports){
[Link] = [Link] || function (arr) {
return [Link](arr) == '[object Array]';
};

},{}],91:[function(require,module,exports){
// shim for using process in browser

var process = [Link] = {};

var queue = [];
var draining = false;

function drainQueue() {
if (draining) {
return;
}
draining = true;
var currentQueue;
var len = [Link];
while(len) {
 currentQueue = queue;
queue = [];
var i = -1;
while (++i < len) {
currentQueue[i]();
}
len = [Link];
}
draining = false;
}
[Link] = function (fun) {
[Link](fun);
if (!draining) {
setTimeout(drainQueue, 0);
}
};

[Link] = 'browser';
[Link] = true;
[Link] = {};
[Link] = [];
[Link] = ''; // empty string to avoid regexp issues

function noop() {}

[Link] = noop;
[Link] = noop;
[Link] = noop;
[Link] = noop;
[Link] = noop;
[Link] = noop;
[Link] = noop;

[Link] = function (name) {

throw new Error('[Link] is not supported');
};

// TODO(shtylman)
[Link] = function () { return '/' };
[Link] = function (dir) {
throw new Error('[Link] is not supported');
};
[Link] = function() { return 0; };

},{}],92:[function(require,module,exports){
[Link] = require("./lib/_stream_duplex.js")

},{"./lib/_stream_duplex.js":93}],93:[function(require,module,exports){
(function (process){
// Copyright Joyent, Inc. and other Node contributors.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to permit
// persons to whom the Software is furnished to do so, subject to the
// following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
// USE OR OTHER DEALINGS IN THE SOFTWARE.

// a duplex stream is just a stream that is both readable and writable.

// Since JS doesn't have multiple prototypal inheritance, this class
// prototypally inherits from Readable, and then parasitically from
// Writable.

[Link] = Duplex;

/*<replacement>*/
var objectKeys = [Link] || function (obj) {
var keys = [];
for (var key in obj) [Link](key);
return keys;
}
/*</replacement>*/

/*<replacement>*/
var util = require('core-util-is');
[Link] = require('inherits');
/*</replacement>*/

var Readable = require('./_stream_readable');

var Writable = require('./_stream_writable');

[Link](Duplex, Readable);

forEach(objectKeys([Link]), function(method) {
if (![Link][method])
[Link][method] = [Link][method];
});

function Duplex(options) {
if (!(this instanceof Duplex))
return new Duplex(options);

[Link](this, options);
[Link](this, options);

if (options && [Link] === false)

[Link] = false;

if (options && [Link] === false)

[Link] = false;

[Link] = true;
if (options && [Link] === false)
[Link] = false;
 [Link]('end', onend);
}

// the no-half-open enforcer

function onend() {
// if we allow half-open state, or if the writable side ended,
// then we're ok.
if ([Link] || this._writableState.ended)
return;

// no more data can be written.

// But allow more writes to happen in this tick.
[Link]([Link](this));
}

function forEach (xs, f) {

for (var i = 0, l = [Link]; i < l; i++) {
f(xs[i], i);
}
}

}).call(this,require('_process'))
},{"./_stream_readable":95,"./_stream_writable":97,"_process":91,"core-util-
is":98,"inherits":89}],94:[function(require,module,exports){
// Copyright Joyent, Inc. and other Node contributors.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to permit
// persons to whom the Software is furnished to do so, subject to the
// following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
// USE OR OTHER DEALINGS IN THE SOFTWARE.

// a passthrough stream.
// basically just the most minimal sort of Transform stream.
// Every written chunk gets output as-is.

[Link] = PassThrough;

var Transform = require('./_stream_transform');

/*<replacement>*/
var util = require('core-util-is');
[Link] = require('inherits');
/*</replacement>*/

[Link](PassThrough, Transform);
function PassThrough(options) {
if (!(this instanceof PassThrough))
return new PassThrough(options);

[Link](this, options);
}

[Link]._transform = function(chunk, encoding, cb) {

cb(null, chunk);
};

},{"./_stream_transform":96,"core-util-is":98,"inherits":89}],95:
[function(require,module,exports){
(function (process){
// Copyright Joyent, Inc. and other Node contributors.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to permit
// persons to whom the Software is furnished to do so, subject to the
// following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
// USE OR OTHER DEALINGS IN THE SOFTWARE.

[Link] = Readable;

/*<replacement>*/
var isArray = require('isarray');
/*</replacement>*/

/*<replacement>*/
var Buffer = require('buffer').Buffer;
/*</replacement>*/

[Link] = ReadableState;

var EE = require('events').EventEmitter;

/*<replacement>*/
if (![Link]) [Link] = function(emitter, type) {
return [Link](type).length;
};
/*</replacement>*/

var Stream = require('stream');

/*<replacement>*/
var util = require('core-util-is');
[Link] = require('inherits');
/*</replacement>*/

var StringDecoder;

/*<replacement>*/
var debug = require('util');
if (debug && [Link]) {
debug = [Link]('stream');
} else {
debug = function () {};
}
/*</replacement>*/

[Link](Readable, Stream);

function ReadableState(options, stream) {

var Duplex = require('./_stream_duplex');

options = options || {};

// the point at which it stops calling _read() to fill the buffer

// Note: 0 is a valid value, means "don't call _read preemptively ever"
var hwm = [Link];
var defaultHwm = [Link] ? 16 : 16 * 1024;
[Link] = (hwm || hwm === 0) ? hwm : defaultHwm;

// cast to ints.
[Link] = ~~[Link];

[Link] = [];
[Link] = 0;
[Link] = null;
[Link] = 0;
[Link] = null;
[Link] = false;
[Link] = false;
[Link] = false;

// a flag to be able to tell if the onwrite cb is called immediately,

// or on a later tick. We set this to true at first, because any
// actions that shouldn't happen until "later" should generally also
// not happen before the first write call.
[Link] = true;

// whenever we return null, then we set a flag to say

// that we're awaiting a 'readable' event emission.
[Link] = false;
[Link] = false;
[Link] = false;

// object stream flag. Used to make read(n) ignore n and to

// make all the buffer merging and length checks go away
[Link] = !![Link];
 if (stream instanceof Duplex)
[Link] = [Link] || !![Link];

// Crypto is kind of old and crusty. Historically, its default string

// encoding is 'binary' so we have to make this configurable.
// Everything else in the universe uses 'utf8', though.
[Link] = [Link] || 'utf8';

// when piping, we only care about 'readable' events that happen

// after read()ing all the bytes and not getting any pushback.
[Link] = false;

// the number of writers that are awaiting a drain event in .pipe()s

[Link] = 0;

// if true, a maybeReadMore has been scheduled

[Link] = false;

[Link] = null;
[Link] = null;
if ([Link]) {
if (!StringDecoder)
StringDecoder = require('string_decoder/').StringDecoder;
[Link] = new StringDecoder([Link]);
[Link] = [Link];
}
}

function Readable(options) {
var Duplex = require('./_stream_duplex');

if (!(this instanceof Readable))

return new Readable(options);

this._readableState = new ReadableState(options, this);

// legacy
[Link] = true;

[Link](this);
}

// Manually shove something into the read() buffer.

// This returns true if the highWaterMark has not been hit yet,
// similar to how [Link]() returns true if you should
// write() some more.
[Link] = function(chunk, encoding) {
var state = this._readableState;

if ([Link](chunk) && ![Link]) {

encoding = encoding || [Link];
if (encoding !== [Link]) {
chunk = new Buffer(chunk, encoding);
encoding = '';
}
}

return readableAddChunk(this, state, chunk, encoding, false);

};

// Unshift should *always* be something directly out of read()

[Link] = function(chunk) {
var state = this._readableState;
return readableAddChunk(this, state, chunk, '', true);
};

function readableAddChunk(stream, state, chunk, encoding, addToFront) {

var er = chunkInvalid(state, chunk);
if (er) {
[Link]('error', er);
} else if ([Link](chunk)) {
[Link] = false;
if (![Link])
onEofChunk(stream, state);
} else if ([Link] || chunk && [Link] > 0) {
if ([Link] && !addToFront) {
var e = new Error('[Link]() after EOF');
[Link]('error', e);
} else if ([Link] && addToFront) {
var e = new Error('[Link]() after end event');
[Link]('error', e);
} else {
if ([Link] && !addToFront && !encoding)
chunk = [Link](chunk);

if (!addToFront)
[Link] = false;

// if we want the data now, just emit it.

if ([Link] && [Link] === 0 && ![Link]) {
[Link]('data', chunk);
[Link](0);
} else {
// update the buffer info.
[Link] += [Link] ? 1 : [Link];
if (addToFront)
[Link](chunk);
else
[Link](chunk);

if ([Link])
emitReadable(stream);
}

maybeReadMore(stream, state);
}
} else if (!addToFront) {
[Link] = false;
}

return needMoreData(state);
}

// if it's past the high water mark, we can push in some more.
// Also, if we have no data yet, we can stand some
// more bytes. This is to work around cases where hwm=0,
// such as the repl. Also, if the push() triggered a
// readable event, and the user called read(largeNumber) such that
// needReadable was set, then we ought to push more, so that another
// 'readable' event will be triggered.
function needMoreData(state) {
return ![Link] &&
([Link] ||
[Link] < [Link] ||
[Link] === 0);
}

// backwards compatibility.
[Link] = function(enc) {
if (!StringDecoder)
StringDecoder = require('string_decoder/').StringDecoder;
this._readableState.decoder = new StringDecoder(enc);
this._readableState.encoding = enc;
return this;
};

// Don't raise the hwm > 128MB

var MAX_HWM = 0x800000;
function roundUpToNextPowerOf2(n) {
if (n >= MAX_HWM) {
n = MAX_HWM;
} else {
// Get the next highest power of 2
n--;
for (var p = 1; p < 32; p <<= 1) n |= n >> p;
n++;
}
return n;
}

function howMuchToRead(n, state) {

if ([Link] === 0 && [Link])
return 0;

if ([Link])
return n === 0 ? 0 : 1;

if (isNaN(n) || [Link](n)) {
// only flow one buffer at a time
if ([Link] && [Link])
return [Link][0].length;
else
return [Link];
}

if (n <= 0)
return 0;

// If we're asking for more than the target buffer level,

// then raise the water mark. Bump up to the next highest
// power of 2, to prevent increasing it excessively in tiny
// amounts.
if (n > [Link])
[Link] = roundUpToNextPowerOf2(n);
 // don't have that much. return null, unless we've ended.
if (n > [Link]) {
if (![Link]) {
[Link] = true;
return 0;
} else
return [Link];
}

return n;
}

// you can override either this method, or the async _read(n) below.
[Link] = function(n) {
debug('read', n);
var state = this._readableState;
var nOrig = n;

if ( || n > 0)
[Link] = false;

// if we're doing read(0) to trigger a readable event, but we

// already have a bunch of data in the buffer, then just trigger
// the 'readable' event and move on.
if (n === 0 &&
[Link] &&
([Link] >= [Link] || [Link])) {
debug('read: emitReadable', [Link], [Link]);
if ([Link] === 0 && [Link])
endReadable(this);
else
emitReadable(this);
return null;
}

n = howMuchToRead(n, state);

// if we've ended, and we're now clear, then finish it up.

if (n === 0 && [Link]) {
if ([Link] === 0)
endReadable(this);
return null;
}

// All the actual chunk generation logic needs to be

// *below* the call to _read. The reason is that in certain
// synthetic stream cases, such as passthrough streams, _read
// may be a completely synchronous operation which may change
// the state of the read buffer, providing enough data when
// before there was *not* enough.
//
// So, the steps are:
// 1. Figure out what the state of things will be after we do
// a read from the buffer.
//
// 2. If that resulting state will trigger a _read, then call _read.
// Note that this may be asynchronous, or synchronous. Yes, it is
// deeply ugly to write APIs this way, but that still doesn't mean
// that the Readable class should behave improperly, as streams are
// designed to be sync/async agnostic.
// Take note if the _read call is sync or async (ie, if the read call
// has returned yet), so that we know whether or not it's safe to emit
// 'readable' etc.
//
// 3. Actually pull the requested chunks out of the buffer and return.

// if we need a readable event, then we need to do some reading.

var doRead = [Link];
debug('need readable', doRead);

// if we currently have less than the highWaterMark, then also read some
if ([Link] === 0 || [Link] - n < [Link]) {
doRead = true;
debug('length less than watermark', doRead);
}

// however, if we've ended, then there's no point, and if we're already

// reading, then it's unnecessary.
if ([Link] || [Link]) {
doRead = false;
debug('reading or ended', doRead);
}

if (doRead) {
debug('do read');
[Link] = true;
[Link] = true;
// if the length is currently zero, then we *need* a readable event.
if ([Link] === 0)
[Link] = true;
// call internal read method
this._read([Link]);
[Link] = false;
}

// If _read pushed data synchronously, then `reading` will be false,

// and we need to re-evaluate how much data we can return to the user.
if (doRead && ![Link])
n = howMuchToRead(nOrig, state);

var ret;
if (n > 0)
ret = fromList(n, state);
else
ret = null;

if ([Link](ret)) {
[Link] = true;
n = 0;
}

[Link] -= n;

// If we have nothing in the buffer, then we want to know

// as soon as we *do* get something into the buffer.
if ([Link] === 0 && ![Link])
[Link] = true;
 // If we tried to read() past the EOF, then emit end on the next tick.
if (nOrig !== n && [Link] && [Link] === 0)
endReadable(this);

if ()
[Link]('data', ret);

return ret;
};

function chunkInvalid(state, chunk) {

var er = null;
if ( &&
 &&
 &&
![Link]) {
er = new TypeError('Invalid non-string/buffer chunk');
}
return er;
}

function onEofChunk(stream, state) {

if ([Link] && ![Link]) {
var chunk = [Link]();
if (chunk && [Link]) {
[Link](chunk);
[Link] += [Link] ? 1 : [Link];
}
}
[Link] = true;

// emit 'readable' now to make sure it gets picked up.

emitReadable(stream);
}

// Don't emit readable right away in sync mode, because this can trigger
// another read() call => stack overflow. This way, it might trigger
// a nextTick recursion warning, but that's not so bad.
function emitReadable(stream) {
var state = stream._readableState;
[Link] = false;
if (![Link]) {
debug('emitReadable', [Link]);
[Link] = true;
if ([Link])
[Link](function() {
emitReadable_(stream);
});
else
emitReadable_(stream);
}
}

function emitReadable_(stream) {
debug('emit readable');
[Link]('readable');
flow(stream);
}

// at this point, the user has presumably seen the 'readable' event,
// and called read() to consume some data. that may have triggered
// in turn another _read(n) call, in which case reading = true if
// it's in progress.
// However, if we're not ended, or reading, and the length < hwm,
// then go ahead and try to read some more preemptively.
function maybeReadMore(stream, state) {
if (![Link]) {
[Link] = true;
[Link](function() {
maybeReadMore_(stream, state);
});
}
}

function maybeReadMore_(stream, state) {

var len = [Link];
while (![Link] && ![Link] && ![Link] &&
[Link] < [Link]) {
debug('maybeReadMore read 0');
[Link](0);
if (len === [Link])
// didn't get any data, stop spinning.
break;
else
len = [Link];
}
[Link] = false;
}

// abstract method. to be overridden in specific implementation classes.

// call cb(er, data) where data is <= n in length.
// for virtual (non-string, non-buffer) streams, "length" is somewhat
// arbitrary, and perhaps not very meaningful.
[Link]._read = function(n) {
[Link]('error', new Error('not implemented'));
};

[Link] = function(dest, pipeOpts) {

var src = this;
var state = this._readableState;

switch ([Link]) {
case 0:
[Link] = dest;
break;
case 1:
[Link] = [[Link], dest];
break;
default:
[Link](dest);
break;
}
[Link] += 1;
debug('pipe count=%d opts=%j', [Link], pipeOpts);
var doEnd = (!pipeOpts || [Link] !== false) &&
dest !== [Link] &&
dest !== [Link];

var endFn = doEnd ? onend : cleanup;

if ([Link])
[Link](endFn);
else
[Link]('end', endFn);

[Link]('unpipe', onunpipe);
function onunpipe(readable) {
debug('onunpipe');
if (readable === src) {
cleanup();
}
}

function onend() {
debug('onend');
[Link]();
}

// when the dest drains, it reduces the awaitDrain counter

// on the source. This would be more elegant with a .once()
// handler in flow(), but adding and removing repeatedly is
// too slow.
var ondrain = pipeOnDrain(src);
[Link]('drain', ondrain);

function cleanup() {
debug('cleanup');
// cleanup event handlers once the pipe is broken
[Link]('close', onclose);
[Link]('finish', onfinish);
[Link]('drain', ondrain);
[Link]('error', onerror);
[Link]('unpipe', onunpipe);
[Link]('end', onend);
[Link]('end', cleanup);
[Link]('data', ondata);

// if the reader is waiting for a drain event from this

// specific writer, then it would cause it to never start
// flowing again.
// So, if this is awaiting a drain, then we just call it now.
// If we don't know, then assume that we are waiting for one.
if ([Link] &&
(!dest._writableState || dest._writableState.needDrain))
ondrain();
}

[Link]('data', ondata);
function ondata(chunk) {
debug('ondata');
var ret = [Link](chunk);
if (false === ret) {
debug('false write response, pause',
src._readableState.awaitDrain);
 src._readableState.awaitDrain++;
[Link]();
}
}

// if the dest has an error, then stop piping into it.

// however, don't suppress the throwing behavior for this.
function onerror(er) {
debug('onerror', er);
unpipe();
[Link]('error', onerror);
if ([Link](dest, 'error') === 0)
[Link]('error', er);
}
// This is a brutally ugly hack to make sure that our error handler
// is attached before any userland ones. NEVER DO THIS.
if (!dest._events || !dest._events.error)
[Link]('error', onerror);
else if (isArray(dest._events.error))
dest._events.[Link](onerror);
else
dest._events.error = [onerror, dest._events.error];

// Both close and finish should trigger unpipe, but only once.
function onclose() {
[Link]('finish', onfinish);
unpipe();
}
[Link]('close', onclose);
function onfinish() {
debug('onfinish');
[Link]('close', onclose);
unpipe();
}
[Link]('finish', onfinish);

function unpipe() {
debug('unpipe');
[Link](dest);
}

// tell the dest that it's being piped to

[Link]('pipe', src);

// start the flow if it hasn't been started already.

if (![Link]) {
debug('pipe resume');
[Link]();
}

return dest;
};

function pipeOnDrain(src) {
return function() {
var state = src._readableState;
debug('pipeOnDrain', [Link]);
 if ([Link])
[Link]--;
if ([Link] === 0 && [Link](src, 'data')) {
[Link] = true;
flow(src);
}
};
}

[Link] = function(dest) {
var state = this._readableState;

// if we're not piping anywhere, then do nothing.

if ([Link] === 0)
return this;

// just one destination. most common case.

if ([Link] === 1) {
// passed in one, but it's not the right one.
if (dest && dest !== [Link])
return this;

if (!dest)
dest = [Link];

// got a match.
[Link] = null;
[Link] = 0;
[Link] = false;
if (dest)
[Link]('unpipe', this);
return this;
}

// slow case. multiple pipe destinations.

if (!dest) {
// remove all.
var dests = [Link];
var len = [Link];
[Link] = null;
[Link] = 0;
[Link] = false;

for (var i = 0; i < len; i++)

dests[i].emit('unpipe', this);
return this;
}

// try to find the right one.

var i = indexOf([Link], dest);
if (i === -1)
return this;

[Link](i, 1);
[Link] -= 1;
if ([Link] === 1)
[Link] = [Link][0];
 [Link]('unpipe', this);

return this;
};

// set up data events if they are asked for

// Ensure readable listeners eventually get something
[Link] = function(ev, fn) {
var res = [Link](this, ev, fn);

// If listening to data, and it has not explicitly been paused,

// then call resume to start the flow of data on the next tick.
if (ev === 'data' && false !== this._readableState.flowing) {
[Link]();
}

if (ev === 'readable' && [Link]) {

var state = this._readableState;
if (![Link]) {
[Link] = true;
[Link] = false;
[Link] = true;
if (![Link]) {
var self = this;
[Link](function() {
debug('readable nexttick read 0');
[Link](0);
});
} else if ([Link]) {
emitReadable(this, state);
}
}
}

return res;
};
[Link] = [Link];

// pause() and resume() are remnants of the legacy readable stream API
// If the user uses them, then switch into old mode.
[Link] = function() {
var state = this._readableState;
if (![Link]) {
debug('resume');
[Link] = true;
if (![Link]) {
debug('resume read 0');
[Link](0);
}
resume(this, state);
}
return this;
};

function resume(stream, state) {

if (![Link]) {
[Link] = true;
[Link](function() {
 resume_(stream, state);
});
}
}

function resume_(stream, state) {

[Link] = false;
[Link]('resume');
flow(stream);
if ([Link] && ![Link])
[Link](0);
}

[Link] = function() {
debug('call pause flowing=%j', this._readableState.flowing);
if (false !== this._readableState.flowing) {
debug('pause');
this._readableState.flowing = false;
[Link]('pause');
}
return this;
};

function flow(stream) {
var state = stream._readableState;
debug('flow', [Link]);
if ([Link]) {
do {
var chunk = [Link]();
} while (null !== chunk && [Link]);
}
}

// wrap an old-style stream as the async data source.

// This is *not* part of the readable stream interface.
// It is an ugly unfortunate mess of history.
[Link] = function(stream) {
var state = this._readableState;
var paused = false;

var self = this;

[Link]('end', function() {
debug('wrapped end');
if ([Link] && ![Link]) {
var chunk = [Link]();
if (chunk && [Link])
[Link](chunk);
}

[Link](null);
});

[Link]('data', function(chunk) {
debug('wrapped data');
if ([Link])
chunk = [Link](chunk);
if (!chunk || ![Link] && ![Link])
return;
 var ret = [Link](chunk);
if (!ret) {
paused = true;
[Link]();
}
});

// proxy all the other methods.

// important when wrapping filters and duplexes.
for (var i in stream) {
if ([Link](stream[i]) && [Link](this[i])) {
this[i] = function(method) { return function() {
return stream[method].apply(stream, arguments);
}}(i);
}
}

// proxy certain important events.

var events = ['error', 'close', 'destroy', 'pause', 'resume'];
forEach(events, function(ev) {
[Link](ev, [Link](self, ev));
});

// when we try to consume some more bytes, simply unpause the

// underlying stream.
self._read = function(n) {
debug('wrapped _read', n);
if (paused) {
paused = false;
[Link]();
}
};

return self;
};

// exposed for testing purposes only.

Readable._fromList = fromList;

// Pluck off n bytes from an array of buffers.

// Length is the combined lengths of all the buffers in the list.
function fromList(n, state) {
var list = [Link];
var length = [Link];
var stringMode = !![Link];
var objectMode = !![Link];
var ret;

// nothing in the list, definitely empty.

if ([Link] === 0)
return null;

if (length === 0)
ret = null;
else if (objectMode)
ret = [Link]();
else if (!n || n >= length) {
 // read it all, truncate the array.
if (stringMode)
ret = [Link]('');
else
ret = [Link](list, length);
[Link] = 0;
} else {
// read just some of it.
if (n < list[0].length) {
// just take a part of the first list item.
// slice is the same for buffers and strings.
var buf = list[0];
ret = [Link](0, n);
list[0] = [Link](n);
} else if (n === list[0].length) {
// first list is a perfect match
ret = [Link]();
} else {
// complex case.
// we have enough to cover it, but it spans past the first buffer.
if (stringMode)
ret = '';
else
ret = new Buffer(n);

var c = 0;
for (var i = 0, l = [Link]; i < l && c < n; i++) {
var buf = list[0];
var cpy = [Link](n - c, [Link]);

if (stringMode)
ret += [Link](0, cpy);
else
[Link](ret, c, 0, cpy);

if (cpy < [Link])

list[0] = [Link](cpy);
else
[Link]();

c += cpy;
}
}
}

return ret;
}

function endReadable(stream) {
var state = stream._readableState;

// If we get here before consuming all the bytes, then that is a

// bug in node. Should never happen.
if ([Link] > 0)
throw new Error('endReadable called on non-empty stream');

if (![Link]) {
[Link] = true;
[Link](function() {
 // Check that we didn't get one last unshift.
if (![Link] && [Link] === 0) {
[Link] = true;
[Link] = false;
[Link]('end');
}
});
}
}

function forEach (xs, f) {

for (var i = 0, l = [Link]; i < l; i++) {
f(xs[i], i);
}
}

function indexOf (xs, x) {

for (var i = 0, l = [Link]; i < l; i++) {
if (xs[i] === x) return i;
}
return -1;
}

}).call(this,require('_process'))
},{"./_stream_duplex":93,"_process":91,"buffer":84,"core-util-
is":98,"events":88,"inherits":89,"isarray":90,"stream":103,"string_decoder/":104,"u
til":83}],96:[function(require,module,exports){
// Copyright Joyent, Inc. and other Node contributors.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to permit
// persons to whom the Software is furnished to do so, subject to the
// following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
// USE OR OTHER DEALINGS IN THE SOFTWARE.

// a transform stream is a readable/writable stream where you do

// something with the data. Sometimes it's called a "filter",
// but that's not a great name for it, since that implies a thing where
// some bits pass through, and others are simply ignored. (That would
// be a valid example of a transform, of course.)
//
// While the output is causally related to the input, it's not a
// necessarily symmetric or synchronous transformation. For example,
// a zlib stream might take multiple plain-text writes(), and then
// emit a single compressed chunk some time in the future.
//
// Here's how this works:
//
// The Transform stream has all the aspects of the readable and writable
// stream classes. When you write(chunk), that calls _write(chunk,cb)
// internally, and returns false if there's a lot of pending writes
// buffered up. When you call read(), that calls _read(n) until
// there's enough pending readable data buffered up.
//
// In a transform stream, the written data is placed in a buffer. When
// _read(n) is called, it transforms the queued up data, calling the
// buffered _write cb's as it consumes chunks. If consuming a single
// written chunk would result in multiple output chunks, then the first
// outputted bit calls the readcb, and subsequent chunks just go into
// the read buffer, and will cause it to emit 'readable' if necessary.
//
// This way, back-pressure is actually determined by the reading side,
// since _read has to be called to start processing a new chunk. However,
// a pathological inflate type of transform can cause excessive buffering
// here. For example, imagine a stream where every byte of input is
// interpreted as an integer from 0-255, and then results in that many
// bytes of output. Writing the 4 bytes {ff,ff,ff,ff} would result in
// 1kb of data being output. In this case, you could write a very small
// amount of input, and end up with a very large amount of output. In
// such a pathological inflating mechanism, there'd be no way to tell
// the system to stop doing the transform. A single 4MB write could
// cause the system to run out of memory.
//
// However, even in such a pathological case, only a single written chunk
// would be consumed, and then the rest would wait (un-transformed) until
// the results of the previous transformed chunk were consumed.

[Link] = Transform;

var Duplex = require('./_stream_duplex');

/*<replacement>*/
var util = require('core-util-is');
[Link] = require('inherits');
/*</replacement>*/

[Link](Transform, Duplex);

function TransformState(options, stream) {

[Link] = function(er, data) {
return afterTransform(stream, er, data);
};

[Link] = false;
[Link] = false;
[Link] = null;
[Link] = null;
}

function afterTransform(stream, er, data) {

var ts = stream._transformState;
[Link] = false;
 var cb = [Link];

if (!cb)
return [Link]('error', new Error('no writecb in Transform class'));

[Link] = null;
[Link] = null;

if ()
[Link](data);

if (cb)
cb(er);

var rs = stream._readableState;
[Link] = false;
if ([Link] || [Link] < [Link]) {
stream._read([Link]);
}
}

function Transform(options) {
if (!(this instanceof Transform))
return new Transform(options);

[Link](this, options);

this._transformState = new TransformState(options, this);

// when the writable side finishes, then flush out anything remaining.
var stream = this;

// start out asking for a readable event once data is transformed.

this._readableState.needReadable = true;

// we have implemented the _read method, and done the other things
// that Readable wants before the first _read call, so unset the
// sync guard flag.
this._readableState.sync = false;

[Link]('prefinish', function() {
if ([Link](this._flush))
this._flush(function(er) {
done(stream, er);
});
else
done(stream);
});
}

[Link] = function(chunk, encoding) {

this._transformState.needTransform = false;
return [Link](this, chunk, encoding);
};

// This is the part where you do stuff!

// override this function in implementation classes.
// 'chunk' is an input chunk.
//
// Call `push(newChunk)` to pass along transformed output
// to the readable side. You may call 'push' zero or more times.
//
// Call `cb(err)` when you are done with this chunk. If you pass
// an error, then that'll put the hurt on the whole operation. If you
// never call cb(), then you'll never get another chunk.
[Link]._transform = function(chunk, encoding, cb) {
throw new Error('not implemented');
};

[Link]._write = function(chunk, encoding, cb) {

var ts = this._transformState;
[Link] = cb;
[Link] = chunk;
[Link] = encoding;
if (![Link]) {
var rs = this._readableState;
if ([Link] ||
[Link] ||
[Link] < [Link])
this._read([Link]);
}
};

// Doesn't matter what the args are here.

// _transform does all the work.
// That we got here means that the readable side wants more data.
[Link]._read = function(n) {
var ts = this._transformState;

if ( && [Link] && ![Link]) {

[Link] = true;
this._transform([Link], [Link], [Link]);
} else {
// mark that we need a transform, so that any data that comes in
// will get processed, now that we've asked for it.
[Link] = true;
}
};

function done(stream, er) {

if (er)
return [Link]('error', er);

// if there's nothing in the write buffer, then that means

// that nothing more will ever be provided
var ws = stream._writableState;
var ts = stream._transformState;

if ([Link])
throw new Error('calling transform done when [Link] != 0');

if ([Link])
throw new Error('calling transform done when still transforming');

return [Link](null);
}
},{"./_stream_duplex":93,"core-util-is":98,"inherits":89}],97:
[function(require,module,exports){
(function (process){
// Copyright Joyent, Inc. and other Node contributors.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to permit
// persons to whom the Software is furnished to do so, subject to the
// following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
// USE OR OTHER DEALINGS IN THE SOFTWARE.

// A bit simpler than readable streams.

// Implement an async ._write(chunk, cb), and it'll handle all
// the drain event emission and buffering.

[Link] = Writable;

/*<replacement>*/
var Buffer = require('buffer').Buffer;
/*</replacement>*/

[Link] = WritableState;

/*<replacement>*/
var util = require('core-util-is');
[Link] = require('inherits');
/*</replacement>*/

var Stream = require('stream');

[Link](Writable, Stream);

function WriteReq(chunk, encoding, cb) {

[Link] = chunk;
[Link] = encoding;
[Link] = cb;
}

function WritableState(options, stream) {

var Duplex = require('./_stream_duplex');

options = options || {};

// the point at which write() starts returning false

// Note: 0 is a valid value, means that we always return false if
// the entire buffer is not flushed immediately on write()
var hwm = [Link];
var defaultHwm = [Link] ? 16 : 16 * 1024;
[Link] = (hwm || hwm === 0) ? hwm : defaultHwm;

// object stream flag to indicate whether or not this stream

// contains buffers or objects.
[Link] = !![Link];

if (stream instanceof Duplex)

[Link] = [Link] || !![Link];

// cast to ints.
[Link] = ~~[Link];

[Link] = false;
// at the start of calling end()
[Link] = false;
// when end() has been called, and returned
[Link] = false;
// when 'finish' is emitted
[Link] = false;

// should we decode strings into buffers before passing to _write?

// this is here so that some node-core streams can optimize string
// handling at a lower level.
var noDecode = [Link] === false;
[Link] = !noDecode;

// Crypto is kind of old and crusty. Historically, its default string

// encoding is 'binary' so we have to make this configurable.
// Everything else in the universe uses 'utf8', though.
[Link] = [Link] || 'utf8';

// not an actual buffer we keep track of, but a measurement

// of how much we're waiting to get pushed to some underlying
// socket or file.
[Link] = 0;

// a flag to see when we're in the middle of a write.

[Link] = false;

// when true all writes will be buffered until .uncork() call

[Link] = 0;

// a flag to be able to tell if the onwrite cb is called immediately,

// or on a later tick. We set this to true at first, because any
// actions that shouldn't happen until "later" should generally also
// not happen before the first write call.
[Link] = true;

// a flag to know if we're processing previously buffered items, which

// may call the _write() callback in the same tick, so that we don't
// end up in an overlapped onwrite situation.
[Link] = false;

// the callback that's passed to _write(chunk,cb)

[Link] = function(er) {
 onwrite(stream, er);
};

// the callback that the user supplies to write(chunk,encoding,cb)

[Link] = null;

// the amount that is being written when _write is called.

[Link] = 0;

[Link] = [];

// number of pending user-supplied write callbacks

// this must be 0 before 'finish' can be emitted
[Link] = 0;

// emit prefinish if the only thing we're waiting for is _write cbs
// This is relevant for synchronous Transform streams
[Link] = false;

// True if the error was already emitted and should not be thrown again
[Link] = false;
}

function Writable(options) {
var Duplex = require('./_stream_duplex');

// Writable ctor is applied to Duplexes, though they're not

// instanceof Writable, they're instanceof Readable.
if (!(this instanceof Writable) && !(this instanceof Duplex))
return new Writable(options);

this._writableState = new WritableState(options, this);

// legacy.
[Link] = true;

[Link](this);
}

// Otherwise people can pipe Writable streams, which is just wrong.

[Link] = function() {
[Link]('error', new Error('Cannot pipe. Not readable.'));
};

function writeAfterEnd(stream, state, cb) {

var er = new Error('write after end');
// TODO: defer error events consistently everywhere, not just the cb
[Link]('error', er);
[Link](function() {
cb(er);
});
}

// If we get something that is not a buffer, string, null, or undefined,

// and we're not in objectMode, then that's an error.
// Otherwise stream chunks are all considered to be of length=1, and the
// watermarks determine how many objects to keep in the buffer, rather than
// how many bytes or characters.
function validChunk(stream, state, chunk, cb) {
var valid = true;
if ( &&
 &&
 &&
![Link]) {
var er = new TypeError('Invalid non-string/buffer chunk');
[Link]('error', er);
[Link](function() {
cb(er);
});
valid = false;
}
return valid;
}

[Link] = function(chunk, encoding, cb) {

var state = this._writableState;
var ret = false;

if ([Link](encoding)) {
cb = encoding;
encoding = null;
}

if ([Link](chunk))
encoding = 'buffer';
else if (!encoding)
encoding = [Link];

if ()
cb = function() {};

if ([Link])
writeAfterEnd(this, state, cb);
else if (validChunk(this, state, chunk, cb)) {
[Link]++;
ret = writeOrBuffer(this, state, chunk, encoding, cb);
}

return ret;
};

[Link] = function() {
var state = this._writableState;

[Link]++;
};

[Link] = function() {
var state = this._writableState;

if ([Link]) {
[Link]--;

if (![Link] &&
![Link] &&
![Link] &&
![Link] &&
 [Link])
clearBuffer(this, state);
}
};

function decodeChunk(state, chunk, encoding) {

if (![Link] &&
[Link] !== false &&
[Link](chunk)) {
chunk = new Buffer(chunk, encoding);
}
return chunk;
}

// if we're already writing something, then just put this

// in the queue, and wait our turn. Otherwise, call _write
// If we return false, then we need a drain event, so set that flag.
function writeOrBuffer(stream, state, chunk, encoding, cb) {
chunk = decodeChunk(state, chunk, encoding);
if ([Link](chunk))
encoding = 'buffer';
var len = [Link] ? 1 : [Link];

[Link] += len;

var ret = [Link] < [Link];

// we must ensure that previous needDrain will not be reset to false.
if (!ret)
[Link] = true;

if ([Link] || [Link])
[Link](new WriteReq(chunk, encoding, cb));
else
doWrite(stream, state, false, len, chunk, encoding, cb);

return ret;
}

function doWrite(stream, state, writev, len, chunk, encoding, cb) {

[Link] = len;
[Link] = cb;
[Link] = true;
[Link] = true;
if (writev)
stream._writev(chunk, [Link]);
else
stream._write(chunk, encoding, [Link]);
[Link] = false;
}

function onwriteError(stream, state, sync, er, cb) {

if (sync)
[Link](function() {
[Link]--;
cb(er);
});
else {
[Link]--;
cb(er);
 }

stream._writableState.errorEmitted = true;
[Link]('error', er);
}

function onwriteStateUpdate(state) {
[Link] = false;
[Link] = null;
[Link] -= [Link];
[Link] = 0;
}

function onwrite(stream, er) {

var state = stream._writableState;
var sync = [Link];
var cb = [Link];

onwriteStateUpdate(state);

if (er)
onwriteError(stream, state, sync, er, cb);
else {
// Check if we're actually ready to finish, but don't emit yet
var finished = needFinish(stream, state);

if (!finished &&
![Link] &&
![Link] &&
[Link]) {
clearBuffer(stream, state);
}

if (sync) {
[Link](function() {
afterWrite(stream, state, finished, cb);
});
} else {
afterWrite(stream, state, finished, cb);
}
}
}

function afterWrite(stream, state, finished, cb) {

if (!finished)
onwriteDrain(stream, state);
[Link]--;
cb();
finishMaybe(stream, state);
}

// Must force callback to be called on nextTick, so that we don't

// emit 'drain' before the write() consumer gets the 'false' return
// value, and has a chance to attach a 'drain' listener.
function onwriteDrain(stream, state) {
if ([Link] === 0 && [Link]) {
[Link] = false;
[Link]('drain');
}
}

// if there's something in the buffer waiting, then process it

function clearBuffer(stream, state) {
[Link] = true;

if (stream._writev && [Link] > 1) {

// Fast case, write everything using _writev()
var cbs = [];
for (var c = 0; c < [Link]; c++)
[Link]([Link][c].callback);

// count the one we are adding, as well.

// TODO(isaacs) clean this up
[Link]++;
doWrite(stream, state, true, [Link], [Link], '', function(err) {
for (var i = 0; i < [Link]; i++) {
[Link]--;
cbs[i](err);
}
});

// Clear buffer
[Link] = [];
} else {
// Slow case, write chunks one-by-one
for (var c = 0; c < [Link]; c++) {
var entry = [Link][c];
var chunk = [Link];
var encoding = [Link];
var cb = [Link];
var len = [Link] ? 1 : [Link];

doWrite(stream, state, false, len, chunk, encoding, cb);

// if we didn't call the onwrite immediately, then

// it means that we need to wait until it does.
// also, that means that the chunk and cb are currently
// being processed, so move the buffer counter past them.
if ([Link]) {
c++;
break;
}
}

if (c < [Link])
[Link] = [Link](c);
else
[Link] = 0;
}

[Link] = false;
}

[Link]._write = function(chunk, encoding, cb) {

cb(new Error('not implemented'));

};
[Link]._writev = null;

[Link] = function(chunk, encoding, cb) {

var state = this._writableState;

if ([Link](chunk)) {
cb = chunk;
chunk = null;
encoding = null;
} else if ([Link](encoding)) {
cb = encoding;
encoding = null;
}

if ()
[Link](chunk, encoding);

// .end() fully uncorks

if ([Link]) {
[Link] = 1;
[Link]();
}

// ignore unnecessary end() calls.

if (![Link] && ![Link])
endWritable(this, state, cb);
};

function needFinish(stream, state) {

return ([Link] &&
[Link] === 0 &&
![Link] &&
![Link]);
}

function prefinish(stream, state) {

if (![Link]) {
[Link] = true;
[Link]('prefinish');
}
}

function finishMaybe(stream, state) {

var need = needFinish(stream, state);
if (need) {
if ([Link] === 0) {
prefinish(stream, state);
[Link] = true;
[Link]('finish');
} else
prefinish(stream, state);
}
return need;
}

function endWritable(stream, state, cb) {

[Link] = true;
 finishMaybe(stream, state);
if (cb) {
if ([Link])
[Link](cb);
else
[Link]('finish', cb);
}
[Link] = true;
}

}).call(this,require('_process'))
},{"./_stream_duplex":93,"_process":91,"buffer":84,"core-util-
is":98,"inherits":89,"stream":103}],98:[function(require,module,exports){
(function (Buffer){
// Copyright Joyent, Inc. and other Node contributors.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to permit
// persons to whom the Software is furnished to do so, subject to the
// following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
// USE OR OTHER DEALINGS IN THE SOFTWARE.

// NOTE: These type checking functions intentionally don't use `instanceof`

// because it is fragile and can be easily faked with `[Link]()`.
function isArray(ar) {
return [Link](ar);
}
[Link] = isArray;

function isBoolean(arg) {
return typeof arg === 'boolean';
}
[Link] = isBoolean;

function isNull(arg) {
return arg === null;
}
[Link] = isNull;

function isNullOrUndefined(arg) {
return arg == null;
}
[Link] = isNullOrUndefined;

function isNumber(arg) {
return typeof arg === 'number';
}
[Link] = isNumber;

function isString(arg) {
return typeof arg === 'string';
}
[Link] = isString;

function isSymbol(arg) {
return typeof arg === 'symbol';
}
[Link] = isSymbol;

function isUndefined(arg) {
return arg === void 0;
}
[Link] = isUndefined;

function isRegExp(re) {
return isObject(re) && objectToString(re) === '[object RegExp]';
}
[Link] = isRegExp;

function isObject(arg) {
return typeof arg === 'object' && arg !== null;
}
[Link] = isObject;

function isDate(d) {
return isObject(d) && objectToString(d) === '[object Date]';
}
[Link] = isDate;

function isError(e) {
return isObject(e) &&
(objectToString(e) === '[object Error]' || e instanceof Error);
}
[Link] = isError;

function isFunction(arg) {
return typeof arg === 'function';
}
[Link] = isFunction;

function isPrimitive(arg) {
return arg === null ||
typeof arg === 'boolean' ||
typeof arg === 'number' ||
typeof arg === 'string' ||
typeof arg === 'symbol' || // ES6 symbol
typeof arg === 'undefined';
}
[Link] = isPrimitive;

function isBuffer(arg) {
return [Link](arg);
}
[Link] = isBuffer;
function objectToString(o) {
return [Link](o);
}
}).call(this,require("buffer").Buffer)
},{"buffer":84}],99:[function(require,module,exports){
[Link] = require("./lib/_stream_passthrough.js")

},{"./lib/_stream_passthrough.js":94}],100:[function(require,module,exports){
exports = [Link] = require('./lib/_stream_readable.js');
[Link] = require('stream');
[Link] = exports;
[Link] = require('./lib/_stream_writable.js');
[Link] = require('./lib/_stream_duplex.js');
[Link] = require('./lib/_stream_transform.js');
[Link] = require('./lib/_stream_passthrough.js');

},{"./lib/_stream_duplex.js":93,"./lib/_stream_passthrough.js":94,"./lib/
_stream_readable.js":95,"./lib/_stream_transform.js":96,"./lib/
_stream_writable.js":97,"stream":103}],101:[function(require,module,exports){
[Link] = require("./lib/_stream_transform.js")

},{"./lib/_stream_transform.js":96}],102:[function(require,module,exports){
[Link] = require("./lib/_stream_writable.js")

},{"./lib/_stream_writable.js":97}],103:[function(require,module,exports){
// Copyright Joyent, Inc. and other Node contributors.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to permit
// persons to whom the Software is furnished to do so, subject to the
// following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
// USE OR OTHER DEALINGS IN THE SOFTWARE.

[Link] = Stream;

var EE = require('events').EventEmitter;
var inherits = require('inherits');

inherits(Stream, EE);
[Link] = require('readable-stream/[Link]');
[Link] = require('readable-stream/[Link]');
[Link] = require('readable-stream/[Link]');
[Link] = require('readable-stream/[Link]');
[Link] = require('readable-stream/[Link]');

// Backwards-compat with node 0.4.x

[Link] = Stream;

// old-style streams. Note that the pipe method (the only relevant
// part of this class) is overridden in the Readable class.

function Stream() {
[Link](this);
}

[Link] = function(dest, options) {

var source = this;

function ondata(chunk) {
if ([Link]) {
if (false === [Link](chunk) && [Link]) {
[Link]();
}
}
}

[Link]('data', ondata);

function ondrain() {
if ([Link] && [Link]) {
[Link]();
}
}

[Link]('drain', ondrain);

// If the 'end' option is not supplied, [Link]() will be called when

// source gets the 'end' or 'close' events. Only [Link]() once.
if (!dest._isStdio && (!options || [Link] !== false)) {
[Link]('end', onend);
[Link]('close', onclose);
}

var didOnEnd = false;

function onend() {
if (didOnEnd) return;
didOnEnd = true;

[Link]();
}

function onclose() {
if (didOnEnd) return;
didOnEnd = true;

if (typeof [Link] === 'function') [Link]();

}

// don't leave dangling pipes when there are errors.

function onerror(er) {
cleanup();
if ([Link](this, 'error') === 0) {
 throw er; // Unhandled stream error in pipe.
}
}

[Link]('error', onerror);
[Link]('error', onerror);

// remove all the event listeners that were added.

function cleanup() {
[Link]('data', ondata);
[Link]('drain', ondrain);

[Link]('end', onend);
[Link]('close', onclose);

[Link]('error', onerror);
[Link]('error', onerror);

[Link]('end', cleanup);
[Link]('close', cleanup);

[Link]('close', cleanup);
}

[Link]('end', cleanup);
[Link]('close', cleanup);

[Link]('close', cleanup);

[Link]('pipe', source);

// Allow for unix-like usage: [Link](B).pipe(C)

return dest;
};

},{"events":88,"inherits":89,"readable-stream/[Link]":92,"readable-stream/
[Link]":99,"readable-stream/[Link]":100,"readable-stream/
[Link]":101,"readable-stream/[Link]":102}],104:
[function(require,module,exports){
// Copyright Joyent, Inc. and other Node contributors.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to permit
// persons to whom the Software is furnished to do so, subject to the
// following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
// USE OR OTHER DEALINGS IN THE SOFTWARE.
var Buffer = require('buffer').Buffer;

var isBufferEncoding = [Link]

|| function(encoding) {
switch (encoding && [Link]()) {
case 'hex': case 'utf8': case 'utf-8': case 'ascii': case 'binary': case
'base64': case 'ucs2': case 'ucs-2': case 'utf16le': case 'utf-16le': case 'raw':
return true;
default: return false;
}
}

function assertEncoding(encoding) {
if (encoding && !isBufferEncoding(encoding)) {
throw new Error('Unknown encoding: ' + encoding);
}
}

// StringDecoder provides an interface for efficiently splitting a series of

// buffers into a series of JS strings without breaking apart multi-byte
// characters. CESU-8 is handled as part of the UTF-8 encoding.
//
// @TODO Handling all encodings inside a single object makes it very difficult
// to reason about this code, so it should be split up in the future.
// @TODO There should be a utf8-strict encoding that rejects invalid UTF-8 code
// points as used by CESU-8.
var StringDecoder = [Link] = function(encoding) {
[Link] = (encoding || 'utf8').toLowerCase().replace(/[-_]/, '');
assertEncoding(encoding);
switch ([Link]) {
case 'utf8':
// CESU-8 represents each of Surrogate Pair by 3-bytes
[Link] = 3;
break;
case 'ucs2':
case 'utf16le':
// UTF-16 represents each of Surrogate Pair by 2-bytes
[Link] = 2;
[Link] = utf16DetectIncompleteChar;
break;
case 'base64':
// Base-64 stores 3 bytes in 4 chars, and pads the remainder.
[Link] = 3;
[Link] = base64DetectIncompleteChar;
break;
default:
[Link] = passThroughWrite;
return;
}

// Enough space to store all bytes of a single character. UTF-8 needs 4

// bytes, but CESU-8 may require up to 6 (3 bytes per surrogate).
[Link] = new Buffer(6);
// Number of bytes received for the current incomplete multi-byte character.
[Link] = 0;
// Number of bytes expected for the current incomplete multi-byte character.
[Link] = 0;
};

// write decodes the given buffer and returns it as JS string that is

// guaranteed to not contain any partial multi-byte characters. Any partial
// character found at the end of the buffer is buffered up, and will be
// returned when calling write again with the remaining bytes.
//
// Note: Converting a Buffer containing an orphan surrogate to a String
// currently works, but converting a String to a Buffer (via `new Buffer`, or
// Buffer#write) will replace incomplete surrogates with the unicode
// replacement character. See [Link] .
[Link] = function(buffer) {
var charStr = '';
// if our last write ended with an incomplete multibyte character
while ([Link]) {
// determine how many remaining bytes this buffer has to offer for this char
var available = ([Link] >= [Link] - [Link]) ?
[Link] - [Link] :
[Link];

// add the new bytes to the char buffer

[Link]([Link], [Link], 0, available);
[Link] += available;

if ([Link] < [Link]) {

// still not enough chars in this buffer? wait for more ...
return '';
}

// remove bytes belonging to the current character from the buffer

buffer = [Link](available, [Link]);

// get the character that was split

charStr = [Link](0, [Link]).toString([Link]);

// CESU-8: lead surrogate (D800-DBFF) is also the incomplete character

var charCode = [Link]([Link] - 1);
if (charCode >= 0xD800 && charCode <= 0xDBFF) {
[Link] += [Link];
charStr = '';
continue;
}
[Link] = [Link] = 0;

// if there are no more bytes in this buffer, just emit our char
if ([Link] === 0) {
return charStr;
}
break;
}

// determine and set charLength / charReceived

[Link](buffer);

var end = [Link];

if ([Link]) {
// buffer the incomplete character bytes we got
[Link]([Link], 0, [Link] - [Link], end);
 end -= [Link];
}

charStr += [Link]([Link], 0, end);

var end = [Link] - 1;

var charCode = [Link](end);
// CESU-8: lead surrogate (D800-DBFF) is also the incomplete character
if (charCode >= 0xD800 && charCode <= 0xDBFF) {
var size = [Link];
[Link] += size;
[Link] += size;
[Link]([Link], size, 0, size);
[Link]([Link], 0, 0, size);
return [Link](0, end);
}

// or just emit the charStr

return charStr;
};

// detectIncompleteChar determines if there is an incomplete UTF-8 character at

// the end of the given buffer. If so, it sets [Link] to the byte
// length that character, and sets [Link] to the number of bytes
// that are available for this character.
[Link] = function(buffer) {
// determine how many bytes we have to check at the end of this buffer
var i = ([Link] >= 3) ? 3 : [Link];

// Figure out if one of the last i bytes of our buffer announces an

// incomplete char.
for (; i > 0; i--) {
var c = buffer[[Link] - i];

// See [Link]

// 110XXXXX
if (i == 1 && c >> 5 == 0x06) {
[Link] = 2;
break;
}

// 1110XXXX
if (i <= 2 && c >> 4 == 0x0E) {
[Link] = 3;
break;
}

// 11110XXX
if (i <= 3 && c >> 3 == 0x1E) {
[Link] = 4;
break;
}
}
[Link] = i;
};

[Link] = function(buffer) {
var res = '';
 if (buffer && [Link])
res = [Link](buffer);

if ([Link]) {
var cr = [Link];
var buf = [Link];
var enc = [Link];
res += [Link](0, cr).toString(enc);
}

return res;
};

function passThroughWrite(buffer) {
return [Link]([Link]);
}

function utf16DetectIncompleteChar(buffer) {
[Link] = [Link] % 2;
[Link] = [Link] ? 2 : 0;
}

function base64DetectIncompleteChar(buffer) {
[Link] = [Link] % 3;
[Link] = [Link] ? 3 : 0;
}

},{"buffer":84}],105:[function(require,module,exports){
[Link] = function isBuffer(arg) {
return arg && typeof arg === 'object'
&& typeof [Link] === 'function'
&& typeof [Link] === 'function'
&& typeof arg.readUInt8 === 'function';
}
},{}],106:[function(require,module,exports){
(function (process,global){
// Copyright Joyent, Inc. and other Node contributors.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to permit
// persons to whom the Software is furnished to do so, subject to the
// following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
// USE OR OTHER DEALINGS IN THE SOFTWARE.

var formatRegExp = /%[sdj%]/g;

[Link] = function(f) {
 if (!isString(f)) {
var objects = [];
for (var i = 0; i < [Link]; i++) {
[Link](inspect(arguments[i]));
}
return [Link](' ');
}

var i = 1;
var args = arguments;
var len = [Link];
var str = String(f).replace(formatRegExp, function(x) {
if (x === '%%') return '%';
if (i >= len) return x;
switch (x) {
case '%s': return String(args[i++]);
case '%d': return Number(args[i++]);
case '%j':
try {
return [Link](args[i++]);
} catch (_) {
return '[Circular]';
}
default:
return x;
}
});
for (var x = args[i]; i < len; x = args[++i]) {
if (isNull(x) || !isObject(x)) {
str += ' ' + x;
} else {
str += ' ' + inspect(x);
}
}
return str;
};

// Mark that a method should not be used.

// Returns a modified function which warns once by default.
// If --no-deprecation is set, then it is a no-op.
[Link] = function(fn, msg) {
// Allow for deprecating things in the process of starting up.
if (isUndefined([Link])) {
return function() {
return [Link](fn, msg).apply(this, arguments);
};
}

if ([Link] === true) {

return fn;
}

var warned = false;

function deprecated() {
if (!warned) {
if ([Link]) {
throw new Error(msg);
} else if ([Link]) {
 [Link](msg);
} else {
[Link](msg);
}
warned = true;
}
return [Link](this, arguments);
}

return deprecated;
};

var debugs = {};

var debugEnviron;
[Link] = function(set) {
if (isUndefined(debugEnviron))
debugEnviron = [Link].NODE_DEBUG || '';
set = [Link]();
if (!debugs[set]) {
if (new RegExp('\\b' + set + '\\b', 'i').test(debugEnviron)) {
var pid = [Link];
debugs[set] = function() {
var msg = [Link](exports, arguments);
[Link]('%s %d: %s', set, pid, msg);
};
} else {
debugs[set] = function() {};
}
}
return debugs[set];
};

/**
* Echos the value of a value. Trys to print the value out
* in the best way possible given the different types.
*
* @param {Object} obj The object to print out.
* @param {Object} opts Optional options object that alters the output.
*/
/* legacy: obj, showHidden, depth, colors*/
function inspect(obj, opts) {
// default options
var ctx = {
seen: [],
stylize: stylizeNoColor
};
// legacy...
if ([Link] >= 3) [Link] = arguments[2];
if ([Link] >= 4) [Link] = arguments[3];
if (isBoolean(opts)) {
// legacy...
[Link] = opts;
} else if (opts) {
// got an "options" object
exports._extend(ctx, opts);
}
// set default options
 if (isUndefined([Link])) [Link] = false;
if (isUndefined([Link])) [Link] = 2;
if (isUndefined([Link])) [Link] = false;
if (isUndefined([Link])) [Link] = true;
if ([Link]) [Link] = stylizeWithColor;
return formatValue(ctx, obj, [Link]);
}
[Link] = inspect;

// [Link]
[Link] = {
'bold' : [1, 22],
'italic' : [3, 23],
'underline' : [4, 24],
'inverse' : [7, 27],
'white' : [37, 39],
'grey' : [90, 39],
'black' : [30, 39],
'blue' : [34, 39],
'cyan' : [36, 39],
'green' : [32, 39],
'magenta' : [35, 39],
'red' : [31, 39],
'yellow' : [33, 39]
};

// Don't use 'blue' not visible on [Link]

[Link] = {
'special': 'cyan',
'number': 'yellow',
'boolean': 'yellow',
'undefined': 'grey',
'null': 'bold',
'string': 'green',
'date': 'magenta',
// "name": intentionally not styling
'regexp': 'red'
};

function stylizeWithColor(str, styleType) {

var style = [Link][styleType];

if (style) {
return '\u001b[' + [Link][style][0] + 'm' + str +
'\u001b[' + [Link][style][1] + 'm';
} else {
return str;
}
}

function stylizeNoColor(str, styleType) {

return str;
}

function arrayToHash(array) {
 var hash = {};

[Link](function(val, idx) {
hash[val] = true;
});

return hash;
}

function formatValue(ctx, value, recurseTimes) {

// Provide a hook for user-specified inspect functions.
// Check that value is an object with an inspect function on it
if ([Link] &&
value &&
isFunction([Link]) &&
// Filter out the util module, it's inspect function is special
[Link] !== [Link] &&
// Also filter out any prototype objects using the circular check.
!([Link] && [Link] === value)) {
var ret = [Link](recurseTimes, ctx);
if (!isString(ret)) {
ret = formatValue(ctx, ret, recurseTimes);
}
return ret;
}

// Primitive types cannot have properties

var primitive = formatPrimitive(ctx, value);
if (primitive) {
return primitive;
}

// Look up the keys of the object.

var keys = [Link](value);
var visibleKeys = arrayToHash(keys);

if ([Link]) {
keys = [Link](value);
}

// IE doesn't make error fields non-enumerable

// [Link]
if (isError(value)
&& ([Link]('message') >= 0 || [Link]('description') >= 0)) {
return formatError(value);
}

// Some type of object without properties can be shortcutted.

if ([Link] === 0) {
if (isFunction(value)) {
var name = [Link] ? ': ' + [Link] : '';
return [Link]('[Function' + name + ']', 'special');
}
if (isRegExp(value)) {
return [Link]([Link](value), 'regexp');
}
if (isDate(value)) {
return [Link]([Link](value), 'date');
 }
if (isError(value)) {
return formatError(value);
}
}

var base = '', array = false, braces = ['{', '}'];

// Make Array say that they are Array

if (isArray(value)) {
array = true;
braces = ['[', ']'];
}

// Make functions say that they are functions

if (isFunction(value)) {
var n = [Link] ? ': ' + [Link] : '';
base = ' [Function' + n + ']';
}

// Make RegExps say that they are RegExps

if (isRegExp(value)) {
base = ' ' + [Link](value);
}

// Make dates with properties first say the date

if (isDate(value)) {
base = ' ' + [Link](value);
}

// Make error with message first say the error

if (isError(value)) {
base = ' ' + formatError(value);
}

if ([Link] === 0 && (!array || [Link] == 0)) {

return braces[0] + base + braces[1];
}

if (recurseTimes < 0) {
if (isRegExp(value)) {
return [Link]([Link](value), 'regexp');
} else {
return [Link]('[Object]', 'special');
}
}

[Link](value);

var output;
if (array) {
output = formatArray(ctx, value, recurseTimes, visibleKeys, keys);
} else {
output = [Link](function(key) {
return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array);
});
}

[Link]();
 return reduceToSingleString(output, base, braces);
}

function formatPrimitive(ctx, value) {

if (isUndefined(value))
return [Link]('undefined', 'undefined');
if (isString(value)) {
var simple = '\'' + [Link](value).replace(/^"|"$/g, '')
.replace(/'/g, "\\'")
.replace(/\\"/g, '"') + '\'';
return [Link](simple, 'string');
}
if (isNumber(value))
return [Link]('' + value, 'number');
if (isBoolean(value))
return [Link]('' + value, 'boolean');
// For some reason typeof null is "object", so special case here.
if (isNull(value))
return [Link]('null', 'null');
}

function formatError(value) {
return '[' + [Link](value) + ']';
}

function formatArray(ctx, value, recurseTimes, visibleKeys, keys) {

var output = [];
for (var i = 0, l = [Link]; i < l; ++i) {
if (hasOwnProperty(value, String(i))) {
[Link](formatProperty(ctx, value, recurseTimes, visibleKeys,
String(i), true));
} else {
[Link]('');
}
}
[Link](function(key) {
if () {
[Link](formatProperty(ctx, value, recurseTimes, visibleKeys,
key, true));
}
});
return output;
}

function formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) {

var name, str, desc;
desc = [Link](value, key) || { value: value[key] };
if ([Link]) {
if ([Link]) {
str = [Link]('[Getter/Setter]', 'special');
} else {
str = [Link]('[Getter]', 'special');
}
} else {
 if ([Link]) {
str = [Link]('[Setter]', 'special');
}
}
if (!hasOwnProperty(visibleKeys, key)) {
name = '[' + key + ']';
}
if (!str) {
if ([Link]([Link]) < 0) {
if (isNull(recurseTimes)) {
str = formatValue(ctx, [Link], null);
} else {
str = formatValue(ctx, [Link], recurseTimes - 1);
}
if ([Link]('\n') > -1) {
if (array) {
str = [Link]('\n').map(function(line) {
return ' ' + line;
}).join('\n').substr(2);
} else {
str = '\n' + [Link]('\n').map(function(line) {
return ' ' + line;
}).join('\n');
}
}
} else {
str = [Link]('[Circular]', 'special');
}
}
if (isUndefined(name)) {
if (array && [Link](/^\d+$/)) {
return str;
}
name = [Link]('' + key);
if ([Link](/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)) {
name = [Link](1, [Link] - 2);
name = [Link](name, 'name');
} else {
name = [Link](/'/g, "\\'")
.replace(/\\"/g, '"')
.replace(/(^"|"$)/g, "'");
name = [Link](name, 'string');
}
}

return name + ': ' + str;

}

function reduceToSingleString(output, base, braces) {

var numLinesEst = 0;
var length = [Link](function(prev, cur) {
numLinesEst++;
if ([Link]('\n') >= 0) numLinesEst++;
return prev + [Link](/\u001b\[\d\d?m/g, '').length + 1;
}, 0);

if (length > 60) {

return braces[0] +
 (base === '' ? '' : base + '\n ') +
' ' +
[Link](',\n ') +
' ' +
braces[1];
}

return braces[0] + base + ' ' + [Link](', ') + ' ' + braces[1];
}

// NOTE: These type checking functions intentionally don't use `instanceof`

// because it is fragile and can be easily faked with `[Link]()`.
function isArray(ar) {
return [Link](ar);
}
[Link] = isArray;

function isBoolean(arg) {
return typeof arg === 'boolean';
}
[Link] = isBoolean;

function isNull(arg) {
return arg === null;
}
[Link] = isNull;

function isNullOrUndefined(arg) {
return arg == null;
}
[Link] = isNullOrUndefined;

function isNumber(arg) {
return typeof arg === 'number';
}
[Link] = isNumber;

function isString(arg) {
return typeof arg === 'string';
}
[Link] = isString;

function isSymbol(arg) {
return typeof arg === 'symbol';
}
[Link] = isSymbol;

function isUndefined(arg) {
return arg === void 0;
}
[Link] = isUndefined;

function isRegExp(re) {
return isObject(re) && objectToString(re) === '[object RegExp]';
}
[Link] = isRegExp;

function isObject(arg) {
 return typeof arg === 'object' && arg !== null;
}
[Link] = isObject;

function isDate(d) {
return isObject(d) && objectToString(d) === '[object Date]';
}
[Link] = isDate;

function isError(e) {
return isObject(e) &&
(objectToString(e) === '[object Error]' || e instanceof Error);
}
[Link] = isError;

function isFunction(arg) {
return typeof arg === 'function';
}
[Link] = isFunction;

function isPrimitive(arg) {
return arg === null ||
typeof arg === 'boolean' ||
typeof arg === 'number' ||
typeof arg === 'string' ||
typeof arg === 'symbol' || // ES6 symbol
typeof arg === 'undefined';
}
[Link] = isPrimitive;

[Link] = require('./support/isBuffer');

function objectToString(o) {
return [Link](o);
}

function pad(n) {
return n < 10 ? '0' + [Link](10) : [Link](10);
}

var months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep',
'Oct', 'Nov', 'Dec'];

// 26 Feb 16:19:34
function timestamp() {
var d = new Date();
var time = [pad([Link]()),
pad([Link]()),
pad([Link]())].join(':');
return [[Link](), months[[Link]()], time].join(' ');
}

// log is just a thin wrapper to [Link] that prepends a timestamp

[Link] = function() {
[Link]('%s - %s', timestamp(), [Link](exports, arguments));
};
/**
* Inherit the prototype methods from one constructor into another.
*
* The [Link] from [Link] rewritten as a standalone
* function (not on [Link]). NOTE: If this file is to be loaded
* during bootstrapping this function needs to be rewritten using some native
* functions as prototype setup using normal JavaScript does not work as
* expected during bootstrapping (see [Link] in r114903).
*
* @param {function} ctor Constructor function which needs to inherit the
* prototype.
* @param {function} superCtor Constructor function to inherit prototype from.
*/
[Link] = require('inherits');

exports._extend = function(origin, add) {

// Don't do anything if add isn't an object
if (!add || !isObject(add)) return origin;

var keys = [Link](add);

var i = [Link];
while (i--) {
origin[keys[i]] = add[keys[i]];
}
return origin;
};

function hasOwnProperty(obj, prop) {

return [Link](obj, prop);
}

}).call(this,require('_process'),typeof global !== "undefined" ? global : typeof

self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
},{"./support/isBuffer":105,"_process":91,"inherits":89}]},{},[53])(53)
});