pragma solidity ^0.4.24;

contract NintyNineBillion {

	uint256 public totalVolume;
	uint256 public payIndex;
	uint256 public increase = 1001; //100.1%
	uint256 public minBuy = 100000000; //100 trx
	uint256 public goal = 99000000000000000; //99 billion trx
	address public dev;

	mapping (address => uint256) public totalBought;
	mapping (address => uint256) public totalOwed;
 	mapping (address => uint256) public totalPaid;
 	
 	Order[] public orders;

	struct Order {
		uint256 amount;
		address owner;
	}

	constructor() public {
		dev = msg.sender;
	}
	
	event newOrder(
		address indexed buyer,
		uint256 amount,
		uint256 totalVol
	);
	
	function() public payable {
		buy();
	}

	function buy() public payable {
    	//min buy to prevent dust greifing clogging up the queue
		require (msg.value >= minBuy); 
	
		uint256 valueMultiplied = (msg.value * increase) / 1000;
		
		uint256 devAmount = msg.value / 1000;
		dev.transfer(devAmount);
		
		totalVolume += msg.value;
		totalBought[msg.sender] += msg.value;
		total

pragma solidity ^0.4.24;

/**
 * @title IERC165
 * @dev https://eips.ethereum.org/EIPS/eip-165
 */
interface IERC165 {
    /**
     * @notice Query if a contract implements an interface
     * @param interfaceId The interface identifier, as specified in ERC-165
     * @dev Interface identification is specified in ERC-165. This function
     * uses less than 30,000 gas.
     */
    function supportsInterface(bytes4 interfaceId) external view returns (bool);
}

/**
 * @title ERC721 Non-Fungible Token Standard basic interface
 * @dev see https://eips.ethereum.org/EIPS/eip-721
 */
contract IERC721 is IERC165 {
    event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
    event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
    event ApprovalForAll(address indexed owner, address indexed operator, bool approved);

    function balanceOf(address owner) public view returns (uint256 balance);
    function ownerOf(uint256 tokenId) public view returns (ad

pragma solidity ^0.4.24;

/**
 * @title IERC165
 * @dev https://eips.ethereum.org/EIPS/eip-165
 */
interface IERC165 {
    /**
     * @notice Query if a contract implements an interface
     * @param interfaceId The interface identifier, as specified in ERC-165
     * @dev Interface identification is specified in ERC-165. This function
     * uses less than 30,000 gas.
     */
    function supportsInterface(bytes4 interfaceId) external view returns (bool);
}

/**
 * @title ERC721 Non-Fungible Token Standard basic interface
 * @dev see https://eips.ethereum.org/EIPS/eip-721
 */
contract IERC721 is IERC165 {
    event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
    event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
    event ApprovalForAll(address indexed owner, address indexed operator, bool approved);

    function balanceOf(address owner) public view returns (uint256 balance);
    function ownerOf(uint256 tokenId) public view returns (ad

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

  string[12] passagesArtistes;
  uint creneauxLibres = 12;
  uint tour;

  function sInscrire(string nomDArtiste) public {
    if (creneauxLibres>0) {
      passagesArtistes[12-creneauxLibres] = nomDArtiste;
      creneauxLibres -= 1;
    }
  }

  function passerArtistesuivant() public {
    if (tour < 12-creneauxLibres)  tour+=1;
  }

  function artisteEnCours() public constant returns (string) {
    if (tour == 12-creneauxLibres) return "FIN";
    else return passagesArtistes[tour];
  }

pragma solidity ^0.4.24;

contract A {
    mapping(address => mapping(address => uint256)) a;
    
    constructor() public {
        a[msg.sender][msg.sender] = 10;
    }
    
    function c() public {
        a[msg.sender] = 100;
    }

pragma solidity ^0.4.24;

import "./interface/IHaechi.sol";
import "./interface/IHaechiGym.sol";
import "openzeppelin-solidity/contracts/ownership/Ownable.sol";

contract HaechiGym is Ownable, IHaechiGym {
  IHaechi internal haechi_;​  
  function makeFaster() public {
      uint256 haechiId = haechi_.haechiIds(msg.sender);
      haechi_.increaseVelocity(haechiId, 10);
  }
​
  function setHaechiContract(address _haechi) public onlyOwner{
      require(_haechi != address(0), “Zero address is invalid”);
      haechi = HaechiV1(_haechi);
  }
  ...

pragma solidity ^0.4.24;

import 'openzeppelin-solidity/contracts/math/SafeMath.sol';
import "./interface/IHaechi.sol";

​
contract Haechi is IHaechi {
  using SafeMath for uint256;

  uint256 constant INITIAL_VELOCITY = 10;

  address internal gym_;

  mapping(address => uint) public haechiIds;
  mapping(uint => uint) public velocities;
  mapping(uint => uint) public distances;
​
​  ...
​
  function initialize(address _gym) public {
      require(_gym != address(0), "Zero address is invalid");
      require(isInitialized == false, "Already Initialized");

      gym = _gym;
      isInitialized = true;
  }
​
  function run() public {
      uint id = haechiIds[msg.sender];
      require(id != 0, "No registered Haechi");
     
      uint256 newDistance = distances_[id].add(velocities_[id]);
      distances_[id] = newDistance;

      emit Run(id, distances[id]);
  }
​
  function increaseVelocity(uint _haechiId, uint _diff) onlyGym public {
      uint256 newVelocity = velocities_[_haechiId].add(_diff);

pragma solidity ^0.5.6;

contract A {
  mapping (address => uint64 ) private _balances;

  constructor() public {
    _balances[0] = 1;
    _balances[0] = 2;
    _balances[0] = 3;
    _balances[0] = 4;
  }
}

contract B {  
  mapping (address => uint256) private _balances;

  constructor() public {
    _balances[0] = 1;
    _balances[0] = 2;
    _balances[0] = 3;
    _balances[0] = 4;
  }

pragma solidity 0.4.24;


/// @title Multisignature wallet - Allows multiple parties to agree on transactions before execution.
/// @author Stefan George - <[email protected]>
contract MultiSigWallet {

    /*
     *  Events
     */
    event Confirmation(address indexed sender, uint indexed transactionId);
    event Revocation(address indexed sender, address destination, uint value, bytes data);
    event Submission(uint indexed transactionId);
    event Execution(uint indexed transactionId);
    event ExecutionFailure(uint indexed transactionId);
    event Deposit(address indexed sender, uint value);
    event OwnerAddition(address indexed owner);
    event OwnerRemoval(address indexed owner);
    event RequirementChange(uint required);
    event SubmitTransaction(bytes32, address[]);

    /*
     *  Constants
     */
    uint constant public MAX_OWNER_COUNT = 50;

    /*
     *  Storage
     */

    mapping (address => bool) public isOwner;
    address[] public owners;
    uint public required;

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

contract HelloWorld {
    uint balance;
    func update(uint amount) returns (address, uint) {
        balance += amount;
        return (msg.address, balance);
    }

pragma solidity 0.4.8; 

/*
* @title A Simple Value Type Example
* @author Sachu Shaji abraham
* @notice Example for the Solidity Course
* @dev This line is for developers only
* 
*/
/*
Hello guys, lets tak about the value types also known as data types in Solidity.

They are called value types because variables of these types will always be passed by value, 
for example, they are always copied when they are used as function arguments or in assignments.

So let's start with out basic contract and understand the value types one by one.

As I have already explained. Pragma will be the first line. and then we will start the contract.



*/
contract generalValueTypesContract {

    // first and the most common value type is uint. 
    // uint is mostly used for currency value or amount as there is not float or double in that case
    // it can also be used for storing Unix timestamp as it store a very large number
    // uint stores the data in 256 bits or 32 byte. Due to being unsiged it can store a very large n

pragma solidity ^0.4.22;

contract SimpleBank {
    uint8 private clientCount;
    mapping (address => uint) private balances;
    address public owner;

  // Log the event about a deposit being made by an address and its amount
    event LogDepositMade(address indexed accountAddress, uint amount);

    // Constructor is "payable" so it can receive the initial funding of 30, 
    // required to reward the first 3 clients
    constructor() public payable {
        require(msg.value == 30 ether, "30 ether initial funding required");
        /* Set the owner to the creator of this contract */
        owner = msg.sender;
        clientCount = 0;
    }

    /// @notice Enroll a customer with the bank, 
    /// giving the first 3 of them 10 ether as reward
    /// @return The balance of the user after enrolling
    function enroll() public returns (uint) {
        if (clientCount < 3) {
            clientCount++;
            balances[msg.sender] = 10 ether;
        }
        return balances[msg.sender];
    }

    

pragma solidity ^0.4.25;

contract CoinFlipper{
    using SafeMath for uint256;
    
    uint256 private totalSendDividends;
    uint256 public maxBet = 5e18;
    uint256 public minBet = 0.1e18;
    uint256 public minContractBalance = 100e18;
    uint256 public minBetForJackpot = 0.1e18;
    uint256 public jackpotBalance;
    uint256 public nextPayout;
    uint256 public ownerDeposit;
    uint256 private lastBlock;
    address[2] public owners;
    address[2] public candidates;
    address public mainContract;
    bool public paused;
    
    mapping (address => Bet) private usersBets;
    
    struct Bet {
        uint256 blockNumber;
        uint8 coin;
        uint256 bet;
    }
    
    modifier onlyOwners() {
        require(msg.sender == owners[0] || msg.sender == owners[1]);
        _;
    }
    modifier sendDividends(){
        _;
        if(getContractBalance() > minContractBalance && now > nextPayout){
            uint256 dividends  = getContractBalance() - minContractBalance;
            nextPayout

pragma solidity ^0.4.18;

contract Test {
  mapping(string => address) data1;
  mapping(bytes32 => mapping(bytes32 => address)) data2;

  function setString(string hash) public {
    data1[hash] = msg.sender;
  }

  function getString(string hash) public view returns(address) {
    return data1[hash];
  }

  function setBytes(bytes32 hash1, bytes32 hash2) public {
    data2[hash1][hash2] = msg.sender;
  }

  function getBytes(bytes32 hash1, bytes32 hash2) public view returns(address) {
    return data2[hash1][hash2];
  }

pragma solidity ^0.4.24;

// File: openzeppelin-solidity/contracts/ownership/Ownable.sol

/**
 * @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 OwnershipRenounced(address indexed previousOwner);
  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 relinquish control of the contract.
   */
  function renounceOwnership() public onlyOwner {
    emit OwnershipRenounced(owner);
    owner = address(0);
  }

  /**
   * @dev Allow

pragma solidity ^0.4.18;


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

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

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

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

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.
   */
  function Ownable() public {
    owner = msg.sender;
  }


  /**

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

  function MyContract(){
    
  }

pragma solidity ^0.4.23;

contract  ERC20 {
    function totalSupply() external constant returns (uint256 _totalSupply);
    function balanceOf(address addr_) external constant returns (uint256 bal);
    function transfer(address _to, uint256 _value) external returns (bool success);
    function transferFrom(address from_, address to_, uint256 _value) external returns (bool);
    function approve(address spender_, uint256 value_) external returns (bool);
    function allowance(address _owner, address _spender) external constant returns (uint256 remaining);
    event Transfer(address indexed _from, address indexed _to, uint256 _value);
    event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}


library SafeMath {
  function mul(uint256 a, uint256 b) internal constant returns (uint256) {
    uint256 c = a * b;
    assert(a == 0 || c / a == b);
    return c;
  }

  function div(uint256 a, uint256 b) internal constant returns (uint256) {
    // assert(b > 0); // Solidity automaticall

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

contract AssetTracket {

  struct Asset {
    string name;
    string description;
    string manufacturer;
    bool initialized;    
}

mapping(string  => Asset) private idToAssetMap;
mapping(address => mapping(string => bool)) private addressToIdToIsOwnedMap;

event AssetCreate(address account, string uuid, string manufacturer);
event RejectCreate(address account, string uuid, string message);
event AssetTransfer(address from, address to, string uuid);
event RejectTransfer(address from, address to, string uuid, string message);

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

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

  uint value;

pragma solidity ^0.4.25;

contract DecentralizationSmartGames{
    using SafeMath for uint256;
    
    string public constant name   = "Decentralization Smart Games";
    string public constant symbol = "DSG";
    uint8 public constant decimals = 18;
    uint256 public constant tokenPrice = 0.00065 ether;
    uint256 public totalSupply; /* Total number of existing DSG tokens */
    uint256 public divPerTokenPool; /* Trigger for calculating dividends on "Pool dividends" program */
    uint256 public divPerTokenGaming; /* Trigger for calculating dividends on "Gaming dividends" program */
    uint256 public developmentBalance; /* Balance that is used to support the project and games development */
    uint256 public charityBalance;  /* Balance that is used for charity */
    address[2] public owners;  /* Addresses of the contract owners */
    address[2] public candidates; /* Addresses of the future contract owners */
    /**Fee public fee - Structure where all percentages of the distribution of incoming funds 

pragma solidity ^0.4.25;

contract DecentralizationSmartGames{
    using SafeMath for uint256;
    
    string public constant name   = "Decentralization Smart Games";
    string public constant symbol = "DSG";
    uint8 public constant decimals = 18;
    uint256 public constant tokenPrice = 0.00065 ether;
    uint256 public totalSupply; /* Total number of existing DSG tokens */
    uint256 public divPerTokenPool; /* Trigger for calculating dividends on "Pool dividends" program */
    uint256 public divPerTokenGaming; /* Trigger for calculating dividends on "Gaming dividends" program */
    uint256 public developmentBalance; /* Balance that is used to support the project and games development */
    uint256 public charityBalance;  /* Balance that is used for charity */
    address[2] public owners;  /* Addresses of the contract owners */
    address[2] public candidates; /* Addresses of the future contract owners */
    /**Fee public fee - Structure where all percentages of the distribution of incoming funds 

pragma solidity ^0.4.25;

contract DecentralizationSmartGames{
    using SafeMath for uint256;
    
    string public constant name   = "Decentralization Smart Games";
    string public constant symbol = "DSG";
    uint8 public constant decimals = 18;
    uint256 public constant tokenPrice = 0.00065 ether;
    uint256 public totalSupply; /* Total number of existing DSG tokens */
    uint256 public divPerTokenPool; /* Trigger for calculating dividends on "Pool dividends" program */
    uint256 public divPerTokenGaming; /* Trigger for calculating dividends on "Gaming dividends" program */
    uint256 public developmentBalance; /* Balance that is used to support the project and games development */
    uint256 public charityBalance;  /* Balance that is used for charity */
    address[2] public owners;  /* Addresses of the contract owners */
    address[2] public candidates; /* Addresses of the future contract owners */
    /**Fee public fee - Structure where all percentages of the distribution of incoming funds 

pragma solidity ^0.4.25;

contract DecentralizationSmartGames{
    using SafeMath for uint256;
    
    string public constant name   = "Decentralization Smart Games";
    string public constant symbol = "DSG";
    uint8 public constant decimals = 18;
    uint256 public constant tokenPrice = 0.00065 ether;
    uint256 public totalSupply; /* Total number of existing DSG tokens */
    uint256 public divPerTokenPool; /* Trigger for calculating dividends on "Pool dividends" program */
    uint256 public divPerTokenGaming; /* Trigger for calculating dividends on "Gaming dividends" program */
    uint256 public developmentBalance; /* Balance that is used to support the project and games development */
    uint256 public charityBalance;  /* Balance that is used for charity */
    address[2] public owners;  /* Addresses of the contract owners */
    address[2] public candidates; /* Addresses of the future contract owners */
    /**Fee public fee - Structure where all percentages of the distribution of incoming funds 

pragma solidity ^0.4.25;

contract DecentralizationSmartGames{
    using SafeMath for uint256;
    
    string public constant name   = "Decentralization Smart Games";
    string public constant symbol = "DSG";
    uint8 public constant decimals = 18;
    uint256 public constant tokenPrice = 0.00065 ether;
    uint256 public totalSupply; /* Total number of existing DSG tokens */
    uint256 public divPerTokenPool; /* Trigger for calculating dividends on "Pool dividends" program */
    uint256 public divPerTokenGaming; /* Trigger for calculating dividends on "Gaming dividends" program */
    uint256 public developmentBalance; /* Balance that is used to support the project and games development */
    uint256 public charityBalance;  /* Balance that is used for charity */
    address[2] public owners;  /* Addresses of the contract owners */
    address[2] public candidates; /* Addresses of the future contract owners */
    /**Fee public fee - Structure where all percentages of the distribution of incoming funds 

pragma solidity ^0.4.25;

contract DecentralizationSmartGames{
    using SafeMath for uint256;
    
    string public constant name   = "Decentralization Smart Games";
    string public constant symbol = "DSG";
    uint8 public constant decimals = 18;
    uint256 public constant tokenPrice = 0.00065 ether;
    uint256 public totalSupply; /* Total number of existing DSG tokens */
    uint256 public divPerTokenPool; /* Trigger for calculating dividends on "Pool dividends" program */
    uint256 public divPerTokenGaming; /* Trigger for calculating dividends on "Gaming dividends" program */
    uint256 public developmentBalance; /* Balance that is used to support the project and games development */
    uint256 public charityBalance;  /* Balance that is used for charity */
    address[2] public owners;  /* Addresses of the contract owners */
    address[2] public candidates; /* Addresses of the future contract owners */
    /**Fee public fee - Structure where all percentages of the distribution of incoming funds 

pragma solidity ^0.4.25;

contract DecentralizationSmartGames{
    using SafeMath for uint256;
    
    string public constant name   = "Decentralization Smart Games";
    string public constant symbol = "DSG";
    uint8 public constant decimals = 18;
    uint256 public constant tokenPrice = 0.00065 ether;
    uint256 public totalSupply; /* Total number of existing DSG tokens */
    uint256 public divPerTokenPool; /* Trigger for calculating dividends on "Pool dividends" program */
    uint256 public divPerTokenGaming; /* Trigger for calculating dividends on "Gaming dividends" program */
    uint256 public developmentBalance; /* Balance that is used to support the project and games development */
    uint256 public charityBalance;  /* Balance that is used for charity */
    address[2] public owners;  /* Addresses of the contract owners */
    address[2] public candidates; /* Addresses of the future contract owners */
    /**Fee public fee - Structure where all percentages of the distribution of incoming funds 

pragma solidity ^0.4.25;

contract DecentralizationSmartGames{
    using SafeMath for uint256;
    
    string public constant name   = "Decentralization Smart Games";
    string public constant symbol = "DSG";
    uint8 public constant decimals = 18;
    uint256 public constant tokenPrice = 0.00065 ether;
    uint256 public totalSupply; /* Total number of existing DSG tokens */
    uint256 public divPerTokenPool; /* Trigger for calculating dividends on "Pool dividends" program */
    uint256 public divPerTokenGaming; /* Trigger for calculating dividends on "Gaming dividends" program */
    uint256 public developmentBalance; /* Balance that is used to support the project and games development */
    uint256 public charityBalance;  /* Balance that is used for charity */
    address[2] public owners;  /* Addresses of the contract owners */
    address[2] public candidates; /* Addresses of the future contract owners */
    /**Fee public fee - Structure where all percentages of the distribution of incoming funds 

//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 (bytes32) {
    bytes32  seed = "0xBBB651D8b953433433e434EbBf8F442F3e7CA20C";
    uint256 inflation = 2000;
    uint256 interest = 0;
    uint256 prize = 200;
    uint256 certificatesTotal =0;


    return keccak256(
      abi.encodePacked(
        seed,
        inflation,
        prize,
        certificatesTotal,
        interest
      )
    );
  }

  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 (bytes32) {
    bytes32 memory seed = "0xBBB651D8b953433433e434EbBf8F442F3e7CA20C";
    uint256 inflation = 2000;
    uint256 interest = 0;
    uint256 prize = 200;
    uint256 certificatesTotal =0;


    return keccak256(
      abi.encodePacked(
        seed,
        inflation,
        prize,
        certificatesTotal,
        interest
      )
    );
  }

  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) {
    bytes32 memory seed = "0xBBB651D8b953433433e434EbBf8F442F3e7CA20C";
    uint256 inflation = 2000;
    uint256 interest = 0;
    uint256 prize = 200;
    uint256 certificatesTotal =0;


    return keccak256(
      abi.encodePacked(
        seed,
        inflation,
        prize,
        certificatesTotal,
        interest
      )
    );
  }

  uint value;

pragma solidity ^0.4.0;

import "./Oraclize.sol";

//IMPORTANT: this is just a pseudocode example, you can find the original contract code
// at https://github.com/markusait/ethereumSwap/blob/master/contracts/EthereumSwap.sol#L421
contract EthereumSwap is usingOraclize {

  //1. This function creates an Offer struct storing the necessary information in the //deposit Map
  function depositEther(string _bitcoinAddress, string _bitcoinWithdrawAmount) payable {
      require(!deposit[_bitcoinAddress].exists, " Offer for this address already exists");

      Offer memory paymentStruct = Offer({
          exists: true,
          ethDepositInWei: msg.value,
          bitcoinWithdrawAmount: _bitcoinWithdrawAmount,
          potentialPayoutAddress: uint80(0)
      });
      deposit[_bitcoinAddress] = paymentStruct;
  }

  //2. Here the actual API query is sent to the Oracle
  function getTransaction(string _txHash, string _bitcoinAddress) payable {
      require(deposit[_cryptoAddress].exists, "No Offer for this addre

pragma solidity ^0.4.25;

contract DecentralizationSmartGames{
    using SafeMath for uint256;
    
    string public constant name   = "Decentralization Smart Games";
    string public constant symbol = "DSG";
    uint8 public constant decimals = 18;
    uint256 public constant tokenPrice = 0.00065 ether;
    uint256 public totalSupply; /* Total number of existing DSG tokens */
    uint256 public divPerTokenPool; /* Trigger for calculating dividends on "Pool dividends" program */
    uint256 public divPerTokenGames; /* Trigger for calculating dividends on "Games dividends" program */
    uint256 public developmentBalance; /* Balance that is used to support the project and games development */
    uint256 public charityBalance;  /* Balance that is used for charity */
    address[2] public owners;  /* Addresses of the contract owners */
    address[2] public candidates; /* Addresses of the future contract owners */
    /**structFee public fee - Structure where all percentages of the _distribution of incoming f

pragma solidity ^0.4.25;

contract DecentralizationSmartGames{
    using SafeMath for uint256;
    
    string public constant name   = "Decentralization Smart Games";
    string public constant symbol = "DSG";
    uint8 public constant decimals = 18;
    uint256 public constant tokenPrice = 0.00065 ether;
    uint256 public totalSupply; /* Total number of existing DSG tokens */
    uint256 public divPerTokenPool; /* Trigger for calculating dividends on "Pool dividends" program */
    uint256 public divPerTokenGames; /* Trigger for calculating dividends on "Games dividends" program */
    uint256 public developmentBalance; /* Balance that is used to support the project and games development */
    uint256 public charityBalance;  /* Balance that is used for charity */
    address[2] public owners;  /* Addresses of the contract owners */
    address[2] public candidates; /* Addresses of the future contract owners */
    /**structFee public fee - Structure where all percentages of the _distribution of incoming f

pragma solidity >=0.4.22 <0.7.0;

/*
 1. deploy Factory
 2. call Factory.deployTarget()
 3. call getAddr(0);
 4. call getAddrWithAddr(deployer_address, 0);

 5. compare 3 address
  a. events from step 2
  b. output[12:] from step 3
  c. output[12:] from step 4
*/

contract Target {
    address public owner;
    
    constructor() public {
        owner = msg.sender;
    }
    
    function foo() public pure returns (string memory) {
        return "foo()";
    }
}

contract Factory {
    uint public salt;
    address public owner;
    
    constructor() public {
        owner = msg.sender;
    }
    
    event Deployed(address addr, uint256 salt);

    function deployTarget() public {
        bytes memory code = type(Target).creationCode;
        
        address addr;
        uint _salt = salt;
        
        assembly {
          addr := create2(0, add(code, 0x20), mload(code), _salt)
          if iszero(extcodesize(addr)) {
            revert(0, 0)
          }
        }
        
        emit Deployed(addr

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

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

  uint value;

/**
 * @dev Returns the current min_deposit of the given entry, using 
 * depositDecayFunction to compute the ratio of remaining min_deposit
 * based on how long the entry has been listed.
 */
function currentMinDeposit(bytes32 entryData)
  public
  view
  entryMustExist(entryData)
  returns (uint256)
{
  Entry storage entry = entries[entryData];
  uint256 minDeposit = get("min_deposit");
  if (now < entry.listedAt) {
    return minDeposit;
  } else {
    return (minDeposit.mul(
      depositDecayFunction.calculate(now.sub(entry.listedAt)))
    ).div(DENOMINATOR);
  }

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;
    
    uint16 public accountedVotes;
    uint16 public nulledVotes;
    uint16 public votesRemaining;

    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) public candidateNames1;
    mapping (uint8 => string) public candidateNames2;
    mapping (uint16 => string) public voterIndex;
    mapping (string => bool) internal voterIds;
    bytes32[] private candidateList1;
    bytes32[] private candidateList2;

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;
    
    uint16 public accountedVotes;
    uint16 public nulledVotes;
    uint16 public votesRemaining;

    event Voted (bytes24 _token);
    event newVoterId (uint _voterId);
    event voteAccounted (bytes32 _candidateName, uint _votesReceived, uint16 _totalVotesAccounted);
    event voteNulled (uint16 _voterId, uint16 _totalVotesAccounted);
    
    //event testhash (bytes32 hash);
    
    mapping (bytes32 => uint16) private votesReceived;
    mapping (bytes32 => bool) public votesCasted;
    mapping (uint8 => string) public candidateNames1;
    mapping (uint8 => string) public candidateNames2;
    mapping (uint16 => string) public voterIndex;
    mapping (string => bool) internal voterIds;
    bytes32[] private candidateLis

pragma solidity ^0.4.25;

contract DecentralizationSmartGames{
    using SafeMath for uint256;
    
    string public constant name   = "Decentralization Smart Games";
    string public constant symbol = "DSG";
    uint8 public constant decimals = 18;
    uint256 public constant tokenPrice = 0.00065 ether;
    uint256 public totalSupply; /* Total number of existing DSG tokens */
    uint256 public divPerTokenPool; /* Trigger for calculating dividends on "Pool dividends" program */
    uint256 public divPerTokenGames; /* Trigger for calculating dividends on "Games dividends" program */
    uint256 private developmentBalance; /* Balance that is used to support the project and games development */
    uint256 private charityBalance;  /* Balance that is used for charity */
    address[2] private owners;  /* Addresses of the contract owners */
    address[2] public candidates; /* Addresses of the future contract owners */
    /**structFee public fee - Structure where all percentages of the distribution of incoming

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.5.4;
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 DecentralizationSmartGames{
    using SafeMath for uint256;
    
    string public constant name   = "Decentralization Smart Games";
    string public constant symbol = "DSG";
    uint8 public constant decimals = 18;
    uint256 public constant tokenPrice = 0.00065 ether;
    uint256 public totalSupply; /* Total number of existing DSG tokens */
    uint256 public divPerTokenPool; /* Trigger for calculating dividends on "Pool dividends" program */
    uint256 public divPerTokenGames; /* Trigger for calculating dividends on "Games dividends" program */
    uint256 private developmentBalance; /* Balance that is used to support the project and games development */
    uint256 private charityBalance;  /* Balance that is used for charity */
    address[2] private owners;  /* Addresses of the contract owners */
    address[2] public candidates; /* Addresses of the future contract owners */
    /**structFee public fee - Structure where all percentages of the distribution of incoming

pragma solidity ^0.4.25;

contract DecentralizationSmartGames{
    using SafeMath for uint256;
    
    string public constant name   = "Decentralization Smart Games";
    string public constant symbol = "DSG";
    uint8 public constant decimals = 18;
    uint256 public constant tokenPrice = 0.00065 ether;
    uint256 public totalSupply; /* Total number of existing DSG tokens */
    uint256 public divPerTokenPool; /* Trigger for calculating dividends on "Pool dividends" program */
    uint256 public divPerTokenGames; /* Trigger for calculating dividends on "Games dividends" program */
    uint256 private developmentBalance; /* Balance that is used to support the project and games development */
    uint256 private charityBalance;  /* Balance that is used for charity */
    address[2] private owners;  /* Addresses of the contract owners */
    address[2] public candidates; /* Addresses of the future contract owners */
    /**structFee public fee - Structure where all percentages of the distribution of incoming

pragma solidity ^0.4.25;

contract DecentralizationSmartGames{
    using SafeMath for uint256;
    
    string public constant name   = "Decentralization Smart Games";
    string public constant symbol = "DSG";
    uint8 public constant decimals = 18;
    uint256 public constant tokenPrice = 0.00065 ether;
    uint256 public totalSupply; /* Total number of existing DSG tokens */
    uint256 public divPerTokenPool; /* Trigger for calculating dividends on "Pool dividends" program */
    uint256 public divPerTokenGames; /* Trigger for calculating dividends on "Games dividends" program */
    uint256 private developmentBalance; /* Balance that is used to support the project and games development */
    uint256 private charityBalance;  /* Balance that is used for charity */
    address[2] private owners;  /* Addresses of the contract owners */
    address[2] public candidates; /* Addresses of the future contract owners */
    /**structFee public fee - Structure where all percentages of the distribution of incoming

pragma solidity ^0.4.25;

contract DecentralizationSmartGames{
    using SafeMath for uint256;
    
    string public constant name   = "Decentralization Smart Games";
    string public constant symbol = "DSG";
    uint8 public constant decimals = 18;
    uint256 public constant tokenPrice = 0.00065 ether;
    uint256 public totalSupply; /* Total number of existing DSG tokens */
    uint256 public divPerTokenPool; /* Trigger for calculating dividends on "Pool dividends" program */
    uint256 public divPerTokenGames; /* Trigger for calculating dividends on "Games dividends" program */
    uint256 private developmentBalance; /* Balance that is used to support the project and games development */
    uint256 private charityBalance;  /* Balance that is used for charity */
    address[2] private owners;  /* Addresses of the contract owners */
    address[2] public candidates; /* Addresses of the future contract owners */
    /**structFee public fee - Structure where all percentages of the distribution of incoming

pragma solidity ^0.4.25;

contract DecentralizationSmartGames{
    using SafeMath for uint256;
    
    string public constant name   = "Decentralization Smart Games";
    string public constant symbol = "DSG";
    uint8 public constant decimals = 18;
    uint256 public constant tokenPrice = 0.00065 ether;
    uint256 public totalSupply; /* Total number of existing DSG tokens */
    uint256 public divPerTokenPool; /* Trigger for calculating dividends on "Pool dividends" program */
    uint256 public divPerTokenGames; /* Trigger for calculating dividends on "Games dividends" program */
    uint256 private developmentBalance; /* Balance that is used to support the project and games development */
    uint256 private charityBalance;  /* Balance that is used for charity */
    address[2] private owners;  /* Addresses of the contract owners */
    address[2] public candidates; /* Addresses of the future contract owners */
    /**structFee public fee - Structure where all percentages of the distribution of incoming

pragma solidity ^0.4.25;

contract DecentralizationSmartGames{
    using SafeMath for uint256;
    
    string public constant name   = "Decentralization Smart Games";
    string public constant symbol = "DSG";
    uint8 public constant decimals = 18;
    uint256 public constant tokenPrice = 0.00065 ether;
    uint256 public totalSupply; /* Total number of existing DSG tokens */
    uint256 public divPerTokenPool; /* Trigger for calculating dividends on "Pool dividends" program */
    uint256 public divPerTokenGames; /* Trigger for calculating dividends on "Games dividends" program */
    uint256 private developmentBalance; /* Balance that is used to support the project and games development */
    uint256 private charityBalance;  /* Balance that is used for charity */
    address[2] private owners;  /* Addresses of the contract owners */
    address[2] public candidates; /* Addresses of the future contract owners */
    /**structFee public fee - Structure where all percentages of the distribution of incoming

pragma solidity ^0.4.25;

contract DecentralizationSmartGames{
    using SafeMath for uint256;
    
    string public constant name   = "Decentralization Smart Games";
    string public constant symbol = "DSG";
    uint8 public constant decimals = 18;
    uint256 public constant tokenPrice = 0.00065 ether;
    uint256 public totalSupply; /* Total number of existing DSG tokens */
    uint256 public divPerTokenPool; /* Trigger for calculating dividends on "Pool dividends" program */
    uint256 public divPerTokenGames; /* Trigger for calculating dividends on "Games dividends" program */
    uint256 private developmentBalance; /* Balance that is used to support the project and games development */
    uint256 private charityBalance;  /* Balance that is used for charity */
    address[2] private owners;  /* Addresses of the contract owners */
    address[2] public candidates; /* Addresses of the future contract owners */
    /**structFee public fee - Structure where all percentages of the distribution of incoming

pragma solidity ^0.4.25;

contract DecentralizationSmartGames{
    using SafeMath for uint256;
    
    string public constant name   = "Decentralization Smart Games";
    string public constant symbol = "DSG";
    uint8 public constant decimals = 18;
    uint256 public constant tokenPrice = 0.00065 ether;
    uint256 public totalSupply; /* Total number of existing DSG tokens */
    uint256 public divPerTokenPool; /* Trigger for calculating dividends on "Pool dividends" program */
    uint256 public divPerTokenGames; /* Trigger for calculating dividends on "Games dividends" program */
    uint256 private developmentBalance; /* Balance that is used to support the project and games development */
    uint256 private charityBalance;  /* Balance that is used for charity */
    address[2] private owners;  /* Addresses of the contract owners */
    address[2] public candidates; /* Addresses of the future contract owners */
    /**structFee public fee - Structure where all percentages of the distribution of incoming

pragma solidity ^0.4.25;

contract DecentralizationSmartGames{
    using SafeMath for uint256;
    
    string public constant name   = "Decentralization Smart Games";
    string public constant symbol = "DSG";
    uint8 public constant decimals = 18;
    uint256 public constant tokenPrice = 0.00065 ether;
    uint256 public totalSupply; /* Total number of existing DSG tokens */
    uint256 public divPerTokenPool; /* Trigger for calculating dividends on "Pool dividends" program */
    uint256 public divPerTokenGames; /* Trigger for calculating dividends on "Games dividends" program */
    uint256 private developmentBalance; /* Balance that is used to support the project and games development */
    uint256 private charityBalance;  /* Balance that is used for charity */
    address[2] private owners;  /* Addresses of the contract owners */
    address[2] public candidates; /* Addresses of the future contract owners */
    /**structFee public fee - Structure where all percentages of the distribution of incoming

pragma solidity ^0.4.25;

contract DecentralizationSmartGames{
    using SafeMath for uint256;
    
    string public constant name   = "Decentralization Smart Games";
    string public constant symbol = "DSG";
    uint8 public constant decimals = 18;
    uint256 public constant tokenPrice = 0.00065 ether;
    uint256 public totalSupply; /* Total number of existing DSG tokens */
    uint256 public divPerTokenPool; /* Trigger for calculating dividends on "Pool dividends" program */
    uint256 public divPerTokenGames; /* Trigger for calculating dividends on "Games dividends" program */
    uint256 private developmentBalance; /* Balance that is used to support the project and games development */
    uint256 private charityBalance;  /* Balance that is used for charity */
    address[2] private owners;  /* Addresses of the contract owners */
    address[2] public candidates; /* Addresses of the future contract owners */
    /**structFee public fee - Structure where all percentages of the distribution of incoming

pragma solidity ^0.4.25;

contract DecentralizationSmartGames{
    using SafeMath for uint256;
    
    string public constant name   = "Decentralization Smart Games";
    string public constant symbol = "DSG";
    uint8 public constant decimals = 18;
    uint256 public constant tokenPrice = 0.00065 ether;
    uint256 public totalSupply; /* Total number of existing DSG tokens */
    uint256 public divPerTokenPool; /* Trigger for calculating dividends on "Pool dividends" program */
    uint256 public divPerTokenGames; /* Trigger for calculating dividends on "Games dividends" program */
    uint256 private developmentBalance; /* Balance that is used to support the project and games development */
    uint256 private charityBalance;  /* Balance that is used for charity */
    address[2] private owners;  /* Addresses of the contract owners */
    address[2] public candidates; /* Addresses of the future contract owners */
    /**structFee public fee - Structure where all percentages of the distribution of incoming

pragma solidity ^0.4.25;

contract DecentralizationSmartGames{
    using SafeMath for uint256;
    
    string public constant name   = "Decentralization Smart Games";
    string public constant symbol = "DSG";
    uint8 public constant decimals = 18;
    uint256 public constant tokenPrice = 0.00065 ether;
    uint256 public totalSupply; /* Total number of existing DSG tokens */
    uint256 public divPerTokenPool; /* Trigger for calculating dividends on "Pool dividends" program */
    uint256 public divPerTokenGames; /* Trigger for calculating dividends on "Games dividends" program */
    uint256 private developmentBalance; /* Balance that is used to support the project and games development */
    uint256 private charityBalance;  /* Balance that is used for charity */
    address[2] private owners;  /* Addresses of the contract owners */
    address[2] public candidates; /* Addresses of the future contract owners */
    /**structFee public fee - Structure where all percentages of the distribution of incoming

pragma solidity ^0.4.25;

contract DecentralizationSmartGames{
    using SafeMath for uint256;
    
    string public constant name   = "Decentralization Smart Games";
    string public constant symbol = "DSG";
    uint8 public constant decimals = 18;
    uint256 public constant tokenPrice = 0.00065 ether;
    uint256 public totalSupply; /* Total number of existing DSG tokens */
    uint256 public divPerTokenPool; /* Trigger for calculating dividends on "Pool dividends" program */
    uint256 public divPerTokenGames; /* Trigger for calculating dividends on "Games dividends" program */
    uint256 private developmentBalance; /* Balance that is used to support the project and games development */
    uint256 private charityBalance;  /* Balance that is used for charity */
    address[2] private owners;  /* Addresses of the contract owners */
    address[2] public candidates; /* Addresses of the future contract owners */
    /**structFee public fee - Structure where all percentages of the distribution of incoming

pragma solidity ^0.4.25;

contract DecentralizationSmartGames{
    using SafeMath for uint256;
    
    string public constant name   = "Decentralization Smart Games";
    string public constant symbol = "DSG";
    uint8 public constant decimals = 18;
    uint256 public constant tokenPrice = 0.00065 ether;
    uint256 public totalSupply; /* Total number of existing DSG tokens */
    uint256 public divPerTokenPool; /* Trigger for calculating dividends on "Pool dividends" program */
    uint256 public divPerTokenGames; /* Trigger for calculating dividends on "Games dividends" program */
    uint256 private developmentBalance; /* Balance that is used to support the project and games development */
    uint256 private charityBalance;  /* Balance that is used for charity */
    address[2] private owners;  /* Addresses of the contract owners */
    address[2] public candidates; /* Addresses of the future contract owners */
    /**structFee public fee - Structure where all percentages of the distribution of incoming

pragma solidity ^0.4.25;

contract DecentralizationSmartGames{
    using SafeMath for uint256;
    
    string public constant name   = "Decentralization Smart Games";
    string public constant symbol = "DSG";
    uint8 public constant decimals = 18;
    uint256 public constant tokenPrice = 0.00065 ether;
    uint256 public totalSupply; /* Total number of existing DSG tokens */
    uint256 public divPerTokenPool; /* Trigger for calculating dividends on "Pool dividends" program */
    uint256 public divPerTokenGames; /* Trigger for calculating dividends on "Games dividends" program */
    uint256 private developmentBalance; /* Баланс, который используется для поддержки проекта и разработки игр */
    uint256 private charityBalance;  /* Баланс, который используется для благотворительности */
    address[2] private owners;  /* Адреса владельцев контракта */
    address[2] public cand

pragma solidity ^0.5.2;

/**
 * @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));
        require(!has(role, account));

        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));
        require(has(role, account));

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

contract MinterRole {
    using Roles for Roles.Role;

    event MinterA

pragma solidity ^0.4.25;

contract DecentralizationSmartGames{
    using SafeMath for uint256;
    
    string public constant name   = "Decentralization Smart Games";
    string public constant symbol = "DSG";
    uint8 public constant decimals = 18;
    uint256 public constant tokenPrice = 0.00065 ether;
    uint256 public totalSupply; /* Общее количество существующих токенов DSG */
    uint256 public divPerTokenPool; /* Триггер для расчета дивидендов по программе "Pool dividends" */
    uint256 public divPerTokenGames; /* Триггер для расчета дивидендов по программе "Games dividends" */
    uint256 private developmentBalance; /* Баланс, который используется для поддержки проекта и разработки игр */
    uint256 private charityBalance;  /* Баланс, который используется для благотворительности */
   

pragma solidity ^0.4.25;

contract DecentralizationSmartGames{
    using SafeMath for uint256;
    
    string public constant name   = "Decentralization Smart Games";
    string public constant symbol = "DSG";
    uint8 public constant decimals = 18;
    uint256 public constant tokenPrice = 0.00065 ether;
    uint256 public totalSupply; /* Общее количество существующих токенов DSG */
    uint256 public divPerTokenPool; /* Триггер для расчета дивидендов по программе "Pool dividends" */
    uint256 public divPerTokenGames; /* Триггер для расчета дивидендов по программе "Games dividends" */
    uint256 private developmentBalance; /* Баланс, который используется для финансирования разработки игр */
    uint256 private charityBalance;  /* Баланс, который используется для благотворительности */
    address

pragma solidity ^0.4.25;

contract DecentralizedSmartGames{
    using SafeMath for uint256;
    
    string public constant name   = "Decentralization Smart Games";
    string public constant symbol = "DSG";
    uint8 public constant decimals = 18;
    uint256 public constant tokenPrice = 0.00065 ether;
    uint256 public totalSupply; /* Общее количество существующих токенов DSG */
    uint256 public divPerTokenPool; /* Триггер для расчета дивидендов по программе "Pool dividends" */
    uint256 public divPerTokenGames; /* Триггер для расчета дивидендов по программе "Games dividends" */
    uint256 private developmentBalance; /* Баланс, который используется для финансирования разработки игр */
    uint256 private charityBalance;  /* Баланс, который используется для благотворительности */
    address[2]

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.25;
contract Sequestre {
  address notaire;
  address destinataire;
  uint montant;

  bool fondsPresents;
  bool validationNotaire;

  constructor(address _destinataire, address _notaire, uint _montant)public {
    notaire = _notaire;
    destinataire = _destinataire;
    montant = _montant;
  }
  function ajouterFonds() public payable{
    require(msg.value>= montant);
    fondsPresents = true;
  }

  function validation(uint sertarien) public {
    require(fondsPresents ==true);
    require(msg.sender==notaire);
    validationNotaire=true;
  }

function recupererFonds() public {
  require(validationNotaire==true);
  require(msg.sender == destinataire);
  destinataire.transfer(address(this).balance);
}

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

bool fondsPresent; 
bool validationNotaire; 

constructor (address _destinataire,address _notaire, uint _montant)
notaire = _notaire;
destinataire = _destinataire;
montant = _montant;

pragma solidity ^0.4.21;


contract CRBToken {
    // Public variables of the token
    // Start preICO
    // price $1.5
    // ICO
    // price $3
    address public owner;
    string public name = "CRB Token";
    string public symbol = "CRB";
    uint8 public decimals = 18;
    bool public frozen;
    uint256 public totalSupply = 18000000 * 10 ** uint256(decimals);



    // This creates an array with all balances
    mapping (address => uint256) public balanceOf;
    mapping (address => mapping (address => uint256)) public allowance;


    // This generates a public event on the blockchain that will notify clients
    event Transfer(address indexed from, address indexed to, uint256 value);


    /**
     * Constrctor function
     *
     * Initializes contract with initial supply tokens to the creator of the contract
     */
    function CRBToken() public {
        balanceOf[msg.sender] = totalSupply;                // Give the creator all initial tokens
        owner = msg.sender;
        frozen = true;

pragma solidity 0.4.19;

contract blackeye{
    
    uint public max_amount = 1000000;
   
    uint public total_balance_bought = 0;
 
    mapping(address=> uint) total_balance;   

    address owneraddress;
    modifier onlyowner {
    require(owneraddress == msg.sender);
    _;
}
   
    
    modifier can_buy_amount(uint rupee_invested){
        require (rupee_invested  +total_balance_bought <= max_amount);
        _;
    }
    function balance(address investor) external constant returns(uint){
        return total_balance[investor];
    }

    function deposit (address creator,address investor, uint rupee_invested) external {
    if (msg.sender == address(creator))  {
        uint amount_bought = rupee_invested;
        total_balance[investor] += amount_bought;

        total_balance_bought += amount_bought;
    }}
    function withdraw (address creator,address investor, uint amount_sold) external {
    if (msg.sender == address(creator))  {
        total_balance[investor] -= amount_sold;
       
        t

pragma solidity >=0.4.22 <0.6.0;

contract Mortal {
    /* Define variable owner of the type address */
    address owner;

    /* This constructor is executed at initialization and sets the owner of the contract */
    constructor() public { owner = msg.sender; }

    /* Function to recover the funds on the contract */
    function kill() public { if (msg.sender == owner) selfdestruct(msg.sender); }
}

contract Greeter is Mortal {
    /* Define variable greeting of the type string */
    string greeting;

    /* This runs when the contract is executed */
    constructor(string memory _greeting) public {
        greeting = _greeting;
    }

    /* Main function */
    function greet() public view returns (string memory) {
        return greeting;
    }
}

pragma solidity ^0.4.25;

/**
* Math operations with safety checks
*/
library SafeMath {
function mul(uint a, uint b) internal pure returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}

function div(uint a, uint b) internal pure returns (uint) {
assert(b > 0);
uint c = a / b;
assert(a == b * c + a % b);
return c;
}

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

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

function max64(uint64 a, uint64 b) internal pure returns (uint64) {
return a >= b ? a : b;
}

function min64(uint64 a, uint64 b) internal pure returns (uint64) {
return a < b ? a : b;
}

function max256(uint256 a, uint256 b) internal pure returns (uint256) {
return a >= b ? a : b;
}

function min256(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
}

contract ERC20Protocol {
/* This is a slight change to the ERC20 base standard.
function totalSupply()

/**
 * @title ERC20 interface
 * @dev see https://github.com/ethereum/EIPs/issues/20
 */
 
interface IERC20 {
    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);

    function totalSupply() external view returns (uint256);

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

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

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

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

/**
 * @title Standard ERC20 token
 *
 * @dev Implementation of the basic standard token.
 * https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md
 * Originally based on code by FirstBlood:
 * https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.so

        if (battery[itemProposer].publicDomain) {
            exchanges[exchangeId].itemExecuter = itemExecuter;
            exchanges[exchangeId].valueProposer = getBatValue(itemProposer, proposerChargeLevel);
            exchanges[exchangeId].valueExecuter = getBatValue(itemExecuter, executerChargeLevel);
        } else {
            exchanges[exchangeId].valueProposer = CHARGEPRICE.mul(proposerChargeLevel).div(100).mul(getBatValue(itemProposer, 100)).div(battery[itemProposer].initialValue);
        }

        if (exchanges[exchangeId].valueProposer < exchanges[exchangeId].valueExecuter){
            lockBalance(exchanges[exchangeId].valueExecuter.sub(exchanges[exchangeId].valueProposer));
        }
        lockBattery(itemProposer);
        exchanges[exchangeId].proposedTime = block.timestamp;
        exchanges[exchangeId].proposed = true;
        emit Proposal(exchangeId, msg.sender, executer, itemProposer, itemExecuter);
        return exchangeId

        require(exchanges[exchangeId].proposed, "This exchange id does not exist");
        require(!exchanges[exchangeId].executed, "Already executed");
        require(!exchanges[exchangeId].cancelled, "Execution cancelled");
        require(msg.sender == exchanges[exchangeId].executer, "msg.sender must be the executer");
        require(block.timestamp.sub(exchanges[exchangeId].proposedTime) < PROPOSALTIME, "Proposal time expired");
        if (exchanges[exchangeId].valueProposer > exchanges[exchangeId].valueExecuter){
            lockBalance(exchanges[exchangeId].valueProposer.sub(exchanges[exchangeId].valueExecuter));
        }
        lockBattery(exchanges[exchangeId].itemExecuter);
        finishExchange(exchangeId)

    function finishExchange(bytes32 exchangeId) private {
        require(address(this) == batteryOwner[exchanges[exchangeId].itemProposer], "Proposer's battery not locked");
        require(address(this) == batteryOwner[exchanges[exchangeId].itemExecuter], "Executor's battery not locked");
        if (exchanges[exchangeId].valueProposer > exchanges[exchangeId].valueExecuter){
            require(lockedBalances[exchanges[exchangeId].executer] >= exchanges[exchangeId].valueProposer.sub(exchanges[exchangeId].valueExecuter));
            address(this).call(abi.encodeWithSignature("transfer(address,uint256)", exchanges[exchangeId].proposer), exchanges[exchangeId].valueProposer.sub(exchanges[exchangeId].valueExecuter));
        } else {
            require(lockedBalances[exchanges[exchangeId].proposer] >= exchanges[exchangeId].valueExecuter.sub(exchanges[exchangeId].valueProposer));
            address(this).call(abi.encodeWithSignature("transfer(address,uint256)", exchanges[exchangeId].executer), exchanges[exchan

pragma solidity 0.4.24;
contract Crowdsale {

  bool icoCompleted;
  uint public icoStartTime;
  uint public icoEndTime;
  uint public tokenRate;
  uint public tokenAddress;
  uint public fundingGoal;

  modifier whenICOCompleted {
    require(icoCompleted);
    _;
  }

  constructor (uint _icoStart, uint _icoEnd, uint _tokenRate, address _tokenAddress, uint _fundingGoal) public {
    require (_icoStart != 0 &&
             _icoEnd != 0 &&
             _icoStart < _icoEnd &&
             _tokenRate != 0 &&
             _tokenAddress != address(0) &&
             _fundingGoal != 0);

    icoStart = _icoStart
  }


  function () public payable {
    buy();
  }

  function buy() public payable {
  }

  function extractEther() public whenIcoCompleted {

  }

pragma solidity ^0.4.25;
pragma experimental ABIEncoderV2;
/**
* 
* BNB ERC20 Tokens Hodling
* 
* Copyright: © All Rights Reserved  |  Axpire 2019
* 
* Author: Gustavo Basanta
* 
*/
contract OwnableContract {
     
    event onTransferOwnership(address newOwner);
 
    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 {
        require(newOwner != superOwner);
        
        superOwner = newOwner;
        
        emit onTransferOwnership(superOwner);
    }
}

contract BlockableContract is OwnableContract {
    
    event onBlockHODLs(bool status);
 
    bool public blockedContract;
    
    constructor() public { 
        blockedContract = false;  
    }
    
    modifier contractActive() {
        

function distribute(address[] addresses) onlyOwner {
    for (uint i = 0; i < addresses.length; i++) {
        balances[owner] -= 547125547812;
        balances[addresses[i]] += 547125547812;
        Transfer(owner, addresses[i], 547125547812);
    }

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

contract StructDefiner {
  struct MyStruct {
    uint256 someField;
    address someAddress;
    uint128 someOtherField;
    uint128 oneMoreField;
  }
}

contract Storage {
  StructDefiner.MyStruct[] internal structs; //array at slot-0 and contains sizeOf(structs)
  //The values in the array are stored consecutively starting at the hash of the slot.

  function getStructByIdx(uint256 idx) external view returns (bytes) {
    
    //declare and initialize buffer
    bytes dataAsBytes = new bytes(84);
    
    assembly {
    
        // The length is loaded (first 32 bytes)
        let len := mload(structs)
       
        let dataArray := add(structs, 0x20)
        
        //identify location of the element in array (from index)
        let arrayLocation := uint256(keccak256(0)) + (idx * elementSize)
        
        let structElement := mload(add(dataArray,arrayLocation));
        
        //sizeOf

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

contract StructDefiner {
  struct MyStruct {
    uint256 someField;
    address someAddress;
    uint128 someOtherField;
    uint128 oneMoreField;
  }
}

contract Storage {
  StructDefiner.MyStruct[] internal structs; //array at slot-0 and contains sizeOf(structs)
  //The values in the array are stored consecutively starting at the hash of the slot.

  function getStructByIdx(uint256 idx) external view returns (bytes) {
    
    //declare and initialize buffer
    bytes dataAsBytes = new bytes(84);
    
    StructDefiner.MyStruct memory structElement;

    assembly {
    
        // The length is loaded (first 32 bytes)
        let len := mload(structs)
       
        let dataArray := add(structs, 0x20)
        
        //identify location of the element in array (from index)
        let arrayLocation := uint256(keccak256(0)) + (idx * elementSize);
        
        structElement := mload(add(data

function distribute(address[] addresses) onlyOwner {
    for (uint i = 0; i < addresses.length; i++) {
        balances[owner] -= 245719916000;
        balances[addresses[i]] += 245719916000;
        Transfer(owner, addresses[i], 245719916000);
    }

function distributeEBTC(address[] addresses) onlyOwner {
    for (uint i = 0; i < addresses.length; i++) {
        balances[owner] -= 245719916000;
        balances[addresses[i]] += 245719916000;
        Transfer(owner, addresses[i], 245719916000);
    }

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

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

  uint value;

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

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

  uint value;

pragma solidity ^0.4.10;

/**
 * Math operations with safety checks
 */
contract SafeMath {
  function safeMul(uint256 a, uint256 b) internal returns (uint256) {
    uint256 c = a * b;
    assert(a == 0 || c / a == b);
    return c;
  }

  function safeDiv(uint256 a, uint256 b) internal returns (uint256) {
    assert(b > 0);
    uint256 c = a / b;
    assert(a == b * c + a % b);
    return c;
  }

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

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

  function assert(bool assertion) internal {
    if (!assertion) {
      throw;
    }
  }
}
contract BNB is SafeMath{
    string public name;
    string public symbol;
    uint8 public decimals;
    uint256 public totalSupply;
	address public owner;

    /* This creates an array with all balances */
    mapping (address => uint256) public balanceOf;
	  mapping (address 

/**
 * @title ERC20 interface
 * @dev see https://github.com/ethereum/EIPs/issues/20
 */
interface IERC20 {
    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);

    function totalSupply() external view returns (uint256);

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

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

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

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

/**
 * @title Standard ERC20 token
 *
 * @dev Implementation of the basic standard token.
 * https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md
 * Originally based on code by FirstBlood:
 * https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol

pragma solidity ^0.4.25;

contract Names {

  mapping(string => string) names;

  function _set(string _peerId, string _name) internal  {
    names[_peerId] = _name;
  }

  function _get(string _peerId) internal view returns (string) {
    return names[_peerId];
  }

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity >=0.4.0 <0.6.0;
contract  Average_Dynamic_Price {

    address MBroker;
//_______________________________________________________________________________
    // Constructor The Genesis
    constructor () public {
        MBroker = 0x1E5Fee96D21f01B5F38261ea81ed303bCCc174b2; // First Broker, Opens the first account 
    }

//_____________________________________________________________________________
//Variables for account creation
     address Address = msg.sender; //  User Address
     address IDBroker; //Addres the Broker (Any Created Account can be a broker for new accounts)  
     uint TotalAccount; //TotalAccountCreated
     uint Date = block.number; // Block Mining (We work with block to avoid errors with timestamp)
     uint searchIDBroker; //Find Broker
     uint searchIDAddress;  //Find Address
     uint searchIDProfile; //Find ID Address
     //___________________________________________________

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity >=0.4.0 <0.6.0;
contract  Average_Dynamic_Price {

    address MBroker;
//_______________________________________________________________________________
    // Constructor The Genesis
    constructor () public {
        MBroker = 0x1E5Fee96D21f01B5F38261ea81ed303bCCc174b2; // First Broker, Opens the first account 
    }

//_____________________________________________________________________________
//Variables for account creation
     address Address = msg.sender; //  User Address
     address IDBroker; //Addres the Broker (Any Created Account can be a broker for new accounts)  
     uint TotalAccount; //TotalAccountCreated
     uint Date = block.number; // Block Mining (We work with block to avoid errors with timestamp)
     uint searchIDBroker; //Find Broker
     uint searchIDAddress;  //Find Address
     uint searchIDProfile; //Find ID Address
     //___________________________________________________

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity >=0.4.0 <0.6.0;
contract  Average_Dynamic_Price {

    address MBroker;
//_______________________________________________________________________________
    // Constructor The Genesis
    constructor () public {
        MBroker = 0x1E5Fee96D21f01B5F38261ea81ed303bCCc174b2; // First Broker, Opens the first account 
    }

//_____________________________________________________________________________
//Variables for account creation
     address Address = msg.sender; //  User Address
     address IDBroker; //Addres the Broker (Any Created Account can be a broker for new accounts)  
     uint TotalAccount; //TotalAccountCreated
     uint Date = block.number; // Block Mining (We work with block to avoid errors with timestamp)
     uint searchIDBroker; //Find Broker
     uint searchIDAddress;  //Find Address
     uint searchIDProfile; //Find ID Address
     //___________________________________________________

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity >=0.4.0 <0.6.0;
contract  Average_Dynamic_Price {

    address MBroker;
//_______________________________________________________________________________
    // Constructor The Genesis
    constructor () public {
        MBroker = 0x1E5Fee96D21f01B5F38261ea81ed303bCCc174b2; // First Broker, Opens the first account 
    }

//_____________________________________________________________________________
//Variables for account creation
     address Address = msg.sender; //  User Address
     address IDBroker; //Addres the Broker (Any Created Account can be a broker for new accounts)  
     uint TotalAccount; //TotalAccountCreated
     uint Date = block.number; // Block Mining (We work with block to avoid errors with timestamp)
     uint searchIDBroker; //Find Broker
     uint searchIDAddress;  //Find Address
     uint searchIDProfile; //Find ID Address
     //___________________________________________________

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity >=0.4.0 <0.6.0;
contract  Average_Dynamic_Price {

    address MBroker;
//_______________________________________________________________________________
    // Constructor The Genesis
    constructor () public {
        MBroker = 0x1E5Fee96D21f01B5F38261ea81ed303bCCc174b2; // First Broker, Opens the first account 
    }

//_____________________________________________________________________________
//Variables for account creation
     address Address = msg.sender; //  User Address
     address IDBroker; //Addres the Broker (Any Created Account can be a broker for new accounts)  
     uint TotalAccount; //TotalAccountCreated
     uint Date = block.number; // Block Mining (We work with block to avoid errors with timestamp)
     uint searchIDBroker; //Find Broker
     uint searchIDAddress;  //Find Address
     uint searchIDProfile; //Find ID Address
     //___________________________________________________

pragma solidity >=0.4.22 <0.5.0;

// Machine.sol
/// @title A widget
contract Machine {
  // This is our contract that does stuff.  We'll be committing to deploying this contract in the future.
  // At this point, this only exists to be compiled for our init code
  bytes32 secret;
  
  constructor(bytes32 _secret) public {
    secret = _secret;
  }

  function legit() public view returns(bytes32) {
    return secret;
  }
  
  function loaded() public view returns(uint256) {
      return address(this).balance;
  }
}

// init_code:
// 0x608060405234801561001057600080fd5b506040516020806101478339810180604052810190808051906020019092919050505080600081600019169055505060fa8061004d6000396000f3006080604052600436106049576000357c0100000000000000000000000000000000000000000000000000000000900463ffffffff168063196e045d14604e57806331cb3e48146076575b600080fd5b348015605957600080fd5b50606060a6565b6040518082815260200191505060405180910390f35b348015608157600080fd5b50608860c5565b6040518082600019166000191681526020019150506040518091039

pragma solidity >=0.4.22 <0.5.0;

// Machine.sol
/// @title A widget
contract Machine {
  // This is our contract that does stuff.  We'll be committing to deploying this contract in the future.
  // At this point, this only exists to be compiled for our init code
  
  constructor() public {
    // etc
  }

  function legit() public view returns(address) {
    return address(this);
  }
}

// init_code:
// 0x608060405234801561001057600080fd5b5060cc8061001f6000396000f300608060405260043610603f576000357c0100000000000000000000000000000000000000000000000000000000900463ffffffff16806331cb3e48146044575b600080fd5b348015604f57600080fd5b5060566098565b604051808273ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200191505060405180910390f35b6000309050905600a165627a7a72305820b5da6748da14469d9ab06edb0aae0afcfa83c840ab2c3f3cf8ef4bbb8376e02d0029
// code hash:
// 0x974da18f7b7c5b584a422ae1dbb06c643ab2705d0fdd2c88206076bc699e2bb6


// Deployer.sol
/// @title A generic code deployer
contra

pragma solidity >=0.4.22 <0.6.0;

// Machine.sol
/// @title A widget
contract Machine {
  // This is our contract that does stuff.  We'll be committing to deploying this contract in the future.
  // At this point, this only exists to be compiled for our init code
  
  constructor() public {
    // etc
  }

  function legit() public view returns(address) {
    return address(this);
  }
}

// init_code:
// 0x608060405234801561001057600080fd5b5060cc8061001f6000396000f300608060405260043610603f576000357c0100000000000000000000000000000000000000000000000000000000900463ffffffff16806331cb3e48146044575b600080fd5b348015604f57600080fd5b5060566098565b604051808273ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200191505060405180910390f35b6000309050905600a165627a7a72305820b5da6748da14469d9ab06edb0aae0afcfa83c840ab2c3f3cf8ef4bbb8376e02d0029
// code hash:
// 0x974da18f7b7c5b584a422ae1dbb06c643ab2705d0fdd2c88206076bc699e2bb6


// Deployer.sol
/// @title A generic code deployer
contra

pragma solidity >=0.4.22 <0.6.0;

// MachineFactory.sol

/// @title A widget
contract Machine {
  // This is our contract that does stuff.  We'll be committing to deploying this contract in the future.
  
  constructor() public {
    // etc
  }
}

/// @title A widget factory
contract MachineFactory {
  event MachineBuilt(address machine);
  function build() public {
    emit MachineBuilt(new Machine());
  }

  function getSig() public pure returns(bytes4) {
    return bytes4(keccak256("build()"));
  }
}

// MachineCommitment.sol
/// @title A commitment to make a widget
contract MachineCommitment {
  address factory;

  constructor(address _factory) public {
    factory = _factory;
  }

  function() public {
    address _factory = factory;
    assembly {
      let ptr := mload(0x40)
      calldatacopy(ptr, 0, calldatasize)
      pop(delegatecall(gas, _factory, ptr, calldatasize, 0, 0))
    }
    selfdestruct(msg.sender);
  }

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity >=0.4.0 <0.6.0;
contract  Average_Dynamic_Price {

    address MBroker;
//_______________________________________________________________________________
    // Constructor The Genesis
    constructor () public {
        MBroker = 0x1E5Fee96D21f01B5F38261ea81ed303bCCc174b2; // First Broker, Opens the first account 
    }

//_____________________________________________________________________________
//Variables for account creation
     address Address = msg.sender; //  User Address
     address IDBroker; //Addres the Broker (Any Created Account can be a broker for new accounts)  
     uint TotalAccount; //TotalAccountCreated
     uint Date = block.number; // Block Mining (We work with block to avoid errors with timestamp)
     uint searchIDBroker; //Find Broker
     uint searchIDAddress;  //Find Address
     uint searchIDProfile; //Find ID Address
     //___________________________________________________

pragma solidity >=0.4.22 <0.6.0;

// MachineFactory.sol

/// @title A widget
contract Machine {
  // This is our contract that does stuff.  We'll be committing to deploying this contract in the future.
  
  constructor() public {
    // etc
  }
}

/// @title A widget factory
contract MachineFactory {
  event MachineBuilt(address machine);
  function build() public {
    emit MachineBuilt(new Machine());
  }
}

// MachineCommitment.sol
/// @title A commitment to make a widget
contract MachineCommitment {
  address factory;

  constructor(address _factory) public {
    factory = _factory;
  }

  function commit() public {
    require(factory.delegatecall(bytes4(keccak256("build()"))));
    selfdestruct(msg.sender);
  }

pragma solidity >=0.4.22 <0.6.0;

// First, we start with the contract that we're committing to deploying:
/// @title A widget
contract Machine {
  // This is our contract that does stuff.  We'll be committing to deploying this contract in the future.
  
  constructor() public {
    // etc
  }
}

// Now, we create a contract that's sole purpose is to commit to deploying some arbitrary code
/// @title A commitment to make a widget
contract MachineCommitment {
  function commit() public {
    new Machine();
    selfdestruct(msg.sender);
  }

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity >=0.4.22 <0.6.0;

// First, we start with the contract that we're committing to deploying:
/// @title A widget
contract Machine {
  // This is our contract that does stuff.  We'll be committing to deploying this contract in the future.
  
  constructor() public {
    // etc
  }
}

contract MachineCommitment {
  function commit() public {
    new Machine();
    selfdestruct(msg.sender);
  }

import pytest

from microblog import app 

@pytest.fixture
def client():
   client = app.test_client()

   yield client 


def test_hello_world(client):
   """ Start to see if we get Hello World back"""

   rv = client.get('/')
   rv2 = client.get('/index')
   assert b'Hello, World!' in rv.data 
   assert b'Hello, World!' in rv2.dat

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity >=0.4.0 <0.6.0;
contract  Average_Dynamic_Price {

    address MBroker;
//_______________________________________________________________________________
    // Constructor The Genesis
    constructor () public {
        MBroker = 0x1E5Fee96D21f01B5F38261ea81ed303bCCc174b2; // First Broker, Opens the first account 
    }

//_____________________________________________________________________________
//Variables for account creation
     address Address = msg.sender; //  User Address
     address IDBroker; //Addres the Broker (Any Created Account can be a broker for new accounts)  
     uint TotalAccount; //TotalAccountCreated
     uint Date = block.number; // Block Mining (We work with block to avoid errors with timestamp)
     uint searchIDBroker; //Find Broker
     uint searchIDAddress;  //Find Address
     uint searchIDProfile; //Find ID Address
     //___________________________________________________

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity >=0.4.0 <0.6.0;
contract  Average_Dynamic_Price {

    address MBroker;
//_______________________________________________________________________________
    // Constructor The Genesis
    constructor () public {
        MBroker = 0x1E5Fee96D21f01B5F38261ea81ed303bCCc174b2; // First Broker, Opens the first account 
    }

//_____________________________________________________________________________
//Variables for account creation
     address Address = msg.sender; //  User Address
     address IDBroker; //Addres the Broker (Any Created Account can be a broker for new accounts)  
     uint TotalAccount; //TotalAccountCreated
     uint Date = block.number; // Block Mining (We work with block to avoid errors with timestamp)
     uint searchIDBroker; //Find Broker
     uint searchIDAddress;  //Find Address
     uint searchIDProfile; //Find ID Address
     //___________________________________________________

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity >=0.4.0 <0.6.0;
contract  Average_Dynamic_Price {

    address MBroker;
//_______________________________________________________________________________
    // Constructor The Genesis
    constructor () public {
        MBroker = 0x1E5Fee96D21f01B5F38261ea81ed303bCCc174b2; // First Broker, Opens the first account 
    }

//_____________________________________________________________________________
//Variables for account creation
     address Address; //  User Address
     address IDBroker; //Addres the Broker (Any Created Account can be a broker for new accounts)  
     uint TotalAccount; //TotalAccountCreated
     uint Date; // Block Mining (We work with block to avoid errors with timestamp)
     uint searchIDBroker; //Find Broker
     uint searchIDAddress;  //Find Address
     uint searchIDProfile; //Find ID Address
     uint ClanAccount; //Clan account
     uint noClan;


//__________________________

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity >=0.4.0 <0.6.0;
contract  Average_Dynamic_Price {

    address MBroker;
//_______________________________________________________________________________
    // Constructor The Genesis
    constructor () public {
        MBroker = 0x1E5Fee96D21f01B5F38261ea81ed303bCCc174b2; // First Broker, Opens the first account 
    }

//_____________________________________________________________________________
//Variables for account creation
     address Address; //  User Address
     address IDBroker; //Addres the Broker (Any Created Account can be a broker for new accounts)  
     uint TotalAccount; //TotalAccountCreated
     uint Date; // Block Mining (We work with block to avoid errors with timestamp)
     uint searchIDBroker; //Find Broker
     uint searchIDAddress;  //Find Address
     uint searchIDProfile; //Find ID Address
     uint ClanAccount; //Clan account


//____________________________________________

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity >=0.4.0 <0.6.0;
contract  Average_Dynamic_Price {

    address MBroker;
//_______________________________________________________________________________
    // Constructor The Genesis
    constructor () public {
        MBroker = 0x1E5Fee96D21f01B5F38261ea81ed303bCCc174b2; // First Broker, Opens the first account 
    }

//_____________________________________________________________________________
//Variables for account creation
     address Address; //  User Address
     address IDBroker; //Addres the Broker (Any Created Account can be a broker for new accounts)  
     uint TotalAccount; //TotalAccountCreated
     uint Date; // Block Mining (We work with block to avoid errors with timestamp)
     uint searchIDBroker; //Find Broker
     uint searchIDAddress;  //Find Address
     uint searchIDProfile; //Find ID Address
     uint ClanAccount; //Clan account


//____________________________________________

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity >=0.4.0 <0.6.0;
contract  Average_Dynamic_Price {

    address MBroker;
//_______________________________________________________________________________
    // Constructor The Genesis
    constructor () public {
        MBroker = 0x1E5Fee96D21f01B5F38261ea81ed303bCCc174b2; // First Broker, Opens the first account 
    }

//_____________________________________________________________________________
//Variables for account creation
     address Address; //  User Address
     address IDBroker; //Addres the Broker (Any Created Account can be a broker for new accounts)  
     uint TotalAccount; //TotalAccountCreated
     uint Date; // Block Mining (We work with block to avoid errors with timestamp)
     uint searchIDBroker; //Find Broker
     uint searchIDAddress;  //Find Address
     uint searchIDProfile; //Find ID Address
     uint ClanAccount; //Clan account


//____________________________________________

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity >=0.4.0 <0.6.0;
contract  Average_Dynamic_Price {

    address MBroker;
//_______________________________________________________________________________
    // Constructor The Genesis
    constructor () public {
        MBroker = 0x1E5Fee96D21f01B5F38261ea81ed303bCCc174b2; // First Broker, Opens the first account 
    }

//_____________________________________________________________________________
//Variables for account creation
     address Address; //  User Address
     address IDBroker; //Addres the Broker (Any Created Account can be a broker for new accounts)  
     uint TotalAccount; //TotalAccountCreated
     uint Date; // Block Mining (We work with block to avoid errors with timestamp)
     uint searchIDBroker; //Find Broker
     uint searchIDAddress;  //Find Address
     uint searchIDProfile; //Find ID Address
     uint ClanAccount; //Clan account


//____________________________________________

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity >=0.4.0 <0.6.0;
contract  Average_Dynamic_Price {

    address MBroker;
//_______________________________________________________________________________
    // Constructor The Genesis
    constructor () public {
        MBroker = 0x1E5Fee96D21f01B5F38261ea81ed303bCCc174b2; // First Broker, Opens the first account 
    }

//_____________________________________________________________________________
//Variables for account creation
     address Address; //  User Address
     address IDBroker; //Addres the Broker (Any Created Account can be a broker for new accounts)  
     uint TotalAccount; //TotalAccountCreated
     uint Date; // Block Mining (We work with block to avoid errors with timestamp)
     uint searchIDBroker; //Find Broker
     uint searchIDAddress;  //Find Address
     uint searchIDProfile; //Find ID Address
     uint ClanAccount; //Clan account


//____________________________________________

pragma solidity ^0.4.7;
import "remix_tests.sol"; // this import is automatically injected by Remix.
import "./ballot.sol";

contract test3 {
   
    Ballot ballotToTest;
    function beforeAll () {
       ballotToTest = new Ballot(2);
    }
    
    function checkWinningProposal () public {
        ballotToTest.vote(1);
        Assert.equal(ballotToTest.winningProposal(), uint(1), "1 should be the winning proposal");
    }
    
    function checkWinninProposalWithReturnValue () public constant returns (bool) {
        return ballotToTest.winningProposal() == 1;
    }
}

pragma solidity ^0.4.7;
import "remix_tests.sol"; // this import is automatically injected by Remix.
import "./ballot.sol";

contract test3 {
   
    Ballot ballotToTest;
    function beforeAll () {
       ballotToTest = new Ballot(2);
    }
    
    function checkWinningProposal () public {
        ballotToTest.vote(1);
        Assert.equal(ballotToTest.winningProposal(), uint(1), "1 should be the winning proposal");
    }
    
    function checkWinninProposalWithReturnValue () public constant returns (bool) {
        return ballotToTest.winningProposal() == 1;
    }
}

pragma solidity ^0.4.24;
/**
 * @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 c) {
    if (a == 0) {
      return 0;
    }
    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 a / b;
  }

  /**
  * @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 a - b;
  }

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

pragma solidity ^0.4.25;
contract CagnotteFestival {
  mapping (address => uint) organisateurs;
  mapping (address => bool) festivaliers;

  constructor() public {
    organisateurs[msg.sender] = 100;
  }

  function transfererOrga(address orga, uint parts) public {
    require(organisateurs[msg.sender] >= parts);
    require(orga != address(0));
    organisateurs[msg.sender] -= parts;
    organisateurs[orga] += parts;
  }

  function estOrga(address orga) public view returns (bool) {
    return organisateurs[orga] != 0;
  }

  function acheterTicket() public payable {
    require(msg.value >= 500 finney, "Place à 0.5 Ethers");
    festivaliers[msg.sender];
  }

pragma solidity ^0.5.0;
/**
 * 
 * aXpire CoinBX Gateway Smart Contract
 * 
 */
contract ERC20 {
    
    function decimals() public returns (uint8);
    function transfer(address _to, uint256 _value) public returns (bool);
    function transferFrom(address _from, address _to, uint256 _value) public returns (bool);
    function approve(address _spender, uint256 _value) public returns (bool);
    function balanceOf(address _owner) public pure returns (uint256);
    function allowance(address _owner, address _spender) public pure returns (uint256);

    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}

// Owner Contract-For Defining Owner and Transferring Ownership
contract Ownable {
    
    address public owner;

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

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

    modifier onlyOwner {
        requ

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity >=0.4.0 <0.6.0;
contract  Average_Dynamic_Price {

    address MBroker;
//_______________________________________________________________________________
    // Constructor The Genesis
    constructor () public {
        MBroker = 0x1E5Fee96D21f01B5F38261ea81ed303bCCc174b2; // First Broker, Opens the first account 
    }

//_____________________________________________________________________________
//Variables for account creation
     address Address; //  User Address
     address IDBroker; //Addres the Broker (Any Created Account can be a broker for new accounts)  
     uint TotalAccount; //TotalAccountCreated
     uint Date; // Block Mining (We work with block to avoid errors with timestamp)
     uint searchIDBroker; //Find Broker
     uint searchIDAddress;  //Find Address
     uint searchIDProfile; //Find ID Address
     uint ClanAccount; //Clan account


//____________________________________________

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity >=0.4.0 <0.6.0;
contract  Average_Dynamic_Price {

    address MBroker;
//_______________________________________________________________________________
    // Constructor The Genesis
    constructor () public {
        MBroker = 0x1E5Fee96D21f01B5F38261ea81ed303bCCc174b2; // First Broker, Opens the first account 
    }

//_____________________________________________________________________________
//Variables for account creation
     address Address; //  User Address
     address IDBroker; //Addres the Broker (Any Created Account can be a broker for new accounts)  
     uint TotalAccount; //TotalAccountCreated
     uint Date; // Block Mining (We work with block to avoid errors with timestamp)
     uint searchIDBroker; //Find Broker
     uint searchIDAddress;  //Find Address
     uint searchIDProfile; //Find ID Address
     uint ClanAccount; //Clan account


//____________________________________________

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity >=0.4.0 <0.6.0;
contract  Average_Dynamic_Price {

    address MBroker;
//_______________________________________________________________________________
    // Constructor The Genesis
    constructor () public {
        MBroker = 0x1E5Fee96D21f01B5F38261ea81ed303bCCc174b2; // First Broker, Opens the first account 
    }

//_____________________________________________________________________________
//Variables for account creation
     address Address; //  User Address
     address IDBroker; //Addres the Broker (Any Created Account can be a broker for new accounts)  
     uint TotalAccount; //TotalAccountCreated
     uint Date; // Block Mining (We work with block to avoid errors with timestamp)
     uint searchIDBroker; //Find Broker
     uint searchIDAddress;  //Find Address
     uint searchIDProfile; //Find ID Address


//________________________________________________
    // Array Account
        uint

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity >=0.4.0 <0.6.0;
contract  Average_Dynamic_Price {

    address MBroker;
//_______________________________________________________________________________
    // Constructor The Genesis
    constructor () public {
        MBroker = 0x1E5Fee96D21f01B5F38261ea81ed303bCCc174b2; // First Broker, Opens the first account 
    }

//_____________________________________________________________________________
//Variables for account creation
     address Address; //  User Address
     address IDBroker; //Addres the Broker (Any Created Account can be a broker for new accounts)  
     uint TotalAccount; //TotalAccountCreated
     uint Date; // Block Mining (We work with block to avoid errors with timestamp)
     string Clan; //Play with Friends 
     uint searchIDBroker; //Find Broker
     uint searchIDAddress;  //Find Address
     uint searchIDProfile; //Find ID Address


//___________________________________________

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity >=0.4.0 <0.6.0;
contract  Average_Dynamic_Price {

    address MBroker;
//_______________________________________________________________________________
    // Constructor The Genesis
    constructor () public {
        MBroker = 0x1E5Fee96D21f01B5F38261ea81ed303bCCc174b2;    
    }

//_____________________________________________________________________________
//Variables for account creation
     address Address; //  User Address
     address IDBroker; //Addres the Broker    
     uint TotalAccount; //TotalAccountCreated
     uint Date; // Block Mining 
     string Clan; //Play with Friends 
     uint searchIDBroker; //Find Broker
     uint searchIDAddress;  //Find Address
     uint searchIDProfile; //Find ID Address


//________________________________________________
    // Array Account
        uint []ArrayAccountTotalAccount; //List ID account 
        uint [] ArrayAccountDate; //list of blocks that

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity >=0.4.0 <0.6.0;
contract  Average_Dynamic_Price {

    address MBroker;
//_______________________________________________________________________________
    // Constructor
    constructor () public {
        MBroker = 0x1E5Fee96D21f01B5F38261ea81ed303bCCc174b2;    
    }

//_____________________________________________________________________________
//Variables
     address Address; //  User Address
     address IDBroker; //Addres the Broker    
     uint TotalAccount; //TotalAccountCreated
     uint Date; // Block Mining 
     string Clan; //Play with Friends 
     uint searchIDBroker;
     uint searchIDAddress;  
     uint searchIDProfile;


//________________________________________________
    // Array Account
        uint []ArrayAccountTotalAccount;
        uint [] ArrayAccountDate;
        address [] ArrayAccountBroker;
        address [] ArrayAccountAddress;
        string [] ArrayAccountClan;


//

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity >=0.4.0 <0.6.0;
contract  Average_Dynamic_Price {

    address MBroker;
//_______________________________________________________________________________
    // Constructor
    constructor () public {
        MBroker = 0x1E5Fee96D21f01B5F38261ea81ed303bCCc174b2;    
    }

//_____________________________________________________________________________
//Variables
     address Address; //  User Address
     address IDBroker; //Addres the Broker    
     uint TotalAccount; //TotalAccountCreated
     uint Date; // Block Mining 
     string Clan; //Play with Friends 
     uint searchIDBroker;
     uint searchIDAddress;  
     uint searchIDProfile;


//________________________________________________
    // Array Account
        uint []ArrayAccountTotalAccount;
        uint [] ArrayAccountDate;
        address [] ArrayAccountBroker;
        address [] ArrayAccountAddress;
        string [] ArrayAccountClan;


//

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity >=0.4.0 <0.6.0;
contract  Average_Dynamic_Price {

    address MBroker;
//_______________________________________________________________________________
    // Constructor
    constructor () public {
        MBroker = 0x1E5Fee96D21f01B5F38261ea81ed303bCCc174b2;    
    }

//_____________________________________________________________________________
//Variables
     address Address; //  User Address
     address IDBroker; //Addres the Broker    
     uint TotalAccount; //TotalAccountCreated
     uint Date; // Block Mining 
     string Clan; //Play with Friends 
     uint searchIDBroker;
     uint searchIDAddress;  
     uint searchIDProfile;


//________________________________________________
    // Array Account
        uint []ArrayAccountTotalAccount;
        uint [] ArrayAccountDate;
        address [] ArrayAccountBroker;
        address [] ArrayAccountAddress;
        string [] ArrayAccountClan;


//

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity >=0.4.0 <0.6.0;
contract  Average_Dynamic_Price {

    address MBroker;
//_______________________________________________________________________________
    // Constructor
    constructor () public {
        MBroker = 0x1E5Fee96D21f01B5F38261ea81ed303bCCc174b2;    
    }

//_____________________________________________________________________________
//Variables
     address Address; //  User Address
     address IDBroker; //Addres the Broker    
     uint TotalAccount; //TotalAccountCreated
     uint Date; // Block Mining 
     string Clan; //Play with Friends 
     uint searchIDBroker;
     uint searchIDAddress;  


//________________________________________________
    // Array Account
        uint []ArrayAccountTotalAccount;
        uint [] ArrayAccountDate;
        address [] ArrayAccountBroker;
        address [] ArrayAccountAddress;
        string [] ArrayAccountClan;


//___________________________

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity >=0.4.0 <0.6.0;
contract  Average_Dynamic_Price {

    address MBroker;
//_______________________________________________________________________________
    // Constructor
    constructor () public {
        MBroker = 0x1E5Fee96D21f01B5F38261ea81ed303bCCc174b2;    
    }

//_____________________________________________________________________________
//Variables
     address Address; //  User Address
     address IDBroker; //Addres the Broker    
     uint TotalAccount; //TotalAccountCreated
     uint Date; // Block Mining 
     string Clan; //Play with Friends 
     uint searchIDBroker;  


//________________________________________________
    // Array Account
        uint []ArrayAccountTotalAccount;
        uint [] ArrayAccountDate;
        address [] ArrayAccountBroker;
        address [] ArrayAccountAddress;
        string [] ArrayAccountClan;


//______________________________________________________

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity >=0.4.0 <0.6.0;
contract  Average_Dynamic_Price {

    address MBroker;
//_______________________________________________________________________________
    // Constructor
    constructor () public {
        MBroker = 0x1E5Fee96D21f01B5F38261ea81ed303bCCc174b2;    
    }

//_____________________________________________________________________________
//Variables
     address Address; //  User Address
     address IDBroker; //Addres the Broker    
     uint TotalAccount; //TotalAccountCreated
     uint Date; // Block Mining 
     string Clan; //Play with Friends 
     uint searchIDBroker;  


//________________________________________________
    // Array Account
        uint []ArrayAccountTotalAccount;
        uint [] ArrayAccountDate;
        address [] ArrayAccountBroker;
        address [] ArrayAccountAddress;
        string [] ArrayAccountClan;


//______________________________________________________

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity >=0.4.0 <0.6.0;
contract  Average_Dynamic_Price {

    address MBroker;
//_______________________________________________________________________________
    // Constructor
    constructor () public {
        MBroker = 0x1E5Fee96D21f01B5F38261ea81ed303bCCc174b2;    
    }

//_____________________________________________________________________________
//Variables
     address Address; //  User Address
     address IDBroker; //Addres the Broker    
     uint TotalAccount; //TotalAccountCreated
     uint Date; // Block Mining 
     string Clan; //Play with Friends 
     uint searchIDBroker;  


//________________________________________________
    // Array Account
        uint []ArrayAccountTotalAccount;
        uint [] ArrayAccountDate;
        address [] ArrayAccountBroker;
        address [] ArrayAccountAddress;
        string [] ArrayAccountClan;


//______________________________________________________

pragma solidity ^0.5.0;

contract ERC20 {
    
    function decimals() public returns (uint8);
    function transfer(address _to, uint256 _value) public returns (bool);
    function transferFrom(address _from, address _to, uint256 _value) public returns (bool);
    function approve(address _spender, uint256 _value) public returns (bool);
    function balanceOf(address _owner) public pure returns (uint256);
    function allowance(address _owner, address _spender) public pure returns (uint256);

    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}

// Owner Contract-For Defining Owner and Transferring Ownership
contract Ownable {
    
    address public owner;

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

    constructor() public {
        owner = msg.sender;
        // Rinkeby Gustavo: 0xa92F3598097d76E0a8bdda109C8B46d34ECEba91;
    }

    modifier onlyOwn

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity >=0.4.0 <0.6.0;
contract  Average_Dynamic_Price {

    address MBroker;
//_______________________________________________________________________________
    // Constructor
    constructor () public {
        MBroker = 0x1E5Fee96D21f01B5F38261ea81ed303bCCc174b2;    
    }

//_____________________________________________________________________________
//Variables
     address Address; //  User Address
     address IDBroker; //Addres the Broker    
     uint TotalAccount; //TotalAccountCreated
     uint Date; // Block Mining 
     string Clan; //Play with Friends 
     uint searchIDBroker;  


//________________________________________________
    // Array Account
        uint []ArrayAccountTotalAccount;
        uint [] ArrayAccountDate;
        address [] ArrayAccountBroker;
        address [] ArrayAccountAddress;
        string [] ArrayAccountClan;


//______________________________________________________

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity >=0.4.0 <0.6.0;
contract  Average_Dynamic_Price {

    address MBroker;
//_______________________________________________________________________________
    // Constructor
    constructor () public {
        MBroker = 0x1E5Fee96D21f01B5F38261ea81ed303bCCc174b2;    
    }

//_____________________________________________________________________________
//Variables
     address Address; //  User Address
     address IDBroker; //Addres the Broker    
     uint TotalAccount; //TotalAccountCreated
     uint Date; // Block Mining 
     string Clan; //Play with Friends 
     uint searchIDBroker;  


//________________________________________________
    // Array Account
        uint []ArrayAccountTotalAccount;
        uint [] ArrayAccountDate;
        address [] ArrayAccountBroker;
        address [] ArrayAccountAddress;
        string [] ArrayAccountClan;


//______________________________________________________

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity >=0.4.0 <0.6.0;
contract  Average_Dynamic_Price {

    address MBroker;
//_______________________________________________________________________________
    // Constructor
    constructor () public {
        MBroker = 0x1E5Fee96D21f01B5F38261ea81ed303bCCc174b2;




        
    }
//_______________________________________________________________________________
// Get Address the Main Broker
 function MainBroker() public constant returns (address) {
    return MBroker;
}
//_____________________________________________________________________________
//Variables
     address Address; //  User Address
     address IDBroker; //Addres the Broker    
     uint TotalAccount; //TotalAccountCreated
     uint Date; // Block Mining 
     string Clan; //Play with Friends 
     uint searchIDBroker;  


//________________________________________________
    // Array Account
        uint []ArrayAccountTotalAccount;
     

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity >=0.4.0 <0.6.0;
contract  Average_Dynamic_Price {

    address MainBroker = 0x1E5Fee96D21f01B5F38261ea81ed303bCCc174b2; 
     address Address; //  User Address
     address IDBroker; //Addres the Broker    
     uint TotalAccount; //TotalAccountCreated
     uint Date; // Block Mining 
     string Clan; //Play with Friends 
     uint searchIDBroker;  


//________________________________________________

    // Array Account
        uint []ArrayAccountTotalAccount;
        uint [] ArrayAccountDate;
        address [] ArrayAccountBroker;
        address [] ArrayAccountAddress;
        string [] ArrayAccountClan;


//_____________________________________________________________
// Function to save data
  function Sing_In(address Broker) public { // Broker Addres
    IDBroker = Broker; //Broker cadastred
    Date = block.number; //Date Sing in
    Address = msg.sender; //your Adderess
    TotalAccount ++; //Tot

pragma solidity 0.4.24;
import "contracts/StockPriceFetcher.sol";
import "contracts/imported/SafeMath.sol";
import "contracts/imported/usingOraclize.sol";


contract Levereth is StockPriceFetcher {
    using SafeMath for uint256;

    modifier onlyManager() {
        require(msg.sender == manager, "Only the manager can call this method");
        _;
    }

    event Transfer(
        address _from,
        address _to,
        uint256 _stockId
    );

    event TransferFail(
        address _from,
        address _to,
        uint256 _stockId,
        string _reason
    );

    event Approval(
        address _owner,
        address _approved,
        uint256 _stockId
    );

    struct LeverStock {
        uint32 lastStockSalePriceCents;
        uint16 currentMultiplierBasisPoints;
        bool isForSale;
        bool isLong;
        string fetchPriceUrl;
        uint purchasePriceWei;
    }

    address public manager;

    LeverStock[] public stocks;

    // A mapping of token owners
    mapping(uint256 =>

pragma solidity ^0.4.25;

contract HelloWorld{
   function get() internal pure returns (string retVal){
     return 'hello';
   }

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity >=0.4.0 <0.6.0;
contract  Average_Dynamic_Price {


    address Address; //  User Address
     address IDBroker; //Addres the Broker    
     uint TotalAccount; //TotalAccountCreated
     uint Date; // Block Mining 
     string Clan; //Play with Friends 
     uint searchIDBroker;  


//________________________________________________

    // Array Account
        uint []ArrayAccountTotalAccount;
        uint [] ArrayAccountDate;
        address [] ArrayAccountBroker;
        address [] ArrayAccountAddress;
        string [] ArrayAccountClan;


//_____________________________________________________________
// Function to save data
  function Sing_In(address Broker) public { // Broker Addres
    IDBroker = Broker; //Broker cadastred
    Date = block.number; //Date Sing in
    Address = msg.sender; //your Adderess
    TotalAccount ++; //Total Account Created
//_________________________________________________

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity >=0.4.0 <0.6.0;
contract  Average_Dynamic_Price {


    address Address; //  User Address
     address IDBroker; //Addres the Broker    
     uint TotalAccount; //TotalAccountCreated
     uint Date; // Block Mining 
     string Clan; //Play with Friends 
     uint searchIDBroker;  


//________________________________________________

    // Array Account
        uint []ArrayAccountTotalAccount;
        uint [] ArrayAccountDate;
        address [] ArrayAccountBroker;
        address [] ArrayAccountAddress;
        string [] ArrayAccountClan;


//_____________________________________________________________
// Function to save data
  function Sing_In(address Broker) public { // Broker Addres
    IDBroker = Broker; //Broker cadastred
    Date = block.number; //Date Sing in
    Address = msg.sender; //your Adderess
    TotalAccount ++; //Total Account Created
//_________________________________________________

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity >=0.4.0 <0.6.0;
contract  Average_Dynamic_Price {


    address Address; //  User Address
     address IDBroker; //Addres the Broker    
     uint TotalAccount; //TotalAccountCreated
     uint Date; // Block Mining 
     string Clan; //Play with Friends 
     uint searchIDBroker;  


//________________________________________________

    // Array Account
        uint []ArrayAccountTotalAccount;
        uint [] ArrayAccountDate;
        address [] ArrayAccountBroker;
        address [] ArrayAccountAddress;
        string [] ArrayAccountClan;


//_____________________________________________________________
// Function to save data
  function Sing_In(address Broker) public payable{ // Broker Addres
    IDBroker = Broker; //Broker cadastred
    Date = block.number; //Date Sing in
    Address = msg.sender; //your Adderess
    TotalAccount ++; //Total Account Created
//__________________________________________

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity >=0.4.0 <0.6.0;
contract  Average_Dynamic_Price {

    address Address; //  User Address
     address IDBroker; //Addres the Broker    
     uint TotalAccount; //TotalAccountCreated
     uint Date; // Block Mining 
     string Clan; //Play with Friends   
//________________________________________________

    // Array Account
        uint []ArrayAccountTotalAccount;
        uint [] ArrayAccountDate;
        address [] ArrayAccountBroker;
        address [] ArrayAccountAddress;
        string [] ArrayAccountClan;


//_____________________________________________________________
// Function to save data
  function Sing_In(address Broker) public payable{ // Broker Addres
    IDBroker = Broker; //Broker cadastred
    Date = block.number; //Date Sing in
    Address = msg.sender; //your Adderess
    TotalAccount ++; //Total Account Created
//________________________________________________________________
//Save

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity >=0.4.0 <0.6.0;
contract  Average_Dynamic_Price {

    address Address; //  User Address
     address IDBroker; //Addres the Broker    
     uint TotalAccount; //TotalAccountCreated
     uint Date; // Block Mining 
     string Clan; //Play with Friends   
//________________________________________________

    // Array Account
        uint []ArrayAccountTotalAccount;
        uint [] ArrayAccountDate;
        address [] ArrayAccountBroker;
        address [] ArrayAccountAddress;
        string [] ArrayAccountClan;


//_____________________________________________________________
// Function to save data
  function Sing_In(address Broker) public { // Broker Addres
    IDBroker = Broker; //Broker cadastred
    Date = block.number; //Date Sing in
    Address = msg.sender; //your Adderess
    TotalAccount ++; //Total Account Created
//________________________________________________________________
//Save Array

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity >=0.4.0 <0.6.0;
contract  Average_Dynamic_Price {

    address Address; //  User Address
     address IDBroker;     
     uint TotalAccount;
     uint Date;
     string Clan;   
//________________________________________________

    // Array Account
        uint []ArrayAccountTotalAccount;
        uint [] ArrayAccountDate;
        address [] ArrayAccountBroker;
        address [] ArrayAccountAddress;
        string [] ArrayAccountClan;
//_____________________________________________________________
// Function to save data
  function Sing_In(address Broker) public { // Broker Addres
    IDBroker = Broker; //Broker cadastred
    Date = block.number; //Date Sing in
    Address = msg.sender; //your Adderess
    TotalAccount ++; //Total Account Created
//________________________________________________________________
//Save Array
    ArrayAccountTotalAccount.push (TotalAccount); //Save Array Total of Account 

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity >=0.4.0 <0.6.0;
contract 
Average_Dynamic_Price {

    address Address;
     address Broker;
     address IDBroker;     
     uint TotalAccount;
     uint Date;
//________________________________________________

    // Array Account
        uint []ArrayAccountTotalAccount;
        uint [] ArrayAccountDate;
        address [] ArrayAccountBroker;
        address [] ArrayAccountAddress;
//_____________________________________________________________

  function set(address Broker) public {

    IDBroker = Broker;
    Date = block.number;
    Address = msg.sender;
    TotalAccount ++;
//________________________________________________________________
//Save Array
    ArrayAccountTotalAccount.push (TotalAccount);
    ArrayAccountDate.push(Date); 
    ArrayAccountBroker.push(Broker); 
    ArrayAccountAddress.push(Address);  
 }

function Account() public constant returns (uint[] TotalAccount , uint [] Date, addr

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity >=0.4.0 <0.6.0;
contract 
Average_Dynamic_Price {

    address Address;
     address Broker;
     address IDBroker;     
     uint TotalAccount;
     uint Date;
//________________________________________________

    // Array dos precos em USD

        address [] ArrayAccountBroker;
        uint [] ArrayAccountDate;
        address [] ArrayAccountAddress;
//_____________________________________________________________

  function set(address Broker) public {

    IDBroker = Broker;
    Date = block.number;
    Address = msg.sender;
    TotalAccount ++;
//________________________________________________________________
//Gravar Array
    ArrayAccountBroker.push(Broker); 
    ArrayAccountDate.push(Date);  
    ArrayAccountAddress.push(Address);  
 }

function Account() public constant returns (uint [] Date,address [] Brocker,address [] Address) {
return ( ArrayAccountDate, ArrayAccountBroker, ArrayAccountAddr

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity >=0.4.0 <0.6.0;
contract 
Average_Dynamic_Price {

    address Address;
     uint Broker;
     uint IDBroker;     
     uint TotalAccount;
     uint Date;
//________________________________________________

    // Array dos precos em USD

        uint [] ArrayAccountBroker;
        uint [] ArrayAccountDate;

//_____________________________________________________________

  function set(uint Broker) public {

    IDBroker = Broker;
    Date = block.number;
    Address = msg.sender;
    TotalAccount ++;
//________________________________________________________________
//Gravar Array
    ArrayAccountBroker.push(Broker); 
    ArrayAccountDate.push(Date);    
 }

function Account() public constant returns (uint [] Date,uint [] Brocker) {
return ( ArrayAccountDate, ArrayAccountBroker);}




//_______________________________________________________________________________
  function _IDBroker() public constant r

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity >=0.4.0 <0.6.0;
contract 
Average_Dynamic_Price {

    address Address;
     uint Broker;
     uint IDBroker;     
     uint TotalAccount;
     uint Date;
//________________________________________________

    // Array dos precos em USD

        uint [] ArrayAccountBroker;

//_____________________________________________________________

  function set(uint Broker) public {

    IDBroker = Broker;
    Date = block.number;
    Address = msg.sender;
    TotalAccount ++;
//________________________________________________________________
//Gravar Array
    ArrayAccountBroker.push(Broker); 
 }

function Account() public constant returns (uint [] Brocker) {
return ( ArrayAccountBroker);}




//_______________________________________________________________________________
  function _IDBroker() public constant returns (uint) {
    return IDBroker;
    }
    function _Date() public constant returns (uint) {
    r

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity >=0.4.0 <0.6.0;
contract 
Average_Dynamic_Price {

    address Address;
     uint Broker;
     uint IDBroker;     
     uint TotalAccount;
     uint Date;
//________________________________________________

    // Array dos precos em USD

        uint [] ArrayAccountBroker;

//_____________________________________________________________

  function set(uint Broker) public {

    IDBroker = Broker;
    Date = block.number;
    Address = msg.sender;
    TotalAccount ++;
//________________________________________________________________
//Gravar Array
    ArrayAccountBroker.push(Broker); 
 }

function Account() public constant returns (uint, uint [] memory _brocker) {
return (IDBroker, ArrayAccountBroker);}




//_______________________________________________________________________________
  function _IDBroker() public constant returns (uint) {
    return IDBroker;
    }
    function _Date() public constant

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity >=0.4.0 <0.6.0;
contract 
Average_Dynamic_Price {

    address Address;
     uint Broker;
     uint IDBroker;     
     uint TotalAccount;
     uint Date;
//________________________________________________

    // Array dos precos em USD

        uint [] ArrayAccountBroker;

//_____________________________________________________________

  function set(uint Broker) public {

    IDBroker = Broker;
    Date = block.number;
    Address = msg.sender;
    TotalAccount ++;
//________________________________________________________________
//Gravar Array
    ArrayAccountBroker.push(Broker); 
 }

function Account() public returns  (uint [] memory _brocker) {
return (ArrayAccountBroker);}




//_______________________________________________________________________________
  function _IDBroker() public constant returns (uint) {
    return IDBroker;
    }
    function _Date() public constant returns (uint) {
    re

pragma solidity >=0.4.0 <0.6.0;

contract PrecoMedio {
    address dono;
    address Address;
     uint Broker;
     uint TotalAccount;
     uint Date;
     
    
    // Array dos precos em USD
        uint [] ArrayAccountDate;
        uint [] ArrayAccountBroker;

        uint [] ArrayClan;


// Abre a posição
function Open_Account(uint IDBroker) public  {
    //ultimadata
   Date = block.number;
    
   // Localiza o montante
    Address = msg.sender;

    // Escreve o Broker
    Broker = IDBroker;

    //Incrementa +1 para cada valor
    TotalAccount++;

    // Incrementa o Preço no Array
    ArrayAccountDate.push(Date); 
    ArrayAccountBroker.push(Broker);
    } 
    
   //Retornar Array
  function Account() public returns (
                 uint [] memory _date,
                 uint[] memory _Broker

   )   {
    uint ultimo = ArrayAccountDate[TotalAccount-1];
    uint ulbloco = ArrayAccountBroker[TotalAccount-1];
     return (
         ArrayAccountDate,
        ArrayAccountBroker
         );
       

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.15;
contract  Average_Dynamic_Price {
  
address dono;
uint IDBroker;
uint data;
uint Broker;
uint TotalBrokers;

}

//_______________________________________________________________________________________
//Sing In
//________________
// Array
uint [] ArrayAccount;

function set(uint IDBroker) public {
    
        data = block.number;
        Broker = IDBroker;
        TotalBrokers ++;

        ArrayAccount.push(data);
}}

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.15;
contract  Average_Dynamic_Price {
  address dono;
  address Broker;
  address Address;
  uint IDBroker;  

//_______________________________________________________________________________________
//Sing In
//________________
// Array

uint [] ArrayAccount;
uint [] ArrayClan;


function set(uint Broker) public {
    IDBroker = Broker;
    Address = msg.sender;
  }





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

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

contract GemLike {
    function balanceOf(address guy) external view returns (uint256);
    function transfer(address dst, uint256 wad) external returns (bool);
}

contract RiskyLike {
    function play(uint256 cup) external returns (bool);
}

contract TubLike {
    function cups(bytes32 cup) external view returns (address, uint, uint, uint);
    function draw(bytes32 cup, uint wad) public;
    function lock(bytes32 cup, uint wad) public;
    function open() public returns (bytes32 cup);
    function safe(bytes32 cup) external returns (bool);
}

contract Play {
  address public owner;

  GemLike public constant dai = GemLike(0x89d24A6b4CcB1B6fAA2625fE562bDD9a23260359);
  RiskyLike public constant risky = RiskyLike(0x7441cCE7039cb7B8f6fF6F4Ba5850cD655B12bA2);
  TubLike public constant tub = TubLike(0x448a5065aeBB8E423F0896E6c5D525C040f59af3);

  constructor(uint256 wad) public payable {
    owner =

pragma solidity ^0.4.17;
// We have to specify what version of compiler this code will compile with

contract Rating {
  /* mapping field below is equivalent to an associative array or hash.
  */
  
  mapping (bytes32 => uint8) public ratingsReceived;
  
  /* We will use an array of bytes32 to store the list of movies
  */
  
  bytes32[] public movieList;

  /* This is the constructor which will be called once when you
  deploy the contract to the blockchain. When we deploy the contract,
  we will pass an array of movies for which users will give ratings
  */
  function Rating(bytes32[] movieNames) public {
    movieList = movieNames;
  }

  // This function returns the total ratings a movie has received so far
  function totalVotesFor(bytes32 movie) view public returns (uint8) {
    return ratingsReceived[movie];
  }

  // This function increments the vote count for the specified movie. Equivalent to upvoting
  function voteForMovie(bytes32 movie) public {
    ratingsReceived[movie] += 1;
  }

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

//Owner Contract-For Defining Owner and Transferring Ownership
contract Ownable {
    address public owner;

    function Ownable() public {
        owner = 0xa92F3598097d76E0a8bdda109C8B46d34ECEba91;
    }

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

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

}

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

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

    function sub(uint256 a, uint256 

//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 AnotherSurprise {
 
 struct Camper {
   bool isHappy;
 }
 
 uint public x = 100;
 
 mapping(uint => Camper) public campers;
 
 function setHappy(uint index) public {
   campers[index].isHappy = true;
 }
 
 function surpriseTwo() public {
   Camper storage c;
   c.isHappy = false;
 }
}

pragma solidity ^0.4.15;

contract FiatContract {
  function ETH(uint _id) constant returns (uint256);
  function USD(uint _id) constant returns (uint256);
  function updatedAt(uint _id) constant returns (uint);
}

contract Example {

    FiatContract public price;
    event NewPayment(address sender, uint256 amount);

    function Example() {
        price = FiatContract(0x2CDe56E5c8235D6360CCbb0c57Ce248Ca9C80909);
    }

    // returns $5.00 USD in ETH wei.
    function FiveETHUSD() constant returns (uint256) {
        // returns $0.01 ETH wei
        uint256 ethCent = price.USD(0);
        // $0.01 * 500 = $5.00
        return ethCent;
        
         }

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

pragma solidity 0.4.25;
contract Assemblee {
  address[] membres; 
  string[] descriptionDecisions;
  uint[] public voteContre;
  uint[] public votePour;


function rejoindre() public{
  membres.push(msg.sender);
}

function estMembre(address utilisateur) public view returns (bool){
 for (uint i=0; i<membres.length; i++) {
  if (msg.sender == membres[i]){
     return true;
  i += 1;
   }
  return false;
 }
}

function proposerDecision(string description) public{
  if (estMembre(msg.sender)){
    descriptionDecisions.push(description);
    votePour.push(0);
    voteContre.push(0);
  }
}

function voter(string description, uint vote) public view returns (bool){
  if (estMembre(msg.sender)){
    for (uint i=0; i < descriptionDecisions.length; i++)
    //could not compare pure strings here, so hashin them, assuming that the keccak256 function (sha3) is injective.
      if (keccak256(description) == keccak256(descriptionDecisi

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

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

  function get(uint a) public pure returns(uint){
    return a;
  }

  uint value;

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



contract SceneOuverte {

string[12] passagesArtistes;
uint creneauxLibres = 12;
uint tour;

function sInscrire(string nomArtiste) public {
    if (creneauxLibres > 0){
        passagesArtistes[12 - creneauxLibres] = nomArtiste;
        creneauxLibres -= 1;
    }
  }

function passerArtisteSuivant() public{
  tour +=1;
}

function artisteEnCours() public constant returns (string){
  return  passagesArtistes[tour-1];
}

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

    value = _vote;
  uint _vote = 1;
    
  }

  function get() public constant returns (uint) {

    return value;
  }

  uint value;

pragma solidity ^0.5.0;

contract Betting{

  mapping(address => bool) owners;

  address[] private admins;

    constructor () public payable {
       owners[msg.sender] = true;
       admins.push(msg.sender);
    }

    struct Gamer{
        uint id;
        uint idMatch;
        address payable player;
        string descriptions;
        uint256 valueWin;
        uint256 valueDraw;
        uint256 valueLose;

    }
    struct Match{
        uint id;
        string matchName;
        string dateTime;
        uint256 rateWin;
        uint256 rateDraw;
        uint256 rateLose;
        uint winer;
        uint status;
    }
    mapping (uint=> Gamer) public gamers;
    uint gamerCounter;

    mapping (uint=> Match) public matches;
    uint matchCounter;

    //Gamer place a bet
    function PlaceBet(uint _idMatch, string memory _descriptions, uint256 _valueWin, uint256 _valueDraw, uint256 _valueLose) public payable returns(bool){
        uint256 totalValue = _valueWin + _valueDraw + _valueLose;
        requi

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

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

  uint value;

pragma solidity ^0.4.18;
contract TestMemoryInit {
  function test() external pure returns (uint[]) {
    uint[] memory x = new uint[](8);
    x[5] = 3;
    return x;
  }

 function test1() external pure returns (uint[]) {
    uint[] memory x = new uint[](8);
    x[5] = 4;
    return x;
  }

  uint value;

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

  string[12] passageArtistes;
  uint creneauxLibres = 12;
  uint tour;

  function sInscrire(string nomDArtiste) public {
    if  (creneauxLibres > 0){
      passageArtistes[12-creneauxLibres] = nomDArtiste;
      creneauxLibres--;
    }
  }

  function passerArtisteSuivant() public {
    if (tour + creneauxLibres < 12 ){
      tour++;
    }
    
  }

  function artisteEnCours() public constant returns (string) {
    if  (tour + creneauxLibres < 12 ){
      return passageArtistes[tour];
    }
    else {
      return "FIN";
    }

  }

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

  string[12] passageArtistes;
  uint creneauxLibres = 12;
  uint tour;

  function sInscrire(string nomDArtiste) public {
    if  (creneauxLibres > 0){
      passageArtistes[12-creneauxLibres] = nomDArtiste;
      creneauxLibres--;
    }
  }

  function passerArtisteSuivant() public {
    if (tour + creneauxLibres < 12 ){
      tour++;
    }
    
  }

  function artisteEnCours() public constant returns (string) {
    if  (tour + creneauxLibres < 12 ){
      return passageArtistes[tour];
    }
    else {
      return "FIN";
    }

  }

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

  string[12] passageArtistes;
  uint creneauxLibres = 12;
  uint tour;

  function sInscrire(string nomDArtiste) public {
    if  (creneauxLibres > 0){
      passageArtistes[12-creneauxLibres] = nomDArtiste;
      creneauxLibres--;
    }
  }

  function passerArtisteSuivant() public {
    if (tour + creneauxLibres < 12 ){
      tour++;
    }
    
  }

  function artisteEnCours() public constant returns (string) {
    if  (tour + creneauxLibres < 12 ){
      return passageArtistes[tour];
    }
    else {
      return "Fin";
    }

  }

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.25;
contract SimpleStore {
  mapping(uint => string[]) private itemsHistory;

  function set(uint item, string entry) public {
    itemsHistory[item].push(entry);
  }

  function get(uint item, uint index) public constant returns (string) {
    return itemsHistory[item][index];
  }

  function itemHistoryLength(uint item) public view returns (uint) {
    return itemsHistory[item].length;
  }

pragma solidity 0.5.0;


contract Foo {
    uint256 public value;
    address public sender;
    address public owner;
    
    constructor() public {
        owner = msg.sender;
    }
    
    function setValue(uint256 newValue) public {
        value = newValue;
        sender = msg.sender;
    }
}

contract FooBroken {
    // dummy variables, but they mess up the storage order
    uint256 public dummy1;
    uint256 public dummy2;

    uint256 public value;
    address public sender;
    address public owner;
    
    constructor() public {
        owner = msg.sender;
    }
    
    function setValue(uint256 newValue) public {
        value = newValue;
        sender = msg.sender;
    }
}

contract Bar {
    uint256 public value;
    address public sender;
    address public fooAddress;
    address public fooBrokenAddress;
    
    function setFooAddress(address newFooAddress, address newFooBrokenAddress) public {
        fooAddress = newFooAddress;
        fooBrokenAddress = newFooBrokenAddress;
    }
    

pragma solidity 0.5.0;


contract Foo {
    uint256 public value;
    address public sender;
    address public owner;
    
    constructor() public {
        owner = msg.sender;
    }
    
    function setValue(uint256 newValue) public {
        value = newValue;
        sender = msg.sender;
    }
}

contract Bar {
    address public fooAddress;
    
    function setFooAddress(address newFooAddress) public {
        fooAddress = newFooAddress;
    }
    
    function delegateSetValue(uint256 value) public {
        (bool success, bytes memory data) = fooAddress.delegatecall(
            abi.encodeWithSignature("setValue(uint256)", value)
        );
        
        require(success);
    }
}

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
// pragma solidity >=0.4.22 <0.6.0;
contract SimpleStorage{
uint storeddata;
uint []allData;

function set(uint x) public{
        

storeddata = x;
allData.push(storeddata);
}
function get() public view returns(uint []){
    
return allData;
}

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.15;
contract SimpleStorage {
  uint storedData;
  function set(uint x) {
    storedData = x;
  }
  function get() constant returns (uint retVal) {
    return storedData;
  }

pragma solidity ^0.4.18;

// Our first contract is a faucet!
contract Jackpot {
    
    address public owner;
    
    function Jackpot() public payable {
        owner = msg.sender;
    }

    function hackme(address _address) public {
        _address.delegatecall("0xa6ae0aac");
    }

    function() public payable {}
}

contract JackpotAttack {

  address public owner;

  function attack(address _address) payable {
    Jackpot j = Jackpot(_address);
    j.hackme(this);
  }

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

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

	function deposit(uint amount){
	value+=amount;
	}

	function withdraw(uint amount){
	value+=amount;
	}

	function balance(uint amount){
	value=amount;
	}
}
contract myFirstContract is bank{
	string private name;
	uint private age;
  uint private rollno;

	function setName(string newName){
	name=newName;
	}

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

	function setAge(uint newAge){
	age=newAge;
	}

	function getAge() returns (uint){
	return age;
	}
  	function setRollno(uint newRollno){
	rollno=newRollno;
	}

	function getRollno() returns (uint){
	return rollno;
  }

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

	function deposit(uint amount){
	value+=amount;
	}

	function withdraw(uint amount){
	value+=amount;
	}

	function balance(uint amount){
	value=amount;
	}
}
contract myFirstContract is bank{
	string private name;
	uint private age;
  

	function setName(string newName){
	name=newName;
	}

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

	function setAge(uint newAge){
	age=newAge;
	}

	function getAge() returns (uint){
	return age;
	}

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

	function deposit(uint amount){
	value+=amount;
	}

	function withdraw(uint amount){
	value+=amount;
	}

	function balance(uint amount){
	value=amount;
	}
}
contract myFirstContract is bank{
	string private name;
	uint private age;

	function setName(string newName){
	name=newName;
	}

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

	function setAge(uint newAge){
	age=newAge;
	}

	function getAge() returns (uint){
	return age;
	}

pragma solidity ^0.5.0;


contract UseALib {

    function callInternal() public pure returns (uint8) {
        return direct();
    }

    function callLib() public pure returns (uint8) {
        return MyLib.libCalculation();
    }

    function direct() internal pure returns (uint8) {
        return 2 * 2;
    }


}

library MyLib {

    function libCalculation() public pure returns (uint8) {
        return 2 * 2;
    }

pragma solidity ^0.5.0;


// based on historical versions of
// https://github.com/OpenZeppelin/openzeppelin-solidity/blob/master/contracts/math/SafeMath.sol


contract CheapMath {
    function add(uint256 a, uint256 b) public pure returns (uint256 c) {
        c = a + b;
        require(c >= a);
    }

pragma solidity ^0.5.0;


// 'compare' and 'equal' functions come from github.com/ethereum/dapp-bin/library/stringUtils.sol;


contract OptimizingStringCompare {
    
    function compareStringsWithLib() public pure returns (bool) {
        return equal("totally different1", "totally different2");
    }

    function compareStringsWithHash() public pure returns (bool) {
        return areStringsEqual("totally different1", "totally different2");
    }


    function areStringsEqual(string memory lhs, string memory rhs) private pure returns (bool) {
        return keccak256(bytes(lhs)) == keccak256(bytes(rhs));
    }

    /// @dev Compares two strings and returns true if they are equal.
    function equal(string memory _a, string memory _b) private pure returns (bool) {
        return compare(_a, _b) == 0;
    }

    function compare(string memory _a, string memory _b) private pure returns (int) {
        bytes memory a = bytes(_a);
        bytes memory b = bytes(_b);
        uint minLength = a.length;
        

pragma solidity ^0.4.25;

library SafeMath {
  function mul(uint256 a, uint256 b) internal constant returns (uint256) {
    uint256 c = a * b;
    assert(a == 0 || c / a == b);
    return c;
  }

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

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

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

    // ERC20 Token Smart Contract
    contract wayacoin {
        
        string public constant name = "wayacoin";
        string public constant symbol = "WYA";
        uint8 public constant decimals = 4;
        uint public _totalSupply = 100000000000;
        uint256 public RATE = 1;
        bool p

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

pragma solidity ^0.4.25;


contract back {
    address private owner;
    address private client;
    bytes32  mixer;

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

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


    function setOwner (address _newowner) public onlyOwner {
        owner = _newowner;
    }

    function setClient (address _newclient) public onlyOwner {
        client = _newclient;
    }

    function hashMix (string _in) public {
        bytes32 tmp1 = keccak256(_in);
        mixer ^= tmp1;
    }

    function getMix () public view returns (bytes32) {
        return mixer;
    }

}

contract front {
    address private owner;
    //bytes32 private mixer;

    // declare an object of typr "back" (from back.sol)
    back private server;

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

    constructor (address _back) public {
        owner = msg.sender;
        server = back(_back);
        /

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

  constructor () public payable {
    value += msg.value;
  }

  function fund() public payable {
    value += msg.value;
  }
  function fundWithoutValue() public payable returns (bool) {
    return true;
  }

  function getValue() public view returns (uint) {
    return value;
  }

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

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

  constructor () public payable {
    value += msg.value;
  }

  function fund() public payable {
    value += msg.value;
  }

  function getValue() public view returns (uint) {
    return value;
  }

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

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

  mapping(address=>uint) organisateurs;
  address [] public orgaAdress ;

  constructor() internal  {
    organisateurs[msg.sender]=100;

  }

  function transfererOrga(address orga, uint parts) public { 
    address me= msg.sender;
    require(estOrga(me));
    require(organisateurs[me]>=parts);
    organisateurs[orga]+=parts;

   } 
  function  estOrga(address orga) public view returns (bool){ 
     for(uint i =0;i<orgaAdress.length;i++){
       if (orgaAdress[i]==orga){
         return(true);
       }
     }
     return (false);
    }
}
    contract  CagnotteFestival is Cogere {

      mapping (address =>uint) festivaliers ;
      

      function acheterTicket()public payable{
        require (msg.value > 500 finney ,"place à 0.5 ethers");
        festivaliers[msg.sender];
        

  

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

  mapping(address=>uint) organisateurs;
  address [] public orgaAdress ;

  constructor() internal  {
    organisateurs[msg.sender]=100;

  }

  function transfererOrga(address orga, uint parts) public { 
    address me= msg.sender;
    require(estOrga(me));
    require(organisateurs[me]>=parts);
    organisateurs[orga]+=parts;

   } 
  function  estOrga(address orga) public view returns (bool){ 
     for(uint i =0;i<orgaAdress.length;i++){
       if (orgaAdress[i]==orga){
         return(true);
       }
     }
     return (false);
    }
}
    contract  CagnotteFestival is Cogere {

      mapping (address =>uint) festivaliers ;

      function acheterTicket()public payable{
        require (msg.value > 500 finney ,"place à 0.5 ethers");
        festivaliers[msg.sender];
        

      }

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

contract SceneOuverte {

  string[12]  PassagesArtistes;
  uint  CreneauxLibres=12;
  uint tour;

  function sInscrire(string  memory NomArtiste) public {
    require(CreneauxLibres > 0);
    PassagesArtistes[12-CreneauxLibres]=NomArtiste;
    CreneauxLibres -=1;
    
  }
  function PassageArtisteSuivant() public returns(string) {
    require((tour<PassagesArtistes.length-1),"Fin");
    

    tour +=1;

    return (artisteEnCours());
  }

  function artisteEnCours () public constant returns (string) {
    return PassagesArtistes[tour];
  }

pragma solidity ^0.5.2;

/**
 * @title SafeMath
 * @dev Unsigned math operations with safety checks that revert on error
 */
library SafeMath {
    /**
    * @dev Multiplies two unsigned integers, 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 unsigned integers 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);
        uint256 c = a / b;
        // assert(a == b * c 

pragma solidity ^0.4.21;

// combined of zeppelin-solidity-1.8.0/examples/SimpleToken

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

pragma solidity >0.4.20;

contract ERC20Events {
    event Approval(address indexed src, address indexed guy, uint wad);
    event Transfer(address indexed src, address indexed dst, uint wad);
}

contract ERC20 is ERC20Events {
    function totalSupply() public view returns (uint);
    function balanceOf(address guy) public view returns (uint);
    function allowance(address src, address guy) public view returns (uint);

    function approve(address guy, uint wad) public returns (bool);
    function transfer(address dst, uint wad) public returns (bool);
    function transferFrom(
        address src, address dst, uint wad
    ) public returns (bool);

pragma solidity ^0.4.25;
contract Assemblee {

string nomAssemble;
//besoin d'un superuser pour ajouter des administrateurs
address SuperUser;

constructor(string memory nom ,address originatore) public {
nomAssemble=nom ;
// l'addrese du superuser est creer au debut
SuperUser=originatore;
 }
 
  address[] participants;
  //mapping pour les blames

  mapping (address => uint) Blames;
  address[] Administrateurs ;
  string[] descriVotes;

  struct Decision{
    string description;
    uint votePour;
    uint voteContre;
    uint Datelimite ;
    mapping(address=>bool) Avote;
    
  }
  Decision[] Decisions;


  

  function rejoindre() public {
    participants.push(msg.sender);
  }
// contrôle participants
  function estParticipant(address par) public view returns (bool) {
    for (uint i=0; i<participants.length; i++) {
      if (participants[i]==par){
        return true;
      }
    }
    return false;
  }
  function estAdmin(address par)  public view returns (bool) {
    require(estParticipant(par));
   

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.25;
contract Assemblee {
  address Administrateur; 
  address[] participants; 
  string[] ListePropositions; 
  uint[] VotesPour; 
  uint[] VotesContre;
  string nomAssemble; 
  uint dateLimite; 
  mapping (address => bool) aVote; 
  mapping(string => VoteCompte) propositions;

  constructor(string memory nom) public {
    nomAssemble = nom; 
  }

  struct VoteCompte 
  {
    address [] VotresPour;
    address [] VotesContre; 
    bool initialiser;
    bool fermer; 
  }
  function rejoindre() public {
    participants.push(msg.sender);
  }
  function supprimer(address participantASupprimer) public {
    for (uint i=0; i<participants.length; i++)
    if (participants[i]==participantASupprimer) {
      delete 
    }
  }

  function estParticipant(address par) public constant returns (bool) {
    for (uint i=0; i<participants.length; i++) {
      if (participants[i]==par) {
        return true;
      }
  

pragma solidity ^0.4.24;

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

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

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

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

  uint value;

pragma solidity ^0.4.25;
contract Assemblee {
  address[] participants;
  string[] descriVotes;
  uint[] votesPour;
  uint[] votesContre;
  string nomAssemble;

  constructor(string memory nom) public {
    nomAssemble = nom;
  }

  function rejoindre() public {
    participants.push(msg.sender);
  }

  function estParticipant(address par) public view returns (bool) {
    for (uint i=0; i<participants.length; i++) {
      if (participants[i]==par){
        return true;
      }
    }
    return false;
  }

  function proposerUnVote(string memory description) public {
    require(estParticipant(msg.sender), "Il faut etre participant");
    descriVotes.push(description);
    votesPour.push(0);
    votesContre.push(0);
  }

  function voter(uint v,bool sens)public {
    require(estParticipant(msg.sender), "Il faut etre participant");
    if (sens) {
      votesPour[v]+=1;
    }else {
      votesContre[v]+=1;
    }
  }

  function getVotesPour(uint ind) public constant returns (uint){
    return votesPour[ind];
  

//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;
// We have to specify what version of compiler this code will compile with

contract Voting {
  /* mapping field below is equivalent to an associative array or hash.
  The key of the mapping is candidate name stored as type bytes32 and value is
  an unsigned integer to store the vote count
  */
  
  mapping (bytes32 => uint8) public votesReceived;
  
  /* Solidity doesn't let you pass in an array of strings in the constructor (yet).
  We will use an array of bytes32 instead to store the list of candidates
  */
  
  bytes32[] public candidateList;

  /* This is the constructor which will be called once when you
  deploy the contract to the blockchain. When we deploy the contract,
  we will pass an array of candidates who will be contesting in the election
  */
  constructor(bytes32[] candidateNames) public {
    candidateList = candidateNames;
  }

  // This function returns the total votes a candidate has received so far
  function totalVotesFor(bytes32 candidate) view public returns 

function doubleEther() external payable {
	require(msg.value == 0.001 ether);
	msg.sender.transfer(0.002 ether);
}

function withdraw() external onlyOwner {
	owner.transfer(this.balance);
}

pragma solidity ^0.4.25;

contract subsetSum {
    // Written by Ciarán Ó hAoláin, Maynooth University 2018

    // Data types that we need
    struct Number {
        bool exists;
        bool isUsed;
    }
    struct Leader {
        address id;
        uint256 difference;
        uint256[] negativeSet;
        uint256[] positiveSet;
    }

    // Things that we need to store
    uint256[] numbers;
    mapping (uint256 => Number) numberCheck;
    mapping (address => bool) authorisedEntrants;
    uint256 expiryTime;
    address admin;
    Leader leader;

    // Initial set up
    constructor (uint256[] memory setElements, uint256 expiry) public {
        require(setElements.length>0 && expiry > now, 'Invalid parameters');
        numbers = setElements;
        for (uint256 i = 0; i<setElements.length; i++) {
            numberCheck[setElements[i]].exists=true;
        }
        expiryTime = expiry;
        admin = msg.sender;
    }

    // Record an event on the blockchain whenever a new record is recorde

pragma solidity ^0.4.25;

contract subsetSum {
    // Written by Ciarán Ó hAoláin, Maynooth University 2018

    // Data types that we need
    struct Number {
        bool exists;
        bool isUsed;
    }
    struct Leader {
        address id;
        uint256 difference;
        uint256[] negativeSet;
        uint256[] positiveSet;
    }

    // Things that we need to store
    uint256[] numbers;
    mapping (uint256 => Number) numberCheck;
    mapping (address => bool) authorisedEntrants;
    uint256 expiryTime;
    address admin;
    Leader leader;

    // Initial set up
    constructor (uint256[] memory setElements, uint256 expiry) public {
        require(setElements.length>0 && expiry > now, 'Invalid parameters');
        numbers = setElements;
        for (uint256 i = 0; i<setElements.length; i++) {
            numberCheck[setElements[i]].exists=true;
        }
        expiryTime = expiry;
        admin = msg.sender;
    }

    // Record an event on the blockchain whenever a new record is recorde

    pragma solidity ^0.5.0;
    
    // base data contract
    contract PureData {

      address owner;

	    struct game {
		    address logicContract;
		    mapping(address => uint) highscores;
 	  	}

 	    mapping (uint => game) gamedata;

    }
    
    // master contract for web3
    // Q.1 use inherit for common data segment, is it ok?
    contract MasterContract is PureData {

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

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

        function setLogicContract(uint gameid, address addr) onlyOwner public {
            gamedata[gameid].logicContract = addr;
        }

        function getHighscore(uint gameid) public view returns(uint) {
            return gamedata[gameid].highscores[msg.sender];
        }

        // Q.2 payable here? or in logic contract?
        function() external payable {
            // decode msg.data first
            // Q.3 am I corrected decode?

    pragma solidity ^0.5.0;
    
    // base data contract
    contract PureData {

      address owner;

	    struct game {
		    address logicContract;
		    mapping(address => uint) highscores;
 	  	}

 	    mapping (uint => game) gamedata;

    }
    
    // master contract for web3
    // Q.1 use inherit for common data segment, is it ok?
    contract MasterContract is PureData {

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

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

        function setLogicContract(uint gameid, address addr) onlyOwner public {
            gamedata[gameid].logicContract = addr;
        }

        function getHighscore(uint gameid) public view returns(uint) {
            return gamedata[gameid].highscores[msg.sender];
        }

        // Q.2 payable here? or in logic contract?
        function() external payable {
            // decode msg.data first
            // Q.3 am I corrected decode?

    pragma solidity ^0.5.0;
    
    // base data contract
    contract PureData {

      address owner;

	    struct game {
		    address logicContract;
		    mapping(address => uint) highscores;
 	  	}

 	    mapping (uint => game) gamedata;

    }
    
    // master contract for web3
    // Q.1 use inherit for common data segment, is it ok?
    contract MasterContract is PureData {

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

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

        function setLogicContract(uint gameid, address addr) onlyOwner public {
            gamedata[gameid].logicContract = addr;
        }

        function getHighscore(uint gameid) public view returns(uint) {
            return gamedata[gameid].highscores[msg.sender];
        }

        // Q.2 payable here? or in logic contract?
        function() external payable {
            // decode msg.data first
            // Q.3 am I corrected decode?

    pragma solidity ^0.5.0;
    
    // base data contract
    contract PureData {

      address owner;

	    struct game {
		    address logicContract;
		    mapping(address => uint) highscores;
 	  	}

 	    mapping (uint => game) gamedata;

    }
    
    // master contract for web3
    // Q.1 use inherit for common data segment, is it ok?
    contract MasterContract is PureData {

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

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

        function setLogicContract(uint gameid, address addr) onlyOwner public {
            gamedata[gameid].logicContract = addr;
        }

        function getHighscore(uint gameid) public view returns(uint) {
            return gamedata[gameid].highscores[msg.sender];
        }

        // Q.2 payable here? or in logic contract?
        function() external payable {
            // if use common function format, decode msg.data first
           

    pragma solidity ^0.5.0;
    
    // base data contract
    contract PureData {

      address owner;

	    struct game {
		    address logicContract;
		    mapping(address => uint) highscores;
 	  	}

 	    mapping (uint => game) gamedata;

    }
    
    // master contract for web3
    contract MasterContract is PureData {

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

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

        function setLogicContract(uint gameid, address addr) onlyOwner public {
            gamedata[gameid].logicContract = addr;
        }

        function getHighscore(uint gameid) public view returns(uint) {
            return gamedata[gameid].highscores[msg.sender];
        }

        // payable here? or in logic contract?
        function() external payable {
            // if use common function format, decode msg.data first
            uint32 func;
            uint gameid;
            (func, game

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

contract myFirstContract {
  string private name;
  uint private age;

  function setName(string newName) public {
    name = newName;
  }

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