pragma solidity ^0.4.20;


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

contract Courses {
    struct Instructor {
       uint age;
        string fName;
        string lName;
    }
    mapping(address => Instructor) instructors;
    address[] public instructorAccts;

    function setInstructor(address _address, uint _age, string _fName, string _lName) public {
        var instructor = instructors[_address];
 //       var inst=Instructor;
 //       inst.age=_age;

     instructor.age=_age;
     instructor.fName=_fName;
     instructor.lName=_lName;
    
    instructorAccts.push(_address) -1;
    }
    function getInstructor() view public returns(address[]) {
return instructorAccts;

    }
    
    
Apr 20, 2018 08:23:46 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract GamesStore {

  mapping (uint=>string) GameList;


  function set(uint _id, string _value) public {
   GameList[_id] = _value;
  }

  function get(uint _id) public constant returns (string) {
    return GameList[_id];
  }

  function del(uint _id) public {
    delete GameList[_id];
  }
 
Apr 20, 2018 07:22:10 UTC
pragma solidity ^0.4.19;

import "./libraries/SafeMath.sol";

/**
 * @dev 
 */ 
contract HidingNameContract is SafeMath {

    event DividendsWithdrawn(address beneficiary, int256 ethValue);
    event DividendsReinvested(address beneficiary, uint256 tokenAmount);
    event TokensPurchased(address beneficiary, uint256 tokenAmount, uint256 ethValue);
    event TokensSold(address beneficiary, uint256 tokenAmount, uint256 ethValue);
    
    // constants for token info
    string constant public name = "RANDOM Token";
    string constant public symbol = "RANDOM";
    uint8 constant public decimals = 18;
    
    // constants for pyramid
    uint constant minPurchaseAmount = 0.000001 ether;
    uint constant maxPurchaseAmount = 1000000 ether;
    uint constant divisor = 20;
    uint constant scaleFactor = 0x10000000000000000;
    uint constant baseNumber = 37;
    uint constant maxBetSizeMultiplier = 12500;
    int constant crr_n = 1;
    int constant crr_d = 2;
    int constant price_coeff = -0x296ABF784A358468C;
Apr 20, 2018 03:26:03 UTC
```
pragma solidity ^0.4.19;

import "./libraries/SafeMath.sol";

/**
 * @dev 
 */ 
contract HidingNameContract is SafeMath {

    event DividendsWithdrawn(address beneficiary, int256 ethValue);
    event DividendsReinvested(address beneficiary, uint256 tokenAmount);
    event TokensPurchased(address beneficiary, uint256 tokenAmount, uint256 ethValue);
    event TokensSold(address beneficiary, uint256 tokenAmount, uint256 ethValue);
    
    // constants for token info
    string constant public name = "RANDOM Token";
    string constant public symbol = "RANDOM";
    uint8 constant public decimals = 18;
    
    // constants for pyramid
    uint constant minPurchaseAmount = 0.000001 ether;
    uint constant maxPurchaseAmount = 1000000 ether;
    uint constant divisor = 20;
    uint constant scaleFactor = 0x10000000000000000;
    uint constant baseNumber = 37;
    uint constant maxBetSizeMultiplier = 12500;
    int constant crr_n = 1;
    int constant crr_d = 2;
    int constant price_coeff = -0x296ABF784A3584
Apr 20, 2018 03:25:17 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 Subtracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend).
  */
  function sub(uint256 a, uint256 b) internal pure returns (uint256) {
    assert(b <= a);
    return a - b;
  }

  /**
  * @dev Adds two numbers, throws on overflow.
  */
  function add(uint256 a, uint256 b) internal pure returns (uint256) {
    uint256 c = a + b;
    assert(c >
Apr 20, 2018 02:31:03 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

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

  uint value;
}
//Working: Player starts the game by entering their name and a pokemon is selected randomly from the database as users first pokemon and require makes sure that the func is called only once.The player starts with only one pokemon in the begining of the game. Mapping and addressing can be used to track the owenship of the pokemon and number of pokemons the owner has.Player Buys/sells pokefood,poekmon eggs and pokemons.Pokemon feeds on pokefood for evolving and player can buy eggs and hatch them for increasing their pokemon count.

pragma solidity ^0.4.19;
contract PokemonFactory {

  
 struct Pokemon {
       string name;
       string type;
   }

   Pokemon[] public pokemons;

   function _createPokemon(string _name, uint _dna)
Apr 20, 2018 02:29:22 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 Subtracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend).
  */
  function sub(uint256 a, uint256 b) internal pure returns (uint256) {
    assert(b <= a);
    return a - b;
  }

  /**
  * @dev Adds two numbers, throws on overflow.
  */
  function add(uint256 a, uint256 b) internal pure returns (uint256) {
    uint256 c = a + b;
    assert(c >= 
Apr 20, 2018 01:24:05 UTC
pragma solidity ^0.4.18;

contract MyToken {

  string private tokenName = "My Super Awesome Token";
  string private tokenSymbol = "MSAT";
  // The number of zeros that your token is divisible by
  // With the # of decimals being 2, each of our tokens can be divisible 100 times
  uint private tokenDecimals = 2;
  uint private supplyOfTokens = 500;

  mapping(address => uint) private balances;
  mapping (address => mapping (address => uint)) private allowed;

  function MyToken() public {
    // When the contract is first deployed,
    // let the creator have all of the tokens
    // for them to distribute
    balances[msg.sender] = supplyOfTokens;
  }

  function name() public constant returns (string) {
    return tokenName;
  }

  function symbol() public constant returns (string) {
    return tokenSymbol;
  }

  function decimals() public constant returns (uint) {
    return tokenDecimals;
  }
  
  function totalSupply() public view returns (uint) {
    return supplyOfTokens;
  }
  
  function transfer(ad
Apr 19, 2018 23:53:30 UTC
pragma solidity ^0.4.18;

contract MyToken {

  string private tokenName = "My Super Awesome Token";
  string private tokenSymbol = "MSAT";
  // The number of zeros that your token is divisible by
  // With the # of decimals being 2, each of our tokens can be divisible 100 times
  uint private tokenDecimals = 2;
  uint private supplyOfTokens = 500;

  mapping(address => uint) private balances;
  mapping (address => mapping (address => uint)) private allowed;

  function name() public constant returns (string) {
    return tokenName;
  }

  function symbol() public constant returns (string) {
    return tokenSymbol;
  }

  function decimals() public constant returns (uint) {
    return tokenDecimals;
  }
  
  function totalSupply() public view returns (uint) {
    return supplyOfTokens;
  }
  
  function transfer(address _to, uint _value) public returns (bool) {
    require(_value <= balances[msg.sender]);

    balances[msg.sender] = balances[msg.sender] - _value;
    balances[_to] = balances[_to] + _value;
  
Apr 19, 2018 23:35:04 UTC
pragma solidity ^0.4.17;

/** 
 *  A game where a player tries to guess a number between 1 and 10.
 *  Operator sets the bet amount which the player must send when making a guess.
 *  Operator must deposit 8 times the bet amount.
 *  If player guess, they get all the funds.
 *  Otherwise, the operator gets the funds.
 */
contract GuessTheNumberGame {
    
    event SecretNumberSubmitted(bytes32 secretNumber);
    event GuessSubmitted(address player, uint guess);
    event ResultSubmitted(uint result);
    event PlayerWins();
    event OperatorWins();
    
    enum State {
        WAITING_SECRET, WAITING_GUESS, WAITING_RESULT, OPERATOR_WIN, PLAYER_WIN
    }
    
    address public operator;
    address public player;
    State public state;
    uint256 public bet;
    
    bytes32 public secretNumber;
    uint public guess;
    uint public result; // This is not strictly needed: can use state instead
    
    modifier byOperator() {
        require(msg.sender == operator);
        _;
    }
    
    modifier by
Apr 19, 2018 19:57:39 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;

contract MusicLibrary {
  enum Genre {RAP,POP,ROCK}

  struct MusicObject {
      uint id;
      string title;
      string url;
      Genre genre;
      uint duration;
      bool banned;
  }
    mapping (uint => MusicObject) listOfData;
    uint listOfDataLength;

  function set(uint _id, string _value, string _url, uint _genre, uint _duration) public {
    listOfDataLength++;
    Genre selectedGenre = Genre(_genre);
    listOfData[_id] = MusicObject(_id, _value, _url, selectedGenre, _duration, false);
  }

 function getGenre(uint _id) public constant returns (string) {
     if (uint(listOfData[_id].genre) == 0) {
         return "RAP";
     }
     if (uint(listOfData[_id].genre) == 1) {
         return "POP";
     } else {
        return "ROCK";
     }
 }

  function setBanned(uint _id) public {
    listOfData[_id].banned = true;
  }  

  function get(uint _id) public constant returns (string) {
Apr 19, 2018 19:55:43 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;

contract MusicLibrary {
  enum Genre {RAP,POP,ROCK}

  struct MusicObject {
      uint id;
      string title;
      string url;
      Genre genre;
      uint duration;
      bool banned;
  }
    mapping (uint => MusicObject) listOfData;
    uint listOfDataLength;

  function set(uint _id, string _value, string _url, uint _genre, uint _duration) public {
    listOfDataLength++;
    Genre selectedGenre = Genre(_genre);
    listOfData[_id] = MusicObject(_id, _value, _url, selectedGenre, _duration, false);
  }

 function getGenre(uint _id) public constant returns (uint) {
     return uint(listOfData[_id].genre);
 }

  function setBanned(uint _id) public {
    listOfData[_id].banned = true;
  }  

  function get(uint _id) public constant returns (string) {
    return listOfData[_id].title;
  }

  function getOnTripStatus(uint _id) public constant returns (bool) {
    return listOfData[_id].banned;
  }
Apr 19, 2018 19:52:33 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;

contract SimpleTrips {
  struct TripObject {
      uint id;
      string title;
      uint distance;
      bool onTrip;
  }
    mapping (uint => TripObject) listOfData;
    uint listOfDataLength;

  function set(uint _id, string _value, uint _distance) public {
    listOfDataLength++;
    listOfData[_id] = TripObject(_id, _value, _distance, false);
  }

  function setOnTrip(uint _id) public {
    listOfData[_id].onTrip = true;
  }  

  function get(uint _id) public constant returns (string) {
    return listOfData[_id].title;
  }

  function getOnTripStatus(uint _id) public constant returns (bool) {
    return listOfData[_id].onTrip;
  }  
  function remove(uint _id) public {
    delete listOfData[_id];
  }

  function showOnTrip(uint _id) public constant returns (string) {
      if (listOfData[_id].onTrip == true) {
          return "Уже в пути";
      } else {
          return "Едем"
Apr 19, 2018 19:44:43 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;


contract SimpleStore {
  struct NewsFeed {
      uint id;
      string title;
      bool readable;
  }

    // 1. Создать структуру данных под сущность из реального мира
    mapping (uint => NewsFeed) listOfData;
    uint listOfDataLength;
// Связать функции добавления/удаления/чтения с этой структурой
  function set(uint _id, string _value) public {
    listOfDataLength++;
    listOfData[_id] = NewsFeed(_id, _value, false);
  }
  function setPublic(uint _id) public {
    listOfData[_id].readable = true;
  }  
  function get(uint _id) public constant returns (string) {
    return listOfData[_id].title;
  }
  function getReadable(uint _id) public constant returns (bool) {
    return listOfData[_id].readable;
  }  
  function remove(uint _id) public {
    delete listOfData[_id];
  }

 // Созда
Apr 19, 2018 19:41:40 UTC
pragma solidity ^0.4.22;

contract TryNewFeatureContract {
  function TryNewFeatureContract() public { // for ~0.4.21
  // constructor() public {
    // constructorは function なしのconstructorという名前で定義するようになった。
  }

  function constructor() public pure returns(string) {
    // function 識別子をつけた場合はただの関数なので注意。
    return string(normalFuctionMessage());
  }

  function normalFuctionMessage() internal pure returns(bytes) {
    bytes memory message =  "This is normal 0.4.21..";
    return message;
  }

  function oneIsError(uint _num) returns(uint, string) {
    require(_num != 1, "hogehoge");
  }
Apr 19, 2018 15:32:51 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

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

  uint value;
Apr 19, 2018 12:35:56 UTC
pragma solidity ^0.4.21;

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

contract Assignment2 {
    // 기존 버전은 Transaction 단위 없이 ( 입금, 출금 ) 잔액 정보만 존재했음,
    // 이를 struct 를 사용하여 deposit_id, 시간, deposit 양, 상태(deposit, return) 정보를 함께 하나의 단위로 저장
    // 각 유저는 여러번 deposit 하여 여러 deposit_id 를 가질 수 있고, 각 단위에 대해 deposit_id 를 통해 claim 할 수 있도록 구현
    using SafeMath for uint256;

    // 원장
    struct Ledger {
        address deposit_id;
        uint time; // time of start burrow
        uint256 deposit_amount;
        string status;
    }

    Ledger[] ledgerList;
    event Logging(Ledger);
    // id별 입금 처리
    function() public payable {
        // 전송한 ETH(Wei) 양이 0 보다 커야 하는 조건        
        require(msg.value > 0);
        // 원장목록에 존재하는 id면 deposit 양에 받은 값을 
Apr 19, 2018 11:43:43 UTC
pragma solidity ^0.4.21;

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

contract Assignment2 {
    // 기존 버전은 Transaction 단위 없이 ( 입금, 출금 ) 잔액 정보만 존재했음,
    // 이를 struct 를 사용하여 deposit_id, 시간, deposit 양, 상태(deposit, return) 정보를 함께 하나의 단위로 저장
    // 각 유저는 여러번 deposit 하여 여러 deposit_id 를 가질 수 있고, 각 단위에 대해 deposit_id 를 통해 claim 할 수 있도록 구현
    using SafeMath for uint256;

    // 원장
    struct Ledger {
        address deposit_id;
        uint time; // time of start burrow
        uint256 deposit_amount;
        string status;
    }

    Ledger[] ledgerList;
    event Logging(Ledger);
    // id별 입금 처리
    function() public payable {
        // 전송한 ETH(Wei) 양이 0 보다 커야 하는 조건        
        require(msg.value > 0);
        // 원장목록에 존재하는 id면 deposit 양에 받은 값을 
Apr 19, 2018 11:36:18 UTC
pragma solidity ^0.4.21;

// File: node_modules/zeppelin-solidity/contracts/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 Subtracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend).
  */
  function sub(uint256 a, uint256 b) internal pure returns (uint256) {
    assert(b <= a);
    return a - b;
  }

  /**
  *
Apr 19, 2018 10:59:47 UTC
pragma solidity ^0.4.21;

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

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

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

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

  /**
  * @dev Adds two numbers, throws on overflow.
  */
  function add(uint
Apr 19, 2018 10:56:26 UTC
pragma solidity ^0.4.21;

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

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

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

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

  /**
  * @dev Adds two numbers, throws on overflow.
  */
  function add(uint
Apr 19, 2018 10:55:00 UTC
pragma solidity ^0.4.21;

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

contract Accounts {
    using SafeMath for uint256;
    
    event Logging(address sender, uint _timestamp, uint _amount, bool _state);
    event checkBalance(uint bal);
    
    struct account {
        mapping(uint => Book[]) books;
    }
    
    struct Book {
        uint timestamp;
        uint amount;
        bool state;
    }
    
    mapping (address => account) accounts;
    
    
    function readBook(uint _deposit_id, uint _index) public {
        Book storage _books = accounts[msg.sender].books[_deposit_id][_index];
        uint book_timestamp = _books.timestamp;
        uint book_amount = _books.amount;
        bool book_state = _books.state;
        emit Logging(msg.sender, book_timestamp, book_amount, book_state);
    }
    
    
    function deposit(uint _deposit_id) public payable {
        require(msg.value > 0);
        accounts[msg.sender].books[_deposit_id].push(Book(now, msg.value, 
Apr 19, 2018 10:54:06 UTC

pragma solidity ^0.4.21;

/**
 * @title ERC20Basic
 * @dev Simpler version of ERC20 interface
 * @dev see https://github.com/ethereum/EIPs/issues/179
 */
contract ERC20Basic {
  function totalSupply() public view returns (uint256);
  function balanceOf(address who) public view returns (uint256);
  function transfer(address to, uint256 value) public returns (bool);
  event Transfer(address indexed from, address indexed to, uint256 value);
}

/**
 * @title ERC20 interface
 * @dev see https://github.com/ethereum/EIPs/issues/20
 */
contract ERC20 is ERC20Basic {
  function allowance(address owner, address spender) public view returns (uint256);
  function transferFrom(address from, address to, uint256 value) public returns (bool);
  function approve(address spender, uint256 value) public returns (bool);
  event Approval(address indexed owner, address indexed spender, uint256 value);
Apr 19, 2018 10:19:33 UTC

pragma solidity ^0.4.21;

import "./ERC20Basic.sol";


/**
 * @title ERC20 interface
 * @dev see https://github.com/ethereum/EIPs/issues/20
 */
contract ERC20 is ERC20Basic {
  function allowance(address owner, address spender) public view returns (uint256);
  function transferFrom(address from, address to, uint256 value) public returns (bool);
  function approve(address spender, uint256 value) public returns (bool);
  event Approval(address indexed owner, address indexed spender, uint256 value);
Apr 19, 2018 10:18:37 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;

import "github.com/OpenZeppelin/zeppelin-solidity/blob/master/contracts/token/ERC20/ERC20Basic.sol";

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

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

  uint value;
Apr 19, 2018 10:10:00 UTC
pragma solidity ^0.4.21;

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

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

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

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

  /**
  * @dev Adds two numbers, throws on overflow.
  */
  function add(uint
Apr 19, 2018 09:25:15 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.21;

contract Deposit {

  struct sDepositInfo
  {
      uint256 deposit_id;
      uint256 deposit;
  }

  sDepositInfo[] depositArray;

  mapping(address => uint256) balances;

  function() public payable
  {
    require( msg.value > 0);
    balances[msg.sender] += msg.value;
    depositArray.push(sDepositInfo(depositArray.length,msg.value));
  }
  function myBalance() public view returns(uint256)
  {
    return balances[msg.sender];
  }
  function totalDepositAmount() public view returns(uint256)
  {
    return address(this).balance;    
  }
  function claim(uint256 _deposit_id) public 
  {
    require(_deposit_id <= depositArray.length - 1 && 
            _deposit_id == depositArray[_deposit_id].deposit_id && 
            depositArray[_deposit_id].deposit > 0 &&
            balances[msg.sender] >= depositArray[_deposit_id].deposit );
    
    uint256 _deposit = depositArray[_deposit_id].deposit;
   
Apr 19, 2018 09:07:50 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.21;

library SafeMath {

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

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

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

  /**
  * @dev Adds two numbers, throws on overflow.
  */
  function add(uint25
Apr 19, 2018 08:00:51 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

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

  uint value;
Apr 19, 2018 05:41:49 UTC
pragma solidity ^0.4.18;
contract SimpleTest {
  uint8[4] constant tiers = [0, 2 * 1 ether, 20 * 1 ether, 200 * 1 ether, 2000 * 1 ether];
Apr 19, 2018 04:42: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 * 2;
  }

  uint value;

function addText(string _text) public {
    text = _text;
  }

  function getText() public constant returns (string) {
    return text;
  }

  function changeText(string _text) public {
    text = _text;
  }
  string text;
Apr 19, 2018 01:16:48 UTC
pragma solidity ^0.4.19;

/*
TODO:
- нужно обновлять fundsWallet, когда мы обновляем owner в контракте Ownable
- NonPayloadAttackable проверить, на какие функции должна назначаться эта проверка
- добавить удаление реферрала из списка соответствий аффилиатам
- удалить лишние переменные
NOTE:
- реферральная программа работает на стороне веба. приглашенные инвесторы добавляются админом вручную
- сроки сейла не в нормальном времени, а в блоках потому, что так безопасней
- перед продажей не обязательно выпускать токен. можно его выпустить в начале сейла.
- удаление адреса из массива. это дорого? може
Apr 18, 2018 20:15:40 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.17;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

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

  uint value;
Apr 18, 2018 17:21:03 UTC
// Contract address: 0xf27e34c2b0acc3edd0559a9c3c21a884176a32c2
// Contract name: COVERCOINToken
// Etherscan link: https://etherscan.io/address/0xf27e34c2b0acc3edd0559a9c3c21a884176a32c2#code
pragma solidity ^0.4.19;

/**
 * @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
Apr 18, 2018 14:28:16 UTC
pragma solidity ^0.4.11;

// Интерфейс токена
interface ChangableToken {
    function stop();
    function start();
    function changebuyPrice(uint buyPrice);
    function balanceOf(address user) returns (uint256);
}

// Контракт ДАО
contract DAOContract {

    // Переменная для хранения токена
    ChangableToken public token;

    // Минимальное число голосов
    uint8 public minVotes = 1;

    // Переменная для предложенного названия
    uint public proposalbuyPrice;

    // Переменная для хранения состояния голосования
    bool public voteActive = false;

    // Стукрутра для голосов
    struct Votes {
        int current;
        uint numberOfVotes;
    }

    // Переменная для структуры голосов
    Votes public election;

    // Функция инициализации ( принимает адрес ток
Apr 18, 2018 08:51:06 UTC
// Указываем версию для компилятора
pragma solidity ^0.4.11;

// Контракт для установки прав
contract OwnableWithDAO{

    // Переменная для хранения владельца контракта
    address public owner;

    // Переменная для хранения адреса DAO
    address public daoContract;

    // Конструктор, который при создании инициализирует переменную с владельцем
    function OwnableWithDAO() {
        owner = msg.sender;
    }

    // Модификатор для защиты от вызовов не создалетя контракта
    modifier onlyOwner(){
        require(msg.sender == owner);
        _;
    }


    // Модификатор для защиты от вызовов не со стороны DAO
    modifier onlyDAO(){
        require(msg.sender == daoContract);
        _;
    }

    // Функция для замены
Apr 18, 2018 07:53:37 UTC
// Указываем версию для компилятора
pragma solidity ^0.4.11;

// Объявляем интерфейс
interface MyFirstERC20ICO {
    function transfer(address _receiver, uint256 _amount);
    function getbuyPrice() returns (uint);
}

// Объявляем контракт
contract MyFirstSafeICO {

    // Объявялем переменную для токена
    MyFirstERC20ICO public token;


    // Функция инициализации
    function MyFirstSafeICO(MyFirstERC20ICO _token){
        // Присваиваем токен
        token = _token;
    }

    // Функция для прямой отправки эфиров на контракт
    function () payable {
        _buy(msg.sender, msg.value);
    }

    // Вызываемая функция для отправки эфиров на контракт, возвращающая количество купленных токенов
    function buy() payable returns (uint){
        // Получ
Apr 18, 2018 07:48:11 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.22;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

  function sayHelllo() public view returns (string){
    return "hello";
  }

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

  uint value;
Apr 18, 2018 07:38:40 UTC
// Указываем версию для компилятора
pragma solidity ^0.4.11;

// Контракт для установки прав
contract OwnableWithDAO{

    // Переменная для хранения владельца контракта
    address public owner;

    // Переменная для хранения адреса DAO
    address public daoContract;

    // Конструктор, который при создании инициализирует переменную с владельцем
    function OwnableWithDAO() {
        owner = msg.sender;
    }

    // Модификатор для защиты от вызовов не создалетя контракта
    modifier onlyOwner(){
        require(msg.sender == owner);
        _;
    }


    // Модификатор для защиты от вызовов не со стороны DAO
    modifier onlyDAO(){
        require(msg.sender == daoContract);
        _;
    }

    // Функция для замены
Apr 18, 2018 07:35:47 UTC
// Указываем версию для компилятора
pragma solidity ^0.4.11;

// Контракт для установки прав
contract OwnableWithDAO{

    // Переменная для хранения владельца контракта
    address public owner;

    // Переменная для хранения адреса DAO
    address public daoContract;

    // Конструктор, который при создании инициализирует переменную с владельцем
    function OwnableWithDAO() {
        owner = msg.sender;
    }

    // Модификатор для защиты от вызовов не создалетя контракта
    modifier onlyOwner(){
        require(msg.sender == owner);
        _;
    }


    // Модификатор для защиты от вызовов не со стороны DAO
    modifier onlyDAO(){
        require(msg.sender == daoContract);
        _;
    }

    // Функция для замены
Apr 18, 2018 07:23:04 UTC
// Contract address: 0xd899b525844aceaf5908c044729d40298fdb89ff
// Contract name: ELOT
// Etherscan link: https://etherscan.io/address/0xd899b525844aceaf5908c044729d40298fdb89ff#code
pragma solidity ^0.4.18;

library SafeMath {

  function add(uint a, uint b)
    internal
    pure
    returns (uint c)
  {
    c = a + b;
    require(c >= a);
  }

  function sub(uint a, uint b)
    internal
    pure
    returns (uint c)
  {
    require(b <= a);
    c = a - b;
  }

  function mul(uint a, uint b)
    internal
    pure
    returns (uint c)
  {
    c = a * b;
    require(a == 0 || c / a == b);
  }

  function div(uint a, uint b)
    internal
    pure
    returns (uint c)
  {
    require(b > 0);
    c = a / b;
  }

}


contract ERC20Interface {

  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);
  function 
Apr 18, 2018 05:20:15 UTC
pragma solidity ^0.4.21;

library SafeMath {

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

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

contract DepositTransaction {
    using SafeMath for uint256;
    
    mapping (address => Transaction[]) public transactions;
    mapping (address => uint256) private balances_;
    enum State { Deposited, Returned }
    
    struct Transaction {
        uint16 deposit_id;
        uint256 amount;
        uint64 time;
        State state;
    }
    
    event Deposited(address who, uint16 deposit_id, uint256 amount);
    event Returned(address who, uint16 deposit_id, uint256 amount);
    
    function() public payable {
        require(msg.sender != address(0));
        require(msg.value > 0);
        
        balances_[msg.sender] = balances_[msg.sender].add(msg.value);
        
        Transaction[] storage tran = transact
Apr 18, 2018 04:16:48 UTC
// Contract address: 0xbf7323ca37ce99fcd03af08f0c5ea203ddda3740
// Contract name: MyAdvancedToken
// Etherscan link: https://etherscan.io/address/0xbf7323ca37ce99fcd03af08f0c5ea203ddda3740#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 = 8;
    // 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;
    map
Apr 18, 2018 02:48:13 UTC
// Contract address: 0xce3ec766d9336907862f3cdeb49129c6f6df4702
// Contract name: WilliamCoin
// Etherscan link: https://etherscan.io/address/0xce3ec766d9336907862f3cdeb49129c6f6df4702#code
pragma solidity ^0.4.18;

// ----------------------------------------------------------------------------
// 'ISB' token contract
//
// Deployed to : 0x116312c3471C2e7C34C52782D0399eBE601f3F30
// Symbol      : WILLY
// Name        : William 好朋友 Foundation Coin
// Total supply: 1000000000000000000
// Decimals    : 10
//
// Enjoy.
//
// (c) by Moritz Neto with BokkyPooBah / Bok Consulting Pty Ltd Au 2017. The MIT Licence.
// ----------------------------------------------------------------------------


// ----------------------------------------------------------------------------
// Safe maths
// ----------------------------------------------------------------------------
contract SafeMath {
    function safeAdd(uint a, uint b) public pure returns (uint c) {
        c = a + b;
        require(c 
Apr 18, 2018 00:56:13 UTC
pragma solidity ^0.4.11;
// Thanks to OpenZeppeline & TokenMarket for the awesome Libraries.
contract SafeMathLib {
  function safeMul(uint a, uint b) returns (uint) {
    uint c = a * b;
    assert(a == 0 || c / a == b);
    return c;
  }

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

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

contract Ownable {
  address public owner;
  address public newOwner;
  event OwnershipTransferred(address indexed _from, address indexed _to);
  function Ownable() {
    owner = msg.sender;
  }
  modifier onlyOwner {
    require(msg.sender == owner);
    _;
  }
  function transferOwnership(address _newOwner) onlyOwner {
    newOwner = _newOwner;
  }

  function acceptOwnership() {
    require(msg.sender == newOwner);
    OwnershipTransferred(owner, newOwner);
    owner = newOwner;
  }
  
}

contract ERC20Basic {
  uint public totalSupply;
  function balanceOf(address wh
Apr 17, 2018 21:18:14 UTC
// Contract address: 0xca6e1c4bce9f720e15c72d81d280734086fd7bd4
// Contract name: ArinToken
// Etherscan link: https://etherscan.io/address/0xca6e1c4bce9f720e15c72d81d280734086fd7bd4#code
pragma solidity ^0.4.18;
   
    
   library SafeMath {
       function add(uint a, uint b) internal pure returns (uint c) {
           c = a + b;
           require(c >= a);
       }
       function sub(uint a, uint b) internal pure returns (uint c) {
           require(b <= a);
           c = a - b;
       }
       function mul(uint a, uint b) internal pure returns (uint c) {
           c = a * b;
           require(a == 0 || c / a == b);
       }
       function div(uint a, uint b) internal pure returns (uint c) {
           require(b > 0);
           c = a / b;
       }
   }      
 
   contract ERC20Interface {
       function totalSupply() public constant returns (uint);
       function balanceOf(address tokenOwner) public constant returns (uint balance);
       function allowance(address tokenO
Apr 17, 2018 18:36:17 UTC
pragma solidity ^0.4.21;

import "../../node_modules/zeppelin-solidity/contracts/token/ERC20/ERC20.sol";
import "../../node_modules/zeppelin-solidity/contracts/ownership/Ownable.sol";
import "../webshop/Webshop.sol";

contract Escrow is Ownable {
    enum PaymentStatus { Pending, Completed, Refunded }

    event PaymentCreation(uint indexed orderId, address indexed customer, uint value);
    event PaymentCompletion(uint indexed orderId, address indexed customer, uint value, PaymentStatus status);

    struct Payment {
        address customer;
        uint value;
        PaymentStatus status;
        bool refundApproved;
    }

    mapping (uint => Payment) public payments;
    ERC20 public currency;
    address public collectionAddress;
    Webshop public webshop;

    function Escrow(ERC20 _currency, address _collectionAddress) public {
        currency = _currency;
        collectionAddress = _collectionAddress;
        webshop = Webshop(msg.sender);
    }

    function createPayment(uint _orderId, address
Apr 17, 2018 14:52:02 UTC
// Указываем версию для компилятора
pragma solidity ^0.4.11;

// Инициализация контракта
contract SimpleDAO {
    
    // Объявляем переменную в которой будет название токена
    string public name;
    // Объявляем переменную в которой будет символ токена
    string public symbol;
    // Объявляем переменную в которой будет число нулей токена
    uint8 public decimals;

    // Объявляем переменную в которой будет храниться общее число токенов
    uint256 public totalSupply;

    // Объявляем маппинг для хранения балансов пользователей
    mapping (address => uint256) public balanceOf;
    // Объявляем маппинг для хранения одобренных транзакций
    mapping (address => mappi
Apr 17, 2018 10:31:19 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {

    // Создать список данных
    mapping (uint => string) listOfData;

// Создать функцию добавления данных в список
  function set(uint _id, string _value) public {
    listOfData[_id] = _value;
  }

// Создать функцию чтения данных из списка
  function get(uint _id) public constant returns (string) {
    return listOfData[_id];
  }
// Создать функцию удаления данных из списка
  function remove(uint _id) public {
    //listOfData[_id] = "";
    delete listOfData[_id];
  }

  uint value;
}



contract A {
    uint[] public amounts; // [1, 2, 3]
    function init(uint[] _amounts) {
        amounts = _amounts;
    }
}

contract Factory {
    struct AData {
        uint[] amounts;
    }
    mapping (address => AData) listOfData;

    function set(uint[] 
Apr 17, 2018 09:40:40 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract CrowdFunding {
    struct Funder {
        address addr;
        uint amount;
    }
    struct Campaign {
        address beneficiary;
        uint fundingGoal;
        uint numFunders;
        uint amount;
        mapping (uint => Funder) funders;
    }

    uint numCampaigns;
    mapping (uint => Campaign) campaigns;

    function newCampaign(address beneficiary, uint goal) public returns (uint campaignID) {
        campaignID = numCampaigns++; // campaignID is return variable
        campaigns[campaignID] = Campaign(beneficiary, goal, 0, 0);
    }

    function contribute(uint campaignID) public payable {
        Campaign storage c = campaigns[campaignID];
        c.funders[c.numFunders++] = Funder({addr: msg.sender, amount: msg.value});
        c.amount += msg.value;
    }

    function checkGoalReached(uint campaignID) public returns (bool reached) {
        Campaign storage c = campa
Apr 17, 2018 09:09:02 UTC
// Contract address: 0x8e1537a4f9b55046c3998c42c821780eceed87ac
// Contract name: ADZbuzzCommunityToken
// Etherscan link: https://etherscan.io/address/0x8e1537a4f9b55046c3998c42c821780eceed87ac#code
pragma solidity ^0.4.18;
    
    // ----------------------------------------------------------------------------
    // 'ACT221283' token contract
    //
    // Deployed to : 0x3f70c0B02879c36162C2C902ECfe9Ac0a8a8a187
    // Symbol      : ACT221283
    // Name        : ADZbuzz Cupofjo.com Community Token
    // Total supply: 2000000
    // Decimals    : 8
    //
    // Enjoy.
    //
    // (c) by Moritz Neto with BokkyPooBah / Bok Consulting Pty Ltd Au 2017. The MIT Licence.
    // (c) by Darwin Jayme with ADZbuzz Ltd. UK (adzbuzz.com) 2018. 
    // ----------------------------------------------------------------------------
    
    
    // ----------------------------------------------------------------------------
    // Safe maths
    // ---------------------------------------------------
Apr 17, 2018 08:48:15 UTC
pragma solidity ^0.4.18;

contract A {
    uint public a = 0;
    
    function f() internal {
        a = a * 10 + 1;
        
        g();
    }
    
    function g() internal {
        a = a * 10 + 2;
    }
}

contract B is A {
    function f() internal {
        a = a * 10 + 3;
        
        super.f();
    }
    
    function g() internal {
        a = a * 10 + 4;
        
        super.g();
    }
}

contract C is B {
    function fp() public {
        super.f(); // a = 3142
    }


    function fpB() public {
        B.f(); // a = 3142
    }

    function fpA() public {
        A.f(); // a = 142
    }
    
    function reset() public {
        a = 0;
    }
Apr 17, 2018 08:35:16 UTC
pragma solidity ^0.4.18;

contract A {
    uint public a = 0;
    
    function f() public {
        a = a * 10 + 1;
    }
}

contract B is A {
    function f() public {
        a = a * 10 + 2;
        
        super.f();
    }
}

contract C is A {
    function f() public {
        a = a * 10 + 3;
        
        super.f();
    }
}

contract D is B, C {}

// call D.f(), and a becomes 32
Apr 17, 2018 08:34:19 UTC
pragma solidity ^0.4.18;

contract A {
    uint public a = 0;
    
    function f() internal {
        a = a * 10 + 1;
        
        g();
    }
    
    function g() internal {
        a = a * 10 + 2;
    }
}

contract B is A {
    function f() internal {
        a = a * 10 + 3;
        
        super.f();
    }
    
    function g() internal {
        a = a * 10 + 4;
        
        super.g();
    }
}

contract C is B {
    function fp() public {
        super.f(); // a = 3142
    }

    function fpB() public {
        B.f(); // a = 3142
    }

    function fpA() public {
        A.f(); // a = 142
    }
    
    function reset() public {
        a = 0;
    }
Apr 17, 2018 08:29:09 UTC
pragma solidity ^0.4.18;

contract A {
    uint public a = 0;
    
    function f() internal {
        a = a * 10 + 1;
        
        g();
    }
    
    function g() internal {
        a = a * 10 + 2;
    }
}

contract B is A {
    function f() internal {
        a = a * 10 + 3;
        
        super.f();
    }
    
    function g() internal {
        a = a * 10 + 4;
        
        super.g();
    }
}

contract C is B {
    function fp() public {
        super.f();
    }

    function fpA() public {
        A.f();
    }
    
    function fpB() public {
        B.f();
    }

    function reset() public {
        a = 0;
    }
Apr 17, 2018 08:12:24 UTC
pragma solidity ^0.4.18;

contract A {
    function f() internal {
        g();
    }
    
    function g() internal {
    }
}

contract B is A {
    function f() internal {
        super.f();
    }
    
    function g() internal {
        super.g();
    }
}

contract C is B {
    function fp() public {
        super.f();
    }
Apr 17, 2018 08:11:47 UTC
// Contract address: 0x491c9a23db85623eed455a8efdd6aba9b911c5df
// Contract name: HeroNodeToken
// Etherscan link: https://etherscan.io/address/0x491c9a23db85623eed455a8efdd6aba9b911c5df#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;
  }
}


contract ERC20 {

  function totalSupply() public view returns (uint256);
  function allowance(address owner, address spender) public view returns (uint256);
  function transferFrom(address from, address to, uint256 value) public returns (bool);
  function approve(address spender, uint256 value) public returns (bool);

  function bal
Apr 17, 2018 07:00:18 UTC
pragma solidity^0.4.21;

contract ModifierTests {
    
    event PrintParam(uint8 param);
    uint8 public param;
    
    function ModifierTests() public {
        param = 0;
    }
    
    function functionA() public modifierA returns (address) {
        param = 0;
        return msg.sender;
    }
    
    function functionB() public modifierB {
        emit PrintParam(param);
        param++;
        emit PrintParam(param);
    }
    
    modifier modifierA() {
        _;
        require(msg.sender == address(0x0));
    }
    
    modifier modifierB() {
        _;
        require(param <= 1);
        _;
        require(param <= 1);
    }
    
Apr 17, 2018 02:51:52 UTC
// Contract address: 0xbad06500aff375ff2b7f1a6e92d1be08ab44ff6d
// Contract name: Batiktoken
// Etherscan link: https://etherscan.io/address/0xbad06500aff375ff2b7f1a6e92d1be08ab44ff6d#code
contract ERC20Basic {
  uint256 public totalSupply;
  function balanceOf(address who) public view returns (uint256);
  function transfer(address to, uint256 value) public returns (bool);
  event Transfer(address indexed from, address indexed to, uint256 value);
}

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 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);
 
Apr 16, 2018 19:48:18 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract hometask{

    mapping(address => uint8) User;
    
    
    function addValue(address wallet, uint8 value) {
      
       User[wallet] = value;
    }
    
    
    function getValue(address wallet) constant returns (uint8) {
        return User[wallet];
    }
        function deleteValue(address wallet) constant returns (uint8) {
          //не могу понять,как удалить само значение, а не кошелёк
          delete wallet;
        return User[wallet];
    }
Apr 16, 2018 15:54:56 UTC
if (id &lt; array.length) {
// do something...
} else {
// do other things
Apr 16, 2018 11:42:19 UTC
pragma solidity ^0.4.19;

import './SafeMath.sol';
import './DogRacingToken.sol';

/**
 * DogRacing Crowdsale
 */
contract DogRacingCrowdsale {
  using SafeMath for uint256;

  DogRacingToken public token;		// Token contract address

  uint256 public stage1_start;		// Crowdsale timing
  uint256 public stage2_start;
  uint256 public stage3_start;
  uint256 public stage4_start;
  uint256 public crowdsale_end;

  uint256 public stage1_price;		// Prices in token millis / ETH
  uint256 public stage2_price;		
  uint256 public stage3_price;		
  uint256 public stage4_price;

  uint256 public hard_cap_wei;		// Crowdsale hard cap in wei

  address public owner;   			// Owner address

  uint256 public wei_raised;		// Total Wei raised by crowdsale

  event TokenPurchase(address buyer, uint256 weiAmount, uint256 tokensAmount);

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

  modifier withinCrowdsaleTime {
	require(now >= stage1_start && now < crowdsale_end);
	_;
  }

  modifier afterCrowdsale {
	requ
Apr 16, 2018 09:58:28 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract ValueContract{
   string word;
   address owner;
   // to avoid double code we add this modifier
   modifier onlyOwner(){
     require(msg.sender==owner);
     //must have _;!!
     _;
   }
  //constractor
   function ValueContract(string _word) public{
     word=_word;
     owner=msg.sender;
   }


//seter
   function setWord(string _word) public payable{
     require(msg.value> 1 ether);
     word=_word;
   }
//geter
   function getWord()  public view  returns(string ){
     return word;
   }
// seter for the owner so it wont cost him gas
   function setWordForFree(string _word) onlyOwner public{
    word=_word;
   }
   //transfer the ownership only by the owner
   function transferOwnership(address _owner) onlyOwner public{
     owner=_owner;
   }
     //fallback fucntion
   //fucntion () payable{

   //}
Apr 16, 2018 06:16:06 UTC
// Contract address: 0x57ab031f30599bac9afc532f142c1643a3178874
// Contract name: _0xLitecoinToken
// Etherscan link: https://etherscan.io/address/0x57ab031f30599bac9afc532f142c1643a3178874#code
pragma solidity ^0.4.18;


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

// '0xLitecoin Token' contract

// Mineable ERC20 Token using Proof Of Work

//

// Symbol      : 0xLTC

// Name        : 0xLitecoin Token

// Total supply: 84,000,000.00

// Decimals    : 8

//


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



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

// 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) {

        requi
Apr 16, 2018 06:12:13 UTC
// Contract address: 0x170836bdfbbe668480c311f45e416dd9bde303f4
// Contract name: TwoExRush
// Etherscan link: https://etherscan.io/address/0x170836bdfbbe668480c311f45e416dd9bde303f4#code
pragma solidity ^0.4.18;

/*
TWO EX RUSH!
Receive 2x your deposit only after the contract reaches 10 ETH.
The first to withdraw after the 20 ETH is hit wins, the others are stuck holding the bag.

Anti Whale: If you withdraw() and there is not enough ether in the contract to 2x your deposit,
            then the transaction fails. This prevents whales and encourages smaller deposits.
            i.e: Deposit 1ETH, withdraw() with 1.8 in the contract and it will fail.
*/

contract TwoExRush {

	string constant public name = "TwoExRush";
	address owner;
	address sender;
	uint256 withdrawAmount;
	uint256 contractATH;
	uint256 contractBalance;

	mapping(address => uint256) internal balance;

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

    // Require goal to be met before allowi
Apr 16, 2018 02:40:17 UTC
// Contract address: 0x7a5ad48978ea7476c4baa65bfb0e1f566bb21855
// Contract name: TokenLSCKcoin
// Etherscan link: https://etherscan.io/address/0x7a5ad48978ea7476c4baa65bfb0e1f566bb21855#code
pragma solidity ^0.4.21;

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

contract TokenLSCKcoin {
    // Public variables of the token
    string public name="LSCKcoin";
    string public symbol="LSCK";
    uint8 public decimals = 8;
    // 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(a
Apr 16, 2018 02:40:17 UTC
// Contract address: 0x02439eb051fc9ce20a4e0192cd436cfdc44db52a
// Contract name: MANHATTANPROXYLEXINGTONAVE
// Etherscan link: https://etherscan.io/address/0x02439eb051fc9ce20a4e0192cd436cfdc44db52a#code
pragma solidity ^0.4.4;

// ----------------------------------------------------------------------------------------------
// MANHATTAN:PROXY BY KEVIN ABOSCH ©2018
// LEXINGTON AVENUE (10,000 ERC-20 TOKENS)
// VERIFY SMART CONTRACT ADDRESS WITH LIST AT HTTP://MANHATTANPROXY.COM
// ----------------------------------------------------------------------------------------------


contract Token {

    
    function totalSupply() constant returns (uint256 supply) {}

    
    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)
Apr 16, 2018 02:40:15 UTC
// Contract address: 0xf310d06a54eda5d5ae204b0aa9b5e207972d80b9
// Contract name: MicoinToken
// Etherscan link: https://etherscan.io/address/0xf310d06a54eda5d5ae204b0aa9b5e207972d80b9#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;
    mapping 
Apr 16, 2018 02:40:15 UTC
// Contract address: 0x9ed8d6cf06342d3498d96cf72daadd7994e5367d
// Contract name: Hypes
// Etherscan link: https://etherscan.io/address/0x9ed8d6cf06342d3498d96cf72daadd7994e5367d#code
pragma solidity ^0.4.18;

contract Hypes {
  event NewOne(address owner, uint256 cost, uint256 new_price);

  struct Hype {
    address owner;
    uint256 cost;
  }

  mapping (uint256 => Hype) public hypes;
  mapping (address => string) public msgs;

  address public ceoAddress;
  uint256 public seatPrice = 2500000000000000;

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

  function Hypes() public {
    ceoAddress = msg.sender;
    hypes[1] = Hype(msg.sender, 0);
    hypes[2] = Hype(msg.sender, 0);
    hypes[3] = Hype(msg.sender, 0);
    hypes[4] = Hype(msg.sender, 0);
    hypes[5] = Hype(msg.sender, 0);
    hypes[6] = Hype(msg.sender, 0);
    hypes[7] = Hype(msg.sender, 0);
    hypes[8] = Hype(msg.sender, 0);
    hypes[9] = Hype(msg.sender, 0);
    msgs[msg.sender] = "Claim this sp
Apr 16, 2018 01:12:14 UTC
// Contract address: 0x2F9233B57baBCF15bAa3Ce736723FdcCd9617abE
// Contract name: CrowdsaleTokenExt
// Etherscan link: https://etherscan.io/address/0x2F9233B57baBCF15bAa3Ce736723FdcCd9617abE#code
// Created using Token Wizard https://github.com/poanetwork/token-wizard by POA Network 
pragma solidity ^0.4.11;


/**
 * @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 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 previo
Apr 16, 2018 00:56:15 UTC
// Contract address: 0x5fdbf531dcda48c6f4b25d8e7a44db2edb98b314
// Contract name: CBCK
// Etherscan link: https://etherscan.io/address/0x5fdbf531dcda48c6f4b25d8e7a44db2edb98b314#code
pragma solidity ^0.4.19;

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

contract CBCK {
    // 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 from, uint256 v
Apr 15, 2018 20:56:17 UTC
// Contract address: 0xc94aeb51b34ebe0a8be941009b65883fd97ecff0
// Contract name: MANHATTANPROXYBRDWY
// Etherscan link: https://etherscan.io/address/0xc94aeb51b34ebe0a8be941009b65883fd97ecff0#code
pragma solidity ^0.4.4;

// ----------------------------------------------------------------------------------------------
// MANHATTAN:PROXY BY KEVIN ABOSCH ©2018
// BROADWAY (10,000 ERC-20 TOKENS)
// VERIFY SMART CONTRACT ADDRESS WITH LIST AT HTTP://MANHATTANPROXY.COM
// ----------------------------------------------------------------------------------------------


contract Token {

    
    function totalSupply() constant returns (uint256 supply) {}

    
    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 
Apr 15, 2018 19:08:16 UTC
// Contract address: 0xdb059e944ceb7062f62fc619f168036f3bb998d0
// Contract name: HumanStandardToken
// Etherscan link: https://etherscan.io/address/0xdb059e944ceb7062f62fc619f168036f3bb998d0#code
pragma solidity ^0.4.8;
contract Token{
    // token总量,默认会为public变量生成一个getter函数接口,名称为totalSupply().
    uint256 public totalSupply;

    /// 获取账户_owner拥有token的数量 
    function balanceOf(address _owner) constant returns (uint256 balance);

    //从消息发送者账户中往_to账户转数量为_value的token
    function transfer(address _to, uint256 _value) returns (bool success);

    //从账户_from中往账户_to转数量为_value的token,与approve方法配合使用
    function transferFrom(address _from, address _to, uint256 _value) returns   
    (bool success);

    //消息发送账户设置账户_spender能从发送账户中转出数量为_value的token
    function approve(address _spender, uint256 _value) returns (bool succe
Apr 15, 2018 17:44:14 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract ValueContract {

  string word;
  address owner;
  
  funtion valueContract(string _word) public {
    word = _word;
    owner = msg.sender;
  }

//The owner and only him can give the ownership on the contract!
  function transferOwnership(address _newOwner) public {
    require(msg.sender == owner);
    owner = _newOwner;
  }

  function setWordFree(string _word) public {
    requires(msg.sender == owner);
    word = _word;
  }

  function setWord(string _word) public payable {
    require(msg.value == 1 ether);
    word = _word;
  }

  function getWord() public view returns (string) {
    return word;
  }

Apr 15, 2018 17:21:42 UTC
pragma solidity 0.4.18;


contract StringBytesPlayground {

  // convert a string less than 32 characters long to bytes32
  function toBytes32(string _string, uint256 _memoryOffset)
    // pure means we are not accessing state nor changing state
    pure
    public
    returns (bytes32)
  {
    // make sure that the string isn't too long for this function
    // will work but will cut off the any characters past the 32nd character
    require(bytes(_string).length <= 32);
    bytes32 _stringBytes;
    // simplest way to convert 32 character long string
    assembly {
      // load the memory pointer of string with an offset of 32
      // 32 passes over non-core data parts of string such as length of text
      _stringBytes := mload(add(_string, _memoryOffset))
    }

    return _stringBytes;
  }

  // play around with the different data conversions that are happening
  // by uncommenting/commenting different returns
  function testBytesToChar(bytes32 _data, uint256 _offset)
    pure
    public
    returns (b
Apr 15, 2018 17:05:30 UTC
pragma solidity ^0.4.21;


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


/**
 * @title SimpleToken
 * @dev Very simple ERC20 Token example, where all tokens are pre-assigned to the creator.
 * Note they can later distribute these tokens as they wish using `transfer` and other
 * `StandardToken` functions.
 */
contract SimpleToken is StandardToken {

  string public constant name = "SimpleToken"; // solium-disable-line uppercase
  string public constant symbol = "SIM"; // solium-disable-line uppercase
  uint8 public constant decimals = 18; // solium-disable-line uppercase

  uint256 public constant INITIAL_SUPPLY = 10000 * (10 ** uint256(decimals));

  /**
   * @dev Constructor that gives msg.sender all of existing tokens.
   */
  function SimpleToken() public {
    totalSupply_ = INITIAL_SUPPLY;
    balances[msg.sender] = INITIAL_SUPPLY;
    emit Transfer(0x0, msg.sender, INITIAL_SUPPLY);
  }

Apr 15, 2018 17:03:28 UTC
pragma solidity 0.4.18;


contract StringBytesPlayground {

  // convert a string less than 32 characters long to bytes32
  function toBytes32(string _string, uint256 _memoryOffset)
    // pure means we are not accessing state nor changing state
    pure
    public
    returns (bytes32)
  {
    // make sure that the string isn't too long for this function
    // will work but will cut off the any characters past the 32nd character
    require(bytes(_string).length <= 32);
    bytes32 _stringBytes;

    // simplest way to convert 32 character long string
    assembly {
      // load the memory pointer of string with an offset of 32
      // 32 passes over non-core data parts of string such as length of text
      _stringBytes := mload(add(_string, _memoryOffset))
    }

    return _stringBytes;
  }

  // take bytes32 and return a string
  function toShortString(bytes32 _data)
    pure
    public
    returns (string)
  {
    // create new bytes with a length of 32
    // needs to be bytes type rather than bytes
Apr 15, 2018 16:55:46 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

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

  uint value;
Apr 15, 2018 16:21:56 UTC
// Contract address: 0x0bf0872390a94c15aaa2865a2f9d8dec90b0af6c
// Contract name: Eurovision
// Etherscan link: https://etherscan.io/address/0x0bf0872390a94c15aaa2865a2f9d8dec90b0af6c#code
pragma solidity ^0.4.19;

// <ORACLIZE_API>
/*
Copyright (c) 2015-2016 Oraclize SRL
Copyright (c) 2016 Oraclize LTD



Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:



The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.



THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIE
Apr 15, 2018 14:40:17 UTC
pragma solidity ^0.4.21;

contract Deposit {
    using SafeMath for uint256;
    uint depositId = 1;
    enum DepositStatus { RETURN, DEPOSIT }
    
    event Logging(uint);
    
    struct DepositTx {
        uint deposit_id;
        uint deposit_time;
        uint deposit_amount;
        address deposit_sender;
        DepositStatus deposit_state;
    }
    mapping (uint => DepositTx) public deposits;
    mapping (address => uint256) balances;
    
    function() public payable {
        require(msg.value > 0);
        balances[msg.sender] = balances[msg.sender].add(msg.value);
        uint currentId = depositId++;
        DepositTx memory depositTx = DepositTx({
            deposit_id: currentId,
            deposit_time: uint(now),
            deposit_amount: msg.value,
            deposit_sender: msg.sender,
            deposit_state: DepositStatus.DEPOSIT
        });
        deposits[currentId] = depositTx;
        emit Logging(currentId);
    }
    
    function myBalance() public view returns(uint256)
Apr 15, 2018 12:28:46 UTC
// Contract address: 0x776b9d69519fc786e103e39f1576df88b66b93ee
// Contract name: CryptonewsIndonesia
// Etherscan link: https://etherscan.io/address/0x776b9d69519fc786e103e39f1576df88b66b93ee#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;
    functi
Apr 15, 2018 11:52:16 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;
}pragma solidity ^0.4.18;

/**
 * @dev SafeMath by openzepplin
 */ 
contract 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); 
        uint256 c = a / b;
        // assert(a == b * 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);
  
Apr 15, 2018 05:14:28 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;

contract ERC721 {
  function ownerOf(uint256) public returns (address);
}

contract ComposableAssetFactory {  
  
  // which asset owns which other assets at which address
  mapping(uint256 => mapping(address => uint256)) children;

  // which address owns which tokens
  mapping(uint256 => address) owners;
  
  modifier onlyOwner(uint256 _tokenID) {
    require(msg.sender == owners[_tokenID]);
    _;
  }
  function registerOwner(uint256 _tokenID, address _contract) public returns (bool) {
    require(owners[_tokenID] == address(0));

    ERC721 erc721 = ERC721(_contract);

    address owner = erc721.ownerOf(_tokenID);
    assert(owner == msg.sender);

    owners[_tokenID] = msg.sender;
    return true;
  }
  // change owner of a token
  function changeOwner(address _newOwner, uint256 _tokenID) onlyOwner(_tokenID) public returns (bool) {
    owners[_tokenID] = _newOwner;
    return true;
  }
  
  /
Apr 15, 2018 04:27:13 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;

contract ERC721 {
  function ownerOf(uint256) public returns (address);
}

contract ComposableAssetFactory {  
  
  // which asset owns which other assets at which address
  mapping(uint256 => mapping(address => uint256)) children;

  // which address owns which tokens
  mapping(uint256 => address) owners;
  
  modifier onlyOwner(uint256 _tokenID) {
    require(msg.sender == owners[_tokenID]);
    _;
  }
  function registerOwner(uint256 _tokenID, address _contract) public returns (bool) {
    require(owners[_tokenID] == address(0));

    ERC721 erc721 = ERC721(_contract);

    address owner = erc721.ownerOf(_tokenID);
    assert(owner == msg.sender);

    owners[_tokenID] = msg.sender;
    return true;
  }
  // change owner of a token
  function changeOwner(address _newOwner, uint256 _tokenID) onlyOwner(_tokenID) public returns (bool) {
    owners[_tokenID] = _newOwner;
    return true;
  }
  
  /
Apr 15, 2018 04:23:34 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;

contract ERC721 {
  function ownerOf(uint256) public returns (address);
}

contract ComposableAssetFactory {  
  
  // which asset owns which other assets at which address
  mapping(uint256 => mapping(address => uint256)) children;

  // which address owns which tokens
  mapping(uint256 => address) owners;
  
  modifier onlyOwner(uint256 _tokenID) {
    require(msg.sender == owners[_tokenID]);
    _;
  }
  function registerOwner(uint256 _tokenID, address _contract) public returns (bool) {
    require(owners[_tokenID] == address(0));

    ERC721 erc721 = ERC721(_contract);

    address owner = erc721.ownerOf(_tokenID);
    assert(owner == msg.sender);

    owners[_tokenID] = msg.sender;
    return true;
  }
  // change owner of a token
  function changeOwner(address _newOwner, uint256 _tokenID) onlyOwner(_tokenID) public returns (bool) {
    owners[_tokenID] = _newOwner;
    return true;
  }
  
  /
Apr 15, 2018 04:12:04 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;

contract ERC721 {
  function ownerOf(uint256) public returns (address);
}

contract ComposableAssetFactory {  
  
  // which asset owns which other assets at which address
  mapping(uint256 => mapping(address => uint256)) children;

  // which address owns which tokens
  mapping(uint256 => address) owners;
  
  modifier onlyOwner(uint256 _tokenID) {
    require(msg.sender == owners[_tokenID]);
    _;
  }
  function registerOwner(uint256 _tokenID, address _contract) public returns (bool) {
    require(owners[_tokenID] == address(0));

    ERC721 erc721 = ERC721(_contract);

    address owner = erc721.ownerOf(_tokenID);
    assert(owner == msg.sender);

    owners[_tokenID] = msg.sender;
    return true;
  }
  // change owner of a token
  function changeOwner(address _newOwner, uint256 _tokenID) onlyOwner public returns (bool) {
    owners[_tokenID] = _newOwner;
    return true;
  }
  
  // add chil
Apr 15, 2018 04:11:28 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;

contract ERC721 {
  function ownerOf(uint256) public returns (address);
}

contract ComposableAssetFactory {  
  
  // which asset owns which other assets at which address
  mapping(uint256 => mapping(address => uint256)) children;

  // which address owns which tokens
  mapping(uint256 => address) owners;
  
  function registerOwner(uint256 _tokenID, address _contract) public returns (bool) {
    require(owners[_tokenID] == address(0));

    ERC721 erc721 = ERC721(_contract);

    address owner = erc721.ownerOf(_tokenID);
    assert(owner == msg.sender);

    owners[_tokenID] = msg.sender;
    return true;
  }
  // change owner of a token
  function changeOwner(address _newOwner, uint256 _tokenID) public returns (bool) {
    require(owners[_tokenID] == msg.sender);
    owners[_tokenID] = _newOwner;
    return true;
  }
  
  // add child to a composable asset
  function addChild(uint256 _tokenID, 
Apr 15, 2018 04:09:44 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;

contract ERC721 {
  function ownerOf(uint256) public returns (address);
}

contract ComposableAssetFactory {  
  
  // which asset owns which other assets at which address
  mapping(uint256 => mapping(address => uint256)) children;

  // which address owns which tokens
  mapping(uint256 => address) owners;
  
  function registerOwner(uint256 _tokenID, address _contract) public {
    require(owners[_tokenID] == address(0));

    ERC721 erc721 = ERC721(_contract);

    address owner = erc721.ownerOf(_tokenID);
    assert(owner == msg.sender);

    owners[_tokenID] = msg.sender;

  }
  // change owner of a token
  function changeOwner(address _newOwner, uint256 _tokenID) public {
    require(owners[_tokenID] == msg.sender);
    owners[_tokenID] = _newOwner;
  }
  
  // add child to a composable asset
  function addChild(uint256 _tokenID, address _childContract, uint256 _indexOrAmount) public {
    re
Apr 15, 2018 04:06:29 UTC
pragma solidity ^0.4.21;

contract PredictTheBlockHashChallenge {
    address guesser;
    bytes32 guess;
    uint256 settlementBlockNumber;

    function PredictTheBlockHashChallenge() public payable {
        require(msg.value == 1 ether);
    }

    function isComplete() public view returns (bool) {
        return address(this).balance == 0;
    }

    function lockInGuess(bytes32 hash) public payable {
        require(guesser == 0);
        require(msg.value == 1 ether);

        guesser = msg.sender;
        guess = hash;
        settlementBlockNumber = block.number + 1;
    }

    function settle() public {
        require(msg.sender == guesser);
        require(block.number > settlementBlockNumber);

        bytes32 answer = block.blockhash(settlementBlockNumber);

        guesser = 0;
        if (guess == answer) {
            msg.sender.transfer(2 ether);
        }
    }
Apr 15, 2018 03:48:34 UTC
pragma solidity ^0.4.21;

contract PredictTheFutureChallenge {
    address guesser;
    uint8 guess;
    uint256 settlementBlockNumber;

    function PredictTheFutureChallenge() public payable {
        require(msg.value == 1 ether);
    }

    function isComplete() public view returns (bool) {
        return address(this).balance == 0;
    }

    function lockInGuess(uint8 n) public payable {
        require(guesser == 0);
        require(msg.value == 1 ether);

        guesser = msg.sender;
        guess = n;
        settlementBlockNumber = block.number + 1;
    }

    function settle() public {
        require(msg.sender == guesser);
        require(block.number > settlementBlockNumber);

        uint8 answer = uint8(keccak256(block.blockhash(block.number - 1), now)) % 10;

        guesser = 0;
        if (guess == answer) {
            msg.sender.transfer(2 ether);
        }
    }
Apr 15, 2018 02:55:33 UTC
pragma solidity ^0.4.21;

contract GuessTheNewNumberChallenge {
    function GuessTheNewNumberChallenge() public payable {
        require(msg.value == 1 ether);
    }

    function isComplete() public view returns (bool) {
        return address(this).balance == 0;
    }

    function guess(uint8 n) public payable {
        require(msg.value == 1 ether);
        uint8 answer = uint8(keccak256(block.blockhash(block.number - 1), now));

        if (n == answer) {
            msg.sender.transfer(2 ether);
        }
    }
}
Apr 15, 2018 00:32:59 UTC
pragma solidity ^0.4.21;

contract GuessTheRandomNumberChallenge {
    uint8 answer;

    function GuessTheRandomNumberChallenge() public payable {
        require(msg.value == 1 ether);
        answer = uint8(keccak256(block.blockhash(block.number - 1), now));
    }

    function isComplete() public view returns (bool) {
        return address(this).balance == 0;
    }

    function guess(uint8 n) public payable {
        require(msg.value == 1 ether);

        if (n == answer) {
            msg.sender.transfer(2 ether);
        }
    }
Apr 14, 2018 22:31:07 UTC
pragma solidity ^0.4.21;

contract GuessTheSecretNumberChallenge {
    bytes32 answerHash = 0xdb81b4d58595fbbbb592d3661a34cdca14d7ab379441400cbfa1b78bc447c365;

    function GuessTheSecretNumberChallenge() public payable {
        require(msg.value == 1 ether);
    }
    
    function isComplete() public view returns (bool) {
        return address(this).balance == 0;
    }

    function guess(uint8 n) public payable {
        require(msg.value == 1 ether);

        if (keccak256(n) == answerHash) {
            msg.sender.transfer(2 ether);
        }
    }
}

contract GuessTheSecretNumberSolver {
    bytes32 answerHash = 0xdb81b4d58595fbbbb592d3661a34cdca14d7ab379441400cbfa1b78bc447c365;
    
    function guess() public view returns(uint8) {
      for (uint8 i = 0; i < 2 ** 8; i++) {
        if (keccak256(i) == answerHash) {
            break;
        }
      }
      return i;
    }

    function keccak256Uint(uint n) public pure returns(bytes32) {
      return keccak256(n);
    }
Apr 14, 2018 22:00:03 UTC
pragma solidity ^0.4.21;

contract GuessTheNumberChallenge {
    uint8 answer = 42;

    function GuessTheNumberChallenge() public payable {
        require(msg.value == 1 ether);
    }

    function isComplete() public view returns (bool) {
        return address(this).balance == 0;
    }

    function guess(uint8 n) public payable {
        require(msg.value == 1 ether);

        if (n == answer) {
            msg.sender.transfer(2 ether);
        }
    }
Apr 14, 2018 21:26:04 UTC
// Contract address: 0x5510f1996e210659e135b05d6bf48d6682af23a7
// Contract name: EthereumPrivate
// Etherscan link: https://etherscan.io/address/0x5510f1996e210659e135b05d6bf48d6682af23a7#code
pragma solidity ^0.4.16;

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

contract EthereumPrivate  {
    // Public variables of the token
    string public name;
    string public symbol;
    uint8 public decimals = 8;
    // 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
Apr 14, 2018 20:08:12 UTC
pragma solidity ^0.4.21;

contract CrowdFunding {

    // 投資家
    struct Investor {
        address addr;   // 投資家のアドレス
        uint amount;    // 投資額
    }

    // 投資家管理用のマップ(だけど、uintをkeyに持つと配列っぽくつかえる)
    // publicのため、getterが自動生成
    // cf.investors(0)[1] で投資額にアクセスできる
    mapping (uint => Investor) public investors;

    address public owner;       // コントラクトのオーナー
    uint public numInvestors;   // 投資家の数(カウンタ)
    uint public deadline;       // 締切(UnixTime)
    string public status;       // キャンペーンのステータス
    bool public ended;          // キェンペーンが終了しているか否か
    uint public goalAmount;     // 投資の目標額
    uint public totalAmount;    // 投資の総額

    // 関数実行アドレスが、コントラクトオーナーがチェック
    modifier onlyOwner() {
       
Apr 14, 2018 19:46:21 UTC
pragma solidity ^0.4.21;

contract CrowdFunding {

    // 投資家
    struct Investor {
        address addr;   // 投資家のアドレス
        uint amount;    // 投資額
    }

    // 投資家管理用のマップ(だけど、uintをkeyに持つと配列っぽくつかえる)
    // publicのため、getterが自動生成
    // cf.investors(0)[1] で投資額にアクセスできる
    mapping (uint => Investor) public investors;

    address public owner;       // コントラクトのオーナー
    uint public numInvestors;   // 投資家の数(カウンタ)
    uint public deadline;       // 締切(UnixTime)
    string public status;       // キャンペーンのステータス
    bool public ended;          // キェンペーンが終了しているか否か
    uint public goalAmount;     // 投資の目標額
    uint public totalAmount;    // 投資の総額

    // 関数実行アドレスが、コントラクトオーナーがチェック
    modifier onlyOwner() {
       
Apr 14, 2018 19:45:25 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;
  }
}

/**
 * @title ERC20Basic
 * @dev Simpler version of ERC20 interface
 * @dev see https://github.com/ethereum/EIPs/issues/179
 */
contract ERC20Basic {
  uint256 public totalSupply;
  function bal
Apr 14, 2018 18:20:42 UTC

/*
Dapp名稱 = V-Box
說明🐳 =
可以製造您的V-Box 或向其他的V-Box付款。V-Box可永遠無限次使用,可以設定兩條文字信息(一條必須付款才可觀看)
及可設定 每次收款金額(以finney計算 1finney = 0.001ETH) 及 V_Fans功能。
           
由於V-Box是用您自己產生的以太錢包製造出來,所以無需擔心 您在本程式內作出的任何交易 都沒有經過任何第三者。
           
每一個地址只能製造出一個V-Box,如果您的以太錢包地址已經製造過V-Box,當您再用同一地址製造V-Box時
           新的內容將會覆蓋舊內容。 但,此一個V-Box的交易記錄將永遠不會被覆蓋。
           
           本程式會記錄您V-Box的總收款次數 及 每個付款的地址 及 每個地址已付的費用 。

           
           每一個向您V-Box付款的以太錢包地址,將會獲得一個名為 V_Fans / V粉 的標記。
           成為 V粉 後 這個以太錢包地址 將永
Apr 14, 2018 16:30:20 UTC

/*
Dapp名稱 = V-Box
說明🐳 =
可以製造您的V-Box 或向其他的V-Box付款。V-Box可永遠無限次使用,可以設定兩條文字信息(一條必須付款才可觀看)
及可設定 每次收款金額(以finney計算 1finney = 0.001ETH) 及 V_Fans功能。
           
由於V-Box是用您自己產生的以太錢包製造出來,所以無需擔心 您在本程式內作出的任何交易 都沒有經過任何第三者。
           
每一個地址只能製造出一個V-Box,如果您的以太錢包地址已經製造過V-Box,當您再用同一地址製造V-Box時
           新的內容將會覆蓋舊內容。 但,此一個V-Box的交易記錄將永遠不會被覆蓋。
           
           本程式會記錄您V-Box的總收款次數 及 每個付款的地址 及 每個地址已付的費用 。

           
           每一個向您V-Box付款的以太錢包地址,將會獲得一個名為 V_Fans / V粉 的標記。
           成為 V粉 後 這個以太錢包地址 將永
Apr 14, 2018 16:30:18 UTC
pragma solidity ^0.4.16;

contract Address {
    
    function Address() public {
        
    }
    
    // fallback関数(匿名・引数・戻り値を持たない)
    function () payable public {}
    
    
    // アドレス(アカウント)が保持するetherを返す
    function getBalance(address _thisAddress) view public returns (uint) {
        
        // address(0) はデプロイされるようとしているコントラクトのアドレス
        if (_thisAddress == address(0)) {
            _thisAddress = this;
        }
        return _thisAddress.balance;
    }
    
    // 相手アドレスにetherを送金
    function transfer(address _to, uint _amount) public {
        _to.transfer(_amount);
    }
    
    // 相手アドレスにetherを送信(失敗時は処理を全てrevertする)
    function send(address _to, uint _amount) public {
        if (!_to.send(_amount)) {
            revert();
        }
    }
    
    // 相手アドレスにetherをgasを指定し送信
Apr 14, 2018 16:16:41 UTC
pragma solidity ^0.4.16;

contract Address {
    
    function Address() public {
        
    }
    
    // fallback関数(匿名・引数・戻り値を持たない)
    function () payable public {}
    
    
    // アドレス(アカウント)が保持するetherを返す
    function getBalance(address _t) view public returns (uint) {
        
        // address(0) はデプロイされるようとしているコントラクトのアドレス
        if (_t == address(0)) {
            _t = this;
        }
        return _t.balance;
    }
    
    // 相手アドレスにetherを送金
    function transfer(address _to, uint _amount) public {
        _to.transfer(_amount);
    }
    
    // 相手アドレスにetherを送信(失敗時は処理を全てrevertする)
    function send(address _to, uint _amount) public {
        if (!_to.send(_amount)) {
            revert();
        }
    }
    
    // 相手アドレスにetherをgasを指定し送信(失敗時は処理を全てrevertす
Apr 14, 2018 16:07:24 UTC
pragma solidity ^0.4.21;

contract HelloEthereum {

    string public msg1;
    string private msg2;
    address public owner;
    uint8 private counter;

    
    // constructor
    function HelloEthereum(string _msg1) public {
        msg1 = _msg1;
        owner = msg.sender;
        counter = 0;
    }
    
    // ownerのみがmsg2をセットできるようにする
    function setMsg2(string _msg2) public {
        if(owner != msg.sender) {
            revert();
        } else {
            msg2 = _msg2;
        }
    }
    
    function getMsg2() view public returns(string) {
        return msg2;
    }
    
    function setCounter() public {
        for(uint8 i = 0; i < 3; i++) {
            counter++;
        }
    }
    
    function getCounter() view public returns(uint8) {
        return counter;
    }
    
Apr 14, 2018 16:04:55 UTC
// Contract address: 0x1771e600e72cca46abeab857f301b6bf5a032ca7
// Contract name: Mainsale
// Etherscan link: https://etherscan.io/address/0x1771e600e72cca46abeab857f301b6bf5a032ca7#code
pragma solidity 0.4.18;

// File: contracts/ownership/Ownable.sol

/**
 * @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 newOw
Apr 14, 2018 13:32:15 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.19;

import "http://github.com/OpenZeppelin/zeppelin-solidity/contracts/math/SafeMath.sol";

contract Deposit {
  using SafeMath for uint256;
  mapping (address => uint256) balances;
  // callback 함수로서 payable 하여 Account가 ETH 를 전송하면 Contract 에 Deposit 하는 함수

  function() public payable {
    // 전송한 ETH(Wei) 양이 0 보다 커야 하는 조건
    require(msg.value > 0);
    // payable 을 통해 받은 ETH(Wei) 를 balances 에 저장 ( 각 account 별로 따로 )
    balances[msg.sender].add(msg.value);
  }

  // Doposit 한 Account 가 자신의 Deposit 양을 리턴하는 view 함수
  function myBalance() public view returns(uint256) {
    return balances[msg.sender];
  }

  // 모든 Account 가 Deposit 한 총 ETH(Wei)의 양을 리턴하는 view 함수
  // this.balance 사용
  function totalDepositAmount() public view returns(uint256) {
    return this.
Apr 14, 2018 05:11:36 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.19;

contract Deposit {
  using SafeMath for uint256;
  mapping (address => uint256) balances;
  // callback 함수로서 payable 하여 Account가 ETH 를 전송하면 Contract 에 Deposit 하는 함수

  function() public payable {
    // 전송한 ETH(Wei) 양이 0 보다 커야 하는 조건
    require(msg.value > 0);
    // payable 을 통해 받은 ETH(Wei) 를 balances 에 저장 ( 각 account 별로 따로 )
    balance[msg.sender].add(msg.value);
  }

  // Doposit 한 Account 가 자신의 Deposit 양을 리턴하는 view 함수
  function myBalance() public view returns(uint256) {
    return balance[msg.sender];
  }

  // 모든 Account 가 Deposit 한 총 ETH(Wei)의 양을 리턴하는 view 함수
  // this.balance 사용
  function totalDepositAmount() public view returns(uint256) {
    return this.balance;
  }

  // 해당 함수를 호출한 Account 의 Deposit ETH(Wei)를 모두 다
Apr 14, 2018 04:58:19 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract Deposit {
  using SafeMath for uint256;
  mapping (address => uint256) balances;

  uint256 public myBalance_;
  // callback 함수로서 payable 하여 Account가 ETH 를 전송하면 Contract 에 Deposit 하는 함수
  function() public payable {
  // 전송한 ETH(Wei) 양이 0 보다 커야 하는 조건
  // payable 을 통해 받은 ETH(Wei) 를 balances 에 저장 ( 각 account 별로 따로 )
    if(msg.value > 0) {
      balances[address] += msg.value;
    }
  }

  // Doposit 한 Account 가 자신의 Deposit 양을 리턴하는 view 함수
  function myBalance() public view returns(uint256) {
    return balances[address];
  }

  // 모든 Account 가 Deposit 한 총 ETH(Wei)의 양을 리턴하는 view 함수
  // this.balance 사용
  function totalDepositAmount() public view returns(uint256) {
    return this.balance;
  }

  // 해당 함수를 호출한 Account 의 Deposit ET
Apr 14, 2018 03:14:06 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract Deposit {
  using SafeMath for uint256;
  mapping (address => uint256) balances;

  uint256 public myBalance_;
  // callback 함수로서 payable 하여 Account가 ETH 를 전송하면 Contract 에 Deposit 하는 함수
  function() public payable {
  // 전송한 ETH(Wei) 양이 0 보다 커야 하는 조건
  // payable 을 통해 받은 ETH(Wei) 를 balances 에 저장 ( 각 account 별로 따로 )
    if(msg.value > 0) {
      balances[address] += msg.value;
    }
  }

  // Doposit 한 Account 가 자신의 Deposit 양을 리턴하는 view 함수
  function myBalance() public view returns(uint256) {
    return balances[address];
  }

  // 모든 Account 가 Deposit 한 총 ETH(Wei)의 양을 리턴하는 view 함수
  // this.balance 사용
  function totalDepositAmount() public view returns(uint256) {
    return this.balance;
  }

  // 해당 함수를 호출한 Account 의 Deposit ET
Apr 14, 2018 03:13:28 UTC

/*早晨
Dapp名稱 = V-Box
說明🐳 =
可以製造您的V-Box 或向其他的V-Box付款。V-Box可永遠無限次使用,可以設定兩條文字信息(一條必須付款才可觀看)
及可設定 每次收款金額(以finney計算 1finney = 0.001ETH) 及 V_Fans功能。
           
由於V-Box是用您自己產生的以太錢包製造出來,所以無需擔心 您在本程式內作出的任何交易 都沒有經過任何第三者。
           
每一個地址只能製造出一個V-Box,如果您的以太錢包地址已經製造過V-Box,當您再用同一地址製造V-Box時
           新的內容將會覆蓋舊內容。 但,此一個V-Box的交易記錄將永遠不會被覆蓋。
           
           本程式會記錄您V-Box的總收款次數 及 每個付款的地址 及 每個地址已付的費用 。

           
           每一個向您V-Box付款的以太錢包地址,將會獲得一個名為 V_Fans / V粉 的標記。
           成為 V粉 後 這個以太錢包地址 
Apr 14, 2018 00:00:21 UTC
pragma solidity ^0.4.19;

import "./Dapp-VBox.sol";//收款箱
import "./前台顯示.sol";//引用其他驗證條件
import "./BigBoss.sol";  //我的權限 
contract AdminPage is SetBigBoss,SimpleData,ValueBox {
    
/*
    //大大佬才可取錢 
  function You_Cant_See_Me_He_He__________Just_Big_Boss_I_Need_Get_Money_GoHome_La_886()external JustBigBoss returns (uint,bool){
      msg.sender.transfer(this.balance);
      return (msg.sender.balance,true);
 }
*/
    //轉換大大佬 
  function You_Cant_See_Me_He_He__________Just_Big_Boss_Change_BigBoss_0_0(address NewBigBossAdd)NeedNot0(NewBigBossAdd) public JustBigBoss returns (address,bool){
      IAmBigBossHaHa = NewBigBossAdd;
      return (NewBigBossAdd,true);
 }




//function SetWho_are_we(string WHOUSME,string IptNewVal) JustBigBoss public { Who_are_we[WHOUSME] = IptNewVal; }


	
   function BigBoss_address_is() constant public returns (address) {return IAmBigBossHaHa;}
 //顯示BigBoss地址
    


/****************
Apr 13, 2018 23:18:25 UTC
pragma solidity ^0.4.19;


contract SetNeed {
    
    //地址不能是0
    modifier NeedNot0(address _InputAllAdd) {require(_InputAllAdd != 0x0);  _;}
    //if (newOwner != address(0)) //再聲明多一次為地址比較好? address(0)
    
    //地址不能是自己
    modifier CanNotIsMe(address _InputAllAdd) {require(_InputAllAdd != msg.sender);  _;}



}
Apr 13, 2018 23:18:03 UTC
pragma solidity ^0.4.19;


contract SimpleData {
    
//顯示本合約地址及ETH存儲量
function Help(
    address You_can_input_anyone_ETH_address_i_will_display_she_balance
    ) 
    public constant returns (
        address This_App_Address_Is,
        uint256 she_balance_is_finney
        ) {
            return (
                this,
                (You_can_input_anyone_ETH_address_i_will_display_she_balance.balance / 1.000 finney)
                ); 
            
        }





//string HI ;
//mapping(string => string) Who_are_we ;
//   function DisWho_are_we(string WHOUSME) constant public returns (string This_is_we) {return Who_are_we[WHOUSME];}
 //是管時會顯示管理員地址
    
    
    


}
Apr 13, 2018 23:17:21 UTC
pragma solidity ^0.4.19;

/*
//http://me.tryblockchain.org/%E6%94%AF%E4%BB%98%E7%9B%B8%E5%85%B3.html
//https://mshk.top/2017/11/go-ethereum-1-7-2-mist-0-9-2-token/
//https://ethfans.org/posts/the-anatomy-of-erc721
//http://www.tryblockchain.org/Solidity-Type-Address-%E5%9C%B0%E5%9D%80.html
//https://github.com/OpenZeppelin/zeppelin-solidity/blob/master/contracts/token/ERC721/ERC721.sol
//http://www.blockcode.org/archives/204
//https://github.com/dapperlabs/cryptokitties-bounty/blob/master/contracts/ERC721Draft.sol
//https://ethereum.org/token
//https://ethereum.org/crowdsale
//http://www.tryblockchain.org/Solidity-Type-Address-%E5%9C%B0%E5%9D%80.html
//http://me.tryblockchain.org/%E6%94%AF%E4%BB%98%E7%9B%B8%E5%85%B3.html
//https://ethfiddle.com/09YbyJRfiI
//https://mshk.top/2017/11/go-ethereum-1-7-2-mist-0-9-2-token/




import "./SupplyIncome.sol";   //貢獻者回報     
import "./SetBigBoss.sol";     //我的權限 
import "./SetNeed.sol";        //其他驗證條件          
import "./SimpleData.sol";  
Apr 13, 2018 23:15:13 UTC
import "./基本規則.sol";//引用其他驗證條件

pragma solidity ^0.4.19;
contract SetBigBoss is SetNeed{ 
    
    address internal IAmBigBossHaHa;

    //大大佬才可執行
    function SetBigBoss() internal { IAmBigBossHaHa = msg.sender; }
    modifier JustBigBoss() {assert(msg.sender == IAmBigBossHaHa);  _;}
    




       uint internal Price_ValueBox = 3 finney;                                                 //使用收款箱的費用 預設= 3 finney 
    
    
    
        
}
Apr 13, 2018 23:12:57 UTC

/*
Dapp名稱 = V-Box
說明🐳 =
可以製造您的V-Box 或向其他的V-Box付款。V-Box可永遠無限次使用,可以設定兩條文字信息(一條必須付款才可觀看)
及可設定 每次收款金額(以finney計算 1finney = 0.001ETH) 及 V_Fans功能。
           
由於V-Box是用您自己產生的以太錢包製造出來,所以無需擔心 您在本程式內作出的任何交易 都沒有經過任何第三者。
           
每一個地址只能製造出一個V-Box,如果您的以太錢包地址已經製造過V-Box,當您再用同一地址製造V-Box時
           新的內容將會覆蓋舊內容。 但,此一個V-Box的交易記錄將永遠不會被覆蓋。
           
           本程式會記錄您V-Box的總收款次數 及 每個付款的地址 及 每個地址已付的費用 。

           
           每一個向您V-Box付款的以太錢包地址,將會獲得一個名為 V_Fans / V粉 的標記。
           成為 V粉 後 這個以太錢包地址 將永
Apr 13, 2018 23:06:49 UTC
pragma solidity ^0.4.18;
contract CallToTheUnknown {
  // Highest bidder becomes the Leader. 
  // Vulnerable to DoS attack by an attacker contract which reverts all transactions to it.

    address currentLeader;
    uint highestBid;

    function() payable {
        require(msg.value > highestBid);
        require(currentLeader.send(highestBid)); // Refund the old leader, if it fails then revert
        currentLeader = msg.sender;
        highestBid = msg.value;
    }
}

contract Pwn {
  // call become leader 
  function becomeLeader(address _address, uint bidAmount) {
    _address.call.value(bidAmount);
  }
    
  // reverts anytime it receives ether, thus cancelling out the change of the leader
  function() payable {
    revert();
  }
Apr 13, 2018 19:08:35 UTC
// Так делать не нужно :)

// Указываем версию для компилятора
pragma solidity ^0.4.11;


// Инициализация контракта
contract MyFirstERC20Coin {

    // Объявляем переменную в которой будет название токена
    string public name;
    // Объявляем переменную в которой будет символ токена
    string public symbol;
    // Объявляем переменную в которой будет число нулей токена
    uint8 public decimals;

    uint public buyPrice1;
    uint public buyPrice2;
    uint public buyPrice3;

    // Объявляем переменную в которой будет храниться общее число токенов
    uint256 public totalSupply;
    
    uint public startTime;

    // Объявляем маппинг для хранения балансов пользователей
    mapping (address => ui
Apr 13, 2018 13:15:03 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.19;

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

  // callback 함수로서 payable 하여 Account가 ETH 를 전송하면 Contract 에 Deposit 하는 함
  function() public payable {
    // 전송한 ETH(Wei) 양이 0 보다 커야 하는 조건
    require(msg.value > 0);
    // payable 을 통해 받은 ETH(Wei) 를 balances 에 저장 ( 각 account 별로 따로 )
    balances[msg.sender] += msg.value;
  }
  // Doposit 한 Account 가 자신의 Deposit 양을 리턴하는 view 함수
  function myBalance() public view returns(uint256) {
    return balances[msg.sender];
  }

  // 모든 Account 가 Deposit 한 총 ETH(Wei)의 양을 리턴하는 view 함수
  // this.balance 사용
  function totalDepositAmount() public view returns(uint256) {
    return this.balance;
  }
  // 해당 함수를 호출한 Account 의 Deposit ETH(Wei)를 모두 다시 
Apr 13, 2018 12:32:36 UTC
// Contract address: 0xe746f3be8c69b05e3ca38760f1eb8c55d24da2c9
// Contract name: AltExtraHolderContract
// Etherscan link: https://etherscan.io/address/0xe746f3be8c69b05e3ca38760f1eb8c55d24da2c9#code
pragma solidity ^0.4.18;

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

/**
 * @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 view returns (uint256);
  function transfer(address to, uint256 value) public returns (bool);
  event Transfer(address indexed from, address indexed to, uint256 value);
}

/**
 * @title ERC20 interface
 * @dev see https://github.com/ethereum/EIPs/issues/20
 */
contract ERC20 is ERC20Basic {
  function allowance(address owner, address spender) public view returns (uint256);
  function transferFrom(address from, address 
Apr 13, 2018 12:24:12 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract hometask{

    mapping(address => uint8) User;
    
    
    function addValue(address wallet, uint8 value) {
      
       User[wallet] = value;
    }
    
    
    function getValue(address wallet) constant returns (uint8) {
        return User[wallet];
    }
        function deleteValue(address wallet) constant returns (uint8) {
          //не могу понять,как удалить само значение, а не кошелёк
          delete wallet;
        return User[wallet];
    }
Apr 13, 2018 10:20:30 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract hometask{

    mapping(uint32 => uint8) User;
    
    
    function addValue(uint32 wallet, uint8 value) {
      
       User[wallet] = value;
    }
    
    
    function getValue(uint32 wallet) constant returns (uint8) {
        return User[wallet];
    }
        function deleteValue(uint32 wallet) constant returns (uint8) {
          //не могу понять,как удалить само значение, а не кошелёк
          delete wallet;
        return User[wallet];
    }
Apr 13, 2018 10:08:39 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract hometask{


    mapping(address => userStruct) private userstructs;
      
    function addValue(uint32 wallet, uint8 value) {
      
       User[wallet] += value;
      
    }
    

    function getValue(uint32 wallet) constant returns (uint8) {
        
        return User[wallet];
    }
    function deleteValue(uint32 wallet) constant returns (uint8) {  
      //не получается разобраться,как удалить сами данные,а не кошелёк
      delete wallet;

        return User[wallet];
    }

Apr 13, 2018 10:05:36 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract hometask{

    mapping(uint32 => uint8) User;
    
    
    function addValue(uint32 wallet, uint8 value) {
      
       User[wallet] = value;
    }
    

    function getValue(uint32 wallet) constant returns (uint8) {
        return User[wallet];
    }
 function deleteValue(uint32 wallet) constant returns (uint8) {

   delete wallet;
        return User[wallet];
    }

Apr 13, 2018 09:09:20 UTC
// Contract address: 0xe0658fd31924785a15fd270a97072d57baa1cda9
// Contract name: ADZbuzzCommunityToken
// Etherscan link: https://etherscan.io/address/0xe0658fd31924785a15fd270a97072d57baa1cda9#code
pragma solidity ^0.4.18;
    
    // ----------------------------------------------------------------------------
    // 'ACT865934' token contract
    //
    // Deployed to : 0x3f70c0B02879c36162C2C902ECfe9Ac0a8a8a187
    // Symbol      : ACT865934
    // Name        : ADZbuzz 500px.com Community Token
    // Total supply: 2000000
    // Decimals    : 8
    //
    // Enjoy.
    //
    // (c) by Moritz Neto with BokkyPooBah / Bok Consulting Pty Ltd Au 2017. The MIT Licence.
    // (c) by Darwin Jayme with ADZbuzz Ltd. UK (adzbuzz.com) 2018. 
    // ----------------------------------------------------------------------------
    
    
    // ----------------------------------------------------------------------------
    // Safe maths
    // -----------------------------------------------------
Apr 13, 2018 08:04:34 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
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(uint25
Apr 13, 2018 07:46:12 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
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(uint25
Apr 13, 2018 07:35:56 UTC
// Contract address: 0xe03070d46c30b30cfc792fa3b586f2b71be89ad1
// Contract name: ReleaseToken
// Etherscan link: https://etherscan.io/address/0xe03070d46c30b30cfc792fa3b586f2b71be89ad1#code
pragma solidity ^0.4.21;

interface itoken {
    function freezeAccount(address _target, bool _freeze) external;
    function freezeAccountPartialy(address _target, uint256 _value) external;
    function transferFrom(address _from, address _to, uint256 _value) external returns (bool);
    function balanceOf(address _owner) external view returns (uint256 balance);
    // function transferOwnership(address newOwner) external;
    function allowance(address _owner, address _spender) external view returns (uint256);
    function frozenAccount(address _account) external view returns (bool);
    function frozenAmount(address _account) external view returns (uint256);
}

library SafeMath {

  /**
  * @dev Multiplies two numbers, throws on overflow.
  */
  function mul(uint256 a, uint256 b) internal pure returns
Apr 13, 2018 02:48:16 UTC
// Contract address: 0x62c5a9b7f293ac6a0b92dbe7c6cd083e2a309109
// Contract name: AwesomeToken
// Etherscan link: https://etherscan.io/address/0x62c5a9b7f293ac6a0b92dbe7c6cd083e2a309109#code
pragma solidity ^0.4.18;

// ----------------------------------------------------------------------------
// 'Awesome' token contract
//
// Deployed to : 0xC7A42e69AdfFA67C452eE8Ef561910770C44Bf4F
// Symbol      : AWS
// Name        : Awesome Token
// Total supply: 100000000
// Decimals    : 18
//
// Enjoy.
//
// (c) by Moritz Neto with BokkyPooBah / Bok Consulting Pty Ltd Au 2017. The MIT Licence.
// ----------------------------------------------------------------------------


// ----------------------------------------------------------------------------
// Safe maths
// ----------------------------------------------------------------------------
contract SafeMath {
    function safeAdd(uint a, uint b) public pure returns (uint c) {
        c = a + b;
        require(c >= a);
    }
    function
Apr 13, 2018 02:48:16 UTC
// Contract address: 0x790284cc4910343fd936277c002791ed620238d9
// Contract name: ProofOfPassiveDividends
// Etherscan link: https://etherscan.io/address/0x790284cc4910343fd936277c002791ed620238d9#code
pragma solidity ^0.4.21;

/*
*
* _______    _______    _______    ______             ___     _______ 
|       |  |       |  |       |  |      |           |   |   |       |
|    _  |  |   _   |  |    _  |  |  _    |          |   |   |   _   |
|   |_| |  |  | |  |  |   |_| |  | | |   |          |   |   |  | |  |
|    ___|  |  |_|  |  |    ___|  | |_|   |   ___    |   |   |  |_|  |
|   |      |       |  |   |      |       |  |   |   |   |   |       |
|___|      |_______|  |___|      |______|   |___|   |___|   |_______|
* 
* 
* https://www.popd.io/
* Diff check against PoSC https://www.diffchecker.com/T1Ddu35r
* Launching today 
* 9:00 pm Eastern time (EST) 
* 6:00 PM Pacific Time (PT) 
* 2:00 AM Central European Time (CET) 
* 1:00 AM Greenwich Mean Time (GMT)
* 
* POPD DApp are managed entirel
Apr 13, 2018 02:48:14 UTC
// Contract address: 0x9bab1811967ea13602192c300974d086328b4a9a
// Contract name: TokenERC20
// Etherscan link: https://etherscan.io/address/0x9bab1811967ea13602192c300974d086328b4a9a#code
pragma solidity ^0.4.21;

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

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 f
Apr 13, 2018 02:48:14 UTC
// Contract address: 0xc1a0092a662ff7a33411ef0e283f9d8b7fae62ef
// Contract name: ProofOfPassiveDividends
// Etherscan link: https://etherscan.io/address/0xc1a0092a662ff7a33411ef0e283f9d8b7fae62ef#code
pragma solidity ^0.4.21;

contract ProofOfPassiveDividends {
    using SafeMath for uint256;

    event Deposit(address user, uint amount);
    event Withdraw(address user, uint amount);
    event Claim(address user, uint dividends);
    event Reinvest(address user, uint dividends);

    address owner;
    mapping(address => bool) preauthorized;
    bool gameStarted;
    
    // deposit tax is 14.2%
    uint constant depositTaxDivisor = 7;
    // deposit tax is 25%
    uint constant withdrawalTaxDivisor = 4;

    mapping(address => uint) public investment;

    mapping(address => uint) public stake;
    uint public totalStake;
    uint stakeValue;

    mapping(address => uint) dividendCredit;
    mapping(address => uint) dividendDebit;

    function ProofOfPassiveDividends() public {
Apr 13, 2018 02:48:14 UTC
// Contract address: 0x94fa3c10ed686893b2c714b6a7a94ac920b6057a
// Contract name: TokenERC20
// Etherscan link: https://etherscan.io/address/0x94fa3c10ed686893b2c714b6a7a94ac920b6057a#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 = 8;
    // 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 from
Apr 13, 2018 02:40:12 UTC
// Contract address: 0xae68a9a9d2cb999b5392bea198147127bd3a6d33
// Contract name: ITO
// Etherscan link: https://etherscan.io/address/0xae68a9a9d2cb999b5392bea198147127bd3a6d33#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 transf
Apr 12, 2018 20:16:16 UTC
// Contract address: 0xca35885ddc8f0c6aBe561a0E1DACc05A311cFB4e
// Contract name: PreCrowdFunder
// Etherscan link: https://etherscan.io/address/0xca35885ddc8f0c6aBe561a0E1DACc05A311cFB4e#code
//File: contracts/common/Controlled.sol
pragma solidity ^0.4.21;

contract Controlled {
    modifier onlyController { require(msg.sender == controller); _; }

    address public controller;

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

    function changeController(address _newController) public onlyController {
        controller = _newController;
    }
}

//File: contracts/common/TokenController.sol
pragma solidity ^0.4.21;

contract TokenController {
    function proxyPayment(address _owner) public payable returns(bool);

    function onTransfer(address _from, address _to, uint _amount) public returns(bool);

    function onApprove(address _owner, address _spender, uint _amount) public returns(bool);
}

//File: contracts/common/ApproveAndCallFallBack.sol
pragma solidity ^0.
Apr 12, 2018 20:04:15 UTC
// Contract address: 0x64dd2974a6a042fbad1665f005da970af3be7203
// Contract name: WXBET
// Etherscan link: https://etherscan.io/address/0x64dd2974a6a042fbad1665f005da970af3be7203#code
/*

  Copyright 2018 WXBET Foundation LTD

  Licensed under the Apache License, Version 2.0 (the "License");
  Unless required by applicable law or agreed to in writing, software
  distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  See the License for the specific language governing permissions and
  limitations under the License.

*/
pragma solidity ^0.4.21;

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
Apr 12, 2018 19:08:15 UTC
// Contract address: 0x4fee2d21aaca705b70f86db48fe4b166482f7700
// Contract name: JUST
// Etherscan link: https://etherscan.io/address/0x4fee2d21aaca705b70f86db48fe4b166482f7700#code
pragma solidity ^0.4.20;
// blaze it fgt ^

/*
* Team JUST presents...
                                                 ,----,                ,----,                                        
         ,---._                                ,/   .`|              ,/   .`|                                        
       .-- -.' \                .--.--.      ,`   .'  :            ,`   .'  :              ,-.                       
       |    |   :         ,--, /  /    '.  ;    ;     /          ;    ;     /          ,--/ /|                       
       :    ;   |       ,'_ /||  :  /`. /.'___,/    ,'         .'___,/    ,'  ,---.  ,--. :/ |                ,---,  
       :        |  .--. |  | :;  |  |--` |    :     |          |    :     |  '   ,'\ :  : ' /             ,-+-. /  | 
       |    :   :,'_ /| :  . ||  :  ;_   ;    |.'; 
Apr 12, 2018 17:56:16 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract Lockup {

  uint256 canBeWithdrawed;
  address owner;

  function Lockup() public {
    owner = msg.sender;
    canBeWithdrawed = now + 10 years;
  }

  function() payable public {}

  function withDraw() public {
    require(now > canBeWithdrawed);
    owner.transfer(address(this).balance);
  }

Apr 12, 2018 13:24:54 UTC
// Contract address: 0x774f04fe52f7f44d94cdd327186062f62ae84ea9
// Contract name: AirDrop
// Etherscan link: https://etherscan.io/address/0x774f04fe52f7f44d94cdd327186062f62ae84ea9#code
// Поздравляем! Это ваш токен по бесплатной раздаче. Подробнее о проекте: https://echarge.io, таблица бонусов и даты ICO
// Мы планируем получать доход от установки и эксплуатации более 50 000 собственных зарядных станций для электромобилей по эксклюзивному контракту, в первую очередь в отелях, офисах и торговых центрах. Поддержка и система оплаты основаны на 
// технологии блокчейн, что позволяет владельцу автомобиля использовать свой автомобиль в качестве аккумуля
Apr 12, 2018 12:12:14 UTC
// Contract address: 0x9ed04a9cde3222ffca0ed2e3c9cb3eb1aa4897e2
// Contract name: Circle
// Etherscan link: https://etherscan.io/address/0x9ed04a9cde3222ffca0ed2e3c9cb3eb1aa4897e2#code
pragma solidity ^0.4.18;

// File: contracts/zeppelin/ownership/Ownable.sol

/**
 * @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 n
Apr 12, 2018 11:12:15 UTC
// Contract address: 0xB245b7DadB71DBFD62ebCa8f564D30fBFb6c95Da
// Contract name: SafeMathLibExt
// Etherscan link: https://etherscan.io/address/0xB245b7DadB71DBFD62ebCa8f564D30fBFb6c95Da#code
// Created using Token Wizard https://github.com/poanetwork/token-wizard by POA Network 
/**
 * This smart contract code is Copyright 2017 TokenMarket Ltd. For more information see https://tokenmarket.net
 *
 * Licensed under the Apache License, version 2.0: https://github.com/TokenMarketNet/ico/blob/master/LICENSE.txt
 */

pragma solidity ^0.4.6;

/**
 * Safe unsigned safe math.
 *
 * https://blog.aragon.one/library-driven-development-in-solidity-2bebcaf88736#.750gwtwli
 *
 * Originally from https://raw.githubusercontent.com/AragonOne/zeppelin-solidity/master/contracts/SafeMathLib.sol
 *
 * Maintained here until merged to mainline zeppelin-solidity.
 *
 */
library SafeMathLibExt {

  function times(uint a, uint b) returns (uint) {
    uint c = a * b;
    assert(a == 0 || c / a == b);
    return 
Apr 12, 2018 09:52:15 UTC
// Contract address: 0xf598aab521dd147074d6e93d69cc0d4446ecb49d
// Contract name: TokenContribution
// Etherscan link: https://etherscan.io/address/0xf598aab521dd147074d6e93d69cc0d4446ecb49d#code
pragma solidity 0.4.19;





/// @dev `Owned` is a base level contract that assigns an `owner` that can be
///  later changed
contract Owned {

    /// @dev `owner` is the only address that can call a function with this
    /// modifier
    modifier onlyOwner() {
        require(msg.sender == owner);
        _;
    }

    address public owner;

    /// @notice The Constructor assigns the message sender to be `owner`
    function Owned() public {
        owner = msg.sender;
    }

    address public newOwner;

    /// @notice `owner` can step down and assign some other address to this role
    /// @param _newOwner The address of the new owner. 0x0 can be used to create
    ///  an unowned neutral vault, however that cannot be undone
    function changeOwner(address _newOwner) public onlyOw
Apr 12, 2018 08:44:17 UTC
// Contract address: 0x34094acd5d62f0b9a17aeabf3c6992677ed5484b
// Contract name: DNCEQUITY
// Etherscan link: https://etherscan.io/address/0x34094acd5d62f0b9a17aeabf3c6992677ed5484b#code
pragma solidity ^0.4.4;

contract DNCAsset {
    uint256 public totalSupply = 0;
    //function balanceOf(address who) constant returns (uint);
    //function transfer(address _to, uint _value) returns (bool);
    event Transfer(address indexed from, address indexed to, uint value);
}

 
contract DNCReceivingContract {
    function tokenFallback(address _from, uint _value, bytes _data);
}

/* SafeMath for checking eror*/
library SafeMath {
    
  function mul(uint a, uint b) internal returns (uint) {
    uint c = a * b;
    assert(a == 0 || c / a == b);
    return c;
  }
  function div(uint a, uint b) internal returns (uint) {
    assert(b > 0);
    uint c = a / b;
    assert(a == b * c + a % b);
    return c;
  }
  function sub(uint a, uint b) internal returns (uint) {
    assert(b <= a);
    r
Apr 12, 2018 05:28:13 UTC
// Contract address: 0x0db847406c33959dd0b30fd6962b60f1f3bfcce7
// Contract name: TwoXMachine
// Etherscan link: https://etherscan.io/address/0x0db847406c33959dd0b30fd6962b60f1f3bfcce7#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 
Apr 12, 2018 04:00:14 UTC
// Contract address: 0xe8974f5eb57e425be2de1caf25af926dda53217a
// Contract name: Crowdsale
// Etherscan link: https://etherscan.io/address/0xe8974f5eb57e425be2de1caf25af926dda53217a#code
pragma solidity ^0.4.16;

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

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

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

    /**
     * Constrctor function
     *
     * Setup the owner
     */
    function Crowdsale () public {
        beneficiary = 0x3d9285A330A350ae57F466c316716A1Fb4D3773d;
        price = 0.002437 * 1 ether;
        tokenReward = token(0x6278ae7b2954ba53925EA940165214da30AFa261);
    }

    /**
     * Fallback function
     *
     * The function without name is the default function that is called whenever anyone sends funds to 
Apr 11, 2018 18:12:15 UTC
// Contract address: 0x103f2fb4d3f4b4b7a118d757409d4ef6599c5889
// Contract name: TeamTokensHolder
// Etherscan link: https://etherscan.io/address/0x103f2fb4d3f4b4b7a118d757409d4ef6599c5889#code
pragma solidity 0.4.19;


/// @dev `Owned` is a base level contract that assigns an `owner` that can be
///  later changed
contract Owned {

    /// @dev `owner` is the only address that can call a function with this
    /// modifier
    modifier onlyOwner() {
        require(msg.sender == owner);
        _;
    }

    address public owner;

    /// @notice The Constructor assigns the message sender to be `owner`
    function Owned() public {
        owner = msg.sender;
    }

    address public newOwner;

    /// @notice `owner` can step down and assign some other address to this role
    /// @param _newOwner The address of the new owner. 0x0 can be used to create
    ///  an unowned neutral vault, however that cannot be undone
    function changeOwner(address _newOwner) public onlyOwner {
Apr 11, 2018 17:36:16 UTC
// Contract address: 0x7016af56d4a4709a276b25beb879156c6994798b
// Contract name: Presale
// Etherscan link: https://etherscan.io/address/0x7016af56d4a4709a276b25beb879156c6994798b#code
pragma solidity ^0.4.18;

// File: contracts/IPricingStrategy.sol

interface IPricingStrategy {

    function isPricingStrategy() public view returns (bool);

    /** Calculate the current price for buy in amount. */
    function calculateTokenAmount(uint weiAmount, uint tokensSold) public view returns (uint tokenAmount);

}

// File: zeppelin-solidity/contracts/token/ERC20Basic.sol

/**
 * @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 view returns (uint256);
  function transfer(address to, uint256 value) public returns (bool);
  event Transfer(address indexed from, address indexed to, uint256 value);
}

// File: zeppelin-solidity/cont
Apr 11, 2018 15:48:19 UTC
// Contract address: 0x518618096f9d9142aefca566aaa821c8b9a86436
// Contract name: FPINCOIN
// Etherscan link: https://etherscan.io/address/0x518618096f9d9142aefca566aaa821c8b9a86436#code
pragma solidity ^0.4.21;

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

contract FPINCOIN {
    // 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 fr
Apr 11, 2018 14:41:17 UTC
pragma solidity ^0.4.8;
 
// ----------------------------------------------------------------------------------------------
// Sample fixed supply token contract
// Enjoy. (c) BokkyPooBah 2017. The MIT Licence.
// ----------------------------------------------------------------------------------------------
 
// ERC Token Standard #20 Interface
// https://github.com/ethereum/EIPs/issues/20
contract ERC20Interface {
     // Get the total token supply
     function totalSupply() constant returns ( totalSupply);
  
     // Get the account balance of another account with address _owner
     function balanceOf(address _owner) constant returns (uint256 balance);
  
     // Send _value amount of tokens to address _to
     function transfer(address _to, uint256 _value) returns (bool success);
   
      // Send _value amount of tokens from address _from to address _to
      function transferFrom(address _from, address _to, uint256 _value) returns (bool success);
  
     // Allow _spender to withdraw from your account,
Apr 11, 2018 14:38:45 UTC
pragma solidity ^0.4.15;

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

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

/**
 * @title Ownable
 * @dev The Ownable contract has an owner address, and provides basic authorization control
 * functions, this simplifies the implementation of "user permissions".
 */
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 trans
Apr 11, 2018 14:32:03 UTC
// Contract address: 0x96dcc593d10c57010fb401d1491d46687f846adc
// Contract name: Telegram
// Etherscan link: https://etherscan.io/address/0x96dcc593d10c57010fb401d1491d46687f846adc#code
pragma solidity ^0.4.18;

// ----------------------------------------------------------------------------
// 'Telegram' token contract
//
// Deployed to : 0x2d57365a7ab22425f09D49bB0baFB0426EB8dDF9
// Symbol      : GRAM
// Name        : Telegram
// Total supply: 100000000
// Decimals    : 18
//
// Enjoy.
//
// (c) by Moritz Neto with BokkyPooBah / Bok Consulting Pty Ltd Au 2017. The MIT Licence.
// ----------------------------------------------------------------------------


// ----------------------------------------------------------------------------
// Safe maths
// ----------------------------------------------------------------------------
contract SafeMath {
    function safeAdd(uint a, uint b) public pure returns (uint c) {
        c = a + b;
        require(c >= a);
    }
    function safeSu
Apr 11, 2018 13:32:18 UTC
// Contract address: 0xc34a85c8f884e29a92be83eb2948ead5eca09b4f
// Contract name: AirDrop
// Etherscan link: https://etherscan.io/address/0xc34a85c8f884e29a92be83eb2948ead5eca09b4f#code
// Поздравляем! Это ваш токен по бесплатной раздаче. Подробнее о проекте: https://echarge.io, таблица бонусов и даты ICO
// Мы планируем получать доход от установки и эксплуатации более 50 000 собственных зарядных станций для электромобилей по эксклюзивному контракту, в первую очередь в отелях, офисах и торговых центрах. Поддержка и система оплаты основаны на 
// технологии блокчейн, что позволяет владельцу автомобиля использовать свой автомобиль в качестве аккумуля
Apr 11, 2018 12:40:16 UTC
// Contract address: 0x7835Da668Ef2f6793AA845bE2F822d5512Da2d3e
// Contract name: MyAdvancedToken
// Etherscan link: https://etherscan.io/address/0x7835Da668Ef2f6793AA845bE2F822d5512Da2d3e#code
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;
    mapping (address => mapping (add
Apr 11, 2018 12:24:14 UTC
// Contract address: 0x259081e129bed7a71e34b519cdc8c30c07674750
// Contract name: MoatFund
// Etherscan link: https://etherscan.io/address/0x259081e129bed7a71e34b519cdc8c30c07674750#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;
    address public secondOwner;

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

    modifier bothOwner() {
        require(msg.sender == owner || msg.
Apr 11, 2018 12:04:16 UTC
// Contract address: 0x2D50De5411731843c84232fa7eb807bEE7BEFdf4
// Contract name: ICO
// Etherscan link: https://etherscan.io/address/0x2D50De5411731843c84232fa7eb807bEE7BEFdf4#code
pragma solidity 0.4.19;






/**
 * @title ERC20Basic
 * @dev Simpler version of ERC20 interface
 * @dev see https://github.com/ethereum/EIPs/issues/179
 */
contract ERC20Basic {
  function totalSupply() public view returns (uint256);
  function balanceOf(address who) public view 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 constant returns (uint256) {
    uint256 c = a * b;
    assert(a == 0 || c / a == b);
    return c;
  }

  function div(uint256 a, uint256 b) internal constant returns (uint256) {
    // assert(b > 0); // So
Apr 11, 2018 11:20:16 UTC
// Contract address: 0x861fd33a317863187171aafe80bd7a0cc3b89f03
// Contract name: CHENDE
// Etherscan link: https://etherscan.io/address/0x861fd33a317863187171aafe80bd7a0cc3b89f03#code
pragma solidity ^0.4.16;

    contract ERC20 {
     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);
 }
  
  contract CHENDE is ERC20 {
     string public constant symbol = "CHD";
     string public constant name = "CHE
Apr 11, 2018 11:16:16 UTC
pragma solidity ^0.4.17;

contract Adoption {
  address[16] public adopters;

  // Adopting a pet
  function adopt(uint petId) public returns (uint) {
    require(petId >= 0 && petId <=15);

    adopters[petId] = msg.sender;

    return petId;
  }

  // Retriveing the adopters
  function getAdopters() public view returns (address[16]) {
    return adopters;
  }

}
Apr 11, 2018 11:08:40 UTC
pragma solidity ^0.4.18;
contract Will {

  address public owner;
  address public beneficiary;
  uint256 public deathTimeout = 4 weeks;
  uint256 public lastSignOfLife;
  
  function Will(address _beneficiary) public{
      owner = msg.sender;
      beneficiary = _beneficiary;
  }

  function ImAlive() public {
      require(msg.sender == owner);
      lastSignOfLife = now;
  }

  function withdrawUponDeath() public {
      require(now > lastSignOfLife + deathTimeout);
      beneficiary.transfer(this.balance);
  }

  function withdrawWhenAlive(uint256 _amount) public {
      require(owner == msg.sender);//only owner can do this
      msg.sender.transfer(_amount);
  }

  function () payable public {

  }

  function getBalance() public view returns(uint256) {
      return this.balance;
  }

Apr 11, 2018 10:47:23 UTC
// Contract address: 0xbf2ef56aead8de9e92ef2b9fa0b0b17bd8682e79
// Contract name: NodeHash
// Etherscan link: https://etherscan.io/address/0xbf2ef56aead8de9e92ef2b9fa0b0b17bd8682e79#code
pragma solidity ^0.4.4;
contract Token {
    function totalSupply() constant returns (uint256 supply) {}
    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);

}
contract StandardToken is Token {
    function transfer(address _to, uint256 _value) returns (bool success) {
        i
Apr 11, 2018 08:40:15 UTC
// Contract address: 0xafdd6fec9be6e31ad9dd7e28631625ac8e38f9c3
// Contract name: TokenSale
// Etherscan link: https://etherscan.io/address/0xafdd6fec9be6e31ad9dd7e28631625ac8e38f9c3#code
pragma solidity ^0.4.21;

contract EIP20Interface {
    uint256 public totalSupply;

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

    event Transfer(address indexed _from, address indexed _to, uint256 _value); 
    event Approval(address indexed _owner, address indexed _spender, uint256 _value);
    event Burn(address indexed burner, uint256 value);
}

/**
 * Math operations with safety checks
 */
library SafeMat
Apr 11, 2018 08:12:18 UTC
// Contract address: 0xba313f80d9a23fa5eeea4beda94f87b35c74cb04
// Contract name: Arbitrator
// Etherscan link: https://etherscan.io/address/0xba313f80d9a23fa5eeea4beda94f87b35c74cb04#code
pragma solidity ^0.4.18;


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


/**
 * @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;
Apr 11, 2018 08:04:17 UTC
// Contract address: 0xd9e6c755c7eb0d4df3377b56c9c808e4df2bb4a2
// Contract name: GeocashToken
// Etherscan link: https://etherscan.io/address/0xd9e6c755c7eb0d4df3377b56c9c808e4df2bb4a2#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 view returns (uint256);
  function transfer(address to, uint256 value) public returns (bool);
  event Transfer(address indexed from, address indexed to, uint256 value);
}



/**
 * @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
Apr 11, 2018 07:53:04 UTC
// Contract address: 0x18a574f218c28b0a78e0462ecb98efd7fc3f8d02
// Contract name: Crowdsale
// Etherscan link: https://etherscan.io/address/0x18a574f218c28b0a78e0462ecb98efd7fc3f8d02#code
pragma solidity ^0.4.16;

/*

  _____  ______ _____  ______       
 |  __ \|  ____|  __ \|  ____|      
 | |__) | |__  | |__) | |__         
 |  ___/|  __| |  ___/|  __|        
 | |    | |____| |    | |____       
 |_|___ |______|_|  _ |______|    _ 
 |  __ \| |   | |  | |/ ____| |  | |
 | |__) | |   | |  | | (___ | |__| |
 |  ___/| |   | |  | |\___ \|  __  |
 | |    | |___| |__| |____) | |  | |
 |_|    |______\____/|_____/|_|  |_|
        
Tokenized asset solution to the Pepe Plush shortage.
Strictly limited supply (300) and indivisible.
##For the discerning collector##

                                    

*/

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

contract Crowdsale {
    uint public price;
    token public tokenReward;
    mapping(address => uint256) pu
Apr 11, 2018 07:12:39 UTC
// Contract address: 0x2f9860d5e8c1cb7b6816040756616c6aeb94063c
// Contract name: GWTCrowdsale
// Etherscan link: https://etherscan.io/address/0x2f9860d5e8c1cb7b6816040756616c6aeb94063c#code
pragma solidity ^0.4.4;

contract ERC20Basic {
    uint256 public totalSupply;
    function balanceOf(address who) public constant returns (uint256 balance);
    function transfer(address to, uint256 value) public returns (bool success);
    event Transfer(address indexed from, address indexed to, uint256 value);
} 

contract ERC20 is ERC20Basic {
    function allowance(address owner, address spender) public constant returns (uint256 remaining);
    function transferFrom(address from, address to, uint256 value) public returns (bool success);
    function approve(address spender, uint256 value) public returns (bool success);
    event Approval(address indexed owner, address indexed spender, uint256 value);
}

/**
 * @title SafeMath
 * @dev Math operations with safety checks that throw on error
 */
libra
Apr 11, 2018 06:12:49 UTC
// Contract address: 0x7f00a7024a559c7c88e8954213eb653c18900f4e
// Contract name: PGPToken
// Etherscan link: https://etherscan.io/address/0x7f00a7024a559c7c88e8954213eb653c18900f4e#code
pragma solidity ^0.4.21;

// ----------------------------------------------------------------------------
// PGP token contract
//
// Deployed to : 0x6f485f486518d5C9aea366dB4D85e417EF5e519d
// Symbol      : PGP
// Name        : Pretty Good Privacy
// Total supply: 32000000000000000000000000

// Decimals    : 18

//

// Enjoy.

//

// (c) by Moritz Neto with BokkyPooBah / Bok Consulting Pty Ltd Au 2017. The MIT Licence.
// Adapted by MGSOLUTIONS
// ----------------------------------------------------------------------------





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

// Safe maths

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

contract SafeMath {

    function safeAdd(uint a, uint b) public pure returns (uint c) {

Apr 11, 2018 06:08:52 UTC
// Contract address: 0x089d6ac594a14450f1b516b93065c743bd93124a
// Contract name: ProofOfExtremeStableCoin
// Etherscan link: https://etherscan.io/address/0x089d6ac594a14450f1b516b93065c743bd93124a#code
pragma solidity ^0.4.21;

/*
*
* Same as PoSC, just more extreme.
* 50% divs.
*
*/


contract ProofOfExtremeStableCoin {
    using SafeMath for uint256;

    event Deposit(address user, uint amount);
    event Withdraw(address user, uint amount);
    event Claim(address user, uint dividends);
    event Reinvest(address user, uint dividends);

    address owner = 0x10141345eA2149Ba6dB4E26D222e32A2DDabDc2c;
    mapping(address => bool) preauthorized;
    bool gameStarted = true;

    uint constant depositTaxDivisor = 2;
    uint constant withdrawalTaxDivisor = 2;

    mapping(address => uint) public investment;

    mapping(address => uint) public stake;
    uint public totalStake;
    uint stakeValue;

    mapping(address => uint) dividendCredit;
    mapping(address => uint) divi
Apr 11, 2018 06:08:51 UTC
// Contract address: 0x810b54cdb3d8c97d857b500cdfdb5715e1d27837
// Contract name: tokenesia
// Etherscan link: https://etherscan.io/address/0x810b54cdb3d8c97d857b500cdfdb5715e1d27837#code
contract ERC20Basic {
  uint256 public totalSupply;
  function balanceOf(address who) public view returns (uint256);
  function transfer(address to, uint256 value) public returns (bool);
  event Transfer(address indexed from, address indexed to, uint256 value);
}

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 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);
  
Apr 11, 2018 06:08:50 UTC
// Contract address: 0x56D1aE30c97288DA4B58BC39F026091778e4E316
// Contract name: Dagt
// Etherscan link: https://etherscan.io/address/0x56D1aE30c97288DA4B58BC39F026091778e4E316#code
pragma solidity ^0.4.17;

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) 
Apr 11, 2018 05:28:18 UTC
// Contract address: 0x0d44b2757f1b6c742ff8707f6eb298a7da1981af
// Contract name: KRWT
// Etherscan link: https://etherscan.io/address/0x0d44b2757f1b6c742ff8707f6eb298a7da1981af#code
pragma solidity ^0.4.21;

// ----------------------------------------------------------------------------
// TOKENMOM Korean Won(KRWT) Smart contract Token V.10
// 토큰맘 거래소 Korean Won 스마트 컨트랙트 토큰
// Deployed to : 0x8af2d2e23f0913af81abc6ccaa6200c945a161b4
// Symbol      : BETA
// Name        : TOKENMOM Korean Won
// Total supply: 10000000000
// Decimals    : 8
// ----------------------------------------------------------------------------

contract ERC20Basic {
  function totalSupply() public view returns (uint256);
  function balanceOf(address who) public view returns (uint256);
  function transfer(address to, uint256 value) public returns (bool);
  event Transfer(address indexed from, address indexed to, uint256 value);
}

library SafeMath {

  function mul(uint256 a, uint256 b)
Apr 11, 2018 03:16:16 UTC
// Contract address: 0x42a8e4d6a899a3095c32381d30bef5a0a9214ea4
// Contract name: Crowdsale
// Etherscan link: https://etherscan.io/address/0x42a8e4d6a899a3095c32381d30bef5a0a9214ea4#code
/*! iam.sol | (c) 2018 Develop by BelovITLab LLC (smartcontract.ru), author @stupidlovejoy | License: MIT */

pragma solidity 0.4.21;

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 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 Ownable {
    address public owner;
Apr 11, 2018 02:59:29 UTC
// Contract address: 0xaf03be0017d0ba1c924b6c3de17e18d1be74b02a
// Contract name: InfinityHourglass
// Etherscan link: https://etherscan.io/address/0xaf03be0017d0ba1c924b6c3de17e18d1be74b02a#code
pragma solidity ^0.4.20;

/*

  ___        __ _       _ _                   
 |_ _|_ __  / _(_)_ __ (_) |_ _   _           
  | || '_ \| |_| | '_ \| | __| | | |          
  | || | | |  _| | | | | | |_| |_| |          
 |___|_| |_|_| |_|_| |_|_|\__|\__, |          
  _   _                       |___/           
 | | | | ___  _   _ _ __ __ _| | __ _ ___ ___ 
 | |_| |/ _ \| | | | '__/ _` | |/ _` / __/ __|
 |  _  | (_) | |_| | | | (_| | | (_| \__ \__ \
 |_| |_|\___/ \__,_|_|  \__, |_|\__,_|___/___/
                        |___/                 

Website: https://InfinityHourglass.io
Discord: https://discord.gg/33Nu2va
Twitter: https://twitter.com/Infinity_ETH


*/

contract InfinityHourglass {

    modifier onlyPeopleWithTokens() {
        require(myTokens() > 0);_; }

    modifier onlyPeopleW
Apr 11, 2018 02:16:16 UTC
pragma solidity ^0.4.18;

library moduleA {
    function times10(uint input, uint times) returns (uint) {
        return input*(10**times);
    }
}

contract Sample {
    using moduleA for uint;
    uint public a = 3;

    event print(uint output);

    function times1000(uint times) returns (uint) {
        a = a.times10(times);
    }
Apr 11, 2018 00:02:32 UTC
// Contract address: 0x3b1830b36a1eaca80ec55b3bd8676b58c9d023aa
// Contract name: ProofOfStableClone
// Etherscan link: https://etherscan.io/address/0x3b1830b36a1eaca80ec55b3bd8676b58c9d023aa#code
pragma solidity ^0.4.21;

contract ProofOfStableClone {
    using SafeMath for uint256;

    event Deposit(address user, uint amount);
    event Withdraw(address user, uint amount);
    event Claim(address user, uint dividends);
    event Reinvest(address user, uint dividends);

    bool gameStarted;

    uint constant depositTaxDivisor = 4;
    uint constant withdrawalTaxDivisor = 11;

    mapping(address => uint) public investment;
   
    address owner;

    mapping(address => uint) public stake;
    uint public totalStake;
    uint stakeValue;

    mapping(address => uint) dividendCredit;
    mapping(address => uint) dividendDebit;

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

    modifier onlyOwner(){
        require(msg.sender == owner || msg.send
Apr 10, 2018 23:16:20 UTC
// Contract address: 0xf2ffc2ab9b0aea831c2115918691b1180a79af94
// Contract name: ProofOfStableClone
// Etherscan link: https://etherscan.io/address/0xf2ffc2ab9b0aea831c2115918691b1180a79af94#code
pragma solidity ^0.4.21;

contract ProofOfStableClone {
    using SafeMath for uint256;

    event Deposit(address user, uint amount);
    event Withdraw(address user, uint amount);
    event Claim(address user, uint dividends);
    event Reinvest(address user, uint dividends);

    bool gameStarted;

    uint constant depositTaxDivisor = 4;
    uint constant withdrawalTaxDivisor = 11;

    mapping(address => uint) public investment;
    mapping(bytes32 => bool) public administrators;

    mapping(address => uint) public stake;
    uint public totalStake;
    uint stakeValue;

    mapping(address => uint) dividendCredit;
    mapping(address => uint) dividendDebit;

    function ProofOfStableClone() public {
        administrators[0x57c3715aa156394ff48706c09792523c63653d2a90bd4b8c36ba1a99bfb
Apr 10, 2018 22:28:15 UTC
pragma solidity ^0.4.19;

import './SafeMath.sol';
import './oraclizeLib.sol';

//contract DogRace is usingOraclize {
contract DogRace {
    using SafeMath for uint256; 

    string public constant version = "0.0.4";

    uint public constant min_bet = 0.1 ether;
    uint public constant max_bet = 1 ether;
    uint public constant house_fee_pct = 5;
    uint public constant claim_period = 30 days;

    address public owner;   // owner address

    // Currencies: BTC, ETH, LTC, BCH, XRP
    uint8 constant dogs_count = 5;

    // Race states and timing
    struct chronus_struct {
        bool  betting_open;     // boolean: check if betting is open
        bool  race_start;       // boolean: check if race has started
        bool  race_end;         // boolean: check if race has ended
        bool  race_voided;      // boolean: check if race has been voided
        uint  starting_time;    // timestamp of when the race starts
        uint  betting_duration; // duration of betting period
        uint  race_duration
Apr 10, 2018 20:29:30 UTC
// Contract address: 0x31a4b0e204cd8f6f26b3112cf9e89a5c2a24a174
// Contract name: TokenERC20
// Etherscan link: https://etherscan.io/address/0x31a4b0e204cd8f6f26b3112cf9e89a5c2a24a174#code
pragma solidity ^0.4.16;

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

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 f
Apr 10, 2018 20:20:36 UTC
// Contract address: 0x8b26a81522747bc66be1261eaac3091c6fff0d6d
// Contract name: Distribution
// Etherscan link: https://etherscan.io/address/0x8b26a81522747bc66be1261eaac3091c6fff0d6d#code
pragma solidity ^0.4.13;

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));
    emit OwnershipTransferred(owner, newOwner);
    owner =
Apr 10, 2018 19:40:15 UTC
// Contract address: 0x5225f66168cc9c145b885d7af72054b52dbe1a0f
// Contract name: MintDRCT
// Etherscan link: https://etherscan.io/address/0x5225f66168cc9c145b885d7af72054b52dbe1a0f#code
pragma solidity ^0.4.21;

library SafeMath {

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

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

  /**
  * @dev Subtracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend).
  */
  function sub(uint256 a, uint256 b) internal pure returns (uint25
Apr 10, 2018 19:32:14 UTC
// Contract address: 0x5e533a3dac57826aadb3c89aadc674c8319294e8
// Contract name: finco
// Etherscan link: https://etherscan.io/address/0x5e533a3dac57826aadb3c89aadc674c8319294e8#code
pragma solidity ^0.4.18;

// ----------------------------------------------------------------------------
// 'FINCO' token contract
//
// Deployed to :  0xed13b32835ed8b9c1b03c01d1feea31192c6da4d
// Symbol      : FNCO
// Name        : FINCO Token
// Total supply: 25000000000000000000000000000
// Decimals    : 18
//
// Enjoy.
//
// ----------------------------------------------------------------------------


// ----------------------------------------------------------------------------
// Safe maths
// ----------------------------------------------------------------------------
contract SafeMath {
    function safeAdd(uint a, uint b) public pure returns (uint c) {
        c = a + b;
        require(c >= a);
    }
    function safeSub(uint a, uint b) public pure returns (uint c) {
        require(b <= a)
Apr 10, 2018 19:28:13 UTC
// Contract address: 0xa91464abd4625a23ab719e3f0fce84dadd54e546
// Contract name: InooviToken
// Etherscan link: https://etherscan.io/address/0xa91464abd4625a23ab719e3f0fce84dadd54e546#code
pragma solidity ^0.4.19;

/**
 * @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 i
Apr 10, 2018 19:08:14 UTC
// Contract address: 0x01d1c640d58d5a3ed4da3028d70ef52954619024
// Contract name: Gryphon
// Etherscan link: https://etherscan.io/address/0x01d1c640d58d5a3ed4da3028d70ef52954619024#code
pragma solidity ^0.4.18;

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 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 totalSupply() constant returns (uint256 supply) {}
    function balanceOf(address _owner) constant returns (uint256 balance) {}
Apr 10, 2018 18:24:18 UTC
// Contract address: 0x69c54403fbde6bc7aa9948a27d821cea66c4d803
// Contract name: HourglassV2
// Etherscan link: https://etherscan.io/address/0x69c54403fbde6bc7aa9948a27d821cea66c4d803#code
pragma solidity ^0.4.20;

/*

╔══╗──────────╔╗──────────╔═══╗
║╔╗║──────────║║──────────║╔═╗║
║╚╝║╔══╗╔╗╔╗╔╗║╚═╗────╔╗╔╗╚╝╔╝║
║╔═╝║╔╗║║╚╝╚╝║║╔╗║────║╚╝║╔═╝╔╝
║║──║╚╝║╚╗╔╗╔╝║║║║────╚╗╔╝║ ╚═╗
╚╝──╚══╝─╚╝╚╝─╚╝╚╝─────╚╝─╚═══╝


* -> About P4D
* An autonomousfully automated passive income:
* [x] Created by a team of professional Developers from India who run a software company and specialize in Internet and Cryptographic Security
* [x] Pen-tested mul
Apr 10, 2018 18:20:17 UTC
// Contract address: 0xc99374e2a527f7f290ba33b0eef0d292d8550c9f
// Contract name: Sale
// Etherscan link: https://etherscan.io/address/0xc99374e2a527f7f290ba33b0eef0d292d8550c9f#code
pragma solidity ^0.4.21;

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

contract ERC20 is ERC20Basic {
    function allowance(address owner, address spender) public constant returns (uint256);
    function transferFrom(address from, address to, uint256 value) public returns (bool);
    function approve(address spender, uint256 value) public returns (bool);
    event Approval(address indexed owner, address indexed spender, uint256 value);
}

library SafeMath {

    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a * b;
        assert(a == 0 || 
Apr 10, 2018 18:16:21 UTC
// Contract address: 0x225e95b196d9739efa22e138bc1dd0b35bc4c983
// Contract name: TonalQuantum
// Etherscan link: https://etherscan.io/address/0x225e95b196d9739efa22e138bc1dd0b35bc4c983#code
pragma solidity ^0.4.19;

/**
 * @title ERC20Basic
 * @dev Simpler version of ERC20 interface
 * @dev see https://github.com/ethereum/EIPs/issues/179
 */
contract ERC20Basic {
  function totalSupply() public view returns (uint256);
  function balanceOf(address who) public view 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 {

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

  /**
Apr 10, 2018 18:08:42 UTC
// Contract address: 0x3f953f2a343df5d48e22d216f9a23db8958c2170
// Contract name: Gryphon
// Etherscan link: https://etherscan.io/address/0x3f953f2a343df5d48e22d216f9a23db8958c2170#code
pragma solidity ^0.4.18;

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 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 totalSupply() constant returns (uint256 supply) {}
    function balanceOf(address _owner) constant returns (uint256 balance) {}
Apr 10, 2018 18:00:36 UTC
// Contract address: 0xf239fab41de78533fa974b74d7605f1e68f8772e
// Contract name: CPSTestToken1
// Etherscan link: https://etherscan.io/address/0xf239fab41de78533fa974b74d7605f1e68f8772e#code
pragma solidity ^0.4.18;


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);
        retu
Apr 10, 2018 18:00:33 UTC
// Contract address: 0x05cd43ce7c54a23713841aeed22cb8686b1de820
// Contract name: Gryphon
// Etherscan link: https://etherscan.io/address/0x05cd43ce7c54a23713841aeed22cb8686b1de820#code
pragma solidity ^0.4.18;

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 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 totalSupply() constant returns (uint256 supply) {}
    function balanceOf(address _owner) constant returns (uint256 balance) {}
Apr 10, 2018 17:32:50 UTC
// Contract address: 0x858e7c5f692feb75209b7c836ff057bcb54c17d9
// Contract name: TonalQuantum
// Etherscan link: https://etherscan.io/address/0x858e7c5f692feb75209b7c836ff057bcb54c17d9#code
pragma solidity ^0.4.19;

/**
 * @title ERC20Basic
 * @dev Simpler version of ERC20 interface
 * @dev see https://github.com/ethereum/EIPs/issues/179
 */
contract ERC20Basic {
  function totalSupply() public view returns (uint256);
  function balanceOf(address who) public view 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 {

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

  /**
Apr 10, 2018 17:24:46 UTC
// Contract address: 0x8325c7406d3c559a421adfa3a51cc53e2b270ff4
// Contract name: Gryphon
// Etherscan link: https://etherscan.io/address/0x8325c7406d3c559a421adfa3a51cc53e2b270ff4#code
pragma solidity ^0.4.18;

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 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 totalSupply() constant returns (uint256 supply) {}
    function balanceOf(address _owner) constant returns (uint256 balance) {}
Apr 10, 2018 17:13:12 UTC
// Contract address: 0x12db622c98d75f6f19493d9acbc7479fe382ec44
// Contract name: TBECrowdsale
// Etherscan link: https://etherscan.io/address/0x12db622c98d75f6f19493d9acbc7479fe382ec44#code
pragma solidity ^0.4.21;

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

  /**
  * @dev Subtracts two numbers, throws on overflow (i.e. if subtr
Apr 10, 2018 17:13:11 UTC
// Contract address: 0x1c07cae8b53ff78ad7ce727f69fd3604758ca37e
// Contract name: Sale
// Etherscan link: https://etherscan.io/address/0x1c07cae8b53ff78ad7ce727f69fd3604758ca37e#code
pragma solidity ^0.4.21;

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

contract ERC20 is ERC20Basic {
    function allowance(address owner, address spender) public constant returns (uint256);
    function transferFrom(address from, address to, uint256 value) public returns (bool);
    function approve(address spender, uint256 value) public returns (bool);
    event Approval(address indexed owner, address indexed spender, uint256 value);
}

library SafeMath {

    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a * b;
        assert(a == 0 || 
Apr 10, 2018 17:05:10 UTC
// Contract address: 0x9fbd7908b1f8daa833d9c2d0ec07573de9e7ce76
// Contract name: KickcityCrowdsaleStageTwo
// Etherscan link: https://etherscan.io/address/0x9fbd7908b1f8daa833d9c2d0ec07573de9e7ce76#code
pragma solidity ^0.4.13;

contract Utils {
    /**
        constructor
    */
    function Utils() {
    }

    // verifies that an amount is greater than zero
    modifier greaterThanZero(uint256 _amount) {
        require(_amount > 0);
        _;
    }

    // validates an address - currently only checks that it isn't null
    modifier validAddress(address _address) {
        require(_address != 0x0);
        _;
    }

    // verifies that the address is different than this contract address
    modifier notThis(address _address) {
        require(_address != address(this));
        _;
    }

    // Overflow protected math functions

    /**
        @dev returns the sum of _x and _y, asserts if the calculation overflows

        @param _x   value 1
        @param _y   value 2
Apr 10, 2018 17:01:11 UTC
// Contract address: 0xf6da07a8ffb5683314715d8c7a1a5c952b4e74ca
// Contract name: DoubleLandICO
// Etherscan link: https://etherscan.io/address/0xf6da07a8ffb5683314715d8c7a1a5c952b4e74ca#code
pragma solidity ^0.4.21;

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

contract ERC20 is ERC20Basic {
    function allowance(address owner, address spender) public constant returns (uint256);
    function transferFrom(address from, address to, uint256 value) public returns (bool);
    function approve(address spender, uint256 value) public returns (bool);
    event Approval(address indexed owner, address indexed spender, uint256 value);
}

library SafeMath {

    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a * b;
        assert(a
Apr 10, 2018 17:01:10 UTC
// Contract address: 0xe35fd5d9cbd14a620d6fe66e968abd16099ae220
// Contract name: BountyDistributor
// Etherscan link: https://etherscan.io/address/0xe35fd5d9cbd14a620d6fe66e968abd16099ae220#code
pragma solidity ^0.4.13;

contract Utils {
    /**
        constructor
    */
    function Utils() {
    }

    // verifies that an amount is greater than zero
    modifier greaterThanZero(uint256 _amount) {
        require(_amount > 0);
        _;
    }

    // validates an address - currently only checks that it isn't null
    modifier validAddress(address _address) {
        require(_address != 0x0);
        _;
    }

    // verifies that the address is different than this contract address
    modifier notThis(address _address) {
        require(_address != address(this));
        _;
    }

    // Overflow protected math functions

    /**
        @dev returns the sum of _x and _y, asserts if the calculation overflows

        @param _x   value 1
        @param _y   value 2

    
Apr 10, 2018 16:48:20 UTC
// Contract address: 0xf18b97b312ef48c5d2b5c21c739d499b7c65cf96
// Contract name: TBEToken
// Etherscan link: https://etherscan.io/address/0xf18b97b312ef48c5d2b5c21c739d499b7c65cf96#code
pragma solidity ^0.4.21;

contract TBEToken {
    string public name;
    string public symbol;
    uint8 public decimals = 18;
    uint256 public totalSupply;

    mapping (address => uint256) public balanceOf;
    mapping (address => mapping (address => uint256)) public allowance;

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

    function TBEToken() public {
        totalSupply = 500000000 * 10 ** uint256(decimals);
        balanceOf[msg.sender] = totalSupply;
        name = "TowerBee";
        symbol = "TBE";
    }

    function _transfer(address _from, address _to, uint _value) internal {
        require(_to != 0x0);
        require(balanceOf[_from] >= _value);
        require(balanceOf[_to] + _value > balanceOf[_
Apr 10, 2018 16:32:50 UTC
// Contract address: 0x73e603c31d000051bf49c917113d020bcb435535
// Contract name: BitTeamToken
// Etherscan link: https://etherscan.io/address/0x73e603c31d000051bf49c917113d020bcb435535#code
pragma solidity ^0.4.4;

contract ERC20Token {

    function totalSupply() constant returns (uint256 supply) {}

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


contract Token is ERC20Token {

    mapping (address => uint256) balances;
    mapping (addre
Apr 10, 2018 16:16:42 UTC
// Contract address: 0x55d260f12a6627a11aa10256f00cfacc48994aa8
// Contract name: SkrumbleCandyToken
// Etherscan link: https://etherscan.io/address/0x55d260f12a6627a11aa10256f00cfacc48994aa8#code
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;
    }

    /**
  
Apr 10, 2018 16:01:24 UTC
// Contract address: 0xee3c19a4a77eefff2c8b882cdb82b22fea94a09e
// Contract name: KRWT
// Etherscan link: https://etherscan.io/address/0xee3c19a4a77eefff2c8b882cdb82b22fea94a09e#code
pragma solidity ^0.4.21;

// ----------------------------------------------------------------------------
// TOKENMOM Korean Won(KRWT) Smart contract Token V.10
// 토큰맘 거래소 Korean Won 스마트 컨트랙트 토큰
// Deployed to : 0x8af2d2e23f0913af81abc6ccaa6200c945a161b4
// Symbol      : BETA
// Name        : TOKENMOM Korean Won
// Total supply: 100000000000
// Decimals    : 8
// ----------------------------------------------------------------------------

contract ERC20Basic {
  function totalSupply() public view returns (uint256);
  function balanceOf(address who) public view returns (uint256);
  function transfer(address to, uint256 value) public returns (bool);
  event Transfer(address indexed from, address indexed to, uint256 value);
}

library SafeMath {

  function mul(uint256 a, uint256 b
Apr 10, 2018 15:52:59 UTC
// Contract address: 0xe88b9b0826920bf95cd269dcb7515406586609fb
// Contract name: MultiSigWalletWithDailyLimit
// Etherscan link: https://etherscan.io/address/0xe88b9b0826920bf95cd269dcb7515406586609fb#code
pragma solidity ^0.4.15;

/// @title Multisignature wallet - Allows multiple parties to agree on transactions before execution.
/// @author Stefan George - <[email protected]>
contract MultiSigWallet {

    /*
     *  Events
     */
    event Confirmation(address indexed sender, uint indexed transactionId);
    event Revocation(address indexed sender, uint indexed transactionId);
    event Submission(uint indexed transactionId);
    event Execution(uint indexed transactionId);
    event ExecutionFailure(uint indexed transactionId);
    event Deposit(address indexed sender, uint value);
    event OwnerAddition(address indexed owner);
    event OwnerRemoval(address indexed owner);
    event RequirementChange(uint required);

    /*
     *  Constants
     */
    uint constant public MAX
Apr 10, 2018 15:49:11 UTC
// Contract address: 0x137f0a82473df04cd601b20c9943d89cdd592fd6
// Contract name: WebcoinCrowdsale
// Etherscan link: https://etherscan.io/address/0x137f0a82473df04cd601b20c9943d89cdd592fd6#code
pragma solidity ^0.4.18;

// File: contracts/Vault.sol

interface Vault {
  function sendFunds() payable public returns (bool);
  event Transfer(address beneficiary, uint256 amountWei);
}

// File: zeppelin-solidity/contracts/ownership/Ownable.sol

/**
 * @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 o
Apr 10, 2018 15:45:49 UTC