Contract

Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

• 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 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)
•  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 ...
• library Roles
•    - function add(Role storage role, addre ...
•    - function remove(Role storage role, ad ...
•    - function has(Role storage role, addre ...
•  contract MinterRole
•    - function isMinter(address account)
•    - function addMinter(address account)
•    - function renounceMinter()
•    - function _addMinter(address account)
•    - function _removeMinter(address accoun ...
•  contract ERC20Mintable is ERC20, M ...
•    - function mint(address to, uint256 val ...
• 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 supply()
•    - function sold()
•    - function _addSold(uint256 tokenAmount ...
•    - 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 _getWeiAmount(uint256 tokenA ...
•    - function _forwardFunds(uint256 weiAmo ...
•    - function _countSurplus(uint256 weiAmo ...
•    - function _returnSurplus(uint256 weiAm ...
•    - function _changeRate(uint256 newRate)
• library Role
•    - function total (RoleContainer storage ...
•    - function has(RoleContainer storage ro ...
•    - function add(RoleContainer storage ro ...
•    - function remove(RoleContainer storage ...
•    - function removeFromList(RoleContainer ...
• library Helpers
•    - function majority(uint total)
•    - function idFromAddress(address addr)
•    - function idFromUint256(uint256 x)
•    - function mixId(address addr, uint256 ...
• library Votings
•    - function voteAndCheck(Voting storage ...
•    - function isComplete(Voting storage vo ...
•    - function vote(Voting storage voting,
•    - function hadVoted(Voting storage voti ...
•  contract AdminRole
•    - function isAdmin(address account)
•    - function listAdmins()
•    - function countAdmins()
•    - function initAdmins(address[] memory ...
•    - function addAdmin(address account)
•    - function expelAdmin(address account)
•    - function _addAdminVoting(address acco ...
•    - function _expelAdminVoting(address ac ...
•    - function _add(address account)
•    - function _expel(address account)
•  contract InvestOnBehalf is AdminRo ...
•    - function consensus(address account, u ...
•    - function investOnBehalf(address to, u ...
•  contract MilestonedCrowdsale is Ad ...
•    - function _newMilestone(uint256 start, ...
•    - function initMilestones(uint256[] mem ...
•    - function _countSurplus(uint256 weiAmo ...
•    - function _returnSurplus(uint256 weiAm ...
•    - function _getMilestoneOverhead(uint25 ...
•    - function _checkStage(uint256 from, ui ...
•  contract UpdatableRateCrowdsale is ...
•    - function consensus(uint256 rate)
•    - function changeRate(uint256 rate)
•  contract MintedCrowdsale is Crowds ...
•    - function _deliverTokens(address benef ...
•  contract SoftcappedCrowdsale is Ad ...
•    - function goal()
•    - function minimalPay()
•    - function setMinimalPay(uint256 weiAmo ...
•    - function goalReached()
•    - function _preValidatePurchase(address ...
•  contract TimedCrowdsale is Softcap ...
•    - function openingTime()
•    - function softcapDeadline()
•    - function closingTime()
•    - function hasClosed()
•    - function _preValidatePurchase(address ...
•  contract FinalizableCrowdsale is A ...
•    - 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 customWithdraw(uint256 ether ...
•    - function withdrawalAllowed(address)
•  contract RefundableCrowdsale is Fi ...
•    - function claimRefund(address payable ...
•    - function beneficiaryWithdraw(uint256 ...
•    - function _finalization()
•    - function _forwardFunds(uint256 weiAmo ...
•    - function consensus(uint256 etherAmoun ...
•  contract PostDeliveryCrowdsale is ...
•    - function withdrawTokens(address benef ...
•    - function balanceOf(address account)
•    - function backers()
•    - function _processPurchase(address ben ...
•  contract RefundablePostDeliveryCro ...
•    - function withdrawTokens(address benef ...
•  contract Moon_Token_Crowdsale is *
•    - function finishSetup(

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2019-05-25
*/

/*
    Moon Token for MoonTrader Platform and projects
    More information at https://moontrader.io/

    MoonTrader is a successor of the  MoonBot project, https://moon-bot.com/en/

    Mail us to: [email protected] 

    Join the Telegram channel https://t.me/moontrader_news_en, 
    Visit BTT forum thread https://bitcointalk.org/index.php?topic=5143969 for more information.

 */

// File: 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: 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: 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: openzeppelin-solidity/contracts/access/Roles.sol

pragma solidity ^0.5.2;

/**
 * @title Roles
 * @dev Library for managing addresses assigned to a Role.
 */
library Roles {
    struct Role {
        mapping (address => bool) bearer;
    }

    /**
     * @dev give an account access to this role
     */
    function add(Role storage role, address account) internal {
        require(account != address(0));
        require(!has(role, account));

        role.bearer[account] = true;
    }

    /**
     * @dev remove an account's access to this role
     */
    function remove(Role storage role, address account) internal {
        require(account != address(0));
        require(has(role, account));

        role.bearer[account] = false;
    }

    /**
     * @dev check if an account has this role
     * @return bool
     */
    function has(Role storage role, address account) internal view returns (bool) {
        require(account != address(0));
        return role.bearer[account];
    }
}

// File: openzeppelin-solidity/contracts/access/roles/MinterRole.sol

pragma solidity ^0.5.2;


contract MinterRole {
    using Roles for Roles.Role;

    event MinterAdded(address indexed account);
    event MinterRemoved(address indexed account);

    Roles.Role private _minters;

    constructor () internal {
        _addMinter(msg.sender);
    }

    modifier onlyMinter() {
        require(isMinter(msg.sender));
        _;
    }

    function isMinter(address account) public view returns (bool) {
        return _minters.has(account);
    }

    function addMinter(address account) public onlyMinter {
        _addMinter(account);
    }

    function renounceMinter() public {
        _removeMinter(msg.sender);
    }

    function _addMinter(address account) internal {
        _minters.add(account);
        emit MinterAdded(account);
    }

    function _removeMinter(address account) internal {
        _minters.remove(account);
        emit MinterRemoved(account);
    }
}

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

pragma solidity ^0.5.2;



/**
 * @title ERC20Mintable
 * @dev ERC20 minting logic
 */
contract ERC20Mintable is ERC20, MinterRole {
    /**
     * @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 onlyMinter returns (bool) {
        _mint(to, value);
        return true;
    }
}

// File: 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: 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: 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: contracts/Crowdsale/Core/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;

    // Hardcap in tokens
    uint256 private _supply;

    // Amount of sold tokens
    uint256 private _sold;

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

    /**
     * Event for conversion rate changes logging
     * @param rate New rate
     */
    event RateUpdated(uint256 indexed rate);

    /**
     * Events for crowdsale state tracking
     */
    event CrowdsalePaused();
    event CrowdsaleUnpaused();

    /**
     * @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, uint256 supply, address payable wallet, IERC20 token) public {
        require(rate > 0);
        require(wallet != address(0));
        require(address(token) != address(0));

        _rate = rate;
        _supply = supply;
        _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 amount of supplied tokens.
     */
    function supply() internal view returns (uint256) {
        return _supply;
    }

    /**
     * @return amount of sold tokens.
     */
    function sold() public view returns (uint256) {
        return _sold;
    }

    /**
     * @dev Increase amount of sold tokens by tokenAmount.
     * @param tokenAmount Amount of last-purchased tokens
     */
    function _addSold(uint256 tokenAmount) internal {
        _sold = _sold.add(tokenAmount);
    }

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

        uint256 surplus = _countSurplus(weiAmount);
        weiAmount -= surplus;

        // 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(weiAmount);
        _returnSurplus(surplus);

        _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);
        require(rate() > 0);
        require(_supply >= _sold + _getTokenAmount(weiAmount)); //todo
    }

    /**
     * @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);
        _addSold(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);
    }

    /**
     * @param tokenAmount amount of tokens to be converted in wei
     * @return amount of wei to be spent on the purchase of tokenAmount tokens
     */
    function _getWeiAmount(uint256 tokenAmount) internal view returns (uint256) {
        return tokenAmount.div(_rate);
    }

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

    /*
     * @dev Override to define the way in which surplus will be counted
     * @param weiAmount Amount of wei sent by user
     * @return surplus to be returned
     */
    function _countSurplus(uint256 weiAmount) internal returns (uint256){
        // solhint-disable-previous-line no-empty-blocks
    }

    /**
     * @dev Override to change the way in which wei surplus returns to user
     * @param weiAmount Amount of wei to be returned
     */
    function _returnSurplus(uint256 weiAmount) internal {
        if (weiAmount > 0) {
            msg.sender.transfer(weiAmount);
        }
    }

    /**
     * @dev Changes conversion rate. Override for extend the way in which rate changing affects on crowdsale
     * @param newRate Value in tokens to be paid per 1 wei
     */
    function _changeRate(uint256 newRate) internal {
        if ((newRate > 0) && (_rate == 0)) {
            emit CrowdsaleUnpaused();
        } else if (newRate == 0) {
            emit CrowdsalePaused();
        }

        _rate = newRate;
        emit RateUpdated(newRate);
    }

}

// File: contracts/Crowdsale/Util/Role.sol

pragma solidity ^0.5.2;

library Role {

    struct RoleContainer {
        address[] bearer;
    }

    /**
     * @param role role storage
     * @return amount of accounts in this role
     */
    function total (RoleContainer storage role) internal view returns (uint count) {
        for (uint i = 0; i < role.bearer.length; i++) {
            count += (role.bearer[i] == address(0)) ? 0 : 1;
        }
        return count;
    }


    /**
     * @dev check if an account has this role
     * @return bool
     */
    function has(RoleContainer storage role, address account) internal view returns (bool) {
        require(account != address(0));
        address[] memory list = role.bearer;
        uint len = role.bearer.length;
        for (uint index = 0; index < len; index++) {
            if (list[index] == account) {
                return true;
            }
        }
        return false;
    }

    /**
     * @dev give an account access to this role
     */
    function add(RoleContainer storage role, address account) internal {
        require(account != address(0));
        require(!has(role, account));

        role.bearer.push(account);
    }

    /**
     * @dev remove an account's access to this role
     */
    function remove(RoleContainer storage role, address account) internal {
        require(account != address(0));
        require(has(role, account));

        removeFromList(role, account);
    }

    /**
     * @dev Helper function. Iterates over array to find and
       remove given account from it
       @param role Role storage
       @param account Expelled account
     */
    function removeFromList(RoleContainer storage role, address account) private {
        address[] storage list = role.bearer;
        uint len = role.bearer.length;

        for (uint index = 0; index <= len; index++) {
            if (list[index] != account) {
                continue;
            }
            list[index] = list[len - 1];
            delete list[len - 1];
            return;
        }
    }
}

// File: contracts/Crowdsale/Util/Helpers.sol

pragma solidity ^0.5.2;

library Helpers {
    function majority(uint total) internal pure returns (uint) {
        return uint(total / 2) + 1;
    }

    function idFromAddress(address addr) internal pure returns (bytes32) {
        return keccak256(abi.encode(addr));
    }

    function idFromUint256(uint256 x) internal pure returns (bytes32) {
        return keccak256(abi.encode(x));
    }

    function mixId(address addr, uint256 x) internal pure returns (bytes32) {
        return keccak256(abi.encode(addr, x));
    }
}

// File: contracts/Crowdsale/Util/Votings.sol

pragma solidity ^0.5.2;


library Votings {

    struct Voting {
        mapping(bytes32 => address[]) process;
    }

    /**
     * @dev Votes and check if voting is completed. If vote is completed - deletes it
     * @param voting Storage
     * @param index Of voting process
     * @param issuer Voter
     * @param required Amount of votes for this process to be successful
     * @return (is voting completed?)
     */
    function voteAndCheck(Voting storage voting,
        bytes32 index, address issuer, uint required) internal returns (bool)
    {
        vote(voting, index, issuer);
        return isComplete(voting, index, required);
    }

    /**
     * @dev Check if voting is completed. If vote is completed - deletes it
     * @param voting Storage
     * @param index Of voting process
     * @param required Amount of votes for this process to be successful
     * @return (is voting completed?)
     */
    function isComplete(Voting storage voting,
        bytes32 index, uint required) internal returns (bool)
    {
        if (voting.process[index].length < required) {
            return false;
        }

        delete voting.process[index];
        return true;
    }



    /**
     * @dev Vote
     * @param voting Storage
     * @param index Of voting process
     * @param issuer Voter
     */
    function vote(Voting storage voting,
        bytes32 index, address issuer) internal
    {
        require(!hadVoted(voting, index, issuer));
        voting.process[index].push(issuer);
    }

    /**
     * @dev Check of issuer had voted on this process
     * @param voting Storage
     * @param index Of voting process
     * @param issuer Voter
     * @return bool
     */
    function hadVoted(Voting storage voting,
        bytes32 index, address issuer) internal view returns (bool)
    {
        address[] storage _process = voting.process[index];

        for (uint ind = 0; ind < _process.length; ind++) {
            if (_process[ind] == issuer) {
                return true;
            }
        }

        return false;
    }
}

// File: contracts/Crowdsale/Roles/AdminRole.sol

pragma solidity ^0.5.2;





contract AdminRole {
    using Role for Role.RoleContainer;
    using Votings for Votings.Voting;

    //admin storage
    Role.RoleContainer private _admins;

    //voting storage
    Votings.Voting private _addVoting;
    Votings.Voting private _expelVoting;

    /**
     * @dev events for "add admin" action logging
     * @param account New admin
     */
    event AdminAdded(address indexed account);

    /**
     * @dev events for "expel admin" action logging
     * @param account Expelled admin
     */
    event AdminRemoved(address indexed account);

    modifier AdminOnly() {
        require(isAdmin(msg.sender));
        _;
    }

    modifier WhileSetup() {
        require(isAdmin(msg.sender));
        require(countAdmins() == 1);
        _;
    }

    constructor () internal {
        _add(msg.sender);
    }

    /**
     * @param account to check
     * @return is this account contains in admin list
     */
    function isAdmin(address account) public view returns (bool) {
        return _admins.has(account);
    }

    /**
     * @return list of admins
     */
    function listAdmins() public view returns (address[] memory) {
        return _admins.bearer;
    }

    /**
     * @return amount of admins
     */
    function countAdmins() public view returns (uint) {
        return _admins.total();
    }

    /**
     * @dev initialize admin list while setup-stage of sale
     * @param defaultAdmins list of default admins
     */
    function initAdmins(address[] memory defaultAdmins) WhileSetup internal {
        for (uint256 index = 0; index < defaultAdmins.length; index++) {
            _add(defaultAdmins[index]);
        }
    }

    /**
     * @dev Vote and append given account to the admin list after consensus
     * @param account Account to be appended
     */
    function addAdmin(address account) AdminOnly public {
        if (_addAdminVoting(account)) {
            _add(account);
        }
    }

    /**
     * @dev Vote and remove given account from admin list after consensus
     * @param account Account to be removed
     */
    function expelAdmin(address account) AdminOnly public {
        if (_expelAdminVoting(account)) {
            _expel(account);
        }
    }


    /**
     * @dev require (N/2)+1 admins to be agreed with the add proposal
     * @param account Account to be appended
     * @return do (N/2)+1  admins agreed with the proposal?
     */
    function _addAdminVoting(address account) private returns (bool) {
        return _addVoting.voteAndCheck(
            Helpers.idFromAddress(account),
            msg.sender,
            Helpers.majority(countAdmins())
        );
    }

    /**
     * @dev require (N/2)+1 admins to be agreed with the removal proposal
     * @param account Account to be removed
     * @return do (N/2)+1  admins agreed with the proposal?
     */
    function _expelAdminVoting(address account) private returns (bool) {
        require(msg.sender != account);
        return _expelVoting.voteAndCheck(
            Helpers.idFromAddress(account),
            msg.sender,
            Helpers.majority(countAdmins())
        );
    }


    /**
     * @dev appends given account to admin list
     * @param account Account to be appended
     */
    function _add(address account) private {
        _admins.add(account);
        emit AdminAdded(account);
    }

    /**
     * @dev removes given account to admin list
     * @param account Account to be excluded
     */
    function _expel(address account) private {
        _admins.remove(account);
        emit AdminRemoved(account);
    }


}

// File: contracts/Crowdsale/Functionalities/InvestOnBehalf.sol

pragma solidity ^0.5.2;





contract InvestOnBehalf is AdminRole, Crowdsale {
    using Votings for Votings.Voting;

    // Current vote processes
    Votings.Voting private _votings;

    /**
     * Event for investOnBehalf actions logging
     * @param account Transfer target
     * @param tokens Amount of transferred tokens
     */
    event InvestedOnBehalf(address indexed account, uint256 indexed tokens);

    /**
     * @dev require (N/2)+1 admins to be agreed with the proposal
     * @param account Transfer target
     * @param tokens Amount of tokens to be transferred
     * @return do all admins agreed with the proposal?
     */
    function consensus(address account, uint256 tokens) private returns (bool) {
        return _votings.voteAndCheck(Helpers.mixId(account, tokens), msg.sender, Helpers.majority(countAdmins()));
    }


    /*
     * @dev Vote and add X tokens to the user balance after consensus
     * @param to Transfer target
     * @param tokens Amount of tokens to be transferred
     */
    function investOnBehalf(address to, uint256 tokens) AdminOnly public {
        if (consensus(to, tokens)) {
            _processPurchase(to, tokens * 1e18);
            emit InvestedOnBehalf(to, tokens * 1e18);
        }
    }
}

// File: contracts/Crowdsale/Functionalities/MilestonedCrowdsale.sol

pragma solidity ^0.5.2;



contract MilestonedCrowdsale is AdminRole, Crowdsale {
    event MilestoneReached(uint256 indexed milestone);

    /**
     * @dev Container for milestone ranges
     * @param start Milestone start timestamp
     * @param finish Milestone finish timestamp
     * @param fired
     */
    struct Milestone {
        uint256 start;
        uint256 finish;
        bool fired;
    }

    Milestone[] private _milestones;

    /**
     * @dev Creates single milestone in storage
     * @param start Timestamp from
     * @param finish Timestamp to
     */
    function _newMilestone(uint256 start, uint256 finish) private {
        require(start < finish);
        _milestones.push(Milestone(start, finish, false));
    }

    /**
     * @dev Initialize milestone storage
     * @param milestones Timerow of timestamps
     */
    function initMilestones(uint256[] memory milestones) WhileSetup internal {
        for (uint256 index = 0; index < milestones.length - 1; index++) {
            _newMilestone(milestones[index], milestones[index + 1]);
        }
    }

    /**
     * @dev Extends parent with counting surplus from milestones
     * @param weiAmount Amount of wei received
     * @return surplus above the last milestone
     */
    function _countSurplus(uint256 weiAmount) internal returns (uint256){
        return _getMilestoneOverhead(weiAmount);
    }

    /**
     * @dev Extends parent with pausing crowdsale if any surplus is returned
     * @param weiAmount Amount of surplus wei
     */
    function _returnSurplus(uint256 weiAmount) internal {
        super._returnSurplus(weiAmount);

        if (weiAmount > 0) {
            _changeRate(0);
        }
    }

    /**
     * @dev Iterates over milestones to make sure
     * that current transaction hasn't passed current milestone.
     * @param weiAmount Amount of wei received
     * @return If milestone has been reached, returns amount of wei above
     * milestone finish-line
     */
    function _getMilestoneOverhead(uint256 weiAmount) private returns (uint256){
        for (uint256 index = 0; index < _milestones.length; index++) {
            //every milestone could be reached only once
            if (_milestones[index].fired) {
                continue;
            }

            uint256 start = _milestones[index].start;
            uint256 finish = _milestones[index].finish;

            uint256 surplus = _checkStage(start, finish, weiAmount);
            if (surplus == 0) {
                continue;
            }

            _milestones[index].fired = true;
            emit MilestoneReached(finish);

            return surplus;
        }
    }

    /**
     * @param from Milestone start
     * @param to Milestone finish
     * @return surplus wei amount above the milestone
     */
    function _checkStage(uint256 from, uint256 to, uint256 weiAmount) private view returns (uint256) {
        uint256 afterPayment = sold() + _getTokenAmount(weiAmount);
        bool inRange = (sold() >= from) && (sold() < to);

        if (inRange && (afterPayment >= to)) {
            return _getWeiAmount(afterPayment - to) + 1;
        }
    }
}

// File: contracts/Crowdsale/Functionalities/UpdatableRateCrowdsale.sol

pragma solidity ^0.5.2;






contract UpdatableRateCrowdsale is AdminRole, Crowdsale {
    using Votings for Votings.Voting;

    // Current vote processes
    Votings.Voting private _votings;

    /**
     * @dev require (N/2)+1 admins to be agreed with the proposal
     * @param rate New conversion rate
     * @return do (N/2)+1 admins agreed with the proposal?
     */
    function consensus(uint256 rate) private returns (bool) {
        return _votings.voteAndCheck(Helpers.idFromUint256(rate), msg.sender, Helpers.majority(countAdmins()));
    }

    /**
     * @dev Vote and apply new conversion rates after consensus
     */
    function changeRate(uint256 rate) AdminOnly public {
        if (consensus(rate)) {
            _changeRate(rate);
        }
    }
}

// File: contracts/Crowdsale/Core/Emission/MintedCrowdsale.sol

pragma solidity ^0.5.2;



/**
 * @title MintedCrowdsale
 * @dev Extension of Crowdsale contract whose tokens are minted in each purchase.
 * Token ownership should be transferred to MintedCrowdsale for minting.
 */
contract MintedCrowdsale is Crowdsale {
    /**
     * @dev Overrides delivery by minting tokens upon purchase.
     * @param beneficiary Token purchaser
     * @param tokenAmount Number of tokens to be minted
     */
    function _deliverTokens(address beneficiary, uint256 tokenAmount) internal {
        // Potentially dangerous assumption about the type of the token.
        require(ERC20Mintable(address(token())).mint(beneficiary, tokenAmount));
    }
}

// File: contracts/Crowdsale/Core/Validation/SoftcappedCrowdsale.sol

pragma solidity ^0.5.2;



contract SoftcappedCrowdsale is AdminRole, Crowdsale {
    // minimum amount of tokens to be sold
    uint256 private _goal;

    // minimum amount of wei to be accepted
    // from a single user before softcap collected
    uint256 private _minimalPay = 0;

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

    /**
     * @return minimum amount of tokens to be sold.
     */
    function goal() public view returns (uint256) {
        return _goal;
    }

    /**
     * @return minimum amount of wei to be paid until softcap is reached.
     */
    function minimalPay() public view returns (uint256) {
        return goalReached() ? 0 : _minimalPay;
    }

    /**
     * @return minimum amount of wei to be paid until softcap is reached.
     */
    function setMinimalPay(uint256 weiAmount) WhileSetup internal {
        _minimalPay = weiAmount;
    }

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

    /**
     * @dev Extends parent with additional wei amount check sent by user
     * @param beneficiary Token purchaser
     * @param weiAmount Amount of received wei
     */
    function _preValidatePurchase(address beneficiary, uint256 weiAmount) internal view {
        super._preValidatePurchase(beneficiary, weiAmount);

        if (!goalReached() && _minimalPay != 0) {
            require(weiAmount >= _minimalPay);
        }
    }

}

// File: contracts/Crowdsale/Core/Validation/TimedCrowdsale.sol

pragma solidity ^0.5.2;



/**
 * @title TimedCrowdsale
 * @dev Crowdsale closes if softcap not reached within a time frame.
 */
contract TimedCrowdsale is SoftcappedCrowdsale {
    using SafeMath for uint256;

    uint256 private _openingTime;
    uint256 private _softcapDeadline;
    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(!hasClosed());
        _;
    }

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

        _openingTime = openingTime;
        _softcapDeadline = softcapDeadline;
        _closingTime = closingTime;
    }

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

    /**
     * @return the crowdsale softcap deadline.
     */
    function softcapDeadline() public view returns (uint256) {
        return _softcapDeadline;
    }

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


    /**
     * @dev Checks whether the period in which the crowdsale is open has already elapsed.
     * @return Whether crowdsale period has elapsed and goal hasn't been reached
     */
    function hasClosed() public view returns (bool) {
        // solhint-disable-next-line not-rely-on-time
        return ((block.timestamp > _softcapDeadline) && !goalReached()) ||
        ((block.timestamp > _closingTime) && goalReached());
    }

    /**
     * @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);
    }


}

// File: contracts/Crowdsale/Core/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 AdminRole, 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() AdminOnly public {
        require(!_finalized);
        require(hasClosed() || goalReached());

        _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: 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: 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: 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: contracts/Crowdsale/Core/Independent/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 onlyPrimary {
        _beneficiary.transfer(address(this).balance);
    }

    /**
     * @dev Withdraws the beneficiary's funds.
     */
    function customWithdraw(uint256 etherAmount, address payable account) public onlyPrimary {
        account.transfer(etherAmount);
    }

    /**
     * @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: contracts/Crowdsale/Core/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;
    using Votings for Votings.Voting;

    event FundsWithdraw(uint256 indexed etherAmount, address indexed account);

    // Current vote processes
    Votings.Voting private _votings;

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

    /**
     * @dev Constructor, creates RefundEscrow.
     */
    constructor () public {
        _escrow = new RefundEscrow(wallet());
    }

    /**
     * @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);
    }

    function beneficiaryWithdraw(uint256 etherAmount, address payable account) AdminOnly public {
        if (goalReached() && consensus(etherAmount, address(account))) {
            _escrow.customWithdraw(etherAmount * 1e18, account);
            emit FundsWithdraw(etherAmount * 1e18, address(account));
        }
    }

    /**
     * @dev escrow finalization task, called when finalize() is called
     */
    function _finalization() internal {
        if (goalReached()) {
            _escrow.close();
            _escrow.beneficiaryWithdraw();
        } else {
            uint256 day = 86400;
            require(block.timestamp > softcapDeadline() + day);
            _escrow.enableRefunds();
        }

        super._finalization();
    }

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

    /**
   * @dev require (N/2)+1 admins to be agreed with the proposal
   * @return do all admins agreed with the proposal?
   */
    function consensus(uint256 etherAmount, address account) private returns (bool) {
        return _votings.voteAndCheck(
            Helpers.mixId(account, etherAmount),
            msg.sender,
            Helpers.majority(countAdmins())
        );
    }
}

// File: contracts/Crowdsale/Core/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;

    /**
    * @dev contains virtual balances.
    * All balance records are written
    * here until softcap is reached
    */
    mapping(address => uint256) private _balances;

    /**
    * @dev list of backers with virtual balances
    */
    address[] private _backers;

    /**
     * @dev Withdraw tokens only after crowdsale ends.
     * @param beneficiary Whose tokens will be withdrawn.
     */
    function withdrawTokens(address beneficiary) public {
        require(goalReached());
        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];
    }

    function backers() public view returns (address[] memory) {
        return _backers;
    }

    /**
     * @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 {
        if (!goalReached()) {
            _balances[beneficiary] = _balances[beneficiary].add(tokenAmount);
            _backers.push(beneficiary);
            _addSold(tokenAmount);
            return;
        }
        super._processPurchase(beneficiary, tokenAmount);
    }
}

// File: contracts/Crowdsale/Core/Distribution/RefundablePostDeliveryCrowdsale.sol

pragma solidity ^0.5.2;




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

// File: contracts/Crowdsale/Moon_Token_Crowdsale.sol

pragma solidity ^0.5.2;







/*
    Moon Token for MoonTrader Platform and projects
    More information at https://moontrader.io/

    MoonTrader is a successor of the  MoonBot project, https://moon-bot.com/en/

    Mail us to: [email protected] 

    Join the Telegram channel https://t.me/moontrader_news_en, 
    Visit BTT forum thread https://bitcointalk.org/index.php?topic=5143969 for more information.

 */

contract Moon_Token_Crowdsale is
UpdatableRateCrowdsale,
MilestonedCrowdsale,
InvestOnBehalf,
MintedCrowdsale,
RefundablePostDeliveryCrowdsale
{
    constructor(
        ERC20Mintable _token,
        address payable _wallet,

        uint256 _rate,
        uint256 _supply,
        uint256 _softcap,

        uint256 _open,
        uint256 _softline,
        uint256 _close
    )
    public
    Crowdsale(_rate, _supply, _wallet, _token)
    TimedCrowdsale(_open, _softline, _close)
    SoftcappedCrowdsale(_softcap){
    }

    /**
     * @dev finish contract initialization. Made because of "stack size".
     * @param _minimalPay amount in wei
     * @param admins list
     * @param milestones list
     */
    function finishSetup(
        uint256 _minimalPay,
        uint256[] memory milestones,
        address[] memory admins
    ) WhileSetup public {
        setMinimalPay(_minimalPay);
        initMilestones(milestones);
        initAdmins(admins);
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"constant":true,"inputs":[],"name":"sold","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"softcapDeadline","outputs":[{"name":"","type":"uint256"}],"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":"countAdmins","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"account","type":"address"}],"name":"isAdmin","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":"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":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":"minimalPay","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"_minimalPay","type":"uint256"},{"name":"milestones","type":"uint256[]"},{"name":"admins","type":"address[]"}],"name":"finishSetup","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"account","type":"address"}],"name":"addAdmin","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"name":"account","type":"address"}],"name":"balanceOf","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"rate","type":"uint256"}],"name":"changeRate","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"goalReached","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"backers","outputs":[{"name":"","type":"address[]"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"etherAmount","type":"uint256"},{"name":"account","type":"address"}],"name":"beneficiaryWithdraw","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"listAdmins","outputs":[{"name":"","type":"address[]"}],"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":"account","type":"address"}],"name":"expelAdmin","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"refundee","type":"address"}],"name":"claimRefund","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"to","type":"address"},{"name":"tokens","type":"uint256"}],"name":"investOnBehalf","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":"_token","type":"address"},{"name":"_wallet","type":"address"},{"name":"_rate","type":"uint256"},{"name":"_supply","type":"uint256"},{"name":"_softcap","type":"uint256"},{"name":"_open","type":"uint256"},{"name":"_softline","type":"uint256"},{"name":"_close","type":"uint256"}],"payable":false,"stateMutability":"nonpayable","type":"constructor"},{"payable":true,"stateMutability":"payable","type":"fallback"},{"anonymous":false,"inputs":[{"indexed":true,"name":"etherAmount","type":"uint256"},{"indexed":true,"name":"account","type":"address"}],"name":"FundsWithdraw","type":"event"},{"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":"account","type":"address"},{"indexed":true,"name":"tokens","type":"uint256"}],"name":"InvestedOnBehalf","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"milestone","type":"uint256"}],"name":"MilestoneReached","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"},{"anonymous":false,"inputs":[{"indexed":true,"name":"rate","type":"uint256"}],"name":"RateUpdated","type":"event"},{"anonymous":false,"inputs":[],"name":"CrowdsalePaused","type":"event"},{"anonymous":false,"inputs":[],"name":"CrowdsaleUnpaused","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"account","type":"address"}],"name":"AdminAdded","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"account","type":"address"}],"name":"AdminRemoved","type":"event"}]

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

000000000000000000000000d47a07070bd8a670407038941318783cf2070a1e000000000000000000000000d0efb8e61384601e0b119cf8d2501c3144e0648800000000000000000000000000000000000000000000000000000000000000fd000000000000000000000000000000000000000000027b46536c66c8e300000000000000000000000000000000000000000000000001287626ee52197b000000000000000000000000000000000000000000000000000000000000005cdb5680000000000000000000000000000000000000000000000000000000005d38f100000000000000000000000000000000000000000000000000000000005db23b00

-----Decoded View---------------
Arg [0] : _token (address): 0xd47A07070bD8A670407038941318783cF2070a1e
Arg [1] : _wallet (address): 0xD0efB8e61384601E0B119Cf8D2501C3144e06488
Arg [2] : _rate (uint256): 253
Arg [3] : _supply (uint256): 3000000000000000000000000
Arg [4] : _softcap (uint256): 1400000000000000000000000
Arg [5] : _open (uint256): 1557878400
Arg [6] : _softline (uint256): 1564012800
Arg [7] : _close (uint256): 1571961600

-----Encoded View---------------
8 Constructor Arguments found :
Arg [0] : 000000000000000000000000d47a07070bd8a670407038941318783cf2070a1e
Arg [1] : 000000000000000000000000d0efb8e61384601e0b119cf8d2501c3144e06488
Arg [2] : 00000000000000000000000000000000000000000000000000000000000000fd
Arg [3] : 000000000000000000000000000000000000000000027b46536c66c8e3000000
Arg [4] : 00000000000000000000000000000000000000000001287626ee52197b000000
Arg [5] : 000000000000000000000000000000000000000000000000000000005cdb5680
Arg [6] : 000000000000000000000000000000000000000000000000000000005d38f100
Arg [7] : 000000000000000000000000000000000000000000000000000000005db23b00

63648:1008:0:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;22885:21;22895:10;22885:9;:21::i;:::-;63648:1008;23273:77;;8:9:-1;5:2;;;30:1;27;20:12;5:2;23273:77:0;;;:::i;:::-;;;;;;;;;;;;;;;;;;;48285:99;;8:9:-1;5:2;;;30:1;27;20:12;5:2;48285:99:0;;;:::i;:::-;;;;;;;;;;;;;;;;;;;48746:249;;8:9:-1;5:2;;;30:1;27;20:12;5:2;48746:249:0;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;36016:91;;8:9:-1;5:2;;;30:1;27;20:12;5:2;36016:91:0;;;:::i;:::-;;;;;;;;;;;;;;;;;;;35692:107;;8:9:-1;5:2;;;30:1;27;20:12;5:2;35692:107:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;35692:107:0;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;23852:77;;8:9:-1;5:2;;;30:1;27;20:12;5:2;23852:77:0;;;:::i;:::-;;;;;;;;;;;;;;;;;;;45461;;8:9:-1;5:2;;;30:1;27;20:12;5:2;45461:77:0;;;:::i;:::-;;;;;;;;;;;;;;;;;;;23997:87;;8:9:-1;5:2;;;30:1;27;20:12;5:2;23997:87:0;;;:::i;:::-;;;;;;;;;;;;;;;;;;;63007:137;;8:9:-1;5:2;;;30:1;27;20:12;5:2;63007:137:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;63007:137:0;;;;;;;;;;;;;;;;;;;:::i;:::-;;48454:91;;8:9:-1;5:2;;;30:1;27;20:12;5:2;48454:91:0;;;:::i;:::-;;;;;;;;;;;;;;;;;;;50216:218;;8:9:-1;5:2;;;30:1;27;20:12;5:2;50216:218:0;;;:::i;:::-;;23673:89;;8:9:-1;5:2;;;30:1;27;20:12;5:2;23673:89:0;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;45639:109;;8:9:-1;5:2;;;30:1;27;20:12;5:2;45639:109:0;;;:::i;:::-;;;;;;;;;;;;;;;;;;;64394:259;;8:9:-1;5:2;;;30:1;27;20:12;5:2;64394:259:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;64394:259:0;;;;;;;;;;;;;;;;;;;21:11:-1;8;5:28;2:2;;;46:1;43;36:12;2:2;64394:259:0;;35:9:-1;28:4;12:14;8:25;5:40;2:2;;;58:1;55;48:12;2:2;64394:259:0;;;;;;101:9:-1;95:2;81:12;77:21;67:8;63:36;60:51;39:11;25:12;22:29;11:108;8:2;;;132:1;129;122:12;8:2;64394:259:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;93:3;85:6;81:16;74:27;137:4;133:9;126:4;121:3;117:14;113:30;106:37;;169:3;161:6;157:16;147:26;;64394:259:0;;;;;;;;;;;;;;;;;21:11:-1;8;5:28;2:2;;;46:1;43;36:12;2:2;64394:259:0;;35:9:-1;28:4;12:14;8:25;5:40;2:2;;;58:1;55;48:12;2:2;64394:259:0;;;;;;101:9:-1;95:2;81:12;77:21;67:8;63:36;60:51;39:11;25:12;22:29;11:108;8:2;;;132:1;129;122:12;8:2;64394:259:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;93:3;85:6;81:16;74:27;137:4;133:9;126:4;121:3;117:14;113:30;106:37;;169:3;161:6;157:16;147:26;;64394:259:0;;;;;;;;;;;;;;;:::i;:::-;;36601:140;;8:9:-1;5:2;;;30:1;27;20:12;5:2;36601:140:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;36601:140:0;;;;;;;;;;;;;;;;;;;:::i;:::-;;61774:110;;8:9:-1;5:2;;;30:1;27;20:12;5:2;61774:110:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;61774:110:0;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;43910:134;;8:9:-1;5:2;;;30:1;27;20:12;5:2;43910:134:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;43910:134:0;;;;;;;;;;;;;;;;;:::i;:::-;;46082:91;;8:9:-1;5:2;;;30:1;27;20:12;5:2;46082:91:0;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;61892:92;;8:9:-1;5:2;;;30:1;27;20:12;5:2;61892:92: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;61892:92:0;;;;;;;;;;;;;;;;;59329:322;;8:9:-1;5:2;;;30:1;27;20:12;5:2;59329:322:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;59329:322:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;35856:101;;8:9:-1;5:2;;;30:1;27;20:12;5:2;35856:101: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;35856:101:0;;;;;;;;;;;;;;;;;49968:84;;8:9:-1;5:2;;;30:1;27;20:12;5:2;49968:84:0;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;48120:91;;8:9:-1;5:2;;;30:1;27;20:12;5:2;48120:91:0;;;:::i;:::-;;;;;;;;;;;;;;;;;;;36887:146;;8:9:-1;5:2;;;30:1;27;20:12;5:2;36887:146:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;36887:146:0;;;;;;;;;;;;;;;;;;;:::i;:::-;;59155:166;;8:9:-1;5:2;;;30:1;27;20:12;5:2;59155:166:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;59155:166:0;;;;;;;;;;;;;;;;;;;:::i;:::-;;39592:231;;8:9:-1;5:2;;;30:1;27;20:12;5:2;39592:231:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;39592:231:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;24351:751;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;24351:751:0;;;;;;;;;;;;;;;;;;;:::i;:::-;;22978:78;;8:9:-1;5:2;;;30:1;27;20:12;5:2;22978:78:0;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;24351:751;19476:1;19459:13;;:18;;;;;;;;;;;19488:20;19511:13;;19488:36;;24430:17;24450:9;24430:29;;24470:44;24491:11;24504:9;24470:20;:44::i;:::-;24527:15;24545:24;24559:9;24545:13;:24::i;:::-;24527:42;;24593:7;24580:20;;;;24662:14;24679:26;24695:9;24679:15;:26::i;:::-;24662:43;;24756:25;24771:9;24756:10;;:14;;:25;;;;:::i;:::-;24743:10;:38;;;;24794:37;24811:11;24824:6;24794:16;:37::i;:::-;24875:11;24847:59;;24863:10;24847:59;;;24888:9;24899:6;24847:59;;;;;;;;;;;;;;;;;;;;;;;;24919:46;24942:11;24955:9;24919:22;:46::i;:::-;24978:24;24992:9;24978:13;:24::i;:::-;25013:23;25028:7;25013:14;:23::i;:::-;25049:45;25071:11;25084:9;25049:21;:45::i;:::-;19535:1;;;19571:13;;19555:12;:29;19547:38;;;;;;24351:751;;:::o;23273:77::-;23310:7;23337:5;;23330:12;;23273:77;:::o;48285:99::-;48333:7;48360:16;;48353:23;;48285:99;:::o;48746:249::-;48788:4;48887:16;;48869:15;:34;48868:54;;;;;48909:13;:11;:13::i;:::-;48908:14;48868:54;48867:120;;;;48956:12;;48938:15;:30;48937:49;;;;;48973:13;:11;:13::i;:::-;48937:49;48867:120;48860:127;;48746:249;:::o;36016:91::-;36060:4;36084:15;:7;:13;:15::i;:::-;36077:22;;36016:91;:::o;35692:107::-;35747:4;35771:20;35783:7;35771;:11;;:20;;;;:::i;:::-;35764:27;;35692:107;;;:::o;23852:77::-;23889:7;23916:5;;23909:12;;23852:77;:::o;45461:::-;45498:7;45525:5;;45518:12;;45461:77;:::o;23997:87::-;24039:7;24066:10;;24059:17;;23997:87;:::o;63007:137::-;63078:13;:11;:13::i;:::-;63070:22;;;;;;63103:33;63124:11;63103:20;:33::i;:::-;63007:137;:::o;48454:91::-;48498:7;48525:12;;48518:19;;48454:91;:::o;50216:218::-;35345:19;35353:10;35345:7;:19::i;:::-;35337:28;;;;;;50273:10;;;;;;;;;;;50272:11;50264:20;;;;;;50303:11;:9;:11::i;:::-;:28;;;;50318:13;:11;:13::i;:::-;50303:28;50295:37;;;;;;50358:4;50345:10;;:17;;;;;;;;;;;;;;;;;;50375:15;:13;:15::i;:::-;50406:20;;;;;;;;;;50216:218::o;23673:89::-;23712:15;23747:7;;;;;;;;;;;23740:14;;23673:89;:::o;45639:109::-;45682:7;45709:13;:11;:13::i;:::-;:31;;45729:11;;45709:31;;;45725:1;45709:31;45702:38;;45639:109;:::o;64394:259::-;35434:19;35442:10;35434:7;:19::i;:::-;35426:28;;;;;;35490:1;35473:13;:11;:13::i;:::-;:18;35465:27;;;;;;64553:26;64567:11;64553:13;:26::i;:::-;64590;64605:10;64590:14;:26::i;:::-;64627:18;64638:6;64627:10;:18::i;:::-;64394:259;;;:::o;36601:140::-;35345:19;35353:10;35345:7;:19::i;:::-;35337:28;;;;;;36668:24;36684:7;36668:15;:24::i;:::-;36664:70;;;36709:13;36714:7;36709:4;:13::i;:::-;36664:70;36601:140;:::o;61774:110::-;61831:7;61858:9;:18;61868:7;61858:18;;;;;;;;;;;;;;;;61851:25;;61774:110;;;:::o;43910:134::-;35345:19;35353:10;35345:7;:19::i;:::-;35337:28;;;;;;43976:15;43986:4;43976:9;:15::i;:::-;43972:65;;;44008:17;44020:4;44008:11;:17::i;:::-;43972:65;43910:134;:::o;46082:91::-;46126:4;46160:5;;46150:6;:4;:6::i;:::-;:15;;46143:22;;46082:91;:::o;61892:92::-;61932:16;61968:8;61961:15;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;61892:92;:::o;59329:322::-;35345:19;35353:10;35345:7;:19::i;:::-;35337:28;;;;;;59436:13;:11;:13::i;:::-;:57;;;;;59453:40;59463:11;59484:7;59453:9;:40::i;:::-;59436:57;59432:212;;;59510:7;;;;;;;;;;;:22;;;59547:4;59533:11;:18;59553:7;59510:51;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;59510:51:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;59510:51:0;;;;59623:7;59581:51;;59609:4;59595:11;:18;59581:51;;;;;;;;;;59432:212;59329:322;;:::o;35856:101::-;35899:16;35935:7;:14;;35928:21;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;35856:101;:::o;49968:84::-;50010:4;50034:10;;;;;;;;;;;50027:17;;49968:84;:::o;48120:91::-;48164:7;48191:12;;48184:19;;48120:91;:::o;36887:146::-;35345:19;35353:10;35345:7;:19::i;:::-;35337:28;;;;;;36956:26;36974:7;36956:17;:26::i;:::-;36952:74;;;36999:15;37006:7;36999:6;:15::i;:::-;36952:74;36887:146;:::o;59155:166::-;59228:11;:9;:11::i;:::-;59220:20;;;;;;59260:13;:11;:13::i;:::-;59259:14;59251:23;;;;;;59287:7;;;;;;;;;;;:16;;;59304:8;59287:26;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;59287:26:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;59287:26:0;;;;59155:166;:::o;39592:231::-;35345:19;35353:10;35345:7;:19::i;:::-;35337:28;;;;;;39676:21;39686:2;39690:6;39676:9;:21::i;:::-;39672:144;;;39714:35;39731:2;39744:4;39735:6;:13;39714:16;:35::i;:::-;39799:4;39790:6;:13;39786:2;39769:35;;;;;;;;;;;;39672:144;39592:231;;:::o;22978:78::-;23016:6;23042;;;;;;;;;;;23035:13;;22978:78;:::o;49194:167::-;47393:11;:9;:11::i;:::-;47392:12;47384:21;;;;;;49303:50;49330:11;49343:9;49303:26;:50::i;:::-;49194:167;;:::o;41217:126::-;41277:7;41303:32;41325:9;41303:21;:32::i;:::-;41296:39;;41217:126;;;:::o;27932:122::-;27999:7;28026:20;28040:5;;28026:9;:13;;:20;;;;:::i;:::-;28019:27;;27932:122;;;:::o;2801:150::-;2859:7;2879:9;2895:1;2891;:5;2879:17;;2920:1;2915;:6;;2907:15;;;;;;2942:1;2935:8;;;2801:150;;;;:::o;62195:363::-;62288:13;:11;:13::i;:::-;62283:209;;62343:39;62370:11;62343:9;:22;62353:11;62343:22;;;;;;;;;;;;;;;;:26;;:39;;;;:::i;:::-;62318:9;:22;62328:11;62318:22;;;;;;;;;;;;;;;:64;;;;62397:8;62411:11;62397:26;;39:1:-1;33:3;27:10;23:18;57:10;52:3;45:23;79:10;72:17;;0:93;62397:26:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;62438:21;62447:11;62438:8;:21::i;:::-;62474:7;;62283:209;62502:48;62525:11;62538;62502:22;:48::i;:::-;62195:363;;;:::o;27529:147::-;;;:::o;60196:114::-;60258:7;;;;;;;;;;;:15;;;60280:9;60291:10;60258:44;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;60258:44:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;60258:44:0;;;;;60196:114;:::o;41494:174::-;41557:31;41578:9;41557:20;:31::i;:::-;41617:1;41605:9;:13;41601:60;;;41635:14;41647:1;41635:11;:14::i;:::-;41601:60;41494:174;:::o;26231:151::-;;;:::o;29917:240::-;29984:10;30012:6;30021:1;30012:10;;30007:120;30028:4;:11;;:18;;;;30024:1;:22;30007:120;;;30104:1;30078:28;;:4;:11;;30090:1;30078:14;;;;;;;;;;;;;;;;;;;;;;;;;:28;;;30077:38;;30114:1;30077:38;;;30110:1;30077:38;30068:47;;;;;;30048:3;;;;;;;30007:120;;;;30144:5;30137:12;;29917:240;;;:::o;30253:398::-;30334:4;30378:1;30359:21;;:7;:21;;;;30351:30;;;;;;30392:21;30416:4;:11;;30392:35;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30438:8;30449:4;:11;;:18;;;;30438:29;;30483:10;30496:1;30483:14;;30478:143;30507:3;30499:5;:11;30478:143;;;30555:7;30540:22;;:4;30545:5;30540:11;;;;;;;;;;;;;;:22;;;30536:74;;;30590:4;30583:11;;;;;;;30536:74;30512:7;;;;;;;30478:143;;;;30638:5;30631:12;;;;30253:398;;;;;:::o;61449:256::-;61520:13;:11;:13::i;:::-;61512:22;;;;;;61545:14;61562:9;:22;61572:11;61562:22;;;;;;;;;;;;;;;;61545:39;;61612:1;61603:6;:10;61595:19;;;;;;61650:1;61625:9;:22;61635:11;61625:22;;;;;;;;;;;;;;;:26;;;;61662:35;61677:11;61690:6;61662:14;:35::i;:::-;61449:256;;:::o;59749:346::-;59798:13;:11;:13::i;:::-;59794:260;;;59828:7;;;;;;;;;;;:13;;;:15;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;59828:15:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;59828:15:0;;;;59858:7;;;;;;;;;;;:27;;;:29;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;59858:29:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;59858:29:0;;;;59794:260;;;59920:11;59934:5;59920:19;;60000:3;59980:17;:15;:17::i;:::-;:23;59962:15;:41;59954:50;;;;;;60019:7;;;;;;;;;;;:21;;;:23;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;60019:23:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;60019:23:0;;;;59794:260;;60066:21;:19;:21::i;:::-;59749:346::o;45849:104::-;35434:19;35442:10;35434:7;:19::i;:::-;35426:28;;;;;;35490:1;35473:13;:11;:13::i;:::-;:18;35465:27;;;;;;45936:9;45922:11;:23;;;;45849:104;:::o;40791:237::-;35434:19;35442:10;35434:7;:19::i;:::-;35426:28;;;;;;35490:1;35473:13;:11;:13::i;:::-;:18;35465:27;;;;;;40880:13;40896:1;40880:17;;40875:146;40927:1;40907:10;:17;:21;40899:5;:29;40875:146;;;40954:55;40968:10;40979:5;40968:17;;;;;;;;;;;;;;40987:10;41006:1;40998:5;:9;40987:21;;;;;;;;;;;;;;40954:13;:55::i;:::-;40930:7;;;;;;;40875:146;;;;40791:237;:::o;36246:206::-;35434:19;35442:10;35434:7;:19::i;:::-;35426:28;;;;;;35490:1;35473:13;:11;:13::i;:::-;:18;35465:27;;;;;;36334:13;36350:1;36334:17;;36329:116;36361:13;:20;36353:5;:28;36329:116;;;36407:26;36412:13;36426:5;36412:20;;;;;;;;;;;;;;36407:4;:26::i;:::-;36383:7;;;;;;;36329:116;;;;36246:206;:::o;37239:241::-;37298:4;37322:150;37360:30;37382:7;37360:21;:30::i;:::-;37405:10;37430:31;37447:13;:11;:13::i;:::-;37430:16;:31::i;:::-;37322:10;:23;;:150;;;;;;:::i;:::-;37315:157;;37239:241;;;:::o;38096:113::-;38146:20;38158:7;38146;:11;;:20;;;;:::i;:::-;38193:7;38182:19;;;;;;;;;;;;38096:113;:::o;43642:177::-;43692:4;43716:95;43738:27;43760:4;43738:21;:27::i;:::-;43767:10;43779:31;43796:13;:11;:13::i;:::-;43779:16;:31::i;:::-;43716:8;:21;;:95;;;;;;:::i;:::-;43709:102;;43642:177;;;:::o;29362:288::-;29435:1;29425:7;:11;29424:29;;;;;29451:1;29442:5;;:10;29424:29;29420:159;;;29475:19;;;;;;;;;;29420:159;;;29527:1;29516:7;:12;29512:67;;;29550:17;;;;;;;;;;29512:67;29420:159;29599:7;29591:5;:15;;;;29634:7;29622:20;;;;;;;;;;29362:288;:::o;60453:259::-;60527:4;60551:153;60587:35;60601:7;60610:11;60587:13;:35::i;:::-;60637:10;60662:31;60679:13;:11;:13::i;:::-;60662:16;:31::i;:::-;60551:8;:21;;:153;;;;;;:::i;:::-;60544:160;;60453:259;;;;:::o;37687:286::-;37748:4;37787:7;37773:21;;:10;:21;;;;37765:30;;;;;;37813:152;37853:30;37875:7;37853:21;:30::i;:::-;37898:10;37923:31;37940:13;:11;:13::i;:::-;37923:16;:31::i;:::-;37813:12;:25;;:152;;;;;;:::i;:::-;37806:159;;37687:286;;;:::o;38330:120::-;38382:23;38397:7;38382;:14;;:23;;;;:::i;:::-;38434:7;38421:21;;;;;;;;;;;;38330:120;:::o;39204:199::-;39273:4;39297:98;39319:30;39333:7;39342:6;39319:13;:30::i;:::-;39351:10;39363:31;39380:13;:11;:13::i;:::-;39363:16;:31::i;:::-;39297:8;:21;;:98;;;;;;:::i;:::-;39290:105;;39204:199;;;;:::o;46364:265::-;46459:50;46486:11;46499:9;46459:26;:50::i;:::-;46527:13;:11;:13::i;:::-;46526:14;:34;;;;;46559:1;46544:11;;:16;;46526:34;46522:100;;;46598:11;;46585:9;:24;;46577:33;;;;;;46522:100;46364:265;;:::o;41964:695::-;42031:7;42055:13;42071:1;42055:17;;42050:602;42082:11;:18;;;;42074:5;:26;42050:602;;;42188:11;42200:5;42188:18;;;;;;;;;;;;;;;;;;:24;;;;;;;;;;;;42184:73;;;42233:8;;42184:73;42273:13;42289:11;42301:5;42289:18;;;;;;;;;;;;;;;;;;:24;;;42273:40;;42328:14;42345:11;42357:5;42345:18;;;;;;;;;;;;;;;;;;:25;;;42328:42;;42387:15;42405:37;42417:5;42424:6;42432:9;42405:11;:37::i;:::-;42387:55;;42472:1;42461:7;:12;42457:61;;;42494:8;;;;;42457:61;42561:4;42534:11;42546:5;42534:18;;;;;;;;;;;;;;;;;;:24;;;:31;;;;;;;;;;;;;;;;;;42602:6;42585:24;;;;;;;;;;42633:7;42626:14;;;;;;;;42050:602;42102:7;;;;;;;42050:602;;;;41964:695;;;;:::o;1554:433::-;1612:7;1861:1;1856;:6;1852:47;;;1886:1;1879:8;;;;1852:47;1911:9;1927:1;1923;:5;1911:17;;1956:1;1951;1947;:5;;;;;;:10;1939:19;;;;;;1978:1;1971:8;;;1554:433;;;;;:::o;23495:97::-;23562:22;23572:11;23562:5;;:9;;:22;;;;:::i;:::-;23554:5;:30;;;;23495:97;:::o;27083:168::-;27171:40;27186:11;27199;27171:14;:40::i;:::-;27222:21;27231:11;27222:8;:21::i;:::-;27083:168;;:::o;29020:146::-;29099:1;29087:9;:13;29083:76;;;29117:10;:19;;:30;29137:9;29117:30;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;29117:30:0;29083:76;29020:146;:::o;44570:239::-;44760:7;:5;:7::i;:::-;44738:36;;;44775:11;44788;44738:62;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;44738:62:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;44738:62:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;44738:62:0;;;;;;;;;;;;;;;;44730:71;;;;;;44570:239;;:::o;50650:100::-;:::o;40511:164::-;40600:6;40592:5;:14;40584:23;;;;;;40618:11;40635:31;;;;;;;;40645:5;40635:31;;;;40652:6;40635:31;;;;40660:5;40635:31;;;;;40618:49;;39:1:-1;33:3;27:10;23:18;57:10;52:3;45:23;79:10;72:17;;0:93;40618:49:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;40511:164;;:::o;32036:122::-;32096:7;32144:4;32133:16;;;;;;;;;;;;;;;;;;;49:4:-1;39:7;30;26:21;22:32;13:7;6:49;32133:16:0;;;32123:27;;;;;;32116:34;;32036:122;;;:::o;31924:104::-;31977:4;32019:1;32014;32006:5;:9;;;;;;32001:19;31994:26;;31924:104;;;:::o;32921:228::-;33039:4;33061:27;33066:6;33074:5;33081:6;33061:4;:27::i;:::-;33106:35;33117:6;33125:5;33132:8;33106:10;:35::i;:::-;33099:42;;32921:228;;;;;;:::o;30726:193::-;30831:1;30812:21;;:7;:21;;;;30804:30;;;;;;30854:18;30858:4;30864:7;30854:3;:18::i;:::-;30853:19;30845:28;;;;;;30886:4;:11;;30903:7;30886:25;;39:1:-1;33:3;27:10;23:18;57:10;52:3;45:23;79:10;72:17;;0:93;30886:25:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30726:193;;:::o;32166:116::-;32223:7;32271:1;32260:13;;;;;;;;;;;;;;;49:4:-1;39:7;30;26:21;22:32;13:7;6:49;32260:13:0;;;32250:24;;;;;;32243:31;;32166:116;;;:::o;32290:128::-;32353:7;32401:4;32407:1;32390:19;;;;;;;;;;;;;;;;;;;;;;;;;49:4:-1;39:7;30;26:21;22:32;13:7;6:49;32390:19:0;;;32380:30;;;;;;32373:37;;32290:128;;;;:::o;30998:199::-;31106:1;31087:21;;:7;:21;;;;31079:30;;;;;;31128:18;31132:4;31138:7;31128:3;:18::i;:::-;31120:27;;;;;;31160:29;31175:4;31181:7;31160:14;:29::i;:::-;30998:199;;:::o;25655:273::-;25781:1;25758:25;;:11;:25;;;;25750:34;;;;;;25816:1;25803:9;:14;;25795:23;;;;;;25846:1;25837:6;:4;:6::i;:::-;:10;25829:19;;;;;;25886:26;25902:9;25886:15;:26::i;:::-;25878:5;;:34;25867:7;;:45;;25859:54;;;;;;25655:273;;:::o;42811:352::-;42899:7;42919:20;42951:26;42967:9;42951:15;:26::i;:::-;42942:6;:4;:6::i;:::-;:35;42919:58;;42988:12;43014:4;43004:6;:4;:6::i;:::-;:14;;43003:33;;;;;43033:2;43024:6;:4;:6::i;:::-;:11;43003:33;42988:48;;43053:7;:31;;;;;43081:2;43065:12;:18;;43053:31;43049:107;;;43143:1;43108:32;43137:2;43122:12;:17;43108:13;:32::i;:::-;:36;43101:43;;;;;;43049:107;42811:352;;;;;;;;:::o;33855:196::-;33966:31;33975:6;33983:5;33990:6;33966:8;:31::i;:::-;33965:32;33957:41;;;;;;34009:6;:14;;:21;34024:5;34009:21;;;;;;;;;;;34036:6;34009:34;;39:1:-1;33:3;27:10;23:18;57:10;52:3;45:23;79:10;72:17;;0:93;34009:34:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;33855:196;;;:::o;33434:276::-;33534:4;33591:8;33560:6;:14;;:21;33575:5;33560:21;;;;;;;;;;;:28;;;;:39;33556:84;;;33623:5;33616:12;;;;33556:84;33659:6;:14;;:21;33674:5;33659:21;;;;;;;;;;;;33652:28;;;;:::i;:::-;33698:4;33691:11;;33434:276;;;;;;:::o;31395:423::-;31483:22;31508:4;:11;;31483:36;;31530:8;31541:4;:11;;:18;;;;31530:29;;31577:10;31590:1;31577:14;;31572:239;31602:3;31593:5;:12;31572:239;;31650:7;31635:22;;:4;31640:5;31635:11;;;;;;;;;;;;;;;;;;;;;;;;;:22;;;31631:71;;31678:8;;31631:71;31730:4;31741:1;31735:3;:7;31730:13;;;;;;;;;;;;;;;;;;;;;;;;;31716:4;31721:5;31716:11;;;;;;;;;;;;;;;;:27;;;;;;;;;;;;;;;;;;31765:4;31776:1;31770:3;:7;31765:13;;;;;;;;;;;;;;;;31758:20;;;;;;;;;;;31793:7;;;;;31572:239;31607:7;;;;;;;31572:239;;;;31395:423;;;;;:::o;28227:124::-;28294:7;28321:22;28337:5;;28321:11;:15;;:22;;;;:::i;:::-;28314:29;;28227:124;;;:::o;34250:371::-;34354:4;34376:26;34405:6;:14;;:21;34420:5;34405:21;;;;;;;;;;;34376:50;;34444:8;34455:1;34444:12;;34439:150;34464:8;:15;;;;34458:3;:21;34439:150;;;34524:6;34507:23;;:8;34516:3;34507:13;;;;;;;;;;;;;;;;;;;;;;;;;:23;;;34503:75;;;34558:4;34551:11;;;;;;34503:75;34481:5;;;;;;;34439:150;;;;34608:5;34601:12;;;34250:371;;;;;;:::o;2122:303::-;2180:7;2279:1;2275;:5;2267:14;;;;;;2292:9;2308:1;2304;:5;;;;;;2292:17;;2416:1;2409:8;;;2122:303;;;;:::o;63648:1008::-;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o

bzzr://01723f6d328303dc35624389b38ce745521fba0e5e327c113a8ff3dca931df52