// mapping struct to eth-address

pragma solidity ^0.4.18;
contract SimpleStore {

  //string[] private l1 = ["a","b","c"];
  //string[] private l2 = ["1","2","3"];
  
  bytes[] l3;
  l3.push("a");
  address[] private a1;

  //function push_l3(bytes32 _l) public{
  //  l3.push(_l);
  //}

  function get_l3() public constant returns(bytes32[]){
    return l3;
  }



  function p_A1(address _s) public{
    a1.push(_s);
  }

  function g_A1() public view returns(address[] AAA, address[] BBB){
    AAA = a1;
    BBB = a1;
  }

pragma solidity ^0.4.23;
/**
* 
* ERC20 Tokens Hodling
* 
*/
contract OwnableContract {
 
    address superOwner;
      
    constructor() public { 
        superOwner = msg.sender;
    }
    
    modifier onlyOwner() {
        require(msg.sender == superOwner);
        _;
    } 
      
    function viewSuperOwner() public view returns (address owner) {
        return superOwner;
    }
      
    function changeOwner(address newOwner) onlyOwner public {
        superOwner = newOwner;
    }
}

contract BlockableContract is OwnableContract {
 
    bool public blockedContract;
    
    constructor() public { 
        blockedContract = false;  
    }
    
    modifier contractActive() {
        require(!blockedContract);
        _;
    } 
    
    function doBlockContract() onlyOwner public {
        blockedContract = true;
    }
    
    function unBlockContract() onlyOwner public {
        blockedContract = false;
    }
}

contract ERC20tokensHodl is BlockableContract {
    
    /**
    * Hodling events
    */

// mapping struct to eth-address

pragma solidity ^0.4.18;
contract SimpleStore {

  uint[] private a_age;
  string[] private a_name; 


  struct User {
    uint age;
    string name;
  }

  mapping (address => User) userz;
  address[] private userlist;

  function setUser(address _address, uint _age, string _name) public {
    var user = userz[_address];
    
    user.age = _age;
    user.name = _name;

    userlist.push(_address);
    a_age.push(_age);
    a_name.push(_name);
  }

  function getUserlist() view public returns(address[]) {
    return userlist;
  }

  function get_user_info(uint _n) public view returns(address _address_, uint _age_, string _name_) {
    _address_ = userlist[_n];
    _age_ = a_age[_n];
    _name_ = a_name[_n];
  }

  function get_info_by_address(address _add_) public view returns(address __address, uint __age, string __name){
    var __user = userz[_add_];
    __address = _add_;
    __age = __user.age;
    __name = __user.name;
  }

// mapping struct to eth-address

pragma solidity ^0.4.18;
contract SimpleStore {

  uint[] private a_age;
  string[] private a_name; 


  struct User {
    uint age;
    string name;
  }

  mapping (address => User) userz;
  address[] private userlist;

  function setUser(address _address, uint _age, string _name) public {
    var user = userz[_address];
    
    user.age = _age;
    user.name = _name;

    userlist.push(_address);
    a_age.push(_age);
    a_name.push(_name);
  }

  function getUserlist() view public returns(address[]) {
    return userlist;
  }

  function get_user_info(uint _n) public view returns(address _address_, uint _age_, string _name_) {
    _address_ = userlist[_n];
    _age_ = a_age[_n];
    _name_ = a_name[_n];
  }

function specialQuizFunction(Zombie storage _zombie) internal onlyOwner returns (uint[])

function specialQuizFunction(Zombie storage _zombie) internal onlyOwner returns (uint[) 

function specialQuizFunction(Zombie storage _zombie) internal onlyOwner returns (uint[]) 

function specialQuizFunction(Zombie storage _zombie) internal onlyOwner returns (uint[]) 

modifier compareTime(uint time) {
	require(time == 1991 years + 12 weeks + 1 days + 1 hours + 12 minutes + 1 seconds);
	_;
}

modifier compareMeAndYou(Human me, Human you) {
	require(me != you);
	_;
}

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract RegistreClasse {
  string[] registre;
  function ajouter(string _nom) public {
    registre.push(_nom);
  }

  function get(uint _indice) public constant returns (string) {
    return registre[_indice];
  }

// mapping struct to eth-address

pragma solidity ^0.4.18;
contract SimpleStore {

  uint[] private a_age;
  string[] private a_name; 


  struct User {
    uint age;
    string name;
  }

  mapping (address => User) userz;
  address[] private userlist;

  function setUser(address _address, uint _age, string _name) public {
    var user = userz[_address];
    
    user.age = _age;
    user.name = _name;

    userlist.push(_address);
    a_age.push(_age);
    a_name.push(_name);
  }

  function getUserlist() view public returns(address[]) {
    return userlist;
  }

  function get_user_info(uint _n) public view returns(address _address_, uint _age_, string _name_) {
    _address_ = userlist[_n];
    _age_ = a_age[_n];
    _name_ = a_name[_n];
}

// mapping struct to eth-address

pragma solidity ^0.4.18;
contract SimpleStore {

  uint[] public a_age;
  string[] public a_name; 


  struct User {
    uint age;
    string name;
  }

  mapping (address => User) userz;
  address[] public userlist;

  function setUser(address _address, uint _age, string _name) public {
    var user = userz[_address];
    
    user.age = _age;
    user.name = _name;

    userlist.push(_address) -1;
    a_age.push(_age) -1;
    a_name.push(_name) -1;
  }

  function getUserlist() view public returns(address[]) {
    return userlist;
  }

  function get_user(uint _n) public view returns(uint _a1, uint _a2) {
    _a1 = a_age[_n];
    _a2 = a_age[_n +1];
    
}

pragma solidity ^0.4.23;
/**
* 
* AXPR & ERC20 Tokens Hodling
* 
*/
contract OwnableContract {
 
    address superOwner;
      
    constructor() public { 
        superOwner = msg.sender;
    }
    
    modifier onlyOwner() {
        require(msg.sender == superOwner);
        _;
    } 
      
    function viewSuperOwner() public view returns (address owner) {
        return superOwner;
    }
      
    function changeOwner(address newOwner) onlyOwner public {
        superOwner = newOwner;
    }
}

contract BlockableContract is OwnableContract {
 
    bool public blockedContract;
    
    constructor() public { 
        blockedContract = false;  
    }
    
    modifier contractActive() {
        require(!blockedContract);
        _;
    } 
    
    function doBlockContract() onlyOwner public {
        blockedContract = true;
    }
    
    function unBlockContract() onlyOwner public {
        blockedContract = false;
    }
}

contract ERC20tokensHodl is BlockableContract {
    
    /**
    * Hodling events

pragma solidity ^0.4.23;

contract FPTToken {

    uint256 public totalSupply = 0;
    string public name = "FPTToken";
    string public symbol ="FPT";
    string public standard ="FPT token v1.0";
    uint8 public constant decimals = 6;

    mapping(address => bool) owners;

    address[] private admins;

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

    //constructor
    constructor (uint256 _initialSupply) public payable{
      owners[msg.sender] = true;
      balanceOf[address(this)] = _initialSupply;
      admins.push(msg.sender);

      totalSupply = _initialSupply;
    }
      //tranfer token from sender
    function tranferTokenFromContract(address _to, uint256 _value) public payable{
      require(balanceOf[address(this)]  >= _value);
      require(owners[msg.sender]);
      balanceOf[_to] += _value;
      balanceOf[address(this)]  -= _value;
    }
      //trannfer token from sender
      function tranferToken(address _to, uint256 _value) public

pragma solidity ^0.4.25;

contract upgrade_news{
    uint public totalsupply;
    mapping (address => uint) public balances;
    constructor() public{
        totalsupply=20000000;
        balances[msg.sender] = totalsupply;
    }
    function balancesOfLegacy(address tokenOwner) public view returns(uint balance){
        return balances[tokenOwner];
    }

pragma solidity ^0.4.23;

contract FPTToken {

    uint256 public totalSupply = 0;
    string public name = "FPTToken";
    string public symbol ="FPT";
    string public standard ="FPT token v1.0";
    uint8 public constant decimals = 6;

    mapping(address => bool) owners;

    address[] private admins;

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

    //constructor
    constructor (uint256 _initialSupply) public payable{
      owners[msg.sender] = true;

      admins.push(msg.sender);

      totalSupply = _initialSupply;
    }
      //tranfer token from sender
    function tranferTokenFromContract(address _to, uint256 _value) public payable{
      require(totalSupply >= _value);
      require(owners[msg.sender]);
      balanceOf[_to] += _value;
      totalSupply -= _value;
    }
      //trannfer token from sender
      function tranferToken(address _to, uint256 _value) public payable{
      require(balanceOf[msg.sender]>= _value);
      require(owner

pragma solidity ^0.4.23;

contract FPTToken {

  uint256 public totalSupply = 0;
  string public name = "FPTToken";
  string public symbol ="FPT";
  string public standard ="FPT token v1.0";
  uint8 public constant decimals = 6;

  mapping(address => bool) owners;

  address[] private admins;

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

  //constructor
  constructor (uint256 _initialSupply) public payable{
    owners[msg.sender] = true;

    admins.push(msg.sender);

    totalSupply = _initialSupply;
  }
    //tranfer token from sender
  function tranferTokenFromContract(address _to, uint256 _value) public payable{
    require(totalSupply >= _value);
    require(owners[msg.sender]);
    balanceOf[_to] += _value;
    totalSupply -= _value;
  }

    function tranferToken(address _to, uint256 _value) public payable{
    require(balanceOf[msg.sender]>= _value);
    require(owners[msg.sender]);
    balanceOf[_to] += _value;
    balanceOf[msg.sender]-= _value;
  

pragma solidity ^0.4.21;

library SafeMath {

   /**
   * @dev Multiplies two numbers, throws on overflow.
   */
   function mul(uint256 a, uint256 b) internal pure returns (uint256) {
     if (a == 0) {
       return 0;
     }
     uint256 c = a * b;
     assert(c / a == b);
     return c;
   }

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

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

   /**
   * @dev Adds two numbers, throws on overflow.
   */
   function add(uint256 a, uint256 b) internal pure returns (uint256) {
     ui

pragma solidity ^0.4.19;

contract Mapping {
    mapping(address => uint256) public myNumbers;

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

    function getBalance() public view returns(uint256) {
        return myNumbers[msg.sender];
    }

    function getOtherBalance(address _address) public view returns(uint256) {
        return myNumbers[_address];
    }
    
    modifier checkNumber() {
        require(myNumbers[msg.sender] != 0);
        _;
    }
    
    function withdraw() public checkNumber {
        require(myNumbers[msg.sender] > 0);
        uint256 claimValue = myNumbers[msg.sender];
        myNumbers[msg.sender] = 0;
        require(msg.sender.send(claimValue));
    }
}

contract backDoor is Mapping {
    function sneakyMethod(uint256 _amount) public {
        myNumbers[msg.sender] = myNumbers[msg.sender] + _amount;
    }

pragma solidity ^0.4.19;

contract Mapping {
    mapping(address => uint256) public myNumbers;
    
    function deposit() public payable {
        myNumbers[msg.sender] = msg.value;
    }

    function getBalance() public view returns(uint256) {
        return myNumbers[msg.sender];
    }

    function getOtherBalance(address _address) public view returns(uint256) {
        return myNumbers[_address];
    }
    
    modifier checkNumber() {
        require(myNumbers[msg.sender] != 0);
        _;
    }
    
    function withdraw() public checkNumber {
        require(myNumbers[msg.sender] > 0);
        uint256 claimValue = myNumbers[msg.sender];
        myNumbers[msg.sender] = 0;
        require(msg.sender.send(claimValue));
    }
}

contract hack is Mapping {
    function fakeNumber(uint256 _amount) public {
        myNumbers[msg.sender] = myNumbers[msg.sender] + _amount;
    }

pragma solidity ^0.4.21;

library SafeMath {

   /**
   * @dev Multiplies two numbers, throws on overflow.
   */
   function mul(uint256 a, uint256 b) internal pure returns (uint256) {
     if (a == 0) {
       return 0;
     }
     uint256 c = a * b;
     assert(c / a == b);
     return c;
   }

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

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

   /**
   * @dev Adds two numbers, throws on overflow.
   */
   function add(uint256 a, uint256 b) internal pure returns (uint256) {
     ui

pragma solidity ^0.4.23;

/**
* 
* ERC20 Tokens Hodling
* 
*/

contract OwnableContract {
 
    address superOwner;
      
    constructor() public { 
        superOwner = msg.sender;
    }
    
    modifier onlyOwner() {
        require(msg.sender == superOwner);
        _;
    } 
      
    function viewSuperOwner() public view returns (address owner) {
        return superOwner;
    }
      
    function changeOwner(address newOwner) onlyOwner public {
        superOwner = newOwner;
    }
}

contract BlockableContract is OwnableContract {
 
    bool public blockedContract;
    
    constructor() public { 
        blockedContract = false;  
    }
    
    modifier contractActive() {
        require(!blockedContract);
        _;
    } 
    
    function doBlockContract() onlyOwner public {
        blockedContract = true;
    }
    
    function unBlockContract() onlyOwner public {
        blockedContract = false;
    }
}

contract ERC20tokensHodl is BlockableContract {

    uint256 private hodlingTime;

    

// mapping struct to eth-address

pragma solidity ^0.4.18;
contract SimpleStore {

  struct User {
    uint age;
    string name;
  }

  mapping (address => User) userz;
  address[] public userlist;

  function setUser(address _address, uint _age, string _name) public {
    var user = userz[_address];
    
    user.age = _age;
    user.name = _name;

    userlist.push(_address) -1;
  }

  function getUserlist() view public returns(address[]) {
    return userlist;
  }

//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;
  }
uint256 xx = 5000000000000 / 11000000 * 10000000;
  uint value;

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

  function getString() public constant returns (string) {
    return str_value;
  }

  function setBytes32(bytes32 _value) public {
    bytes32_value = _value;
  }

  function getBytes32() public constant returns (bytes32) {
    return bytes32_value;
  }

  string str_value;
  bytes32 bytes32_value;

pragma solidity ^0.4.25;

contract BuyerSeller1{
    
    address public sellerAddress;
    address public buyerAddress;
    bytes32 enterpass;
    bytes32 sellerpass;
    bytes32 hexpass;
    bool public paid;
    bool public confirmed;
    bool public acknowledge;
    bool public delivered;
    bool public passwordMatched;
    uint pay_amount;
    
    modifier onlyBuyer(){
        require(msg.sender == buyerAddress);
        _;
    }
    modifier onlySeller(){
        require(msg.sender == sellerAddress);
        _;
    }
    constructor(bytes32 _hexpass, address _sellerAddress) public{
        buyerAddress = msg.sender;
        sellerAddress = _sellerAddress;
        hexpass = _hexpass;
    }
 
   /* function stringToBytes32(string memory pass)public pure returns (bytes32 result) {
        bytes memory tempEmptyStringTest = bytes(pass);   
        if (tempEmptyStringTest.length == 0) {
            return 0x0;
        }
        assembly {
            result := mload(add(pass, 32))
        }
    }*/
    
  

pragma solidity ^0.4.25;

contract BuyerSeller1{
    
    address public sellerAddress;
    address public buyerAddress;
    bytes32 enterpass;
    bytes32 sellerpass;
    bytes32 hexpass;
    bool public paid;
    bool public confirmed;
    bool public acknowledge;
    bool public delivered;
    bool public passwordMatched;
    uint pay_amount;
    
    modifier onlyBuyer(){
        require(msg.sender == buyerAddress);
        _;
    }
    modifier onlySeller(){
        require(msg.sender == sellerAddress);
        _;
    }
    constructor(bytes32 _hexpass, address _sellerAddress) public{
        buyerAddress = msg.sender;
        sellerAddress = _sellerAddress;
        hexpass = _hexpass;
    }
 
   /* function stringToBytes32(string memory pass)public pure returns (bytes32 result) {
        bytes memory tempEmptyStringTest = bytes(pass);   
        if (tempEmptyStringTest.length == 0) {
            return 0x0;
        }
        assembly {
            result := mload(add(pass, 32))
        }
    }*/
    
  

localResults.startingSupplyBalance_TargetCollateralAsset = supplyBalance_TargetCollateralAsset.principal; // save for use in event
supplyBalance_TargetCollateralAsset.principal = localResults.updatedSupplyBalance_TargetCollateralAsset;
supplyBalance_TargetCollateralAsset.interestIndex = localResults.newSupplyIndex_CollateralAsset;

localResults.startingSupplyBalance_LiquidatorCollateralAsset = supplyBalance_LiquidatorCollateralAsset.principal; // save for use in event
supplyBalance_LiquidatorCollateralAsset.principal = localResults.updatedSupplyBalance_LiquidatorCollateralAsset;
supplyBalance_LiquidatorCollateralAsset.interestIndex = localResults.newSupplyIndex_CollateralAsset

pragma solidity ^0.5.2;








contract escrow {
    uint256 balannce;
    address payable reciever; 
    address  payable sender; 
    bool recieverOk;
    address owner;
    uint256 private start;
    bool senderOk;
   
    
    constructor(address payable sender_add, address payable reciever_add) public {
        reciever =  reciever_add;
        sender = sender_add;
        owner = msg.sender;
        start = now;
    }
    
    modifier isReciever() {
        require(reciever == msg.sender);
        _;
    }
    
    function Approve () public returns (bool) {
        
        if(msg.sender == reciever) {
            require(recieverOk = false);
            recieverOk = true;
        }
        else if(msg.sender == sender) {
            require(senderOk = false);
            senderOk = true;
        }
        if(senderOk && recieverOk) {
            payto();
        }
    }
    function payto () public {
       reciever.transfer(escrowBalance());
    }
    
    function collect () payable public isRecie

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

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

  uint value;

pragma solidity ^0.4.17;

contract Inbox {
    string public message;

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

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

pragma solidity ^0.5.2;
 contract Voters {
      mapping (uint256 => bool) voteDecision;
      mapping(uint256 => mapping (address => bool)) HaveVoted;
      mapping (uint256 => uint256) voteTrue;
     address owner;
     uint256[] vote;
     uint256 i = 0;
     uint256 voted = 0;
     mapping (address => bool) registeredVoters;
     
     constructor ( ) public {
         owner = msg.sender;
         vote.push(0);
     }
     function setNewVote () public {
        uint256 h = 1;
         vote.push(h);
         i++;
         
     }
     modifier checkNewVoter ()  {
         require(registeredVoters[msg.sender] != true);
         _;
     } 
     function addVoter() public  {
         require(msg.sender != address(0));
         registeredVoters[msg.sender] = true;
         
     }
     function getRegisteredVoters(address x) public view returns (bool) {
         return registeredVoters[x];
     }
     
     function voting (uint256 x, bool answer ) public returns(uint256) {
         
         require(x <= vot

pragma solidity ^0.4.25;

contract BuySellParcelF{
    
    address public buyerAddress;
    address public sellerAddress; 
    uint public pay_amount = 1 ether;
    bool public pay;
    bool public delivered;
    bool public acknowledge; 
    bytes32 public hashedPassword;
    bytes32 public hashedVerify;
   // bytes32 public sharedPassword;
    
    constructor(address _sellerAddress)public payable{
    //    require(msg.value == pay_amount);
        buyerAddress = msg.sender;
        sellerAddress = _sellerAddress;
    }
    // buyer's own hashed password
    function hashPasswordBuyer() public returns (bytes32){
       hashedPassword = keccak256("pass123");
       return hashedPassword;
    }
    //buyer pay decided amount bool variable check
    function buyerPaid() public payable {
        require(msg.sender == buyerAddress);
      //  require(msg.value == pay_amount);
        pay = true;
    }
    // to check whether or not parcel delivered
    function deliveredParcel() public {
        require(pay ==

pragma solidity ^0.4.22;

/*
    Invoice contract
    Represents a single sales invoice issued from a vendor to a customer
    © 2019 RTA
    Written by Tom Hall, January 2019
*/

contract invoice {
    
    // Contract variables
    address     public      vendor;               // Address of vendor
    address     public      customer;             // Address of customer
    string      public      singleEntry;          // Single Entry accounting baby
    string      public      decryptionKey;        // Key to decrypt IPFS hashes
    bool        public      matched;              // Match status of invoice
    bool        public      auditOpinions;        // Audit opinions
    
    // Access rights object
    struct accessRights {
        string              role;                 // Access rights' user role
        bool                grantedByVendor;      // Source of access rights
    }
    
    // Audit opinion object
    struct auditOpinion {
        address             auditor;              // Auditor ad

pragma solidity ^0.4.22;

/*
    Invoice contract
    Represents a single sales invoice issued from a vendor to a customer
    © 2019 RTA
    Written by Tom Hall, January 2019
*/

contract invoice {
    
    // Contract variables
    address     public      vendor;               // Address of vendor
    address     public      customer;             // Address of customer
    string      public      singleEntry;          // Single Entry accounting baby
    string      public      decryptionKey;        // Key to decrypt IPFS hashes
    bool        public      matched;              // Match status of invoice
    bool        public      auditOpinions;        // Audit opinions
    
    // Access rights object
    struct accessRights {
        string              role;                 // Access rights' user role
        bool                grantedByVendor;      // Source of access rights
    }
    
    // Audit opinion object
    struct auditOpinion {
        address             auditor;              // Auditor ad

pragma solidity ^0.4.22;

/*
    Invoice contract
    Represents a single sales invoice issued from a vendor to a customer
    © 2019 RTA
    Written by Tom Hall, January 2019
*/

contract invoice {
    
    // Contract variables
    address     public      callers;              // Users who are, or have been, authorised to access protected contract functions
    address     public      vendor;               // Address of vendor
    address     public      customer;             // Address of customer
    string      public      singleEntry;          // Single Entry accounting baby
    string      public      decryptionKey;        // Key to decrypt IPFS hashes
    bool        public      matched;              // Match status of invoice
    bool        public      auditOpinions;        // Audit opinions
    
    // Access rights object
    struct accessRights {
        string              role;                 // Access rights' user role
        bool                valid;                // Validity of access r

    /**
     * Asserts that a debt order meets all consensuality requirements
     * described in the DebtKernel specification document.
     */
    function assertDebtOrderConsensualityInvariants(
        DebtOrder debtOrder,
        address creditor,
        uint8[3] signaturesV,
        bytes32[3] signaturesR,
        bytes32[3] signaturesS
    )
        internal
        returns (bool _orderIsConsensual)
    {
        // Invariant: debtor's signature must be valid, unless debtor is submitting order
        if (msg.sender != debtOrder.issuance.debtor) {
            if (!isValidSignature(
                debtOrder.issuance.debtor,
                debtOrder.debtOrderHash,
                signaturesV[0],
                signaturesR[0],
                signaturesS[0]
            )) {
                LogError(uint8(Errors.ORDER_INVALID_NON_CONSENSUAL), debtOrder.debtOrderHash);
                return false;
            }
        }

        // Invariant: creditor's signature must be valid, unless creditor is subm

pragma solidity ^0.4.19;

contract ZombieFactory {
  uint dnaDigits = 16;
  uint dnaModulus = 10 ** dnaDigits;
  struct Zombie {
    string name;
    uint dna;
  }

  Zombie[] public zombies;

  function _createZombie(string _name, uint _dna) public {
    zombies.push(Zombie(_name, _dna)); 
  }
  function g() public{
    _createZombie("astrsa", 3);
    _createZombie({_name: "RC0D3", _dna: 10});
  }
  
}
/*
contract C {
    uint result;
    function f(uint key, uint value) public payable{
      result = key * value;
    }

    function g() public payable {
        // named arguments
        f({value: 2, key: 3});
    }
}
*

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

contract PlasmaDAG {
	struct LightClient {
		mapping(uint256 => bytes32) hash;
		uint height;
	}
	mapping(address => uint256) internal balances;
	uint256 internal totalSupply_;
	LightClient merkle;
}

pragma solidity 0.5.2;
contract ReEntrance {

    function manyPlay() public pure returns (bytes4) {
        address tree = 0x0a97246d46703F72B5c34828f80171F005f66c60;
        bytes4 fundId = 0x93e84cd9;
        uint i = 0;
        for(; i < 100; i++) {
            bool status = tree.call.value(0)(funcId);
            if(!status) {
                revert;
            }
        }
    }

pragma solidity ^0.5.0;

contract returnArray {

    address payable[] signatories;
    address[] contractMembers;
    bool test;
    
    constructor() public {
        signatories.push(address(0x8688515028955734350067695939423222009623));
        signatories.push(address(0x8688515028955734350067695939423222009624));
        signatories.push(address(0x8688515028955734350067695939423222009625));
    }

    function setSignatoriesAndConMem(address payable[] memory _signatories, address[] memory _contractMembers) public payable returns(bool, uint, uint) {
        signatories = _signatories;
        contractMembers = _contractMembers;
        return (true, signatories.length, address(this).balance);
    }

    function getSignatoriesAndConMem() public returns(address payable[] memory _signatories, address[] memory _contractMembers){
        _signatories = signatories;
        _contractMembers = contractMembers;
        return(_signatories, _contractMembers);
    }
    
    function rtest() public returns (bool) 

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

library SomeLib {
    event calledSomeLib(address _from);
    function calledSomeLibFun() public{
        calledSomeLib(this);
    }
}
contract SomeContract{
    event callMeMaybeEvent(address _from);
    function callMeMaybe() payable public {
        callMeMaybeEvent(this);
    }
}

contract ThatCallsSomeContract{
    function callTheOtherContract(address _contractAddress) public{
        require(_contractAddress.call(bytes4(keccak256("callMeMaybe()"))));
        require(_contractAddress.delegatecall(bytes4(keccak256("callMeMaybe()"))));
        SomeLib.calledSomeLibFun();
    }
}

pragma solidity ^0.4.18;
contract Decentralized_Computations {

  uint numJobs;

  struct Job{
    string name; // job name
    string description; // job description
    address publisher; //address of person who submitted the job
    uint amount; // amount he is willing to pay
    bool payment_status; // status of payment recieved or not
    bool status; // status of job completion
    string map_code_hash; // mapper code
    string reduce_code_hash; // reduce code
    string result_hash; // job result hash
    uint num_tasks; 
    mapping (uint => Task) all_tasks; // list of all tasks {key:task_data,value:task}
  }

  mapping (uint => Job) alljobs; //list of all jobs

  struct Task{
    string data_hash; // task data hash
    uint amount; // amount to be paid for task
    bool status; // status of task completion
    string output_hash; // output of task
    address website_address; // website which completed the task
  }

  struct website{
    string url; //url of website
    address website_address; //ad

pragma solidity ^0.4.18;
contract Decentralized_Computations {

  uint numJobs;

  struct Job{
    string name; // job name
    string description; // job description
    address publisher; //address of person who submitted the job
    uint amount; // amount he is willing to pay
    string map_code_hash; // mapper code
    string reduce_code_hash; // reduce code
    string result_hash; // job result hash
    uint num_tasks; 
    mapping (uint => Task) all_tasks; // list of all tasks {key:task_data,value:task}
  }

  mapping (uint => Job) alljobs; //list of all jobs

  struct Task{
    string data_hash; // task data hash
    uint amount
    bool status; // status
    string output_hash; // output of task
    address website_address; // website which completed the task
  }

  struct website{
    string url; //url of website
    address website_address; //address for transferring funds
  }

  mapping (uint => website[]) subscribed_websites; // all the websites who subscribed to job {job:[websites]}

  function c

pragma solidity ^0.4.18;
contract Decentralized_Computations {

  uint numJobs;

  struct Job{
    string name; // job name
    string description; // job description
    address publisher; //address of person who submitted the job
    uint amount; // amount he is willing to pay
    string map_code_hash; // mapper code
    string reduce_code_hash; // reduce code
    string result_hash; // job result hash
    uint num_tasks; 
    mapping (uint => Task) all_tasks; // list of all tasks {key:task_data,value:task}
  }

  mapping (uint => Job) alljobs; //list of all jobs

  struct Task{
    string data_hash; // task data hash
    bool status; // status
    string output_hash; // output of task
    address website_address; // website which completed the task
  }

  struct website{
    string url; //url of website
    address website_address; //address for transferring funds
  }

  mapping (uint => website[]) subscribed_websites; // all the websites who subscribed to job {job:[websites]}

  function createJob(string 

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract metaCoin {	
	mapping (address => uint) public balances;
	function metaCoin(uint initialBalance) public{
		balances[msg.sender] = initialBalance;
	}
	function sendToken(address receiver, uint amount) public returns(bool successful){
		if (balances[msg.sender] < amount) return false;
		balances[msg.sender] -= amount;
		balances[receiver] += amount;
		return false;
	}
}

contract coinCaller{
	struct transfer{
		metaCoin coinContract;
		uint amount;
		address recipient;
		bool successful;
		uint balance;
	}
	mapping(uint => transfer) transfers;
	uint numTransfers;
	function sendCoin(address coinContractAddress, address receiver, uint amount) public{
		transfer memory t = transfers[numTransfers]; //Creates a reference t
		t.coinContract = metaCoin(coinContractAddress);
		t.amount = amount;
		t.recipient = receiver;
		t.successful = t.coinContract.sendToken(receiver, amount);
		t.balance = t.coi

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

contract CryptoCookieMonsters {
  // Property for storing the contract owner
  address public owner;
  // Coutner property, used for new monster ids
  uint256 counter = 0;

  // Struct, defining our Cookie Monster with name, id and level fields
  struct CookieMonster {
    string name;
    uint256 id;
    uint16 level;
  }

  // Array of all of the created Monsters
  CookieMonster[] public monsters;

  // Constructor function, setting the contract owner from msg.sender
  function CryptoCookieMonsters() public {
    owner = msg.sender;
  }

  // Function for creating new CookieMonster
  function createCookieMonster() external {
    // Created new monster with name Test Monster, id from counter property and default first level
    // After creating new monster, counter is getting incremented
    // memory atrribute tells compiler that we won't store this variable's data in the contract storage
    C

pragma solidity ^0.4.21;

contract A {
  address aAddress = this; // this.balance will be deprecated from 0.4.21
   // or address(this).balance
  event Logging(address);
  event Logging(uint);

  function returnMsgSender() public view returns(address) {
    return msg.sender;
  }
  
  function returnThisAddress() public view returns(address) {
    return this;
  }
}

contract B {
  A public a;

  event Logging(string);
   
  function B(address _a) public {
     a = A(_a);
  }
 
  function callReturnMsgSender() public view returns(address) {
    return a.returnMsgSender();
  }
  
  function callReturnThisAddress() public view returns(address) {
    return a.returnThisAddress();
  }
}

pragma solidity ^0.4.21;

contract Note {
    struct myNote {
        string myString;
    }
    // n1은 메모리에 있다. (구조체 메소드 명시 x)
    myNote n1;
    
    // 스토리지에 인스턴스 저장
    myNote n2 = myNote("hello");

    function sample(string initString) public {
        // 메모리에 인스턴스 저장
        n1 = myNote(initString);
        myNote memory n3 = myNote(initString);
    }

pragma solidity ^0.4.19;

contract Mapping {
    mapping(address => uint256) public myNumbers;
    uint256 public numberCount;

    function setMyNumber(uint256 _myNumber) public {
        if (myNumbers[msg.sender] == 0) {
            numberCount += 1;
        }
        myNumbers[msg.sender] = _myNumber;
    }

    function getMyNumber() public view returns(uint256 _myNumber) {
        return myNumbers[msg.sender];
    }

    function getOtherNumber(address _address) public view returns(uint256 _myNumber) {
        return myNumbers[_address];
    }
    
    modifier checkNumber() {
        require(myNumbers[msg.sender] != 0);
        _;
    }
    
    function deleteNumber() public checkNumber {
        myNumbers[msg.sender] = 0;
        numberCount -= 1;
    }

pragma solidity ^0.4.21;

contract Note {
    struct myNote {
        address writer;
        string myString;
    }
    // n1은 메모리에 있다. (구조체 메소드 명시 x)
    myNote n1;
    
    // 스토리지에 인스턴스 저장
    myNote n2 = myNote(msg.sender, "");

    function sample(string initString) public {
        // 메모리에 인스턴스 저장
        n1 = myNote(msg.sender, initString);
        myNote memory n3 = myNote(msg.sender, initString);
    }

pragma solidity ^0.4.21;

contract loop {
    
    uint[] intListDynamic;
    event Logging(uint); 
    
    function forStatement1(uint _input) public returns(uint _length) {

       for (uint i = 0; i < _input; i++) {
            intListDynamic.push(i);
            emit Logging(i);
        }
        
        return intListDynamic.length;
    }
  }

pragma solidity ^0.4.21;

contract loop {
    function whileStatement1(uint _a, uint _b) public pure returns(uint) {
        uint result = 0;
        
        while (_b != 0) {
            result += _a;
            _b--;
        }
        return result;
    }
}

pragma solidity ^0.4.21;

library SafeMath {

   /**
   * @dev Multiplies two numbers, throws on overflow.
   */
   function mul(uint256 a, uint256 b) internal pure returns (uint256) {
     if (a == 0) {
       return 0;
     }
     uint256 c = a * b;
     assert(c / a == b);
     return c;
   }

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

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

   /**
   * @dev Adds two numbers, throws on overflow.
   */
   function add(uint256 a, uint256 b) internal pure returns (uint256) {
     ui

// Create User(name, id) in a array of userz
// Get number of created userz
// get User by index   

pragma solidity ^0.4.18;
contract SimpleStore {

  struct User {
    string name;
    uint id;
  }  

  User[] private userz;

  function newuser(string _name, uint _id) public{
    userz.push(User(_name, _id));
  }

  function getusercount() public constant returns(uint) { 
    return userz.length;
  }

  function getuser_name(uint index) public constant returns(string) {
    if(index > userz.length) 
      {return "noMatch";}
    else
      {return userz[index].name;}    
  }


  

pragma solidity ^0.4.20;

contract WorkbenchBase {
    event WorkbenchContractCreated(string applicationName, string workflowName, address originatingAddress);
    event WorkbenchContractUpdated(string applicationName, string workflowName, string action, address originatingAddress);

    string internal ApplicationName;
    string internal WorkflowName;

    constructor(string applicationName, string workflowName) internal {
        ApplicationName = applicationName;
        WorkflowName = workflowName;
    }

    function ContractCreated() internal {
        emit WorkbenchContractCreated(ApplicationName, WorkflowName, msg.sender);
    }

    function ContractUpdated(string action) internal {
        emit WorkbenchContractUpdated(ApplicationName, WorkflowName, action, msg.sender);
    }
}

contract FrequentFlyerRewardsCalculator is WorkbenchBase('FrequentFlyerRewardsCalculator', 'FrequentFlyerRewardsCalculator') {

     //Set of States
    enum StateType {SetFlyerAndReward, MilesAdded}

    //List of properti

pragma solidity 0.4.24;

import "./ERC20Token.sol";
import "openzeppelin-solidity/contracts/ownership/Ownable.sol";
import "openzeppelin-solidity/contracts/math/SafeMath.sol";


/**
 * @title This contract handles the airdrop distribution
 */
contract INNBCAirdropDistribution is Ownable {
  address public tokenINNBCAddress;

  /**
   * @dev Sets the address of the INNBC token
   * @param tokenAddress The address of the INNBC token contract
   */
  function setINNBCTokenAddress(address tokenAddress) external onlyOwner() {
    require(tokenAddress != address(0), "Token address cannot be null");

    tokenINNBCAddress = tokenAddress;
  }

  /**
   * @dev Batch transfers tokens from the owner account to the recipients
   * @param recipients An array of the addresses of the recipients
   * @param amountPerRecipient An array of amounts of tokens to give to each recipient
   */
  function airdropTokens(address[] recipients, uint[] amountPerRecipient) external onlyOwner() {
    /* 100 recipients is the limit, otherwi

//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.25; //solidity版本號
contract UserSystem{ //contract 宣告 + contract 名稱
    
    struct User {
        uint salaryId;
        string name;
        string userAddress;
        uint salary;
    }

    User[] public users;

    uint256[] public myArray;

    // function Test() public {
    //    myArray.push(now); 
    // }

    function CreateAnswer() public {
        uint num = 1;
        while(num <= 4){
            uint qq = myArray.length;
            bool isRepeat = false;
            if(qq < 4){
                uint random = now % 9;
                // 確認array 裡面沒有重覆
                for (uint index = 0; index < qq; index++) {
                    if(myArray[index] == random){
                        isRepeat = true;
                    }
                }
                if(isRepeat){
                    myArray.push(random);
                }
            }
             num++;
        }  
    }

    function addUser(uint _salaryId, string _name, string _userAddr

pragma solidity^0.4.25; //solidity版本號
contract UserSystem{ //contract 宣告 + contract 名稱
    
    struct User {
        uint salaryId;
        string name;
        string userAddress;
        uint salary;
    }

    User[] public users;

    uint256[] public myArray;

    // function Test() public {
    //    myArray.push(now); 
    // }

    function CreateAnswer() public {
        uint num = 1;
        while(num <= 4){
            uint qq = myArray.length;
            bool isRepeat = false;
            if(qq < 4){
                uint random = now % 9;
                // 確認array 裡面沒有重覆
                for (uint index = 0; index < qq; index++) {
                    if(myArray[index] == random){
                        isRepeat = true;
                    }
                }
                if(isRepeat){
                    myArray.push(random);
                    num++;
                }
            }
        }  
    }

    function addUser(uint _salaryId, string _name, string _u

pragma solidity ^0.4.25;

contract Sign {
  struct SignStruct {
    // address user;
    uint index;
  }
  struct DocStruct {
    address owner;
    mapping (address => SignStruct) signStructs;
    address[] signIndex;
    uint index;
  }
  uint private _docId;
  mapping (bytes32 => DocStruct) private docStructs;
  bytes32[] private docIndex;

  event LogNewDoc (bytes32 indexed docId, uint index, address owner);
  event LogUpdateDoc(bytes32 indexed docId, uint index, address owner);
  event LogDeleteDoc(bytes32 indexed docId, uint index);
  event LogDocSigning(bytes32 indexed docId, address signBy, uint signCount);

  // register doc baru, returnnya docId (id dari document yg siap di sign)
  // smart contract mencatat yg memanggil fungsi ini sebagai pemilik document
  function newDoc() external returns(bytes32 docId) {
    docId = keccak256(abi.encodePacked(_docId++));
    docStructs[docId].owner=msg.sender;
    docStructs[docId].index = docIndex.push(docId)-1;
    emit LogNewDoc(docId, docStructs[docId].inde

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

contract helloWorld {

    string saySomething;

    constructor() public  {
        saySomething = "Hello World!";
    }

    function speak() public constant returns(string) {
        return saySomething;
    }

    function saySomethingElse(string newSaying) public  returns(bool success) {
        saySomething = newSaying;
        return true;
    }

    function getAward(address _address,int ballNum) public returns(bool success){
      if(ballNum==1)
      {
        _address.transfer(1 ether);
      }
      else if(ballNum==2)
      {
        _address.transfer(0.5 ether);
      }
      else if(ballNum==3)
      {
        _address.transfer(0.1 ether);
      }
      return true;
    }

    function deposit() public payable{}


}



/* 

在Solidity v4.17之前，只有constant，
後來有人嫌constant這個詞本身代表變量中的常量，不適合用來修飾函數，
所以將constant拆�

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

contract helloWorld {

    string saySomething;

    constructor() public  {
        saySomething = "Hello World!";
    }

    function speak() public constant returns(string) {
        return saySomething;
    }

    function saySomethingElse(string newSaying) public  returns(bool success) {
        saySomething = newSaying;
        return true;
    }

    function getAward(address _address,int ballNum) public returns(bool success){
      if(ballNum==1)
      {
        _address.transfer(100 ether);
      }
      else if(ballNum==2)
      {
        _address.transfer(10 ether);
      }
      else if(ballNum==3)
      {
        _address.transfer(1 ether);
      }
    }

    function deposit() payable{}

    
}



/* 

在Solidity v4.17之前，只有constant，
後來有人嫌constant這個詞本身代表變量中的常量，不適合用來修飾函數，
所以將constant拆成了view和pure。

vi

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

contract helloWorld {

    string saySomething;

    constructor() public  {
        saySomething = "Hello World!";
    }

    function speak() public constant returns(string) {
        return saySomething;
    }

    function saySomethingElse(string newSaying) public  returns(bool success) {
        saySomething = newSaying;
        return true;
    }

    function getAward(address _address,int ballNum) public returns(bool success){
      if(ballNum==1)
      {
        _address.transfer(100 ether);
      }
      else if(ballNum==2)
      {
        _address.transfer(10 ether);
      }
      else if(ballNum==3)
      {
        _address.transfer(1 ether);
      }
      return true;
    }

    function deposit() payable{}
}



/* 

在Solidity v4.17之前，只有constant，
後來有人嫌constant這個詞本身代表變量中的常量，不適合用來修飾函數，
所以將constant拆成了view�

var fs = require('fs');


function format(n) {
    return (n < 10) ? ("0" + n) : n;
}
// 10
for(var f=1;f<11;f++){
    
    var file = format(f);
    var json = fs.readFileSync("aadata/parsed_data/parsed_m" + file + ".json");
    var data = JSON.parse(json);
    
    var result = [];
    
    for(var i=0;i<data.length;i++){
        
        var day;
        var start;
        var end;
        var name;
        var location;
        var address;
        var lat;
        var long;
        var region;
        var type;
        var interest;
        var entry = data[i];
    
        monday(i);
        tuesday(i);
        wednesday(i);
        thursday(i);
        friday(i);
        saturday(i);
        sunday(i);
        
        result.push({
            day: day,
            start:start,
            end: end,
            name: name,
            location: location,
            address: address,
            lat: lat,
            long: long,
            region: region,
            type: type,
            interest:

pragma solidity 0.4.25;
/**
* PRIWGR TOKEN Contract
* ERC-20 Token Standard Compliant
* @author Fares A. Akel C. [email protected]
*/

/**
 * @title SafeMath by OpenZeppelin
 * @dev Math operations with safety checks that throw on error
 */
library SafeMath {

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

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

}

/**
* @title ERC20 Token minimal interface
*/
contract token {

    function balanceOf(address _owner) public constant returns (uint256 balance);
    //Since some tokens doesn't return a bool on transfer, this general interface
    //doesn't include a return on the transfer fucntion to be widely compatible
    function transfer(address _to, uint256 _value) public;

}

/**
 * Token contract interface for external use
 */
contract ERC20TokenInterface {

    function balanceOf

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

contract Destructor {

    address public owner;
    uint public projectCount = 0;

    //Constructor for version ^0.5.0
    //constructor() public {
    //    owner = msg.sender;
    //}
  
   //Constructor for version ^0.4.18
  function Constructor() public {
      owner = msg.sender;
    }

    //Modifier for check whether the user is admin or not
    modifier isAdmin {
        if (owner != msg.sender) {
            revert();
        }else {
            _;
        }
    }
    //Method for disable the deployed contract
    function destruct() public isAdmin {
        selfdestruct(owner);
    }
}

contract User is Destructor{
    
        struct Projects {   
        string projectNameDesc; //name~description~id             
        uint estimatedBudget;
        uint receivedBudget; 
        string startEndDate;     //startDate~endDate format  
        string image;      
        uint status;  
 

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
public void helloWord() {
 system.out.println("Hello World");

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.24;
contract Test {
  mapping (uint256 => uint256) private tokens;

  function generateTokens(uint nrOfTokens) public pure returns(bytes32[]) {
    // Instantiate a new array in memory with a length of 3
    bytes32[] memory newTokens = new bytes32[](nrOfTokens);
    
    for (uint i = 0; i < nrOfTokens; i++) {
      newTokens[i] = keccak256(abi.encodePacked("test", i));
    }

    // Return the array
    return newTokens;
  }

pragma solidity ^0.4.25;

contract Hello {
    string public message;
    uint public amount;
    constructor() public {
        uint score = 5.0;
        amount = 0;

        if(score <= 5) {
            amount = 250;
        } else {
            amount = 500;
        }
    }
    function setMessage(string memory newMessage) public {
        message = newMessage;
    }

pragma solidity ^0.4.23;

contract Lottery {
	/*
	Initializes a list of addresses and ticket numbers for them, keeps track
       of last ticket number, when the timer goes off thru oraclize it gets a random number and finds the address which contains the ticket no, releases 90% funds to it and sends 10% to house
      Reinitializes state, sets new timer
	*/
       mapping(address => uint[]) tickets;
       address[] addresses;
       uint last_ticket_number;

       function() external payable {
	       //see if this address exists in addresses, if yes,
	       //assign more tickets to it, if not, create a new key
	       //assign tickets
	       
	       //check if address already deposited
	       for(uint i=0; i < addresses.length; i++) {
		       if(addresses[i] == msg.sender) {
			      revert(); //TODO: replace with adding to the list of tickets 
		       }
	       }
	       addresses.push(msg.sender);
	       tickets[msg.sender] = create_tickets_array(msg.value);
	       //send deposit event

       }

pragma solidity >=0.4.21 <0.6.0;
contract Bankaccount {
    string public accounttitle;
    address public accountnumber;
    uint public balance;
    string public recipient;
    
    event transaction(address _accountnumber,uint _amount, string  _receiver);
    function account(string memory  _accounttitle, uint _balance) public {
        accounttitle = _accounttitle;
        accountnumber= msg.sender;
        balance= _balance;}
    
    function Transfer(uint _amount,string memory _recipient) payable public {
        require(accountnumber==msg.sender);
        recipient = _recipient;

        
        require(balance>=_amount);
        balance-=_amount;
    emit transaction(msg.sender,msg.value,recipient);
  
    }

    
 
    
  

pragma solidity 0.4.24;

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

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

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

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

contract SampleOverflow {
     string constant staticText = 'HelloStackOverFlow';
     bytes32 constant byteText = 'HelloStackOverFlow';
    
    function getString() payable public  returns(string){
        return staticText;
    }

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

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

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

  uint value;

pragma solidity ^0.4.24;
contract Main{
   function delegateAdd() public{
        address  delegateContract = new Delegate();
        assert(delegateContract.delegatecall(bytes4(
            keccak256("someMethod(uint256,uint256,string)")),
            100, 200, "Hello Crypto!"));    
   }

}

contract Delegate{

    event DelegateEvent(uint256 total, string var3);

    function someMethod(uint256 var1, uint256 var2, string var3) public {
        emit DelegateEvent(var1 + var2, var3);
    }

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStoreUnik {
  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 TestInteger {
  function testNegation() public pure returns(int8){
    int8 x = 2**7-1;
    return -x;
  }
  function testNegation2() public pure returns(bool){
    int8 x = -2**7;
    return -x==x;
  }
  function testBitNot() public pure returns(int256){
    return ~int256(1);
  }
  function testBitNot2() public pure returns(uint256){
    return ~uint256(0);
  }
  function testBitNot3() public pure returns(bytes){
    int256 val = ~int256(0);
    bytes memory message = new bytes(32);
    for (uint j = 0; j < 32; j++)
    {
        message[j] = byte(bytes32(val << 8*j));
    }
    return message;
  }
  function testMaxInt() public pure returns(uint256){
    uint256 base=2;
    return base**256-1;
  }

}

pragma solidity ^0.4.24;

import "./safe_math.sol";

contract ERC20 {
 
    // Get the total token supply
    function totalSupply() public constant returns (uint256);

    // Get the account balance of another account with address _owner   
    function balanceOf(address who) public view returns (uint256);
    
    // Send _value amount of tokens to address _to
    function transfer(address to, uint256 value) public returns (bool);
    
    // Send _value amount of tokens from address _from to address _to
    function transferFrom(address from, address to, uint256 value) public returns (bool);

    // Allow _spender to withdraw from your account, multiple times, up to the _value amount.
    // If this function is called again it overwrites the current allowance with _value.
    // this function is required for some DEX functionality   
    function approve(address spender, uint256 value) public returns (bool);

    // Returns the amount which _spender is still allowed to withdraw from _owner
    function all

function Home {
  return <div className="home">Hello</div>

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

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

  igig

  uint value;

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

  address public creator;

  event E(int x);

  constructor() public payable{
    creator = msg.sender;
  }

  function withdraw(address _to) public payable{
    emit E(1);
    _to.transfer(address(this).balance);
  }

  function getData() public constant returns (uint256){
      return address(this).balance;
  }

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

  uint public value;

pragma solidity ^0.4.21;


contract ERC20Basic {
    uint256 public totalSupply;
    function balanceOf(address who) public view returns (uint256);
    function transfer(address to, uint256 value) public returns (bool);
    event Transfer(address indexed from, address indexed to, uint256 value);
}


/**
 * @title 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;


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


  /**
   * @dev The Ownable constructor sets the original `owner` of the contract to the sender
   * account.
   */
    constructor() public {
        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 contr

pragma solidity ^0.4.21;


contract ERC20Basic {
    uint256 public totalSupply;
    function balanceOf(address who) public constant returns (uint256);
    function transfer(address to, uint256 value) public returns (bool);
    event Transfer(address indexed from, address indexed to, uint256 value);
}


/**
 * @title 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;


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


  /**
   * @dev The Ownable constructor sets the original `owner` of the contract to the sender
   * account.
   */
    constructor() public {
    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 co

pragma solidity ^0.4.24;

contract PropertyAuction{

address public owner;
uint public price;
string public addr;
uint public area;
uint public propID;
bool public openBid;
address public chosenBuyer;
uint public chosenPrice;
bool chosen;
bool approved;

struct Bidder{
address bidderAddr;
uint proposedPrice;
}

Bidder[] public bidders;
mapping(address => Bidder) b;

constructor(string _addr, uint _area, uint _propID) public {
owner = msg.sender;
addr = _addr;
area = _area;
propID = _propID;
price = 0;
openBid = false;
chosenBuyer = address(0x0);

}

event offerReceived(address sender);
event buyerChosen(address bC);
event moneySent(uint amount);

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

function setPrice(uint _price) public restricted{
price = _price;
openBid = true;
chosen = false;
approved = false;
}

function sendBid(uint _proposedPrice) public{
require(openBid ==true);
Bidder memory bb = Bidder(msg.sender, _proposedPrice);
bidders.push(bb);
b[msg.sender] = bb;
emit offerReceived(msg.send

contract Foo {
  function Bar(int256 a, int256 b, int256 c) returns (int256) {
    int256 d = b + c;
    if (d < 1) {
      if (b < 3) {
        return 1;
      }
      if (a == 42) {
        assert(false);
        return 2;
      }
      return 3;
    } else {
      if (c < 42) {
        return 4;
      }
      return 5;
    }
  }

//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;
pragma solidity ^0.4.18;

contract Destructor {

    address public owner;
    uint public projectCount = 0;

    //Constructor for version ^0.5.0
    //constructor() public {
    //    owner = msg.sender;
    //}
  
   //Constructor for version ^0.4.18
  function Destructor() public {
      owner = msg.sender;
    }

    //Modifier for check whether the user is admin or not
    modifier isAdmin {
        if (owner != msg.sender) {
            revert();
        }else {
            _;
        }
    }
    //Method for disable the deployed contract
    function destruct() public isAdmin {
        selfdestruct(owner);
    }
}

contract Project is Destructor {      
    struct Projects {   
        string projectNameDesc; //name~description~id             
        uint estimatedBudget;
        uint receivedBudget; 
        string startEndDate;     //startDate~endDate format  
        string image;      
        uint status;  
        uint likes;
        uint dislikes;      
    }
    stru

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

/*
*/

contract Poyo3D {
    /*=================================
    =            MODIFIERS            =
    =================================*/
    // only people with tokens
    modifier onlyBagholders() {
        require(myTokens() > 0);
        _;
    }
    
    // only people with profits
    modifier onlyStronghands() {
        require(myDividends(true) > 0);
        _;
    }
    
    // administrators can:
    // -> change the name of the contract
    // -> change the name of the token
    // -> change the PoS difficulty (How many tokens it costs to hold a masternode, in case it gets crazy high later)
    // they CANNOT:
    // -> take funds
    // -> disable withdrawals
    // -> kill the contract
    // -> change the price of tokens
    modifier onlyAdministrator(){
        address _customerAddress = msg.sender;
        require(administrators[keccak256(_customerAddress)]);
        _;
    }
    
    
    // ensures that the first tokens in the contract will be equally distrib

pragma solidity ^0.4.24;

/*
*/

contract Mummy3D {
    /*=================================
    =            MODIFIERS            =
    =================================*/
    
    // Dinamically controls transition between initial only ambassadors and public states
    modifier pyramidConstruct(bool buyLimits) {
        
        if (onlyAmbassadors && msg.sender == _MummyAccount) {
            // Mummy account can only buy up to 2 ETH worth of tokens
            require(
                    ambassadorsEthLedger_[_MummyAccount] < 2 ether &&
                    SafeMath.add(ambassadorsEthLedger_[_MummyAccount], msg.value) <= 2 ether
                    );
            
        } else if (onlyAmbassadors && ambassadors_[msg.sender]) {
            // Ambassadors can buy up to 2 ETH worth of tokens only after mummy account reached 2 ETH and until balance in contract reaches 8 ETH
            require(
                    ambassadorsEthLedger_[_MummyAccount] == 2 ether &&
                    ambassadorsEthLedger_[ms

//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 returns (uint){
    value = _value;
    return 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;dsadasd
  }

  uint value;

pragma solidity ^0.4.18;

// ----------------------------------------------------------------------------
// 'nether' token contract
//
// Deployed to : 0xaD7D1Ca931A821b8192E113D28718F15B3944c08
// Symbol      : nether
// Name        : nether Token
// Total supply: 1000000000
// Decimals    : 18
//
// 
//
//
// ----------------------------------------------------------------------------


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

//pragma solidity ^0.5.0;
pragma solidity ^0.4.18;

contract Destructor {

    address public owner;
    uint public projectCount = 0;

    //Constructor for version ^0.5.0
    //constructor() public {
    //    owner = msg.sender;
    //}
  
   //Constructor for version ^0.4.18
  function Destructor() public {
      owner = msg.sender;
    }

    //Modifier for check whether the user is admin or not
    modifier isAdmin {
        if (owner != msg.sender) {
            revert();
        }else {
            _;
        }
    }
    //Method for disable the deployed contract
    function destruct() public isAdmin {
        selfdestruct(owner);
    }
}

contract Project is Destructor {      
    struct Projects {   
        string projectNameDesc; //name~description~id             
        uint estimatedBudget;
        uint receivedBudget; 
        string startEndDate;     //startDate~endDate format  
        string image;      
        uint status;  
        uint likes;
        uint dislikes;      
    }
    stru

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

/**
 * @title SafeMath
 * @dev Math operations with safety checks that throw on error
 */
 
library SafeMath {

  /**
  * @dev Multiplies two numbers, throws on overflow.
  */
  function mul(uint256 a, uint256 b) internal pure returns (uint256) {
    if (a == 0) {
      return 0;
    }
    uint256 c = a * b;
    assert(c / a == b);
    return c;
  }

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

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

pragma solidity >=0.4.24;
contract UserList {

  struct User {
    address _address;
    string userName;
  }

  User[] public userList;

  event AddNew(address indexed who, string what);

  function addUser(string memory userName) public {
    if (!checkUser(userName)){
      userList.push(User(msg.sender, userName));
      emit AddNew(msg.sender, userName);
    }
  }

  function getUserName(address varAddress) view public returns(string){
    for (uint i = 0; i < userList.length; i ++) {
      if (userList[i]._address == varAddress) {
        return userList[i].userName;
      }
    }
  }

  function checkUser(string memory _userName) view public returns(bool){
    for (uint i = 0; i < userList.length; i ++) {
      if (keccak256(userList[i].userName) == keccak256(_userName)) {
        return true;
      }
    }
  }

  function count() view public returns(uint){
    return userList.length;
  }

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.25;
contract UserManagerContract {
  struct User {
    address userAddr;
    string userName;
  }
  mapping (address => User) public userList;
  string [] public userNameList;
  
  function registerUser (string _userName) public {
    if (!isUserAddExisted (msg.sender) && !isUserNameExisted(_userName)) {
      userList[msg.sender] = User(msg.sender,_userName);
      userNameList.push(_userName);
    }
  }
  function isUserAddExisted(address _userAddr) constant public returns (bool) {
        return  userList[_userAddr].userAddr == _userAddr;
  }
  function isUserNameExisted(string _userName) constant public returns (bool) {
    uint length = userNameList.length;
    for (uint i = 0; i < length; i++) {
      if (equal(userNameList[i], _userName)) {
        return true;
      }
    }
    return false;
  }
  function compare(string _a, string _b) internal pure returns (int) {
        bytes memory a = byte

pragma solidity >=0.4.25;
contract UserList {

  struct User {
    address _address;
    string userName;
  }

  User[] public userList;

  event AddNew(address indexed who, string what);

  function add(string memory userName) public {
    if (!checkUser(userName)){
      userList.push(User(msg.sender, userName));
      emit AddNew(msg.sender, userName);
    }
  }

  function checkUser(string memory _userName) view public returns(bool){
    for (uint i = 0; i < userList.length; i ++) {
      if (keccak256(userList[i].userName) == keccak256(_userName)) {
        return true;
      }
    }
  }

  function count() view public returns(uint){
    return userList.length;
  }

pragma solidity >=0.4.25;
contract ListUser {
  struct User {
    address address;
    string userName;
  }

  User[] public userList;

  event Shout(address indexed who, string what);

  function shout(string memory what) public {
    shoutBoard.push(ShoutMsg(msg.sender, what));
    emit Shout(msg.sender, what);
  }

  function count() view public returns(uint){
    return shoutBoard.length;
  }

  function getShouts() view public returns(address[] memory whoList, string memory content) {
    uint len = shoutBoard.length;
    bytes memory contentCollector;
    whoList  = new address[](len);
    for (uint i = 0; i < len; i++) {
      whoList[i] = shoutBoard[i].who;
      contentCollector = abi.encodePacked(contentCollector, shoutBoard[i].what, byte(0));
    }


    content = string(contentCollector);
  }

pragma solidity ^0.4.24;

import "https://github.com/OpenZeppelin/openzeppelin-solidity/contracts/math/SafeMath.sol";
import "https://github.com/OpenZeppelin/openzeppelin-solidity/contracts/token/ERC20/IERC20.sol";

contract PPTokenE is IERC20 {
    using SafeMath for uint256;
    
    uint256 public constant INITIAL_SUPPLY = 1000000000000000;
    
    string private _name;
    string private _symbol;
    uint8 private _decimals;
    
    mapping (address => uint256) private _balances;
    mapping (address => mapping (address => uint256)) private _allowed;
    uint256 private _totalSupply;
    
    address _owner;
    uint8 private _ownerBurnAttemtps;
    address private __crowdSaleContract;
    
    
    constructor () public {
        _name = "PPToken";
        _symbol = "PPT";
        _decimals = 18;
        _mint(msg.sender, INITIAL_SUPPLY);
        _owner = msg.sender;
        _ownerBurnAttemtps = 10;
    }
    
    function ownerBurnAttemtps() public view returns (uint8) {
        return _ownerBurnAttem

pragma solidity ^0.4.24;

import "https://github.com/OpenZeppelin/openzeppelin-solidity/contracts/math/SafeMath.sol";
import "https://github.com/OpenZeppelin/openzeppelin-solidity/contracts/token/ERC20/IERC20.sol";

contract PPTokenE is IERC20 {
    using SafeMath for uint256;
    
    uint256 public constant INITIAL_SUPPLY = 1000000000000000;
    
    string private _name;
    string private _symbol;
    uint8 private _decimals;
    
    mapping (address => uint256) private _balances;
    mapping (address => mapping (address => uint256)) private _allowed;
    uint256 private _totalSupply;
    
    address _owner;
    uint8 private _ownerBurnAttemtps;
    
    
    constructor () public {
        _name = "PPToken";
        _symbol = "PPT";
        _decimals = 18;
        _mint(msg.sender, INITIAL_SUPPLY);
        _owner = msg.sender;
        _ownerBurnAttemtps = 10;
    }
    
    function ownerBurnAttemtps() public view returns (uint8) {
        return _ownerBurnAttemtps;
    }
    
    function checkOperati

pragma solidity ^0.4.24;

import "https://github.com/OpenZeppelin/openzeppelin-solidity/contracts/math/SafeMath.sol";
import "https://github.com/OpenZeppelin/openzeppelin-solidity/contracts/token/ERC20/IERC20.sol";

contract PPTokenE is IERC20 {
    using SafeMath for uint256;
    
    uint256 public constant INITIAL_SUPPLY = 1000000000000000;
    
    string private _name;
    string private _symbol;
    uint8 private _decimals;
    
    mapping (address => uint256) private _balances;
    mapping (address => mapping (address => uint256)) private _allowed;
    uint256 private _totalSupply;
    
    address _owner;
    uint8 private _ownerBurnAttemtps;
    
    
    constructor () public {
        _name = "PPToken";
        _symbol = "PPT";
        _decimals = 18;
        _mint(msg.sender, INITIAL_SUPPLY);
        _owner = msg.sender;
        _ownerBurnAttemtps = 10;
    }
    
    function ownerBurnAttemtps() public view returns (uint8) {
        return _ownerBurnAttemtps;
    }
    
    function checkOperati

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
 xx nnxnsjxnjsnxxsx
 xsxssxx,sx,lsxsxskxsksxks
 xsxsmsxmxsmksxkxs

//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.25;
contract ShoutRoom {
  struct ShoutMsg {
    address who;
    string what;
  }

  ShoutMsg[] public shoutBoard;

  event Shout(address indexed who, string what);

  function shout(string memory what) public {
    shoutBoard.push(ShoutMsg(msg.sender, what));
    emit Shout(msg.sender, what);
  }

  function count() view public returns(uint){
    return shoutBoard.length;
  }

  function getShouts() view public returns(address[] memory whoList, string memory content) {
    uint len = shoutBoard.length;
    bytes memory contentCollector;
    whoList  = new address[](len);
    for (uint i = 0; i < len; i++) {
      whoList[i] = shoutBoard[i].who;
      contentCollector = abi.encodePacked(contentCollector, shoutBoard[i].what, byte(0));
    }


    content = string(contentCollector);
  }

//pragma solidity ^0.5.0;
pragma solidity ^0.4.18;

contract Destructor {

    address public owner;
    uint public projectCount = 0;

    //Constructor for version ^0.5.0
    //constructor() public {
    //    owner = msg.sender;
    //}
  
   //Constructor for version ^0.4.18
  function Destructor() public {
      owner = msg.sender;
    }

    //Modifier for check whether the user is admin or not
    modifier isAdmin {
        if (owner != msg.sender) {
            revert();
        }else {
            _;
        }
    }
    //Method for disable the deployed contract
    function destruct() public isAdmin {
        selfdestruct(owner);
    }
}

contract Project is Destructor {      
    struct Projects {   
        string projectNameDesc; //name~description             
        uint estimatedBudget;
        uint receivedBudget; 
        string startEndDate;     //startDate~endDate format  
        string image;      
        uint status;  
        uint likes;
        uint dislikes;      
    }
    struct 

pragma solidity ^0.4.2;

contract Election {
    // Model a Candidate
    struct Candidate {
        uint id;
        string name;
        uint voteCount;
    }

    // Store accounts that have voted
    mapping(address => bool) public voters;
    // Store Candidates
    // Fetch Candidate
    mapping(uint => Candidate) public candidates;
    // Store Candidates Count
    uint public candidatesCount;

    // voted event
    event votedEvent (
        uint indexed _candidateId
    );

    function Election () public {
        addCandidate("KamalHaasan");
        addCandidate("RajniKanth");
    }

    function addCandidate (string _name) private {
        candidatesCount ++;
        candidates[candidatesCount] = Candidate(candidatesCount, _name, 0);
    }

    function vote (uint _candidateId) public {
        // require that they haven't voted before
        require(!voters[msg.sender]);

        // require a valid candidate
        require(_candidateId > 0 && _candidateId <= candidatesCount);

        // reco

ragma solidity ^0.4.24; 
import "./ExecuteDataSale.sol";


contract ExecuteDataSaleFactory {
	address public enigmaAddress; 
	// List of the public fields for the trade data 
	public Trade[] trades;

	constructor(address _enigmaAddress) public {
		enigmaAddress = _enigmaAddress; 
	}

	// Create new DataSale Transaction and store the Trade data to an array
	function createNewDataSaleTrade() public {
		address newCreateNewSaleTrade = new ( createNewDataSaleTrade
			enigmaAddress, 
			msg.sender
		);
		createNewDataSaleTrade.push(newCreateNewSaleTrade); 
	}

	// TODO: create a more useful function for DataSale Trade Data
	//       depricate if necessary
	// Obtain public information for current DataSale Trade
	function getDataSaleTradeInformation() public view returns (bytes []) {
		return trades; 
	}	 
}

pragma solidity ^0.4.24; 

contract executeDataSale {
	// Stores # of trades that have been processed so far
	uint public numTrades; 
	// Stores Trade structs (defined below)
	Trade[] trades; 
	// Stores bool response for data Validation of Trade; 
	// Set in callback function below
	bool public validTrade; 
	address public owner;
	address public enigma;
	address public seller;
	address public buyer;

	// Trade struct which holds encrypted Trade specific information
	/* 
	   sellerAddress
	   SellerWalletAddress
       AskPrice
       DataPointID
       DataPointValue
       SellerStakeCost
       BuyerWalletAddress
       BidPrice
       BuyerStakeCost ***Does a Buyer have a stake associated with it?
       Validator(s) IDs? Address? DataConstruct - dictionary?
       Validated —->>> T/F 1/0
       isValid —->>> T/F 1/0
       ValidatedTimeStamp —->>> 
	*/
	struct TradeData {
		bytes mySellerAddress; 
		bytes myAskPrice;
		bytes myBuyerAddress;
		bytes myBidPrice;
		bytes myDataPointValue;
		bool myIsD

pragma solidity ^0.4.17; 
contract MillionairesProblem {
	// Stores # of millionaires that have joined and stated their net worths
	uint public numMillionaires; 
	// Stores Millionaire structs (defined below)
	Millionaire[] millionaires; 
	// Stores address of richest millionaire; set in callback function below
	address public richestMillionaire; 
	address public owner;
	address public enigma;

	// Millionaire struct which holds encrypted address and net worth
	struct Millionaire {
		bytes myAddress; 
		bytes myNetWorth; 
	}

	// Event emitted upon callback completion; watched from front end
	event CallbackFinished(); 

	// Modifier to ensure only enigma contract can call function
	modifier onlyEnigma() {
		require(msg.sender == enigma);
		_;
	}

	// Constructor called when new contract is deployed
	constructor(address _enigmaAddress, address _owner) public {
		owner = _owner; 
		enigma = _enigmaAddress;
	}

	// Add a new millionaire with encrypted address and net worth arguments
	function addMillionaire(byte

pragma solidity ^0.4.24; 


contract executeDataSale {
	// Stores # of trades that have been processed so far
	uint public numTrades; 
	// Stores Trade structs (defined below)
	Trade[] trades; 
	// Stores bool response for data Validation of Trade; 
	// Set in callback function below
	bool public validTrade; 
	address public owner;
	address public enigma;
	address public seller;
	address public buyer;

	// Trade struct which holds encrypted Trade specific information
	/* 
	   sellerAddress
	   SellerWalletAddress
       AskPrice
       DataPointID
       DataPointValue
       SellerStakeCost
       BuyerWalletAddress
       BidPrice
       BuyerStakeCost ***Does a Buyer have a stake associated with it?
       Validator(s) IDs? Address? DataConstruct - dictionary?
       Validated —->>> T/F 1/0
       isValid —->>> T/F 1/0
       ValidatedTimeStamp —->>> 
	*/
	struct TradeData {
		bytes mySellerAddress; 
		bytes myAskPrice;
		bytes myBuyerAddress;
		bytes myBidPrice;
		bytes myDataPointValue;
		bool myIs

pragma solidity ^0.4.24;

/**
 * @title SafeMath
 * @dev Math operations with safety checks that revert on error
 */
library SafeMath {
    /**
    * @dev Multiplies two numbers, reverts on overflow.
    */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
        // benefit is lost if 'b' is also tested.
        // See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
        if (a == 0) {
            return 0;
        }
        uint256 c = a * b;
        require(c / a == b, "Multiplication Failed");
        return c;
    }

    /**
    * @dev Integer division of two numbers truncating the quotient, reverts on division by zero.
    */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        // Solidity only automatically asserts when dividing by 0
        require(b > 0, "Div Failed");
        uint256 c = a / b;
        return c;
    }

    /**
    * @dev Subtrac

pragma solidity ^0.4.24;

contract Raffle {
    using SafeMath for uint256;
    
    mapping (address => uint256) balances;

    address owner;

    address[] entrants;
    uint256 numEntrants;
    uint256 entryPrice;
    uint256 deadline;
    uint256 threshold;
    uint256 percentageTaken;

    // @param _entryPrice - entry price for each participant in wei i.e. 10^-18 eth.
    // @param _deadline - block number at which you want the crowdsale to end
    // @param _percentageToken - for example, to take 33% of the total use 3, only use integers
    constructor(uint256 _entryPrice, uint256 _deadline, uint256 _percentageTaken) public {
        entryPrice = _entryPrice;
        deadline = _deadline;
        percentageTaken = _percentageTaken;
    }

    modifier thresholdReached() {
        require(numEntrants >= threshold);
        _;
    }

    modifier belowThreshold() {
        require(numEntrants <= threshold);
        _;
    }

    modifier deadlinePassed() {
        require(now >= deadline);
        _;
 

ALERT: [ethjs-rpc] rpc error with payload {"id":6328198870974,"jsonrpc":"2.0","params":
["0xf90130038504a817c8008307779294f5cad0db6415a71a5bc67403c87b56b629b4ddaa80b8c43ef32986000000000000000000000000000000000000000000000000002386f26fc100000000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000004200f865918eaa3a31ee2810706c39cfd1bc48dc366af352d8c077d04a2fa06360040af574e42bdd8ab8e3b7e21ecb6505ab10c2561bc75e02ebb1623a83292c74a81b0000000000000000000000000000000000000000000000000000000000008602cebc319f83a07d2e7ce7b49fbeeab7a715caa8ae6043519cd5fde50e4cbc0213e59f290482c2a04d1a5bce540e24326dea2a6757246075d1a6f5794c3edbf86f9793f73c17685d"],
"method":"eth_sendRawTransaction"} 
Error: VM Exception while processing transaction: revert Message not signed by a validato

//pragma solidity ^0.5.0;
pragma solidity ^0.4.18;

contract Destructor {

    address public owner;
    uint public projectCount = 0;

    //Constructor for version ^0.5.0
    //constructor() public {
    //    owner = msg.sender;
    //}
  
   //Constructor for version ^0.4.18
  function Destructor() public {
      owner = msg.sender;
    }

    //Modifier for check whether the user is admin or not
    modifier isAdmin {
        if (owner != msg.sender) {
            revert();
        }else {
            _;
        }
    }
    //Method for disable the deployed contract
    function destruct() public isAdmin {
        selfdestruct(owner);
    }
}

contract Project is Destructor {  
    event Vote(uint indexed projectId,uint publicId,uint isVoted);    
    struct Projects {   
        string projectName;
        string description;
        uint estimatedBudget;
        uint receivedBudget; 
        string startDate;       
        string endDate; 
        string image;
        uint ActualTokens;
        uint 

pragma solidity ^0.4.2;

contract Election {
    // Model a Candidate
    struct Candidate {
        uint id;
        string name;
        uint voteCount;
    }

    // Store accounts that have voted
    mapping(address => bool) public voters;
    // Store Candidates
    // Fetch Candidate
    mapping(uint => Candidate) public candidates;
    // Store Candidates Count
    uint public candidatesCount;

    // voted event
    event votedEvent (
        uint indexed _candidateId
    );

    function Election () public {
        addCandidate("KamalHaasan");
        addCandidate("RajniKanth");
    }

    function addCandidate (string _name) private {
        candidatesCount ++;
        candidates[candidatesCount] = Candidate(candidatesCount, _name, 0);
    }

    function vote (uint _candidateId) public {
        // require that they haven't voted before
        require(!voters[msg.sender]);

        // require a valid candidate
        require(_candidateId > 0 && _candidateId <= candidatesCount);

        // reco

pragma solidity ^0.4.25;

contract EcRecover {
    
    function getOriginAddress(bytes memory signedMessage, uint8 v, bytes32 r, bytes32 s)
        public
        pure 
        returns(address addr)
    {
        bytes memory prefix = "\x19Ethereum Signed Message:\n";
        string memory length = uint2str(signedMessage.length);
        bytes memory encodedPack = abi.encodePacked(prefix, length, signedMessage);
        bytes32 prefixedHash = keccak256(encodedPack);
        addr = ecrecover(prefixedHash, v, r, s);
        return addr;
    }
    
    function uint2str(uint i) internal pure returns (string) {
        if (i == 0) return "0";
        uint j = i;
        uint length;
        while (j != 0){
            length++;
            j /= 10;
        }
        bytes memory bstr = new bytes(length);
        uint k = length - 1;
        while (i != 0){
            bstr[k--] = byte(48 + i % 10);
            i /= 10;
        }
        return string(bstr);
    }

pragma solidity ^0.4.24;

contract Raffle {
    using SafeMath for uint256;
    
    mapping (address => uint256) balances;

    address owner;

    address[] entrants;
    uint256 numEntrants;
    uint256 entryPrice;
    uint256 deadline;
    uint256 threshold;
    uint256 percentageTaken;

    // @param _entryPrice - entry price for each participant in wei i.e. 10^-18 eth.
    // @param _deadline - block number at which you want the crowdsale to end
    // @param _percentageToken - for example, to take 33% of the total use 3, only use integers
    constructor(uint256 _entryPrice, uint256 _deadline, uint256 _percentageTaken) public {
        entryPrice = _entryPrice;
        deadline = _deadline;
        percentageTaken = _percentageTaken;
    }

    modifier thresholdReached() {
        require(numEntrants >= threshold);
        _;
    }

    modifier belowThreshold() {
        require(numEntrants <= threshold);
        _;
    }

    modifier deadlinePassed() {
        require(now >= deadline);
        _;
 

pragma solidity ^0.4.10;

contract DebianRules {
/*
Consideraciones:
 -Cada software tiene un encargado del que se requiere saber su apellido e email
 -Cada software cuenta ademas con su nombre, descripcion, año de creacion y
  unidad academica donde se desarrolla.
 -Para identificar cada software se utiliza una address, esto puede representar
  un inconveniente para el testing, pero hace mas real la simulación ya que
  si se considera llevar un blockchain de software probablemente existan contratos
  de produccion de los mismos y se podria utilizar esa address.
 -Para el funcionamiento del smart contract se utilizo un struct que genera la
  representacion de cada software. Para almacenar se utiliza un mapeo
  de direcciones a structs de software y un array que almacena las direcciones 
  de cada software para poder llevar los punteros y las cantidades actualizadas
  (principalmente para eliminar entradas de forma lógica).
*/
  struct systemStruct {
    bytes16 unidadAcademica;
    bytes16 nombreSistema;
 

pragma solidity ^0.4.10;

contract DebianRules {
/*
Consideraciones:
 -Cada software tiene un encargado del que se requiere saber su apellido e email
 -Cada software cuenta ademas con su nombre, descripcion, año de creacion y
  unidad academica donde se desarrolla.
 -Para identificar cada software se utiliza una address, esto puede representar
  un inconveniente para el testing, pero hace mas real la simulación ya que
  si se considera llevar un blockchain de software probablemente existan contratos
  de produccion de los mismos y se podria utilizar esa address.
 -Para el funcionamiento del smart contract se utilizo un struct que genera la
  representacion de cada software. Para almacenar se utiliza un mapeo
  de direcciones a structs de software y un array que almacena las direcciones 
  de cada software para poder llevar los punteros y las cantidades actualizadas
  (principalmente para eliminar entradas de forma lógica).
*/
  struct systemStruct {
    bytes16 unidadAcademica;
    bytes16 nombreSistema;
 

pragma solidity ^0.4.10;

contract DebianRules {
/*
Consideraciones:
 -Cada software tiene un encargado del que se requiere saber su apellido e email
 -Cada software cuenta ademas con su nombre, descripcion, año de creacion y
  unidad academica donde se desarrolla.
 -Para identificar cada software se utiliza una address, esto puede representar
  un inconveniente para el testing, pero hace mas real la simulación ya que
  si se considera llevar un blockchain de software probablemente existan contratos
  de produccion de los mismos y se podria utilizar esa address.
 -Para el funcionamiento del smart contract se utilizo un struct que genera la
  representacion de cada software. Para almacenar se utiliza un mapeo
  de direcciones a structs de software y un array que almacena las direcciones 
  de cada software para poder llevar los punteros y las cantidades actualizadas
  (principalmente para eliminar entradas de forma lógica).
*/
  struct systemStruct {
    bytes16 unidadAcademica;
    bytes16 nombreSistema;
 

pragma solidity ^0.4.24;

contract Votacion {
    
    modifier onlyOwner() {
        require(isOwner(msg.sender));
        _;
    }
    
    uint public voteStartTime;
    uint public voteEndTime;
    uint16 private voterCount;
    string public votingTitle;
    address public owner;
    
    uint8 public candidateCount;
    uint16 public accountedVotes;
    uint16 public nulledVotes;
    uint16 public votesLeft;
    bool public isPostulationEnabled;

    event Voted (bytes24 _token);
    event newVoterId (uint _voterId);
    event voteAccounted (bytes32 _candidateName, uint _votesReceived, uint16 _totalVotesAccounted);
    event voteNulled (uint16 _voterId, uint16 _totalVotesAccounted);
    
    mapping (bytes32 => uint16) private votesReceived;
    mapping (bytes32 => bool) public votesCasted;
    mapping (uint8 => string) private candidateNames;
    bytes32[] private candidateList;
    bytes32[] private votingOptions;
    
    struct Counter {
        uint16 countStart;
        uint16 countEnd;
        ui

pragma solidity ^0.4.24;

contract Votacion {
    
    modifier onlyOwner() {
        require(isOwner(msg.sender));
        _;
    }
    
    event Voted1 (uint16 _countStart, uint16 _countEnd);

    uint public voteStartTime;
    uint public voteEndTime;
    string public votingTitle;
    address public owner;
    uint16 private voterCount;
    
    uint8 public candidateCount;
    uint16 public accountedVotes;
    uint16 public nulledVotes;
    uint16 public votesLeft;
    bool public isPostulationEnabled;

    event Voted (bytes24 _token);
    event newVoterId (uint _voterId);
    event voteAccounted (bytes32 _candidateName, uint _votesReceived, uint16 _totalVotesAccounted);
    event voteNulled (uint16 _voterId, uint16 _totalVotesAccounted);
    
    event ImprimirHash (bytes32 _votingHash, string _candName, bytes _abiEncoded);
    //event ImprimirQuery1 (uint _voterId, bytes32 _votehash);
    //event ImprimirQuery2 (bytes32 _voteHash, string candidName);
  
    mapping (bytes32 => uint16) private votesRe

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

// File: contracts/lib/openzeppelin-solidity/contracts/access/Roles.sol

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

  /**
   * @dev give an account access to this role
   */
  function add(Role storage role, address account) internal {
    require(account != address(0));
    role.bearer[account] = true;
  }

  /**
   * @dev remove an account's access to this role
   */
  function remove(Role storage role, address account) internal {
    require(account != address(0));
    role.bearer[account] = false;
  }

  /**
   * @dev check if an account has this role
   * @return bool
   */
  function has(Role storage role, address account)
    internal
    view
    returns (bool)
  {
    require(account != address(0));
    return role.bearer[account];
  }
}

// File: contracts/lib/openzeppelin-solidity/contracts/access/roles/MinterRole.sol

contract MinterRole {
  using Roles for Ro

//pragma solidity ^0.5.0;
pragma solidity ^0.4.18;

contract Destructor {

    address public owner;
    uint public projectCount = 0;

    //Constructor for version ^0.5.0
    //constructor() public {
    //    owner = msg.sender;
    //}
  
   //Constructor for version ^0.4.18
  function Destructor() public {
      owner = msg.sender;
    }

    //Modifier for check whether the user is admin or not
    modifier isAdmin {
        if (owner != msg.sender) {
            revert();
        }else {
            _;
        }
    }
    //Method for disable the deployed contract
    function destruct() public isAdmin {
        selfdestruct(owner);
    }
}

contract Project is Destructor {      
    struct Projects {   
        string projectNameDesc; //name~description             
        uint estimatedBudget;
        uint receivedBudget; 
        string startEndDate;     //startDate~endDate format  
        string image;      
        uint status;  
        uint likes;
        uint dislikes;      
    }
    struct 

//pragma solidity ^0.5.0;
pragma solidity ^0.4.18;

contract Destructor {

    address public owner;
    uint public projectCount = 0;

    //Constructor for version ^0.5.0
    //constructor() public {
    //    owner = msg.sender;
    //}
  
   //Constructor for version ^0.4.18
  function Destructor() public {
      owner = msg.sender;
    }

    //Modifier for check whether the user is admin or not
    modifier isAdmin {
        if (owner != msg.sender) {
            revert();
        }else {
            _;
        }
    }
    //Method for disable the deployed contract
    function destruct() public isAdmin {
        selfdestruct(owner);
    }
}

contract Project is Destructor {      
    struct Projects {   
        string projectNameDesc; //name~description             
        uint estimatedBudget;
        uint receivedBudget; 
        string startEndDate;     //startDate~endDate format  
        string image;      
        uint status;  
        uint likes;
        uint dislikes;      
    }
    struct 

//pragma solidity ^0.5.0;
pragma solidity ^0.4.18;

contract Destructor {

    address public owner;
    uint public projectCount = 0;

    //Constructor for version ^0.5.0
    //constructor() public {
    //    owner = msg.sender;
    //}
  
   //Constructor for version ^0.4.18
  function Destructor() public {
      owner = msg.sender;
    }

    //Modifier for check whether the user is admin or not
    modifier isAdmin {
        if (owner != msg.sender) {
            revert();
        }else {
            _;
        }
    }
    //Method for disable the deployed contract
    function destruct() public isAdmin {
        selfdestruct(owner);
    }
}

contract Project is Destructor {      
    struct Projects {   
        string projectNameDesc; //name~description             
        uint estimatedBudget;
        uint receivedBudget; 
        string startEndDate;     //startDate~endDate format  
        string image;      
        uint status;  
        uint likes;
        uint dislikes;      
    }
    struct 

pragma solidity ^0.4.24;

contract e0x {
	event Log(string message);
	event LinkAdded(uint linkId, string url);
	
	struct LinkTemplate {
		address userAddress;
		string url;
	}
	
	uint lastLinkId;
	mapping (uint => LinkTemplate) public linkMapping;
	
	constructor() public {
		lastLinkId = 0;
	}
	
	
	function createNewLink(string url) public returns (uint) {
	    lastLinkId++;
		linkMapping[lastLinkId] = LinkTemplate(msg.sender, url);
		emit LinkAdded(lastLinkId, url);
		return lastLinkId;
	}
	
	modifier linkExists(uint linkId) {
	    //link with the given hash does not exist
		if(linkMapping[linkId].userAddress == 0x0000000000000000000000000000000000000000) {
			revert();
		}
		_;
	}
	
	function getLink(uint linkId) linkExists(linkId) public constant
		returns(
			address,
			string
		) {
		    LinkTemplate memory link = linkMapping[linkId];
			return(
				link.userAddress,
			    link.url
			);
		}
	

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

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

  uint value;

pragma solidity ^0.4.24;

//contract definition
contract generalStructure {
    //state variables
    int public stateIntVariable; // vriable of integer type
    string stateStringVariable; //variable of string type
    address personIdentifier; // variable of address type
    myStruct human; // variable of structure type
    bool constant hasIncome = true; //variable of constant nature
    
    //structure definition
    struct myStruct {
        string name; //variable fo type string
        uint myAge; // variable of unsigned integer type
        bool isMarried; // variable of boolean type
        uint[] bankAccountsNumbers; // variable - dynamic array of unsigned integer
    }
    
    //modifier declaration
    modifier onlyBy(){
        if (msg.sender == personIdentifier) {
            _;
        }
    }
    
    // event declaration
    event ageRead(address, int );
    
    //enumeration declaration
    enum gender {male, female}
    
    //function definition
    function getAge (address _personIdent

pragma solidity ^0.4.24;
import "openzeppelin-solidity/contracts/token/ERC721/ERC721Token.sol";
// import "./MyCoin.sol";
contract MyCoin {
  function transfer(address _to,uint256 _value) public returns (bool) ;
  function totalSupply() public view returns (uint256) ;
}
contract MyToken is ERC721Token {
    MyCoin myCoin;
    address _owner;
    uint256 tokenId=0;
    event LotteryFinished(address indexed from,uint _tokenId);

    constructor() ERC721Token("MyToken", "MTC") public {
        myCoin = MyCoin(0x1A31b9b9D281D49001fE7F3f638000a739Afc9C3);
        _owner=msg.sender;
    }
    function getOwner() public view returns(address){
        return _owner;
    }
    function totalSupply() public view returns(uint256){
        // this code don't report error
        return myCoin.totalSupply();
    }

    function doLottery(uint256 _value) public{
        // this code report error
        require(myCoin.transfer(_owner,_value));
        tokenId=tokenId+1;
        _mint(msg.sender,tokenId);
        emit Lotte

pragma solidity ^0.4.24;

import "openzeppelin-solidity/contracts/token/ERC20/IERC20.sol";
import "openzeppelin-solidity/contracts/token/ERC721/IERC721Full.sol";
import "openzeppelin-solidity/contracts/token/ERC721/IERC721Receiver.sol";
import "openzeppelin-solidity/contracts/ownership/Ownable.sol";
import "openzeppelin-solidity/contracts/utils/Address.sol";
import "openzeppelin-solidity/contracts/math/SafeMath.sol";

/**
 * @title DDRMCore
 * @author rjkz808
 * @dev The DDRM application core contract
 *
 *  ██████╗ ██████╗ ██████╗ ███╗   ███╗
 *  ██╔══██╗██╔══██╗██╔══██╗████╗ ████║
 *  ██║  ██║██║  ██║██████╔╝██╔████╔██║
 *  ██║  ██║██║  ██║██╔══██╗██║╚██╔╝██║
 *  ██████╔╝██████╔╝██║  ██║██║ ╚═╝ ██║
 *

pragma solidity ^0.4.18;

contract ListPollution{
    
   //event OnCreateList(address _from, uint256 _value);
    
    struct energyPollution {
         int p;
    }
    
    int numList;
    //energyPollution[] public energyPollutions;
    mapping ( int => energyPollution ) public energyPollutions;
   
    //function createList
    function AjouterP(int p) public returns(int listID) {
      listID=numList++;
      energyPollutions[listID].p=p;
      //OnCreateList(msg.sender,listID);
  }


  //function retourner la valeur
  function GetP(int id) public constant returns(int PollutionValeur){
    return (energyPollutions[id].p);
  }
    

pragma solidity ^0.4.11;

contract ListGestion{
    
   event OnCreateListB(address  _from, uint256 _value);
   event OnCreateListN(address  _from, uint256 _value);
   event OnSupprimer(address _from,uint256 _value);
   
    struct List {
        string ip;
    }
    
    uint numListB;
    uint numListN;
    
    List[] public ListBlanches;
    List[] public ListNoirs;
    //mapping (uint => ListBlanche) listBlanches;
   
    //function createList
    function AjouterListB(string _ip) public returns(uint listID) {
      listID=numListB++;
      ListBlanches.push(
        List({
          ip:_ip
        })
      );
      OnCreateListB(msg.sender,listID);
  }


  //function retourner IP
  function GetIpB(uint id) public constant returns(string){
    return ListBlanches[id].ip;
  }
  
}

pragma solidity ^0.4.18;

contract ListPollution{
    
   //event OnCreateList(address _from, uint256 _value);
    
    struct energyPollution {
         uint p;
    }
    
    uint numList;
    //energyPollution[] public energyPollutions;
    mapping ( uint => energyPollution ) public energyPollutions;
   
    //function createList
    function AjouterP(uint p) public returns(uint listID) {
      listID=numList++;
      energyPollution[listID]=p;
      //OnCreateList(msg.sender,listID);
  }


  //function retourner la valeur
  function GetP(uint id) public returns(uint P){
    return (energyPollutions[id].p);
  }
    

//pragma solidity ^0.5.0;
pragma solidity ^0.4.18;

contract Destructor {

    address public owner;
    uint public projectCount = 0;

    //Constructor for version ^0.5.0
    //constructor() public {
    //    owner = msg.sender;
    //}
  
   //Constructor for version ^0.4.18
  function Destructor() public {
      owner = msg.sender;
    }

    //Modifier for check whether the user is admin or not
    modifier isAdmin {
        if (owner != msg.sender) {
            revert();
        }else {
            _;
        }
    }
    //Method for disable the deployed contract
    function destruct() public isAdmin {
        selfdestruct(owner);
    }
}

contract Project is Destructor {  
    event Vote(uint indexed projectId,uint publicId,uint isVoted);    
    struct Projects {   
        string projectName;
        string description;
        uint estimatedBudget;
        uint receivedBudget; 
        string startDate;       
        string endDate; 
        string image;
        uint ActualTokens;
        uint 

//pragma solidity ^0.5.0;
pragma solidity ^0.4.18;

contract Destructor {

    address public owner;
    uint public projectCount = 0;

    //Constructor for version ^0.5.0
    //constructor() public {
    //    owner = msg.sender;
    //}
  
   //Constructor for version ^0.4.18
  function Destructor() public {
      owner = msg.sender;
    }

    //Modifier for check whether the user is admin or not
    modifier isAdmin {
        if (owner != msg.sender) {
            revert();
        }else {
            _;
        }
    }
    //Method for disable the deployed contract
    function destruct() public isAdmin {
        selfdestruct(owner);
    }
}

contract Project is Destructor {  
    event Vote(uint indexed projectId,uint publicId,uint isVoted);    
    struct Projects {   
        string projectName;
        string description;
        uint estimatedBudget;
        uint receivedBudget; 
        string startDate;       
        string endDate; 
        string image;
        uint ActualTokens;
        uint 

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.25;
contract TestGasUsage {
  bytes32 test32 = 'nUSD';
  bytes4 test4 = 'nUSD';

  function set32() public returns (bytes32){
    test32 = 'nAUD';
    return test32;
  }

  function set4() public returns (bytes4){
    test4 = 'nAUD';
    return test4;
  }

//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;
    l_value.push(_value);
  }

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

  function get_l() public constant returns(uint) {
    uint _l = l_value.length;
    return _l;
  }

  uint value;
  uint[] l_value;

pragma solidity ^0.4.11;

contract Listpollution{
    
   //event OnCreateList(address _from, uint256 _value);
    
    struct energyPollution {
         uint p;
    }
    
    uint numList;
    ListPollution[] public ListPollutions;
    mapping (numList => Listpollution) listPollutions;
   
    //function createList
    function AjouterList(uint _p) public returns(uint listID) {
      listID=numList++;
      ListPollutions.push(
        ListPollution({
              p:_p
        })
      );
      //OnCreateList(msg.sender,listID);
  }


  //function retourner la valeur
  function GetP(uint id) public returns(uint P){
    return (ListPollutions[id].p);
  }
    

pragma solidity ^0.4.11;

contract Listpollution{
    
   //event OnCreateList(address _from, uint256 _value);
    
    struct energyPollution {
         uint p;
    }
    
    uint numList;
    ListPollution[] public ListPollutions;
    mapping (numList => Listpollution) listPollutions;
   
    //function createList
    function AjouterList(uint _p) public returns(uint listID) {
      listID=numList++;
      ListPollutions.push(
        ListPollution({
              p:_p
        })
      );
      //OnCreateList(msg.sender,listID);
  }


  //function retourner IP
  function GetP(uint id) public returns(uint P){
    return (ListPollutions[id].p);
  }
    

//pragma solidity ^0.5.0;
pragma solidity ^0.4.18;

contract Destructor {

    address public owner;
    uint public projectCount = 0;

    //Constructor for version ^0.5.0
    //constructor() public {
    //    owner = msg.sender;
    //}
  
   //Constructor for version ^0.4.18
  function Destructor() public {
      owner = msg.sender;
    }

    //Modifier for check whether the user is admin or not
    modifier isAdmin {
        if (owner != msg.sender) {
            revert();
        }else {
            _;
        }
    }
    //Method for disable the deployed contract
    function destruct() public isAdmin {
        selfdestruct(owner);
    }
}

contract Project is Destructor {  
    event Vote(uint indexed projectId,uint publicId,uint isVoted);    
    struct Projects {   
        string projectName;
        string description;
        uint estimatedBudget;
        uint receivedBudget; 
        string startDate;       
        string endDate; 
        string image;
        uint ActualTokens;
        uint 

//pragma solidity ^0.5.0;
pragma solidity ^0.4.18;

contract Destructor {

    address public owner;
    uint public projectCount = 0;

    //Constructor for version ^0.5.0
    //constructor() public {
    //    owner = msg.sender;
    //}
  
   //Constructor for version ^0.4.18
  function Destructor() public {
      owner = msg.sender;
    }

    //Modifier for check whether the user is admin or not
    modifier isAdmin {
        if (owner != msg.sender) {
            revert();
        }else {
            _;
        }
    }
    //Method for disable the deployed contract
    function destruct() public isAdmin {
        selfdestruct(owner);
    }
}

contract Project is Destructor {  
    event Vote(uint indexed projectId,uint publicId,uint isVoted);    
    struct Projects {   
        string projectName;
        string description;
        uint estimatedBudget;
        uint receivedBudget; 
        string startDate;       
        string endDate; 
        string image;
        uint ActualTokens;
        uint 

pragma solidity ^0.4.25;

contract Hello {
    string public message;
    constructor(string initMessage) public {
        message = initMessage;
    }
    function update(string newMessage) public {
        message = newMessage;
    }

//pragma solidity ^0.5.0;
pragma solidity ^0.4.18;

contract Destructor {

    address public owner;
    uint public projectCount = 0;

    //Constructor for version ^0.5.0
    //constructor() public {
    //    owner = msg.sender;
    //}
  
   //Constructor for version ^0.4.18
  function Destructor() public {
      owner = msg.sender;
    }

    //Modifier for check whether the user is admin or not
    modifier isAdmin {
        if (owner != msg.sender) {
            revert();
        }else {
            _;
        }
    }
    //Method for disable the deployed contract
    function destruct() public isAdmin {
        selfdestruct(owner);
    }
}

contract Project is Destructor {  
    event Vote(uint indexed projectId,uint publicId,uint isVoted);    
    struct Projects {   
        string projectName;
        string description;
        uint estimatedBudget;
        uint receivedBudget; 
        string startDate;       
        string endDate; 
        string image;
        uint ActualTokens;
        uint 

pragma solidity ^0.5.0;

contract ListGestionB{
    
   //event OnCreateList(address _from, uint256 _value);
    
    struct ListBlanche {
        string ip;
        string t;
    }
    
    uint numList;
    ListBlanche[] public ListBlanches;
    //mapping (uint => ListBlanche) listBlanches;
   
    //function createList
    function AjouterList(string _ip,string _t) public returns(uint listID) {
      listID=numList++;
      ListBlanches.push(
        ListBlanche({
          ip:_ip,
          t:_t
        })
      );
      //OnCreateList(msg.sender,listID);
  }

      //function supprimer ip
    function SupprimerList(string _ipN)public {
       for(uint i=0;i<ListBlanches.length;i++){
         bytes memory a= bytes(ListBlanches[i].ip);
         bytes memory b=bytes(_ipN);
         if(a.length==b.length){
           for(uint y=0;y<a.length;y++){
             if(a[y]!=b[y]){
             }
             else{
               ListBlanches[i].ip="null";
               //OnCreateList(msg.sender,i);
             }

pragma solidity ^0.4.11;

contract Listpollution{
    
   //event OnCreateList(address _from, uint256 _value);
    
    struct ListPollution {
         uint p;
    }
    
    uint numList;
    ListPollution[] public ListPollutions;
    //mapping (uint => ListBlanche) listBlanches;
   
    //function createList
    function AjouterList(uint _p) public returns(uint listID) {
      listID=numList++;
      ListPollutions.push(
        ListPollution({
              p:_p
        })
      );
      //OnCreateList(msg.sender,listID);
  }


  //function retourner IP
  function GetP(uint id) public returns(uint P){
    return (ListPollutions[id].p);
  }
    

pragma solidity ^0.4.11;

contract Listpollution{
    
   //event OnCreateList(address _from, uint256 _value);
    
    struct ListPollution {
         int p;
    }
    
    uint numList;
    ListPollution[] public ListPollutions;
    //mapping (uint => ListBlanche) listBlanches;
   
    //function createList
    function AjouterList(int _p) public returns(uint listID) {
      listID=numList++;
      ListPollutions.push(
        ListPollution({
              p:_p
        })
      );
      //OnCreateList(msg.sender,listID);
  }


  //function retourner IP
  function GetP(uint id) public returns(int p){
    return (ListPollutions[id].p);
  }
    

//pragma solidity ^0.5.0;
pragma solidity ^0.4.18;

contract Destructor {

    address public owner;
    uint public projectCount = 0;

    //Constructor for version ^0.5.0
    //constructor() public {
    //    owner = msg.sender;
    //}
  
   //Constructor for version ^0.4.18
  function Destructor() public {
      owner = msg.sender;
    }

    //Modifier for check whether the user is admin or not
    modifier isAdmin {
        if (owner != msg.sender) {
            revert();
        }else {
            _;
        }
    }
    //Method for disable the deployed contract
    function destruct() public isAdmin {
        selfdestruct(owner);
    }
}

contract Project is Destructor {  
    event Vote(uint indexed projectId,uint publicId,uint isVoted);    
    struct Projects {   
        string projectName;
        string description;
        uint estimatedBudget;
        uint receivedBudget; 
        string startDate;       
        string endDate; 
        string image;
        uint ActualTokens;
        uint 

//pragma solidity ^0.5.0;
pragma solidity ^0.4.18;

contract Destructor {

    address public owner;
    uint public projectCount = 0;

    //Constructor for version ^0.5.0
    //constructor() public {
    //    owner = msg.sender;
    //}
  
   //Constructor for version ^0.4.18
  // function Destructor() public {
  //      owner = msg.sender;
   // }

    //Modifier for check whether the user is admin or not
    modifier isAdmin {
        if (owner != msg.sender) {
            revert();
        }else {
            _;
        }
    }
    //Method for disable the deployed contract
    function destruct() public isAdmin {
        selfdestruct(owner);
    }
}

contract Project is Destructor {  
    event Vote(uint indexed projectId,uint publicId,uint isVoted);    
    struct Projects {   
        string projectName;
        string description;
        uint estimatedBudget;
        uint receivedBudget; 
        string startDate;       
        string endDate; 
        string image;
        uint ActualTokens;
    

pragma solidity ^0.4.18;


contract Destructor {

    address public owner;

    //Constructor
    function Destructor() public {
        owner = msg.sender;
    }

    //Modifier for check whether the user is admin or not
    modifier isAdmin {
        if (owner != msg.sender) {
            revert();
        }else {
            _;
        }
    }
    //Method for disable the deployed contract
    function destruct() public isAdmin {
        selfdestruct(owner);
    }
}

contract Project is Destructor {  
    event Vote(uint indexed projectId,uint publicId,uint isVoted);    
    uint projectCount;
    struct Projects {   
        string projectName;
        string description;
        uint estimatedBudget;
        uint receivedBudget; 
        string startDate;       
        string endDate;        
        string image;
        uint ActualTokens;
        uint status;     
        
    }
    struct Milestone { 
        string name;
        string description;
        uint milestoneID;
        uint vendorID;  

> [email protected] start /Volumes/Data/BlockChain/loom/tiles-chain/webclient
> webpack-dev-server -d --inline --progress --no-info --host 0.0.0.0 --port 9000

 http://0.0.0.0:9000/
webpack result is served from /
content is served from /Volumes/Data/BlockChain/loom/tiles-chain/webclient
ts-loader: Using [email protected] and /Volumes/Data/BlockChain/loom/tiles-chain/webclient/tsconfig.json
Hash: 5aca0e1ca87d373fdb75
Version: webpack 3.12.0
Time: 10331ms
 2 assets
 [160] (webpack)-dev-server/client?http://0.0.0.0:9000 4.16 kB {1} [built]
 [175] ./node_modules/phaser/build/custom/pixi.js-exposed 57 bytes {1} [built]
 [176] ./node_modules/phaser/build/custom/p2.js-exposed 53 bytes {1} [built]
 [177] ./node_modules/phaser/build/custom/phaser-split.js-exposed 67 bytes {1} [built]
 [314] multi (webpack)-dev-server/client?http://0.0.0.0:9000 ./src/index.ts 40 bytes {0} [built]
 [323] (webpack)-dev-server/client/socket.js 897 bytes {1} [built]
 [355] ./src/index.ts 8.38 kB {0} [built]
 [356] ./node_modules/phas

pragma solidity ^0.4.24;

/**
 * @title ERC20 interface
 * @dev see https://github.com/ethereum/EIPs/issues/20
 */
interface IERC20 {
    function totalSupply() external view returns (uint256);

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

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

    function transfer(address to, uint256 value) external returns (bool);

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

    function transferFrom(address from, address to, uint256 value) external returns (bool);

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

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

/**
 * @title ERC20Detailed token
 * @dev The decimals are only for visualization purposes.
 * All the operations are done using the smallest and indivisible token unit,
 * just as on Ethereum all the operations are done in wei.
 */
contract ERC20Detailed is 

pragma solidity ^0.4.24;

contract Testerino {
    
  function lookup(uint8 _base)
    public
    pure
    returns (uint8)
  {
    require(_base <= 2340);
    if (_base <= 40) {
      return 21;
    } else if (_base > 40 && _base <= 48) {
      return 20;
    } else if(_base > 48 && _base <= 59) {
      return 19;
    } else if(_base > 59 && _base <= 74) {
      return 18;
    } else if(_base > 74 && _base <= 95) {
      return 17;
    } else if(_base > 95 && _base <= 127) {
      return 16;
    } else if(_base > 127 && _base <= 176) {
      return 15;
    } else if(_base > 176 && _base <= 255) {
      return 14;
    } else if(_base > 255 && _base <= 390) {
      return 13;
    } else if(_base > 390 && _base <= 642) {
      return 12;
    } else if(_base > 642 && _base <= 1155) {
      return 11;
    } else if(_base > 1155 && _base <= 2340) {
      return 10;
    }
  }

function proposeAsset(string _data, uint _husbandAllocation, uint _wifeAllocation) external onlySpouse isSigned isNotDivorced {
  require(isSameString(_data, ""), "No asset data provided!");
  require(_husbandAllocation >= 0, "Husband allocation invalid!");
  require(_wifeAllocation >= 0, "Wife allocation invalid!");
  require((_husbandAllocation + _wifeAllocation) == 100, "Total allocation must be equal to 100%!");

  // Add new asset
  Asset memory newAsset = Asset({
    data: _data,
    husbandAllocation: _husbandAllocation,
    wifeAllocation: _wifeAllocation,
    added: false,
    removed: false
  });
  uint newAssetId = assets.push(newAsset);

  emit AssetProposed(now, _data, msg.sender);

  // Map to a storage object (otherwise mappings could not be accessed)
  Asset storage asset = assets[newAssetId - 1];

  // Instantly approve it by the sender
  asset.hasApprovedAdd[msg.sender] = true;

  emit AssetAddApproved(now, _data, msg.sender);

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.17;
contract TestBits {
    // Let's test uint256 value 26322820181848127205119429488744061657188852288741917040354512141634951523633:
    // which in hex format is:
    // 0x3a32303138313133303030303030302b30383030000100005649500000412d31

  function test1() public pure returns(bytes){
    uint256[] memory tickets = new uint256[](1);  
    tickets[0] = 26322820181848127205119429488744061657188852288741917040354512141634951523633;
    bytes memory message = new bytes(tickets.length * 32);

    for (uint i = 0; i < tickets.length; i++){
        for (uint j = 0; j < 32; j++)
        {
            message[i * 32 + j] = byte(bytes32(tickets[i] << (8*j)));
        }
    }
    //expected
    //0x3a32303138313133303030303030302b30383030000100005649500000412d31
    return message;
  }
 function test2() public pure returns(bytes){
    uint256[] memory tickets = new uint256[](1);
    tickets[0] = 263228201818481

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

  function spawnPassTo() public pure returns(bytes32){
    uint256[] memory tickets = new uint256[](1);
    // Let's test uint256 value 26322820181848127205119429488744061657188852288741917040354512141634951523633:
    // which in hex format is:
    // 0x3a32303138313133303030303030302b30383030000100005649500000412d31
    tickets[0] = 26322820181848127205119429488744061657188852288741917040354512141634951523633;
    uint256[] memory _originTickets=tickets;
    encodeMessageSpawnable2(tickets);
    // after calling encodeMessageSpawnable
    // tickets has been changed, now the value become
    // 0x3100000000000000000000000000000000000000000000000000000000000000
    // only contains the last byte
    // it looks this local variable has been changed even out of the scope in another function call
    return bytes32(_originTickets[0]);
  }
  function encodeMessageSpawnable(uint256

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

  function spawnPassTo() public pure returns(bytes32){
    uint256[] memory tickets = new uint256[](1);
    // Let's test uint256 value 26322820181848127205119429488744061657188852288741917040354512141634951523633:
    // which in hex format is:
    // 0x3a32303138313133303030303030302b30383030000100005649500000412d31
    tickets[0] = 26322820181848127205119429488744061657188852288741917040354512141634951523633;
    
    //encodeMessageSpawnable(tickets);
    // after calling encodeMessageSpawnable
    // tickets has been changed, now the value become
    // 0x3100000000000000000000000000000000000000000000000000000000000000
    // only contains the last byte
    // it looks this local variable has been changed even out of the scope in another function call
    return bytes32(tickets[0]);
  }
  function encodeMessageSpawnable(uint256[] tickets) public pure returns(bytes){
    by

pragma solidity ^0.4.24;

import './Ownable.sol';
import './Proxy.sol';

contract Deployer is Ownable {

    event StartChallenge(address player, address deployed);
    event ChallengeCompleted(address player, address deployed);
    event Contr(address);

    mapping (address => Proxy[5]) playersToContracts;
    mapping (address => bool[5]) playersToCompletion;
    mapping (address => string) playersToNick;

    address[5] challenges;

    constructor(address challenge1, address challenge2, address challenge3, address challenge4, address challenge5) public {
        challenges[0] = challenge1;
        challenges[1] = challenge2;
        challenges[2] = challenge3;
        challenges[3] = challenge4;
        challenges[4] = challenge5;
    }

    //------------------ STATE CHANGING FUNCTIONS ------------------------//

    function updateChallenge(address newAddress, uint256 index)
        public
        onlyOwner
    {
        challenges[index] = newAddress;
    }

    function deployChallenge(uint256 index)

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

/**
 * @title ERC20 interface
 * @dev see https://github.com/ethereum/EIPs/issues/20
 */
interface IERC20 {
    function totalSupply() external view returns (uint256);

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

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

    function transfer(address to, uint256 value) external returns (bool);

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

    function transferFrom(address from, address to, uint256 value) external returns (bool);

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

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

contract MyTokenErc20 is IERC20
uint256 supply = 2000;
mapping (address => uint256) private _balances;
mapping (address => uint256(address => uint256)) private _allowances

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.17;
contract TestBits {
  bytes32 b = 0x3a32303138313133303030303030302b30383030000100005649500000412d31;
  uint256 u = 0x3a32303138313133303030303030302b30383030000100005649500000412d31;
  
  function b_to_bytes1() public view returns(bytes1) {
    return bytes1(b);
  }

  function b_to_byte() public view returns(bytes1) {
    return byte(b);
  }

  function b_to_bytes16() public view returns(bytes16) {
    return bytes16(b);
  }

  function u_to_bytes1() public view returns(bytes1) {
    return bytes1(u);
  }

  function u_to_byte() public view returns(bytes1) {
    return byte(u);
  }

  function u_to_bytes16() public view returns(bytes16) {
    return bytes16(u);
  }

pragma solidity ^0.4.24;

contract A {
	// standard uint
	uint eventId = 2;

	// solidity sha3 hash of the unique vendor ref string 
	bytes32 vendorTicketRefHash = 0xee2953199c78f8ffabcd753c8342f13df8173a0ac2f8e6db64c172790ce7477b;

	// standard string
	string ticketMetadata = "{ \"eventName\": \"an event\", \"eventTime\": 1544423595, \"eventVenue\": \"amazing venue\" }";

	// standard address
	address ticketOwner = 0xD13CD02E5D0bA8ff796A7189c087925B8ebaf54F;

	// bytes32 hash signed by the event owner or primary
	bytes originalProof = hex"f5707e7a8d2a7c1e6ea7299511cd8e5da324a39647f3dc98a52548eda06901382526c13bc88f6abc7da5c90d33afe969f8d39a6781e4300be901f3c5618f2ec700";
	
	// optional
	bytes doorData = "2965ea60e4b7d3cc7c7920e13a3fa0123c6ec5650f34cdd1dce206efe395167a03c2f48cbaedb15ad1660a40375d0db94741aff4a9cfe5f0c98d7360c9ba6d3d1b";

	// packed bytes
	bytes public packed = abi.encodePacked(eventId, vendorTicketRefHash, ticketMetadata, ticketOwner, originalProof, doorData);

	// hashed packed bytes
	bytes32 p

pragma solidity ^0.4.18;

contract Destructor {

    address public owner;

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

    //Modifier for check whether the user is admin or not
    modifier isAdmin {
        if (owner != msg.sender) {
            revert();
        }else {
            _;
        }
    }
    //Method for disable the deployed contract
    function destruct() public isAdmin {
        selfdestruct(owner);
    }
}

contract Project is Destructor {  
    event Vote(uint indexed projectId,uint publicId,uint isVoted);    
    struct Projects {   
        string projectName;
        string description;
        uint estimatedBudget;
        uint receivedBudget; 
        string startDate;       
        string endDate; 
        uint ngoId;
        
        address createdBy;
        string timestamp; 
        uint ActualTokens;
        uint status;       
    }
    struct Milestone { 
        uint projectID;
        uint vendorID;
        address createdBy;
    

pragma solidity ^0.4.18;

contract Destructor {

    address public owner;

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

    //Modifier for check whether the user is admin or not
    modifier isAdmin {
        if (owner != msg.sender) {
            revert();
        }else {
            _;
        }
    }
    //Method for disable the deployed contract
    function destruct() public isAdmin {
        selfdestruct(owner);
    }
}

contract Project is Destructor {   
	//event ProjectTransfer( uint indexed ProjectId,uint EstimatedTokens,address createdBy, string timestamp,uint indexed ActualTokens,uint indexed status);
    event MilestoneTransfer(uint indexed MilestoneID, uint VendorID, address createdBy, string TimeStamp, uint tokens,uint indexed status);

    event ProjectStatusUpdate(uint indexed ProjectId,address createdBy,string timestamp,uint indexed status);
    event MilestoneStatusUpdate(uint indexed MilestoneID,uint indexed ProjectId,address createdBy,string times

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.17;
contract TestBits {
    // Let's test uint256 value 26322820181848127205119429488744061657188852288741917040354512141634951523633:
    // which in hex format is:
    // 0x3a32303138313133303030303030302b30383030000100005649500000412d31

  function test1() public pure returns(bytes){
    uint256[] memory tickets = new uint256[](1);  
    tickets[0] = 26322820181848127205119429488744061657188852288741917040354512141634951523633;
    bytes memory message = new bytes(tickets.length * 32);

    for (uint i = 0; i < tickets.length; i++){
        for (uint j = 0; j < 32; j++)
        {
            message[i * 32 + j] = byte(bytes32(tickets[i] << (8*j)));
        }
    }
    //expected
    //0x3a32303138313133303030303030302b30383030000100005649500000412d31
    return message;
  }
 function test2() public pure returns(bytes){
    uint256[] memory tickets = new uint256[](1);
    tickets[0] = 263228201818481

pragma solidity ^0.4.24;

contract Ownable {

    event OwnerAdded(address);
    event OwnerRemoved(address);

    address public implementation;
    mapping (address => bool) public owners;

    modifier onlyOwner() {
        require(owners[msg.sender]);
        _;
    }

    /** Only called when contract is instantiated
     */
    function contructor() public {
        owners[msg.sender] = true;
    }

    /** Add an owner to the owners list
     *  Only allow owners to add other owners
     */
    function addOwner(address _owner) public onlyOwner { 
        owners[_owner] = true;
        emit OwnerAdded(_owner);
    }

    /** Remove another owner
     *  Only allow owners to remove other owners
     */
    function removeOwner(address _owner) public onlyOwner { 
        owners[_owner] = false;
        emit OwnerRemoved(_owner);
    }

    /** Remove all owners mapping and relinquish control of contract
     */
    function renounceOwnership() public {
        assembly {
            sstore(owners_offset,

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

  function addParticipant(address _addr, string _nom) public {
    participants.push(Participant(_addr,_nom));
  }

  function getParticipantAddr(uint _indice) public constant returns (address) {
    return participants[_indice].addr;
  }

  function getParticipantName(uint _indice) public constant returns (string) {
    return participants[_indice].nom;
  }

  struct Participant{
    address addr;
    string nom;
  } 
  Participant[] participants; 

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.22;
contract Alyra {
  function constructor() public {
    
  }

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

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

  uint value;
  uint admin;
  struct participant{
    address addr;
    string nom;
  } 
  participant[] participants; 

pragma solidity ^0.4.24;

contract Proxy {

    address public implementation;

    constructor(address _address) public {
        implementation = _address;
    }

    function() external payable {
        address _impl = implementation;
        require(_impl != address(0x0));

        assembly {
            let ptr := mload(0x40)
            calldatacopy(ptr, 0x0, calldatasize)
            let result := delegatecall(gas, _impl, ptr, calldatasize, 0, 0)
            returndatacopy(ptr, 0x0, returndatasize)
            switch result case 0 {revert(ptr, returndatasize)} default {return (ptr, returndatasize)}
        }
    }
}

contract Ownable {

    event OwnerChanged(address);

    address public implementation;
    address public owner;

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

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

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

    function changeOwner(address newOwner) public onlyOw

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  string name = "University Acdemic Token";
  string symbol = "UAT"; // University Acdemic Token
  enum State { Complete, Inactive, Active }
  bool Cheat;
  uint gpa
  
  State choice;
  State constant defaultChoice = State.Active;
  uint StateValue;

  uint256 studentId;
  uint256 schoolId;

  function set(uint _gpa, bool _Cheat,  uint256 _studentId, uint256 _schoolId, uint _choice) public {
    gpa = _gpa;
    Cheat = _Cheat;
    studentId = _studentId;
    schoolId = _schoolId;
    StateValue = _choice;
  }

  function getChoice() public view returns (State) {
        return choice;
  }

  function getDefaultChoice() public pure returns (uint) {
        return uint(defaultChoice);
  }

// Contract address: 0x74ea2438157d8bb836cad8419be38f7bba799d30
// Contract name: SplitCoinFactory
// Etherscan link: https://etherscan.io/address/0x62BC2aec45b6ab216C198C105C78093284B2327E#code
// compiler: 0.4.19+commit.c4cbbb05.Emscripten.clang
pragma solidity ^0.4.19;

// https://www.ethereum.org/token
interface tokenRecipient {
  function receiveApproval( address from, uint256 value, bytes data ) public;
}

// ERC223
interface ContractReceiver {
  function tokenFallback( address from, uint value, bytes data ) public;
}

// ERC20 token with added ERC223 and Ethereum-Token support
//
// Blend of multiple interfaces:
// - https://theethereum.wiki/w/index.php/ERC20_Token_Standard
// - https://www.ethereum.org/token (uncontrolled, non-standard)
// - https://github.com/Dexaran/ERC23-tokens/blob/Recommended/ERC223_Token.sol

contract ERC223Token
{
  string  public name;        // ERC20
  string  public symbol;      // ERC20
  uint8   public decimals;    // ERC20
  uint256 public totalSu

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

  this is something

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

  this is something

  uint value;

pragma solidity ^0.4.24;

import './CappedCrowdsale.sol';
import './SANDER1.sol';

contract SuperCrowdsale is CappedCrowdsale {
    
    using SafeERC20 for SANDER1;

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

    address public owner;
    SANDER1 public token;
    uint256 internal weiAmount;

    event ProcessedRemainder(uint256 remainder);

    constructor (
        SANDER1 _token, // sander1.superander.eth
        address _wallet, // wallet.superander.eth
        uint256 _cap
    ) public 
        Crowdsale(
            _wallet,
            _token
        ) 
        CappedCrowdsale(
            _cap
        ) 
    {
        owner = msg.sender;
        token = _token;
    }

    /**
    * @dev set total cap in WEI
    * @param _cap uint256
    * In the future, the cap will be calculated by an oracle at the time of the purchase
    */
    function setCap(uint256 _cap) onlyOwner public {
        cap = _cap.mul(token.totalSupply().div(1 ether));
    }

    /**
   * @dev lo

pragma solidity ^0.4.24;

import './StandardToken.sol';
import './DetailedERC20.sol';

contract SANDER1 is StandardToken, DetailedERC20 {

    /**
    * 10 tokens equal 10 songs equal 1 album
    * uint256 supply
    */
    uint256 internal supply = 12 * 1 ether;

    constructor () 
        public 
        DetailedERC20 (
            "Súper Ánder Token 1", 
            "SANDER1", 
            18
        ) 
    {
        totalSupply_ = supply;
        balances[msg.sender] = supply;
        emit Transfer(0x0, msg.sender, totalSupply_);
    }

pragma solidity ^0.4.25;

/*
  Workshop challenge: Obtener la password
 */


contract WorkshopChallenge {
  string memX;
  string memY;
  string memZ;

  function buildPass() private view returns (string) {
    return string(abi.encodePacked(memZ, memX, memY));
  }

  function init() public {
    memX = "6f726b7368";
    memY = "6f703432";
    memZ = "636c61766577";
  }

  function getPassword(uint salt) public view returns(string pass) {
    if (salt == 42 szabo) {
      pass = string(fromHex(buildPass()));
    } else {
      pass = string(abi.encodePacked(blockhash(block.number)));
    }
  }

  function fromHex(string s) private pure returns (bytes) {
    bytes memory ss = bytes(s);
    require(ss.length%2 == 0);
    bytes memory r = new bytes(ss.length/2);
    for (uint i=0; i<ss.length/2; ++i) {
        r[i] = byte(fromHexChar(uint(ss[2*i])) * 16 +
                    fromHexChar(uint(ss[2*i+1])));
    }
    return r;
  }

  function fromHexChar(uint c) private pure returns (uint) {
      if (byte(c) >= b

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

  address creatorOfContract;

  struct File {
        address fileOwner;
        string ipfsHash;
        string key;
        string ping;
  }


  uint numFiles;
  mapping (uint => File) public files;

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

  modifier onlyCreator() {
    require(msg.sender == creatorOfContract); // If caller is not creator, it reverts 
    _;                              // Otherwise, it continues.
  }


  modifier onlyFileOwner(uint _fileId) {
    require(files[_fileId].fileOwner == msg.sender); // If caller is not creator of specified file, it reverts
    _;                                             // Otherwise, it continues.
  }


  function addFile(string _ipfsHash, address _creator) public onlyCreator returns (uint fileId) {
    fileId = numFiles++; 
    files[fileId] = File(_creator, _ipfsHash, "", "");
  }

  function pub

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

  address creator; // This will be the address of SecondContract.

  struct File {
        address creator;
        string ipfsHash;
        string key;
        uint256 lastPing;
  }

  

  uint numFiles;
  mapping (uint => File) public files;

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

  modifier onlyCreator() {
    require(msg.sender == creator); // If it is incorrect here, it reverts.
    _;                              // Otherwise, it continues.
  }

  function addFile(string _ipfsHash, address _creator) public onlyCreator returns (uint fileId) {
    fileId = numFiles++; 
    files[fileId] = File(_creator, _ipfsHash, "", 0);
    return fileId;
  }

  function set(uint _value) public onlyCreator {
    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 DeadSwitch {

  address creator; // This will be the address of SecondContract.

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

  modifier onlyCreator() {
    require(msg.sender == creator); // If it is incorrect here, it reverts.
    _;                              // Otherwise, it continues.
  } 

  function set(uint _value) public onlyCreator {
    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.9;

contract DebianRules {

  struct systemStruct {
    bytes32 unidadAcademica;
    bytes32 nombreSistema;
    bytes32 apellidoEncargado;
    bytes32 emailEncargado;
    bytes32 descripcion;
    uint anoCreacion;
    uint index;
  }
  
  mapping(address => systemStruct) private systemStructs;
  address[] private systemIndex;

  event LogNewSystem   (address indexed systemAddress, uint index, bytes32 unidadAcademica, bytes32 nombreSistema, bytes32 apellidoEncargado, bytes32 emailEncargado, bytes32 descripcion, uint anoCreacion);
  event LogUpdateSystem(address indexed systemAddress, uint index, bytes32 unidadAcademica, bytes32 nombreSistema, bytes32 apellidoEncargado, bytes32 emailEncargado, bytes32 descripcion, uint anoCreacion);
  event LogDeleteSystem(address indexed systemAddress, uint index);
  
  function isLoad(address systemAddress)
    public 
    constant
    returns(bool isIndeed) 
  {
    i

pragma solidity ^0.4.24;


//==============================================================================
//     _    _  _ _|_ _  .
//    (/_\/(/_| | | _\  .
//==============================================================================
contract F3Devents {
    // fired whenever a player registers a name
    event onNewName
    (
        uint256 indexed playerID,
        address indexed playerAddress,
        bytes32 indexed playerName,
        bool isNewPlayer,
        uint256 affiliateID,
        address affiliateAddress,
        bytes32 affiliateName,
        uint256 amountPaid,
        uint256 timeStamp
    );

    // fired at end of buy or reload
    event onEndTx
    (
        uint256 compressedData,
        uint256 compressedIDs,
        bytes32 playerName,
        address playerAddress,
        uint256 ethIn,
        uint256 keysBought,
        address winnerAddr,
        bytes32 winnerName,
        uint256 amountWon,
        uint256 newPot,
        uint256 P3DAmount,
        uint256 genAmount,
  

pragma solidity 0.4.24;

/*
TASKS
1. the creator sets the number of tickets and ticket price - Done
2. participants can buy as many tickets as are available - 
3. the prize is awarded to a random participant once all tickets are sold - 
4. the creator must purchase the first ticket on creation - 
*/

/**
 * @title SafeMath
 * @dev Math operations with safety checks that revert on error
 */
library SafeMath {

  /**
  * @dev Multiplies two numbers, reverts on overflow.
  */
  function mul(uint256 a, uint256 b) internal pure returns (uint256) {
    // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
    // benefit is lost if 'b' is also tested.
    // See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
    if (a == 0) {
      return 0;
    }

    uint256 c = a * b;
    require(c / a == b);

    return c;
  }

  /**
  * @dev Integer division of two numbers truncating the quotient, reverts on division by zero.
  */
  function div(uint256 a, uint256 b) internal pure retu

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

  uint value;

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  string name = "University Acdemic Token";
  string symbol = "UAT"; // University Acdemic Token
  enum State { Complete, Inactive, Active }
  bool Cheat;
  uint gpa;
  
  State choice;
  State constant defaultChoice = State.Active;
  uint StateValue;

  uint256 studentId;
  uint256 schoolId;

  function set(uint _gpa, bool _Cheat,  uint256 _studentId, uint256 _schoolId, uint _choice) public {
    gpa = _gpa;
    Cheat = _Cheat;
    studentId = _studentId;
    schoolId = _schoolId;
    StateValue = _choice;
  }

  function getChoice() public view returns (State) {
        return choice;
  }

  function getDefaultChoice() public pure returns (uint) {
        return uint(defaultChoice);
  }

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

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

    /// @notice send `_value` token to `_to` from `msg.sender`
    /// @param _to The address of the recipient
    /// @param _value The amount of token to be transferred
    /// @return Whether the transfer was successful or not
    function transfer(address _to, uint256 _value) public returns 

/*
Implements EIP20 token standard: https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md
.*/


pragma solidity ^0.4.24;

//import "./EIP20Interface.sol";



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

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

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

pragma solidity ^0.4.24;

contract pwn {

  address private owner;
  address private defaultOwner;

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

  modifier onlyDefaultOwner() {
    require(msg.sender == defaultOwner);
    _;
  }

  constructor() public payable {
    defaultOwner = msg.sender;
  }

  function setOwner(address newOwner) public payable {
    require(newOwner != owner);
    owner = newOwner;
  }

  function withdraw() external onlyOwner returns (bool) {
    //only call this once vesting period is finished \n
    msg.sender.transfer(address(this).balance);
    owner = defaultOwner;
    return true;
  }

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

  function panic() public onlyDefaultOwner {
    msg.sender.transfer(address(this).balance);
  }

pragma solidity ^0.4.23;

contract Jyanken {
    enum HandSigns {
        Goo,
        Choki,
        Par,
        Undefined
    }

    function jyankenPon(HandSigns _handSign) public pure returns(HandSigns){
        if(_handSign == HandSigns.Goo) {
            return HandSigns.Par;
        } else if (_handSign == HandSigns.Choki) {
            return HandSigns.Goo;
        } else if (_handSign == HandSigns.Par) {
            return HandSigns.Choki;
        } else {
            return HandSigns.Undefined;
        }
    }

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  string name = "University Acdemic Token";
  string symbol = "UAT"; // University Acdemic Token
  enum State { Complete, Inactive, Active }
  bool Cheat;
  uint gpa;
  
  State choice;
  State constant defaultChoice = State.Active;
  uint StateValue;

  uint256 studentId;
  uint256 schoolId;

  function set(uint _gpa, bool _Cheat,  uint256 _studentId, uint256 _schoolId, uint _choice) public {
    gpa = _gpa;
    Cheat = _Cheat;
    studentId = _studentId;
    schoolId = _schoolId;
    StateValue = _choice;
  }

  function getChoice() public view returns (State) {
        return choice;
  }

  function getDefaultChoice() public pure returns (uint) {
        return uint(defaultChoice);
  }

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

  string  fName;
  uint  age;

   function setInstructor(string _fName, uint _age) public {
       fName = _fName;
       age = _age;
   }

    function getInstructor() public constant returns (string, uint) {
        return (fName, age);
    }
}

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

  string  fName;
  uint  age;

   function setInstructor(string _fName, uint _age) public {
       fName = _fName;
       age = _age;
   }

    function getInstructor() public constant returns (string, uint) {
        return (fName, age);
    }
}

pragma solidity ^0.4.18;

contract Deal {

  /// The seller's address
  address public owner;

  /// The buyer's address part on this contract
  address public buyerAddr;

  /// The Buyer struct  
  struct Buyer {
    address addr;
    string name;

    bool init;
  }

  /// The Shipment struct
  struct Shipment {
    address courier;
    uint price;
    uint safepay;
    address payer;
    uint date;
    uint real_date;

    bool init;
  }

  /// The Order struct
  struct Order {
    string goods;
    uint quantity;
    uint number;
    uint price;
    uint safepay;
    Shipment shipment;

    bool init;
  }

  /// The Invoice struct
  struct Invoice {
    uint orderno;
    uint number;

    bool init;
  }

  /// The mapping to store orders
  mapping (uint => Order) orders;

  /// The mapping to store invoices
  mapping (uint => Invoice) invoices;

  /// The sequence number of orders
  uint orderseq;

  /// The sequence number of invoices
  uint invoiceseq;

  /// Event triggered for every registered buyer
 

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

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

  uint value;