Contract 0xaA3e80a42E7Bac1072BEe7Ee5Ac72123969b8400

pragma solidity 0.4.15;

pragma solidity 0.4.15;

/**
 * @title MultiOwnable
 * allows creating contracts with up to 16 owners with their shares
 */
contract MultiOwnable {
    /** a single owner record */
    struct Owner {
        address recipient;
        uint share;
    }

    /** contract owners */
    Owner[] public owners;

    /**
     * Returns total owners count
     * @return count - owners count
     */
    function ownersCount ()   constant   returns (uint count) {  
        return owners.length;
    }

    /**
     * Returns owner's info
     * @param  idx - index of the owner
     * @return owner - owner's info
     */
    function owner (uint idx)   constant   returns (address owner_dot_recipient, uint owner_dot_share) {  
Owner memory owner;

        owner = owners[idx];
    owner_dot_recipient = address(owner.recipient);
owner_dot_share = uint(owner.share);}

    /** reverse lookup helper */
    mapping (address => bool) ownersIdx;

    /**
     * Creates the contract with up to 16 owners
     * shares must be > 0
     */
    function MultiOwnable (address[16] _owners_dot_recipient, uint[16] _owners_dot_share)   {  
Owner[16] memory _owners;

for(uint __recipient_iterator__ = 0; __recipient_iterator__ < _owners_dot_recipient.length;__recipient_iterator__++)
  _owners[__recipient_iterator__].recipient = address(_owners_dot_recipient[__recipient_iterator__]);
for(uint __share_iterator__ = 0; __share_iterator__ < _owners_dot_share.length;__share_iterator__++)
  _owners[__share_iterator__].share = uint(_owners_dot_share[__share_iterator__]);
        for(var idx = 0; idx < _owners_dot_recipient.length; idx++) {
            if(_owners[idx].recipient != 0) {
                owners.push(_owners[idx]);
                assert(owners[idx].share > 0);
                ownersIdx[_owners[idx].recipient] = true;
            }
        }
    }

    /**
     * Function with this modifier can be called only by one of owners
     */
    modifier onlyOneOfOwners() {
        require(ownersIdx[msg.sender]);
        _;
    }


}


pragma solidity 0.4.15;

pragma solidity 0.4.15;

/**
 * Basic interface for contracts, following ERC20 standard
 */
contract ERC20Token {
    

    /**
     * Triggered when tokens are transferred.
     * @param from - address tokens were transfered from
     * @param to - address tokens were transfered to
     * @param value - amount of tokens transfered
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * Triggered whenever allowance status changes
     * @param owner - tokens owner, allowance changed for
     * @param spender - tokens spender, allowance changed for
     * @param value - new allowance value (overwriting the old value)
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);

    /**
     * Returns total supply of tokens ever emitted
     * @return totalSupply - total supply of tokens ever emitted
     */
    function totalSupply() constant returns (uint256 totalSupply);

    /**
     * Returns `owner` balance of tokens
     * @param owner address to request balance for
     * @return balance - token balance of `owner`
     */
    function balanceOf(address owner) constant returns (uint256 balance);

    /**
     * Transfers `amount` of tokens to `to` address
     * @param  to - address to transfer to
     * @param  value - amount of tokens to transfer
     * @return success - `true` if the transfer was succesful, `false` otherwise
     */
    function transfer(address to, uint256 value) returns (bool success);

    /**
     * Transfers `value` tokens from `from` address to `to`
     * the sender needs to have allowance for this operation
     * @param  from - address to take tokens from
     * @param  to - address to send tokens to
     * @param  value - amount of tokens to send
     * @return success - `true` if the transfer was succesful, `false` otherwise
     */
    function transferFrom(address from, address to, uint256 value) returns (bool success);

    /**
     * Allow spender to withdraw from your account, multiple times, up to the value amount.
     * If this function is called again it overwrites the current allowance with `value`.
     * this function is required for some DEX functionality
     * @param spender - address to give allowance to
     * @param value - the maximum amount of tokens allowed for spending
     * @return success - `true` if the allowance was given, `false` otherwise
     */
    function approve(address spender, uint256 value) returns (bool success);

    /**
     * Returns the amount which `spender` is still allowed to withdraw from `owner`
     * @param  owner - tokens owner
     * @param  spender - addres to request allowance for
     * @return remaining - remaining allowance (token count)
     */
    function allowance(address owner, address spender) constant returns (uint256 remaining);
}


/**
 * @title Blind Croupier Token
 * WIN fixed supply Token, used for Blind Croupier TokenDistribution
 */
 contract WIN is ERC20Token {
    

    string public constant symbol = "WIN";
    string public constant name = "WIN";

    uint8 public constant decimals = 7;
    uint256 constant TOKEN = 10**7;
    uint256 constant MILLION = 10**6;
    uint256 public totalTokenSupply = 500 * MILLION * TOKEN;

    /** balances of each accounts */
    mapping(address => uint256) balances;

    /** amount of tokens approved for transfer */
    mapping(address => mapping (address => uint256)) allowed;

    /** Triggered when `owner` destroys `amount` tokens */
    event Destroyed(address indexed owner, uint256 amount);

    /**
     * Constucts the token, and supplies the creator with `totalTokenSupply` tokens
     */
    function WIN ()   { 
        balances[msg.sender] = totalTokenSupply;
    }

    /**
     * Returns total supply of tokens ever emitted
     * @return result - total supply of tokens ever emitted
     */
    function totalSupply ()  constant  returns (uint256 result) { 
        result = totalTokenSupply;
    }

    /**
    * Returns `owner` balance of tokens
    * @param owner address to request balance for
    * @return balance - token balance of `owner`
    */
    function balanceOf (address owner)  constant  returns (uint256 balance) { 
        return balances[owner];
    }

    /**
     * Transfers `amount` of tokens to `to` address
     * @param  to - address to transfer to
     * @param  amount - amount of tokens to transfer
     * @return success - `true` if the transfer was succesful, `false` otherwise
     */
    function transfer (address to, uint256 amount)   returns (bool success) { 
        if(balances[msg.sender] < amount)
            return false;

        if(amount <= 0)
            return false;

        if(balances[to] + amount <= balances[to])
            return false;

        balances[msg.sender] -= amount;
        balances[to] += amount;
        Transfer(msg.sender, to, amount);
        return true;
    }

    /**
     * Transfers `amount` tokens from `from` address to `to`
     * the sender needs to have allowance for this operation
     * @param  from - address to take tokens from
     * @param  to - address to send tokens to
     * @param  amount - amount of tokens to send
     * @return success - `true` if the transfer was succesful, `false` otherwise
     */
    function transferFrom (address from, address to, uint256 amount)   returns (bool success) { 
        if (balances[from] < amount)
            return false;

        if(allowed[from][msg.sender] < amount)
            return false;

        if(amount == 0)
            return false;

        if(balances[to] + amount <= balances[to])
            return false;

        balances[from] -= amount;
        allowed[from][msg.sender] -= amount;
        balances[to] += amount;
        Transfer(from, to, amount);
        return true;
    }

    /**
     * Allow spender to withdraw from your account, multiple times, up to the amount amount.
     * If this function is called again it overwrites the current allowance with `amount`.
     * this function is required for some DEX functionality
     * @param spender - address to give allowance to
     * @param amount - the maximum amount of tokens allowed for spending
     * @return success - `true` if the allowance was given, `false` otherwise
     */
    function approve (address spender, uint256 amount)   returns (bool success) { 
       allowed[msg.sender][spender] = amount;
       Approval(msg.sender, spender, amount);
       return true;
   }

    /**
     * Returns the amount which `spender` is still allowed to withdraw from `owner`
     * @param  owner - tokens owner
     * @param  spender - addres to request allowance for
     * @return remaining - remaining allowance (token count)
     */
    function allowance (address owner, address spender)  constant  returns (uint256 remaining) { 
        return allowed[owner][spender];
    }

     /**
      * Destroys `amount` of tokens permanently, they cannot be restored
      * @return success - `true` if `amount` of tokens were destroyed, `false` otherwise
      */
    function destroy (uint256 amount)   returns (bool success) { 
        if(amount == 0) return false;
        if(balances[msg.sender] < amount) return false;
        balances[msg.sender] -= amount;
        totalTokenSupply -= amount;
        Destroyed(msg.sender, amount);
    }
}

pragma solidity 0.4.15;

/**
 * @title Various Math utilities
 */
library Math {
     /** 1/1000, 1000 uint = 1 */

    /**
     * Returns `promille` promille of `value`
     * e.g. `takePromille(5000, 1) == 5`
     * @param value - uint to take promille value
     * @param promille - promille value
     * @return result - `value * promille / 1000`
     */
    function takePromille (uint value, uint promille)  constant  returns (uint result) { 
        result = value * promille / 1000;
    }

    /**
     * Returns `value` with added `promille` promille
     * @param value - uint to add promille to
     * @param promille - promille value to add
     * @return result - `value + value * promille / 1000`
     */
    function addPromille (uint value, uint promille)  constant  returns (uint result) { 
        result = value + takePromille(value, promille);
    }
}


/**
 * @title Blind Croupier TokenDistribution
 * It possesses some `WIN` tokens.
 * The distribution is divided into many 'periods'.
 * The zero one is `Presale` with `TOKENS_FOR_PRESALE` tokens
 * It's ended when all tokens are sold or manually with `endPresale()` function
 * The length of first period is `FIRST_PERIOD_DURATION`.
 * The length of other periods is `PERIOD_DURATION`.
 * During each period, `TOKENS_PER_PERIOD` are offered for sale (`TOKENS_PER_FIRST_PERIOD` for the first one)
 * Investors send their money to the contract
 * and call `claimAllTokens()` function to get `WIN` tokens.
 * Period 0 Token price is `PRESALE_TOKEN_PRICE`
 * Period 1 Token price is `SALE_INITIAL_TOKEN_PRICE`
 * Period 2+ price is determined by the following rules:
 * If more than `TOKENS_TO_INCREASE_NEXT_PRICE * TOKENS_PER_PERIOD / 1000`
 * were sold during the period, the price of the Tokens for the next period
 * is increased by `PERIOD_PRICE_INCREASE` promille,
 * if ALL tokens were sold, price is increased by `FULLY_SOLD_PRICE_INCREASE` promille
 * Otherwise, the price remains the same.
 */
contract BlindCroupierTokenDistribution is MultiOwnable {
    
    
    
    
    
    

    uint256 constant TOKEN = 10**7;
    uint256 constant MILLION = 10**6;

    uint256 constant MINIMUM_DEPOSIT = 100 finney; /** minimum deposit accepted to bank */
    uint256 constant PRESALE_TOKEN_PRICE = 0.00035 ether / TOKEN;
    uint256 constant SALE_INITIAL_TOKEN_PRICE = 0.0005 ether / TOKEN;

    uint256 constant TOKENS_FOR_PRESALE = 5 * MILLION * TOKEN; /** 5M tokens */
    uint256 constant TOKENS_PER_FIRST_PERIOD = 15 * MILLION * TOKEN; /** 15M tokens */
    uint256 constant TOKENS_PER_PERIOD = 1 * MILLION * TOKEN; /** 1M tokens */
    uint256 constant FIRST_PERIOD_DURATION = 161 hours; /** duration of 1st sale period */
    uint256 constant PERIOD_DURATION = 23 hours; /** duration of all other sale periods */
    uint256 constant PERIOD_PRICE_INCREASE = 5; /** `next_token_price = old_token_price + old_token_price * PERIOD_PRICE_INCREASE / 1000` */
    uint256 constant FULLY_SOLD_PRICE_INCREASE = 10; /** to increase price if ALL tokens sold */
    uint256 constant TOKENS_TO_INCREASE_NEXT_PRICE = 800; /** the price is increased if `sold_tokens > period_tokens * TOKENS_TO_INCREASE_NEXT_PRICE / 1000` */

    uint256 constant NEVER = 0;
    uint16 constant UNKNOWN_COUNTRY = 0;

    /**
     * State of Blind Croupier crowdsale
     */
    enum State {
        NotStarted,
        Presale,
        Sale
    }

    uint256 public totalUnclaimedTokens; /** total amount of tokens, TokenDistribution owns to investors */
    uint256 public totalTokensSold; /** total amount of Tokens sold during the TokenDistribution */
    uint256 public totalTokensDestroyed; /** total amount of Tokens destroyed by this contract */

    mapping(address => uint256) public unclaimedTokensForInvestor; /** unclaimed tokens for each investor */

    /**
     * One token sale period information
     */
    struct Period {
        uint256 startTime;
        uint256 endTime;
        uint256 tokenPrice;
        uint256 tokensSold;
    }

    /**
     * Emited when `investor` sends `amount` of money to the Bank
     * @param investor - address, sending the money
     * @param amount - Wei sent
     */
    event Deposited(address indexed investor, uint256 amount, uint256 tokenCount);

    /**
     * Emited when a new period is opened
     * @param periodIndex - index of new period
     * @param tokenPrice - price of WIN Token in new period
     */
    event PeriodStarted(uint periodIndex, uint256 tokenPrice, uint256 tokensToSale, uint256 startTime, uint256 endTime, uint256 now);

    /**
     * Emited when `investor` claims `claimed` tokens
     * @param investor - address getting the Tokens
     * @param claimed - amount of Tokens claimed
     */
    event TokensClaimed(address indexed investor, uint256 claimed);

    /** current Token sale period */
    uint public currentPeriod = 0;

    /** information about past and current periods, by periods index, starting from `0` */
    mapping(uint => Period) periods;

    /** WIN tokens contract  */
    WIN public win;

    /** The state of the crowdsale - `NotStarted`, `Presale`, `Sale` */
    State public state;

    /** the counter of investment by a country code (3-digit ISO 3166 code) */
    mapping(uint16 => uint256) investmentsByCountries;

    /**
     * Returns amount of Wei invested by the specified country
     * @param country - 3-digit country code
     */
    function getInvestmentsByCountry (uint16 country)   constant   returns (uint256 investment) {  
        investment = investmentsByCountries[country];
    }

    /**
     * Returns the Token price in the current period
     * @return tokenPrice - current Token price
     */
    function getTokenPrice ()   constant   returns (uint256 tokenPrice) {  
        tokenPrice = periods[currentPeriod].tokenPrice;
    }

    /**
     * Returns the Token price for the period requested
     * @param periodIndex - the period index
     * @return tokenPrice - Token price for the period
     */
    function getTokenPriceForPeriod (uint periodIndex)   constant   returns (uint256 tokenPrice) {  
        tokenPrice = periods[periodIndex].tokenPrice;
    }

    /**
     * Returns the amount of Tokens sold
     * @param period - period index to get tokens for
     * @return tokensSold - amount of tokens sold
     */
    function getTokensSold (uint period)   constant   returns (uint256 tokensSold) {  
        return periods[period].tokensSold;
    }

    /**
     * Returns `true` if TokenDistribution has enough tokens for the current period
     * and thus going on
     * @return active - `true` if TokenDistribution is going on, `false` otherwise
     */
    function isActive ()   constant   returns (bool active) {  
        return win.balanceOf(this) >= totalUnclaimedTokens + tokensForPeriod(currentPeriod) - periods[currentPeriod].tokensSold;
    }

    /**
     * Accepts money deposit and makes record
     * minimum deposit is MINIMUM_DEPOSIT
     * @param beneficiar - the address to receive Tokens
     * @param countryCode - 3-digit country code
     * @dev if `msg.value < MINIMUM_DEPOSIT` throws
     */
    function deposit (address beneficiar, uint16 countryCode)   payable  {  
        require(msg.value >= MINIMUM_DEPOSIT);
        require(state == State.Sale || state == State.Presale);

        /* this should end any finished period before starting any operations */
        tick();

        /* check if have enough tokens for the current period
         * if not, the call fails until tokens are deposited to the contract
         */
        require(isActive());

        uint256 tokensBought = msg.value / getTokenPrice();

        if(periods[currentPeriod].tokensSold + tokensBought >= tokensForPeriod(currentPeriod)) {
            tokensBought = tokensForPeriod(currentPeriod) - periods[currentPeriod].tokensSold;
        }

        uint256 moneySpent = getTokenPrice() * tokensBought;

        investmentsByCountries[countryCode] += moneySpent;

        if(tokensBought > 0) {
            assert(moneySpent <= msg.value);

            /* return the rest */
            if(msg.value > moneySpent) {
                msg.sender.transfer(msg.value - moneySpent);
            }

            periods[currentPeriod].tokensSold += tokensBought;
            unclaimedTokensForInvestor[beneficiar] += tokensBought;
            totalUnclaimedTokens += tokensBought;
            totalTokensSold += tokensBought;
            Deposited(msg.sender, moneySpent, tokensBought);
        }

        /* if all tokens are sold, get to the next period */
        tick();
    }

    /**
     * See `deposit` function
     */
    function() payable {
        deposit(msg.sender, UNKNOWN_COUNTRY);
    }

    /**
     * Creates the contract and sets the owners
     * @param owners_dot_recipient - array of 16 owner records  (MultiOwnable.Owner.recipient fields)
* @param owners_dot_share - array of 16 owner records  (MultiOwnable.Owner.share fields)
     */
    function BlindCroupierTokenDistribution (address[16] owners_dot_recipient, uint[16] owners_dot_share)   MultiOwnable(owners_dot_recipient, owners_dot_share)  {  
MultiOwnable.Owner[16] memory owners;

for(uint __recipient_iterator__ = 0; __recipient_iterator__ < owners_dot_recipient.length;__recipient_iterator__++)
  owners[__recipient_iterator__].recipient = address(owners_dot_recipient[__recipient_iterator__]);
for(uint __share_iterator__ = 0; __share_iterator__ < owners_dot_share.length;__share_iterator__++)
  owners[__share_iterator__].share = uint(owners_dot_share[__share_iterator__]);
        state = State.NotStarted;
    }

    /**
     * Begins the crowdsale (presale period)
     * @param tokenContractAddress - address of the `WIN` contract (token holder)
     * @dev must be called by one of owners
     */
    function startPresale (address tokenContractAddress)   onlyOneOfOwners  {  
        require(state == State.NotStarted);

        win = WIN(tokenContractAddress);

        assert(win.balanceOf(this) >= tokensForPeriod(0));

        periods[0] = Period(now, NEVER, PRESALE_TOKEN_PRICE, 0);
        PeriodStarted(0,
            PRESALE_TOKEN_PRICE,
            tokensForPeriod(currentPeriod),
            now,
            NEVER,
            now);
        state = State.Presale;
    }

    /**
     * Ends the presale and begins period 1 of the crowdsale
     * @dev must be called by one of owners
     */
    function endPresale ()   onlyOneOfOwners  {  
        require(state == State.Presale);
        state = State.Sale;
        nextPeriod();
    }

    /**
     * Returns a time interval for a specific `period`
     * @param  period - period index to count interval for
     * @return startTime - timestamp of period start time (INCLUSIVE)
     * @return endTime - timestamp of period end time (INCLUSIVE)
     */
    function periodTimeFrame (uint period)   constant   returns (uint256 startTime, uint256 endTime) {  
        require(period <= currentPeriod);

        startTime = periods[period].startTime;
        endTime = periods[period].endTime;
    }

    /**
     * Returns `true` if the time for the `period` has already passed
     */
    function isPeriodTimePassed (uint period)   constant   returns (bool finished) {  
        require(periods[period].startTime > 0);

        uint256 endTime = periods[period].endTime;

        if(endTime == NEVER) {
            return false;
        }

        return (endTime < now);
    }

    /**
     * Returns `true` if `period` has already finished (time passed or tokens sold)
     */
    function isPeriodClosed (uint period)   constant   returns (bool finished) {  
        return period < currentPeriod;
    }

    /**
     * Returns `true` if all tokens for the `period` has been sold
     */
    function isPeriodAllTokensSold (uint period)   constant   returns (bool finished) {  
        return periods[period].tokensSold == tokensForPeriod(period);
    }

    /**
     * Returns unclaimed Tokens count for the caller
     * @return tokens - amount of unclaimed Tokens for the caller
     */
    function unclaimedTokens ()   constant   returns (uint256 tokens) {  
        return unclaimedTokensForInvestor[msg.sender];
    }

    /**
     * Transfers all the tokens stored for this `investor` to his address
     * @param investor - investor to claim tokens for
     */
    function claimAllTokensForInvestor (address investor)   {  
        assert(totalUnclaimedTokens >= unclaimedTokensForInvestor[investor]);
        totalUnclaimedTokens -= unclaimedTokensForInvestor[investor];
        win.transfer(investor, unclaimedTokensForInvestor[investor]);
        TokensClaimed(investor, unclaimedTokensForInvestor[investor]);
        unclaimedTokensForInvestor[investor] = 0;
    }

    /**
     * Claims all the tokens for the sender
     * @dev efficiently calling `claimAllForInvestor(msg.sender)`
     */
    function claimAllTokens ()   {  
        claimAllTokensForInvestor(msg.sender);
    }

    /**
     * Returns the total token count for the period specified
     * @param  period - period number
     * @return tokens - total tokens count
     */
    function tokensForPeriod (uint period)   constant   returns (uint256 tokens) {  
        if(period == 0) {
            return TOKENS_FOR_PRESALE;
        } else if(period == 1) {
            return TOKENS_PER_FIRST_PERIOD;
        } else {
            return TOKENS_PER_PERIOD;
        }
    }

    /**
     * Returns the duration of the sale (not presale) period
     * @param  period - the period number
     * @return duration - duration in seconds
     */
    function periodDuration (uint period)   constant   returns (uint256 duration) {  
        require(period > 0);

        if(period == 1) {
            return FIRST_PERIOD_DURATION;
        } else {
            return PERIOD_DURATION;
        }
    }

    /**
     * Finishes the current period and starts a new one
     */
    function nextPeriod() internal {
        uint256 oldPrice = periods[currentPeriod].tokenPrice;
        uint256 newPrice;
        if(currentPeriod == 0) {
            newPrice = SALE_INITIAL_TOKEN_PRICE;
        } else if(periods[currentPeriod].tokensSold  == tokensForPeriod(currentPeriod)) {
            newPrice = Math.addPromille(oldPrice, FULLY_SOLD_PRICE_INCREASE);
        } else if(periods[currentPeriod].tokensSold >= Math.takePromille(tokensForPeriod(currentPeriod), TOKENS_TO_INCREASE_NEXT_PRICE)) {
            newPrice = Math.addPromille(oldPrice, PERIOD_PRICE_INCREASE);
        } else {
            newPrice = oldPrice;
        }

        /* destroy unsold tokens */
        if(periods[currentPeriod].tokensSold < tokensForPeriod(currentPeriod)) {
            uint256 toDestroy = tokensForPeriod(currentPeriod) - periods[currentPeriod].tokensSold;
            /* do not destroy if we don't have enough to pay investors */
            uint256 balance = win.balanceOf(this);
            if(balance < toDestroy + totalUnclaimedTokens) {
                toDestroy = (balance - totalUnclaimedTokens);
            }
            win.destroy(toDestroy);
            totalTokensDestroyed += toDestroy;
        }

        /* if we are force ending the period set in the future or without end time,
         * set end time to now
         */
        if(periods[currentPeriod].endTime > now ||
            periods[currentPeriod].endTime == NEVER) {
            periods[currentPeriod].endTime = now;
        }

        uint256 duration = periodDuration(currentPeriod + 1);

        periods[currentPeriod + 1] = Period(
            periods[currentPeriod].endTime,
            periods[currentPeriod].endTime + duration,
            newPrice,
            0);

        currentPeriod++;

        PeriodStarted(currentPeriod,
            newPrice,
            tokensForPeriod(currentPeriod),
            periods[currentPeriod].startTime,
            periods[currentPeriod].endTime,
            now);
    }

    /**
     * To be called as frequently as required by any external party
     * Will check if 1 or more periods have finished and move on to the next
     */
    function tick ()   {  
        if(!isActive()) {
            return;
        }

        while(state == State.Sale &&
            (isPeriodTimePassed(currentPeriod) ||
            isPeriodAllTokensSold(currentPeriod))) {
            nextPeriod();
        }
    }

    /**
     * Withdraws the money to be spent to Blind Croupier Project needs
     * @param  amount - amount of Wei to withdraw (total)
     */
    function withdraw (uint256 amount)   onlyOneOfOwners  {  
        require(this.balance >= amount);

        uint totalShares = 0;
        for(var idx = 0; idx < owners.length; idx++) {
            totalShares += owners[idx].share;
        }

        for(idx = 0; idx < owners.length; idx++) {
            owners[idx].recipient.transfer(amount * owners[idx].share / totalShares);
        }
    }
}

[{"constant":true,"inputs":[{"name":"","type":"uint256"}],"name":"owners","outputs":[{"name":"recipient","type":"address"},{"name":"share","type":"uint256"}],"payable":false,"type":"function"},{"constant":true,"inputs":[],"name":"currentPeriod","outputs":[{"name":"","type":"uint256"}],"payable":false,"type":"function"},{"constant":true,"inputs":[],"name":"totalUnclaimedTokens","outputs":[{"name":"","type":"uint256"}],"payable":false,"type":"function"},{"constant":false,"inputs":[],"name":"claimAllTokens","outputs":[],"payable":false,"type":"function"},{"constant":true,"inputs":[{"name":"period","type":"uint256"}],"name":"tokensForPeriod","outputs":[{"name":"tokens","type":"uint256"}],"payable":false,"type":"function"},{"constant":true,"inputs":[],"name":"isActive","outputs":[{"name":"active","type":"bool"}],"payable":false,"type":"function"},{"constant":false,"inputs":[{"name":"amount","type":"uint256"}],"name":"withdraw","outputs":[],"payable":false,"type":"function"},{"constant":false,"inputs":[],"name":"tick","outputs":[],"payable":false,"type":"function"},{"constant":true,"inputs":[{"name":"periodIndex","type":"uint256"}],"name":"getTokenPriceForPeriod","outputs":[{"name":"tokenPrice","type":"uint256"}],"payable":false,"type":"function"},{"constant":true,"inputs":[],"name":"win","outputs":[{"name":"","type":"address"}],"payable":false,"type":"function"},{"constant":true,"inputs":[],"name":"getTokenPrice","outputs":[{"name":"tokenPrice","type":"uint256"}],"payable":false,"type":"function"},{"constant":true,"inputs":[{"name":"period","type":"uint256"}],"name":"periodTimeFrame","outputs":[{"name":"startTime","type":"uint256"},{"name":"endTime","type":"uint256"}],"payable":false,"type":"function"},{"constant":true,"inputs":[{"name":"period","type":"uint256"}],"name":"getTokensSold","outputs":[{"name":"tokensSold","type":"uint256"}],"payable":false,"type":"function"},{"constant":true,"inputs":[],"name":"totalTokensDestroyed","outputs":[{"name":"","type":"uint256"}],"payable":false,"type":"function"},{"constant":true,"inputs":[{"name":"country","type":"uint16"}],"name":"getInvestmentsByCountry","outputs":[{"name":"investment","type":"uint256"}],"payable":false,"type":"function"},{"constant":true,"inputs":[],"name":"totalTokensSold","outputs":[{"name":"","type":"uint256"}],"payable":false,"type":"function"},{"constant":false,"inputs":[{"name":"investor","type":"address"}],"name":"claimAllTokensForInvestor","outputs":[],"payable":false,"type":"function"},{"constant":true,"inputs":[{"name":"idx","type":"uint256"}],"name":"owner","outputs":[{"name":"owner_dot_recipient","type":"address"},{"name":"owner_dot_share","type":"uint256"}],"payable":false,"type":"function"},{"constant":false,"inputs":[],"name":"endPresale","outputs":[],"payable":false,"type":"function"},{"constant":false,"inputs":[{"name":"tokenContractAddress","type":"address"}],"name":"startPresale","outputs":[],"payable":false,"type":"function"},{"constant":true,"inputs":[{"name":"period","type":"uint256"}],"name":"isPeriodAllTokensSold","outputs":[{"name":"finished","type":"bool"}],"payable":false,"type":"function"},{"constant":true,"inputs":[{"name":"period","type":"uint256"}],"name":"isPeriodTimePassed","outputs":[{"name":"finished","type":"bool"}],"payable":false,"type":"function"},{"constant":true,"inputs":[],"name":"ownersCount","outputs":[{"name":"count","type":"uint256"}],"payable":false,"type":"function"},{"constant":true,"inputs":[{"name":"","type":"address"}],"name":"unclaimedTokensForInvestor","outputs":[{"name":"","type":"uint256"}],"payable":false,"type":"function"},{"constant":true,"inputs":[],"name":"state","outputs":[{"name":"","type":"uint8"}],"payable":false,"type":"function"},{"constant":true,"inputs":[],"name":"unclaimedTokens","outputs":[{"name":"tokens","type":"uint256"}],"payable":false,"type":"function"},{"constant":false,"inputs":[{"name":"beneficiar","type":"address"},{"name":"countryCode","type":"uint16"}],"name":"deposit","outputs":[],"payable":true,"type":"function"},{"constant":true,"inputs":[{"name":"period","type":"uint256"}],"name":"isPeriodClosed","outputs":[{"name":"finished","type":"bool"}],"payable":false,"type":"function"},{"constant":true,"inputs":[{"name":"period","type":"uint256"}],"name":"periodDuration","outputs":[{"name":"duration","type":"uint256"}],"payable":false,"type":"function"},{"inputs":[{"name":"owners_dot_recipient","type":"address[16]"},{"name":"owners_dot_share","type":"uint256[16]"}],"payable":false,"type":"constructor"},{"payable":true,"type":"fallback"},{"anonymous":false,"inputs":[{"indexed":true,"name":"investor","type":"address"},{"indexed":false,"name":"amount","type":"uint256"},{"indexed":false,"name":"tokenCount","type":"uint256"}],"name":"Deposited","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"name":"periodIndex","type":"uint256"},{"indexed":false,"name":"tokenPrice","type":"uint256"},{"indexed":false,"name":"tokensToSale","type":"uint256"},{"indexed":false,"name":"startTime","type":"uint256"},{"indexed":false,"name":"endTime","type":"uint256"},{"indexed":false,"name":"now","type":"uint256"}],"name":"PeriodStarted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"investor","type":"address"},{"indexed":false,"name":"claimed","type":"uint256"}],"name":"TokensClaimed","type":"event"}]

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

-----Encoded View---------------
32 Constructor Arguments found :
Arg [0] : 000000000000000000000000b38815581e26a1a4ddd87f6e852299579d3c966d
Arg [1] : 000000000000000000000000069dba3ddf3dc1477c68431e5bd3982da4977177
Arg [2] : 0000000000000000000000000bfdc7b5c0e4cdb33741bbe5c54a9e02bb8fcd71
Arg [3] : 000000000000000000000000b016d117670b106d4e9ece7389ce8cc551e35832
Arg [4] : 0000000000000000000000000000000000000000000000000000000000000000
Arg [5] : 0000000000000000000000000000000000000000000000000000000000000000
Arg [6] : 0000000000000000000000000000000000000000000000000000000000000000
Arg [7] : 0000000000000000000000000000000000000000000000000000000000000000
Arg [8] : 0000000000000000000000000000000000000000000000000000000000000000
Arg [9] : 0000000000000000000000000000000000000000000000000000000000000000
Arg [10] : 0000000000000000000000000000000000000000000000000000000000000000
Arg [11] : 0000000000000000000000000000000000000000000000000000000000000000
Arg [12] : 0000000000000000000000000000000000000000000000000000000000000000
Arg [13] : 0000000000000000000000000000000000000000000000000000000000000000
Arg [14] : 0000000000000000000000000000000000000000000000000000000000000000
Arg [15] : 0000000000000000000000000000000000000000000000000000000000000000
Arg [16] : 000000000000000000000000000000000000000000000000000000000000001e
Arg [17] : 000000000000000000000000000000000000000000000000000000000000001e
Arg [18] : 000000000000000000000000000000000000000000000000000000000000001e
Arg [19] : 000000000000000000000000000000000000000000000000000000000000000a
Arg [20] : 0000000000000000000000000000000000000000000000000000000000000000
Arg [21] : 0000000000000000000000000000000000000000000000000000000000000000
Arg [22] : 0000000000000000000000000000000000000000000000000000000000000000
Arg [23] : 0000000000000000000000000000000000000000000000000000000000000000
Arg [24] : 0000000000000000000000000000000000000000000000000000000000000000
Arg [25] : 0000000000000000000000000000000000000000000000000000000000000000
Arg [26] : 0000000000000000000000000000000000000000000000000000000000000000
Arg [27] : 0000000000000000000000000000000000000000000000000000000000000000
Arg [28] : 0000000000000000000000000000000000000000000000000000000000000000
Arg [29] : 0000000000000000000000000000000000000000000000000000000000000000
Arg [30] : 0000000000000000000000000000000000000000000000000000000000000000
Arg [31] : 0000000000000000000000000000000000000000000000000000000000000000

Math : 0x4183ffb15d5e9a7efbf6f62f1970c053663ad435

bzzr://94d6199e534d0d3f0d69e96718dc286bc534036bc692154007374dcceee2014e