{
  "version": 3,
  "sources": [
    "node_modules/browserify/node_modules/browser-pack/_prelude.js",
    "lib/solidity/abi.js",
    "lib/solidity/formatters.js",
    "lib/solidity/types.js",
    "lib/utils/browser-xhr.js",
    "lib/utils/config.js",
    "lib/utils/utils.js",
    "lib/version.json",
    "lib/web3.js",
    "lib/web3/contract.js",
    "lib/web3/db.js",
    "lib/web3/errors.js",
    "lib/web3/eth.js",
    "lib/web3/event.js",
    "lib/web3/filter.js",
    "lib/web3/formatters.js",
    "lib/web3/httpprovider.js",
    "lib/web3/jsonrpc.js",
    "lib/web3/method.js",
    "lib/web3/net.js",
    "lib/web3/property.js",
    "lib/web3/qtsync.js",
    "lib/web3/requestmanager.js",
    "lib/web3/shh.js",
    "lib/web3/signature.js",
    "lib/web3/watches.js",
    "node_modules/browserify/lib/_empty.js",
    "node_modules/bignumber.js/bignumber.js",
    "index.js"
  ],
  "names": [],
  "mappings": "AAAA;ACAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACrPA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnNA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC7EA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACTA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACrEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/c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nPA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC9PA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC1IA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AClLA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChNA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC7DA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC7EA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtHA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC3EA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC9MA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC1CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvFA;;ACAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC7mFA;AACA;AACA;AACA;AACA;AACA;AACA;AACA",
  "file": "generated.js",
  "sourceRoot": "",
  "sourcesContent": [
    "(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 f.code=\"MODULE_NOT_FOUND\",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require==\"function\"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})",
    "/*\n    This file is part of ethereum.js.\n\n    ethereum.js is free software: you can redistribute it and/or modify\n    it under the terms of the GNU Lesser General Public License as published by\n    the Free Software Foundation, either version 3 of the License, or\n    (at your option) any later version.\n\n    ethereum.js is distributed in the hope that it will be useful,\n    but WITHOUT ANY WARRANTY; without even the implied warranty of\n    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n    GNU Lesser General Public License for more details.\n\n    You should have received a copy of the GNU Lesser General Public License\n    along with ethereum.js.  If not, see <http://www.gnu.org/licenses/>.\n*/\n/** @file abi.js\n * @authors:\n *   Marek Kotewicz <marek@ethdev.com>\n *   Gav Wood <g@ethdev.com>\n * @date 2014\n */\n\nvar utils = require('../utils/utils');\nvar c = require('../utils/config');\nvar types = require('./types');\nvar f = require('./formatters');\n\n/**\n * throw incorrect type error\n *\n * @method throwTypeError\n * @param {String} type\n * @throws incorrect type error\n */\nvar throwTypeError = function (type) {\n    throw new Error('parser does not support type: ' + type);\n};\n\n/** This method should be called if we want to check if givent type is an array type\n *\n * @method isArrayType\n * @param {String} type name\n * @returns {Boolean} true if it is, otherwise false\n */\nvar isArrayType = function (type) {\n    return type.slice(-2) === '[]';\n};\n\n/**\n * This method should be called to return dynamic type length in hex\n *\n * @method dynamicTypeBytes\n * @param {String} type\n * @param {String|Array} dynamic type\n * @return {String} length of dynamic type in hex or empty string if type is not dynamic\n */\nvar dynamicTypeBytes = function (type, value) {\n    // TODO: decide what to do with array of strings\n    if (isArrayType(type) || type === 'bytes')\n        return f.formatInputInt(value.length);\n    return \"\";\n};\n\nvar inputTypes = types.inputTypes();\n\n/**\n * Formats input params to bytes\n *\n * @method formatInput\n * @param {Array} abi inputs of method\n * @param {Array} params that will be formatted to bytes\n * @returns bytes representation of input params\n */\nvar formatInput = function (inputs, params) {\n    var bytes = \"\";\n    var toAppendConstant = \"\";\n    var toAppendArrayContent = \"\";\n\n    /// first we iterate in search for dynamic\n    inputs.forEach(function (input, index) {\n        bytes += dynamicTypeBytes(input.type, params[index]);\n    });\n\n    inputs.forEach(function (input, i) {\n        /*jshint maxcomplexity:5 */\n        var typeMatch = false;\n        for (var j = 0; j < inputTypes.length && !typeMatch; j++) {\n            typeMatch = inputTypes[j].type(inputs[i].type, params[i]);\n        }\n        if (!typeMatch) {\n            throwTypeError(inputs[i].type);\n        }\n\n        var formatter = inputTypes[j - 1].format;\n\n        if (isArrayType(inputs[i].type))\n            toAppendArrayContent += params[i].reduce(function (acc, curr) {\n                return acc + formatter(curr);\n            }, \"\");\n        else if (inputs[i].type === 'bytes')\n            toAppendArrayContent += formatter(params[i]);\n        else\n            toAppendConstant += formatter(params[i]);\n    });\n\n    bytes += toAppendConstant + toAppendArrayContent;\n\n    return bytes;\n};\n\n/**\n * This method should be called to predict the length of dynamic type\n *\n * @method dynamicBytesLength\n * @param {String} type\n * @returns {Number} length of dynamic type, 0 or multiplication of ETH_PADDING (32)\n */\nvar dynamicBytesLength = function (type) {\n    if (isArrayType(type) || type === 'bytes')\n        return c.ETH_PADDING * 2;\n    return 0;\n};\n\nvar outputTypes = types.outputTypes();\n\n/** \n * Formats output bytes back to param list\n *\n * @method formatOutput\n * @param {Array} abi outputs of method\n * @param {String} bytes represention of output\n * @returns {Array} output params\n */\nvar formatOutput = function (outs, output) {\n\n    output = output.slice(2);\n    var result = [];\n    var padding = c.ETH_PADDING * 2;\n\n    var dynamicPartLength = outs.reduce(function (acc, curr) {\n        return acc + dynamicBytesLength(curr.type);\n    }, 0);\n\n    var dynamicPart = output.slice(0, dynamicPartLength);\n    output = output.slice(dynamicPartLength);\n\n    outs.forEach(function (out, i) {\n        /*jshint maxcomplexity:6 */\n        var typeMatch = false;\n        for (var j = 0; j < outputTypes.length && !typeMatch; j++) {\n            typeMatch = outputTypes[j].type(outs[i].type);\n        }\n\n        if (!typeMatch) {\n            throwTypeError(outs[i].type);\n        }\n\n        var formatter = outputTypes[j - 1].format;\n        if (isArrayType(outs[i].type)) {\n            var size = f.formatOutputUInt(dynamicPart.slice(0, padding));\n            dynamicPart = dynamicPart.slice(padding);\n            var array = [];\n            for (var k = 0; k < size; k++) {\n                array.push(formatter(output.slice(0, padding)));\n                output = output.slice(padding);\n            }\n            result.push(array);\n        }\n        else if (types.prefixedType('bytes')(outs[i].type)) {\n            dynamicPart = dynamicPart.slice(padding);\n            result.push(formatter(output.slice(0, padding)));\n            output = output.slice(padding);\n        } else {\n            result.push(formatter(output.slice(0, padding)));\n            output = output.slice(padding);\n        }\n    });\n\n    return result;\n};\n\n/**\n * Should be called to create input parser for contract with given abi\n *\n * @method inputParser\n * @param {Array} contract abi\n * @returns {Object} input parser object for given json abi\n * TODO: refactor creating the parser, do not double logic from contract\n */\nvar inputParser = function (json) {\n    var parser = {};\n    json.forEach(function (method) {\n        var displayName = utils.extractDisplayName(method.name);\n        var typeName = utils.extractTypeName(method.name);\n\n        var impl = function () {\n            var params = Array.prototype.slice.call(arguments);\n            return formatInput(method.inputs, params);\n        };\n\n        if (parser[displayName] === undefined) {\n            parser[displayName] = impl;\n        }\n\n        parser[displayName][typeName] = impl;\n    });\n\n    return parser;\n};\n\n/**\n * Should be called to create output parser for contract with given abi\n *\n * @method outputParser\n * @param {Array} contract abi\n * @returns {Object} output parser for given json abi\n */\nvar outputParser = function (json) {\n    var parser = {};\n    json.forEach(function (method) {\n\n        var displayName = utils.extractDisplayName(method.name);\n        var typeName = utils.extractTypeName(method.name);\n\n        var impl = function (output) {\n            return formatOutput(method.outputs, output);\n        };\n\n        if (parser[displayName] === undefined) {\n            parser[displayName] = impl;\n        }\n\n        parser[displayName][typeName] = impl;\n    });\n\n    return parser;\n};\n\nmodule.exports = {\n    inputParser: inputParser,\n    outputParser: outputParser,\n    formatInput: formatInput,\n    formatOutput: formatOutput\n};\n",
    "/*\n    This file is part of ethereum.js.\n\n    ethereum.js is free software: you can redistribute it and/or modify\n    it under the terms of the GNU Lesser General Public License as published by\n    the Free Software Foundation, either version 3 of the License, or\n    (at your option) any later version.\n\n    ethereum.js is distributed in the hope that it will be useful,\n    but WITHOUT ANY WARRANTY; without even the implied warranty of\n    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n    GNU Lesser General Public License for more details.\n\n    You should have received a copy of the GNU Lesser General Public License\n    along with ethereum.js.  If not, see <http://www.gnu.org/licenses/>.\n*/\n/** @file formatters.js\n * @authors:\n *   Marek Kotewicz <marek@ethdev.com>\n * @date 2015\n */\n\nvar BigNumber = require('bignumber.js');\nvar utils = require('../utils/utils');\nvar c = require('../utils/config');\n\n/**\n * Should be called to pad string to expected length\n *\n * @method padLeft\n * @param {String} string to be padded\n * @param {Number} characters that result string should have\n * @param {String} sign, by default 0\n * @returns {String} right aligned string\n */\nvar padLeft = function (string, chars, sign) {\n    return new Array(chars - string.length + 1).join(sign ? sign : \"0\") + string;\n};\n\n/**\n * Formats input value to byte representation of int\n * If value is negative, return it's two's complement\n * If the value is floating point, round it down\n *\n * @method formatInputInt\n * @param {String|Number|BigNumber} value that needs to be formatted\n * @returns {String} right-aligned byte representation of int\n */\nvar formatInputInt = function (value) {\n    var padding = c.ETH_PADDING * 2;\n    BigNumber.config(c.ETH_BIGNUMBER_ROUNDING_MODE);\n    return padLeft(utils.toTwosComplement(value).round().toString(16), padding);\n};\n\n/**\n * Formats input value to byte representation of string\n *\n * @method formatInputString\n * @param {String}\n * @returns {String} left-algined byte representation of string\n */\nvar formatInputString = function (value) {\n    return utils.fromAscii(value, c.ETH_PADDING).substr(2);\n};\n\n/**\n * Formats input value to byte representation of bool\n *\n * @method formatInputBool\n * @param {Boolean}\n * @returns {String} right-aligned byte representation bool\n */\nvar formatInputBool = function (value) {\n    return '000000000000000000000000000000000000000000000000000000000000000' + (value ?  '1' : '0');\n};\n\n/**\n * Formats input value to byte representation of real\n * Values are multiplied by 2^m and encoded as integers\n *\n * @method formatInputReal\n * @param {String|Number|BigNumber}\n * @returns {String} byte representation of real\n */\nvar formatInputReal = function (value) {\n    return formatInputInt(new BigNumber(value).times(new BigNumber(2).pow(128))); \n};\n\n/**\n * Check if input value is negative\n *\n * @method signedIsNegative\n * @param {String} value is hex format\n * @returns {Boolean} true if it is negative, otherwise false\n */\nvar signedIsNegative = function (value) {\n    return (new BigNumber(value.substr(0, 1), 16).toString(2).substr(0, 1)) === '1';\n};\n\n/**\n * Formats right-aligned output bytes to int\n *\n * @method formatOutputInt\n * @param {String} bytes\n * @returns {BigNumber} right-aligned output bytes formatted to big number\n */\nvar formatOutputInt = function (value) {\n\n    value = value || \"0\";\n\n    // check if it's negative number\n    // it it is, return two's complement\n    if (signedIsNegative(value)) {\n        return new BigNumber(value, 16).minus(new BigNumber('ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff', 16)).minus(1);\n    }\n    return new BigNumber(value, 16);\n};\n\n/**\n * Formats right-aligned output bytes to uint\n *\n * @method formatOutputUInt\n * @param {String} bytes\n * @returns {BigNumeber} right-aligned output bytes formatted to uint\n */\nvar formatOutputUInt = function (value) {\n    value = value || \"0\";\n    return new BigNumber(value, 16);\n};\n\n/**\n * Formats right-aligned output bytes to real\n *\n * @method formatOutputReal\n * @param {String}\n * @returns {BigNumber} input bytes formatted to real\n */\nvar formatOutputReal = function (value) {\n    return formatOutputInt(value).dividedBy(new BigNumber(2).pow(128)); \n};\n\n/**\n * Formats right-aligned output bytes to ureal\n *\n * @method formatOutputUReal\n * @param {String}\n * @returns {BigNumber} input bytes formatted to ureal\n */\nvar formatOutputUReal = function (value) {\n    return formatOutputUInt(value).dividedBy(new BigNumber(2).pow(128)); \n};\n\n/**\n * Should be used to format output hash\n *\n * @method formatOutputHash\n * @param {String}\n * @returns {String} right-aligned output bytes formatted to hex\n */\nvar formatOutputHash = function (value) {\n    return \"0x\" + value;\n};\n\n/**\n * Should be used to format output bool\n *\n * @method formatOutputBool\n * @param {String}\n * @returns {Boolean} right-aligned input bytes formatted to bool\n */\nvar formatOutputBool = function (value) {\n    return value === '0000000000000000000000000000000000000000000000000000000000000001' ? true : false;\n};\n\n/**\n * Should be used to format output string\n *\n * @method formatOutputString\n * @param {Sttring} left-aligned hex representation of string\n * @returns {String} ascii string\n */\nvar formatOutputString = function (value) {\n    return utils.toAscii(value);\n};\n\n/**\n * Should be used to format output address\n *\n * @method formatOutputAddress\n * @param {String} right-aligned input bytes\n * @returns {String} address\n */\nvar formatOutputAddress = function (value) {\n    return \"0x\" + value.slice(value.length - 40, value.length);\n};\n\nmodule.exports = {\n    formatInputInt: formatInputInt,\n    formatInputString: formatInputString,\n    formatInputBool: formatInputBool,\n    formatInputReal: formatInputReal,\n    formatOutputInt: formatOutputInt,\n    formatOutputUInt: formatOutputUInt,\n    formatOutputReal: formatOutputReal,\n    formatOutputUReal: formatOutputUReal,\n    formatOutputHash: formatOutputHash,\n    formatOutputBool: formatOutputBool,\n    formatOutputString: formatOutputString,\n    formatOutputAddress: formatOutputAddress\n};\n\n",
    "/*\n    This file is part of ethereum.js.\n\n    ethereum.js is free software: you can redistribute it and/or modify\n    it under the terms of the GNU Lesser General Public License as published by\n    the Free Software Foundation, either version 3 of the License, or\n    (at your option) any later version.\n\n    ethereum.js is distributed in the hope that it will be useful,\n    but WITHOUT ANY WARRANTY; without even the implied warranty of\n    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n    GNU Lesser General Public License for more details.\n\n    You should have received a copy of the GNU Lesser General Public License\n    along with ethereum.js.  If not, see <http://www.gnu.org/licenses/>.\n*/\n/** @file types.js\n * @authors:\n *   Marek Kotewicz <marek@ethdev.com>\n * @date 2015\n */\n\nvar f = require('./formatters');\n\n/// @param expected type prefix (string)\n/// @returns function which checks if type has matching prefix. if yes, returns true, otherwise false\nvar prefixedType = function (prefix) {\n    return function (type) {\n        return type.indexOf(prefix) === 0;\n    };\n};\n\n/// @param expected type name (string)\n/// @returns function which checks if type is matching expected one. if yes, returns true, otherwise false\nvar namedType = function (name) {\n    return function (type) {\n        return name === type;\n    };\n};\n\n/// Setups input formatters for solidity types\n/// @returns an array of input formatters \nvar inputTypes = function () {\n    \n    return [\n        { type: prefixedType('uint'), format: f.formatInputInt },\n        { type: prefixedType('int'), format: f.formatInputInt },\n        { type: prefixedType('bytes'), format: f.formatInputString }, \n        { type: prefixedType('real'), format: f.formatInputReal },\n        { type: prefixedType('ureal'), format: f.formatInputReal },\n        { type: namedType('address'), format: f.formatInputInt },\n        { type: namedType('bool'), format: f.formatInputBool }\n    ];\n};\n\n/// Setups output formaters for solidity types\n/// @returns an array of output formatters\nvar outputTypes = function () {\n\n    return [\n        { type: prefixedType('uint'), format: f.formatOutputUInt },\n        { type: prefixedType('int'), format: f.formatOutputInt },\n        { type: prefixedType('bytes'), format: f.formatOutputString },\n        { type: prefixedType('real'), format: f.formatOutputReal },\n        { type: prefixedType('ureal'), format: f.formatOutputUReal },\n        { type: namedType('address'), format: f.formatOutputAddress },\n        { type: namedType('bool'), format: f.formatOutputBool }\n    ];\n};\n\nmodule.exports = {\n    prefixedType: prefixedType,\n    namedType: namedType,\n    inputTypes: inputTypes,\n    outputTypes: outputTypes\n};\n\n",
    "'use strict';\n\n// go env doesn't have and need XMLHttpRequest\nif (typeof XMLHttpRequest === 'undefined') {\n    exports.XMLHttpRequest = {};\n} else {\n    exports.XMLHttpRequest = XMLHttpRequest; // jshint ignore:line\n}\n\n",
    "/*\n    This file is part of ethereum.js.\n\n    ethereum.js is free software: you can redistribute it and/or modify\n    it under the terms of the GNU Lesser General Public License as published by\n    the Free Software Foundation, either version 3 of the License, or\n    (at your option) any later version.\n\n    ethereum.js is distributed in the hope that it will be useful,\n    but WITHOUT ANY WARRANTY; without even the implied warranty of\n    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n    GNU Lesser General Public License for more details.\n\n    You should have received a copy of the GNU Lesser General Public License\n    along with ethereum.js.  If not, see <http://www.gnu.org/licenses/>.\n*/\n/** @file config.js\n * @authors:\n *   Marek Kotewicz <marek@ethdev.com>\n * @date 2015\n */\n\n/**\n * Utils\n * \n * @module utils\n */\n\n/**\n * Utility functions\n * \n * @class [utils] config\n * @constructor\n */\n\n/// required to define ETH_BIGNUMBER_ROUNDING_MODE\nvar BigNumber = require('bignumber.js');\n\nvar ETH_UNITS = [ \n    'wei', \n    'Kwei', \n    'Mwei', \n    'Gwei', \n    'szabo', \n    'finney', \n    'ether', \n    'grand', \n    'Mether', \n    'Gether', \n    'Tether', \n    'Pether', \n    'Eether', \n    'Zether', \n    'Yether', \n    'Nether', \n    'Dether', \n    'Vether', \n    'Uether' \n];\n\nmodule.exports = {\n    ETH_PADDING: 32,\n    ETH_SIGNATURE_LENGTH: 4,\n    ETH_UNITS: ETH_UNITS,\n    ETH_BIGNUMBER_ROUNDING_MODE: { ROUNDING_MODE: BigNumber.ROUND_DOWN },\n    ETH_POLLING_TIMEOUT: 1000,\n    ETH_DEFAULTBLOCK: 'latest'\n};\n\n",
    "/*\n    This file is part of ethereum.js.\n\n    ethereum.js is free software: you can redistribute it and/or modify\n    it under the terms of the GNU Lesser General Public License as published by\n    the Free Software Foundation, either version 3 of the License, or\n    (at your option) any later version.\n\n    ethereum.js is distributed in the hope that it will be useful,\n    but WITHOUT ANY WARRANTY; without even the implied warranty of\n    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n    GNU Lesser General Public License for more details.\n\n    You should have received a copy of the GNU Lesser General Public License\n    along with ethereum.js.  If not, see <http://www.gnu.org/licenses/>.\n*/\n/** @file utils.js\n * @authors:\n *   Marek Kotewicz <marek@ethdev.com>\n * @date 2015\n */\n\n/**\n * Utils\n * \n * @module utils\n */\n\n/**\n * Utility functions\n * \n * @class [utils] utils\n * @constructor\n */\n\nvar BigNumber = require('bignumber.js');\n\nvar unitMap = {\n    'wei':      '1',\n    'kwei':     '1000',\n    'ada':      '1000',\n    'mwei':     '1000000',\n    'babbage':  '1000000',\n    'gwei':     '1000000000',\n    'shannon':  '1000000000',\n    'szabo':    '1000000000000',\n    'finney':   '1000000000000000',\n    'ether':    '1000000000000000000',\n    'kether':   '1000000000000000000000',\n    'grand':    '1000000000000000000000',\n    'einstein': '1000000000000000000000',\n    'mether':   '1000000000000000000000000',\n    'gether':   '1000000000000000000000000000',\n    'tether':   '1000000000000000000000000000000'\n};\n\n\n/** Finds first index of array element matching pattern\n *\n * @method findIndex\n * @param {Array}\n * @param {Function} pattern\n * @returns {Number} index of element\n */\nvar findIndex = function (array, callback) {\n    var end = false;\n    var i = 0;\n    for (; i < array.length && !end; i++) {\n        end = callback(array[i]);\n    }\n    return end ? i - 1 : -1;\n};\n\n/** \n * Should be called to get sting from it's hex representation\n *\n * @method toAscii\n * @param {String} string in hex\n * @returns {String} ascii string representation of hex value\n */\nvar toAscii = function(hex) {\n// Find termination\n    var str = \"\";\n    var i = 0, l = hex.length;\n    if (hex.substring(0, 2) === '0x') {\n        i = 2;\n    }\n    for (; i < l; i+=2) {\n        var code = parseInt(hex.substr(i, 2), 16);\n        if (code === 0) {\n            break;\n        }\n\n        str += String.fromCharCode(code);\n    }\n\n    return str;\n};\n    \n/**\n * Shold be called to get hex representation (prefixed by 0x) of ascii string \n *\n * @method fromAscii\n * @param {String} string\n * @returns {String} hex representation of input string\n */\nvar toHexNative = function(str) {\n    var hex = \"\";\n    for(var i = 0; i < str.length; i++) {\n        var n = str.charCodeAt(i).toString(16);\n        hex += n.length < 2 ? '0' + n : n;\n    }\n\n    return hex;\n};\n\n/**\n * Shold be called to get hex representation (prefixed by 0x) of ascii string \n *\n * @method fromAscii\n * @param {String} string\n * @param {Number} optional padding\n * @returns {String} hex representation of input string\n */\nvar fromAscii = function(str, pad) {\n    pad = pad === undefined ? 0 : pad;\n    var hex = toHexNative(str);\n    while (hex.length < pad*2)\n        hex += \"00\";\n    return \"0x\" + hex;\n};\n\n/**\n * Should be called to get display name of contract function\n * \n * @method extractDisplayName\n * @param {String} name of function/event\n * @returns {String} display name for function/event eg. multiply(uint256) -> multiply\n */\nvar extractDisplayName = function (name) {\n    var length = name.indexOf('('); \n    return length !== -1 ? name.substr(0, length) : name;\n};\n\n/// @returns overloaded part of function/event name\nvar extractTypeName = function (name) {\n    /// TODO: make it invulnerable\n    var length = name.indexOf('(');\n    return length !== -1 ? name.substr(length + 1, name.length - 1 - (length + 1)).replace(' ', '') : \"\";\n};\n\n/**\n * Filters all functions from input abi\n *\n * @method filterFunctions\n * @param {Array} abi\n * @returns {Array} abi array with filtered objects of type 'function'\n */\nvar filterFunctions = function (json) {\n    return json.filter(function (current) {\n        return current.type === 'function'; \n    }); \n};\n\n/**\n * Filters all events from input abi\n *\n * @method filterEvents\n * @param {Array} abi\n * @returns {Array} abi array with filtered objects of type 'event'\n */\nvar filterEvents = function (json) {\n    return json.filter(function (current) {\n        return current.type === 'event';\n    });\n};\n\n/**\n * Converts value to it's decimal representation in string\n *\n * @method toDecimal\n * @param {String|Number|BigNumber}\n * @return {String}\n */\nvar toDecimal = function (value) {\n    return toBigNumber(value).toNumber();\n};\n\n/**\n * Converts value to it's hex representation\n *\n * @method fromDecimal\n * @param {String|Number|BigNumber}\n * @return {String}\n */\nvar fromDecimal = function (value) {\n    var number = toBigNumber(value);\n    var result = number.toString(16);\n\n    return number.lessThan(0) ? '-0x' + result.substr(1) : '0x' + result;\n};\n\n/**\n * Auto converts any given value into it's hex representation.\n *\n * And even stringifys objects before.\n *\n * @method toHex\n * @param {String|Number|BigNumber|Object}\n * @return {String}\n */\nvar toHex = function (val) {\n    /*jshint maxcomplexity:7 */\n\n    if (isBoolean(val))\n        return fromDecimal(+val);\n\n    if (isBigNumber(val))\n        return fromDecimal(val);\n\n    if (isObject(val))\n        return fromAscii(JSON.stringify(val));\n\n    // if its a negative number, pass it through fromDecimal\n    if (isString(val)) {\n        if (val.indexOf('-0x') === 0)\n           return fromDecimal(val);\n        else if (!isFinite(val))\n            return fromAscii(val);\n    }\n\n    return fromDecimal(val);\n};\n\n/**\n * Returns value of unit in Wei\n *\n * @method getValueOfUnit\n * @param {String} unit the unit to convert to, default ether\n * @returns {BigNumber} value of the unit (in Wei)\n * @throws error if the unit is not correct:w\n */\nvar getValueOfUnit = function (unit) {\n    unit = unit ? unit.toLowerCase() : 'ether';\n    var unitValue = unitMap[unit];\n    if (unitValue === undefined) {\n        throw new Error('This unit doesn\\'t exists, please use the one of the following units' + JSON.stringify(unitMap, null, 2));\n    }\n    return new BigNumber(unitValue, 10);\n};\n\n/**\n * Takes a number of wei and converts it to any other ether unit.\n *\n * Possible units are:\n * - kwei/ada\n * - mwei/babbage\n * - gwei/shannon\n * - szabo\n * - finney\n * - ether\n * - kether/grand/einstein\n * - mether\n * - gether\n * - tether\n *\n * @method fromWei\n * @param {Number|String} number can be a number, number string or a HEX of a decimal\n * @param {String} unit the unit to convert to, default ether\n * @return {String|Object} When given a BigNumber object it returns one as well, otherwise a number\n*/\nvar fromWei = function(number, unit) {\n    var returnValue = toBigNumber(number).dividedBy(getValueOfUnit(unit));\n\n    return isBigNumber(number) ? returnValue : returnValue.toString(10); \n};\n\n/**\n * Takes a number of a unit and converts it to wei.\n *\n * Possible units are:\n * - kwei/ada\n * - mwei/babbage\n * - gwei/shannon\n * - szabo\n * - finney\n * - ether\n * - kether/grand/einstein\n * - mether\n * - gether\n * - tether\n *\n * @method toWei\n * @param {Number|String|BigNumber} number can be a number, number string or a HEX of a decimal\n * @param {String} unit the unit to convert from, default ether\n * @return {String|Object} When given a BigNumber object it returns one as well, otherwise a number\n*/\nvar toWei = function(number, unit) {\n    var returnValue = toBigNumber(number).times(getValueOfUnit(unit));\n\n    return isBigNumber(number) ? returnValue : returnValue.toString(10); \n};\n\n/**\n * Takes an input and transforms it into an bignumber\n *\n * @method toBigNumber\n * @param {Number|String|BigNumber} a number, string, HEX string or BigNumber\n * @return {BigNumber} BigNumber\n*/\nvar toBigNumber = function(number) {\n    /*jshint maxcomplexity:5 */\n    number = number || 0;\n    if (isBigNumber(number))\n        return number;\n\n    if (isString(number) && (number.indexOf('0x') === 0 || number.indexOf('-0x') === 0)) {\n        return new BigNumber(number.replace('0x',''), 16);\n    }\n   \n    return new BigNumber(number.toString(10), 10);\n};\n\n/**\n * Takes and input transforms it into bignumber and if it is negative value, into two's complement\n *\n * @method toTwosComplement\n * @param {Number|String|BigNumber}\n * @return {BigNumber}\n */\nvar toTwosComplement = function (number) {\n    var bigNumber = toBigNumber(number);\n    if (bigNumber.lessThan(0)) {\n        return new BigNumber(\"ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff\", 16).plus(bigNumber).plus(1);\n    }\n    return bigNumber;\n};\n\n/**\n * Checks if the given string has proper length\n *\n * @method isAddress\n * @param {String} address the given HEX adress\n * @return {Boolean}\n*/\nvar isAddress = function(address) {\n    if (!isString(address)) {\n        return false;\n    }\n\n    return ((address.indexOf('0x') === 0 && address.length === 42) ||\n            (address.indexOf('0x') === -1 && address.length === 40));\n};\n\n/**\n * Returns true if object is BigNumber, otherwise false\n *\n * @method isBigNumber\n * @param {Object}\n * @return {Boolean} \n */\nvar isBigNumber = function (object) {\n    return object instanceof BigNumber ||\n        (object && object.constructor && object.constructor.name === 'BigNumber');\n};\n\n/**\n * Returns true if object is string, otherwise false\n * \n * @method isString\n * @param {Object}\n * @return {Boolean}\n */\nvar isString = function (object) {\n    return typeof object === 'string' ||\n        (object && object.constructor && object.constructor.name === 'String');\n};\n\n/**\n * Returns true if object is function, otherwise false\n *\n * @method isFunction\n * @param {Object}\n * @return {Boolean}\n */\nvar isFunction = function (object) {\n    return typeof object === 'function';\n};\n\n/**\n * Returns true if object is Objet, otherwise false\n *\n * @method isObject\n * @param {Object}\n * @return {Boolean}\n */\nvar isObject = function (object) {\n    return typeof object === 'object';\n};\n\n/**\n * Returns true if object is boolean, otherwise false\n *\n * @method isBoolean\n * @param {Object}\n * @return {Boolean}\n */\nvar isBoolean = function (object) {\n    return typeof object === 'boolean';\n};\n\n/**\n * Returns true if object is array, otherwise false\n *\n * @method isArray\n * @param {Object}\n * @return {Boolean}\n */\nvar isArray = function (object) {\n    return object instanceof Array; \n};\n\n/**\n * Returns true if given string is valid json object\n * \n * @method isJson\n * @param {String}\n * @return {Boolean}\n */\nvar isJson = function (str) {\n    try {\n        JSON.parse(str);\n    } catch (e) {\n        return false;\n    }\n    return true;\n};\n\nmodule.exports = {\n    findIndex: findIndex,\n    toHex: toHex,\n    toDecimal: toDecimal,\n    fromDecimal: fromDecimal,\n    toAscii: toAscii,\n    fromAscii: fromAscii,\n    extractDisplayName: extractDisplayName,\n    extractTypeName: extractTypeName,\n    filterFunctions: filterFunctions,\n    filterEvents: filterEvents,\n    toWei: toWei,\n    fromWei: fromWei,\n    toBigNumber: toBigNumber,\n    toTwosComplement: toTwosComplement,\n    isBigNumber: isBigNumber,\n    isAddress: isAddress,\n    isFunction: isFunction,\n    isString: isString,\n    isObject: isObject,\n    isBoolean: isBoolean,\n    isArray: isArray,\n    isJson: isJson\n};\n\n",
    "module.exports={\n    \"version\": \"0.1.3\"\n}",
    "/*\n    This file is part of ethereum.js.\n\n    ethereum.js is free software: you can redistribute it and/or modify\n    it under the terms of the GNU Lesser General Public License as published by\n    the Free Software Foundation, either version 3 of the License, or\n    (at your option) any later version.\n\n    ethereum.js is distributed in the hope that it will be useful,\n    but WITHOUT ANY WARRANTY; without even the implied warranty of\n    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n    GNU Lesser General Public License for more details.\n\n    You should have received a copy of the GNU Lesser General Public License\n    along with ethereum.js.  If not, see <http://www.gnu.org/licenses/>.\n*/\n/** @file web3.js\n * @authors:\n *   Jeffrey Wilcke <jeff@ethdev.com>\n *   Marek Kotewicz <marek@ethdev.com>\n *   Marian Oancea <marian@ethdev.com>\n *   Fabian Vogelsteller <fabian@ethdev.com>\n *   Gav Wood <g@ethdev.com>\n * @date 2014\n */\n\nvar version = require('./version.json');\nvar net = require('./web3/net');\nvar eth = require('./web3/eth');\nvar db = require('./web3/db');\nvar shh = require('./web3/shh');\nvar watches = require('./web3/watches');\nvar filter = require('./web3/filter');\nvar utils = require('./utils/utils');\nvar formatters = require('./web3/formatters');\nvar RequestManager = require('./web3/requestmanager');\nvar c = require('./utils/config');\nvar Method = require('./web3/method');\nvar Property = require('./web3/property');\n\n/// @returns an array of objects describing web3 api methods\nvar web3Methods = function () {\n    var sha3 = new Method({\n        name: 'sha3',\n        call: 'web3_sha3',\n        params: 1,\n        inputFormatter:[utils.toHex]\n    });\n\n    return [sha3];\n};\n\nvar web3Properties = [\n    new Property({\n        name: 'version.client',\n        getter: 'web3_clientVersion'\n    }),\n    new Property({\n        name: 'version.network',\n        getter: 'net_version'\n    })\n];\n\n/// creates methods in a given object based on method description on input\n/// setups api calls for these methods\nvar setupMethods = function (obj, methods) {\n    methods.forEach(function (method) {\n        var func = function () {\n            var args = Array.prototype.slice.call(arguments);\n            var call = method.getCall(args); \n            var callback = method.extractCallback(args);\n            var params = method.formatInput(args);\n            method.validateArgs(params);\n            \n            var payload = {\n                method: call,\n                params: params\n            };\n\n            if (callback && web3.manager.sendAsync) {\n                return web3.manager.sendAsync(payload, function (err, result) {\n                    callback(null, method.formatOutput(result));\n                });\n            }\n\n            return method.formatOutput(web3.manager.send(payload));\n        };\n        method.attachToObject(obj, func);\n    });\n};\n\n/// creates properties in a given object based on properties description on input\n/// setups api calls for these properties\nvar setupProperties = function (obj, properties) {\n    properties.forEach(function (property) {\n        var proto = {};\n\n        proto.get = function () {\n            return property.formatOutput(web3.manager.send({\n                method: property.getter\n            }));\n        };\n\n        if (property.setter) {\n            proto.set = function (val) {\n                return web3.manager.send({\n                    method: property.setter,\n                    params: [property.formatInput(val)]\n                });\n            };\n        }\n\n        property.attachToObject(obj, proto);\n    });\n};\n\n/*jshint maxparams:4 */\nvar startPolling = function (method, id, callback, uninstall) {\n    web3.manager.startPolling({\n        method: method, \n        params: [id]\n    }, id,  callback, uninstall); \n};\n/*jshint maxparams:3 */\n\nvar stopPolling = function (id) {\n    web3.manager.stopPolling(id);\n};\n\nvar ethWatch = {\n    startPolling: startPolling.bind(null, 'eth_getFilterChanges'), \n    stopPolling: stopPolling\n};\n\nvar shhWatch = {\n    startPolling: startPolling.bind(null, 'shh_getFilterChanges'), \n    stopPolling: stopPolling\n};\n\n/// setups web3 object, and it's in-browser executed methods\nvar web3 = {\n\n    version: {\n        api: version.version\n    },\n\n    manager: new RequestManager(),\n    providers: {},\n\n    setProvider: function (provider) {\n        web3.manager.setProvider(provider);\n    },\n    \n    /// Should be called to reset state of web3 object\n    /// Resets everything except manager\n    reset: function () {\n        web3.manager.reset(); \n    },\n\n    /// @returns hex string of the input\n    toHex: utils.toHex,\n\n    /// @returns ascii string representation of hex value prefixed with 0x\n    toAscii: utils.toAscii,\n\n    /// @returns hex representation (prefixed by 0x) of ascii string\n    fromAscii: utils.fromAscii,\n\n    /// @returns decimal representaton of hex value prefixed by 0x\n    toDecimal: utils.toDecimal,\n\n    /// @returns hex representation (prefixed by 0x) of decimal value\n    fromDecimal: utils.fromDecimal,\n\n    /// @returns a BigNumber object\n    toBigNumber: utils.toBigNumber,\n\n    toWei: utils.toWei,\n    fromWei: utils.fromWei,\n    isAddress: utils.isAddress,\n\n    // provide network information\n    net: {\n        // peerCount: \n    },\n\n\n    /// eth object prototype\n    eth: {\n        // DEPRECATED\n        contractFromAbi: function (abi) {\n            console.warn('Initiating a contract like this is deprecated please use var MyContract = eth.contract(abi); new MyContract(address); instead.');\n\n            return function(addr) {\n                // Default to address of Config. TODO: rremove prior to genesis.\n                addr = addr || '0xc6d9d2cd449a754c494264e1809c50e34d64562b';\n                var ret = web3.eth.contract(addr, abi);\n                ret.address = addr;\n                return ret;\n            };\n        },\n\n        /// @param filter may be a string, object or event\n        /// @param eventParams is optional, this is an object with optional event eventParams params\n        /// @param options is optional, this is an object with optional event options ('max'...)\n        /*jshint maxparams:4 */\n        filter: function (fil, eventParams, options) {\n\n            // if its event, treat it differently\n            if (fil._isEvent)\n                return fil(eventParams, options);\n\n            return filter(fil, ethWatch, formatters.outputLogFormatter);\n        },\n        // DEPRECATED\n        watch: function (fil, eventParams, options) {\n            console.warn('eth.watch() is deprecated please use eth.filter() instead.');\n            return this.filter(fil, eventParams, options);\n        }\n        /*jshint maxparams:3 */\n    },\n\n    /// db object prototype\n    db: {},\n\n    /// shh object prototype\n    shh: {\n        /// @param filter may be a string, object or event\n        filter: function (fil) {\n            return filter(fil, shhWatch, formatters.outputPostFormatter);\n        },\n        // DEPRECATED\n        watch: function (fil) {\n            console.warn('shh.watch() is deprecated please use shh.filter() instead.');\n            return this.filter(fil);\n        }\n    }\n};\n\n\n// ADD defaultblock\nObject.defineProperty(web3.eth, 'defaultBlock', {\n    get: function () {\n        return c.ETH_DEFAULTBLOCK;\n    },\n    set: function (val) {\n        c.ETH_DEFAULTBLOCK = val;\n        return c.ETH_DEFAULTBLOCK;\n    }\n});\n\n\n/// setups all api methods\nsetupMethods(web3, web3Methods());\nsetupProperties(web3, web3Properties);\nsetupMethods(web3.net, net.methods);\nsetupProperties(web3.net, net.properties);\nsetupMethods(web3.eth, eth.methods);\nsetupProperties(web3.eth, eth.properties);\nsetupMethods(web3.db, db.methods);\nsetupMethods(web3.shh, shh.methods);\nsetupMethods(ethWatch, watches.eth());\nsetupMethods(shhWatch, watches.shh());\n\nmodule.exports = web3;\n\n",
    "/*\n    This file is part of ethereum.js.\n\n    ethereum.js is free software: you can redistribute it and/or modify\n    it under the terms of the GNU Lesser General Public License as published by\n    the Free Software Foundation, either version 3 of the License, or\n    (at your option) any later version.\n\n    ethereum.js is distributed in the hope that it will be useful,\n    but WITHOUT ANY WARRANTY; without even the implied warranty of\n    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n    GNU Lesser General Public License for more details.\n\n    You should have received a copy of the GNU Lesser General Public License\n    along with ethereum.js.  If not, see <http://www.gnu.org/licenses/>.\n*/\n/** @file contract.js\n * @authors:\n *   Marek Kotewicz <marek@ethdev.com>\n * @date 2014\n */\n\nvar web3 = require('../web3'); \nvar abi = require('../solidity/abi');\nvar utils = require('../utils/utils');\nvar eventImpl = require('./event');\nvar signature = require('./signature');\n\nvar exportNatspecGlobals = function (vars) {\n    // it's used byt natspec.js\n    // TODO: figure out better way to solve this\n    web3._currentContractAbi = vars.abi;\n    web3._currentContractAddress = vars.address;\n    web3._currentContractMethodName = vars.method;\n    web3._currentContractMethodParams = vars.params;\n};\n\nvar addFunctionRelatedPropertiesToContract = function (contract) {\n    \n    contract.call = function (options) {\n        contract._isTransaction = false;\n        contract._options = options;\n        return contract;\n    };\n\n\n    contract.sendTransaction = function (options) {\n        contract._isTransaction = true;\n        contract._options = options;\n        return contract;\n    };\n    // DEPRECATED\n    contract.transact = function (options) {\n\n        console.warn('myContract.transact() is deprecated please use myContract.sendTransaction() instead.');\n\n        return contract.sendTransaction(options);\n    };\n\n    contract._options = {};\n    ['gas', 'gasPrice', 'value', 'from'].forEach(function(p) {\n        contract[p] = function (v) {\n            contract._options[p] = v;\n            return contract;\n        };\n    });\n\n};\n\nvar addFunctionsToContract = function (contract, desc, address) {\n    var inputParser = abi.inputParser(desc);\n    var outputParser = abi.outputParser(desc);\n\n    // create contract functions\n    utils.filterFunctions(desc).forEach(function (method) {\n\n        var displayName = utils.extractDisplayName(method.name);\n        var typeName = utils.extractTypeName(method.name);\n\n        var impl = function () {\n            /*jshint maxcomplexity:7 */\n            var params = Array.prototype.slice.call(arguments);\n            var sign = signature.functionSignatureFromAscii(method.name);\n            var parsed = inputParser[displayName][typeName].apply(null, params);\n\n            var options = contract._options || {};\n            options.to = address;\n            options.data = sign + parsed;\n            \n            var isTransaction = contract._isTransaction === true || (contract._isTransaction !== false && !method.constant);\n            var collapse = options.collapse !== false;\n            \n            // reset\n            contract._options = {};\n            contract._isTransaction = null;\n\n            if (isTransaction) {\n                \n                exportNatspecGlobals({\n                    abi: desc,\n                    address: address,\n                    method: method.name,\n                    params: params\n                });\n\n                // transactions do not have any output, cause we do not know, when they will be processed\n                web3.eth.sendTransaction(options);\n                return;\n            }\n            \n            var output = web3.eth.call(options);\n            var ret = outputParser[displayName][typeName](output);\n            if (collapse)\n            {\n                if (ret.length === 1)\n                    ret = ret[0];\n                else if (ret.length === 0)\n                    ret = null;\n            }\n            return ret;\n        };\n\n        if (contract[displayName] === undefined) {\n            contract[displayName] = impl;\n        }\n\n        contract[displayName][typeName] = impl;\n    });\n};\n\nvar addEventRelatedPropertiesToContract = function (contract, desc, address) {\n    contract.address = address;\n    contract._onWatchEventResult = function (data) {\n        var matchingEvent = event.getMatchingEvent(utils.filterEvents(desc));\n        var parser = eventImpl.outputParser(matchingEvent);\n        return parser(data);\n    };\n    \n    Object.defineProperty(contract, 'topics', {\n        get: function() {\n            return utils.filterEvents(desc).map(function (e) {\n                return signature.eventSignatureFromAscii(e.name);\n            });\n        }\n    });\n\n};\n\nvar addEventsToContract = function (contract, desc, address) {\n    // create contract events\n    utils.filterEvents(desc).forEach(function (e) {\n\n        var impl = function () {\n            var params = Array.prototype.slice.call(arguments);\n            var sign = signature.eventSignatureFromAscii(e.name);\n            var event = eventImpl.inputParser(address, sign, e);\n            var o = event.apply(null, params);\n            var outputFormatter = function (data) {\n                var parser = eventImpl.outputParser(e);\n                return parser(data);\n            };\n            return web3.eth.filter(o, undefined, undefined, outputFormatter);\n        };\n        \n        // this property should be used by eth.filter to check if object is an event\n        impl._isEvent = true;\n\n        var displayName = utils.extractDisplayName(e.name);\n        var typeName = utils.extractTypeName(e.name);\n\n        if (contract[displayName] === undefined) {\n            contract[displayName] = impl;\n        }\n\n        contract[displayName][typeName] = impl;\n\n    });\n};\n\n\n/**\n * This method should be called when we want to call / transact some solidity method from javascript\n * it returns an object which has same methods available as solidity contract description\n * usage example: \n *\n * var abi = [{\n *      name: 'myMethod',\n *      inputs: [{ name: 'a', type: 'string' }],\n *      outputs: [{name: 'd', type: 'string' }]\n * }];  // contract abi\n *\n * var MyContract = web3.eth.contract(abi); // creation of contract prototype\n *\n * var contractInstance = new MyContract('0x0123123121');\n *\n * contractInstance.myMethod('this is test string param for call'); // myMethod call (implicit, default)\n * contractInstance.call().myMethod('this is test string param for call'); // myMethod call (explicit)\n * contractInstance.sendTransaction().myMethod('this is test string param for transact'); // myMethod sendTransaction\n *\n * @param abi - abi json description of the contract, which is being created\n * @returns contract object\n */\nvar contract = function (abi) {\n\n    // return prototype\n    if(abi instanceof Array && arguments.length === 1) {\n        return Contract.bind(null, abi);\n\n    // deprecated: auto initiate contract\n    } else {\n\n        console.warn('Initiating a contract like this is deprecated please use var MyContract = eth.contract(abi); new MyContract(address); instead.');\n\n        return new Contract(arguments[1], arguments[0]);\n    }\n\n};\n\nfunction Contract(abi, address) {\n\n    // workaround for invalid assumption that method.name is the full anonymous prototype of the method.\n    // it's not. it's just the name. the rest of the code assumes it's actually the anonymous\n    // prototype, so we make it so as a workaround.\n    // TODO: we may not want to modify input params, maybe use copy instead?\n    abi.forEach(function (method) {\n        if (method.name.indexOf('(') === -1) {\n            var displayName = method.name;\n            var typeName = method.inputs.map(function(i){return i.type; }).join();\n            method.name = displayName + '(' + typeName + ')';\n        }\n    });\n\n    var result = {};\n    addFunctionRelatedPropertiesToContract(result);\n    addFunctionsToContract(result, abi, address);\n    addEventRelatedPropertiesToContract(result, abi, address);\n    addEventsToContract(result, abi, address);\n\n    return result;\n}\n\nmodule.exports = contract;\n\n",
    "/*\n    This file is part of ethereum.js.\n\n    ethereum.js is free software: you can redistribute it and/or modify\n    it under the terms of the GNU Lesser General Public License as published by\n    the Free Software Foundation, either version 3 of the License, or\n    (at your option) any later version.\n\n    ethereum.js is distributed in the hope that it will be useful,\n    but WITHOUT ANY WARRANTY; without even the implied warranty of\n    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n    GNU Lesser General Public License for more details.\n\n    You should have received a copy of the GNU Lesser General Public License\n    along with ethereum.js.  If not, see <http://www.gnu.org/licenses/>.\n*/\n/** @file db.js\n * @authors:\n *   Marek Kotewicz <marek@ethdev.com>\n * @date 2015\n */\n\nvar Method = require('./method');\n\nvar putString = new Method({\n    name: 'putString',\n    call: 'db_putString',\n    params: 3\n});\n\nvar putHex = new Method({\n    name: 'putHex',\n    call: 'db_putHex',\n    params: 3\n});\n\nvar getString = new Method({\n    name: 'getString',\n    call: 'db_getString',\n    params: 2\n});\n\nvar getHex = new Method({\n    name: 'getHex',\n    call: 'db_getHex',\n    params: 2\n});\n\nvar methods = [\n    putString, putHex, getString, getHex\n];\n\nmodule.exports = {\n    methods: methods\n};\n",
    "/*\n    This file is part of ethereum.js.\n\n    ethereum.js is free software: you can redistribute it and/or modify\n    it under the terms of the GNU Lesser General Public License as published by\n    the Free Software Foundation, either version 3 of the License, or\n    (at your option) any later version.\n\n    ethereum.js is distributed in the hope that it will be useful,\n    but WITHOUT ANY WARRANTY; without even the implied warranty of\n    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n    GNU Lesser General Public License for more details.\n\n    You should have received a copy of the GNU Lesser General Public License\n    along with ethereum.js.  If not, see <http://www.gnu.org/licenses/>.\n*/\n/** \n * @file errors.js\n * @author Marek Kotewicz <marek@ethdev.com>\n * @date 2015\n */\n\nvar utils = require('../utils/utils');\n\nmodule.exports = {\n    InvalidNumberOfParams: new Error('Invalid number of input parameters'),\n    InvalidProvider: new Error('Providor not set or invalid'),\n    InvalidResponse: function(result){\n        var message = 'Invalid JSON RPC response';\n\n        if(utils.isObject(result) && result.error && result.error.message) {\n            message = result.error.message;\n        }\n\n        return new Error(message);\n    }\n};\n\n",
    "/*\n    This file is part of ethereum.js.\n\n    ethereum.js is free software: you can redistribute it and/or modify\n    it under the terms of the GNU Lesser General Public License as published by\n    the Free Software Foundation, either version 3 of the License, or\n    (at your option) any later version.\n\n    ethereum.js is distributed in the hope that it will be useful,\n    but WITHOUT ANY WARRANTY; without even the implied warranty of\n    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n    GNU Lesser General Public License for more details.\n\n    You should have received a copy of the GNU Lesser General Public License\n    along with ethereum.js.  If not, see <http://www.gnu.org/licenses/>.\n*/\n/**\n * @file eth.js\n * @author Marek Kotewicz <marek@ethdev.com>\n * @author Fabian Vogelsteller <fabian@ethdev.com>\n * @date 2015\n */\n\n/**\n * Web3\n * \n * @module web3\n */\n\n/**\n * Eth methods and properties\n *\n * An example method object can look as follows:\n *\n *      {\n *      name: 'getBlock',\n *      call: blockCall,\n *      params: 2,\n *      outputFormatter: formatters.outputBlockFormatter,\n *      inputFormatter: [ // can be a formatter funciton or an array of functions. Where each item in the array will be used for one parameter\n *           utils.toHex, // formats paramter 1\n *           function(param){ return !!param; } // formats paramter 2\n *         ]\n *       },\n *\n * @class [web3] eth\n * @constructor\n */\n\n\"use strict\";\n\nvar formatters = require('./formatters');\nvar utils = require('../utils/utils');\nvar Method = require('./method');\nvar Property = require('./property');\n\nvar blockCall = function (args) {\n    return (utils.isString(args[0]) && args[0].indexOf('0x') === 0) ? \"eth_getBlockByHash\" : \"eth_getBlockByNumber\";\n};\n\nvar transactionFromBlockCall = function (args) {\n    return (utils.isString(args[0]) && args[0].indexOf('0x') === 0) ? 'eth_getTransactionByBlockHashAndIndex' : 'eth_getTransactionByBlockNumberAndIndex';\n};\n\nvar uncleCall = function (args) {\n    return (utils.isString(args[0]) && args[0].indexOf('0x') === 0) ? 'eth_getUncleByBlockHashAndIndex' : 'eth_getUncleByBlockNumberAndIndex';\n};\n\nvar getBlockTransactionCountCall = function (args) {\n    return (utils.isString(args[0]) && args[0].indexOf('0x') === 0) ? 'eth_getBlockTransactionCountByHash' : 'eth_getBlockTransactionCountByNumber';\n};\n\nvar uncleCountCall = function (args) {\n    return (utils.isString(args[0]) && args[0].indexOf('0x') === 0) ? 'eth_getUncleCountByBlockHash' : 'eth_getUncleCountByBlockNumber';\n};\n\n/// @returns an array of objects describing web3.eth api methods\n\nvar getBalance = new Method({\n    name: 'getBalance', \n    call: 'eth_getBalance', \n    params: 2,\n    inputFormatter: [utils.toHex, formatters.inputDefaultBlockNumberFormatter],\n    outputFormatter: formatters.outputBigNumberFormatter\n});\n\nvar getStorageAt = new Method({\n    name: 'getStorageAt', \n    call: 'eth_getStorageAt', \n    params: 3,\n    inputFormatter: [null, utils.toHex, formatters.inputDefaultBlockNumberFormatter]\n});\n\nvar getCode = new Method({\n    name: 'getCode',\n    call: 'eth_getCode',\n    params: 2,\n    inputFormatter: [null, formatters.inputDefaultBlockNumberFormatter]\n});\n\nvar getBlock = new Method({\n    name: 'getBlock', \n    call: blockCall,\n    params: 2,\n    inputFormatter: [utils.toHex, function (val) { return !!val; }],\n    outputFormatter: formatters.outputBlockFormatter\n});\n\nvar getUncle = new Method({\n    name: 'getUncle',\n    call: uncleCall,\n    params: 2,\n    inputFormatter: [utils.toHex, utils.toHex, function (val) { return !!val; }],\n    outputFormatter: formatters.outputBlockFormatter,\n\n});\n\nvar getCompilers = new Method({\n    name: 'getCompilers',\n    call: 'eth_getCompilers',\n    params: 0\n});\n\nvar getBlockTransactounCount = new Method({\n    name: 'getBlockTransactionCount',\n    call: getBlockTransactionCountCall,\n    params: 1,\n    inputFormatter: [utils.toHex],\n    outputFormatter: utils.toDecimal\n});\n\nvar getBlockUncleCount = new Method({\n    name: 'getBlockUncleCount',\n    call: uncleCountCall,\n    params: 1,\n    inputFormatter: [utils.toHex],\n    outputFormatter: utils.toDecimal\n});\n\nvar getTransaction = new Method({\n    name: 'getTransaction',\n    call: 'eth_getTransactionByHash',\n    params: 1,\n    outputFormatter: formatters.outputTransactionFormatter\n});\n\nvar getTransactionFromBlock = new Method({\n    name: 'getTransactionFromBlock',\n    call: transactionFromBlockCall,\n    params: 2,\n    inputFormatter: [utils.toHex, utils.toHex],\n    outputFormatter: formatters.outputTransactionFormatter\n});\n\nvar getTransactionCount = new Method({\n    name: 'getTransactionCount',\n    call: 'eth_getTransactionCount',\n    params: 2,\n    inputFormatter: [null, formatters.inputDefaultBlockNumberFormatter],\n    outputFormatter: utils.toDecimal\n});\n\nvar sendTransaction = new Method({\n    name: 'sendTransaction',\n    call: 'eth_sendTransaction',\n    params: 1,\n    inputFormatter: [formatters.inputTransactionFormatter]\n});\n\nvar call = new Method({\n    name: 'call',\n    call: 'eth_call',\n    params: 2,\n    inputFormatter: [formatters.inputCallFormatter, formatters.inputDefaultBlockNumberFormatter]\n});\n\nvar compileSolidity = new Method({\n    name: 'compile.solidity',\n    call: 'eth_compileSolidity',\n    params: 1\n});\n\nvar compileLLL = new Method({\n    name: 'compile.lll',\n    call: 'eth_compileLLL',\n    params: 1\n});\n\nvar compileSerpent = new Method({\n    name: 'compile.serpent',\n    call: 'eth_compileSerpent',\n    params: 1\n});\n\nvar flush = new Method({\n    name: 'flush',\n    call: 'eth_flush',\n    params: 0\n});\n\nvar methods = [\n    getBalance,\n    getStorageAt,\n    getCode,\n    getBlock,\n    getUncle,\n    getCompilers,\n    getBlockTransactounCount,\n    getBlockUncleCount,\n    getTransaction,\n    getTransactionFromBlock,\n    getTransactionCount,\n    call,\n    sendTransaction,\n    compileSolidity,\n    compileLLL,\n    compileSerpent,\n    flush\n];\n\n/// @returns an array of objects describing web3.eth api properties\n\n\n\nvar properties = [\n    new Property({\n        name: 'coinbase',\n        getter: 'eth_coinbase'\n    }),\n    new Property({\n        name: 'mining',\n        getter: 'eth_mining'\n    }),\n    new Property({\n        name: 'gasPrice',\n        getter: 'eth_gasPrice',\n        outputFormatter: formatters.inputNumberFormatter\n    }),\n    new Property({\n        name: 'accounts',\n        getter: 'eth_accounts'\n    }),\n    new Property({\n        name: 'blockNumber',\n        getter: 'eth_blockNumber',\n        outputFormatter: utils.toDecimal\n    })\n];\n\nmodule.exports = {\n    methods: methods,\n    properties: properties\n};\n\n",
    "/*\n    This file is part of ethereum.js.\n\n    ethereum.js is free software: you can redistribute it and/or modify\n    it under the terms of the GNU Lesser General Public License as published by\n    the Free Software Foundation, either version 3 of the License, or\n    (at your option) any later version.\n\n    ethereum.js is distributed in the hope that it will be useful,\n    but WITHOUT ANY WARRANTY; without even the implied warranty of\n    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n    GNU Lesser General Public License for more details.\n\n    You should have received a copy of the GNU Lesser General Public License\n    along with ethereum.js.  If not, see <http://www.gnu.org/licenses/>.\n*/\n/** @file event.js\n * @authors:\n *   Marek Kotewicz <marek@ethdev.com>\n * @date 2014\n */\n\nvar abi = require('../solidity/abi');\nvar utils = require('../utils/utils');\nvar signature = require('./signature');\n\n/// filter inputs array && returns only indexed (or not) inputs\n/// @param inputs array\n/// @param bool if result should be an array of indexed params on not\n/// @returns array of (not?) indexed params\nvar filterInputs = function (inputs, indexed) {\n    return inputs.filter(function (current) {\n        return current.indexed === indexed;\n    });\n};\n\nvar inputWithName = function (inputs, name) {\n    var index = utils.findIndex(inputs, function (input) {\n        return input.name === name;\n    });\n    \n    if (index === -1) {\n        console.error('indexed param with name ' + name + ' not found');\n        return undefined;\n    }\n    return inputs[index];\n};\n\nvar indexedParamsToTopics = function (event, indexed) {\n    // sort keys?\n    return Object.keys(indexed).map(function (key) {\n        var inputs = [inputWithName(filterInputs(event.inputs, true), key)];\n\n        var value = indexed[key];\n        if (value instanceof Array) {\n            return value.map(function (v) {\n                return abi.formatInput(inputs, [v]);\n            }); \n        }\n        return abi.formatInput(inputs, [value]);\n    });\n};\n\nvar inputParser = function (address, sign, event) {\n    \n    // valid options are 'earliest', 'latest', 'offset' and 'max', as defined for 'eth.filter'\n    return function (indexed, options) {\n        var o = options || {};\n        o.address = address;\n        o.topics = [];\n        o.topics.push(sign);\n        if (indexed) {\n            o.topics = o.topics.concat(indexedParamsToTopics(event, indexed));\n        }\n        return o;\n    };\n};\n\nvar getArgumentsObject = function (inputs, indexed, notIndexed) {\n    var indexedCopy = indexed.slice();\n    var notIndexedCopy = notIndexed.slice();\n    return inputs.reduce(function (acc, current) {\n        var value;\n        if (current.indexed)\n            value = indexedCopy.splice(0, 1)[0];\n        else\n            value = notIndexedCopy.splice(0, 1)[0];\n\n        acc[current.name] = value;\n        return acc;\n    }, {}); \n};\n \nvar outputParser = function (event) {\n    \n    return function (output) {\n        var result = {\n            event: utils.extractDisplayName(event.name),\n            number: output.number,\n            hash: output.hash,\n            args: {}\n        };\n\n        output.topics = output.topic; // fallback for go-ethereum\n        if (!output.topics) {\n            return result;\n        }\n       \n        var indexedOutputs = filterInputs(event.inputs, true);\n        var indexedData = \"0x\" + output.topics.slice(1, output.topics.length).map(function (topics) { return topics.slice(2); }).join(\"\");\n        var indexedRes = abi.formatOutput(indexedOutputs, indexedData);\n\n        var notIndexedOutputs = filterInputs(event.inputs, false);\n        var notIndexedRes = abi.formatOutput(notIndexedOutputs, output.data);\n\n        result.args = getArgumentsObject(event.inputs, indexedRes, notIndexedRes);\n\n        return result;\n    };\n};\n\nvar getMatchingEvent = function (events, payload) {\n    for (var i = 0; i < events.length; i++) {\n        var sign = signature.eventSignatureFromAscii(events[i].name); \n        if (sign === payload.topics[0]) {\n            return events[i];\n        }\n    }\n    return undefined;\n};\n\n\nmodule.exports = {\n    inputParser: inputParser,\n    outputParser: outputParser,\n    getMatchingEvent: getMatchingEvent\n};\n\n",
    "/*\n    This file is part of ethereum.js.\n\n    ethereum.js is free software: you can redistribute it and/or modify\n    it under the terms of the GNU Lesser General Public License as published by\n    the Free Software Foundation, either version 3 of the License, or\n    (at your option) any later version.\n\n    ethereum.js is distributed in the hope that it will be useful,\n    but WITHOUT ANY WARRANTY; without even the implied warranty of\n    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n    GNU Lesser General Public License for more details.\n\n    You should have received a copy of the GNU Lesser General Public License\n    along with ethereum.js.  If not, see <http://www.gnu.org/licenses/>.\n*/\n/** @file filter.js\n * @authors:\n *   Jeffrey Wilcke <jeff@ethdev.com>\n *   Marek Kotewicz <marek@ethdev.com>\n *   Marian Oancea <marian@ethdev.com>\n *   Fabian Vogelsteller <fabian@ethdev.com>\n *   Gav Wood <g@ethdev.com>\n * @date 2014\n */\n\nvar utils = require('../utils/utils');\n\n/// Should be called to check if filter implementation is valid\n/// @returns true if it is, otherwise false\nvar implementationIsValid = function (i) {\n    return !!i && \n        typeof i.newFilter === 'function' && \n        typeof i.getLogs === 'function' && \n        typeof i.uninstallFilter === 'function' &&\n        typeof i.startPolling === 'function' &&\n        typeof i.stopPolling === 'function';\n};\n\n/// This method should be called on options object, to verify deprecated properties && lazy load dynamic ones\n/// @param should be string or object\n/// @returns options string or object\nvar getOptions = function (options) {\n    /*jshint maxcomplexity:9 */\n\n    if (typeof options === 'string') {\n        return options;\n    } \n\n    options = options || {};\n\n    if (options.topic) {\n        console.warn('\"topic\" is deprecated, is \"topics\" instead');\n        options.topics = options.topic;\n    }\n\n    if (options.earliest) {\n        console.warn('\"earliest\" is deprecated, is \"fromBlock\" instead');\n        options.fromBlock = options.earliest;\n    }\n\n    if (options.latest) {\n        console.warn('\"latest\" is deprecated, is \"toBlock\" instead');\n        options.toBlock = options.latest;\n    }\n\n    if (options.skip) {\n        console.warn('\"skip\" is deprecated, is \"offset\" instead');\n        options.offset = options.skip;\n    }\n\n    if (options.max) {\n        console.warn('\"max\" is deprecated, is \"limit\" instead');\n        options.limit = options.max;\n    }\n\n    // make sure topics, get converted to hex\n    if(options.topics instanceof Array) {\n        options.topics = options.topics.map(function(topic){\n            return utils.toHex(topic);\n        });\n    }\n\n\n    // evaluate lazy properties\n    return {\n        fromBlock: utils.toHex(options.fromBlock),\n        toBlock: utils.toHex(options.toBlock),\n        limit: utils.toHex(options.limit),\n        offset: utils.toHex(options.offset),\n        to: options.to,\n        address: options.address,\n        topics: options.topics\n    };\n};\n\n/// Should be used when we want to watch something\n/// it's using inner polling mechanism and is notified about changes\n/// @param options are filter options\n/// @param implementation, an abstract polling implementation\n/// @param formatter (optional), callback function which formats output before 'real' callback \nvar filter = function(options, implementation, formatter) {\n    if (!implementationIsValid(implementation)) {\n        console.error('filter implemenation is invalid');\n        return;\n    }\n\n    options = getOptions(options);\n    var callbacks = [];\n    var filterId = implementation.newFilter(options);\n\n    // call the callbacks\n    var onMessages = function (messages) {\n        messages.forEach(function (message) {\n            message = formatter ? formatter(message) : message;\n            callbacks.forEach(function (callback) {\n                callback(message);\n            });\n        });\n    };\n\n\n    var watch = function(callback) {\n        implementation.startPolling(filterId, onMessages, implementation.uninstallFilter);\n        callbacks.push(callback);\n    };\n\n    var stopWatching = function() {\n        implementation.stopPolling(filterId);\n        callbacks = [];\n    };\n\n    var uninstall = function() {\n        implementation.stopPolling(filterId);\n        implementation.uninstallFilter(filterId);\n        callbacks = [];\n    };\n\n    var get = function () {\n        var results = implementation.getLogs(filterId);\n\n        return utils.isArray(results) ? results.map(function(message){\n                return formatter ? formatter(message) : message;\n            }) : results;\n    };\n    \n    return {\n        watch: watch,\n        stopWatching: stopWatching,\n        get: get,\n        uninstall: uninstall,\n\n        // DEPRECATED methods\n        changed:  function(){\n            console.warn('watch().changed() is deprecated please use filter().watch() instead.');\n            return watch.apply(this, arguments);\n        },\n        arrived:  function(){\n            console.warn('watch().arrived() is deprecated please use filter().watch() instead.');\n            return watch.apply(this, arguments);\n        },\n        happened:  function(){\n            console.warn('watch().happened() is deprecated please use filter().watch() instead.');\n            return watch.apply(this, arguments);\n        },\n        messages: function(){\n            console.warn('watch().messages() is deprecated please use filter().get() instead.');\n            return get.apply(this, arguments);\n        },\n        logs: function(){\n            console.warn('watch().logs() is deprecated please use filter().get() instead.');\n            return get.apply(this, arguments);\n        }\n    };\n};\n\nmodule.exports = filter;\n\n",
    "/*\n    This file is part of ethereum.js.\n\n    ethereum.js is free software: you can redistribute it and/or modify\n    it under the terms of the GNU Lesser General Public License as published by\n    the Free Software Foundation, either version 3 of the License, or\n    (at your option) any later version.\n\n    ethereum.js is distributed in the hope that it will be useful,\n    but WITHOUT ANY WARRANTY; without even the implied warranty of\n    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n    GNU Lesser General Public License for more details.\n\n    You should have received a copy of the GNU Lesser General Public License\n    along with ethereum.js.  If not, see <http://www.gnu.org/licenses/>.\n*/\n/** \n * @file formatters.js\n * @author Marek Kotewicz <marek@ethdev.com>\n * @author Fabian Vogelsteller <fabian@ethdev.com>\n * @date 2015\n */\n\nvar utils = require('../utils/utils');\nvar config = require('../utils/config');\n\n/**\n * Should the format output to a big number\n *\n * @method outputBigNumberFormatter\n * @param {String|Number|BigNumber}\n * @returns {BigNumber} object\n */\nvar outputBigNumberFormatter = function (number) {\n    return utils.toBigNumber(number);\n};\n\nvar inputDefaultBlockNumberFormatter = function (blockNumber) {\n    return blockNumber === undefined ? config.ETH_DEFAULTBLOCK : utils.toHex(blockNumber); // instead use default block number here\n};\n\n/**\n * Formats the input of a transaction and converts all values to HEX\n *\n * @method inputTransactionFormatter\n * @param {Object} transaction options\n * @returns object\n*/\nvar inputTransactionFormatter = function (options){\n\n    // make code -> data\n    if (options.code) {\n        options.data = options.code;\n        delete options.code;\n    }\n\n    ['gasPrice', 'gas', 'value'].forEach(function(key){\n        options[key] = utils.fromDecimal(options[key]);\n    });\n\n    return options; \n};\n\n/**\n * Formats the output of a transaction to its proper values\n * \n * @method outputTransactionFormatter\n * @param {Object} transaction\n * @returns {Object} transaction\n*/\nvar outputTransactionFormatter = function (tx){\n    tx.blockNumber = utils.toDecimal(tx.blockNumber);\n    tx.transactionIndex = utils.toDecimal(tx.transactionIndex);\n    tx.gas = utils.toDecimal(tx.gas);\n    tx.gasPrice = utils.toBigNumber(tx.gasPrice);\n    tx.value = utils.toBigNumber(tx.value);\n    return tx;\n};\n\n/**\n * Formats the input of a call and converts all values to HEX\n *\n * @method inputCallFormatter\n * @param {Object} transaction options\n * @returns object\n*/\nvar inputCallFormatter = function (options){\n    \n    // make code -> data\n    if (options.code) {\n        options.data = options.code;\n        delete options.code;\n    }\n\n    return options; \n};\n\n/**\n * Formats the output of a block to its proper values\n *\n * @method outputBlockFormatter\n * @param {Object} block object \n * @returns {Object} block object\n*/\nvar outputBlockFormatter = function(block) {\n\n    // transform to number\n    block.gasLimit = utils.toDecimal(block.gasLimit);\n    block.gasUsed = utils.toDecimal(block.gasUsed);\n    block.size = utils.toDecimal(block.size);\n    block.timestamp = utils.toDecimal(block.timestamp);\n    block.number = utils.toDecimal(block.number);\n\n    block.minGasPrice = utils.toBigNumber(block.minGasPrice);\n    block.difficulty = utils.toBigNumber(block.difficulty);\n    block.totalDifficulty = utils.toBigNumber(block.totalDifficulty);\n\n    if (utils.isArray(block.transactions)) {\n        block.transactions.forEach(function(item){\n            if(!utils.isString(item))\n                return outputTransactionFormatter(item);\n        });\n    }\n\n    return block;\n};\n\n/**\n * Formats the output of a log\n * \n * @method outputLogFormatter\n * @param {Object} log object\n * @returns {Object} log\n*/\nvar outputLogFormatter = function(log){\n    log.blockNumber = utils.toDecimal(log.blockNumber);\n    log.transactionIndex = utils.toDecimal(log.transactionIndex);\n    log.logIndex = utils.toDecimal(log.logIndex);\n\n    return log;\n};\n\n\n/**\n * Formats the input of a whisper post and converts all values to HEX\n *\n * @method inputPostFormatter\n * @param {Object} transaction object\n * @returns {Object}\n*/\nvar inputPostFormatter = function(post){\n\n    post.payload = utils.toHex(post.payload);\n    post.ttl = utils.fromDecimal(post.ttl);\n    post.priority = utils.fromDecimal(post.priority);\n\n    if(!utils.isArray(post.topics)) {\n        post.topics = [post.topics];\n    }\n\n    // format the following options\n    post.topics = post.topics.map(function(topic){\n        return utils.fromAscii(topic);\n    });\n\n    return post; \n};\n\n/**\n * Formats the output of a received post message\n *\n * @method outputPostFormatter\n * @param {Object}\n * @returns {Object}\n */\nvar outputPostFormatter = function(post){\n\n    post.expiry = utils.toDecimal(post.expiry);\n    post.sent = utils.toDecimal(post.sent);\n    post.ttl = utils.toDecimal(post.ttl);\n    post.workProved = utils.toDecimal(post.workProved);\n    post.payloadRaw = post.payload;\n    post.payload = utils.toAscii(post.payload);\n\n    if (utils.isJson(post.payload)) {\n        post.payload = JSON.parse(post.payload);\n    }\n\n    // format the following options\n    post.topics = post.topics.map(function(topic){\n        return utils.toAscii(topic);\n    });\n\n    return post;\n};\n\nmodule.exports = {\n    inputDefaultBlockNumberFormatter: inputDefaultBlockNumberFormatter,\n    inputTransactionFormatter: inputTransactionFormatter,\n    inputCallFormatter: inputCallFormatter,\n    inputPostFormatter: inputPostFormatter,\n    outputBigNumberFormatter: outputBigNumberFormatter,\n    outputTransactionFormatter: outputTransactionFormatter,\n    outputBlockFormatter: outputBlockFormatter,\n    outputLogFormatter: outputLogFormatter,\n    outputPostFormatter: outputPostFormatter\n};\n\n",
    "/*\n    This file is part of ethereum.js.\n\n    ethereum.js is free software: you can redistribute it and/or modify\n    it under the terms of the GNU Lesser General Public License as published by\n    the Free Software Foundation, either version 3 of the License, or\n    (at your option) any later version.\n\n    ethereum.js is distributed in the hope that it will be useful,\n    but WITHOUT ANY WARRANTY; without even the implied warranty of\n    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n    GNU Lesser General Public License for more details.\n\n    You should have received a copy of the GNU Lesser General Public License\n    along with ethereum.js.  If not, see <http://www.gnu.org/licenses/>.\n*/\n/** @file httpprovider.js\n * @authors:\n *   Marek Kotewicz <marek@ethdev.com>\n *   Marian Oancea <marian@ethdev.com>\n *   Fabian Vogelsteller <fabian@ethdev.com>\n * @date 2014\n */\n\n\"use strict\";\n\nvar XMLHttpRequest = require('xmlhttprequest').XMLHttpRequest; // jshint ignore:line\n\nvar HttpProvider = function (host) {\n    this.host = host || 'http://localhost:8080';\n};\n\nHttpProvider.prototype.send = function (payload) {\n    var request = new XMLHttpRequest();\n\n    request.open('POST', this.host, false);\n    request.send(JSON.stringify(payload));\n\n    // check request.status\n    // TODO: throw an error here! it cannot silently fail!!!\n    //if (request.status !== 200) {\n        //return;\n    //}\n    return JSON.parse(request.responseText);\n};\n\nHttpProvider.prototype.sendAsync = function (payload, callback) {\n    var request = new XMLHttpRequest();\n    request.onreadystatechange = function() {\n        if (request.readyState === 4) {\n            // TODO: handle the error properly here!!!\n            callback(null, JSON.parse(request.responseText));\n        }\n    };\n\n    request.open('POST', this.host, true);\n    request.send(JSON.stringify(payload));\n};\n\nmodule.exports = HttpProvider;\n\n",
    "/*\n    This file is part of ethereum.js.\n\n    ethereum.js is free software: you can redistribute it and/or modify\n    it under the terms of the GNU Lesser General Public License as published by\n    the Free Software Foundation, either version 3 of the License, or\n    (at your option) any later version.\n\n    ethereum.js is distributed in the hope that it will be useful,\n    but WITHOUT ANY WARRANTY; without even the implied warranty of\n    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n    GNU Lesser General Public License for more details.\n\n    You should have received a copy of the GNU Lesser General Public License\n    along with ethereum.js.  If not, see <http://www.gnu.org/licenses/>.\n*/\n/** @file jsonrpc.js\n * @authors:\n *   Marek Kotewicz <marek@ethdev.com>\n * @date 2015\n */\n\nvar Jsonrpc = function () {\n    this.messageId = 1;\n};\n\n/**\n * Should be called to valid json create payload object\n *\n * @method toPayload\n * @param {Function} method of jsonrpc call, required\n * @param {Array} params, an array of method params, optional\n * @returns {Object} valid jsonrpc payload object\n */\nJsonrpc.prototype.toPayload = function (method, params) {\n    if (!method)\n        console.error('jsonrpc method should be specified!');\n\n    return {\n        jsonrpc: '2.0',\n        method: method,\n        params: params || [],\n        id: this.messageId++\n    }; \n};\n\n/**\n * Should be called to check if jsonrpc response is valid\n *\n * @method isValidResponse\n * @param {Object}\n * @returns {Boolean} true if response is valid, otherwise false \n */\nJsonrpc.prototype.isValidResponse = function (response) {\n    return !!response &&\n        !response.error &&\n        response.jsonrpc === '2.0' &&\n        typeof response.id === 'number' &&\n        response.result !== undefined; // only undefined is not valid json object\n};\n\n/**\n * Should be called to create batch payload object\n *\n * @method toBatchPayload\n * @param {Array} messages, an array of objects with method (required) and params (optional) fields\n * @returns {Array} batch payload\n */\nJsonrpc.prototype.toBatchPayload = function (messages) {\n    var self = this;\n    return messages.map(function (message) {\n        return self.toPayload(message.method, message.params);\n    }); \n};\n\nmodule.exports = Jsonrpc;\n\n",
    "/*\n    This file is part of ethereum.js.\n\n    ethereum.js is free software: you can redistribute it and/or modify\n    it under the terms of the GNU Lesser General Public License as published by\n    the Free Software Foundation, either version 3 of the License, or\n    (at your option) any later version.\n\n    ethereum.js is distributed in the hope that it will be useful,\n    but WITHOUT ANY WARRANTY; without even the implied warranty of\n    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n    GNU Lesser General Public License for more details.\n\n    You should have received a copy of the GNU Lesser General Public License\n    along with ethereum.js.  If not, see <http://www.gnu.org/licenses/>.\n*/\n/**\n * @file method.js\n * @author Marek Kotewicz <marek@ethdev.com>\n * @date 2015\n */\n\nvar utils = require('../utils/utils');\nvar errors = require('./errors');\n\nvar Method = function (options) {\n    this.name = options.name;\n    this.call = options.call;\n    this.params = options.params || 0;\n    this.inputFormatter = options.inputFormatter;\n    this.outputFormatter = options.outputFormatter;\n};\n\n/**\n * Should be used to determine name of the jsonrpc method based on arguments\n *\n * @method getCall\n * @param {Array} arguments\n * @return {String} name of jsonrpc method\n */\nMethod.prototype.getCall = function (args) {\n    return utils.isFunction(this.call) ? this.call(args) : this.call;\n};\n\n/**\n * Should be used to extract callback from array of arguments. Modifies input param\n *\n * @method extractCallback\n * @param {Array} arguments\n * @return {Function|Null} callback, if exists\n */\nMethod.prototype.extractCallback = function (args) {\n    if (utils.isFunction(args[args.length - 1])) {\n        return args.pop(); // modify the args array!\n    }\n    return null;\n};\n\n/**\n * Should be called to check if the number of arguments is correct\n * \n * @method validateArgs\n * @param {Array} arguments\n * @throws {Error} if it is not\n */\nMethod.prototype.validateArgs = function (args) {\n    if (args.length !== this.params) {\n        throw errors.InvalidNumberOfParams;\n    }\n};\n\n/**\n * Should be called to format input args of method\n * \n * @method formatInput\n * @param {Array}\n * @return {Array}\n */\nMethod.prototype.formatInput = function (args) {\n    if (!this.inputFormatter) {\n        return args;\n    }\n\n    return this.inputFormatter.map(function (formatter, index) {\n        return formatter ? formatter(args[index]) : args[index];\n    });\n};\n\n/**\n * Should be called to format output(result) of method\n *\n * @method formatOutput\n * @param {Object}\n * @return {Object}\n */\nMethod.prototype.formatOutput = function (result) {\n    return this.outputFormatter && result !== null ? this.outputFormatter(result) : result;\n};\n\n/**\n * Should attach function to method\n * \n * @method attachToObject\n * @param {Object}\n * @param {Function}\n */\nMethod.prototype.attachToObject = function (obj, func) {\n    var name = this.name.split('.');\n    if (name.length > 1) {\n        obj[name[0]] = obj[name[0]] || {};\n        obj[name[0]][name[1]] = func;\n    } else {\n        obj[name[0]] = func; \n    }\n};\n\nmodule.exports = Method;\n\n",
    "/*\n    This file is part of ethereum.js.\n\n    ethereum.js is free software: you can redistribute it and/or modify\n    it under the terms of the GNU Lesser General Public License as published by\n    the Free Software Foundation, either version 3 of the License, or\n    (at your option) any later version.\n\n    ethereum.js is distributed in the hope that it will be useful,\n    but WITHOUT ANY WARRANTY; without even the implied warranty of\n    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n    GNU Lesser General Public License for more details.\n\n    You should have received a copy of the GNU Lesser General Public License\n    along with ethereum.js.  If not, see <http://www.gnu.org/licenses/>.\n*/\n/** @file eth.js\n * @authors:\n *   Marek Kotewicz <marek@ethdev.com>\n * @date 2015\n */\n\nvar utils = require('../utils/utils');\nvar Property = require('./property');\n\n/// @returns an array of objects describing web3.eth api methods\nvar methods = [\n];\n\n/// @returns an array of objects describing web3.eth api properties\nvar properties = [\n    new Property({\n        name: 'listening',\n        getter: 'net_listening'\n    }),\n    new Property({\n        name: 'peerCount',\n        getter: 'net_peerCount',\n        outputFormatter: utils.toDecimal\n    })\n];\n\n\nmodule.exports = {\n    methods: methods,\n    properties: properties\n};\n\n",
    "/*\n    This file is part of ethereum.js.\n\n    ethereum.js is free software: you can redistribute it and/or modify\n    it under the terms of the GNU Lesser General Public License as published by\n    the Free Software Foundation, either version 3 of the License, or\n    (at your option) any later version.\n\n    ethereum.js is distributed in the hope that it will be useful,\n    but WITHOUT ANY WARRANTY; without even the implied warranty of\n    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n    GNU Lesser General Public License for more details.\n\n    You should have received a copy of the GNU Lesser General Public License\n    along with ethereum.js.  If not, see <http://www.gnu.org/licenses/>.\n*/\n/**\n * @file property.js\n * @author Fabian Vogelsteller <fabian@frozeman.de>\n * @date 2015\n */\n\nvar utils = require('../utils/utils');\nvar errors = require('./errors');\n\nvar Property = function (options) {\n    this.name = options.name;\n    this.getter = options.getter;\n    this.setter = options.setter;\n    this.outputFormatter = options.outputFormatter;\n    this.inputFormatter = options.inputFormatter;\n};\n\n/**\n * Should be called to format input args of method\n * \n * @method formatInput\n * @param {Array}\n * @return {Array}\n */\nProperty.prototype.formatInput = function (arg) {\n    return this.inputFormatter ? this.inputFormatter(arg) : arg;\n};\n\n/**\n * Should be called to format output(result) of method\n *\n * @method formatOutput\n * @param {Object}\n * @return {Object}\n */\nProperty.prototype.formatOutput = function (result) {\n    return this.outputFormatter && result !== null ? this.outputFormatter(result) : result;\n};\n\n/**\n * Should attach function to method\n * \n * @method attachToObject\n * @param {Object}\n * @param {Function}\n */\nProperty.prototype.attachToObject = function (obj, proto) {\n    var name = this.name.split('.');\n    if (name.length > 1) {\n        obj[name[0]] = obj[name[0]] || {};\n\n        Object.defineProperty(obj[name[0]], name[1], proto); \n    } else {\n        Object.defineProperty(obj, name[0], proto);\n    }\n};\n\nmodule.exports = Property;\n\n",
    "/*\n    This file is part of ethereum.js.\n\n    ethereum.js is free software: you can redistribute it and/or modify\n    it under the terms of the GNU Lesser General Public License as published by\n    the Free Software Foundation, either version 3 of the License, or\n    (at your option) any later version.\n\n    ethereum.js is distributed in the hope that it will be useful,\n    but WITHOUT ANY WARRANTY; without even the implied warranty of\n    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n    GNU Lesser General Public License for more details.\n\n    You should have received a copy of the GNU Lesser General Public License\n    along with ethereum.js.  If not, see <http://www.gnu.org/licenses/>.\n*/\n/** @file qtsync.js\n * @authors:\n *   Marek Kotewicz <marek@ethdev.com>\n *   Marian Oancea <marian@ethdev.com>\n * @date 2014\n */\n\nvar QtSyncProvider = function () {\n};\n\nQtSyncProvider.prototype.send = function (payload) {\n    var result = navigator.qt.callMethod(JSON.stringify(payload));\n    return JSON.parse(result);\n};\n\nmodule.exports = QtSyncProvider;\n\n",
    "/*\n    This file is part of ethereum.js.\n\n    ethereum.js is free software: you can redistribute it and/or modify\n    it under the terms of the GNU Lesser General Public License as published by\n    the Free Software Foundation, either version 3 of the License, or\n    (at your option) any later version.\n\n    ethereum.js is distributed in the hope that it will be useful,\n    but WITHOUT ANY WARRANTY; without even the implied warranty of\n    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n    GNU Lesser General Public License for more details.\n\n    You should have received a copy of the GNU Lesser General Public License\n    along with ethereum.js.  If not, see <http://www.gnu.org/licenses/>.\n*/\n/** \n * @file requestmanager.js\n * @author Jeffrey Wilcke <jeff@ethdev.com>\n * @author Marek Kotewicz <marek@ethdev.com>\n * @author Marian Oancea <marian@ethdev.com>\n * @author Fabian Vogelsteller <fabian@ethdev.com>\n * @author Gav Wood <g@ethdev.com>\n * @date 2014\n */\n\nvar Jsonrpc = require('./jsonrpc');\nvar utils = require('../utils/utils');\nvar c = require('../utils/config');\nvar errors = require('./errors');\n\n/**\n * It's responsible for passing messages to providers\n * It's also responsible for polling the ethereum node for incoming messages\n * Default poll timeout is 1 second\n */\nvar RequestManager = function(provider) {\n    this.jsonrpc = new Jsonrpc();\n    this.provider = provider;\n    this.polls = [];\n    this.timeout = null;\n    this.poll();\n};\n\n/**\n * Should be used to synchronously send request\n *\n * @method send\n * @param {Object} data\n * @return {Object}\n */\nRequestManager.prototype.send = function (data) {\n    if (!this.provider) {\n        console.error(errors.InvalidProvider);\n        return null;\n    }\n\n    var payload = this.jsonrpc.toPayload(data.method, data.params);\n    var result = this.provider.send(payload);\n\n    if (!this.jsonrpc.isValidResponse(result)) {\n        throw errors.InvalidResponse(result);\n    }\n\n    return result.result;\n};\n\n/**\n * Should be used to asynchronously send request\n *\n * @method sendAsync\n * @param {Object} data\n * @param {Function} callback\n */\nRequestManager.prototype.sendAsync = function (data, callback) {\n    if (!this.provider) {\n        return callback(errors.InvalidProvider);\n    }\n\n    var payload = this.jsonrpc.toPayload(data.method, data.params);\n    var self = this;\n    this.provider.sendAsync(payload, function (err, result) {\n        if (err) {\n            return callback(err);\n        }\n        \n        if (!self.jsonrpc.isValidResponse(result)) {\n            return callback(errors.InvalidResponse(result));\n        }\n\n        callback(null, result.result);\n    });\n};\n\n/**\n * Should be used to set provider of request manager\n *\n * @method setProvider\n * @param {Object}\n */\nRequestManager.prototype.setProvider = function (p) {\n    this.provider = p;\n};\n\n/*jshint maxparams:4 */\n\n/**\n * Should be used to start polling\n *\n * @method startPolling\n * @param {Object} data\n * @param {Number} pollId\n * @param {Function} callback\n * @param {Function} uninstall\n *\n * @todo cleanup number of params\n */\nRequestManager.prototype.startPolling = function (data, pollId, callback, uninstall) {\n    this.polls.push({data: data, id: pollId, callback: callback, uninstall: uninstall});\n};\n/*jshint maxparams:3 */\n\n/**\n * Should be used to stop polling for filter with given id\n *\n * @method stopPolling\n * @param {Number} pollId\n */\nRequestManager.prototype.stopPolling = function (pollId) {\n    for (var i = this.polls.length; i--;) {\n        var poll = this.polls[i];\n        if (poll.id === pollId) {\n            this.polls.splice(i, 1);\n        }\n    }\n};\n\n/**\n * Should be called to reset polling mechanism of request manager\n *\n * @method reset\n */\nRequestManager.prototype.reset = function () {\n    this.polls.forEach(function (poll) {\n        poll.uninstall(poll.id); \n    });\n    this.polls = [];\n\n    if (this.timeout) {\n        clearTimeout(this.timeout);\n        this.timeout = null;\n    }\n    this.poll();\n};\n\n/**\n * Should be called to poll for changes on filter with given id\n *\n * @method poll\n */\nRequestManager.prototype.poll = function () {\n    this.timeout = setTimeout(this.poll.bind(this), c.ETH_POLLING_TIMEOUT);\n\n    if (!this.polls.length) {\n        return;\n    }\n\n    if (!this.provider) {\n        console.error(errors.InvalidProvider);\n        return;\n    }\n\n    var payload = this.jsonrpc.toBatchPayload(this.polls.map(function (data) {\n        return data.data;\n    }));\n\n    var self = this;\n    this.provider.sendAsync(payload, function (error, results) {\n        // TODO: console log?\n        if (error) {\n            return;\n        }\n            \n        if (!utils.isArray(results)) {\n            throw errors.InvalidResponse(results);\n        }\n\n        results.map(function (result, index) {\n            result.callback = self.polls[index].callback;\n            return result;\n        }).filter(function (result) {\n            var valid = self.jsonrpc.isValidResponse(result);\n            if (!valid) {\n                result.callback(errors.InvalidResponse(result));\n            }\n            return valid;\n        }).filter(function (result) {\n            return utils.isArray(result.result) && result.result.length > 0;\n        }).forEach(function (result) {\n            result.callback(null, result);\n        });\n    });\n};\n\nmodule.exports = RequestManager;\n\n",
    "/*\n    This file is part of ethereum.js.\n\n    ethereum.js is free software: you can redistribute it and/or modify\n    it under the terms of the GNU Lesser General Public License as published by\n    the Free Software Foundation, either version 3 of the License, or\n    (at your option) any later version.\n\n    ethereum.js is distributed in the hope that it will be useful,\n    but WITHOUT ANY WARRANTY; without even the implied warranty of\n    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n    GNU Lesser General Public License for more details.\n\n    You should have received a copy of the GNU Lesser General Public License\n    along with ethereum.js.  If not, see <http://www.gnu.org/licenses/>.\n*/\n/** @file shh.js\n * @authors:\n *   Marek Kotewicz <marek@ethdev.com>\n * @date 2015\n */\n\nvar Method = require('./method');\nvar formatters = require('./formatters');\n\nvar post = new Method({\n    name: 'post', \n    call: 'shh_post', \n    params: 1,\n    inputFormatter: formatters.inputPostFormatter\n});\n\nvar newIdentity = new Method({\n    name: 'newIdentity',\n    call: 'shh_newIdentity',\n    params: 0\n});\n\nvar hasIdentity = new Method({\n    name: 'hasIdentity',\n    call: 'shh_hasIdentity',\n    params: 1\n});\n\nvar newGroup = new Method({\n    name: 'newGroup',\n    call: 'shh_newGroup',\n    params: 0\n});\n\nvar addToGroup = new Method({\n    name: 'addToGroup',\n    call: 'shh_addToGroup',\n    params: 0\n});\n\nvar methods = [\n    post,\n    newIdentity,\n    hasIdentity,\n    newGroup,\n    addToGroup\n];\n\nmodule.exports = {\n    methods: methods\n};\n\n",
    "/*\n    This file is part of ethereum.js.\n\n    ethereum.js is free software: you can redistribute it and/or modify\n    it under the terms of the GNU Lesser General Public License as published by\n    the Free Software Foundation, either version 3 of the License, or\n    (at your option) any later version.\n\n    ethereum.js is distributed in the hope that it will be useful,\n    but WITHOUT ANY WARRANTY; without even the implied warranty of\n    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n    GNU Lesser General Public License for more details.\n\n    You should have received a copy of the GNU Lesser General Public License\n    along with ethereum.js.  If not, see <http://www.gnu.org/licenses/>.\n*/\n/** @file signature.js\n * @authors:\n *   Marek Kotewicz <marek@ethdev.com>\n * @date 2015\n */\n\nvar web3 = require('../web3'); \nvar c = require('../utils/config');\n\n/// @param function name for which we want to get signature\n/// @returns signature of function with given name\nvar functionSignatureFromAscii = function (name) {\n    return web3.sha3(web3.fromAscii(name)).slice(0, 2 + c.ETH_SIGNATURE_LENGTH * 2);\n};\n\n/// @param event name for which we want to get signature\n/// @returns signature of event with given name\nvar eventSignatureFromAscii = function (name) {\n    return web3.sha3(web3.fromAscii(name));\n};\n\nmodule.exports = {\n    functionSignatureFromAscii: functionSignatureFromAscii,\n    eventSignatureFromAscii: eventSignatureFromAscii\n};\n\n",
    "/*\n    This file is part of ethereum.js.\n\n    ethereum.js is free software: you can redistribute it and/or modify\n    it under the terms of the GNU Lesser General Public License as published by\n    the Free Software Foundation, either version 3 of the License, or\n    (at your option) any later version.\n\n    ethereum.js is distributed in the hope that it will be useful,\n    but WITHOUT ANY WARRANTY; without even the implied warranty of\n    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n    GNU Lesser General Public License for more details.\n\n    You should have received a copy of the GNU Lesser General Public License\n    along with ethereum.js.  If not, see <http://www.gnu.org/licenses/>.\n*/\n/** @file watches.js\n * @authors:\n *   Marek Kotewicz <marek@ethdev.com>\n * @date 2015\n */\n\nvar Method = require('./method');\n\n/// @returns an array of objects describing web3.eth.filter api methods\nvar eth = function () {\n    var newFilterCall = function (args) {\n        return typeof args[0] === 'string' ? 'eth_newBlockFilter' : 'eth_newFilter';\n    };\n\n    var newFilter = new Method({\n        name: 'newFilter',\n        call: newFilterCall,\n        params: 1\n    });\n\n    var uninstallFilter = new Method({\n        name: 'uninstallFilter',\n        call: 'eth_uninstallFilter',\n        params: 1\n    });\n\n    var getLogs = new Method({\n        name: 'getLogs',\n        call: 'eth_getFilterLogs',\n        params: 1\n    });\n\n    return [\n        newFilter,\n        uninstallFilter,\n        getLogs\n    ];\n};\n\n/// @returns an array of objects describing web3.shh.watch api methods\nvar shh = function () {\n    var newFilter = new Method({\n        name: 'newFilter',\n        call: 'shh_newFilter',\n        params: 1\n    });\n\n    var uninstallFilter = new Method({\n        name: 'uninstallFilter',\n        call: 'shh_uninstallFilter',\n        params: 1\n    });\n\n    var getLogs = new Method({\n        name: 'getLogs',\n        call: 'shh_getMessages',\n        params: 1\n    });\n\n    return [\n        newFilter,\n        uninstallFilter,\n        getLogs\n    ];\n};\n\nmodule.exports = {\n    eth: eth,\n    shh: shh\n};\n\n",
    null,
    "/*! bignumber.js v2.0.3 https://github.com/MikeMcl/bignumber.js/LICENCE */\r\n\r\n;(function (global) {\r\n    'use strict';\r\n\r\n    /*\r\n      bignumber.js v2.0.3\r\n      A JavaScript library for arbitrary-precision arithmetic.\r\n      https://github.com/MikeMcl/bignumber.js\r\n      Copyright (c) 2015 Michael Mclaughlin <M8ch88l@gmail.com>\r\n      MIT Expat Licence\r\n    */\r\n\r\n\r\n    var BigNumber, crypto, parseNumeric,\r\n        isNumeric = /^-?(\\d+(\\.\\d*)?|\\.\\d+)(e[+-]?\\d+)?$/i,\r\n        mathceil = Math.ceil,\r\n        mathfloor = Math.floor,\r\n        notBool = ' not a boolean or binary digit',\r\n        roundingMode = 'rounding mode',\r\n        tooManyDigits = 'number type has more than 15 significant digits',\r\n        ALPHABET = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ$_',\r\n        BASE = 1e14,\r\n        LOG_BASE = 14,\r\n        MAX_SAFE_INTEGER = 0x1fffffffffffff,         // 2^53 - 1\r\n        // MAX_INT32 = 0x7fffffff,                   // 2^31 - 1\r\n        POWS_TEN = [1, 10, 100, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9, 1e10, 1e11, 1e12, 1e13],\r\n        SQRT_BASE = 1e7,\r\n\r\n        /*\r\n         * The limit on the value of DECIMAL_PLACES, TO_EXP_NEG, TO_EXP_POS, MIN_EXP, MAX_EXP, and\r\n         * the arguments to toExponential, toFixed, toFormat, and toPrecision, beyond which an\r\n         * exception is thrown (if ERRORS is true).\r\n         */\r\n        MAX = 1E9;                                   // 0 to MAX_INT32\r\n\r\n\r\n    /*\r\n     * Create and return a BigNumber constructor.\r\n     */\r\n    function another(configObj) {\r\n        var div,\r\n\r\n            // id tracks the caller function, so its name can be included in error messages.\r\n            id = 0,\r\n            P = BigNumber.prototype,\r\n            ONE = new BigNumber(1),\r\n\r\n\r\n            /********************************* EDITABLE DEFAULTS **********************************/\r\n\r\n\r\n            /*\r\n             * The default values below must be integers within the inclusive ranges stated.\r\n             * The values can also be changed at run-time using BigNumber.config.\r\n             */\r\n\r\n            // The maximum number of decimal places for operations involving division.\r\n            DECIMAL_PLACES = 20,                     // 0 to MAX\r\n\r\n            /*\r\n             * The rounding mode used when rounding to the above decimal places, and when using\r\n             * toExponential, toFixed, toFormat and toPrecision, and round (default value).\r\n             * UP         0 Away from zero.\r\n             * DOWN       1 Towards zero.\r\n             * CEIL       2 Towards +Infinity.\r\n             * FLOOR      3 Towards -Infinity.\r\n             * HALF_UP    4 Towards nearest neighbour. If equidistant, up.\r\n             * HALF_DOWN  5 Towards nearest neighbour. If equidistant, down.\r\n             * HALF_EVEN  6 Towards nearest neighbour. If equidistant, towards even neighbour.\r\n             * HALF_CEIL  7 Towards nearest neighbour. If equidistant, towards +Infinity.\r\n             * HALF_FLOOR 8 Towards nearest neighbour. If equidistant, towards -Infinity.\r\n             */\r\n            ROUNDING_MODE = 4,                       // 0 to 8\r\n\r\n            // EXPONENTIAL_AT : [TO_EXP_NEG , TO_EXP_POS]\r\n\r\n            // The exponent value at and beneath which toString returns exponential notation.\r\n            // Number type: -7\r\n            TO_EXP_NEG = -7,                         // 0 to -MAX\r\n\r\n            // The exponent value at and above which toString returns exponential notation.\r\n            // Number type: 21\r\n            TO_EXP_POS = 21,                         // 0 to MAX\r\n\r\n            // RANGE : [MIN_EXP, MAX_EXP]\r\n\r\n            // The minimum exponent value, beneath which underflow to zero occurs.\r\n            // Number type: -324  (5e-324)\r\n            MIN_EXP = -1e7,                          // -1 to -MAX\r\n\r\n            // The maximum exponent value, above which overflow to Infinity occurs.\r\n            // Number type:  308  (1.7976931348623157e+308)\r\n            // For MAX_EXP > 1e7, e.g. new BigNumber('1e100000000').plus(1) may be slow.\r\n            MAX_EXP = 1e7,                           // 1 to MAX\r\n\r\n            // Whether BigNumber Errors are ever thrown.\r\n            ERRORS = true,                           // true or false\r\n\r\n            // Change to intValidatorNoErrors if ERRORS is false.\r\n            isValidInt = intValidatorWithErrors,     // intValidatorWithErrors/intValidatorNoErrors\r\n\r\n            // Whether to use cryptographically-secure random number generation, if available.\r\n            CRYPTO = false,                          // true or false\r\n\r\n            /*\r\n             * The modulo mode used when calculating the modulus: a mod n.\r\n             * The quotient (q = a / n) is calculated according to the corresponding rounding mode.\r\n             * The remainder (r) is calculated as: r = a - n * q.\r\n             *\r\n             * UP        0 The remainder is positive if the dividend is negative, else is negative.\r\n             * DOWN      1 The remainder has the same sign as the dividend.\r\n             *             This modulo mode is commonly known as 'truncated division' and is\r\n             *             equivalent to (a % n) in JavaScript.\r\n             * FLOOR     3 The remainder has the same sign as the divisor (Python %).\r\n             * HALF_EVEN 6 This modulo mode implements the IEEE 754 remainder function.\r\n             * EUCLID    9 Euclidian division. q = sign(n) * floor(a / abs(n)).\r\n             *             The remainder is always positive.\r\n             *\r\n             * The truncated division, floored division, Euclidian division and IEEE 754 remainder\r\n             * modes are commonly used for the modulus operation.\r\n             * Although the other rounding modes can also be used, they may not give useful results.\r\n             */\r\n            MODULO_MODE = 1,                         // 0 to 9\r\n\r\n            // The maximum number of significant digits of the result of the toPower operation.\r\n            // If POW_PRECISION is 0, there will be unlimited significant digits.\r\n            POW_PRECISION = 100,                     // 0 to MAX\r\n\r\n            // The format specification used by the BigNumber.prototype.toFormat method.\r\n            FORMAT = {\r\n                decimalSeparator: '.',\r\n                groupSeparator: ',',\r\n                groupSize: 3,\r\n                secondaryGroupSize: 0,\r\n                fractionGroupSeparator: '\\xA0',      // non-breaking space\r\n                fractionGroupSize: 0\r\n            };\r\n\r\n\r\n        /******************************************************************************************/\r\n\r\n\r\n        // CONSTRUCTOR\r\n\r\n\r\n        /*\r\n         * The BigNumber constructor and exported function.\r\n         * Create and return a new instance of a BigNumber object.\r\n         *\r\n         * n {number|string|BigNumber} A numeric value.\r\n         * [b] {number} The base of n. Integer, 2 to 64 inclusive.\r\n         */\r\n        function BigNumber( n, b ) {\r\n            var c, e, i, num, len, str,\r\n                x = this;\r\n\r\n            // Enable constructor usage without new.\r\n            if ( !( x instanceof BigNumber ) ) {\r\n\r\n                // 'BigNumber() constructor call without new: {n}'\r\n                if (ERRORS) raise( 26, 'constructor call without new', n );\r\n                return new BigNumber( n, b );\r\n            }\r\n\r\n            // 'new BigNumber() base not an integer: {b}'\r\n            // 'new BigNumber() base out of range: {b}'\r\n            if ( b == null || !isValidInt( b, 2, 64, id, 'base' ) ) {\r\n\r\n                // Duplicate.\r\n                if ( n instanceof BigNumber ) {\r\n                    x.s = n.s;\r\n                    x.e = n.e;\r\n                    x.c = ( n = n.c ) ? n.slice() : n;\r\n                    id = 0;\r\n                    return;\r\n                }\r\n\r\n                if ( ( num = typeof n == 'number' ) && n * 0 == 0 ) {\r\n                    x.s = 1 / n < 0 ? ( n = -n, -1 ) : 1;\r\n\r\n                    // Fast path for integers.\r\n                    if ( n === ~~n ) {\r\n                        for ( e = 0, i = n; i >= 10; i /= 10, e++ );\r\n                        x.e = e;\r\n                        x.c = [n];\r\n                        id = 0;\r\n                        return;\r\n                    }\r\n\r\n                    str = n + '';\r\n                } else {\r\n                    if ( !isNumeric.test( str = n + '' ) ) return parseNumeric( x, str, num );\r\n                    x.s = str.charCodeAt(0) === 45 ? ( str = str.slice(1), -1 ) : 1;\r\n                }\r\n            } else {\r\n                b = b | 0;\r\n                str = n + '';\r\n\r\n                // Ensure return value is rounded to DECIMAL_PLACES as with other bases.\r\n                // Allow exponential notation to be used with base 10 argument.\r\n                if ( b == 10 ) {\r\n                    x = new BigNumber( n instanceof BigNumber ? n : str );\r\n                    return round( x, DECIMAL_PLACES + x.e + 1, ROUNDING_MODE );\r\n                }\r\n\r\n                // Avoid potential interpretation of Infinity and NaN as base 44+ values.\r\n                // Any number in exponential form will fail due to the [Ee][+-].\r\n                if ( ( num = typeof n == 'number' ) && n * 0 != 0 ||\r\n                  !( new RegExp( '^-?' + ( c = '[' + ALPHABET.slice( 0, b ) + ']+' ) +\r\n                    '(?:\\\\.' + c + ')?$',b < 37 ? 'i' : '' ) ).test(str) ) {\r\n                    return parseNumeric( x, str, num, b );\r\n                }\r\n\r\n                if (num) {\r\n                    x.s = 1 / n < 0 ? ( str = str.slice(1), -1 ) : 1;\r\n\r\n                    if ( ERRORS && str.replace( /^0\\.0*|\\./, '' ).length > 15 ) {\r\n\r\n                        // 'new BigNumber() number type has more than 15 significant digits: {n}'\r\n                        raise( id, tooManyDigits, n );\r\n                    }\r\n\r\n                    // Prevent later check for length on converted number.\r\n                    num = false;\r\n                } else {\r\n                    x.s = str.charCodeAt(0) === 45 ? ( str = str.slice(1), -1 ) : 1;\r\n                }\r\n\r\n                str = convertBase( str, 10, b, x.s );\r\n            }\r\n\r\n            // Decimal point?\r\n            if ( ( e = str.indexOf('.') ) > -1 ) str = str.replace( '.', '' );\r\n\r\n            // Exponential form?\r\n            if ( ( i = str.search( /e/i ) ) > 0 ) {\r\n\r\n                // Determine exponent.\r\n                if ( e < 0 ) e = i;\r\n                e += +str.slice( i + 1 );\r\n                str = str.substring( 0, i );\r\n            } else if ( e < 0 ) {\r\n\r\n                // Integer.\r\n                e = str.length;\r\n            }\r\n\r\n            // Determine leading zeros.\r\n            for ( i = 0; str.charCodeAt(i) === 48; i++ );\r\n\r\n            // Determine trailing zeros.\r\n            for ( len = str.length; str.charCodeAt(--len) === 48; );\r\n            str = str.slice( i, len + 1 );\r\n\r\n            if (str) {\r\n                len = str.length;\r\n\r\n                // Disallow numbers with over 15 significant digits if number type.\r\n                // 'new BigNumber() number type has more than 15 significant digits: {n}'\r\n                if ( num && ERRORS && len > 15 ) raise( id, tooManyDigits, x.s * n );\r\n\r\n                e = e - i - 1;\r\n\r\n                 // Overflow?\r\n                if ( e > MAX_EXP ) {\r\n\r\n                    // Infinity.\r\n                    x.c = x.e = null;\r\n\r\n                // Underflow?\r\n                } else if ( e < MIN_EXP ) {\r\n\r\n                    // Zero.\r\n                    x.c = [ x.e = 0 ];\r\n                } else {\r\n                    x.e = e;\r\n                    x.c = [];\r\n\r\n                    // Transform base\r\n\r\n                    // e is the base 10 exponent.\r\n                    // i is where to slice str to get the first element of the coefficient array.\r\n                    i = ( e + 1 ) % LOG_BASE;\r\n                    if ( e < 0 ) i += LOG_BASE;\r\n\r\n                    if ( i < len ) {\r\n                        if (i) x.c.push( +str.slice( 0, i ) );\r\n\r\n                        for ( len -= LOG_BASE; i < len; ) {\r\n                            x.c.push( +str.slice( i, i += LOG_BASE ) );\r\n                        }\r\n\r\n                        str = str.slice(i);\r\n                        i = LOG_BASE - str.length;\r\n                    } else {\r\n                        i -= len;\r\n                    }\r\n\r\n                    for ( ; i--; str += '0' );\r\n                    x.c.push( +str );\r\n                }\r\n            } else {\r\n\r\n                // Zero.\r\n                x.c = [ x.e = 0 ];\r\n            }\r\n\r\n            id = 0;\r\n        }\r\n\r\n\r\n        // CONSTRUCTOR PROPERTIES\r\n\r\n\r\n        BigNumber.another = another;\r\n\r\n        BigNumber.ROUND_UP = 0;\r\n        BigNumber.ROUND_DOWN = 1;\r\n        BigNumber.ROUND_CEIL = 2;\r\n        BigNumber.ROUND_FLOOR = 3;\r\n        BigNumber.ROUND_HALF_UP = 4;\r\n        BigNumber.ROUND_HALF_DOWN = 5;\r\n        BigNumber.ROUND_HALF_EVEN = 6;\r\n        BigNumber.ROUND_HALF_CEIL = 7;\r\n        BigNumber.ROUND_HALF_FLOOR = 8;\r\n        BigNumber.EUCLID = 9;\r\n\r\n\r\n        /*\r\n         * Configure infrequently-changing library-wide settings.\r\n         *\r\n         * Accept an object or an argument list, with one or many of the following properties or\r\n         * parameters respectively:\r\n         *\r\n         *   DECIMAL_PLACES  {number}  Integer, 0 to MAX inclusive\r\n         *   ROUNDING_MODE   {number}  Integer, 0 to 8 inclusive\r\n         *   EXPONENTIAL_AT  {number|number[]}  Integer, -MAX to MAX inclusive or\r\n         *                                      [integer -MAX to 0 incl., 0 to MAX incl.]\r\n         *   RANGE           {number|number[]}  Non-zero integer, -MAX to MAX inclusive or\r\n         *                                      [integer -MAX to -1 incl., integer 1 to MAX incl.]\r\n         *   ERRORS          {boolean|number}   true, false, 1 or 0\r\n         *   CRYPTO          {boolean|number}   true, false, 1 or 0\r\n         *   MODULO_MODE     {number}           0 to 9 inclusive\r\n         *   POW_PRECISION   {number}           0 to MAX inclusive\r\n         *   FORMAT          {object}           See BigNumber.prototype.toFormat\r\n         *      decimalSeparator       {string}\r\n         *      groupSeparator         {string}\r\n         *      groupSize              {number}\r\n         *      secondaryGroupSize     {number}\r\n         *      fractionGroupSeparator {string}\r\n         *      fractionGroupSize      {number}\r\n         *\r\n         * (The values assigned to the above FORMAT object properties are not checked for validity.)\r\n         *\r\n         * E.g.\r\n         * BigNumber.config(20, 4) is equivalent to\r\n         * BigNumber.config({ DECIMAL_PLACES : 20, ROUNDING_MODE : 4 })\r\n         *\r\n         * Ignore properties/parameters set to null or undefined.\r\n         * Return an object with the properties current values.\r\n         */\r\n        BigNumber.config = function () {\r\n            var v, p,\r\n                i = 0,\r\n                r = {},\r\n                a = arguments,\r\n                o = a[0],\r\n                has = o && typeof o == 'object'\r\n                  ? function () { if ( o.hasOwnProperty(p) ) return ( v = o[p] ) != null; }\r\n                  : function () { if ( a.length > i ) return ( v = a[i++] ) != null; };\r\n\r\n            // DECIMAL_PLACES {number} Integer, 0 to MAX inclusive.\r\n            // 'config() DECIMAL_PLACES not an integer: {v}'\r\n            // 'config() DECIMAL_PLACES out of range: {v}'\r\n            if ( has( p = 'DECIMAL_PLACES' ) && isValidInt( v, 0, MAX, 2, p ) ) {\r\n                DECIMAL_PLACES = v | 0;\r\n            }\r\n            r[p] = DECIMAL_PLACES;\r\n\r\n            // ROUNDING_MODE {number} Integer, 0 to 8 inclusive.\r\n            // 'config() ROUNDING_MODE not an integer: {v}'\r\n            // 'config() ROUNDING_MODE out of range: {v}'\r\n            if ( has( p = 'ROUNDING_MODE' ) && isValidInt( v, 0, 8, 2, p ) ) {\r\n                ROUNDING_MODE = v | 0;\r\n            }\r\n            r[p] = ROUNDING_MODE;\r\n\r\n            // EXPONENTIAL_AT {number|number[]}\r\n            // Integer, -MAX to MAX inclusive or [integer -MAX to 0 inclusive, 0 to MAX inclusive].\r\n            // 'config() EXPONENTIAL_AT not an integer: {v}'\r\n            // 'config() EXPONENTIAL_AT out of range: {v}'\r\n            if ( has( p = 'EXPONENTIAL_AT' ) ) {\r\n\r\n                if ( isArray(v) ) {\r\n                    if ( isValidInt( v[0], -MAX, 0, 2, p ) && isValidInt( v[1], 0, MAX, 2, p ) ) {\r\n                        TO_EXP_NEG = v[0] | 0;\r\n                        TO_EXP_POS = v[1] | 0;\r\n                    }\r\n                } else if ( isValidInt( v, -MAX, MAX, 2, p ) ) {\r\n                    TO_EXP_NEG = -( TO_EXP_POS = ( v < 0 ? -v : v ) | 0 );\r\n                }\r\n            }\r\n            r[p] = [ TO_EXP_NEG, TO_EXP_POS ];\r\n\r\n            // RANGE {number|number[]} Non-zero integer, -MAX to MAX inclusive or\r\n            // [integer -MAX to -1 inclusive, integer 1 to MAX inclusive].\r\n            // 'config() RANGE not an integer: {v}'\r\n            // 'config() RANGE cannot be zero: {v}'\r\n            // 'config() RANGE out of range: {v}'\r\n            if ( has( p = 'RANGE' ) ) {\r\n\r\n                if ( isArray(v) ) {\r\n                    if ( isValidInt( v[0], -MAX, -1, 2, p ) && isValidInt( v[1], 1, MAX, 2, p ) ) {\r\n                        MIN_EXP = v[0] | 0;\r\n                        MAX_EXP = v[1] | 0;\r\n                    }\r\n                } else if ( isValidInt( v, -MAX, MAX, 2, p ) ) {\r\n                    if ( v | 0 ) MIN_EXP = -( MAX_EXP = ( v < 0 ? -v : v ) | 0 );\r\n                    else if (ERRORS) raise( 2, p + ' cannot be zero', v );\r\n                }\r\n            }\r\n            r[p] = [ MIN_EXP, MAX_EXP ];\r\n\r\n            // ERRORS {boolean|number} true, false, 1 or 0.\r\n            // 'config() ERRORS not a boolean or binary digit: {v}'\r\n            if ( has( p = 'ERRORS' ) ) {\r\n\r\n                if ( v === !!v || v === 1 || v === 0 ) {\r\n                    id = 0;\r\n                    isValidInt = ( ERRORS = !!v ) ? intValidatorWithErrors : intValidatorNoErrors;\r\n                } else if (ERRORS) {\r\n                    raise( 2, p + notBool, v );\r\n                }\r\n            }\r\n            r[p] = ERRORS;\r\n\r\n            // CRYPTO {boolean|number} true, false, 1 or 0.\r\n            // 'config() CRYPTO not a boolean or binary digit: {v}'\r\n            // 'config() crypto unavailable: {crypto}'\r\n            if ( has( p = 'CRYPTO' ) ) {\r\n\r\n                if ( v === !!v || v === 1 || v === 0 ) {\r\n                    CRYPTO = !!( v && crypto && typeof crypto == 'object' );\r\n                    if ( v && !CRYPTO && ERRORS ) raise( 2, 'crypto unavailable', crypto );\r\n                } else if (ERRORS) {\r\n                    raise( 2, p + notBool, v );\r\n                }\r\n            }\r\n            r[p] = CRYPTO;\r\n\r\n            // MODULO_MODE {number} Integer, 0 to 9 inclusive.\r\n            // 'config() MODULO_MODE not an integer: {v}'\r\n            // 'config() MODULO_MODE out of range: {v}'\r\n            if ( has( p = 'MODULO_MODE' ) && isValidInt( v, 0, 9, 2, p ) ) {\r\n                MODULO_MODE = v | 0;\r\n            }\r\n            r[p] = MODULO_MODE;\r\n\r\n            // POW_PRECISION {number} Integer, 0 to MAX inclusive.\r\n            // 'config() POW_PRECISION not an integer: {v}'\r\n            // 'config() POW_PRECISION out of range: {v}'\r\n            if ( has( p = 'POW_PRECISION' ) && isValidInt( v, 0, MAX, 2, p ) ) {\r\n                POW_PRECISION = v | 0;\r\n            }\r\n            r[p] = POW_PRECISION;\r\n\r\n            // FORMAT {object}\r\n            // 'config() FORMAT not an object: {v}'\r\n            if ( has( p = 'FORMAT' ) ) {\r\n\r\n                if ( typeof v == 'object' ) {\r\n                    FORMAT = v;\r\n                } else if (ERRORS) {\r\n                    raise( 2, p + ' not an object', v );\r\n                }\r\n            }\r\n            r[p] = FORMAT;\r\n\r\n            return r;\r\n        };\r\n\r\n\r\n        /*\r\n         * Return a new BigNumber whose value is the maximum of the arguments.\r\n         *\r\n         * arguments {number|string|BigNumber}\r\n         */\r\n        BigNumber.max = function () { return maxOrMin( arguments, P.lt ); };\r\n\r\n\r\n        /*\r\n         * Return a new BigNumber whose value is the minimum of the arguments.\r\n         *\r\n         * arguments {number|string|BigNumber}\r\n         */\r\n        BigNumber.min = function () { return maxOrMin( arguments, P.gt ); };\r\n\r\n\r\n        /*\r\n         * Return a new BigNumber with a random value equal to or greater than 0 and less than 1,\r\n         * and with dp, or DECIMAL_PLACES if dp is omitted, decimal places (or less if trailing\r\n         * zeros are produced).\r\n         *\r\n         * [dp] {number} Decimal places. Integer, 0 to MAX inclusive.\r\n         *\r\n         * 'random() decimal places not an integer: {dp}'\r\n         * 'random() decimal places out of range: {dp}'\r\n         * 'random() crypto unavailable: {crypto}'\r\n         */\r\n        BigNumber.random = (function () {\r\n            var pow2_53 = 0x20000000000000;\r\n\r\n            // Return a 53 bit integer n, where 0 <= n < 9007199254740992.\r\n            // Check if Math.random() produces more than 32 bits of randomness.\r\n            // If it does, assume at least 53 bits are produced, otherwise assume at least 30 bits.\r\n            // 0x40000000 is 2^30, 0x800000 is 2^23, 0x1fffff is 2^21 - 1.\r\n            var random53bitInt = (Math.random() * pow2_53) & 0x1fffff\r\n              ? function () { return mathfloor( Math.random() * pow2_53 ); }\r\n              : function () { return ((Math.random() * 0x40000000 | 0) * 0x800000) +\r\n                  (Math.random() * 0x800000 | 0); };\r\n\r\n            return function (dp) {\r\n                var a, b, e, k, v,\r\n                    i = 0,\r\n                    c = [],\r\n                    rand = new BigNumber(ONE);\r\n\r\n                dp = dp == null || !isValidInt( dp, 0, MAX, 14 ) ? DECIMAL_PLACES : dp | 0;\r\n                k = mathceil( dp / LOG_BASE );\r\n\r\n                if (CRYPTO) {\r\n\r\n                    // Browsers supporting crypto.getRandomValues.\r\n                    if ( crypto && crypto.getRandomValues ) {\r\n\r\n                        a = crypto.getRandomValues( new Uint32Array( k *= 2 ) );\r\n\r\n                        for ( ; i < k; ) {\r\n\r\n                            // 53 bits:\r\n                            // ((Math.pow(2, 32) - 1) * Math.pow(2, 21)).toString(2)\r\n                            // 11111 11111111 11111111 11111111 11100000 00000000 00000000\r\n                            // ((Math.pow(2, 32) - 1) >>> 11).toString(2)\r\n                            //                                     11111 11111111 11111111\r\n                            // 0x20000 is 2^21.\r\n                            v = a[i] * 0x20000 + (a[i + 1] >>> 11);\r\n\r\n                            // Rejection sampling:\r\n                            // 0 <= v < 9007199254740992\r\n                            // Probability that v >= 9e15, is\r\n                            // 7199254740992 / 9007199254740992 ~= 0.0008, i.e. 1 in 1251\r\n                            if ( v >= 9e15 ) {\r\n                                b = crypto.getRandomValues( new Uint32Array(2) );\r\n                                a[i] = b[0];\r\n                                a[i + 1] = b[1];\r\n                            } else {\r\n\r\n                                // 0 <= v <= 8999999999999999\r\n                                // 0 <= (v % 1e14) <= 99999999999999\r\n                                c.push( v % 1e14 );\r\n                                i += 2;\r\n                            }\r\n                        }\r\n                        i = k / 2;\r\n\r\n                    // Node.js supporting crypto.randomBytes.\r\n                    } else if ( crypto && crypto.randomBytes ) {\r\n\r\n                        // buffer\r\n                        a = crypto.randomBytes( k *= 7 );\r\n\r\n                        for ( ; i < k; ) {\r\n\r\n                            // 0x1000000000000 is 2^48, 0x10000000000 is 2^40\r\n                            // 0x100000000 is 2^32, 0x1000000 is 2^24\r\n                            // 11111 11111111 11111111 11111111 11111111 11111111 11111111\r\n                            // 0 <= v < 9007199254740992\r\n                            v = ( ( a[i] & 31 ) * 0x1000000000000 ) + ( a[i + 1] * 0x10000000000 ) +\r\n                                  ( a[i + 2] * 0x100000000 ) + ( a[i + 3] * 0x1000000 ) +\r\n                                  ( a[i + 4] << 16 ) + ( a[i + 5] << 8 ) + a[i + 6];\r\n\r\n                            if ( v >= 9e15 ) {\r\n                                crypto.randomBytes(7).copy( a, i );\r\n                            } else {\r\n\r\n                                // 0 <= (v % 1e14) <= 99999999999999\r\n                                c.push( v % 1e14 );\r\n                                i += 7;\r\n                            }\r\n                        }\r\n                        i = k / 7;\r\n                    } else if (ERRORS) {\r\n                        raise( 14, 'crypto unavailable', crypto );\r\n                    }\r\n                }\r\n\r\n                // Use Math.random: CRYPTO is false or crypto is unavailable and ERRORS is false.\r\n                if (!i) {\r\n\r\n                    for ( ; i < k; ) {\r\n                        v = random53bitInt();\r\n                        if ( v < 9e15 ) c[i++] = v % 1e14;\r\n                    }\r\n                }\r\n\r\n                k = c[--i];\r\n                dp %= LOG_BASE;\r\n\r\n                // Convert trailing digits to zeros according to dp.\r\n                if ( k && dp ) {\r\n                    v = POWS_TEN[LOG_BASE - dp];\r\n                    c[i] = mathfloor( k / v ) * v;\r\n                }\r\n\r\n                // Remove trailing elements which are zero.\r\n                for ( ; c[i] === 0; c.pop(), i-- );\r\n\r\n                // Zero?\r\n                if ( i < 0 ) {\r\n                    c = [ e = 0 ];\r\n                } else {\r\n\r\n                    // Remove leading elements which are zero and adjust exponent accordingly.\r\n                    for ( e = -1 ; c[0] === 0; c.shift(), e -= LOG_BASE);\r\n\r\n                    // Count the digits of the first element of c to determine leading zeros, and...\r\n                    for ( i = 1, v = c[0]; v >= 10; v /= 10, i++);\r\n\r\n                    // adjust the exponent accordingly.\r\n                    if ( i < LOG_BASE ) e -= LOG_BASE - i;\r\n                }\r\n\r\n                rand.e = e;\r\n                rand.c = c;\r\n                return rand;\r\n            };\r\n        })();\r\n\r\n\r\n        // PRIVATE FUNCTIONS\r\n\r\n\r\n        // Convert a numeric string of baseIn to a numeric string of baseOut.\r\n        function convertBase( str, baseOut, baseIn, sign ) {\r\n            var d, e, k, r, x, xc, y,\r\n                i = str.indexOf( '.' ),\r\n                dp = DECIMAL_PLACES,\r\n                rm = ROUNDING_MODE;\r\n\r\n            if ( baseIn < 37 ) str = str.toLowerCase();\r\n\r\n            // Non-integer.\r\n            if ( i >= 0 ) {\r\n                k = POW_PRECISION;\r\n\r\n                // Unlimited precision.\r\n                POW_PRECISION = 0;\r\n                str = str.replace( '.', '' );\r\n                y = new BigNumber(baseIn);\r\n                x = y.pow( str.length - i );\r\n                POW_PRECISION = k;\r\n\r\n                // Convert str as if an integer, then restore the fraction part by dividing the\r\n                // result by its base raised to a power.\r\n                y.c = toBaseOut( toFixedPoint( coeffToString( x.c ), x.e ), 10, baseOut );\r\n                y.e = y.c.length;\r\n            }\r\n\r\n            // Convert the number as integer.\r\n            xc = toBaseOut( str, baseIn, baseOut );\r\n            e = k = xc.length;\r\n\r\n            // Remove trailing zeros.\r\n            for ( ; xc[--k] == 0; xc.pop() );\r\n            if ( !xc[0] ) return '0';\r\n\r\n            if ( i < 0 ) {\r\n                --e;\r\n            } else {\r\n                x.c = xc;\r\n                x.e = e;\r\n\r\n                // sign is needed for correct rounding.\r\n                x.s = sign;\r\n                x = div( x, y, dp, rm, baseOut );\r\n                xc = x.c;\r\n                r = x.r;\r\n                e = x.e;\r\n            }\r\n\r\n            d = e + dp + 1;\r\n\r\n            // The rounding digit, i.e. the digit to the right of the digit that may be rounded up.\r\n            i = xc[d];\r\n            k = baseOut / 2;\r\n            r = r || d < 0 || xc[d + 1] != null;\r\n\r\n            r = rm < 4 ? ( i != null || r ) && ( rm == 0 || rm == ( x.s < 0 ? 3 : 2 ) )\r\n                       : i > k || i == k &&( rm == 4 || r || rm == 6 && xc[d - 1] & 1 ||\r\n                         rm == ( x.s < 0 ? 8 : 7 ) );\r\n\r\n            if ( d < 1 || !xc[0] ) {\r\n\r\n                // 1^-dp or 0.\r\n                str = r ? toFixedPoint( '1', -dp ) : '0';\r\n            } else {\r\n                xc.length = d;\r\n\r\n                if (r) {\r\n\r\n                    // Rounding up may mean the previous digit has to be rounded up and so on.\r\n                    for ( --baseOut; ++xc[--d] > baseOut; ) {\r\n                        xc[d] = 0;\r\n\r\n                        if ( !d ) {\r\n                            ++e;\r\n                            xc.unshift(1);\r\n                        }\r\n                    }\r\n                }\r\n\r\n                // Determine trailing zeros.\r\n                for ( k = xc.length; !xc[--k]; );\r\n\r\n                // E.g. [4, 11, 15] becomes 4bf.\r\n                for ( i = 0, str = ''; i <= k; str += ALPHABET.charAt( xc[i++] ) );\r\n                str = toFixedPoint( str, e );\r\n            }\r\n\r\n            // The caller will add the sign.\r\n            return str;\r\n        }\r\n\r\n\r\n        // Perform division in the specified base. Called by div and convertBase.\r\n        div = (function () {\r\n\r\n            // Assume non-zero x and k.\r\n            function multiply( x, k, base ) {\r\n                var m, temp, xlo, xhi,\r\n                    carry = 0,\r\n                    i = x.length,\r\n                    klo = k % SQRT_BASE,\r\n                    khi = k / SQRT_BASE | 0;\r\n\r\n                for ( x = x.slice(); i--; ) {\r\n                    xlo = x[i] % SQRT_BASE;\r\n                    xhi = x[i] / SQRT_BASE | 0;\r\n                    m = khi * xlo + xhi * klo;\r\n                    temp = klo * xlo + ( ( m % SQRT_BASE ) * SQRT_BASE ) + carry;\r\n                    carry = ( temp / base | 0 ) + ( m / SQRT_BASE | 0 ) + khi * xhi;\r\n                    x[i] = temp % base;\r\n                }\r\n\r\n                if (carry) x.unshift(carry);\r\n\r\n                return x;\r\n            }\r\n\r\n            function compare( a, b, aL, bL ) {\r\n                var i, cmp;\r\n\r\n                if ( aL != bL ) {\r\n                    cmp = aL > bL ? 1 : -1;\r\n                } else {\r\n\r\n                    for ( i = cmp = 0; i < aL; i++ ) {\r\n\r\n                        if ( a[i] != b[i] ) {\r\n                            cmp = a[i] > b[i] ? 1 : -1;\r\n                            break;\r\n                        }\r\n                    }\r\n                }\r\n                return cmp;\r\n            }\r\n\r\n            function subtract( a, b, aL, base ) {\r\n                var i = 0;\r\n\r\n                // Subtract b from a.\r\n                for ( ; aL--; ) {\r\n                    a[aL] -= i;\r\n                    i = a[aL] < b[aL] ? 1 : 0;\r\n                    a[aL] = i * base + a[aL] - b[aL];\r\n                }\r\n\r\n                // Remove leading zeros.\r\n                for ( ; !a[0] && a.length > 1; a.shift() );\r\n            }\r\n\r\n            // x: dividend, y: divisor.\r\n            return function ( x, y, dp, rm, base ) {\r\n                var cmp, e, i, more, n, prod, prodL, q, qc, rem, remL, rem0, xi, xL, yc0,\r\n                    yL, yz,\r\n                    s = x.s == y.s ? 1 : -1,\r\n                    xc = x.c,\r\n                    yc = y.c;\r\n\r\n                // Either NaN, Infinity or 0?\r\n                if ( !xc || !xc[0] || !yc || !yc[0] ) {\r\n\r\n                    return new BigNumber(\r\n\r\n                      // Return NaN if either NaN, or both Infinity or 0.\r\n                      !x.s || !y.s || ( xc ? yc && xc[0] == yc[0] : !yc ) ? NaN :\r\n\r\n                        // Return ±0 if x is ±0 or y is ±Infinity, or return ±Infinity as y is ±0.\r\n                        xc && xc[0] == 0 || !yc ? s * 0 : s / 0\r\n                    );\r\n                }\r\n\r\n                q = new BigNumber(s);\r\n                qc = q.c = [];\r\n                e = x.e - y.e;\r\n                s = dp + e + 1;\r\n\r\n                if ( !base ) {\r\n                    base = BASE;\r\n                    e = bitFloor( x.e / LOG_BASE ) - bitFloor( y.e / LOG_BASE );\r\n                    s = s / LOG_BASE | 0;\r\n                }\r\n\r\n                // Result exponent may be one less then the current value of e.\r\n                // The coefficients of the BigNumbers from convertBase may have trailing zeros.\r\n                for ( i = 0; yc[i] == ( xc[i] || 0 ); i++ );\r\n                if ( yc[i] > ( xc[i] || 0 ) ) e--;\r\n\r\n                if ( s < 0 ) {\r\n                    qc.push(1);\r\n                    more = true;\r\n                } else {\r\n                    xL = xc.length;\r\n                    yL = yc.length;\r\n                    i = 0;\r\n                    s += 2;\r\n\r\n                    // Normalise xc and yc so highest order digit of yc is >= base/2\r\n\r\n                    n = mathfloor( base / ( yc[0] + 1 ) );\r\n\r\n                    if ( n > 1 ) {\r\n                        yc = multiply( yc, n, base );\r\n                        xc = multiply( xc, n, base );\r\n                        yL = yc.length;\r\n                        xL = xc.length;\r\n                    }\r\n\r\n                    xi = yL;\r\n                    rem = xc.slice( 0, yL );\r\n                    remL = rem.length;\r\n\r\n                    // Add zeros to make remainder as long as divisor.\r\n                    for ( ; remL < yL; rem[remL++] = 0 );\r\n                    yz = yc.slice();\r\n                    yz.unshift(0);\r\n                    yc0 = yc[0];\r\n                    if ( yc[1] >= base / 2 ) yc0++;\r\n\r\n                    do {\r\n                        n = 0;\r\n\r\n                        // Compare divisor and remainder.\r\n                        cmp = compare( yc, rem, yL, remL );\r\n\r\n                        // If divisor < remainder.\r\n                        if ( cmp < 0 ) {\r\n\r\n                            // Calculate trial digit, n.\r\n\r\n                            rem0 = rem[0];\r\n                            if ( yL != remL ) rem0 = rem0 * base + ( rem[1] || 0 );\r\n\r\n                            // n is how many times the divisor goes into the current remainder.\r\n                            n = mathfloor( rem0 / yc0 );\r\n\r\n                            //  Algorithm:\r\n                            //  1. product = divisor * trial digit (n)\r\n                            //  2. if product > remainder: product -= divisor, n--\r\n                            //  3. remainder -= product\r\n                            //  4. if product was < remainder at 2:\r\n                            //    5. compare new remainder and divisor\r\n                            //    6. If remainder > divisor: remainder -= divisor, n++\r\n\r\n                            if ( n > 1 ) {\r\n                                if ( n >= base ) n = base - 1;\r\n\r\n                                // product = divisor * trial digit.\r\n                                prod = multiply( yc, n, base );\r\n                                prodL = prod.length;\r\n                                remL = rem.length;\r\n\r\n                                // Compare product and remainder.\r\n                                cmp = compare( prod, rem, prodL, remL );\r\n\r\n                                // product > remainder.\r\n                                if ( cmp == 1 ) {\r\n                                    n--;\r\n\r\n                                    // Subtract divisor from product.\r\n                                    subtract( prod, yL < prodL ? yz : yc, prodL, base );\r\n                                }\r\n                            } else {\r\n\r\n                                // cmp is -1.\r\n                                // If n is 0, there is no need to compare yc and rem again\r\n                                // below, so change cmp to 1 to avoid it.\r\n                                // If n is 1, compare yc and rem again below.\r\n                                if ( n == 0 ) cmp = n = 1;\r\n                                prod = yc.slice();\r\n                            }\r\n\r\n                            prodL = prod.length;\r\n                            if ( prodL < remL ) prod.unshift(0);\r\n\r\n                            // Subtract product from remainder.\r\n                            subtract( rem, prod, remL, base );\r\n\r\n                            // If product was < previous remainder.\r\n                            if ( cmp == -1 ) {\r\n                                remL = rem.length;\r\n\r\n                                // Compare divisor and new remainder.\r\n                                cmp = compare( yc, rem, yL, remL );\r\n\r\n                                // If divisor < new remainder, subtract divisor from remainder.\r\n                                if ( cmp < 1 ) {\r\n                                    n++;\r\n\r\n                                    // Subtract divisor from remainder.\r\n                                    subtract( rem, yL < remL ? yz : yc, remL, base );\r\n                                }\r\n                            }\r\n                            remL = rem.length;\r\n                        } else if ( cmp === 0 ) {\r\n                            n++;\r\n                            rem = [0];\r\n                        }\r\n                        // if cmp === 1, n will be 0\r\n\r\n                        // Add the next digit, n, to the result array.\r\n                        qc[i++] = n;\r\n\r\n                        // Update the remainder.\r\n                        if ( cmp && rem[0] ) {\r\n                            rem[remL++] = xc[xi] || 0;\r\n                        } else {\r\n                            rem = [ xc[xi] ];\r\n                            remL = 1;\r\n                        }\r\n                    } while ( ( xi++ < xL || rem[0] != null ) && s-- );\r\n\r\n                    more = rem[0] != null;\r\n\r\n                    // Leading zero?\r\n                    if ( !qc[0] ) qc.shift();\r\n                }\r\n\r\n                if ( base == BASE ) {\r\n\r\n                    // To calculate q.e, first get the number of digits of qc[0].\r\n                    for ( i = 1, s = qc[0]; s >= 10; s /= 10, i++ );\r\n                    round( q, dp + ( q.e = i + e * LOG_BASE - 1 ) + 1, rm, more );\r\n\r\n                // Caller is convertBase.\r\n                } else {\r\n                    q.e = e;\r\n                    q.r = +more;\r\n                }\r\n\r\n                return q;\r\n            };\r\n        })();\r\n\r\n\r\n        /*\r\n         * Return a string representing the value of BigNumber n in fixed-point or exponential\r\n         * notation rounded to the specified decimal places or significant digits.\r\n         *\r\n         * n is a BigNumber.\r\n         * i is the index of the last digit required (i.e. the digit that may be rounded up).\r\n         * rm is the rounding mode.\r\n         * caller is caller id: toExponential 19, toFixed 20, toFormat 21, toPrecision 24.\r\n         */\r\n        function format( n, i, rm, caller ) {\r\n            var c0, e, ne, len, str;\r\n\r\n            rm = rm != null && isValidInt( rm, 0, 8, caller, roundingMode )\r\n              ? rm | 0 : ROUNDING_MODE;\r\n\r\n            if ( !n.c ) return n.toString();\r\n            c0 = n.c[0];\r\n            ne = n.e;\r\n\r\n            if ( i == null ) {\r\n                str = coeffToString( n.c );\r\n                str = caller == 19 || caller == 24 && ne <= TO_EXP_NEG\r\n                  ? toExponential( str, ne )\r\n                  : toFixedPoint( str, ne );\r\n            } else {\r\n                n = round( new BigNumber(n), i, rm );\r\n\r\n                // n.e may have changed if the value was rounded up.\r\n                e = n.e;\r\n\r\n                str = coeffToString( n.c );\r\n                len = str.length;\r\n\r\n                // toPrecision returns exponential notation if the number of significant digits\r\n                // specified is less than the number of digits necessary to represent the integer\r\n                // part of the value in fixed-point notation.\r\n\r\n                // Exponential notation.\r\n                if ( caller == 19 || caller == 24 && ( i <= e || e <= TO_EXP_NEG ) ) {\r\n\r\n                    // Append zeros?\r\n                    for ( ; len < i; str += '0', len++ );\r\n                    str = toExponential( str, e );\r\n\r\n                // Fixed-point notation.\r\n                } else {\r\n                    i -= ne;\r\n                    str = toFixedPoint( str, e );\r\n\r\n                    // Append zeros?\r\n                    if ( e + 1 > len ) {\r\n                        if ( --i > 0 ) for ( str += '.'; i--; str += '0' );\r\n                    } else {\r\n                        i += e - len;\r\n                        if ( i > 0 ) {\r\n                            if ( e + 1 == len ) str += '.';\r\n                            for ( ; i--; str += '0' );\r\n                        }\r\n                    }\r\n                }\r\n            }\r\n\r\n            return n.s < 0 && c0 ? '-' + str : str;\r\n        }\r\n\r\n\r\n        // Handle BigNumber.max and BigNumber.min.\r\n        function maxOrMin( args, method ) {\r\n            var m, n,\r\n                i = 0;\r\n\r\n            if ( isArray( args[0] ) ) args = args[0];\r\n            m = new BigNumber( args[0] );\r\n\r\n            for ( ; ++i < args.length; ) {\r\n                n = new BigNumber( args[i] );\r\n\r\n                // If any number is NaN, return NaN.\r\n                if ( !n.s ) {\r\n                    m = n;\r\n                    break;\r\n                } else if ( method.call( m, n ) ) {\r\n                    m = n;\r\n                }\r\n            }\r\n\r\n            return m;\r\n        }\r\n\r\n\r\n        /*\r\n         * Return true if n is an integer in range, otherwise throw.\r\n         * Use for argument validation when ERRORS is true.\r\n         */\r\n        function intValidatorWithErrors( n, min, max, caller, name ) {\r\n            if ( n < min || n > max || n != truncate(n) ) {\r\n                raise( caller, ( name || 'decimal places' ) +\r\n                  ( n < min || n > max ? ' out of range' : ' not an integer' ), n );\r\n            }\r\n\r\n            return true;\r\n        }\r\n\r\n\r\n        /*\r\n         * Strip trailing zeros, calculate base 10 exponent and check against MIN_EXP and MAX_EXP.\r\n         * Called by minus, plus and times.\r\n         */\r\n        function normalise( n, c, e ) {\r\n            var i = 1,\r\n                j = c.length;\r\n\r\n             // Remove trailing zeros.\r\n            for ( ; !c[--j]; c.pop() );\r\n\r\n            // Calculate the base 10 exponent. First get the number of digits of c[0].\r\n            for ( j = c[0]; j >= 10; j /= 10, i++ );\r\n\r\n            // Overflow?\r\n            if ( ( e = i + e * LOG_BASE - 1 ) > MAX_EXP ) {\r\n\r\n                // Infinity.\r\n                n.c = n.e = null;\r\n\r\n            // Underflow?\r\n            } else if ( e < MIN_EXP ) {\r\n\r\n                // Zero.\r\n                n.c = [ n.e = 0 ];\r\n            } else {\r\n                n.e = e;\r\n                n.c = c;\r\n            }\r\n\r\n            return n;\r\n        }\r\n\r\n\r\n        // Handle values that fail the validity test in BigNumber.\r\n        parseNumeric = (function () {\r\n            var basePrefix = /^(-?)0([xbo])(?=\\w[\\w.]*$)/i,\r\n                dotAfter = /^([^.]+)\\.$/,\r\n                dotBefore = /^\\.([^.]+)$/,\r\n                isInfinityOrNaN = /^-?(Infinity|NaN)$/,\r\n                whitespaceOrPlus = /^\\s*\\+(?=[\\w.])|^\\s+|\\s+$/g;\r\n\r\n            return function ( x, str, num, b ) {\r\n                var base,\r\n                    s = num ? str : str.replace( whitespaceOrPlus, '' );\r\n\r\n                // No exception on ±Infinity or NaN.\r\n                if ( isInfinityOrNaN.test(s) ) {\r\n                    x.s = isNaN(s) ? null : s < 0 ? -1 : 1;\r\n                } else {\r\n                    if ( !num ) {\r\n\r\n                        // basePrefix = /^(-?)0([xbo])(?=\\w[\\w.]*$)/i\r\n                        s = s.replace( basePrefix, function ( m, p1, p2 ) {\r\n                            base = ( p2 = p2.toLowerCase() ) == 'x' ? 16 : p2 == 'b' ? 2 : 8;\r\n                            return !b || b == base ? p1 : m;\r\n                        });\r\n\r\n                        if (b) {\r\n                            base = b;\r\n\r\n                            // E.g. '1.' to '1', '.1' to '0.1'\r\n                            s = s.replace( dotAfter, '$1' ).replace( dotBefore, '0.$1' );\r\n                        }\r\n\r\n                        if ( str != s ) return new BigNumber( s, base );\r\n                    }\r\n\r\n                    // 'new BigNumber() not a number: {n}'\r\n                    // 'new BigNumber() not a base {b} number: {n}'\r\n                    if (ERRORS) raise( id, 'not a' + ( b ? ' base ' + b : '' ) + ' number', str );\r\n                    x.s = null;\r\n                }\r\n\r\n                x.c = x.e = null;\r\n                id = 0;\r\n            }\r\n        })();\r\n\r\n\r\n        // Throw a BigNumber Error.\r\n        function raise( caller, msg, val ) {\r\n            var error = new Error( [\r\n                'new BigNumber',     // 0\r\n                'cmp',               // 1\r\n                'config',            // 2\r\n                'div',               // 3\r\n                'divToInt',          // 4\r\n                'eq',                // 5\r\n                'gt',                // 6\r\n                'gte',               // 7\r\n                'lt',                // 8\r\n                'lte',               // 9\r\n                'minus',             // 10\r\n                'mod',               // 11\r\n                'plus',              // 12\r\n                'precision',         // 13\r\n                'random',            // 14\r\n                'round',             // 15\r\n                'shift',             // 16\r\n                'times',             // 17\r\n                'toDigits',          // 18\r\n                'toExponential',     // 19\r\n                'toFixed',           // 20\r\n                'toFormat',          // 21\r\n                'toFraction',        // 22\r\n                'pow',               // 23\r\n                'toPrecision',       // 24\r\n                'toString',          // 25\r\n                'BigNumber'          // 26\r\n            ][caller] + '() ' + msg + ': ' + val );\r\n\r\n            error.name = 'BigNumber Error';\r\n            id = 0;\r\n            throw error;\r\n        }\r\n\r\n\r\n        /*\r\n         * Round x to sd significant digits using rounding mode rm. Check for over/under-flow.\r\n         * If r is truthy, it is known that there are more digits after the rounding digit.\r\n         */\r\n        function round( x, sd, rm, r ) {\r\n            var d, i, j, k, n, ni, rd,\r\n                xc = x.c,\r\n                pows10 = POWS_TEN;\r\n\r\n            // if x is not Infinity or NaN...\r\n            if (xc) {\r\n\r\n                // rd is the rounding digit, i.e. the digit after the digit that may be rounded up.\r\n                // n is a base 1e14 number, the value of the element of array x.c containing rd.\r\n                // ni is the index of n within x.c.\r\n                // d is the number of digits of n.\r\n                // i is the index of rd within n including leading zeros.\r\n                // j is the actual index of rd within n (if < 0, rd is a leading zero).\r\n                out: {\r\n\r\n                    // Get the number of digits of the first element of xc.\r\n                    for ( d = 1, k = xc[0]; k >= 10; k /= 10, d++ );\r\n                    i = sd - d;\r\n\r\n                    // If the rounding digit is in the first element of xc...\r\n                    if ( i < 0 ) {\r\n                        i += LOG_BASE;\r\n                        j = sd;\r\n                        n = xc[ ni = 0 ];\r\n\r\n                        // Get the rounding digit at index j of n.\r\n                        rd = n / pows10[ d - j - 1 ] % 10 | 0;\r\n                    } else {\r\n                        ni = mathceil( ( i + 1 ) / LOG_BASE );\r\n\r\n                        if ( ni >= xc.length ) {\r\n\r\n                            if (r) {\r\n\r\n                                // Needed by sqrt.\r\n                                for ( ; xc.length <= ni; xc.push(0) );\r\n                                n = rd = 0;\r\n                                d = 1;\r\n                                i %= LOG_BASE;\r\n                                j = i - LOG_BASE + 1;\r\n                            } else {\r\n                                break out;\r\n                            }\r\n                        } else {\r\n                            n = k = xc[ni];\r\n\r\n                            // Get the number of digits of n.\r\n                            for ( d = 1; k >= 10; k /= 10, d++ );\r\n\r\n                            // Get the index of rd within n.\r\n                            i %= LOG_BASE;\r\n\r\n                            // Get the index of rd within n, adjusted for leading zeros.\r\n                            // The number of leading zeros of n is given by LOG_BASE - d.\r\n                            j = i - LOG_BASE + d;\r\n\r\n                            // Get the rounding digit at index j of n.\r\n                            rd = j < 0 ? 0 : n / pows10[ d - j - 1 ] % 10 | 0;\r\n                        }\r\n                    }\r\n\r\n                    r = r || sd < 0 ||\r\n\r\n                    // Are there any non-zero digits after the rounding digit?\r\n                    // The expression  n % pows10[ d - j - 1 ]  returns all digits of n to the right\r\n                    // of the digit at j, e.g. if n is 908714 and j is 2, the expression gives 714.\r\n                      xc[ni + 1] != null || ( j < 0 ? n : n % pows10[ d - j - 1 ] );\r\n\r\n                    r = rm < 4\r\n                      ? ( rd || r ) && ( rm == 0 || rm == ( x.s < 0 ? 3 : 2 ) )\r\n                      : rd > 5 || rd == 5 && ( rm == 4 || r || rm == 6 &&\r\n\r\n                        // Check whether the digit to the left of the rounding digit is odd.\r\n                        ( ( i > 0 ? j > 0 ? n / pows10[ d - j ] : 0 : xc[ni - 1] ) % 10 ) & 1 ||\r\n                          rm == ( x.s < 0 ? 8 : 7 ) );\r\n\r\n                    if ( sd < 1 || !xc[0] ) {\r\n                        xc.length = 0;\r\n\r\n                        if (r) {\r\n\r\n                            // Convert sd to decimal places.\r\n                            sd -= x.e + 1;\r\n\r\n                            // 1, 0.1, 0.01, 0.001, 0.0001 etc.\r\n                            xc[0] = pows10[ sd % LOG_BASE ];\r\n                            x.e = -sd || 0;\r\n                        } else {\r\n\r\n                            // Zero.\r\n                            xc[0] = x.e = 0;\r\n                        }\r\n\r\n                        return x;\r\n                    }\r\n\r\n                    // Remove excess digits.\r\n                    if ( i == 0 ) {\r\n                        xc.length = ni;\r\n                        k = 1;\r\n                        ni--;\r\n                    } else {\r\n                        xc.length = ni + 1;\r\n                        k = pows10[ LOG_BASE - i ];\r\n\r\n                        // E.g. 56700 becomes 56000 if 7 is the rounding digit.\r\n                        // j > 0 means i > number of leading zeros of n.\r\n                        xc[ni] = j > 0 ? mathfloor( n / pows10[ d - j ] % pows10[j] ) * k : 0;\r\n                    }\r\n\r\n                    // Round up?\r\n                    if (r) {\r\n\r\n                        for ( ; ; ) {\r\n\r\n                            // If the digit to be rounded up is in the first element of xc...\r\n                            if ( ni == 0 ) {\r\n\r\n                                // i will be the length of xc[0] before k is added.\r\n                                for ( i = 1, j = xc[0]; j >= 10; j /= 10, i++ );\r\n                                j = xc[0] += k;\r\n                                for ( k = 1; j >= 10; j /= 10, k++ );\r\n\r\n                                // if i != k the length has increased.\r\n                                if ( i != k ) {\r\n                                    x.e++;\r\n                                    if ( xc[0] == BASE ) xc[0] = 1;\r\n                                }\r\n\r\n                                break;\r\n                            } else {\r\n                                xc[ni] += k;\r\n                                if ( xc[ni] != BASE ) break;\r\n                                xc[ni--] = 0;\r\n                                k = 1;\r\n                            }\r\n                        }\r\n                    }\r\n\r\n                    // Remove trailing zeros.\r\n                    for ( i = xc.length; xc[--i] === 0; xc.pop() );\r\n                }\r\n\r\n                // Overflow? Infinity.\r\n                if ( x.e > MAX_EXP ) {\r\n                    x.c = x.e = null;\r\n\r\n                // Underflow? Zero.\r\n                } else if ( x.e < MIN_EXP ) {\r\n                    x.c = [ x.e = 0 ];\r\n                }\r\n            }\r\n\r\n            return x;\r\n        }\r\n\r\n\r\n        // PROTOTYPE/INSTANCE METHODS\r\n\r\n\r\n        /*\r\n         * Return a new BigNumber whose value is the absolute value of this BigNumber.\r\n         */\r\n        P.absoluteValue = P.abs = function () {\r\n            var x = new BigNumber(this);\r\n            if ( x.s < 0 ) x.s = 1;\r\n            return x;\r\n        };\r\n\r\n\r\n        /*\r\n         * Return a new BigNumber whose value is the value of this BigNumber rounded to a whole\r\n         * number in the direction of Infinity.\r\n         */\r\n        P.ceil = function () {\r\n            return round( new BigNumber(this), this.e + 1, 2 );\r\n        };\r\n\r\n\r\n        /*\r\n         * Return\r\n         * 1 if the value of this BigNumber is greater than the value of BigNumber(y, b),\r\n         * -1 if the value of this BigNumber is less than the value of BigNumber(y, b),\r\n         * 0 if they have the same value,\r\n         * or null if the value of either is NaN.\r\n         */\r\n        P.comparedTo = P.cmp = function ( y, b ) {\r\n            id = 1;\r\n            return compare( this, new BigNumber( y, b ) );\r\n        };\r\n\r\n\r\n        /*\r\n         * Return the number of decimal places of the value of this BigNumber, or null if the value\r\n         * of this BigNumber is ±Infinity or NaN.\r\n         */\r\n        P.decimalPlaces = P.dp = function () {\r\n            var n, v,\r\n                c = this.c;\r\n\r\n            if ( !c ) return null;\r\n            n = ( ( v = c.length - 1 ) - bitFloor( this.e / LOG_BASE ) ) * LOG_BASE;\r\n\r\n            // Subtract the number of trailing zeros of the last number.\r\n            if ( v = c[v] ) for ( ; v % 10 == 0; v /= 10, n-- );\r\n            if ( n < 0 ) n = 0;\r\n\r\n            return n;\r\n        };\r\n\r\n\r\n        /*\r\n         *  n / 0 = I\r\n         *  n / N = N\r\n         *  n / I = 0\r\n         *  0 / n = 0\r\n         *  0 / 0 = N\r\n         *  0 / N = N\r\n         *  0 / I = 0\r\n         *  N / n = N\r\n         *  N / 0 = N\r\n         *  N / N = N\r\n         *  N / I = N\r\n         *  I / n = I\r\n         *  I / 0 = I\r\n         *  I / N = N\r\n         *  I / I = N\r\n         *\r\n         * Return a new BigNumber whose value is the value of this BigNumber divided by the value of\r\n         * BigNumber(y, b), rounded according to DECIMAL_PLACES and ROUNDING_MODE.\r\n         */\r\n        P.dividedBy = P.div = function ( y, b ) {\r\n            id = 3;\r\n            return div( this, new BigNumber( y, b ), DECIMAL_PLACES, ROUNDING_MODE );\r\n        };\r\n\r\n\r\n        /*\r\n         * Return a new BigNumber whose value is the integer part of dividing the value of this\r\n         * BigNumber by the value of BigNumber(y, b).\r\n         */\r\n        P.dividedToIntegerBy = P.divToInt = function ( y, b ) {\r\n            id = 4;\r\n            return div( this, new BigNumber( y, b ), 0, 1 );\r\n        };\r\n\r\n\r\n        /*\r\n         * Return true if the value of this BigNumber is equal to the value of BigNumber(y, b),\r\n         * otherwise returns false.\r\n         */\r\n        P.equals = P.eq = function ( y, b ) {\r\n            id = 5;\r\n            return compare( this, new BigNumber( y, b ) ) === 0;\r\n        };\r\n\r\n\r\n        /*\r\n         * Return a new BigNumber whose value is the value of this BigNumber rounded to a whole\r\n         * number in the direction of -Infinity.\r\n         */\r\n        P.floor = function () {\r\n            return round( new BigNumber(this), this.e + 1, 3 );\r\n        };\r\n\r\n\r\n        /*\r\n         * Return true if the value of this BigNumber is greater than the value of BigNumber(y, b),\r\n         * otherwise returns false.\r\n         */\r\n        P.greaterThan = P.gt = function ( y, b ) {\r\n            id = 6;\r\n            return compare( this, new BigNumber( y, b ) ) > 0;\r\n        };\r\n\r\n\r\n        /*\r\n         * Return true if the value of this BigNumber is greater than or equal to the value of\r\n         * BigNumber(y, b), otherwise returns false.\r\n         */\r\n        P.greaterThanOrEqualTo = P.gte = function ( y, b ) {\r\n            id = 7;\r\n            return ( b = compare( this, new BigNumber( y, b ) ) ) === 1 || b === 0;\r\n\r\n        };\r\n\r\n\r\n        /*\r\n         * Return true if the value of this BigNumber is a finite number, otherwise returns false.\r\n         */\r\n        P.isFinite = function () {\r\n            return !!this.c;\r\n        };\r\n\r\n\r\n        /*\r\n         * Return true if the value of this BigNumber is an integer, otherwise return false.\r\n         */\r\n        P.isInteger = P.isInt = function () {\r\n            return !!this.c && bitFloor( this.e / LOG_BASE ) > this.c.length - 2;\r\n        };\r\n\r\n\r\n        /*\r\n         * Return true if the value of this BigNumber is NaN, otherwise returns false.\r\n         */\r\n        P.isNaN = function () {\r\n            return !this.s;\r\n        };\r\n\r\n\r\n        /*\r\n         * Return true if the value of this BigNumber is negative, otherwise returns false.\r\n         */\r\n        P.isNegative = P.isNeg = function () {\r\n            return this.s < 0;\r\n        };\r\n\r\n\r\n        /*\r\n         * Return true if the value of this BigNumber is 0 or -0, otherwise returns false.\r\n         */\r\n        P.isZero = function () {\r\n            return !!this.c && this.c[0] == 0;\r\n        };\r\n\r\n\r\n        /*\r\n         * Return true if the value of this BigNumber is less than the value of BigNumber(y, b),\r\n         * otherwise returns false.\r\n         */\r\n        P.lessThan = P.lt = function ( y, b ) {\r\n            id = 8;\r\n            return compare( this, new BigNumber( y, b ) ) < 0;\r\n        };\r\n\r\n\r\n        /*\r\n         * Return true if the value of this BigNumber is less than or equal to the value of\r\n         * BigNumber(y, b), otherwise returns false.\r\n         */\r\n        P.lessThanOrEqualTo = P.lte = function ( y, b ) {\r\n            id = 9;\r\n            return ( b = compare( this, new BigNumber( y, b ) ) ) === -1 || b === 0;\r\n        };\r\n\r\n\r\n        /*\r\n         *  n - 0 = n\r\n         *  n - N = N\r\n         *  n - I = -I\r\n         *  0 - n = -n\r\n         *  0 - 0 = 0\r\n         *  0 - N = N\r\n         *  0 - I = -I\r\n         *  N - n = N\r\n         *  N - 0 = N\r\n         *  N - N = N\r\n         *  N - I = N\r\n         *  I - n = I\r\n         *  I - 0 = I\r\n         *  I - N = N\r\n         *  I - I = N\r\n         *\r\n         * Return a new BigNumber whose value is the value of this BigNumber minus the value of\r\n         * BigNumber(y, b).\r\n         */\r\n        P.minus = P.sub = function ( y, b ) {\r\n            var i, j, t, xLTy,\r\n                x = this,\r\n                a = x.s;\r\n\r\n            id = 10;\r\n            y = new BigNumber( y, b );\r\n            b = y.s;\r\n\r\n            // Either NaN?\r\n            if ( !a || !b ) return new BigNumber(NaN);\r\n\r\n            // Signs differ?\r\n            if ( a != b ) {\r\n                y.s = -b;\r\n                return x.plus(y);\r\n            }\r\n\r\n            var xe = x.e / LOG_BASE,\r\n                ye = y.e / LOG_BASE,\r\n                xc = x.c,\r\n                yc = y.c;\r\n\r\n            if ( !xe || !ye ) {\r\n\r\n                // Either Infinity?\r\n                if ( !xc || !yc ) return xc ? ( y.s = -b, y ) : new BigNumber( yc ? x : NaN );\r\n\r\n                // Either zero?\r\n                if ( !xc[0] || !yc[0] ) {\r\n\r\n                    // Return y if y is non-zero, x if x is non-zero, or zero if both are zero.\r\n                    return yc[0] ? ( y.s = -b, y ) : new BigNumber( xc[0] ? x :\r\n\r\n                      // IEEE 754 (2008) 6.3: n - n = -0 when rounding to -Infinity\r\n                      ROUNDING_MODE == 3 ? -0 : 0 );\r\n                }\r\n            }\r\n\r\n            xe = bitFloor(xe);\r\n            ye = bitFloor(ye);\r\n            xc = xc.slice();\r\n\r\n            // Determine which is the bigger number.\r\n            if ( a = xe - ye ) {\r\n\r\n                if ( xLTy = a < 0 ) {\r\n                    a = -a;\r\n                    t = xc;\r\n                } else {\r\n                    ye = xe;\r\n                    t = yc;\r\n                }\r\n\r\n                t.reverse();\r\n\r\n                // Prepend zeros to equalise exponents.\r\n                for ( b = a; b--; t.push(0) );\r\n                t.reverse();\r\n            } else {\r\n\r\n                // Exponents equal. Check digit by digit.\r\n                j = ( xLTy = ( a = xc.length ) < ( b = yc.length ) ) ? a : b;\r\n\r\n                for ( a = b = 0; b < j; b++ ) {\r\n\r\n                    if ( xc[b] != yc[b] ) {\r\n                        xLTy = xc[b] < yc[b];\r\n                        break;\r\n                    }\r\n                }\r\n            }\r\n\r\n            // x < y? Point xc to the array of the bigger number.\r\n            if (xLTy) t = xc, xc = yc, yc = t, y.s = -y.s;\r\n\r\n            b = ( j = yc.length ) - ( i = xc.length );\r\n\r\n            // Append zeros to xc if shorter.\r\n            // No need to add zeros to yc if shorter as subtract only needs to start at yc.length.\r\n            if ( b > 0 ) for ( ; b--; xc[i++] = 0 );\r\n            b = BASE - 1;\r\n\r\n            // Subtract yc from xc.\r\n            for ( ; j > a; ) {\r\n\r\n                if ( xc[--j] < yc[j] ) {\r\n                    for ( i = j; i && !xc[--i]; xc[i] = b );\r\n                    --xc[i];\r\n                    xc[j] += BASE;\r\n                }\r\n\r\n                xc[j] -= yc[j];\r\n            }\r\n\r\n            // Remove leading zeros and adjust exponent accordingly.\r\n            for ( ; xc[0] == 0; xc.shift(), --ye );\r\n\r\n            // Zero?\r\n            if ( !xc[0] ) {\r\n\r\n                // Following IEEE 754 (2008) 6.3,\r\n                // n - n = +0  but  n - n = -0  when rounding towards -Infinity.\r\n                y.s = ROUNDING_MODE == 3 ? -1 : 1;\r\n                y.c = [ y.e = 0 ];\r\n                return y;\r\n            }\r\n\r\n            // No need to check for Infinity as +x - +y != Infinity && -x - -y != Infinity\r\n            // for finite x and y.\r\n            return normalise( y, xc, ye );\r\n        };\r\n\r\n\r\n        /*\r\n         *   n % 0 =  N\r\n         *   n % N =  N\r\n         *   n % I =  n\r\n         *   0 % n =  0\r\n         *  -0 % n = -0\r\n         *   0 % 0 =  N\r\n         *   0 % N =  N\r\n         *   0 % I =  0\r\n         *   N % n =  N\r\n         *   N % 0 =  N\r\n         *   N % N =  N\r\n         *   N % I =  N\r\n         *   I % n =  N\r\n         *   I % 0 =  N\r\n         *   I % N =  N\r\n         *   I % I =  N\r\n         *\r\n         * Return a new BigNumber whose value is the value of this BigNumber modulo the value of\r\n         * BigNumber(y, b). The result depends on the value of MODULO_MODE.\r\n         */\r\n        P.modulo = P.mod = function ( y, b ) {\r\n            var q, s,\r\n                x = this;\r\n\r\n            id = 11;\r\n            y = new BigNumber( y, b );\r\n\r\n            // Return NaN if x is Infinity or NaN, or y is NaN or zero.\r\n            if ( !x.c || !y.s || y.c && !y.c[0] ) {\r\n                return new BigNumber(NaN);\r\n\r\n            // Return x if y is Infinity or x is zero.\r\n            } else if ( !y.c || x.c && !x.c[0] ) {\r\n                return new BigNumber(x);\r\n            }\r\n\r\n            if ( MODULO_MODE == 9 ) {\r\n\r\n                // Euclidian division: q = sign(y) * floor(x / abs(y))\r\n                // r = x - qy    where  0 <= r < abs(y)\r\n                s = y.s;\r\n                y.s = 1;\r\n                q = div( x, y, 0, 3 );\r\n                y.s = s;\r\n                q.s *= s;\r\n            } else {\r\n                q = div( x, y, 0, MODULO_MODE );\r\n            }\r\n\r\n            return x.minus( q.times(y) );\r\n        };\r\n\r\n\r\n        /*\r\n         * Return a new BigNumber whose value is the value of this BigNumber negated,\r\n         * i.e. multiplied by -1.\r\n         */\r\n        P.negated = P.neg = function () {\r\n            var x = new BigNumber(this);\r\n            x.s = -x.s || null;\r\n            return x;\r\n        };\r\n\r\n\r\n        /*\r\n         *  n + 0 = n\r\n         *  n + N = N\r\n         *  n + I = I\r\n         *  0 + n = n\r\n         *  0 + 0 = 0\r\n         *  0 + N = N\r\n         *  0 + I = I\r\n         *  N + n = N\r\n         *  N + 0 = N\r\n         *  N + N = N\r\n         *  N + I = N\r\n         *  I + n = I\r\n         *  I + 0 = I\r\n         *  I + N = N\r\n         *  I + I = I\r\n         *\r\n         * Return a new BigNumber whose value is the value of this BigNumber plus the value of\r\n         * BigNumber(y, b).\r\n         */\r\n        P.plus = P.add = function ( y, b ) {\r\n            var t,\r\n                x = this,\r\n                a = x.s;\r\n\r\n            id = 12;\r\n            y = new BigNumber( y, b );\r\n            b = y.s;\r\n\r\n            // Either NaN?\r\n            if ( !a || !b ) return new BigNumber(NaN);\r\n\r\n            // Signs differ?\r\n             if ( a != b ) {\r\n                y.s = -b;\r\n                return x.minus(y);\r\n            }\r\n\r\n            var xe = x.e / LOG_BASE,\r\n                ye = y.e / LOG_BASE,\r\n                xc = x.c,\r\n                yc = y.c;\r\n\r\n            if ( !xe || !ye ) {\r\n\r\n                // Return ±Infinity if either ±Infinity.\r\n                if ( !xc || !yc ) return new BigNumber( a / 0 );\r\n\r\n                // Either zero?\r\n                // Return y if y is non-zero, x if x is non-zero, or zero if both are zero.\r\n                if ( !xc[0] || !yc[0] ) return yc[0] ? y : new BigNumber( xc[0] ? x : a * 0 );\r\n            }\r\n\r\n            xe = bitFloor(xe);\r\n            ye = bitFloor(ye);\r\n            xc = xc.slice();\r\n\r\n            // Prepend zeros to equalise exponents. Faster to use reverse then do unshifts.\r\n            if ( a = xe - ye ) {\r\n                if ( a > 0 ) {\r\n                    ye = xe;\r\n                    t = yc;\r\n                } else {\r\n                    a = -a;\r\n                    t = xc;\r\n                }\r\n\r\n                t.reverse();\r\n                for ( ; a--; t.push(0) );\r\n                t.reverse();\r\n            }\r\n\r\n            a = xc.length;\r\n            b = yc.length;\r\n\r\n            // Point xc to the longer array, and b to the shorter length.\r\n            if ( a - b < 0 ) t = yc, yc = xc, xc = t, b = a;\r\n\r\n            // Only start adding at yc.length - 1 as the further digits of xc can be ignored.\r\n            for ( a = 0; b; ) {\r\n                a = ( xc[--b] = xc[b] + yc[b] + a ) / BASE | 0;\r\n                xc[b] %= BASE;\r\n            }\r\n\r\n            if (a) {\r\n                xc.unshift(a);\r\n                ++ye;\r\n            }\r\n\r\n            // No need to check for zero, as +x + +y != 0 && -x + -y != 0\r\n            // ye = MAX_EXP + 1 possible\r\n            return normalise( y, xc, ye );\r\n        };\r\n\r\n\r\n        /*\r\n         * Return the number of significant digits of the value of this BigNumber.\r\n         *\r\n         * [z] {boolean|number} Whether to count integer-part trailing zeros: true, false, 1 or 0.\r\n         */\r\n        P.precision = P.sd = function (z) {\r\n            var n, v,\r\n                x = this,\r\n                c = x.c;\r\n\r\n            // 'precision() argument not a boolean or binary digit: {z}'\r\n            if ( z != null && z !== !!z && z !== 1 && z !== 0 ) {\r\n                if (ERRORS) raise( 13, 'argument' + notBool, z );\r\n                if ( z != !!z ) z = null;\r\n            }\r\n\r\n            if ( !c ) return null;\r\n            v = c.length - 1;\r\n            n = v * LOG_BASE + 1;\r\n\r\n            if ( v = c[v] ) {\r\n\r\n                // Subtract the number of trailing zeros of the last element.\r\n                for ( ; v % 10 == 0; v /= 10, n-- );\r\n\r\n                // Add the number of digits of the first element.\r\n                for ( v = c[0]; v >= 10; v /= 10, n++ );\r\n            }\r\n\r\n            if ( z && x.e + 1 > n ) n = x.e + 1;\r\n\r\n            return n;\r\n        };\r\n\r\n\r\n        /*\r\n         * Return a new BigNumber whose value is the value of this BigNumber rounded to a maximum of\r\n         * dp decimal places using rounding mode rm, or to 0 and ROUNDING_MODE respectively if\r\n         * omitted.\r\n         *\r\n         * [dp] {number} Decimal places. Integer, 0 to MAX inclusive.\r\n         * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n         *\r\n         * 'round() decimal places out of range: {dp}'\r\n         * 'round() decimal places not an integer: {dp}'\r\n         * 'round() rounding mode not an integer: {rm}'\r\n         * 'round() rounding mode out of range: {rm}'\r\n         */\r\n        P.round = function ( dp, rm ) {\r\n            var n = new BigNumber(this);\r\n\r\n            if ( dp == null || isValidInt( dp, 0, MAX, 15 ) ) {\r\n                round( n, ~~dp + this.e + 1, rm == null ||\r\n                  !isValidInt( rm, 0, 8, 15, roundingMode ) ? ROUNDING_MODE : rm | 0 );\r\n            }\r\n\r\n            return n;\r\n        };\r\n\r\n\r\n        /*\r\n         * Return a new BigNumber whose value is the value of this BigNumber shifted by k places\r\n         * (powers of 10). Shift to the right if n > 0, and to the left if n < 0.\r\n         *\r\n         * k {number} Integer, -MAX_SAFE_INTEGER to MAX_SAFE_INTEGER inclusive.\r\n         *\r\n         * If k is out of range and ERRORS is false, the result will be ±0 if k < 0, or ±Infinity\r\n         * otherwise.\r\n         *\r\n         * 'shift() argument not an integer: {k}'\r\n         * 'shift() argument out of range: {k}'\r\n         */\r\n        P.shift = function (k) {\r\n            var n = this;\r\n            return isValidInt( k, -MAX_SAFE_INTEGER, MAX_SAFE_INTEGER, 16, 'argument' )\r\n\r\n              // k < 1e+21, or truncate(k) will produce exponential notation.\r\n              ? n.times( '1e' + truncate(k) )\r\n              : new BigNumber( n.c && n.c[0] && ( k < -MAX_SAFE_INTEGER || k > MAX_SAFE_INTEGER )\r\n                ? n.s * ( k < 0 ? 0 : 1 / 0 )\r\n                : n );\r\n        };\r\n\r\n\r\n        /*\r\n         *  sqrt(-n) =  N\r\n         *  sqrt( N) =  N\r\n         *  sqrt(-I) =  N\r\n         *  sqrt( I) =  I\r\n         *  sqrt( 0) =  0\r\n         *  sqrt(-0) = -0\r\n         *\r\n         * Return a new BigNumber whose value is the square root of the value of this BigNumber,\r\n         * rounded according to DECIMAL_PLACES and ROUNDING_MODE.\r\n         */\r\n        P.squareRoot = P.sqrt = function () {\r\n            var m, n, r, rep, t,\r\n                x = this,\r\n                c = x.c,\r\n                s = x.s,\r\n                e = x.e,\r\n                dp = DECIMAL_PLACES + 4,\r\n                half = new BigNumber('0.5');\r\n\r\n            // Negative/NaN/Infinity/zero?\r\n            if ( s !== 1 || !c || !c[0] ) {\r\n                return new BigNumber( !s || s < 0 && ( !c || c[0] ) ? NaN : c ? x : 1 / 0 );\r\n            }\r\n\r\n            // Initial estimate.\r\n            s = Math.sqrt( +x );\r\n\r\n            // Math.sqrt underflow/overflow?\r\n            // Pass x to Math.sqrt as integer, then adjust the exponent of the result.\r\n            if ( s == 0 || s == 1 / 0 ) {\r\n                n = coeffToString(c);\r\n                if ( ( n.length + e ) % 2 == 0 ) n += '0';\r\n                s = Math.sqrt(n);\r\n                e = bitFloor( ( e + 1 ) / 2 ) - ( e < 0 || e % 2 );\r\n\r\n                if ( s == 1 / 0 ) {\r\n                    n = '1e' + e;\r\n                } else {\r\n                    n = s.toExponential();\r\n                    n = n.slice( 0, n.indexOf('e') + 1 ) + e;\r\n                }\r\n\r\n                r = new BigNumber(n);\r\n            } else {\r\n                r = new BigNumber( s + '' );\r\n            }\r\n\r\n            // Check for zero.\r\n            // r could be zero if MIN_EXP is changed after the this value was created.\r\n            // This would cause a division by zero (x/t) and hence Infinity below, which would cause\r\n            // coeffToString to throw.\r\n            if ( r.c[0] ) {\r\n                e = r.e;\r\n                s = e + dp;\r\n                if ( s < 3 ) s = 0;\r\n\r\n                // Newton-Raphson iteration.\r\n                for ( ; ; ) {\r\n                    t = r;\r\n                    r = half.times( t.plus( div( x, t, dp, 1 ) ) );\r\n\r\n                    if ( coeffToString( t.c   ).slice( 0, s ) === ( n =\r\n                         coeffToString( r.c ) ).slice( 0, s ) ) {\r\n\r\n                        // The exponent of r may here be one less than the final result exponent,\r\n                        // e.g 0.0009999 (e-4) --> 0.001 (e-3), so adjust s so the rounding digits\r\n                        // are indexed correctly.\r\n                        if ( r.e < e ) --s;\r\n                        n = n.slice( s - 3, s + 1 );\r\n\r\n                        // The 4th rounding digit may be in error by -1 so if the 4 rounding digits\r\n                        // are 9999 or 4999 (i.e. approaching a rounding boundary) continue the\r\n                        // iteration.\r\n                        if ( n == '9999' || !rep && n == '4999' ) {\r\n\r\n                            // On the first iteration only, check to see if rounding up gives the\r\n                            // exact result as the nines may infinitely repeat.\r\n                            if ( !rep ) {\r\n                                round( t, t.e + DECIMAL_PLACES + 2, 0 );\r\n\r\n                                if ( t.times(t).eq(x) ) {\r\n                                    r = t;\r\n                                    break;\r\n                                }\r\n                            }\r\n\r\n                            dp += 4;\r\n                            s += 4;\r\n                            rep = 1;\r\n                        } else {\r\n\r\n                            // If rounding digits are null, 0{0,4} or 50{0,3}, check for exact\r\n                            // result. If not, then there are further digits and m will be truthy.\r\n                            if ( !+n || !+n.slice(1) && n.charAt(0) == '5' ) {\r\n\r\n                                // Truncate to the first rounding digit.\r\n                                round( r, r.e + DECIMAL_PLACES + 2, 1 );\r\n                                m = !r.times(r).eq(x);\r\n                            }\r\n\r\n                            break;\r\n                        }\r\n                    }\r\n                }\r\n            }\r\n\r\n            return round( r, r.e + DECIMAL_PLACES + 1, ROUNDING_MODE, m );\r\n        };\r\n\r\n\r\n        /*\r\n         *  n * 0 = 0\r\n         *  n * N = N\r\n         *  n * I = I\r\n         *  0 * n = 0\r\n         *  0 * 0 = 0\r\n         *  0 * N = N\r\n         *  0 * I = N\r\n         *  N * n = N\r\n         *  N * 0 = N\r\n         *  N * N = N\r\n         *  N * I = N\r\n         *  I * n = I\r\n         *  I * 0 = N\r\n         *  I * N = N\r\n         *  I * I = I\r\n         *\r\n         * Return a new BigNumber whose value is the value of this BigNumber times the value of\r\n         * BigNumber(y, b).\r\n         */\r\n        P.times = P.mul = function ( y, b ) {\r\n            var c, e, i, j, k, m, xcL, xlo, xhi, ycL, ylo, yhi, zc,\r\n                base, sqrtBase,\r\n                x = this,\r\n                xc = x.c,\r\n                yc = ( id = 17, y = new BigNumber( y, b ) ).c;\r\n\r\n            // Either NaN, ±Infinity or ±0?\r\n            if ( !xc || !yc || !xc[0] || !yc[0] ) {\r\n\r\n                // Return NaN if either is NaN, or one is 0 and the other is Infinity.\r\n                if ( !x.s || !y.s || xc && !xc[0] && !yc || yc && !yc[0] && !xc ) {\r\n                    y.c = y.e = y.s = null;\r\n                } else {\r\n                    y.s *= x.s;\r\n\r\n                    // Return ±Infinity if either is ±Infinity.\r\n                    if ( !xc || !yc ) {\r\n                        y.c = y.e = null;\r\n\r\n                    // Return ±0 if either is ±0.\r\n                    } else {\r\n                        y.c = [0];\r\n                        y.e = 0;\r\n                    }\r\n                }\r\n\r\n                return y;\r\n            }\r\n\r\n            e = bitFloor( x.e / LOG_BASE ) + bitFloor( y.e / LOG_BASE );\r\n            y.s *= x.s;\r\n            xcL = xc.length;\r\n            ycL = yc.length;\r\n\r\n            // Ensure xc points to longer array and xcL to its length.\r\n            if ( xcL < ycL ) zc = xc, xc = yc, yc = zc, i = xcL, xcL = ycL, ycL = i;\r\n\r\n            // Initialise the result array with zeros.\r\n            for ( i = xcL + ycL, zc = []; i--; zc.push(0) );\r\n\r\n            base = BASE;\r\n            sqrtBase = SQRT_BASE;\r\n\r\n            for ( i = ycL; --i >= 0; ) {\r\n                c = 0;\r\n                ylo = yc[i] % sqrtBase;\r\n                yhi = yc[i] / sqrtBase | 0;\r\n\r\n                for ( k = xcL, j = i + k; j > i; ) {\r\n                    xlo = xc[--k] % sqrtBase;\r\n                    xhi = xc[k] / sqrtBase | 0;\r\n                    m = yhi * xlo + xhi * ylo;\r\n                    xlo = ylo * xlo + ( ( m % sqrtBase ) * sqrtBase ) + zc[j] + c;\r\n                    c = ( xlo / base | 0 ) + ( m / sqrtBase | 0 ) + yhi * xhi;\r\n                    zc[j--] = xlo % base;\r\n                }\r\n\r\n                zc[j] = c;\r\n            }\r\n\r\n            if (c) {\r\n                ++e;\r\n            } else {\r\n                zc.shift();\r\n            }\r\n\r\n            return normalise( y, zc, e );\r\n        };\r\n\r\n\r\n        /*\r\n         * Return a new BigNumber whose value is the value of this BigNumber rounded to a maximum of\r\n         * sd significant digits using rounding mode rm, or ROUNDING_MODE if rm is omitted.\r\n         *\r\n         * [sd] {number} Significant digits. Integer, 1 to MAX inclusive.\r\n         * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n         *\r\n         * 'toDigits() precision out of range: {sd}'\r\n         * 'toDigits() precision not an integer: {sd}'\r\n         * 'toDigits() rounding mode not an integer: {rm}'\r\n         * 'toDigits() rounding mode out of range: {rm}'\r\n         */\r\n        P.toDigits = function ( sd, rm ) {\r\n            var n = new BigNumber(this);\r\n            sd = sd == null || !isValidInt( sd, 1, MAX, 18, 'precision' ) ? null : sd | 0;\r\n            rm = rm == null || !isValidInt( rm, 0, 8, 18, roundingMode ) ? ROUNDING_MODE : rm | 0;\r\n            return sd ? round( n, sd, rm ) : n;\r\n        };\r\n\r\n\r\n        /*\r\n         * Return a string representing the value of this BigNumber in exponential notation and\r\n         * rounded using ROUNDING_MODE to dp fixed decimal places.\r\n         *\r\n         * [dp] {number} Decimal places. Integer, 0 to MAX inclusive.\r\n         * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n         *\r\n         * 'toExponential() decimal places not an integer: {dp}'\r\n         * 'toExponential() decimal places out of range: {dp}'\r\n         * 'toExponential() rounding mode not an integer: {rm}'\r\n         * 'toExponential() rounding mode out of range: {rm}'\r\n         */\r\n        P.toExponential = function ( dp, rm ) {\r\n            return format( this,\r\n              dp != null && isValidInt( dp, 0, MAX, 19 ) ? ~~dp + 1 : null, rm, 19 );\r\n        };\r\n\r\n\r\n        /*\r\n         * Return a string representing the value of this BigNumber in fixed-point notation rounding\r\n         * to dp fixed decimal places using rounding mode rm, or ROUNDING_MODE if rm is omitted.\r\n         *\r\n         * Note: as with JavaScript's number type, (-0).toFixed(0) is '0',\r\n         * but e.g. (-0.00001).toFixed(0) is '-0'.\r\n         *\r\n         * [dp] {number} Decimal places. Integer, 0 to MAX inclusive.\r\n         * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n         *\r\n         * 'toFixed() decimal places not an integer: {dp}'\r\n         * 'toFixed() decimal places out of range: {dp}'\r\n         * 'toFixed() rounding mode not an integer: {rm}'\r\n         * 'toFixed() rounding mode out of range: {rm}'\r\n         */\r\n        P.toFixed = function ( dp, rm ) {\r\n            return format( this, dp != null && isValidInt( dp, 0, MAX, 20 )\r\n              ? ~~dp + this.e + 1 : null, rm, 20 );\r\n        };\r\n\r\n\r\n        /*\r\n         * Return a string representing the value of this BigNumber in fixed-point notation rounded\r\n         * using rm or ROUNDING_MODE to dp decimal places, and formatted according to the properties\r\n         * of the FORMAT object (see BigNumber.config).\r\n         *\r\n         * FORMAT = {\r\n         *      decimalSeparator : '.',\r\n         *      groupSeparator : ',',\r\n         *      groupSize : 3,\r\n         *      secondaryGroupSize : 0,\r\n         *      fractionGroupSeparator : '\\xA0',    // non-breaking space\r\n         *      fractionGroupSize : 0\r\n         * };\r\n         *\r\n         * [dp] {number} Decimal places. Integer, 0 to MAX inclusive.\r\n         * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n         *\r\n         * 'toFormat() decimal places not an integer: {dp}'\r\n         * 'toFormat() decimal places out of range: {dp}'\r\n         * 'toFormat() rounding mode not an integer: {rm}'\r\n         * 'toFormat() rounding mode out of range: {rm}'\r\n         */\r\n        P.toFormat = function ( dp, rm ) {\r\n            var str = format( this, dp != null && isValidInt( dp, 0, MAX, 21 )\r\n              ? ~~dp + this.e + 1 : null, rm, 21 );\r\n\r\n            if ( this.c ) {\r\n                var i,\r\n                    arr = str.split('.'),\r\n                    g1 = +FORMAT.groupSize,\r\n                    g2 = +FORMAT.secondaryGroupSize,\r\n                    groupSeparator = FORMAT.groupSeparator,\r\n                    intPart = arr[0],\r\n                    fractionPart = arr[1],\r\n                    isNeg = this.s < 0,\r\n                    intDigits = isNeg ? intPart.slice(1) : intPart,\r\n                    len = intDigits.length;\r\n\r\n                if (g2) i = g1, g1 = g2, g2 = i, len -= i;\r\n\r\n                if ( g1 > 0 && len > 0 ) {\r\n                    i = len % g1 || g1;\r\n                    intPart = intDigits.substr( 0, i );\r\n\r\n                    for ( ; i < len; i += g1 ) {\r\n                        intPart += groupSeparator + intDigits.substr( i, g1 );\r\n                    }\r\n\r\n                    if ( g2 > 0 ) intPart += groupSeparator + intDigits.slice(i);\r\n                    if (isNeg) intPart = '-' + intPart;\r\n                }\r\n\r\n                str = fractionPart\r\n                  ? intPart + FORMAT.decimalSeparator + ( ( g2 = +FORMAT.fractionGroupSize )\r\n                    ? fractionPart.replace( new RegExp( '\\\\d{' + g2 + '}\\\\B', 'g' ),\r\n                      '$&' + FORMAT.fractionGroupSeparator )\r\n                    : fractionPart )\r\n                  : intPart;\r\n            }\r\n\r\n            return str;\r\n        };\r\n\r\n\r\n        /*\r\n         * Return a string array representing the value of this BigNumber as a simple fraction with\r\n         * an integer numerator and an integer denominator. The denominator will be a positive\r\n         * non-zero value less than or equal to the specified maximum denominator. If a maximum\r\n         * denominator is not specified, the denominator will be the lowest value necessary to\r\n         * represent the number exactly.\r\n         *\r\n         * [md] {number|string|BigNumber} Integer >= 1 and < Infinity. The maximum denominator.\r\n         *\r\n         * 'toFraction() max denominator not an integer: {md}'\r\n         * 'toFraction() max denominator out of range: {md}'\r\n         */\r\n        P.toFraction = function (md) {\r\n            var arr, d0, d2, e, exp, n, n0, q, s,\r\n                k = ERRORS,\r\n                x = this,\r\n                xc = x.c,\r\n                d = new BigNumber(ONE),\r\n                n1 = d0 = new BigNumber(ONE),\r\n                d1 = n0 = new BigNumber(ONE);\r\n\r\n            if ( md != null ) {\r\n                ERRORS = false;\r\n                n = new BigNumber(md);\r\n                ERRORS = k;\r\n\r\n                if ( !( k = n.isInt() ) || n.lt(ONE) ) {\r\n\r\n                    if (ERRORS) {\r\n                        raise( 22,\r\n                          'max denominator ' + ( k ? 'out of range' : 'not an integer' ), md );\r\n                    }\r\n\r\n                    // ERRORS is false:\r\n                    // If md is a finite non-integer >= 1, round it to an integer and use it.\r\n                    md = !k && n.c && round( n, n.e + 1, 1 ).gte(ONE) ? n : null;\r\n                }\r\n            }\r\n\r\n            if ( !xc ) return x.toString();\r\n            s = coeffToString(xc);\r\n\r\n            // Determine initial denominator.\r\n            // d is a power of 10 and the minimum max denominator that specifies the value exactly.\r\n            e = d.e = s.length - x.e - 1;\r\n            d.c[0] = POWS_TEN[ ( exp = e % LOG_BASE ) < 0 ? LOG_BASE + exp : exp ];\r\n            md = !md || n.cmp(d) > 0 ? ( e > 0 ? d : n1 ) : n;\r\n\r\n            exp = MAX_EXP;\r\n            MAX_EXP = 1 / 0;\r\n            n = new BigNumber(s);\r\n\r\n            // n0 = d1 = 0\r\n            n0.c[0] = 0;\r\n\r\n            for ( ; ; )  {\r\n                q = div( n, d, 0, 1 );\r\n                d2 = d0.plus( q.times(d1) );\r\n                if ( d2.cmp(md) == 1 ) break;\r\n                d0 = d1;\r\n                d1 = d2;\r\n                n1 = n0.plus( q.times( d2 = n1 ) );\r\n                n0 = d2;\r\n                d = n.minus( q.times( d2 = d ) );\r\n                n = d2;\r\n            }\r\n\r\n            d2 = div( md.minus(d0), d1, 0, 1 );\r\n            n0 = n0.plus( d2.times(n1) );\r\n            d0 = d0.plus( d2.times(d1) );\r\n            n0.s = n1.s = x.s;\r\n            e *= 2;\r\n\r\n            // Determine which fraction is closer to x, n0/d0 or n1/d1\r\n            arr = div( n1, d1, e, ROUNDING_MODE ).minus(x).abs().cmp(\r\n                  div( n0, d0, e, ROUNDING_MODE ).minus(x).abs() ) < 1\r\n                    ? [ n1.toString(), d1.toString() ]\r\n                    : [ n0.toString(), d0.toString() ];\r\n\r\n            MAX_EXP = exp;\r\n            return arr;\r\n        };\r\n\r\n\r\n        /*\r\n         * Return the value of this BigNumber converted to a number primitive.\r\n         */\r\n        P.toNumber = function () {\r\n            var x = this;\r\n\r\n            // Ensure zero has correct sign.\r\n            return +x || ( x.s ? x.s * 0 : NaN );\r\n        };\r\n\r\n\r\n        /*\r\n         * Return a BigNumber whose value is the value of this BigNumber raised to the power n.\r\n         * If n is negative round according to DECIMAL_PLACES and ROUNDING_MODE.\r\n         * If POW_PRECISION is not 0, round to POW_PRECISION using ROUNDING_MODE.\r\n         *\r\n         * n {number} Integer, -9007199254740992 to 9007199254740992 inclusive.\r\n         * (Performs 54 loop iterations for n of 9007199254740992.)\r\n         *\r\n         * 'pow() exponent not an integer: {n}'\r\n         * 'pow() exponent out of range: {n}'\r\n         */\r\n        P.toPower = P.pow = function (n) {\r\n            var k, y,\r\n                i = mathfloor( n < 0 ? -n : +n ),\r\n                x = this;\r\n\r\n            // Pass ±Infinity to Math.pow if exponent is out of range.\r\n            if ( !isValidInt( n, -MAX_SAFE_INTEGER, MAX_SAFE_INTEGER, 23, 'exponent' ) &&\r\n              ( !isFinite(n) || i > MAX_SAFE_INTEGER && ( n /= 0 ) ||\r\n                parseFloat(n) != n && !( n = NaN ) ) ) {\r\n                return new BigNumber( Math.pow( +x, n ) );\r\n            }\r\n\r\n            // Truncating each coefficient array to a length of k after each multiplication equates\r\n            // to truncating significant digits to POW_PRECISION + [28, 41], i.e. there will be a\r\n            // minimum of 28 guard digits retained. (Using + 1.5 would give [9, 21] guard digits.)\r\n            k = POW_PRECISION ? mathceil( POW_PRECISION / LOG_BASE + 2 ) : 0;\r\n            y = new BigNumber(ONE);\r\n\r\n            for ( ; ; ) {\r\n\r\n                if ( i % 2 ) {\r\n                    y = y.times(x);\r\n                    if ( !y.c ) break;\r\n                    if ( k && y.c.length > k ) y.c.length = k;\r\n                }\r\n\r\n                i = mathfloor( i / 2 );\r\n                if ( !i ) break;\r\n\r\n                x = x.times(x);\r\n                if ( k && x.c && x.c.length > k ) x.c.length = k;\r\n            }\r\n\r\n            if ( n < 0 ) y = ONE.div(y);\r\n            return k ? round( y, POW_PRECISION, ROUNDING_MODE ) : y;\r\n        };\r\n\r\n\r\n        /*\r\n         * Return a string representing the value of this BigNumber rounded to sd significant digits\r\n         * using rounding mode rm or ROUNDING_MODE. If sd is less than the number of digits\r\n         * necessary to represent the integer part of the value in fixed-point notation, then use\r\n         * exponential notation.\r\n         *\r\n         * [sd] {number} Significant digits. Integer, 1 to MAX inclusive.\r\n         * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n         *\r\n         * 'toPrecision() precision not an integer: {sd}'\r\n         * 'toPrecision() precision out of range: {sd}'\r\n         * 'toPrecision() rounding mode not an integer: {rm}'\r\n         * 'toPrecision() rounding mode out of range: {rm}'\r\n         */\r\n        P.toPrecision = function ( sd, rm ) {\r\n            return format( this, sd != null && isValidInt( sd, 1, MAX, 24, 'precision' )\r\n              ? sd | 0 : null, rm, 24 );\r\n        };\r\n\r\n\r\n        /*\r\n         * Return a string representing the value of this BigNumber in base b, or base 10 if b is\r\n         * omitted. If a base is specified, including base 10, round according to DECIMAL_PLACES and\r\n         * ROUNDING_MODE. If a base is not specified, and this BigNumber has a positive exponent\r\n         * that is equal to or greater than TO_EXP_POS, or a negative exponent equal to or less than\r\n         * TO_EXP_NEG, return exponential notation.\r\n         *\r\n         * [b] {number} Integer, 2 to 64 inclusive.\r\n         *\r\n         * 'toString() base not an integer: {b}'\r\n         * 'toString() base out of range: {b}'\r\n         */\r\n        P.toString = function (b) {\r\n            var str,\r\n                n = this,\r\n                s = n.s,\r\n                e = n.e;\r\n\r\n            // Infinity or NaN?\r\n            if ( e === null ) {\r\n\r\n                if (s) {\r\n                    str = 'Infinity';\r\n                    if ( s < 0 ) str = '-' + str;\r\n                } else {\r\n                    str = 'NaN';\r\n                }\r\n            } else {\r\n                str = coeffToString( n.c );\r\n\r\n                if ( b == null || !isValidInt( b, 2, 64, 25, 'base' ) ) {\r\n                    str = e <= TO_EXP_NEG || e >= TO_EXP_POS\r\n                      ? toExponential( str, e )\r\n                      : toFixedPoint( str, e );\r\n                } else {\r\n                    str = convertBase( toFixedPoint( str, e ), b | 0, 10, s );\r\n                }\r\n\r\n                if ( s < 0 && n.c[0] ) str = '-' + str;\r\n            }\r\n\r\n            return str;\r\n        };\r\n\r\n\r\n        /*\r\n         * Return a new BigNumber whose value is the value of this BigNumber truncated to a whole\r\n         * number.\r\n         */\r\n        P.truncated = P.trunc = function () {\r\n            return round( new BigNumber(this), this.e + 1, 1 );\r\n        };\r\n\r\n\r\n\r\n        /*\r\n         * Return as toString, but do not accept a base argument.\r\n         */\r\n        P.valueOf = P.toJSON = function () {\r\n            return this.toString();\r\n        };\r\n\r\n\r\n        // Aliases for BigDecimal methods.\r\n        //P.add = P.plus;         // P.add included above\r\n        //P.subtract = P.minus;   // P.sub included above\r\n        //P.multiply = P.times;   // P.mul included above\r\n        //P.divide = P.div;\r\n        //P.remainder = P.mod;\r\n        //P.compareTo = P.cmp;\r\n        //P.negate = P.neg;\r\n\r\n\r\n        if ( configObj != null ) BigNumber.config(configObj);\r\n\r\n        return BigNumber;\r\n    }\r\n\r\n\r\n    // PRIVATE HELPER FUNCTIONS\r\n\r\n\r\n    function bitFloor(n) {\r\n        var i = n | 0;\r\n        return n > 0 || n === i ? i : i - 1;\r\n    }\r\n\r\n\r\n    // Return a coefficient array as a string of base 10 digits.\r\n    function coeffToString(a) {\r\n        var s, z,\r\n            i = 1,\r\n            j = a.length,\r\n            r = a[0] + '';\r\n\r\n        for ( ; i < j; ) {\r\n            s = a[i++] + '';\r\n            z = LOG_BASE - s.length;\r\n            for ( ; z--; s = '0' + s );\r\n            r += s;\r\n        }\r\n\r\n        // Determine trailing zeros.\r\n        for ( j = r.length; r.charCodeAt(--j) === 48; );\r\n        return r.slice( 0, j + 1 || 1 );\r\n    }\r\n\r\n\r\n    // Compare the value of BigNumbers x and y.\r\n    function compare( x, y ) {\r\n        var a, b,\r\n            xc = x.c,\r\n            yc = y.c,\r\n            i = x.s,\r\n            j = y.s,\r\n            k = x.e,\r\n            l = y.e;\r\n\r\n        // Either NaN?\r\n        if ( !i || !j ) return null;\r\n\r\n        a = xc && !xc[0];\r\n        b = yc && !yc[0];\r\n\r\n        // Either zero?\r\n        if ( a || b ) return a ? b ? 0 : -j : i;\r\n\r\n        // Signs differ?\r\n        if ( i != j ) return i;\r\n\r\n        a = i < 0;\r\n        b = k == l;\r\n\r\n        // Either Infinity?\r\n        if ( !xc || !yc ) return b ? 0 : !xc ^ a ? 1 : -1;\r\n\r\n        // Compare exponents.\r\n        if ( !b ) return k > l ^ a ? 1 : -1;\r\n\r\n        j = ( k = xc.length ) < ( l = yc.length ) ? k : l;\r\n\r\n        // Compare digit by digit.\r\n        for ( i = 0; i < j; i++ ) if ( xc[i] != yc[i] ) return xc[i] > yc[i] ^ a ? 1 : -1;\r\n\r\n        // Compare lengths.\r\n        return k == l ? 0 : k > l ^ a ? 1 : -1;\r\n    }\r\n\r\n\r\n    /*\r\n     * Return true if n is a valid number in range, otherwise false.\r\n     * Use for argument validation when ERRORS is false.\r\n     * Note: parseInt('1e+1') == 1 but parseFloat('1e+1') == 10.\r\n     */\r\n    function intValidatorNoErrors( n, min, max ) {\r\n        return ( n = truncate(n) ) >= min && n <= max;\r\n    }\r\n\r\n\r\n    function isArray(obj) {\r\n        return Object.prototype.toString.call(obj) == '[object Array]';\r\n    }\r\n\r\n\r\n    /*\r\n     * Convert string of baseIn to an array of numbers of baseOut.\r\n     * Eg. convertBase('255', 10, 16) returns [15, 15].\r\n     * Eg. convertBase('ff', 16, 10) returns [2, 5, 5].\r\n     */\r\n    function toBaseOut( str, baseIn, baseOut ) {\r\n        var j,\r\n            arr = [0],\r\n            arrL,\r\n            i = 0,\r\n            len = str.length;\r\n\r\n        for ( ; i < len; ) {\r\n            for ( arrL = arr.length; arrL--; arr[arrL] *= baseIn );\r\n            arr[ j = 0 ] += ALPHABET.indexOf( str.charAt( i++ ) );\r\n\r\n            for ( ; j < arr.length; j++ ) {\r\n\r\n                if ( arr[j] > baseOut - 1 ) {\r\n                    if ( arr[j + 1] == null ) arr[j + 1] = 0;\r\n                    arr[j + 1] += arr[j] / baseOut | 0;\r\n                    arr[j] %= baseOut;\r\n                }\r\n            }\r\n        }\r\n\r\n        return arr.reverse();\r\n    }\r\n\r\n\r\n    function toExponential( str, e ) {\r\n        return ( str.length > 1 ? str.charAt(0) + '.' + str.slice(1) : str ) +\r\n          ( e < 0 ? 'e' : 'e+' ) + e;\r\n    }\r\n\r\n\r\n    function toFixedPoint( str, e ) {\r\n        var len, z;\r\n\r\n        // Negative exponent?\r\n        if ( e < 0 ) {\r\n\r\n            // Prepend zeros.\r\n            for ( z = '0.'; ++e; z += '0' );\r\n            str = z + str;\r\n\r\n        // Positive exponent\r\n        } else {\r\n            len = str.length;\r\n\r\n            // Append zeros.\r\n            if ( ++e > len ) {\r\n                for ( z = '0', e -= len; --e; z += '0' );\r\n                str += z;\r\n            } else if ( e < len ) {\r\n                str = str.slice( 0, e ) + '.' + str.slice(e);\r\n            }\r\n        }\r\n\r\n        return str;\r\n    }\r\n\r\n\r\n    function truncate(n) {\r\n        n = parseFloat(n);\r\n        return n < 0 ? mathceil(n) : mathfloor(n);\r\n    }\r\n\r\n\r\n    // EXPORT\r\n\r\n\r\n    BigNumber = another();\r\n\r\n    // AMD.\r\n    if ( typeof define == 'function' && define.amd ) {\r\n        define( function () { return BigNumber; } );\r\n\r\n    // Node and other environments that support module.exports.\r\n    } else if ( typeof module != 'undefined' && module.exports ) {\r\n        module.exports = BigNumber;\r\n        if ( !crypto ) try { crypto = require('crypto'); } catch (e) {}\r\n\r\n    // Browser.\r\n    } else {\r\n        global.BigNumber = BigNumber;\r\n    }\r\n})(this);\r\n",
    "var web3 = require('./lib/web3');\nweb3.providers.HttpProvider = require('./lib/web3/httpprovider');\nweb3.providers.QtSyncProvider = require('./lib/web3/qtsync');\nweb3.eth.contract = require('./lib/web3/contract');\nweb3.abi = require('./lib/solidity/abi');\n\nmodule.exports = web3;\n"
  ]
}