Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2018-01-23
*/

pragma solidity ^0.4.18;

contract OraclizeI {
    address public cbAddress;
    function query(uint _timestamp, string _datasource, string _arg) external payable returns (bytes32 _id);
    function query_withGasLimit(uint _timestamp, string _datasource, string _arg, uint _gaslimit) external payable returns (bytes32 _id);
    function query2(uint _timestamp, string _datasource, string _arg1, string _arg2) public payable returns (bytes32 _id);
    function query2_withGasLimit(uint _timestamp, string _datasource, string _arg1, string _arg2, uint _gaslimit) external payable returns (bytes32 _id);
    function queryN(uint _timestamp, string _datasource, bytes _argN) public payable returns (bytes32 _id);
    function queryN_withGasLimit(uint _timestamp, string _datasource, bytes _argN, uint _gaslimit) external payable returns (bytes32 _id);
    function getPrice(string _datasource) public returns (uint _dsprice);
    function getPrice(string _datasource, uint gaslimit) public returns (uint _dsprice);
    function setProofType(byte _proofType) external;
    function setCustomGasPrice(uint _gasPrice) external;
    function randomDS_getSessionPubKeyHash() external constant returns(bytes32);
}
contract OraclizeAddrResolverI {
    function getAddress() public returns (address _addr);
}
contract usingOraclize {
    uint constant day = 60*60*24;
    uint constant week = 60*60*24*7;
    uint constant month = 60*60*24*30;
    byte constant proofType_NONE = 0x00;
    byte constant proofType_TLSNotary = 0x10;
    byte constant proofType_Android = 0x20;
    byte constant proofType_Ledger = 0x30;
    byte constant proofType_Native = 0xF0;
    byte constant proofStorage_IPFS = 0x01;
    uint8 constant networkID_auto = 0;
    uint8 constant networkID_mainnet = 1;
    uint8 constant networkID_testnet = 2;
    uint8 constant networkID_morden = 2;
    uint8 constant networkID_consensys = 161;

    OraclizeAddrResolverI OAR;

    OraclizeI oraclize;
    modifier oraclizeAPI {
        if((address(OAR)==0)||(getCodeSize(address(OAR))==0))
            oraclize_setNetwork(networkID_auto);

        if(address(oraclize) != OAR.getAddress())
            oraclize = OraclizeI(OAR.getAddress());

        _;
    }
    modifier coupon(string code){
        oraclize = OraclizeI(OAR.getAddress());
        _;
    }

    function oraclize_setNetwork(uint8 networkID) internal returns(bool){
      return oraclize_setNetwork();
      networkID; // silence the warning and remain backwards compatible
    }
    function oraclize_setNetwork() internal returns(bool){
        if (getCodeSize(0x1d3B2638a7cC9f2CB3D298A3DA7a90B67E5506ed)>0){ //mainnet
            OAR = OraclizeAddrResolverI(0x1d3B2638a7cC9f2CB3D298A3DA7a90B67E5506ed);
            oraclize_setNetworkName("eth_mainnet");
            return true;
        }
        if (getCodeSize(0xc03A2615D5efaf5F49F60B7BB6583eaec212fdf1)>0){ //ropsten testnet
            OAR = OraclizeAddrResolverI(0xc03A2615D5efaf5F49F60B7BB6583eaec212fdf1);
            oraclize_setNetworkName("eth_ropsten3");
            return true;
        }
        if (getCodeSize(0xB7A07BcF2Ba2f2703b24C0691b5278999C59AC7e)>0){ //kovan testnet
            OAR = OraclizeAddrResolverI(0xB7A07BcF2Ba2f2703b24C0691b5278999C59AC7e);
            oraclize_setNetworkName("eth_kovan");
            return true;
        }
        if (getCodeSize(0x146500cfd35B22E4A392Fe0aDc06De1a1368Ed48)>0){ //rinkeby testnet
            OAR = OraclizeAddrResolverI(0x146500cfd35B22E4A392Fe0aDc06De1a1368Ed48);
            oraclize_setNetworkName("eth_rinkeby");
            return true;
        }
        if (getCodeSize(0x6f485C8BF6fc43eA212E93BBF8ce046C7f1cb475)>0){ //ethereum-bridge
            OAR = OraclizeAddrResolverI(0x6f485C8BF6fc43eA212E93BBF8ce046C7f1cb475);
            return true;
        }
        if (getCodeSize(0x20e12A1F859B3FeaE5Fb2A0A32C18F5a65555bBF)>0){ //ether.camp ide
            OAR = OraclizeAddrResolverI(0x20e12A1F859B3FeaE5Fb2A0A32C18F5a65555bBF);
            return true;
        }
        if (getCodeSize(0x51efaF4c8B3C9AfBD5aB9F4bbC82784Ab6ef8fAA)>0){ //browser-solidity
            OAR = OraclizeAddrResolverI(0x51efaF4c8B3C9AfBD5aB9F4bbC82784Ab6ef8fAA);
            return true;
        }
        return false;
    }

    function __callback(bytes32 myid, string result) public {
        __callback(myid, result, new bytes(0));
    }
    function __callback(bytes32 myid, string result, bytes proof) public {
      return;
      myid; result; proof; // Silence compiler warnings
    }

    function oraclize_getPrice(string datasource) oraclizeAPI internal returns (uint){
        return oraclize.getPrice(datasource);
    }

    function oraclize_getPrice(string datasource, uint gaslimit) oraclizeAPI internal returns (uint){
        return oraclize.getPrice(datasource, gaslimit);
    }

    function oraclize_query(string datasource, string arg) oraclizeAPI internal returns (bytes32 id){
        uint price = oraclize.getPrice(datasource);
        if (price > 1 ether + tx.gasprice*200000) return 0; // unexpectedly high price
        return oraclize.query.value(price)(0, datasource, arg);
    }
    function oraclize_query(uint timestamp, string datasource, string arg) oraclizeAPI internal returns (bytes32 id){
        uint price = oraclize.getPrice(datasource);
        if (price > 1 ether + tx.gasprice*200000) return 0; // unexpectedly high price
        return oraclize.query.value(price)(timestamp, datasource, arg);
    }
    function oraclize_query(uint timestamp, string datasource, string arg, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
        uint price = oraclize.getPrice(datasource, gaslimit);
        if (price > 1 ether + tx.gasprice*gaslimit) return 0; // unexpectedly high price
        return oraclize.query_withGasLimit.value(price)(timestamp, datasource, arg, gaslimit);
    }
    function oraclize_query(string datasource, string arg, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
        uint price = oraclize.getPrice(datasource, gaslimit);
        if (price > 1 ether + tx.gasprice*gaslimit) return 0; // unexpectedly high price
        return oraclize.query_withGasLimit.value(price)(0, datasource, arg, gaslimit);
    }
    function oraclize_query(string datasource, string arg1, string arg2) oraclizeAPI internal returns (bytes32 id){
        uint price = oraclize.getPrice(datasource);
        if (price > 1 ether + tx.gasprice*200000) return 0; // unexpectedly high price
        return oraclize.query2.value(price)(0, datasource, arg1, arg2);
    }
    function oraclize_query(uint timestamp, string datasource, string arg1, string arg2) oraclizeAPI internal returns (bytes32 id){
        uint price = oraclize.getPrice(datasource);
        if (price > 1 ether + tx.gasprice*200000) return 0; // unexpectedly high price
        return oraclize.query2.value(price)(timestamp, datasource, arg1, arg2);
    }
    function oraclize_query(uint timestamp, string datasource, string arg1, string arg2, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
        uint price = oraclize.getPrice(datasource, gaslimit);
        if (price > 1 ether + tx.gasprice*gaslimit) return 0; // unexpectedly high price
        return oraclize.query2_withGasLimit.value(price)(timestamp, datasource, arg1, arg2, gaslimit);
    }
    function oraclize_query(string datasource, string arg1, string arg2, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
        uint price = oraclize.getPrice(datasource, gaslimit);
        if (price > 1 ether + tx.gasprice*gaslimit) return 0; // unexpectedly high price
        return oraclize.query2_withGasLimit.value(price)(0, datasource, arg1, arg2, gaslimit);
    }
    function oraclize_query(string datasource, string[] argN) oraclizeAPI internal returns (bytes32 id){
        uint price = oraclize.getPrice(datasource);
        if (price > 1 ether + tx.gasprice*200000) return 0; // unexpectedly high price
        bytes memory args = stra2cbor(argN);
        return oraclize.queryN.value(price)(0, datasource, args);
    }
    function oraclize_query(uint timestamp, string datasource, string[] argN) oraclizeAPI internal returns (bytes32 id){
        uint price = oraclize.getPrice(datasource);
        if (price > 1 ether + tx.gasprice*200000) return 0; // unexpectedly high price
        bytes memory args = stra2cbor(argN);
        return oraclize.queryN.value(price)(timestamp, datasource, args);
    }
    function oraclize_query(uint timestamp, string datasource, string[] argN, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
        uint price = oraclize.getPrice(datasource, gaslimit);
        if (price > 1 ether + tx.gasprice*gaslimit) return 0; // unexpectedly high price
        bytes memory args = stra2cbor(argN);
        return oraclize.queryN_withGasLimit.value(price)(timestamp, datasource, args, gaslimit);
    }
    function oraclize_query(string datasource, string[] argN, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
        uint price = oraclize.getPrice(datasource, gaslimit);
        if (price > 1 ether + tx.gasprice*gaslimit) return 0; // unexpectedly high price
        bytes memory args = stra2cbor(argN);
        return oraclize.queryN_withGasLimit.value(price)(0, datasource, args, gaslimit);
    }
    function oraclize_query(string datasource, string[1] args) oraclizeAPI internal returns (bytes32 id) {
        string[] memory dynargs = new string[](1);
        dynargs[0] = args[0];
        return oraclize_query(datasource, dynargs);
    }
    function oraclize_query(uint timestamp, string datasource, string[1] args) oraclizeAPI internal returns (bytes32 id) {
        string[] memory dynargs = new string[](1);
        dynargs[0] = args[0];
        return oraclize_query(timestamp, datasource, dynargs);
    }
    function oraclize_query(uint timestamp, string datasource, string[1] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
        string[] memory dynargs = new string[](1);
        dynargs[0] = args[0];
        return oraclize_query(timestamp, datasource, dynargs, gaslimit);
    }
    function oraclize_query(string datasource, string[1] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
        string[] memory dynargs = new string[](1);
        dynargs[0] = args[0];
        return oraclize_query(datasource, dynargs, gaslimit);
    }

    function oraclize_query(string datasource, string[2] args) oraclizeAPI internal returns (bytes32 id) {
        string[] memory dynargs = new string[](2);
        dynargs[0] = args[0];
        dynargs[1] = args[1];
        return oraclize_query(datasource, dynargs);
    }
    function oraclize_query(uint timestamp, string datasource, string[2] args) oraclizeAPI internal returns (bytes32 id) {
        string[] memory dynargs = new string[](2);
        dynargs[0] = args[0];
        dynargs[1] = args[1];
        return oraclize_query(timestamp, datasource, dynargs);
    }
    function oraclize_query(uint timestamp, string datasource, string[2] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
        string[] memory dynargs = new string[](2);
        dynargs[0] = args[0];
        dynargs[1] = args[1];
        return oraclize_query(timestamp, datasource, dynargs, gaslimit);
    }
    function oraclize_query(string datasource, string[2] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
        string[] memory dynargs = new string[](2);
        dynargs[0] = args[0];
        dynargs[1] = args[1];
        return oraclize_query(datasource, dynargs, gaslimit);
    }
    function oraclize_query(string datasource, string[3] args) oraclizeAPI internal returns (bytes32 id) {
        string[] memory dynargs = new string[](3);
        dynargs[0] = args[0];
        dynargs[1] = args[1];
        dynargs[2] = args[2];
        return oraclize_query(datasource, dynargs);
    }
    function oraclize_query(uint timestamp, string datasource, string[3] args) oraclizeAPI internal returns (bytes32 id) {
        string[] memory dynargs = new string[](3);
        dynargs[0] = args[0];
        dynargs[1] = args[1];
        dynargs[2] = args[2];
        return oraclize_query(timestamp, datasource, dynargs);
    }
    function oraclize_query(uint timestamp, string datasource, string[3] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
        string[] memory dynargs = new string[](3);
        dynargs[0] = args[0];
        dynargs[1] = args[1];
        dynargs[2] = args[2];
        return oraclize_query(timestamp, datasource, dynargs, gaslimit);
    }
    function oraclize_query(string datasource, string[3] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
        string[] memory dynargs = new string[](3);
        dynargs[0] = args[0];
        dynargs[1] = args[1];
        dynargs[2] = args[2];
        return oraclize_query(datasource, dynargs, gaslimit);
    }

    function oraclize_query(string datasource, string[4] args) oraclizeAPI internal returns (bytes32 id) {
        string[] memory dynargs = new string[](4);
        dynargs[0] = args[0];
        dynargs[1] = args[1];
        dynargs[2] = args[2];
        dynargs[3] = args[3];
        return oraclize_query(datasource, dynargs);
    }
    function oraclize_query(uint timestamp, string datasource, string[4] args) oraclizeAPI internal returns (bytes32 id) {
        string[] memory dynargs = new string[](4);
        dynargs[0] = args[0];
        dynargs[1] = args[1];
        dynargs[2] = args[2];
        dynargs[3] = args[3];
        return oraclize_query(timestamp, datasource, dynargs);
    }
    function oraclize_query(uint timestamp, string datasource, string[4] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
        string[] memory dynargs = new string[](4);
        dynargs[0] = args[0];
        dynargs[1] = args[1];
        dynargs[2] = args[2];
        dynargs[3] = args[3];
        return oraclize_query(timestamp, datasource, dynargs, gaslimit);
    }
    function oraclize_query(string datasource, string[4] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
        string[] memory dynargs = new string[](4);
        dynargs[0] = args[0];
        dynargs[1] = args[1];
        dynargs[2] = args[2];
        dynargs[3] = args[3];
        return oraclize_query(datasource, dynargs, gaslimit);
    }
    function oraclize_query(string datasource, string[5] args) oraclizeAPI internal returns (bytes32 id) {
        string[] memory dynargs = new string[](5);
        dynargs[0] = args[0];
        dynargs[1] = args[1];
        dynargs[2] = args[2];
        dynargs[3] = args[3];
        dynargs[4] = args[4];
        return oraclize_query(datasource, dynargs);
    }
    function oraclize_query(uint timestamp, string datasource, string[5] args) oraclizeAPI internal returns (bytes32 id) {
        string[] memory dynargs = new string[](5);
        dynargs[0] = args[0];
        dynargs[1] = args[1];
        dynargs[2] = args[2];
        dynargs[3] = args[3];
        dynargs[4] = args[4];
        return oraclize_query(timestamp, datasource, dynargs);
    }
    function oraclize_query(uint timestamp, string datasource, string[5] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
        string[] memory dynargs = new string[](5);
        dynargs[0] = args[0];
        dynargs[1] = args[1];
        dynargs[2] = args[2];
        dynargs[3] = args[3];
        dynargs[4] = args[4];
        return oraclize_query(timestamp, datasource, dynargs, gaslimit);
    }
    function oraclize_query(string datasource, string[5] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
        string[] memory dynargs = new string[](5);
        dynargs[0] = args[0];
        dynargs[1] = args[1];
        dynargs[2] = args[2];
        dynargs[3] = args[3];
        dynargs[4] = args[4];
        return oraclize_query(datasource, dynargs, gaslimit);
    }
    function oraclize_query(string datasource, bytes[] argN) oraclizeAPI internal returns (bytes32 id){
        uint price = oraclize.getPrice(datasource);
        if (price > 1 ether + tx.gasprice*200000) return 0; // unexpectedly high price
        bytes memory args = ba2cbor(argN);
        return oraclize.queryN.value(price)(0, datasource, args);
    }
    function oraclize_query(uint timestamp, string datasource, bytes[] argN) oraclizeAPI internal returns (bytes32 id){
        uint price = oraclize.getPrice(datasource);
        if (price > 1 ether + tx.gasprice*200000) return 0; // unexpectedly high price
        bytes memory args = ba2cbor(argN);
        return oraclize.queryN.value(price)(timestamp, datasource, args);
    }
    function oraclize_query(uint timestamp, string datasource, bytes[] argN, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
        uint price = oraclize.getPrice(datasource, gaslimit);
        if (price > 1 ether + tx.gasprice*gaslimit) return 0; // unexpectedly high price
        bytes memory args = ba2cbor(argN);
        return oraclize.queryN_withGasLimit.value(price)(timestamp, datasource, args, gaslimit);
    }
    function oraclize_query(string datasource, bytes[] argN, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
        uint price = oraclize.getPrice(datasource, gaslimit);
        if (price > 1 ether + tx.gasprice*gaslimit) return 0; // unexpectedly high price
        bytes memory args = ba2cbor(argN);
        return oraclize.queryN_withGasLimit.value(price)(0, datasource, args, gaslimit);
    }
    function oraclize_query(string datasource, bytes[1] args) oraclizeAPI internal returns (bytes32 id) {
        bytes[] memory dynargs = new bytes[](1);
        dynargs[0] = args[0];
        return oraclize_query(datasource, dynargs);
    }
    function oraclize_query(uint timestamp, string datasource, bytes[1] args) oraclizeAPI internal returns (bytes32 id) {
        bytes[] memory dynargs = new bytes[](1);
        dynargs[0] = args[0];
        return oraclize_query(timestamp, datasource, dynargs);
    }
    function oraclize_query(uint timestamp, string datasource, bytes[1] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
        bytes[] memory dynargs = new bytes[](1);
        dynargs[0] = args[0];
        return oraclize_query(timestamp, datasource, dynargs, gaslimit);
    }
    function oraclize_query(string datasource, bytes[1] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
        bytes[] memory dynargs = new bytes[](1);
        dynargs[0] = args[0];
        return oraclize_query(datasource, dynargs, gaslimit);
    }

    function oraclize_query(string datasource, bytes[2] args) oraclizeAPI internal returns (bytes32 id) {
        bytes[] memory dynargs = new bytes[](2);
        dynargs[0] = args[0];
        dynargs[1] = args[1];
        return oraclize_query(datasource, dynargs);
    }
    function oraclize_query(uint timestamp, string datasource, bytes[2] args) oraclizeAPI internal returns (bytes32 id) {
        bytes[] memory dynargs = new bytes[](2);
        dynargs[0] = args[0];
        dynargs[1] = args[1];
        return oraclize_query(timestamp, datasource, dynargs);
    }
    function oraclize_query(uint timestamp, string datasource, bytes[2] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
        bytes[] memory dynargs = new bytes[](2);
        dynargs[0] = args[0];
        dynargs[1] = args[1];
        return oraclize_query(timestamp, datasource, dynargs, gaslimit);
    }
    function oraclize_query(string datasource, bytes[2] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
        bytes[] memory dynargs = new bytes[](2);
        dynargs[0] = args[0];
        dynargs[1] = args[1];
        return oraclize_query(datasource, dynargs, gaslimit);
    }
    function oraclize_query(string datasource, bytes[3] args) oraclizeAPI internal returns (bytes32 id) {
        bytes[] memory dynargs = new bytes[](3);
        dynargs[0] = args[0];
        dynargs[1] = args[1];
        dynargs[2] = args[2];
        return oraclize_query(datasource, dynargs);
    }
    function oraclize_query(uint timestamp, string datasource, bytes[3] args) oraclizeAPI internal returns (bytes32 id) {
        bytes[] memory dynargs = new bytes[](3);
        dynargs[0] = args[0];
        dynargs[1] = args[1];
        dynargs[2] = args[2];
        return oraclize_query(timestamp, datasource, dynargs);
    }
    function oraclize_query(uint timestamp, string datasource, bytes[3] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
        bytes[] memory dynargs = new bytes[](3);
        dynargs[0] = args[0];
        dynargs[1] = args[1];
        dynargs[2] = args[2];
        return oraclize_query(timestamp, datasource, dynargs, gaslimit);
    }
    function oraclize_query(string datasource, bytes[3] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
        bytes[] memory dynargs = new bytes[](3);
        dynargs[0] = args[0];
        dynargs[1] = args[1];
        dynargs[2] = args[2];
        return oraclize_query(datasource, dynargs, gaslimit);
    }

    function oraclize_query(string datasource, bytes[4] args) oraclizeAPI internal returns (bytes32 id) {
        bytes[] memory dynargs = new bytes[](4);
        dynargs[0] = args[0];
        dynargs[1] = args[1];
        dynargs[2] = args[2];
        dynargs[3] = args[3];
        return oraclize_query(datasource, dynargs);
    }
    function oraclize_query(uint timestamp, string datasource, bytes[4] args) oraclizeAPI internal returns (bytes32 id) {
        bytes[] memory dynargs = new bytes[](4);
        dynargs[0] = args[0];
        dynargs[1] = args[1];
        dynargs[2] = args[2];
        dynargs[3] = args[3];
        return oraclize_query(timestamp, datasource, dynargs);
    }
    function oraclize_query(uint timestamp, string datasource, bytes[4] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
        bytes[] memory dynargs = new bytes[](4);
        dynargs[0] = args[0];
        dynargs[1] = args[1];
        dynargs[2] = args[2];
        dynargs[3] = args[3];
        return oraclize_query(timestamp, datasource, dynargs, gaslimit);
    }
    function oraclize_query(string datasource, bytes[4] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
        bytes[] memory dynargs = new bytes[](4);
        dynargs[0] = args[0];
        dynargs[1] = args[1];
        dynargs[2] = args[2];
        dynargs[3] = args[3];
        return oraclize_query(datasource, dynargs, gaslimit);
    }
    function oraclize_query(string datasource, bytes[5] args) oraclizeAPI internal returns (bytes32 id) {
        bytes[] memory dynargs = new bytes[](5);
        dynargs[0] = args[0];
        dynargs[1] = args[1];
        dynargs[2] = args[2];
        dynargs[3] = args[3];
        dynargs[4] = args[4];
        return oraclize_query(datasource, dynargs);
    }
    function oraclize_query(uint timestamp, string datasource, bytes[5] args) oraclizeAPI internal returns (bytes32 id) {
        bytes[] memory dynargs = new bytes[](5);
        dynargs[0] = args[0];
        dynargs[1] = args[1];
        dynargs[2] = args[2];
        dynargs[3] = args[3];
        dynargs[4] = args[4];
        return oraclize_query(timestamp, datasource, dynargs);
    }
    function oraclize_query(uint timestamp, string datasource, bytes[5] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
        bytes[] memory dynargs = new bytes[](5);
        dynargs[0] = args[0];
        dynargs[1] = args[1];
        dynargs[2] = args[2];
        dynargs[3] = args[3];
        dynargs[4] = args[4];
        return oraclize_query(timestamp, datasource, dynargs, gaslimit);
    }
    function oraclize_query(string datasource, bytes[5] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
        bytes[] memory dynargs = new bytes[](5);
        dynargs[0] = args[0];
        dynargs[1] = args[1];
        dynargs[2] = args[2];
        dynargs[3] = args[3];
        dynargs[4] = args[4];
        return oraclize_query(datasource, dynargs, gaslimit);
    }

    function oraclize_cbAddress() oraclizeAPI internal returns (address){
        return oraclize.cbAddress();
    }
    function oraclize_setProof(byte proofP) oraclizeAPI internal {
        return oraclize.setProofType(proofP);
    }
    function oraclize_setCustomGasPrice(uint gasPrice) oraclizeAPI internal {
        return oraclize.setCustomGasPrice(gasPrice);
    }

    function oraclize_randomDS_getSessionPubKeyHash() oraclizeAPI internal returns (bytes32){
        return oraclize.randomDS_getSessionPubKeyHash();
    }

    function getCodeSize(address _addr) constant internal returns(uint _size) {
        assembly {
            _size := extcodesize(_addr)
        }
    }

    function parseAddr(string _a) internal pure returns (address){
        bytes memory tmp = bytes(_a);
        uint160 iaddr = 0;
        uint160 b1;
        uint160 b2;
        for (uint i=2; i<2+2*20; i+=2){
            iaddr *= 256;
            b1 = uint160(tmp[i]);
            b2 = uint160(tmp[i+1]);
            if ((b1 >= 97)&&(b1 <= 102)) b1 -= 87;
            else if ((b1 >= 65)&&(b1 <= 70)) b1 -= 55;
            else if ((b1 >= 48)&&(b1 <= 57)) b1 -= 48;
            if ((b2 >= 97)&&(b2 <= 102)) b2 -= 87;
            else if ((b2 >= 65)&&(b2 <= 70)) b2 -= 55;
            else if ((b2 >= 48)&&(b2 <= 57)) b2 -= 48;
            iaddr += (b1*16+b2);
        }
        return address(iaddr);
    }

    function strCompare(string _a, string _b) internal pure returns (int) {
        bytes memory a = bytes(_a);
        bytes memory b = bytes(_b);
        uint minLength = a.length;
        if (b.length < minLength) minLength = b.length;
        for (uint i = 0; i < minLength; i ++)
            if (a[i] < b[i])
                return -1;
            else if (a[i] > b[i])
                return 1;
        if (a.length < b.length)
            return -1;
        else if (a.length > b.length)
            return 1;
        else
            return 0;
    }

    function indexOf(string _haystack, string _needle) internal pure returns (int) {
        bytes memory h = bytes(_haystack);
        bytes memory n = bytes(_needle);
        if(h.length < 1 || n.length < 1 || (n.length > h.length))
            return -1;
        else if(h.length > (2**128 -1))
            return -1;
        else
        {
            uint subindex = 0;
            for (uint i = 0; i < h.length; i ++)
            {
                if (h[i] == n[0])
                {
                    subindex = 1;
                    while(subindex < n.length && (i + subindex) < h.length && h[i + subindex] == n[subindex])
                    {
                        subindex++;
                    }
                    if(subindex == n.length)
                        return int(i);
                }
            }
            return -1;
        }
    }

    function strConcat(string _a, string _b, string _c, string _d, string _e) internal pure returns (string) {
        bytes memory _ba = bytes(_a);
        bytes memory _bb = bytes(_b);
        bytes memory _bc = bytes(_c);
        bytes memory _bd = bytes(_d);
        bytes memory _be = bytes(_e);
        string memory abcde = new string(_ba.length + _bb.length + _bc.length + _bd.length + _be.length);
        bytes memory babcde = bytes(abcde);
        uint k = 0;
        for (uint i = 0; i < _ba.length; i++) babcde[k++] = _ba[i];
        for (i = 0; i < _bb.length; i++) babcde[k++] = _bb[i];
        for (i = 0; i < _bc.length; i++) babcde[k++] = _bc[i];
        for (i = 0; i < _bd.length; i++) babcde[k++] = _bd[i];
        for (i = 0; i < _be.length; i++) babcde[k++] = _be[i];
        return string(babcde);
    }

    function strConcat(string _a, string _b, string _c, string _d) internal pure returns (string) {
        return strConcat(_a, _b, _c, _d, "");
    }

    function strConcat(string _a, string _b, string _c) internal pure returns (string) {
        return strConcat(_a, _b, _c, "", "");
    }

    function strConcat(string _a, string _b) internal pure returns (string) {
        return strConcat(_a, _b, "", "", "");
    }

    // parseInt
    function parseInt(string _a) internal pure returns (uint) {
        return parseInt(_a, 0);
    }

    // parseInt(parseFloat*10^_b)
    function parseInt(string _a, uint _b) internal pure returns (uint) {
        bytes memory bresult = bytes(_a);
        uint mint = 0;
        bool decimals = false;
        for (uint i=0; i<bresult.length; i++){
            if ((bresult[i] >= 48)&&(bresult[i] <= 57)){
                if (decimals){
                   if (_b == 0) break;
                    else _b--;
                }
                mint *= 10;
                mint += uint(bresult[i]) - 48;
            } else if (bresult[i] == 46) decimals = true;
        }
        if (_b > 0) mint *= 10**_b;
        return mint;
    }

    function uint2str(uint i) internal pure returns (string){
        if (i == 0) return "0";
        uint j = i;
        uint len;
        while (j != 0){
            len++;
            j /= 10;
        }
        bytes memory bstr = new bytes(len);
        uint k = len - 1;
        while (i != 0){
            bstr[k--] = byte(48 + i % 10);
            i /= 10;
        }
        return string(bstr);
    }

    function stra2cbor(string[] arr) internal pure returns (bytes) {
            uint arrlen = arr.length;

            // get correct cbor output length
            uint outputlen = 0;
            bytes[] memory elemArray = new bytes[](arrlen);
            for (uint i = 0; i < arrlen; i++) {
                elemArray[i] = (bytes(arr[i]));
                outputlen += elemArray[i].length + (elemArray[i].length - 1)/23 + 3; //+3 accounts for paired identifier types
            }
            uint ctr = 0;
            uint cborlen = arrlen + 0x80;
            outputlen += byte(cborlen).length;
            bytes memory res = new bytes(outputlen);

            while (byte(cborlen).length > ctr) {
                res[ctr] = byte(cborlen)[ctr];
                ctr++;
            }
            for (i = 0; i < arrlen; i++) {
                res[ctr] = 0x5F;
                ctr++;
                for (uint x = 0; x < elemArray[i].length; x++) {
                    // if there's a bug with larger strings, this may be the culprit
                    if (x % 23 == 0) {
                        uint elemcborlen = elemArray[i].length - x >= 24 ? 23 : elemArray[i].length - x;
                        elemcborlen += 0x40;
                        uint lctr = ctr;
                        while (byte(elemcborlen).length > ctr - lctr) {
                            res[ctr] = byte(elemcborlen)[ctr - lctr];
                            ctr++;
                        }
                    }
                    res[ctr] = elemArray[i][x];
                    ctr++;
                }
                res[ctr] = 0xFF;
                ctr++;
            }
            return res;
        }

    function ba2cbor(bytes[] arr) internal pure returns (bytes) {
            uint arrlen = arr.length;

            // get correct cbor output length
            uint outputlen = 0;
            bytes[] memory elemArray = new bytes[](arrlen);
            for (uint i = 0; i < arrlen; i++) {
                elemArray[i] = (bytes(arr[i]));
                outputlen += elemArray[i].length + (elemArray[i].length - 1)/23 + 3; //+3 accounts for paired identifier types
            }
            uint ctr = 0;
            uint cborlen = arrlen + 0x80;
            outputlen += byte(cborlen).length;
            bytes memory res = new bytes(outputlen);

            while (byte(cborlen).length > ctr) {
                res[ctr] = byte(cborlen)[ctr];
                ctr++;
            }
            for (i = 0; i < arrlen; i++) {
                res[ctr] = 0x5F;
                ctr++;
                for (uint x = 0; x < elemArray[i].length; x++) {
                    // if there's a bug with larger strings, this may be the culprit
                    if (x % 23 == 0) {
                        uint elemcborlen = elemArray[i].length - x >= 24 ? 23 : elemArray[i].length - x;
                        elemcborlen += 0x40;
                        uint lctr = ctr;
                        while (byte(elemcborlen).length > ctr - lctr) {
                            res[ctr] = byte(elemcborlen)[ctr - lctr];
                            ctr++;
                        }
                    }
                    res[ctr] = elemArray[i][x];
                    ctr++;
                }
                res[ctr] = 0xFF;
                ctr++;
            }
            return res;
        }


    string oraclize_network_name;
    function oraclize_setNetworkName(string _network_name) internal {
        oraclize_network_name = _network_name;
    }

    function oraclize_getNetworkName() internal view returns (string) {
        return oraclize_network_name;
    }

    function oraclize_newRandomDSQuery(uint _delay, uint _nbytes, uint _customGasLimit) internal returns (bytes32){
        require((_nbytes > 0) && (_nbytes <= 32));
        bytes memory nbytes = new bytes(1);
        nbytes[0] = byte(_nbytes);
        bytes memory unonce = new bytes(32);
        bytes memory sessionKeyHash = new bytes(32);
        bytes32 sessionKeyHash_bytes32 = oraclize_randomDS_getSessionPubKeyHash();
        assembly {
            mstore(unonce, 0x20)
            mstore(add(unonce, 0x20), xor(blockhash(sub(number, 1)), xor(coinbase, timestamp)))
            mstore(sessionKeyHash, 0x20)
            mstore(add(sessionKeyHash, 0x20), sessionKeyHash_bytes32)
        }
        bytes[3] memory args = [unonce, nbytes, sessionKeyHash];
        bytes32 queryId = oraclize_query(_delay, "random", args, _customGasLimit);
        oraclize_randomDS_setCommitment(queryId, keccak256(bytes8(_delay), args[1], sha256(args[0]), args[2]));
        return queryId;
    }

    function oraclize_randomDS_setCommitment(bytes32 queryId, bytes32 commitment) internal {
        oraclize_randomDS_args[queryId] = commitment;
    }

    mapping(bytes32=>bytes32) oraclize_randomDS_args;
    mapping(bytes32=>bool) oraclize_randomDS_sessionKeysHashVerified;

    function verifySig(bytes32 tosignh, bytes dersig, bytes pubkey) internal returns (bool){
        bool sigok;
        address signer;

        bytes32 sigr;
        bytes32 sigs;

        bytes memory sigr_ = new bytes(32);
        uint offset = 4+(uint(dersig[3]) - 0x20);
        sigr_ = copyBytes(dersig, offset, 32, sigr_, 0);
        bytes memory sigs_ = new bytes(32);
        offset += 32 + 2;
        sigs_ = copyBytes(dersig, offset+(uint(dersig[offset-1]) - 0x20), 32, sigs_, 0);

        assembly {
            sigr := mload(add(sigr_, 32))
            sigs := mload(add(sigs_, 32))
        }


        (sigok, signer) = safer_ecrecover(tosignh, 27, sigr, sigs);
        if (address(keccak256(pubkey)) == signer) return true;
        else {
            (sigok, signer) = safer_ecrecover(tosignh, 28, sigr, sigs);
            return (address(keccak256(pubkey)) == signer);
        }
    }

    function oraclize_randomDS_proofVerify__sessionKeyValidity(bytes proof, uint sig2offset) internal returns (bool) {
        bool sigok;

        // Step 6: verify the attestation signature, APPKEY1 must sign the sessionKey from the correct ledger app (CODEHASH)
        bytes memory sig2 = new bytes(uint(proof[sig2offset+1])+2);
        copyBytes(proof, sig2offset, sig2.length, sig2, 0);

        bytes memory appkey1_pubkey = new bytes(64);
        copyBytes(proof, 3+1, 64, appkey1_pubkey, 0);

        bytes memory tosign2 = new bytes(1+65+32);
        tosign2[0] = byte(1); //role
        copyBytes(proof, sig2offset-65, 65, tosign2, 1);
        bytes memory CODEHASH = hex"fd94fa71bc0ba10d39d464d0d8f465efeef0a2764e3887fcc9df41ded20f505c";
        copyBytes(CODEHASH, 0, 32, tosign2, 1+65);
        sigok = verifySig(sha256(tosign2), sig2, appkey1_pubkey);

        if (sigok == false) return false;


        // Step 7: verify the APPKEY1 provenance (must be signed by Ledger)
        bytes memory LEDGERKEY = hex"7fb956469c5c9b89840d55b43537e66a98dd4811ea0a27224272c2e5622911e8537a2f8e86a46baec82864e98dd01e9ccc2f8bc5dfc9cbe5a91a290498dd96e4";

        bytes memory tosign3 = new bytes(1+65);
        tosign3[0] = 0xFE;
        copyBytes(proof, 3, 65, tosign3, 1);

        bytes memory sig3 = new bytes(uint(proof[3+65+1])+2);
        copyBytes(proof, 3+65, sig3.length, sig3, 0);

        sigok = verifySig(sha256(tosign3), sig3, LEDGERKEY);

        return sigok;
    }

    modifier oraclize_randomDS_proofVerify(bytes32 _queryId, string _result, bytes _proof) {
        // Step 1: the prefix has to match 'LP\x01' (Ledger Proof version 1)
        require((_proof[0] == "L") && (_proof[1] == "P") && (_proof[2] == 1));

        bool proofVerified = oraclize_randomDS_proofVerify__main(_proof, _queryId, bytes(_result), oraclize_getNetworkName());
        require(proofVerified);

        _;
    }

    function oraclize_randomDS_proofVerify__returnCode(bytes32 _queryId, string _result, bytes _proof) internal returns (uint8){
        // Step 1: the prefix has to match 'LP\x01' (Ledger Proof version 1)
        if ((_proof[0] != "L")||(_proof[1] != "P")||(_proof[2] != 1)) return 1;

        bool proofVerified = oraclize_randomDS_proofVerify__main(_proof, _queryId, bytes(_result), oraclize_getNetworkName());
        if (proofVerified == false) return 2;

        return 0;
    }

    function matchBytes32Prefix(bytes32 content, bytes prefix, uint n_random_bytes) internal pure returns (bool){
        bool match_ = true;
        

        for (uint256 i=0; i< n_random_bytes; i++) {
            if (content[i] != prefix[i]) match_ = false;
        }

        return match_;
    }

    function oraclize_randomDS_proofVerify__main(bytes proof, bytes32 queryId, bytes result, string context_name) internal returns (bool){

        // Step 2: the unique keyhash has to match with the sha256 of (context name + queryId)
        uint ledgerProofLength = 3+65+(uint(proof[3+65+1])+2)+32;
        bytes memory keyhash = new bytes(32);
        copyBytes(proof, ledgerProofLength, 32, keyhash, 0);
        if (!(keccak256(keyhash) == keccak256(sha256(context_name, queryId)))) return false;

        bytes memory sig1 = new bytes(uint(proof[ledgerProofLength+(32+8+1+32)+1])+2);
        copyBytes(proof, ledgerProofLength+(32+8+1+32), sig1.length, sig1, 0);

        // Step 3: we assume sig1 is valid (it will be verified during step 5) and we verify if 'result' is the prefix of sha256(sig1)
        if (!matchBytes32Prefix(sha256(sig1), result, uint(proof[ledgerProofLength+32+8]))) return false;

        // Step 4: commitment match verification, keccak256(delay, nbytes, unonce, sessionKeyHash) == commitment in storage.
        // This is to verify that the computed args match with the ones specified in the query.
        bytes memory commitmentSlice1 = new bytes(8+1+32);
        copyBytes(proof, ledgerProofLength+32, 8+1+32, commitmentSlice1, 0);

        bytes memory sessionPubkey = new bytes(64);
        uint sig2offset = ledgerProofLength+32+(8+1+32)+sig1.length+65;
        copyBytes(proof, sig2offset-64, 64, sessionPubkey, 0);

        bytes32 sessionPubkeyHash = sha256(sessionPubkey);
        if (oraclize_randomDS_args[queryId] == keccak256(commitmentSlice1, sessionPubkeyHash)){ //unonce, nbytes and sessionKeyHash match
            delete oraclize_randomDS_args[queryId];
        } else return false;


        // Step 5: validity verification for sig1 (keyhash and args signed with the sessionKey)
        bytes memory tosign1 = new bytes(32+8+1+32);
        copyBytes(proof, ledgerProofLength, 32+8+1+32, tosign1, 0);
        if (!verifySig(sha256(tosign1), sig1, sessionPubkey)) return false;

        // verify if sessionPubkeyHash was verified already, if not.. let's do it!
        if (oraclize_randomDS_sessionKeysHashVerified[sessionPubkeyHash] == false){
            oraclize_randomDS_sessionKeysHashVerified[sessionPubkeyHash] = oraclize_randomDS_proofVerify__sessionKeyValidity(proof, sig2offset);
        }

        return oraclize_randomDS_sessionKeysHashVerified[sessionPubkeyHash];
    }

    // the following function has been written by Alex Beregszaszi (@axic), use it under the terms of the MIT license
    function copyBytes(bytes from, uint fromOffset, uint length, bytes to, uint toOffset) internal pure returns (bytes) {
        uint minLength = length + toOffset;

        // Buffer too small
        require(to.length >= minLength); // Should be a better way?

        // NOTE: the offset 32 is added to skip the `size` field of both bytes variables
        uint i = 32 + fromOffset;
        uint j = 32 + toOffset;

        while (i < (32 + fromOffset + length)) {
            assembly {
                let tmp := mload(add(from, i))
                mstore(add(to, j), tmp)
            }
            i += 32;
            j += 32;
        }

        return to;
    }

    // the following function has been written by Alex Beregszaszi (@axic), use it under the terms of the MIT license
    // Duplicate Solidity's ecrecover, but catching the CALL return value
    function safer_ecrecover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal returns (bool, address) {
        // We do our own memory management here. Solidity uses memory offset
        // 0x40 to store the current end of memory. We write past it (as
        // writes are memory extensions), but don't update the offset so
        // Solidity will reuse it. The memory used here is only needed for
        // this context.

        // FIXME: inline assembly can't access return values
        bool ret;
        address addr;

        assembly {
            let size := mload(0x40)
            mstore(size, hash)
            mstore(add(size, 32), v)
            mstore(add(size, 64), r)
            mstore(add(size, 96), s)

            // NOTE: we can reuse the request memory because we deal with
            //       the return code
            ret := call(3000, 1, 0, size, 128, size, 32)
            addr := mload(size)
        }

        return (ret, addr);
    }

    // the following function has been written by Alex Beregszaszi (@axic), use it under the terms of the MIT license
    function ecrecovery(bytes32 hash, bytes sig) internal returns (bool, address) {
        bytes32 r;
        bytes32 s;
        uint8 v;

        if (sig.length != 65)
          return (false, 0);

        // The signature format is a compact form of:
        //   {bytes32 r}{bytes32 s}{uint8 v}
        // Compact means, uint8 is not padded to 32 bytes.
        assembly {
            r := mload(add(sig, 32))
            s := mload(add(sig, 64))

            // Here we are loading the last 32 bytes. We exploit the fact that
            // 'mload' will pad with zeroes if we overread.
            // There is no 'mload8' to do this, but that would be nicer.
            v := byte(0, mload(add(sig, 96)))

            // Alternative solution:
            // 'byte' is not working due to the Solidity parser, so lets
            // use the second best option, 'and'
            // v := and(mload(add(sig, 65)), 255)
        }

        // albeit non-transactional signatures are not specified by the YP, one would expect it
        // to match the YP range of [27, 28]
        //
        // geth uses [0, 1] and some clients have followed. This might change, see:
        //  https://github.com/ethereum/go-ethereum/issues/2053
        if (v < 27)
          v += 27;

        if (v != 27 && v != 28)
            return (false, 0);

        return safer_ecrecover(hash, v, r, s);
    }

}
// </ORACLIZE_API>

library SafeMath {
  function mul(uint256 a, uint256 b) internal pure returns (uint256) {
    if (a == 0) {
      return 0;
    }
    uint256 c = a * b;
    assert(c / a == b);
    return c;
  }

  function div(uint256 a, uint256 b) internal pure returns (uint256) {
    // assert(b > 0); // Solidity automatically throws when dividing by 0
    uint256 c = a / b;
    // assert(a == b * c + a % b); // There is no case in which this doesn't hold
    return c;
  }

  function sub(uint256 a, uint256 b) internal pure returns (uint256) {
    assert(b <= a);
    return a - b;
  }

  function add(uint256 a, uint256 b) internal pure returns (uint256) {
    uint256 c = a + b;
    assert(c >= a);
    return c;
  }
}

contract ERC20 {
    uint256 public totalSupply;
    function balanceOf(address who) public view returns (uint256);
    function transfer(address to, uint256 value) public returns (bool);
    function transferFrom(address from, address to, uint256 value) public returns (bool);
    function allowance(address owner, address spender) public view returns (uint256);
    function approve(address spender, uint256 value) public returns (bool);
    event Approval(address indexed owner, address indexed spender, uint256 value);
    event Transfer(address indexed from, address indexed to, uint256 value);
}

contract StandardToken is ERC20 {
    using SafeMath for uint256;

    mapping(address => uint256) balances;
    mapping (address => mapping (address => uint256)) internal allowed;

    /**
    * @dev Gets the balance of the specified address.
    * @param _owner The address to query the the balance of.
    * @return An uint256 representing the amount owned by the passed address.
    */
    function balanceOf(address _owner) public view returns (uint256 balance) {
        return balances[_owner];
    }

    /**
    * @dev transfer token for a specified address
    * @param _to The address to transfer to.
    * @param _value The amount to be transferred.
    */
    function transfer(address _to, uint256 _value) public returns (bool) {
        require(_to != address(0));
        require(_value <= balances[msg.sender]);

        // SafeMath.sub will throw if there is not enough balance.
        balances[msg.sender] = balances[msg.sender].sub(_value);
        balances[_to] = balances[_to].add(_value);
        Transfer(msg.sender, _to, _value);
        return true;
    }

    /**
    * @dev Transfer tokens from one address to another
    * @param _from address The address which you want to send tokens from
    * @param _to address The address which you want to transfer to
    * @param _value uint256 the amount of tokens to be transferred
    */
    function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
        require(_to != address(0));
        require(_value <= balances[_from]);
        require(_value <= allowed[_from][msg.sender]);

        balances[_from] = balances[_from].sub(_value);
        balances[_to] = balances[_to].add(_value);
        allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
        Transfer(_from, _to, _value);
        return true;
    }

    /**
    * @dev Function to check the amount of tokens that an owner allowed to a spender.
    * @param _owner address The address which owns the funds.
    * @param _spender address The address which will spend the funds.
    * @return A uint256 specifying the amount of tokens still available for the spender.
    */
    function allowance(address _owner, address _spender) public view returns (uint256) {
        return allowed[_owner][_spender];
    }

    /**
    * @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
    *
    * Beware that changing an allowance with this method brings the risk that someone may use both the old
    * and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this
    * race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards:
    * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
    * @param _spender The address which will spend the funds.
    * @param _value The amount of tokens to be spent.
    */
    function approve(address _spender, uint256 _value) public returns (bool) {
        allowed[msg.sender][_spender] = _value;
        Approval(msg.sender, _spender, _value);
        return true;
    }


    /**
    * approve should be called when allowed[_spender] == 0. To increment
    * allowed value is better to use this function to avoid 2 calls (and wait until
    * the first transaction is mined)
    * From MonolithDAO Token.sol
    */
    function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
        allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
        Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
        return true;
    }

    function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
        uint oldValue = allowed[msg.sender][_spender];
        if (_subtractedValue > oldValue) {
        allowed[msg.sender][_spender] = 0;
        } else {
        allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
        }
        Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
        return true;
    }
}

contract FiCoin is StandardToken, usingOraclize {

    using SafeMath for uint256;

    struct Contributor {
        address addr;
        uint256 amount;
    }

    mapping (bytes32 => Contributor) internal contributors;

    //==========================================================
    // TOKEN PROPERTIES
    //==========================================================
    string public constant name = "FiCoin";
    string public constant symbol = "FiC";
    uint256 public constant decimals = 18;
    string public version = "1.0";

    //==========================================================
    // STAGE LIMITS PROPERTIES
    //==========================================================
    uint256 public saleCap;

    //==========================================================
    // WALLETS
    //==========================================================
    address public FiCoinFundDeposit;
    address public CoinStorage;
    address public OwnerAddress;

    //==========================================================
    // CROWDSALE STAGES
    //==========================================================
    bool internal isPreSale = false;
    bool internal isFirstRound  = false;
    bool internal isSecondRound = false;

    uint256 public burnedTokens;

    //==========================================================
    // INTERNAL VARIABLES
    //==========================================================
    uint256 internal tokenPriceInCents;
    uint256 internal buyLimit;
    uint256 internal totalLocked;
    uint256 internal startDate;
    uint256 internal endDate;
    mapping(address => uint256) internal lockedTokens;
    mapping(address => uint256) internal buyLimitPerAddress;

    //==========================================================
    // EVENTS
    //==========================================================
    event OraclizeQuery(string description);
    event Burn(address indexed burner, uint256 value);
    event TokenPurchase(address indexed purchaser, uint256 value, uint256 amount);
    event Lock(address indexed purchaser, uint256 value);

    //==========================================================
    // MODIFIERS
    //==========================================================
    modifier onlyOwner() {
        require(msg.sender == OwnerAddress);
        _;
    }

    //==========================================================
    // CONSTRUCTOR
    //==========================================================
    function FiCoin() public {

        FiCoinFundDeposit = 0x00aa6ddfa8ADD5B1E6bCfFcbaB83c3FDBd10DA91;
        CoinStorage = 0x00aD59ec96C12dA4C4546383fac422fEF45a21bB;
        OwnerAddress = 0x00aD59ec96C12dA4C4546383fac422fEF45a21bB;
        
        totalSupply = 14930352 * 10 ** decimals;

        // crowdsale statistics
        tokenPriceInCents = 34;
        buyLimit = 0;
        saleCap = 0;

        // burned tokens
        burnedTokens = 0;

        // move the supply the storage
        balances[CoinStorage] = totalSupply;

        startDate = 0;
        endDate = 0;
    }

    //==========================================================
    // ONLY OWNER FUNCTIONS
    //==========================================================
    function forwardFunds() onlyOwner public {
        FiCoinFundDeposit.transfer(this.balance);
    }

    //==========================================================
    // PUBLIC FUNCTIONS
    //==========================================================
    function () public payable {
        buyTokens(msg.sender);
    }

    // low level token purchase function
    function buyTokens(address beneficiary) public payable {
        require(beneficiary != address(0));
        require(msg.value >= 1 * 10 ** 17); // minimum ETH contribution is 0.1 ETH
        require(startDate < now && endDate > now);
        
        // this functionallity is kept in the same function with purpose.
        if (oraclize_getPrice("URL") > this.balance) {
            OraclizeQuery("Oraclize query was NOT sent, please add some ETH to cover for the query fee");
        } else {
            OraclizeQuery("Oraclize query was sent, standing by for the answer.");
            bytes32 queryId = oraclize_query("URL", "json(https://api.coinmarketcap.com/v1/ticker/ethereum).0.price_usd");
            contributors[queryId] = Contributor(beneficiary, msg.value);
        }
    }
    
    function lockedOf(address _owner) public view returns (uint256 locked) {
        return lockedTokens[_owner];
    }
    
    function __callback(bytes32 myid, string result, bytes proof) public {
        require (msg.sender == oraclize_cbAddress());

        uint256 etherPrice = parseInt(result, 2);
        uint256 purchasedTokens = getPurchasedTokens(contributors[myid].amount, etherPrice);
    
        privateTransfer(contributors[myid].addr, purchasedTokens);
        TokenPurchase(contributors[myid].addr, contributors[myid].amount, purchasedTokens);

        delete contributors[myid];
    }


    //==========================================================
    // INTERNAL FUNCTIONS
    //==========================================================
    function getPurchasedTokens(uint256 _weiAmount, uint256 _etherPrice) internal constant returns (uint256) { 
        require(_etherPrice > 0);

        //Formula:
        //( weiAmount * etherPrice (cents) ) / ( tokenPrice (cents) )
        uint256 purchasedTokens = _weiAmount.mul(_etherPrice);
        purchasedTokens = purchasedTokens.div(tokenPriceInCents);

        return purchasedTokens;
    }

    function privateTransfer(address _to, uint256 _value) internal returns (bool) {
        require(_to != address(0));
        require(_value <= balances[CoinStorage]);
        // check that sold tokens + purchase value + totalLocked is less than the saleCap
        require(totalSupply - balances[CoinStorage] + _value + totalLocked <= saleCap);
        // check that user's locked tokens + purchase value is less than the purchase limit
        require(buyLimitPerAddress[_to] + lockedTokens[_to] + _value <= buyLimit); 

        // SafeMath.sub will throw if there is not enough balance.
        balances[CoinStorage] = balances[CoinStorage].sub(_value);
        balances[_to] = balances[_to].add(_value);
        //===================================================================
        buyLimitPerAddress[_to] = buyLimitPerAddress[_to].add(_value);
        //===================================================================
        Transfer(CoinStorage, _to, _value);
        return true;
    }

    // Add to totalLocked
    // Substract from owner's balance
    // Init mapping.
    function lock(address _to, uint256 _value) onlyOwner public {
        require(_to != address(0));
        require(_value <= balances[CoinStorage]);
        // check that sold tokens + purchase value + totalLocked is less than the saleCap
        require(totalSupply - balances[CoinStorage] + _value + totalLocked <= saleCap);
        // check that user's locked tokens + purchase value is less than the purchase limit
        require(buyLimitPerAddress[_to] + lockedTokens[_to] + _value <= buyLimit);
        
        totalLocked = totalLocked + _value;
        balances[CoinStorage] = balances[CoinStorage].sub(_value);
        lockedTokens[_to] = _value;
    }

    // Unlock tokens
    // Transfer tokens
    function pay(address _to, uint256 _value) onlyOwner public {
        unlock(_to);
        privateTransfer(_to, _value);
    }

    // Substract from totalLocked
    // Add the locked tokens to the owner's balance
    // Delete mapping element
    function unlock(address _to) onlyOwner public {
        require(_to != address(0));
        require(lockedTokens[_to] > 0);

        totalLocked = totalLocked.sub(lockedTokens[_to]);
        balances[CoinStorage] = balances[CoinStorage].add(lockedTokens[_to]);
        delete lockedTokens[_to];
    }


    //==========================================================
    // EXTERNAL FUNCTIONS
    //==========================================================
    function switchSaleStage() onlyOwner public {
        require(!isSecondRound);

        if (!isPreSale) {
            isPreSale = true;
            tokenPriceInCents = 34;
            buyLimit = 5000 * 10 ** decimals;
            saleCap = 2178309 * 10 ** decimals;
        } else if (!isFirstRound) {
            isFirstRound = true;
            tokenPriceInCents = 55;
            buyLimit = buyLimit + 10000 * 10 ** decimals;
            saleCap = totalSupply - balances[CoinStorage] + 3524578 * 10 ** decimals;
        } else if (!isSecondRound) {
            isSecondRound = true;
            tokenPriceInCents = 89;
            buyLimit = buyLimit + 15000 * 10**decimals;
            saleCap = totalSupply - balances[CoinStorage] + 5702887 * 10 ** decimals;
        } 

        startDate = now + 1 minutes;
        endDate = startDate + 120 hours;
    }
    
    /**
     * @dev Burns a specific amount of tokens.
     * @param _value The amount of token to be burned.
     */
    function burn(uint256 _value) public {
        require(_value > 0);
        require(_value <= balances[msg.sender]);
        // no need to require value <= totalSupply, since that would imply the
        // sender's balance is greater than the totalSupply, which *should* be an assertion failure

        address burner = msg.sender;
        balances[burner] = balances[burner].sub(_value);
        totalSupply = totalSupply.sub(_value);
        burnedTokens = burnedTokens.add(_value);
        Burn(burner, _value);
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"constant":true,"inputs":[],"name":"FiCoinFundDeposit","outputs":[{"name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"name","outputs":[{"name":"","type":"string"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"saleCap","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"_spender","type":"address"},{"name":"_value","type":"uint256"}],"name":"approve","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"totalSupply","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"_from","type":"address"},{"name":"_to","type":"address"},{"name":"_value","type":"uint256"}],"name":"transferFrom","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[],"name":"switchSaleStage","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"myid","type":"bytes32"},{"name":"result","type":"string"}],"name":"__callback","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"_to","type":"address"},{"name":"_value","type":"uint256"}],"name":"lock","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"_to","type":"address"}],"name":"unlock","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"decimals","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"myid","type":"bytes32"},{"name":"result","type":"string"},{"name":"proof","type":"bytes"}],"name":"__callback","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"_value","type":"uint256"}],"name":"burn","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"burnedTokens","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"version","outputs":[{"name":"","type":"string"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"_spender","type":"address"},{"name":"_subtractedValue","type":"uint256"}],"name":"decreaseApproval","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"name":"_owner","type":"address"}],"name":"balanceOf","outputs":[{"name":"balance","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"OwnerAddress","outputs":[{"name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"symbol","outputs":[{"name":"","type":"string"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[],"name":"forwardFunds","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"name":"_owner","type":"address"}],"name":"lockedOf","outputs":[{"name":"locked","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"_to","type":"address"},{"name":"_value","type":"uint256"}],"name":"transfer","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"_to","type":"address"},{"name":"_value","type":"uint256"}],"name":"pay","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"_spender","type":"address"},{"name":"_addedValue","type":"uint256"}],"name":"increaseApproval","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"name":"_owner","type":"address"},{"name":"_spender","type":"address"}],"name":"allowance","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"CoinStorage","outputs":[{"name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"beneficiary","type":"address"}],"name":"buyTokens","outputs":[],"payable":true,"stateMutability":"payable","type":"function"},{"inputs":[],"payable":false,"stateMutability":"nonpayable","type":"constructor"},{"payable":true,"stateMutability":"payable","type":"fallback"},{"anonymous":false,"inputs":[{"indexed":false,"name":"description","type":"string"}],"name":"OraclizeQuery","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"burner","type":"address"},{"indexed":false,"name":"value","type":"uint256"}],"name":"Burn","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"purchaser","type":"address"},{"indexed":false,"name":"value","type":"uint256"},{"indexed":false,"name":"amount","type":"uint256"}],"name":"TokenPurchase","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"purchaser","type":"address"},{"indexed":false,"name":"value","type":"uint256"}],"name":"Lock","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"owner","type":"address"},{"indexed":true,"name":"spender","type":"address"},{"indexed":false,"name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"from","type":"address"},{"indexed":true,"name":"to","type":"address"},{"indexed":false,"name":"value","type":"uint256"}],"name":"Transfer","type":"event"}]

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

bzzr://c34392be577502526747ca841dac8160664c48afd128c47b1eed3774f898b16b