//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

  function get() public constant returns (uint) {
    return value;
  }

  uint value;
Feb 23, 2019 01:42:54 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.15;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

  function get() public constant returns (uint) {
    return value;
  }

  uint value;
Feb 22, 2019 20:49:07 UTC
pragma solidity ^0.4.10;

/**
 * Math operations with safety checks
 */
contract SafeMath {
  function safeMul(uint256 a, uint256 b) internal returns (uint256) {
    uint256 c = a * b;
    assert(a == 0 || c / a == b);
    return c;
  }

  function safeDiv(uint256 a, uint256 b) internal returns (uint256) {
    assert(b > 0);
    uint256 c = a / b;
    assert(a == b * c + a % b);
    return c;
  }

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

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

  function assert(bool assertion) internal {
    if (!assertion) {
      throw;
    }
  }
}
contract BNB is SafeMath{
    string public name;
    string public symbol;
    uint8 public decimals;
    uint256 public totalSupply;
	address public owner;

    /* This creates an array with all balances */
    mapping (address => uint256) public balanceOf;
	  mapping (address 
Feb 22, 2019 18:05:30 UTC

/**
 * @title ERC20 interface
 * @dev see https://github.com/ethereum/EIPs/issues/20
 */
interface IERC20 {
    function transfer(address to, uint256 value) external returns (bool);

    function approve(address spender, uint256 value) external returns (bool);

    function transferFrom(address from, address to, uint256 value) external returns (bool);

    function totalSupply() external view returns (uint256);

    function balanceOf(address who) external view returns (uint256);

    function allowance(address owner, address spender) external view returns (uint256);

    event Transfer(address indexed from, address indexed to, uint256 value);

    event Approval(address indexed owner, address indexed spender, uint256 value);
}

/**
 * @title Standard ERC20 token
 *
 * @dev Implementation of the basic standard token.
 * https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md
 * Originally based on code by FirstBlood:
 * https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
Feb 22, 2019 08:29:28 UTC
pragma solidity ^0.4.25;

contract Names {

  mapping(string => string) names;

  function _set(string _peerId, string _name) internal  {
    names[_peerId] = _name;
  }

  function _get(string _peerId) internal view returns (string) {
    return names[_peerId];
  }
Feb 21, 2019 11:28:28 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity >=0.4.0 <0.6.0;
contract  Average_Dynamic_Price {

    address MBroker;
//_______________________________________________________________________________
    // Constructor The Genesis
    constructor () public {
        MBroker = 0x1E5Fee96D21f01B5F38261ea81ed303bCCc174b2; // First Broker, Opens the first account 
    }

//_____________________________________________________________________________
//Variables for account creation
     address Address = msg.sender; //  User Address
     address IDBroker; //Addres the Broker (Any Created Account can be a broker for new accounts)  
     uint TotalAccount; //TotalAccountCreated
     uint Date = block.number; // Block Mining (We work with block to avoid errors with timestamp)
     uint searchIDBroker; //Find Broker
     uint searchIDAddress;  //Find Address
     uint searchIDProfile; //Find ID Address
     //___________________________________________________
Feb 21, 2019 11:19:40 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity >=0.4.0 <0.6.0;
contract  Average_Dynamic_Price {

    address MBroker;
//_______________________________________________________________________________
    // Constructor The Genesis
    constructor () public {
        MBroker = 0x1E5Fee96D21f01B5F38261ea81ed303bCCc174b2; // First Broker, Opens the first account 
    }

//_____________________________________________________________________________
//Variables for account creation
     address Address = msg.sender; //  User Address
     address IDBroker; //Addres the Broker (Any Created Account can be a broker for new accounts)  
     uint TotalAccount; //TotalAccountCreated
     uint Date = block.number; // Block Mining (We work with block to avoid errors with timestamp)
     uint searchIDBroker; //Find Broker
     uint searchIDAddress;  //Find Address
     uint searchIDProfile; //Find ID Address
     //___________________________________________________
Feb 21, 2019 11:06:21 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity >=0.4.0 <0.6.0;
contract  Average_Dynamic_Price {

    address MBroker;
//_______________________________________________________________________________
    // Constructor The Genesis
    constructor () public {
        MBroker = 0x1E5Fee96D21f01B5F38261ea81ed303bCCc174b2; // First Broker, Opens the first account 
    }

//_____________________________________________________________________________
//Variables for account creation
     address Address = msg.sender; //  User Address
     address IDBroker; //Addres the Broker (Any Created Account can be a broker for new accounts)  
     uint TotalAccount; //TotalAccountCreated
     uint Date = block.number; // Block Mining (We work with block to avoid errors with timestamp)
     uint searchIDBroker; //Find Broker
     uint searchIDAddress;  //Find Address
     uint searchIDProfile; //Find ID Address
     //___________________________________________________
Feb 21, 2019 10:03:23 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity >=0.4.0 <0.6.0;
contract  Average_Dynamic_Price {

    address MBroker;
//_______________________________________________________________________________
    // Constructor The Genesis
    constructor () public {
        MBroker = 0x1E5Fee96D21f01B5F38261ea81ed303bCCc174b2; // First Broker, Opens the first account 
    }

//_____________________________________________________________________________
//Variables for account creation
     address Address = msg.sender; //  User Address
     address IDBroker; //Addres the Broker (Any Created Account can be a broker for new accounts)  
     uint TotalAccount; //TotalAccountCreated
     uint Date = block.number; // Block Mining (We work with block to avoid errors with timestamp)
     uint searchIDBroker; //Find Broker
     uint searchIDAddress;  //Find Address
     uint searchIDProfile; //Find ID Address
     //___________________________________________________
Feb 21, 2019 09:59:20 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity >=0.4.0 <0.6.0;
contract  Average_Dynamic_Price {

    address MBroker;
//_______________________________________________________________________________
    // Constructor The Genesis
    constructor () public {
        MBroker = 0x1E5Fee96D21f01B5F38261ea81ed303bCCc174b2; // First Broker, Opens the first account 
    }

//_____________________________________________________________________________
//Variables for account creation
     address Address = msg.sender; //  User Address
     address IDBroker; //Addres the Broker (Any Created Account can be a broker for new accounts)  
     uint TotalAccount; //TotalAccountCreated
     uint Date = block.number; // Block Mining (We work with block to avoid errors with timestamp)
     uint searchIDBroker; //Find Broker
     uint searchIDAddress;  //Find Address
     uint searchIDProfile; //Find ID Address
     //___________________________________________________
Feb 21, 2019 09:57:36 UTC
pragma solidity >=0.4.22 <0.5.0;

// Machine.sol
/// @title A widget
contract Machine {
  // This is our contract that does stuff.  We'll be committing to deploying this contract in the future.
  // At this point, this only exists to be compiled for our init code
  bytes32 secret;
  
  constructor(bytes32 _secret) public {
    secret = _secret;
  }

  function legit() public view returns(bytes32) {
    return secret;
  }
  
  function loaded() public view returns(uint256) {
      return address(this).balance;
  }
}

// init_code:
// 0x608060405234801561001057600080fd5b506040516020806101478339810180604052810190808051906020019092919050505080600081600019169055505060fa8061004d6000396000f3006080604052600436106049576000357c0100000000000000000000000000000000000000000000000000000000900463ffffffff168063196e045d14604e57806331cb3e48146076575b600080fd5b348015605957600080fd5b50606060a6565b6040518082815260200191505060405180910390f35b348015608157600080fd5b50608860c5565b6040518082600019166000191681526020019150506040518091039
Feb 21, 2019 09:03:53 UTC
pragma solidity >=0.4.22 <0.5.0;

// Machine.sol
/// @title A widget
contract Machine {
  // This is our contract that does stuff.  We'll be committing to deploying this contract in the future.
  // At this point, this only exists to be compiled for our init code
  
  constructor() public {
    // etc
  }

  function legit() public view returns(address) {
    return address(this);
  }
}

// init_code:
// 0x608060405234801561001057600080fd5b5060cc8061001f6000396000f300608060405260043610603f576000357c0100000000000000000000000000000000000000000000000000000000900463ffffffff16806331cb3e48146044575b600080fd5b348015604f57600080fd5b5060566098565b604051808273ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200191505060405180910390f35b6000309050905600a165627a7a72305820b5da6748da14469d9ab06edb0aae0afcfa83c840ab2c3f3cf8ef4bbb8376e02d0029
// code hash:
// 0x974da18f7b7c5b584a422ae1dbb06c643ab2705d0fdd2c88206076bc699e2bb6


// Deployer.sol
/// @title A generic code deployer
contra
Feb 21, 2019 08:25:35 UTC
pragma solidity >=0.4.22 <0.6.0;

// Machine.sol
/// @title A widget
contract Machine {
  // This is our contract that does stuff.  We'll be committing to deploying this contract in the future.
  // At this point, this only exists to be compiled for our init code
  
  constructor() public {
    // etc
  }

  function legit() public view returns(address) {
    return address(this);
  }
}

// init_code:
// 0x608060405234801561001057600080fd5b5060cc8061001f6000396000f300608060405260043610603f576000357c0100000000000000000000000000000000000000000000000000000000900463ffffffff16806331cb3e48146044575b600080fd5b348015604f57600080fd5b5060566098565b604051808273ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200191505060405180910390f35b6000309050905600a165627a7a72305820b5da6748da14469d9ab06edb0aae0afcfa83c840ab2c3f3cf8ef4bbb8376e02d0029
// code hash:
// 0x974da18f7b7c5b584a422ae1dbb06c643ab2705d0fdd2c88206076bc699e2bb6


// Deployer.sol
/// @title A generic code deployer
contra
Feb 21, 2019 08:25:27 UTC
pragma solidity >=0.4.22 <0.6.0;

// MachineFactory.sol

/// @title A widget
contract Machine {
  // This is our contract that does stuff.  We'll be committing to deploying this contract in the future.
  
  constructor() public {
    // etc
  }
}

/// @title A widget factory
contract MachineFactory {
  event MachineBuilt(address machine);
  function build() public {
    emit MachineBuilt(new Machine());
  }

  function getSig() public pure returns(bytes4) {
    return bytes4(keccak256("build()"));
  }
}

// MachineCommitment.sol
/// @title A commitment to make a widget
contract MachineCommitment {
  address factory;

  constructor(address _factory) public {
    factory = _factory;
  }

  function() public {
    address _factory = factory;
    assembly {
      let ptr := mload(0x40)
      calldatacopy(ptr, 0, calldatasize)
      pop(delegatecall(gas, _factory, ptr, calldatasize, 0, 0))
    }
    selfdestruct(msg.sender);
  }
Feb 21, 2019 07:00:22 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity >=0.4.0 <0.6.0;
contract  Average_Dynamic_Price {

    address MBroker;
//_______________________________________________________________________________
    // Constructor The Genesis
    constructor () public {
        MBroker = 0x1E5Fee96D21f01B5F38261ea81ed303bCCc174b2; // First Broker, Opens the first account 
    }

//_____________________________________________________________________________
//Variables for account creation
     address Address = msg.sender; //  User Address
     address IDBroker; //Addres the Broker (Any Created Account can be a broker for new accounts)  
     uint TotalAccount; //TotalAccountCreated
     uint Date = block.number; // Block Mining (We work with block to avoid errors with timestamp)
     uint searchIDBroker; //Find Broker
     uint searchIDAddress;  //Find Address
     uint searchIDProfile; //Find ID Address
     //___________________________________________________
Feb 21, 2019 06:36:40 UTC
pragma solidity >=0.4.22 <0.6.0;

// MachineFactory.sol

/// @title A widget
contract Machine {
  // This is our contract that does stuff.  We'll be committing to deploying this contract in the future.
  
  constructor() public {
    // etc
  }
}

/// @title A widget factory
contract MachineFactory {
  event MachineBuilt(address machine);
  function build() public {
    emit MachineBuilt(new Machine());
  }
}

// MachineCommitment.sol
/// @title A commitment to make a widget
contract MachineCommitment {
  address factory;

  constructor(address _factory) public {
    factory = _factory;
  }

  function commit() public {
    require(factory.delegatecall(bytes4(keccak256("build()"))));
    selfdestruct(msg.sender);
  }
Feb 21, 2019 06:30:05 UTC
pragma solidity >=0.4.22 <0.6.0;

// First, we start with the contract that we're committing to deploying:
/// @title A widget
contract Machine {
  // This is our contract that does stuff.  We'll be committing to deploying this contract in the future.
  
  constructor() public {
    // etc
  }
}

// Now, we create a contract that's sole purpose is to commit to deploying some arbitrary code
/// @title A commitment to make a widget
contract MachineCommitment {
  function commit() public {
    new Machine();
    selfdestruct(msg.sender);
  }
Feb 21, 2019 05:57:56 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity >=0.4.22 <0.6.0;

// First, we start with the contract that we're committing to deploying:
/// @title A widget
contract Machine {
  // This is our contract that does stuff.  We'll be committing to deploying this contract in the future.
  
  constructor() public {
    // etc
  }
}

contract MachineCommitment {
  function commit() public {
    new Machine();
    selfdestruct(msg.sender);
  }
Feb 21, 2019 05:55:05 UTC
import pytest

from microblog import app 

@pytest.fixture
def client():
   client = app.test_client()

   yield client 


def test_hello_world(client):
   """ Start to see if we get Hello World back"""

   rv = client.get('/')
   rv2 = client.get('/index')
   assert b'Hello, World!' in rv.data 
   assert b'Hello, World!' in rv2.dat
Feb 21, 2019 01:38:36 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity >=0.4.0 <0.6.0;
contract  Average_Dynamic_Price {

    address MBroker;
//_______________________________________________________________________________
    // Constructor The Genesis
    constructor () public {
        MBroker = 0x1E5Fee96D21f01B5F38261ea81ed303bCCc174b2; // First Broker, Opens the first account 
    }

//_____________________________________________________________________________
//Variables for account creation
     address Address = msg.sender; //  User Address
     address IDBroker; //Addres the Broker (Any Created Account can be a broker for new accounts)  
     uint TotalAccount; //TotalAccountCreated
     uint Date = block.number; // Block Mining (We work with block to avoid errors with timestamp)
     uint searchIDBroker; //Find Broker
     uint searchIDAddress;  //Find Address
     uint searchIDProfile; //Find ID Address
     //___________________________________________________
Feb 20, 2019 13:37:48 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity >=0.4.0 <0.6.0;
contract  Average_Dynamic_Price {

    address MBroker;
//_______________________________________________________________________________
    // Constructor The Genesis
    constructor () public {
        MBroker = 0x1E5Fee96D21f01B5F38261ea81ed303bCCc174b2; // First Broker, Opens the first account 
    }

//_____________________________________________________________________________
//Variables for account creation
     address Address = msg.sender; //  User Address
     address IDBroker; //Addres the Broker (Any Created Account can be a broker for new accounts)  
     uint TotalAccount; //TotalAccountCreated
     uint Date = block.number; // Block Mining (We work with block to avoid errors with timestamp)
     uint searchIDBroker; //Find Broker
     uint searchIDAddress;  //Find Address
     uint searchIDProfile; //Find ID Address
     //___________________________________________________
Feb 20, 2019 13:28:49 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity >=0.4.0 <0.6.0;
contract  Average_Dynamic_Price {

    address MBroker;
//_______________________________________________________________________________
    // Constructor The Genesis
    constructor () public {
        MBroker = 0x1E5Fee96D21f01B5F38261ea81ed303bCCc174b2; // First Broker, Opens the first account 
    }

//_____________________________________________________________________________
//Variables for account creation
     address Address; //  User Address
     address IDBroker; //Addres the Broker (Any Created Account can be a broker for new accounts)  
     uint TotalAccount; //TotalAccountCreated
     uint Date; // Block Mining (We work with block to avoid errors with timestamp)
     uint searchIDBroker; //Find Broker
     uint searchIDAddress;  //Find Address
     uint searchIDProfile; //Find ID Address
     uint ClanAccount; //Clan account
     uint noClan;


//__________________________
Feb 20, 2019 12:25:00 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity >=0.4.0 <0.6.0;
contract  Average_Dynamic_Price {

    address MBroker;
//_______________________________________________________________________________
    // Constructor The Genesis
    constructor () public {
        MBroker = 0x1E5Fee96D21f01B5F38261ea81ed303bCCc174b2; // First Broker, Opens the first account 
    }

//_____________________________________________________________________________
//Variables for account creation
     address Address; //  User Address
     address IDBroker; //Addres the Broker (Any Created Account can be a broker for new accounts)  
     uint TotalAccount; //TotalAccountCreated
     uint Date; // Block Mining (We work with block to avoid errors with timestamp)
     uint searchIDBroker; //Find Broker
     uint searchIDAddress;  //Find Address
     uint searchIDProfile; //Find ID Address
     uint ClanAccount; //Clan account


//____________________________________________
Feb 20, 2019 11:59:25 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity >=0.4.0 <0.6.0;
contract  Average_Dynamic_Price {

    address MBroker;
//_______________________________________________________________________________
    // Constructor The Genesis
    constructor () public {
        MBroker = 0x1E5Fee96D21f01B5F38261ea81ed303bCCc174b2; // First Broker, Opens the first account 
    }

//_____________________________________________________________________________
//Variables for account creation
     address Address; //  User Address
     address IDBroker; //Addres the Broker (Any Created Account can be a broker for new accounts)  
     uint TotalAccount; //TotalAccountCreated
     uint Date; // Block Mining (We work with block to avoid errors with timestamp)
     uint searchIDBroker; //Find Broker
     uint searchIDAddress;  //Find Address
     uint searchIDProfile; //Find ID Address
     uint ClanAccount; //Clan account


//____________________________________________
Feb 20, 2019 11:54:25 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity >=0.4.0 <0.6.0;
contract  Average_Dynamic_Price {

    address MBroker;
//_______________________________________________________________________________
    // Constructor The Genesis
    constructor () public {
        MBroker = 0x1E5Fee96D21f01B5F38261ea81ed303bCCc174b2; // First Broker, Opens the first account 
    }

//_____________________________________________________________________________
//Variables for account creation
     address Address; //  User Address
     address IDBroker; //Addres the Broker (Any Created Account can be a broker for new accounts)  
     uint TotalAccount; //TotalAccountCreated
     uint Date; // Block Mining (We work with block to avoid errors with timestamp)
     uint searchIDBroker; //Find Broker
     uint searchIDAddress;  //Find Address
     uint searchIDProfile; //Find ID Address
     uint ClanAccount; //Clan account


//____________________________________________
Feb 20, 2019 11:50:11 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity >=0.4.0 <0.6.0;
contract  Average_Dynamic_Price {

    address MBroker;
//_______________________________________________________________________________
    // Constructor The Genesis
    constructor () public {
        MBroker = 0x1E5Fee96D21f01B5F38261ea81ed303bCCc174b2; // First Broker, Opens the first account 
    }

//_____________________________________________________________________________
//Variables for account creation
     address Address; //  User Address
     address IDBroker; //Addres the Broker (Any Created Account can be a broker for new accounts)  
     uint TotalAccount; //TotalAccountCreated
     uint Date; // Block Mining (We work with block to avoid errors with timestamp)
     uint searchIDBroker; //Find Broker
     uint searchIDAddress;  //Find Address
     uint searchIDProfile; //Find ID Address
     uint ClanAccount; //Clan account


//____________________________________________
Feb 20, 2019 11:43:58 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity >=0.4.0 <0.6.0;
contract  Average_Dynamic_Price {

    address MBroker;
//_______________________________________________________________________________
    // Constructor The Genesis
    constructor () public {
        MBroker = 0x1E5Fee96D21f01B5F38261ea81ed303bCCc174b2; // First Broker, Opens the first account 
    }

//_____________________________________________________________________________
//Variables for account creation
     address Address; //  User Address
     address IDBroker; //Addres the Broker (Any Created Account can be a broker for new accounts)  
     uint TotalAccount; //TotalAccountCreated
     uint Date; // Block Mining (We work with block to avoid errors with timestamp)
     uint searchIDBroker; //Find Broker
     uint searchIDAddress;  //Find Address
     uint searchIDProfile; //Find ID Address
     uint ClanAccount; //Clan account


//____________________________________________
Feb 20, 2019 11:43:24 UTC
pragma solidity ^0.4.7;
import "remix_tests.sol"; // this import is automatically injected by Remix.
import "./ballot.sol";

contract test3 {
   
    Ballot ballotToTest;
    function beforeAll () {
       ballotToTest = new Ballot(2);
    }
    
    function checkWinningProposal () public {
        ballotToTest.vote(1);
        Assert.equal(ballotToTest.winningProposal(), uint(1), "1 should be the winning proposal");
    }
    
    function checkWinninProposalWithReturnValue () public constant returns (bool) {
        return ballotToTest.winningProposal() == 1;
    }
}
Feb 20, 2019 06:08:01 UTC
pragma solidity ^0.4.7;
import "remix_tests.sol"; // this import is automatically injected by Remix.
import "./ballot.sol";

contract test3 {
   
    Ballot ballotToTest;
    function beforeAll () {
       ballotToTest = new Ballot(2);
    }
    
    function checkWinningProposal () public {
        ballotToTest.vote(1);
        Assert.equal(ballotToTest.winningProposal(), uint(1), "1 should be the winning proposal");
    }
    
    function checkWinninProposalWithReturnValue () public constant returns (bool) {
        return ballotToTest.winningProposal() == 1;
    }
}
Feb 20, 2019 06:06:33 UTC

pragma solidity ^0.4.24;
/**
 * @title SafeMath
 * @dev Math operations with safety checks that throw on error
 */
library SafeMath {

  /**
  * @dev Multiplies two numbers, throws on overflow.
  */
  function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
    if (a == 0) {
      return 0;
    }
    c = a * b;
    assert(c / a == b);
    return c;
  }

  /**
  * @dev Integer division of two numbers, truncating the quotient.
  */
  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 a / b;
  }

  /**
  * @dev Subtracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend).
  */
  function sub(uint256 a, uint256 b) internal pure returns (uint256) {
    assert(b <= a);
    return a - b;
  }

  /**
  * @dev Adds two numbers, throws on overflow.
  */
  function add(uint
Feb 20, 2019 01:52:24 UTC
pragma solidity ^0.4.25;
contract CagnotteFestival {
  mapping (address => uint) organisateurs;
  mapping (address => bool) festivaliers;

  constructor() public {
    organisateurs[msg.sender] = 100;
  }

  function transfererOrga(address orga, uint parts) public {
    require(organisateurs[msg.sender] >= parts);
    require(orga != address(0));
    organisateurs[msg.sender] -= parts;
    organisateurs[orga] += parts;
  }

  function estOrga(address orga) public view returns (bool) {
    return organisateurs[orga] != 0;
  }

  function acheterTicket() public payable {
    require(msg.value >= 500 finney, "Place à 0.5 Ethers");
    festivaliers[msg.sender];
  }
Feb 19, 2019 19:02:41 UTC
pragma solidity ^0.5.0;
/**
 * 
 * aXpire CoinBX Gateway Smart Contract
 * 
 */
contract ERC20 {
    
    function decimals() public returns (uint8);
    function transfer(address _to, uint256 _value) public returns (bool);
    function transferFrom(address _from, address _to, uint256 _value) public returns (bool);
    function approve(address _spender, uint256 _value) public returns (bool);
    function balanceOf(address _owner) public pure returns (uint256);
    function allowance(address _owner, address _spender) public pure returns (uint256);

    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}

// Owner Contract-For Defining Owner and Transferring Ownership
contract Ownable {
    
    address public owner;

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    constructor() public {
        owner = msg.sender;
    }

    modifier onlyOwner {
        requ
Feb 19, 2019 18:37:19 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity >=0.4.0 <0.6.0;
contract  Average_Dynamic_Price {

    address MBroker;
//_______________________________________________________________________________
    // Constructor The Genesis
    constructor () public {
        MBroker = 0x1E5Fee96D21f01B5F38261ea81ed303bCCc174b2; // First Broker, Opens the first account 
    }

//_____________________________________________________________________________
//Variables for account creation
     address Address; //  User Address
     address IDBroker; //Addres the Broker (Any Created Account can be a broker for new accounts)  
     uint TotalAccount; //TotalAccountCreated
     uint Date; // Block Mining (We work with block to avoid errors with timestamp)
     uint searchIDBroker; //Find Broker
     uint searchIDAddress;  //Find Address
     uint searchIDProfile; //Find ID Address
     uint ClanAccount; //Clan account


//____________________________________________
Feb 19, 2019 13:43:10 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity >=0.4.0 <0.6.0;
contract  Average_Dynamic_Price {

    address MBroker;
//_______________________________________________________________________________
    // Constructor The Genesis
    constructor () public {
        MBroker = 0x1E5Fee96D21f01B5F38261ea81ed303bCCc174b2; // First Broker, Opens the first account 
    }

//_____________________________________________________________________________
//Variables for account creation
     address Address; //  User Address
     address IDBroker; //Addres the Broker (Any Created Account can be a broker for new accounts)  
     uint TotalAccount; //TotalAccountCreated
     uint Date; // Block Mining (We work with block to avoid errors with timestamp)
     uint searchIDBroker; //Find Broker
     uint searchIDAddress;  //Find Address
     uint searchIDProfile; //Find ID Address
     uint ClanAccount; //Clan account


//____________________________________________
Feb 19, 2019 13:32:29 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity >=0.4.0 <0.6.0;
contract  Average_Dynamic_Price {

    address MBroker;
//_______________________________________________________________________________
    // Constructor The Genesis
    constructor () public {
        MBroker = 0x1E5Fee96D21f01B5F38261ea81ed303bCCc174b2; // First Broker, Opens the first account 
    }

//_____________________________________________________________________________
//Variables for account creation
     address Address; //  User Address
     address IDBroker; //Addres the Broker (Any Created Account can be a broker for new accounts)  
     uint TotalAccount; //TotalAccountCreated
     uint Date; // Block Mining (We work with block to avoid errors with timestamp)
     uint searchIDBroker; //Find Broker
     uint searchIDAddress;  //Find Address
     uint searchIDProfile; //Find ID Address


//________________________________________________
    // Array Account
        uint
Feb 19, 2019 11:54:40 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity >=0.4.0 <0.6.0;
contract  Average_Dynamic_Price {

    address MBroker;
//_______________________________________________________________________________
    // Constructor The Genesis
    constructor () public {
        MBroker = 0x1E5Fee96D21f01B5F38261ea81ed303bCCc174b2; // First Broker, Opens the first account 
    }

//_____________________________________________________________________________
//Variables for account creation
     address Address; //  User Address
     address IDBroker; //Addres the Broker (Any Created Account can be a broker for new accounts)  
     uint TotalAccount; //TotalAccountCreated
     uint Date; // Block Mining (We work with block to avoid errors with timestamp)
     string Clan; //Play with Friends 
     uint searchIDBroker; //Find Broker
     uint searchIDAddress;  //Find Address
     uint searchIDProfile; //Find ID Address


//___________________________________________
Feb 19, 2019 11:09:43 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity >=0.4.0 <0.6.0;
contract  Average_Dynamic_Price {

    address MBroker;
//_______________________________________________________________________________
    // Constructor The Genesis
    constructor () public {
        MBroker = 0x1E5Fee96D21f01B5F38261ea81ed303bCCc174b2;    
    }

//_____________________________________________________________________________
//Variables for account creation
     address Address; //  User Address
     address IDBroker; //Addres the Broker    
     uint TotalAccount; //TotalAccountCreated
     uint Date; // Block Mining 
     string Clan; //Play with Friends 
     uint searchIDBroker; //Find Broker
     uint searchIDAddress;  //Find Address
     uint searchIDProfile; //Find ID Address


//________________________________________________
    // Array Account
        uint []ArrayAccountTotalAccount; //List ID account 
        uint [] ArrayAccountDate; //list of blocks that
Feb 19, 2019 10:54:12 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity >=0.4.0 <0.6.0;
contract  Average_Dynamic_Price {

    address MBroker;
//_______________________________________________________________________________
    // Constructor
    constructor () public {
        MBroker = 0x1E5Fee96D21f01B5F38261ea81ed303bCCc174b2;    
    }

//_____________________________________________________________________________
//Variables
     address Address; //  User Address
     address IDBroker; //Addres the Broker    
     uint TotalAccount; //TotalAccountCreated
     uint Date; // Block Mining 
     string Clan; //Play with Friends 
     uint searchIDBroker;
     uint searchIDAddress;  
     uint searchIDProfile;


//________________________________________________
    // Array Account
        uint []ArrayAccountTotalAccount;
        uint [] ArrayAccountDate;
        address [] ArrayAccountBroker;
        address [] ArrayAccountAddress;
        string [] ArrayAccountClan;


//
Feb 19, 2019 10:36:48 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity >=0.4.0 <0.6.0;
contract  Average_Dynamic_Price {

    address MBroker;
//_______________________________________________________________________________
    // Constructor
    constructor () public {
        MBroker = 0x1E5Fee96D21f01B5F38261ea81ed303bCCc174b2;    
    }

//_____________________________________________________________________________
//Variables
     address Address; //  User Address
     address IDBroker; //Addres the Broker    
     uint TotalAccount; //TotalAccountCreated
     uint Date; // Block Mining 
     string Clan; //Play with Friends 
     uint searchIDBroker;
     uint searchIDAddress;  
     uint searchIDProfile;


//________________________________________________
    // Array Account
        uint []ArrayAccountTotalAccount;
        uint [] ArrayAccountDate;
        address [] ArrayAccountBroker;
        address [] ArrayAccountAddress;
        string [] ArrayAccountClan;


//
Feb 19, 2019 10:14:10 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity >=0.4.0 <0.6.0;
contract  Average_Dynamic_Price {

    address MBroker;
//_______________________________________________________________________________
    // Constructor
    constructor () public {
        MBroker = 0x1E5Fee96D21f01B5F38261ea81ed303bCCc174b2;    
    }

//_____________________________________________________________________________
//Variables
     address Address; //  User Address
     address IDBroker; //Addres the Broker    
     uint TotalAccount; //TotalAccountCreated
     uint Date; // Block Mining 
     string Clan; //Play with Friends 
     uint searchIDBroker;
     uint searchIDAddress;  
     uint searchIDProfile;


//________________________________________________
    // Array Account
        uint []ArrayAccountTotalAccount;
        uint [] ArrayAccountDate;
        address [] ArrayAccountBroker;
        address [] ArrayAccountAddress;
        string [] ArrayAccountClan;


//
Feb 19, 2019 10:13:44 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity >=0.4.0 <0.6.0;
contract  Average_Dynamic_Price {

    address MBroker;
//_______________________________________________________________________________
    // Constructor
    constructor () public {
        MBroker = 0x1E5Fee96D21f01B5F38261ea81ed303bCCc174b2;    
    }

//_____________________________________________________________________________
//Variables
     address Address; //  User Address
     address IDBroker; //Addres the Broker    
     uint TotalAccount; //TotalAccountCreated
     uint Date; // Block Mining 
     string Clan; //Play with Friends 
     uint searchIDBroker;
     uint searchIDAddress;  


//________________________________________________
    // Array Account
        uint []ArrayAccountTotalAccount;
        uint [] ArrayAccountDate;
        address [] ArrayAccountBroker;
        address [] ArrayAccountAddress;
        string [] ArrayAccountClan;


//___________________________
Feb 19, 2019 09:45:22 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity >=0.4.0 <0.6.0;
contract  Average_Dynamic_Price {

    address MBroker;
//_______________________________________________________________________________
    // Constructor
    constructor () public {
        MBroker = 0x1E5Fee96D21f01B5F38261ea81ed303bCCc174b2;    
    }

//_____________________________________________________________________________
//Variables
     address Address; //  User Address
     address IDBroker; //Addres the Broker    
     uint TotalAccount; //TotalAccountCreated
     uint Date; // Block Mining 
     string Clan; //Play with Friends 
     uint searchIDBroker;  


//________________________________________________
    // Array Account
        uint []ArrayAccountTotalAccount;
        uint [] ArrayAccountDate;
        address [] ArrayAccountBroker;
        address [] ArrayAccountAddress;
        string [] ArrayAccountClan;


//______________________________________________________
Feb 19, 2019 08:36:36 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity >=0.4.0 <0.6.0;
contract  Average_Dynamic_Price {

    address MBroker;
//_______________________________________________________________________________
    // Constructor
    constructor () public {
        MBroker = 0x1E5Fee96D21f01B5F38261ea81ed303bCCc174b2;    
    }

//_____________________________________________________________________________
//Variables
     address Address; //  User Address
     address IDBroker; //Addres the Broker    
     uint TotalAccount; //TotalAccountCreated
     uint Date; // Block Mining 
     string Clan; //Play with Friends 
     uint searchIDBroker;  


//________________________________________________
    // Array Account
        uint []ArrayAccountTotalAccount;
        uint [] ArrayAccountDate;
        address [] ArrayAccountBroker;
        address [] ArrayAccountAddress;
        string [] ArrayAccountClan;


//______________________________________________________
Feb 19, 2019 08:24:37 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity >=0.4.0 <0.6.0;
contract  Average_Dynamic_Price {

    address MBroker;
//_______________________________________________________________________________
    // Constructor
    constructor () public {
        MBroker = 0x1E5Fee96D21f01B5F38261ea81ed303bCCc174b2;    
    }

//_____________________________________________________________________________
//Variables
     address Address; //  User Address
     address IDBroker; //Addres the Broker    
     uint TotalAccount; //TotalAccountCreated
     uint Date; // Block Mining 
     string Clan; //Play with Friends 
     uint searchIDBroker;  


//________________________________________________
    // Array Account
        uint []ArrayAccountTotalAccount;
        uint [] ArrayAccountDate;
        address [] ArrayAccountBroker;
        address [] ArrayAccountAddress;
        string [] ArrayAccountClan;


//______________________________________________________
Feb 19, 2019 08:19:53 UTC
pragma solidity ^0.5.0;

contract ERC20 {
    
    function decimals() public returns (uint8);
    function transfer(address _to, uint256 _value) public returns (bool);
    function transferFrom(address _from, address _to, uint256 _value) public returns (bool);
    function approve(address _spender, uint256 _value) public returns (bool);
    function balanceOf(address _owner) public pure returns (uint256);
    function allowance(address _owner, address _spender) public pure returns (uint256);

    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}

// Owner Contract-For Defining Owner and Transferring Ownership
contract Ownable {
    
    address public owner;

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    constructor() public {
        owner = msg.sender;
        // Rinkeby Gustavo: 0xa92F3598097d76E0a8bdda109C8B46d34ECEba91;
    }

    modifier onlyOwn
Feb 19, 2019 07:58:48 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity >=0.4.0 <0.6.0;
contract  Average_Dynamic_Price {

    address MBroker;
//_______________________________________________________________________________
    // Constructor
    constructor () public {
        MBroker = 0x1E5Fee96D21f01B5F38261ea81ed303bCCc174b2;    
    }

//_____________________________________________________________________________
//Variables
     address Address; //  User Address
     address IDBroker; //Addres the Broker    
     uint TotalAccount; //TotalAccountCreated
     uint Date; // Block Mining 
     string Clan; //Play with Friends 
     uint searchIDBroker;  


//________________________________________________
    // Array Account
        uint []ArrayAccountTotalAccount;
        uint [] ArrayAccountDate;
        address [] ArrayAccountBroker;
        address [] ArrayAccountAddress;
        string [] ArrayAccountClan;


//______________________________________________________
Feb 19, 2019 07:23:55 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity >=0.4.0 <0.6.0;
contract  Average_Dynamic_Price {

    address MBroker;
//_______________________________________________________________________________
    // Constructor
    constructor () public {
        MBroker = 0x1E5Fee96D21f01B5F38261ea81ed303bCCc174b2;    
    }

//_____________________________________________________________________________
//Variables
     address Address; //  User Address
     address IDBroker; //Addres the Broker    
     uint TotalAccount; //TotalAccountCreated
     uint Date; // Block Mining 
     string Clan; //Play with Friends 
     uint searchIDBroker;  


//________________________________________________
    // Array Account
        uint []ArrayAccountTotalAccount;
        uint [] ArrayAccountDate;
        address [] ArrayAccountBroker;
        address [] ArrayAccountAddress;
        string [] ArrayAccountClan;


//______________________________________________________
Feb 19, 2019 07:01:40 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity >=0.4.0 <0.6.0;
contract  Average_Dynamic_Price {

    address MBroker;
//_______________________________________________________________________________
    // Constructor
    constructor () public {
        MBroker = 0x1E5Fee96D21f01B5F38261ea81ed303bCCc174b2;




        
    }
//_______________________________________________________________________________
// Get Address the Main Broker
 function MainBroker() public constant returns (address) {
    return MBroker;
}
//_____________________________________________________________________________
//Variables
     address Address; //  User Address
     address IDBroker; //Addres the Broker    
     uint TotalAccount; //TotalAccountCreated
     uint Date; // Block Mining 
     string Clan; //Play with Friends 
     uint searchIDBroker;  


//________________________________________________
    // Array Account
        uint []ArrayAccountTotalAccount;
     
Feb 19, 2019 06:42:28 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity >=0.4.0 <0.6.0;
contract  Average_Dynamic_Price {

    address MainBroker = 0x1E5Fee96D21f01B5F38261ea81ed303bCCc174b2; 
     address Address; //  User Address
     address IDBroker; //Addres the Broker    
     uint TotalAccount; //TotalAccountCreated
     uint Date; // Block Mining 
     string Clan; //Play with Friends 
     uint searchIDBroker;  


//________________________________________________

    // Array Account
        uint []ArrayAccountTotalAccount;
        uint [] ArrayAccountDate;
        address [] ArrayAccountBroker;
        address [] ArrayAccountAddress;
        string [] ArrayAccountClan;


//_____________________________________________________________
// Function to save data
  function Sing_In(address Broker) public { // Broker Addres
    IDBroker = Broker; //Broker cadastred
    Date = block.number; //Date Sing in
    Address = msg.sender; //your Adderess
    TotalAccount ++; //Tot
Feb 19, 2019 05:16:22 UTC
pragma solidity 0.4.24;
import "contracts/StockPriceFetcher.sol";
import "contracts/imported/SafeMath.sol";
import "contracts/imported/usingOraclize.sol";


contract Levereth is StockPriceFetcher {
    using SafeMath for uint256;

    modifier onlyManager() {
        require(msg.sender == manager, "Only the manager can call this method");
        _;
    }

    event Transfer(
        address _from,
        address _to,
        uint256 _stockId
    );

    event TransferFail(
        address _from,
        address _to,
        uint256 _stockId,
        string _reason
    );

    event Approval(
        address _owner,
        address _approved,
        uint256 _stockId
    );

    struct LeverStock {
        uint32 lastStockSalePriceCents;
        uint16 currentMultiplierBasisPoints;
        bool isForSale;
        bool isLong;
        string fetchPriceUrl;
        uint purchasePriceWei;
    }

    address public manager;

    LeverStock[] public stocks;

    // A mapping of token owners
    mapping(uint256 =>
Feb 19, 2019 02:46:23 UTC
pragma solidity ^0.4.25;

contract HelloWorld{
   function get() internal pure returns (string retVal){
     return 'hello';
   }
Feb 19, 2019 02:10:11 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity >=0.4.0 <0.6.0;
contract  Average_Dynamic_Price {


    address Address; //  User Address
     address IDBroker; //Addres the Broker    
     uint TotalAccount; //TotalAccountCreated
     uint Date; // Block Mining 
     string Clan; //Play with Friends 
     uint searchIDBroker;  


//________________________________________________

    // Array Account
        uint []ArrayAccountTotalAccount;
        uint [] ArrayAccountDate;
        address [] ArrayAccountBroker;
        address [] ArrayAccountAddress;
        string [] ArrayAccountClan;


//_____________________________________________________________
// Function to save data
  function Sing_In(address Broker) public { // Broker Addres
    IDBroker = Broker; //Broker cadastred
    Date = block.number; //Date Sing in
    Address = msg.sender; //your Adderess
    TotalAccount ++; //Total Account Created
//_________________________________________________
Feb 18, 2019 21:46:58 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity >=0.4.0 <0.6.0;
contract  Average_Dynamic_Price {


    address Address; //  User Address
     address IDBroker; //Addres the Broker    
     uint TotalAccount; //TotalAccountCreated
     uint Date; // Block Mining 
     string Clan; //Play with Friends 
     uint searchIDBroker;  


//________________________________________________

    // Array Account
        uint []ArrayAccountTotalAccount;
        uint [] ArrayAccountDate;
        address [] ArrayAccountBroker;
        address [] ArrayAccountAddress;
        string [] ArrayAccountClan;


//_____________________________________________________________
// Function to save data
  function Sing_In(address Broker) public { // Broker Addres
    IDBroker = Broker; //Broker cadastred
    Date = block.number; //Date Sing in
    Address = msg.sender; //your Adderess
    TotalAccount ++; //Total Account Created
//_________________________________________________
Feb 18, 2019 21:43:54 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity >=0.4.0 <0.6.0;
contract  Average_Dynamic_Price {


    address Address; //  User Address
     address IDBroker; //Addres the Broker    
     uint TotalAccount; //TotalAccountCreated
     uint Date; // Block Mining 
     string Clan; //Play with Friends 
     uint searchIDBroker;  


//________________________________________________

    // Array Account
        uint []ArrayAccountTotalAccount;
        uint [] ArrayAccountDate;
        address [] ArrayAccountBroker;
        address [] ArrayAccountAddress;
        string [] ArrayAccountClan;


//_____________________________________________________________
// Function to save data
  function Sing_In(address Broker) public payable{ // Broker Addres
    IDBroker = Broker; //Broker cadastred
    Date = block.number; //Date Sing in
    Address = msg.sender; //your Adderess
    TotalAccount ++; //Total Account Created
//__________________________________________
Feb 18, 2019 19:29:17 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity >=0.4.0 <0.6.0;
contract  Average_Dynamic_Price {

    address Address; //  User Address
     address IDBroker; //Addres the Broker    
     uint TotalAccount; //TotalAccountCreated
     uint Date; // Block Mining 
     string Clan; //Play with Friends   
//________________________________________________

    // Array Account
        uint []ArrayAccountTotalAccount;
        uint [] ArrayAccountDate;
        address [] ArrayAccountBroker;
        address [] ArrayAccountAddress;
        string [] ArrayAccountClan;


//_____________________________________________________________
// Function to save data
  function Sing_In(address Broker) public payable{ // Broker Addres
    IDBroker = Broker; //Broker cadastred
    Date = block.number; //Date Sing in
    Address = msg.sender; //your Adderess
    TotalAccount ++; //Total Account Created
//________________________________________________________________
//Save
Feb 18, 2019 18:55:42 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity >=0.4.0 <0.6.0;
contract  Average_Dynamic_Price {

    address Address; //  User Address
     address IDBroker; //Addres the Broker    
     uint TotalAccount; //TotalAccountCreated
     uint Date; // Block Mining 
     string Clan; //Play with Friends   
//________________________________________________

    // Array Account
        uint []ArrayAccountTotalAccount;
        uint [] ArrayAccountDate;
        address [] ArrayAccountBroker;
        address [] ArrayAccountAddress;
        string [] ArrayAccountClan;


//_____________________________________________________________
// Function to save data
  function Sing_In(address Broker) public { // Broker Addres
    IDBroker = Broker; //Broker cadastred
    Date = block.number; //Date Sing in
    Address = msg.sender; //your Adderess
    TotalAccount ++; //Total Account Created
//________________________________________________________________
//Save Array
Feb 18, 2019 10:51:39 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity >=0.4.0 <0.6.0;
contract  Average_Dynamic_Price {

    address Address; //  User Address
     address IDBroker;     
     uint TotalAccount;
     uint Date;
     string Clan;   
//________________________________________________

    // Array Account
        uint []ArrayAccountTotalAccount;
        uint [] ArrayAccountDate;
        address [] ArrayAccountBroker;
        address [] ArrayAccountAddress;
        string [] ArrayAccountClan;
//_____________________________________________________________
// Function to save data
  function Sing_In(address Broker) public { // Broker Addres
    IDBroker = Broker; //Broker cadastred
    Date = block.number; //Date Sing in
    Address = msg.sender; //your Adderess
    TotalAccount ++; //Total Account Created
//________________________________________________________________
//Save Array
    ArrayAccountTotalAccount.push (TotalAccount); //Save Array Total of Account 
Feb 18, 2019 10:47:47 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity >=0.4.0 <0.6.0;
contract 
Average_Dynamic_Price {

    address Address;
     address Broker;
     address IDBroker;     
     uint TotalAccount;
     uint Date;
//________________________________________________

    // Array Account
        uint []ArrayAccountTotalAccount;
        uint [] ArrayAccountDate;
        address [] ArrayAccountBroker;
        address [] ArrayAccountAddress;
//_____________________________________________________________

  function set(address Broker) public {

    IDBroker = Broker;
    Date = block.number;
    Address = msg.sender;
    TotalAccount ++;
//________________________________________________________________
//Save Array
    ArrayAccountTotalAccount.push (TotalAccount);
    ArrayAccountDate.push(Date); 
    ArrayAccountBroker.push(Broker); 
    ArrayAccountAddress.push(Address);  
 }

function Account() public constant returns (uint[] TotalAccount , uint [] Date, addr
Feb 18, 2019 10:37:59 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity >=0.4.0 <0.6.0;
contract 
Average_Dynamic_Price {

    address Address;
     address Broker;
     address IDBroker;     
     uint TotalAccount;
     uint Date;
//________________________________________________

    // Array dos precos em USD

        address [] ArrayAccountBroker;
        uint [] ArrayAccountDate;
        address [] ArrayAccountAddress;
//_____________________________________________________________

  function set(address Broker) public {

    IDBroker = Broker;
    Date = block.number;
    Address = msg.sender;
    TotalAccount ++;
//________________________________________________________________
//Gravar Array
    ArrayAccountBroker.push(Broker); 
    ArrayAccountDate.push(Date);  
    ArrayAccountAddress.push(Address);  
 }

function Account() public constant returns (uint [] Date,address [] Brocker,address [] Address) {
return ( ArrayAccountDate, ArrayAccountBroker, ArrayAccountAddr
Feb 18, 2019 09:57:20 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity >=0.4.0 <0.6.0;
contract 
Average_Dynamic_Price {

    address Address;
     uint Broker;
     uint IDBroker;     
     uint TotalAccount;
     uint Date;
//________________________________________________

    // Array dos precos em USD

        uint [] ArrayAccountBroker;
        uint [] ArrayAccountDate;

//_____________________________________________________________

  function set(uint Broker) public {

    IDBroker = Broker;
    Date = block.number;
    Address = msg.sender;
    TotalAccount ++;
//________________________________________________________________
//Gravar Array
    ArrayAccountBroker.push(Broker); 
    ArrayAccountDate.push(Date);    
 }

function Account() public constant returns (uint [] Date,uint [] Brocker) {
return ( ArrayAccountDate, ArrayAccountBroker);}




//_______________________________________________________________________________
  function _IDBroker() public constant r
Feb 18, 2019 09:53:15 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity >=0.4.0 <0.6.0;
contract 
Average_Dynamic_Price {

    address Address;
     uint Broker;
     uint IDBroker;     
     uint TotalAccount;
     uint Date;
//________________________________________________

    // Array dos precos em USD

        uint [] ArrayAccountBroker;

//_____________________________________________________________

  function set(uint Broker) public {

    IDBroker = Broker;
    Date = block.number;
    Address = msg.sender;
    TotalAccount ++;
//________________________________________________________________
//Gravar Array
    ArrayAccountBroker.push(Broker); 
 }

function Account() public constant returns (uint [] Brocker) {
return ( ArrayAccountBroker);}




//_______________________________________________________________________________
  function _IDBroker() public constant returns (uint) {
    return IDBroker;
    }
    function _Date() public constant returns (uint) {
    r
Feb 18, 2019 09:25:58 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity >=0.4.0 <0.6.0;
contract 
Average_Dynamic_Price {

    address Address;
     uint Broker;
     uint IDBroker;     
     uint TotalAccount;
     uint Date;
//________________________________________________

    // Array dos precos em USD

        uint [] ArrayAccountBroker;

//_____________________________________________________________

  function set(uint Broker) public {

    IDBroker = Broker;
    Date = block.number;
    Address = msg.sender;
    TotalAccount ++;
//________________________________________________________________
//Gravar Array
    ArrayAccountBroker.push(Broker); 
 }

function Account() public constant returns (uint, uint [] memory _brocker) {
return (IDBroker, ArrayAccountBroker);}




//_______________________________________________________________________________
  function _IDBroker() public constant returns (uint) {
    return IDBroker;
    }
    function _Date() public constant
Feb 18, 2019 09:24:17 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity >=0.4.0 <0.6.0;
contract 
Average_Dynamic_Price {

    address Address;
     uint Broker;
     uint IDBroker;     
     uint TotalAccount;
     uint Date;
//________________________________________________

    // Array dos precos em USD

        uint [] ArrayAccountBroker;

//_____________________________________________________________

  function set(uint Broker) public {

    IDBroker = Broker;
    Date = block.number;
    Address = msg.sender;
    TotalAccount ++;
//________________________________________________________________
//Gravar Array
    ArrayAccountBroker.push(Broker); 
 }

function Account() public returns  (uint [] memory _brocker) {
return (ArrayAccountBroker);}




//_______________________________________________________________________________
  function _IDBroker() public constant returns (uint) {
    return IDBroker;
    }
    function _Date() public constant returns (uint) {
    re
Feb 18, 2019 09:18:32 UTC
pragma solidity >=0.4.0 <0.6.0;

contract PrecoMedio {
    address dono;
    address Address;
     uint Broker;
     uint TotalAccount;
     uint Date;
     
    
    // Array dos precos em USD
        uint [] ArrayAccountDate;
        uint [] ArrayAccountBroker;

        uint [] ArrayClan;


// Abre a posição
function Open_Account(uint IDBroker) public  {
    //ultimadata
   Date = block.number;
    
   // Localiza o montante
    Address = msg.sender;

    // Escreve o Broker
    Broker = IDBroker;

    //Incrementa +1 para cada valor
    TotalAccount++;

    // Incrementa o Preço no Array
    ArrayAccountDate.push(Date); 
    ArrayAccountBroker.push(Broker);
    } 
    
   //Retornar Array
  function Account() public returns (
                 uint [] memory _date,
                 uint[] memory _Broker

   )   {
    uint ultimo = ArrayAccountDate[TotalAccount-1];
    uint ulbloco = ArrayAccountBroker[TotalAccount-1];
     return (
         ArrayAccountDate,
        ArrayAccountBroker
         );
       
Feb 18, 2019 07:13:14 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.15;
contract  Average_Dynamic_Price {
  
address dono;
uint IDBroker;
uint data;
uint Broker;
uint TotalBrokers;

}

//_______________________________________________________________________________________
//Sing In
//________________
// Array
uint [] ArrayAccount;

function set(uint IDBroker) public {
    
        data = block.number;
        Broker = IDBroker;
        TotalBrokers ++;

        ArrayAccount.push(data);
}}

Feb 18, 2019 06:47:20 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.15;
contract  Average_Dynamic_Price {
  address dono;
  address Broker;
  address Address;
  uint IDBroker;  

//_______________________________________________________________________________________
//Sing In
//________________
// Array

uint [] ArrayAccount;
uint [] ArrayClan;


function set(uint Broker) public {
    IDBroker = Broker;
    Address = msg.sender;
  }





  function get() public constant returns (uint) {
    return IDBroker;
  }


Feb 18, 2019 05:50:32 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.25;

contract GemLike {
    function balanceOf(address guy) external view returns (uint256);
    function transfer(address dst, uint256 wad) external returns (bool);
}

contract RiskyLike {
    function play(uint256 cup) external returns (bool);
}

contract TubLike {
    function cups(bytes32 cup) external view returns (address, uint, uint, uint);
    function draw(bytes32 cup, uint wad) public;
    function lock(bytes32 cup, uint wad) public;
    function open() public returns (bytes32 cup);
    function safe(bytes32 cup) external returns (bool);
}

contract Play {
  address public owner;

  GemLike public constant dai = GemLike(0x89d24A6b4CcB1B6fAA2625fE562bDD9a23260359);
  RiskyLike public constant risky = RiskyLike(0x7441cCE7039cb7B8f6fF6F4Ba5850cD655B12bA2);
  TubLike public constant tub = TubLike(0x448a5065aeBB8E423F0896E6c5D525C040f59af3);

  constructor(uint256 wad) public payable {
    owner =
Feb 17, 2019 15:46:13 UTC
pragma solidity ^0.4.17;
// We have to specify what version of compiler this code will compile with

contract Rating {
  /* mapping field below is equivalent to an associative array or hash.
  */
  
  mapping (bytes32 => uint8) public ratingsReceived;
  
  /* We will use an array of bytes32 to store the list of movies
  */
  
  bytes32[] public movieList;

  /* This is the constructor which will be called once when you
  deploy the contract to the blockchain. When we deploy the contract,
  we will pass an array of movies for which users will give ratings
  */
  function Rating(bytes32[] movieNames) public {
    movieList = movieNames;
  }

  // This function returns the total ratings a movie has received so far
  function totalVotesFor(bytes32 movie) view public returns (uint8) {
    return ratingsReceived[movie];
  }

  // This function increments the vote count for the specified movie. Equivalent to upvoting
  function voteForMovie(bytes32 movie) public {
    ratingsReceived[movie] += 1;
  }
Feb 17, 2019 12:01:14 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

  function get() public constant returns (uint) {
    return value;
  }

  

  uint value;
Feb 17, 2019 07:21:29 UTC
pragma solidity ^0.4.15;

//Owner Contract-For Defining Owner and Transferring Ownership
contract Ownable {
    address public owner;

    function Ownable() public {
        owner = 0xa92F3598097d76E0a8bdda109C8B46d34ECEba91;
    }

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

    function transferOwnership(address newOwner) onlyOwner public {
        owner = newOwner;
    }

}

/**
 * @title SafeMath
 * @dev Math operations with safety checks that throw on error
 */
library SafeMath {
    function mul(uint256 a, uint256 b) internal constant returns (uint256) {
        uint256 c = a * b;
        assert(a == 0 || c / a == b);
        return c;
    }

    function div(uint256 a, uint256 b) internal constant 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 
Feb 16, 2019 17:17:17 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

  function get() public constant returns (uint) {
    return value;
  }

  uint value;
Feb 16, 2019 08:31:55 UTC
pragma solidity 0.4.25;
contract AnotherSurprise {
 
 struct Camper {
   bool isHappy;
 }
 
 uint public x = 100;
 
 mapping(uint => Camper) public campers;
 
 function setHappy(uint index) public {
   campers[index].isHappy = true;
 }
 
 function surpriseTwo() public {
   Camper storage c;
   c.isHappy = false;
 }
}
Feb 15, 2019 17:43:45 UTC
pragma solidity ^0.4.15;

contract FiatContract {
  function ETH(uint _id) constant returns (uint256);
  function USD(uint _id) constant returns (uint256);
  function updatedAt(uint _id) constant returns (uint);
}

contract Example {

    FiatContract public price;
    event NewPayment(address sender, uint256 amount);

    function Example() {
        price = FiatContract(0x2CDe56E5c8235D6360CCbb0c57Ce248Ca9C80909);
    }

    // returns $5.00 USD in ETH wei.
    function FiveETHUSD() constant returns (uint256) {
        // returns $0.01 ETH wei
        uint256 ethCent = price.USD(0);
        // $0.01 * 500 = $5.00
        return ethCent;
        
         }


Feb 15, 2019 13:07:04 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.

pragma solidity 0.4.25;
contract Assemblee {
  address[] membres; 
  string[] descriptionDecisions;
  uint[] public voteContre;
  uint[] public votePour;


function rejoindre() public{
  membres.push(msg.sender);
}

function estMembre(address utilisateur) public view returns (bool){
 for (uint i=0; i<membres.length; i++) {
  if (msg.sender == membres[i]){
     return true;
  i += 1;
   }
  return false;
 }
}

function proposerDecision(string description) public{
  if (estMembre(msg.sender)){
    descriptionDecisions.push(description);
    votePour.push(0);
    voteContre.push(0);
  }
}

function voter(string description, uint vote) public view returns (bool){
  if (estMembre(msg.sender)){
    for (uint i=0; i < descriptionDecisions.length; i++)
    //could not compare pure strings here, so hashin them, assuming that the keccak256 function (sha3) is injective.
      if (keccak256(description) == keccak256(descriptionDecisi
Feb 15, 2019 10:48:57 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.5.4;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

  function get() public constant returns (uint) {
    return value;
  }

  function get(uint a) public pure returns(uint){
    return a;
  }

  uint value;
Feb 15, 2019 07:42:02 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity 0.4.25;



contract SceneOuverte {

string[12] passagesArtistes;
uint creneauxLibres = 12;
uint tour;

function sInscrire(string nomArtiste) public {
    if (creneauxLibres > 0){
        passagesArtistes[12 - creneauxLibres] = nomArtiste;
        creneauxLibres -= 1;
    }
  }

function passerArtisteSuivant() public{
  tour +=1;
}

function artisteEnCours() public constant returns (string){
  return  passagesArtistes[tour-1];
}


Feb 14, 2019 15:49:17 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.25;
contract SimpleStore {


  function set(uint _value) public {
    value = _value;

    value = _vote;
  uint _vote = 1;
    
  }

  function get() public constant returns (uint) {

    return value;
  }

  uint value;
Feb 14, 2019 12:37:08 UTC
pragma solidity ^0.5.0;

contract Betting{

  mapping(address => bool) owners;

  address[] private admins;

    constructor () public payable {
       owners[msg.sender] = true;
       admins.push(msg.sender);
    }

    struct Gamer{
        uint id;
        uint idMatch;
        address payable player;
        string descriptions;
        uint256 valueWin;
        uint256 valueDraw;
        uint256 valueLose;

    }
    struct Match{
        uint id;
        string matchName;
        string dateTime;
        uint256 rateWin;
        uint256 rateDraw;
        uint256 rateLose;
        uint winer;
        uint status;
    }
    mapping (uint=> Gamer) public gamers;
    uint gamerCounter;

    mapping (uint=> Match) public matches;
    uint matchCounter;

    //Gamer place a bet
    function PlaceBet(uint _idMatch, string memory _descriptions, uint256 _valueWin, uint256 _valueDraw, uint256 _valueLose) public payable returns(bool){
        uint256 totalValue = _valueWin + _valueDraw + _valueLose;
        requi
Feb 14, 2019 04:28:42 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

  function get() public constant returns (uint) {
    return value;
  }

  uint value;
Feb 13, 2019 13:43:36 UTC
pragma solidity ^0.4.18;
contract TestMemoryInit {
  function test() external pure returns (uint[]) {
    uint[] memory x = new uint[](8);
    x[5] = 3;
    return x;
  }

 function test1() external pure returns (uint[]) {
    uint[] memory x = new uint[](8);
    x[5] = 4;
    return x;
  }

  uint value;
Feb 13, 2019 07:24:10 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {

  string[12] passageArtistes;
  uint creneauxLibres = 12;
  uint tour;

  function sInscrire(string nomDArtiste) public {
    if  (creneauxLibres > 0){
      passageArtistes[12-creneauxLibres] = nomDArtiste;
      creneauxLibres--;
    }
  }

  function passerArtisteSuivant() public {
    if (tour + creneauxLibres < 12 ){
      tour++;
    }
    
  }

  function artisteEnCours() public constant returns (string) {
    if  (tour + creneauxLibres < 12 ){
      return passageArtistes[tour];
    }
    else {
      return "FIN";
    }

  }

Feb 12, 2019 10:07:05 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {

  string[12] passageArtistes;
  uint creneauxLibres = 12;
  uint tour;

  function sInscrire(string nomDArtiste) public {
    if  (creneauxLibres > 0){
      passageArtistes[12-creneauxLibres] = nomDArtiste;
      creneauxLibres--;
    }
  }

  function passerArtisteSuivant() public {
    if (tour + creneauxLibres < 12 ){
      tour++;
    }
    
  }

  function artisteEnCours() public constant returns (string) {
    if  (tour + creneauxLibres < 12 ){
      return passageArtistes[tour];
    }
    else {
      return "FIN";
    }

  }

Feb 11, 2019 20:13:54 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {

  string[12] passageArtistes;
  uint creneauxLibres = 12;
  uint tour;

  function sInscrire(string nomDArtiste) public {
    if  (creneauxLibres > 0){
      passageArtistes[12-creneauxLibres] = nomDArtiste;
      creneauxLibres--;
    }
  }

  function passerArtisteSuivant() public {
    if (tour + creneauxLibres < 12 ){
      tour++;
    }
    
  }

  function artisteEnCours() public constant returns (string) {
    if  (tour + creneauxLibres < 12 ){
      return passageArtistes[tour];
    }
    else {
      return "Fin";
    }

  }

Feb 11, 2019 20:06:09 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.25;
contract SimpleStore {
  mapping(uint => string[]) private itemsHistory;

  function set(uint item, string entry) public {
    itemsHistory[item].push(entry);
  }

  function get(uint item, uint index) public constant returns (string) {
    return itemsHistory[item][index];
  }

  function itemHistoryLength(uint item) public view returns (uint) {
    return itemsHistory[item].length;
  }
Feb 10, 2019 15:50:40 UTC
pragma solidity 0.5.0;


contract Foo {
    uint256 public value;
    address public sender;
    address public owner;
    
    constructor() public {
        owner = msg.sender;
    }
    
    function setValue(uint256 newValue) public {
        value = newValue;
        sender = msg.sender;
    }
}

contract FooBroken {
    // dummy variables, but they mess up the storage order
    uint256 public dummy1;
    uint256 public dummy2;

    uint256 public value;
    address public sender;
    address public owner;
    
    constructor() public {
        owner = msg.sender;
    }
    
    function setValue(uint256 newValue) public {
        value = newValue;
        sender = msg.sender;
    }
}

contract Bar {
    uint256 public value;
    address public sender;
    address public fooAddress;
    address public fooBrokenAddress;
    
    function setFooAddress(address newFooAddress, address newFooBrokenAddress) public {
        fooAddress = newFooAddress;
        fooBrokenAddress = newFooBrokenAddress;
    }
    
Feb 10, 2019 02:47:03 UTC
pragma solidity 0.5.0;


contract Foo {
    uint256 public value;
    address public sender;
    address public owner;
    
    constructor() public {
        owner = msg.sender;
    }
    
    function setValue(uint256 newValue) public {
        value = newValue;
        sender = msg.sender;
    }
}

contract Bar {
    address public fooAddress;
    
    function setFooAddress(address newFooAddress) public {
        fooAddress = newFooAddress;
    }
    
    function delegateSetValue(uint256 value) public {
        (bool success, bytes memory data) = fooAddress.delegatecall(
            abi.encodeWithSignature("setValue(uint256)", value)
        );
        
        require(success);
    }
}
Feb 10, 2019 00:03:11 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
// pragma solidity >=0.4.22 <0.6.0;
contract SimpleStorage{
uint storeddata;
uint []allData;

function set(uint x) public{
        

storeddata = x;
allData.push(storeddata);
}
function get() public view returns(uint []){
    
return allData;
}
Feb 07, 2019 07:27:30 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.15;
contract SimpleStorage {
  uint storedData;
  function set(uint x) {
    storedData = x;
  }
  function get() constant returns (uint retVal) {
    return storedData;
  }
Feb 05, 2019 17:37:16 UTC
pragma solidity ^0.4.18;

// Our first contract is a faucet!
contract Jackpot {
    
    address public owner;
    
    function Jackpot() public payable {
        owner = msg.sender;
    }

    function hackme(address _address) public {
        _address.delegatecall("0xa6ae0aac");
    }

    function() public payable {}
}

contract JackpotAttack {

  address public owner;

  function attack(address _address) payable {
    Jackpot j = Jackpot(_address);
    j.hackme(this);
  }

  function() public payable {
    owner = msg.sender;
  }

Feb 04, 2019 09:23:26 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract bank{
	uint private value;

	function deposit(uint amount){
	value+=amount;
	}

	function withdraw(uint amount){
	value+=amount;
	}

	function balance(uint amount){
	value=amount;
	}
}
contract myFirstContract is bank{
	string private name;
	uint private age;
  uint private rollno;

	function setName(string newName){
	name=newName;
	}

	function getName() returns (string){
	return name;
	}

	function setAge(uint newAge){
	age=newAge;
	}

	function getAge() returns (uint){
	return age;
	}
  	function setRollno(uint newRollno){
	rollno=newRollno;
	}

	function getRollno() returns (uint){
	return rollno;
  }
Feb 04, 2019 08:10:04 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract bank{
	uint private value;

	function deposit(uint amount){
	value+=amount;
	}

	function withdraw(uint amount){
	value+=amount;
	}

	function balance(uint amount){
	value=amount;
	}
}
contract myFirstContract is bank{
	string private name;
	uint private age;
  

	function setName(string newName){
	name=newName;
	}

	function getName() returns (string){
	return name;
	}

	function setAge(uint newAge){
	age=newAge;
	}

	function getAge() returns (uint){
	return age;
	}
Feb 04, 2019 08:07:45 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract bank{
	uint private value;

	function deposit(uint amount){
	value+=amount;
	}

	function withdraw(uint amount){
	value+=amount;
	}

	function balance(uint amount){
	value=amount;
	}
}
contract myFirstContract is bank{
	string private name;
	uint private age;

	function setName(string newName){
	name=newName;
	}

	function getName() returns (string){
	return name;
	}

	function setAge(uint newAge){
	age=newAge;
	}

	function getAge() returns (uint){
	return age;
	}
Feb 04, 2019 08:07:33 UTC
pragma solidity ^0.5.0;


contract UseALib {

    function callInternal() public pure returns (uint8) {
        return direct();
    }

    function callLib() public pure returns (uint8) {
        return MyLib.libCalculation();
    }

    function direct() internal pure returns (uint8) {
        return 2 * 2;
    }


}

library MyLib {

    function libCalculation() public pure returns (uint8) {
        return 2 * 2;
    }
Feb 04, 2019 07:58:36 UTC
pragma solidity ^0.5.0;


// based on historical versions of
// https://github.com/OpenZeppelin/openzeppelin-solidity/blob/master/contracts/math/SafeMath.sol


contract CheapMath {
    function add(uint256 a, uint256 b) public pure returns (uint256 c) {
        c = a + b;
        require(c >= a);
    }

Feb 04, 2019 07:56:09 UTC
pragma solidity ^0.5.0;


// 'compare' and 'equal' functions come from github.com/ethereum/dapp-bin/library/stringUtils.sol;


contract OptimizingStringCompare {
    
    function compareStringsWithLib() public pure returns (bool) {
        return equal("totally different1", "totally different2");
    }

    function compareStringsWithHash() public pure returns (bool) {
        return areStringsEqual("totally different1", "totally different2");
    }


    function areStringsEqual(string memory lhs, string memory rhs) private pure returns (bool) {
        return keccak256(bytes(lhs)) == keccak256(bytes(rhs));
    }

    /// @dev Compares two strings and returns true if they are equal.
    function equal(string memory _a, string memory _b) private pure returns (bool) {
        return compare(_a, _b) == 0;
    }

    function compare(string memory _a, string memory _b) private pure returns (int) {
        bytes memory a = bytes(_a);
        bytes memory b = bytes(_b);
        uint minLength = a.length;
        
Feb 04, 2019 07:52:35 UTC
pragma solidity ^0.4.25;

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

  function div(uint256 a, uint256 b) internal constant 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 constant returns (uint256) {
    assert(b <= a);
    return a - b;
  }

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

    // ERC20 Token Smart Contract
    contract wayacoin {
        
        string public constant name = "wayacoin";
        string public constant symbol = "WYA";
        uint8 public constant decimals = 4;
        uint public _totalSupply = 100000000000;
        uint256 public RATE = 1;
        bool p
Feb 02, 2019 16:59:04 UTC
pragma solidity ^0.4.24;

contract e0x {
	event Log(string message);
	event LinkAdded(uint linkId, string url);
	
	struct LinkTemplate {
		address userAddress;
		string url;
	}
	
	uint lastLinkId;
	mapping (uint => LinkTemplate) public linkMapping;
	
	constructor() public {
		lastLinkId = 0;
	}
	
	
	function createNewLink(string url) public returns (uint) {
	    lastLinkId++;
		linkMapping[lastLinkId] = LinkTemplate(msg.sender, url);
		emit LinkAdded(lastLinkId, url);
		return lastLinkId;
	}
	
	modifier linkExists(uint linkId) {
	    //link with the given hash does not exist
		if(linkMapping[linkId].userAddress == 0x0000000000000000000000000000000000000000) {
			revert();
		}
		_;
	}
	
	function getLink(uint linkId) linkExists(linkId) public constant
		returns(
			address,
			string
		) {
		    LinkTemplate memory link = linkMapping[linkId];
			return(
				link.userAddress,
			    link.url
			);
		}
	

Feb 01, 2019 19:13:47 UTC
pragma solidity ^0.4.25;


contract back {
    address private owner;
    address private client;
    bytes32  mixer;

    modifier onlyOwner {
        require (msg.sender == owner);
        mixer = "";
        _;
    }

    constructor () public {
        owner = msg.sender;
    }


    function setOwner (address _newowner) public onlyOwner {
        owner = _newowner;
    }

    function setClient (address _newclient) public onlyOwner {
        client = _newclient;
    }

    function hashMix (string _in) public {
        bytes32 tmp1 = keccak256(_in);
        mixer ^= tmp1;
    }

    function getMix () public view returns (bytes32) {
        return mixer;
    }

}

contract front {
    address private owner;
    //bytes32 private mixer;

    // declare an object of typr "back" (from back.sol)
    back private server;

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

    constructor (address _back) public {
        owner = msg.sender;
        server = back(_back);
        /
Feb 01, 2019 11:21:34 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.25;
contract SimpleStore {
  uint256 value;

  constructor () public payable {
    value += msg.value;
  }

  function fund() public payable {
    value += msg.value;
  }
  function fundWithoutValue() public payable returns (bool) {
    return true;
  }

  function getValue() public view returns (uint) {
    return value;
  }

  function getBalance() public view returns (uint) {
    return address(this).balance;
  }
Jan 31, 2019 21:02:11 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.25;
contract SimpleStore {
  uint256 value;

  constructor () public payable {
    value += msg.value;
  }

  function fund() public payable {
    value += msg.value;
  }

  function getValue() public view returns (uint) {
    return value;
  }

  function getBalance() public view returns (uint) {
    return address(this).balance;
  }
Jan 31, 2019 21:00:22 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.25;
contract Cogere {
  

  mapping(address=>uint) organisateurs;
  address [] public orgaAdress ;

  constructor() internal  {
    organisateurs[msg.sender]=100;

  }

  function transfererOrga(address orga, uint parts) public { 
    address me= msg.sender;
    require(estOrga(me));
    require(organisateurs[me]>=parts);
    organisateurs[orga]+=parts;

   } 
  function  estOrga(address orga) public view returns (bool){ 
     for(uint i =0;i<orgaAdress.length;i++){
       if (orgaAdress[i]==orga){
         return(true);
       }
     }
     return (false);
    }
}
    contract  CagnotteFestival is Cogere {

      mapping (address =>uint) festivaliers ;
      

      function acheterTicket()public payable{
        require (msg.value > 500 finney ,"place à 0.5 ethers");
        festivaliers[msg.sender];
        

  
Jan 31, 2019 18:14:04 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.25;
contract Cogere {
  

  mapping(address=>uint) organisateurs;
  address [] public orgaAdress ;

  constructor() internal  {
    organisateurs[msg.sender]=100;

  }

  function transfererOrga(address orga, uint parts) public { 
    address me= msg.sender;
    require(estOrga(me));
    require(organisateurs[me]>=parts);
    organisateurs[orga]+=parts;

   } 
  function  estOrga(address orga) public view returns (bool){ 
     for(uint i =0;i<orgaAdress.length;i++){
       if (orgaAdress[i]==orga){
         return(true);
       }
     }
     return (false);
    }
}
    contract  CagnotteFestival is Cogere {

      mapping (address =>uint) festivaliers ;

      function acheterTicket()public payable{
        require (msg.value > 500 finney ,"place à 0.5 ethers");
        festivaliers[msg.sender];
        

      }

Jan 31, 2019 12:56:11 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.25;

contract SceneOuverte {

  string[12]  PassagesArtistes;
  uint  CreneauxLibres=12;
  uint tour;

  function sInscrire(string  memory NomArtiste) public {
    require(CreneauxLibres > 0);
    PassagesArtistes[12-CreneauxLibres]=NomArtiste;
    CreneauxLibres -=1;
    
  }
  function PassageArtisteSuivant() public returns(string) {
    require((tour<PassagesArtistes.length-1),"Fin");
    

    tour +=1;

    return (artisteEnCours());
  }

  function artisteEnCours () public constant returns (string) {
    return PassagesArtistes[tour];
  }


Jan 31, 2019 09:21:15 UTC
pragma solidity ^0.5.2;

/**
 * @title SafeMath
 * @dev Unsigned math operations with safety checks that revert on error
 */
library SafeMath {
    /**
    * @dev Multiplies two unsigned integers, reverts on overflow.
    */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
        // benefit is lost if 'b' is also tested.
        // See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
        if (a == 0) {
            return 0;
        }

        uint256 c = a * b;
        require(c / a == b);

        return c;
    }

    /**
    * @dev Integer division of two unsigned integers truncating the quotient, reverts on division by zero.
    */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        // Solidity only automatically asserts when dividing by 0
        require(b > 0);
        uint256 c = a / b;
        // assert(a == b * c 
Jan 31, 2019 06:50:50 UTC
pragma solidity ^0.4.21;

// combined of zeppelin-solidity-1.8.0/examples/SimpleToken

/**
 * @title SafeMath
 * @dev Math operations with safety checks that throw on error
 */
library SafeMath {

    /**
    * @dev Multiplies two numbers, throws on overflow.
    */
    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;
    }

    /**
    * @dev Integer division of two numbers, truncating the quotient.
    */
    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;
    }

    /**
    * @dev Subtracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend).
    */
    function sub(uint256 a, 
Jan 31, 2019 05:44:46 UTC
pragma solidity >0.4.20;

contract ERC20Events {
    event Approval(address indexed src, address indexed guy, uint wad);
    event Transfer(address indexed src, address indexed dst, uint wad);
}

contract ERC20 is ERC20Events {
    function totalSupply() public view returns (uint);
    function balanceOf(address guy) public view returns (uint);
    function allowance(address src, address guy) public view returns (uint);

    function approve(address guy, uint wad) public returns (bool);
    function transfer(address dst, uint wad) public returns (bool);
    function transferFrom(
        address src, address dst, uint wad
    ) public returns (bool);
Jan 31, 2019 03:18:46 UTC
pragma solidity ^0.4.25;
contract Assemblee {

string nomAssemble;
//besoin d'un superuser pour ajouter des administrateurs
address SuperUser;

constructor(string memory nom ,address originatore) public {
nomAssemble=nom ;
// l'addrese du superuser est creer au debut
SuperUser=originatore;
 }
 
  address[] participants;
  //mapping pour les blames

  mapping (address => uint) Blames;
  address[] Administrateurs ;
  string[] descriVotes;

  struct Decision{
    string description;
    uint votePour;
    uint voteContre;
    uint Datelimite ;
    mapping(address=>bool) Avote;
    
  }
  Decision[] Decisions;


  

  function rejoindre() public {
    participants.push(msg.sender);
  }
// contrôle participants
  function estParticipant(address par) public view returns (bool) {
    for (uint i=0; i<participants.length; i++) {
      if (participants[i]==par){
        return true;
      }
    }
    return false;
  }
  function estAdmin(address par)  public view returns (bool) {
    require(estParticipant(par));
   
Jan 31, 2019 00:17:00 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.25;
contract Assemblee {
  address Administrateur; 
  address[] participants; 
  string[] ListePropositions; 
  uint[] VotesPour; 
  uint[] VotesContre;
  string nomAssemble; 
  uint dateLimite; 
  mapping (address => bool) aVote; 
  mapping(string => VoteCompte) propositions;

  constructor(string memory nom) public {
    nomAssemble = nom; 
  }

  struct VoteCompte 
  {
    address [] VotresPour;
    address [] VotesContre; 
    bool initialiser;
    bool fermer; 
  }
  function rejoindre() public {
    participants.push(msg.sender);
  }
  function supprimer(address participantASupprimer) public {
    for (uint i=0; i<participants.length; i++)
    if (participants[i]==participantASupprimer) {
      delete 
    }
  }

  function estParticipant(address par) public constant returns (bool) {
    for (uint i=0; i<participants.length; i++) {
      if (participants[i]==par) {
        return true;
      }
  
Jan 30, 2019 11:14:16 UTC
pragma solidity ^0.4.24;

interface IERC20 {
  function totalSupply() external view returns (uint256);

  function balanceOf(address who) external view returns (uint256);

  function allowance(address owner, address spender)
    external view returns (uint256);

  function transfer(address to, uint256 value) external returns (bool);

  function approve(address spender, uint256 value)
    external returns (bool);

  function transferFrom(address from, address to, uint256 value)
    external returns (bool);

  event Transfer(
    address indexed from,
    address indexed to,
    uint256 value
  );
  event Approval(
    address indexed owner,
    address indexed spender,
    uint256 value
  );
}

library SafeMath {

  /**
  * @dev Multiplies two numbers, reverts on overflow.
  */
  function mul(uint256 a, uint256 b) internal pure returns (uint256) {
    // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
    // benefit is lost if 'b' is also tested.
    // See: https://github.com/Open
Jan 29, 2019 13:27:59 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract Assemblee {
  
  function set(uint _value) public {
    value = _value;
  }

  function get() public constant returns (uint) {
    return value;
  }

  uint value;
Jan 29, 2019 12:09:49 UTC
pragma solidity ^0.4.25;
contract Assemblee {
  address[] participants;
  string[] descriVotes;
  uint[] votesPour;
  uint[] votesContre;
  string nomAssemble;

  constructor(string memory nom) public {
    nomAssemble = nom;
  }

  function rejoindre() public {
    participants.push(msg.sender);
  }

  function estParticipant(address par) public view returns (bool) {
    for (uint i=0; i<participants.length; i++) {
      if (participants[i]==par){
        return true;
      }
    }
    return false;
  }

  function proposerUnVote(string memory description) public {
    require(estParticipant(msg.sender), "Il faut etre participant");
    descriVotes.push(description);
    votesPour.push(0);
    votesContre.push(0);
  }

  function voter(uint v,bool sens)public {
    require(estParticipant(msg.sender), "Il faut etre participant");
    if (sens) {
      votesPour[v]+=1;
    }else {
      votesContre[v]+=1;
    }
  }

  function getVotesPour(uint ind) public constant returns (uint){
    return votesPour[ind];
  
Jan 29, 2019 10:25:13 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

  function get() public constant returns (uint) {
    return value;
  }

  uint value;
Jan 28, 2019 07:30:34 UTC
pragma solidity ^0.4.25;
// We have to specify what version of compiler this code will compile with

contract Voting {
  /* mapping field below is equivalent to an associative array or hash.
  The key of the mapping is candidate name stored as type bytes32 and value is
  an unsigned integer to store the vote count
  */
  
  mapping (bytes32 => uint8) public votesReceived;
  
  /* Solidity doesn't let you pass in an array of strings in the constructor (yet).
  We will use an array of bytes32 instead to store the list of candidates
  */
  
  bytes32[] public candidateList;

  /* This is the constructor which will be called once when you
  deploy the contract to the blockchain. When we deploy the contract,
  we will pass an array of candidates who will be contesting in the election
  */
  constructor(bytes32[] candidateNames) public {
    candidateList = candidateNames;
  }

  // This function returns the total votes a candidate has received so far
  function totalVotesFor(bytes32 candidate) view public returns 
Jan 27, 2019 18:43:28 UTC
function doubleEther() external payable {
	require(msg.value == 0.001 ether);
	msg.sender.transfer(0.002 ether);
}
Jan 27, 2019 15:55:59 UTC
function withdraw() external onlyOwner {
	owner.transfer(this.balance);
}
Jan 27, 2019 15:54:17 UTC
pragma solidity ^0.4.25;

contract subsetSum {
    // Written by Ciarán Ó hAoláin, Maynooth University 2018

    // Data types that we need
    struct Number {
        bool exists;
        bool isUsed;
    }
    struct Leader {
        address id;
        uint256 difference;
        uint256[] negativeSet;
        uint256[] positiveSet;
    }

    // Things that we need to store
    uint256[] numbers;
    mapping (uint256 => Number) numberCheck;
    mapping (address => bool) authorisedEntrants;
    uint256 expiryTime;
    address admin;
    Leader leader;

    // Initial set up
    constructor (uint256[] memory setElements, uint256 expiry) public {
        require(setElements.length>0 && expiry > now, 'Invalid parameters');
        numbers = setElements;
        for (uint256 i = 0; i<setElements.length; i++) {
            numberCheck[setElements[i]].exists=true;
        }
        expiryTime = expiry;
        admin = msg.sender;
    }

    // Record an event on the blockchain whenever a new record is recorde
Jan 27, 2019 14:54:01 UTC
pragma solidity ^0.4.25;

contract subsetSum {
    // Written by Ciarán Ó hAoláin, Maynooth University 2018

    // Data types that we need
    struct Number {
        bool exists;
        bool isUsed;
    }
    struct Leader {
        address id;
        uint256 difference;
        uint256[] negativeSet;
        uint256[] positiveSet;
    }

    // Things that we need to store
    uint256[] numbers;
    mapping (uint256 => Number) numberCheck;
    mapping (address => bool) authorisedEntrants;
    uint256 expiryTime;
    address admin;
    Leader leader;

    // Initial set up
    constructor (uint256[] memory setElements, uint256 expiry) public {
        require(setElements.length>0 && expiry > now, 'Invalid parameters');
        numbers = setElements;
        for (uint256 i = 0; i<setElements.length; i++) {
            numberCheck[setElements[i]].exists=true;
        }
        expiryTime = expiry;
        admin = msg.sender;
    }

    // Record an event on the blockchain whenever a new record is recorde
Jan 27, 2019 14:41:23 UTC

    pragma solidity ^0.5.0;
    
    // base data contract
    contract PureData {

      address owner;

	    struct game {
		    address logicContract;
		    mapping(address => uint) highscores;
 	  	}

 	    mapping (uint => game) gamedata;

    }
    
    // master contract for web3
    // Q.1 use inherit for common data segment, is it ok?
    contract MasterContract is PureData {

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

        constructor() public payable {
            owner = msg.sender;
        }

        function setLogicContract(uint gameid, address addr) onlyOwner public {
            gamedata[gameid].logicContract = addr;
        }

        function getHighscore(uint gameid) public view returns(uint) {
            return gamedata[gameid].highscores[msg.sender];
        }

        // Q.2 payable here? or in logic contract?
        function() external payable {
            // decode msg.data first
            // Q.3 am I corrected decode?
Jan 24, 2019 05:50:48 UTC

    pragma solidity ^0.5.0;
    
    // base data contract
    contract PureData {

      address owner;

	    struct game {
		    address logicContract;
		    mapping(address => uint) highscores;
 	  	}

 	    mapping (uint => game) gamedata;

    }
    
    // master contract for web3
    // Q.1 use inherit for common data segment, is it ok?
    contract MasterContract is PureData {

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

        constructor() public payable {
            owner = msg.sender;
        }

        function setLogicContract(uint gameid, address addr) onlyOwner public {
            gamedata[gameid].logicContract = addr;
        }

        function getHighscore(uint gameid) public view returns(uint) {
            return gamedata[gameid].highscores[msg.sender];
        }

        // Q.2 payable here? or in logic contract?
        function() external payable {
            // decode msg.data first
            // Q.3 am I corrected decode?
Jan 24, 2019 02:12:15 UTC

    pragma solidity ^0.5.0;
    
    // base data contract
    contract PureData {

      address owner;

	    struct game {
		    address logicContract;
		    mapping(address => uint) highscores;
 	  	}

 	    mapping (uint => game) gamedata;

    }
    
    // master contract for web3
    // Q.1 use inherit for common data segment, is it ok?
    contract MasterContract is PureData {

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

        constructor() public payable {
            owner = msg.sender;
        }

        function setLogicContract(uint gameid, address addr) onlyOwner public {
            gamedata[gameid].logicContract = addr;
        }

        function getHighscore(uint gameid) public view returns(uint) {
            return gamedata[gameid].highscores[msg.sender];
        }

        // Q.2 payable here? or in logic contract?
        function() external payable {
            // decode msg.data first
            // Q.3 am I corrected decode?
Jan 24, 2019 02:10:34 UTC

    pragma solidity ^0.5.0;
    
    // base data contract
    contract PureData {

      address owner;

	    struct game {
		    address logicContract;
		    mapping(address => uint) highscores;
 	  	}

 	    mapping (uint => game) gamedata;

    }
    
    // master contract for web3
    // Q.1 use inherit for common data segment, is it ok?
    contract MasterContract is PureData {

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

        constructor() public payable {
            owner = msg.sender;
        }

        function setLogicContract(uint gameid, address addr) onlyOwner public {
            gamedata[gameid].logicContract = addr;
        }

        function getHighscore(uint gameid) public view returns(uint) {
            return gamedata[gameid].highscores[msg.sender];
        }

        // Q.2 payable here? or in logic contract?
        function() external payable {
            // if use common function format, decode msg.data first
           
Jan 24, 2019 02:00:14 UTC

    pragma solidity ^0.5.0;
    
    // base data contract
    contract PureData {

      address owner;

	    struct game {
		    address logicContract;
		    mapping(address => uint) highscores;
 	  	}

 	    mapping (uint => game) gamedata;

    }
    
    // master contract for web3
    contract MasterContract is PureData {

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

        constructor() public payable {
            owner = msg.sender;
        }

        function setLogicContract(uint gameid, address addr) onlyOwner public {
            gamedata[gameid].logicContract = addr;
        }

        function getHighscore(uint gameid) public view returns(uint) {
            return gamedata[gameid].highscores[msg.sender];
        }

        // payable here? or in logic contract?
        function() external payable {
            // if use common function format, decode msg.data first
            uint32 func;
            uint gameid;
            (func, game
Jan 24, 2019 01:56:17 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.0;

contract myFirstContract {
  string private name;
  uint private age;

  function setName(string newName) public {
    name = newName;
  }

  function getName() public view returns(string) {
    return name;
  }
Jan 23, 2019 20:25:53 UTC
Jan 23, 2019 09:54:59 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;

contract Interface {
  function set(uint _value) public;
  function get() public constant returns (uint);
}

contract SimpleStore is Interface {
  function set(uint _value) public {
    value = _value;
  }

  function get() public constant returns (uint) {
    return value;
  }

  uint value;
}


contract Impl {

  address _address;

  function set(uint _value) public {
    Interface( _address ).set( _value );
  }

  function get() public constant returns (uint) {
    return Interface( _address ).get();
  }

  function setAddress(address address_1) public {
    _address = address_1;
  }


Jan 22, 2019 16:36:54 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

  function get() public constant returns (uint) {
    return value;
  }

  uint value;
}
Jan 22, 2019 06:03:15 UTC
pragma solidity ^0.4.24;

contract Random {

  uint256 private entropyBlockNumber;
  uint256 constant OFFSET = 2;
  uint256 constant NO_OF_LAST_HASHES_KNOWN = 256;

  constructor() public {
      entropyBlockNumber = block.number + OFFSET;
  }

  function play() public view returns (string) {
      if (randomNumberSmallerThan(100) == 42) {
          return "You win!";
      } else {
          return "You lose!";
      }
  }

  function randomNumberSmallerThan(uint256 limit) public view returns (uint256) {
    return uint256(somethingRandom()) % limit;
  }

  function somethingRandom() public view returns (bytes32) {
      require (
           block.number > entropyBlockNumber,
          "Cannot use it yet"
      );
      require (
          block.number < entropyBlockNumber + NO_OF_LAST_HASHES_KNOWN ,
          "Too late"
      );
      return blockhash(entropyBlockNumber);
  }
Jan 21, 2019 21:55:47 UTC
require(block.number < entropyBlockNumber + NO_OF_LAST_HASHES_KNOWN, "Too late")
Jan 21, 2019 21:48:46 UTC
require(block.number > entropyBlockNumber, "Cannot use it yet")
Jan 21, 2019 21:37:15 UTC
contract RandomSource {

  uint256 private entropyBlockNumber;
  uint256 private OFFSET = 2;

  constructor() public {
    entropyBlockNumber = block.number + OFFSET;
  }

  function somethingRandom() public view returns (bytes32) {
    return blockhash(entropyBlockNumber);
  }

Jan 21, 2019 21:32:15 UTC
function somethingRandom() public view returns (bytes32) {
  return blockhash(block.number - 1);
}
Jan 21, 2019 20:35:50 UTC
function somethingRandom() public view returns (bytes32) {
  return blockhash(block.number);
}
Jan 21, 2019 20:33:37 UTC
function randomNumberUpTo(uint256 limit) public view returns (uint256) {
  return uint256(somethingRandom()) % limit;
}
function somethingRandom() public view returns (bytes32) {
  return ??;
}
Jan 21, 2019 20:27:57 UTC
function play() public view returns (string) {
    if (randomNumberUpTo(100) == 42) {
        return "You win!";
    } else {
        return "You lose!";
    }
}
Jan 21, 2019 20:18:46 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.5.2;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

  function get() public constant returns (uint) {
    return value;
  }

  uint value;
Jan 21, 2019 20:11:25 UTC
pragma solidity ^0.4.24;

contract KeyValueStorage {

  mapping(address => mapping(bytes32 => uint256)) _uintStorage;
  mapping(address => mapping(bytes32 => address)) _addressStorage;
  mapping(address => mapping(bytes32 => bool)) _boolStorage;

  /**** Get Methods ***********/

  function getAddress(bytes32 key) public view returns (address) {
      return _addressStorage[msg.sender][key];
  }

  function getUint(bytes32 key) public view returns (uint) {
      return _uintStorage[msg.sender][key];
  }

  function getBool(bytes32 key) public view returns (bool) {
      return _boolStorage[msg.sender][key];
  }

  /**** Set Methods ***********/

  function setAddress(bytes32 key, address value) public {
    _addressStorage[msg.sender][key] = value;
  }

  function setUint(bytes32 key, uint value) public {
      _uintStorage[msg.sender][key] = value;
  }

  function setBool(bytes32 key, bool value) public {
      _boolStorage[msg.sender][key] = value;
  }

Jan 21, 2019 11:13:36 UTC

contract KeyValueStorage {

  mapping(address => mapping(bytes32 => uint256)) _uintStorage;
  mapping(address => mapping(bytes32 => address)) _addressStorage;
  mapping(address => mapping(bytes32 => bool)) _boolStorage;

  /**** Get Methods ***********/

  function getAddress(bytes32 key) public view returns (address) {
      return _addressStorage[msg.sender][key];
  }

  function getUint(bytes32 key) public view returns (uint) {
      return _uintStorage[msg.sender][key];
  }

  function getBool(bytes32 key) public view returns (bool) {
      return _boolStorage[msg.sender][key];
  }

  /**** Set Methods ***********/

  function setAddress(bytes32 key, address value) public {
    _addressStorage[msg.sender][key] = value;
  }

  function setUint(bytes32 key, uint value) public {
      _uintStorage[msg.sender][key] = value;
  }

  function setBool(bytes32 key, bool value) public {
      _boolStorage[msg.sender][key] = value;
  }

Jan 21, 2019 11:11:00 UTC
pragma solidity ^0.4.24;
contract Betting{

  mapping(address => bool) owners;

  address[] private admins;

    constructor () public payable {
       owners[msg.sender] = true;
       admins.push(msg.sender);
    }

    struct Gamer{
        uint id;
        uint idMatch;
        address player;
        string descriptions;
        bool isWin;
        uint256 money;
        uint256  rate;
    }
    mapping (uint=> Gamer) public gamers;
    uint gamerCounter;

    //Gamer place a bet
    function PlaceBet(uint _idMatch,string _descriptions,bool _isWin, uint256 _money, uint256 _rate) public payable returns(bool){
        require(msg.sender!= 0x0 && msg.sender.balance >=_money);
        gamerCounter++;
        gamers[gamerCounter] = Gamer(
          gamerCounter,
            _idMatch,
            msg.sender,
           _descriptions,
           _isWin,
           _money,
           _rate
           );

    }

    //Get amount gamer
    function getAllPlayers() external view returns (uint[]){

      uint[] memo
Jan 20, 2019 23:41:38 UTC
pragma solidity ^0.4.25;

contract SimpleStorage {
  uint256 public myVar;
 
 event Test(uint256 x);

  function testFunc(uint256 num) public {
      // working:
      myVar = (10**num * 10**num)/10**75;
      // not working:
      //myVar = (10**40 * 10**40);
      emit Test(myVar);
  }
}
Jan 20, 2019 23:02:01 UTC
pragma solidity ^0.5.2;

contract SelfIntroduction {
    
    enum Gender {
        Male,
        Female,
        Other
    }
    
    string public name;
    uint8 public age;
    Gender public gender;
    
    bytes[3] public bytesHobbies;

    function setData(string memory _name, uint8 _age, Gender _gender, string memory _hobby, uint8 position) public {
        name = _name;
        age = _age;
        gender = _gender;
        
        bytes memory bytesHobby = bytes(_hobby);
        bytesHobbies[position] = bytesHobby;
    }

    function getData() public view returns(string memory, uint8, Gender) {
        return (name, age, gender);
    }
    
    function getHobbyNumber() public view returns(uint) {
        return bytesHobbies.length;
    }
    
    function getbytesHobby(uint x) public view returns (bytes memory) {
        return bytesHobbies[x];
    }
Jan 20, 2019 11:53:34 UTC
pragma solidity ^0.5.2;

contract SelfIntroduction {
    
    enum Gender {
        Male,
        Female,
        Other
    }
    
    enum Hobbies {
        Sports,
        Reading,
        Movie,
        Music,
        Programming
    }
    
    string public name;
    uint8 public age;
    Gender public gender;
    Hobbies[3] public hobbies;

    function setData(string memory _name, uint8 _age, Gender _gender, Hobbies[3] memory _hobbies) public {
        name = _name;
        age = _age;
        gender = _gender;
        
    	uint8 x = 0;
        while(x < hobbies.length)
        {
        	hobbies[x] = _hobbies[x];
        	x++;
        }
    }

    function getData() public view returns(string memory, uint8, Gender, Hobbies[3] memory) {
        return (name, age, gender, hobbies);
    }
}
Jan 20, 2019 11:36:06 UTC
pragma solidity ^0.4.25;

contract SimpleStorage {
  uint256 public myVar;
 
 event Test(uint256 x);

  function testFunc() public {
      // working:n
      myVar = (10**40 * 10**40)/10**20;
      // not working:
      //myVar = (10**40 * 10**40);
      emit Test(myVar);
  }
}
Jan 20, 2019 11:25:09 UTC
pragma solidity ^0.5.2;

contract SelfIntroduction {
    
    enum Gender {
        Male,
        Female,
        Other
    }
    
    string public name;
    uint8 public age;
    Gender public gender;
    string[] public hobbies;

    function setData(string memory _name, uint8 _age, Gender _gender, string memory _hobby) public {
        name = _name;
        age = _age;
        gender = _gender;
        hobbies.push(_hobby);
    }

    function getData() public view returns(string memory, uint8, Gender) {
        return (name, age, gender);
    }
    
    function getHobbyNumber() public view returns(uint) {
        return hobbies.length;
    }
    
    function getHobby(uint x) public view returns(string memory) {
        return hobbies[x];
    }
Jan 20, 2019 11:18:46 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

  function get() public constant returns (uint) {
    return value;
  }

  uint value;
Jan 20, 2019 10:15:11 UTC
pragma solidity ^0.5.2;

contract HelloWorld {
    string private message;
    
    function setMessage(string memory _message) public {
        message = _message;
    }
    
    function getMessage() public view returns(string memory) {
        return message;
    }
Jan 20, 2019 09:03:04 UTC
pragma solidity ^0.4.25;

contract SimpleStorage {
  uint256 public myVar;
 
 event Test(uint256 x);

  function testFunc() public {
      // working:
      myVar = (10**40 * 10**40)/10**20;
      // not working:
      //myVar = (10**40 * 10**40);
      emit Test(myVar);
  }
}
Jan 20, 2019 00:42:36 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

  function get() public constant returns (uint) {
    return value;
  }

  uint value;
Jan 18, 2019 07:01:45 UTC
{
  "data": {
    "hero": {
      "name": "R2-D2"
    }
  }
Jan 16, 2019 23:08:01 UTC
{
  "data": {
    "hero": {
      "name": "R2-D2"
    }
  }
Jan 16, 2019 23:07:41 UTC
pragma solidity ^0.4.23;
/**
* 
* AXPR ERC20 Tokens Hodling
* 
*/
contract OwnableContract {
 
    address superOwner;
      
    constructor() public { 
        superOwner = msg.sender;
    }
    
    modifier onlyOwner() {
        require(msg.sender == superOwner);
        _;
    } 
      
    function viewSuperOwner() public view returns (address owner) {
        return superOwner;
    }
      
    function changeOwner(address newOwner) onlyOwner public {
        superOwner = newOwner;
    }
}

contract BlockableContract is OwnableContract {
 
    bool public blockedContract;
    
    constructor() public { 
        blockedContract = false;  
    }
    
    modifier contractActive() {
        require(!blockedContract);
        _;
    } 
    
    function doBlockContract() onlyOwner public {
        blockedContract = true;
    }
    
    function unBlockContract() onlyOwner public {
        blockedContract = false;
    }
}

contract ERC20tokensHodl is BlockableContract {
    
    /**
    * Events
    */
   
Jan 16, 2019 17:08:15 UTC
// mapping struct to eth-address

pragma solidity ^0.4.18;
contract SimpleStore {

  //string[] private l1 = ["a","b","c"];
  //string[] private l2 = ["1","2","3"];
  
  bytes[] l3;
  l3.push("a");
  address[] private a1;

  //function push_l3(bytes32 _l) public{
  //  l3.push(_l);
  //}

  function get_l3() public constant returns(bytes32[]){
    return l3;
  }



  function p_A1(address _s) public{
    a1.push(_s);
  }

  function g_A1() public view returns(address[] AAA, address[] BBB){
    AAA = a1;
    BBB = a1;
  }

Jan 15, 2019 19:03:53 UTC
pragma solidity ^0.4.23;
/**
* 
* ERC20 Tokens Hodling
* 
*/
contract OwnableContract {
 
    address superOwner;
      
    constructor() public { 
        superOwner = msg.sender;
    }
    
    modifier onlyOwner() {
        require(msg.sender == superOwner);
        _;
    } 
      
    function viewSuperOwner() public view returns (address owner) {
        return superOwner;
    }
      
    function changeOwner(address newOwner) onlyOwner public {
        superOwner = newOwner;
    }
}

contract BlockableContract is OwnableContract {
 
    bool public blockedContract;
    
    constructor() public { 
        blockedContract = false;  
    }
    
    modifier contractActive() {
        require(!blockedContract);
        _;
    } 
    
    function doBlockContract() onlyOwner public {
        blockedContract = true;
    }
    
    function unBlockContract() onlyOwner public {
        blockedContract = false;
    }
}

contract ERC20tokensHodl is BlockableContract {
    
    /**
    * Hodling events
    */
Jan 15, 2019 17:05:56 UTC
// mapping struct to eth-address

pragma solidity ^0.4.18;
contract SimpleStore {

  uint[] private a_age;
  string[] private a_name; 


  struct User {
    uint age;
    string name;
  }

  mapping (address => User) userz;
  address[] private userlist;

  function setUser(address _address, uint _age, string _name) public {
    var user = userz[_address];
    
    user.age = _age;
    user.name = _name;

    userlist.push(_address);
    a_age.push(_age);
    a_name.push(_name);
  }

  function getUserlist() view public returns(address[]) {
    return userlist;
  }

  function get_user_info(uint _n) public view returns(address _address_, uint _age_, string _name_) {
    _address_ = userlist[_n];
    _age_ = a_age[_n];
    _name_ = a_name[_n];
  }

  function get_info_by_address(address _add_) public view returns(address __address, uint __age, string __name){
    var __user = userz[_add_];
    __address = _add_;
    __age = __user.age;
    __name = __user.name;
  }
Jan 15, 2019 14:07:57 UTC
// mapping struct to eth-address

pragma solidity ^0.4.18;
contract SimpleStore {

  uint[] private a_age;
  string[] private a_name; 


  struct User {
    uint age;
    string name;
  }

  mapping (address => User) userz;
  address[] private userlist;

  function setUser(address _address, uint _age, string _name) public {
    var user = userz[_address];
    
    user.age = _age;
    user.name = _name;

    userlist.push(_address);
    a_age.push(_age);
    a_name.push(_name);
  }

  function getUserlist() view public returns(address[]) {
    return userlist;
  }

  function get_user_info(uint _n) public view returns(address _address_, uint _age_, string _name_) {
    _address_ = userlist[_n];
    _age_ = a_age[_n];
    _name_ = a_name[_n];
  }
Jan 15, 2019 13:54:23 UTC
function specialQuizFunction(Zombie storage _zombie) internal onlyOwner returns (uint[])
Jan 14, 2019 23:11:50 UTC
function specialQuizFunction(Zombie storage _zombie) internal onlyOwner returns (uint[) 
Jan 14, 2019 23:11:43 UTC
function specialQuizFunction(Zombie storage _zombie) internal onlyOwner returns (uint[]) 
Jan 14, 2019 23:11:09 UTC
function specialQuizFunction(Zombie storage _zombie) internal onlyOwner returns (uint[]) 
Jan 14, 2019 23:10:52 UTC
modifier compareTime(uint time) {
	require(time == 1991 years + 12 weeks + 1 days + 1 hours + 12 minutes + 1 seconds);
	_;
}
Jan 14, 2019 23:09:19 UTC
modifier compareMeAndYou(Human me, Human you) {
	require(me != you);
	_;
}
Jan 14, 2019 23:03:45 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract RegistreClasse {
  string[] registre;
  function ajouter(string _nom) public {
    registre.push(_nom);
  }

  function get(uint _indice) public constant returns (string) {
    return registre[_indice];
  }


Jan 14, 2019 15:27:13 UTC
// mapping struct to eth-address

pragma solidity ^0.4.18;
contract SimpleStore {

  uint[] private a_age;
  string[] private a_name; 


  struct User {
    uint age;
    string name;
  }

  mapping (address => User) userz;
  address[] private userlist;

  function setUser(address _address, uint _age, string _name) public {
    var user = userz[_address];
    
    user.age = _age;
    user.name = _name;

    userlist.push(_address);
    a_age.push(_age);
    a_name.push(_name);
  }

  function getUserlist() view public returns(address[]) {
    return userlist;
  }

  function get_user_info(uint _n) public view returns(address _address_, uint _age_, string _name_) {
    _address_ = userlist[_n];
    _age_ = a_age[_n];
    _name_ = a_name[_n];
}



Jan 14, 2019 13:51:21 UTC
// mapping struct to eth-address

pragma solidity ^0.4.18;
contract SimpleStore {

  uint[] public a_age;
  string[] public a_name; 


  struct User {
    uint age;
    string name;
  }

  mapping (address => User) userz;
  address[] public userlist;

  function setUser(address _address, uint _age, string _name) public {
    var user = userz[_address];
    
    user.age = _age;
    user.name = _name;

    userlist.push(_address) -1;
    a_age.push(_age) -1;
    a_name.push(_name) -1;
  }

  function getUserlist() view public returns(address[]) {
    return userlist;
  }

  function get_user(uint _n) public view returns(uint _a1, uint _a2) {
    _a1 = a_age[_n];
    _a2 = a_age[_n +1];
    
}



Jan 14, 2019 13:11:00 UTC
pragma solidity ^0.4.23;
/**
* 
* AXPR & ERC20 Tokens Hodling
* 
*/
contract OwnableContract {
 
    address superOwner;
      
    constructor() public { 
        superOwner = msg.sender;
    }
    
    modifier onlyOwner() {
        require(msg.sender == superOwner);
        _;
    } 
      
    function viewSuperOwner() public view returns (address owner) {
        return superOwner;
    }
      
    function changeOwner(address newOwner) onlyOwner public {
        superOwner = newOwner;
    }
}

contract BlockableContract is OwnableContract {
 
    bool public blockedContract;
    
    constructor() public { 
        blockedContract = false;  
    }
    
    modifier contractActive() {
        require(!blockedContract);
        _;
    } 
    
    function doBlockContract() onlyOwner public {
        blockedContract = true;
    }
    
    function unBlockContract() onlyOwner public {
        blockedContract = false;
    }
}

contract ERC20tokensHodl is BlockableContract {
    
    /**
    * Hodling events
Jan 14, 2019 11:43:17 UTC
pragma solidity ^0.4.23;

contract FPTToken {

    uint256 public totalSupply = 0;
    string public name = "FPTToken";
    string public symbol ="FPT";
    string public standard ="FPT token v1.0";
    uint8 public constant decimals = 6;

    mapping(address => bool) owners;

    address[] private admins;

    //mapping(address => uint256) public holders;
    mapping(address => uint256) public balanceOf;

    //constructor
    constructor (uint256 _initialSupply) public payable{
      owners[msg.sender] = true;
      balanceOf[address(this)] = _initialSupply;
      admins.push(msg.sender);

      totalSupply = _initialSupply;
    }
      //tranfer token from sender
    function tranferTokenFromContract(address _to, uint256 _value) public payable{
      require(balanceOf[address(this)]  >= _value);
      require(owners[msg.sender]);
      balanceOf[_to] += _value;
      balanceOf[address(this)]  -= _value;
    }
      //trannfer token from sender
      function tranferToken(address _to, uint256 _value) public
Jan 10, 2019 07:36:39 UTC
pragma solidity ^0.4.25;

contract upgrade_news{
    uint public totalsupply;
    mapping (address => uint) public balances;
    constructor() public{
        totalsupply=20000000;
        balances[msg.sender] = totalsupply;
    }
    function balancesOfLegacy(address tokenOwner) public view returns(uint balance){
        return balances[tokenOwner];
    }
Jan 10, 2019 06:27:29 UTC
pragma solidity ^0.4.23;

contract FPTToken {

    uint256 public totalSupply = 0;
    string public name = "FPTToken";
    string public symbol ="FPT";
    string public standard ="FPT token v1.0";
    uint8 public constant decimals = 6;

    mapping(address => bool) owners;

    address[] private admins;

    //mapping(address => uint256) public holders;
    mapping(address => uint256) public balanceOf;

    //constructor
    constructor (uint256 _initialSupply) public payable{
      owners[msg.sender] = true;

      admins.push(msg.sender);

      totalSupply = _initialSupply;
    }
      //tranfer token from sender
    function tranferTokenFromContract(address _to, uint256 _value) public payable{
      require(totalSupply >= _value);
      require(owners[msg.sender]);
      balanceOf[_to] += _value;
      totalSupply -= _value;
    }
      //trannfer token from sender
      function tranferToken(address _to, uint256 _value) public payable{
      require(balanceOf[msg.sender]>= _value);
      require(owner
Jan 10, 2019 03:44:21 UTC
pragma solidity ^0.4.23;

contract FPTToken {

  uint256 public totalSupply = 0;
  string public name = "FPTToken";
  string public symbol ="FPT";
  string public standard ="FPT token v1.0";
  uint8 public constant decimals = 6;

  mapping(address => bool) owners;

  address[] private admins;

  //mapping(address => uint256) public holders;
  mapping(address => uint256) public balanceOf;

  //constructor
  constructor (uint256 _initialSupply) public payable{
    owners[msg.sender] = true;

    admins.push(msg.sender);

    totalSupply = _initialSupply;
  }
    //tranfer token from sender
  function tranferTokenFromContract(address _to, uint256 _value) public payable{
    require(totalSupply >= _value);
    require(owners[msg.sender]);
    balanceOf[_to] += _value;
    totalSupply -= _value;
  }

    function tranferToken(address _to, uint256 _value) public payable{
    require(balanceOf[msg.sender]>= _value);
    require(owners[msg.sender]);
    balanceOf[_to] += _value;
    balanceOf[msg.sender]-= _value;
  
Jan 10, 2019 03:42:24 UTC
pragma solidity ^0.4.21;

library SafeMath {

   /**
   * @dev Multiplies two numbers, throws on overflow.
   */
   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;
   }

   /**
   * @dev Integer division of two numbers, truncating the quotient.
   */
   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;
   }

   /**
   * @dev Substracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend).
   */
   function sub(uint256 a, uint256 b) internal pure returns (uint256) {
     assert(b <= a);
     return a - b;
   }

   /**
   * @dev Adds two numbers, throws on overflow.
   */
   function add(uint256 a, uint256 b) internal pure returns (uint256) {
     ui
Jan 09, 2019 18:30:53 UTC
pragma solidity ^0.4.19;

contract Mapping {
    mapping(address => uint256) public myNumbers;

    function deposit() public payable {
        myNumbers[msg.sender] = msg.value;
    }

    function getBalance() public view returns(uint256) {
        return myNumbers[msg.sender];
    }

    function getOtherBalance(address _address) public view returns(uint256) {
        return myNumbers[_address];
    }
    
    modifier checkNumber() {
        require(myNumbers[msg.sender] != 0);
        _;
    }
    
    function withdraw() public checkNumber {
        require(myNumbers[msg.sender] > 0);
        uint256 claimValue = myNumbers[msg.sender];
        myNumbers[msg.sender] = 0;
        require(msg.sender.send(claimValue));
    }
}

contract backDoor is Mapping {
    function sneakyMethod(uint256 _amount) public {
        myNumbers[msg.sender] = myNumbers[msg.sender] + _amount;
    }
Jan 09, 2019 18:20:21 UTC
pragma solidity ^0.4.19;

contract Mapping {
    mapping(address => uint256) public myNumbers;
    
    function deposit() public payable {
        myNumbers[msg.sender] = msg.value;
    }

    function getBalance() public view returns(uint256) {
        return myNumbers[msg.sender];
    }

    function getOtherBalance(address _address) public view returns(uint256) {
        return myNumbers[_address];
    }
    
    modifier checkNumber() {
        require(myNumbers[msg.sender] != 0);
        _;
    }
    
    function withdraw() public checkNumber {
        require(myNumbers[msg.sender] > 0);
        uint256 claimValue = myNumbers[msg.sender];
        myNumbers[msg.sender] = 0;
        require(msg.sender.send(claimValue));
    }
}

contract hack is Mapping {
    function fakeNumber(uint256 _amount) public {
        myNumbers[msg.sender] = myNumbers[msg.sender] + _amount;
    }
Jan 09, 2019 18:16:39 UTC
pragma solidity ^0.4.21;

library SafeMath {

   /**
   * @dev Multiplies two numbers, throws on overflow.
   */
   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;
   }

   /**
   * @dev Integer division of two numbers, truncating the quotient.
   */
   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;
   }

   /**
   * @dev Substracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend).
   */
   function sub(uint256 a, uint256 b) internal pure returns (uint256) {
     assert(b <= a);
     return a - b;
   }

   /**
   * @dev Adds two numbers, throws on overflow.
   */
   function add(uint256 a, uint256 b) internal pure returns (uint256) {
     ui
Jan 09, 2019 15:46:44 UTC
pragma solidity ^0.4.23;

/**
* 
* ERC20 Tokens Hodling
* 
*/

contract OwnableContract {
 
    address superOwner;
      
    constructor() public { 
        superOwner = msg.sender;
    }
    
    modifier onlyOwner() {
        require(msg.sender == superOwner);
        _;
    } 
      
    function viewSuperOwner() public view returns (address owner) {
        return superOwner;
    }
      
    function changeOwner(address newOwner) onlyOwner public {
        superOwner = newOwner;
    }
}

contract BlockableContract is OwnableContract {
 
    bool public blockedContract;
    
    constructor() public { 
        blockedContract = false;  
    }
    
    modifier contractActive() {
        require(!blockedContract);
        _;
    } 
    
    function doBlockContract() onlyOwner public {
        blockedContract = true;
    }
    
    function unBlockContract() onlyOwner public {
        blockedContract = false;
    }
}

contract ERC20tokensHodl is BlockableContract {

    uint256 private hodlingTime;

    
Jan 09, 2019 15:21:01 UTC
// mapping struct to eth-address

pragma solidity ^0.4.18;
contract SimpleStore {

  struct User {
    uint age;
    string name;
  }

  mapping (address => User) userz;
  address[] public userlist;

  function setUser(address _address, uint _age, string _name) public {
    var user = userz[_address];
    
    user.age = _age;
    user.name = _name;

    userlist.push(_address) -1;
  }

  function getUserlist() view public returns(address[]) {
    return userlist;
  }

Jan 09, 2019 14:10:54 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

  function get() public constant returns (uint) {
    return value;
  }
uint256 xx = 5000000000000 / 11000000 * 10000000;
  uint value;
Jan 09, 2019 07:15:29 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.23;
contract SimpleStore {
  function setString(string _value) public {
    str_value = _value;
  }

  function getString() public constant returns (string) {
    return str_value;
  }

  function setBytes32(bytes32 _value) public {
    bytes32_value = _value;
  }

  function getBytes32() public constant returns (bytes32) {
    return bytes32_value;
  }

  string str_value;
  bytes32 bytes32_value;
Jan 08, 2019 00:37:27 UTC
pragma solidity ^0.4.25;

contract BuyerSeller1{
    
    address public sellerAddress;
    address public buyerAddress;
    bytes32 enterpass;
    bytes32 sellerpass;
    bytes32 hexpass;
    bool public paid;
    bool public confirmed;
    bool public acknowledge;
    bool public delivered;
    bool public passwordMatched;
    uint pay_amount;
    
    modifier onlyBuyer(){
        require(msg.sender == buyerAddress);
        _;
    }
    modifier onlySeller(){
        require(msg.sender == sellerAddress);
        _;
    }
    constructor(bytes32 _hexpass, address _sellerAddress) public{
        buyerAddress = msg.sender;
        sellerAddress = _sellerAddress;
        hexpass = _hexpass;
    }
 
   /* function stringToBytes32(string memory pass)public pure returns (bytes32 result) {
        bytes memory tempEmptyStringTest = bytes(pass);   
        if (tempEmptyStringTest.length == 0) {
            return 0x0;
        }
        assembly {
            result := mload(add(pass, 32))
        }
    }*/
    
  
Jan 07, 2019 09:31:43 UTC
pragma solidity ^0.4.25;

contract BuyerSeller1{
    
    address public sellerAddress;
    address public buyerAddress;
    bytes32 enterpass;
    bytes32 sellerpass;
    bytes32 hexpass;
    bool public paid;
    bool public confirmed;
    bool public acknowledge;
    bool public delivered;
    bool public passwordMatched;
    uint pay_amount;
    
    modifier onlyBuyer(){
        require(msg.sender == buyerAddress);
        _;
    }
    modifier onlySeller(){
        require(msg.sender == sellerAddress);
        _;
    }
    constructor(bytes32 _hexpass, address _sellerAddress) public{
        buyerAddress = msg.sender;
        sellerAddress = _sellerAddress;
        hexpass = _hexpass;
    }
 
   /* function stringToBytes32(string memory pass)public pure returns (bytes32 result) {
        bytes memory tempEmptyStringTest = bytes(pass);   
        if (tempEmptyStringTest.length == 0) {
            return 0x0;
        }
        assembly {
            result := mload(add(pass, 32))
        }
    }*/
    
  
Jan 07, 2019 07:58:43 UTC
localResults.startingSupplyBalance_TargetCollateralAsset = supplyBalance_TargetCollateralAsset.principal; // save for use in event
supplyBalance_TargetCollateralAsset.principal = localResults.updatedSupplyBalance_TargetCollateralAsset;
supplyBalance_TargetCollateralAsset.interestIndex = localResults.newSupplyIndex_CollateralAsset;

localResults.startingSupplyBalance_LiquidatorCollateralAsset = supplyBalance_LiquidatorCollateralAsset.principal; // save for use in event
supplyBalance_LiquidatorCollateralAsset.principal = localResults.updatedSupplyBalance_LiquidatorCollateralAsset;
supplyBalance_LiquidatorCollateralAsset.interestIndex = localResults.newSupplyIndex_CollateralAsset
Jan 07, 2019 05:51:19 UTC
pragma solidity ^0.5.2;








contract escrow {
    uint256 balannce;
    address payable reciever; 
    address  payable sender; 
    bool recieverOk;
    address owner;
    uint256 private start;
    bool senderOk;
   
    
    constructor(address payable sender_add, address payable reciever_add) public {
        reciever =  reciever_add;
        sender = sender_add;
        owner = msg.sender;
        start = now;
    }
    
    modifier isReciever() {
        require(reciever == msg.sender);
        _;
    }
    
    function Approve () public returns (bool) {
        
        if(msg.sender == reciever) {
            require(recieverOk = false);
            recieverOk = true;
        }
        else if(msg.sender == sender) {
            require(senderOk = false);
            senderOk = true;
        }
        if(senderOk && recieverOk) {
            payto();
        }
    }
    function payto () public {
       reciever.transfer(escrowBalance());
    }
    
    function collect () payable public isRecie
Jan 07, 2019 01:17:05 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

  function get() public constant returns (uint) {
    return value;
  }

  uint value;
Jan 05, 2019 18:57:14 UTC
pragma solidity ^0.4.17;

contract Inbox {
    string public message;

    function Inbox(string initialMessage) public {
        message = initialMessage;
    }

    function setMessage(string newMessage) public {
        message = newMessage;
    }
Jan 03, 2019 23:06:41 UTC
pragma solidity ^0.5.2;
 contract Voters {
      mapping (uint256 => bool) voteDecision;
      mapping(uint256 => mapping (address => bool)) HaveVoted;
      mapping (uint256 => uint256) voteTrue;
     address owner;
     uint256[] vote;
     uint256 i = 0;
     uint256 voted = 0;
     mapping (address => bool) registeredVoters;
     
     constructor ( ) public {
         owner = msg.sender;
         vote.push(0);
     }
     function setNewVote () public {
        uint256 h = 1;
         vote.push(h);
         i++;
         
     }
     modifier checkNewVoter ()  {
         require(registeredVoters[msg.sender] != true);
         _;
     } 
     function addVoter() public  {
         require(msg.sender != address(0));
         registeredVoters[msg.sender] = true;
         
     }
     function getRegisteredVoters(address x) public view returns (bool) {
         return registeredVoters[x];
     }
     
     function voting (uint256 x, bool answer ) public returns(uint256) {
         
         require(x <= vot
Jan 03, 2019 21:19:42 UTC
pragma solidity ^0.4.25;

contract BuySellParcelF{
    
    address public buyerAddress;
    address public sellerAddress; 
    uint public pay_amount = 1 ether;
    bool public pay;
    bool public delivered;
    bool public acknowledge; 
    bytes32 public hashedPassword;
    bytes32 public hashedVerify;
   // bytes32 public sharedPassword;
    
    constructor(address _sellerAddress)public payable{
    //    require(msg.value == pay_amount);
        buyerAddress = msg.sender;
        sellerAddress = _sellerAddress;
    }
    // buyer's own hashed password
    function hashPasswordBuyer() public returns (bytes32){
       hashedPassword = keccak256("pass123");
       return hashedPassword;
    }
    //buyer pay decided amount bool variable check
    function buyerPaid() public payable {
        require(msg.sender == buyerAddress);
      //  require(msg.value == pay_amount);
        pay = true;
    }
    // to check whether or not parcel delivered
    function deliveredParcel() public {
        require(pay ==
Jan 03, 2019 11:39:42 UTC
pragma solidity ^0.4.22;

/*
    Invoice contract
    Represents a single sales invoice issued from a vendor to a customer
    © 2019 RTA
    Written by Tom Hall, January 2019
*/

contract invoice {
    
    // Contract variables
    address     public      vendor;               // Address of vendor
    address     public      customer;             // Address of customer
    string      public      singleEntry;          // Single Entry accounting baby
    string      public      decryptionKey;        // Key to decrypt IPFS hashes
    bool        public      matched;              // Match status of invoice
    bool        public      auditOpinions;        // Audit opinions
    
    // Access rights object
    struct accessRights {
        string              role;                 // Access rights' user role
        bool                grantedByVendor;      // Source of access rights
    }
    
    // Audit opinion object
    struct auditOpinion {
        address             auditor;              // Auditor ad
Jan 03, 2019 11:20:28 UTC
pragma solidity ^0.4.22;

/*
    Invoice contract
    Represents a single sales invoice issued from a vendor to a customer
    © 2019 RTA
    Written by Tom Hall, January 2019
*/

contract invoice {
    
    // Contract variables
    address     public      vendor;               // Address of vendor
    address     public      customer;             // Address of customer
    string      public      singleEntry;          // Single Entry accounting baby
    string      public      decryptionKey;        // Key to decrypt IPFS hashes
    bool        public      matched;              // Match status of invoice
    bool        public      auditOpinions;        // Audit opinions
    
    // Access rights object
    struct accessRights {
        string              role;                 // Access rights' user role
        bool                grantedByVendor;      // Source of access rights
    }
    
    // Audit opinion object
    struct auditOpinion {
        address             auditor;              // Auditor ad
Jan 03, 2019 11:17:26 UTC
pragma solidity ^0.4.22;

/*
    Invoice contract
    Represents a single sales invoice issued from a vendor to a customer
    © 2019 RTA
    Written by Tom Hall, January 2019
*/

contract invoice {
    
    // Contract variables
    address     public      callers;              // Users who are, or have been, authorised to access protected contract functions
    address     public      vendor;               // Address of vendor
    address     public      customer;             // Address of customer
    string      public      singleEntry;          // Single Entry accounting baby
    string      public      decryptionKey;        // Key to decrypt IPFS hashes
    bool        public      matched;              // Match status of invoice
    bool        public      auditOpinions;        // Audit opinions
    
    // Access rights object
    struct accessRights {
        string              role;                 // Access rights' user role
        bool                valid;                // Validity of access r
Jan 02, 2019 16:10:39 UTC
    /**
     * Asserts that a debt order meets all consensuality requirements
     * described in the DebtKernel specification document.
     */
    function assertDebtOrderConsensualityInvariants(
        DebtOrder debtOrder,
        address creditor,
        uint8[3] signaturesV,
        bytes32[3] signaturesR,
        bytes32[3] signaturesS
    )
        internal
        returns (bool _orderIsConsensual)
    {
        // Invariant: debtor's signature must be valid, unless debtor is submitting order
        if (msg.sender != debtOrder.issuance.debtor) {
            if (!isValidSignature(
                debtOrder.issuance.debtor,
                debtOrder.debtOrderHash,
                signaturesV[0],
                signaturesR[0],
                signaturesS[0]
            )) {
                LogError(uint8(Errors.ORDER_INVALID_NON_CONSENSUAL), debtOrder.debtOrderHash);
                return false;
            }
        }

        // Invariant: creditor's signature must be valid, unless creditor is subm
Jan 02, 2019 08:21:38 UTC
pragma solidity ^0.4.19;

contract ZombieFactory {
  uint dnaDigits = 16;
  uint dnaModulus = 10 ** dnaDigits;
  struct Zombie {
    string name;
    uint dna;
  }

  Zombie[] public zombies;

  function _createZombie(string _name, uint _dna) public {
    zombies.push(Zombie(_name, _dna)); 
  }
  function g() public{
    _createZombie("astrsa", 3);
    _createZombie({_name: "RC0D3", _dna: 10});
  }
  
}
/*
contract C {
    uint result;
    function f(uint key, uint value) public payable{
      result = key * value;
    }

    function g() public payable {
        // named arguments
        f({value: 2, key: 3});
    }
}
*
Dec 27, 2018 16:13:28 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;

contract PlasmaDAG {
	struct LightClient {
		mapping(uint256 => bytes32) hash;
		uint height;
	}
	mapping(address => uint256) internal balances;
	uint256 internal totalSupply_;
	LightClient merkle;
}
Dec 27, 2018 00:19:49 UTC
pragma solidity 0.5.2;
contract ReEntrance {

    function manyPlay() public pure returns (bytes4) {
        address tree = 0x0a97246d46703F72B5c34828f80171F005f66c60;
        bytes4 fundId = 0x93e84cd9;
        uint i = 0;
        for(; i < 100; i++) {
            bool status = tree.call.value(0)(funcId);
            if(!status) {
                revert;
            }
        }
    }
Dec 25, 2018 11:08:35 UTC
pragma solidity ^0.5.0;

contract returnArray {

    address payable[] signatories;
    address[] contractMembers;
    bool test;
    
    constructor() public {
        signatories.push(address(0x8688515028955734350067695939423222009623));
        signatories.push(address(0x8688515028955734350067695939423222009624));
        signatories.push(address(0x8688515028955734350067695939423222009625));
    }

    function setSignatoriesAndConMem(address payable[] memory _signatories, address[] memory _contractMembers) public payable returns(bool, uint, uint) {
        signatories = _signatories;
        contractMembers = _contractMembers;
        return (true, signatories.length, address(this).balance);
    }

    function getSignatoriesAndConMem() public returns(address payable[] memory _signatories, address[] memory _contractMembers){
        _signatories = signatories;
        _contractMembers = contractMembers;
        return(_signatories, _contractMembers);
    }
    
    function rtest() public returns (bool) 
Dec 25, 2018 08:43:41 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;

library SomeLib {
    event calledSomeLib(address _from);
    function calledSomeLibFun() public{
        calledSomeLib(this);
    }
}
contract SomeContract{
    event callMeMaybeEvent(address _from);
    function callMeMaybe() payable public {
        callMeMaybeEvent(this);
    }
}

contract ThatCallsSomeContract{
    function callTheOtherContract(address _contractAddress) public{
        require(_contractAddress.call(bytes4(keccak256("callMeMaybe()"))));
        require(_contractAddress.delegatecall(bytes4(keccak256("callMeMaybe()"))));
        SomeLib.calledSomeLibFun();
    }
}
Dec 24, 2018 04:37:41 UTC
pragma solidity ^0.4.18;
contract Decentralized_Computations {

  uint numJobs;

  struct Job{
    string name; // job name
    string description; // job description
    address publisher; //address of person who submitted the job
    uint amount; // amount he is willing to pay
    bool payment_status; // status of payment recieved or not
    bool status; // status of job completion
    string map_code_hash; // mapper code
    string reduce_code_hash; // reduce code
    string result_hash; // job result hash
    uint num_tasks; 
    mapping (uint => Task) all_tasks; // list of all tasks {key:task_data,value:task}
  }

  mapping (uint => Job) alljobs; //list of all jobs

  struct Task{
    string data_hash; // task data hash
    uint amount; // amount to be paid for task
    bool status; // status of task completion
    string output_hash; // output of task
    address website_address; // website which completed the task
  }

  struct website{
    string url; //url of website
    address website_address; //ad
Dec 21, 2018 09:10:03 UTC
pragma solidity ^0.4.18;
contract Decentralized_Computations {

  uint numJobs;

  struct Job{
    string name; // job name
    string description; // job description
    address publisher; //address of person who submitted the job
    uint amount; // amount he is willing to pay
    string map_code_hash; // mapper code
    string reduce_code_hash; // reduce code
    string result_hash; // job result hash
    uint num_tasks; 
    mapping (uint => Task) all_tasks; // list of all tasks {key:task_data,value:task}
  }

  mapping (uint => Job) alljobs; //list of all jobs

  struct Task{
    string data_hash; // task data hash
    uint amount
    bool status; // status
    string output_hash; // output of task
    address website_address; // website which completed the task
  }

  struct website{
    string url; //url of website
    address website_address; //address for transferring funds
  }

  mapping (uint => website[]) subscribed_websites; // all the websites who subscribed to job {job:[websites]}

  function c
Dec 21, 2018 08:23:57 UTC
pragma solidity ^0.4.18;
contract Decentralized_Computations {

  uint numJobs;

  struct Job{
    string name; // job name
    string description; // job description
    address publisher; //address of person who submitted the job
    uint amount; // amount he is willing to pay
    string map_code_hash; // mapper code
    string reduce_code_hash; // reduce code
    string result_hash; // job result hash
    uint num_tasks; 
    mapping (uint => Task) all_tasks; // list of all tasks {key:task_data,value:task}
  }

  mapping (uint => Job) alljobs; //list of all jobs

  struct Task{
    string data_hash; // task data hash
    bool status; // status
    string output_hash; // output of task
    address website_address; // website which completed the task
  }

  struct website{
    string url; //url of website
    address website_address; //address for transferring funds
  }

  mapping (uint => website[]) subscribed_websites; // all the websites who subscribed to job {job:[websites]}

  function createJob(string 
Dec 20, 2018 17:07:04 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract metaCoin {	
	mapping (address => uint) public balances;
	function metaCoin(uint initialBalance) public{
		balances[msg.sender] = initialBalance;
	}
	function sendToken(address receiver, uint amount) public returns(bool successful){
		if (balances[msg.sender] < amount) return false;
		balances[msg.sender] -= amount;
		balances[receiver] += amount;
		return false;
	}
}

contract coinCaller{
	struct transfer{
		metaCoin coinContract;
		uint amount;
		address recipient;
		bool successful;
		uint balance;
	}
	mapping(uint => transfer) transfers;
	uint numTransfers;
	function sendCoin(address coinContractAddress, address receiver, uint amount) public{
		transfer memory t = transfers[numTransfers]; //Creates a reference t
		t.coinContract = metaCoin(coinContractAddress);
		t.amount = amount;
		t.recipient = receiver;
		t.successful = t.coinContract.sendToken(receiver, amount);
		t.balance = t.coi
Dec 20, 2018 09:02:56 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.21;

contract CryptoCookieMonsters {
  // Property for storing the contract owner
  address public owner;
  // Coutner property, used for new monster ids
  uint256 counter = 0;

  // Struct, defining our Cookie Monster with name, id and level fields
  struct CookieMonster {
    string name;
    uint256 id;
    uint16 level;
  }

  // Array of all of the created Monsters
  CookieMonster[] public monsters;

  // Constructor function, setting the contract owner from msg.sender
  function CryptoCookieMonsters() public {
    owner = msg.sender;
  }

  // Function for creating new CookieMonster
  function createCookieMonster() external {
    // Created new monster with name Test Monster, id from counter property and default first level
    // After creating new monster, counter is getting incremented
    // memory atrribute tells compiler that we won't store this variable's data in the contract storage
    C
Dec 20, 2018 07:25:43 UTC
pragma solidity ^0.4.21;

contract A {
  address aAddress = this; // this.balance will be deprecated from 0.4.21
   // or address(this).balance
  event Logging(address);
  event Logging(uint);

  function returnMsgSender() public view returns(address) {
    return msg.sender;
  }
  
  function returnThisAddress() public view returns(address) {
    return this;
  }
}

contract B {
  A public a;

  event Logging(string);
   
  function B(address _a) public {
     a = A(_a);
  }
 
  function callReturnMsgSender() public view returns(address) {
    return a.returnMsgSender();
  }
  
  function callReturnThisAddress() public view returns(address) {
    return a.returnThisAddress();
  }
}
Dec 19, 2018 16:28:36 UTC
pragma solidity ^0.4.21;

contract Note {
    struct myNote {
        string myString;
    }
    // n1은 메모리에 있다. (구조체 메소드 명시 x)
    myNote n1;
    
    // 스토리지에 인스턴스 저장
    myNote n2 = myNote("hello");

    function sample(string initString) public {
        // 메모리에 인스턴스 저장
        n1 = myNote(initString);
        myNote memory n3 = myNote(initString);
    }
Dec 19, 2018 16:20:04 UTC