Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

• library SafeMath
•    - function mul(uint256 a, uint256 b)
•    - function div(uint256 a, uint256 b)
•    - function sub(uint256 a, uint256 b)
•    - function add(uint256 a, uint256 b)
•    - function mod(uint256 a, uint256 b)
• interface IERC20
•    - function transfer(address to, uint256 ...
•    - function approve(address spender, uin ...
•    - function transferFrom(address from, a ...
•    - function totalSupply()
•    - function balanceOf(address who)
•    - function allowance(address owner, add ...
• library Address
•    - function isContract(address account)
• library SafeERC20
•    - function safeTransfer(IERC20 token, a ...
•    - function safeTransferFrom(IERC20 toke ...
•    - function safeApprove(IERC20 token, ad ...
•    - function safeIncreaseAllowance(IERC20 ...
•    - function safeDecreaseAllowance(IERC20 ...
•    - function callOptionalReturn(IERC20 to ...
•  contract ReentrancyGuard
•  contract Crowdsale is ReentrancyGu ...
•    - function ()
•    - function token()
•    - function wallet()
•    - function rate()
•    - function weiRaised()
•    - function buyTokens(address beneficiar ...
•    - function _preValidatePurchase(address ...
•    - function _postValidatePurchase(addres ...
•    - function _deliverTokens(address benef ...
•    - function _processPurchase(address ben ...
•    - function _updatePurchasingState(addre ...
•    - function _getTokenAmount(uint256 weiA ...
•    - function _forwardFunds()
•  contract TimedCrowdsale is Crowdsa ...
•    - function openingTime()
•    - function closingTime()
•    - function isOpen()
•    - function hasClosed()
•    - function _preValidatePurchase(address ...
•    - function _extendTime(uint256 newClosi ...
•  contract FinalizableCrowdsale is T ...
•    - function finalized()
•    - function finalize()
•    - function _finalization()
•  contract Secondary
•    - function primary()
•    - function transferPrimary(address reci ...
•  contract Escrow is Secondary
•    - function depositsOf(address payee)
•    - function deposit(address payee)
•    - function withdraw(address payable pay ...
•  contract ConditionalEscrow is Escr ...
•    - function withdrawalAllowed(address pa ...
•    - function withdraw(address payable pay ...
•  contract RefundEscrow is Condition ...
•    - function state()
•    - function beneficiary()
•    - function deposit(address refundee)
•    - function close()
•    - function enableRefunds()
•    - function beneficiaryWithdraw()
•    - function withdrawalAllowed(address)
•  contract RefundableCrowdsale is Fi ...
•    - function goal()
•    - function claimRefund(address payable ...
•    - function goalReached()
•    - function _finalization()
•    - function _forwardFunds()
•  contract PostDeliveryCrowdsale is ...
•    - function withdrawTokens(address benef ...
•    - function balanceOf(address account)
•    - function _processPurchase(address ben ...
•  contract RefundablePostDeliveryCro ...
•    - function withdrawTokens(address benef ...
•  contract ERC20Detailed is IERC20
•    - function name()
•    - function symbol()
•    - function decimals()
•  contract Ownable
•    - function owner()
•    - function isOwner()
•    - function renounceOwnership()
•    - function transferOwnership(address ne ...
•    - function _transferOwnership(address n ...
•  contract ERC20 is IERC20
•    - function totalSupply()
•    - function balanceOf(address owner)
•    - function allowance(address owner, add ...
•    - function transfer(address to, uint256 ...
•    - function approve(address spender, uin ...
•    - function transferFrom(address from, a ...
•    - function increaseAllowance(address sp ...
•    - function decreaseAllowance(address sp ...
•    - function _transfer(address from, addr ...
•    - function _mint(address account, uint2 ...
•    - function _burn(address account, uint2 ...
•    - function _approve(address owner, addr ...
•    - function _burnFrom(address account, u ...
•  contract InterfaceUpgradeAgent
•    - function upgradeFrom(address holder, ...
•  contract UpgradableToken is ERC20, ...
•    - function setUpgradeAgent(address _upg ...
•    - function upgrade(address from)
•  contract InnToken is ERC20Detailed ...
•    - function mint(address to, uint256 val ...
•  contract InnCrowdsale is Refundabl ...
•    - function minPurchase()
•    - function transferPremiumTokens()
•    - function name()
•    - function symbol()
•    - function decimals()
•    - function isSaleOpen()
•    - function isOpen()
•    - function hasClosed()
•    - function _processPurchase(address ben ...
•    - function _forwardFunds()
•    - function _preValidatePurchase(address ...
•    - function _deliverTokens(address benef ...
•  contract InnCrowdsaleReady is InnC ... *

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2019-06-04
*/

// File: installed_contracts/openzeppelin-solidity/contracts/math/SafeMath.sol

pragma solidity ^0.5.2;

/**
 * @title SafeMath
 * @dev Unsigned math operations with safety checks that revert on error
 */
library SafeMath {
    /**
     * @dev Multiplies two unsigned integers, reverts on overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
        // benefit is lost if 'b' is also tested.
        // See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
        if (a == 0) {
            return 0;
        }

        uint256 c = a * b;
        require(c / a == b);

        return c;
    }

    /**
     * @dev Integer division of two unsigned integers truncating the quotient, reverts on division by zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        // Solidity only automatically asserts when dividing by 0
        require(b > 0);
        uint256 c = a / b;
        // assert(a == b * c + a % b); // There is no case in which this doesn't hold

        return c;
    }

    /**
     * @dev Subtracts two unsigned integers, reverts on overflow (i.e. if subtrahend is greater than minuend).
     */
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b <= a);
        uint256 c = a - b;

        return c;
    }

    /**
     * @dev Adds two unsigned integers, reverts on overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a);

        return c;
    }

    /**
     * @dev Divides two unsigned integers and returns the remainder (unsigned integer modulo),
     * reverts when dividing by zero.
     */
    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b != 0);
        return a % b;
    }
}

// File: installed_contracts/openzeppelin-solidity/contracts/token/ERC20/IERC20.sol

pragma solidity ^0.5.2;

/**
 * @title ERC20 interface
 * @dev see https://eips.ethereum.org/EIPS/eip-20
 */
interface IERC20 {
    function transfer(address to, uint256 value) external returns (bool);

    function approve(address spender, uint256 value) external returns (bool);

    function transferFrom(address from, address to, uint256 value) external returns (bool);

    function totalSupply() external view returns (uint256);

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

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

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

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

// File: installed_contracts/openzeppelin-solidity/contracts/utils/Address.sol

pragma solidity ^0.5.2;

/**
 * Utility library of inline functions on addresses
 */
library Address {
    /**
     * Returns whether the target address is a contract
     * @dev This function will return false if invoked during the constructor of a contract,
     * as the code is not actually created until after the constructor finishes.
     * @param account address of the account to check
     * @return whether the target address is a contract
     */
    function isContract(address account) internal view returns (bool) {
        uint256 size;
        // XXX Currently there is no better way to check if there is a contract in an address
        // than to check the size of the code at that address.
        // See https://ethereum.stackexchange.com/a/14016/36603
        // for more details about how this works.
        // TODO Check this again before the Serenity release, because all addresses will be
        // contracts then.
        // solhint-disable-next-line no-inline-assembly
        assembly { size := extcodesize(account) }
        return size > 0;
    }
}

// File: installed_contracts/openzeppelin-solidity/contracts/token/ERC20/SafeERC20.sol

pragma solidity ^0.5.2;




/**
 * @title SafeERC20
 * @dev Wrappers around ERC20 operations that throw on failure (when the token
 * contract returns false). Tokens that return no value (and instead revert or
 * throw on failure) are also supported, non-reverting calls are assumed to be
 * successful.
 * 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 {
    using SafeMath for uint256;
    using Address for address;

    function safeTransfer(IERC20 token, address to, uint256 value) internal {
        callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
    }

    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
        callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
    }

    function safeApprove(IERC20 token, address spender, uint256 value) internal {
        // safeApprove should only be called when setting an initial allowance,
        // or when resetting it to zero. To increase and decrease it, use
        // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
        require((value == 0) || (token.allowance(address(this), spender) == 0));
        callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
    }

    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        uint256 newAllowance = token.allowance(address(this), spender).add(value);
        callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
    }

    function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        uint256 newAllowance = token.allowance(address(this), spender).sub(value);
        callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
    }

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must equal true).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     */
    function callOptionalReturn(IERC20 token, bytes memory data) private {
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
        // we're implementing it ourselves.

        // A Solidity high level call has three parts:
        //  1. The target address is checked to verify it contains contract code
        //  2. The call itself is made, and success asserted
        //  3. The return value is decoded, which in turn checks the size of the returned data.

        require(address(token).isContract());

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = address(token).call(data);
        require(success);

        if (returndata.length > 0) { // Return data is optional
            require(abi.decode(returndata, (bool)));
        }
    }
}

// File: installed_contracts/openzeppelin-solidity/contracts/utils/ReentrancyGuard.sol

pragma solidity ^0.5.2;

/**
 * @title Helps contracts guard against reentrancy attacks.
 * @author Remco Bloemen <remco@2π.com>, Eenae <[email protected]>
 * @dev If you mark a function `nonReentrant`, you should also
 * mark it `external`.
 */
contract ReentrancyGuard {
    /// @dev counter to allow mutex lock with only one SSTORE operation
    uint256 private _guardCounter;

    constructor () internal {
        // The counter starts at one to prevent changing it from zero to a non-zero
        // value, which is a more expensive operation.
        _guardCounter = 1;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and make it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        _guardCounter += 1;
        uint256 localCounter = _guardCounter;
        _;
        require(localCounter == _guardCounter);
    }
}

// File: installed_contracts/openzeppelin-solidity/contracts/crowdsale/Crowdsale.sol

pragma solidity ^0.5.2;





/**
 * @title Crowdsale
 * @dev Crowdsale is a base contract for managing a token crowdsale,
 * allowing investors to purchase tokens with ether. This contract implements
 * such functionality in its most fundamental form and can be extended to provide additional
 * functionality and/or custom behavior.
 * The external interface represents the basic interface for purchasing tokens, and conforms
 * the base architecture for crowdsales. It is *not* intended to be modified / overridden.
 * The internal interface conforms the extensible and modifiable surface of crowdsales. Override
 * the methods to add functionality. Consider using 'super' where appropriate to concatenate
 * behavior.
 */
contract Crowdsale is ReentrancyGuard {
    using SafeMath for uint256;
    using SafeERC20 for IERC20;

    // The token being sold
    IERC20 private _token;

    // Address where funds are collected
    address payable private _wallet;

    // How many token units a buyer gets per wei.
    // The rate is the conversion between wei and the smallest and indivisible token unit.
    // So, if you are using a rate of 1 with a ERC20Detailed token with 3 decimals called TOK
    // 1 wei will give you 1 unit, or 0.001 TOK.
    uint256 private _rate;

    // Amount of wei raised
    uint256 private _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 TokensPurchased(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);

    /**
     * @param rate Number of token units a buyer gets per wei
     * @dev The rate is the conversion between wei and the smallest and indivisible
     * token unit. So, if you are using a rate of 1 with a ERC20Detailed token
     * with 3 decimals called TOK, 1 wei will give you 1 unit, or 0.001 TOK.
     * @param wallet Address where collected funds will be forwarded to
     * @param token Address of the token being sold
     */
    constructor (uint256 rate, address payable wallet, IERC20 token) public {
        require(rate > 0);
        require(wallet != address(0));
        require(address(token) != address(0));

        _rate = rate;
        _wallet = wallet;
        _token = token;
    }

    /**
     * @dev fallback function ***DO NOT OVERRIDE***
     * Note that other contracts will transfer funds with a base gas stipend
     * of 2300, which is not enough to call buyTokens. Consider calling
     * buyTokens directly when purchasing tokens from a contract.
     */
    function () external payable {
        buyTokens(msg.sender);
    }

    /**
     * @return the token being sold.
     */
    function token() public view returns (IERC20) {
        return _token;
    }

    /**
     * @return the address where funds are collected.
     */
    function wallet() public view returns (address payable) {
        return _wallet;
    }

    /**
     * @return the number of token units a buyer gets per wei.
     */
    function rate() public view returns (uint256) {
        return _rate;
    }

    /**
     * @return the amount of wei raised.
     */
    function weiRaised() public view returns (uint256) {
        return _weiRaised;
    }

    /**
     * @dev low level token purchase ***DO NOT OVERRIDE***
     * This function has a non-reentrancy guard, so it shouldn't be called by
     * another `nonReentrant` function.
     * @param beneficiary Recipient of the token purchase
     */
    function buyTokens(address beneficiary) public nonReentrant payable {
        uint256 weiAmount = msg.value;
        _preValidatePurchase(beneficiary, weiAmount);

        // calculate token amount to be created
        uint256 tokens = _getTokenAmount(weiAmount);

        // update state
        _weiRaised = _weiRaised.add(weiAmount);

        _processPurchase(beneficiary, tokens);
        emit TokensPurchased(msg.sender, beneficiary, weiAmount, tokens);

        _updatePurchasingState(beneficiary, weiAmount);

        _forwardFunds();
        _postValidatePurchase(beneficiary, weiAmount);
    }

    /**
     * @dev Validation of an incoming purchase. Use require statements to revert state when conditions are not met.
     * Use `super` in contracts that inherit from Crowdsale to extend their validations.
     * Example from CappedCrowdsale.sol's _preValidatePurchase method:
     *     super._preValidatePurchase(beneficiary, weiAmount);
     *     require(weiRaised().add(weiAmount) <= cap);
     * @param beneficiary Address performing the token purchase
     * @param weiAmount Value in wei involved in the purchase
     */
    function _preValidatePurchase(address beneficiary, uint256 weiAmount) internal view {
        require(beneficiary != address(0));
        require(weiAmount != 0);
    }

    /**
     * @dev Validation of an executed purchase. Observe state and use revert statements to undo rollback when valid
     * conditions are not met.
     * @param beneficiary Address performing the token purchase
     * @param weiAmount Value in wei involved in the purchase
     */
    function _postValidatePurchase(address beneficiary, uint256 weiAmount) internal view {
        // solhint-disable-previous-line no-empty-blocks
    }

    /**
     * @dev Source of tokens. Override this method to modify the way in which the crowdsale ultimately gets and sends
     * its tokens.
     * @param beneficiary Address performing the token purchase
     * @param tokenAmount Number of tokens to be emitted
     */
    function _deliverTokens(address beneficiary, uint256 tokenAmount) internal {
        _token.safeTransfer(beneficiary, tokenAmount);
    }

    /**
     * @dev Executed when a purchase has been validated and is ready to be executed. Doesn't necessarily emit/send
     * tokens.
     * @param beneficiary Address receiving the tokens
     * @param tokenAmount Number of tokens to be purchased
     */
    function _processPurchase(address beneficiary, uint256 tokenAmount) internal {
        _deliverTokens(beneficiary, tokenAmount);
    }

    /**
     * @dev Override for extensions that require an internal state to check for validity (current user contributions,
     * etc.)
     * @param beneficiary Address receiving the tokens
     * @param weiAmount Value in wei involved in the purchase
     */
    function _updatePurchasingState(address beneficiary, uint256 weiAmount) internal {
        // solhint-disable-previous-line no-empty-blocks
    }

    /**
     * @dev Override to extend the way in which ether is converted to tokens.
     * @param weiAmount Value in wei to be converted into tokens
     * @return Number of tokens that can be purchased with the specified _weiAmount
     */
    function _getTokenAmount(uint256 weiAmount) internal view returns (uint256) {
        return weiAmount.mul(_rate);
    }

    /**
     * @dev Determines how ETH is stored/forwarded on purchases.
     */
    function _forwardFunds() internal {
        _wallet.transfer(msg.value);
    }
}

// File: installed_contracts/openzeppelin-solidity/contracts/crowdsale/validation/TimedCrowdsale.sol

pragma solidity ^0.5.2;



/**
 * @title TimedCrowdsale
 * @dev Crowdsale accepting contributions only within a time frame.
 */
contract TimedCrowdsale is Crowdsale {
    using SafeMath for uint256;

    uint256 private _openingTime;
    uint256 private _closingTime;

    /**
     * Event for crowdsale extending
     * @param newClosingTime new closing time
     * @param prevClosingTime old closing time
     */
    event TimedCrowdsaleExtended(uint256 prevClosingTime, uint256 newClosingTime);

    /**
     * @dev Reverts if not in crowdsale time range.
     */
    modifier onlyWhileOpen {
        require(isOpen());
        _;
    }

    /**
     * @dev Constructor, takes crowdsale opening and closing times.
     * @param openingTime Crowdsale opening time
     * @param closingTime Crowdsale closing time
     */
    constructor (uint256 openingTime, uint256 closingTime) public {
        // solhint-disable-next-line not-rely-on-time
        require(openingTime >= block.timestamp);
        require(closingTime > openingTime);

        _openingTime = openingTime;
        _closingTime = closingTime;
    }

    /**
     * @return the crowdsale opening time.
     */
    function openingTime() public view returns (uint256) {
        return _openingTime;
    }

    /**
     * @return the crowdsale closing time.
     */
    function closingTime() public view returns (uint256) {
        return _closingTime;
    }

    /**
     * @return true if the crowdsale is open, false otherwise.
     */
    function isOpen() public view returns (bool) {
        // solhint-disable-next-line not-rely-on-time
        return block.timestamp >= _openingTime && block.timestamp <= _closingTime;
    }

    /**
     * @dev Checks whether the period in which the crowdsale is open has already elapsed.
     * @return Whether crowdsale period has elapsed
     */
    function hasClosed() public view returns (bool) {
        // solhint-disable-next-line not-rely-on-time
        return block.timestamp > _closingTime;
    }

    /**
     * @dev Extend parent behavior requiring to be within contributing period
     * @param beneficiary Token purchaser
     * @param weiAmount Amount of wei contributed
     */
    function _preValidatePurchase(address beneficiary, uint256 weiAmount) internal onlyWhileOpen view {
        super._preValidatePurchase(beneficiary, weiAmount);
    }

    /**
     * @dev Extend crowdsale
     * @param newClosingTime Crowdsale closing time
     */
    function _extendTime(uint256 newClosingTime) internal {
        require(!hasClosed());
        require(newClosingTime > _closingTime);

        emit TimedCrowdsaleExtended(_closingTime, newClosingTime);
        _closingTime = newClosingTime;
    }
}

// File: installed_contracts/openzeppelin-solidity/contracts/crowdsale/distribution/FinalizableCrowdsale.sol

pragma solidity ^0.5.2;



/**
 * @title FinalizableCrowdsale
 * @dev Extension of TimedCrowdsale with a one-off finalization action, where one
 * can do extra work after finishing.
 */
contract FinalizableCrowdsale is TimedCrowdsale {
    using SafeMath for uint256;

    bool private _finalized;

    event CrowdsaleFinalized();

    constructor () internal {
        _finalized = false;
    }

    /**
     * @return true if the crowdsale is finalized, false otherwise.
     */
    function finalized() public view returns (bool) {
        return _finalized;
    }

    /**
     * @dev Must be called after crowdsale ends, to do some extra finalization
     * work. Calls the contract's finalization function.
     */
    function finalize() public {
        require(!_finalized);
        require(hasClosed());

        _finalized = true;

        _finalization();
        emit CrowdsaleFinalized();
    }

    /**
     * @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 {
        // solhint-disable-previous-line no-empty-blocks
    }
}

// File: installed_contracts/openzeppelin-solidity/contracts/ownership/Secondary.sol

pragma solidity ^0.5.2;

/**
 * @title Secondary
 * @dev A Secondary contract can only be used by its primary account (the one that created it)
 */
contract Secondary {
    address private _primary;

    event PrimaryTransferred(
        address recipient
    );

    /**
     * @dev Sets the primary account to the one that is creating the Secondary contract.
     */
    constructor () internal {
        _primary = msg.sender;
        emit PrimaryTransferred(_primary);
    }

    /**
     * @dev Reverts if called from any account other than the primary.
     */
    modifier onlyPrimary() {
        require(msg.sender == _primary);
        _;
    }

    /**
     * @return the address of the primary.
     */
    function primary() public view returns (address) {
        return _primary;
    }

    /**
     * @dev Transfers contract to a new primary.
     * @param recipient The address of new primary.
     */
    function transferPrimary(address recipient) public onlyPrimary {
        require(recipient != address(0));
        _primary = recipient;
        emit PrimaryTransferred(_primary);
    }
}

// File: installed_contracts/openzeppelin-solidity/contracts/payment/escrow/Escrow.sol

pragma solidity ^0.5.2;



 /**
  * @title Escrow
  * @dev Base escrow contract, holds funds designated for a payee until they
  * withdraw them.
  * @dev Intended usage: This contract (and derived escrow contracts) should be a
  * standalone contract, that only interacts with the contract that instantiated
  * it. That way, it is guaranteed that all Ether will be handled according to
  * the Escrow rules, and there is no need to check for payable functions or
  * transfers in the inheritance tree. The contract that uses the escrow as its
  * payment method should be its primary, and provide public methods redirecting
  * to the escrow's deposit and withdraw.
  */
contract Escrow is Secondary {
    using SafeMath for uint256;

    event Deposited(address indexed payee, uint256 weiAmount);
    event Withdrawn(address indexed payee, uint256 weiAmount);

    mapping(address => uint256) private _deposits;

    function depositsOf(address payee) public view returns (uint256) {
        return _deposits[payee];
    }

    /**
     * @dev Stores the sent amount as credit to be withdrawn.
     * @param payee The destination address of the funds.
     */
    function deposit(address payee) public onlyPrimary payable {
        uint256 amount = msg.value;
        _deposits[payee] = _deposits[payee].add(amount);

        emit Deposited(payee, amount);
    }

    /**
     * @dev Withdraw accumulated balance for a payee.
     * @param payee The address whose funds will be withdrawn and transferred to.
     */
    function withdraw(address payable payee) public onlyPrimary {
        uint256 payment = _deposits[payee];

        _deposits[payee] = 0;

        payee.transfer(payment);

        emit Withdrawn(payee, payment);
    }
}

// File: installed_contracts/openzeppelin-solidity/contracts/payment/escrow/ConditionalEscrow.sol

pragma solidity ^0.5.2;


/**
 * @title ConditionalEscrow
 * @dev Base abstract escrow to only allow withdrawal if a condition is met.
 * @dev Intended usage: See Escrow.sol. Same usage guidelines apply here.
 */
contract ConditionalEscrow is Escrow {
    /**
     * @dev Returns whether an address is allowed to withdraw their funds. To be
     * implemented by derived contracts.
     * @param payee The destination address of the funds.
     */
    function withdrawalAllowed(address payee) public view returns (bool);

    function withdraw(address payable payee) public {
        require(withdrawalAllowed(payee));
        super.withdraw(payee);
    }
}

// File: installed_contracts/openzeppelin-solidity/contracts/payment/escrow/RefundEscrow.sol

pragma solidity ^0.5.2;


/**
 * @title RefundEscrow
 * @dev Escrow that holds funds for a beneficiary, deposited from multiple
 * parties.
 * @dev Intended usage: See Escrow.sol. Same usage guidelines apply here.
 * @dev The primary account (that is, the contract that instantiates this
 * contract) may deposit, close the deposit period, and allow for either
 * withdrawal by the beneficiary, or refunds to the depositors. All interactions
 * with RefundEscrow will be made through the primary contract. See the
 * RefundableCrowdsale contract for an example of RefundEscrow’s use.
 */
contract RefundEscrow is ConditionalEscrow {
    enum State { Active, Refunding, Closed }

    event RefundsClosed();
    event RefundsEnabled();

    State private _state;
    address payable private _beneficiary;

    /**
     * @dev Constructor.
     * @param beneficiary The beneficiary of the deposits.
     */
    constructor (address payable beneficiary) public {
        require(beneficiary != address(0));
        _beneficiary = beneficiary;
        _state = State.Active;
    }

    /**
     * @return the current state of the escrow.
     */
    function state() public view returns (State) {
        return _state;
    }

    /**
     * @return the beneficiary of the escrow.
     */
    function beneficiary() public view returns (address) {
        return _beneficiary;
    }

    /**
     * @dev Stores funds that may later be refunded.
     * @param refundee The address funds will be sent to if a refund occurs.
     */
    function deposit(address refundee) public payable {
        require(_state == State.Active);
        super.deposit(refundee);
    }

    /**
     * @dev Allows for the beneficiary to withdraw their funds, rejecting
     * further deposits.
     */
    function close() public onlyPrimary {
        require(_state == State.Active);
        _state = State.Closed;
        emit RefundsClosed();
    }

    /**
     * @dev Allows for refunds to take place, rejecting further deposits.
     */
    function enableRefunds() public onlyPrimary {
        require(_state == State.Active);
        _state = State.Refunding;
        emit RefundsEnabled();
    }

    /**
     * @dev Withdraws the beneficiary's funds.
     */
    function beneficiaryWithdraw() public {
        require(_state == State.Closed);
        _beneficiary.transfer(address(this).balance);
    }

    /**
     * @dev Returns whether refundees can withdraw their deposits (be refunded). The overridden function receives a
     * 'payee' argument, but we ignore it here since the condition is global, not per-payee.
     */
    function withdrawalAllowed(address) public view returns (bool) {
        return _state == State.Refunding;
    }
}

// File: installed_contracts/openzeppelin-solidity/contracts/crowdsale/distribution/RefundableCrowdsale.sol

pragma solidity ^0.5.2;




/**
 * @title RefundableCrowdsale
 * @dev Extension of FinalizableCrowdsale contract that adds a funding goal, and the possibility of users
 * getting a refund if goal is not met.
 *
 * Deprecated, use RefundablePostDeliveryCrowdsale instead. Note that if you allow tokens to be traded before the goal
 * is met, then an attack is possible in which the attacker purchases tokens from the crowdsale and when they sees that
 * the goal is unlikely to be met, they sell their tokens (possibly at a discount). The attacker will be refunded when
 * the crowdsale is finalized, and the users that purchased from them will be left with worthless tokens.
 */
contract RefundableCrowdsale is FinalizableCrowdsale {
    using SafeMath for uint256;

    // minimum amount of funds to be raised in weis
    uint256 private _goal;

    // refund escrow used to hold funds while crowdsale is running
    RefundEscrow private _escrow;

    /**
     * @dev Constructor, creates RefundEscrow.
     * @param goal Funding goal
     */
    constructor (uint256 goal) public {
        require(goal > 0);
        _escrow = new RefundEscrow(wallet());
        _goal = goal;
    }

    /**
     * @return minimum amount of funds to be raised in wei.
     */
    function goal() public view returns (uint256) {
        return _goal;
    }

    /**
     * @dev Investors can claim refunds here if crowdsale is unsuccessful
     * @param refundee Whose refund will be claimed.
     */
    function claimRefund(address payable refundee) public {
        require(finalized());
        require(!goalReached());

        _escrow.withdraw(refundee);
    }

    /**
     * @dev Checks whether funding goal was reached.
     * @return Whether funding goal was reached
     */
    function goalReached() public view returns (bool) {
        return weiRaised() >= _goal;
    }

    /**
     * @dev escrow finalization task, called when finalize() is called
     */
    function _finalization() internal {
        if (goalReached()) {
            _escrow.close();
            _escrow.beneficiaryWithdraw();
        } else {
            _escrow.enableRefunds();
        }

        super._finalization();
    }

    /**
     * @dev Overrides Crowdsale fund forwarding, sending funds to escrow.
     */
    function _forwardFunds() internal {
        _escrow.deposit.value(msg.value)(msg.sender);
    }
}

// File: installed_contracts/openzeppelin-solidity/contracts/crowdsale/distribution/PostDeliveryCrowdsale.sol

pragma solidity ^0.5.2;



/**
 * @title PostDeliveryCrowdsale
 * @dev Crowdsale that locks tokens from withdrawal until it ends.
 */
contract PostDeliveryCrowdsale is TimedCrowdsale {
    using SafeMath for uint256;

    mapping(address => uint256) private _balances;

    /**
     * @dev Withdraw tokens only after crowdsale ends.
     * @param beneficiary Whose tokens will be withdrawn.
     */
    function withdrawTokens(address beneficiary) public {
        require(hasClosed());
        uint256 amount = _balances[beneficiary];
        require(amount > 0);
        _balances[beneficiary] = 0;
        _deliverTokens(beneficiary, amount);
    }

    /**
     * @return the balance of an account.
     */
    function balanceOf(address account) public view returns (uint256) {
        return _balances[account];
    }

    /**
     * @dev Overrides parent by storing balances instead of issuing tokens right away.
     * @param beneficiary Token purchaser
     * @param tokenAmount Amount of tokens purchased
     */
    function _processPurchase(address beneficiary, uint256 tokenAmount) internal {
        _balances[beneficiary] = _balances[beneficiary].add(tokenAmount);
    }

}

// File: installed_contracts/openzeppelin-solidity/contracts/crowdsale/distribution/RefundablePostDeliveryCrowdsale.sol

pragma solidity ^0.5.2;




/**
 * @title RefundablePostDeliveryCrowdsale
 * @dev Extension of RefundableCrowdsale contract that only delivers the tokens
 * once the crowdsale has closed and the goal met, preventing refunds to be issued
 * to token holders.
 */
contract RefundablePostDeliveryCrowdsale is RefundableCrowdsale, PostDeliveryCrowdsale {
    function withdrawTokens(address beneficiary) public {
        require(finalized());
        require(goalReached());

        super.withdrawTokens(beneficiary);
    }
}

// File: installed_contracts/openzeppelin-solidity/contracts/token/ERC20/ERC20Detailed.sol

pragma solidity ^0.5.2;


/**
 * @title ERC20Detailed token
 * @dev The decimals are only for visualization purposes.
 * All the operations are done using the smallest and indivisible token unit,
 * just as on Ethereum all the operations are done in wei.
 */
contract ERC20Detailed is IERC20 {
    string private _name;
    string private _symbol;
    uint8 private _decimals;

    constructor (string memory name, string memory symbol, uint8 decimals) public {
        _name = name;
        _symbol = symbol;
        _decimals = decimals;
    }

    /**
     * @return the name of the token.
     */
    function name() public view returns (string memory) {
        return _name;
    }

    /**
     * @return the symbol of the token.
     */
    function symbol() public view returns (string memory) {
        return _symbol;
    }

    /**
     * @return the number of decimals of the token.
     */
    function decimals() public view returns (uint8) {
        return _decimals;
    }
}

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

pragma solidity ^0.5.2;

/**
 * @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 private _owner;

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

    /**
     * @dev The Ownable constructor sets the original `owner` of the contract to the sender
     * account.
     */
    constructor () internal {
        _owner = msg.sender;
        emit OwnershipTransferred(address(0), _owner);
    }

    /**
     * @return the address of the owner.
     */
    function owner() public view returns (address) {
        return _owner;
    }

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

    /**
     * @return true if `msg.sender` is the owner of the contract.
     */
    function isOwner() public view returns (bool) {
        return msg.sender == _owner;
    }

    /**
     * @dev Allows the current owner to relinquish control of the contract.
     * It will not be possible to call the functions with the `onlyOwner`
     * modifier anymore.
     * @notice Renouncing ownership will leave the contract without an owner,
     * thereby removing any functionality that is only available to the owner.
     */
    function renounceOwnership() public onlyOwner {
        emit OwnershipTransferred(_owner, address(0));
        _owner = address(0);
    }

    /**
     * @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) public onlyOwner {
        _transferOwnership(newOwner);
    }

    /**
     * @dev Transfers control of the contract to a newOwner.
     * @param newOwner The address to transfer ownership to.
     */
    function _transferOwnership(address newOwner) internal {
        require(newOwner != address(0));
        emit OwnershipTransferred(_owner, newOwner);
        _owner = newOwner;
    }
}

// File: installed_contracts/openzeppelin-solidity/contracts/token/ERC20/ERC20.sol

pragma solidity ^0.5.2;



/**
 * @title Standard ERC20 token
 *
 * @dev Implementation of the basic standard token.
 * https://eips.ethereum.org/EIPS/eip-20
 * Originally based on code by FirstBlood:
 * https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
 *
 * This implementation emits additional Approval events, allowing applications to reconstruct the allowance status for
 * all accounts just by listening to said events. Note that this isn't required by the specification, and other
 * compliant implementations may not do it.
 */
contract ERC20 is IERC20 {
    using SafeMath for uint256;

    mapping (address => uint256) private _balances;

    mapping (address => mapping (address => uint256)) private _allowed;

    uint256 private _totalSupply;

    /**
     * @dev Total number of tokens in existence
     */
    function totalSupply() public view returns (uint256) {
        return _totalSupply;
    }

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

    /**
     * @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 view returns (uint256) {
        return _allowed[owner][spender];
    }

    /**
     * @dev Transfer token to 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) {
        _transfer(msg.sender, 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) {
        _approve(msg.sender, spender, value);
        return true;
    }

    /**
     * @dev Transfer tokens from one address to another.
     * Note that while this function emits an Approval event, this is not required as per the specification,
     * and other compliant implementations may not emit the event.
     * @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) {
        _transfer(from, to, value);
        _approve(from, msg.sender, _allowed[from][msg.sender].sub(value));
        return true;
    }

    /**
     * @dev Increase the amount of tokens that an owner allowed to a spender.
     * approve should be called when _allowed[msg.sender][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
     * Emits an Approval event.
     * @param spender The address which will spend the funds.
     * @param addedValue The amount of tokens to increase the allowance by.
     */
    function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
        _approve(msg.sender, spender, _allowed[msg.sender][spender].add(addedValue));
        return true;
    }

    /**
     * @dev Decrease the amount of tokens that an owner allowed to a spender.
     * approve should be called when _allowed[msg.sender][spender] == 0. To decrement
     * allowed value is better to use this function to avoid 2 calls (and wait until
     * the first transaction is mined)
     * From MonolithDAO Token.sol
     * Emits an Approval event.
     * @param spender The address which will spend the funds.
     * @param subtractedValue The amount of tokens to decrease the allowance by.
     */
    function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
        _approve(msg.sender, spender, _allowed[msg.sender][spender].sub(subtractedValue));
        return true;
    }

    /**
     * @dev Transfer token for a specified addresses
     * @param from The address to transfer from.
     * @param to The address to transfer to.
     * @param value The amount to be transferred.
     */
    function _transfer(address from, address to, uint256 value) internal {
        require(to != address(0));

        _balances[from] = _balances[from].sub(value);
        _balances[to] = _balances[to].add(value);
        emit Transfer(from, to, value);
    }

    /**
     * @dev Internal function that mints an amount of the token and assigns it to
     * an account. This encapsulates the modification of balances such that the
     * proper events are emitted.
     * @param account The account that will receive the created tokens.
     * @param value The amount that will be created.
     */
    function _mint(address account, uint256 value) internal {
        require(account != address(0));

        _totalSupply = _totalSupply.add(value);
        _balances[account] = _balances[account].add(value);
        emit Transfer(address(0), account, value);
    }

    /**
     * @dev Internal function that burns an amount of the token of a given
     * account.
     * @param account The account whose tokens will be burnt.
     * @param value The amount that will be burnt.
     */
    function _burn(address account, uint256 value) internal {
        require(account != address(0));

        _totalSupply = _totalSupply.sub(value);
        _balances[account] = _balances[account].sub(value);
        emit Transfer(account, address(0), value);
    }

    /**
     * @dev Approve an address to spend another addresses' tokens.
     * @param owner The address that owns the tokens.
     * @param spender The address that will spend the tokens.
     * @param value The number of tokens that can be spent.
     */
    function _approve(address owner, address spender, uint256 value) internal {
        require(spender != address(0));
        require(owner != address(0));

        _allowed[owner][spender] = value;
        emit Approval(owner, spender, value);
    }

    /**
     * @dev Internal function that burns an amount of the token of a given
     * account, deducting from the sender's allowance for said account. Uses the
     * internal burn function.
     * Emits an Approval event (reflecting the reduced allowance).
     * @param account The account whose tokens will be burnt.
     * @param value The amount that will be burnt.
     */
    function _burnFrom(address account, uint256 value) internal {
        _burn(account, value);
        _approve(account, msg.sender, _allowed[account][msg.sender].sub(value));
    }
}

// File: contracts/token/InterfaceUpgradeAgent.sol

pragma solidity ^0.5.2;

/**
* @title Upgrade agent interface
*/
contract InterfaceUpgradeAgent {

    uint32 public revision;

    /**
     * @dev Reissue the tokens onto the new contract revision.
     * @param holder Holder (owner) of the tokens
     * @param tokenQty How many tokens to be issued
     * @return true if tokens properly reissued, false (or reverts) otherwise
     */
    function upgradeFrom(address holder, uint256 tokenQty) external returns (bool success);
}

// File: contracts/token/UpgradableToken.sol

pragma solidity ^0.5.2;





/**
 * @title UpgradableToken
 * @dev The UpgradableToken contract provides an option of upgrading the tokens to a new revision.
 * The contract owner only may enable the upgrade. After that anyone may trigger the upgrade.
 */

contract UpgradableToken is ERC20, Ownable {

    using SafeMath for uint256;

    uint32 public REVISION;

    /** Address of the contract that issues the new revision tokens. */
    address public upgradeAgent = address(0);

    /** How many tokens are upgraded. */
    uint256 public totalUpgraded;

    event Upgrade(address indexed _from, uint256 _value);
    event UpgradeEnabled(address agent);

    /**
     * @dev Set the upgrade agent (once only) thus enabling the upgrade.
     * @param _upgradeAgent Upgrade agent contract address
     * @param _revision Unique ID that agent contract must return on ".revision()"
     */
    function setUpgradeAgent(address _upgradeAgent, uint32 _revision)
        onlyOwner whenUpgradeDisabled external
    {
        require((_upgradeAgent != address(0)) && (_revision != 0));

        InterfaceUpgradeAgent agent = InterfaceUpgradeAgent(_upgradeAgent);
        require(agent.revision() == _revision);

        upgradeAgent = _upgradeAgent;
        emit UpgradeEnabled(_upgradeAgent);
    }

    /**
     * @dev Upgrade tokens to the new revision.
     * @param from address tokens of which to be upgraded
     */
    function upgrade(address from) whenUpgradeEnabled external {
        require(from != address(0));

        uint256 value = balanceOf(from);
        require(value > 0);

        // Take tokens out from the old contract
        _burn(from, value);
        // Issue the new revision tokens
        totalUpgraded = totalUpgraded.add(value);
        InterfaceUpgradeAgent agent = InterfaceUpgradeAgent(upgradeAgent);
        require(agent.upgradeFrom(from, value));

        emit Upgrade(from, value);
    }

    /**
    * @dev Modifier to make a function callable only when the upgrade is enabled.
    */
    modifier whenUpgradeEnabled() {
        require(upgradeAgent != address(0));
        _;
    }

    /**
    * @dev Modifier to make a function callable only when the upgrade is impossible.
    */
    modifier whenUpgradeDisabled() {
        require(upgradeAgent == address(0));
        _;
    }

}

// File: contracts/token/InnouToken.sol

pragma solidity ^0.5.2;





contract InnToken is ERC20Detailed, UpgradableToken, Secondary {
    using SafeMath for uint256;

    string public constant NAME = "INNOU.IO Token";
    string public constant SYMBOL = "INNOU";

    /**
     * @dev The decimals are only for visualization purposes -
     * just as operations with ethers are done in wei,
     * all operations with the tokens are done in "atom"
     * that is the smallest and indivisible token unit:
     *     1 token = 1x10^DECIMALS atom(s)
     */
    uint8 public constant DECIMALS = 14;

    /**
     * @dev On top of tokens to investors the contract mints extra tokens to the primary account
     * (i.e. the one that created the contract) at this percent rate:
     */
    uint256 public constant PREMIUM_MINT_PCT = 15;

    constructor()
    ERC20Detailed(NAME, SYMBOL, DECIMALS)
    public
    {
    }

    /**
     * @dev Function to mint tokens
     * @param to The address that will receive the minted tokens.
     * @param value The amount of tokens to mint.
     * @return A boolean that indicates if the operation was successful.
     */
    function mint(address to, uint256 value) public onlyPrimary returns (bool) {
        // mint tokens to the requested address
        _mint(to, value);
        // mint extra tokens to the primary account
        uint256 premium = PREMIUM_MINT_PCT.mul(value).div(100);
        _mint(primary(), premium);

        return true;
    }

}

// File: contracts/crowdsale/InnouCrowdsale.sol

pragma solidity ^0.5.2;



/*
 * @title InnCrowdsale
 * @dev Before the goal (soft-cap) is reached the contract acts as openzeppelin RefundablePostDeliveryCrowdsale.
 * As soon as the goal is reached the contract behaves like openzeppelin MintedCrowdsale
 */

contract InnCrowdsale is RefundablePostDeliveryCrowdsale {

    InnToken private _token = new InnToken();
    uint256 private _minPurchase;

    constructor(
        uint256 openingTime,
        uint256 closingTime,
        uint256 rate,
        address payable wallet,
        uint256 goal,
        uint256 minPurchase
    )
    Crowdsale(rate, wallet, _token)
    TimedCrowdsale(openingTime, closingTime)
    RefundableCrowdsale(goal)
    public{
        _minPurchase = minPurchase;
        _token.transferOwnership(msg.sender);
    }

    /**
    * @return the min purchase possible (in wei).
    */
    function minPurchase() public view returns (uint256) {
        return _minPurchase;
    }

    /**
     * @dev Transfer tokens held by the contract itself ("premium" tokens) to the wallet address.
     * Reverts if called by any address except the wallet.
     * @return true if tokens have been transferred.
     */
    function transferPremiumTokens() external returns (bool) {
        require(msg.sender == wallet());
        uint256 value = InnToken(_token).balanceOf(address(this));
        require(InnToken(_token).transfer(msg.sender, value));
        return true;
    }

    /**
     * @dev Like ERC20 tokens does, the contract provides the name the symbol and decimals for the token on sale.
     * It facilitates software wallets in getting info on the token.
     * @return the name of the token on sale.
     */
    function name() public view returns (string memory) {
        return _token.name();
    }
    /**
     * @return the symbol of the token on sale.
     */
    function symbol() public view returns (string memory) {
        return _token.symbol();
    }
    /**
     * @return the number of decimals of the token on sale.
     */
    function decimals() public view returns (uint8) {
        return _token.decimals();
    }

    /**
     * @return true if the crowdsale is open, false otherwise.
     */
    function isSaleOpen() public view returns (bool) {
        return TimedCrowdsale.isOpen();
    }

    /**
     * @dev Overrides parents by checking whether the REFUNDABLE part of the crowdsale is open.
     * (it considers if the goal has not yet been reached)
     * @return true if the refundable part of the crowdsale is open, false otherwise.
     */
    function isOpen() public view returns (bool) {
        if (goalReached()) {
            return false;
        }
        return super.isOpen();
    }

    /**
     * @dev Overrides parents by checking whether the REFUNDABLE part of the crowdsale has closed.
     * (i.e. considers if the goal has reached)
     * @return Whether the refundable part of the crowdsale has closed.
     */
    function hasClosed() public view returns (bool) {
        if (goalReached()) {
            return true;
        }
        return super.hasClosed();
    }

    /**
     * @dev Overrides parents by issuing tokens if the goal reached or storing the balance to mint them later otherwise.
     * @param beneficiary Token purchaser
     * @param tokenAmount Amount of tokens purchased
     */
    function _processPurchase(address beneficiary, uint256 tokenAmount) internal {
        if (goalReached()) {
            // mint tokens
            Crowdsale._processPurchase(beneficiary, tokenAmount);
        } else {
            // book balance to mint tokens later
            super._processPurchase(beneficiary, tokenAmount);
        }
    }

    /**
     * @dev Overrides fund forwarding.
     */
    function _forwardFunds() internal {
        if (goalReached()) {
            // directly to the wallet
            Crowdsale._forwardFunds();
        } else {
            // to the escrow
            RefundableCrowdsale._forwardFunds();
        }
    }

    /**
     * @dev Overrides pre-validation on token purchase transaction.
     * Replica of the openzeppelin methods except for re-defined isSaleOpen
     */
    function _preValidatePurchase(address beneficiary, uint256 weiAmount) internal view {
        // (note: this code runs before Crowdsale._weiRaised gets incremented with weiAmount)
        require(weiAmount >= _minPurchase);
        require(beneficiary != address(0));
        require(isSaleOpen());
    }

    /**
     * @dev Overrides delivery by minting tokens
     * (effectively, InnCrowdsale is MintedCrowdsale)
     * Replica of the openzeppelin MintedCrowdsale contract only own method
     * @param beneficiary Token purchaser
     * @param tokenAmount Number of tokens to be minted
     */
    function _deliverTokens(address beneficiary, uint256 tokenAmount) internal {
        require(InnToken(address(token())).mint(beneficiary, tokenAmount));
    }

}

// File: contracts/crowdsale/InnouCrowdsaleReady.sol

pragma solidity ^0.5.2;


contract InnCrowdsaleReady is InnCrowdsale {

    // From 06/07/2019 @ 12:00am (UTC) to 07/18/2019 @ 11:59pm (UTC), Goal: 2000 ETH
    uint256 public constant OpeningTime = 1559865600;
    uint256 public constant ClosingTime = 1563494399;
    uint256 public constant Goal = 2000 ether;

    /**
     * all operations with tokens are done in "atom"
     * that is the smallest and indivisible token unit:
     *   1 token = 1e+14 atom
     *
     * token(s) exchanged for ether(s) at the fixed rate:
     *   1 ether => 10,000 token (1 wei => 1 atom)
     */

    // 1 wei gets this number of atom(s)
    uint256 public constant Rate = 1;

    //   1 szabo = 1e+12 wei = 1e-6 ether
    uint256 public constant MinPurchase = 5000 szabo;

    constructor(address payable wallet)
    InnCrowdsale(
        OpeningTime,
        ClosingTime,
        Rate,
        wallet,
        Goal,
        MinPurchase
    )
    public {
    }

}

• No Contract Security Audit Submitted- Submit Audit Here

[{"constant":true,"inputs":[],"name":"name","outputs":[{"name":"","type":"string"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"hasClosed","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"isSaleOpen","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"Rate","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"rate","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"decimals","outputs":[{"name":"","type":"uint8"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"minPurchase","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"MinPurchase","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"goal","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"weiRaised","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"OpeningTime","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"isOpen","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"beneficiary","type":"address"}],"name":"withdrawTokens","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"closingTime","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[],"name":"finalize","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"wallet","outputs":[{"name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"account","type":"address"}],"name":"balanceOf","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"ClosingTime","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"goalReached","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[],"name":"transferPremiumTokens","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"Goal","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"symbol","outputs":[{"name":"","type":"string"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"finalized","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"openingTime","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"refundee","type":"address"}],"name":"claimRefund","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"beneficiary","type":"address"}],"name":"buyTokens","outputs":[],"payable":true,"stateMutability":"payable","type":"function"},{"constant":true,"inputs":[],"name":"token","outputs":[{"name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"inputs":[{"name":"wallet","type":"address"}],"payable":false,"stateMutability":"nonpayable","type":"constructor"},{"payable":true,"stateMutability":"payable","type":"fallback"},{"anonymous":false,"inputs":[],"name":"CrowdsaleFinalized","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"name":"prevClosingTime","type":"uint256"},{"indexed":false,"name":"newClosingTime","type":"uint256"}],"name":"TimedCrowdsaleExtended","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"purchaser","type":"address"},{"indexed":true,"name":"beneficiary","type":"address"},{"indexed":false,"name":"value","type":"uint256"},{"indexed":false,"name":"amount","type":"uint256"}],"name":"TokensPurchased","type":"event"}]

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

0000000000000000000000008038aca215a031a673f4e7d9d7c20e623e006c8f

-----Decoded View---------------
Arg [0] : wallet (address): 0x8038aCa215a031a673F4E7D9D7c20e623E006c8F

-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 0000000000000000000000008038aca215a031a673f4e7d9d7c20e623e006c8f

53052:961:0:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;11647:21;11657:10;11647:9;:21::i;:::-;53052:961;49634:91;;8:9:-1;5:2;;;30:1;27;20:12;5:2;49634:91:0;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:10;8:100;;;99:1;94:3;90:11;84:18;80:1;75:3;71:11;64:39;52:2;49:1;45:10;40:15;;8:100;;;12:14;49634:91:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;50928:158;;8:9:-1;5:2;;;30:1;27;20:12;5:2;50928:158:0;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;50159:98;;8:9:-1;5:2;;;30:1;27;20:12;5:2;50159:98:0;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;53673:32;;8:9:-1;5:2;;;30:1;27;20:12;5:2;53673:32:0;;;:::i;:::-;;;;;;;;;;;;;;;;;;;12078:77;;8:9:-1;5:2;;;30:1;27;20:12;5:2;12078:77:0;;;:::i;:::-;;;;;;;;;;;;;;;;;;;49978:91;;8:9:-1;5:2;;;30:1;27;20:12;5:2;49978:91:0;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;48785;;8:9:-1;5:2;;;30:1;27;20:12;5:2;48785:91:0;;;:::i;:::-;;;;;;;;;;;;;;;;;;;53757:48;;8:9:-1;5:2;;;30:1;27;20:12;5:2;53757:48:0;;;:::i;:::-;;;;;;;;;;;;;;;;;;;28760:77;;8:9:-1;5:2;;;30:1;27;20:12;5:2;28760:77:0;;;:::i;:::-;;;;;;;;;;;;;;;;;;;12223:87;;8:9:-1;5:2;;;30:1;27;20:12;5:2;12223:87:0;;;:::i;:::-;;;;;;;;;;;;;;;;;;;53190:48;;8:9:-1;5:2;;;30:1;27;20:12;5:2;53190:48:0;;;:::i;:::-;;;;;;;;;;;;;;;;;;;50527:153;;8:9:-1;5:2;;;30:1;27;20:12;5:2;50527:153:0;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;31769:170;;8:9:-1;5:2;;;30:1;27;20:12;5:2;31769:170:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;31769:170:0;;;;;;;;;;;;;;;;;;;:::i;:::-;;17684:91;;8:9:-1;5:2;;;30:1;27;20:12;5:2;17684:91:0;;;:::i;:::-;;;;;;;;;;;;;;;;;;;19989:191;;8:9:-1;5:2;;;30:1;27;20:12;5:2;19989:191:0;;;:::i;:::-;;11899:89;;8:9:-1;5:2;;;30:1;27;20:12;5:2;11899:89:0;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;30789:110;;8:9:-1;5:2;;;30:1;27;20:12;5:2;30789:110:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;30789:110:0;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;53245:48;;8:9:-1;5:2;;;30:1;27;20:12;5:2;53245:48:0;;;:::i;:::-;;;;;;;;;;;;;;;;;;;29287:96;;8:9:-1;5:2;;;30:1;27;20:12;5:2;29287:96:0;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;49115:261;;8:9:-1;5:2;;;30:1;27;20:12;5:2;49115:261:0;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;53300:41;;8:9:-1;5:2;;;30:1;27;20:12;5:2;53300:41:0;;;:::i;:::-;;;;;;;;;;;;;;;;;;;49798:95;;8:9:-1;5:2;;;30:1;27;20:12;5:2;49798:95:0;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:10;8:100;;;99:1;94:3;90:11;84:18;80:1;75:3;71:11;64:39;52:2;49:1;45:10;40:15;;8:100;;;12:14;49798:95:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;19741:84;;8:9:-1;5:2;;;30:1;27;20:12;5:2;19741:84:0;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;17523:91;;8:9:-1;5:2;;;30:1;27;20:12;5:2;17523:91:0;;;:::i;:::-;;;;;;;;;;;;;;;;;;;28992:166;;8:9:-1;5:2;;;30:1;27;20:12;5:2;28992:166:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;28992:166:0;;;;;;;;;;;;;;;;;;;:::i;:::-;;12575:620;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;12575:620:0;;;;;;;;;;;;;;;;;;;:::i;:::-;;11740:78;;8:9:-1;5:2;;;30:1;27;20:12;5:2;11740:78:0;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;12575:620;8632:1;8615:13;;:18;;;;;;;;;;;8644:20;8667:13;;8644:36;;12654:17;12674:9;12654:29;;12694:44;12715:11;12728:9;12694:20;:44::i;:::-;12800:14;12817:26;12833:9;12817:15;:26::i;:::-;12800:43;;12894:25;12909:9;12894:10;;:14;;:25;;;;:::i;:::-;12881:10;:38;;;;12932:37;12949:11;12962:6;12932:16;:37::i;:::-;13013:11;12985:59;;13001:10;12985:59;;;13026:9;13037:6;12985:59;;;;;;;;;;;;;;;;;;;;;;;;13057:46;13080:11;13093:9;13057:22;:46::i;:::-;13116:15;:13;:15::i;:::-;13142:45;13164:11;13177:9;13142:21;:45::i;:::-;8691:1;;8727:13;;8711:12;:29;8703:38;;;;;;;;12575:620;;:::o;49634:91::-;49671:13;49704:6;;;;;;;;;;;:11;;;:13;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;49704:13:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;49704:13:0;;;;;;39:16:-1;36:1;17:17;2:54;49704:13:0;101:4:-1;97:9;90:4;84;80:15;76:31;69:5;65:43;126:6;120:4;113:20;0:138;13:2;8:3;5:11;2:2;;;29:1;26;19:12;2:2;49704:13:0;;;;;;19:11:-1;14:3;11:20;8:2;;;44:1;41;34:12;8:2;71:11;66:3;62:21;55:28;;123:4;118:3;114:14;159:9;141:16;138:31;135:2;;;182:1;179;172:12;135:2;219:3;213:10;330:9;325:1;311:12;307:20;289:16;285:43;282:58;261:11;247:12;244:29;233:115;230:2;;;361:1;358;351:12;230:2;0:372;;49704:13:0;;;;;;49697:20;;49634:91;:::o;50928:158::-;50970:4;50991:13;:11;:13::i;:::-;50987:57;;;51028:4;51021:11;;;;50987:57;51061:17;:15;:17::i;:::-;51054:24;;50928:158;;:::o;50159:98::-;50202:4;50226:23;:21;:23::i;:::-;50219:30;;50159:98;:::o;53673:32::-;53704:1;53673:32;:::o;12078:77::-;12115:7;12142:5;;12135:12;;12078:77;:::o;49978:91::-;50019:5;50044:6;;;;;;;;;;;:15;;;:17;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;50044:17:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;50044:17:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;50044:17:0;;;;;;;;;;;;;;;;50037:24;;49978:91;:::o;48785:::-;48829:7;48856:12;;48849:19;;48785:91;:::o;53757:48::-;53795:10;53757:48;:::o;28760:77::-;28797:7;28824:5;;28817:12;;28760:77;:::o;12223:87::-;12265:7;12292:10;;12285:17;;12223:87;:::o;53190:48::-;53228:10;53190:48;:::o;50527:153::-;50566:4;50587:13;:11;:13::i;:::-;50583:58;;;50624:5;50617:12;;;;50583:58;50658:14;:12;:14::i;:::-;50651:21;;50527:153;;:::o;31769:170::-;31840:11;:9;:11::i;:::-;31832:20;;;;;;;;31871:13;:11;:13::i;:::-;31863:22;;;;;;;;31898:33;31919:11;31898:20;:33::i;:::-;31769:170;:::o;17684:91::-;17728:7;17755:12;;17748:19;;17684:91;:::o;19989:191::-;20036:10;;;;;;;;;;;20035:11;20027:20;;;;;;;;20066:11;:9;:11::i;:::-;20058:20;;;;;;;;20104:4;20091:10;;:17;;;;;;;;;;;;;;;;;;20121:15;:13;:15::i;:::-;20152:20;;;;;;;;;;19989:191::o;11899:89::-;11938:15;11973:7;;;;;;;;;;;11966:14;;11899:89;:::o;30789:110::-;30846:7;30873:9;:18;30883:7;30873:18;;;;;;;;;;;;;;;;30866:25;;30789:110;;;:::o;53245:48::-;53283:10;53245:48;:::o;29287:96::-;29331:4;29370:5;;29355:11;:9;:11::i;:::-;:20;;29348:27;;29287:96;:::o;49115:261::-;49166:4;49205:8;:6;:8::i;:::-;49191:22;;:10;:22;;;49183:31;;;;;;;;49225:13;49250:6;;;;;;;;;;;49241:26;;;49276:4;49241:41;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;49241:41:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;49241:41:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;49241:41:0;;;;;;;;;;;;;;;;49225:57;;49310:6;;;;;;;;;;;49301:25;;;49327:10;49339:5;49301:44;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;49301:44:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;49301:44:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;49301:44:0;;;;;;;;;;;;;;;;49293:53;;;;;;;;49364:4;49357:11;;;49115:261;:::o;53300:41::-;53331:10;53300:41;:::o;49798:95::-;49837:13;49870:6;;;;;;;;;;;:13;;;:15;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;49870:15:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;49870:15:0;;;;;;39:16:-1;36:1;17:17;2:54;49870:15:0;101:4:-1;97:9;90:4;84;80:15;76:31;69:5;65:43;126:6;120:4;113:20;0:138;13:2;8:3;5:11;2:2;;;29:1;26;19:12;2:2;49870:15:0;;;;;;19:11:-1;14:3;11:20;8:2;;;44:1;41;34:12;8:2;71:11;66:3;62:21;55:28;;123:4;118:3;114:14;159:9;141:16;138:31;135:2;;;182:1;179;172:12;135:2;219:3;213:10;330:9;325:1;311:12;307:20;289:16;285:43;282:58;261:11;247:12;244:29;233:115;230:2;;;361:1;358;351:12;230:2;0:372;;49870:15:0;;;;;;49863:22;;49798:95;:::o;19741:84::-;19783:4;19807:10;;;;;;;;;;;19800:17;;19741:84;:::o;17523:91::-;17567:7;17594:12;;17587:19;;17523:91;:::o;28992:166::-;29065:11;:9;:11::i;:::-;29057:20;;;;;;;;29097:13;:11;:13::i;:::-;29096:14;29088:23;;;;;;;;29124:7;;;;;;;;;;;:16;;;29141:8;29124:26;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;29124:26:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;29124:26:0;;;;28992:166;:::o;11740:78::-;11778:6;11804;;;;;;;;;;;11797:13;;11740:78;:::o;52181:309::-;52392:12;;52379:9;:25;;52371:34;;;;;;;;52447:1;52424:25;;:11;:25;;;;52416:34;;;;;;;;52469:12;:10;:12::i;:::-;52461:21;;;;;;;;52181:309;;:::o;15891:122::-;15958:7;15985:20;15999:5;;15985:9;:13;;:20;;;;:::i;:::-;15978:27;;15891:122;;;:::o;1570:150::-;1628:7;1648:9;1664:1;1660;:5;1648:17;;1689:1;1684;:6;;1676:15;;;;;;;;1711:1;1704:8;;;1570:150;;;;:::o;51331:352::-;51423:13;:11;:13::i;:::-;51419:257;;;51481:52;51508:11;51521;51481:26;:52::i;:::-;51419:257;;;51616:48;51639:11;51652;51616:22;:48::i;:::-;51419:257;51331:352;;:::o;15488:147::-;;;:::o;51749:260::-;51798:13;:11;:13::i;:::-;51794:208;;;51867:25;:23;:25::i;:::-;51794:208;;;51955:35;:33;:35::i;:::-;51794:208;51749:260::o;14222:151::-;;;:::o;18227:159::-;18269:4;18366:12;;18348:15;:30;18341:37;;18227:159;:::o;17865:192::-;17904:4;18002:12;;17983:15;:31;;:66;;;;;18037:12;;18018:15;:31;;17983:66;17976:73;;17865:192;:::o;30466:254::-;30537:11;:9;:11::i;:::-;30529:20;;;;;;;;30560:14;30577:9;:22;30587:11;30577:22;;;;;;;;;;;;;;;;30560:39;;30627:1;30618:6;:10;30610:19;;;;;;;;30665:1;30640:9;:22;30650:11;30640:22;;;;;;;;;;;;;;;:26;;;;30677:35;30692:11;30705:6;30677:14;:35::i;:::-;30466:254;;:::o;29481:247::-;29530:13;:11;:13::i;:::-;29526:161;;;29560:7;;;;;;;;;;;:13;;;:15;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;29560:15:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;29560:15:0;;;;29590:7;;;;;;;;;;;:27;;;:29;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;29590:29:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;29590:29:0;;;;29526:161;;;29652:7;;;;;;;;;;;:21;;;:23;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;29652:23:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;29652:23:0;;;;29526:161;29699:21;:19;:21::i;:::-;29481:247::o;323:433::-;381:7;630:1;625;:6;621:47;;;655:1;648:8;;;;621:47;680:9;696:1;692;:5;680:17;;725:1;720;716;:5;;;;;;;;:10;708:19;;;;;;;;747:1;740:8;;;323:433;;;;;:::o;15074:136::-;15162:40;15177:11;15190;15162:14;:40::i;:::-;15074:136;;:::o;31110:160::-;31223:39;31250:11;31223:9;:22;31233:11;31223:22;;;;;;;;;;;;;;;;:26;;:39;;;;:::i;:::-;31198:9;:22;31208:11;31198:22;;;;;;;;;;;;;;;:64;;;;31110:160;;:::o;16105:80::-;16150:7;;;;;;;;;;;:16;;:27;16167:9;16150:27;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;16150:27:0;16105:80::o;29829:97::-;29874:7;;;;;;;;;;;:15;;;29896:9;29907:10;29874:44;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;29874:44:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;29874:44:0;;;;;29829:97::o;52798:160::-;52909:7;:5;:7::i;:::-;52892:31;;;52924:11;52937;52892:57;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;52892:57:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;52892:57:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;52892:57:0;;;;;;;;;;;;;;;;52884:66;;;;;;;;52798:160;;:::o;20396:100::-;:::o

bzzr://615e768d905ff0924bec1356ff152de492ea39e28c4f3800cdea644f03feb69f