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-11-05
*/

pragma solidity ^0.4.20;
/* import "github.com/oraclize/ethereum-api/oraclizeAPI.sol"; */


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));
        // Convert from seconds to ledger timer ticks
        _delay *= 10;
        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 memory delay = new bytes(32);
        assembly {
            mstore(add(delay, 0x20), _delay)
        }

        bytes memory delay_bytes8 = new bytes(8);
        copyBytes(delay, 24, 8, delay_bytes8, 0);

        bytes[4] memory args = [unonce, nbytes, sessionKeyHash, delay];
        bytes32 queryId = oraclize_query("random", args, _customGasLimit);

        bytes memory delay_bytes8_left = new bytes(8);

        assembly {
            let x := mload(add(delay_bytes8, 0x20))
            mstore8(add(delay_bytes8_left, 0x27), div(x, 0x100000000000000000000000000000000000000000000000000000000000000))
            mstore8(add(delay_bytes8_left, 0x26), div(x, 0x1000000000000000000000000000000000000000000000000000000000000))
            mstore8(add(delay_bytes8_left, 0x25), div(x, 0x10000000000000000000000000000000000000000000000000000000000))
            mstore8(add(delay_bytes8_left, 0x24), div(x, 0x100000000000000000000000000000000000000000000000000000000))
            mstore8(add(delay_bytes8_left, 0x23), div(x, 0x1000000000000000000000000000000000000000000000000000000))
            mstore8(add(delay_bytes8_left, 0x22), div(x, 0x10000000000000000000000000000000000000000000000000000))
            mstore8(add(delay_bytes8_left, 0x21), div(x, 0x100000000000000000000000000000000000000000000000000))
            mstore8(add(delay_bytes8_left, 0x20), div(x, 0x1000000000000000000000000000000000000000000000000))

        }

        oraclize_randomDS_setCommitment(queryId, keccak256(delay_bytes8_left, 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;

        require(prefix.length == n_random_bytes);

        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);
    }

}

contract BetContract is usingOraclize{
  uint  maxProfit;//最高奖池
  uint  maxmoneypercent;
  uint public contractBalance;
  uint minBet;
  uint onoff;//游戏启用或关闭
  address private owner;
  uint private orderId;
  uint private randonce;

  event LogNewOraclizeQuery(string description,bytes32 queryId);
  event LogNewRandomNumber(string result,bytes32 queryId);
  event LogSendBonus(uint id,bytes32 lableId,uint playId,uint content,uint singleMoney,uint mutilple,address user,uint betTime,uint status,uint winMoney);

  mapping (address => bytes32[]) playerLableList;//玩家下注批次
  mapping (bytes32 => mapping (uint => uint[7])) betList;//批次，注单映射
  mapping (bytes32 => uint) lableCount;//批次，注单数
  mapping (bytes32 => uint) lableTime;//批次，投注时间
  mapping (bytes32 => uint) lableStatus;//批次，状态 0 未结算，1 已撤单，2 已结算 3 已派奖
  mapping (bytes32 => uint[3]) openNumberList;//批次开奖号码映射
  mapping (bytes32 => string) openNumberStr;//批次开奖号码映射
  mapping (bytes32 => address) lableUser;

  function BetContract() public {
    owner = msg.sender;
    orderId = 0;

    onoff=1;
    minBet=1500000000000000;//最小金额要比手续费大
    maxmoneypercent=80;
    contractBalance = this.balance;
    maxProfit=(this.balance * maxmoneypercent)/100;
    randonce = 0;
  }

  /*
    * uintToString
    */
   function uintToString(uint i) internal  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);
   }


  modifier onlyAdmin() {
      require(msg.sender == owner);
      _;
  }

  function setGameOnoff(uint _on0ff) public onlyAdmin{
    onoff=_on0ff;
  }

  function getPlayRate(uint playId,uint level) internal pure returns (uint){
      uint result = 0;
      if(playId == 1 || playId == 2){
        //大小单双，赔率放大了10倍
        result = 19;
      }else if(playId == 3){
        //二同号复选
        result = 11;
      }else if(playId == 4){
        //三同号单选
        result = 156;
      }else if(playId == 5){
        //三同号通选
        result = 26;
      }else if(playId == 6){
        //和值
        if(level == 4 || level == 17){
          result = 53;
        }else if(level == 5 || level == 16){
          result = 21;
        }else if(level == 6 || level == 15){
          result = 17;
        }else if(level == 7 || level == 14){
          result = 13;
        }else if(level == 8 || level == 13){
          result = 9;
        }else if(level == 9 || level == 12){
          result = 8;
        }else if(level == 10 || level == 11){
          result = 7;
        }
      }else if(playId == 7){
        //二不同号
        result = 6;
      }else if(playId == 8){
        //猜1个号，赔率放大了10倍
        if(level == 1){
          result = 19;//单色子
        }else if(level == 2){
          result = 28;//对子
        }else if(level == 3){
          result = 37;//豹子
        }
      }
      return result;
    }

    function doBet(uint[] playid,uint[] betMoney,uint[] betContent,uint mutiply) public payable returns (bytes32) {
      require(onoff==1);
      require(playid.length > 0);
      require(mutiply > 0);
      require(msg.value >= minBet);

      /* checkBet(playid,betMoney,betContent,mutiply,msg.value); */

      /* uint total = 0; */
      bytes32 queryId;
      queryId = keccak256(block.blockhash(block.number-1),now,randonce);

       uint[7] tmp ;
      for(uint i=0;i<playid.length;i++){
        orderId++;
        tmp[0] =orderId;
        tmp[1] =playid[i];
        tmp[2] =betContent[i];
        tmp[3] =betMoney[i]*mutiply;
        tmp[4] =now;
        tmp[5] =0;
        tmp[6] =0;
        betList[queryId][i] =tmp;
      }
      lableTime[queryId] = now;
      lableCount[queryId] = playid.length;
      lableUser[queryId] = msg.sender;
      uint[3] memory codes = [uint(0),0,0];//开奖号码
      openNumberList[queryId] = codes;
      openNumberStr[queryId] ="0,0,0";
      lableStatus[queryId] = 0;

      uint index=playerLableList[msg.sender].length++;
      playerLableList[msg.sender][index]=queryId;//index:id
      opencode(queryId);
      return queryId;
    }

    function checkBet(uint[] playid,uint[] betMoney,uint[] betContent,uint mutiply,uint betTotal) internal{
        uint totalMoney = 0;
      uint totalWin1 = 0;//三个开奖号码不同时的盈利
      uint totalWin2 = 0;//两个开奖号码相同时的盈利
      uint totalWin3 = 0;//三个号码相同时的盈利
      uint rate;
      uint i;
      for(i=0;i<playid.length;i++){
        if(playid[i] >=1 && playid[i]<= 8){
          totalMoney += betMoney[i] * mutiply;
        }else{
          throw;
        }
        if(playid[i] ==1 || playid[i] ==2){
          rate = getPlayRate(playid[i],0)-10;
          totalWin1+=betMoney[i] * mutiply *rate/10;
          totalWin2+=betMoney[i] * mutiply *rate/10;
        }else if(playid[i] ==3){
          rate = getPlayRate(playid[i],0)-1;
          totalWin2+=betMoney[i] * mutiply *rate;
          totalWin3+=betMoney[i] * mutiply *rate;
        }else if(playid[i] ==4 || playid[i] ==5){
          rate = getPlayRate(playid[i],0)-1;
          totalWin3+=betMoney[i] * mutiply *rate;
        }else if(playid[i] ==6){
          rate = getPlayRate(playid[i],betContent[i])-1;
          totalWin1+=betMoney[i] * mutiply *rate;
          totalWin2+=betMoney[i] * mutiply *rate;
        }else if(playid[i] ==7){
          rate = getPlayRate(playid[i],0)-1;
          totalWin1+=betMoney[i] * mutiply *rate;
          totalWin2+=betMoney[i] * mutiply *rate;
        }else if(playid[i] ==8){
          totalWin1+=betMoney[i] * mutiply *9/10;
          totalWin2+=betMoney[i] * mutiply *18/10;
          totalWin3+=betMoney[i] * mutiply *27/10;
        }
      }
      uint maxWin=totalWin1;
      if(totalWin2 > maxWin){
        maxWin=totalWin2;
      }
      if(totalWin3 > maxWin){
        maxWin=totalWin3;
      }
      require(betTotal >= totalMoney);

      require(maxWin < maxProfit);
    }
    function opencode(bytes32 queryId) private {
      if (lableCount[queryId] < 1) revert();
      uint[3] memory codes = [uint(0),0,0];//开奖号码

      bytes32 code0hash = keccak256(abi.encodePacked(block.blockhash(block.number-1), now,msg.sender,randonce));
      randonce  = randonce + uint(code0hash)%10;
      uint code0int = uint(code0hash) % 6 + 1;
      bytes32 code1hash = keccak256(abi.encodePacked(block.blockhash(block.number-1), now,msg.sender,randonce));
      randonce  = randonce + uint(code1hash)%10;
      uint code1int = uint(code1hash) % 6 + 1;
      bytes32 code2hash = keccak256(abi.encodePacked(block.blockhash(block.number-1), now,msg.sender,randonce));
      randonce  = randonce + uint(code2hash)%10;
      uint code2int = uint(code2hash) % 6 + 1;
      var code0=uintToString(code0int);
      var code1=uintToString(code1int);
      var code2=uintToString(code2int);
      codes[0] = code0int;
      codes[1] = code1int;
      codes[2] = code2int;
      openNumberList[queryId] = codes;
      openNumberStr[queryId] = strConcat(code0,",",code1,",",code2);

      //结算，派奖
      doCheckBounds(queryId);
    }

    function doCancel(bytes32 queryId) internal {
      uint sta = lableStatus[queryId];
      require(sta == 0);
      uint[3] memory codes = openNumberList[queryId];
      require(codes[0] == 0 || codes[1] == 0 ||codes[2] == 0);

      uint totalBet = 0;
      uint len = lableCount[queryId];

      address to = lableUser[queryId];
      for(uint aa = 0 ; aa<len; aa++){
        //未结算
        if(betList[queryId][aa][5] == 0){
          totalBet+=betList[queryId][aa][3];
        }
      }

      if(totalBet > 0){
        to.transfer(totalBet);
      }
      contractBalance=this.balance;
      maxProfit=(this.balance * maxmoneypercent)/100;
      lableStatus[queryId] = 1;
    }

    function doSendBounds(bytes32 queryId) public payable {
      uint sta = lableStatus[queryId];
      require(sta == 2);

      uint totalWin = 0;
      uint len = lableCount[queryId];

      address to = lableUser[queryId];
      for(uint aa = 0 ; aa<len; aa++){
        //中奖
        if(betList[queryId][aa][5] == 2){
          totalWin+=betList[queryId][aa][6];
        }
      }

      if(totalWin > 0){
          to.transfer(totalWin);//转账
      }
      lableStatus[queryId] = 3;
      contractBalance=this.balance;
      maxProfit=(this.balance * maxmoneypercent)/100;
    }

    //中奖判断
    function checkWinMoney(uint[7] storage betinfo,uint[3] codes) internal {
      uint rates;
      if(betinfo[1] ==1){
          //大小 豹子不中奖
          if(codes[0] == codes[1] && codes[1] == codes[2]){
            betinfo[5]=1;//未中奖
          }else{
            uint sum = codes[0]+codes[1]+codes[2];
            if(sum >= 4 && sum < 11){
              sum = 4;//小
            }else if(sum >= 11 && sum < 18){
              sum = 17;//大
            }else{
              sum = 0;
            }
            betinfo[5]=1;
            if(sum >0 && betinfo[2] == sum){
                betinfo[5]=2;
                rates = getPlayRate(betinfo[1],0);
                betinfo[6]=betinfo[3]*rates/10;
            }

          }
      }else if(betinfo[1] == 2){
          //单双 豹子不中奖
          if(codes[0] == codes[1] && codes[1] == codes[2]){
            betinfo[5]=1;//未中奖
          }else{
            uint sums = codes[0]+codes[1]+codes[2];
            if(sums % 2 == 0){
              sums = 2;//双
            }else{
              sums = 3;//单
            }
            betinfo[5]=1;
            if(sums == betinfo[2]){
              betinfo[5]=2;
              rates = getPlayRate(betinfo[1],0);
              betinfo[6]=betinfo[3]*rates/10;
            }

          }

        }else if(betinfo[1] == 3){
          //二同号复选
          betinfo[5]=1;//不中奖
          if(codes[0] == codes[1] || codes[1] == codes[2] ){
            uint tmp = 0;
            if(codes[0] == codes[1] ){
              tmp = codes[0];
            }else if(codes[1] == codes[2]){
              tmp = codes[1];
            }
            if(tmp == betinfo[2]){
              betinfo[5]=2;
              rates = getPlayRate(betinfo[1],0);
              betinfo[6]=betinfo[3]*rates;
            }

          }
        }else if(betinfo[1] == 4){
          //三同号单选
          betinfo[5]=1;//不中奖
          if(codes[0] == codes[1] && codes[1] == codes[2] ){
            if(codes[0] == betinfo[2]){
              betinfo[5]=2;
              rates = getPlayRate(betinfo[1],0);
              betinfo[6]=betinfo[3]*rates;
            }
          }
        }else if(betinfo[1] == 5){
          //三同号通选
          betinfo[5]=1;//不中奖
          if(codes[0] == codes[1] && codes[1] == codes[2] ){
              betinfo[5]=2;
              rates = getPlayRate(betinfo[1],0);
              betinfo[6]=betinfo[3]*rates;
          }
        }else if(betinfo[1] == 6){
          //和值 豹子不中奖
          if(codes[0] == codes[1] && codes[1] == codes[2]){
            betinfo[5]=1;//不中奖
          }else{
            betinfo[5]=1;//不中奖
            uint sum6 = codes[0]+codes[1]+codes[2];
            if(sum6 == betinfo[2]){
              betinfo[5]=2;
              rates = getPlayRate(betinfo[1],sum6);
              betinfo[6]=betinfo[3]*rates;
            }
          }
        }else if(betinfo[1] == 7){
          //二不同号 豹子不中奖
          if(codes[0] == codes[1] && codes[1] == codes[2]){
            betinfo[5]=1;//不中奖
          }else{
            uint[2] memory haoma = getErbutongHao(betinfo[2]);
            bool atmp=false;
            bool btmp=false;
            for(uint ai=0;ai<codes.length;ai++){
              if(codes[ai] == haoma[0]){
                atmp = true;
                continue;
              }
              if(codes[ai] == haoma[1]){
                btmp = true;
                continue;
              }
            }
            betinfo[5]=1;
            if(atmp && btmp){
              betinfo[5]=2;
              rates = getPlayRate(betinfo[1],0);
              betinfo[6]=betinfo[3]*rates;
            }
          }
        }else if(betinfo[1] == 8){
          //猜1个号，赔率放大了10倍
          uint tmpp = 0;
          betinfo[5]=1;//不中奖
          if(codes[0] == betinfo[2]){
            tmpp++;
          }
          if(codes[1] == betinfo[2]){
            tmpp++;
          }
          if(codes[2] == betinfo[2]){
            tmpp++;
          }
          if(tmpp > 0){
            betinfo[5]=2;
            rates = getPlayRate(betinfo[1],tmpp);
            betinfo[6]=betinfo[3]*rates/10;
          }
        }

    }

    function getErbutongHao(uint sss) internal view returns(uint[2]){
      uint[2] memory result ;
      if(sss == 12){
        result = [uint(1),2];
      }else if(sss == 13){
         result = [uint(1),3];
      }else if(sss == 14){
         result = [uint(1),4];
      }else if(sss == 15){
         result = [uint(1),5];
      }else if(sss == 16){
         result = [uint(1),6];
      }else if(sss == 23){
         result = [uint(2),3];
      }else if(sss == 24){
         result = [uint(2),4];
      }else if(sss == 25){
         result = [uint(2),5];
      }else if(sss == 26){
         result = [uint(2),6];
      }else if(sss == 34){
         result = [uint(3),4];
      }else if(sss == 35){
         result = [uint(3),5];
      }else if(sss == 36){
         result = [uint(3),6];
      }else if(sss == 45){
         result = [uint(4),5];
      }else if(sss == 46){
         result = [uint(4),6];
      }else if(sss == 56){
         result = [uint(5),6];
      }
      return (result);
    }

    function getLastBet() public view returns(string,uint[7][]){
      uint len=playerLableList[msg.sender].length;
      require(len>0);

      uint i=len-1;
      bytes32 lastLable = playerLableList[msg.sender][i];
      uint max = lableCount[lastLable];
      if(max > 50){
          max = 50;
      }
      uint[7][] memory result = new uint[7][](max) ;
      var opennum = "";
      for(uint a=0;a<max;a++){
         var ttmp =openNumberStr[lastLable];
         if(a==0){
           opennum =ttmp;
         }else{
           opennum = strConcat(opennum,";",ttmp);
         }

         result[a] = betList[lastLable][a];
         if(lableStatus[lastLable] == 1){
           result[a][5]=3;
         }

      }

      return (opennum,result);
    }

    function getLableRecords(bytes32 lable) public view returns(string,uint[7][]){
      uint max = lableCount[lable];
      if(max > 50){
          max = 50;
      }
      uint[7][] memory result = new uint[7][](max) ;
      var opennum="";

      for(uint a=0;a<max;a++){
         result[a] = betList[lable][a];
         if(lableStatus[lable] == 1){
           result[a][5]=3;
         }
         var ttmp =openNumberStr[lable];
         if(a==0){
           opennum =ttmp;
         }else{
           opennum = strConcat(opennum,";",ttmp);
         }
      }

      return (opennum,result);
    }

    function getAllRecords() public view returns(string,uint[7][]){
        uint len=playerLableList[msg.sender].length;
        require(len>0);

        uint max;
        bytes32 lastLable ;
        uint ss;

        for(uint i1=0;i1<len;i1++){
            ss = len-i1-1;
            lastLable = playerLableList[msg.sender][ss];
            max += lableCount[lastLable];
            if(100 < max){
              max = 100;
              break;
            }
        }

        uint[7][] memory result = new uint[7][](max) ;
        bytes32[] memory resultlable = new bytes32[](max) ;
        var opennum="";

        bool flag=false;
        uint betnums;
        uint j=0;

        for(uint ii=0;ii<len;ii++){
            ss = len-ii-1;
            lastLable = playerLableList[msg.sender][ss];
            betnums = lableCount[lastLable];
            for(uint k= 0; k<betnums; k++){
              if(j<max){
                  resultlable[j] = lastLable;
              	 var ttmp =openNumberStr[lastLable];
                 if(j==0){
                   opennum =ttmp;
                 }else{
                   opennum = strConcat(opennum,";",ttmp);
                 }
                  result[j] = betList[lastLable][k];
                  if(lableStatus[lastLable] == 1){
                    result[j][5]=3;
                  }else if(lableStatus[lastLable] == 2){
                    if(result[j][5]==2){
                      result[j][5]=4;
                    }
                  }else if(lableStatus[lastLable] == 3){
                    if(result[j][5]==2){
                      result[j][5]=5;
                    }
                  }
                  j++;
              }else{
                flag = true;
                break;
              }
            }
            if(flag){
                break;
            }
        }
        return (opennum,result);
    }

  function senttest() public payable onlyAdmin{
      contractBalance=this.balance;
      maxProfit=(this.balance*maxmoneypercent)/100;
  }

  function setRandomSeed(uint _randomSeed) public payable onlyAdmin{
      randonce = _randomSeed;
  }

  function getRandomSeed() public view onlyAdmin returns(uint _randonce) {
      _randonce = randonce;
  }

  function withdraw(uint _amount , address desaccount) public onlyAdmin{
      desaccount.transfer(_amount);
      contractBalance=this.balance;
      maxProfit=(this.balance * maxmoneypercent)/100;
  }

  function getDatas() public view returns(
    uint _maxProfit,
    uint _minBet,
    uint _contractbalance,
    uint _onoff,
    address _owner
    //uint _oraclizeFee
    ){
        _maxProfit=maxProfit;
        _minBet=minBet;
        _contractbalance=contractBalance;
        _onoff=onoff;
        _owner=owner;
    }

    function getLableList() public view returns(string,bytes32[],uint[],uint[],uint){
      uint len=playerLableList[msg.sender].length;
      require(len>0);

      uint max=50;
      if(len < 50){
          max = len;
      }

      bytes32[] memory lablelist = new bytes32[](max) ;
      uint[] memory labletime = new uint[](max) ;
      uint[] memory lablestatus = new uint[](max) ;
      var opennum="";

      bytes32 lastLable ;
      for(uint i=0;i<max;i++){
          lastLable = playerLableList[msg.sender][max-i-1];
          lablelist[i]=lastLable;
          labletime[i]=lableTime[lastLable];
          lablestatus[i]=lableStatus[lastLable];
          var ttmp =openNumberStr[lastLable];
         if(i==0){
           opennum =ttmp;
         }else{
           opennum = strConcat(opennum,";",ttmp);
         }
      }

      return (opennum,lablelist,labletime,lablestatus,now);
    }

    function doCheckBounds(bytes32 queryId) internal{
        uint sta = lableStatus[queryId];
        require(sta == 0 || sta == 2);
        uint[3] memory codes = openNumberList[queryId];
        require(codes[0] > 0);
        //结算
        uint len = lableCount[queryId];

        uint totalWin;
        address to = lableUser[queryId];
        for(uint aa = 0 ; aa<len; aa++){
          //未结算
          if(sta == 0){
           if(betList[queryId][aa][5] == 0){
             checkWinMoney(betList[queryId][aa],codes);
             totalWin+=betList[queryId][aa][6];
           }
          }else if(sta == 2){
              totalWin+=betList[queryId][aa][6];
          }
        }

        lableStatus[queryId] = 2;
        //派奖
        if(totalWin > 0){
          if(totalWin < this.balance){
            to.transfer(totalWin);//转账
            lableStatus[queryId] = 3;
          }else{
              LogNewOraclizeQuery("sent bouns fail.",queryId);
          }
        }else{
          lableStatus[queryId] = 3;
        }
        contractBalance=this.balance;
        maxProfit=(this.balance * maxmoneypercent)/100;
    }

    function getOpenNum(bytes32 queryId) public view returns(string){
        return openNumberStr[queryId];
    }

    function doCheckSendBounds() public payable{
        uint len=playerLableList[msg.sender].length;

      uint max=50;
      if(len < 50){
          max = len;
      }

      uint sta;
      bytes32 lastLable ;
      for(uint i=0;i<max;i++){
          lastLable = playerLableList[msg.sender][max-i-1];
          sta = lableStatus[lastLable];
          if(sta == 0 || sta==2){
            doCheckBounds(lastLable);
          }
      }
    }

    function doCancelAll() public payable{
        uint len=playerLableList[msg.sender].length;

      uint max=50;
      if(len < 50){
          max = len;
      }

      uint sta;
      uint bettime;
      bytes32 lastLable ;
      for(uint i=0;i<max;i++){
          lastLable = playerLableList[msg.sender][max-i-1];
          sta = lableStatus[lastLable];
          bettime = lableTime[lastLable];
          if(sta == 0 && (now - bettime)>600){
            doCancel(lastLable);
          }
      }
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"constant":false,"inputs":[{"name":"_amount","type":"uint256"},{"name":"desaccount","type":"address"}],"name":"withdraw","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"name":"queryId","type":"bytes32"}],"name":"getOpenNum","outputs":[{"name":"","type":"string"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"lable","type":"bytes32"}],"name":"getLableRecords","outputs":[{"name":"","type":"string"},{"name":"","type":"uint256[7][]"}],"payable":false,"stateMutability":"view","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":"myid","type":"bytes32"},{"name":"result","type":"string"},{"name":"proof","type":"bytes"}],"name":"__callback","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"getLableList","outputs":[{"name":"","type":"string"},{"name":"","type":"bytes32[]"},{"name":"","type":"uint256[]"},{"name":"","type":"uint256[]"},{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"_randomSeed","type":"uint256"}],"name":"setRandomSeed","outputs":[],"payable":true,"stateMutability":"payable","type":"function"},{"constant":false,"inputs":[],"name":"doCancelAll","outputs":[],"payable":true,"stateMutability":"payable","type":"function"},{"constant":true,"inputs":[],"name":"getDatas","outputs":[{"name":"_maxProfit","type":"uint256"},{"name":"_minBet","type":"uint256"},{"name":"_contractbalance","type":"uint256"},{"name":"_onoff","type":"uint256"},{"name":"_owner","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"_on0ff","type":"uint256"}],"name":"setGameOnoff","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"contractBalance","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"getRandomSeed","outputs":[{"name":"_randonce","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[],"name":"doCheckSendBounds","outputs":[],"payable":true,"stateMutability":"payable","type":"function"},{"constant":true,"inputs":[],"name":"getAllRecords","outputs":[{"name":"","type":"string"},{"name":"","type":"uint256[7][]"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"queryId","type":"bytes32"}],"name":"doSendBounds","outputs":[],"payable":true,"stateMutability":"payable","type":"function"},{"constant":true,"inputs":[],"name":"getLastBet","outputs":[{"name":"","type":"string"},{"name":"","type":"uint256[7][]"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"playid","type":"uint256[]"},{"name":"betMoney","type":"uint256[]"},{"name":"betContent","type":"uint256[]"},{"name":"mutiply","type":"uint256"}],"name":"doBet","outputs":[{"name":"","type":"bytes32"}],"payable":true,"stateMutability":"payable","type":"function"},{"constant":false,"inputs":[],"name":"senttest","outputs":[],"payable":true,"stateMutability":"payable","type":"function"},{"inputs":[],"payable":false,"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"name":"description","type":"string"},{"indexed":false,"name":"queryId","type":"bytes32"}],"name":"LogNewOraclizeQuery","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"name":"result","type":"string"},{"indexed":false,"name":"queryId","type":"bytes32"}],"name":"LogNewRandomNumber","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"name":"id","type":"uint256"},{"indexed":false,"name":"lableId","type":"bytes32"},{"indexed":false,"name":"playId","type":"uint256"},{"indexed":false,"name":"content","type":"uint256"},{"indexed":false,"name":"singleMoney","type":"uint256"},{"indexed":false,"name":"mutilple","type":"uint256"},{"indexed":false,"name":"user","type":"address"},{"indexed":false,"name":"betTime","type":"uint256"},{"indexed":false,"name":"status","type":"uint256"},{"indexed":false,"name":"winMoney","type":"uint256"}],"name":"LogSendBonus","type":"event"}]

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

bzzr://37f736595e7c0b88e97d909a6b4028c056fec5294b27ea00d5afdbe122dc3634