Created using browser-solidity: Realtime Ethereum Contract Compiler and Runtime. Load this file by pasting this gists URL or ID at https://ethereum.github.io/browser-solidity/#version=soljson-v0.4.16+commit.d7661dd9.js&optimize=true&gist=

1.sol

pragma solidity ^0.4.16;

contract owned {
    address public owner;

    function owned() {
        owner = msg.sender;
    }

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

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

contract tokenRecipient {
    event receivedEther(address sender, uint amount);
    event receivedTokens(address _from, uint256 _value, address _token, bytes _extraData);

    function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData){
        Token t = Token(_token);
        require(t.transferFrom(_from, this, _value));
        receivedTokens(_from, _value, _token, _extraData);
    }

    function () payable {
        receivedEther(msg.sender, msg.value);
    }
}

interface Token {
    function transferFrom(address _from, address _to, uint256 _value) returns (bool success);
}

contract TimeLockMultisig is owned, tokenRecipient {

    Proposal[] public proposals;
    uint public numProposals;
    mapping (address => uint) public memberId;
    Member[] public members;
    uint minimumTime = 10;

    event ProposalAdded(uint proposalID, address recipient, uint amount, string description);
    event Voted(uint proposalID, bool position, address voter, string justification);
    event ProposalExecuted(uint proposalID, int result, uint deadline);
    event MembershipChanged(address member, bool isMember);

    struct Proposal {
        address recipient;
        uint amount;
        string description;
        bool executed;
        int currentResult;
        bytes32 proposalHash;
        uint creationDate;
        Vote[] votes;
        mapping (address => bool) voted;
    }

    struct Member {
        address member;
        string name;
        uint memberSince;
    }

    struct Vote {
        bool inSupport;
        address voter;
        string justification;
    }

    // Modifier that allows only shareholders to vote and create new proposals
    modifier onlyMembers {
        require(memberId[msg.sender] != 0);
        _;
    }

    /**
     * Constructor function
     *
     * First time setup
     */
    function TimeLockMultisig(address founder, address[] initialMembers, uint minimumAmountOfMinutes) payable {
        if (founder != 0) owner = founder;
        if (minimumAmountOfMinutes !=0) minimumTime = minimumAmountOfMinutes;
        // It’s necessary to add an empty first member
        addMember(0, '');
        // and let's add the founder, to save a step later
        addMember(owner, 'founder');
        changeMembers(initialMembers, true);
    }

    /**
     * Add member
     *
     * @param targetMember address to add as a member
     * @param memberName label to give this member address
     */
    function addMember(address targetMember, string memberName) onlyOwner {
        uint id;
        if (memberId[targetMember] == 0) {
            memberId[targetMember] = members.length;
            id = members.length++;
        } else {
            id = memberId[targetMember];
        }

        members[id] = Member({member: targetMember, memberSince: now, name: memberName});
        MembershipChanged(targetMember, true);
    }

    /**
     * Remove member
     *
     * @param targetMember the member to remove
     */
    function removeMember(address targetMember) onlyOwner {
        require(memberId[targetMember] != 0);

        for (uint i = memberId[targetMember]; i<members.length-1; i++){
            members[i] = members[i+1];
        }
        delete members[members.length-1];
        members.length--;
    }

    /**
     * Edit existing members
     *
     * @param newMembers array of addresses to update
     * @param canVote new voting value that all the values should be set to
     */
    function changeMembers(address[] newMembers, bool canVote) {
        for (uint i = 0; i < newMembers.length; i++) {
            if (canVote)
                addMember(newMembers[i], '');
            else
                removeMember(newMembers[i]);
        }
    }

    /**
     * Add Proposal
     *
     * Propose to send `weiAmount / 1e18` ether to `beneficiary` for `jobDescription`. `transactionBytecode ? Contains : Does not contain` code.
     *
     * @param beneficiary who to send the ether to
     * @param weiAmount amount of ether to send, in wei
     * @param jobDescription Description of job
     * @param transactionBytecode bytecode of transaction
     */
    function newProposal(
        address beneficiary,
        uint weiAmount,
        string jobDescription,
        bytes transactionBytecode
    )
        onlyMembers
        returns (uint proposalID)
    {
        proposalID = proposals.length++;
        Proposal storage p = proposals[proposalID];
        p.recipient = beneficiary;
        p.amount = weiAmount;
        p.description = jobDescription;
        p.proposalHash = sha3(beneficiary, weiAmount, transactionBytecode);
        p.executed = false;
        p.creationDate = now;
        ProposalAdded(proposalID, beneficiary, weiAmount, jobDescription);
        numProposals = proposalID+1;
        vote(proposalID, true, '');

        return proposalID;
    }

    /**
     * Add proposal in Ether
     *
     * Propose to send `etherAmount` ether to `beneficiary` for `jobDescription`. `transactionBytecode ? Contains : Does not contain` code.
     * This is a convenience function to use if the amount to be given is in round number of ether units.
     *
     * @param beneficiary who to send the ether to
     * @param etherAmount amount of ether to send
     * @param jobDescription Description of job
     * @param transactionBytecode bytecode of transaction
     */
    function newProposalInEther(
        address beneficiary,
        uint etherAmount,
        string jobDescription,
        bytes transactionBytecode
    )
        onlyMembers
        returns (uint proposalID)
    {
        return newProposal(beneficiary, etherAmount * 1 ether, jobDescription, transactionBytecode);
    }

    /**
     * Check if a proposal code matches
     *
     * @param proposalNumber ID number of the proposal to query
     * @param beneficiary who to send the ether to
     * @param weiAmount amount of ether to send
     * @param transactionBytecode bytecode of transaction
     */
    function checkProposalCode(
        uint proposalNumber,
        address beneficiary,
        uint weiAmount,
        bytes transactionBytecode
    )
        constant
        returns (bool codeChecksOut)
    {
        Proposal storage p = proposals[proposalNumber];
        return p.proposalHash == sha3(beneficiary, weiAmount, transactionBytecode);
    }

    /**
     * Log a vote for a proposal
     *
     * Vote `supportsProposal? in support of : against` proposal #`proposalNumber`
     *
     * @param proposalNumber number of proposal
     * @param supportsProposal either in favor or against it
     * @param justificationText optional justification text
     */
    function vote(
        uint proposalNumber,
        bool supportsProposal,
        string justificationText
    )
        onlyMembers
    {
        Proposal storage p = proposals[proposalNumber]; // Get the proposal
        require(p.voted[msg.sender] != true);           // If has already voted, cancel
        p.voted[msg.sender] = true;                     // Set this voter as having voted
        if (supportsProposal) {                         // If they support the proposal
            p.currentResult++;                          // Increase score
        } else {                                        // If they don't
            p.currentResult--;                          // Decrease the score
        }

        // Create a log of this event
        Voted(proposalNumber,  supportsProposal, msg.sender, justificationText);

        // If you can execute it now, do it
        if ( now > proposalDeadline(proposalNumber)
            && p.currentResult > 0
            && p.proposalHash == sha3(p.recipient, p.amount, '')
            && supportsProposal) {
            executeProposal(proposalNumber, '');
        }
    }

    function proposalDeadline(uint proposalNumber) constant returns(uint deadline) {
        Proposal storage p = proposals[proposalNumber];
        uint factor = calculateFactor(uint(p.currentResult), (members.length - 1));
        return p.creationDate + uint(factor * minimumTime *  1 minutes);
    }

    function calculateFactor(uint a, uint b) constant returns (uint factor) {
        return 2**(20 - (20 * a)/b);
    }

    /**
     * Finish vote
     *
     * Count the votes proposal #`proposalNumber` and execute it if approved
     *
     * @param proposalNumber proposal number
     * @param transactionBytecode optional: if the transaction contained a bytecode, you need to send it
     */
    function executeProposal(uint proposalNumber, bytes transactionBytecode) {
        Proposal storage p = proposals[proposalNumber];

        require(now >= proposalDeadline(proposalNumber)                                         // If it is past the voting deadline
            && p.currentResult > 0                                                              // and a minimum quorum has been reached
            && !p.executed                                                                      // and it is not currently being executed
            && checkProposalCode(proposalNumber, p.recipient, p.amount, transactionBytecode));  // and the supplied code matches the proposal...


        p.executed = true;
        assert(p.recipient.call.value(p.amount)(transactionBytecode));

        // Fire Events
        ProposalExecuted(proposalNumber, p.currentResult, proposalDeadline(proposalNumber));
    }
}

ballot.sol

pragma solidity ^0.4.19;

contract ARMOR {
  address public account;
  int public value;
  string public description;
  bool public enabled;
  mapping(uint256 => Label[]) public labels;
  bytes32 public name;
  uint[] public numbers;
  mapping(address => int[]) public register;
  mapping(uint256 => Data) public requirements;

  struct Data {
    uint time;
    string ref;
    string info;
  }

  struct Label {
    string name;
    string company;
  }

  function TestContract() {
  }

  // In Remix IDE: enter address between double quotes and prefix with 0x
  // Setter: "0x583031d1113ad414f02576bd6afabfb302140225"
  function setAccount(address _account){
    account = _account;
  }


  // In Remix IDE: enter value between double quotes.
  // The string is converted into hex values
  // String must be <= 32 bytes otherwise conversion will not be ok.
  // Use http://string-functions.com/hex-string.aspx to convert to string
  // Setter: "12345678901234567890123456789012"   <== value is 32 bytes, OK
  // Setter: "123456789012345678901234567890123"  <== value is 33 bytes, NOT OK
  function setName(bytes32 _name){
    name = _name;
  }

  // In Remix IDE: enter value without double quotes
  // Setter: 12345 or 2e5
  function setValue(int _value){
    value = _value;
  }

  // In Remix IDE: enter key without double quotes.
  // _ref and _info must be entered with double quotes
  // Setter: 456, "aaa", "bbb"
  // Getter: 456
  function setRequirements(uint256 _idx, string _ref, string _info) {
      requirements[_idx] = Data(now, _ref, _info);
  }

  // In Remix IDE: enter address between double quotes and prefix with 0x
  // The array of numbers must be placed between []
  // Setter: "0x583031d1113ad414f02576bd6afabfb302140225", [1,2,3]
  // Getter: "0x583031d1113ad414f02576bd6afabfb302140225", 0  <= array index number
  function setRegister(address _account, int[] _ids) {
      register[_account] = _ids;
  }

  // In Remix IDE: The array of numbers must be placed between []
  // Setter: [1,2,3]
  // Getter: 0 <= array index number
  function setNumbers(uint[] _numbers){
    numbers = _numbers;
  }

  // In Remix IDE: enter boolean without double quotes.
  // Setter: true
  function setEnabled(bool _enabled) {
      enabled = _enabled;
  }

  // In Remix IDE: enter string between double quotes
  // Setter: "Hello World"
  function setDescription(string _description){
    description = _description;
  }

  /* THIS IS NOT ALLOWED
     TypeError: Internal type is not allowed for public or external functions
    function setLabels(uint256 _idx, Label[] _labelList) {
        labels[_idx] = _labelList;
    }
  */
}

New.sol

contract OwnedRegistrar{function name(address _owner)constant returns(bytes32 o_name){}function owner(bytes32 _name)constant returns(address o_owner){}function getAddress(bytes32 _name)constant returns(address o_owner){}function content(bytes32 _name)constant returns(bytes32 ){}function addr(bytes32 _name)constant returns(address ){}function subRegistrar(bytes32 _name)constant returns(address ){}function getName(address _owner)constant returns(bytes32 o_name){}function setSubRegistrar(bytes32 _name,address _registrar){}function record(bytes32 _name)constant returns(address o_primary,address o_subRegistrar,bytes32 o_content){}function setAddress(bytes32 _name,address _a,bool _primary){}function setContent(bytes32 _name,bytes32 _content){}function disown(bytes32 _name){}}

pragma solidity ^0.4.18;

contract PresaleOracles{
/*
 * PresaleOracles
 * Simple Presale contract
 * built by github.com/rstormsf Roman Storm
 */
    using SafeMath for uint256;
    uint256 public startTime;
    uint256 public endTime;
    uint256 public cap;
    uint256 public totalInvestedInWei;
    uint256 public minimumContribution;
    mapping(address => uint256) public investorBalances;
    mapping(address => bool) public whitelist;
    uint256 public investorsLength;
    address public vault;
    bool public isInitialized = false;
    // TESTED by Roman Storm
    function () public payable {
        buy();
    }
    //TESTED by Roman Storm
    function Presale() public {
    }
    //TESTED by Roman Storm
    function initialize(uint256 _startTime, uint256 _endTime, uint256 _cap, uint256 _minimumContribution, address _vault) public onlyOwner {
        require(!isInitialized);
        require(_startTime != 0);
        require(_endTime != 0);
        require(_endTime > _startTime);
        require(_cap != 0);
        require(_minimumContribution != 0);
        require(_vault != 0x0);
        require(_cap > _minimumContribution);
        startTime = _startTime;
        endTime = _endTime;
        cap = _cap;
        isInitialized = true;
        minimumContribution = _minimumContribution;
        vault = _vault;
    }
    //TESTED by Roman Storm
    event Contribution(address indexed investor, uint256 investorAmount, uint256 investorTotal, uint256 totalAmount);
    function buy() public payable {
        require(whitelist[msg.sender]);
        require(isValidPurchase(msg.value));
        require(isInitialized);
        require(getTime() >= startTime && getTime() <= endTime);
        address investor = msg.sender;
        investorBalances[investor] += msg.value;
        totalInvestedInWei += msg.value;
        forwardFunds(msg.value);
        Contribution(msg.sender, msg.value, investorBalances[investor], totalInvestedInWei);
    }
    
    //TESTED by Roman Storm
    function forwardFunds(uint256 _amount) internal {
        vault.transfer(_amount);
    }
    //TESTED by Roman Storm
    function claimTokens(address _token) public onlyOwner {
        if (_token == 0x0) {
            owner.transfer(this.balance);
            return;
        }
    
        ERC20Basic token = ERC20Basic(_token);
        uint256 balance = token.balanceOf(this);
        token.transfer(owner, balance);
    }

    function getTime() internal view returns(uint256) {
        return now;
    }
    //TESTED by Roman Storm
    function isValidPurchase(uint256 _amount) public view returns(bool) {
        bool nonZero = _amount > 0;
        bool hasMinimumAmount = investorBalances[msg.sender].add(_amount) >= minimumContribution;
        bool withinCap = totalInvestedInWei.add(_amount) <= cap;
        return hasMinimumAmount && withinCap && nonZero;
    }
    //TESTED by Roman Storm
    function whitelistInvestor(address _newInvestor) public onlyOwner {
        if(!whitelist[_newInvestor]) {
            whitelist[_newInvestor] = true;
            investorsLength++;
        }
    }
    //TESTED by Roman Storm
    function whitelistInvestors(address[] _investors) external onlyOwner {
        require(_investors.length <= 250);
        for(uint8 i=0; i<_investors.length;i++) {
            address newInvestor = _investors[i];
            if(!whitelist[newInvestor]) {
                whitelist[newInvestor] = true;
                investorsLength++;
            }
        }
    }
    function blacklistInvestor(address _investor) public onlyOwner {
        if(whitelist[_investor]) {
            delete whitelist[_investor];
            if(investorsLength != 0) {
                investorsLength--;
            }
        }
    }
}

Untitled.sol

pragma solidity ^0.4.11;


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


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


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


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


	/**
	 * @title ERC20Basic
	 * @dev Simpler version of ERC20 interface
	 * @dev see https://github.com/ethereum/EIPs/issues/179
	 */
	contract ERC20Basic {
	  uint256 public totalSupply;
	  function balanceOf(address who) public constant returns (uint256);
	  function transfer(address to, uint256 value) public returns (bool);
	  event Transfer(address indexed from, address indexed to, uint256 value);
	}
	/**
	 * @title ERC20 interface
	 * @dev see https://github.com/ethereum/EIPs/issues/20
	 */
	contract ERC20 is ERC20Basic {
	  function allowance(address owner, address spender) public constant returns (uint256);
	  function transferFrom(address from, address to, uint256 value) public returns (bool);
	  function approve(address spender, uint256 value) public returns (bool);
	  event Approval(address indexed owner, address indexed spender, uint256 value);
	}
	/**
	 * @title Standard ERC20 token
	 *
	 * @dev Implementation of the basic standard token.
	 * @dev https://github.com/ethereum/EIPs/issues/20
	 * @dev Based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
	 */
	/**
	 * @title Basic token
	 * @dev Basic version of StandardToken, with no allowances.
	 */
	contract BasicToken is ERC20Basic {
	  using SafeMath for uint256;


	  mapping(address => uint256) balances;


	  /**
	  * @dev transfer token for a specified address
	  * @param _to The address to transfer to.
	  * @param _value The amount to be transferred.
	  */
	  function transfer(address _to, uint256 _value) public returns (bool) {
	    require(_to != address(0));
	    require(_value <= balances[msg.sender]);


	    // SafeMath.sub will throw if there is not enough balance.
	    balances[msg.sender] = balances[msg.sender].sub(_value);
	    balances[_to] = balances[_to].add(_value);
	    Transfer(msg.sender, _to, _value);
	    return true;
	  }


	  /**
	  * @dev Gets the balance of the specified address.
	  * @param _owner The address to query the the balance of.
	  * @return An uint256 representing the amount owned by the passed address.
	  */
	  function balanceOf(address _owner) public constant returns (uint256 balance) {
	    return balances[_owner];
	  }


	}
	contract StandardToken is ERC20, BasicToken {


	  mapping (address => mapping (address => uint256)) internal allowed;




	  /**
	   * @dev Transfer tokens from one address to another
	   * @param _from address The address which you want to send tokens from
	   * @param _to address The address which you want to transfer to
	   * @param _value uint256 the amount of tokens to be transferred
	   */
	  function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
	    require(_to != address(0));
	    require(_value <= balances[_from]);
	    require(_value <= allowed[_from][msg.sender]);


	    balances[_from] = balances[_from].sub(_value);
	    balances[_to] = balances[_to].add(_value);
	    allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
	    Transfer(_from, _to, _value);
	    return true;
	  }


	  /**
	   * @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
	   *
	   * Beware that changing an allowance with this method brings the risk that someone may use both the old
	   * and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this
	   * race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards:
	   * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
	   * @param _spender The address which will spend the funds.
	   * @param _value The amount of tokens to be spent.
	   */
	  function approve(address _spender, uint256 _value) public returns (bool) {
	    allowed[msg.sender][_spender] = _value;
	    Approval(msg.sender, _spender, _value);
	    return true;
	  }


	  /**
	   * @dev Function to check the amount of tokens that an owner allowed to a spender.
	   * @param _owner address The address which owns the funds.
	   * @param _spender address The address which will spend the funds.
	   * @return A uint256 specifying the amount of tokens still available for the spender.
	   */
	  function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
	    return allowed[_owner][_spender];
	  }


	  /**
	   * approve should be called when allowed[_spender] == 0. To increment
	   * allowed value is better to use this function to avoid 2 calls (and wait until
	   * the first transaction is mined)
	   * From MonolithDAO Token.sol
	   */
	  function increaseApproval (address _spender, uint _addedValue) public returns (bool success) {
	    allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
	    Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
	    return true;
	  }


	  function decreaseApproval (address _spender, uint _subtractedValue) public returns (bool success) {
	    uint oldValue = allowed[msg.sender][_spender];
	    if (_subtractedValue > oldValue) {
	      allowed[msg.sender][_spender] = 0;
	    } else {
	      allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
	    }
	    Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
	    return true;
	  }


	}
	/**
	 * @title SafeERC20
	 * @dev Wrappers around ERC20 operations that throw on failure.
	 * To use this library you can add a `using SafeERC20 for ERC20;` statement to your contract,
	 * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
	 */
	library SafeERC20 {
	  function safeTransfer(ERC20Basic token, address to, uint256 value) internal {
	    assert(token.transfer(to, value));
	  }


	  function safeTransferFrom(ERC20 token, address from, address to, uint256 value) internal {
	    assert(token.transferFrom(from, to, value));
	  }


	  function safeApprove(ERC20 token, address spender, uint256 value) internal {
	    assert(token.approve(spender, value));
	  }
	}
	/**
	 * @title Burnable Token
	 * @dev Token that can be irreversibly burned (destroyed).
	 */
	/**
	 * @title Ownable
	 * @dev The Ownable contract has an owner address, and provides basic authorization control
	 * functions, this simplifies the implementation of "user permissions".
	 */
	contract Ownable {
	  address public owner;




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




	  /**
	   * @dev The Ownable constructor sets the original `owner` of the contract to the sender
	   * account.
	   */
	  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 public {
	    require(newOwner != address(0));
	    OwnershipTransferred(owner, newOwner);
	    owner = newOwner;
	  }


	}
	contract BurnableToken is StandardToken {


	    event Burn(address indexed burner, uint256 value);


	    /**
	     * @dev Burns a specific amount of tokens.
	     * @param _value The amount of token to be burned.
	     */
	    function burn(uint256 _value) public {
	        require(_value > 0);
	        require(_value <= balances[msg.sender]);
	        // no need to require value <= totalSupply, since that would imply the
	        // sender's balance is greater than the totalSupply, which *should* be an assertion failure


	        address burner = msg.sender;
	        balances[burner] = balances[burner].sub(_value);
	        totalSupply = totalSupply.sub(_value);
	        Burn(burner, _value);
	    }
	}
	/**
	 * @title AlttradexToken
	 * @dev Created limited supply burnable token and assigns all tokens to the contact creator.
	 */
	contract AlttradexToken is BurnableToken {
	    
	  string public constant name = "Alttradex Token";
	  string public constant symbol = "ATXT";
	  uint32 public constant decimals = 18;
	  uint256 public INITIAL_SUPPLY = 142857143 * 1000000000000000000;


	 function AlttradexToken() {
	    totalSupply = INITIAL_SUPPLY;
	    balances[msg.sender] = totalSupply;
	  }
	    
	}
	/**
	 * @title Crowdsale
	 * @dev Crowdsale is a base contract for managing a token crowdsale.
	 * Crowdsales have a start and end timestamps, where investors can make
	 * token purchases and the crowdsale will assign them tokens based
	 * on a token per ETH rate. Funds collected are forwarded to a wallet
	 * as they arrive.
	 */
	contract Crowdsale {
	  using SafeMath for uint256;


	  // The token being sold
	  AlttradexToken public token;
	  // start and end timestamps where investments are allowed (both inclusive)
	  uint256 public startTime;
	  uint256 public endTime;


	  // address where funds are collected
	  address public wallet;


	  // how many token units a buyer gets per wei
	  uint256 public rate;
	  uint256 public tokensSold; 
	  // amount of raised money in wei
	  uint256 public weiRaised;


	  /**
	   * event for token purchase logging
	   * @param purchaser who paid for the tokens
	   * @param beneficiary who got the tokens
	   * @param value weis paid for purchase
	   * @param amount amount of tokens purchased
	   */
	  event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);




	  function Crowdsale(uint256 _startTime, uint256 _endTime, uint256 _rate, address _wallet, address _tokenAddress) {
	    require(_endTime >= _startTime);
	    require(_rate > 0);
	    require(_wallet != 0x0);
	    require(_tokenAddress != 0x0);
	    
	    token = AlttradexToken(_tokenAddress);
	    startTime = _startTime;
	    endTime = _endTime;
	    rate = _rate;
	    wallet = _wallet;
	  }


	  // fallback function can be used to buy tokens
	  function () payable {
	    buyTokens(msg.sender);
	  }


	  // low level token purchase function
	  function buyTokens(address beneficiary) public payable {
	    require(beneficiary != 0x0);
	    require(validPurchase());
	    require(minAllowed());
	    // amount of wei received 
	    uint256 weiAmount = msg.value;
	    // amount of eth received 
	    // calculate token amount to be transferred
	    uint256 tokens = weiAmount.mul(rate);
	    
	    uint256 bonusTokens = 0;
	    
	    if (belowBonusCap()) {
	        bonusTokens = tokens.div(5);
	    }
	    tokens = tokens.add(bonusTokens);
	    // update state
	    weiRaised = weiRaised.add(weiAmount);
	     
	    // transfers tokens to the beneficiary
	    assert(token.transfer(beneficiary, tokens));
	    tokensSold = tokensSold.add(tokens);
	    
	    TokenPurchase(msg.sender, beneficiary, weiAmount, tokens);
	    
	    forwardFunds();
	  }


	  // send ether to the fund collection wallet
	  // override to create custom fund forwarding mechanisms
	  function forwardFunds() internal {
	    wallet.transfer(msg.value);
	  }
	  function minAllowed() internal constant returns (bool)  {
	      return msg.value > 100000000000000000;
	  }
	  // we're adding a 20% bonus of ATXT for the first million USD worth of ETH sold 
	  function belowBonusCap() internal constant returns (bool) {
	      return weiRaised < 3355000000000000000000;
	  }     
	  // @return true if the transaction can buy tokens
	  function validPurchase() internal constant returns (bool) {
	    bool withinPeriod = now >= startTime && now <= endTime;
	    bool nonZeroPurchase = msg.value != 0;
	    return withinPeriod && nonZeroPurchase;
	  }


	  // @return true if crowdsale event has ended
	  function hasEnded() public constant returns (bool) {
	    return now > endTime;
	  }
	  function tokensSold() public constant returns(uint256) {
	      return tokensSold;
	  }
	  


	}
	/**
	 * @title CappedCrowdsale
	 * @dev Extension of Crowdsale with a max amount of funds raised
	 */
	contract CappedCrowdsale is Crowdsale {
	  using SafeMath for uint256;


	  uint256 public cap;


	  function CappedCrowdsale(uint256 _cap) {
	    require(_cap > 0);
	    cap = _cap;
	  }


	  // overriding Crowdsale#validPurchase to add extra cap logic
	  // @return true if investors can buy at the moment
	  function validPurchase() internal constant returns (bool) {
	    bool withinCap = weiRaised.add(msg.value) <= cap;
	    return super.validPurchase() && withinCap;
	  }


	  // overriding Crowdsale#hasEnded to add cap logic
	  // @return true if crowdsale event has ended
	  function hasEnded() public constant returns (bool) {
	    bool capReached = weiRaised >= cap;
	    return super.hasEnded() || capReached;
	  }


	}
	/**
	 * @title FinalizableCrowdsale
	 * @dev Extension of Crowdsale where an owner can do extra work
	 * after finishing.
	 */
	contract FinalizableCrowdsale is Crowdsale, Ownable {
	  using SafeMath for uint256;


	  bool public isFinalized = false;
	  AlttradexToken alttradexToken;
	  event Finalized();


	  /**
	   * @dev Must be called after crowdsale ends, to do some extra finalization
	   * work. Calls the contract's finalization function.
	   */
	  function finalize() onlyOwner public {
	    require(!isFinalized);
	    require(hasEnded());
	    finalization();
	    Finalized();
	    burnTokens();
	    isFinalized = true;
	  }
	  /**
	   * @dev Will burn all the leftover (unsold) tokens 
	   */
	  
	  function burnTokens() internal {
	    token.burn(token.balanceOf(this));
	  }
	  /**
	   * @dev Can be overridden to add finalization logic. The overriding function
	   * should call super.finalization() to ensure the chain of finalization is
	   * executed entirely.
	   */
	  function finalization() internal {
	  }
	}
	/**
	 * @title RefundVault
	 * @dev This contract is used for storing funds while a crowdsale
	 * is in progress. Supports refunding the money if crowdsale fails,
	 * and forwarding it if crowdsale is successful.
	 */
	contract RefundVault is Ownable {
	  using SafeMath for uint256;


	  enum State { Active, Refunding, Closed }


	  mapping (address => uint256) public deposited;
	  address public wallet;
	  State public state;


	  event Closed();
	  event RefundsEnabled();
	  event Refunded(address indexed beneficiary, uint256 weiAmount);


	  function RefundVault(address _wallet) {
	    require(_wallet != 0x0);
	    wallet = _wallet;
	    state = State.Active;
	  }


	  function deposit(address investor) onlyOwner public payable {
	    require(state == State.Active);
	    deposited[investor] = deposited[investor].add(msg.value);
	  }


	  function close() onlyOwner public {
	    require(state == State.Active);
	    state = State.Closed;
	    Closed();
	    wallet.transfer(this.balance);
	  }


	  function enableRefunds() onlyOwner public {
	    require(state == State.Active);
	    state = State.Refunding;
	    RefundsEnabled();
	  }


	  function refund(address investor) public {
	    require(state == State.Refunding);
	    uint256 depositedValue = deposited[investor];
	    deposited[investor] = 0;
	    investor.transfer(depositedValue);
	    Refunded(investor, depositedValue);
	  }
	}
	/**
	 * @title RefundableCrowdsale
	 * @dev Extension of Crowdsale contract that adds a funding goal, and
	 * the possibility of users getting a refund if goal is not met.
	 * Uses a RefundVault as the crowdsale's vault.
	 */
	contract RefundableCrowdsale is FinalizableCrowdsale {
	  using SafeMath for uint256;


	  // minimum amount of funds to be raised in weis
	  uint256 public goal;


	  // refund vault used to hold funds while crowdsale is running
	  RefundVault public vault;


	  function RefundableCrowdsale(uint256 _goal) {
	    require(_goal > 0);
	    vault = new RefundVault(wallet);
	    goal = _goal;
	  }


	  // We're overriding the fund forwarding from Crowdsale.
	  // In addition to sending the funds, we want to call
	  // the RefundVault deposit function
	  function forwardFunds() internal {
	    vault.deposit.value(msg.value)(msg.sender);
	  }


	  // if crowdsale is unsuccessful, investors can claim refunds here
	  function claimRefund() public {
	    require(isFinalized);
	    require(!goalReached());


	    vault.refund(msg.sender);
	  }


	  // vault finalization task, called when owner calls finalize()
	  function finalization() internal {
	    if (goalReached()) {
	      vault.close();
	    } else {
	      vault.enableRefunds();
	    }


	    super.finalization();
	  }


	  function goalReached() public constant returns (bool) {
	    return weiRaised >= goal;
	  }


	}
	/**
	 * @title AlttradexCrowdsale
	 * @dev Creates capped, refundable and finalizable crowdsale. 
	 * _startTime - Crowdsale Start timestamp;
	 * _endTime - Crowdsale Start timestamp
	 * _rate - Sold Token rate
	 * _goal - Crowdsale goal in wei 
	 * _cap - Crowdsale cap in wei
	 * _wallet - multisig wallet where eth is going to land
	 *  _tokenAddress - Sold Token address
	 */
	contract AlttradexCrowdsale is CappedCrowdsale, RefundableCrowdsale {


	  function AlttradexCrowdsale(uint256 _startTime, uint256 _endTime, uint256 _rate, uint256 _goal, uint256 _cap, address _wallet, address _tokenAddress)
	    CappedCrowdsale(_cap)
	    FinalizableCrowdsale()
	    RefundableCrowdsale(_goal)
	    Crowdsale(_startTime, _endTime, _rate, _wallet, _tokenAddress)
	  {
	    //As goal needs to be met for a successful crowdsale
	    //the value needs to less or equal than a cap which is limit for accepted funds
	    require(_goal <= _cap);
	  }


	}


	contract AlttradexTokenLockup {
	   using SafeMath for uint256;


	   AlttradexToken alttradexToken;


	   // beneficiary of tokens after they are released
	   address public beneficiary;


	   // timestamp when token release is enabled
	   uint256 public releaseTime;


	   function AlttradexTokenLockup(address _tokenContractAddress, address _beneficiary) {
	      require(_tokenContractAddress != address(0));
	      require(_beneficiary != address(0));
	      // 72 weeks = 18 months
	      releaseTime = now.add(72 weeks);
	      alttradexToken = AlttradexToken(_tokenContractAddress);
	      beneficiary = _beneficiary;
	   }


	   /**
	   * @notice Transfers tokens held by timelock to beneficiary.
	   */
	   function release() {
	      require(now >= releaseTime);


	      uint256 balance = alttradexToken.balanceOf(this);
	      require(balance > 0);


	      assert(alttradexToken.transfer(beneficiary, balance));
	   }


	   function fundsAreAvailable() constant returns (bool) {
	      return now >= releaseTime;
	   }
	}

Untitled1.sol

pragma solidity ^0.4.16;

/**
 * @title ERC20Basic
 * @dev Simpler version of ERC20 interface
 * @dev see https://github.com/ethereum/EIPs/issues/179
 */
contract ERC20Basic {
  uint256 public totalSupply;
  function balanceOf(address who) constant returns (uint256);
  function transfer(address to, uint256 value) returns (bool);
  event Transfer(address indexed from, address indexed to, uint256 value);
}

/**
 * @title ERC20 interface
 * @dev see https://github.com/ethereum/EIPs/issues/20
 */
contract ERC20 is ERC20Basic {
  function allowance(address owner, address spender) constant returns (uint256);
  function transferFrom(address from, address to, uint256 value) returns (bool);
  function approve(address spender, uint256 value) returns (bool);
  event Approval(address indexed owner, address indexed spender, uint256 value);
}

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

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

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

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

/**
 * @title Basic token
 * @dev Basic version of StandardToken, with no allowances. 
 */
contract BasicToken is ERC20Basic {
    
  using SafeMath for uint256;

  mapping(address => uint256) balances;

  /**
  * @dev transfer token for a specified address
  * @param _to The address to transfer to.
  * @param _value The amount to be transferred.
  */
  function transfer(address _to, uint256 _value) returns (bool) {
    balances[msg.sender] = balances[msg.sender].sub(_value);
    balances[_to] = balances[_to].add(_value);
    Transfer(msg.sender, _to, _value);
    return true;
  }

  /**
  * @dev Gets the balance of the specified address.
  * @param _owner The address to query the the balance of. 
  * @return An uint256 representing the amount owned by the passed address.
  */
  function balanceOf(address _owner) constant returns (uint256 balance) {
    return balances[_owner];
  }

}

/**
 * @title Standard ERC20 token
 *
 * @dev Implementation of the basic standard token.
 * @dev https://github.com/ethereum/EIPs/issues/20
 * @dev Based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
 */
contract StandardToken is ERC20, BasicToken {

  mapping (address => mapping (address => uint256)) allowed;

  /**
   * @dev Transfer tokens from one address to another
   * @param _from address The address which you want to send tokens from
   * @param _to address The address which you want to transfer to
   * @param _value uint256 the amout of tokens to be transfered
   */
  function transferFrom(address _from, address _to, uint256 _value) returns (bool) {
    var _allowance = allowed[_from][msg.sender];

    // Check is not needed because sub(_allowance, _value) will already throw if this condition is not met
    // require (_value <= _allowance);

    balances[_to] = balances[_to].add(_value);
    balances[_from] = balances[_from].sub(_value);
    allowed[_from][msg.sender] = _allowance.sub(_value);
    Transfer(_from, _to, _value);
    return true;
  }

  /**
   * @dev Aprove the passed address to spend the specified amount of tokens on behalf of msg.sender.
   * @param _spender The address which will spend the funds.
   * @param _value The amount of tokens to be spent.
   */
  function approve(address _spender, uint256 _value) returns (bool) {

    // To change the approve amount you first have to reduce the addresses`
    //  allowance to zero by calling `approve(_spender, 0)` if it is not
    //  already 0 to mitigate the race condition described here:
    //  https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
    require((_value == 0) || (allowed[msg.sender][_spender] == 0));

    allowed[msg.sender][_spender] = _value;
    Approval(msg.sender, _spender, _value);
    return true;
  }

  /**
   * @dev Function to check the amount of tokens that an owner allowed to a spender.
   * @param _owner address The address which owns the funds.
   * @param _spender address The address which will spend the funds.
   * @return A uint256 specifing the amount of tokens still available for the spender.
   */
  function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
    return allowed[_owner][_spender];
  }

}

/**
 * @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 {
    require(newOwner != address(0));      
    owner = newOwner;
  }

}

/**
 * @title Burnable Token
 * @dev Token that can be irreversibly burned (destroyed).
 */
contract BurnableToken is StandardToken {

  /**
   * @dev Burns a specific amount of tokens.
   * @param _value The amount of token to be burned.
   */
  function burn(uint _value) public {
    require(_value > 0);
    address burner = msg.sender;
    balances[burner] = balances[burner].sub(_value);
    totalSupply = totalSupply.sub(_value);
    Burn(burner, _value);
  }

  event Burn(address indexed burner, uint indexed value);

}

contract SAFTPreSaleToken  is BurnableToken {
    
  string public constant name = "SAFT  pre-sale token ";
   
  string public constant symbol = "DTEX";
    
  uint32 public constant decimals = 18;

  uint256 public INITIAL_SUPPLY = 6000000 * 1 ether;

  function SAFTPreSaleToken () {
    totalSupply = INITIAL_SUPPLY;
    balances[0xd3ef2df1152f3117e9d0cdeca82c669dad0dabae] = INITIAL_SUPPLY;
  }
    
}

contract Crowdsale is Ownable {
    
  using SafeMath for uint;
    
  address multisig;

  uint restrictedPercent;

  address restricted;

  SAFTPreSaleToken public token = new SAFTPreSaleToken ();

  uint start;
    
  uint period;

  uint rate;

  function Crowdsale() {
    multisig = 0x315a4749588Ad91c8C6f175D7C3dD68eEd2b9843;
    restricted = 0x315a4749588Ad91c8C6f175D7C3dD68eEd2b9843;
    restrictedPercent = 0;
    rate = 1430000000000000000000;
    start = 1509633905;
    period = 1095;
  }

  modifier saleIsOn() {
    require(now > start && now < start + period * 1 days);
    _;
  }

   function createTokens() saleIsOn payable {
    multisig.transfer(msg.value);
    uint tokens = rate.mul(msg.value).div(1 ether);
    uint bonusTokens = 0;
    uint tokensWithBonus = tokens.add(bonusTokens);
    token.transfer(msg.sender, tokensWithBonus);
    uint restrictedTokens = tokens.mul(restrictedPercent).div(100 - restrictedPercent);
    token.transfer(restricted, restrictedTokens);
  }
 
  function() external payable {
    createTokens();
  }
    
}

Untitled2.sol

pragma solidity ^0.4.18;

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

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

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

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

contract Ownable {
  address public owner;


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


  /**
   * @dev The Ownable constructor sets the original `owner` of the contract to the sender
   * account.
   */
  function Ownable() {
    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 public {
    require(newOwner != address(0));
    OwnershipTransferred(owner, newOwner);
    owner = newOwner;
  }

}

contract Claimable is Ownable {
  address public pendingOwner;

  /**
   * @dev Modifier throws if called by any account other than the pendingOwner.
   */
  modifier onlyPendingOwner() {
    require(msg.sender == pendingOwner);
    _;
  }

  /**
   * @dev Allows the current owner to set the pendingOwner address.
   * @param newOwner The address to transfer ownership to.
   */
  function transferOwnership(address newOwner) onlyOwner public {
    pendingOwner = newOwner;
  }

  /**
   * @dev Allows the pendingOwner address to finalize the transfer.
   */
  function claimOwnership() onlyPendingOwner public {
    OwnershipTransferred(owner, pendingOwner);
    owner = pendingOwner;
    pendingOwner = 0x0;
  }
}

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

contract PresaleOracles is Claimable {
/*
 * PresaleOracles
 * Simple Presale contract
 * built by github.com/rstormsf Roman Storm
 */
    using SafeMath for uint256;
    uint256 public startTime;
    uint256 public endTime;
    uint256 public cap;
    uint256 public totalInvestedInWei;
    uint256 public minimumContribution;
    mapping(address => uint256) public investorBalances;
    mapping(address => bool) public whitelist;
    uint256 public investorsLength;
    address public vault;
    bool public isInitialized = false;
    // TESTED by Roman Storm
    function () public payable {
        buy();
    }
    //TESTED by Roman Storm
    function Presale() public {
    }
    //TESTED by Roman Storm
    function initialize(uint256 _startTime, uint256 _endTime, uint256 _cap, uint256 _minimumContribution, address _vault) public onlyOwner {
        require(!isInitialized);
        require(_startTime != 0);
        require(_endTime != 0);
        require(_endTime > _startTime);
        require(_cap != 0);
        require(_minimumContribution != 0);
        require(_vault != 0x0);
        require(_cap > _minimumContribution);
        startTime = _startTime;
        endTime = _endTime;
        cap = _cap;
        isInitialized = true;
        minimumContribution = _minimumContribution;
        vault = _vault;
    }
    //TESTED by Roman Storm
    event Contribution(address indexed investor, uint256 investorAmount, uint256 investorTotal, uint256 totalAmount);
    function buy() public payable {
        require(whitelist[msg.sender]);
        require(isValidPurchase(msg.value));
        require(isInitialized);
        require(getTime() >= startTime && getTime() <= endTime);
        address investor = msg.sender;
        investorBalances[investor] += msg.value;
        totalInvestedInWei += msg.value;
        forwardFunds(msg.value);
        Contribution(msg.sender, msg.value, investorBalances[investor], totalInvestedInWei);
    }
    
    //TESTED by Roman Storm
    function forwardFunds(uint256 _amount) internal {
        vault.transfer(_amount);
    }
    //TESTED by Roman Storm
    function claimTokens(address _token) public onlyOwner {
        if (_token == 0x0) {
            owner.transfer(this.balance);
            return;
        }
    
        ERC20Basic token = ERC20Basic(_token);
        uint256 balance = token.balanceOf(this);
        token.transfer(owner, balance);
    }

    function getTime() internal view returns(uint256) {
        return now;
    }
    //TESTED by Roman Storm
    function isValidPurchase(uint256 _amount) public view returns(bool) {
        bool nonZero = _amount > 0;
        bool hasMinimumAmount = investorBalances[msg.sender].add(_amount) >= minimumContribution;
        bool withinCap = totalInvestedInWei.add(_amount) <= cap;
        return hasMinimumAmount && withinCap && nonZero;
    }
    //TESTED by Roman Storm
    function whitelistInvestor(address _newInvestor) public onlyOwner {
        if(!whitelist[_newInvestor]) {
            whitelist[_newInvestor] = true;
            investorsLength++;
        }
    }
    //TESTED by Roman Storm
    function whitelistInvestors(address[] _investors) external onlyOwner {
        require(_investors.length <= 250);
        for(uint8 i=0; i<_investors.length;i++) {
            address newInvestor = _investors[i];
            if(!whitelist[newInvestor]) {
                whitelist[newInvestor] = true;
                investorsLength++;
            }
        }
    }
    function blacklistInvestor(address _investor) public onlyOwner {
        if(whitelist[_investor]) {
            delete whitelist[_investor];
            if(investorsLength != 0) {
                investorsLength--;
            }
        }
    }
}

wallet.sol

//sol Wallet
// Multi-sig, daily-limited account proxy/wallet.
// @authors:
// Gav Wood <g@ethdev.com>
// inheritable "property" contract that enables methods to be protected by requiring the acquiescence of either a
// single, or, crucially, each of a number of, designated owners.
// usage:
// use modifiers onlyowner (just own owned) or onlymanyowners(hash), whereby the same hash must be provided by
// some number (specified in constructor) of the set of owners (specified in the constructor, modifiable) before the
// interior is executed.
contract multiowned {

    // TYPES

    // struct for the status of a pending operation.
    struct PendingState {
        uint yetNeeded;
        uint ownersDone;
        uint index;
    }

    // EVENTS

    // this contract only has five types of events: it can accept a confirmation, in which case
    // we record owner and operation (hash) alongside it.
    event Confirmation(address owner, bytes32 operation);
    event Revoke(address owner, bytes32 operation);
    // some others are in the case of an owner changing.
    event OwnerChanged(address oldOwner, address newOwner);
    event OwnerAdded(address newOwner);
    event OwnerRemoved(address oldOwner);
    // the last one is emitted if the required signatures change
    event RequirementChanged(uint newRequirement);

    // MODIFIERS

    // simple single-sig function modifier.
    modifier onlyowner {
        if (isOwner(msg.sender))
            _;
    }
    
    // multi-sig function modifier: the operation must have an intrinsic hash in order
    // that later attempts can be realised as the same underlying operation and
    // thus count as confirmations.
    modifier onlymanyowners(bytes32 _operation) {
        if (confirmAndCheck(_operation))
            _;
    }

    // METHODS

    // constructor is given number of sigs required to do protected "onlymanyowners" transactions
    // as well as the selection of addresses capable of confirming them.
    function multiowned(address[] _owners, uint _required) {
        m_numOwners = _owners.length + 1;
        m_owners[1] = uint(msg.sender);
        m_ownerIndex[uint(msg.sender)] = 1;
        for (uint i = 0; i < _owners.length; ++i)
        {
            m_owners[2 + i] = uint(_owners[i]);
            m_ownerIndex[uint(_owners[i])] = 2 + i;
        }
        m_required = _required;
    }
    
    // Revokes a prior confirmation of the given operation
    function revoke(bytes32 _operation) external {
        uint ownerIndex = m_ownerIndex[uint(msg.sender)];
        // make sure they're an owner
        if (ownerIndex == 0) return;
        uint ownerIndexBit = 2**ownerIndex;
        var pending = m_pending[_operation];
        if (pending.ownersDone & ownerIndexBit > 0) {
            pending.yetNeeded++;
            pending.ownersDone -= ownerIndexBit;
            Revoke(msg.sender, _operation);
        }
    }
    
    // Replaces an owner `_from` with another `_to`.
    function changeOwner(address _from, address _to) onlymanyowners(sha3(msg.data, block.number)) external {
        if (isOwner(_to)) return;
        uint ownerIndex = m_ownerIndex[uint(_from)];
        if (ownerIndex == 0) return;

        clearPending();
        m_owners[ownerIndex] = uint(_to);
        m_ownerIndex[uint(_from)] = 0;
        m_ownerIndex[uint(_to)] = ownerIndex;
        OwnerChanged(_from, _to);
    }
    
    function addOwner(address _owner) onlymanyowners(sha3(msg.data, block.number)) external {
        if (isOwner(_owner)) return;

        clearPending();
        if (m_numOwners >= c_maxOwners)
            reorganizeOwners();
        if (m_numOwners >= c_maxOwners)
            return;
        m_numOwners++;
        m_owners[m_numOwners] = uint(_owner);
        m_ownerIndex[uint(_owner)] = m_numOwners;
        OwnerAdded(_owner);
    }
    
    function removeOwner(address _owner) onlymanyowners(sha3(msg.data, block.number)) external {
        uint ownerIndex = m_ownerIndex[uint(_owner)];
        if (ownerIndex == 0) return;
        if (m_required > m_numOwners - 1) return;

        m_owners[ownerIndex] = 0;
        m_ownerIndex[uint(_owner)] = 0;
        clearPending();
        reorganizeOwners(); //make sure m_numOwner is equal to the number of owners and always points to the optimal free slot
        OwnerRemoved(_owner);
    }
    
    function changeRequirement(uint _newRequired) onlymanyowners(sha3(msg.data, block.number)) external {
        if (_newRequired > m_numOwners) return;
        m_required = _newRequired;
        clearPending();
        RequirementChanged(_newRequired);
    }
    
    function isOwner(address _addr) returns (bool) {
        return m_ownerIndex[uint(_addr)] > 0;
    }
    
    function hasConfirmed(bytes32 _operation, address _owner) constant returns (bool) {
        var pending = m_pending[_operation];
        uint ownerIndex = m_ownerIndex[uint(_owner)];

        // make sure they're an owner
        if (ownerIndex == 0) return false;

        // determine the bit to set for this owner.
        uint ownerIndexBit = 2**ownerIndex;
        if (pending.ownersDone & ownerIndexBit == 0) {
            return false;
        } else {
            return true;
        }
    }
    
    // INTERNAL METHODS

    function confirmAndCheck(bytes32 _operation) internal returns (bool) {
        // determine what index the present sender is:
        uint ownerIndex = m_ownerIndex[uint(msg.sender)];
        // make sure they're an owner
        if (ownerIndex == 0) return;

        var pending = m_pending[_operation];
        // if we're not yet working on this operation, switch over and reset the confirmation status.
        if (pending.yetNeeded == 0) {
            // reset count of confirmations needed.
            pending.yetNeeded = m_required;
            // reset which owners have confirmed (none) - set our bitmap to 0.
            pending.ownersDone = 0;
            pending.index = m_pendingIndex.length++;
            m_pendingIndex[pending.index] = _operation;
        }
        // determine the bit to set for this owner.
        uint ownerIndexBit = 2**ownerIndex;
        // make sure we (the message sender) haven't confirmed this operation previously.
        if (pending.ownersDone & ownerIndexBit == 0) {
            Confirmation(msg.sender, _operation);
            // ok - check if count is enough to go ahead.
            if (pending.yetNeeded <= 1) {
                // enough confirmations: reset and run interior.
                delete m_pendingIndex[m_pending[_operation].index];
                delete m_pending[_operation];
                return true;
            }
            else
            {
                // not enough: record that this owner in particular confirmed.
                pending.yetNeeded--;
                pending.ownersDone |= ownerIndexBit;
            }
        }
    }

    function reorganizeOwners() private returns (bool) {
        uint free = 1;
        while (free < m_numOwners)
        {
            while (free < m_numOwners && m_owners[free] != 0) free++;
            while (m_numOwners > 1 && m_owners[m_numOwners] == 0) m_numOwners--;
            if (free < m_numOwners && m_owners[m_numOwners] != 0 && m_owners[free] == 0)
            {
                m_owners[free] = m_owners[m_numOwners];
                m_ownerIndex[m_owners[free]] = free;
                m_owners[m_numOwners] = 0;
            }
        }
    }
    
    function clearPending() internal {
        uint length = m_pendingIndex.length;
        for (uint i = 0; i < length; ++i)
            if (m_pendingIndex[i] != 0)
                delete m_pending[m_pendingIndex[i]];
        delete m_pendingIndex;
    }
        
    // FIELDS

    // the number of owners that must confirm the same operation before it is run.
    uint public m_required;
    // pointer used to find a free slot in m_owners
    uint public m_numOwners;
    
    // list of owners
    uint[256] m_owners;
    uint constant c_maxOwners = 250;
    // index on the list of owners to allow reverse lookup
    mapping(uint => uint) m_ownerIndex;
    // the ongoing operations.
    mapping(bytes32 => PendingState) m_pending;
    bytes32[] m_pendingIndex;
}

// inheritable "property" contract that enables methods to be protected by placing a linear limit (specifiable)
// on a particular resource per calendar day. is multiowned to allow the limit to be altered. resource that method
// uses is specified in the modifier.
contract daylimit is multiowned {

    // MODIFIERS

    // simple modifier for daily limit.
    modifier limitedDaily(uint _value) {
        if (underLimit(_value))
            _;
    }

    // METHODS

    // constructor - stores initial daily limit and records the present day's index.
    function daylimit(uint _limit) {
        m_dailyLimit = _limit;
        m_lastDay = today();
    }
    // (re)sets the daily limit. needs many of the owners to confirm. doesn't alter the amount already spent today.
    function setDailyLimit(uint _newLimit) onlymanyowners(sha3(msg.data, block.number)) external {
        m_dailyLimit = _newLimit;
    }
    // (re)sets the daily limit. needs many of the owners to confirm. doesn't alter the amount already spent today.
    function resetSpentToday() onlymanyowners(sha3(msg.data, block.number)) external {
        m_spentToday = 0;
    }
    
    // INTERNAL METHODS
    
    // checks to see if there is at least `_value` left from the daily limit today. if there is, subtracts it and
    // returns true. otherwise just returns false.
    function underLimit(uint _value) internal onlyowner returns (bool) {
        // reset the spend limit if we're on a different day to last time.
        if (today() > m_lastDay) {
            m_spentToday = 0;
            m_lastDay = today();
        }
        // check to see if there's enough left - if so, subtract and return true.
        if (m_spentToday + _value >= m_spentToday && m_spentToday + _value <= m_dailyLimit) {
            m_spentToday += _value;
            return true;
        }
        return false;
    }
    // determines today's index.
    function today() private constant returns (uint) { return now / 1 days; }

    // FIELDS

    uint public m_dailyLimit;
    uint public m_spentToday;
    uint public m_lastDay;
}

// interface contract for multisig proxy contracts; see below for docs.
contract multisig {

    // EVENTS

    // logged events:
    // Funds has arrived into the wallet (record how much).
    event Deposit(address from, uint value);
    // Single transaction going out of the wallet (record who signed for it, how much, and to whom it's going).
    event SingleTransact(address owner, uint value, address to, bytes data);
    // Multi-sig transaction going out of the wallet (record who signed for it last, the operation hash, how much, and to whom it's going).
    event MultiTransact(address owner, bytes32 operation, uint value, address to, bytes data);
    // Confirmation still needed for a transaction.
    event ConfirmationNeeded(bytes32 operation, address initiator, uint value, address to, bytes data);
    
    // FUNCTIONS
    
    // TODO: document
    function changeOwner(address _from, address _to) external;
    function execute(address _to, uint _value, bytes _data) external returns (bytes32);
    function confirm(bytes32 _h) returns (bool);
}

// usage:
// bytes32 h = Wallet(w).from(oneOwner).transact(to, value, data);
// Wallet(w).from(anotherOwner).confirm(h);
contract Wallet is multisig, multiowned, daylimit {

    uint public version = 2;

    // TYPES

    // Transaction structure to remember details of transaction lest it need be saved for a later call.
    struct Transaction {
        address to;
        uint value;
        bytes data;
    }

    // METHODS

    // constructor - just pass on the owner array to the multiowned and
    // the limit to daylimit
    function Wallet(address[] _owners, uint _required, uint _daylimit)
            multiowned(_owners, _required) daylimit(_daylimit) {
    }
    
    // kills the contract sending everything to `_to`.
    function kill(address _to) onlymanyowners(sha3(msg.data, block.number)) external {
        suicide(_to);
    }
    
    // gets called when no other function matches
    function() {
        // just being sent some cash?
        if (msg.value > 0)
            Deposit(msg.sender, msg.value);
    }
    
    // Outside-visible transact entry point. Executes transacion immediately if below daily spend limit.
    // If not, goes into multisig process. We provide a hash on return to allow the sender to provide
    // shortcuts for the other confirmations (allowing them to avoid replicating the _to, _value
    // and _data arguments). They still get the option of using them if they want, anyways.
    function execute(address _to, uint _value, bytes _data) external onlyowner returns (bytes32 _r) {
        // first, take the opportunity to check that we're under the daily limit.
        if (underLimit(_value)) {
            SingleTransact(msg.sender, _value, _to, _data);
            // yes - just execute the call.
            _to.call.value(_value)(_data);
            return 0;
        }
        // determine our operation hash.
        _r = sha3(msg.data, block.number);
        if (!confirm(_r) && m_txs[_r].to == 0) {
            m_txs[_r].to = _to;
            m_txs[_r].value = _value;
            m_txs[_r].data = _data;
            ConfirmationNeeded(_r, msg.sender, _value, _to, _data);
        }
    }
    
    // confirm a transaction through just the hash. we use the previous transactions map, m_txs, in order
    // to determine the body of the transaction from the hash provided.
    function confirm(bytes32 _h) onlymanyowners(_h) returns (bool) {
        if (m_txs[_h].to != 0) {
            m_txs[_h].to.call.value(m_txs[_h].value)(m_txs[_h].data);
            MultiTransact(msg.sender, _h, m_txs[_h].value, m_txs[_h].to, m_txs[_h].data);
            delete m_txs[_h];
            return true;
        }
    }
    
    // INTERNAL METHODS
    
    function clearPending() internal {
        uint length = m_pendingIndex.length;
        for (uint i = 0; i < length; ++i)
            delete m_txs[m_pendingIndex[i]];
        super.clearPending();
    }

    // FIELDS

    // pending transactions we have at present.
    mapping (bytes32 => Transaction) m_txs;
}

web3api.sol

  pragma solidity ^0.4.0;
  
  contract mortal {
    /* Define variable owner of the type address*/
    address owner;

    /* this function is executed at initialization and sets the owner of the contract */
    function mortal() { owner = msg.sender; }

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

  contract greeter is mortal {
    /* define variable greeting of the type string */
    string greeting;

    /* this runs when the contract is executed */
    function greeter(string _greeting) public {
    greeting = _greeting;
    }

    /* main function */
    function greet() constant returns (string) {
    return greeting;
    }
  }

ZZZ.sol

pragma solidity ^0.4.16;

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

contract MyToken {
    // Public variables of the token
    string public name;
    string public symbol;
    uint8 public decimals;
    uint256 public totalSupply;

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

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

    // This notifies clients about the amount burnt
    event Burn(address indexed from, uint256 value);

    /**
     * Constructor function
     *
     * Initializes contract with initial supply tokens to the creator of the contract
     */
    function MyToken(
        uint256 initialSupply,
        string tokenName,
        uint8 decimalUnits,
        string tokenSymbol
    ) {
        balanceOf[msg.sender] = initialSupply;              // Give the creator all initial tokens
        totalSupply = initialSupply;                        // Update total supply
        name = tokenName;                                   // Set the name for display purposes
        symbol = tokenSymbol;                               // Set the symbol for display purposes
        decimals = decimalUnits;                            // Amount of decimals for display purposes
    }

    /**
     * Internal transfer, only can be called by this contract
     */
    function _transfer(address _from, address _to, uint _value) internal {
        require(_to != 0x0);                               // Prevent transfer to 0x0 address. Use burn() instead
        require(balanceOf[_from] >= _value);                // Check if the sender has enough
        require(balanceOf[_to] + _value > balanceOf[_to]); // Check for overflows
        balanceOf[_from] -= _value;                         // Subtract from the sender
        balanceOf[_to] += _value;                           // Add the same to the recipient
        Transfer(_from, _to, _value);
    }

    /**
     * Transfer tokens
     *
     * Send `_value` tokens to `_to` from your account
     *
     * @param _to The address of the recipient
     * @param _value the amount to send
     */
    function transfer(address _to, uint256 _value) {
        _transfer(msg.sender, _to, _value);
    }

    /**
     * Transfer tokens from other address
     *
     * Send `_value` tokens to `_to` in behalf of `_from`
     *
     * @param _from The address of the sender
     * @param _to The address of the recipient
     * @param _value the amount to send
     */
    function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
        require(_value <= allowance[_from][msg.sender]);     // Check allowance
        allowance[_from][msg.sender] -= _value;
        _transfer(_from, _to, _value);
        return true;
    }

    /**
     * Set allowance for other address
     *
     * Allows `_spender` to spend no more than `_value` tokens in your behalf
     *
     * @param _spender The address authorized to spend
     * @param _value the max amount they can spend
     */
    function approve(address _spender, uint256 _value)
        returns (bool success) {
        allowance[msg.sender][_spender] = _value;
        return true;
    }

    /**
     * Set allowance for other address and notify
     *
     * Allows `_spender` to spend no more than `_value` tokens in your behalf, and then ping the contract about it
     *
     * @param _spender The address authorized to spend
     * @param _value the max amount they can spend
     * @param _extraData some extra information to send to the approved contract
     */
    function approveAndCall(address _spender, uint256 _value, bytes _extraData)
        returns (bool success) {
        tokenRecipient spender = tokenRecipient(_spender);
        if (approve(_spender, _value)) {
            spender.receiveApproval(msg.sender, _value, this, _extraData);
            return true;
        }
    }

    /**
     * Destroy tokens
     *
     * Remove `_value` tokens from the system irreversibly
     *
     * @param _value the amount of money to burn
     */
    function burn(uint256 _value) returns (bool success) {
        require(balanceOf[msg.sender] >= _value);   // Check if the sender has enough
        balanceOf[msg.sender] -= _value;            // Subtract from the sender
        totalSupply -= _value;                      // Updates totalSupply
        Burn(msg.sender, _value);
        return true;
    }

    /**
     * Destroy tokens from other ccount
     *
     * Remove `_value` tokens from the system irreversibly on behalf of `_from`.
     *
     * @param _from the address of the sender
     * @param _value the amount of money to burn
     */
    function burnFrom(address _from, uint256 _value) returns (bool success) {
        require(balanceOf[_from] >= _value);                // Check if the targeted balance is enough
        require(_value <= allowance[_from][msg.sender]);    // Check allowance
        balanceOf[_from] -= _value;                         // Subtract from the targeted balance
        allowance[_from][msg.sender] -= _value;             // Subtract from the sender's allowance
        totalSupply -= _value;                              // Update totalSupply
        Burn(_from, _value);
        return true;
    }
}