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)
• 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 Ownable
•    - function owner()
•    - function isOwner()
•    - function renounceOwnership()
•    - function transferOwnership(address ne ...
•    - function _transferOwnership(address n ...
•  contract TokenVesting is Ownable *
•    - function beneficiary()
•    - function cliff()
•    - function start()
•    - function duration()
•    - function revocable()
•    - function released(address token)
•    - function revoked(address token)
•    - function release(IERC20 token)
•    - function revoke(IERC20 token)
•    - function _releasableAmount(IERC20 tok ...
•    - function _vestedAmount(IERC20 token)

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2020-11-01
*/

// 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/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/ownership/Ownable.sol

pragma solidity ^0.5.2;

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

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

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

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

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

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

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

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

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

// File: openzeppelin-solidity/contracts/drafts/TokenVesting.sol

pragma solidity ^0.5.2;




/**
 * @title TokenVesting
 * @dev A token holder contract that can release its token balance gradually like a
 * typical vesting scheme, with a cliff and vesting period. Optionally revocable by the
 * owner.
 */
contract TokenVesting is Ownable {
    // The vesting schedule is time-based (i.e. using block timestamps as opposed to e.g. block numbers), and is
    // therefore sensitive to timestamp manipulation (which is something miners can do, to a certain degree). Therefore,
    // it is recommended to avoid using short time durations (less than a minute). Typical vesting schemes, with a
    // cliff period of a year and a duration of four years, are safe to use.
    // solhint-disable not-rely-on-time

    using SafeMath for uint256;
    using SafeERC20 for IERC20;

    event TokensReleased(address token, uint256 amount);
    event TokenVestingRevoked(address token);

    // beneficiary of tokens after they are released
    address private _beneficiary;

    // Durations and timestamps are expressed in UNIX time, the same units as block.timestamp.
    uint256 private _cliff;
    uint256 private _start;
    uint256 private _duration;

    bool private _revocable;

    mapping (address => uint256) private _released;
    mapping (address => bool) private _revoked;

    /**
     * @dev Creates a vesting contract that vests its balance of any ERC20 token to the
     * beneficiary, gradually in a linear fashion until start + duration. By then all
     * of the balance will have vested.
     * @param beneficiary address of the beneficiary to whom vested tokens are transferred
     * @param cliffDuration duration in seconds of the cliff in which tokens will begin to vest
     * @param start the time (as Unix time) at which point vesting starts
     * @param duration duration in seconds of the period in which the tokens will vest
     * @param revocable whether the vesting is revocable or not
     */
    constructor (address beneficiary, uint256 start, uint256 cliffDuration, uint256 duration, bool revocable) public {
        require(beneficiary != address(0));
        require(cliffDuration <= duration);
        require(duration > 0);
        require(start.add(duration) > block.timestamp);

        _beneficiary = beneficiary;
        _revocable = revocable;
        _duration = duration;
        _cliff = start.add(cliffDuration);
        _start = start;
    }

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

    /**
     * @return the cliff time of the token vesting.
     */
    function cliff() public view returns (uint256) {
        return _cliff;
    }

    /**
     * @return the start time of the token vesting.
     */
    function start() public view returns (uint256) {
        return _start;
    }

    /**
     * @return the duration of the token vesting.
     */
    function duration() public view returns (uint256) {
        return _duration;
    }

    /**
     * @return true if the vesting is revocable.
     */
    function revocable() public view returns (bool) {
        return _revocable;
    }

    /**
     * @return the amount of the token released.
     */
    function released(address token) public view returns (uint256) {
        return _released[token];
    }

    /**
     * @return true if the token is revoked.
     */
    function revoked(address token) public view returns (bool) {
        return _revoked[token];
    }

    /**
     * @notice Transfers vested tokens to beneficiary.
     * @param token ERC20 token which is being vested
     */
    function release(IERC20 token) public {
        uint256 unreleased = _releasableAmount(token);

        require(unreleased > 0);

        _released[address(token)] = _released[address(token)].add(unreleased);

        token.safeTransfer(_beneficiary, unreleased);

        emit TokensReleased(address(token), unreleased);
    }

    /**
     * @notice Allows the owner to revoke the vesting. Tokens already vested
     * remain in the contract, the rest are returned to the owner.
     * @param token ERC20 token which is being vested
     */
    function revoke(IERC20 token) public onlyOwner {
        require(_revocable);
        require(!_revoked[address(token)]);

        uint256 balance = token.balanceOf(address(this));

        uint256 unreleased = _releasableAmount(token);
        uint256 refund = balance.sub(unreleased);

        _revoked[address(token)] = true;

        token.safeTransfer(owner(), refund);

        emit TokenVestingRevoked(address(token));
    }

    /**
     * @dev Calculates the amount that has already vested but hasn't been released yet.
     * @param token ERC20 token which is being vested
     */
    function _releasableAmount(IERC20 token) private view returns (uint256) {
        return _vestedAmount(token).sub(_released[address(token)]);
    }

    /**
     * @dev Calculates the amount that has already vested.
     * @param token ERC20 token which is being vested
     */
    function _vestedAmount(IERC20 token) private view returns (uint256) {
        uint256 currentBalance = token.balanceOf(address(this));
        uint256 totalBalance = currentBalance.add(_released[address(token)]);

        if (block.timestamp < _cliff) {
            return 0;
        } else if (block.timestamp >= _start.add(_duration) || _revoked[address(token)]) {
            return totalBalance;
        } else {
            return totalBalance.mul(block.timestamp.sub(_start)).div(_duration);
        }
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"beneficiary","type":"address"},{"internalType":"uint256","name":"start","type":"uint256"},{"internalType":"uint256","name":"cliffDuration","type":"uint256"},{"internalType":"uint256","name":"duration","type":"uint256"},{"internalType":"bool","name":"revocable","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"token","type":"address"}],"name":"TokenVestingRevoked","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"token","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"TokensReleased","type":"event"},{"constant":true,"inputs":[],"name":"beneficiary","outputs":[{"internalType":"address","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"cliff","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"duration","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"isOwner","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"contract IERC20","name":"token","type":"address"}],"name":"release","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"released","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[],"name":"renounceOwnership","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"revocable","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"contract IERC20","name":"token","type":"address"}],"name":"revoke","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"revoked","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"start","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"}]

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

10055:5515:0:-;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;10055:5515:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;12839:85;;;:::i;:::-;;;;;;;;;;;;;;;;12525:79;;;:::i;13574:337::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;13574:337:0;-1:-1:-1;;;;;13574:337:0;;:::i;:::-;;12355:91;;;:::i;:::-;;;;-1:-1:-1;;;;;12355:91:0;;;;;;;;;;;;;;8965:140;;;:::i;14138:445::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;14138:445:0;-1:-1:-1;;;;;14138:445:0;;:::i;13000:84::-;;;:::i;:::-;;;;;;;;;;;;;;;;;;8175:79;;;:::i;8510:92::-;;;:::i;13160:105::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;13160:105:0;-1:-1:-1;;;;;13160:105:0;;:::i;12683:79::-;;;:::i;9282:109::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;9282:109:0;-1:-1:-1;;;;;9282:109:0;;:::i;13337:100::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;13337:100:0;-1:-1:-1;;;;;13337:100:0;;:::i;12839:85::-;12907:9;;12839:85;:::o;12525:79::-;12590:6;;12525:79;:::o;13574:337::-;13623:18;13644:24;13662:5;13644:17;:24::i;:::-;13623:45;;13702:1;13689:10;:14;13681:23;;;;;;-1:-1:-1;;;;;13745:25:0;;;;;;:9;:25;;;;;;:41;;13775:10;13745:41;:29;:41;:::i;:::-;-1:-1:-1;;;;;13717:25:0;;;;;;;:9;:25;;;;;:69;;;;13818:12;;13799:44;;13717:25;13818:12;13832:10;13799:44;:18;:44;:::i;:::-;13861:42;;;-1:-1:-1;;;;;13861:42:0;;;;;;;;;;;;;;;;;;;;;;;13574:337;;:::o;12355:91::-;12426:12;;-1:-1:-1;;;;;12426:12:0;12355:91;:::o;8965:140::-;8387:9;:7;:9::i;:::-;8379:18;;;;;;9064:1;9048:6;;9027:40;;-1:-1:-1;;;;;9048:6:0;;;;9027:40;;9064:1;;9027:40;9095:1;9078:19;;-1:-1:-1;;;;;;9078:19:0;;;8965:140::o;14138:445::-;8387:9;:7;:9::i;:::-;8379:18;;;;;;14204:10;;;;14196:19;;;;;;-1:-1:-1;;;;;14235:24:0;;;;;;:8;:24;;;;;;;;14234:25;14226:34;;;;;;14291:30;;;-1:-1:-1;;;14291:30:0;;14315:4;14291:30;;;;;;14273:15;;-1:-1:-1;;;;;14291:15:0;;;;;:30;;;;;;;;;;;;;;;:15;:30;;;5:2:-1;;;;30:1;27;20:12;5:2;14291:30:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;14291:30:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;14291:30:0;;-1:-1:-1;14334:18:0;14355:24;14373:5;14355:17;:24::i;:::-;14334:45;-1:-1:-1;14390:14:0;14407:23;:7;14334:45;14407:23;:11;:23;:::i;:::-;-1:-1:-1;;;;;14443:24:0;;;;;;:8;:24;;;;;:31;;-1:-1:-1;;14443:31:0;14470:4;14443:31;;;14390:40;-1:-1:-1;14487:35:0;14506:7;:5;:7::i;:::-;-1:-1:-1;;;;;14487:18:0;;;14515:6;14487:35;:18;:35;:::i;:::-;14540;;;-1:-1:-1;;;;;14540:35:0;;;;;;;;;;;;;;;8408:1;;;14138:445;:::o;13000:84::-;13066:10;;;;13000:84;:::o;8175:79::-;8213:7;8240:6;-1:-1:-1;;;;;8240:6:0;8175:79;:::o;8510:92::-;8550:4;8588:6;-1:-1:-1;;;;;8588:6:0;8574:10;:20;;8510:92::o;13160:105::-;-1:-1:-1;;;;;13241:16:0;;13214:7;13241:16;;;:9;:16;;;;;;13160:105;;;;:::o;12683:79::-;12748:6;;12683:79;:::o;9282:109::-;8387:9;:7;:9::i;:::-;8379:18;;;;;;9355:28;9374:8;9355:18;:28::i;:::-;9282:109;:::o;13337:100::-;-1:-1:-1;;;;;13414:15:0;13390:4;13414:15;;;:8;:15;;;;;;;;;13337:100::o;14753:149::-;-1:-1:-1;;;;;14868:25:0;;14816:7;14868:25;;;:9;:25;;;;;;14843:51;;:20;14886:5;14843:13;:20::i;:::-;:24;:51;:24;:51;:::i;:::-;14836:58;14753:149;-1:-1:-1;;14753:149:0:o;2400:150::-;2458:7;2490:5;;;2514:6;;;;2506:15;;;;;;2541:1;2400:150;-1:-1:-1;;;2400:150:0:o;4675:176::-;4784:58;;;-1:-1:-1;;;;;4784:58:0;;;;;;;;;;;;;;;26:21:-1;;;22:32;;;6:49;;4784:58:0;;;;;;;;25:18:-1;;61:17;;-1:-1;;;;;182:15;-1:-1;;;179:29;160:49;;4758:85:0;;4777:5;;4758:18;:85::i;:::-;4675:176;;;:::o;2162:150::-;2220:7;2253:1;2248;:6;;2240:15;;;;;;-1:-1:-1;2278:5:0;;;2162:150::o;9541:187::-;-1:-1:-1;;;;;9615:22:0;;9607:31;;;;;;9675:6;;;9654:38;;-1:-1:-1;;;;;9654:38:0;;;;9675:6;;;9654:38;;;9703:6;:17;;-1:-1:-1;;;;;;9703:17:0;-1:-1:-1;;;;;9703:17:0;;;;;;;;;;9541:187::o;15043:524::-;15147:30;;;-1:-1:-1;;;15147:30:0;;15171:4;15147:30;;;;;;15102:7;;;;-1:-1:-1;;;;;15147:15:0;;;;;:30;;;;;;;;;;;;;;:15;:30;;;5:2:-1;;;;30:1;27;20:12;5:2;15147:30:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;15147:30:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;15147:30:0;-1:-1:-1;;;;;15230:25:0;;15188:20;15230:25;;;:9;15147:30;15230:25;;;;;15147:30;;-1:-1:-1;15188:20:0;15211:45;;15147:30;;15211:45;:18;:45;:::i;:::-;15188:68;;15291:6;;15273:15;:24;15269:291;;;15321:1;15314:8;;;;;;15269:291;15374:9;;15363:6;;:21;;;:10;:21;:::i;:::-;15344:15;:40;;:68;;;-1:-1:-1;;;;;;15388:24:0;;;;;;:8;:24;;;;;;;;15344:68;15340:220;;;15436:12;-1:-1:-1;15429:19:0;;-1:-1:-1;15429:19:0;15340:220;15488:60;15538:9;;15488:45;15505:27;15525:6;;15505:15;:19;;:27;;;;:::i;:::-;15488:12;;:45;:16;:45;:::i;:::-;:49;:60;:49;:60;:::i;:::-;15481:67;;;;;;6532:887;7084:27;7092:5;-1:-1:-1;;;;;7084:25:0;;:27::i;:::-;7076:36;;;;;;7186:12;7200:23;7235:5;-1:-1:-1;;;;;7227:19:0;7247:4;7227:25;;;;;;;;;;;;;36:153:-1;66:2;61:3;58:11;36:153;;176:10;;164:23;;-1:-1;;139:12;;;;98:2;89:12;;;;114;36:153;;;274:1;267:3;263:2;259:12;254:3;250:22;246:30;315:4;311:9;305:3;299:10;295:26;356:4;350:3;344:10;340:21;389:7;380;377:20;372:3;365:33;3:399;;;7227:25:0;;;;;;;;;;;;;;;;;;;;;;;;14:1:-1;21;16:31;;;;75:4;69:11;64:16;;144:4;140:9;133:4;115:16;111:27;107:43;104:1;100:51;94:4;87:65;169:16;166:1;159:27;225:16;222:1;215:4;212:1;208:12;193:49;7:242;;16:31;36:4;31:9;;7:242;;7185:67:0;;;;7271:7;7263:16;;;;;;7296:17;;:21;7292:120;;7380:10;7369:30;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;7369:30:0;7361:39;;;;;;6532:887;;;;:::o;1153:433::-;1211:7;1455:6;1451:47;;-1:-1:-1;1485:1:0;1478:8;;1451:47;1522:5;;;1526:1;1522;:5;:1;1546:5;;;;;:10;1538:19;;;;;1721:303;1779:7;1878:1;1874;:5;1866:14;;;;;;1891:9;1907:1;1903;:5;;;;;;;1721:303;-1:-1:-1;;;;1721:303:0:o;3380:627::-;3952:20;3991:8;;;3380:627::o

bzzr://04c67e162aed04dec8565763b0a671efb456157f9d50d09c61e689665f5c816e