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

import "remix_tests.sol"; // this import is automatically injected by Remix.
import "./ballot.sol";

contract test3 {
   
    Ballot ballotToTest;
    function beforeAll () public {
       ballotToTest = new Ballot(2);
    }
    
    function checkWinningProposal () public {
        ballotToTest.vote(1);
        Assert.equal(ballotToTest.winningProposal(), uint(1), "1 should be the winning proposal");
    }
    
    function checkWinninProposalWithReturnValue () public view returns (bool) {
        return ballotToTest.winningProposal() == 1;
    }
}
Jun 20, 2020 07:30:11 UTC
pragma solidity ^0.5.0;
pragma experimental ABIEncoderV2;

import "https://github.com/OpenZeppelin/openzeppelin-solidity/contracts/access/Roles.sol";

contract HealthCare {
  using Roles for Roles.Role;
  Roles.Role private superAdmins;
  Roles.Role private hospitalAdmins;
  Roles.Role private receptionist;
  Roles.Role private doctor;
  Roles.Role private patient;
  Roles.Role private pharmacist;
  Roles.Role private radiologist;
  Roles.Role private pathologist;

  constructor() public {
    superAdmins.add(msg.sender);
  }
 //StructureOfPatient'sRecord
  struct patientRecords{
    address patient;
    string fname;
    string lname;
    uint age;
    string[] ipfs;
}
  mapping(address=>patientRecords) patientDetails;

  address[] public patientAccounts;

  //inputtingBasicData(name,age)

  function addPatientDetails(address _patientAddress,string calldata _fname,string calldata _lname,uint _age)
   external  onlyReceptionist(){
        patientDetails[_patientAddress].fname = _fname;
        patientDetails[
Jun 20, 2020 07:13:27 UTC
pragma solidity ^0.4.24;   /*宣告智能合約的版本


/* 合約本體 */
contract SimpleAdd { /*SimpleAdd智能合約的名字

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

    // ... 更多變數


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

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

    
Jun 19, 2020 16:08:47 UTC
pragma solidity ^0.4.18;

import 'zeppelin-solidity/contracts/math/SafeMath.sol';

contract Bank {
  using SafeMath for *;

  uint public totalShares = 0;
  uint public totalReleased = 0;

  mapping(address => uint) public shares;
  mapping(address => uint) public released;
  address[] public payees;

  function Bank(address[] _payees, uint[] _shares) public payable {
    require(_payees.length == _shares.length);

    for (uint i = 0; i < _payees.length; i++) {
      addPayee(_payees[i], _shares[i]);
    }
  }

  function addPayee(address _payee, uint _shares) internal {
    require(_payee != address(0));
    require(_shares > 0);
    require(shares[_payee] == 0);

    payees.push(_payee);
    shares[_payee] = _shares;
    totalShares = totalShares.add(_shares);
  }

  function claim() public {
    address payee = msg.sender;

    require(shares[payee] > 0);

    uint totalReceived = this.balance.add(totalReleased);
    uint payment = totalReceived.mul(shares[payee]).div(totalShares).sub(released[payee]);

 
Jun 13, 2020 22:19:05 UTC
pragma solidity ^0.5.0;

import "./Roles.sol";

contract ERC20Interface{
    
    function totlasupply() public view returns(uint);
    function balanceOf (address tokenOwner) public view returns(uint balance);
    function transfer(address to, uint tokens) public returns(bool success);
    function allowance(address TokenOwner, address spender) public view returns(uint remaining);
    function approve(address spender, uint token) public returns(bool success);
    function transferFrom(address from, address to, uint token) public returns(bool success);
    
    event Transfer(address indexed from, address indexed to,uint tokens);
    event Approval(address indexed tokenOwner,address indexed spender,uint token);
}

contract Crypto is ERC20Interface{
    
    using Roles for Roles.Role;
     Roles.Role private Deployer;
     Roles.Role private admins;
     Roles.Role private publishers;
     Roles.Role private voters;
     Roles.Role private solvers; 
     Roles.Role private guests;
   
    string public name="
Jun 07, 2020 07:48:55 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract IPFS {
    struct
  

  
Jun 05, 2020 06:18:09 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract  {
  

  
Jun 05, 2020 06:03:20 UTC
pragma solidity ^0.4.18;

contract ApprovalContract {

    address public sender;
    address public receiver;
    address public constant approver = 0x95c2332b26bb22153a689ae619d81a6c59e0a804;

    function deposit(address _receiver) external payable {
        require(msg.value > 0);
        sender = msg.sender;
        receiver = _receiver;
    }

    function viewApprover() external pure returns(address) {
        return(approver);
    }

    function approve() external {
        require(msg.sender == approver);
        receiver.transfer(address(this).balance);
    }
Jun 02, 2020 22:12:06 UTC
pragma solidity ^0.4.24;

// import 'openzeppelin-solidity/contracts/token/ERC20/StandardToken.sol';
// https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v1.12.0/contracts/token/ERC20/StandardToken.sol
// https://github.com/OpenZeppelin/openzeppelin-contracts/tree/v1.12.0/contracts/token/ERC20

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

library ExtendedMath {
   function limitLessThan(uint a, uint b) internal pure returns (uint c) {
        if(a > b) return b;
        return a;
    }
}

// --------------------------------
Jun 01, 2020 15:09:53 UTC
pragma solidity ^0.4.24;

// import 'openzeppelin-solidity/contracts/token/ERC20/StandardToken.sol';
// https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v1.12.0/contracts/token/ERC20/StandardToken.sol
// https://github.com/OpenZeppelin/openzeppelin-contracts/tree/v1.12.0/contracts/token/ERC20

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

library ExtendedMath {
   function limitLessThan(uint a, uint b) internal pure returns (uint c) {
        if(a > b) return b;
        return a;
    }
}

// --------------------------------
Jun 01, 2020 14:12: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;
May 31, 2020 11:43:30 UTC
pragma solidity >=0.4.22 <0.7.0;

contract sampleContract {
    function get () public {
        aLib.doStuff();
    }
}

library aLib {
    function doStuff() public {
    }
}
May 29, 2020 20:38:32 UTC
import "github.com/oraclize/ethereum-api/provableAPI_0.4.25.sol";

pragma solidity 0.4.25;

contract Lottery is usingOraclize {
    address public manager;
    address[] public players;
    uint public randomNumber;

    uint public lotteryEndDate;
    bool public isRndNumberGenerated;
    bool public paidOut;
    
    constructor() public {
        manager = msg.sender;
        lotteryEndDate = 1591333505;
        
        oraclize_setProof(proofType_Ledger);
    }
    
    modifier restricted() {
        require(msg.sender == manager);
        _;
    }
    
    function enter() public payable {
        require(msg.value > .1 ether);
        players.push(msg.sender);
    }
    
    function payOut() public {
        require(lotteryEndDate < block.time);
        require(isRndNumberGenerated == true);
        require(paidOut == false);
        
        uint index = randomNumber % players.length;
        players[index].transfer(address(this).balance / 2);
        manager.transfer(address(this).balance / 2);
   
May 29, 2020 19:22:43 UTC
import "github.com/oraclize/ethereum-api/provableAPI_0.4.25.sol";

pragma solidity 0.4.25;

contract Lottery is usingOraclize {
    address public manager;
    address[] public players;
    uint public randomNumber;

    uint public lotteryEndDate;
    bool public isRndNumberGenerated;
    bool public paidOut;
    
    constructor() public {
        manager = msg.sender;
        lotteryEndDate = 1591333505;
        
        oraclize_setProof(proofType_Ledger);
    }
    
    modifier restricted() {
        require(msg.sender == manager);
        _;
    }
    
    function enter() public payable {
        require(msg.value > .1 ether);
        players.push(msg.sender);
    }
    
    function payOut() public {
        require(lotteryEndDate < block.time);
        require(isRndNumberGenerated == true);
        require(paidOut == false);
        
        uint index = randomNumber % players.length;
        players[index].transfer(address(this).balance / 2);
        manager.transfer(address(this).balance / 2);
   
May 29, 2020 19:21: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;
May 27, 2020 09:38:58 UTC
/**
 *Submitted for verification at Etherscan.io on 2020-05-14
*/

pragma solidity >=0.5.0;

interface IERC20 {
    function balanceOf(address account) external view returns (uint256);
}


interface IGateway {
    function mint(bytes32 _pHash, uint256 _amount, bytes32 _nHash, bytes calldata _sig) external returns (uint256);
    function burn(bytes calldata _to, uint256 _amount) external returns (uint256);
}

interface IGatewayRegistry {
    function getGatewayBySymbol(string calldata _tokenSymbol) external view returns (IGateway);
    function getTokenBySymbol(string calldata _tokenSymbol) external view returns (IERC20);
}

contract Basic {
    IGatewayRegistry public registry;
    
    event Deposit(uint256 _amount, bytes _msg);
    event Withdrawal(bytes _to, uint256 _amount, bytes _msg);

    constructor(IGatewayRegistry _registry) public {
        registry = _registry;
    }
    
    function deposit(
        // Parameters from users
        bytes calldata _msg,
        // Parameters from Darknodes
      
May 26, 2020 08:13:00 UTC
pragma solidity ^0.6.8;


library SpecEnums {
    enum UserType {noUser, buyer, seller}
}


library SpecLibrary {
    using SpecEnums for SpecEnums.UserType;
    struct User {
        bytes32 userName;
        uint64 userContact;
        uint8 userGender;
        bytes32 userEmail;
        string userAddr;
        uint32[] orders;
        SpecEnums.UserType userType;
    }
    struct Item {
        bytes32 itemName;
        uint8 itemType;
        uint256 itemPrice;
        bytes32 itemDetails;
        bytes32 itemBrand;
        uint8 itemColor;
        bytes32 imageId;
        uint32 availableCount;
        uint256 disputePrice;
        address payable seller;
    }
    struct Order {
        address payable BuyerAddr;
        uint256 timeStamp;
        string orderDetails;
        uint256 totalPrice;
        mapping(uint32 => uint32) prodCount;
        mapping(uint32 => bool) isOrdered;
        mapping(uint32 => bool) isConfirmed;
        mapping(uint32 => bool) isRejected;
        mapping(uint32 => bool) i
May 24, 2020 13:41:18 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

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

  uint value;
May 24, 2020 09:05:25 UTC
pragma solidity ^0.4.24;

contract ERC20Interface{
    
    function totlasupply() public view returns(uint);
    function balanceOf (address tokenOwner) public view returns(uint balance);
    function transfer(address to, uint tokens) public returns(bool success);
    function allowance(address TokenOwner, address spender) public view returns(uint remaining);
    function approve(address spender, uint token) public returns(bool success);
    function transferFrom(address from, address to, uint token) public returns(bool success);
    
    event Transfer(address indexed from, address indexed to,uint tokens);
    event Approval(address indexed tokenOwner,address indexed spender,uint token);
}

contract Crypto is ERC20Interface{
    
    string public name="Ashis";
    string public symbol="AKP";
    uint public decimals=0;
    uint public supply;
    address public founder;
    
    event Transfer(address indexed from, address indexed to,uint tokens);
    
    constructor ()public{
        supply=1000000;
    
May 21, 2020 14:48:32 UTC