Contract 0xEEbeC7874f46C4452610A11FA6bE0264f7f0557F 1

/**
 *Submitted for verification at Etherscan.io on 2020-12-23
*/

// File: localhost/contracts/Config.sol

pragma solidity ^0.5.0;

contract Config {
    // function signature of "postProcess()"
    bytes4 constant POSTPROCESS_SIG = 0xc2722916;

    // Handler post-process type. Others should not happen now.
    enum HandlerType {Token, Custom, Others}
}

// File: localhost/contracts/lib/LibCache.sol

pragma solidity ^0.5.0;

library LibCache {
    function setAddress(bytes32[] storage _cache, address _input) internal {
        _cache.push(bytes32(uint256(uint160(_input))));
    }

    function set(bytes32[] storage _cache, bytes32 _input) internal {
        _cache.push(_input);
    }

    function setHandlerType(bytes32[] storage _cache, uint256 _input) internal {
        require(_input < uint96(-1), "Invalid Handler Type");
        _cache.push(bytes12(uint96(_input)));
    }

    function setSender(bytes32[] storage _cache, address _input) internal {
        require(_cache.length == 0, "cache not empty");
        setAddress(_cache, _input);
    }

    function getAddress(bytes32[] storage _cache)
        internal
        returns (address ret)
    {
        ret = address(uint160(uint256(peek(_cache))));
        _cache.pop();
    }

    function getSig(bytes32[] storage _cache) internal returns (bytes4 ret) {
        ret = bytes4(peek(_cache));
        _cache.pop();
    }

    function get(bytes32[] storage _cache) internal returns (bytes32 ret) {
        ret = peek(_cache);
        _cache.pop();
    }

    function peek(bytes32[] storage _cache)
        internal
        view
        returns (bytes32 ret)
    {
        require(_cache.length > 0, "cache empty");
        ret = _cache[_cache.length - 1];
    }

    function getSender(bytes32[] storage _cache)
        internal
        returns (address ret)
    {
        require(_cache.length > 0, "cache empty");
        ret = address(uint160(uint256(_cache[0])));
    }
}

// File: localhost/contracts/Cache.sol

pragma solidity ^0.5.0;


/// @notice A cache structure composed by a bytes32 array
contract Cache {
    using LibCache for bytes32[];

    bytes32[] cache;

    modifier isCacheEmpty() {
        require(cache.length == 0, "Cache not empty");
        _;
    }
}

// File: localhost/contracts/interface/IRegistry.sol

pragma solidity ^0.5.0;


interface IRegistry {
    function isValid(address handler) external view returns (bool result);

    function getInfo(address handler) external view returns (bytes32 info);
}

// File: @openzeppelin/contracts/utils/Address.sol

pragma solidity ^0.5.5;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following 
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // According to EIP-1052, 0x0 is the value returned for not-yet created accounts
        // and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
        // for accounts without code, i.e. `keccak256('')`
        bytes32 codehash;
        bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
        // solhint-disable-next-line no-inline-assembly
        assembly { codehash := extcodehash(account) }
        return (codehash != accountHash && codehash != 0x0);
    }

    /**
     * @dev Converts an `address` into `address payable`. Note that this is
     * simply a type cast: the actual underlying value is not changed.
     *
     * _Available since v2.4.0._
     */
    function toPayable(address account) internal pure returns (address payable) {
        return address(uint160(account));
    }

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     *
     * _Available since v2.4.0._
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "Address: insufficient balance");

        // solhint-disable-next-line avoid-call-value
        (bool success, ) = recipient.call.value(amount)("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }
}

// File: @openzeppelin/contracts/math/SafeMath.sol

pragma solidity ^0.5.0;

/**
 * @dev Wrappers over Solidity's arithmetic operations with added overflow
 * checks.
 *
 * Arithmetic operations in Solidity wrap on overflow. This can easily result
 * in bugs, because programmers usually assume that an overflow raises an
 * error, which is the standard behavior in high level programming languages.
 * `SafeMath` restores this intuition by reverting the transaction when an
 * operation overflows.
 *
 * Using this library instead of the unchecked operations eliminates an entire
 * class of bugs, so it's recommended to use it always.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");

        return c;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        return sub(a, b, "SafeMath: subtraction overflow");
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     * - Subtraction cannot overflow.
     *
     * _Available since v2.4.0._
     */
    function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b <= a, errorMessage);
        uint256 c = a - b;

        return c;
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     * - Multiplication cannot 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-contracts/pull/522
        if (a == 0) {
            return 0;
        }

        uint256 c = a * b;
        require(c / a == b, "SafeMath: multiplication overflow");

        return c;
    }

    /**
     * @dev Returns the integer division of two unsigned integers. Reverts on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return div(a, b, "SafeMath: division by zero");
    }

    /**
     * @dev Returns the integer division of two unsigned integers. Reverts with custom message on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     * - The divisor cannot be zero.
     *
     * _Available since v2.4.0._
     */
    function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        // Solidity only automatically asserts when dividing by 0
        require(b > 0, errorMessage);
        uint256 c = a / b;
        // assert(a == b * c + a % b); // There is no case in which this doesn't hold

        return c;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * Reverts when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        return mod(a, b, "SafeMath: modulo by zero");
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * Reverts with custom message when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     * - The divisor cannot be zero.
     *
     * _Available since v2.4.0._
     */
    function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b != 0, errorMessage);
        return a % b;
    }
}

// File: @openzeppelin/contracts/token/ERC20/IERC20.sol

pragma solidity ^0.5.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP. Does not include
 * the optional functions; to access them see {ERC20Detailed}.
 */
interface IERC20 {
    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the amount of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves `amount` tokens from the caller's account to `recipient`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address recipient, uint256 amount) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: 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
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 amount) external returns (bool);

    /**
     * @dev Moves `amount` tokens from `sender` to `recipient` using the
     * allowance mechanism. `amount` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);

    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);
}

// File: @openzeppelin/contracts/token/ERC20/SafeERC20.sol

pragma solidity ^0.5.0;




/**
 * @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'
        // solhint-disable-next-line max-line-length
        require((value == 0) || (token.allowance(address(this), spender) == 0),
            "SafeERC20: approve from non-zero to non-zero allowance"
        );
        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, "SafeERC20: decreased allowance below zero");
        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 not be false).
     * @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.
        // solhint-disable-next-line max-line-length
        require(address(token).isContract(), "SafeERC20: call to non-contract");

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

        if (returndata.length > 0) { // Return data is optional
            // solhint-disable-next-line max-line-length
            require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
        }
    }
}

// File: localhost/contracts/Proxy.sol

pragma solidity ^0.5.0;
pragma experimental ABIEncoderV2;






/**
 * @title The entrance of Furucombo
 * @author Ben Huang
 */
contract Proxy is Cache, Config {
    using Address for address;
    using SafeERC20 for IERC20;

    // keccak256 hash of "furucombo.handler.registry"
    // prettier-ignore
    bytes32 private constant HANDLER_REGISTRY = 0x6874162fd62902201ea0f4bf541086067b3b88bd802fac9e150fd2d1db584e19;

    constructor(address registry) public {
        bytes32 slot = HANDLER_REGISTRY;
        assembly {
            sstore(slot, registry)
        }
    }

    /**
     * @notice Direct transfer from EOA should be reverted.
     * @dev Callback function will be handled here.
     */
    function() external payable {
        require(Address.isContract(msg.sender), "Not allowed from EOA");

        // If triggered by a function call, caller should be registered in registry.
        // The function call will then be forwarded to the location registered in
        // registry.
        if (msg.data.length != 0) {
            require(_isValid(msg.sender), "Invalid caller");

            address target =
                address(bytes20(IRegistry(_getRegistry()).getInfo(msg.sender)));
            _exec(target, msg.data);
        }
    }

    /**
     * @notice Combo execution function. Including three phases: pre-process,
     * exection and post-process.
     * @param tos The handlers of combo.
     * @param datas The combo datas.
     */
    function batchExec(address[] memory tos, bytes[] memory datas)
        public
        payable
    {
        _preProcess();
        _execs(tos, datas);
        _postProcess();
    }

    /**
     * @notice The execution interface for callback function to be executed.
     * @dev This function can only be called through the handler, which makes
     * the caller become proxy itself.
     */
    function execs(address[] memory tos, bytes[] memory datas) public payable {
        require(msg.sender == address(this), "Does not allow external calls");
        require(cache.length > 0, "Cache should be initialized");
        _execs(tos, datas);
    }

    /**
     * @notice The execution phase.
     * @param tos The handlers of combo.
     * @param datas The combo datas.
     */
    function _execs(address[] memory tos, bytes[] memory datas) internal {
        require(
            tos.length == datas.length,
            "Tos and datas length inconsistent"
        );
        for (uint256 i = 0; i < tos.length; i++) {
            _exec(tos[i], datas[i]);
            // Setup the process to be triggered in the post-process phase
            _setPostProcess(tos[i]);
        }
    }

    /**
     * @notice The execution of a single cube.
     * @param _to The handler of cube.
     * @param _data The cube execution data.
     */
    function _exec(address _to, bytes memory _data)
        internal
        returns (bytes memory result)
    {
        require(_isValid(_to), "Invalid handler");
        assembly {
            let succeeded := delegatecall(
                sub(gas, 5000),
                _to,
                add(_data, 0x20),
                mload(_data),
                0,
                0
            )
            let size := returndatasize

            result := mload(0x40)
            mstore(
                0x40,
                add(result, and(add(add(size, 0x20), 0x1f), not(0x1f)))
            )
            mstore(result, size)
            returndatacopy(add(result, 0x20), 0, size)

            switch iszero(succeeded)
                case 1 {
                    revert(add(result, 0x20), size)
                }
        }
    }

    /**
     * @notice Setup the post-process.
     * @param _to The handler of post-process.
     */
    function _setPostProcess(address _to) internal {
        // If the cache length equals 1, just skip
        // If the top is a custom post-process, replace it with the handler
        // address.
        require(cache.length > 0, "cache empty");
        if (cache.length == 1) return;
        else if (cache.peek() == bytes32(bytes12(uint96(HandlerType.Custom)))) {
            cache.pop();
            // Check if the handler is already set.
            if (bytes4(cache.peek()) != 0x00000000) cache.setAddress(_to);
            cache.setHandlerType(uint256(HandlerType.Custom));
        }
    }

    /// @notice The pre-process phase.
    function _preProcess() internal isCacheEmpty {
        // Set the sender on the top of cache.
        cache.setSender(msg.sender);
    }

    /// @notice The post-process phase.
    function _postProcess() internal {
        // If the top of cache is HandlerType.Custom (which makes it being zero
        // address when `cache.getAddress()`), get the handler address and execute
        // the handler with it and the post-process function selector.
        // If not, use it as token address and send the token back to user.
        while (cache.length > 1) {
            address addr = cache.getAddress();
            if (addr == address(0)) {
                addr = cache.getAddress();
                _exec(addr, abi.encodeWithSelector(POSTPROCESS_SIG));
            } else {
                uint256 amount = IERC20(addr).balanceOf(address(this));
                if (amount > 0) IERC20(addr).safeTransfer(msg.sender, amount);
            }
        }

        // Balance should also be returned to user
        uint256 amount = address(this).balance;
        if (amount > 0) msg.sender.transfer(amount);

        // Pop the msg.sender
        cache.pop();
    }

    /// @notice Get the registry contract address.
    function _getRegistry() internal view returns (address registry) {
        bytes32 slot = HANDLER_REGISTRY;
        assembly {
            registry := sload(slot)
        }
    }

    /// @notice Check if the handler is valid in registry.
    function _isValid(address handler) internal view returns (bool result) {
        return IRegistry(_getRegistry()).isValid(handler);
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"registry","type":"address"}],"payable":false,"stateMutability":"nonpayable","type":"constructor"},{"payable":true,"stateMutability":"payable","type":"fallback"},{"constant":false,"inputs":[{"internalType":"address[]","name":"tos","type":"address[]"},{"internalType":"bytes[]","name":"datas","type":"bytes[]"}],"name":"batchExec","outputs":[],"payable":true,"stateMutability":"payable","type":"function"},{"constant":false,"inputs":[{"internalType":"address[]","name":"tos","type":"address[]"},{"internalType":"bytes[]","name":"datas","type":"bytes[]"}],"name":"execs","outputs":[],"payable":true,"stateMutability":"payable","type":"function"}]

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

000000000000000000000000846f271627b970773b235afb11fe0fcf12206c86

-----Decoded View---------------
Arg [0] : registry (address): 0x846f271627b970773b235afb11fe0fcf12206c86

-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 000000000000000000000000846f271627b970773b235afb11fe0fcf12206c86

18012:6040:0:-;;;;;;;;;;;;;;;;;;;;;;;18657:30;18676:10;18657:18;:30::i;:::-;18649:63;;;;-1:-1:-1;;;18649:63:0;;;;;;;;;;;;;;;;;18920:8;:20;18916:252;;18965:20;18974:10;18965:8;:20::i;:::-;18957:47;;;;-1:-1:-1;;;18957:47:0;;;;;;;;;19021:14;19081;:12;:14::i;:::-;-1:-1:-1;;;;;19071:33:0;;19105:10;19071:45;;;;;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;19071:45:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;19071:45:0;;;;;;;101:4:-1;97:9;90:4;84;80:15;76:31;69:5;65:43;126:6;120:4;113:20;0:138;19071:45:0;;;;;;;;;19055:63;;19021:97;;19133:23;19139:6;19147:8;;19133:23;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;81:16;;74:27;;;;-1:-1;19133:5:0;;-1:-1:-1;;;19133:23:0:i;:::-;;18916:252;;18012:6040;19395:187;;;;;;;;;:::i;19805:258::-;;;;;;;;;:::i;3308:619::-;3368:4;3836:20;;3679:66;3876:23;;;;;;:42;;-1:-1:-1;3903:15:0;;;3876:42;3868:51;3308:619;-1:-1:-1;;;;3308:619:0:o;23910:139::-;23968:11;24009:14;:12;:14::i;:::-;-1:-1:-1;;;;;23999:33:0;;24033:7;23999:42;;;;;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;23999:42:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;23999:42:0;;;;;;;101:4:-1;97:9;90:4;84;80:15;76:31;69:5;65:43;126:6;120:4;113:20;0:138;23999:42:0;;;;;;;;;23992:49;23910:139;-1:-1:-1;;23910:139:0:o;23659:183::-;18241:66;23813:11;;23786:49::o;20778:857::-;20862:19;20907:13;20916:3;20907:8;:13::i;:::-;20899:41;;;;-1:-1:-1;;;20899:41:0;;;;;;;;;21164:1;21144;21119:5;21113:12;21089:4;21082:5;21078:16;21056:3;21032:4;21027:3;21023:14;20992:188;21206:14;21252:4;21246:11;21236:21;;21367:4;21363:9;21356:4;21349;21343;21339:15;21335:26;21331:42;21323:6;21319:55;21296:4;21271:118;21418:4;21410:6;21403:20;21474:4;21471:1;21464:4;21456:6;21452:17;21437:42;21509:9;21502:17;21542:1;21537:80;;;;21495:122;;21537:80;21593:4;21586;21578:6;21574:17;21567:31;21495:122;;20960:668;;;;;;:::o;19395:187::-;19507:13;:11;:13::i;:::-;19531:18;19538:3;19543:5;19531:6;:18::i;:::-;19560:14;:12;:14::i;:::-;19395:187;;:::o;19805:258::-;19898:10;19920:4;19898:27;19890:69;;;;-1:-1:-1;;;19890:69:0;;;;;;;;;19993:1;19978:12;19970:56;;;;-1:-1:-1;;;19970:56:0;;;;;;;;;20037:18;20044:3;20049:5;20037:6;:18::i;22405:139::-;2213:5;:12;:17;2205:45;;;;-1:-1:-1;;;2205:45:0;;;;;;;;;22509:27;:5;22525:10;22509:27;:15;:27;:::i;:::-;22405:139::o;20206:412::-;20322:5;:12;20308:3;:10;:26;20286:109;;;;-1:-1:-1;;;20286:109:0;;;;;;;;;20411:9;20406:205;20430:3;:10;20426:1;:14;20406:205;;;20462:23;20468:3;20472:1;20468:6;;;;;;;;;;;;;;20476:5;20482:1;20476:8;;;;;;;;;;;;;;20462:5;:23::i;:::-;;20576;20592:3;20596:1;20592:6;;;;;;;;;;;;;;20576:15;:23::i;:::-;20442:3;;20406:205;;;;20206:412;;:::o;22593:1006::-;22958:5;:12;22973:1;-1:-1:-1;22951:429:0;;;22991:12;23006:18;:5;:16;:18::i;:::-;22991:33;-1:-1:-1;;;;;;23043:18:0;;23039:330;;23089:18;:5;:16;:18::i;:::-;23138:39;;;22:32:-1;6:49;;23138:39:0;;;;;;49:4:-1;25:18;;61:17;;-1:-1;;;;;182:15;-1:-1;;;179:29;160:49;;23082:25:0;;-1:-1:-1;23126:52:0;;23082:25;;23126:5;:52::i;:::-;;23039:330;;;23236:37;;-1:-1:-1;;;23236:37:0;;23219:14;;-1:-1:-1;;;;;23236:22:0;;;;;:37;;23267:4;;23236:37;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;23236:37:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;23236:37:0;;;;;;;101:4:-1;97:9;90:4;84;80:15;76:31;69:5;65:43;126:6;120:4;113:20;0:138;23236:37:0;;;;;;;;;23219:54;-1:-1:-1;23296:10:0;;23292:61;;23308:45;-1:-1:-1;;;;;23308:25:0;;23334:10;23346:6;23308:45;:25;:45;:::i;:::-;23039:330;;22951:429;;;;23461:21;23497:10;;23493:43;;23509:27;;:10;;:27;;;;;23529:6;;23509:27;;;;23529:6;23509:10;:27;;;;;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;23509:27:0;23493:43;23580:5;:11;;;;;;;;;;;;;;;;;;;;;;;;22593:1006;:::o;859:172::-;948:13;;:18;940:46;;;;-1:-1:-1;;;940:46:0;;;;;;;;;997:26;1008:6;1016;997:10;:26::i;21749:608::-;21980:1;21965:12;21957:40;;;;-1:-1:-1;;;21957:40:0;;;;;;;;;22012:5;:12;22028:1;22012:17;22008:342;;;22031:7;;22008:342;-1:-1:-1;;;22057:12:0;:5;:10;:12::i;:::-;:60;22053:297;;;22134:5;:11;;;;;;;;;;;;;;;;;;;;;;;;22224:12;:5;:10;:12::i;:::-;-1:-1:-1;;;;;;22217:34:0;;22213:61;;22253:21;:5;22270:3;22253:21;:16;:21;:::i;:::-;22289:49;:5;22318:18;22289:20;:49::i;:::-;21749:608;:::o;1039:187::-;1121:11;1180:12;1185:6;1180:4;:12::i;:::-;1172:21;;1150:45;;1206:6;:12;;;;;;;;;;;;;;;;;;;;;;;;1039:187;;;:::o;14669:176::-;14778:58;;14752:85;;14771:5;;-1:-1:-1;;;14801:23:0;14778:58;;14826:2;;14830:5;;14778:58;;;;;;;;-1:-1:-1;;26:21;;;22:32;6:49;;14778:58:0;;;49:4:-1;25:18;;61:17;;-1:-1;;;;;182:15;-1:-1;;;;;;14778:58:0;;;179:29:-1;;;;160:49;;;14752:18:0;:85::i;404:136::-;27:10:-1;;39:1;23:18;;45:23;;498:33:0;486:46;;;;;;;-1:-1:-1;;;;;506:24:0;;;486:46;;;404:136::o;1520:210::-;1647:13;;1610:11;;1639:41;;;;-1:-1:-1;;;1639:41:0;;;;;;;;;1704:13;;1697:6;;-1:-1:-1;;1704:17:0;;;1697:25;;;;;;;;;;;;;;1691:31;;1520:210;;;:::o;658:193::-;752:19;;;744:52;;;;-1:-1:-1;;;744:52:0;;;;;;;;;27:10:-1;;39:1;23:18;;45:23;;-1:-1;807:36:0;;;;;;;819:23;;;;;-1:-1:-1;;;;;;807:36:0;;;;658:193::o;16708:1114::-;17312:27;17320:5;-1:-1:-1;;;;;17312:25:0;;:27::i;:::-;17304:71;;;;-1:-1:-1;;;17304:71:0;;;;;;;;;17449:12;17463:23;17498:5;-1:-1:-1;;;;;17490:19:0;17510:4;17490:25;;;;;;;;;;;;;;;;;;;;;;;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;;17448:67:0;;;;17534:7;17526:52;;;;-1:-1:-1;;;17526:52:0;;;;;;;;;17595:17;;:21;17591:224;;17737:10;17726:30;;;;;;;;;;;;;;17718:85;;;;-1:-1:-1;;;17718:85:0;;;;;;;;;16708:1114;;;;:::o;5:130:-1:-;72:20;;97:33;72:20;97:33;;160:707;;277:3;270:4;262:6;258:17;254:27;244:2;;295:1;292;285:12;244:2;332:6;319:20;354:80;369:64;426:6;369:64;;;354:80;;;345:89;;451:5;476:6;469:5;462:21;506:4;498:6;494:17;484:27;;528:4;523:3;519:14;512:21;;581:6;628:3;620:4;612:6;608:17;603:3;599:27;596:36;593:2;;;645:1;642;635:12;593:2;670:1;655:206;680:6;677:1;674:13;655:206;;;738:3;760:37;793:3;781:10;760:37;;;748:50;;-1:-1;821:4;812:14;;;;840;;;;;702:1;695:9;655:206;;;659:14;237:630;;;;;;;;891:693;;1013:3;1006:4;998:6;994:17;990:27;980:2;;1031:1;1028;1021:12;980:2;1068:6;1055:20;1090:85;1105:69;1167:6;1105:69;;1090:85;1203:21;;;1247:4;1235:17;;;;1081:94;;-1:-1;1260:14;;1235:17;1355:1;1340:238;1365:6;1362:1;1359:13;1340:238;;;1448:3;1435:17;1427:6;1423:30;1472:42;1510:3;1498:10;1472:42;;;1460:55;;-1:-1;1538:4;1529:14;;;;1557;;;;;1387:1;1380:9;1340:238;;1592:128;1667:13;;1685:30;1667:13;1685:30;;1727:134;1805:13;;1823:33;1805:13;1823:33;;1869:432;;1966:3;1959:4;1951:6;1947:17;1943:27;1933:2;;1984:1;1981;1974:12;1933:2;2021:6;2008:20;2043:60;2058:44;2095:6;2058:44;;2043:60;2034:69;;2123:6;2116:5;2109:21;2159:4;2151:6;2147:17;2192:4;2185:5;2181:16;2227:3;2218:6;2213:3;2209:16;2206:25;2203:2;;;2244:1;2241;2234:12;2203:2;2254:41;2288:6;2283:3;2278;2254:41;;2450:648;;;2626:2;2614:9;2605:7;2601:23;2597:32;2594:2;;;2642:1;2639;2632:12;2594:2;2677:31;;2728:18;2717:30;;2714:2;;;2760:1;2757;2750:12;2714:2;2780:78;2850:7;2841:6;2830:9;2826:22;2780:78;;;2770:88;;2656:208;2923:2;2912:9;2908:18;2895:32;2947:18;2939:6;2936:30;2933:2;;;2979:1;2976;2969:12;2933:2;2999:83;3074:7;3065:6;3054:9;3050:22;2999:83;;;2989:93;;2874:214;2588:510;;;;;;3105:257;;3217:2;3205:9;3196:7;3192:23;3188:32;3185:2;;;3233:1;3230;3223:12;3185:2;3268:1;3285:61;3338:7;3318:9;3285:61;;3369:263;;3484:2;3472:9;3463:7;3459:23;3455:32;3452:2;;;3500:1;3497;3490:12;3452:2;3535:1;3552:64;3608:7;3588:9;3552:64;;3909:142;4000:45;4039:5;4000:45;;;3995:3;3988:58;3982:69;;;4058:113;4141:24;4159:5;4141:24;;4178:356;;4306:38;4338:5;4306:38;;;4356:88;4437:6;4432:3;4356:88;;;4349:95;;4449:52;4494:6;4489:3;4482:4;4475:5;4471:16;4449:52;;;4513:16;;;;;4286:248;-1:-1;;4286:248;4542:315;;4702:67;4766:2;4761:3;4702:67;;;-1:-1;;;4782:38;;4848:2;4839:12;;4688:169;-1:-1;;4688:169;4866:314;;5026:67;5090:2;5085:3;5026:67;;;-1:-1;;;5106:37;;5171:2;5162:12;;5012:168;-1:-1;;5012:168;5189:332;;5349:67;5413:2;5408:3;5349:67;;;5449:34;5429:55;;5512:2;5503:12;;5335:186;-1:-1;;5335:186;5530:315;;5690:67;5754:2;5749:3;5690:67;;;-1:-1;;;5770:38;;5836:2;5827:12;;5676:169;-1:-1;;5676:169;5854:320;;6014:67;6078:2;6073:3;6014:67;;;-1:-1;;;6094:43;;6165:2;6156:12;;6000:174;-1:-1;;6000:174;6183:320;;6343:67;6407:2;6402:3;6343:67;;;-1:-1;;;6423:43;;6494:2;6485:12;;6329:174;-1:-1;;6329:174;6512:315;;6672:67;6736:2;6731:3;6672:67;;;-1:-1;;;6752:38;;6818:2;6809:12;;6658:169;-1:-1;;6658:169;6836:329;;6996:67;7060:2;7055:3;6996:67;;;7096:31;7076:52;;7156:2;7147:12;;6982:183;-1:-1;;6982:183;7174:370;;7334:67;7398:2;7393:3;7334:67;;;7434:34;7414:55;;-1:-1;;;7498:2;7489:12;;7482:25;7535:2;7526:12;;7320:224;-1:-1;;7320:224;7553:311;;7713:67;7777:2;7772:3;7713:67;;;-1:-1;;;7793:34;;7855:2;7846:12;;7699:165;-1:-1;;7699:165;7873:379;;8033:67;8097:2;8092:3;8033:67;;;8133:34;8113:55;;-1:-1;;;8197:2;8188:12;;8181:34;8243:2;8234:12;;8019:233;-1:-1;;8019:233;8261:327;;8421:67;8485:2;8480:3;8421:67;;;8521:29;8501:50;;8579:2;8570:12;;8407:181;-1:-1;;8407:181;8597:331;;8757:67;8821:2;8816:3;8757:67;;;8857:33;8837:54;;8919:2;8910:12;;8743:185;-1:-1;;8743:185;8936:113;9019:24;9037:5;9019:24;;9056:262;;9200:93;9289:3;9280:6;9200:93;;;9193:100;9181:137;-1:-1;;;9181:137;9325:213;9443:2;9428:18;;9457:71;9432:9;9501:6;9457:71;;9545:229;9671:2;9656:18;;9685:79;9660:9;9737:6;9685:79;;9781:324;9927:2;9912:18;;9941:71;9916:9;9985:6;9941:71;;;10023:72;10091:2;10080:9;10076:18;10067:6;10023:72;;10112:407;10303:2;10317:47;;;10288:18;;10378:131;10288:18;10378:131;;10526:407;10717:2;10731:47;;;10702:18;;10792:131;10702:18;10792:131;;10940:407;11131:2;11145:47;;;11116:18;;11206:131;11116:18;11206:131;;11354:407;11545:2;11559:47;;;11530:18;;11620:131;11530:18;11620:131;;11768:407;11959:2;11973:47;;;11944:18;;12034:131;11944:18;12034:131;;12182:407;12373:2;12387:47;;;12358:18;;12448:131;12358:18;12448:131;;12596:407;12787:2;12801:47;;;12772:18;;12862:131;12772:18;12862:131;;13010:407;13201:2;13215:47;;;13186:18;;13276:131;13186:18;13276:131;;13424:407;13615:2;13629:47;;;13600:18;;13690:131;13600:18;13690:131;;13838:407;14029:2;14043:47;;;14014:18;;14104:131;14014:18;14104:131;;14252:407;14443:2;14457:47;;;14428:18;;14518:131;14428:18;14518:131;;14666:407;14857:2;14871:47;;;14842:18;;14932:131;14842:18;14932:131;;15080:407;15271:2;15285:47;;;15256:18;;15346:131;15256:18;15346:131;;15494:256;15556:2;15550:9;15582:17;;;15657:18;15642:34;;15678:22;;;15639:62;15636:2;;;15714:1;15711;15704:12;15636:2;15730;15723:22;15534:216;;-1:-1;15534:216;15757:304;;15916:18;15908:6;15905:30;15902:2;;;15948:1;15945;15938:12;15902:2;-1:-1;15983:4;15971:17;;;16036:15;;15839:222;16384:317;;16523:18;16515:6;16512:30;16509:2;;;16555:1;16552;16545:12;16509:2;-1:-1;16686:4;16622;16599:17;;;;-1:-1;;16595:33;16676:15;;16446:255;16708:121;16795:12;;16766:63;16837:144;16972:3;16950:31;-1:-1;16950:31;16990:163;17093:19;;;17142:4;17133:14;;17086:67;17161:91;;17223:24;17241:5;17223:24;;17259:85;17325:13;17318:21;;17301:43;17351:72;17413:5;17396:27;17430:121;-1:-1;;;;;17492:54;;17475:76;17637:129;;17724:37;17755:5;17773:121;17852:37;17883:5;17852:37;;18017:145;18098:6;18093:3;18088;18075:30;-1:-1;18154:1;18136:16;;18129:27;18068:94;18171:268;18236:1;18243:101;18257:6;18254:1;18251:13;18243:101;;;18324:11;;;18318:18;18305:11;;;18298:39;18279:2;18272:10;18243:101;;;18359:6;18356:1;18353:13;18350:2;;;-1:-1;;18424:1;18406:16;;18399:27;18220:219;18447:117;18516:24;18534:5;18516:24;;;18509:5;18506:35;18496:2;;18555:1;18552;18545:12;18571:111;18637:21;18652:5;18637:21;;18689:117;18758:24;18776:5;18758:24;

bzzr://d417f22287b43f76fecc81426a53cb2f75ba11bd4f6524873e52018b329dd4cc