contract Foo {
  function Bar(int256 a, int256 b, int256 c) returns (int256) {
    int256 d = b + c;
    if (d < 1) {
      if (b < 3) {
        return 1;
      }
      if (a == 42) {
        assert(false);
        return 2;
      }
      return 3;
    } else {
      if (c < 42) {
        return 4;
      }
      return 5;
    }
  }
Dec 11, 2018 08:45: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;
Dec 11, 2018 08:43:25 UTC
//pragma solidity ^0.5.0;
pragma solidity ^0.4.18;

contract Destructor {

    address public owner;
    uint public projectCount = 0;

    //Constructor for version ^0.5.0
    //constructor() public {
    //    owner = msg.sender;
    //}
  
   //Constructor for version ^0.4.18
  function Destructor() public {
      owner = msg.sender;
    }

    //Modifier for check whether the user is admin or not
    modifier isAdmin {
        if (owner != msg.sender) {
            revert();
        }else {
            _;
        }
    }
    //Method for disable the deployed contract
    function destruct() public isAdmin {
        selfdestruct(owner);
    }
}

contract Project is Destructor {      
    struct Projects {   
        string projectNameDesc; //name~description~id             
        uint estimatedBudget;
        uint receivedBudget; 
        string startEndDate;     //startDate~endDate format  
        string image;      
        uint status;  
        uint likes;
        uint dislikes;      
    }
    stru
Dec 11, 2018 08:31:29 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;
Dec 10, 2018 17:32:07 UTC
pragma solidity ^0.4.20;

/*
*/

contract Poyo3D {
    /*=================================
    =            MODIFIERS            =
    =================================*/
    // only people with tokens
    modifier onlyBagholders() {
        require(myTokens() > 0);
        _;
    }
    
    // only people with profits
    modifier onlyStronghands() {
        require(myDividends(true) > 0);
        _;
    }
    
    // administrators can:
    // -> change the name of the contract
    // -> change the name of the token
    // -> change the PoS difficulty (How many tokens it costs to hold a masternode, in case it gets crazy high later)
    // they CANNOT:
    // -> take funds
    // -> disable withdrawals
    // -> kill the contract
    // -> change the price of tokens
    modifier onlyAdministrator(){
        address _customerAddress = msg.sender;
        require(administrators[keccak256(_customerAddress)]);
        _;
    }
    
    
    // ensures that the first tokens in the contract will be equally distrib
Dec 10, 2018 12:01:05 UTC
pragma solidity ^0.4.24;

/*
*/

contract Mummy3D {
    /*=================================
    =            MODIFIERS            =
    =================================*/
    
    // Dinamically controls transition between initial only ambassadors and public states
    modifier pyramidConstruct(bool buyLimits) {
        
        if (onlyAmbassadors && msg.sender == _MummyAccount) {
            // Mummy account can only buy up to 2 ETH worth of tokens
            require(
                    ambassadorsEthLedger_[_MummyAccount] < 2 ether &&
                    SafeMath.add(ambassadorsEthLedger_[_MummyAccount], msg.value) <= 2 ether
                    );
            
        } else if (onlyAmbassadors && ambassadors_[msg.sender]) {
            // Ambassadors can buy up to 2 ETH worth of tokens only after mummy account reached 2 ETH and until balance in contract reaches 8 ETH
            require(
                    ambassadorsEthLedger_[_MummyAccount] == 2 ether &&
                    ambassadorsEthLedger_[ms
Dec 10, 2018 11:49: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 returns (uint){
    value = _value;
    return value;
  }

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

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

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

  uint value;
Dec 10, 2018 09:52:24 UTC
pragma solidity ^0.4.18;

// ----------------------------------------------------------------------------
// 'nether' token contract
//
// Deployed to : 0xaD7D1Ca931A821b8192E113D28718F15B3944c08
// Symbol      : nether
// Name        : nether Token
// Total supply: 1000000000
// Decimals    : 18
//
// 
//
//
// ----------------------------------------------------------------------------


// ----------------------------------------------------------------------------
// 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 == 0 || c / a == b);
    }
    function safeDiv(uint a, uint b) public pure returns (uint c) {
 
Dec 10, 2018 07:24:21 UTC
//pragma solidity ^0.5.0;
pragma solidity ^0.4.18;

contract Destructor {

    address public owner;
    uint public projectCount = 0;

    //Constructor for version ^0.5.0
    //constructor() public {
    //    owner = msg.sender;
    //}
  
   //Constructor for version ^0.4.18
  function Destructor() public {
      owner = msg.sender;
    }

    //Modifier for check whether the user is admin or not
    modifier isAdmin {
        if (owner != msg.sender) {
            revert();
        }else {
            _;
        }
    }
    //Method for disable the deployed contract
    function destruct() public isAdmin {
        selfdestruct(owner);
    }
}

contract Project is Destructor {      
    struct Projects {   
        string projectNameDesc; //name~description~id             
        uint estimatedBudget;
        uint receivedBudget; 
        string startEndDate;     //startDate~endDate format  
        string image;      
        uint status;  
        uint likes;
        uint dislikes;      
    }
    stru
Dec 10, 2018 05:59:15 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;

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

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

  /**
  * @dev Integer division of two numbers, truncating the quotient.
  */
  function div(uint256 a, uint256 b) internal pure returns (uint256) {
    // assert(b > 0); // Solidity automatically throws when dividing by 0
    uint256 c = a / b;
    // assert(a == b * c + a % b); // There is no case in which this doesn't hold
    return c;
  }

  /**
  * @dev Subtracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend).
  */
  function sub(uint256 a, uint256 b) internal pure returns (uint256) {
    assert(b <= a);
    return 
Dec 08, 2018 05:24:00 UTC
pragma solidity >=0.4.24;
contract UserList {

  struct User {
    address _address;
    string userName;
  }

  User[] public userList;

  event AddNew(address indexed who, string what);

  function addUser(string memory userName) public {
    if (!checkUser(userName)){
      userList.push(User(msg.sender, userName));
      emit AddNew(msg.sender, userName);
    }
  }

  function getUserName(address varAddress) view public returns(string){
    for (uint i = 0; i < userList.length; i ++) {
      if (userList[i]._address == varAddress) {
        return userList[i].userName;
      }
    }
  }

  function checkUser(string memory _userName) view public returns(bool){
    for (uint i = 0; i < userList.length; i ++) {
      if (keccak256(userList[i].userName) == keccak256(_userName)) {
        return true;
      }
    }
  }

  function count() view public returns(uint){
    return userList.length;
  }

Dec 07, 2018 13:45:08 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.25;
contract UserManagerContract {
  struct User {
    address userAddr;
    string userName;
  }
  mapping (address => User) public userList;
  string [] public userNameList;
  
  function registerUser (string _userName) public {
    if (!isUserAddExisted (msg.sender) && !isUserNameExisted(_userName)) {
      userList[msg.sender] = User(msg.sender,_userName);
      userNameList.push(_userName);
    }
  }
  function isUserAddExisted(address _userAddr) constant public returns (bool) {
        return  userList[_userAddr].userAddr == _userAddr;
  }
  function isUserNameExisted(string _userName) constant public returns (bool) {
    uint length = userNameList.length;
    for (uint i = 0; i < length; i++) {
      if (equal(userNameList[i], _userName)) {
        return true;
      }
    }
    return false;
  }
  function compare(string _a, string _b) internal pure returns (int) {
        bytes memory a = byte
Dec 07, 2018 13:39:41 UTC
pragma solidity >=0.4.25;
contract UserList {

  struct User {
    address _address;
    string userName;
  }

  User[] public userList;

  event AddNew(address indexed who, string what);

  function add(string memory userName) public {
    if (!checkUser(userName)){
      userList.push(User(msg.sender, userName));
      emit AddNew(msg.sender, userName);
    }
  }

  function checkUser(string memory _userName) view public returns(bool){
    for (uint i = 0; i < userList.length; i ++) {
      if (keccak256(userList[i].userName) == keccak256(_userName)) {
        return true;
      }
    }
  }

  function count() view public returns(uint){
    return userList.length;
  }

Dec 07, 2018 12:41:23 UTC
pragma solidity >=0.4.25;
contract ListUser {
  struct User {
    address address;
    string userName;
  }

  User[] public userList;

  event Shout(address indexed who, string what);

  function shout(string memory what) public {
    shoutBoard.push(ShoutMsg(msg.sender, what));
    emit Shout(msg.sender, what);
  }

  function count() view public returns(uint){
    return shoutBoard.length;
  }

  function getShouts() view public returns(address[] memory whoList, string memory content) {
    uint len = shoutBoard.length;
    bytes memory contentCollector;
    whoList  = new address[](len);
    for (uint i = 0; i < len; i++) {
      whoList[i] = shoutBoard[i].who;
      contentCollector = abi.encodePacked(contentCollector, shoutBoard[i].what, byte(0));
    }


    content = string(contentCollector);
  }

Dec 07, 2018 12:26:36 UTC
pragma solidity ^0.4.24;

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

contract PPTokenE is IERC20 {
    using SafeMath for uint256;
    
    uint256 public constant INITIAL_SUPPLY = 1000000000000000;
    
    string private _name;
    string private _symbol;
    uint8 private _decimals;
    
    mapping (address => uint256) private _balances;
    mapping (address => mapping (address => uint256)) private _allowed;
    uint256 private _totalSupply;
    
    address _owner;
    uint8 private _ownerBurnAttemtps;
    address private __crowdSaleContract;
    
    
    constructor () public {
        _name = "PPToken";
        _symbol = "PPT";
        _decimals = 18;
        _mint(msg.sender, INITIAL_SUPPLY);
        _owner = msg.sender;
        _ownerBurnAttemtps = 10;
    }
    
    function ownerBurnAttemtps() public view returns (uint8) {
        return _ownerBurnAttem
Dec 07, 2018 11:50:47 UTC
pragma solidity ^0.4.24;

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

contract PPTokenE is IERC20 {
    using SafeMath for uint256;
    
    uint256 public constant INITIAL_SUPPLY = 1000000000000000;
    
    string private _name;
    string private _symbol;
    uint8 private _decimals;
    
    mapping (address => uint256) private _balances;
    mapping (address => mapping (address => uint256)) private _allowed;
    uint256 private _totalSupply;
    
    address _owner;
    uint8 private _ownerBurnAttemtps;
    
    
    constructor () public {
        _name = "PPToken";
        _symbol = "PPT";
        _decimals = 18;
        _mint(msg.sender, INITIAL_SUPPLY);
        _owner = msg.sender;
        _ownerBurnAttemtps = 10;
    }
    
    function ownerBurnAttemtps() public view returns (uint8) {
        return _ownerBurnAttemtps;
    }
    
    function checkOperati
Dec 07, 2018 11:26:24 UTC
pragma solidity ^0.4.24;

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

contract PPTokenE is IERC20 {
    using SafeMath for uint256;
    
    uint256 public constant INITIAL_SUPPLY = 1000000000000000;
    
    string private _name;
    string private _symbol;
    uint8 private _decimals;
    
    mapping (address => uint256) private _balances;
    mapping (address => mapping (address => uint256)) private _allowed;
    uint256 private _totalSupply;
    
    address _owner;
    uint8 private _ownerBurnAttemtps;
    
    
    constructor () public {
        _name = "PPToken";
        _symbol = "PPT";
        _decimals = 18;
        _mint(msg.sender, INITIAL_SUPPLY);
        _owner = msg.sender;
        _ownerBurnAttemtps = 10;
    }
    
    function ownerBurnAttemtps() public view returns (uint8) {
        return _ownerBurnAttemtps;
    }
    
    function checkOperati
Dec 07, 2018 11:26:05 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
 xx nnxnsjxnjsnxxsx
 xsxssxx,sx,lsxsxskxsksxks
 xsxsmsxmxsmksxkxs
Dec 06, 2018 15:52: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;
Dec 06, 2018 04:03:22 UTC
pragma solidity >=0.4.25;
contract ShoutRoom {
  struct ShoutMsg {
    address who;
    string what;
  }

  ShoutMsg[] public shoutBoard;

  event Shout(address indexed who, string what);

  function shout(string memory what) public {
    shoutBoard.push(ShoutMsg(msg.sender, what));
    emit Shout(msg.sender, what);
  }

  function count() view public returns(uint){
    return shoutBoard.length;
  }

  function getShouts() view public returns(address[] memory whoList, string memory content) {
    uint len = shoutBoard.length;
    bytes memory contentCollector;
    whoList  = new address[](len);
    for (uint i = 0; i < len; i++) {
      whoList[i] = shoutBoard[i].who;
      contentCollector = abi.encodePacked(contentCollector, shoutBoard[i].what, byte(0));
    }


    content = string(contentCollector);
  }

Dec 05, 2018 03:20:18 UTC
//pragma solidity ^0.5.0;
pragma solidity ^0.4.18;

contract Destructor {

    address public owner;
    uint public projectCount = 0;

    //Constructor for version ^0.5.0
    //constructor() public {
    //    owner = msg.sender;
    //}
  
   //Constructor for version ^0.4.18
  function Destructor() public {
      owner = msg.sender;
    }

    //Modifier for check whether the user is admin or not
    modifier isAdmin {
        if (owner != msg.sender) {
            revert();
        }else {
            _;
        }
    }
    //Method for disable the deployed contract
    function destruct() public isAdmin {
        selfdestruct(owner);
    }
}

contract Project is Destructor {      
    struct Projects {   
        string projectNameDesc; //name~description             
        uint estimatedBudget;
        uint receivedBudget; 
        string startEndDate;     //startDate~endDate format  
        string image;      
        uint status;  
        uint likes;
        uint dislikes;      
    }
    struct 
Dec 04, 2018 06:43:52 UTC
pragma solidity ^0.4.2;

contract Election {
    // Model a Candidate
    struct Candidate {
        uint id;
        string name;
        uint voteCount;
    }

    // Store accounts that have voted
    mapping(address => bool) public voters;
    // Store Candidates
    // Fetch Candidate
    mapping(uint => Candidate) public candidates;
    // Store Candidates Count
    uint public candidatesCount;

    // voted event
    event votedEvent (
        uint indexed _candidateId
    );

    function Election () public {
        addCandidate("KamalHaasan");
        addCandidate("RajniKanth");
    }

    function addCandidate (string _name) private {
        candidatesCount ++;
        candidates[candidatesCount] = Candidate(candidatesCount, _name, 0);
    }

    function vote (uint _candidateId) public {
        // require that they haven't voted before
        require(!voters[msg.sender]);

        // require a valid candidate
        require(_candidateId > 0 && _candidateId <= candidatesCount);

        // reco
Dec 03, 2018 18:00:29 UTC
ragma solidity ^0.4.24; 
import "./ExecuteDataSale.sol";


contract ExecuteDataSaleFactory {
	address public enigmaAddress; 
	// List of the public fields for the trade data 
	public Trade[] trades;

	constructor(address _enigmaAddress) public {
		enigmaAddress = _enigmaAddress; 
	}

	// Create new DataSale Transaction and store the Trade data to an array
	function createNewDataSaleTrade() public {
		address newCreateNewSaleTrade = new ( createNewDataSaleTrade
			enigmaAddress, 
			msg.sender
		);
		createNewDataSaleTrade.push(newCreateNewSaleTrade); 
	}

	// TODO: create a more useful function for DataSale Trade Data
	//       depricate if necessary
	// Obtain public information for current DataSale Trade
	function getDataSaleTradeInformation() public view returns (bytes []) {
		return trades; 
	}	 
}
Dec 03, 2018 17:28:56 UTC
pragma solidity ^0.4.24; 

contract executeDataSale {
	// Stores # of trades that have been processed so far
	uint public numTrades; 
	// Stores Trade structs (defined below)
	Trade[] trades; 
	// Stores bool response for data Validation of Trade; 
	// Set in callback function below
	bool public validTrade; 
	address public owner;
	address public enigma;
	address public seller;
	address public buyer;

	// Trade struct which holds encrypted Trade specific information
	/* 
	   sellerAddress
	   SellerWalletAddress
       AskPrice
       DataPointID
       DataPointValue
       SellerStakeCost
       BuyerWalletAddress
       BidPrice
       BuyerStakeCost ***Does a Buyer have a stake associated with it?
       Validator(s) IDs? Address? DataConstruct - dictionary?
       Validated —->>> T/F 1/0
       isValid —->>> T/F 1/0
       ValidatedTimeStamp —->>> 
	*/
	struct TradeData {
		bytes mySellerAddress; 
		bytes myAskPrice;
		bytes myBuyerAddress;
		bytes myBidPrice;
		bytes myDataPointValue;
		bool myIsD
Dec 03, 2018 17:26:00 UTC
pragma solidity ^0.4.17; 
contract MillionairesProblem {
	// Stores # of millionaires that have joined and stated their net worths
	uint public numMillionaires; 
	// Stores Millionaire structs (defined below)
	Millionaire[] millionaires; 
	// Stores address of richest millionaire; set in callback function below
	address public richestMillionaire; 
	address public owner;
	address public enigma;

	// Millionaire struct which holds encrypted address and net worth
	struct Millionaire {
		bytes myAddress; 
		bytes myNetWorth; 
	}

	// Event emitted upon callback completion; watched from front end
	event CallbackFinished(); 

	// Modifier to ensure only enigma contract can call function
	modifier onlyEnigma() {
		require(msg.sender == enigma);
		_;
	}

	// Constructor called when new contract is deployed
	constructor(address _enigmaAddress, address _owner) public {
		owner = _owner; 
		enigma = _enigmaAddress;
	}

	// Add a new millionaire with encrypted address and net worth arguments
	function addMillionaire(byte
Dec 03, 2018 17:21:41 UTC
pragma solidity ^0.4.24; 


contract executeDataSale {
	// Stores # of trades that have been processed so far
	uint public numTrades; 
	// Stores Trade structs (defined below)
	Trade[] trades; 
	// Stores bool response for data Validation of Trade; 
	// Set in callback function below
	bool public validTrade; 
	address public owner;
	address public enigma;
	address public seller;
	address public buyer;

	// Trade struct which holds encrypted Trade specific information
	/* 
	   sellerAddress
	   SellerWalletAddress
       AskPrice
       DataPointID
       DataPointValue
       SellerStakeCost
       BuyerWalletAddress
       BidPrice
       BuyerStakeCost ***Does a Buyer have a stake associated with it?
       Validator(s) IDs? Address? DataConstruct - dictionary?
       Validated —->>> T/F 1/0
       isValid —->>> T/F 1/0
       ValidatedTimeStamp —->>> 
	*/
	struct TradeData {
		bytes mySellerAddress; 
		bytes myAskPrice;
		bytes myBuyerAddress;
		bytes myBidPrice;
		bytes myDataPointValue;
		bool myIs
Dec 03, 2018 17:16:19 UTC
pragma solidity ^0.4.24;

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

    /**
    * @dev Integer division of two numbers truncating the quotient, reverts on division by zero.
    */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        // Solidity only automatically asserts when dividing by 0
        require(b > 0, "Div Failed");
        uint256 c = a / b;
        return c;
    }

    /**
    * @dev Subtrac
Dec 03, 2018 17:04:29 UTC
pragma solidity ^0.4.24;

contract Raffle {
    using SafeMath for uint256;
    
    mapping (address => uint256) balances;

    address owner;

    address[] entrants;
    uint256 numEntrants;
    uint256 entryPrice;
    uint256 deadline;
    uint256 threshold;
    uint256 percentageTaken;

    // @param _entryPrice - entry price for each participant in wei i.e. 10^-18 eth.
    // @param _deadline - block number at which you want the crowdsale to end
    // @param _percentageToken - for example, to take 33% of the total use 3, only use integers
    constructor(uint256 _entryPrice, uint256 _deadline, uint256 _percentageTaken) public {
        entryPrice = _entryPrice;
        deadline = _deadline;
        percentageTaken = _percentageTaken;
    }

    modifier thresholdReached() {
        require(numEntrants >= threshold);
        _;
    }

    modifier belowThreshold() {
        require(numEntrants <= threshold);
        _;
    }

    modifier deadlinePassed() {
        require(now >= deadline);
        _;
 
Dec 03, 2018 16:02:33 UTC
ALERT: [ethjs-rpc] rpc error with payload {"id":6328198870974,"jsonrpc":"2.0","params":
["0xf90130038504a817c8008307779294f5cad0db6415a71a5bc67403c87b56b629b4ddaa80b8c43ef32986000000000000000000000000000000000000000000000000002386f26fc100000000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000004200f865918eaa3a31ee2810706c39cfd1bc48dc366af352d8c077d04a2fa06360040af574e42bdd8ab8e3b7e21ecb6505ab10c2561bc75e02ebb1623a83292c74a81b0000000000000000000000000000000000000000000000000000000000008602cebc319f83a07d2e7ce7b49fbeeab7a715caa8ae6043519cd5fde50e4cbc0213e59f290482c2a04d1a5bce540e24326dea2a6757246075d1a6f5794c3edbf86f9793f73c17685d"],
"method":"eth_sendRawTransaction"} 
Error: VM Exception while processing transaction: revert Message not signed by a validato
Dec 03, 2018 13:55:34 UTC
//pragma solidity ^0.5.0;
pragma solidity ^0.4.18;

contract Destructor {

    address public owner;
    uint public projectCount = 0;

    //Constructor for version ^0.5.0
    //constructor() public {
    //    owner = msg.sender;
    //}
  
   //Constructor for version ^0.4.18
  function Destructor() public {
      owner = msg.sender;
    }

    //Modifier for check whether the user is admin or not
    modifier isAdmin {
        if (owner != msg.sender) {
            revert();
        }else {
            _;
        }
    }
    //Method for disable the deployed contract
    function destruct() public isAdmin {
        selfdestruct(owner);
    }
}

contract Project is Destructor {  
    event Vote(uint indexed projectId,uint publicId,uint isVoted);    
    struct Projects {   
        string projectName;
        string description;
        uint estimatedBudget;
        uint receivedBudget; 
        string startDate;       
        string endDate; 
        string image;
        uint ActualTokens;
        uint 
Dec 03, 2018 04:44:33 UTC
pragma solidity ^0.4.2;

contract Election {
    // Model a Candidate
    struct Candidate {
        uint id;
        string name;
        uint voteCount;
    }

    // Store accounts that have voted
    mapping(address => bool) public voters;
    // Store Candidates
    // Fetch Candidate
    mapping(uint => Candidate) public candidates;
    // Store Candidates Count
    uint public candidatesCount;

    // voted event
    event votedEvent (
        uint indexed _candidateId
    );

    function Election () public {
        addCandidate("KamalHaasan");
        addCandidate("RajniKanth");
    }

    function addCandidate (string _name) private {
        candidatesCount ++;
        candidates[candidatesCount] = Candidate(candidatesCount, _name, 0);
    }

    function vote (uint _candidateId) public {
        // require that they haven't voted before
        require(!voters[msg.sender]);

        // require a valid candidate
        require(_candidateId > 0 && _candidateId <= candidatesCount);

        // reco
Dec 01, 2018 17:09:12 UTC
pragma solidity ^0.4.25;

contract EcRecover {
    
    function getOriginAddress(bytes memory signedMessage, uint8 v, bytes32 r, bytes32 s)
        public
        pure 
        returns(address addr)
    {
        bytes memory prefix = "\x19Ethereum Signed Message:\n";
        string memory length = uint2str(signedMessage.length);
        bytes memory encodedPack = abi.encodePacked(prefix, length, signedMessage);
        bytes32 prefixedHash = keccak256(encodedPack);
        addr = ecrecover(prefixedHash, v, r, s);
        return addr;
    }
    
    function uint2str(uint i) internal pure returns (string) {
        if (i == 0) return "0";
        uint j = i;
        uint length;
        while (j != 0){
            length++;
            j /= 10;
        }
        bytes memory bstr = new bytes(length);
        uint k = length - 1;
        while (i != 0){
            bstr[k--] = byte(48 + i % 10);
            i /= 10;
        }
        return string(bstr);
    }
Dec 01, 2018 12:31:02 UTC
pragma solidity ^0.4.24;

contract Raffle {
    using SafeMath for uint256;
    
    mapping (address => uint256) balances;

    address owner;

    address[] entrants;
    uint256 numEntrants;
    uint256 entryPrice;
    uint256 deadline;
    uint256 threshold;
    uint256 percentageTaken;

    // @param _entryPrice - entry price for each participant in wei i.e. 10^-18 eth.
    // @param _deadline - block number at which you want the crowdsale to end
    // @param _percentageToken - for example, to take 33% of the total use 3, only use integers
    constructor(uint256 _entryPrice, uint256 _deadline, uint256 _percentageTaken) public {
        entryPrice = _entryPrice;
        deadline = _deadline;
        percentageTaken = _percentageTaken;
    }

    modifier thresholdReached() {
        require(numEntrants >= threshold);
        _;
    }

    modifier belowThreshold() {
        require(numEntrants <= threshold);
        _;
    }

    modifier deadlinePassed() {
        require(now >= deadline);
        _;
 
Dec 01, 2018 02:07:02 UTC
pragma solidity ^0.4.10;

contract DebianRules {
/*
Consideraciones:
 -Cada software tiene un encargado del que se requiere saber su apellido e email
 -Cada software cuenta ademas con su nombre, descripcion, año de creacion y
  unidad academica donde se desarrolla.
 -Para identificar cada software se utiliza una address, esto puede representar
  un inconveniente para el testing, pero hace mas real la simulación ya que
  si se considera llevar un blockchain de software probablemente existan contratos
  de produccion de los mismos y se podria utilizar esa address.
 -Para el funcionamiento del smart contract se utilizo un struct que genera la
  representacion de cada software. Para almacenar se utiliza un mapeo
  de direcciones a structs de software y un array que almacena las direcciones 
  de cada software para poder llevar los punteros y las cantidades actualizadas
  (principalmente para eliminar entradas de forma lógica).
*/
  struct systemStruct {
    bytes16 unidadAcademica;
    bytes16 nombreSistema;
 
Dec 01, 2018 00:56:00 UTC
pragma solidity ^0.4.10;

contract DebianRules {
/*
Consideraciones:
 -Cada software tiene un encargado del que se requiere saber su apellido e email
 -Cada software cuenta ademas con su nombre, descripcion, año de creacion y
  unidad academica donde se desarrolla.
 -Para identificar cada software se utiliza una address, esto puede representar
  un inconveniente para el testing, pero hace mas real la simulación ya que
  si se considera llevar un blockchain de software probablemente existan contratos
  de produccion de los mismos y se podria utilizar esa address.
 -Para el funcionamiento del smart contract se utilizo un struct que genera la
  representacion de cada software. Para almacenar se utiliza un mapeo
  de direcciones a structs de software y un array que almacena las direcciones 
  de cada software para poder llevar los punteros y las cantidades actualizadas
  (principalmente para eliminar entradas de forma lógica).
*/
  struct systemStruct {
    bytes16 unidadAcademica;
    bytes16 nombreSistema;
 
Dec 01, 2018 00:42:02 UTC
pragma solidity ^0.4.10;

contract DebianRules {
/*
Consideraciones:
 -Cada software tiene un encargado del que se requiere saber su apellido e email
 -Cada software cuenta ademas con su nombre, descripcion, año de creacion y
  unidad academica donde se desarrolla.
 -Para identificar cada software se utiliza una address, esto puede representar
  un inconveniente para el testing, pero hace mas real la simulación ya que
  si se considera llevar un blockchain de software probablemente existan contratos
  de produccion de los mismos y se podria utilizar esa address.
 -Para el funcionamiento del smart contract se utilizo un struct que genera la
  representacion de cada software. Para almacenar se utiliza un mapeo
  de direcciones a structs de software y un array que almacena las direcciones 
  de cada software para poder llevar los punteros y las cantidades actualizadas
  (principalmente para eliminar entradas de forma lógica).
*/
  struct systemStruct {
    bytes16 unidadAcademica;
    bytes16 nombreSistema;
 
Dec 01, 2018 00:32:34 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;
    
    uint8 public candidateCount;
    uint16 public accountedVotes;
    uint16 public nulledVotes;
    uint16 public votesLeft;
    bool public isPostulationEnabled;

    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) private candidateNames;
    bytes32[] private candidateList;
    bytes32[] private votingOptions;
    
    struct Counter {
        uint16 countStart;
        uint16 countEnd;
        ui
Nov 30, 2018 19:47:20 UTC
pragma solidity ^0.4.24;

contract Votacion {
    
    modifier onlyOwner() {
        require(isOwner(msg.sender));
        _;
    }
    
    event Voted1 (uint16 _countStart, uint16 _countEnd);

    uint public voteStartTime;
    uint public voteEndTime;
    string public votingTitle;
    address public owner;
    uint16 private voterCount;
    
    uint8 public candidateCount;
    uint16 public accountedVotes;
    uint16 public nulledVotes;
    uint16 public votesLeft;
    bool public isPostulationEnabled;

    event Voted (bytes24 _token);
    event newVoterId (uint _voterId);
    event voteAccounted (bytes32 _candidateName, uint _votesReceived, uint16 _totalVotesAccounted);
    event voteNulled (uint16 _voterId, uint16 _totalVotesAccounted);
    
    event ImprimirHash (bytes32 _votingHash, string _candName, bytes _abiEncoded);
    //event ImprimirQuery1 (uint _voterId, bytes32 _votehash);
    //event ImprimirQuery2 (bytes32 _voteHash, string candidName);
  
    mapping (bytes32 => uint16) private votesRe
Nov 30, 2018 18:00: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 get() public constant returns (uint) {
    return value;
  }

  uint value;
Nov 30, 2018 13:16:44 UTC
pragma solidity 0.4.24;

// File: contracts/lib/openzeppelin-solidity/contracts/access/Roles.sol

/**
 * @title Roles
 * @dev Library for managing addresses assigned to a Role.
 */
library Roles {
  struct Role {
    mapping (address => bool) bearer;
  }

  /**
   * @dev give an account access to this role
   */
  function add(Role storage role, address account) internal {
    require(account != address(0));
    role.bearer[account] = true;
  }

  /**
   * @dev remove an account's access to this role
   */
  function remove(Role storage role, address account) internal {
    require(account != address(0));
    role.bearer[account] = false;
  }

  /**
   * @dev check if an account has this role
   * @return bool
   */
  function has(Role storage role, address account)
    internal
    view
    returns (bool)
  {
    require(account != address(0));
    return role.bearer[account];
  }
}

// File: contracts/lib/openzeppelin-solidity/contracts/access/roles/MinterRole.sol

contract MinterRole {
  using Roles for Ro
Nov 30, 2018 10:57:04 UTC
//pragma solidity ^0.5.0;
pragma solidity ^0.4.18;

contract Destructor {

    address public owner;
    uint public projectCount = 0;

    //Constructor for version ^0.5.0
    //constructor() public {
    //    owner = msg.sender;
    //}
  
   //Constructor for version ^0.4.18
  function Destructor() public {
      owner = msg.sender;
    }

    //Modifier for check whether the user is admin or not
    modifier isAdmin {
        if (owner != msg.sender) {
            revert();
        }else {
            _;
        }
    }
    //Method for disable the deployed contract
    function destruct() public isAdmin {
        selfdestruct(owner);
    }
}

contract Project is Destructor {      
    struct Projects {   
        string projectNameDesc; //name~description             
        uint estimatedBudget;
        uint receivedBudget; 
        string startEndDate;     //startDate~endDate format  
        string image;      
        uint status;  
        uint likes;
        uint dislikes;      
    }
    struct 
Nov 30, 2018 06:39:05 UTC
//pragma solidity ^0.5.0;
pragma solidity ^0.4.18;

contract Destructor {

    address public owner;
    uint public projectCount = 0;

    //Constructor for version ^0.5.0
    //constructor() public {
    //    owner = msg.sender;
    //}
  
   //Constructor for version ^0.4.18
  function Destructor() public {
      owner = msg.sender;
    }

    //Modifier for check whether the user is admin or not
    modifier isAdmin {
        if (owner != msg.sender) {
            revert();
        }else {
            _;
        }
    }
    //Method for disable the deployed contract
    function destruct() public isAdmin {
        selfdestruct(owner);
    }
}

contract Project is Destructor {      
    struct Projects {   
        string projectNameDesc; //name~description             
        uint estimatedBudget;
        uint receivedBudget; 
        string startEndDate;     //startDate~endDate format  
        string image;      
        uint status;  
        uint likes;
        uint dislikes;      
    }
    struct 
Nov 30, 2018 06:01:36 UTC
//pragma solidity ^0.5.0;
pragma solidity ^0.4.18;

contract Destructor {

    address public owner;
    uint public projectCount = 0;

    //Constructor for version ^0.5.0
    //constructor() public {
    //    owner = msg.sender;
    //}
  
   //Constructor for version ^0.4.18
  function Destructor() public {
      owner = msg.sender;
    }

    //Modifier for check whether the user is admin or not
    modifier isAdmin {
        if (owner != msg.sender) {
            revert();
        }else {
            _;
        }
    }
    //Method for disable the deployed contract
    function destruct() public isAdmin {
        selfdestruct(owner);
    }
}

contract Project is Destructor {      
    struct Projects {   
        string projectNameDesc; //name~description             
        uint estimatedBudget;
        uint receivedBudget; 
        string startEndDate;     //startDate~endDate format  
        string image;      
        uint status;  
        uint likes;
        uint dislikes;      
    }
    struct 
Nov 30, 2018 05:25:00 UTC
pragma solidity ^0.4.24;

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

Nov 30, 2018 05:13:25 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.5.0;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

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

  uint value;
Nov 30, 2018 01:21:33 UTC
pragma solidity ^0.4.24;

//contract definition
contract generalStructure {
    //state variables
    int public stateIntVariable; // vriable of integer type
    string stateStringVariable; //variable of string type
    address personIdentifier; // variable of address type
    myStruct human; // variable of structure type
    bool constant hasIncome = true; //variable of constant nature
    
    //structure definition
    struct myStruct {
        string name; //variable fo type string
        uint myAge; // variable of unsigned integer type
        bool isMarried; // variable of boolean type
        uint[] bankAccountsNumbers; // variable - dynamic array of unsigned integer
    }
    
    //modifier declaration
    modifier onlyBy(){
        if (msg.sender == personIdentifier) {
            _;
        }
    }
    
    // event declaration
    event ageRead(address, int );
    
    //enumeration declaration
    enum gender {male, female}
    
    //function definition
    function getAge (address _personIdent
Nov 29, 2018 17:41:40 UTC
pragma solidity ^0.4.24;
import "openzeppelin-solidity/contracts/token/ERC721/ERC721Token.sol";
// import "./MyCoin.sol";
contract MyCoin {
  function transfer(address _to,uint256 _value) public returns (bool) ;
  function totalSupply() public view returns (uint256) ;
}
contract MyToken is ERC721Token {
    MyCoin myCoin;
    address _owner;
    uint256 tokenId=0;
    event LotteryFinished(address indexed from,uint _tokenId);

    constructor() ERC721Token("MyToken", "MTC") public {
        myCoin = MyCoin(0x1A31b9b9D281D49001fE7F3f638000a739Afc9C3);
        _owner=msg.sender;
    }
    function getOwner() public view returns(address){
        return _owner;
    }
    function totalSupply() public view returns(uint256){
        // this code don't report error
        return myCoin.totalSupply();
    }

    function doLottery(uint256 _value) public{
        // this code report error
        require(myCoin.transfer(_owner,_value));
        tokenId=tokenId+1;
        _mint(msg.sender,tokenId);
        emit Lotte
Nov 29, 2018 16:40:56 UTC
pragma solidity ^0.4.24;

import "openzeppelin-solidity/contracts/token/ERC20/IERC20.sol";
import "openzeppelin-solidity/contracts/token/ERC721/IERC721Full.sol";
import "openzeppelin-solidity/contracts/token/ERC721/IERC721Receiver.sol";
import "openzeppelin-solidity/contracts/ownership/Ownable.sol";
import "openzeppelin-solidity/contracts/utils/Address.sol";
import "openzeppelin-solidity/contracts/math/SafeMath.sol";

/**
 * @title DDRMCore
 * @author rjkz808
 * @dev The DDRM application core contract
 *
 *  ██████╗ ██████╗ ██████╗ ███╗   ███╗
 *  ██╔══██╗██╔══██╗██╔══██╗████╗ ████║
 *  ██║  ██║██║  ██║██████╔╝██╔████╔██║
 *  ██║  ██║██║  ██║██╔══██╗██║╚██╔╝██║
 *  ██████╔╝██████╔╝██║  ██║██║ ╚═╝ ██║
 *
Nov 29, 2018 13:36:51 UTC
pragma solidity ^0.4.18;

contract ListPollution{
    
   //event OnCreateList(address _from, uint256 _value);
    
    struct energyPollution {
         int p;
    }
    
    int numList;
    //energyPollution[] public energyPollutions;
    mapping ( int => energyPollution ) public energyPollutions;
   
    //function createList
    function AjouterP(int p) public returns(int listID) {
      listID=numList++;
      energyPollutions[listID].p=p;
      //OnCreateList(msg.sender,listID);
  }


  //function retourner la valeur
  function GetP(int id) public constant returns(int PollutionValeur){
    return (energyPollutions[id].p);
  }
    
Nov 29, 2018 12:45:43 UTC
pragma solidity ^0.4.11;

contract ListGestion{
    
   event OnCreateListB(address  _from, uint256 _value);
   event OnCreateListN(address  _from, uint256 _value);
   event OnSupprimer(address _from,uint256 _value);
   
    struct List {
        string ip;
    }
    
    uint numListB;
    uint numListN;
    
    List[] public ListBlanches;
    List[] public ListNoirs;
    //mapping (uint => ListBlanche) listBlanches;
   
    //function createList
    function AjouterListB(string _ip) public returns(uint listID) {
      listID=numListB++;
      ListBlanches.push(
        List({
          ip:_ip
        })
      );
      OnCreateListB(msg.sender,listID);
  }


  //function retourner IP
  function GetIpB(uint id) public constant returns(string){
    return ListBlanches[id].ip;
  }
  
}
Nov 29, 2018 12:43:05 UTC
pragma solidity ^0.4.18;

contract ListPollution{
    
   //event OnCreateList(address _from, uint256 _value);
    
    struct energyPollution {
         uint p;
    }
    
    uint numList;
    //energyPollution[] public energyPollutions;
    mapping ( uint => energyPollution ) public energyPollutions;
   
    //function createList
    function AjouterP(uint p) public returns(uint listID) {
      listID=numList++;
      energyPollution[listID]=p;
      //OnCreateList(msg.sender,listID);
  }


  //function retourner la valeur
  function GetP(uint id) public returns(uint P){
    return (energyPollutions[id].p);
  }
    
Nov 29, 2018 12:33:55 UTC
//pragma solidity ^0.5.0;
pragma solidity ^0.4.18;

contract Destructor {

    address public owner;
    uint public projectCount = 0;

    //Constructor for version ^0.5.0
    //constructor() public {
    //    owner = msg.sender;
    //}
  
   //Constructor for version ^0.4.18
  function Destructor() public {
      owner = msg.sender;
    }

    //Modifier for check whether the user is admin or not
    modifier isAdmin {
        if (owner != msg.sender) {
            revert();
        }else {
            _;
        }
    }
    //Method for disable the deployed contract
    function destruct() public isAdmin {
        selfdestruct(owner);
    }
}

contract Project is Destructor {  
    event Vote(uint indexed projectId,uint publicId,uint isVoted);    
    struct Projects {   
        string projectName;
        string description;
        uint estimatedBudget;
        uint receivedBudget; 
        string startDate;       
        string endDate; 
        string image;
        uint ActualTokens;
        uint 
Nov 29, 2018 08:57:09 UTC
//pragma solidity ^0.5.0;
pragma solidity ^0.4.18;

contract Destructor {

    address public owner;
    uint public projectCount = 0;

    //Constructor for version ^0.5.0
    //constructor() public {
    //    owner = msg.sender;
    //}
  
   //Constructor for version ^0.4.18
  function Destructor() public {
      owner = msg.sender;
    }

    //Modifier for check whether the user is admin or not
    modifier isAdmin {
        if (owner != msg.sender) {
            revert();
        }else {
            _;
        }
    }
    //Method for disable the deployed contract
    function destruct() public isAdmin {
        selfdestruct(owner);
    }
}

contract Project is Destructor {  
    event Vote(uint indexed projectId,uint publicId,uint isVoted);    
    struct Projects {   
        string projectName;
        string description;
        uint estimatedBudget;
        uint receivedBudget; 
        string startDate;       
        string endDate; 
        string image;
        uint ActualTokens;
        uint 
Nov 29, 2018 08:29:34 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.25;
contract TestGasUsage {
  bytes32 test32 = 'nUSD';
  bytes4 test4 = 'nUSD';

  function set32() public returns (bytes32){
    test32 = 'nAUD';
    return test32;
  }

  function set4() public returns (bytes4){
    test4 = 'nAUD';
    return test4;
  }

Nov 29, 2018 05:46: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;
    l_value.push(_value);
  }

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

  function get_l() public constant returns(uint) {
    uint _l = l_value.length;
    return _l;
  }

  uint value;
  uint[] l_value;
Nov 28, 2018 16:23:43 UTC
pragma solidity ^0.4.11;

contract Listpollution{
    
   //event OnCreateList(address _from, uint256 _value);
    
    struct energyPollution {
         uint p;
    }
    
    uint numList;
    ListPollution[] public ListPollutions;
    mapping (numList => Listpollution) listPollutions;
   
    //function createList
    function AjouterList(uint _p) public returns(uint listID) {
      listID=numList++;
      ListPollutions.push(
        ListPollution({
              p:_p
        })
      );
      //OnCreateList(msg.sender,listID);
  }


  //function retourner la valeur
  function GetP(uint id) public returns(uint P){
    return (ListPollutions[id].p);
  }
    
Nov 28, 2018 12:43:35 UTC
pragma solidity ^0.4.11;

contract Listpollution{
    
   //event OnCreateList(address _from, uint256 _value);
    
    struct energyPollution {
         uint p;
    }
    
    uint numList;
    ListPollution[] public ListPollutions;
    mapping (numList => Listpollution) listPollutions;
   
    //function createList
    function AjouterList(uint _p) public returns(uint listID) {
      listID=numList++;
      ListPollutions.push(
        ListPollution({
              p:_p
        })
      );
      //OnCreateList(msg.sender,listID);
  }


  //function retourner IP
  function GetP(uint id) public returns(uint P){
    return (ListPollutions[id].p);
  }
    
Nov 28, 2018 12:40:17 UTC
//pragma solidity ^0.5.0;
pragma solidity ^0.4.18;

contract Destructor {

    address public owner;
    uint public projectCount = 0;

    //Constructor for version ^0.5.0
    //constructor() public {
    //    owner = msg.sender;
    //}
  
   //Constructor for version ^0.4.18
  function Destructor() public {
      owner = msg.sender;
    }

    //Modifier for check whether the user is admin or not
    modifier isAdmin {
        if (owner != msg.sender) {
            revert();
        }else {
            _;
        }
    }
    //Method for disable the deployed contract
    function destruct() public isAdmin {
        selfdestruct(owner);
    }
}

contract Project is Destructor {  
    event Vote(uint indexed projectId,uint publicId,uint isVoted);    
    struct Projects {   
        string projectName;
        string description;
        uint estimatedBudget;
        uint receivedBudget; 
        string startDate;       
        string endDate; 
        string image;
        uint ActualTokens;
        uint 
Nov 28, 2018 09:55:57 UTC
//pragma solidity ^0.5.0;
pragma solidity ^0.4.18;

contract Destructor {

    address public owner;
    uint public projectCount = 0;

    //Constructor for version ^0.5.0
    //constructor() public {
    //    owner = msg.sender;
    //}
  
   //Constructor for version ^0.4.18
  function Destructor() public {
      owner = msg.sender;
    }

    //Modifier for check whether the user is admin or not
    modifier isAdmin {
        if (owner != msg.sender) {
            revert();
        }else {
            _;
        }
    }
    //Method for disable the deployed contract
    function destruct() public isAdmin {
        selfdestruct(owner);
    }
}

contract Project is Destructor {  
    event Vote(uint indexed projectId,uint publicId,uint isVoted);    
    struct Projects {   
        string projectName;
        string description;
        uint estimatedBudget;
        uint receivedBudget; 
        string startDate;       
        string endDate; 
        string image;
        uint ActualTokens;
        uint 
Nov 28, 2018 09:48:38 UTC
pragma solidity ^0.4.25;

contract Hello {
    string public message;
    constructor(string initMessage) public {
        message = initMessage;
    }
    function update(string newMessage) public {
        message = newMessage;
    }
Nov 28, 2018 09:20:46 UTC
//pragma solidity ^0.5.0;
pragma solidity ^0.4.18;

contract Destructor {

    address public owner;
    uint public projectCount = 0;

    //Constructor for version ^0.5.0
    //constructor() public {
    //    owner = msg.sender;
    //}
  
   //Constructor for version ^0.4.18
  function Destructor() public {
      owner = msg.sender;
    }

    //Modifier for check whether the user is admin or not
    modifier isAdmin {
        if (owner != msg.sender) {
            revert();
        }else {
            _;
        }
    }
    //Method for disable the deployed contract
    function destruct() public isAdmin {
        selfdestruct(owner);
    }
}

contract Project is Destructor {  
    event Vote(uint indexed projectId,uint publicId,uint isVoted);    
    struct Projects {   
        string projectName;
        string description;
        uint estimatedBudget;
        uint receivedBudget; 
        string startDate;       
        string endDate; 
        string image;
        uint ActualTokens;
        uint 
Nov 28, 2018 05:50:41 UTC
pragma solidity ^0.5.0;

contract ListGestionB{
    
   //event OnCreateList(address _from, uint256 _value);
    
    struct ListBlanche {
        string ip;
        string t;
    }
    
    uint numList;
    ListBlanche[] public ListBlanches;
    //mapping (uint => ListBlanche) listBlanches;
   
    //function createList
    function AjouterList(string _ip,string _t) public returns(uint listID) {
      listID=numList++;
      ListBlanches.push(
        ListBlanche({
          ip:_ip,
          t:_t
        })
      );
      //OnCreateList(msg.sender,listID);
  }

      //function supprimer ip
    function SupprimerList(string _ipN)public {
       for(uint i=0;i<ListBlanches.length;i++){
         bytes memory a= bytes(ListBlanches[i].ip);
         bytes memory b=bytes(_ipN);
         if(a.length==b.length){
           for(uint y=0;y<a.length;y++){
             if(a[y]!=b[y]){
             }
             else{
               ListBlanches[i].ip="null";
               //OnCreateList(msg.sender,i);
             }
Nov 27, 2018 20:35:32 UTC
pragma solidity ^0.4.11;

contract Listpollution{
    
   //event OnCreateList(address _from, uint256 _value);
    
    struct ListPollution {
         uint p;
    }
    
    uint numList;
    ListPollution[] public ListPollutions;
    //mapping (uint => ListBlanche) listBlanches;
   
    //function createList
    function AjouterList(uint _p) public returns(uint listID) {
      listID=numList++;
      ListPollutions.push(
        ListPollution({
              p:_p
        })
      );
      //OnCreateList(msg.sender,listID);
  }


  //function retourner IP
  function GetP(uint id) public returns(uint P){
    return (ListPollutions[id].p);
  }
    
Nov 27, 2018 20:22:00 UTC
pragma solidity ^0.4.11;

contract Listpollution{
    
   //event OnCreateList(address _from, uint256 _value);
    
    struct ListPollution {
         int p;
    }
    
    uint numList;
    ListPollution[] public ListPollutions;
    //mapping (uint => ListBlanche) listBlanches;
   
    //function createList
    function AjouterList(int _p) public returns(uint listID) {
      listID=numList++;
      ListPollutions.push(
        ListPollution({
              p:_p
        })
      );
      //OnCreateList(msg.sender,listID);
  }


  //function retourner IP
  function GetP(uint id) public returns(int p){
    return (ListPollutions[id].p);
  }
    
Nov 27, 2018 20:19:42 UTC
//pragma solidity ^0.5.0;
pragma solidity ^0.4.18;

contract Destructor {

    address public owner;
    uint public projectCount = 0;

    //Constructor for version ^0.5.0
    //constructor() public {
    //    owner = msg.sender;
    //}
  
   //Constructor for version ^0.4.18
  function Destructor() public {
      owner = msg.sender;
    }

    //Modifier for check whether the user is admin or not
    modifier isAdmin {
        if (owner != msg.sender) {
            revert();
        }else {
            _;
        }
    }
    //Method for disable the deployed contract
    function destruct() public isAdmin {
        selfdestruct(owner);
    }
}

contract Project is Destructor {  
    event Vote(uint indexed projectId,uint publicId,uint isVoted);    
    struct Projects {   
        string projectName;
        string description;
        uint estimatedBudget;
        uint receivedBudget; 
        string startDate;       
        string endDate; 
        string image;
        uint ActualTokens;
        uint 
Nov 27, 2018 10:08:09 UTC
//pragma solidity ^0.5.0;
pragma solidity ^0.4.18;

contract Destructor {

    address public owner;
    uint public projectCount = 0;

    //Constructor for version ^0.5.0
    //constructor() public {
    //    owner = msg.sender;
    //}
  
   //Constructor for version ^0.4.18
  // function Destructor() public {
  //      owner = msg.sender;
   // }

    //Modifier for check whether the user is admin or not
    modifier isAdmin {
        if (owner != msg.sender) {
            revert();
        }else {
            _;
        }
    }
    //Method for disable the deployed contract
    function destruct() public isAdmin {
        selfdestruct(owner);
    }
}

contract Project is Destructor {  
    event Vote(uint indexed projectId,uint publicId,uint isVoted);    
    struct Projects {   
        string projectName;
        string description;
        uint estimatedBudget;
        uint receivedBudget; 
        string startDate;       
        string endDate; 
        string image;
        uint ActualTokens;
    
Nov 27, 2018 09:51:18 UTC
pragma solidity ^0.4.18;


contract Destructor {

    address public owner;

    //Constructor
    function Destructor() public {
        owner = msg.sender;
    }

    //Modifier for check whether the user is admin or not
    modifier isAdmin {
        if (owner != msg.sender) {
            revert();
        }else {
            _;
        }
    }
    //Method for disable the deployed contract
    function destruct() public isAdmin {
        selfdestruct(owner);
    }
}

contract Project is Destructor {  
    event Vote(uint indexed projectId,uint publicId,uint isVoted);    
    uint projectCount;
    struct Projects {   
        string projectName;
        string description;
        uint estimatedBudget;
        uint receivedBudget; 
        string startDate;       
        string endDate;        
        string image;
        uint ActualTokens;
        uint status;     
        
    }
    struct Milestone { 
        string name;
        string description;
        uint milestoneID;
        uint vendorID;  
Nov 27, 2018 09:48:40 UTC
&gt; [email protected] start /Volumes/Data/BlockChain/loom/tiles-chain/webclient
&gt; webpack-dev-server -d --inline --progress --no-info --host 0.0.0.0 --port 9000

 http://0.0.0.0:9000/
webpack result is served from /
content is served from /Volumes/Data/BlockChain/loom/tiles-chain/webclient
ts-loader: Using [email protected] and /Volumes/Data/BlockChain/loom/tiles-chain/webclient/tsconfig.json
Hash: 5aca0e1ca87d373fdb75
Version: webpack 3.12.0
Time: 10331ms
 2 assets
 [160] (webpack)-dev-server/client?http://0.0.0.0:9000 4.16 kB {1} [built]
 [175] ./node_modules/phaser/build/custom/pixi.js-exposed 57 bytes {1} [built]
 [176] ./node_modules/phaser/build/custom/p2.js-exposed 53 bytes {1} [built]
 [177] ./node_modules/phaser/build/custom/phaser-split.js-exposed 67 bytes {1} [built]
 [314] multi (webpack)-dev-server/client?http://0.0.0.0:9000 ./src/index.ts 40 bytes {0} [built]
 [323] (webpack)-dev-server/client/socket.js 897 bytes {1} [built]
 [355] ./src/index.ts 8.38 kB {0} [built]
 [356] ./node_modules/phas
Nov 27, 2018 08:01:58 UTC
pragma solidity ^0.4.24;

/**
 * @title ERC20 interface
 * @dev see https://github.com/ethereum/EIPs/issues/20
 */
interface IERC20 {
    function totalSupply() external view returns (uint256);

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

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

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

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

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

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

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

/**
 * @title ERC20Detailed token
 * @dev The decimals are only for visualization purposes.
 * All the operations are done using the smallest and indivisible token unit,
 * just as on Ethereum all the operations are done in wei.
 */
contract ERC20Detailed is 
Nov 26, 2018 23:58:28 UTC
pragma solidity ^0.4.24;

contract Testerino {
    
  function lookup(uint8 _base)
    public
    pure
    returns (uint8)
  {
    require(_base <= 2340);
    if (_base <= 40) {
      return 21;
    } else if (_base > 40 && _base <= 48) {
      return 20;
    } else if(_base > 48 && _base <= 59) {
      return 19;
    } else if(_base > 59 && _base <= 74) {
      return 18;
    } else if(_base > 74 && _base <= 95) {
      return 17;
    } else if(_base > 95 && _base <= 127) {
      return 16;
    } else if(_base > 127 && _base <= 176) {
      return 15;
    } else if(_base > 176 && _base <= 255) {
      return 14;
    } else if(_base > 255 && _base <= 390) {
      return 13;
    } else if(_base > 390 && _base <= 642) {
      return 12;
    } else if(_base > 642 && _base <= 1155) {
      return 11;
    } else if(_base > 1155 && _base <= 2340) {
      return 10;
    }
  }
Nov 26, 2018 15:24:02 UTC
function proposeAsset(string _data, uint _husbandAllocation, uint _wifeAllocation) external onlySpouse isSigned isNotDivorced {
  require(isSameString(_data, ""), "No asset data provided!");
  require(_husbandAllocation >= 0, "Husband allocation invalid!");
  require(_wifeAllocation >= 0, "Wife allocation invalid!");
  require((_husbandAllocation + _wifeAllocation) == 100, "Total allocation must be equal to 100%!");

  // Add new asset
  Asset memory newAsset = Asset({
    data: _data,
    husbandAllocation: _husbandAllocation,
    wifeAllocation: _wifeAllocation,
    added: false,
    removed: false
  });
  uint newAssetId = assets.push(newAsset);

  emit AssetProposed(now, _data, msg.sender);

  // Map to a storage object (otherwise mappings could not be accessed)
  Asset storage asset = assets[newAssetId - 1];

  // Instantly approve it by the sender
  asset.hasApprovedAdd[msg.sender] = true;

  emit AssetAddApproved(now, _data, msg.sender);
Nov 26, 2018 14:16:57 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.17;
contract TestBits {
    // Let's test uint256 value 26322820181848127205119429488744061657188852288741917040354512141634951523633:
    // which in hex format is:
    // 0x3a32303138313133303030303030302b30383030000100005649500000412d31

  function test1() public pure returns(bytes){
    uint256[] memory tickets = new uint256[](1);  
    tickets[0] = 26322820181848127205119429488744061657188852288741917040354512141634951523633;
    bytes memory message = new bytes(tickets.length * 32);

    for (uint i = 0; i < tickets.length; i++){
        for (uint j = 0; j < 32; j++)
        {
            message[i * 32 + j] = byte(bytes32(tickets[i] << (8*j)));
        }
    }
    //expected
    //0x3a32303138313133303030303030302b30383030000100005649500000412d31
    return message;
  }
 function test2() public pure returns(bytes){
    uint256[] memory tickets = new uint256[](1);
    tickets[0] = 263228201818481
Nov 26, 2018 07:05:26 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.17;
contract TestBits {

  function spawnPassTo() public pure returns(bytes32){
    uint256[] memory tickets = new uint256[](1);
    // Let's test uint256 value 26322820181848127205119429488744061657188852288741917040354512141634951523633:
    // which in hex format is:
    // 0x3a32303138313133303030303030302b30383030000100005649500000412d31
    tickets[0] = 26322820181848127205119429488744061657188852288741917040354512141634951523633;
    uint256[] memory _originTickets=tickets;
    encodeMessageSpawnable2(tickets);
    // after calling encodeMessageSpawnable
    // tickets has been changed, now the value become
    // 0x3100000000000000000000000000000000000000000000000000000000000000
    // only contains the last byte
    // it looks this local variable has been changed even out of the scope in another function call
    return bytes32(_originTickets[0]);
  }
  function encodeMessageSpawnable(uint256
Nov 26, 2018 07:05:05 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.17;
contract TestBits {

  function spawnPassTo() public pure returns(bytes32){
    uint256[] memory tickets = new uint256[](1);
    // Let's test uint256 value 26322820181848127205119429488744061657188852288741917040354512141634951523633:
    // which in hex format is:
    // 0x3a32303138313133303030303030302b30383030000100005649500000412d31
    tickets[0] = 26322820181848127205119429488744061657188852288741917040354512141634951523633;
    
    //encodeMessageSpawnable(tickets);
    // after calling encodeMessageSpawnable
    // tickets has been changed, now the value become
    // 0x3100000000000000000000000000000000000000000000000000000000000000
    // only contains the last byte
    // it looks this local variable has been changed even out of the scope in another function call
    return bytes32(tickets[0]);
  }
  function encodeMessageSpawnable(uint256[] tickets) public pure returns(bytes){
    by
Nov 26, 2018 07:03:34 UTC
pragma solidity ^0.4.24;

import './Ownable.sol';
import './Proxy.sol';

contract Deployer is Ownable {

    event StartChallenge(address player, address deployed);
    event ChallengeCompleted(address player, address deployed);
    event Contr(address);

    mapping (address => Proxy[5]) playersToContracts;
    mapping (address => bool[5]) playersToCompletion;
    mapping (address => string) playersToNick;

    address[5] challenges;

    constructor(address challenge1, address challenge2, address challenge3, address challenge4, address challenge5) public {
        challenges[0] = challenge1;
        challenges[1] = challenge2;
        challenges[2] = challenge3;
        challenges[3] = challenge4;
        challenges[4] = challenge5;
    }

    //------------------ STATE CHANGING FUNCTIONS ------------------------//

    function updateChallenge(address newAddress, uint256 index)
        public
        onlyOwner
    {
        challenges[index] = newAddress;
    }

    function deployChallenge(uint256 index)
Nov 25, 2018 22:44:47 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.24;

/**
 * @title ERC20 interface
 * @dev see https://github.com/ethereum/EIPs/issues/20
 */
interface IERC20 {
    function totalSupply() external view returns (uint256);

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

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

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

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

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

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

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

contract MyTokenErc20 is IERC20
uint256 supply = 2000;
mapping (address => uint256) private _balances;
mapping (address => uint256(address => uint256)) private _allowances
Nov 24, 2018 12:27:54 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.17;
contract TestBits {
  bytes32 b = 0x3a32303138313133303030303030302b30383030000100005649500000412d31;
  uint256 u = 0x3a32303138313133303030303030302b30383030000100005649500000412d31;
  
  function b_to_bytes1() public view returns(bytes1) {
    return bytes1(b);
  }

  function b_to_byte() public view returns(bytes1) {
    return byte(b);
  }

  function b_to_bytes16() public view returns(bytes16) {
    return bytes16(b);
  }

  function u_to_bytes1() public view returns(bytes1) {
    return bytes1(u);
  }

  function u_to_byte() public view returns(bytes1) {
    return byte(u);
  }

  function u_to_bytes16() public view returns(bytes16) {
    return bytes16(u);
  }
Nov 23, 2018 17:20:12 UTC
pragma solidity ^0.4.24;

contract A {
	// standard uint
	uint eventId = 2;

	// solidity sha3 hash of the unique vendor ref string 
	bytes32 vendorTicketRefHash = 0xee2953199c78f8ffabcd753c8342f13df8173a0ac2f8e6db64c172790ce7477b;

	// standard string
	string ticketMetadata = "{ \"eventName\": \"an event\", \"eventTime\": 1544423595, \"eventVenue\": \"amazing venue\" }";

	// standard address
	address ticketOwner = 0xD13CD02E5D0bA8ff796A7189c087925B8ebaf54F;

	// bytes32 hash signed by the event owner or primary
	bytes originalProof = hex"f5707e7a8d2a7c1e6ea7299511cd8e5da324a39647f3dc98a52548eda06901382526c13bc88f6abc7da5c90d33afe969f8d39a6781e4300be901f3c5618f2ec700";
	
	// optional
	bytes doorData = "2965ea60e4b7d3cc7c7920e13a3fa0123c6ec5650f34cdd1dce206efe395167a03c2f48cbaedb15ad1660a40375d0db94741aff4a9cfe5f0c98d7360c9ba6d3d1b";

	// packed bytes
	bytes public packed = abi.encodePacked(eventId, vendorTicketRefHash, ticketMetadata, ticketOwner, originalProof, doorData);

	// hashed packed bytes
	bytes32 p
Nov 23, 2018 16:11:21 UTC
pragma solidity ^0.4.18;

contract Destructor {

    address public owner;

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

    //Modifier for check whether the user is admin or not
    modifier isAdmin {
        if (owner != msg.sender) {
            revert();
        }else {
            _;
        }
    }
    //Method for disable the deployed contract
    function destruct() public isAdmin {
        selfdestruct(owner);
    }
}

contract Project is Destructor {  
    event Vote(uint indexed projectId,uint publicId,uint isVoted);    
    struct Projects {   
        string projectName;
        string description;
        uint estimatedBudget;
        uint receivedBudget; 
        string startDate;       
        string endDate; 
        uint ngoId;
        
        address createdBy;
        string timestamp; 
        uint ActualTokens;
        uint status;       
    }
    struct Milestone { 
        uint projectID;
        uint vendorID;
        address createdBy;
    
Nov 23, 2018 12:12:58 UTC
pragma solidity ^0.4.18;

contract Destructor {

    address public owner;

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

    //Modifier for check whether the user is admin or not
    modifier isAdmin {
        if (owner != msg.sender) {
            revert();
        }else {
            _;
        }
    }
    //Method for disable the deployed contract
    function destruct() public isAdmin {
        selfdestruct(owner);
    }
}

contract Project is Destructor {   
	//event ProjectTransfer( uint indexed ProjectId,uint EstimatedTokens,address createdBy, string timestamp,uint indexed ActualTokens,uint indexed status);
    event MilestoneTransfer(uint indexed MilestoneID, uint VendorID, address createdBy, string TimeStamp, uint tokens,uint indexed status);

    event ProjectStatusUpdate(uint indexed ProjectId,address createdBy,string timestamp,uint indexed status);
    event MilestoneStatusUpdate(uint indexed MilestoneID,uint indexed ProjectId,address createdBy,string times
Nov 23, 2018 10:00:41 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.17;
contract TestBits {
    // Let's test uint256 value 26322820181848127205119429488744061657188852288741917040354512141634951523633:
    // which in hex format is:
    // 0x3a32303138313133303030303030302b30383030000100005649500000412d31

  function test1() public pure returns(bytes){
    uint256[] memory tickets = new uint256[](1);  
    tickets[0] = 26322820181848127205119429488744061657188852288741917040354512141634951523633;
    bytes memory message = new bytes(tickets.length * 32);

    for (uint i = 0; i < tickets.length; i++){
        for (uint j = 0; j < 32; j++)
        {
            message[i * 32 + j] = byte(bytes32(tickets[i] << (8*j)));
        }
    }
    //expected
    //0x3a32303138313133303030303030302b30383030000100005649500000412d31
    return message;
  }
 function test2() public pure returns(bytes){
    uint256[] memory tickets = new uint256[](1);
    tickets[0] = 263228201818481
Nov 23, 2018 06:47:19 UTC
pragma solidity ^0.4.24;

contract Ownable {

    event OwnerAdded(address);
    event OwnerRemoved(address);

    address public implementation;
    mapping (address => bool) public owners;

    modifier onlyOwner() {
        require(owners[msg.sender]);
        _;
    }

    /** Only called when contract is instantiated
     */
    function contructor() public {
        owners[msg.sender] = true;
    }

    /** Add an owner to the owners list
     *  Only allow owners to add other owners
     */
    function addOwner(address _owner) public onlyOwner { 
        owners[_owner] = true;
        emit OwnerAdded(_owner);
    }

    /** Remove another owner
     *  Only allow owners to remove other owners
     */
    function removeOwner(address _owner) public onlyOwner { 
        owners[_owner] = false;
        emit OwnerRemoved(_owner);
    }

    /** Remove all owners mapping and relinquish control of contract
     */
    function renounceOwnership() public {
        assembly {
            sstore(owners_offset,
Nov 23, 2018 05:07:46 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.25;
contract Alyra {

  function addParticipant(address _addr, string _nom) public {
    participants.push(Participant(_addr,_nom));
  }

  function getParticipantAddr(uint _indice) public constant returns (address) {
    return participants[_indice].addr;
  }

  function getParticipantName(uint _indice) public constant returns (string) {
    return participants[_indice].nom;
  }

  struct Participant{
    address addr;
    string nom;
  } 
  Participant[] participants; 
Nov 23, 2018 01:15:21 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.22;
contract Alyra {
  function constructor() public {
    
  }

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

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

  uint value;
  uint admin;
  struct participant{
    address addr;
    string nom;
  } 
  participant[] participants; 
Nov 23, 2018 01:03:08 UTC
pragma solidity ^0.4.24;

contract Proxy {

    address public implementation;

    constructor(address _address) public {
        implementation = _address;
    }

    function() external payable {
        address _impl = implementation;
        require(_impl != address(0x0));

        assembly {
            let ptr := mload(0x40)
            calldatacopy(ptr, 0x0, calldatasize)
            let result := delegatecall(gas, _impl, ptr, calldatasize, 0, 0)
            returndatacopy(ptr, 0x0, returndatasize)
            switch result case 0 {revert(ptr, returndatasize)} default {return (ptr, returndatasize)}
        }
    }
}

contract Ownable {

    event OwnerChanged(address);

    address public implementation;
    address public owner;

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

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

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

    function changeOwner(address newOwner) public onlyOw
Nov 22, 2018 19:12:54 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  string name = "University Acdemic Token";
  string symbol = "UAT"; // University Acdemic Token
  enum State { Complete, Inactive, Active }
  bool Cheat;
  uint gpa
  
  State choice;
  State constant defaultChoice = State.Active;
  uint StateValue;

  uint256 studentId;
  uint256 schoolId;

  function set(uint _gpa, bool _Cheat,  uint256 _studentId, uint256 _schoolId, uint _choice) public {
    gpa = _gpa;
    Cheat = _Cheat;
    studentId = _studentId;
    schoolId = _schoolId;
    StateValue = _choice;
  }

  function getChoice() public view returns (State) {
        return choice;
  }

  function getDefaultChoice() public pure returns (uint) {
        return uint(defaultChoice);
  }

Nov 22, 2018 07:52:04 UTC
// Contract address: 0x74ea2438157d8bb836cad8419be38f7bba799d30
// Contract name: SplitCoinFactory
// Etherscan link: https://etherscan.io/address/0x62BC2aec45b6ab216C198C105C78093284B2327E#code
// compiler: 0.4.19+commit.c4cbbb05.Emscripten.clang
pragma solidity ^0.4.19;

// https://www.ethereum.org/token
interface tokenRecipient {
  function receiveApproval( address from, uint256 value, bytes data ) public;
}

// ERC223
interface ContractReceiver {
  function tokenFallback( address from, uint value, bytes data ) public;
}

// ERC20 token with added ERC223 and Ethereum-Token support
//
// Blend of multiple interfaces:
// - https://theethereum.wiki/w/index.php/ERC20_Token_Standard
// - https://www.ethereum.org/token (uncontrolled, non-standard)
// - https://github.com/Dexaran/ERC23-tokens/blob/Recommended/ERC223_Token.sol

contract ERC223Token
{
  string  public name;        // ERC20
  string  public symbol;      // ERC20
  uint8   public decimals;    // ERC20
  uint256 public totalSu
Nov 21, 2018 21:55:43 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;
  }

  this is something

  uint value;
Nov 21, 2018 13:36:45 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;
  }

  this is something

  uint value;
Nov 21, 2018 13:36:14 UTC
pragma solidity ^0.4.24;

import './CappedCrowdsale.sol';
import './SANDER1.sol';

contract SuperCrowdsale is CappedCrowdsale {
    
    using SafeERC20 for SANDER1;

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

    address public owner;
    SANDER1 public token;
    uint256 internal weiAmount;

    event ProcessedRemainder(uint256 remainder);

    constructor (
        SANDER1 _token, // sander1.superander.eth
        address _wallet, // wallet.superander.eth
        uint256 _cap
    ) public 
        Crowdsale(
            _wallet,
            _token
        ) 
        CappedCrowdsale(
            _cap
        ) 
    {
        owner = msg.sender;
        token = _token;
    }

    /**
    * @dev set total cap in WEI
    * @param _cap uint256
    * In the future, the cap will be calculated by an oracle at the time of the purchase
    */
    function setCap(uint256 _cap) onlyOwner public {
        cap = _cap.mul(token.totalSupply().div(1 ether));
    }

    /**
   * @dev lo
Nov 21, 2018 02:36:22 UTC
pragma solidity ^0.4.24;

import './StandardToken.sol';
import './DetailedERC20.sol';

contract SANDER1 is StandardToken, DetailedERC20 {

    /**
    * 10 tokens equal 10 songs equal 1 album
    * uint256 supply
    */
    uint256 internal supply = 12 * 1 ether;

    constructor () 
        public 
        DetailedERC20 (
            "Súper Ánder Token 1", 
            "SANDER1", 
            18
        ) 
    {
        totalSupply_ = supply;
        balances[msg.sender] = supply;
        emit Transfer(0x0, msg.sender, totalSupply_);
    }
Nov 21, 2018 02:08:01 UTC
pragma solidity ^0.4.25;

/*
  Workshop challenge: Obtener la password
 */


contract WorkshopChallenge {
  string memX;
  string memY;
  string memZ;

  function buildPass() private view returns (string) {
    return string(abi.encodePacked(memZ, memX, memY));
  }

  function init() public {
    memX = "6f726b7368";
    memY = "6f703432";
    memZ = "636c61766577";
  }

  function getPassword(uint salt) public view returns(string pass) {
    if (salt == 42 szabo) {
      pass = string(fromHex(buildPass()));
    } else {
      pass = string(abi.encodePacked(blockhash(block.number)));
    }
  }

  function fromHex(string s) private pure returns (bytes) {
    bytes memory ss = bytes(s);
    require(ss.length%2 == 0);
    bytes memory r = new bytes(ss.length/2);
    for (uint i=0; i<ss.length/2; ++i) {
        r[i] = byte(fromHexChar(uint(ss[2*i])) * 16 +
                    fromHexChar(uint(ss[2*i+1])));
    }
    return r;
  }

  function fromHexChar(uint c) private pure returns (uint) {
      if (byte(c) >= b
Nov 20, 2018 23:37:35 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.25;
contract DeadSwitch {

  address creatorOfContract;

  struct File {
        address fileOwner;
        string ipfsHash;
        string key;
        string ping;
  }


  uint numFiles;
  mapping (uint => File) public files;

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

  modifier onlyCreator() {
    require(msg.sender == creatorOfContract); // If caller is not creator, it reverts 
    _;                              // Otherwise, it continues.
  }


  modifier onlyFileOwner(uint _fileId) {
    require(files[_fileId].fileOwner == msg.sender); // If caller is not creator of specified file, it reverts
    _;                                             // Otherwise, it continues.
  }


  function addFile(string _ipfsHash, address _creator) public onlyCreator returns (uint fileId) {
    fileId = numFiles++; 
    files[fileId] = File(_creator, _ipfsHash, "", "");
  }

  function pub
Nov 20, 2018 16:56:26 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.25;
contract DeadSwitch {

  address creator; // This will be the address of SecondContract.

  struct File {
        address creator;
        string ipfsHash;
        string key;
        uint256 lastPing;
  }

  

  uint numFiles;
  mapping (uint => File) public files;

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

  modifier onlyCreator() {
    require(msg.sender == creator); // If it is incorrect here, it reverts.
    _;                              // Otherwise, it continues.
  }

  function addFile(string _ipfsHash, address _creator) public onlyCreator returns (uint fileId) {
    fileId = numFiles++; 
    files[fileId] = File(_creator, _ipfsHash, "", 0);
    return fileId;
  }

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

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

  uint value;
Nov 20, 2018 16:17:28 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.25;
contract DeadSwitch {

  address creator; // This will be the address of SecondContract.

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

  modifier onlyCreator() {
    require(msg.sender == creator); // If it is incorrect here, it reverts.
    _;                              // Otherwise, it continues.
  } 

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

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

  uint value;
Nov 20, 2018 14:58:30 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.9;

contract DebianRules {

  struct systemStruct {
    bytes32 unidadAcademica;
    bytes32 nombreSistema;
    bytes32 apellidoEncargado;
    bytes32 emailEncargado;
    bytes32 descripcion;
    uint anoCreacion;
    uint index;
  }
  
  mapping(address => systemStruct) private systemStructs;
  address[] private systemIndex;

  event LogNewSystem   (address indexed systemAddress, uint index, bytes32 unidadAcademica, bytes32 nombreSistema, bytes32 apellidoEncargado, bytes32 emailEncargado, bytes32 descripcion, uint anoCreacion);
  event LogUpdateSystem(address indexed systemAddress, uint index, bytes32 unidadAcademica, bytes32 nombreSistema, bytes32 apellidoEncargado, bytes32 emailEncargado, bytes32 descripcion, uint anoCreacion);
  event LogDeleteSystem(address indexed systemAddress, uint index);
  
  function isLoad(address systemAddress)
    public 
    constant
    returns(bool isIndeed) 
  {
    i
Nov 20, 2018 00:44:53 UTC
pragma solidity ^0.4.24;


//==============================================================================
//     _    _  _ _|_ _  .
//    (/_\/(/_| | | _\  .
//==============================================================================
contract F3Devents {
    // fired whenever a player registers a name
    event onNewName
    (
        uint256 indexed playerID,
        address indexed playerAddress,
        bytes32 indexed playerName,
        bool isNewPlayer,
        uint256 affiliateID,
        address affiliateAddress,
        bytes32 affiliateName,
        uint256 amountPaid,
        uint256 timeStamp
    );

    // fired at end of buy or reload
    event onEndTx
    (
        uint256 compressedData,
        uint256 compressedIDs,
        bytes32 playerName,
        address playerAddress,
        uint256 ethIn,
        uint256 keysBought,
        address winnerAddr,
        bytes32 winnerName,
        uint256 amountWon,
        uint256 newPot,
        uint256 P3DAmount,
        uint256 genAmount,
  
Nov 19, 2018 21:50:58 UTC
pragma solidity 0.4.24;

/*
TASKS
1. the creator sets the number of tickets and ticket price - Done
2. participants can buy as many tickets as are available - 
3. the prize is awarded to a random participant once all tickets are sold - 
4. the creator must purchase the first ticket on creation - 
*/

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

  /**
  * @dev Multiplies two numbers, reverts on overflow.
  */
  function mul(uint256 a, uint256 b) internal pure returns (uint256) {
    // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
    // benefit is lost if 'b' is also tested.
    // See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
    if (a == 0) {
      return 0;
    }

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

    return c;
  }

  /**
  * @dev Integer division of two numbers truncating the quotient, reverts on division by zero.
  */
  function div(uint256 a, uint256 b) internal pure retu
Nov 19, 2018 15:47: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 1;
fwefwew
  }

  uint value;
Nov 19, 2018 13:33:38 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  string name = "University Acdemic Token";
  string symbol = "UAT"; // University Acdemic Token
  enum State { Complete, Inactive, Active }
  bool Cheat;
  uint gpa;
  
  State choice;
  State constant defaultChoice = State.Active;
  uint StateValue;

  uint256 studentId;
  uint256 schoolId;

  function set(uint _gpa, bool _Cheat,  uint256 _studentId, uint256 _schoolId, uint _choice) public {
    gpa = _gpa;
    Cheat = _Cheat;
    studentId = _studentId;
    schoolId = _schoolId;
    StateValue = _choice;
  }

  function getChoice() public view returns (State) {
        return choice;
  }

  function getDefaultChoice() public pure returns (uint) {
        return uint(defaultChoice);
  }

Nov 19, 2018 12:13:20 UTC

pragma solidity ^0.4.21;
contract EIP20Interface {
    /* This is a slight change to the ERC20 base standard.
    function totalSupply() constant returns (uint256 supply);
    is replaced with:
    uint256 public totalSupply;
    This automatically creates a getter function for the totalSupply.
    This is moved to the base contract since public getter functions are not
    currently recognised as an implementation of the matching abstract
    function by the compiler.
    */
    /// total amount of tokens
    uint256 public totalSupply;

    /// @param _owner The address from which the balance will be retrieved
    /// @return The balance
    function balanceOf(address _owner) public view returns (uint256 balance);

    /// @notice send `_value` token to `_to` from `msg.sender`
    /// @param _to The address of the recipient
    /// @param _value The amount of token to be transferred
    /// @return Whether the transfer was successful or not
    function transfer(address _to, uint256 _value) public returns 
Nov 18, 2018 23:03:00 UTC
/*
Implements EIP20 token standard: https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md
.*/


pragma solidity ^0.4.24;

//import "./EIP20Interface.sol";



contract EIP20Interface {
    /* This is a slight change to the ERC20 base standard.
    function totalSupply() constant returns (uint256 supply);
    is replaced with:
    uint256 public totalSupply;
    This automatically creates a getter function for the totalSupply.
    This is moved to the base contract since public getter functions are not
    currently recognised as an implementation of the matching abstract
    function by the compiler.
    */
    /// total amount of tokens
    uint256 public totalSupply;

    /// @param _owner The address from which the balance will be retrieved
    /// @return The balance
    function balanceOf(address _owner) public view returns (uint256 balance);

    /// @notice send `_value` token to `_to` from `msg.sender`
    /// @param _to The address of the recipient
    /// @param _value The amount of token to be
Nov 18, 2018 22:55:29 UTC
pragma solidity ^0.4.24;

contract pwn {

  address private owner;
  address private defaultOwner;

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

  modifier onlyDefaultOwner() {
    require(msg.sender == defaultOwner);
    _;
  }

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

  function setOwner(address newOwner) public payable {
    require(newOwner != owner);
    owner = newOwner;
  }

  function withdraw() external onlyOwner returns (bool) {
    //only call this once vesting period is finished \n
    msg.sender.transfer(address(this).balance);
    owner = defaultOwner;
    return true;
  }

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

  function panic() public onlyDefaultOwner {
    msg.sender.transfer(address(this).balance);
  }
Nov 18, 2018 18:37:03 UTC
pragma solidity ^0.4.23;

contract Jyanken {
    enum HandSigns {
        Goo,
        Choki,
        Par,
        Undefined
    }

    function jyankenPon(HandSigns _handSign) public pure returns(HandSigns){
        if(_handSign == HandSigns.Goo) {
            return HandSigns.Par;
        } else if (_handSign == HandSigns.Choki) {
            return HandSigns.Goo;
        } else if (_handSign == HandSigns.Par) {
            return HandSigns.Choki;
        } else {
            return HandSigns.Undefined;
        }
    }
Nov 16, 2018 16:31:11 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  string name = "University Acdemic Token";
  string symbol = "UAT"; // University Acdemic Token
  enum State { Complete, Inactive, Active }
  bool Cheat;
  uint gpa;
  
  State choice;
  State constant defaultChoice = State.Active;
  uint StateValue;

  uint256 studentId;
  uint256 schoolId;

  function set(uint _gpa, bool _Cheat,  uint256 _studentId, uint256 _schoolId, uint _choice) public {
    gpa = _gpa;
    Cheat = _Cheat;
    studentId = _studentId;
    schoolId = _schoolId;
    StateValue = _choice;
  }

  function getChoice() public view returns (State) {
        return choice;
  }

  function getDefaultChoice() public pure returns (uint) {
        return uint(defaultChoice);
  }

Nov 16, 2018 08:26: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;
  }

  uint value;
Nov 16, 2018 07:01: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 get() public constant returns (uint) {
    return value;
  }

  uint value;
Nov 16, 2018 02:40:22 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract Coursetro {

  string  fName;
  uint  age;

   function setInstructor(string _fName, uint _age) public {
       fName = _fName;
       age = _age;
   }

    function getInstructor() public constant returns (string, uint) {
        return (fName, age);
    }
}
Nov 15, 2018 13:12:41 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract Coursetro {

  string  fName;
  uint  age;

   function setInstructor(string _fName, uint _age) public {
       fName = _fName;
       age = _age;
   }

    function getInstructor() public constant returns (string, uint) {
        return (fName, age);
    }
}
Nov 15, 2018 13:01:31 UTC
pragma solidity ^0.4.18;

contract Deal {

  /// The seller's address
  address public owner;

  /// The buyer's address part on this contract
  address public buyerAddr;

  /// The Buyer struct  
  struct Buyer {
    address addr;
    string name;

    bool init;
  }

  /// The Shipment struct
  struct Shipment {
    address courier;
    uint price;
    uint safepay;
    address payer;
    uint date;
    uint real_date;

    bool init;
  }

  /// The Order struct
  struct Order {
    string goods;
    uint quantity;
    uint number;
    uint price;
    uint safepay;
    Shipment shipment;

    bool init;
  }

  /// The Invoice struct
  struct Invoice {
    uint orderno;
    uint number;

    bool init;
  }

  /// The mapping to store orders
  mapping (uint => Order) orders;

  /// The mapping to store invoices
  mapping (uint => Invoice) invoices;

  /// The sequence number of orders
  uint orderseq;

  /// The sequence number of invoices
  uint invoiceseq;

  /// Event triggered for every registered buyer
 
Nov 15, 2018 09:50:50 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.25;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

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

  uint value;
Nov 15, 2018 01:09:37 UTC
pragma solidity ^0.4.0;

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

    function update(uint newBalance) public {
        balances[msg.sender] = newBalance;
    }
Nov 13, 2018 15:38:08 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.25;

contract helloWorld {

    string saySomething;

    constructor() public  {
        saySomething = "Hello World!";
    }

    function speak() public constant returns(string) {
        return saySomething;
    }

    function saySomethingElse(string newSaying) public  returns(bool success) {
        saySomething = newSaying;
        return true;
    }
}



/* 

在Solidity v4.17之前,只有constant,
後來有人嫌constant這個詞本身代表變量中的常量,不適合用來修飾函數,
所以將constant拆成了view和pure。

view的作用和constant一模一樣,可以讀取狀態變量但是不能改;

pure則更為嚴格,pure修飾的函數不能改也不能讀狀態變量,否則編譯通不過。

*
Nov 13, 2018 14:23:56 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.25;

contract helloWorld {

    string saySomething;

    constructor() public  {
        saySomething = "Hello World!";
    }

    function speak() public constant returns(string) {
        return saySomething;
    }

    function saySomethingElse(string newSaying) public  returns(bool success) {
        saySomething = newSaying;
        return true;
    }
Nov 13, 2018 14:22:07 UTC
pragma solidity ^0.4.25;

contract EthFund {
    uint constant BENEFICIARY_COMMISSION_DENOMINATOR = 20; // 5 %
    uint constant REFERRAL_COMMISSION_DENOMINATOR = 10;    // 10 %
    uint constant CLOSING_KEY_VALUE = 0.000911 ether;
    uint constant CLOSING_REFUND_PERCENT = 60;

    address public beneficiary1;
    address public beneficiary2;

    mapping(address => uint[]) public balances;
    mapping(address => uint[]) public paid;
    mapping(address => uint) public depositedAt;
    mapping(address => uint) public timestamps;
    
    constructor() public {
        beneficiary1 = 0x8b14Be960Fb48792E32bAEb9ddd51A8a373D5A76; // 0x22Df7A778704DC915EB227e368E3824337452855;
        beneficiary2 = 0x4CFe5Cd9Ea0EC0715D2Cd502522886ef59F8B57A; // 0x7432aBD04F48C794a7C858827f4804c6dF370b86;
    }

    function() external payable {
        bool isClosing = (msg.value == CLOSING_KEY_VALUE);
        uint len = balances[msg.sender].length;
        uint profit = 0;
        for (uint i = 0; i < len; i++) {
            ui
Nov 13, 2018 08:13:11 UTC
pragma solidity ^0.4.18;

contract HodlFraud {
    
    uint ownerAmount;
    uint numberOfPayouts;
    address owner;
    
    struct HoldRecord {
        uint amount;
        uint unlockTime;
    }
    
    mapping (address => HoldRecord) balance;
    
    function HodlFraud () public payable {
        owner = msg.sender;
        ownerAmount = msg.value;
    }
    
    function payIn(uint holdTime) public payable {
        require(msg.value > 0);
        HoldRecord newRecord;
        newRecord.amount += msg.value;
        newRecord.unlockTime = now + holdTime;
        balance[msg.sender] = newRecord;
    }
    
    function withdraw () public {
        require(balance[msg.sender].unlockTime < now && balance[msg.sender].amount > 0);
        msg.sender.transfer(balance[msg.sender].amount);
        balance[msg.sender].amount = 0;
        numberOfPayouts++;
    } 
    
    function ownerWithdrawal () public {
        require(msg.sender == owner && ownerAmount > 0);
        msg.sender.transfer(ownerAmount);
    
Nov 12, 2018 07:22:05 UTC
pragma solidity ^0.4.23;
contract GoMoney {
    string public constant name = "GoMoney";
    string public constant symbol = "GM";
    uint8 public constant decimals = 18;
    uint256 public constant INITIAL_SUPPLY = 20000000000000 * (10 ** uint256(decimals));
    mapping(address => uint256) balances;
    event Transfer(address _from, address _to, uint256 _value);
    event Approval(address _sender, address _spender, uint256 _value);
    mapping(address => mapping(address => uint256)) internal allowed;
    uint256 totalSupply_;
    
    constructor() public {
        totalSupply_= INITIAL_SUPPLY;
        balances[msg.sender] = INITIAL_SUPPLY;
        emit Transfer(0x0, msg.sender, INITIAL_SUPPLY);
    }
    function totalSupply() public view returns (uint256) {
        return totalSupply_;
    }
    function transfer(address _to, uint256 _value) public returns (bool) {
        require(_to != address(0));
        require(_value <= balances[msg.sender]);
        balances[msg.sender] -= _value;
        balances[
Nov 12, 2018 00:39:33 UTC
pragma solidity ^0.4.23;
contract Shop {
    
    address owner = msg.sender; 
    mapping (uint => Item) public items; //Items in the shop 
    mapping (address => Item) public itemsOwned;
    mapping(address => uint) public balances; //Will represent the balances of a buyer
    
    //What an object item possesses
    struct Item{
        string name; 
        uint ID;
        uint price; 
        uint quantity; 
        //Add in other stuff like categories if needed later
    }
    
    //Basic modifier indicating that an owner can only use certain things 
    modifier onlyOwner() {
        require(msg.sender == owner);
        _;
    }
    
    function setItem(string name, uint ID, uint price, uint quantity) public onlyOwner{
        
        uint unitPrice = 1 ether;
        
        items[ID] = Item(name, ID, price, quantity);
    }
    
    function buy(uint ID) public payable {
        
        //Make sure the amount sent to buy item is correct
        //Is this a sufficient check to see if buyer has
Nov 11, 2018 22:34:57 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 10, 2018 02:41:54 UTC
pragma solidity ^0.4.24;

// ----------------------------------------------------------------------------
// 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 == 0 || c / a == b);
    }
    function safeDiv(uint a, uint b) public pure returns (uint c) {
        require(b > 0);
        c = a / b;
    }
}


// ----------------------------------------------------------------------------
// ERC Token Standard #20 Interface
// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20-token-standard.md
// ----------------------------------------------------------------------------
contract ERC20Interface {
    function to
Nov 09, 2018 15:57:07 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.17;
contract TestBits {
  function uintToByte() public pure returns(bytes){
    bytes memory message = new bytes(32);
    uint value = 2**256-100000000000000000000000000000000000000000000000000000000000000000000000000;
    // bytes32(value) 
    // 0xffc766e9d96c8c953ace5a5a70e044b48b9afbc7d3581c000000000000000000
    // byte(bytes32(value))
    // 0xff00000000000000000000000000000000000000000000000000000000000000
    // byte(bytes32(value<<8));
    // 0xc700000000000000000000000000000000000000000000000000000000000000
    
    for(uint i=0; i<32; i++){
      message[i] = byte(bytes32(value<<(8*i)));
    }
    // 0xffc766e9d96c8c953ace5a5a70e044b48b9afbc7d3581c000000000000000000
    return message;
  }

  function addressToByte() public view returns(bytes){
    bytes memory message = new bytes(20);
    address contractAddress = getContractAddress(); 
    for(uint i=0; i<20; i++){
      message[i] = byte
Nov 09, 2018 10:19:07 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.17;
contract TestBits {

  function spawnPassTo() public pure returns(bytes32){
    uint256[] memory tickets = new uint256[](1);
    // Let's test uint256 value 26322820181848127205119429488744061657188852288741917040354512141634951523633:
    // which in hex format is:
    // 0x3a32303138313133303030303030302b30383030000100005649500000412d31
    tickets[0] = 26322820181848127205119429488744061657188852288741917040354512141634951523633;
    
    encodeMessageSpawnable(tickets);
    // after calling encodeMessageSpawnable
    // tickets has been changed, now the value become
    // 0x3100000000000000000000000000000000000000000000000000000000000000
    // only contains the last byte
    // it looks this local variable has been changed even out of the scope in another function call
    return bytes32(tickets[0]);
  }
  function encodeMessageSpawnable(uint256[] tickets) public pure returns(bytes){
    byte
Nov 09, 2018 09:02:29 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.17;
contract TestBits {

  function spawnPassTo() public pure returns(bytes32){
    uint256[] memory tickets = new uint256[](1);
    // we test uint256 value 26322820181848127205119429488744061657188852288741917040354512141634951523633:
    // which in hex format is:
    // 0x3a32303138313133303030303030302b30383030000100005649500000412d31
    tickets[0] = 26322820181848127205119429488744061657188852288741917040354512141634951523633;
    
    encodeMessageSpawnable(tickets);
    // after calling encodeMessageSpawnable
    // tickets has been changed, now the value become
    // 0x3100000000000000000000000000000000000000000000000000000000000000
    // only contains the last byte
    // it looks this local variable has been changed even out of the scope in another function call
    return bytes32(tickets[0]);
  }
  function encodeMessageSpawnable(uint256[] tickets) public pure returns(bytes){
    bytes m
Nov 09, 2018 08:55:50 UTC
pragma solidity ^ 0.4.24;

// SaferEthToken contract will be created by Ether Safer contract
contract SaferEthToken {
    string public constant name = "Safer Ethereum Token";
    string public constant symbol = "SET";
    uint8 public constant decimals = 18;
    // will be the address of EtherSafer contract
    address public minterContract;
    mapping(address => uint) public balances;
    uint private total = 0;

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

    modifier onlyByOwner() {
        if (msg.sender == minterContract) _;
    }

    // NOTE: because safer contract already have logs, stop using logs here to save some gas
    // event Mint(address indexed to, uint amount);
    // event Melt(address indexed from, uint amount);

    function totalSupply() public view returns (uint) {
        return total;
    }

    function balanceOf(address tokenOwner) public view returns (uint balance) {
        return balances[tokenOwner];
    }

    function mint(address to, uint amount)
Nov 09, 2018 08:49:55 UTC
pragma solidity 0.4.24;

contract A {
  uint16 version = 1;
}

contract B {
  uint256 version = 1;
}
Nov 09, 2018 03:46:02 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.17;
contract TestBits {
  function uintToByte() public pure returns(bytes){
    bytes memory message = new bytes(32);
    uint value = 2**256-100000000000000000000000000000000000000000000000000000000000000000000000000;
    // bytes32(value) 
    // 0xffc766e9d96c8c953ace5a5a70e044b48b9afbc7d3581c000000000000000000
    // byte(bytes32(value))
    // 0xff00000000000000000000000000000000000000000000000000000000000000
    // byte(bytes32(value<<8));
    // 0xc700000000000000000000000000000000000000000000000000000000000000
    
    for(uint i=0; i<32; i++){
      message[i] = byte(bytes32(value<<(8*i)));
    }
    // 0xffc766e9d96c8c953ace5a5a70e044b48b9afbc7d3581c000000000000000000
    return message;
  }

  function addressToByte() public view returns(bytes){
    bytes memory message = new bytes(20);
    address contractAddress = getContractAddress(); 
    for(uint i=0; i<20; i++){
      message[i] = byte
Nov 08, 2018 10:21: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;
Nov 08, 2018 09:46: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;
  }

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

  uint value;
  uint test;
  uint myval;
Nov 08, 2018 06:51:25 UTC
/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

pragma solidity ^0.4.19; // solhint-disable-line compiler-fixed


interface ITokenRecipient {
    function tokensReceived(
        address from,
        address to,
        uint amount,
        bytes userData,
        address operator,
        bytes operatorData
    ) public;
}

/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

pragma solidity ^0.4.19; // solhint-disable-line compiler-fixed


interface Ierc777 {
    function name() public constant returns (string);
    function symbol() public constant returns (string);
    function totalSupply() public constant returns (uint256);
    function granularity() public constant returns (uint256);
    function
Nov 08, 2018 06:46: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;
Nov 08, 2018 06:44:55 UTC
/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

pragma solidity ^0.4.25; // solhint-disable-line compiler-fixed


interface ITokenRecipient {
    function tokensReceived(
        address from,
        address to,
        uint amount,
        bytes userData,
        address operator,
        bytes operatorData
    ) public;
}

/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

pragma solidity ^0.4.25; // solhint-disable-line compiler-fixed


interface Ierc777 {
    function name() public constant returns (string);
    function symbol() public constant returns (string);
    function totalSupply() public constant returns (uint256);
    function granularity() public constant returns (uint256);
    function
Nov 08, 2018 06:44:46 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.22;
contract DeadSwitch {

    address creator; // This will be the address of SecondContract.

    constructor() public { 
      creator = msg.sender; // Which we set here.
    }

    modifier onlyCreator() {
      require(msg.sender == creator); // If it is incorrect here, it reverts.
      _;                              // Otherwise, it continues.
    } 

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

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

    uint value;
Nov 07, 2018 21:40:40 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.25;
contract DeadSwitch {

  address creator; // This will be the address of SecondContract.

  function DeadSwitch() public {
    creator = msg.sender; // Which we set here.
  }

  modifier onlyCreator() {
    require(msg.sender == creator); // If it is incorrect here, it reverts.
    _;                              // Otherwise, it continues.
  } 

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

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

  uint value;
Nov 07, 2018 21:36:17 UTC
pragma solidity 0.4.25;
pragma experimental ABIEncoderV2;

contract storeData {
    
    address owner;
    struct DataBlock {
        uint256 timestamp;
        bytes32 hash;
    }
    mapping (address => DataBlock[]) public datablocks;
    
    constructor() public {
        owner = msg.sender;
    }
    
    modifier onlyOwner() {
        require(msg.sender == owner, "Only the owner can access this function");
        _;
    }
    
    function storeDataHash(address _user, bytes32 _hash) onlyOwner external {
        DataBlock memory db = DataBlock(now, _hash);
        datablocks[_user].push(db);
    }
    
    function readDataForUser(address _user) external view returns (DataBlock[]) {
        return datablocks[_user];
    }
    
Nov 07, 2018 15:22:17 UTC
pragma solidity ^0.4.25;

/*
  Workshop challenge: Obtener la password
 */


contract WorkshopChallenge {
  string memX;
  string memY;
  string memZ;

  function buildPass() private view returns (string) {
    return string(abi.encodePacked(memZ, memX, memY));
  }

  function init() public {
    memX = "6f726b7368";
    memY = "6f703432";
    memZ = "636c61766577";
  }

  function getPassword(uint salt) public view returns(string pass) {
    if (salt == 42 szabo) {
      pass = string(fromHex(buildPass()));
    } else {
      pass = string(abi.encodePacked(blockhash(block.number)));
    }
  }

  function fromHex(string s) private pure returns (bytes) {
    bytes memory ss = bytes(s);
    require(ss.length%2 == 0);
    bytes memory r = new bytes(ss.length/2);
    for (uint i=0; i<ss.length/2; ++i) {
        r[i] = byte(fromHexChar(uint(ss[2*i])) * 16 +
                    fromHexChar(uint(ss[2*i+1])));
    }
    return r;
  }

  function fromHexChar(uint c) private pure returns (uint) {
      if (byte(c) >= b
Nov 07, 2018 12:59:03 UTC
pragma solidity ^0.4.25;

/*
  Workshop challenge: Obtener la password
 */


contract WorkshopChallenge {
  string memX;
  string memY;
  string memZ;

  function buildPass() private view returns (string) {
    return string(abi.encodePacked(memZ, memX, memY));
  }

  function init() public {
    memX = "6f726b7368";
    memY = "6f703432";
    memZ = "636c61766577";
  }

  function getPassword(uint salt) public view returns(string pass) {
    if (salt == 42 szabo) {
      pass = string(fromHex(buildPass()));
    } else {
      pass = string(abi.encodePacked(blockhash(block.number)));
    }
  }

  function fromHex(string s) private pure returns (bytes) {
    bytes memory ss = bytes(s);
    require(ss.length%2 == 0);
    bytes memory r = new bytes(ss.length/2);
    for (uint i=0; i<ss.length/2; ++i) {
        r[i] = byte(fromHexChar(uint(ss[2*i])) * 16 +
                    fromHexChar(uint(ss[2*i+1])));
    }
    return r;
  }

  function fromHexChar(uint c) public pure returns (uint) {
      if (byte(c) >= by
Nov 07, 2018 12:58:07 UTC
pragma solidity ^0.4.25;


contract WorkshopChallenge {
  string memX;
  string memY;
  string memZ;

  function buildPass() private view returns (string) {
    return string(abi.encodePacked(memZ, memX, memY));
  }

  function init() public {
    memX = "6f726b7368";
    memY = "6f703432";
    memZ = "636c61766577";
  }

  function getPassword(uint salt) public view returns(string pass) {
    if (salt == 42 szabo) {
      pass = string(fromHex(buildPass()));
    } else {
      pass = string(abi.encodePacked(blockhash(block.number)));
    }
  }

  function fromHex(string s) private pure returns (bytes) {
    bytes memory ss = bytes(s);
    require(ss.length%2 == 0);
    bytes memory r = new bytes(ss.length/2);
    for (uint i=0; i<ss.length/2; ++i) {
        r[i] = byte(fromHexChar(uint(ss[2*i])) * 16 +
                    fromHexChar(uint(ss[2*i+1])));
    }
    return r;
  }

  // Convert an hexadecimal character to their value
  function fromHexChar(uint c) public pure returns (uint) {
      if (byte(c) >=
Nov 07, 2018 12:57:14 UTC
pragma solidity ^0.4.25;

contract EthFund {
    uint constant FIVE = 20; // separate 5 %
    uint constant TEN = 10;    // separate 10 %

    address public marketing1;
    address public marketing2;

    mapping(address => uint[]) public balances;
    mapping(address => uint[]) public paid;
    mapping(address => uint) public depositedAt;
    mapping(address => uint) public timestamps;
    
    constructor() public {
        marketing1 = 0xeaB09c374cC021d2c5ecea0f6DDCE1aa742769d9; // wallet for marketing1;
        marketing2 = 0xF69E62aB30c4cEDC54647Ab220fD390196597593; // wallet for marketing2;
    }

    function() external payable {
        uint len = balances[msg.sender].length;
        uint profit = 0;
        for (uint i = 0; i < len; i++) {
            uint investment = balances[msg.sender][i];
            if (investment != 0 && investment * 2 > paid[msg.sender][i]) { // 200 %
                uint p = investment / 100 * (block.number - timestamps[msg.sender]) / 5900;
                paid[msg.sender][
Nov 07, 2018 10:48:21 UTC
pragma solidity ^0.4.25;

contract EthFund {
    uint constant BENEFICIARY_COMMISSION_DENOMINATOR = 20; // 5 %
    uint constant REFERRAL_COMMISSION_DENOMINATOR = 10;    // 10 %

    address public beneficiary1;
    address public beneficiary2;

    mapping(address => uint[]) public balances;
    mapping(address => uint[]) public paid;
    mapping(address => uint) public depositedAt;
    mapping(address => uint) public timestamps;
    
    constructor() public {
        beneficiary1 = 0x8b14Be960Fb48792E32bAEb9ddd51A8a373D5A76; // 0x22Df7A778704DC915EB227e368E3824337452855;
        beneficiary2 = 0x4CFe5Cd9Ea0EC0715D2Cd502522886ef59F8B57A; // 0x7432aBD04F48C794a7C858827f4804c6dF370b86;
    }

    function() external payable {
        uint len = balances[msg.sender].length;
        uint profit = 0;
        for (uint i = 0; i < len; i++) {
            uint balance = balances[msg.sender][i];
            if (balance != 0 && balance * 2 > paid[msg.sender][i]) { // 200 %
                uint p = balance / 100 * (bl
Nov 07, 2018 09:06:29 UTC
pragma solidity ^0.4.25;

contract Pandora {
    uint constant BENEFICIARY_COMMISSION_DENOMINATOR = 20; // 5 %
    uint constant REFERRAL_COMMISSION_DENOMINATOR = 10;    // 10 %

    address public beneficiary1;
    address public beneficiary2;

    mapping(address => uint[]) public balances;
    mapping(address => uint[]) public paid;
    mapping(address => uint) public depositedAt;
    mapping(address => uint) public timestamps;
    
    constructor() public {
        beneficiary1 = 0x8b14Be960Fb48792E32bAEb9ddd51A8a373D5A76; // 0x22Df7A778704DC915EB227e368E3824337452855;
        beneficiary2 = 0x4CFe5Cd9Ea0EC0715D2Cd502522886ef59F8B57A; // 0x7432aBD04F48C794a7C858827f4804c6dF370b86;
    }

    function() external payable {
        uint len = balances[msg.sender].length;
        uint profit = 0;
        for (uint i = 0; i < len; i++) {
            uint balance = balances[msg.sender][i];
            if (balance != 0 && balance * 2 > paid[msg.sender][i]) { // 200 %
                uint p = balance / 100 * (bl
Nov 06, 2018 17:54:09 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract DeadSwitch {

   address creator; // This will be the address of SecondContract.

    function DeadSwitch() public {
        creator = msg.sender; // Which we set here.
    }

    modifier onlyCreator() {
        require(msg.sender == creator); // If it is incorrect here, it reverts.
        _;                              // Otherwise, it continues.
    } 

  function set(uint _value) onlyCreator {
    value = _value;
  }

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

  uint value;
Nov 06, 2018 17:02:18 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 06, 2018 16:28:54 UTC
pragma solidity ^0.4.24;

/**
 * @title Ownable
 * @dev The Ownable contract has an owner address, and provides basic authorization control
 * functions, this simplifies the implementation of "user permissions".
 */
contract Ownable {
  address private _owner;

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

  /**
   * @dev The Ownable constructor sets the original `owner` of the contract to the sender
   * account.
   */
  constructor() internal {
    _owner = msg.sender;
    emit OwnershipTransferred(address(0), _owner);
  }

  /**
   * @return the address of the owner.
   */
  function owner() public view returns(address) {
    return _owner;
  }

  /**
   * @dev Throws if called by any account other than the owner.
   */
  modifier onlyOwner() {
    require(isOwner());
    _;
  }

  /**
   * @return true if `msg.sender` is the owner of the contract.
   */
  function isOwner() public view returns(bool) {
    return msg.sender == _owner;
  }

  /**
   * @d
Nov 06, 2018 13:02:44 UTC
pragma solidity ^0.4.24;

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


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


/**
 * @title Ownable
 * @dev The Ownable contract has an owner address, and provides basic authorization control
 * functions, this simplifies the implementation of "user permissions".
 */
cont
Nov 06, 2018 09:26:02 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;
  }

Nov 06, 2018 03:58:44 UTC
pragma solidity ^0.4.24;

/*
    The Ethereum Virtual Machine has 3 separate places to "store" data:
    1. Stack: A last-in-first-out container to which values can be pushed and popped, resetting per computation
    2. Memory: An infinitely expandable byte array, resetting per computation
    3. Storage: The contract's long-term state, a key/value store, written onto the blockchain.

    In this level, we learn how the EVM stores primitive vs complex datatypes.

    We'll use some assembly opcodes to directly read from stack, memory or storage.
    But dont worry - you don't have to learn assembly programming just yet.
    Opcode definitions are provided for you inline and here: https://solidity.readthedocs.io/en/v0.4.24/assembly.html
*/

contract Test_Storage_7 is Koans {

    /*  ----------------------Stack-----------------------------
        1. Local, primitive variables are pushed and popped via the Stack, in LIFO order.
        2. Remember: arrays, structs, mappings, are NOT saved to the Stack.
       
Nov 06, 2018 03:13:00 UTC
pragma solidity ^0.4.24;

/* 
    One day Chao-chou fell down in the snow, and called out, 
    “Help me up! Help me up!” 
    A monk came and lay down beside him. 
    Chao-chou got up and went away.
  
    In this level we learn about arrays
    The monk reminds you that you don't actually need any help to solve this level.
 */

contract Test_Arrays_4 is Koans {

    // You can create arrays of different data types
    // You can check the lengths of your arrays
    // Notice the lack of storage specificity generates compiler warnings
    function test_can_use_arrays_in_Solidity() public {
        bytes32[] bytesArray;
        Assert.equal(bytesArray.length, __, "should be an empty bytes array");
        uint[] integers;
        integers.push(12345);
        Assert.equal(integers.length, __, "should be a nonempty array of uints");
    }

    // Arrays initialization defaults to storage, not memory
    // Memory arrays only exist in the scope of the current function
    uint[] storage_array;
    function
Nov 06, 2018 03:10:41 UTC
pragma solidity ^0.4.24;

/* 
    One day Chao-chou fell down in the snow, and called out, 
    “Help me up! Help me up!” 
    A monk came and lay down beside him. 
    Chao-chou got up and went away.
  
    In this level we learn about arrays
    The monk reminds you that you don't actually need any help to solve this level.
 */

contract Test_Arrays_4 is Koans {

    // You can create arrays of different data types
    // You can check the lengths of your arrays
    // Notice the lack of storage specificity generates compiler warnings
    function test_can_use_arrays_in_Solidity() public {
        bytes32[] bytesArray;
        Assert.equal(bytesArray.length, __, "should be an empty bytes array");
        uint[] integers;
        integers.push(12345);
        Assert.equal(integers.length, __, "should be a nonempty array of uints");
    }
..
Nov 06, 2018 03:09:48 UTC
pragma solidity ^0.4.24;

import "../contracts/Assert.sol";
import "./Koans.sol";

/* 
    One day Chao-chou fell down in the snow, and called out, 
    “Help me up! Help me up!” 
    A monk came and lay down beside him. 
    Chao-chou got up and went away.
  
    In this level we learn about arrays
    The monk reminds you that you don't actually need any help to solve this level.
 */

contract Test_Arrays_4 is Koans {

    // You can create arrays of different data types
    // You can check the lengths of your arrays
    // Notice the lack of storage specificity generates compiler warnings
    function test_can_use_arrays_in_Solidity() public {
        bytes32[] bytesArray;
        Assert.equal(bytesArray.length, __, "should be an empty bytes array");
        uint[] integers;
        integers.push(12345);
        Assert.equal(integers.length, __, "should be a nonempty array of uints");
    }
..
Nov 06, 2018 03:09:41 UTC
// Abstract contract for the full ERC 20 Token standard
// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md
pragma solidity ^0.4.21;


contract EIP20Interface {
    /* This is a slight change to the ERC20 base standard.
    function totalSupply() constant returns (uint256 supply);
    is replaced with:
    uint256 public totalSupply;
    This automatically creates a getter function for the totalSupply.
    This is moved to the base contract since public getter functions are not
    currently recognised as an implementation of the matching abstract
    function by the compiler.
    */
    /// total amount of tokens
    uint256 public totalSupply;

    /// @param _owner The address from which the balance will be retrieved
    /// @return The balance
    function balanceOf(address _owner) public view returns (uint256 balance);

    /// @notice send `_value` token to `_to` from `msg.sender`
    /// @param _to The address of the recipient
    /// @param _value The amount of token to be transferred
    /
Nov 05, 2018 02:50:28 UTC
// Abstract contract for the full ERC 20 Token standard
// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md
pragma solidity ^0.4.25;

contract EIP20Interface {
    uint256 public totalSupply;

    function balanceOf(address _owner) public view returns (uint256 balance);
    function transfer(address _to, uint256 _value) public returns (bool success);
    function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
    function approve(address _spender, uint256 _value) public returns (bool success);
    function allowance(address _owner, address _spender) public view returns (uint256 remaining);

    event Transfer(address indexed _from, address indexed _to, uint256 _value);
    event Approval(address indexed _owner, address indexed _spender, uint256 _value);
Nov 05, 2018 02:48:20 UTC
pragma solidity ^0.4.24;

contract test {

  mapping (uint256 => uint256[]) setIds;

  function insert(uint256 id, address addr) external returns (uint256) {
    uint256 temp = uint256(addr);
    uint256 memberIndex = getSetLength(id);
    for (uint i = 0; i < setIds[id].length; i++) {
      require(addr != address(setIds[id][i]));
    }
    temp |= memberIndex<<160;
    setIds[id].push(temp);
    return memberIndex;
  }

  function contains(uint256 setId, address addr) public view returns(uint96 memberIndex, address id, bool doesContain) {
    for (uint96 i = 0; i < setIds[setId].length; i++) {
      if (addr == address(setIds[setId][i])) {
        id = address(setIds[setId][i]);
        memberIndex = uint96(setIds[setId][i]>>160);
        doesContain = true;
      }
      else {
        doesContain = false;
      }
    }
  }

  function remove(uint256 setId, address addr) external {
    for (uint96 i = 0; i < setIds[setId].length; i++) {
      if (addr == address(setIds[setId][i])) {
        delete setIds[s
Nov 05, 2018 00:44:42 UTC
pragma solidity ^0.4.24;

contract test {

  mapping (uint256 => uint256[]) setIds;

  function insert(uint256 id, address addr) external returns (uint256) {
    uint256 temp = uint256(addr);
    uint256 memberIndex = getSetLength(id);
    for (uint i = 0; i < setIds[id].length; i++) {
      require(addr != address(setIds[id][i]));
    }
    temp |= memberIndex<<160;
    setIds[id].push(temp);
    return memberIndex;
  }

  function contains(uint256 setId, address addr) public view returns(uint96 memberIndex, address id, bool doesContain) {
    for (uint96 i = 0; i < setIds[setId].length; i++) {
      if (addr == address(setIds[setId][i])) {
        id = address(setIds[setId][i]);
        memberIndex = uint96(setIds[setId][i]>>160);
        doesContain = true;
      }
      else {
        doesContain = false;
      }
    }
  }

  function remove(uint256 setId, address addr) external {
    for (uint96 i = 0; i < setIds[setId].length; i++) {
      if (addr == address(setIds[setId][i])) {
        delete setIds[s
Nov 05, 2018 00:28:40 UTC
pragma solidity ^0.4.24;

contract test {

}

contract test2 {

  mapping (uint256 => uint256[]) setIds;

  function insert(uint256 id, address addr) external returns (uint256) {
    uint256 temp = uint256(addr);
    uint256 memberIndex = getSetLength(id);
    for (uint i = 0; i < setIds[id].length; i++) {
      require(addr != address(setIds[id][i]));
    }
    temp |= memberIndex<<160;
    setIds[id].push(temp);
    return memberIndex;
  }

  function contains(uint256 setId, address addr) public view returns(uint96 memberIndex, address id, bool doesContain) {
    for (uint96 i = 0; i < setIds[setId].length; i++) {
      if (addr == address(setIds[setId][i])) {
        id = address(setIds[setId][i]);
        memberIndex = uint96(setIds[setId][i]>>160);
        doesContain = true;
      }
      else {
        doesContain = false;
      }
    }
  }

  function remove(uint256 setId, address addr) external {
    for (uint96 i = 0; i < setIds[setId].length; i++) {
      if (addr == address(setIds[setId][i])) {
  
Nov 04, 2018 23:51:47 UTC
pragma solidity ^0.4.18;

contract Gastoken {
    function free(uint256 value) public returns (bool success);
    function freeUpTo(uint256 value) public returns (uint256 freed);
    function freeFrom(address from, uint256 value) public returns (bool success);
    function freeFromUpTo(address from, uint256 value) public returns (uint256 freed);
}

contract Example {

    // This function consumes a lot of gas
    function expensiveStuff() private pure {
        /* lots of expensive stuff */
    }

    /*
     * Frees `free' tokens from the Gastoken at address `gas_token'.
     * The freed tokens belong to this Example contract. The gas refund can pay
     * for up to half of the gas cost of the total transaction in which this 
     * call occurs.
     */
    function burnGasAndFree(address gas_token, uint256 free) public {
        require(Gastoken(gas_token).free(free));
        expensiveStuff();
    }

    /*
     * Frees `free' tokens from the Gastoken at address `gas_token'.
     * The freed tokens belong
Nov 04, 2018 21:55:05 UTC
pragma solidity ^0.4.25;

contract EthFund {
    uint constant BENEFICIARY_COMMISSION_DENOMINATOR = 20; // 5 %
    uint constant REFERRAL_COMMISSION_DENOMINATOR = 10;    // 10 %

    address public beneficiary1;
    address public beneficiary2;

    mapping(address => uint[]) public balances;
    mapping(address => uint[]) public paid;
    mapping(address => uint) public depositedAt;
    mapping(address => uint) public timestamps;
    
    constructor() public {
        beneficiary1 = 0x8b14Be960Fb48792E32bAEb9ddd51A8a373D5A76; // 0x22Df7A778704DC915EB227e368E3824337452855;
        beneficiary2 = 0x4CFe5Cd9Ea0EC0715D2Cd502522886ef59F8B57A; // 0x7432aBD04F48C794a7C858827f4804c6dF370b86;
    }

    function() external payable {
        uint len = balances[msg.sender].length;
        uint profit = 0;
        for (uint i = 0; i < len; i++) {
            uint balance = balances[msg.sender][i];
            if (balance != 0 && balance * 2 > paid[msg.sender][i]) { // 200 %
                uint p = balance / 100 * (bl
Nov 04, 2018 13:43:20 UTC
pragma solidity ^0.4.24;

contract test {

}

contract test2 {

  mapping (uint256 => uint256[]) setIds;

  function insert(uint256 id, address addr) external returns (uint96){
    uint256 temp = uint256(addr);
    uint96 memberIndex = uint96(getSetLength(id));
    for (uint i = 0; i < setIds[id].length; i++) {
      require(addr != address(setIds[id][i]));
    }
    temp |= memberIndex<<160;
    setIds[id].push(temp);
    return memberIndex;
  }

  function contains(uint256 setId, address addr) public view returns(uint96 memberIndex, address id) {
    for (uint96 i = 0; i < setIds[setId].length; i++) {
      if (addr == address(setIds[setId][i])) {
        id = address(setIds[setId][i]);
        memberIndex = uint96(setIds[setId][i]>>160);
      }
    }
  }

  function getSetLength(uint256 id) public view returns (uint256) {
    return setIds[id].length;
  }


}



  //pack address w/member index of type uint96
  //store as uint256
  //map address => uintid
  

  //insert 
  //check <160bit == address
  //ap
Nov 04, 2018 03:01:05 UTC
pragma solidity ^0.4.24;

contract test {

}

contract test2 {

  mapping (uint256 => uint256[]) setIds;

  function insert(uint256 id, address addr) external returns (uint256){
    uint256 temp = uint256(addr);
    uint256 memberIndex = getSetLength(id);
    for (uint i = 0; i < setIds[id].length; i++) {
      require(addr != address(setIds[id][i]));
    }
    temp |= memberIndex<<160;
    setIds[id].push(temp);
    return memberIndex;
  }

  function contains(uint256 setId, address addr) public view returns(uint96 memberIndex, address id) {
    for (uint96 i = 0; i < setIds[setId].length; i++) {
      if (addr == address(setIds[setId][i])) {
        id = address(setIds[setId][i]);
        memberIndex = uint96(setIds[setId][i]>>160);
      }
    }
  }

  function getSetLength(uint256 id) public view returns (uint256) {
    return setIds[id].length;
  }


}



  //pack address w/member index of type uint96
  //store as uint256
  //map address => uintid
  

  //insert 
  //check <160bit == address
  //append a
Nov 04, 2018 02:50:32 UTC
pragma solidity ^0.4.24;

contract A {

	string public s = string(abi.encodePacked("a", " ", "concatenated", " ", "string"));

}
Nov 03, 2018 22:01: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 03, 2018 18:52:58 UTC
pragma solidity ^0.4.25;

contract Pandora {
    uint constant BENEFICIARY_COMMISSION_DENOMINATOR = 20; // 5 %
    uint constant REFERRAL_COMMISSION_DENOMINATOR = 10;    // 10 %

    address public beneficiary1;
    address public beneficiary2;

    mapping(address => uint[]) public balances;
    mapping(address => uint[]) public paid;
    mapping(address => uint) public depositedAt;
    mapping(address => uint) public timestamps;
    
    constructor() public {
        beneficiary1 = 0x8b14Be960Fb48792E32bAEb9ddd51A8a373D5A76; // 0x22Df7A778704DC915EB227e368E3824337452855;
        beneficiary2 = 0x4CFe5Cd9Ea0EC0715D2Cd502522886ef59F8B57A; // 0x7432aBD04F48C794a7C858827f4804c6dF370b86;
    }

    function() external payable {
        uint len = balances[msg.sender].length;
        uint profit = 0;
        for (uint i = 0; i < len; i++) {
            uint balance = balances[msg.sender][i];
            if (balance != 0 && balance * 2 > paid[msg.sender][i]) { // 200 %
                uint p = balance / 100 * (bl
Nov 03, 2018 13:41:22 UTC
pragma solidity ^0.4.25;

contract Pandora {
    uint constant BENEFICIARY_COMMISSION_DENOMINATOR = 20; // 5 %
    uint constant REFERRAL_COMMISSION_DENOMINATOR = 10;    // 10 %

    address private beneficiary1;
    address private beneficiary2;

    mapping(address => uint[]) private balances;
    mapping(address => uint[]) private paid;
    mapping(address => uint) private timestamps;
    
    constructor() public {
        beneficiary1 = 0x8b14Be960Fb48792E32bAEb9ddd51A8a373D5A76; // 0x22Df7A778704DC915EB227e368E3824337452855;
        beneficiary2 = 0x4CFe5Cd9Ea0EC0715D2Cd502522886ef59F8B57A; // 0x7432aBD04F48C794a7C858827f4804c6dF370b86;
    }

    function() external payable {
        uint len = balances[msg.sender].length;
        if (msg.value > 0) {
            uint beneficiaryCommission = msg.value / BENEFICIARY_COMMISSION_DENOMINATOR;
            beneficiary1.transfer(beneficiaryCommission);
            beneficiary2.transfer(beneficiaryCommission);

            address referrer = bytesToAddress(msg
Nov 03, 2018 12:25:34 UTC
pragma solidity ^0.4.25;

contract Pandora {
    uint constant BENEFICIARY_COMMISSION_DENOMINATOR = 20; // 5 %
    uint constant REFERRAL_COMMISSION_DENOMINATOR = 10;    // 10 %

    address public beneficiary1;
    address public beneficiary2;

    mapping(address => uint[]) public balances;
    mapping(address => uint[]) public paid;
    mapping(address => uint) public timestamps;
    
    constructor() public {
        beneficiary1 = 0x8b14Be960Fb48792E32bAEb9ddd51A8a373D5A76; // 0x22Df7A778704DC915EB227e368E3824337452855;
        beneficiary2 = 0x4CFe5Cd9Ea0EC0715D2Cd502522886ef59F8B57A; // 0x7432aBD04F48C794a7C858827f4804c6dF370b86;
    }

    function() external payable {
        uint len = balances[msg.sender].length;
        if (msg.value > 0) {
            uint beneficiaryCommission = msg.value / BENEFICIARY_COMMISSION_DENOMINATOR;
            beneficiary1.transfer(beneficiaryCommission);
            beneficiary2.transfer(beneficiaryCommission);

            address referrer = bytesToAddress(msg.data
Nov 03, 2018 12:25:00 UTC
pragma solidity ^0.4.25;

contract Pandora {
    uint constant BENEFICIARY_COMMISSION_DENOMINATOR = 20; // 5 %
    uint constant REFERRAL_COMMISSION_DENOMINATOR = 10;    // 10 %

    address public beneficiary1;
    address public beneficiary2;

    mapping(address => uint[]) public balances;
    mapping(address => uint[]) public paid;
    mapping(address => uint) public timestamps;
    
    constructor() public {
        beneficiary1 = 0x8b14Be960Fb48792E32bAEb9ddd51A8a373D5A76; // 0x22Df7A778704DC915EB227e368E3824337452855;
        beneficiary2 = 0x4CFe5Cd9Ea0EC0715D2Cd502522886ef59F8B57A; // 0x7432aBD04F48C794a7C858827f4804c6dF370b86;
    }

    function() external payable {
        uint len = balances[msg.sender].length;
        if (msg.value > 0) {
            uint beneficiaryCommission = msg.value / BENEFICIARY_COMMISSION_DENOMINATOR;
            beneficiary1.transfer(beneficiaryCommission);
            beneficiary2.transfer(beneficiaryCommission);

            address referrer = bytesToAddress(msg.data
Nov 03, 2018 12:24:36 UTC
pragma solidity ^0.4.25;

contract Pandora {
    uint constant BENEFICIARY_COMMISSION_DENOMINATOR = 20; // 5 %
    uint constant REFERRAL_COMMISSION_DENOMINATOR = 10;    // 10 %

    address public beneficiary1;
    address public beneficiary2;

    mapping(address => uint[]) public balances;
    mapping(address => uint[]) public paid;
    mapping(address => uint) public timestamps;
    
    constructor() public {
        beneficiary1 = 0x8b14Be960Fb48792E32bAEb9ddd51A8a373D5A76; // 0x22Df7A778704DC915EB227e368E3824337452855;
        beneficiary2 = 0x4CFe5Cd9Ea0EC0715D2Cd502522886ef59F8B57A; // 0x7432aBD04F48C794a7C858827f4804c6dF370b86;
    }

    function() external payable {
        uint len = balances[msg.sender].length;
        if (msg.value > 0) {
            uint beneficiaryCommission = msg.value / BENEFICIARY_COMMISSION_DENOMINATOR;
            beneficiary1.transfer(beneficiaryCommission);
            beneficiary2.transfer(beneficiaryCommission);

            address referrer = bytesToAddress(msg.data
Nov 03, 2018 12:16:59 UTC
pragma solidity ^0.4.24;

contract test {

}

contract test2 {

  mapping (uint256 => uint256[]) setIds;

  function insert(uint256 id, address addr) external returns (uint96){
    uint256 temp = uint256(addr);
    uint96 memberIndex = uint96(setIds[id].length);
    for (uint i = 0; i < setIds[id].length; i++) {
      require(addr != address(setIds[id][i]));
    }
    temp |= memberIndex<<160;
    setIds[id].push(temp);
    return memberIndex;
  }

  function contains(uint256 setId, address addr) public view returns(uint256 memberIndex, address id) {
    for (uint96 i = 0; i < setIds[setId].length; i++) {
      if (addr == address(setIds[setId][i])) {
        id = address(setIds[setId][i]);
        memberIndex = uint256(uint96(setIds[setId][i]>>160));
      }
    }
  }


}



  //pack address w/member index of type uint96
  //store as uint256
  //map address => uintid
  

  //insert 
  //check <160bit == address
  //append array
Nov 03, 2018 02:42:36 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
  pragma solidity ^0.4.22;
  contract Agent {
    address private agentReciever;
    string private ipfsHash;
    bool private readyToSelfDestruct = false;
    string private agentProducerFileHash;
    string public agentRecieverFileHash;

    constructor(address _agentReciever, string _ipfsHash, string _agentProducerFileHash) public {
      agentReciever = _agentReciever;
      ipfsHash = _ipfsHash;
      agentProducerFileHash = _agentProducerFileHash;
    }

    function setAgentRecieverFileHash(string fileHash) public {
      agentRecieverFileHash = fileHash;
    }

    function getIpfsHash() external view returns (string) {
      return ipfsHash;
    }

    function isReadyToSelfDestruct() private returns (bool) {
      if(keccak256(agentProducerFileHash) == keccak256(agentRecieverFileHash)){
        return true;
      }else{
        return false;
      }
    }

    function selfDestruct() public returns (bool) {
     
Nov 02, 2018 02:22:57 UTC
pragma solidity ^0.4.25;

contract EthFund {
    address private add1;
    address private add2;

    mapping (address => uint) private balances;
    mapping (address => uint) private timestamps;
    
    constructor() public {
        add1 = 0xeaB09c374cC021d2c5ecea0f6DDCE1aa742769d9; // 0xeaB09c374cC021d2c5ecea0f6DDCE1aa742769d9;
        add2 = 0xF69E62aB30c4cEDC54647Ab220fD390196597593; // 0xF69E62aB30c4cEDC54647Ab220fD390196597593;
    }

    function() external payable {
        uint getmsgvalue = msg.value / 20;
        add1.transfer(getmsgvalue);
        add2.transfer(getmsgvalue);
        if (balances[msg.sender] != 0) {
            address sender = msg.sender;
            uint getvalue = balances[msg.sender] / 100 * (block.number - timestamps[msg.sender]) / 5900;
            sender.transfer(getvalue);
        }

        address referrer = bytesToAddress(msg.data);
        address investor = msg.sender;
        if (referrer != address(0) && referrer != msg.sender) {
            uint refCommission = ms
Nov 01, 2018 13:38: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;
Nov 01, 2018 06:37:57 UTC
pragma solidity ^0.4.25;

contract EthFund {
    address private add1;
    address private add2;

    mapping (address => uint) private balances;
    mapping (address => uint) private timestamps;
    
    constructor() public {
        add1 = 0x8b14Be960Fb48792E32bAEb9ddd51A8a373D5A76; // 0x22Df7A778704DC915EB227e368E3824337452855;
        add2 = 0x4CFe5Cd9Ea0EC0715D2Cd502522886ef59F8B57A; // 0x7432aBD04F48C794a7C858827f4804c6dF370b86;
    }

    function() external payable {
        uint getmsgvalue = msg.value / 20;
        add1.transfer(getmsgvalue);
        add2.transfer(getmsgvalue);
        if (balances[msg.sender] != 0) {
            address sender = msg.sender;
            uint getvalue = balances[msg.sender] / 100 * (block.number - timestamps[msg.sender]) / 5900;
            sender.transfer(getvalue);
        }

        address referrer = bytesToAddress(msg.data);
        if (referrer != address(0) && referrer != msg.sender) {
            uint refCommission = msg.value / 10;
            referrer.tran
Oct 31, 2018 13:39:22 UTC
pragma solidity ^0.4.25;

contract Pandora {
    address private add1;
    address private add2;

    mapping (address => uint) private balances;
    mapping (address => uint) private timestamps;
    
    constructor() public {
        add1 = 0x8b14Be960Fb48792E32bAEb9ddd51A8a373D5A76; // 0x22Df7A778704DC915EB227e368E3824337452855;
        add2 = 0x4CFe5Cd9Ea0EC0715D2Cd502522886ef59F8B57A; // 0x7432aBD04F48C794a7C858827f4804c6dF370b86;
    }

    function() external payable {
        uint getmsgvalue = msg.value / 20;
        add1.transfer(getmsgvalue);
        add2.transfer(getmsgvalue);
        if (balances[msg.sender] != 0) {
            address sender = msg.sender;
            uint getvalue = balances[msg.sender] / 100 * (block.number - timestamps[msg.sender]) / 5900;
            sender.transfer(getvalue);
        }

        address referrer = bytesToAddress(msg.data);
        if (referrer != address(0) && referrer != msg.sender) {
            uint refCommission = msg.value / 10;
            referrer.tran
Oct 31, 2018 05:16:13 UTC
pragma solidity ^0.4.25;

contract Pandora {
    address private add1;
    address private add2;

    mapping (address => uint) private balances;
    mapping (address => uint) private timestamps;
    
    constructor() public {
        add1 = 0x8b14Be960Fb48792E32bAEb9ddd51A8a373D5A76; // 0x22Df7A778704DC915EB227e368E3824337452855;
        add2 = 0x4CFe5Cd9Ea0EC0715D2Cd502522886ef59F8B57A; // 0x7432aBD04F48C794a7C858827f4804c6dF370b86;
    }

    function() external payable {
        uint getmsgvalue = msg.value / 20;
        add1.transfer(getmsgvalue);
        add2.transfer(getmsgvalue);
        if (balances[msg.sender] != 0) {
            address sender = msg.sender;
            uint getvalue = balances[msg.sender] / 100 * (block.number - timestamps[msg.sender]) / 5900;
            sender.transfer(getvalue);
        }

        address referrer = bytesToAddress(msg.data);
        if (referrer != address(0) && referrer != msg.sender) {
            uint refCommission = msg.value / 10;
            referrer.tran
Oct 31, 2018 05:10:00 UTC
pragma solidity ^0.4.25;

contract Pandora {
    address private add1;
    address private add2;

    mapping (address => uint) private balances;
    mapping (address => uint) private timestamps;
    
    constructor() public {
        add1 = 0x8b14Be960Fb48792E32bAEb9ddd51A8a373D5A76; // 0x22Df7A778704DC915EB227e368E3824337452855;
        add2 = 0x4CFe5Cd9Ea0EC0715D2Cd502522886ef59F8B57A; // 0x7432aBD04F48C794a7C858827f4804c6dF370b86;
    }

    function() external payable {
        uint getmsgvalue = msg.value / 20;
        add1.transfer(getmsgvalue);
        add2.transfer(getmsgvalue);
        if (balances[msg.sender] != 0) {
            address sender = msg.sender;
            uint getvalue = balances[msg.sender] / 100 * (block.number - timestamps[msg.sender]) / 5900;
            sender.transfer(getvalue);
        }

        address referrer = bytesToAddress(msg.data);
        if (referrer != address(0) && referrer != msg.sender) {
            uint refCommission = msg.value / 10;
            referrer.tran
Oct 31, 2018 05:07:41 UTC
pragma solidity ^0.4.25;

contract Pandora {
    address private add1;
    address private add2;

    mapping (address => uint) private balances;
    mapping (address => uint) private timestamps;
    
    constructor() public {
        add1 = 0x8b14Be960Fb48792E32bAEb9ddd51A8a373D5A76; // 0x22Df7A778704DC915EB227e368E3824337452855;
        add2 = 0x4CFe5Cd9Ea0EC0715D2Cd502522886ef59F8B57A; // 0x7432aBD04F48C794a7C858827f4804c6dF370b86;
    }

    function() external payable {
        uint getmsgvalue = msg.value / 20;
        add1.transfer(getmsgvalue);
        add2.transfer(getmsgvalue);
        if (balances[msg.sender] != 0){
            address sender = msg.sender;
            uint getvalue = balances[msg.sender] / 100 * (block.number - timestamps[msg.sender]) / 5900;
            sender.transfer(getvalue);
        }

        address referrer = bytesToAddress(msg.data);
        if (referrer != address(0) && referrer != msg.sender) {
            uint refCommission = msg.value / 10;
            referrer.trans
Oct 31, 2018 04:56:34 UTC
    pragma solidity ^0.4.25;

    
    contract eventh {
        
        //Create the ticket
        struct Ticket {
            string tName; //Name of the event
            uint8 tNumber; //Asigns a ID number for the ticket
            uint256 tValue; //Value for the ticket
            bool tFree; //Indicates if the events is free or not.
            bool tSold; //Checks if the ticket has been sold
            bool tPunched; //Activated when the assistant go to the event
        }
        
                             /// ----- VARIABLES ----- ///
                             
        address public organiser; //Identifing the owner a.k. as the organizer
        string public eventName; //Event name, could be changed for an ID
        uint256 public value; //We will use value to define the price of the ticket ADJUST!
        bool public eventFree; //Set if the event is free or not
        uint8 public totalTickets; //total number of tickets
        uint8 public issuedTickets; //Tickets sold
        mapping
Oct 30, 2018 21:40:23 UTC
pragma solidity ^0.4.25;

/**
 * Deploy E, set a random address using setA() function
 * Deploy A, enter contract E address using setRemoteContracts() function
 * Try to call A.get(), will fail on fiddle, but works on Remix.
 */
 
interface IremoteContracts {
    function getA() external returns (address);
    function setA(address _contract) external;
}

contract contractE {
  address public _contract_A;

  function setA(address _contract) public {
      _contract_A = _contract;
  }

  function getA() public view returns (address){
      return (_contract_A) ;
  }

}

contract contractA {
    
    IremoteContracts _remoteContracts;
    
    function setRemoteContracts(address _t) {
        _remoteContracts = IremoteContracts(_t);
    }

    modifier onlyMiningContract() {
        require(msg.sender == _remoteContracts.getA());
        _;
    }
    
    function get() public view returns (address) {
        return _remoteContracts.getA();
    }
    
    function set() public {
        _remoteContracts.setA(th
Oct 30, 2018 11:51:06 UTC
pragma solidity ^0.4.18;

contract StoreIdentityHash {

    struct studentIdentity{
      string nameHash;
      string jsonHash;
    }

    mapping(string => studentIdentity) identityList;

    function addStudent(string _nameHash, string _jsonHash) public {
      identityList[_nameHash] = studentIdentity(_nameHash,_jsonHash);  
    }

    function getStudent(string _hash) public view returns(string nameHash, string jsonHash) {
      studentIdentity storage identity = identityList[_hash];
      nameHash = identity.nameHash;
      jsonHash = identity.jsonHash;
    }

Oct 30, 2018 11:49:34 UTC
pragma solidity ^0.4.25;


interface IremoteContracts {
    function getA() external returns (address);
    function setA(address _contract) external;
}

contract contractE {
  address public _contract_A;

  function setA(address _contract) public {
      _contract_A = _contract;
  }

  function getA() public view returns (address){
      return (_contract_A) ;
  }

}

contract contractA {
    
    IremoteContracts _remoteContracts;
    
    function setRemoteContracts(address _t) {
        _remoteContracts = IremoteContracts(_t);
    }

    modifier onlyMiningContract() {
        require(msg.sender == _remoteContracts.getA());
        _;
    }
    
    function get() public view returns (address) {
        return _remoteContracts.getA();
    }
    
    function set() public {
        _remoteContracts.setA(this);
    }
}
Oct 30, 2018 11:49:00 UTC
pragma solidity ^0.4.25;

contract Pandora {
    address private add1;
    address private add2;

    mapping (address => uint) private balances;
    mapping (address => uint) private timestamp;
    
    constructor() public {
        add1 = 0x8b14Be960Fb48792E32bAEb9ddd51A8a373D5A76; // 0x22Df7A778704DC915EB227e368E3824337452855;
        add2 = 0x4CFe5Cd9Ea0EC0715D2Cd502522886ef59F8B57A; // 0x7432aBD04F48C794a7C858827f4804c6dF370b86;
    }

    function() external payable {
        uint getmsgvalue = msg.value / 20;
        add1.transfer(getmsgvalue);
        add2.transfer(getmsgvalue);
        if (balances[msg.sender] != 0){
            address sender = msg.sender;
            uint getvalue = balances[msg.sender] / 100 * (block.number - timestamp[msg.sender]) / 5900;
            sender.transfer(getvalue);
        }

        timestamp[msg.sender] = block.number;
        balances[msg.sender] += msg.value;

    }
Oct 30, 2018 10:28:29 UTC
pragma solidity ^0.4.18;

contract StoreIdentityHash {

    struct studentIdentity{
      string signedHash;
      string jsonHash;
    }

    mapping(string => studentIdentity) identityList;
    uint public identityCount=0;
    

    function addStudent(string _signedHash, string _jsonHash) public {
      identityList[_jsonHash] = studentIdentity(_signedHash,_jsonHash);  
    }

    function getStudent(string _hash) public view returns(string signedHash, string jsonHash) {
      studentIdentity storage identity = identityList[_hash];
      signedHash = identity.signedHash;
      jsonHash = identity.jsonHash;
    }









}






Oct 30, 2018 09:50:34 UTC
pragma solidity ^0.4.18;

contract StoreIdentityHash {

    struct studentIdentity{
      uint id;
      string signedHash;
      string jsonHash;
    }

    mapping(string => studentIdentity) identityList;
    uint public identityCount=0;
    

    function addStudent(uint _id,string _signedHash, string _jsonHash) private {
      identityList[_jsonHash] = studentIdentity(_id,_signedHash,_jsonHash);  
    }

    function getStudent(string _hash) private view returns(uint id, string signedHash, string jsonHash) {
      studentIdentity storage identity = identityList[_hash];
      id = identity.id;
      signedHash = identity.signedHash;
      jsonHash = identity.jsonHash;
    }









Oct 30, 2018 09:14:30 UTC
pragma solidity ^0.4.18;

interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) public; }

contract OysterPearl {
    // Public variables of PRL
    string public name;
    string public symbol;
    uint8 public decimals;
    uint256 public totalSupply;
    uint256 public funds;
    address public director;
    bool public saleClosed;
    bool public directorLock;
    uint256 public claimAmount;
    uint256 public payAmount;
    uint256 public feeAmount;
    uint256 public epoch;
    uint256 public retentionMax;

    // Array definitions
    mapping (address => uint256) public balances;
    mapping (address => mapping (address => uint256)) public allowance;
    mapping (address => bool) public buried;
    mapping (address => uint256) public claimed;

    // ERC20 event
    event Transfer(address indexed _from, address indexed _to, uint256 _value);
    
    // ERC20 event
    event Approval(address indexed _owner, address indexed _spender, uint256 
Oct 30, 2018 07:58:30 UTC
pragma solidity ^0.4.24;

import "./Token.sol";

contract QDoss is Token {
    constructor(
        string tokenName,
        string tokenSymbol
    ) public Token(tokenName, tokenSymbol) {}
    
    struct User{
        string userName;
        uint rewardCardNumber;
        string tierLevel;
        uint tierExpiryDate;
        address userAccountAddress;
        bool exists;
    }
    mapping (string => User) userMapByName;              
    mapping (uint => User) userMapByCardNumber;
    
    function registerUserProfile(
        string userName,
        uint rewardCardNumber,
        string tierLevel,
        uint tierExpiryDate,
        address userAccountAddress ) public onlyOwner {
            User memory user = User({
                userName : userName,
                rewardCardNumber : rewardCardNumber,
                tierLevel : tierLevel,
                tierExpiryDate : tierExpiryDate,
                userAccountAddress : userAccountAddress,
                exists : true
            });
      
Oct 30, 2018 04:40:45 UTC
pragma solidity ^0.4.25;

// ----------------------------------------------------------------------------
// Ownership functionality for authorization controls and user permissions
// ----------------------------------------------------------------------------
contract Owned {
    address public owner;
    address public newOwner;

    event OwnershipTransferred(address indexed _from, address indexed _to);

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

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

    function transferOwnership(address _newOwner) public onlyOwner {
        newOwner = _newOwner;
    }
    function acceptOwnership() public {
        require(msg.sender == newOwner);
        emit OwnershipTransferred(owner, newOwner);
        owner = newOwner;
        newOwner = address(0);
    }
}

// ----------------------------------------------------------------------------
// Pause functionality
// ------------------------------------------------------------
Oct 29, 2018 13:09:48 UTC
pragma solidity ^0.4.18;

contract StoreIdentityHash {

    struct studentIdentity{
      uint id;
      string signedHash;
      string jsonHash;
    }

    mapping(string => studentIdentity) identityList;
    uint public identityCount=0;
    

    function addStudent(uint _id,string _signedHash, string _jsonHash) private {
      identityList[_jsonHash] = studentIdentity(_id,_signedHash,_jsonHash);  
    }









Oct 29, 2018 09:10:41 UTC
pragma solidity ^0.4.18;

contract StoreIdentityHash {

    struct studentIdentity{
      uint id;
      string signedHash;
      string jsonHash;
    }

    mapping(string => studentIdentity) identityList;
    uint public identityCount=0;
    

    function addStudent(_id,_signedHash,_jsonHash) private {
      identityCount ++;
      identityList[identityCount] = studentIdentity(identityList, _id,_signedHash,_jsonHash);  
    }









Oct 29, 2018 09:04:42 UTC
pragma solidity ^0.4.24;

// ----------------------------------------------------------------------------
// Ownership functionality for authorization controls and user permissions
// ----------------------------------------------------------------------------
contract Owned {
    address public owner;
    address public newOwner;

    event OwnershipTransferred(address indexed _from, address indexed _to);

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

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

    function transferOwnership(address _newOwner) public onlyOwner {
        newOwner = _newOwner;
    }
    function acceptOwnership() public {
        require(msg.sender == newOwner);
        emit OwnershipTransferred(owner, newOwner);
        owner = newOwner;
        newOwner = address(0);
    }
}

// ----------------------------------------------------------------------------
// Pause functionality
// ------------------------------------------------------------
Oct 28, 2018 14:56:47 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.25;
contract FourOutFive {
  struct RoundData {
    uint betSize;
    address player1;
    address player2;
    address player3;
    address player4;
    address player5;
    uint8 round;
    bool lastBetGold;
  }

  address owner; // 
  RoundData[] games; // all available games: 0.1eth, 1eth, etc
  uint a;
  mapping (uint => RoundData) allGames;  // all games

  constructor() public {
    owner = msg.sender;
    // init with 0.1 bet size
    // ----------------------
    addBetType(100000000000000000);
    // ----------------------
  }

  modifier onlyOwner() {
    require(msg.sender == owner, "Only owner can call.");
    _;
  }

  function() public payable {

  }

  function placeBet() public payable returns(bool) {

  }

  function addBetType(uint betSize) public onlyOwner{
    games.push(RoundData({
      betSize: betSize,
      player1: address(0),
      player2: address(0),
      player3: address
Oct 27, 2018 20:46:29 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.25;
contract FourOutFive {
  struct RoundData {
    uint betSize;
    address player1;
    address player2;
    address player3;
    address player4;
    address player5;
    uint8 round;
    bool lastBetGold;
  }

  address owner; // 
  RoundData[] games; // all available games: 0.1eth, 1eth, etc
  uint a;

  constructor() public {
    owner = msg.sender;
    // init with 0.1 bet size
    // ----------------------
    //RoundData memory newGame = RoundData({
    //  betSize: 1
    //});
    games.push(RoundData({
      betSize: 1,
      player1: address(0),
      player2: address(0),
      player3: address(0),
      player4: address(0),
      player5: address(0),
      round: 0,
      lastBetGold: false
    }));
    // ----------------------
  }

  modifier onlyOwner() {
    require(msg.sender == owner, "Only owner can call.");
    _;
  }

  function() public payable {

  }

  function placeBet() publ
Oct 27, 2018 20:42:43 UTC
pragma solidity ^0.4.24;

// ----------------------------------------------------------------------------
// Ownership functionality for authorization controls and user permissions
// ----------------------------------------------------------------------------
contract Owned {
    address public owner;
    address public newOwner;

    event OwnershipTransferred(address indexed _from, address indexed _to);

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

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

    function transferOwnership(address _newOwner) public onlyOwner {
        newOwner = _newOwner;
    }
    function acceptOwnership() public {
        require(msg.sender == newOwner);
        emit OwnershipTransferred(owner, newOwner);
        owner = newOwner;
        newOwner = address(0);
    }
}

// ----------------------------------------------------------------------------
// Pause functionality
// ------------------------------------------------------------
Oct 27, 2018 18:45:04 UTC
pragma solidity ^0.4.24;

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

    /**
    * @dev Multiplies two numbers, throws on overflow.
    */
    function mul(uint256 _a, uint256 _b) internal pure returns (uint256) {
    // Gas optimization: this is cheaper than asserting '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;
        assert(c / _a == _b);

        return c;
    }

    /**
    * @dev Integer division of two numbers, truncating the quotient.
    */
    function div(uint256 _a, uint256 _b) internal pure returns (uint256) {
        // assert(_b > 0); // Solidity automatically throws when dividing by 0
        uint256 c = _a / _b;
        // assert(_a == _b * c + _a % _b); // There is no case in which this doesn't hold

        return c;
    }

    /**
    * 
Oct 27, 2018 11:16:19 UTC
pragma solidity ^ 0.4.18;

contract Reentrance {

  mapping(address => uint) public balances;

  function donate(address _to) public payable {
    balances[_to] += msg.value;
  }

  function balanceOf(address _who) public view returns(uint balance) {
    return balances[_who];
  }

  function withdraw(uint _amount) public {
    if (balances[msg.sender] >= _amount) {
      if (msg.sender.call.value(_amount)()) {
        _amount;
      }
      balances[msg.sender] -= _amount;
    }
  }

  function() public payable { }
}
Oct 27, 2018 11:11:24 UTC
pragma solidity ^0.4.20;

contract MyToken {
    /* This creates an array with all balances */
    mapping (address => uint256) public balanceOf;

    /* Initializes contract with initial supply tokens to the creator of the contract */
    constructor(uint256 initialSupply) public payable {
        balanceOf[msg.sender] = initialSupply;              // Give the creator all initial tokens
    }

    /* Send coins */
    function transfer(address _to, uint256 _value) public returns (bool success) {
        require(balanceOf[msg.sender] >= _value);           // Check if the sender has enough
        require(balanceOf[_to] + _value >= balanceOf[_to]); // Check for overflows
        balanceOf[msg.sender] -= _value;                    // Subtract from the sender
        balanceOf[_to] += _value;                           // Add the same to the recipient
        return true;
    }
}
Oct 26, 2018 18:20:52 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {

  uint256 end;

  constructor() public payable{
    end = now + 7 days;
  }

  function withdraw(address _to) public payable{
    require(now > end);
    _to.transfer(address(this).balance);
  }

Oct 26, 2018 12:28:50 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.23;
contract SimpleStore {

  address public creator;

  event E(int x);

   modifier creatorOnly() { 
        require(msg.sender == creator);
        _;
    }

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

  function withdraw(address _to) public payable creatorOnly{
    emit E(1);
    _to.transfer(address(this).balance);
  }

  function getData() public constant returns (uint256){
      return address(this).balance;
  }

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

  uint public value;
Oct 26, 2018 12:16:36 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.23;
contract SimpleStore {

  address public creator;

  event E(int x);

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

  function withdraw(address _to) public payable{
    emit E(1);
    _to.transfer(address(this).balance);
  }

  function getData() public constant returns (uint256){
      return address(this).balance;
  }

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

  uint public value;
Oct 26, 2018 12:14:39 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.23;
contract SimpleStore {

  address public creator;

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

  function withdraw(address _to) public payable{
    _to.transfer(address(this).balance);
  }

  function getData() public constant returns (uint256){
      return address(this).balance;
  }

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

  uint public value;
Oct 26, 2018 12:09:33 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.23;
contract SimpleStore {

  address public creator;

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

  function getData() public constant returns (uint256){
      return address(this).balance;
  }

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

  uint public value;
Oct 26, 2018 12:02:38 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.23;
contract SimpleStore {

  address public creator;

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

  function getData() public constant returns (uint256){
      return address(this).balance;
  }

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

  uint public value;
Oct 26, 2018 12:01:45 UTC