pragma solidity ^0.5.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP. Does not include
 * the optional functions; to access them see `ERC20Detailed`.
 */
interface IERC20 {
    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the amount of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves `amount` tokens from the caller's account to `recipient`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a `Transfer` event.
     */
    function transfer(address recipient, uint256 amount) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through `transferFrom`. This is
     * zero by default.
     *
     * This value changes when `approve` or `transferFrom` 
Nov 17, 2019 22:35:35 UTC
pragma solidity ^0.5.1;
contract Timesheet {

    address employee;
    address boss;
    
    mapping(uint  => uint) times; // day (starting 1.1.1970) -> hours worked
    mapping(uint  => bool) approvals; // day (starting 1.1.1970) -> is approved


    constructor(address _employee, address _boss) public {
        employee = _employee;
        boss = _boss;
    }

    function approveWork(uint _day) public {
        // only accept approval from boss:
        if (msg.sender != boss) {
           return;
        }
        approvals[_day] = true;
    }

    function logWork(uint _day, uint _hours) public {
        // only accept work logged by employee:
        if (msg.sender != employee) { 
            return;
        }
        // only accept work logged if day not yet approved:
        if (approvals[_day] == true) {
            return;
        }
        times[_day] = _hours;
        emit WorkLogged(_day, _hours);
    }

    function getHoursWorked(uint _day) public view returns (uint hoursWorked) {
        ho
Nov 14, 2019 16:38:38 UTC
pragma solidity ^0.5.1 <0.6.0;
import "remix_tests.sol"; // this import is automatically injected by Remix.
import "./timesheet.sol";

contract TimesheetTest {
    
    function testNoTimeUpdateAfterApproval() public {
        address employee = address(this);
        address boss = address(this);
        Timesheet timesheet = new Timesheet(employee, boss);
        
        uint _day = 1;
        timesheet.logWork(_day, 8);
        timesheet.approveWork(_day);
        timesheet.logWork(_day, 10);
        
        Assert.equal(timesheet.getHoursWorked(_day), uint(8), "hours worked should still be 8!");
        
    }
    
    function testApprovalByBossOnly() public {
        address employee = address(this);
        address boss = 0x33eC1E7D89F78D4268747FBe99e9A484B5Cb1e47;
        Timesheet timesheet = new Timesheet(employee, boss);
        
        uint _day = 1;
        timesheet.logWork(_day, 8);
        timesheet.approveWork(_day);
        timesheet.logWork(_day, 10);
        
        Assert.equal(timesh
Nov 14, 2019 16:12:15 UTC
pragma solidity ^0.5.1;
contract Timesheet {

    address employee;
    
    mapping(uint  => uint) times; // day (starting 1.1.1970) -> hours worked
    
    // Event (=logging) for logged work
    event WorkLogged(uint _day, uint _hours);

    constructor(address _employee, address _boss) public {
        employee = _employee;
    }

    function approveWork(uint _day) public {
        // TODO
    }

    function logWork(uint _day, uint _hours) public {
        // only accept work logged by employee:
        if (msg.sender != employee) { 
            return;
        }
        times[_day] = _hours;
        emit WorkLogged(_day, _hours);
    }

    function getHoursWorked(uint _day) public view returns (uint hoursWorked) {
        hoursWorked = times[_day];
    }
Nov 14, 2019 16:00:29 UTC
pragma solidity ^0.5.2;
contract Timesheet {

    address employee;
    
    mapping(uint  => uint) times; // day (starting 1.1.1970) -> hours worked
    
    // Event (=logging) for logged work
    event WorkLogged(uint _day, uint _hours);

    constructor(address _employee, address _boss) public {
        employee = _employee;
    }

    function approveWork(uint _day) public {
        // TODO
    }

    function logWork(uint _day, uint _hours) public {
        // only accept work logged by employee:
        if (msg.sender != employee) { 
            return;
        }
        times[_day] = _hours;
        emit WorkLogged(_day, _hours);
    }

    function getHoursWorked(uint _day) public view returns (uint hoursWorked) {
        hoursWorked = times[_day];
    }
Nov 14, 2019 15:56:59 UTC
pragma solidity ^0.5.1;
contract Timesheet {

    address employee;
    
    mapping(uint  => uint) times; // day (starting 1.1.1970) -> hours worked

    constructor(address _employee) public {
        employee = _employee;
    }

    function logWork(uint _day, uint _hours) public {
        // only accept work logged by employee:
        if (msg.sender != employee) { 
            return;
        }
        times[_day] = _hours;
        emit WorkLogged(_day, _hours); // logging
    }

    function getHoursWorked(uint _day) public view returns (uint hoursWorked) {
        hoursWorked = times[_day];
    }
        
    // Event (=logging) for logged work
    event WorkLogged(uint _day, uint _hours);
Nov 14, 2019 15:47:31 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;
Nov 12, 2019 11:18:25 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;
Nov 07, 2019 05:49:35 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.

  pragma solidity >=0.4.24 <0.6.0;

contract OrganisationName {

    struct Organisation {
        string CompanyName;
        string ID;
        string University;
        string location;
    }

    address company;

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

    modifier onlyname() {
        if (msg.sender == company) {
            _;
        }
    }

    Organisation[] public invokeCompany;

    function registerCompnay(
        string memory _CompanyName,
        string memory _ID,
        string memory _University,
        string memory _location) public onlyname {
        invokeCompany.push(Organisation(_CompanyName, _ID, _University, _location));
    }

}
Nov 04, 2019 19:48:52 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;
Nov 04, 2019 12:05:40 UTC
function guess (uint256 _key) public {
        bytes32 time1 = bytes32(block.timestamp);
        bytes32 entropy1 = keccak256(abi.encodePacked(time1));
        
        bytes32 time2 = bytes32(block.timestamp);
        bytes32 entropy2 = keccak256(abi.encodePacked(time2));
        
        bytes32 target = ((entropy1 ^ entropy2) & keccak256(abi.encodePacked(block.number))) & sault;
        complete = (target == bytes32(_key));
Nov 01, 2019 11:21:32 UTC
pragma solidity ^0.4.22;

contract Purchase {
    uint public value;
    address public seller;
    address public buyer;
    enum State { Created, Locked, Inactive }
    State public state;

    //确保 `msg.value` 是一个偶数。
    //如果它是一个奇数,则它将被截断。
    //通过乘法检查它不是奇数。
    constructor() public payable {
        seller = msg.sender;
        value = msg.value / 2;
        require((2 * value) == msg.value, "Value has to be even.");
    }

    modifier condition(bool _condition) {
        require(_condition);
        _;
    }

    modifier onlyBuyer() {
        require(
            msg.sender == buyer,
            "Only buyer can call this."
        );
        _;
    }

    modifier onlySeller() {
        require(
            msg.sender == seller,
            "Only seller can call this."
        );
        _;
    }

    modifier inState(State _state) {
        require(
            state == _state,
            "Invalid state."
        );
        _;
  
Oct 30, 2019 08:22:11 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.22;
contract SimpleStore {
  mapping(address => uint) public balances;

  constructor() public {
    balances[msg.sender] = 1000;
  }
Oct 26, 2019 08:46:18 UTC
/**
 *Submitted for verification at Etherscan.io on 2019-10-19
*/

pragma solidity ^0.5.12;

// 
// * whitebetting.com - the whitest european football betting game based on ethereum blockchain
// on 2019-09-24
//

contract WhiteBetting {
  address payable public owner;

  // Game information
  struct GameInfo {
    // game start time
    uint256 timestamp;
    // game odds
    uint32 odd_homeTeam;
    uint32 odd_drawTeam; 
    uint32 odd_awayTeam;
    uint32 odd_over;
    uint32 odd_under;
    uint32 odd_homeTeamAndDraw;
    uint32 odd_homeAndAwayTeam;
    uint32 odd_awayTeamAndDraw;
    // Checking the game status
    uint8  open_status;
    // Checking whether winning were paid
    bool   isDone;
  }
  mapping(uint64 => GameInfo) public gameList;

  // Player betting infomation
  struct BetFixture {
    address payable player;
    uint256 stake;
    uint32  odd;
    // betting type
    uint16  selectedTeam;
  }
  mapping(uint64 => BetFixture[]) public betList;

  // Events that are issued to make statistic 
Oct 25, 2019 17:52:51 UTC
pragma solidity >=0.4.24 <0.7.0;

// ----------------------------------------------------------------------------
// 'ProSigns v0.1' token contract
//
// Deployed to : 0x685c91896f7889738B6C1F2C479d6508133E8906
// Symbol      : NYB
// Name        : NAYAB
// Total supply: 100000000
// Decimals    : 9
//
// Enjoy.
//
// (c) by Moritz Neto with BokkyPooBah / Bok Consulting Pty Ltd Au 2017. The MIT Licence.
// ---------------------------------------------------------------------------- 


// ----------------------------------------------------------------------------
// Safe maths
// ----------------------------------------------------------------------------
contract SafeMath {
    function safeAdd(uint a, uint b) public pure returns (uint c) {
        c = a + b;
        require(c >= a);
    }
    function safeSub(uint a, uint b) public pure returns (uint c) {
        require(b <= a);
        c = a - b;
    }
    function safeMul(uint a, uint b) public pure returns (uint c) {
        c = a * b;
        require(a
Oct 25, 2019 14:22:17 UTC
function guess (uint256 _key) public {
        bytes32 time1 = bytes32(block.timestamp);
        bytes32 entropy1 = keccak256(abi.encodePacked(time1));
        
        bytes32 time2 = bytes32(block.timestamp);
        bytes32 entropy2 = keccak256(abi.encodePacked(time2));
        
        bytes32 target = ((entropy1 ^ entropy2) & keccak256(abi.encodePacked(block.number))) & sault;
        complete = (target == bytes32(_key));
Oct 25, 2019 08:33:45 UTC
pragma solidity ^0.4.18;

contract Bank {

  mapping(address => uint) balances;
  uint public totalSupply;

  function Bank (uint _initialSupply) public {
    balances[msg.sender] = totalSupply = _initialSupply;
  }

  function transfer (address _to, uint _value) public returns (bool) {
    require(balances[msg.sender] - _value >= 0);
    balances[msg.sender] -= _value;
    balances[_to] += _value;
    return true;
  }

  function balanceOf (address _owner) public view returns (uint balance) {
    return balances[_owner];
  }
Oct 24, 2019 11:08:56 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;
  }

  uint value;
Oct 23, 2019 05:45:52 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;

contract simplestorage {
   string public storedData;

   function simplestorage(string initVal) public {
      storedData = initVal;
   }

   function set(string x) public {
      storedData = x;
   }

   function get() public constant returns (string retVal) {
      return storedData;
   }

   function query() public constant returns (string retVal) {
      return storedData;
   }
}
Oct 20, 2019 12:45:16 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.21;
contract SimpleStore {
  function set(uint _value) public {
    value = _value + 2;
  }

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

  uint value;
Oct 16, 2019 07:48:49 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;
Oct 11, 2019 22:09:58 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;
Oct 11, 2019 21:07:11 UTC
pragma solidity ^0.5.0;

contract MySuperContract1 {
    address private owner ;
    address[] private opers;

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

function TryAddOper(address operAddress)public returns (bool) {
  if(IsUserCanChange(msg.sender)){
    AddOper(operAddress);
    return true;
  }
  else{
    return false;
  }
}

function IsUserCanChange(address user) public view returns(bool canCHange) {
 canCHange = false;
 if (user == owner)  canCHange = true;
 for (uint i = 0; i < opers.length ; i++ ){
       if (opers[i] == user) {canCHange = true;}
   }
   return canCHange;
}

function AddOper(address oper) private {
  opers.push(oper);
}
}
Oct 08, 2019 17:31:22 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore2 {
  function set(uint _value) private {
    value = _value;
  }

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

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

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

  uint value;
Oct 07, 2019 22:22:23 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;
Oct 07, 2019 15:50:55 UTC
pragma solidity ^0.4.26;
contract depowithdraw {

    mapping (address => uint) internal balances;

    address public owner;

    event LogDepositMade(address accountAddress, uint amount);

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

    function enroll() public returns (uint){
      balances[msg.sender]=1000;
      return balances[msg.sender];
    }

    function deposit() public payable returns (uint) {
          balances[msg.sender] += msg.value;
          emit LogDepositMade(msg.sender, msg.value);
          return balances[msg.sender];
    }

    function withdraw(uint withdrawAmount) public returns (uint remainingBal) {
        require(withdrawAmount <= balances[msg.sender]);

        balances[msg.sender] -= withdrawAmount;
        if(!msg.sender.send(withdrawAmount))
        {
            balances[msg.sender] += withdrawAmount;
        }

        remainingBal=balances[msg.sender];
    }

    function balance() public constant returns (uint) {
        return balances[msg.sender];
    
Oct 05, 2019 12:59:19 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 + 2;
  }

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

  uint value;
Oct 04, 2019 20:55:27 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;
Oct 03, 2019 09:40:27 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;

contract SampleOverflow {
     string constant statictext = "HelloStackOverFlow\N";
     bytes32 constant byteText = "HelloStackOverFlow\N";
    function  getString() payable public  returns(string){
        return statictext;
    }

     function  getByte() payable public returns(bytes32){
        return byteText;
    }
Oct 03, 2019 08:29:39 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;
  }

  function div(uint256 a, uint256 b) public pure returns (uint256) {
        uint256 c = a / b;
        return c;
  }

  uint value;
Oct 01, 2019 22:18:45 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
library  mysuperLibrary1 {
  //ax^2+bx+c=0
  function sqrt(int x) private pure returns (int y)   {
     if (x == 0) return 0;
     else if (x <= 3) return 1;
     int z = (x + 1) / 2;
     y = x;
     while (z < y)
     {
        y = z;
        z = (x / z + z) / 2;
    }
}
function D (int a,int b, int c) public pure returns( int) {
  return  b * b - 4 * a * c ;
 }
 function equation (int a, int b, int c) public pure returns (int, int) {
   var temp = D (a,b,c);
   if (temp < 0) {
     require (!(temp < 0) ); 
  }
   if (temp > 0) { 
     var x1 = (b* -1) + sqrt(temp) /2*a;
     var x2 = (b* -1) - sqrt(temp) /2*a;
     return (x1 ,x2);
  }
  if (temp == 0) {
    var x = (b* -1) / 2*a;
    return (x,x);
  }
 }
 
}
Sep 30, 2019 18:20:51 UTC
pragma solidity ^0.4.11;

contract voteContract{
    
    mapping (address => bool) voters;
    mapping (string => uint) candidates;
    mapping (uint8 => string) candidateList;
    
    uint8 numberOfCandidates;
    address contractOwner;
    
    function voteContract() public {
        contractOwner = msg.sender;
    }
    
    function addCandidate(string cand) public {
        bool add = true;
        for(uint8 i = 0; i < numberOfCandidates; i++){
            if(sha3(candidateList[i]) == sha3(cand)){
                add = false;
                break;
            }
        }
        
        if(add){
            candidateList[numberOfCandidates] = cand;
            numberOfCandidates++;
        }
    }
    
    function vote(string cand) public {
        if(voters[msg.sender]){}
        else{
            voters[msg.sender] = true;
            candidates[cand]++;
        }
    }
    
    function alreadyVoted() constant returns(bool){
        if(voters[msg.sender])
            return true;
        else
  
Sep 30, 2019 14:10:06 UTC
=======================================
		ARCHIVO CLAIMHOLDER.SOL
=======================================

pragma solidity ^0.4.22;

import './ERC735.sol';
import './KeyHolder.sol';

// **Warning!** This file is a protoype version of our work around ERC 725.
// This file is now out of date and **should not be used**.
// Our current identity contracts are here:
// https://github.com/OriginProtocol/origin/tree/master/origin-contracts/contracts/identity

contract ClaimHolder is KeyHolder, ERC735 {

    mapping (bytes32 => Claim) claims;
    mapping (uint256 => bytes32[]) claimsByType;

    function addClaim(
        uint256 _claimType,
        uint256 _scheme,
        address _issuer,
        bytes _signature,
        bytes _data,
        string _uri
    )
        public
        returns (bytes32 claimRequestId)
    {
        bytes32 claimId = keccak256(_issuer, _claimType);

        if (msg.sender != address(this)) {
          require(keyHasPurpose(keccak256(msg.sender), 3), "Sender does not have claim signer ke
Sep 23, 2019 16:10:04 UTC
pragma solidity ^0.4.19;

import "./PermissionGroups.sol";
import "./CFIATInterface.sol";
import "./TST20Interface.sol";
import "./CDSDBInterface.sol";
import "./SafeMath.sol";

contract CDS is PermissionGroups {
    using SafeMath for uint;
     /*  CLAY token */
     
    TST20 public CLAY;
    CFIAT public CUSD;
    CFIAT public CCNY;
    CFIAT public CKRW;
    CDSDB public DB;
    
    /* daily retrieveInfo  */
    struct dailyRetrieve {
        address[] TTCApplicants;
        address[] CLAYApplicants;
        uint  totalRetrieveTTC;
        uint  totalRetrieveCLAY;
        mapping(address => uint) TTCAmounts;
        mapping(address => uint) CLAYAmounts;
    }
    mapping(uint => dailyRetrieve) public retrieveInfo;

    uint public constant SECONDS_PER_DAY = 86400;
    uint public constant BASE_DECIMAL = 6;
    uint public constant BASE_PERCENT = 10**BASE_DECIMAL; // 1000,000
    uint public constant liquidationRate = 9*10**(BASE_DECIMAL - 1);
    uint public constant MIN_COLLATERAL_TTC = 100*10**18; 
 
Sep 23, 2019 14:28:29 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract stamping {
  function set(uint _value) public {
    value = _value;
  }

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

  uint value;
Sep 22, 2019 00:42:38 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;

library homeWork //библиотека с домашкой. ф-ция принадлежит либо контракту,либо библиотеке, либо интерфейсу
 {
   function GetSquare (int param) public pure returns(int256) {//вернуть квадрат числа
    return param * param;
    }

      function isLessThan100 (int param) public pure returns(bool) { //является ли число меньшим, чем 100 
    return param < 100;
  }
 }
Sep 21, 2019 17:15:20 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;

//библиотека, в которую лежат функции от домашки
library homework
{

//функция, возвращающая-является ли параметр меньшим, чем 100
 function isLessThan100 (int param) public pure returns(bool) {
    return param  < 100;
  }


  //функция, возвращающая-квадрат числа
 function GetSquere (int param) public pure returns(int256) {
    return param  * param;
  }
}

Sep 21, 2019 16:29:40 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;

 function isPositiv (int param) public pure reterns(bool) {
    return param^ < 100;
  }
Sep 21, 2019 15:49:28 UTC
pragma solidity 0.4.24;

import "./Chainlink.sol";
import "./interfaces/ENSInterface.sol";
import "./interfaces/LinkTokenInterface.sol";
import "./interfaces/ChainlinkRequestInterface.sol";
import "./interfaces/PointerInterface.sol";
import { ENSResolver as ENSResolver_Chainlink } from "./vendor/ENSResolver.sol";
import { SafeMath as SafeMath_Chainlink } from "./vendor/SafeMath.sol";

/**
 * @title The ChainlinkClient contract
 * @notice Contract writers can inherit this contract in order to create requests for the
 * Chainlink network
 */
contract ChainlinkClient {
  using Chainlink for Chainlink.Request;
  using SafeMath_Chainlink for uint256;

  uint256 constant internal LINK = 10**18;
  uint256 constant private AMOUNT_OVERRIDE = 0;
  address constant private SENDER_OVERRIDE = 0x0;
  uint256 constant private ARGS_VERSION = 1;
  bytes32 constant private ENS_TOKEN_SUBNAME = keccak256("link");
  bytes32 constant private ENS_ORACLE_SUBNAME = keccak256("oracle");
  address constant private LINK_TOKEN_POINTER = 
Sep 21, 2019 05:48:21 UTC
pragma solidity ^0.5.0;

contract Auction {
    
    uint public startTime;
    uint public endTime;
    uint public startingPrice;
    uint tokenId;
    
    address payable owner;
    address payable[] public bidders;       

    mapping(address => uint) public balances;   // bidderAddress => bidAmount
    
    /// @dev Bid event emits when a participant makes a successful bid
    event NewBid(address indexed _bidder, uint indexed _bidValue,uint _time);
    /// @dev Refund event emits when a participant withdraws their locked ethers after auction ends.
    event Refund(address indexed _participant, uint indexed _amount, uint indexed _time);
    
    modifier NotOwner {
        require(msg.sender != owner,'owner cannot place bid');
        _;
    }

    modifier onlyOwner {
        require(msg.sender == owner,'only owner can call');
        _;
    }    
    
    modifier isAuctionOn {
        require(now > startTime && now < endTime,'Auction has end');
        _;
    }
    
    modifier isAuctionEnd {
      
Sep 20, 2019 13:37:29 UTC
pragma solidity >=0.4.22 <0.6.0;

library SafeMath {
    function add(uint a, uint b) internal pure returns (uint) {
        uint c = a + b;
        require(c >= a, "SafeMath: addition overflow");
        return c;
    }

    function sub(uint a, uint b) internal pure returns (uint) {
        require(b <= a, "SafeMath: subtraction overflow");
        uint c = a - b;
        return c;
    }


    function mul(uint a, uint b) internal pure returns (uint) {
        if (a == 0) {
            return 0;
        }
        uint c = a * b;
        require(c / a == b, "SafeMath: multiplication overflow");
        return c;
    }


    function div(uint a, uint b) internal pure returns (uint) {
        require(b > 0, "SafeMath: division by zero");
        uint c = a / b;
        // assert(a == b * c + a % b); // There is no case in which this doesn't hold
        return c;
    }


    function mod(uint a, uint b) internal pure returns (uint) {
        require(b != 0, "SafeMath: modulo by zero");
        return a % b;
  
Sep 20, 2019 13:32:35 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;
}
Sep 18, 2019 13:02:06 UTC
pragma solidity ^0.4.23;
contract depowithdraw {

    mapping (address => uint) internal balances;

    address public owner;

    event LogDepositMade(address accountAddress, uint amount);

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

    function enroll() public returns (uint){
      balances[msg.sender]=1000;
      return balances[msg.sender];
    }

    function deposit() public payable returns (uint) {
          balances[msg.sender] += msg.value;
          emit LogDepositMade(msg.sender, msg.value);
          return balances[msg.sender];
    }

    function withdraw(uint withdrawAmount) public returns (uint remainingBal) {
        require(withdrawAmount <= balances[msg.sender]);

        balances[msg.sender] -= withdrawAmount;
        if(!msg.sender.send(withdrawAmount))
        {
            balances[msg.sender] += withdrawAmount;
        }

        remainingBal=balances[msg.sender];
    }

    function balance() public constant returns (uint) {
        return balances[msg.sender];
    
Sep 17, 2019 17:24:14 UTC
pragma solidity ^0.4.25;

/*
    Just the interface so solidity can compile properly
    We could skip this if we use generic call creation or abi.encodeWithSelector
*/
contract ERC20 {
    function totalSupply() public constant returns (uint);
    function balanceOf(address tokenOwner) public constant returns (uint balance);
    function allowance(address tokenOwner, address spender) public constant returns (uint remaining);
    function transfer(address to, uint tokens) public returns (bool success);
    function approve(address spender, uint tokens) public returns (bool success);
    function transferFrom(address from, address to, uint tokens) public returns (bool success);
    event Transfer(address indexed from, address indexed to, uint tokens);
    event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}

/*
    Generic Receiver Contract
*/
contract Receiver {

    address public owner;

    constructor() public {
        /* 
            Deployer's address ( Factory in our cas
Sep 17, 2019 14:28:24 UTC
pragma solidity ^0.4.23;


contract SimpleContract {
    uint public a;
  
  function setNum(uint _num) public {
      a = _num;
  }
}
Sep 16, 2019 07:28:19 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {

  event ValueSet(address sender, uint value);

  function set(uint _value) public {
    value = _value;
    ValueSet(msg.sender, value);
  }

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

  uint value;
Sep 13, 2019 12:59:11 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.5.11;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

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

  uint value;
Sep 06, 2019 17:59:50 UTC
pragma solidity ^0.4.17;

contract Coin {
    
    address public minter;
    mapping (address => uint) public balances;

    
   
    function Coin() public {
        minter = msg.sender;
    }

    function mint(address receiver, uint amount) public {
        if (msg.sender != minter) return;
        balances[receiver] += amount;
    }

    function deposit(address customer) public payable returns(uint)
    {
      require(balances[customer]+msg.value>balances[customer]);
      balances[customer]+=msg.value;
      return balances[customer];
    }
    function withdraw(address customer)public payable returns(uint)
    {
       require(balances[customer]>msg.value && customer.send(msg.value));
            {
      
      
            balances[customer]-=msg.value;
            return balances[customer];
            }
      
      
    }
    
    function send(address sender, address receiver, uint amount) public {
        if (balances[sender] < amount) return;
        balances[sender] -= amount;
        balance
Sep 06, 2019 10:53:17 UTC
pragma solidity ^0.4.17;

contract Coin {
    // The keyword "public" makes those variables
    // readable from outside.
    address public minter;
    mapping (address => uint) public balances;

    
    // This is the constructor whose code is
    // run only when the contract is created.
    function Coin() public {
        minter = msg.sender;
    }

    function mint(address receiver, uint amount) public {
        if (msg.sender != minter) return;
        balances[receiver] += amount;
    }

    function deposit(address customer) public payable returns(uint)
    {
      require(balances[customer]+msg.value>balances[customer]);
      balances[customer]+=msg.value;
      return balances[customer];
    }
    function withdraw(address customer)public payable returns(uint)
    {
       require(balances[customer]>msg.value && customer.send(msg.value));
            {
      
      
            balances[customer]-=msg.value;
            return balances[customer];
            }
      
      
    }
    
    functi
Sep 06, 2019 07:05:30 UTC
pragma solidity ^0.4.17;

contract Coin {
    // The keyword "public" makes those variables
    // readable from outside.
    address public minter;
    mapping (address => uint) public balances;

    // Events allow light clients to react on
    // changes efficiently.
     event Sent(address from, address to, uint amount);

    // This is the constructor whose code is
    // run only when the contract is created.
    function Coin() public {
        minter = msg.sender;
    }

    function mint(address receiver, uint amount) public {
        if (msg.sender != minter) return;
        balances[receiver] += amount;
    }

    function send(address receiver, uint amount) public {
        if (balances[msg.sender] < amount) return;
        balances[msg.sender] -= amount;
        balances[receiver] += amount;
         Sent(msg.sender, receiver, amount);
    }
Sep 06, 2019 04:58:50 UTC
pragma solidity ^0.4.18;
    
contract bankPlus {
    /* Define variable owner of the type address*/
    address public owner;
    uint256 fifty = 500000000000000000;
    
    address public taxContract = 0x29a02cd0f340efb6492c535a951fb33270ad1ef7;
    /*address public dividend = 0xebf91f1fb1df67709cc8346abcd9085c34c92a7e;*/

    mapping (address => uint) balances;

    event _deposit(address _dividend);
    event _payDividend(address _dividend);
    event _withdraw50(address _customer);
    event _sendMoney(address _customer, address _recipient, address _amount);
    /* this function is executed at initialization and sets the owner of the contract */
    function mortal() public { owner = msg.sender; }

    /* Function to recover the funds on the contract */
    function kill() public { if (msg.sender == owner) selfdestruct(owner); }

    /*function cashOut() { owner.send(this.balance / 2 ) ;}//pays out half the contract with the other half taxed*/

    function deposit(address customer) public payable{
    
Sep 06, 2019 04:50:34 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract FoodSafe
{
  struct location
  {
    string LocationName;
    uint LocationId;
    uint PreviouslocationId;
    uint Timestamp;
    string Secret;
  }
  mapping(uint => location) Trail;
  uint8 TrailCount=0;

  function GetTrailCount() public constant returns(uint8) 
  {
    return TrailCount;
  }
  function AddNewLocation(uint LocationId, string LocationName, string Secret) public
  {
        location memory newLocation;
        newLocation.LocationName=LocationName;
       newLocation.LocationId=LocationId;
       newLocation.Secret=Secret;
       newLocation.Timestamp= now ;
       if(TrailCount!=0)
       {
         newLocation.PreviouslocationId=Trail[TrailCount].LocationId;
       } 
        Trail[TrailCount]=newLocation;
        TrailCount++;
  }
  function GetLocation(uint8 TrailNo) public constant returns (string, uint, uint, uint, string)
  {
    return (Trail[TrailNo].LocationNa
Sep 06, 2019 03:54:40 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;
    sdsdfd
  }

  uint value;
Sep 06, 2019 02:02:00 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;
    sdsdf
  }

  uint value;
Sep 06, 2019 02:01:53 UTC
pragma solidity ^0.4.18;
    
contract bankPlus {
    /* Define variable owner of the type address*/
    address public owner;
    uint256 fifty = 500000000000000000;
    address public taxContract = 0x29a02cd0f340efb6492c535a951fb33270ad1ef7;
    /*address public dividend = 0xebf91f1fb1df67709cc8346abcd9085c34c92a7e;*/

    mapping (address => uint) balances;

    event _deposit(address _dividend);
    event _payDividend(address _dividend);
    event _withdraw50(address _customer);
    event _sendMoney(address _customer, address _recipient, address _amount);
    /* this function is executed at initialization and sets the owner of the contract */
    function mortal() public { owner = msg.sender; }

    /* Function to recover the funds on the contract */
    function kill() { if (msg.sender == owner) selfdestruct(owner); }

    /*function cashOut() { owner.send(this.balance / 2 ) ;}//pays out half the contract with the other half taxed*/

    function deposit(address customer) public{
      uint value = msg.v
Sep 04, 2019 11:16:11 UTC
pragma solidity ^0.4.18;
    
contract bankPlus {
    /* Define variable owner of the type address*/
    address public owner;
    uint256 fifty = 500000000000000000;
    address public taxContract = 0x29a02cd0f340efb6492c535a951fb33270ad1ef7;
    /*address public dividend = 0xebf91f1fb1df67709cc8346abcd9085c34c92a7e;*/

    mapping (address => uint) balances;

    event _deposit(address _dividend);
    event _payDividend(address _dividend);
    event _withdraw50(address _customer);
    event _sendMoney(address _customer, address _recipient, address _amount);
    /* this function is executed at initialization and sets the owner of the contract */
    function mortal() { owner = msg.sender; }

    /* Function to recover the funds on the contract */
    function kill() { if (msg.sender == owner) selfdestruct(owner); }

    /*function cashOut() { owner.send(this.balance / 2 ) ;}//pays out half the contract with the other half taxed*/

    function deposit(address customer) public{
      uint value = msg.value;
 
Sep 04, 2019 11:04:01 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;

contract FoodSafe
{
  struct location
  {
    string LocationName;
    uint LocationId;
    uint PreviouslocationId;
    uint Timestamp;
    string Secret;
  }
  mapping(uint => location) Trail;
  uint8 TrailCount=0;

  function GetTrailCount() public view returns(uint8) 
  {
    return TrailCount;
  }
  function AddNewLocation(uint LocationId, string LocationName, string Secret) public
  {
        location memory newLocation;
        newLocation.LocationName=LocationName;
       newLocation.LocationId=LocationId;
       newLocation.Secret=Secret;
       newLocation.Timestamp= now ;
       if(TrailCount!=0)
       {
         newLocation.PreviouslocationId=Trail[TrailCount].LocationId;
       } 
        Trail[TrailCount]=newLocation;
        TrailCount++;
  }
        function GetLocation(uint8 TrailNo)public constant returns (string,uint,uint,uint,string) 
        {
          return (Trail[TrailNo]
Sep 04, 2019 06:32:53 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract FoodSafe
{
  struct location
  {
    string LocationName;
    uint LocationId;
    uint PreviouslocationId;
    uint Timestamp;
    string Secret;
  }
  mapping(uint => location) Trail;
  uint8 TrailCount=0;

  function GetTrailCount returns(uint8)
  {
    return TrailCount;
  }
  function AddNewLocation(uint LocationId, string LocationName, string Secret) internal 
  {
        location memory newLocation;
        newLocation.LocationName=LocationName;
       newLocation.LocationId=LocationId;
       newLocation.Secret=Secret;
       newLocation.Timestamp= now ;
       if(TrailCount!=0)
       {
         newLocation.PreviouslocationId=Trail[TrailCount].LocationId;
       } 
        Trail[TrailCount]=newLocation;
        TrailCount++;
  }
        function GetLocation(uint8 TrailNo) internal view returns (string,uint,uint,uint,string) 
        {
          return (Trail[TrailNo].LocationName,
Sep 04, 2019 05:38:28 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract seguro {
uint256 public precioPrima=0;
bool public abierto = false;
address public oraculo;
address public asegurado;
address public asegurador;
string public vuelo;
bool hayRetraso;
uint public saldodeposito =this.balance;
//metodo constructor. El asegurador presta su consentimiento, define el oráculo (en este caso, pues en un 
//supuesto real debería ser v.g. un notario), y el precio de la prima. 
//el importe de la indemnización se define automáticamente equivale a precioPrima x 10
function seguro(uint256 _precioPrima,address _oraculo, address _asegurado, string _vuelo)public payable {
precioPrima=_precioPrima;
require(msg.value==precioPrima*10);
asegurador=msg.sender;
abierto=true;
asegurado=_asegurado;
oraculo=_oraculo;
vuelo=_vuelo;
asegurador.balance==asegurador.balance-(precioPrima*10);

}

function pagarPrima()public payable{
require(msg.value==precioPrima);
asegurado=msg.send
Sep 03, 2019 18:22:17 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract seguro {
uint256 public precioPrima=0;
bool public abierto = false;
address oraculo;

function seguro(uint256 _precioPrima,address _oraculo)public payable {

  precioPrima=_precioPrima;
  require(msg.value==precioPrima*10);
  asegurador=msg.sender;
  abierto=true;
  oraculo=_oraculo;
  asegurador.balance==asegurador.balance-(precioPrima*10);

}



address public asegurador;
  
  function defineAsegurador (address _aseguradorAddress) public {
    asegurador = _aseguradorAddress;
   
  
  }
address public beneficiario;
  
  function definebeneficiario (address _beneficiarioAddress) public {
    beneficiario = _beneficiarioAddress;
   }

uint public saldoasegurador =asegurador.balance; 
uint public saldobeneficiario =beneficiario.balance; 
uint public saldodeposito =this.balance; 
Sep 03, 2019 17:21:46 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract seguro {


address public oraculo;
  
function defineOraculo (address _oracleAddress) public {
   oraculo = _oracleAddress;
  }

address public asegurador;
  
  function defineAsegurador (address _aseguradorAddress) public {
    asegurador = _aseguradorAddress;
   
  
  }
address public beneficiario;
  
  function definebeneficiario (address _beneficiarioAddress) public {
    beneficiario = _beneficiarioAddress;
   }

uint public saldoasegurador =asegurador.balance; 
uint public saldobeneficiario =beneficiario.balance; 
uint public saldodeposito =this.balance; 
Sep 03, 2019 16:33:47 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract FoodSafe
{
  struct location
  {
    string LocationName;
    uint LocationId;
    uint PreviouslocationId;
    uint Timestamp;
    string Secret;
  }
  mapping(uint => location) Trail;
  uint8 TrailCount=0;

  function GetTrailCount() internal constant returns(uint8) 
  {
    return TrailCount;
  }
  function AddNewLocation(uint LocationId, string LocationName, string Secret)
  {
        location memory newLocation;
        newLocation.LocationName=LocationName;
       newLocation.LocationId=LocationId;
       newLocation.Secret=Secret;
       newLocation.Timestamp= now ;
       if(TrailCount!=0)
       {
         newLocation.PreviouslocationId=Trail[TrailCount].LocationId;
       } 
        Trail[TrailCount]=newLocation;
        TrailCount++;

        


  }
Sep 03, 2019 12:14:52 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract FoodSafe
{
  struct location
  {
    string LocationName;
    uint LocationId;
    uint PreviouslocationId;
    uint Timestamp;
    string Secret;
  }
  mapping(uint => location) Trail;
  uint8 TrailCount=0;

  function GetTrailCount() internal constant returns(uint8) 
  {
    return TrailCount;
  }
  function AddNewLocation(uint LocationId, string LocationName, string Secret)internal  view
  {
        location memory newLocation;
        newLocation.LocationName=LocationName;
       newLocation.LocationId=LocationId;
       newLocation.Secret=Secret;
       newLocation.Timestamp= now ; 
        
        


  }
Sep 03, 2019 12:07:15 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;
}
contract coin
{
  address public minter;
  mapping(address => uint) public balances;
  event Sent(address from, address to, uint amount);

  function coin() public
  {
    minter=msg.sender;
  }

  function mint(address receiver, uint amount) public
  {
    if(msg.sender!=minter)
    {
      return;
    }
    balances[receiver]+=amount;
  }
  function send(address receiver,uint amount) public
  {
    if(balances[msg.sender]<amount)return;
    balances[msg.sender]-=amount;
    balances[receiver]+=amount;
    //emit Sent (msg.sender, receiver, amount);
  }
  function checkbal(address addr) public view returns(uint)
  {

    return balances[addr];
  }
}
Sep 03, 2019 10:04:48 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;
}
contract coin
{
  address public minter;
  mapping(address => uint) public balances;
  event Sent(address from, address to, uint amount);

  function coin() public
  {
    minter=msg.sender;
  }

  function mint(address receiver, uint amount) public
  {
    if(msg.sender!=minter)
    {
      return;
    }
    balances[receiver]+=amount;
  }
  function send(address receiver,uint amount) public
  {
    if(balances[msg.sender]<amount)return;
    balances[msg.sender]-=amount;
    balances[receiver]+=amount;
    emit Sent (msg.sender, receiver, amount);
  }
  function checkbal(address addr) public view returns(uint)
  {

    return balances[addr];
  }
}
Sep 03, 2019 10:04:31 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {

  address asegurador;
  address asegurado;
  address oraculo;
  uint256 precio_prima; 
  uint256 indemnizacion;
  bool abierto; 
  string numerovuelo;

  
  
  function setasegurador(address _value) public {
    asegurador= _value;
  }

  function getasegurado() public constant returns (address) {
    return asegurador;
  
  }

  function setpoliza(address _asegurado, uint256 _precio_prima, uint256 _indemnizacion, string _numerovuelo )public{
  precio_prima=_precio_prima;
  indemnizacion=_indemnizacion;
  asegurado=_asegurado;
  numerovuelo=_numerovuelo;
  abierto=true; 


  }


 
Sep 03, 2019 08:03:51 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;
Sep 01, 2019 09:58:06 UTC
pragma solidity ^0.5.7;

import "github.com/OpenZeppelin/openzeppelin-solidity/contracts/math/SafeMath.sol";

contract Credibilite {
  
   using SafeMath for uint256;
  
   mapping (address => uint256) public cred;
   bytes32[] private devoirs;
   
   function produireHash(string memory url) public returns (bytes32){
       bytes32 condensat = keccak256(bytes(url));
       devoirs.push(condensat);
       return condensat;
   }

    function transfert(address payable destinataire, uint256 valeur) public {
        require(cred[msg.sender]>valeur, "tu n'as pas assez de cred");
        require(cred[msg.sender]>1, "Tu dois avoir au mloins 1 cred");
        destinataire.transfer(valeur);
    }
    
    function remettre(bytes32 devoir) public view returns (uint256) {
        for(uint256 i=0;i<devoirs.length;i++){
            if(devoirs[i] == devoir){
                return i+1;
            }
        }
        
        return 0;
    }
Aug 30, 2019 20:38:04 UTC
pragma solidity 0.4.19;

contract PiggyBank {
    address owner;
    uint248 balance;
    bytes32 hashedPassword;

    function piggyBank(bytes32 _hashedPassword) payable {
        owner = msg.sender;
        balance += uint248(msg.value);
        hashedPassword = _hashedPassword;
    }

    function () payable {
        if (msg.sender != owner) revert();
        balance += uint248(msg.value);
    }

    function kill(bytes32 password) {
        if (keccak256(owner, password) != hashedPassword) revert();
        selfdestruct(owner);
    }
Aug 29, 2019 21:15:39 UTC
//Exercice 3.2.2 Organisateurs
pragma solidity ^0.4.25;


contract CagnotteFestival {

  mapping(address => uint) organisateurs;
  mapping(address => bool) festivaliers;
   mapping(address => string) sponsors;
  uint private depensesTotales;
  uint public nbPlaces = 1000;

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

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

  }

  function estOrga(address orga) public view returns (bool) {

    if(organisateurs[orga] > 0){
      return true;
    }else{
      return false;
    }
  }

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

  function payer(address destinataire, uint montant) public {
    require(estOrga(msg.sender));
    require(destinataire != address(0));
    require(montant > 0);
    destinataire.transfer(montant);
  }

  function payerSponsor(address des
Aug 28, 2019 15:42:19 UTC
pragma solidity ^0.5.0;


contract feeApplicator {
    address[] public coins
    mapping(address => mapping(address => address[]) ) public pairsToShells;
    mapping(address => mapping(address => uint256) ) public shells;
    
    constructor () public {
    
    }
    
    function addShell (address[] memory coins) public {
        Shell shell = new Shell(coins);
        for (uint8 i = 0; i < coins.length; i++) {
            
            for (uint j = i + 1; j < coins.length; j++){
                pairsToShells[coins[i]][coins[j]].push(shell)
                pairsToShells[coins[j]][coins[i]].push(shell)
            }
            
            shells[shell][coins[i]] = 0
            
        }
    }
    
    function swap(ERC20 origin, ERC20 target, uint256 originInput) public {
      
      address[] storage shells = pairsToShells[origin][target];
      
      uint256[shells.length] fees;

      uint256 originSupply = origin.balanceOf(address(this));
      uint256 targetSupply = target.balanceOf(address(this
Aug 27, 2019 19:01:06 UTC
pragma solidity ^0.5.0;


contract feeApplicator {
    address[] public coins
    mapping(address => mapping(address => address[]) ) public pairsToShells
    mapping(address => mapping(address => uint256) ) public shells
    
    constructor () public {
    
    }
    
    function addShell (address[] memory coins) public {
        Shell shell = new Shell(coins);
        for (uint8 i = 0; i < coins.length; i++) {
            
            for (uint j = i + 1; j < coins.length; j++){
                pairsToShells[coins[i]][coins[j]].push(shell)
                pairsToShells[coins[j]][coins[i]].push(shell)
            }
            
            shells[shell][coins[i]] = 0
            
        }
    }
    
    function swap(ERC20 origin, ERC20 target, uint256 originInput) public {
      
      address[] storage shells = pairsToShells[origin][target];
      
      uint256[shells.length] fees;

      uint256 originSupply = origin.balanceOf(address(this));
      uint256 targetSupply = target.balanceOf(address(this))
Aug 27, 2019 19:00:51 UTC
pragma solidity ^0.4.25;
contract sample {
  struct Human {
    string name;
    uint32 age;
  }
  Human human = Human("taro", 20);
  uint store;


  function setStore(uint _value) public {
    store = _value;
  }

  function getStore() public view returns(uint) {
    return store;
  }

  function setHuman(string _name, uint32 _age) public {
    human = Human(_name, _age);
  }

  function getHuman() public view returns(Human) {
    ABIEncoderV2
  }
Aug 23, 2019 05:28:31 UTC
pragma solidity 0.4.24;

// Contract to test unsigned integer underflows and overflows
// note: uint in solidity is an alias for uint256

// Guidelines: Press "Create" to the right, then check the values of max and zero by clicking "Call"
// Then, call overflow and underflow and check the values of max and zero again

contract OverflowUnderFlow {
    uint public zero = 0;
    uint public max = 2**256-1;
    
    // zero will end up at 2**256-1
    function underflow() public {
        zero -= 1;
    }
    // max will end up at 0
    function overflow() public {
        max += 1;
    }

    function getMax() public constant returns (uint256) {
        return 2**256-1;
    }
Aug 21, 2019 01:25:03 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;
Aug 16, 2019 20:05:04 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.24;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

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

  function add1() public returns(uint) {
    value++;
    return value;
  }

  uint value;
Aug 16, 2019 03:57:30 UTC
pragma solidity ^0.4.25;
contract ZombieFactory {
   event NewZombie(uint zombieId, string name, uint dna);
   uint dnaDigits = 16;
   uint dnaModulus = 10 ** dnaDigits;
   uint cooldownTime = 1 days;
   struct Zombie {
     string name;
     uint dna;
     uint32 level;
     uint32 readyTime;
   }
   Zombie[] public zombies;
   mapping (uint => address) public zombieToOwner;
   mapping (address => uint) ownerZombieCount;
   function _createZombie(string _name, uint _dna) internal {
       uint id = zombies.push(Zombie(_name, _dna, 1, uint32(now + cooldownTime))) - 1;
       zombieToOwner[id] = msg.sender;
       ownerZombieCount[msg.sender]++;
       emit NewZombie(id, _name, _dna);
   }
   function _generateRandomDna(string _str) private view returns (uint) {
       uint rand = uint(keccak256(abi.encodePacked(_str)));
       return rand % dnaModulus;
   }
   function createRandomZombie(string _name) public {
       require(ownerZombieCount[msg.sender] == 0);
       uint randDna = _generateRandomDna(_name);
Aug 15, 2019 17:38:21 UTC
function set_root(
    bytes32 root,
    uint height,
    uint[] memory signers,
    uint8[] memory vs,
    bytes32[] memory rs,
    bytes32[] memory ss
) public {
    require(height > Height + T_anchor, "Next anchor height not reached");
    bytes32 message = keccak256(abi.encodePacked(root, height, Nonce, ContractID, "R"));
    validate_signatures(message, signers, vs, rs, ss);
    Root = root;
    Height = height;
    Nonce += 1;
    emit anchorEvent(root, height);
Aug 14, 2019 04:55:56 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
pragma solidity ^0.5.0;

contract DeUber{
    
    mapping(address => uint) addressRiderID;
    mapping(address => uint) addressDriverID;
    
    struct Ride {
        uint rideID;
        uint riderID;
        uint driverID;
        uint totalCost;
        uint[] bids;
        
        bool rideStart;
        bool rideFinish;
        bool riderPaymentPermission;
        bool paymentFinish;
        
        string source;
        string destination;
    }
    
    constructor() public {
       addressRiderID[msg.sender]=5000;
    }
    
    function registerDriver() public payable returns(string memory) {
        require(addressDriverID[msg.sender] == 0,"Already registered as Driver.");
        return "Already registered as Driver.";
    }
    
    function registerRider() public payable returns(string memory) {
        require(addressRiderID[msg.sender] == 0, "Already registered as Rider.");
    
Aug 13, 2019 14:31:49 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;

contract DeUber{
    
    mapping(address => uint) addressRiderID;
    mapping(address => uint) addressDriverID;
    
    struct Ride {
        uint rideID;
        uint riderID;
        uint driverID;
        uint totalCost;
        uint[] bids;
        
        bool rideStart;
        bool rideFinish;
        bool riderPaymentPermission;
        bool paymentFinish;
        
        string source;
        string destination;
    }
    
    constructor() public {
       addressRiderID[msg.sender]=5000;
    }
    
    function registerDriver() public payable returns(string memory) {
        require(addressDriverID[msg.sender] == 0,"Already registered as Driver.");
        return "Already registered as Driver.";
    }
    
    function registerRider() public payable returns(string memory) {
        require(addressRiderID[msg.sender] == 0, "Already registered as Rider.");
        return "Already regi
Aug 13, 2019 14:25:35 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 {sd
    value = _value;
  }

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

  uint value;
Aug 12, 2019 15:57:06 UTC
pragma solidity ^0.4.25;

contract SupplyChain {
    
    enum Status { Created, Delivering, Delivered, Accepted, Declined }
    
    Order[] orders;
    
    struct Order {
        string title;
        string description;
        address supplier;
        address deliveryCompany;
        address customer;
        Status status;
    }
    
    event OrderCreated(
        uint256 index,
        address indexed supplier,
        address indexed deliveryCompany,
        address indexed customer
    );
    
    event OrderDelivering(
        uint256 index,
        address indexed supplier,
        address indexed deliveryCompany,
        address indexed customer
    );
    
    event OrderDelivered(
        uint256 index,
        address indexed supplier,
        address indexed deliveryCompany,
        address indexed customer
    );
    
    event OrderAccepted(
        uint256 index,
        address indexed supplier,
        address indexed deliveryCompany,
        address indexed customer
    );
    
    eve
Aug 11, 2019 18:12:05 UTC
pragma solidity ^0.4.25;

contract SupplyChain {
    
    enum Status { Created, Delivering, Delivered, Accepted, Declined }
    
    Order[] orders;
    
    struct Order {
        string title;
        string description;
        address supplier;
        address deliveryCompany;
        address customer;
        Status status;
    }
    
    event OrderCreated(
        uint256 index,
        address indexed supplier,
        address indexed deliveryCompany,
        address indexed customer
    );
    
    event OrderDelivering(
        uint256 index,
        address indexed supplier,
        address indexed deliveryCompany,
        address indexed customer
    );
    
    event OrderDelivered(
        uint256 index,
        address indexed supplier,
        address indexed deliveryCompany,
        address indexed customer
    );
    
    event OrderAccepted(
        uint256 index,
        address indexed supplier,
        address indexed deliveryCompany,
        address indexed customer
    );
    
    eve
Aug 11, 2019 18:11:30 UTC
pragma solidity ^0.4.0;

contract PizzaOrNot{
    
    struct Candidate {
        string name;
        uint voteCount;
    }
    
    struct Voter {
        bool voted;
        uint voteIndex;
        uint weight;
    } 
    address public owner;
    string public name;
    mapping(address => Voter) public voters;
    Candidate[] public candidates;
    uint public auctionEnd;
    
    event ElectionResult(string name, uint voteCount);
    
    
    function Election(string _name, uint durationMinutes, string candidate1, string candidate2) public{ 
            owner = msg.sender;
            name = _name;
            auctionEnd = now + (durationMinutes * 1 minutes);
            candidates.push(Candidate(candidate1,0));
            candidates.push(Candidate(candidate2,0));
    }
    function authorize(address voter) public {
        require(msg.sender == owner);
        require(!voters[voter].voted);
        voters[voter].weight = 1 ;
    }
    
    function vote(uint voteIndex) {
        require(now < auctionE
Aug 08, 2019 14:49:17 UTC
pragma solidity ^0.5.10;

contract Token {
    bytes32 public standard;
    bytes32 public name;
    bytes32 public symbol;
    uint256 public totalSupply;
    uint8 public decimals;
    bool public allowTransactions;
    mapping (address => uint256) public balanceOf;
    mapping (address => mapping (address => uint256)) public allowance;
    function transfer(address _to, uint256 _value) returns (bool success);
    function approveAndCall(address _spender, uint256 _value, bytes _extraData) returns (bool success);
    function approve(address _spender, uint256 _value) returns (bool success);
    function transferFrom(address _from, address _to, uint256 _value) returns (bool success);
}


contract Dex {
  function safeMul(uint a, uint b) internal returns (uint) {
    uint c = a * b;
    assert(a == 0 || c / a == b);
    return c;
  }

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

  function safeAdd(uint a, uint b) internal returns (uint) {
    uint c = 
Aug 08, 2019 09:16:11 UTC
pragma solidity 0.4.16;
 contract token {
     string public standard = 'yuyangray';
     string public name; //代币名称
     string public symbol; //代币符号比如'$'
    //代币单位,展示的小数点后面多少个0,和以太币一样后面是是18个0
     uint8 public decimals = 2;  
     uint256 public totalSupply; //代币总量
     mapping (address => uint256) public balanceOf;
     event Transfer(address indexed from, address indexed to, uint256 value);  
     function token(address _owned, string tokenName, string tokenSymbol) public {
         //合约的管理者获得的代币总量
         balanceOf[_owned] = totalSupply;
         name = tokenName;
         symbol = tokenSymbol;
     }
     function transfer(address _to, uint256 _value) public {
       //从发送者减掉发送额
       balanceOf[msg.sender] -= _value;
       //给接收者加上相同的量
       balanceOf[_to] += _value;
       //通知任何监听该交易的客户端
       Transfer(msg.sender, _to, _value)
Aug 07, 2019 21:51:50 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;
Aug 06, 2019 06:43:15 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) {
    value = 0;
    return value;
  }

  uint value;
Aug 06, 2019 06:07:08 UTC
pragma solidity >=0.4.3 <0.6.0;

contract MeetingContract {
    address owner;
    uint16  private numMeeting;
    Meeting[] private meetings;
    
    constructor () public {
        owner = msg.sender;
    }
    
    function createMeeting(string memory _description) public onlyOwner fieldCantBeEmpty(_description) returns (uint16) {
        require(numMeeting + 1 > numMeeting, "reached maximum number of meetings");
        
        meetings.length = numMeeting + 1;
        meetings[numMeeting] = Meeting({description:_description, amountMembers:0});    
        numMeeting += 1;
        return numMeeting;
    }

    function registerMemberToMeeting(string memory _passport, uint16 _meetingId) public fieldCantBeEmpty(_passport) checkMeetingId(_meetingId)  returns (bool){
        require(numMeeting + 1 > numMeeting, "no meeting places");
        require(checkMemberRegistration(_passport, _meetingId) == false, "this user is already registered");
        
        bytes32 passportHash = getHash(_passport);
        
Aug 03, 2019 16:56:37 UTC
pragma solidity 0.4.16;
 contract token {
     string public standard = 'yuyangray';
     string public name; //代币名称
     string public symbol; //代币符号比如'$'
    //代币单位,展示的小数点后面多少个0,和以太币一样后面是是18个0
     uint8 public decimals = 2;  
     uint256 public totalSupply; //代币总量
     mapping (address => uint256) public balanceOf;
     event Transfer(address indexed from, address indexed to, uint256 value);  
     function token(address _owned, string tokenName, string tokenSymbol) public {
         //合约的管理者获得的代币总量
         balanceOf[_owned] = totalSupply;
         name = tokenName;
         symbol = tokenSymbol;
     }
     function transfer(address _to, uint256 _value) public {
       //从发送者减掉发送额
       balanceOf[msg.sender] -= _value;
       //给接收者加上相同的量
       balanceOf[_to] += _value;
       //通知任何监听该交易的客户端
       Transfer(msg.sender, _to, _value)
Aug 02, 2019 09:30:41 UTC
pragma solidity ^0.5.0;

import "../../sether-interface/contracts/FacebookSetherAPI.sol";

contract MyContract is FacebookSetherAPI {
    event MyEvent(
		bool targetAchieved,
		bytes32 requestID
    );

	uint64 targetLikes;

	constructor() public 
	{
		targetLikes = 1000;
	}

    function checkFacebookLikesTarget( bytes32 setherToken, bytes32 date, bytes32 targetId, uint8 level, bytes32 requestID) public
    {
        super.get_facebook_page_likes(setherToken, "", date, targetId, level, requestID);
    }

	function callback(uint64 setherMetric, bytes32 requestID) public
	{
        emit MyEvent(setherMetric >= targetLikes, requestID);
	}
Aug 01, 2019 09:09:41 UTC
pragma solidity ^0.5.0;

import "../../sether-interface/contracts/FacebookSetherAPI.sol";

contract MyContract is FacebookSetherAPI {
    event MyEvent(
		bool targetAchieved,
		bytes32 requestID
    );

	uint64 targetLikes;

	constructor() public 
	{
		targetLikes = 1000;
	}

    function checkFacebookLikesTarget( bytes32 setherToken, bytes32 date, bytes32 targetId, uint8 level, bytes32 requestID) public
    {
        get_facebook_page_likes(setherToken, "", date, targetId, level, requestID);
    }

	function callback(uint64 setherMetric, bytes32 requestID) public
	{
        emit MyEvent(setherMetric >= targetLikes, requestID);
	}
Aug 01, 2019 08:52:31 UTC
pragma solidity ^0.4.24;

contract tbdocs {

    address owner;

    string public testData;

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

    function getOwner() public view returns (address) {
        return owner;
    }

    function setTestData(string data) public returns (string) {
        testData = data;
        return testData;
    }

    function getTestData() public view returns (string) {
        return testData;
    }
Aug 01, 2019 01:35:26 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  function sets(uint _value) public {
    value = _value;
  }

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

  uint value;
Jul 30, 2019 06:38:24 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;
Jul 30, 2019 06:37:36 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.5.7;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

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

  uint value;
Jul 29, 2019 12:27:47 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+1;
  }

  uint value;
Jul 24, 2019 19:54:13 UTC
pragma solidity ^0.5.0;

import "../../sether-interface/contracts/FacebookSetherAPI.sol";

contract MyContract is FacebookSetherAPI {
    event MyEvent(
		uint64 setherMetric,
		string requestID
    );
	
	uint64 target_likes;
	
	constructor() public 
	{
		target_likes = 1000;
	}

	function callback(uint64 setherMetric, string memory requestID) public
	{
		if(setherMetric >= target_likes)
		{
			emit MyEvent(setherMetric, requestID);
		}
	}
Jul 24, 2019 02:36:10 UTC
pragma solidity ^0.5.0;

import "../../sether-interface/contracts/FacebookSetherAPI.sol";

contract MyContract is FacebookSetherAPI {
    event MyEvent(
		uint64 setherMetric,
		string requestID
    );
	
	constructor() public 
	{
	}

	function callback(uint64 setherMetric, string memory requestID) public
	{
		emit MyEvent(setherMetric, requestID);
	}
Jul 24, 2019 02:28:27 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 sumPublic(uint _value) public returns (uint) {
    value += _value;
    return value;
  }

  function sumExternal(uint _value) public returns (uint) {
    value += _value;
    return value;
  }

  function getPublic(uint _value) public returns (uint) {
    return value;
  }

  function getExternal(uint _value) public returns (uint) {
    return value;
  }

  uint value;
Jul 22, 2019 18:36:28 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 sumPublic(uint _value) public returns (uint) {
    return value;
  }

  function sumExternal(uint value) public returns (uint) {
    return value;
  }

  uint value;
Jul 22, 2019 18:28:57 UTC
pragma solidity ^0.4.25;

//copy by wiki https://theethereum.wiki/w/index.php/ERC20_Token_Standard

// ----------------------------------------------------------------------------
// 'FIXED' 'Example Fixed Supply Token' token contract
//
// Symbol      : FIXED
// Name        : Example Fixed Supply Token
// Total supply: 1,000,000.000000000000000000
// Decimals    : 18
//
// Enjoy.
//
// (c) BokkyPooBah / Bok Consulting Pty Ltd 2018. The MIT Licence.
// ----------------------------------------------------------------------------


// ----------------------------------------------------------------------------
// Safe maths
// ----------------------------------------------------------------------------
library SafeMath {
    function add(uint a, uint b) internal pure returns (uint c) {
        c = a + b;
        require(c >= a);
    }
    function sub(uint a, uint b) internal pure returns (uint c) {
        require(b <= a);
        c = a - b;
    }
    function mul(uint a, uint b) internal pure returns (uint c)
Jul 21, 2019 01:33:31 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;
Jul 18, 2019 22:07: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;
Jul 16, 2019 11:26:08 UTC
pragma solidity ^0.4.24;

// This is a very simple subscription contract 
// Puts into context how to manage periodic states 
// Using Lazy Evaluation. It uses 

import "openzeppelin-solidity/contracts/ECRecovery.sol";
import "openzeppelin-solidity/contracts/math/SafeMath.sol";
import "openzeppelin-solidity/contracts/ownership/Ownable.sol";
import "openzeppelin-solidity/contracts/token/ERC20/ERC20.sol";


contract Subscription is Ownable {
    using ECRecovery for bytes32;
    using SafeMath for uint256;

    constructor() public { }



    // similar to a nonce that avoids replay attacks this allows a single execution
    // every x seconds for a given subscription
    // subscriptionHash  => next valid block number
    mapping(bytes32 => uint256) public nextValidTimestamp;

    // for some cases of delegated execution, this contract will pay a third party
    // to execute the transfer. If this happens, the owner of this contract must
    // sign the subscriptionHash
    mapping(bytes32 => bool) public publ
Jul 15, 2019 20:36:20 UTC

//

contract Eager {
    uint256 public variable; 

    // This function will be called 
    // You need to trust it!
    function increment(){
        a++;
    }
}


contract Lazy {
    uint256 public variable; 

    // This function will be called 
    // You need to trust it!
    function increment(){
        a++;
    }
Jul 15, 2019 16:02:58 UTC


contract Eager {
    uint256 public a; 

    function increment(){
        a++;

    }
Jul 15, 2019 15:59:04 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.26;
contract SimpleStore {
  using SafeMath for uint;

  function getChangeOrderOfOpps() public constant returns (uint) {
    uint amt = uint(1000).mul(10**18);
    uint percent = 75;
    uint res = amt.mul(percent.div(100));
    return res;
  }

  function getWithoutPrecision() public constant returns (uint) {
    uint amt = uint(1000).mul(10**18);
    uint percent = 75;
    uint res = amt.mul(percent).div(100);
    return res;
  }

  function getWithPrecision() public constant returns (uint) {
    uint amt = uint(1000).mul(10**18);
    uint percent = uint(75).mul(10**18);
    uint denominator = uint(100).mul(10**18);
    uint res = amt.mul(percent).div(denominator);
    return res;
  }
}

/**
 * @title SafeMath
 * @dev Math operations with safety checks that revert on error
 */
library SafeMath {
    int256 constant private INT256_MIN = -2**255;

    /**
    * @dev Multiplies two unsigned integers, r
Jul 11, 2019 16:13:20 UTC
pragma solidity ^0.4.18;


/**
 * @title SafeMath
 * @dev Math operations with safety checks that revert on error
 */
library SafeMath {
    int256 constant private INT256_MIN = -2**255;

    /**
    * @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 Multiplies two signed integers, reverts on overflow.
    */
    function mul(int256 a, int256 b) internal pure returns (int256) {
        // 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/OpenZe
Jul 11, 2019 16:13:00 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.24;

/**
 * @title SafeMath
 * @dev Math operations with safety checks that revert on error
 */
library SafeMath {
    int256 constant private INT256_MIN = -2**255;

    /**
    * @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 Multiplies two signed integers, reverts on overflow.
    */
    function mul(int256 a, int256 b) internal pure returns (int256) {
        // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
    
Jul 11, 2019 16:11:45 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.5.0;


library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");

        return c;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b <= a, "SafeMath: subtraction overflow");
        uint256 c = a - b;

        return c;
    }

    /**
     * @dev Returns the multiplicati
Jul 11, 2019 16:01:26 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;
Jul 11, 2019 16:00:46 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.26;
contract DoubleMap {
  struct Average {
      uint total;
      uint count;
  }
  mapping(string => mapping(string => Average)) AvgValues;

  function getValuesAtIndex(string owner, string id) public view returns (uint a){
    return (AvgValues[owner][id].total);
  }
}
Jul 09, 2019 16:40:09 UTC
pragma solidity ^0.4.26; 

contract test {
    uint total;
    uint counter;

    function calcAverage( uint _newValue) public
    {
        total += _newValue;
        counter++;
    }

    function get() public view returns(uint)
    {
        return total / counter;
    }
Jul 09, 2019 07:46:27 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;
Jul 05, 2019 15:40:38 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {

 struct Token {
    uint TokenID;
    string Text;
  }

  mapping (uint => Token) tokenz;
  
  function setToken(uint IDD, uint _TokenID, string _Text) public {
    var tok = tokenz[IDD];
    
    tok.TokenID = _TokenID;
    tok.Text = _Text;
  }

  function get_token_by_IDD(uint _IDD) public view returns(uint __TokenID, string __Text){
    var __tok = tokenz[_IDD];
    __TokenID = __tok.TokenID;
    __Text = __tok.Text;
  }
    
Jul 05, 2019 14:14:09 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {

 struct Token {
    uint TokenID;
    string Text;
  }

  mapping (uint => Token) tokenz;
  

  function setToken(uint IDD, uint _TokenID, string _Text) public {
    var tok = tokenz[IDD];
    
    tok.TokenID = _TokenID;
    tok.Text = _Text;
  }

  function get_token_by_IDD(uint _IDD) public view returns(uint __TokenID, string __Text){
    var __tok = tokenz[_IDD];
    __TokenID = __tok.TokenID;
    __Text = __tok.Text;
  }
    

Jul 05, 2019 10:54:20 UTC
pragma solidity ^0.4.25;

contract contratoDeVentas {
    address public propietario;
    uint256 public fechaDeActualizacion;
    string public descripcion;
    uint public precio;
    bool public aLaVenta = true;	
	
	string public estadoActual;
    event eventoEstadoActual(string _msg, address user, uint amount, uint256 time);
    
    constructor (string memory _descripcion, uint _precio) public payable {
        propietario = msg.sender;
		    fechaDeActualizacion = block.timestamp;
        descripcion = _descripcion;
        precio = _precio;
        emit eventoEstadoActual('Artículo a la venta:', msg.sender, msg.value, block.timestamp);
		estadoActual = 'Artículo a la venta.';
    }
    
   function actualizarPrecio(uint _precio) public soloPropietario {
        precio = _precio;
        emit eventoEstadoActual('Precio actualizado', msg.sender, precio, block.timestamp);
		estadoActual = 'Artículo a la venta.';
    }

    function modificarDescripcion (string memory _descripcion) public soloPropietari
Jul 03, 2019 16:46:32 UTC
pragma solidity ^0.4.18;

contract RegistroDato {
	string dato;
	
	function RegistradDato (string memory _dato) public {
		dato = _dato;
	}

	function verDato() public view returns (string memory) { 
		return (dato);
	}
	
	function cambiaDato(string memory _nuevoDato)  public {
		dato = _nuevoDato;
	}
	
Jul 03, 2019 16:35:15 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.25;
contract CagnotteFestival{
  mapping (address => uint) organisateurs;

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

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

  function estOrga (address orga) public view returns (bool){
    return organisateurs[orga]>0;
  }
Jul 03, 2019 16:27:58 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;
Jul 03, 2019 10:15: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;
Jul 03, 2019 09:47:59 UTC
pragma solidity ^0.4.17;

import "./ContractRegistry.sol";
/* solium-disable security/no-tx-origin*/
contract ScoreCardContract {
  uint public CONTRACT_VERSION = 0;
  string public CONTRACT_NAME = "ScoreCardContract";
  int score = 0;
  mapping(string => timestamp) players;

  event PlayerScored(
    string scoreUUID,
    string playerName,
    uint256 timeOfScore
  );

  constructor(address _contractRegistryAddress, string _scoreUUID) public {
    ContractRegistry contractRegistry = ContractRegistry(_contractRegistryAddress);
    scoreUUID = _scoreUUID;
  }

  function incrementScore(string _playerName) public{
    players[_playerName] = block.timestamp
    score = score + 1;
    emit PlayerScored(scoreUUID, _playerName, players[_playerName]);
  }
Jul 02, 2019 18:03:25 UTC
pragma solidity ^0.4.18;
contract SimpleStore {
  address creator;
  uint a = 10;
  uint b = 20;
  uint c;

  function addition() public {
    creator = msg.sender;
    c = a + b;
  }

  function getResult() constant public returns (uint) {
    return c; // should return 3
  }

  /**********
  Standard kill() function to recover funds 
  **********/

  function kill() public { 
    if (msg.sender == creator)
      selfdestruct(creator);  // kills this contract and sends remaining funds back to creator
  }
Jul 01, 2019 15:39:08 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.5.10;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

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

  uint value;
Jun 30, 2019 11:52:39 UTC
pragma solidity ^0.4.18;

contract A {
    address constant addr = 0x777e5B07Ec41B71aCbA2e32a878f867d5B1B3f09;
    mapping (string => address) private assets;
    string a = "ABCDE";

    function  getByString() payable public  returns(address){
        assets[a] = addr;
        return assets[a];
    }
}

contract B {
    address constant addr = 0x777e5B07Ec41B71aCbA2e32a878f867d5B1B3f09;
    mapping (uint256 => address) private assets;
    uint256 b = 1;
    
    function  getByInt() payable public returns(address){
        assets[b] = addr;
        return assets[b];
    }
Jun 28, 2019 15:41:36 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.5.0;
contract QueueContract {
  
  uint constant QUEUE_SIZE = 5;
  struct Queue {
    string[] data;
    uint front;
    uint back; 
  }

  Queue q;

  function newQueue() {
    q.data = new string[](QUEUE_SIZE);
    q.front = 0;
    q.back = 1;
  }

  function enqueue(string hash) {
    require(q.back != q.front);
    q.data[q.back] = hash;
    q.back  = (q.back + 1) % QUEUE_SIZE;
  }

  function dequeue() returns (string) {
    string memory hash = q.data[q.front];
    q.front  = (q.front + 1) % QUEUE_SIZE;
    return hash;
  }
Jun 28, 2019 06:43:47 UTC
pragma solidity ^0.4.25;

contract checkBug {
    int128[] public firstMethod = [-1, -2, -3];
    int128[] public secondMethod;
    
    function addInt() public {
        int8[3] memory arrTmp = [-1, -2, -3];
        secondMethod = arrTmp;
    }
}
Jun 26, 2019 17:20:33 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;
Jun 24, 2019 11:45:56 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.23;
contract SimpleStore {

    string private _name;
    string private _symbol;
    uint8 private _decimals;


    constructor (string memory name, string memory symbol, uint8 decimals) public {
        _name = name;
        _symbol = symbol;
        _decimals = decimals;
    }
}
Jun 24, 2019 10:45:04 UTC
pragma solidity ^0.4.18;

//Made to Stackexchange question

contract ERC20 {
    function transfer(address _to, uint256 _value)public returns(bool);
    function balanceOf(address tokenOwner)public view returns(uint balance);
    function transferFrom(address from, address to, uint tokens)public returns(bool success);

}

contract SimpleAirdrop {

      ERC20 public token;

        function SimpleAirdrop(address _tokenAddr) public {
        token = ERC20(_tokenAddr);
}

  function getAirdrop() public {
    token.transfer(msg.sender, 100000000000000000000); //18 decimals token
  }


Jun 23, 2019 17:39:35 UTC
pragma solidity ^0.5.9;

contract DAppContract {
    
    enum SDCType {"DC", "AC", "DU"};
    enum ConsentStatus {"OptIn", "OptOut"};
    mapping (string => uint) statusToEventTimer; 
    enum ConsentModel {"auto_opt_in", "explicit_opt_in"};
    ConsentModel consent_model;
    
    event StatusChanged(string status);

    address organizerAddr;
    mapping (string => address) public vendorToCreator;

    struct Organizer {
        SDCType type;
        string vendorId;
        uint joinedAt;  //timestamp
        uint exitedAt;
    }
    struct Creator {
        SDCType type;
        string vendorId;
        uint joinedAt;  //timestamp
        uint exitedAt;
    }    
    Creator[] public creators;

    struct Subcriber {
        SDCType type;    // 'DU'
        string vendorId;
    }

    struct Investor {
        string podId;
        uint joinedAt;  //timestamp
        uint exitedAt;
        ConsentStatus status;
    }
    Investor[] private investors;
    struct DataSource {
        string type;    //  lo
Jun 22, 2019 16:04:33 UTC
pragma solidity ^0.5.9;

contract DAppContract {
    
    enum SDCType {"DC", "AC", "DU"};
    enum ConsentStatus {"OptIn", "OptOut"};
    mapping (string => uint) statusToEventTimer; 
    enum ConsentModel {"auto_opt_in", "explicit_opt_in"};
    ConsentModel consent_model;
    
    event StatusChanged(string status);

    address organizerAddr;
    mapping (string => address) public vendorToCreator;

    struct Organizer {
        SDCType type;
        string vendorId;
        uint joinedAt;  //timestamp
        uint exitedAt;
    }
    struct Creator {
        SDCType type;
        string vendorId;
        uint joinedAt;  //timestamp
        uint exitedAt;
    }    
    Creator[] public creators;

    struct Subcriber {
        SDCType type;    // 'DU'
        string vendorId;
    }

    struct Investor {
        string podId;
        uint joinedAt;  //timestamp
        uint exitedAt;
        ConsentStatus status;
    }
    Investor[] private investors;
    struct DataSource {
        string type;    //  lo
Jun 22, 2019 16:02:09 UTC
pragma solidity ^0.4.0;

contract first is Bank {
    
    string private name; 
    uint private age; 
    
    function setName(string newName) {
        name = newName; 
    }
    
    function getName() returns (string) {
        return name; 
    }

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

    function getAge() returns (string) { 
      return age; 
    }
}
Jun 21, 2019 08:31:10 UTC
pragma solidity >=0.4.22 <0.6.0;

contract OwnedToken {
    // `TokenCreator` is a contract type that is defined below.
    // It is fine to reference it as long as it is not used
    // to create a new contract.
    TokenCreator creator;
    address owner;
    bytes32 name;

    // This is the constructor which registers the
    // creator and the assigned name.
    constructor(bytes32 _name) public {
        // State variables are accessed via their name
        // and not via e.g. `this.owner`. Functions can
        // be accessed directly or through `this.f`,
        // but the latter provides an external view
        // to the function. Especially in the constructor,
        // you should not access functions externally,
        // because the function does not exist yet.
        // See the next section for details.
        owner = msg.sender;

        // We do an explicit type conversion from `address`
        // to `TokenCreator` and assume that the type of
        // the calling contract is `TokenCrea
Jun 20, 2019 22:06:08 UTC
contract delegable {
    uint public number = 7;

    function Store(uint n) public {
        number = n;
    }
    
    
    function Return() public view returns (uint) {
        return number;
    }
}

contract frontend {
    uint public number;
    address delegate;
    
    constructor(address access) {
        delegate = access;
    }
    
    function returnDelegableNumber() public view returns (uint) {
        return delegable(delegate).Return();
    }
    
    function storeNumber() public {
        delegate.delegatecall(bytes4(sha3("Store(uint256)")), 123);
    }
    
    function returnNumber() public view returns (uint) {
        delegate.delegatecall(bytes4(sha3("Return()")));

        assembly {
                    // determine size of return data
                let size := returndatasize
        
                // load
                let ptr := mload(0x40)
                returndatacopy(ptr, 0, size)
        
                return(ptr, size)
        }
    }
Jun 20, 2019 20:23:01 UTC
pragma solidity ^0.5.1;

contract MainMarket {

    enum Position { Short, Long }

    struct AuxiliaryMarket {
        address addr;
        Position position;
    }

    AuxiliaryMarket auxiliaryMarket;



    constructor() public {

    }
}

contract MainMarketInterface {

    //Withdraw 5% to holders
    function withdraw() external;

    //Convert the asset tokens to Zap Tokens
    function exchangeZap() private;

    //Disperse funds to holders 5% fee based on percentage of stake
    function disperseFunds() private;

    //Self destruct the contract if it goes bankrupt
    function selfDestruct() external;

    //Deposits Zap Tokens to MainMarket Contract
    function deposit() payable external;

    //Get current Zap price
    function getZapPrice() external;

Jun 20, 2019 18:13:50 UTC
pragma solidity ^0.5.1;

contract MainMarket {

    enum Position { Short, Long }

    struct AuxiliaryMarket {
        address addr;
        Position position;
    }

    AuxiliaryMarket auxiliaryMarket;



    constructor() public {

    }
Jun 20, 2019 18:12:49 UTC
pragma solidity ^0.4.24;

contract Democratos {
  // This declares a new complex type which will
  // be used for variables later.
  // It will represent a single voter.
  struct Voter {
    uint weight; // weight is accumulated by delegation
    bool voted;  // if true, that person already voted
    uint vote;   // index of the voted proposal
  }

  // This is a type for a single proposal.
  struct Proposal {
    bytes32 name;   // short name (up to 32 bytes)
    uint voteCount; // number of accumulated votes
  }

  address public chairperson;

  // This declares a state variable that
  // stores a `Voter` struct for each possible address.
  mapping(address => Voter) public voters;

  // A dynamically-sized array of `Proposal` structs.
  Proposal[] public proposals;
  bytes32[] public proposalNames;
  address[] public votersAddress;

  /// Create a new ballot to choose one of `proposalNames`.
  function Demoscratos(bytes32[] pNames) public {
    chairperson = msg.sender;
    voters[chairperson].weight = 1;

Jun 20, 2019 17:16:17 UTC
pragma solidity >=0.4.21 <0.6.0;

contract Oracle {
  Request[] requests; //list of requests made to the contract
  uint currentId = 0; //increasing request id
  uint minQuorum = 2; //minimum number of responses to receive before declaring final result
  uint totalOracleCount = 3; // Hardcoded oracle count
Jun 20, 2019 16:37:49 UTC
pragma solidity >=0.4.21 <0.6.0;
contract Oracle {
 Request[] requests; //list of requests made to the contract
 uint currentId = 0; //increasing request id
 uint minQuorum = 2; //minimum number of responses to receive before declaring final result
 uint totalOracleCount = 3; // Hardcoded oracle count
Jun 20, 2019 16:34:57 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract MakerDaoSandbox {
  uint constant WAD = 10 ** 18;
    uint constant RAY = 10 ** 27;

  function add(uint x, uint y) internal pure returns (uint z) {
        require((z = x + y) >= x);
    }
    function sub(uint x, uint y) internal pure returns (uint z) {
        require((z = x - y) <= x);
    }
    function mul(uint x, uint y) internal pure returns (uint z) {
        require(y == 0 || (z = x * y) / y == x);
    }

    function min(uint x, uint y) internal pure returns (uint z) {
        return x <= y ? x : y;
    }
    function max(uint x, uint y) internal pure returns (uint z) {
        return x >= y ? x : y;
    }
    function imin(int x, int y) internal pure returns (int z) {
        return x <= y ? x : y;
    }
    function imax(int x, int y) internal pure returns (int z) {
        return x >= y ? x : y;
    }
    function wmul(uint x, uint y) internal pure returns (uint z) {
        
Jun 19, 2019 15:17:48 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  uint constant WAD = 10 ** 18;
    uint constant RAY = 10 ** 27;

  function add(uint x, uint y) internal pure returns (uint z) {
        require((z = x + y) >= x);
    }
    function sub(uint x, uint y) internal pure returns (uint z) {
        require((z = x - y) <= x);
    }
    function mul(uint x, uint y) internal pure returns (uint z) {
        require(y == 0 || (z = x * y) / y == x);
    }

    function min(uint x, uint y) internal pure returns (uint z) {
        return x <= y ? x : y;
    }
    function max(uint x, uint y) internal pure returns (uint z) {
        return x >= y ? x : y;
    }
    function imin(int x, int y) internal pure returns (int z) {
        return x <= y ? x : y;
    }
    function imax(int x, int y) internal pure returns (int z) {
        return x >= y ? x : y;
    }
    function wmul(uint x, uint y) internal pure returns (uint z) {
        z = 
Jun 19, 2019 08:02:33 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.16;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

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

  uint value;
Jun 18, 2019 07:53:23 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.5.9;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

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

  uint value;
Jun 17, 2019 11:31:13 UTC
pragma solidity >=0.4.0 <0.7.0;

contract SimpleStorage {

    uint8 storedData;

    function set(uint8 x) public {
        storedData = x;
    }

    function get() public view returns (uint8) {
        return storedData;
    }

Jun 16, 2019 20:32:14 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 nomDArtiste) public {
    if (creneauxLibres > 0) {
      passagesArtistes[12-creneauxLibres] = nomDArtiste;
      creneauxLibres -= 1;
    }
  }

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

  function artisteEnCours () public constant returns (string) {
    if (tour <= 12){
    return passagesArtistes[tour];
    } else {
      return "FIN";
    }
  }
Jun 14, 2019 22:47:49 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 nomDArtiste) public {
    if (creneauxLibres > 0) {
      passagesArtistes[12-creneauxLibres] = nomDArtiste;
      creneauxLibres -= 1;
    }
  }

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

  function artisteEnCours () public constant returns (string) {
    if (tour <= 12){
    return passagesArtistes[tour];
    } else {
      return "FIN";
    }
  }
Jun 14, 2019 16:36:19 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 nomDArtiste) public {
    if (creneauxLibres > 0) {
      passagesArtistes[12-creneauxLibres] = nomDArtiste;
      creneauxLibres -= 1;
    }
  }

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

  function artisteEnCours () public constant returns (string) {
    return passagesArtistes[tour];
  }
Jun 14, 2019 15:24:35 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; //not used

    result = keccak256(uint256(81768547281677189180385955625970379636532081546421658959342142865864158412140));
  }

  function get() public constant returns (uint256) {

    return uint256(result);
  }

  bytes32 result;
  uint value;
Jun 13, 2019 15:51:25 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; //not used

    result = keccak256(uint256(81768547281677189180385955625970379636532081546421658959342142865864158412140));
  }

  function get() public constant returns (bytes32) {

    return result;
  }

  bytes32 result;
  uint value;
Jun 13, 2019 09:32:38 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;

    //bytes32 input = "0123456789012345678901234567890123456789";

    result = keccak256(uint256(81768547281677189180385955625970379636532081546421658959342142865864158412140));
  }

  function get() public constant returns (bytes32) {

    return result;
  }

  bytes32 result;
  uint value;
Jun 13, 2019 09:31:59 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;

    result = keccak256("0123456789012345678901234567890123456789");
  }

  function get() public constant returns (bytes32) {

    return result;
  }

  bytes32 result;
  uint value;
Jun 13, 2019 09:09:25 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;
Jun 12, 2019 11:51:51 UTC
pragma solidity ^0.4.18;

import './levels/base/Level.sol';
import 'zeppelin-solidity/contracts/ownership/Ownable.sol';

contract Ethernaut is Ownable {

  // ----------------------------------
  // Owner interaction
  // ----------------------------------

  mapping(address => bool) registeredLevels;

  // Only registered levels will be allowed to generate and validate level instances.
  function registerLevel(Level _level) public onlyOwner {
    registeredLevels[_level] = true;
  }

  // ----------------------------------
  // Get/submit level instances
  // ----------------------------------

  struct EmittedInstanceData {
    address player;
    Level level;
    bool completed;
  }

  mapping(address => EmittedInstanceData) emittedInstances;

  event LevelInstanceCreatedLog(address indexed player, address instance);
  event LevelCompletedLog(address indexed player, Level level);

  function createLevelInstance(Level _level) public payable {

    // Ensure level is registered.
    require(registeredLevels[
Jun 12, 2019 07:59:40 UTC
pragma solidity ^0.4.13;

contract DSAuthority {
    function canCall(address src, address dst, bytes4 sig) public view returns (bool);
}

contract DSAuthEvents {
    event LogSetAuthority (address indexed authority);
    event LogSetOwner     (address indexed owner);
}

contract DSAuth is DSAuthEvents {
    DSAuthority  public  authority;
    address      public  owner;

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

    function setOwner(address owner_)
        public
        auth
    {
        owner = owner_;
        LogSetOwner(owner);
    }

    function setAuthority(DSAuthority authority_)
        public
        auth
    {
        authority = authority_;
        LogSetAuthority(authority);
    }

    modifier auth {
        require(isAuthorized(msg.sender, msg.sig));
        _;
    }

    function isAuthorized(address src, bytes4 sig) internal view returns (bool) {
        if (src == address(this)) {
            return true;
        } else if (src == o
Jun 11, 2019 08:30:10 UTC
pragma solidity ^0.4.13;

contract DSAuthority {
    function canCall(
        address src, address dst, bytes4 sig
    ) public view returns (bool);
}

contract DSAuthEvents {
    event LogSetAuthority (address indexed authority);
    event LogSetOwner     (address indexed owner);
}

contract DSAuth is DSAuthEvents {
    DSAuthority  public  authority;
    address      public  owner;

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

    function setOwner(address owner_)
        public
        auth
    {
        owner = owner_;
        LogSetOwner(owner);
    }

    function setAuthority(DSAuthority authority_)
        public
        auth
    {
        authority = authority_;
        LogSetAuthority(authority);
    }

    modifier auth {
        require(isAuthorized(msg.sender, msg.sig));
        _;
    }

    function isAuthorized(address src, bytes4 sig) internal view returns (bool) {
        if (src == address(this)) {
            return true;
        } els
Jun 11, 2019 08:21:22 UTC

pragma solidity ^0.4.24;

import "./AddressUtils.sol";
import "./Ownable.sol";

contract Registry is Ownable {

    event RegistryCreated(address addressOfRegistryContract,address from );

    mapping (address => address) public addresses;
    mapping (address => bool) public userPreferences;
    address[] public validImplementations;
    
  
    constructor() public {
        emit RegistryCreated(address(this),msg.sender);
    }
    function setImplementationAddress(address newAddress) public {
        require(newAddress != 0, "cant set value to 0");
        require(checkValidImplementationAddress(newAddress), "not a valid implementation address");
        addresses[msg.sender] = newAddress;
    }

    function checkValidImplementationAddress(address addr) internal view returns (bool) {
        for(uint i = 0; i < validImplementations.length; ++i) {
            if (addr == validImplementations[i]) return true;
        }
        return false;
    }

    function addImplementation(address toAdd) external only
Jun 10, 2019 06:35:32 UTC
➜  ~ ssh [email protected] -p 2220
[email protected]:~$ ls
readme
[email protected]:~$ cat readme
boJ9jbbUNNfktd78OOpsqOltutMc3MY1
[email protected]:~
Jun 10, 2019 03:51:20 UTC
pragma solidity ^0.4.21;


contract GPMCoin {
    // Public variables of the token
    // Start pre ICO 28.05.19
    // price $0,15
    // Start ICO 16.07.19 
    // price $0,3
    address public owner;
    string public name = "GPMCoin";
    string public symbol = "GPM";
    uint8 public decimals = 18;
    bool public frozen;
    uint256 public totalSupply = 18000000 * 10 ** uint256(decimals);



    // This creates an array with all balances
    mapping (address => uint256) public balanceOf;
    mapping (address => mapping (address => uint256)) public allowance;


    // This generates a public event on the blockchain that will notify clients
    event Transfer(address indexed from, address indexed to, uint256 value);


    /**
     * Constrctor function
     *
     * Initializes contract with initial supply tokens to the creator of the contract
     */
    function GPMCoin() public {
        balanceOf[msg.sender] = totalSupply;                // Give the creator all initial tokens
        owner = msg.sende
Jun 06, 2019 08:52:41 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.20;
contract SimpleStore {
function getWinNumbers(string bitcoinBlockHash, uint _numbersCount, uint _numbersCountMax) public pure returns (bytes){
        bytes32 random = keccak256(bitcoinBlockHash);
        bytes memory allNumbers = new bytes(_numbersCountMax);
        bytes memory winNumbers = new bytes(_numbersCount);

        for (uint i = 0; i < _numbersCountMax; i++) {
            allNumbers[i] = byte(i + 1);
        }

        for (i = 0; i < _numbersCount; i++) {
            uint n = _numbersCountMax - i;

            uint r = (uint(random[i * 4]) + (uint(random[i * 4 + 1]) << 8) + (uint(random[i * 4 + 2]) << 16) + (uint(random[i * 4 + 3]) << 24)) % n;

            winNumbers[i] = allNumbers[r];

            allNumbers[r] = allNumbers[n - 1];

        }
        return winNumbers;
    }

  uint value;
Jun 05, 2019 20:56:57 UTC
// mapping struct to eth-address

pragma solidity ^0.4.18;
contract SimpleStore {

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


  struct User {
    uint age;
    string name;
    string role;
  }

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

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

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

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

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

  function get_info_by_address(address _add_) public view returns(address __address, uint __age, string __name, string __r
Jun 05, 2019 12:02:41 UTC
pragma solidity ^0.4.19;

// Our first contract is a faucet!
contract Faucet {

    // Give out ether to anyone who asks
    function withdraw(uint withdraw_amount) public {

        // Limit withdrawal amount
        require(withdraw_amount <= 100000000000000000);

        // Send the amount to the address that requested it
        msg.sender.transfer(withdraw_amount);
    }

    // Accept any incoming amount
    function () public payable {}

Jun 05, 2019 02:55:03 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;
Jun 04, 2019 14:58:16 UTC
pragma solidity ^0.4.26;

contract Thesis
{
    struct HealthRecord {
        string ipfsHash;
        string prevIpfsHash;
        uint timestamp;
    }
    
    HealthRecord[] healthrecords;
    
    function exists(string hash) public view returns (bool, bool) {
      bool hash1exists = false;
      bool hash2exists = false;
      for (uint i = 0; i < healthrecords.length - 1; i++) {
        string storage a = healthrecords[i].ipfsHash;
        string storage b = healthrecords[i].prevIpfsHash;
        if (keccak256(abi.encodePacked(a)) == keccak256(abi.encodePacked(hash))) {
          hash1exists = true;
        }
        if (keccak256(abi.encodePacked(b)) == keccak256(abi.encodePacked(hash))) {
          hash2exists = true;
        }
      }
      return (hash1exists, hash2exists);
    }

    function addHealthRecord(string ipfsHash, string prevIpfsHash) public {
      
      bool a;
      bool b;
      bool c;
      bool d;
      
      //require that ipfsHash doesn't exist in the blockchain
      (a, b)
Jun 04, 2019 09:50:13 UTC
pragma solidity ^0.4.26;

contract Thesis
{
    struct HealthRecord {
        string ipfsHash;
        string prevIpfsHash;
        uint timestamp;
    }
    
    HealthRecord[] healthrecords;
    
    function exists(string hash) public view returns (bool, bool) {
      bool hash1exists = false;
      bool hash2exists = false;
      for (uint i = 0; i < healthrecords.length - 1; i++) {
        string storage a = healthrecords[i].ipfsHash;
        string storage b = healthrecords[i].prevIpfsHash;
        if (keccak256(abi.encodePacked(a)) == keccak256(abi.encodePacked(hash))) {
          hash1exists = true;
        }
        if (keccak256(abi.encodePacked(b)) == keccak256(abi.encodePacked(hash))) {
          hash2exists = true;
        }
      }
      return (hash1exists, hash2exists);
    }

    function addHealthRecord(string ipfsHash, string prevIpfsHash) public {
      bool a;
      bool b;
      bool c;
      bool d;
      (a, b) = exists(ipfsHash);
      ()
      healthrecords.push(HealthRecord(ipfsHash
Jun 04, 2019 09:33:20 UTC
pragma solidity ^0.4.26;

contract Thesis
{
    struct HealthRecord {
        string ipfsHash;
        string prevIpfsHash;
        uint timestamp;
    }
    
    HealthRecord[] healthrecords;
    
    function exists(string hash) public view {
      
    }

    function addHealthRecord(string hash, string prevIpfsHash) public {
      healthrecords.push(HealthRecord(hash, prevIpfsHash, now));
    }

    function getHealthRecords(uint[] indexes)
        public
        returns (string[], string[], uint[])
    {
        string[] memory hashes = new string[](indexes.length);
        string[] memory prev_hashes = new string[](indexes.length);
        uint[] memory timestamps = new uint[](indexes.length);
        
        for (uint i = 0; i < indexes.length; i++) {
            HealthRecord storage healthrecord = healthrecords[indexes[i]];
            hashes[i] = healthrecord.ipfsHash;
            prev_hashes[i] = healthrecord.prevIpfsHash;
            timestamps[i] = healthrecord.timestamp;
        }
        
     
Jun 04, 2019 09:08:03 UTC
    bytes32 private hint; // '0x722074742045753F42742C6575' => "r tt Eu?BT,eu" => "Et tu, Brute?"
    bytes private step; // first one
    bytes32 private tip; // '0x5368616B65737065617265' => "Shakespeare"
    bytes32 private ethcon; // '0x5269676874' => "Right" ascii
    uint[] private plain; // "HACK" -> "8, 0, 2, 11
Jun 03, 2019 17:58:18 UTC
pragma solidity ^0.5.0;

contract Hint {
  bool public assigned;
  bool public set;
  bytes32 private hint;
  bytes private step; // first one
  bytes32 private tip;
  bytes32 private ethcon;
  uint[] private plain;

  HintReward public rewardPool;

  constructor(bytes32 _hint, bytes32 _tip, bytes32 _ethcon, uint[] memory _plain, address _rewardPool) public {
    set = true;
    hint = _hint;
    tip = _tip;
    ethcon = _ethcon;
    plain = _plain;
    rewardPool = HintReward(_rewardPool);
  }

  function assign(bytes32 _hint, bytes memory _step) public returns(bool) {
    require(!assigned);
    require(_hint == hint);
    set = true;
    assigned = true;
    step = _step;
    return true;
  }

  function claim(uint[] memory _answer) public {
    (bool success, bytes memory returnedData) = address(rewardPool).call(abi.encodeWithSelector(rewardPool.check.selector, _answer, plain, step));
    require(returnedData.length >= 0);
    require(success);
  }

  function help() public payable {
    require(msg.value
Jun 03, 2019 17:51:29 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract Company {
  address supporter;
  address owner;
  uint goal;
  uint deadline;
           
  mapping (address => uint256) public pledge;
    
  constructor ( uint256 numDays, uint256 _goal) public {
    owner = msg.sender;
    deadline = now + (numDays * 1 hours);
    goal= _goal;
  }
 
  function Pledge (uint256 amount) public payable {
    require(now < deadline);   
    require(msg.value == amount);
    pledge[msg.sender] += amount;
  }
    
  function claimFunds() public {
    require(address(this).balance >= goal); 
    require(now >= deadline);               
    require(msg.sender == owner);
    msg.sender.transfer(address(this).balance);
  }

  function Fail() public {
    require(address(this).balance < goal);
    require(now >= deadline);
    uint256 amount = pledge[msg.sender];
    pledge[msg.sender] = 0;
    msg.sender.transfer(amount);
  }

Jun 03, 2019 14:11:53 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract Compagn {
   
    address public support;
    uint256 public deposit = 3000;

    constructor() public payable {
        support = msg.sender;
        deposit = msg.value;
    }
      function benificiar () public payable returns (bool) {
        if (msg.value < deposit) {
            support.transfer(msg.value);
            support = msg.sender;
            deposit = msg.value;
            return true;
        } else {
            return false;
        }
    }
Jun 03, 2019 07:28:34 UTC
pragma solidity ^0.5.9;

contract BlockchainTraining {

    address public organiser;
    mapping(bytes32 => bool) private participants;

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

    function addParticipant(string memory name) public {
        
        require(bytes(name).length > 0);
        require(msg.sender == organiser);

        participants[sha256(abi.encodePacked(name))] = true;
    }

    function verify(string memory name) public view returns (bool) {
        
        require(bytes(name).length > 0);

        return (participants[sha256(abi.encodePacked(name))]);
    }
Jun 02, 2019 17:54:58 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract String {
    
    string store = "acderere";
    address public owner;
    
    event LogMessage (string msg, string value);
      
    function getStore () public view returns (string) {
      return store;
    }
    
    function setStore (string _value) public {
        store =_value;
        owner=msg.sender;
    }

Jun 02, 2019 14:41:20 UTC
//Write your own contrasdfsdfdsfsdfcts 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;
Jun 01, 2019 09:36:26 UTC
//Write your own contrasdfsdfdsfsdfcts 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;
Jun 01, 2019 09:35:50 UTC
pragma solidity ^0.4.24;

contract Applicationa {
    function Application() public {}
    enum Assets {
        MotherBoard, Component, ThirdPartyContractor, SensorManufacturer, TAFB, SPO_SCMW, Distributor, MotherBoardManufacturer, OEM, Sensor, Assembler
    }
    Assets _MotherBoardQAInput = Assets.MotherBoard;
    Assets _ComponentQAOutput = Assets.Component;
    Assets _InstallationQAInput = Assets.ThirdPartyContractor;
    Assets _Sensor = Assets.SensorManufacturer;
    Assets _InstallationQAOutput = Assets.ThirdPartyContractor;
    Assets _AssembleComponent = Assets.Component;
    Assets _ComponentQAInput = Assets.Component;
    Assets _RegisterTAFB = Assets.TAFB;
    Assets _TAFB = Assets.SPO_SCMW;
    Assets _RegisterDistributor = Assets.Distributor;
    Assets _ThirdPartyContractor = Assets.TAFB;
    Assets _Component = Assets.Distributor;
    Assets _MotherBoardQAOutput = Assets.MotherBoard;
    Assets _RegisterMotherBoard = Assets.MotherBoardManufacturer;
    Assets _RegisterOEM = Assets.OEM;
    A
Jun 01, 2019 09:35:22 UTC
pragma solidity ^0.4.24;

contract Applicationa {
    function Application() public {}
    enum Assets {
        MotherBoard, Component, ThirdPartyContractor, SensorManufacturer, TAFB, SPO_SCMW, Distributor, MotherBoardManufacturer, OEM, Sensor, Assembler
    }
    Assets _MotherBoardQAInput = Assets.MotherBoard;
    Assets _ComponentQAOutput = Assets.Component;
    Assets _InstallationQAInput = Assets.ThirdPartyContractor;
    Assets _Sensor = Assets.SensorManufacturer;
    Assets _InstallationQAOutput = Assets.ThirdPartyContractor;
    Assets _AssembleComponent = Assets.Component;
    Assets _ComponentQAInput = Assets.Component;
    Assets _RegisterTAFB = Assets.TAFB;
    Assets _TAFB = Assets.SPO_SCMW;
    Assets _RegisterDistributor = Assets.Distributor;
    Assets _ThirdPartyContractor = Assets.TAFB;
    Assets _Component = Assets.Distributor;
    Assets _MotherBoardQAOutput = Assets.MotherBoard;
    Assets _RegisterMotherBoard = Assets.MotherBoardManufacturer;
    Assets _RegisterOEM = Assets.OEM;
    A
Jun 01, 2019 09:35:21 UTC
pragma solidity ^0.4.24;

contract Application {
    function Application() public {}
    enum Assets {
        MotherBoard, Component, ThirdPartyContractor, SensorManufacturer, TAFB, SPO_SCMW, Distributor, MotherBoardManufacturer, OEM, Sensor, Assembler
    }
    Assets _MotherBoardQAInput = Assets.MotherBoard;
    Assets _ComponentQAOutput = Assets.Component;
    Assets _InstallationQAInput = Assets.ThirdPartyContractor;
    Assets _Sensor = Assets.SensorManufacturer;
    Assets _InstallationQAOutput = Assets.ThirdPartyContractor;
    Assets _AssembleComponent = Assets.Component;
    Assets _ComponentQAInput = Assets.Component;
    Assets _RegisterTAFB = Assets.TAFB;
    Assets _TAFB = Assets.SPO_SCMW;
    Assets _RegisterDistributor = Assets.Distributor;
    Assets _ThirdPartyContractor = Assets.TAFB;
    Assets _Component = Assets.Distributor;
    Assets _MotherBoardQAOutput = Assets.MotherBoard;
    Assets _RegisterMotherBoard = Assets.MotherBoardManufacturer;
    Assets _RegisterOEM = Assets.OEM;
    As
Jun 01, 2019 09:35:12 UTC
pragma solidity ^0.4.24;

contract Application {
    function Application() public {}
    enum Assets {
        MotherBoard, Component, ThirdPartyContractor, SensorManufacturer, TAFB, SPO_SCMW, Distributor, MotherBoardManufacturer, OEM, Sensor, Assembler
    }
    Assets _MotherBoardQAInput = Assets.MotherBoard;
    Assets _ComponentQAOutput = Assets.Component;
    Assets _InstallationQAInput = Assets.ThirdPartyContractor;
    Assets _Sensor = Assets.SensorManufacturer;
    Assets _InstallationQAOutput = Assets.ThirdPartyContractor;
    Assets _AssembleComponent = Assets.Component;
    Assets _ComponentQAInput = Assets.Component;
    Assets _RegisterTAFB = Assets.TAFB;
    Assets _TAFB = Assets.SPO_SCMW;
    Assets _RegisterDistributor = Assets.Distributor;
    Assets _ThirdPartyContractor = Assets.TAFB;
    Assets _Component = Assets.Distributor;
    Assets _MotherBoardQAOutput = Assets.MotherBoard;
    Assets _RegisterMotherBoard = Assets.MotherBoardManufacturer;
    Assets _RegisterOEM = Assets.OEM;
    As
May 29, 2019 14:53: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;
May 27, 2019 23:33:21 UTC
pragma solidity ^0.5.0;
import "./oraclizeAPI_0.5.sol";
import "./Strings.sol";

contract BettingContract is usingOraclize
{
    using Strings for string;

    address[] public players;
    string[] public TemperatureGuess;
    uint totalReceived;
    uint playerCount = 0;

    struct Player {
        address addr; //The address of their account
        uint betAmount; //The amount they're betting
        string guess; //What they've made as prediction
    }

    Player[] players;

    //When called for, Oraclize needs to be called and the Total needs to be updated.
    constructor(uint bet) public
    {
        OAR = OraclizeAddrResolverI(0x6f485C8BF6fc43eA212E93BBF8ce046C7f1cb475);
        updateTotalReceived(bet);
    }

    //The Total needs to be counted, so that it can be sent (in total) to the winner(s)
    function updateTotalReceived(uint bet) internal
    {
        totalReceived = totalReceived + bet;
        AddPlayer(/*info*/);
    }

    function AddPlayer(address player, string memory guess ) in
May 27, 2019 09:04:12 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;
May 26, 2019 14:09:10 UTC
// File: contracts/ERC721/ERC721Basic.sol

pragma solidity ^0.4.18;


/**
 * @title ERC721 Non-Fungible Token Standard basic interface
 * @dev see https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md
 */
contract ERC721Basic {
  event Transfer(address indexed _from, address indexed _to, uint256 _tokenId);
  event Approval(address indexed _owner, address indexed _approved, uint256 _tokenId);
  event ApprovalForAll(address indexed _owner, address indexed _operator, bool _approved);

  function balanceOf(address _owner) public view returns (uint256 _balance);
  function ownerOf(uint256 _tokenId) public view returns (address _owner);
  function exists(uint256 _tokenId) public view returns (bool _exists);

  function approve(address _to, uint256 _tokenId) public;
  function getApproved(uint256 _tokenId) public view returns (address _operator);

  function setApprovalForAll(address _operator, bool _approved) public;
  function isApprovedForAll(address _owner, address _operator) public view returns (bool);

May 23, 2019 16:59:49 UTC
pragma solidity ^0.4.21;

contract SimpleStore {
  struct Item {
    uint price;
    uint units; 
  }
  
  Item[] public items;

  function newItem(uint _price, uint _units)
  public
  {
    Item memory item = Item(_price, _units);
    items.push(item);
  }

  function getUsingStorage(uint _itemIdx)
  public
  // set to non-view to estimate gas
  // view
  returns (uint)
  {
    Item storage item = items[_itemIdx];
    return item.units;
  }

  function getUsingMemory(uint _itemIdx)
  public
  // set to non-view to estimate gas
  // view
  returns (uint)
  {
    Item memory item = items[_itemIdx];
    return item.units;
  }

  function addItemUsingStorage(uint _itemIdx, uint _units)
  public
  {
    Item storage item = items[_itemIdx];
    item.units += _units;
  }

  function addItemUsingMemory(uint _itemIdx, uint _units)
  public
  // set to non-view to estimate gas
  // view
  {
    Item memory item = items[_itemIdx];
    item.units += _units;
  }

May 19, 2019 23:05:58 UTC
pragma solidity >=0.4.25 <0.6.0;

contract CupomBrinde {
	enum StateType {AdicionarCupom, CupomCriado,CupomUtilizado}

	StateType public  State;
	address public  Owner;
	string public  Visitante;
    uint public Qtde;
	uint public Retirado;

    constructor(string memory visitante, uint qtde,uint retirado) public
    {
        Owner = msg.sender;
        Visitante = visitante;
        Qtde = qtde;
        Retirado = retirado;
        State = StateType.AdicionarCupom;
    }

    function CriarCupom(uint qtde) public
    {
		Qtde = qtde;
        State = StateType.CupomCriado;
    }

	function UtilizarCupom(uint retirado) public
    {
		Retirado = retirado;
        State = StateType.CupomUtilizado;
    }
}
May 16, 2019 23:13:25 UTC
pragma solidity ^0.4.24;

contract BlockHash {
    event Logging(bytes32);
    event Logging(uint);
    
    function getBlockHash(uint _blockNumber) public view returns (uint blockNumber_, bytes32 blockhash_, uint blockhashToNumber_){
        
        if (_blockNumber == 0){
             _blockNumber = block.number-1;
             
        }
        
        bytes32 _blockhash = block.blockhash(_blockNumber);
        uint _blockhashToNumber = uint(_blockhash);
        
        emit Logging(_blockNumber);
        emit Logging(_blockhash);

    return (_blockNumber, _blockhash, _blockhashToNumber);
    }
}
May 15, 2019 17:19:51 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;
May 13, 2019 10:20:15 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.5.8;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

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

  uint value;
May 13, 2019 08:40:30 UTC
function facebookShare(event) {
    event.preventDefault();

    var title = encodeURIComponent(document.getElementsByTagName("title")[0].innerHTML);
    var url = encodeURIComponent(window.location.href);

    window.open('http://www.facebook.com/sharer.php?u=' + url, 'sharer', 'toolbar=1,status=1');
1
May 11, 2019 16:31:43 UTC
function facebookShare(event) {
    event.preventDefault();

    var title = encodeURIComponent(document.getElementsByTagName("title")[0].innerHTML);
    var url = encodeURIComponent(window.location.href);

    window.open('http://www.facebook.com/sharer.php?u=' + url, 'sharer', 'toolbar=1,status=1');
May 11, 2019 16:29:19 UTC
function facebookShare(event) {
    event.preventDefault();

    var title = encodeURIComponent(document.getElementsByTagName("title")[0].innerHTML);
    var url = encodeURIComponent(window.location.href);

    window.open('http://www.facebook.com/sharer.php?u=' + url, 'sharer', 'toolbar=1,status=1');
May 11, 2019 16:28:56 UTC
pragma solidity ^0.5.0;

contract RandomNumberOracle{
    // @notice This function can be used to generate a random number based on the specific future blockhash
    // @dev The miner of the defined block number has the possiblity to withhold a mined block in order to manipulate the randomness.
    // @param min The lower boundary of the random range (min is part of the range)
    // @param max The upper boundary of the random range (max is part of the range)
    // @param blockNumber The block number which is used to create the random numbers
    // @return A random integer greater or equal to min and smaller or equal to max
    function getRandomNumber(uint256 min, uint256 max, uint256 blockNumber) public view returns(uint256){
        require(block.number > blockNumber);
        return (uint256(blockhash(blockNumber)) % (max - min + 1)) + min;
    }
May 11, 2019 08:07:09 UTC
["American",
"adventurous",
"alcoholic",
"award-winning",
"balanced",
"best",
"big",
"bitter",
"bold",
"bottle-conditioned",
"bottled",
"brewed",
"brewery-fresh",
"bright",
"canned",
"cask-conditioned",
"chilled",
"choice",
"classic",
"clean",
"cold",
"complex",
"crackling",
"craft",
"craft-brewed",
"creamy",
"crisp",
"dark",
"deep",
"home-brewed",
"hoppy",
"ice-cold",
"indulgent",
"innovative",
"intense",
"interesting",
"intoxicating",
"killer",
"layered",
"light",
"limited",
"lively",
"lush",
"macro-brewed",
"maltier",
"malty",
"medium-bodied",
"mellow",
"micro-brewed",
"natural",
"naturally",
"neverending",
"non-alcoholic",
"organic",
"organically produced",
"original",
"pale",
"perfectly balanced",
"delicate",
"delicious",
"dense",
"distinctive",
"drinkable",
"drunk",
"dry",
"dry-hopped",
"elastic",
"elegant",
"exceptional",
"exotic",
"family-owned",
"famous",
"favorite",
"fermented",
"fizzy",
"flavorful",
"flawless",
"floral",
"foamy",
"fragrant",
"fresh",
"freshly brewed",
"frothy",
"full",
"full-bodied
May 10, 2019 12:30:37 UTC
American
adventurous
alcoholic
award-winning
balanced
best
big
bitter
bold
bottle-conditioned
bottled
brewed
brewery-fresh
bright
canned
cask-conditioned
chilled
choice
classic
clean
cold
complex
crackling
craft
craft-brewed
creamy
crisp
dark
deep
home-brewed
hoppy
ice-cold
indulgent
innovative
intense
interesting
intoxicating
killer
layered
light
limited
lively
lush
macro-brewed
maltier
malty
medium-bodied
mellow
micro-brewed
natural
naturally
neverending
non-alcoholic
organic
organically produced
original
pale
perfectly balanced
delicate
delicious
dense
distinctive
drinkable
drunk
dry
dry-hopped
elastic
elegant
exceptional
exotic
family-owned
famous
favorite
fermented
fizzy
flavorful
flawless
floral
foamy
fragrant
fresh
freshly brewed
frothy
full
full-bodied
full-flavored
handcrafted
pioneering
premium
pronounced
proprietary
quintessential
refreshing
rich
richly hopped
robust
sharp
signature
skunk-proof
smoky
smooth
stout
strong
sturdy
superior
the original
thick
thirst-quenching
traditional
unfiltered
unfo
May 10, 2019 12:22:53 UTC
pragma solidity ^0.4.18;
// written for Solidity version 0.4.18 and above that doesnt break functionality

contract Voting {
    // an event that is called whenever a Candidate is added so the frontend could
    // appropriately display the candidate with the right element id (it is used
    // to vote for the candidate, since it is one of arguments for the function "vote")
    event AddedCandidate(uint candidateID);

    // describes a Voter, which has an id and the ID of the candidate they voted for
    struct Voter {
        bytes32 uid; // bytes32 type are basically strings
        uint candidateIDVote;
    }
    // describes a Candidate
    struct Candidate {
        bytes32 name;
        bytes32 party; 
        // "bool doesExist" is to check if this Struct exists
        // This is so we can keep track of the candidates 
        bool doesExist; 
    }

    // These state variables are used keep track of the number of Candidates/Voters 
    // and used to as a way to index them     
    uint numCandidat
May 10, 2019 10:51:57 UTC
pragma solidity ^0.4.24;

contract Votacion {
    
    modifier onlyOwner() {
        require(isOwner(msg.sender));
        _;
    }
    
    uint public voteStartTime;
    uint public voteEndTime;
    uint16 private voterCount;
    string public votingTitle;
    address public owner;
    
    uint16 public accountedVotes;
    uint16 public nulledVotes;
    uint16 public votesRemaining;

    event Voted (bytes24 _token);
    event newVoterId (uint _voterId);
    event voteAccounted (bytes32 _candidateName, uint _votesReceived, uint16 _totalVotesAccounted);
    event voteNulled (uint16 _voterId, uint16 _totalVotesAccounted);
    
    mapping (bytes32 => uint16) private votesReceived;
    mapping (bytes32 => bool) public votesCasted;
    mapping (uint8 => string) public candidateNames1;
    mapping (uint8 => string) public candidateNames2;
    mapping (uint16 => string) public voterIndex;
    mapping (string => bool) internal voterIds;
    bytes32[] private candidateList1;
    bytes32[] private candidateList2;
May 10, 2019 09:16:11 UTC
pragma solidity ^0.4.24;

contract Votacion {
    
    modifier onlyOwner() {
        require(isOwner(msg.sender));
        _;
    }
    
    uint public voteStartTime;
    uint public voteEndTime;
    uint16 private voterCount;
    string public votingTitle;
    address public owner;
    
    uint16 public accountedVotes;
    uint16 public nulledVotes;
    uint16 public votesRemaining;

    event Voted (bytes24 _token);
    event newVoterId (uint _voterId);
    event voteAccounted (bytes32 _candidateName, uint _votesReceived, uint16 _totalVotesAccounted);
    event voteNulled (uint16 _voterId, uint16 _totalVotesAccounted);
    
    mapping (bytes32 => uint16) private votesReceived;
    mapping (bytes32 => bool) public votesCasted;
    mapping (uint8 => string) public candidateNames1;
    mapping (uint8 => string) public candidateNames2;
    mapping (uint16 => string) public voterIndex;
    mapping (string => bool) internal voterIds;
    bytes32[] private candidateList1;
    bytes32[] private candidateList2;
May 09, 2019 21:01:47 UTC
pragma solidity >=0.5.0 <0.7.0;

import "https://github.com/OpenZeppelin/openzeppelin-solidity/contracts/token/ERC20/ERC20.sol";
import "https://github.com/OpenZeppelin/openzeppelin-solidity/contracts/token/ERC20/ERC20Detailed.sol";

contract TokenGenerator is ERC20, ERC20Detailed {
    address account = msg.sender;
    constructor(
        string memory _name, string memory _symbol, uint8 _decimals, uint256 _value
    ) ERC20Detailed(
        _name, _symbol, _decimals
    ) public {
        _mint(account, _value);
    }
May 09, 2019 06:01:19 UTC
//Oscar Ibarhuen-Guereca


pragma solidity >=0.4.22 <0.6.0;

contract Duties {
    
    //The address is the variable that acts as the parties involved in the contract, in this case, the roomates on the agreement.
    address payable [] roommates;
    //The following are the units that are used throughout the contract, including the timer, stake, if the task was done within five or seven days and if the task has been completed. 
    uint totalRoommates;
    uint timeLapse = now - checkTime;
    uint taskId;
    uint sTime;
    uint checkTime;
    uint constant stake = 100;
    uint constant fiveDays = 5;
    uint constant sevenDays = 7;
    
    mapping (uint => bool) taskComplete;
    
    //The following booleans will detect if the following variables apply or not. 
    bool isPayable_ = false;
    bool isLessFiveDay_ = false;
    bool isAssignedCompleted_ = false;
    bool isGreaterFiveDay_ = false;
    
    
    //The events are situations that can happen throughout the time this smart contract is active.
May 08, 2019 23:45:07 UTC