pragma solidity 0.4.25;

contract OrderManager {
  struct Order {
    uint256 foo;
    bool isOpen;
  }

  Order[] public orders;

  mapping (address => uint256[]) usersToOrders;

  function createOrder(uint256 foo) public {
    uint256 orderId = orders.push(
      Order({
        foo: foo,
        isOpen: true
      })
    ) - 1;

    usersToOrders[msg.sender].push(orderId);
  }

  function getOrder(uint256 orderId) public view returns (
    uint256 foo,
    bool isOpen
  ) {
    return (
      orders[orderId].foo,
      orders[orderId].isOpen
    );
  }

  function updateOrder(uint256 orderId, bool newStatus) public {
    orders[orderId].isOpen = newStatus;
  }
Apr 25, 2019 09:12:06 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

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

  uint value;
Apr 25, 2019 02:45:36 UTC

pragma solidity >=0.4.22 <0.6.0;

contract marblesContract {
    
address public contractOwner;


//Marble attributes
  struct Marble {
    string marbleName; 
    uint uuid;
    uint  marblePrice;
    string  marbleColor; 
    string description;
    uint indexInArray;
    bool initialized;

}

modifier onlyOwner(){
        require(msg.sender == contractOwner);
        _;
    }
    
//mapping array to map the marbles
mapping(uint  => Marble) private idToMarbleMap;

//mapping to check the ownership
mapping(address => mapping(uint => bool)) private addressToIdToIsOwnedMap;

//mapping array to save the marbles
mapping(address => Marble[]) private marblesOfAddress;

//Create events to confirm the transaction
event MarbleCreate(address account, uint uuid);

//Reject events to tract rejected transaction
event RejectCreate(address account, uint uuid, string message);

//To track ownership of the marbles
event MarbleTransfer(address from, address to, uint uuid);
event RejectTransfer(address from, address to, uint u
Apr 24, 2019 12:54:46 UTC
pragma solidity >=0.4.0 <0.7.0;

contract SimpleStorage {
    uint storedData;

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

    function get() public view returns (uint) {
        return storedData;
    }
Apr 24, 2019 08:35:23 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.5.6;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

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

  uint value;
Apr 24, 2019 04:08:56 UTC
pragma solidity ^0.4.25;

contract OnlineStore {
    uint public i;
    function buySomething() external payable {
        require(msg.value == 0.001 ether);
        i++;
    }
Apr 23, 2019 10:21:09 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

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

  uint value;
Apr 23, 2019 09:34:20 UTC
pragma solidity ^0.4.25;

contract contratoDeVentas {
    address public propietario;
    uint256 public fechaDeActualizacion;
    string public descripcion;
    uint public precio;
    bool public aLaVenta = true;	
	
	string public estadoActual;
    event eventoEstadoActual(string _msg, address user, uint amount, uint256 time);
    
    constructor (string memory _descripcion, uint _precio) public payable {
        propietario = msg.sender;
		fechaDeActualizacion = block.timestamp;
        descripcion = _descripcion;
        precio = _precio;
        emit eventoEstadoActual('Artículo a la venta:', msg.sender, msg.value, block.timestamp);
		estadoActual = 'Artículo a la venta.';
    }
    
    function comprar() public payable {
        if(msg.value >= precio && aLaVenta == true) {
            propietario.transfer(address(this).balance);
            propietario = msg.sender;
            aLaVenta = false;
            emit eventoEstadoActual('Artículo comprado y retirado de la venta', msg.sender, msg.value, 
Apr 23, 2019 09:34:15 UTC
example.sol

pragma solidity ^0.5.2;  

import "http://github.com/OpenZeppelin/openzeppelin-solidity/contracts/token/ERC20/ERC20.sol";
import "http://github.com/OpenZeppelin/openzeppelin-solidity/contracts/ownership/Ownable.sol";
import "http://github.com/OpenZeppelin/openzeppelin-solidity/contracts/token/ERC20/ERC20Detailed.sol";

  /**  
  * @title ExampleToken is basic ERC20 Token  
  */  
contract ExampleCoin is ERC20, ERC20Detailed, Ownable{  

  uint256 public initialSupply  = 100000000000000000000000000; 
  

  constructor() public payable ERC20Detailed("ExampleCoin", "EXC", 18) {  
  /**  
  * @dev assign totalSupply to account creating this contract 
  */  
   _mint(msg.sender, initialSupply);

 }
    
}



sendable.sol

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 transf
Apr 22, 2019 20:41:34 UTC
pragma solidity ^0.5.2;  

import "http://github.com/OpenZeppelin/openzeppelin-solidity/contracts/token/ERC20/ERC20.sol";
import "http://github.com/OpenZeppelin/openzeppelin-solidity/contracts/ownership/Ownable.sol";
import "http://github.com/OpenZeppelin/openzeppelin-solidity/contracts/token/ERC20/ERC20Detailed.sol";

  /**  
  * @title ExampleToken is basic ERC20 Token  
  */  
contract ExampleCoin is ERC20, ERC20Detailed, Ownable{  

  uint256 public initialSupply  = 100000000000000000000000000; 
  

  constructor() public payable ERC20Detailed("ExampleCoin", "EXC", 18) {  
  /**  
  * @dev assign totalSupply to account creating this contract 
  */  
   _mint(msg.sender, initialSupply);

 }
    
Apr 22, 2019 20:39:48 UTC
pragma solidity ^0.5.2;

contract AbstractENS {
    function owner(bytes32 node) public view returns(address);
    function resolver(bytes32 node) public view returns(address);
    function ttl(bytes32 node) public view returns(uint64);
    function setOwner(bytes32 node, address _owner) public;
    function setSubnodeOwner(bytes32 node, bytes32 _label, address _owner) public;
    function setResolver(bytes32 node, address _resolver) public;
    function setTTL(bytes32 node, uint64 _ttl) public;

    // Logged when the owner of a node assigns a new owner to a subnode.
    event NewOwner(bytes32 indexed node, bytes32 indexed label, address owner);

    // Logged when the owner of a node transfers ownership to a new account.
    event Transfer(bytes32 indexed node, address owner);

    // Logged when the resolver for a node changes.
    event NewResolver(bytes32 indexed node, address resolver);

    // Logged when the TTL of a node changes
    event NewTTL(bytes32 indexed node, uint64 ttl);
}

/**
 * A simple r
Apr 22, 2019 04:39:46 UTC
pragma solidity ^0.4.18;

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

contract Example {

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

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

    /*
     * Frees `free' tokens from the Gastoken at address `gas_token'.
     * The freed tokens belong
Apr 21, 2019 14:43:53 UTC
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;
    }
Apr 21, 2019 01:46:21 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.11;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

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

  uint value;
Apr 21, 2019 01:44:16 UTC
pragma solidity ^0.4.21;


contract CRBTTToken {
    // 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 = tru
Apr 21, 2019 01:43:06 UTC
pragma solidity >= 0.4.24;

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;
    }
Apr 21, 2019 01:42:32 UTC
pragma solidity >= 0.4.24;

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;
    }
Apr 19, 2019 22:23:56 UTC
solidez pragma ^ 0.4.18
Apr 19, 2019 03:58:15 UTC
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 =>
Apr 17, 2019 22:36:08 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
  pragma solidity ^0.4.18;
  contract SimpleStore {
    function setName(string _name) public {
      name = _name;
    }
    function setFrom(string _from) public {
      from = _from;
    }
    function setTo(string _to) public {
      to = _to;
    }
    function setValue(uint _value) public {
      value = _value;
    }

    function getName() public constant returns (string) {
      return name;
    }
    function getFrom() public constant returns (string) {
      return from;
    }
    function getTo() public constant returns (string) {
      return to;
    }
    function getValue() public constant returns (uint) {
      return value;
    }

    string name;
    string from;
    string to;
    uint value;
  
Apr 16, 2019 11:16:48 UTC
pragma solidity 0.4.18;

// Contract to test unsigned integer underflows and overflows
// note: uint in solidity is an alias for uint256

// Guidelines: Press "Create" to the right, then check the values of max and zero by clicking "Call"
// Then, call overflow and underflow and check the values of max and zero again

contract OverflowUnderFlow {
    uint public zero = 0;
    uint public max = 2**256-1;
    
    // zero will end up at 2**256-1
    function underflow() public {
        zero -= 1;
    }
    // max will end up at 0
    function overflow() public {
        max += 1;
    }
Apr 16, 2019 09:13:16 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract LandAresh { 

     

    address public owner;  

    uint public defaultCost; 

    uint public mainLandCost; 

    

    mapping(uint => mapping(uint => address))public properties; 

    mapping(uint => mapping(uint => address))public landContent; 

    mapping(uint => mapping(uint => bool))public status; 

    mapping(uint => mapping(uint => uint))public prices; 

     

    function LandAresh() public { 

        owner = msg.sender; 

    } 

    //x and y represent the position of the land in a GRID 

    function setLandPrice(uint x,uint y,uint price) public 

    { 

       if(status[x][y]) 

       { 

            if(msg.sender==properties[x][y]) 

            { 

                prices[x][y]=price; 

            } 

       } 

       else 

       { 

            if(msg.sender==owner) 

            { 

                prices[x][y]=price; 

            } 

        } 

    } 

     
Apr 15, 2019 18:00:48 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

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

  uint value;
Apr 11, 2019 01:44:28 UTC
pragma solidity ^0.5.0;

contract SolidityCafe {

Apr 10, 2019 14:41:29 UTC
pragma solidity ^0.5.0;

contract SolidityCafe {
  // menu
  ItemDescr[] public menu;
Apr 10, 2019 14:39:57 UTC
pragma solidity ^0.5.0;

contract SolidityCafe {
  // description of items on the menu
    struct ItemDescr {
      string name;
      uint price;
      string ingredients;
      bool hot;
    }
  // menu
  ItemDescr[] public menu;
Apr 10, 2019 14:39:03 UTC
pragma solidity ^0.5.0;

contract SolidityCafe {
  // description of items on the menu
    struct ItemDescr {
      string name;
      uint price;
      string ingredients;
      bool hot;
    }
  // menu
  ItemDescr[] public menu;
  // list of loyal customers with their points
  mapping(address => uint) loyalCustomers;
Apr 10, 2019 14:37:46 UTC
pragma solidity ^0.5.0;

contract SolidityCafe {
  // owner of the contract
  address payable owner;
  // description of items on the menu
    struct ItemDescr {
      string name;
      uint price;
      string ingredients;
      bool hot;
    }
  // menu
  ItemDescr[] public menu;
  // list of loyal customers with their points
  mapping(address => uint) loyalCustomers;
Apr 10, 2019 14:36:34 UTC
pragma solidity ^0.5.0;

contract SolidityCafe {
  // owner of the contract
  address payable owner;
  // description of items on the menu
    struct ItemDescr {
      string name;
      uint price;
      string ingredients;
      bool hot;
    }
  // menu
  ItemDescr[] public menu;
  // list of loyal customers with their points
  mapping(address => uint) loyalCustomers;
  // event emitted when payment is done
  event LogPayment(address _address, uint amount);
Apr 10, 2019 14:35:55 UTC
pragma solidity ^0.5.0;

contract SolidityCafe {
  // owner of the contract
  address payable owner;
  // description of items on the menu
    struct ItemDescr {
      string name;
      uint price;
      string ingredients;
      bool hot;
    }
  // menu
  ItemDescr[] public menu;
  // list of loyal customers with their points
  mapping(address => uint) loyalCustomers;
  // event emitted when payment is done
  event LogPayment(address _address, uint amount);
  
  constructor() public {
    owner = msg.sender;
  }
Apr 10, 2019 14:34:52 UTC
pragma solidity ^0.5.0;

contract SolidityCafe {
  // owner of the contract
  address payable owner;
  // description of items on the menu
    struct ItemDescr {
      string name;
      uint price;
      string ingredients;
      bool hot;
    }
  // menu
  ItemDescr[] public menu;
  // list of loyal customers with their points
  mapping(address => uint) loyalCustomers;
  // event emitted when payment is done
  event LogPayment(address _address, uint amount);
  
  modifier onlyOwner {
    require(msg.sender == owner, "You are not allowed to perform this action!");
    _;
  }
  
  constructor() public {
    owner = msg.sender;
  }
Apr 10, 2019 14:31:02 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

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

  uint value;
Apr 10, 2019 06:15:16 UTC
pragma solidity ^0.5.1;
contract DExchange {
    
    address owner;
    mapping (address => uint256) balance_1;
    mapping (address => uint256) balance_2;
    mapping (address => uint256) reserved_1;
    mapping (address => uint256) reserved_2;
    mapping (string => address) creator;
    mapping (string => string) time;
    mapping (string => uint256) volume;
    mapping (string => uint256) price;
    mapping (string => bool) status;
        
    constructor () public {
        owner = msg.sender;
        
    }    
    
    
    modifier onlyOwner {
        require(owner == msg.sender);
        _;
    }

    
    
    function Deposit (uint256 _currency, uint256 _volume, address _receiver) onlyOwner public {
        if (_currency == 1) {
            balance_1[_receiver]+=_volume;
        } else if (_currency == 2) {
            balance_2[_receiver]+=_volume;
        }
    }
    
    
    function Withdraw (uint256 _currency, uint256 _volume, address _receiver) onlyOwner public {
        if (_currency == 1
Apr 06, 2019 20:54:06 UTC
pragma solidity >=0.5.0 <0.6.0;


import "tzero/compliance/ComplianceRule.sol";
import "tzero/libs/lifecycle/Destroyable.sol";


contract RestrictFromInvestor is ComplianceRule, Destroyable {
  
    uint8 INVESTOR = 4;

    /**
     *  Blocks when the receiver is an investors.
     */
    function check(address initiator, address from, address to, uint8 toKind, uint256 tokens, Storage store)
    external {
        require(toKind != INVESTOR, "The to address cannot be an investor");
    }
Apr 05, 2019 17:48:40 UTC
 modifier onlyCustodian() {
    require(store.accountExists(msg.sender, CUSTODIAN), "Custodian address required");
    require(!store.accountFrozen(msg.sender), "Custodian is frozen");
    _;
}
/**
  *  Sets the storage contract address
  *  @param s The Storage contract to use
  */
function setStorage(Storage s)
onlyOwner
external {
    store = s;
}

/**
  *  Adds a brokerDealer to the registry
  *  Upon successful addition, the contract must emit `BrokerDealerAdded(brokerDealer)`
  *  THROWS if the address has already been added, or is zero
  *  @param brokerDealer The address of the broker-dealer
  */
function add(address brokerDealer)
onlyCustodian
external {
    store.addAccount(brokerDealer, BROKER_DEALER, false, msg.sender);

    emit BrokerDealerAdded(brokerDealer, msg.sender);
}
Apr 05, 2019 17:30:50 UTC
 /**
  *  Ensures the `msg.sender` has permission for the given kind/type of account.
  */
modifier isAllowed(uint8 kind) {
    require(kind > 0, "Invalid, or missing permission");
    if (msg.sender != owner) {
        require(permissions[kind].exists(msg.sender), "Missing permission");
    }
    _;
}
/**
  *  Adds an account to storage
  *  THROWS when `msg.sender` doesn't have permission
  *  THROWS when the account already exists
  *  @param addr The address of the account
  *  @param kind The kind of account
  *  @param isFrozen The frozen status of the account
  *  @param parent The account parent/owner
  */
function addAccount(address addr, uint8 kind, bool isFrozen, address parent)
isUnlocked
isAllowed(kind)
external {
    require(accounts.append(addr, kind, isFrozen, parent), "Account already exists");
}

 /**
  *  Grants the address permission for the given kind
  *  @param kind The kind of address
  *  @param addr The address
  */
function grantPermission(uint8 kind, address addr)
isUnlocked
isAllo
Apr 05, 2019 17:16:25 UTC
 /**
  *  Ensures the `msg.sender` has permission for the given kind/type of account.
  *
  *    - The `owner` account is always allowed
  *    - Addresses/Contracts must have a corresponding entry, for the given kind
  */
modifier isAllowed(uint8 kind) {
    require(kind > 0, "Invalid, or missing permission");
    if (msg.sender != owner) {
        require(permissions[kind].exists(msg.sender), "Missing permission");
    }
    _;
}
/**
  *  Adds an account to storage
  *  THROWS when `msg.sender` doesn't have permission
  *  THROWS when the account already exists
  *  @param addr The address of the account
  *  @param kind The kind of account
  *  @param isFrozen The frozen status of the account
  *  @param parent The account parent/owner
  */
function addAccount(address addr, uint8 kind, bool isFrozen, address parent)
isUnlocked
isAllowed(kind)
external {
    require(accounts.append(addr, kind, isFrozen, parent), "Account already exists");
}
Apr 05, 2019 17:12:29 UTC
/**
  *  Adds an account to storage
  *  THROWS when `msg.sender` doesn't have permission
  *  THROWS when the account already exists
  *  @param addr The address of the account
  *  @param kind The kind of account
  *  @param isFrozen The frozen status of the account
  *  @param parent The account parent/owner
  */
function addAccount(address addr, uint8 kind, bool isFrozen, address parent)
isUnlocked
isAllowed(kind)
external {
    require(accounts.append(addr, kind, isFrozen, parent), "Account already exists");
}

/**
  *  Sets an account's frozen status
  *  THROWS when the account doesn't exist
  *  @param addr The address of the account
  *  @param frozen The frozen status of the account
  */
function setAccountFrozen(address addr, bool frozen)
isUnlocked
isAllowed(accounts.get(addr).kind)
external {
    // NOTE: Not bounds checking `index` here, as `isAllowed` ensures the address exists.
    //       Indices are one-based internally, so we need to add one to compensate.
    int256 index = accounts.index
Apr 05, 2019 17:10:53 UTC
/**
     *  Adds an account to storage
     *  THROWS when `msg.sender` doesn't have permission
     *  THROWS when the account already exists
     *  @param addr The address of the account
     *  @param kind The kind of account
     *  @param isFrozen The frozen status of the account
     *  @param parent The account parent/owner
     */
    function addAccount(address addr, uint8 kind, bool isFrozen, address parent)
    isUnlocked
    isAllowed(kind)
    external {
        require(accounts.append(addr, kind, isFrozen, parent), "Account already exists");
    }

    /**
     *  Sets an account's frozen status
     *  THROWS when the account doesn't exist
     *  @param addr The address of the account
     *  @param frozen The frozen status of the account
     */
    function setAccountFrozen(address addr, bool frozen)
    isUnlocked
    isAllowed(accounts.get(addr).kind)
    external {
        // NOTE: Not bounds checking `index` here, as `isAllowed` ensures the address exists.
        //       Indices are o
Apr 05, 2019 17:10:44 UTC
/**
  *  Checks if a transfer is compliant for the given amount of tokens, between the accounts.
  *  @param initiator The address initiating the transfer.
  *  @param from The from account.
  *  @param to The to account.
  */
function checkRules(address initiator, address from, address to, uint8 fromKind, uint8 toKind, uint256 tokens)
private {
    // Ensure the transfer is compliant with each rule matching the from account's kind.
    ComplianceRule[] storage rules = complianceRules[fromKind];
    for (uint8 i = 0; i < rules.length; i++) {
        rules[i].check(initiator, from, to, toKind, tokens, store);
    }
Apr 05, 2019 16:58:43 UTC
/**
  *  @dev Checks if a transfer can occur between the from/to addresses.
  *
  *  Both addresses must be whitelisted, unfrozen, and pass all compliance rule checks.
  *  THROWS when the transfer should fail.
  *  @param initiator The address initiating the transfer.
  *  @param from The address of the sender.
  *  @param to The address of the receiver.
  *  @param tokens The number of tokens being transferred.
  *  @return If a transfer can occur between the from/to addresses.
  */
function canTransfer(address initiator, address from, address to, uint256 tokens)
external
returns (bool) {
    uint8 fromKind = getUnfrozenKind(from, UNSET_KIND);
    uint8 toKind = getUnfrozenKind(to, UNSET_KIND);
    if (initiator != from) {
        getUnfrozenKind(initiator, UNSET_KIND);
    }
    checkRules(initiator, from, to, fromKind, toKind, tokens);
    return true;
}

/**
  *  Returns the kind for the account and if it, or any of it's ancestors are frozen.
  *  @param addr The account to retrieve kind and frozen state
Apr 05, 2019 16:51:47 UTC
/**
  *  @dev Checks if a transfer can occur between the from/to addresses.
  *
  *  Both addresses must be whitelisted, unfrozen, and pass all compliance rule checks.
  *  THROWS when the transfer should fail.
  *  @param initiator The address initiating the transfer.
  *  @param from The address of the sender.
  *  @param to The address of the receiver.
  *  @param tokens The number of tokens being transferred.
  *  @return If a transfer can occur between the from/to addresses.
  */
function canTransfer(address initiator, address from, address to, uint256 tokens)
external
returns (bool) {
    uint8 fromKind = getUnfrozenKind(from, UNSET_KIND);
    uint8 toKind = getUnfrozenKind(to, UNSET_KIND);
    if (initiator != from) {
        getUnfrozenKind(initiator, UNSET_KIND);
    }
    checkRules(initiator, from, to, fromKind, toKind, tokens);
    return true;
}
Apr 05, 2019 16:50:33 UTC
/**
  *  @dev Checks if a transfer/override may take place between the two accounts.
  *
  *   Validates that the transfer can take place.
  *     - Ensure the 'to' address is not cancelled
  *     - Ensure the transfer is compliant
  *  @param from The sender address.
  *  @param to The recipient address.
  *  @param tokens The number of tokens being transferred.
  *  @param isOverride If this is a transfer override
  *  @return If the transfer can take place.
  */
function canTransfer(address from, address to, uint256 tokens, bool isOverride)
private
isNotCancelled(to)
returns (bool) {
    // Don't allow overrides and ignore compliance rules when compliance not set.
    if (address(compliance) == ZERO_ADDRESS) {
        return !isOverride;
    }

    // Ensure the override is valid, or that the transfer is compliant.
    if (isOverride) {
        return compliance.canOverride(msg.sender, from, to, tokens);
    } else {
        return compliance.canTransfer(msg.sender, from, to, tokens);
    }
}
Apr 05, 2019 16:30:45 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

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

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

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

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

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

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

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

  uint value;
Apr 04, 2019 14:22:17 UTC
pragma solidity ^0.4.25;

interface DSG {
    function gamingDividendsReception() payable external;
}

contract CoinFlipperDSG{
    using SafeMath for uint256;
    
    address constant public DSG_ADDRESS = 0x696826C18A6Bc9Be4BBfe3c3A6BB9f5a69388687;
    uint256 public totalDividends;
    uint256 public totalWinnings;
    uint256 public totalTurnover;
    uint256 public maxBet;
    uint256 public minBet;
    uint256 public minContractBalance;
    uint256 public minBetForJackpot;
    uint256 public jackpotBalance;
    uint256 public nextPayout;
    uint256 public ownerDeposit;
    address[2] public owners;
    address[2] public candidates;
    bool public paused;
    
    mapping (address => Bet) public usersBets;
    
    struct Bet {
        uint256 blockNumber;
        uint8 coin;
        uint256 bet;
    }
    
    modifier onlyOwners() {
        require(msg.sender == owners[0] || msg.sender == owners[1]);
        _;
    }
    modifier checkBlockNumber(){
        uint256 blockNumber = usersBets[msg.sender]
Apr 04, 2019 07:48:00 UTC
//Exercice 3.3.1 Pulsation
pragma solidity ^0.4.18;

int public battement

contract Pulsation {

   constructor() {
     battement = 0;
   }

   function ajouterBattement(){
     battement++;
   }
Apr 03, 2019 17:10:10 UTC
//Exercice 3.3.1 Pulsation
pragma solidity ^0.4.18;

int public battement

contract Pulsation {

   constructor() {
     battement = 0;
   }

   function ajouterBattement(){
     battement++;
   }



Apr 03, 2019 17:09:38 UTC
//Exercice 3.2.2 Organisateurs
pragma solidity ^0.4.25;


contract CagnotteFestival {

  mapping(address => uint) organisateurs;
  mapping(address => bool) festivaliers;
   mapping(address => string) sponsors;
  uint private depensesTotales;
  uint public nbPlaces = 1000;

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

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

  }

  function estOrga(address orga) public view returns (bool) {

    if(organisateurs[orga] > 0){
      return true;
    }else{
      return false;
    }
  }

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

  function payer(address destinataire, uint montant) public {
    require(estOrga(msg.sender));
    require(destinataire != address(0));
    require(montant > 0);
    destinataire.transfer(montant);
  }

  function payerSponsor(address des
Apr 03, 2019 15:05:51 UTC
//Exercice 3.2.2 Organisateurs
pragma solidity ^0.4.25;


contract CagnotteFestival {

  mapping(address => uint) organisateurs;
  mapping(address => bool) festivaliers;
   mapping(address => string) sponsors;
  uint private depensesTotales;
  uint public nbPlaces = 1000;

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

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

  }

  function estOrga(address orga) public view returns (bool) {

    if(organisateurs[orga] > 0){
      return true;
    }else{
      return false;
    }

  }

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

  function payer(address destinataire, uint montant) public {
    require(estOrga(msg.sender));
    require(destinataire != address(0));
    require(montant > 0);
    destinataire.transfer(montant);
  }

  function comptabiliserDepense(ui
Apr 02, 2019 20:10:00 UTC
//Exercice 3.2.2 Organisateurs
pragma solidity ^0.4.25;


contract CagnotteFestival {

  mapping(address => uint) organisateurs;
  mapping(address => bool) festivaliers;
   mapping(address => string) sponsors;
  uint private depensesTotales;
  uint public nbPlaces = 1000;

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

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

  }

  function estOrga(address orga) public view returns (bool) {

    if(organisateurs[orga] > 0){
      return true;
    }else{
      return false;
    }

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

  function payer(address destinataire, uint montant) public {
    require(estOrga(msg.sender));
    require(destinataire != address(0));
    require(montant > 0);
    destinataire.transfer(montant);
  }

  function comptabiliserDepense(
Apr 02, 2019 20:06:45 UTC
//Exercice 3.2.2 Organisateurs
pragma solidity ^0.4.25;


contract CagnotteFestival {

  mapping(address => uint) organisateurs;
  mapping(address => bool) festivaliers;
   mapping(address => string) sponsors;
  uint private depensesTotales;
  uint public nbPlaces = 1000;

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

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

  }

  function estOrga(address orga) public view returns (bool) {

    if(organisateurs[orga] > 0){
      return true;
    }else{
      return false;
    }

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

  function payer(address destinataire, uint montant) public {
    require(estOrga(msg.sender));
    require(destinataire != address(0));
    require(montant > 0);
    destinataire.transfer(montant);
  }

  function comptabiliserDepense(
Apr 02, 2019 19:57:09 UTC
//Exercice 3.2.1 Organisateurs
pragma solidity ^0.4.25;


contract CagnotteFestival {

  mapping(address => uint) organisateurs;

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

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

  }

  function estOrga(address orga) public view returns (bool) {

    if(organisateurs[orga] > 0){
      return true;
    }else{
      return false;
    }

  }

Apr 02, 2019 19:25:20 UTC
//Exercice 3.1.2.4  Contrôle des votes
pragma solidity ^0.4.25;

contract Assemblee {

  address[] membres;
  string[] public descriptionDecisions;
  uint[] public votesPour;
  uint[] public votesContre;
  //bool[] public aVote;
  
  Decision[] public decisions;
  Decision public decision;

struct Decision {
  string description;
  uint votesPour;
  uint votesContre;
  mapping (address => bool) aVote;
}


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

  function estMembre(address utilisateur) public view returns (bool) {

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

        if(utilisateur == membres[i]){
          return true;
        }
      }

      return false;
  }


  function proposerDecision(string description) public  {


    if(estMembre(msg.sender)) {
      //descriptionDecisions.push(description);
      decision.description = description;
      decision.votesPour = 0;
      decision.votesContre = 0;

      //votesPour.push(0);
      //votesContre.push(0);

      decisions.push(d
Apr 02, 2019 16:28:41 UTC
//Exercice 3.1.2.3 - Vérifier qu'une personne est membre de l'assemblée
pragma solidity ^0.4.25;

contract Assemblee {

  address[] membres;
  string[] public descriptionDecisions;
  uint[] public votesPour;
  uint[] public votesContre;

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

  function estMembre(address utilisateur) public view returns (bool) {

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

        if(utilisateur == membres[i]){
          return true;
        }
      }

      return false;
  }

  function proposerDecision(string description) public  {

    if(estMembre(msg.sender)) {
      descriptionDecisions.push(description);
      votesPour.push(0);
      votesContre.push(0);
    }
  }

  function voter(uint indice, uint vote) public {

    if(vote == 0) {
      votesContre[indice] += 1;
    }

    if(vote == 1) {
      votesPour[indice] += 1;
    }
  }

  function comptabilise(uint indice) public view returns (int) {


    return int(votesPour[indice]-votesContre[indice]);

 
Apr 01, 2019 13:35:54 UTC
//Exercice 3.1.2.1 - Vérifier qu'une personne est membre de l'assemblée
pragma solidity ^0.4.25;

contract Assemblee {

  address[] membres;
  string[] public descriptionDecisions;
  uint[] public votesPour;
  uint[] public votesContre;

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

  function estMembre(address utilisateur) public view returns (bool) {

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

        if(utilisateur == membres[i]){
          return true;
        }
      }

      return false;
  }

  function proposerDecision(string description) public  {

    if(estMembre(msg.sender)) {
      descriptionDecisions.push(description);
      votesPour.push(0);
      votesContre.push(0);
    }
  }

  function voter(uint indice, uint vote) public {

    if(vote == 0) {
      votesContre[indice] += 1;
    }

    if(vote == 1) {
      votesPour[indice] += 1;
    }
  }

  function comptabilise(uint indice) public view returns (int) {


    return int(votesPour[indice]-votesContre[indice]);

 
Apr 01, 2019 13:34:24 UTC
void setup()
{
  Serial.begin(9600);
  Serial.println("Enter AT commands:");
  Serial2.begin(38400);  // HC-05 default speed in AT command more
}

void loop()
{

  // Keep reading from HC-05 and send to Arduino Serial Monitor
  if (Serial2.available())
    Serial.write(Serial2.read());

  // Keep reading from Arduino Serial Monitor and send to HC-05
  if (Serial.available())
    Serial2.write(Serial.read());
}

/*

To return HC-05 to mfg. default settings: "AT+ORGL"
To get version of your HC-05 enter: "AT+VERSION?"
To change device name from the default HC-05 to let's say MYBLUE enter: "AT+NAME=MYBLUE"
To change default security code from 1234 to 2987 enter: "AT+PSWD=2987"
To change HC-05 baud rate from default 9600 to 115200, 1 stop bit, 0 parity enter: "AT+UART=115200,1,0"

 *
Mar 30, 2019 19:25:10 UTC
pragma solidity ^0.4.25;

/*
................&..,&&&&&&.......%&&&%..........&....................
................#&&&&&...&&&&&&&&&&&&&&&&&&&&&.......................
..............&&&&&..&&&&&&&&&&&&&&&&&&&&&&&&&&&&&...................
..........%.&&&&&.&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&................
..........&&&&&.&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&..............
.........&&&&.&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&............
........&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&..........
.......&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&.........
......&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&........
.....&&&&&&&&&&&&&&&&&&&&(&&&&&&&&&&&&&&&&&/&&&&&&&&&&&&&&&&&&.......
....#&&&&&&&&&&&&&&,&&&&&&&.&&&&&&&&&&&&&.&&&&&&&(.&&&&&&&&&&&&......
....&&&&&&&&&&&&&&&&&.&&&&&&&..&&&&&&&..&&&&&&&*...&&&&&&&&&&&&&.....
....&&&&&&&&&&&&&&&&&&&/#&&&&&&&..&..&&&&&&&&......&&&&&&&&&&&&&.....
....&&&&&&&&&&&&&&.&&&&&&&.&&&&&&&.&&&&&&&%.......&&&&&&&&&&&&&&&....
...*&&&&&&&&&&&
Mar 29, 2019 09:27:09 UTC
pragma solidity ^0.4.25;

/*
................&..,&&&&&&.......%&&&%..........&....................
................#&&&&&...&&&&&&&&&&&&&&&&&&&&&.......................
..............&&&&&..&&&&&&&&&&&&&&&&&&&&&&&&&&&&&...................
..........%.&&&&&.&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&................
..........&&&&&.&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&..............
.........&&&&.&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&............
........&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&..........
.......&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&.........
......&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&........
.....&&&&&&&&&&&&&&&&&&&&(&&&&&&&&&&&&&&&&&/&&&&&&&&&&&&&&&&&&.......
....#&&&&&&&&&&&&&&,&&&&&&&.&&&&&&&&&&&&&.&&&&&&&(.&&&&&&&&&&&&......
....&&&&&&&&&&&&&&&&&.&&&&&&&..&&&&&&&..&&&&&&&*...&&&&&&&&&&&&&.....
....&&&&&&&&&&&&&&&&&&&/#&&&&&&&..&..&&&&&&&&......&&&&&&&&&&&&&.....
....&&&&&&&&&&&&&&.&&&&&&&.&&&&&&&.&&&&&&&%.......&&&&&&&&&&&&&&&....
...*&&&&&&&&&&&
Mar 29, 2019 09:23:24 UTC
pragma solidity ^0.4.25;

/*
................&..,&&&&&&.......%&&&%..........&....................
................#&&&&&...&&&&&&&&&&&&&&&&&&&&&.......................
..............&&&&&..&&&&&&&&&&&&&&&&&&&&&&&&&&&&&...................
..........%.&&&&&.&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&................
..........&&&&&.&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&..............
.........&&&&.&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&............
........&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&..........
.......&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&.........
......&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&........
.....&&&&&&&&&&&&&&&&&&&&(&&&&&&&&&&&&&&&&&/&&&&&&&&&&&&&&&&&&.......
....#&&&&&&&&&&&&&&,&&&&&&&.&&&&&&&&&&&&&.&&&&&&&(.&&&&&&&&&&&&......
....&&&&&&&&&&&&&&&&&.&&&&&&&..&&&&&&&..&&&&&&&*...&&&&&&&&&&&&&.....
....&&&&&&&&&&&&&&&&&&&/#&&&&&&&..&..&&&&&&&&......&&&&&&&&&&&&&.....
....&&&&&&&&&&&&&&.&&&&&&&.&&&&&&&.&&&&&&&%.......&&&&&&&&&&&&&&&....
...*&&&&&&&&&&&
Mar 29, 2019 08:55:12 UTC
//Exercice 3.1.2.1 - Vérifier qu'une personne est membre de l'assemblée
pragma solidity ^0.4.25;

contract Assemblee {

  address[] membres;
  string[] public descriptionDecisions;
  uint[] public votesPour;
  uint[] public votesContre;

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

  function estMembre(address utilisateur) public view returns (bool) {

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

        if(utilisateur == membres[i]){
          return true;
        }
      }

      return false;
  }

  function proposerDecision(string description) public  {

    if(estMembre(msg.sender)) {
      descriptionDecisions.push(description);
      votesPour.push(0);
      votesContre.push(0);
    }
  }

  function voter(uint indice, uint vote) public {

    if(vote == 0) {
      votesContre.push(0);
    }

    if(vote == 1) {
      votesPour.push(0);
    }
  }

  



Mar 28, 2019 18:04:04 UTC
//Exercice 3.1.2.1 - Vérifier qu'une personne est membre de l'assemblée
pragma solidity ^0.4.25;

contract Assemblee {

  address[] membres;

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

  function estMembre(address utilisateur) public view returns (bool) {

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

        if(utilisateur == membres[i]){
          return true;
        }
      }

      return false;

  }

Mar 28, 2019 12:15:29 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.25;


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

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

  uint value;
Mar 28, 2019 12:06:50 UTC
//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 = 0;

  function sInscrire(string nomArtiste) public {

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

  function passerArtisteSuivant() public {
    if(creneauxLibres != 0) {
      tour +=1;
    }  
  }

  function artisteEnCours() public constant returns (string) {

    if(tour < passagesArtistes.length) {
      return passagesArtistes[tour];
    }else{
      return "FIN";
    }
  }


Mar 28, 2019 11:59:05 UTC
pragma solidity ^0.4.24;

contract A {

	string public s = string(abi.encodePacked("a", " ", "concatenated", " ", "string"));
	
	function tokenURI(
	uint256 tokenId
	)
	external
	view
	returns (
		string memory
	)
	{

		return string(abi.encodePacked(
			"test",
			string(abi.encodePacked(address(this)))
		));
	}

}
Mar 28, 2019 10:50:54 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.24;

contract AssetTracker {

  struct Asset {
    string name; 
    string description;
    string manufacturer;
    uint uuid;
    uint indexInArray;
    bool recallMarked;
    bool initialized;
} 

mapping(uint  => Asset) private idToAssetMap;
mapping(address => mapping(uint => bool)) private addressToIdToIsOwnedMap;
mapping(address => Asset[]) private assetsOfAddress;
mapping(uint => address) private assetIdToManufacturer;

event AssetCreate(address account, uint uuid, string manufacturer);
event RejectCreate(address account, uint uuid, string message);

event AssetTransfer(address from, address to, uint uuid);
event RejectTransfer(address from, address to, uint uuid, string message);

event TriggerRecall(uint uuid, string name, string description);
event RejectRecall(uint uuid, string description);

function createAsset(string name, string description, uint uuid, string manufacturerName) public {
Mar 28, 2019 07:11:43 UTC
pragma solidity >0.4.23 <0.5.0;

contract BlindAuction {
    struct Bid {
        bytes32 blindedBid;
        uint deposit;
    }

    address public beneficiary;
    uint public biddingEnd;
    uint public revealEnd;
    bool public ended;

    mapping(address => Bid[]) public bids;

    address public highestBidder;
    uint public highestBid;

    // Allowed withdrawals of previous bids
    mapping(address => uint) pendingReturns;

    event AuctionEnded(address winner, uint highestBid);

    /// Modifiers are a convenient way to validate inputs to
    /// functions. `onlyBefore` is applied to `bid` below:
    /// The new function body is the modifier's body where
    /// `_` is replaced by the old function body.
    modifier onlyBefore(uint _time) { require(now < _time); _; }
    modifier onlyAfter(uint _time) { require(now > _time); _; }

    constructor(
        uint _biddingTime,
        uint _revealTime,
        address _beneficiary
    ) public {
        beneficiary = _beneficiary;
        biddingEnd
Mar 28, 2019 02:35:06 UTC
pragma solidity ^0.4.24;

contract Test {

	/****************
		VARIABLES
	****************/

	bool public jackpotAwarded;
	address public admin;
	uint256 public totalVolume;
	uint256 public payIndex;
	uint256 public increase = 1001; //100.1%
	uint256 public minBuy = 10000000000; //10000 trx
	uint256 public goal = 99000000000000000; //99 billion trx
	mapping (address => uint256) public totalBought;
 	mapping (address => uint256) public totalPaid;

 	bool public lottoAwarded;
 	uint256 public highestNumber;
 	address public currentWinner;
 	mapping (address => bool) public hasPlayed;
 	mapping (address => uint256) public lottoNumber;
 	
 	Order[] public orders;

	struct Order {
		uint256 amount;
		address owner;
	}

	/******************
		CONSTRUCTOR
	******************/

	constructor() public {
		admin = msg.sender;
	}
	
	/*************
		EVENTS
	*************/

	event newOrder(
		address indexed buyer,
		uint256 amount,
		uint256 totalVol
	);

	event jackpotWon(
		address indexed winner,
		uint256 jackpotAmo
Mar 27, 2019 20:44:19 UTC
pragma solidity ^0.4.24;

contract NintyNineBillion {

	/**
	 * VARIABLES
	 */
	address public admin;
	bool public jackpotAwarded;
	uint256 public totalVolume;
	uint256 public payIndex;
	uint256 public increase = 1001; //100.1%
	uint256 public minBuy = 10000000000; //10000 trx
	uint256 public goal = 99000000000000000; //approximate trx supply
	mapping (address => uint256) public totalBought;
 	mapping (address => uint256) public totalPaid;

 	bool public lottoAwarded;
 	uint256 public highestNumber;
 	address public currentWinner;
 	mapping (address => bool) hasPlayed;
 	mapping (address => uint256) lottoNumber;
 	
 	Order[] public orders;

	struct Order {
		uint256 amount;
		address owner;
	}

	/**
	 * CONSTRUCTOR
	 */
	constructor() public {
		admin = msg.sender;
	}
	
	/** 
	 * EVENTS
	 */
	event newOrder(
		address indexed buyer,
		uint256 amount,
		uint256 totalVol
	);

	event jackpotWon(
		address indexed winner,
		uint256 jackpotAmount
	);

	event lottoPlayed(
		address indexed player,
		uint256 number
Mar 27, 2019 05:11:08 UTC
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);
  }
Mar 26, 2019 11:39:56 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.24;

contract AssetTracker {

  struct Asset {
    string name; 
    string description;
    string manufacturer;
    uint uuid;
    uint indexInArray;
    bool initialized;
}

mapping(uint  => Asset) private idToAssetMap;
mapping(address => mapping(uint => bool)) private addressToIdToIsOwnedMap;
mapping(address => Asset[]) private assetsOfAddress;
mapping(uint => address) private assetIdToManufacturer;

event AssetCreate(address account, uint uuid, string manufacturer);
event RejectCreate(address account, uint uuid, string message);
event AssetTransfer(address from, address to, uint uuid);
event RejectTransfer(address from, address to, uint uuid, string message);
event RecallIssued(int uuid, string name, string description);

function createAsset(string name, string description, uint uuid, string manufacturer) public {
 
    if(idToAssetMap[uuid].initialized) {
        emit RejectCreate(msg.sender, uu
Mar 26, 2019 01:17:52 UTC
<IfModule mod_expires.c>
  ExpiresActive On

  # Images
  ExpiresByType image/jpeg "access plus 1 year"
  ExpiresByType image/gif "access plus 1 year"
  ExpiresByType image/png "access plus 1 year"
  ExpiresByType image/webp "access plus 1 year"
  ExpiresByType image/svg+xml "access plus 1 year"
  ExpiresByType image/x-icon "access plus 1 year"

  # Video
  ExpiresByType video/mp4 "access plus 1 year"
  ExpiresByType video/mpeg "access plus 1 year"

  # CSS, JavaScript
  ExpiresByType text/css "access plus 1 month"
  ExpiresByType text/javascript "access plus 1 month"
  ExpiresByType application/javascript "access plus 1 month"

  # Others
  ExpiresByType application/pdf "access plus 1 month"
  ExpiresByType application/x-shockwave-flash "access plus 1 month"
</IfModule
Mar 24, 2019 16:34:41 UTC
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
Mar 21, 2019 18:17:14 UTC
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
Mar 21, 2019 12:01:57 UTC
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
Mar 21, 2019 12:01:57 UTC
//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];
  }

Mar 20, 2019 10:09:53 UTC
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;
    }
Mar 20, 2019 01:34:15 UTC
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);
  }
  ...
Mar 18, 2019 06:49:18 UTC
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);
Mar 18, 2019 06:43:19 UTC
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;
  }
Mar 18, 2019 02:55:04 UTC
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;

Mar 17, 2019 12:10:50 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

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

  uint value;
Mar 17, 2019 08:35:24 UTC
pragma ^0.4.0;

contract HelloWorld {
    uint balance;
    func update(uint amount) returns (address, uint) {
        balance += amount;
        return (msg.address, balance);
    }
Mar 17, 2019 07:43:39 UTC
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
Mar 16, 2019 19:54:23 UTC
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];
    }

    
Mar 16, 2019 19:43:36 UTC
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
Mar 16, 2019 12:54:54 UTC
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];
  }
Mar 15, 2019 15:38:33 UTC
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
Mar 15, 2019 15:06:21 UTC
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;
  }


  /**
Mar 14, 2019 01:11:30 UTC
//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(){
    
  }
Mar 12, 2019 23:51:29 UTC
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
Mar 12, 2019 11:34:41 UTC
//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;
Mar 12, 2019 10:23:12 UTC
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 
Mar 10, 2019 16:57:12 UTC
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 
Mar 10, 2019 16:54:46 UTC
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 
Mar 10, 2019 15:52:35 UTC
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 
Mar 10, 2019 14:51:54 UTC
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 
Mar 10, 2019 14:47:10 UTC
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 
Mar 10, 2019 14:38:28 UTC
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 
Mar 10, 2019 14:36:45 UTC
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 
Mar 10, 2019 10:51:45 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

  function get() public constant returns (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;
Mar 09, 2019 01:13:00 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

  function get() public constant returns (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;
Mar 08, 2019 23:03:01 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

  function get() public constant returns (uint) {
    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;
Mar 08, 2019 23:02:04 UTC
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
Mar 08, 2019 13:59:04 UTC
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
Mar 07, 2019 13:11:18 UTC
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
Mar 07, 2019 11:58:35 UTC
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
Mar 07, 2019 10:11:06 UTC
//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;
Mar 06, 2019 07:28:56 UTC
/**
 * @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);
  }
Mar 06, 2019 06:09:01 UTC
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;
Mar 05, 2019 19:06:43 UTC
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
Mar 05, 2019 16:29:46 UTC
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
Mar 05, 2019 14:27:10 UTC
//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;
Mar 05, 2019 07:10:12 UTC
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
Mar 04, 2019 17:02:50 UTC
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
Mar 04, 2019 16:58:46 UTC
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
Mar 04, 2019 16:54:00 UTC
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
Mar 04, 2019 16:46:21 UTC
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
Mar 04, 2019 16:39:50 UTC
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
Mar 04, 2019 16:25:05 UTC
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
Mar 04, 2019 16:19:39 UTC
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
Mar 04, 2019 16:09:54 UTC
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
Mar 04, 2019 16:03:39 UTC
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
Mar 04, 2019 15:54:51 UTC
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
Mar 04, 2019 13:47:42 UTC
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
Mar 04, 2019 11:28:20 UTC
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
Mar 04, 2019 11:13:42 UTC
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
Mar 04, 2019 10:27:42 UTC
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
Mar 04, 2019 10:01:16 UTC
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
Mar 03, 2019 21:03:42 UTC
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;  /* Баланс, который используется для благотворительности */
   
Mar 02, 2019 12:23:32 UTC
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
Mar 02, 2019 12:07:23 UTC
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]
Mar 02, 2019 12:04:13 UTC
//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);
}
Mar 02, 2019 11:37:31 UTC
//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;
Mar 02, 2019 11:02:20 UTC
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;
Mar 01, 2019 10:08:18 UTC
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
Feb 28, 2019 02:42:52 UTC
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;
    }
}
Feb 27, 2019 20:31:59 UTC
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()
Feb 27, 2019 06:11:27 UTC

/**
 * @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
Feb 27, 2019 04:37:34 UTC
        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
Feb 26, 2019 16:37:43 UTC
        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)
Feb 26, 2019 16:35:15 UTC
    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
Feb 26, 2019 16:31:50 UTC
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 {

  }
Feb 25, 2019 13:11:59 UTC
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() {
        
Feb 25, 2019 09:50:21 UTC
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);
    }
Feb 25, 2019 03:19:04 UTC
//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
Feb 24, 2019 16:52:13 UTC
//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
Feb 24, 2019 16:41:12 UTC
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);
    }
Feb 24, 2019 15:35:19 UTC
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);
    }
Feb 24, 2019 15:31:49 UTC
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

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

  uint value;
Feb 23, 2019 01:42:54 UTC
//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;
Feb 22, 2019 20:49:07 UTC
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 
Feb 22, 2019 18:05:30 UTC

/**
 * @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
Feb 22, 2019 08:29:28 UTC
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];
  }
Feb 21, 2019 11:28:28 UTC
//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
     //___________________________________________________
Feb 21, 2019 11:19:40 UTC
//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
     //___________________________________________________
Feb 21, 2019 11:06:21 UTC
//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
     //___________________________________________________
Feb 21, 2019 10:03:23 UTC
//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
     //___________________________________________________
Feb 21, 2019 09:59:20 UTC
//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
     //___________________________________________________
Feb 21, 2019 09:57:36 UTC
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
Feb 21, 2019 09:03:53 UTC
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
Feb 21, 2019 08:25:35 UTC
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
Feb 21, 2019 08:25:27 UTC
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);
  }
Feb 21, 2019 07:00:22 UTC
//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
     //___________________________________________________
Feb 21, 2019 06:36:40 UTC
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);
  }
Feb 21, 2019 06:30:05 UTC
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);
  }
Feb 21, 2019 05:57:56 UTC
//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);
  }
Feb 21, 2019 05:55:05 UTC
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
Feb 21, 2019 01:38:36 UTC
//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
     //___________________________________________________
Feb 20, 2019 13:37:48 UTC
//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
     //___________________________________________________
Feb 20, 2019 13:28:49 UTC
//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;


//__________________________
Feb 20, 2019 12:25:00 UTC
//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


//____________________________________________
Feb 20, 2019 11:59:25 UTC
//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


//____________________________________________
Feb 20, 2019 11:54:25 UTC
//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


//____________________________________________
Feb 20, 2019 11:50:11 UTC
//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


//____________________________________________
Feb 20, 2019 11:43:58 UTC
//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


//____________________________________________
Feb 20, 2019 11:43:24 UTC
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;
    }
}
Feb 20, 2019 06:08:01 UTC
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;
    }
}
Feb 20, 2019 06:06:33 UTC

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
Feb 20, 2019 01:52:24 UTC
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];
  }
Feb 19, 2019 19:02:41 UTC
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
Feb 19, 2019 18:37:19 UTC
//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


//____________________________________________
Feb 19, 2019 13:43:10 UTC
//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


//____________________________________________
Feb 19, 2019 13:32:29 UTC
//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
Feb 19, 2019 11:54:40 UTC
//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


//___________________________________________
Feb 19, 2019 11:09:43 UTC
//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
Feb 19, 2019 10:54:12 UTC
//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;


//
Feb 19, 2019 10:36:48 UTC
//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;


//
Feb 19, 2019 10:14:10 UTC
//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;


//
Feb 19, 2019 10:13:44 UTC
//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;


//___________________________
Feb 19, 2019 09:45:22 UTC
//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;


//______________________________________________________
Feb 19, 2019 08:36:36 UTC
//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;


//______________________________________________________
Feb 19, 2019 08:24:37 UTC
//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;


//______________________________________________________
Feb 19, 2019 08:19:53 UTC
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
Feb 19, 2019 07:58:48 UTC
//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;


//______________________________________________________
Feb 19, 2019 07:23:55 UTC
//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;


//______________________________________________________
Feb 19, 2019 07:01:40 UTC
//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;
     
Feb 19, 2019 06:42:28 UTC
//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
Feb 19, 2019 05:16:22 UTC