Contract 0xb79dcd181bc79d1774df65658fcbe9916beda3a5

/**
 *Submitted for verification at cronoscan.com on 2022-01-18
*/

// Sources flattened with hardhat v2.6.7 https://hardhat.org

// File @openzeppelin/contracts/math/[email protected]

// SPDX-License-Identifier: MIT

pragma solidity >=0.6.0 <0.8.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, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        uint256 c = a + b;
        if (c < a) return (false, 0);
        return (true, c);
    }

    /**
     * @dev Returns the substraction of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        if (b > a) return (false, 0);
        return (true, a - b);
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryMul(uint256 a, uint256 b) internal pure returns (bool, 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 (true, 0);
        uint256 c = a * b;
        if (c / a != b) return (false, 0);
        return (true, c);
    }

    /**
     * @dev Returns the division of two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        if (b == 0) return (false, 0);
        return (true, a / b);
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        if (b == 0) return (false, 0);
        return (true, a % b);
    }

    /**
     * @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) {
        require(b <= a, "SafeMath: subtraction overflow");
        return a - b;
    }

    /**
     * @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) {
        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, reverting 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) {
        require(b > 0, "SafeMath: division by zero");
        return a / b;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting 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) {
        require(b > 0, "SafeMath: modulo by zero");
        return a % b;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {trySub}.
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b <= a, errorMessage);
        return a - b;
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting with custom message on
     * division by zero. The result is rounded towards zero.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryDiv}.
     *
     * 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, string memory errorMessage) internal pure returns (uint256) {
        require(b > 0, errorMessage);
        return a / b;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting with custom message when dividing by zero.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryMod}.
     *
     * 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, string memory errorMessage) internal pure returns (uint256) {
        require(b > 0, errorMessage);
        return a % b;
    }
}


// File @openzeppelin/contracts/token/ERC20/[email protected]

pragma solidity >=0.6.0 <0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
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/utils/[email protected]

pragma solidity >=0.6.2 <0.8.0;

/**
 * @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) {
        // This method relies on extcodesize, which returns 0 for contracts in
        // construction, since the code is only stored at the end of the
        // constructor execution.

        uint256 size;
        // solhint-disable-next-line no-inline-assembly
        assembly { size := extcodesize(account) }
        return size > 0;
    }

    /**
     * @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].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "Address: insufficient balance");

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

    /**
     * @dev Performs a Solidity function call using a low level `call`. A
     * plain`call` is an unsafe replacement for a function call: use this
     * function instead.
     *
     * If `target` reverts with a revert reason, it is bubbled up by this
     * function (like regular Solidity function calls).
     *
     * Returns the raw returned data. To convert to the expected return value,
     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
     *
     * Requirements:
     *
     * - `target` must be a contract.
     * - calling `target` with `data` must not revert.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
      return functionCall(target, data, "Address: low-level call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
     * `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
        return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
    }

    /**
     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
     * with `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
        require(address(this).balance >= value, "Address: insufficient balance for call");
        require(isContract(target), "Address: call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.call{ value: value }(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
        return functionStaticCall(target, data, "Address: low-level static call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
        require(isContract(target), "Address: static call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.staticcall(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionDelegateCall(target, data, "Address: low-level delegate call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
        require(isContract(target), "Address: delegate call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }

    function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
        if (success) {
            return returndata;
        } else {
            // Look for revert reason and bubble it up if present
            if (returndata.length > 0) {
                // The easiest way to bubble the revert reason is using memory via assembly

                // solhint-disable-next-line no-inline-assembly
                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}


// File @openzeppelin/contracts/token/ERC20/[email protected]

pragma solidity >=0.6.0 <0.8.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 IERC20;` 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));
    }

    /**
     * @dev Deprecated. This function has issues similar to the ones found in
     * {IERC20-approve}, and its usage is discouraged.
     *
     * Whenever possible, use {safeIncreaseAllowance} and
     * {safeDecreaseAllowance} instead.
     */
    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. We use {Address.functionCall} to perform this call, which verifies that
        // the target address contains contract code and also asserts for success in the low-level call.

        bytes memory returndata = address(token).functionCall(data, "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 @openzeppelin/contracts/utils/[email protected]

pragma solidity >=0.6.0 <0.8.0;

/*
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with GSN meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address payable) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes memory) {
        this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
        return msg.data;
    }
}


// File @openzeppelin/contracts/access/[email protected]

pragma solidity >=0.6.0 <0.8.0;

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * By default, the owner account will be the one that deploys the contract. This
 * can later be changed with {transferOwnership}.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
abstract contract Ownable is Context {
    address private _owner;

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

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor () internal {
        address msgSender = _msgSender();
        _owner = msgSender;
        emit OwnershipTransferred(address(0), msgSender);
    }

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

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
        _;
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions anymore. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby removing any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        emit OwnershipTransferred(_owner, address(0));
        _owner = address(0);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        emit OwnershipTransferred(_owner, newOwner);
        _owner = newOwner;
    }
}


// File @openzeppelin/contracts/utils/[email protected]

pragma solidity >=0.6.0 <0.8.0;

/**
 * @dev Contract module which allows children to implement an emergency stop
 * mechanism that can be triggered by an authorized account.
 *
 * This module is used through inheritance. It will make available the
 * modifiers `whenNotPaused` and `whenPaused`, which can be applied to
 * the functions of your contract. Note that they will not be pausable by
 * simply including this module, only once the modifiers are put in place.
 */
abstract contract Pausable is Context {
    /**
     * @dev Emitted when the pause is triggered by `account`.
     */
    event Paused(address account);

    /**
     * @dev Emitted when the pause is lifted by `account`.
     */
    event Unpaused(address account);

    bool private _paused;

    /**
     * @dev Initializes the contract in unpaused state.
     */
    constructor () internal {
        _paused = false;
    }

    /**
     * @dev Returns true if the contract is paused, and false otherwise.
     */
    function paused() public view virtual returns (bool) {
        return _paused;
    }

    /**
     * @dev Modifier to make a function callable only when the contract is not paused.
     *
     * Requirements:
     *
     * - The contract must not be paused.
     */
    modifier whenNotPaused() {
        require(!paused(), "Pausable: paused");
        _;
    }

    /**
     * @dev Modifier to make a function callable only when the contract is paused.
     *
     * Requirements:
     *
     * - The contract must be paused.
     */
    modifier whenPaused() {
        require(paused(), "Pausable: not paused");
        _;
    }

    /**
     * @dev Triggers stopped state.
     *
     * Requirements:
     *
     * - The contract must not be paused.
     */
    function _pause() internal virtual whenNotPaused {
        _paused = true;
        emit Paused(_msgSender());
    }

    /**
     * @dev Returns to normal state.
     *
     * Requirements:
     *
     * - The contract must be paused.
     */
    function _unpause() internal virtual whenPaused {
        _paused = false;
        emit Unpaused(_msgSender());
    }
}


// File @openzeppelin/contracts/utils/[email protected]

pragma solidity >=0.6.0 <0.8.0;

/**
 * @dev Contract module that helps prevent reentrant calls to a function.
 *
 * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
 * available, which can be applied to functions to make sure there are no nested
 * (reentrant) calls to them.
 *
 * Note that because there is a single `nonReentrant` guard, functions marked as
 * `nonReentrant` may not call one another. This can be worked around by making
 * those functions `private`, and then adding `external` `nonReentrant` entry
 * points to them.
 *
 * TIP: If you would like to learn more about reentrancy and alternative ways
 * to protect against it, check out our blog post
 * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
 */
abstract contract ReentrancyGuard {
    // Booleans are more expensive than uint256 or any type that takes up a full
    // word because each write operation emits an extra SLOAD to first read the
    // slot's contents, replace the bits taken up by the boolean, and then write
    // back. This is the compiler's defense against contract upgrades and
    // pointer aliasing, and it cannot be disabled.

    // The values being non-zero value makes deployment a bit more expensive,
    // but in exchange the refund on every call to nonReentrant will be lower in
    // amount. Since refunds are capped to a percentage of the total
    // transaction's gas, it is best to keep them low in cases like this one, to
    // increase the likelihood of the full refund coming into effect.
    uint256 private constant _NOT_ENTERED = 1;
    uint256 private constant _ENTERED = 2;

    uint256 private _status;

    constructor () internal {
        _status = _NOT_ENTERED;
    }

    /**
     * @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() {
        // On the first call to nonReentrant, _notEntered will be true
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

        // Any calls to nonReentrant after this point will fail
        _status = _ENTERED;

        _;

        // By storing the original value once again, a refund is triggered (see
        // https://eips.ethereum.org/EIPS/eip-2200)
        _status = _NOT_ENTERED;
    }
}


// File contracts/interfaces/IVVSPair.sol

pragma solidity 0.6.12;

interface IVVSPair {
    function deposit(uint256 _pid, uint256 _amount) external;

    function withdraw(uint256 _pid, uint256 _amount) external;

    function kLast() external view returns (uint256);

    function totalSupply() external view returns (uint256);

    function getReserves()
        external
        view
        returns (
            uint112 reserve0,
            uint112 reserve1,
            uint32 blockTimestampLast
        );

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

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

    function token0() external view returns (address);

    function token1() external view returns (address);

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

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

    function sync() external;
}


// File contracts/libraries/VVSLibrary.sol

// Ref https://github.com/Uniswap/v2-periphery/blob/master/contracts/libraries/UniswapV2Library.sol
pragma solidity 0.6.12;


library VVSLibrary {
    using SafeMath for uint256;

    // returns sorted token addresses, used to handle return values from pairs sorted in this order
    function sortTokens(address tokenA, address tokenB)
        internal
        pure
        returns (address token0, address token1)
    {
        require(tokenA != tokenB, "VVSLibrary: IDENTICAL_ADDRESSES");
        (token0, token1) = tokenA < tokenB
            ? (tokenA, tokenB)
            : (tokenB, tokenA);
        require(token0 != address(0), "VVSLibrary: ZERO_ADDRESS");
    }

    // calculates the CREATE2 address for a pair without making any external calls
    function pairFor(
        address factory,
        address tokenA,
        address tokenB,
        bytes32 initCodehash
    ) internal pure returns (address pair) {
        (address token0, address token1) = sortTokens(tokenA, tokenB);
        pair = address(
            uint256(
                keccak256(
                    abi.encodePacked(
                        hex"ff",
                        factory,
                        keccak256(abi.encodePacked(token0, token1)),
                        initCodehash
                    )
                )
            )
        );
    }

    // fetches and sorts the reserves for a pair
    function getReserves(
        address factory,
        address tokenA,
        address tokenB,
        bytes32 initCodehash
    ) internal view returns (uint256 reserveA, uint256 reserveB) {
        (address token0, ) = sortTokens(tokenA, tokenB);
        (uint256 reserve0, uint256 reserve1, ) = IVVSPair(
            pairFor(factory, tokenA, tokenB, initCodehash)
        ).getReserves();
        (reserveA, reserveB) = tokenA == token0
            ? (reserve0, reserve1)
            : (reserve1, reserve0);
    }
}


// File contracts/interfaces/IVVSFactory.sol

pragma solidity 0.6.12;

interface IVVSFactory {
    event PairCreated(
        address indexed token0,
        address indexed token1,
        address pair,
        uint256
    );

    function INIT_CODE_PAIR_HASH() external view returns (bytes32);

    function feeTo() external view returns (address);

    function feeToSetter() external view returns (address);

    function getPair(address tokenA, address tokenB)
        external
        view
        returns (address pair);

    function allPairs(uint256) external view returns (address pair);

    function allPairsLength() external view returns (uint256);

    function createPair(address tokenA, address tokenB)
        external
        returns (address pair);

    function setFeeTo(address) external;

    function setFeeToSetter(address) external;
}


// File contracts/libraries/Babylonian.sol

// Exact copy of https://github.com/Uniswap/solidity-lib/blob/master/contracts/libraries/Babylonian.sol
pragma solidity 0.6.12;

// computes square roots using the babylonian method
// https://en.wikipedia.org/wiki/Methods_of_computing_square_roots#Babylonian_method
library Babylonian {
    // credit for this implementation goes to
    // https://github.com/abdk-consulting/abdk-libraries-solidity/blob/master/ABDKMath64x64.sol#L687
    function sqrt(uint256 x) internal pure returns (uint256) {
        if (x == 0) return 0;
        // this block is equivalent to r = uint256(1) << (BitMath.mostSignificantBit(x) / 2);
        // however that code costs significantly more gas
        uint256 xx = x;
        uint256 r = 1;
        if (xx >= 0x100000000000000000000000000000000) {
            xx >>= 128;
            r <<= 64;
        }
        if (xx >= 0x10000000000000000) {
            xx >>= 64;
            r <<= 32;
        }
        if (xx >= 0x100000000) {
            xx >>= 32;
            r <<= 16;
        }
        if (xx >= 0x10000) {
            xx >>= 16;
            r <<= 8;
        }
        if (xx >= 0x100) {
            xx >>= 8;
            r <<= 4;
        }
        if (xx >= 0x10) {
            xx >>= 4;
            r <<= 2;
        }
        if (xx >= 0x8) {
            r <<= 1;
        }
        r = (r + x / r) >> 1;
        r = (r + x / r) >> 1;
        r = (r + x / r) >> 1;
        r = (r + x / r) >> 1;
        r = (r + x / r) >> 1;
        r = (r + x / r) >> 1;
        r = (r + x / r) >> 1; // Seven iterations should be enough
        uint256 r1 = x / r;
        return (r < r1 ? r : r1);
    }
}


// File contracts/libraries/FullMath.sol

// Exact copy of https://github.com/Uniswap/solidity-lib/blob/master/contracts/libraries/FullMath.sol
pragma solidity >=0.4.0;

// taken from https://medium.com/coinmonks/math-in-solidity-part-3-percents-and-proportions-4db014e080b1
library FullMath {
    function fullMul(uint256 x, uint256 y)
        internal
        pure
        returns (uint256 l, uint256 h)
    {
        uint256 mm = mulmod(x, y, uint256(-1));
        l = x * y;
        h = mm - l;
        if (mm < l) h -= 1;
    }

    function fullDiv(
        uint256 l,
        uint256 h,
        uint256 d
    ) private pure returns (uint256) {
        uint256 pow2 = d & -d;
        d /= pow2;
        l /= pow2;
        l += h * ((-pow2) / pow2 + 1);
        uint256 r = 1;
        r *= 2 - d * r;
        r *= 2 - d * r;
        r *= 2 - d * r;
        r *= 2 - d * r;
        r *= 2 - d * r;
        r *= 2 - d * r;
        r *= 2 - d * r;
        r *= 2 - d * r;
        return l * r;
    }

    function mulDiv(
        uint256 x,
        uint256 y,
        uint256 d
    ) internal pure returns (uint256) {
        (uint256 l, uint256 h) = fullMul(x, y);

        uint256 mm = mulmod(x, y, d);
        if (mm > l) h -= 1;
        l -= mm;

        if (h == 0) return l / d;

        require(h < d, "FullMath: FULLDIV_OVERFLOW");
        return fullDiv(l, h, d);
    }
}


// File contracts/libraries/VVSLiquidityMathLibrary.sol

// Ref: https://github.com/Uniswap/v2-periphery/blob/master/contracts/libraries/UniswapV2LiquidityMathLibrary.sol
pragma solidity 0.6.12;





// library containing some math for dealing with the liquidity shares of a pair, e.g. computing their exact value
// in terms of the underlying tokens
library VVSLiquidityMathLibrary {
    using SafeMath for uint256;

    // computes liquidity value given all the parameters of the pair
    function computeLiquidityValue(
        uint256 reservesA,
        uint256 reservesB,
        uint256 totalSupply,
        uint256 liquidityAmount,
        bool feeOn,
        uint256 kLast
    ) internal pure returns (uint256 tokenAAmount, uint256 tokenBAmount) {
        if (feeOn && kLast > 0) {
            uint256 rootK = Babylonian.sqrt(reservesA.mul(reservesB));
            uint256 rootKLast = Babylonian.sqrt(kLast);
            if (rootK > rootKLast) {
                uint256 numerator1 = totalSupply;
                uint256 numerator2 = rootK.sub(rootKLast);
                uint256 denominator = rootK.mul(4).add(rootKLast);
                uint256 feeLiquidity = FullMath.mulDiv(
                    numerator1,
                    numerator2,
                    denominator
                );
                totalSupply = totalSupply.add(feeLiquidity);
            }
        }
        return (
            reservesA.mul(liquidityAmount) / totalSupply,
            reservesB.mul(liquidityAmount) / totalSupply
        );
    }

    // get all current parameters from the pair and compute value of a liquidity amount
    // **note this is subject to manipulation, e.g. sandwich attacks**. prefer passing a manipulation resistant price to
    // #getLiquidityValueAfterArbitrageToPrice
    function getLiquidityValue(
        address factory,
        address tokenA,
        address tokenB,
        uint256 liquidityAmount,
        bytes32 initCodeHash
    ) internal view returns (uint256 tokenAAmount, uint256 tokenBAmount) {
        (uint256 reservesA, uint256 reservesB) = VVSLibrary.getReserves(
            factory,
            tokenA,
            tokenB,
            initCodeHash
        );
        IVVSPair pair = IVVSPair(
            VVSLibrary.pairFor(factory, tokenA, tokenB, initCodeHash)
        );
        bool feeOn = IVVSFactory(factory).feeTo() != address(0);
        uint256 kLast = feeOn ? pair.kLast() : 0;
        uint256 totalSupply = pair.totalSupply();
        return
            computeLiquidityValue(
                reservesA,
                reservesB,
                totalSupply,
                liquidityAmount,
                feeOn,
                kLast
            );
    }
}


// File contracts/interfaces/IVVSRouter.sol

pragma solidity 0.6.12;

interface IVVSRouter {
    function removeLiquidity(
        address tokenA,
        address tokenB,
        uint256 liquidity,
        uint256 amountAMin,
        uint256 amountBMin,
        address to,
        uint256 deadline
    ) external returns (uint256 amountA, uint256 amountB);

    function addLiquidity(
        address tokenA,
        address tokenB,
        uint256 amountADesired,
        uint256 amountBDesired,
        uint256 amountAMin,
        uint256 amountBMin,
        address to,
        uint256 deadline
    )
        external
        returns (
            uint256 amountA,
            uint256 amountB,
            uint256 liquidity
        );

    function swapTokensForExactTokens(
        uint256 amountOut,
        uint256 amountInMax,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external returns (uint256[] memory amounts);

    function swapExactTokensForTokens(
        uint256 amountIn,
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external returns (uint256[] memory amounts);

    function swapExactTokensForTokensSupportingFeeOnTransferTokens(
        uint256 amountIn,
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external;
}


// File contracts/interfaces/ICraftsman.sol

pragma solidity 0.6.12;

interface ICraftsman {
    function userInfo(uint256 pid, address user)
        external
        view
        returns (uint256 amount, uint256 rewardDebt);

    function poolInfo(uint256 _pid)
        external
        view
        returns (
            address lpToken,
            uint256,
            uint256,
            uint256
        );

    function pendingVVS(uint256 _pid, address _user)
        external
        view
        returns (uint256);

    function deposit(uint256 _pid, uint256 _amount) external;

    function withdraw(uint256 _pid, uint256 _amount) external;

    function owner() external view returns (address);

    function add(
        uint256 _allocPoint,
        IERC20 _lpToken,
        bool _withUpdate
    ) external;

    function poolLength() external view returns (uint256);

    function vvsPerBlock() external view returns (uint256);
}


// File contracts/ConditionalLiquidity.sol

pragma solidity 0.6.12;

contract ConditionalLiquidity is Ownable, ReentrancyGuard, Pausable {
    using SafeMath for uint256;
    using SafeERC20 for IERC20;

    IVVSFactory public immutable factory;
    IVVSRouter public immutable router;
    ICraftsman public immutable craftsman;
    IERC20 public immutable vvs;
    bytes32 public immutable INIT_CODE_PAIR_HASH;

    uint256 public constant MAX_VVS_FEE = 10000; // 100%
    uint256 public vvsTreasuryFee = 400; // 4%
    uint256 public vvsCallerFee = 100; // 1 %

    address public treasury;

    // Store how LP user have deposited. LP address -> (User address, staked)
    mapping(address => mapping(address => UserInfo)) public userInfo;

    // Store LP address to craftsman info
    mapping(address => PoolInfo) public lpPoolInfo;

    // Store whether an address is whitelisted to breakLp
    bool public breakLpWhitelistEnabled = true;
    mapping(address => bool) public breakLpWhitelist;

    // Info of each user.
    struct UserInfo {
        uint256 amount; // How many LP tokens the user has provided.
        bool hasRuleEnabled; // whether the user has rule enabled
        uint256 minToken0Amt; // how much token0 before break
        uint256 minToken1Amt; // how much token1 before break
        uint256 rewardDebt; // number of reward debt which user has claimed
    }

    struct PoolInfo {
        uint256 pid; // pid of craftsman
        uint256 accVVSPerLp; // number of VVS per Lp
    }

    event Deposit(
        address indexed user,
        address indexed lpToken,
        uint256 amount
    );
    event Withdraw(
        address indexed user,
        address indexed lpToken,
        uint256 amount
    );
    event LpRuleUpdate(
        address indexed user,
        address indexed lpToken,
        bool hasRuleEnabled,
        uint256 token0,
        uint256 token1
    );
    event LpRedeemed(
        address indexed user,
        address indexed caller,
        address indexed lpToken,
        uint256 liquidity,
        uint256 token0,
        uint256 token1
    );
    event TreasuryReward(address indexed lpToken, uint256 vvsAmount);
    event CallerReward(
        address indexed lpToken,
        address indexed user,
        uint256 vvsAmount
    );
    event PoolSet(address indexed lpToken, uint256 pid);
    event SetVVSTreasuryFee(uint256 vvsFee);
    event SetVVSCallerFee(uint256 vvsFee);
    event SetTreasury(address treasury);
    event BreakLpWhitelistAdded(address addr);
    event BreakLpWhitelistRemoved(address addr);
    event BreakLpWhitelistEnabledSet(bool enabled);

    modifier onlyVVSPair(IVVSPair _lpToken) {
        address pair = VVSLibrary.pairFor(
            address(factory),
            _lpToken.token0(),
            _lpToken.token1(),
            INIT_CODE_PAIR_HASH
        );
        require(
            pair == address(_lpToken),
            "ConditionalLiquidity: Not VVS pair"
        );
        _;
    }

    modifier ensure(uint256 deadline) {
        require(deadline >= block.timestamp, "ConditionalLiquidity: EXPIRED");
        _;
    }

    constructor(
        IVVSFactory _factory,
        IVVSRouter _router,
        ICraftsman _craftsman,
        IERC20 _vvs,
        address _treasury
    ) public {
        factory = _factory;
        router = _router;
        craftsman = _craftsman;
        vvs = _vvs;
        treasury = _treasury;
        INIT_CODE_PAIR_HASH = _factory.INIT_CODE_PAIR_HASH();
    }

    /**
     * @dev Set up new pool or overwrite existing lpToken pool pid
     */
    function setPoolPid(IVVSPair _lpToken, uint256 _pid)
        external
        onlyVVSPair(_lpToken)
        onlyOwner
    {
        require(_pid > 0, "ConditionalLiquidity: pid must be 1 or greater");
        PoolInfo storage pool = lpPoolInfo[address(_lpToken)];

        uint256 balance = _lpToken.balanceOf(address(this));
        uint256 pid = pool.pid;

        // Verify if pid is assigned this lpToken on craftsman
        (address craftsmanPoolLp, , , ) = craftsman.poolInfo(_pid);
        require(
            craftsmanPoolLp == address(_lpToken),
            "ConditionalLiquidity: LP token not same as craftsman"
        );

        // Scenario 1: PID does not exist previously, deposit LP craftsman
        if (pid == 0 && balance != 0) {
            _lpToken.approve(address(craftsman), balance);
            craftsman.deposit(_pid, balance);
        }

        // Scenario 2: PID exist previously - migrate to the other pid and update pool.accVVSPerLp
        if (pid != 0) {
            (uint256 _totalLp, ) = craftsman.userInfo(pid, address(this));

            if (_totalLp > 0) {
                // Update pool.accVVSPerLp so existing user can claim them later
                uint256 pendingVVS = craftsman.pendingVVS(pid, address(this));

                pool.accVVSPerLp = pool.accVVSPerLp.add(
                    pendingVVS.mul(1e12).div(_totalLp)
                );
                craftsman.withdraw(pid, _totalLp);

                // deposit all LP token in contract
                _lpToken.approve(address(craftsman), _totalLp.add(balance));
                craftsman.deposit(_pid, _totalLp.add(balance));
            }
        }

        pool.pid = _pid;
        emit PoolSet(address(_lpToken), _pid);
    }

    /**
     * @dev Deposit user's LP, remove existing rule for user
     * If amount: 0 - trigger only vvs rewards collection
     */
    function deposit(IVVSPair _lpToken, uint256 _amount)
        external
        onlyVVSPair(_lpToken)
        whenNotPaused
    {
        if (_amount > 0) {
            _lpToken.transferFrom(msg.sender, address(this), _amount);
        }

        UserInfo storage user = userInfo[address(_lpToken)][msg.sender];
        PoolInfo storage pool = lpPoolInfo[address(_lpToken)];

        uint256 pid = pool.pid;
        // pid != 0 means lp token has a craftsman pid
        if (pid != 0) {
            (uint256 _totalLp, ) = craftsman.userInfo(pid, address(this)); // get total amount staked
            uint256 pendingVVS = craftsman.pendingVVS(pid, address(this));
            if (pendingVVS > 0 && _totalLp > 0) {
                // _totalLp should be over 0 here if there is pending vvs
                pool.accVVSPerLp = pool.accVVSPerLp.add(
                    pendingVVS.mul(1e12).div(_totalLp)
                );
            }

            // deposit lp token from here into the craftsman to get pending vvs as well
            _lpToken.approve(address(craftsman), _amount);
            craftsman.deposit(pid, _amount);

            uint256 pending = user.amount.mul(pool.accVVSPerLp).div(1e12).sub(
                user.rewardDebt
            );
            if (pending > 0) {
                uint256 fee = _distributeVVSFeeToTreasury(_lpToken, pending);
                vvs.safeTransfer(msg.sender, pending.sub(fee));
            }
        }

        if (_amount > 0) {
            user.amount = user.amount.add(_amount);
            _removeRule(_lpToken, msg.sender);
        }
        user.rewardDebt = user.amount.mul(pool.accVVSPerLp).div(1e12);
        emit Deposit(msg.sender, address(_lpToken), _amount);
    }

    /**
     * @dev Withdraw user's LP, remove existing rule for user
     * If amount: 0 - trigger only vvs rewards collection
     */
    function withdraw(IVVSPair _lpToken, uint256 _amount) external {
        UserInfo storage user = userInfo[address(_lpToken)][msg.sender];
        require(
            _amount <= user.amount,
            "ConditionalLiquidity: withdraw amount > balance"
        );

        PoolInfo storage pool = lpPoolInfo[address(_lpToken)];

        uint256 pid = pool.pid;
        // pid != 0 means lp token has a craftsman pid
        if (pid != 0) {
            (uint256 _totalLp, ) = craftsman.userInfo(pid, address(this)); // get total amount staked
            uint256 pendingVVS = craftsman.pendingVVS(pid, address(this));
            if (pendingVVS > 0 && _totalLp > 0) {
                // _totalLp should be over 0 here if there is pending vvs
                pool.accVVSPerLp = pool.accVVSPerLp.add(
                    pendingVVS.mul(1e12).div(_totalLp)
                );
            }

            // withdraw lp token from craftsman to get pending vvs as well
            craftsman.withdraw(pid, _amount);

            uint256 pending = user.amount.mul(pool.accVVSPerLp).div(1e12).sub(
                user.rewardDebt
            );

            if (pending > 0) {
                uint256 fee = _distributeVVSFeeToTreasury(_lpToken, pending);
                vvs.safeTransfer(msg.sender, pending.sub(fee));
            }
        }

        if (_amount > 0) {
            user.amount = user.amount.sub(_amount);
            _lpToken.transfer(msg.sender, _amount);
            _removeRule(_lpToken, msg.sender);
        }
        user.rewardDebt = user.amount.mul(pool.accVVSPerLp).div(1e12);
        emit Withdraw(msg.sender, address(_lpToken), _amount);
    }

    /**
     * @dev Add rule for an LP. If existing rule exist, it will be replaced
     * @param _lpToken token to add rule for
     * @param _minToken0Amt min token0 amount, must be higher than current LP value
     * @param _minToken1Amt min token1 amount, must be higher than current LP value
     * @param _deadline in sec, if block timestamp is after, txn will fail
     */
    function addRule(
        IVVSPair _lpToken,
        uint256 _minToken0Amt,
        uint256 _minToken1Amt,
        uint256 _deadline
    ) external ensure(_deadline) whenNotPaused {
        UserInfo storage user = userInfo[address(_lpToken)][msg.sender];
        require(user.amount > 0, "ConditionalLiquidity: Amount is 0");

        (uint256 token0Amt, uint256 token1Amt) = VVSLiquidityMathLibrary
            .getLiquidityValue(
                address(factory),
                _lpToken.token0(),
                _lpToken.token1(),
                user.amount,
                INIT_CODE_PAIR_HASH
            );

        // Either token0 or token1 must be greater than LP current val
        require(
            token0Amt < _minToken0Amt || token1Amt < _minToken1Amt,
            "ConditionalLiquidity: token0 or token1 must be greater than LP val"
        );

        user.hasRuleEnabled = true;
        user.minToken0Amt = _minToken0Amt;
        user.minToken1Amt = _minToken1Amt;

        emit LpRuleUpdate(
            msg.sender,
            address(_lpToken),
            true,
            _minToken0Amt,
            _minToken1Amt
        );
    }

    /**
     * @dev remove previously set rule for the lp token
     * @param _lpToken address of lp token to remove rule
     */
    function removeRule(IVVSPair _lpToken) external {
        _removeRule(_lpToken, msg.sender);
    }

    /**
     * @dev Break user LP if it matches user's rule,
     * @dev Requirements: lp token0 and token1 matches user's rule
     * @param _lpToken address of lp token to break
     * @param _user address of user
     */
    function breakLp(IVVSPair _lpToken, address _user)
        external
        whenNotPaused
        nonReentrant
    {
        require(
            !breakLpWhitelistEnabled || breakLpWhitelist[msg.sender],
            "CL: Not in whitelist"
        );

        UserInfo storage user = userInfo[address(_lpToken)][_user];
        require(user.amount > 0, "ConditionalLiquidity: No LP added");
        require(user.hasRuleEnabled, "ConditionalLiquidity: No rule");

        uint256 amount = user.amount;

        PoolInfo storage pool = lpPoolInfo[address(_lpToken)];

        uint256 pid = pool.pid;
        // pid != 0 means lp token has a craftsman pid
        if (pid != 0) {
            (uint256 _totalLp, ) = craftsman.userInfo(pid, address(this)); // get total amount staked

            uint256 pendingVVS = craftsman.pendingVVS(pid, address(this));
            if (pendingVVS > 0 && _totalLp > 0) {
                // _totalLp should not be 0 over here if there is pending vvs
                pool.accVVSPerLp = pool.accVVSPerLp.add(
                    pendingVVS.mul(1e12).div(_totalLp)
                );
            }

            // deposit lp token from here into the craftsman to get pending vvs as well
            craftsman.withdraw(pid, amount);

            uint256 pending = amount.mul(pool.accVVSPerLp).div(1e12).sub(
                user.rewardDebt
            );

            if (pending > 0) {
                // fee to treasury and caller
                uint256 treasuryFee = _distributeVVSFeeToTreasury(
                    _lpToken,
                    pending
                );
                uint256 callerFee = _distributeVVSFeeToCaller(
                    _lpToken,
                    pending,
                    msg.sender
                );
                vvs.safeTransfer(
                    _user,
                    pending.sub(treasuryFee).sub(callerFee)
                );
            }
        }

        uint256 minToken0Amt = user.minToken0Amt;
        uint256 minToken1Amt = user.minToken1Amt;
        address token0 = _lpToken.token0();
        address token1 = _lpToken.token1();

        _lpToken.approve(address(router), amount);

        router.removeLiquidity(
            token0,
            token1,
            amount,
            0,
            0,
            address(this),
            block.timestamp.add(600)
        );

        require(
            IERC20(token0).balanceOf(address(this)) >= minToken0Amt,
            "ConditionalLiquidity: token0 below minToken0Amt"
        );
        require(
            IERC20(token1).balanceOf(address(this)) >= minToken1Amt,
            "ConditionalLiquidity: token1 below minToken0Amt"
        );

        // revert user's rule and set amount = 0
        user.amount = 0;
        user.rewardDebt = 0;
        _removeRule(_lpToken, _user);

        (uint256 t0Increment, uint256 t1Increment) = _transferTokensToUser(
            _user,
            IERC20(token0),
            IERC20(token1),
            minToken0Amt,
            minToken1Amt
        );

        emit LpRedeemed(
            _user,
            msg.sender,
            address(_lpToken),
            amount,
            t0Increment,
            t1Increment
        );
    }

    /**
     * @notice get pending VVS for the user, does not take into account of fees
     * @param _lpToken adress of lp token to check
     * @param _user address of user to check
     * @return user pending vvs
     */
    function pendingVVS(IVVSPair _lpToken, address _user)
        external
        view
        returns (uint256)
    {
        UserInfo storage user = userInfo[address(_lpToken)][_user];
        PoolInfo storage pool = lpPoolInfo[address(_lpToken)];

        uint256 pid = pool.pid;
        if (pid == 0) {
            return 0; // not staked in craftsman = 0 vvs reward
        }

        (uint256 _totalLp, ) = craftsman.userInfo(pid, address(this)); // get total amount staked
        uint256 accVVSPerLp = pool.accVVSPerLp;
        if (_totalLp != 0) {
            uint256 poolPendingVVS = craftsman.pendingVVS(pid, address(this));
            accVVSPerLp = pool.accVVSPerLp.add(
                poolPendingVVS.mul(1e12).div(_totalLp)
            );
        }

        return user.amount.mul(accVVSPerLp).div(1e12).sub(user.rewardDebt);
    }

    /**
     * @dev Only possible when contract not paused.
     */
    function pause() external onlyOwner {
        _pause();
    }

    /**
     * @dev Only possible when contract is paused.
     */
    function unpause() external onlyOwner {
        _unpause();
    }

    /**
     * @dev Update vvs treasury fee,, check that treasury + caller fee does not exceed max fee
     */
    function setVVSTreasuryFee(uint256 _vvsTreasuryFee) external onlyOwner {
        require(
            _vvsTreasuryFee.add(vvsCallerFee) <= MAX_VVS_FEE,
            "ConditionalLiquidity: fee cannot be more than MAX_VVS_FEE"
        );
        vvsTreasuryFee = _vvsTreasuryFee;

        emit SetVVSTreasuryFee(_vvsTreasuryFee);
    }

    /**
     * @dev Update vvs caller fee, check that treasury + caller fee does not exceed max fee
     */
    function setVVSCallerFee(uint256 _vvsCallerFee) external onlyOwner {
        require(
            _vvsCallerFee.add(vvsTreasuryFee) <= MAX_VVS_FEE,
            "ConditionalLiquidity: fee cannot be more than MAX_VVS_FEE"
        );
        vvsCallerFee = _vvsCallerFee;

        emit SetVVSCallerFee(_vvsCallerFee);
    }

    /*
     * @dev Update treasury
     */
    function setTreasury(address _treasury) external onlyOwner {
        treasury = _treasury;

        emit SetTreasury(_treasury);
    }

    /**
     * @dev add addresses to breakLp whitelist
     * @param addr address
     */
    function addAddressesToWhitelist(address addr) external onlyOwner {
        if (!breakLpWhitelist[addr]) {
            breakLpWhitelist[addr] = true;
            emit BreakLpWhitelistAdded(addr);
        }
    }

    /**
     * @dev remove an address from breakLp whitelist
     * @param addr address
     */
    function removeAddressFromWhitelist(address addr) external onlyOwner {
        if (breakLpWhitelist[addr]) {
            breakLpWhitelist[addr] = false;
            emit BreakLpWhitelistRemoved(addr);
        }
    }

    /**
     * @dev if true, breakLp only allow whitelist caller, else anyone can call breakLp
     */
    function setBreakLpWhitelistEnabled(bool _enabled) external onlyOwner {
        breakLpWhitelistEnabled = _enabled;
        emit BreakLpWhitelistEnabledSet(_enabled);
    }

    function _removeRule(IVVSPair _lpToken, address _user) internal {
        UserInfo storage user = userInfo[address(_lpToken)][_user];
        user.hasRuleEnabled = false;
        user.minToken0Amt = 0;
        user.minToken1Amt = 0;
        emit LpRuleUpdate(_user, address(_lpToken), false, 0, 0);
    }

    /**
     * @dev transfer all balance of both token0 and token1 to the user, require user balance to increase by _minToken0Amt and _minToken1Amt
     * @param _user address to transfer token to
     * @param _token0 address of token0
     * @param _token1 address of token1
     * @param _minToken0Amt min token0 amount user balance should increase
     * @param _minToken1Amt min token1 amount user balance should increase
     * @return t0Increment amount of token0 increased
     * @return t1Increment amount of token1 increased
     */
    function _transferTokensToUser(
        address _user,
        IERC20 _token0,
        IERC20 _token1,
        uint256 _minToken0Amt,
        uint256 _minToken1Amt
    ) internal returns (uint256 t0Increment, uint256 t1Increment) {
        // Bal of user before transfer
        uint256 userToken0BalBefore = _token0.balanceOf(_user);
        uint256 userToken1BalBefore = _token1.balanceOf(_user);

        // Transfer all token0 and token1 bal to user
        uint256 token0Bal = _token0.balanceOf(address(this));
        uint256 token1Bal = _token1.balanceOf(address(this));
        _token0.safeTransfer(_user, token0Bal);
        _token1.safeTransfer(_user, token1Bal);

        // Bal of user after transfer
        uint256 userToken0BalAfter = _token0.balanceOf(_user);
        uint256 userToken1BalAfter = _token1.balanceOf(_user);

        // Check user token increase as some token incur a fee for each transfer
        t0Increment = userToken0BalAfter.sub(userToken0BalBefore);
        require(
            t0Increment >= _minToken0Amt,
            "ConditionalLiquidity: user token0Bal under minToken0Amt"
        );

        t1Increment = userToken1BalAfter.sub(userToken1BalBefore);
        require(
            t1Increment >= _minToken1Amt,
            "ConditionalLiquidity: user token1Bal under minToken1Amt"
        );
    }

    /**
     * @dev distribute vvs fee to treasury
     * @return fee sent to treasury
     */
    function _distributeVVSFeeToTreasury(IVVSPair _lpToken, uint256 _amt)
        internal
        returns (uint256)
    {
        uint256 fee = 0;
        if (_amt > 0) {
            fee = _amt.mul(vvsTreasuryFee).div(MAX_VVS_FEE);

            vvs.safeTransfer(treasury, fee);
            emit TreasuryReward(address(_lpToken), fee);
        }

        return fee;
    }

    /**
     * @dev distribute vvs fee to caller
     * @return fee sent to caller
     */
    function _distributeVVSFeeToCaller(
        IVVSPair _lpToken,
        uint256 _amt,
        address _caller
    ) internal returns (uint256) {
        uint256 fee = 0;

        if (_amt > 0) {
            fee = _amt.mul(vvsCallerFee).div(MAX_VVS_FEE);

            vvs.safeTransfer(_caller, fee);
            emit CallerReward(address(_lpToken), _caller, fee);
        }

        return fee;
    }
}

[{"inputs":[{"internalType":"contract IVVSFactory","name":"_factory","type":"address"},{"internalType":"contract IVVSRouter","name":"_router","type":"address"},{"internalType":"contract ICraftsman","name":"_craftsman","type":"address"},{"internalType":"contract IERC20","name":"_vvs","type":"address"},{"internalType":"address","name":"_treasury","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"addr","type":"address"}],"name":"BreakLpWhitelistAdded","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"bool","name":"enabled","type":"bool"}],"name":"BreakLpWhitelistEnabledSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"addr","type":"address"}],"name":"BreakLpWhitelistRemoved","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"lpToken","type":"address"},{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"vvsAmount","type":"uint256"}],"name":"CallerReward","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"address","name":"lpToken","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Deposit","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"address","name":"caller","type":"address"},{"indexed":true,"internalType":"address","name":"lpToken","type":"address"},{"indexed":false,"internalType":"uint256","name":"liquidity","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"token0","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"token1","type":"uint256"}],"name":"LpRedeemed","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"address","name":"lpToken","type":"address"},{"indexed":false,"internalType":"bool","name":"hasRuleEnabled","type":"bool"},{"indexed":false,"internalType":"uint256","name":"token0","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"token1","type":"uint256"}],"name":"LpRuleUpdate","type":"event"},{"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":"account","type":"address"}],"name":"Paused","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"lpToken","type":"address"},{"indexed":false,"internalType":"uint256","name":"pid","type":"uint256"}],"name":"PoolSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"treasury","type":"address"}],"name":"SetTreasury","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"vvsFee","type":"uint256"}],"name":"SetVVSCallerFee","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"vvsFee","type":"uint256"}],"name":"SetVVSTreasuryFee","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"lpToken","type":"address"},{"indexed":false,"internalType":"uint256","name":"vvsAmount","type":"uint256"}],"name":"TreasuryReward","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Unpaused","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"address","name":"lpToken","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Withdraw","type":"event"},{"inputs":[],"name":"INIT_CODE_PAIR_HASH","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAX_VVS_FEE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"addr","type":"address"}],"name":"addAddressesToWhitelist","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IVVSPair","name":"_lpToken","type":"address"},{"internalType":"uint256","name":"_minToken0Amt","type":"uint256"},{"internalType":"uint256","name":"_minToken1Amt","type":"uint256"},{"internalType":"uint256","name":"_deadline","type":"uint256"}],"name":"addRule","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IVVSPair","name":"_lpToken","type":"address"},{"internalType":"address","name":"_user","type":"address"}],"name":"breakLp","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"breakLpWhitelist","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"breakLpWhitelistEnabled","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"craftsman","outputs":[{"internalType":"contract ICraftsman","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"contract IVVSPair","name":"_lpToken","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"deposit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"factory","outputs":[{"internalType":"contract IVVSFactory","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"lpPoolInfo","outputs":[{"internalType":"uint256","name":"pid","type":"uint256"},{"internalType":"uint256","name":"accVVSPerLp","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"contract IVVSPair","name":"_lpToken","type":"address"},{"internalType":"address","name":"_user","type":"address"}],"name":"pendingVVS","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"addr","type":"address"}],"name":"removeAddressFromWhitelist","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IVVSPair","name":"_lpToken","type":"address"}],"name":"removeRule","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"router","outputs":[{"internalType":"contract IVVSRouter","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bool","name":"_enabled","type":"bool"}],"name":"setBreakLpWhitelistEnabled","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IVVSPair","name":"_lpToken","type":"address"},{"internalType":"uint256","name":"_pid","type":"uint256"}],"name":"setPoolPid","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_treasury","type":"address"}],"name":"setTreasury","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_vvsCallerFee","type":"uint256"}],"name":"setVVSCallerFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_vvsTreasuryFee","type":"uint256"}],"name":"setVVSTreasuryFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"treasury","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"unpause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"}],"name":"userInfo","outputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"bool","name":"hasRuleEnabled","type":"bool"},{"internalType":"uint256","name":"minToken0Amt","type":"uint256"},{"internalType":"uint256","name":"minToken1Amt","type":"uint256"},{"internalType":"uint256","name":"rewardDebt","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"vvs","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"vvsCallerFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"vvsTreasuryFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"contract IVVSPair","name":"_lpToken","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

0000000000000000000000003b44b2a187a7b3824131f8db5a74194d0a42fc15000000000000000000000000145863eb42cf62847a6ca784e6416c1682b1b2ae000000000000000000000000dccd6455ae04b03d785f12196b492b18129564bc0000000000000000000000002d03bece6747adc00e1a131bba1469c15fd11e03000000000000000000000000e09f3b486c6d45cf7017d5d45dfb3ab35f8a51b8

-----Decoded View---------------
Arg [0] : _factory (address): 0x3b44b2a187a7b3824131f8db5a74194d0a42fc15
Arg [1] : _router (address): 0x145863eb42cf62847a6ca784e6416c1682b1b2ae
Arg [2] : _craftsman (address): 0xdccd6455ae04b03d785f12196b492b18129564bc
Arg [3] : _vvs (address): 0x2d03bece6747adc00e1a131bba1469c15fd11e03
Arg [4] : _treasury (address): 0xe09f3b486c6d45cf7017d5d45dfb3ab35f8a51b8

-----Encoded View---------------
5 Constructor Arguments found :
Arg [0] : 0000000000000000000000003b44b2a187a7b3824131f8db5a74194d0a42fc15
Arg [1] : 000000000000000000000000145863eb42cf62847a6ca784e6416c1682b1b2ae
Arg [2] : 000000000000000000000000dccd6455ae04b03d785f12196b492b18129564bc
Arg [3] : 0000000000000000000000002d03bece6747adc00e1a131bba1469c15fd11e03
Arg [4] : 000000000000000000000000e09f3b486c6d45cf7017d5d45dfb3ab35f8a51b8

42959:21276:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;43230:27;;;:::i;:::-;;;;-1:-1:-1;;;;;43230:27:0;;;;;;;;;;;;;;43583:64;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;43583:64:0;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;43317:43;;;:::i;:::-;;;;;;;;;;;;;;;;60141:216;;;;;;;;;;;;;;;;-1:-1:-1;60141:216:0;-1:-1:-1;;;;;60141:216:0;;:::i;:::-;;43186:37;;;:::i;60465:221::-;;;;;;;;;;;;;;;;-1:-1:-1;60465:221:0;-1:-1:-1;;;;;60465:221:0;;:::i;43862:48::-;;;;;;;;;;;;;;;;-1:-1:-1;43862:48:0;-1:-1:-1;;;;;43862:48:0;;:::i;:::-;;;;;;;;;;;;;;;;;;58871:67;;;:::i;59060:340::-;;;;;;;;;;;;;;;;-1:-1:-1;59060:340:0;;:::i;48520:1766::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;48520:1766:0;;;;;;;;:::i;60800:175::-;;;;;;;;;;;;;;;;-1:-1:-1;60800:175:0;;;;:::i;52531:1193::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;52531:1193:0;;;;;;;;;;;;;;;;;;:::i;43264:44::-;;;:::i;26563:86::-;;;:::i;43472:23::-;;;:::i;57785:866::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;57785:866:0;;;;;;;;;;:::i;43699:46::-;;;;;;;;;;;;;;;;-1:-1:-1;43699:46:0;-1:-1:-1;;;;;43699:46:0;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;24918:148;;;:::i;58730:63::-;;;:::i;59519:328::-;;;;;;;;;;;;;;;;-1:-1:-1;59519:328:0;;:::i;24267:87::-;;;:::i;43375:35::-;;;:::i;43813:42::-;;;:::i;46591:1782::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;46591:1782:0;;;;;;;;:::i;54204:3343::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;54204:3343:0;;;;;;;;;;:::i;43102:36::-;;;:::i;53866:100::-;;;;;;;;;;;;;;;;-1:-1:-1;53866:100:0;-1:-1:-1;;;;;53866:100:0;;:::i;43423:33::-;;;:::i;59901:138::-;;;;;;;;;;;;;;;;-1:-1:-1;59901:138:0;-1:-1:-1;;;;;59901:138:0;;:::i;25221:244::-;;;;;;;;;;;;;;;;-1:-1:-1;25221:244:0;-1:-1:-1;;;;;25221:244:0;;:::i;50434:1702::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;50434:1702:0;;;;;;;;:::i;43145:34::-;;;:::i;43230:27::-;;;:::o;43583:64::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;43317:43::-;43355:5;43317:43;:::o;60141:216::-;24498:12;:10;:12::i;:::-;-1:-1:-1;;;;;24487:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;24487:23:0;;24479:68;;;;;-1:-1:-1;;;24479:68:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;24479:68:0;;;;;;;;;;;;;;;-1:-1:-1;;;;;60223:22:0;::::1;;::::0;;;:16:::1;:22;::::0;;;;;::::1;;60218:132;;-1:-1:-1::0;;;;;60262:22:0;::::1;;::::0;;;:16:::1;:22;::::0;;;;;;;;:29;;-1:-1:-1;;60262:29:0::1;60287:4;60262:29;::::0;;60311:27;;;;;;;::::1;::::0;;;;;;;;::::1;60218:132;60141:216:::0;:::o;43186:37::-;;;:::o;60465:221::-;24498:12;:10;:12::i;:::-;-1:-1:-1;;;;;24487:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;24487:23:0;;24479:68;;;;;-1:-1:-1;;;24479:68:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;24479:68:0;;;;;;;;;;;;;;;-1:-1:-1;;;;;60549:22:0;::::1;;::::0;;;:16:::1;:22;::::0;;;;;::::1;;60545:134;;;-1:-1:-1::0;;;;;60588:22:0;::::1;60613:5;60588:22:::0;;;:16:::1;:22;::::0;;;;;;;;:30;;-1:-1:-1;;60588:30:0::1;::::0;;60638:29;;;;;;;::::1;::::0;;;;;;;;::::1;60465:221:::0;:::o;43862:48::-;;;;;;;;;;;;;;;:::o;58871:67::-;24498:12;:10;:12::i;:::-;-1:-1:-1;;;;;24487:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;24487:23:0;;24479:68;;;;;-1:-1:-1;;;24479:68:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;24479:68:0;;;;;;;;;;;;;;;58920:10:::1;:8;:10::i;:::-;58871:67::o:0;59060:340::-;24498:12;:10;:12::i;:::-;-1:-1:-1;;;;;24487:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;24487:23:0;;24479:68;;;;;-1:-1:-1;;;24479:68:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;24479:68:0;;;;;;;;;;;;;;;43355:5:::1;59164:33;59184:12;;59164:15;:19;;:33;;;;:::i;:::-;:48;;59142:155;;;;-1:-1:-1::0;;;59142:155:0::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;59308:14;:32:::0;;;59358:34:::1;::::0;;;;;;;::::1;::::0;;;;::::1;::::0;;::::1;59060:340:::0;:::o;48520:1766::-;48612:8;45654:12;45669:158;45710:7;45733:8;-1:-1:-1;;;;;45733:15:0;;:17;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;45733:17:0;45765;;;-1:-1:-1;;;45765:17:0;;;;-1:-1:-1;;;;;45765:15:0;;;;;:17;;;;;45733;;45765;;;;;;;:15;:17;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;45765:17:0;45797:19;45669:18;:158::i;:::-;45654:173;;45876:8;-1:-1:-1;;;;;45860:25:0;:4;-1:-1:-1;;;;;45860:25:0;;45838:109;;;;-1:-1:-1;;;45838:109:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;26889:8:::1;:6;:8::i;:::-;26888:9;26880:38;;;::::0;;-1:-1:-1;;;26880:38:0;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;-1:-1:-1;;;26880:38:0;;;;;;;;;;;;;::::1;;48665:11:::0;;48661:101:::2;;48693:57;::::0;;-1:-1:-1;;;48693:57:0;;48715:10:::2;48693:57;::::0;::::2;::::0;48735:4:::2;48693:57:::0;;;;;;;;;;;;-1:-1:-1;;;;;48693:21:0;::::2;::::0;::::2;::::0;:57;;;;;::::2;::::0;;;;;;;;-1:-1:-1;48693:21:0;:57;::::2;;::::0;::::2;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;::::0;::::2;;-1:-1:-1::0;;48661:101:0::2;-1:-1:-1::0;;;;;48798:27:0;::::2;48774:21;48798:27:::0;;;:8:::2;:27;::::0;;;;;;;48826:10:::2;48798:39:::0;;;;;;;48872:29;;;:10:::2;:29:::0;;;;;48928:8;;49007;;49003:999:::2;;49055:38;::::0;;-1:-1:-1;;;49055:38:0;;::::2;::::0;::::2;::::0;;;49087:4:::2;49055:38:::0;;;;;;49033:16:::2;::::0;-1:-1:-1;;;;;49055:9:0::2;:18;::::0;::::2;::::0;:38;;;;;;;;;;;:18;:38;::::2;;::::0;::::2;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;::::0;::::2;;-1:-1:-1::0;49055:38:0;;49156:40;;-1:-1:-1;;;49156:40:0;;::::2;::::0;::::2;::::0;;;49190:4:::2;49156:40:::0;;;;;;49055:38;;-1:-1:-1;49135:18:0::2;::::0;-1:-1:-1;;;;;49156:9:0::2;:20;::::0;::::2;::::0;:40;;;;;49055:38:::2;::::0;49156:40;;;;;;;:20;:40;::::2;;::::0;::::2;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;::::0;::::2;;-1:-1:-1::0;49156:40:0;;-1:-1:-1;49215:14:0;;;;;:30:::2;;;49244:1;49233:8;:12;49215:30;49211:261;;;49360:96;49403:34;49428:8:::0;49403:20:::2;:10:::0;49418:4:::2;49403:14;:20::i;:::-;:24:::0;::::2;:34::i;:::-;49360:16;::::0;::::2;::::0;;:20:::2;:96::i;:::-;49341:16;::::0;::::2;:115:::0;49211:261:::2;49577:8;-1:-1:-1::0;;;;;49577:16:0::2;;49602:9;49614:7;49577:45;;;;;;;;;;;;;-1:-1:-1::0;;;;;49577:45:0::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;::::0;::::2;;-1:-1:-1::0;;49637:31:0::2;::::0;;-1:-1:-1;;;49637:31:0;;::::2;::::0;::::2;::::0;;;;;;;;;;;-1:-1:-1;;;;;49637:9:0::2;:17;::::0;::::2;::::0;:31;;;;;-1:-1:-1;;49637:31:0;;;;;;;-1:-1:-1;49637:17:0;:31;::::2;;::::0;::::2;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;49685:15;49703:96;49769:4;:15;;;49703:43;49741:4;49703:33;49719:4;:16;;;49703:4;:11;;;:15;;:33;;;;:::i;:43::-;:47:::0;::::2;:96::i;:::-;49685:114:::0;-1:-1:-1;49818:11:0;;49814:177:::2;;49850:11;49864:46;49892:8;49902:7;49864:27;:46::i;:::-;49850:60:::0;-1:-1:-1;49929:46:0::2;49946:10;49958:16;:7:::0;49850:60;49958:11:::2;:16::i;:::-;-1:-1:-1::0;;;;;49929:3:0::2;:16;::::0;:46;:16:::2;:46::i;:::-;49814:177;;49003:999;;;;50018:11:::0;;50014:130:::2;;50060:11:::0;;:24:::2;::::0;50076:7;50060:15:::2;:24::i;:::-;50046:38:::0;;50099:33:::2;50111:8:::0;50121:10:::2;50099:11;:33::i;:::-;50188:16;::::0;::::2;::::0;50172:11;;:43:::2;::::0;50210:4:::2;::::0;50172:33:::2;::::0;:15:::2;:33::i;:43::-;50154:15;::::0;::::2;:61:::0;50231:47:::2;::::0;;;;;;;-1:-1:-1;;;;;50231:47:0;::::2;::::0;50239:10:::2;::::0;50231:47:::2;::::0;;;;::::2;::::0;;::::2;26929:1;;;48520:1766:::0;;;;:::o;60800:175::-;24498:12;:10;:12::i;:::-;-1:-1:-1;;;;;24487:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;24487:23:0;;24479:68;;;;;-1:-1:-1;;;24479:68:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;24479:68:0;;;;;;;;;;;;;;;60881:23:::1;:34:::0;;;::::1;;-1:-1:-1::0;;60881:34:0;;::::1;::::0;::::1;::::0;;;60931:36:::1;::::0;;;;;;::::1;::::0;;;;::::1;::::0;;::::1;60800:175:::0;:::o;52531:1193::-;52691:9;46040:15;46028:8;:27;;46020:69;;;;;-1:-1:-1;;;46020:69:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;26889:8:::1;:6;:8::i;:::-;26888:9;26880:38;;;::::0;;-1:-1:-1;;;26880:38:0;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;-1:-1:-1;;;26880:38:0;;;;;;;;;;;;;::::1;;-1:-1:-1::0;;;;;52751:27:0;::::2;52727:21;52751:27:::0;;;:8:::2;:27;::::0;;;;;;;52779:10:::2;52751:39:::0;;;;;;;52809:11;;52801:61:::2;;;;-1:-1:-1::0;;;52801:61:0::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;52876:17;52895::::0;52916:245:::2;52998:7;53025:8;-1:-1:-1::0;;;;;53025:15:0::2;;:17;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;::::0;::::2;;-1:-1:-1::0;53025:17:0;53061::::2;::::0;;-1:-1:-1;;;53061:17:0;;;;-1:-1:-1;;;;;53061:15:0;::::2;::::0;::::2;::::0;:17:::2;::::0;;::::2;::::0;53025::::2;::::0;53061;;;;;;;:15;:17;::::2;;::::0;::::2;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;::::0;::::2;;-1:-1:-1::0;53061:17:0;53097:11;;53127:19:::2;52916:55;:245::i;:::-;52875:286;;;;53280:13;53268:9;:25;:54;;;;53309:13;53297:9;:25;53268:54;53246:170;;;;-1:-1:-1::0;;;53246:170:0::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;53451:4;53429:19:::0;;::::2;:26:::0;;-1:-1:-1;;53429:26:0::2;::::0;::::2;::::0;;53466:17:::2;::::0;::::2;:33:::0;;;53510:17:::2;::::0;::::2;:33:::0;;;53561:155:::2;::::0;;;;;::::2;::::0;::::2;::::0;;;;;;;;;;-1:-1:-1;;;;;53561:155:0;::::2;::::0;53588:10:::2;::::0;53561:155:::2;::::0;;;;;;;::::2;26929:1;;;52531:1193:::0;;;;;:::o;43264:44::-;;;:::o;26563:86::-;26634:7;;;;26563:86;:::o;43472:23::-;;;-1:-1:-1;;;;;43472:23:0;;:::o;57785:866::-;-1:-1:-1;;;;;57938:27:0;;;57889:7;57938:27;;;:8;:27;;;;;;;;:34;;;;;;;;;;;58007:29;;;:10;:29;;;;;58063:8;;58086;58082:91;;58118:1;58111:8;;;;;;;58082:91;58208:38;;;-1:-1:-1;;;58208:38:0;;;;;;;;58240:4;58208:38;;;;;;58186:16;;-1:-1:-1;;;;;58208:9:0;:18;;;;:38;;;;;;;;;;;:18;:38;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;58208:38:0;58306:16;;;;58208:38;;-1:-1:-1;58337:13:0;;58333:232;;58367:22;58392:9;-1:-1:-1;;;;;58392:20:0;;58413:3;58426:4;58392:40;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;58392:40:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;58392:40:0;;-1:-1:-1;58461:92:0;58500:38;58529:8;58500:24;58392:40;58519:4;58500:18;:24::i;:38::-;58461:16;;;;;:20;:92::i;:::-;58447:106;;58333:232;;58584:59;58627:4;:15;;;58584:38;58617:4;58584:28;58600:11;58584:4;:11;;;:15;;:28;;;;:::i;:59::-;58577:66;;;;;;;57785:866;;;;;:::o;43699:46::-;;;;;;;;;;;;;;;;;;;:::o;24918:148::-;24498:12;:10;:12::i;:::-;-1:-1:-1;;;;;24487:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;24487:23:0;;24479:68;;;;;-1:-1:-1;;;24479:68:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;24479:68:0;;;;;;;;;;;;;;;25025:1:::1;25009:6:::0;;24988:40:::1;::::0;-1:-1:-1;;;;;25009:6:0;;::::1;::::0;24988:40:::1;::::0;25025:1;;24988:40:::1;25056:1;25039:19:::0;;-1:-1:-1;;;;;;25039:19:0::1;::::0;;24918:148::o;58730:63::-;24498:12;:10;:12::i;:::-;-1:-1:-1;;;;;24487:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;24487:23:0;;24479:68;;;;;-1:-1:-1;;;24479:68:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;24479:68:0;;;;;;;;;;;;;;;58777:8:::1;:6;:8::i;59519:328::-:0;24498:12;:10;:12::i;:::-;-1:-1:-1;;;;;24487:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;24487:23:0;;24479:68;;;;;-1:-1:-1;;;24479:68:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;24479:68:0;;;;;;;;;;;;;;;43355:5:::1;59619:33;59637:14;;59619:13;:17;;:33;;;;:::i;:::-;:48;;59597:155;;;;-1:-1:-1::0;;;59597:155:0::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;59763:12;:28:::0;;;59809:30:::1;::::0;;;;;;;::::1;::::0;;;;::::1;::::0;;::::1;59519:328:::0;:::o;24267:87::-;24313:7;24340:6;-1:-1:-1;;;;;24340:6:0;24267:87;:::o;43375:35::-;;;;:::o;43813:42::-;;;;;;:::o;46591:1782::-;46683:8;45654:12;45669:158;45710:7;45733:8;-1:-1:-1;;;;;45733:15:0;;:17;;;;;;;;;;;;;;;;;;;;;;;;;;;;;45669:158;45654:173;;45876:8;-1:-1:-1;;;;;45860:25:0;:4;-1:-1:-1;;;;;45860:25:0;;45838:109;;;;-1:-1:-1;;;45838:109:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;24498:12:::1;:10;:12::i;:::-;-1:-1:-1::0;;;;;24487:23:0::1;:7;:5;:7::i;:::-;-1:-1:-1::0;;;;;24487:23:0::1;;24479:68;;;::::0;;-1:-1:-1;;;24479:68:0;;::::1;;::::0;::::1;::::0;;;;;;;-1:-1:-1;;;;;;;;;;;24479:68:0;;;;;;;;;;;;;::::1;;46743:1:::2;46736:4;:8;46728:67;;;;-1:-1:-1::0;;;46728:67:0::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1::0;;;;;46830:29:0;::::2;46806:21;46830:29:::0;;;:10:::2;:29;::::0;;;;;;;46890:33;;-1:-1:-1;;;46890:33:0;;46917:4:::2;46890:33;::::0;::::2;::::0;;;46830:29;;;46890:18:::2;::::0;:33;;;;;;;;;;;46830:29;46890:33;::::2;;::::0;::::2;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;::::0;::::2;;-1:-1:-1::0;46890:33:0;46948:8;;47067:24:::2;::::0;;-1:-1:-1;;;47067:24:0;;::::2;::::0;::::2;::::0;;;;;46890:33;;-1:-1:-1;46948:8:0;;46934:11:::2;::::0;-1:-1:-1;;;;;47067:9:0::2;:18;::::0;::::2;::::0;:24;;;;;::::2;::::0;;;;;;;;;:18;:24;::::2;;::::0;::::2;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;::::0;::::2;;-1:-1:-1::0;47067:24:0;;-1:-1:-1;;;;;;47124:36:0;;::::2;::::0;;::::2;;47102:138;;;;-1:-1:-1::0;;;47102:138:0::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;47333:8:::0;;:24;::::2;;;-1:-1:-1::0;47345:12:0;;::::2;47333:24;47329:149;;;47374:8;-1:-1:-1::0;;;;;47374:16:0::2;;47399:9;47411:7;47374:45;;;;;;;;;;;;;-1:-1:-1::0;;;;;47374:45:0::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;::::0;::::2;;-1:-1:-1::0;;47434:32:0::2;::::0;;-1:-1:-1;;;47434:32:0;;::::2;::::0;::::2;::::0;;;;;;;;;;;-1:-1:-1;;;;;47434:9:0::2;:17;::::0;::::2;::::0;:32;;;;;-1:-1:-1;;47434:32:0;;;;;;;-1:-1:-1;47434:17:0;:32;::::2;;::::0;::::2;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;47329:149;47594:8:::0;;47590:700:::2;;47642:38;::::0;;-1:-1:-1;;;47642:38:0;;::::2;::::0;::::2;::::0;;;47674:4:::2;47642:38:::0;;;;;;47620:16:::2;::::0;-1:-1:-1;;;;;47642:9:0::2;:18;::::0;::::2;::::0;:38;;;;;;;;;;;:18;:38;::::2;;::::0;::::2;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;::::0;::::2;;-1:-1:-1::0;47642:38:0;;-1:-1:-1;47701:12:0;;47697:582:::2;;47816:18;47837:9;-1:-1:-1::0;;;;;47837:20:0::2;;47858:3;47871:4;47837:40;;;;;;;;;;;;;;;;;;-1:-1:-1::0;;;;;47837:40:0::2;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;::::0;::::2;;-1:-1:-1::0;47837:40:0;;-1:-1:-1;47917:96:0::2;47960:34;47985:8:::0;47960:20:::2;47837:40:::0;47975:4:::2;47960:14;:20::i;:34::-;47917:16;::::0;::::2;::::0;;:20:::2;:96::i;:::-;47898:16;::::0;::::2;:115:::0;48032:33:::2;::::0;;-1:-1:-1;;;48032:33:0;;::::2;::::0;::::2;::::0;;;;;;;;;;;-1:-1:-1;;;;;48032:9:0::2;:18;::::0;::::2;::::0;:33;;;;;-1:-1:-1;;48032:33:0;;;;;;;-1:-1:-1;48032:18:0;:33;::::2;;::::0;::::2;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;-1:-1:-1::0;;;;;;;;48139:16:0;::::2;::::0;-1:-1:-1;48139:16:0::2;48164:9;48176:21;:8:::0;48189:7;48176:12:::2;:21::i;:::-;48139:59;;;;;;;;;;;;;-1:-1:-1::0;;;;;48139:59:0::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;::::0;::::2;;-1:-1:-1::0;;;;;;;48217:9:0::2;:17;;48235:4:::0;48241:21:::2;:8:::0;48254:7;48241:12:::2;:21::i;:::-;48217:46;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;47697:582;;47590:700;;48302:15:::0;;;48333:32:::2;::::0;;;;;;;-1:-1:-1;;;;;48333:32:0;::::2;::::0;::::2;::::0;;;;;::::2;::::0;;::::2;24558:1;;;;46591:1782:::0;;;;:::o;54204:3343::-;26889:8;:6;:8::i;:::-;26888:9;26880:38;;;;;-1:-1:-1;;;26880:38:0;;;;;;;;;;;;-1:-1:-1;;;26880:38:0;;;;;;;;;;;;;;;29505:1:::1;30111:7;;:19;;30103:63;;;::::0;;-1:-1:-1;;;30103:63:0;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;::::1;::::0;;;;;;;;;;;;;::::1;;29505:1;30244:7;:18:::0;54357:23:::2;::::0;::::2;;54356:24;::::0;:56:::2;;-1:-1:-1::0;54401:10:0::2;54384:28;::::0;;;:16:::2;:28;::::0;;;;;::::2;;54356:56;54334:126;;;::::0;;-1:-1:-1;;;54334:126:0;;::::2;;::::0;::::2;::::0;::::2;::::0;;;;-1:-1:-1;;;54334:126:0;;;;;;;;;;;;;::::2;;-1:-1:-1::0;;;;;54497:27:0;;::::2;54473:21;54497:27:::0;;;:8:::2;:27;::::0;;;;;;;:34;;::::2;::::0;;;;;;54550:11;;54542:61:::2;;;;-1:-1:-1::0;;;54542:61:0::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;54622:19;::::0;::::2;::::0;::::2;;54614:61;;;::::0;;-1:-1:-1;;;54614:61:0;;::::2;;::::0;::::2;::::0;::::2;::::0;;;;::::2;::::0;;;;;;;;;;;;;::::2;;54705:11:::0;;-1:-1:-1;;;;;54753:29:0;::::2;54688:14;54753:29:::0;;;:10:::2;:29;::::0;;;;54809:8;;54888;;54884:1314:::2;;54936:38;::::0;;-1:-1:-1;;;54936:38:0;;::::2;::::0;::::2;::::0;;;54968:4:::2;54936:38:::0;;;;;;54914:16:::2;::::0;-1:-1:-1;;;;;54936:9:0::2;:18;::::0;::::2;::::0;:38;;;;;;;;;;;:18;:38;::::2;;::::0;::::2;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;::::0;::::2;;-1:-1:-1::0;54936:38:0;;55039:40;;-1:-1:-1;;;55039:40:0;;::::2;::::0;::::2;::::0;;;55073:4:::2;55039:40:::0;;;;;;54936:38;;-1:-1:-1;55018:18:0::2;::::0;-1:-1:-1;;;;;55039:9:0::2;:20;::::0;::::2;::::0;:40;;;;;54936:38:::2;::::0;55039:40;;;;;;;:20;:40;::::2;;::::0;::::2;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;::::0;::::2;;-1:-1:-1::0;55039:40:0;;-1:-1:-1;55098:14:0;;;;;:30:::2;;;55127:1;55116:8;:12;55098:30;55094:265;;;55247:96;55290:34;55315:8:::0;55290:20:::2;:10:::0;55305:4:::2;55290:14;:20::i;55247:96::-;55228:16;::::0;::::2;:115:::0;55094:265:::2;55464:9;-1:-1:-1::0;;;;;55464:18:0::2;;55483:3;55488:6;55464:31;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;55512:15;55530:91;55591:4;:15;;;55530:38;55563:4;55530:28;55541:4;:16;;;55530:6;:10;;:28;;;;:::i;:91::-;55512:109:::0;-1:-1:-1;55642:11:0;;55638:549:::2;;55721:19;55743:107;55793:8;55824:7;55743:27;:107::i;:::-;55721:129;;55869:17;55889:138;55937:8;55968:7;55998:10;55889:25;:138::i;:::-;55869:158:::0;-1:-1:-1;56046:125:0::2;56085:5:::0;56113:39:::2;55869:158:::0;56113:24:::2;:7:::0;56125:11;56113::::2;:24::i;56046:125::-;55638:549;;;54884:1314;;;;56210:20;56233:4;:17;;;56210:40;;56261:20;56284:4;:17;;;56261:40;;56312:14;56329:8;-1:-1:-1::0;;;;;56329:15:0::2;;:17;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;::::0;::::2;;-1:-1:-1::0;56329:17:0;56374::::2;::::0;;-1:-1:-1;;;56374:17:0;;;;56329;;-1:-1:-1;56357:14:0::2;::::0;-1:-1:-1;;;;;56374:15:0;::::2;::::0;::::2;::::0;:17:::2;::::0;;::::2;::::0;56329::::2;::::0;56374;;;;;;;:15;:17;::::2;;::::0;::::2;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;::::0;::::2;;-1:-1:-1::0;56374:17:0;56404:41:::2;::::0;;-1:-1:-1;;;56404:41:0;;-1:-1:-1;;;;;56429:6:0::2;56404:41:::0;::::2;;::::0;::::2;::::0;;;;;;;;;56374:17;;-1:-1:-1;56404:16:0;;::::2;::::0;::::2;::::0;:41;;;;;56374:17:::2;::::0;56404:41;;;;;;;;-1:-1:-1;56404:16:0;:41;::::2;;::::0;::::2;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;::::0;::::2;;-1:-1:-1::0;;;;;;;56458:6:0::2;:22;;56495:6:::0;56516;56537;56558:1:::2;::::0;56598:4:::2;56618:24;:15;56638:3;56618:19;:24::i;:::-;56458:195;;;;;;;;;;;;;-1:-1:-1::0;;;;;56458:195:0::2;;;;;;-1:-1:-1::0;;;;;56458:195:0::2;;;;;;;;;;;;;;;;;;;;;-1:-1:-1::0;;;;;56458:195:0::2;;;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;::::0;::::2;;-1:-1:-1::0;;56458:195:0;56688:39;;-1:-1:-1;;;56688:39:0;;56721:4:::2;56688:39;::::0;::::2;::::0;;;56731:12;;-1:-1:-1;;;;;56688:24:0;::::2;::::0;::::2;::::0;:39;;;;;56458:195:::2;::::0;56688:39;;;;;;;;:24;:39;::::2;;::::0;::::2;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;::::0;::::2;;-1:-1:-1::0;56688:39:0;:55:::2;;56666:152;;;;-1:-1:-1::0;;;56666:152:0::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;56894:12;56858:6;-1:-1:-1::0;;;;;56851:24:0::2;;56884:4;56851:39;;;;;;;;;;;;;-1:-1:-1::0;;;;;56851:39:0::2;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;::::0;::::2;;-1:-1:-1::0;56851:39:0;:55:::2;;56829:152;;;;-1:-1:-1::0;;;56829:152:0::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;57058:1;57044:15:::0;;;57070::::2;::::0;::::2;:19:::0;57100:28:::2;57112:8:::0;57122:5;57100:11:::2;:28::i;:::-;57142:19;57163::::0;57186:164:::2;57222:5;57249:6;57278;57300:12;57327;57186:21;:164::i;:::-;57141:209;;;;57446:8;-1:-1:-1::0;;;;;57368:171:0::2;57413:10;-1:-1:-1::0;;;;;57368:171:0::2;57393:5;-1:-1:-1::0;;;;;57368:171:0::2;;57470:6;57491:11;57517;57368:171;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1::0;;29461:1:0::1;30423:22:::0;;-1:-1:-1;;;;;;;;;;54204:3343:0:o;43102:36::-;;;:::o;53866:100::-;53925:33;53937:8;53947:10;53925:11;:33::i;43423:::-;;;;:::o;59901:138::-;24498:12;:10;:12::i;:::-;-1:-1:-1;;;;;24487:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;24487:23:0;;24479:68;;;;;-1:-1:-1;;;24479:68:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;24479:68:0;;;;;;;;;;;;;;;59971:8:::1;:20:::0;;-1:-1:-1;;;;;59971:20:0;::::1;-1:-1:-1::0;;;;;;59971:20:0;;::::1;::::0;::::1;::::0;;;60009:22:::1;::::0;;;;;;::::1;::::0;;;;::::1;::::0;;::::1;59901:138:::0;:::o;25221:244::-;24498:12;:10;:12::i;:::-;-1:-1:-1;;;;;24487:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;24487:23:0;;24479:68;;;;;-1:-1:-1;;;24479:68:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;24479:68:0;;;;;;;;;;;;;;;-1:-1:-1;;;;;25310:22:0;::::1;25302:73;;;;-1:-1:-1::0;;;25302:73:0::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;25412:6;::::0;;25391:38:::1;::::0;-1:-1:-1;;;;;25391:38:0;;::::1;::::0;25412:6;::::1;::::0;25391:38:::1;::::0;::::1;25440:6;:17:::0;;-1:-1:-1;;;;;;25440:17:0::1;-1:-1:-1::0;;;;;25440:17:0;;;::::1;::::0;;;::::1;::::0;;25221:244::o;50434:1702::-;-1:-1:-1;;;;;50532:27:0;;50508:21;50532:27;;;:8;:27;;;;;;;;50560:10;50532:39;;;;;;;50615:11;;50604:22;;;50582:119;;;;-1:-1:-1;;;50582:119:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;50738:29:0;;50714:21;50738:29;;;:10;:29;;;;;50794:8;;50873;;50869:929;;50921:38;;;-1:-1:-1;;;50921:38:0;;;;;;;;50953:4;50921:38;;;;;;50899:16;;-1:-1:-1;;;;;50921:9:0;:18;;;;:38;;;;;;;;;;;:18;:38;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;50921:38:0;;51022:40;;-1:-1:-1;;;51022:40:0;;;;;;;;51056:4;51022:40;;;;;;50921:38;;-1:-1:-1;51001:18:0;;-1:-1:-1;;;;;51022:9:0;:20;;;;:40;;;;;50921:38;;51022:40;;;;;;;:20;:40;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;51022:40:0;;-1:-1:-1;51081:14:0;;;;;:30;;;51110:1;51099:8;:12;51081:30;51077:261;;;51226:96;51269:34;51294:8;51269:20;:10;51284:4;51269:14;:20::i;51226:96::-;51207:16;;;:115;51077:261;51430:9;-1:-1:-1;;;;;51430:18:0;;51449:3;51454:7;51430:32;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;51479:15;51497:96;51563:4;:15;;;51497:43;51535:4;51497:33;51513:4;:16;;;51497:4;:11;;;:15;;:33;;;;:::i;:96::-;51479:114;-1:-1:-1;51614:11:0;;51610:177;;51646:11;51660:46;51688:8;51698:7;51660:27;:46::i;:::-;51646:60;-1:-1:-1;51725:46:0;51742:10;51754:16;:7;51646:60;51754:11;:16::i;51725:46::-;51610:177;;50869:929;;;;51814:11;;51810:183;;51856:11;;:24;;51872:7;51856:15;:24::i;:::-;51842:38;;51895;;;-1:-1:-1;;;51895:38:0;;51913:10;51895:38;;;;;;;;;;;;-1:-1:-1;;;;;51895:17:0;;;;;:38;;;;;;;;;;;;;;51842:11;51895:17;:38;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;51948:33:0;;-1:-1:-1;51960:8:0;51970:10;51948:11;:33::i;:::-;52037:16;;;;52021:11;;:43;;52059:4;;52021:33;;:15;:33::i;:43::-;52003:15;;;:61;52080:48;;;;;;;;-1:-1:-1;;;;;52080:48:0;;;52089:10;;52080:48;;;;;;;;;50434:1702;;;;;:::o;43145:34::-;;;:::o;22798:106::-;22886:10;22798:106;:::o;27622:120::-;27166:8;:6;:8::i;:::-;27158:41;;;;;-1:-1:-1;;;27158:41:0;;;;;;;;;;;;-1:-1:-1;;;27158:41:0;;;;;;;;;;;;;;;27681:7:::1;:15:::0;;-1:-1:-1;;27681:15:0::1;::::0;;27712:22:::1;27721:12;:10;:12::i;:::-;27712:22;::::0;;-1:-1:-1;;;;;27712:22:0;;::::1;::::0;;;;;;;::::1;::::0;;::::1;27622:120::o:0;2898:179::-;2956:7;2988:5;;;3012:6;;;;3004:46;;;;;-1:-1:-1;;;3004:46:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;3068:1;2898:179;-1:-1:-1;;;2898:179:0:o;32344:607::-;32498:12;32524:14;32540;32558:26;32569:6;32577;32558:10;:26::i;:::-;32803:32;;;-1:-1:-1;;32803:32:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;32793:43;;;;;;-1:-1:-1;;;;;;32682:216:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;32650:267:0;;;;;;;;32344:607;-1:-1:-1;;;32344:607:0:o;3777:220::-;3835:7;3859:6;3855:20;;-1:-1:-1;3874:1:0;3867:8;;3855:20;3898:5;;;3902:1;3898;:5;:1;3922:5;;;;;:10;3914:56;;;;-1:-1:-1;;;3914:56:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4475:153;4533:7;4565:1;4561;:5;4553:44;;;;;-1:-1:-1;;;4553:44:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;4619:1;4615;:5;;;;;;;4475:153;-1:-1:-1;;;4475:153:0:o;3360:158::-;3418:7;3451:1;3446;:6;;3438:49;;;;;-1:-1:-1;;;3438:49:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;3505:5:0;;;3360:158::o;63335:381::-;63441:7;;63496:8;;63492:194;;63527:41;43355:5;63527:24;63536:14;;63527:4;:8;;:24;;;;:::i;:41::-;63602:8;;63521:47;;-1:-1:-1;63585:31:0;;-1:-1:-1;;;;;63585:3:0;:16;;;63602:8;63521:47;63585:16;:31::i;:::-;63636:38;;;;;;;;-1:-1:-1;;;;;63636:38:0;;;;;;;;;;;;;63705:3;63335:381;-1:-1:-1;;;63335:381:0:o;19085:177::-;19195:58;;;-1:-1:-1;;;;;19195:58:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;19195:58:0;-1:-1:-1;;;19195:58:0;;;19168:86;;19188:5;;19168:19;:86::i;:::-;19085:177;;;:::o;60983:310::-;-1:-1:-1;;;;;61082:27:0;;;61058:21;61082:27;;;:8;:27;;;;;;;;:34;;;;;;;;;;;;61127:19;;;:27;;-1:-1:-1;;61127:27:0;;;61165:17;;;:21;;;61197:17;;;:21;;;61234:51;;;;;;;;;;;;;;;;;;;61082:34;;;61234:51;;;;;;;;;60983:310;;;:::o;39472:947::-;39670:20;39692;39726:17;39745;39766:124;39803:7;39825:6;39846;39867:12;39766:22;:124::i;:::-;39725:165;;;;39901:13;39940:57;39959:7;39968:6;39976;39984:12;39940:18;:57::i;:::-;39901:107;;40019:10;40072:1;-1:-1:-1;;;;;40032:42:0;40044:7;-1:-1:-1;;;;;40032:26:0;;:28;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;40032:28:0;-1:-1:-1;;;;;40032:42:0;;;;-1:-1:-1;40085:13:0;40032:42;40101:24;;40124:1;40101:24;;;40109:4;-1:-1:-1;;;;;40109:10:0;;:12;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;40109:12:0;40101:24;40085:40;;40136:19;40158:4;-1:-1:-1;;;;;40158:16:0;;:18;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;40158:18:0;;-1:-1:-1;40207:204:0;40247:9;40275;40158:18;40333:15;40367:5;40391;40207:21;:204::i;:::-;40187:224;;;;;;;;;;39472:947;;;;;;;;:::o;27363:118::-;26889:8;:6;:8::i;:::-;26888:9;26880:38;;;;;-1:-1:-1;;;26880:38:0;;;;;;;;;;;;-1:-1:-1;;;26880:38:0;;;;;;;;;;;;;;;27423:7:::1;:14:::0;;-1:-1:-1;;27423:14:0::1;27433:4;27423:14;::::0;;27453:20:::1;27460:12;:10;:12::i;63819:413::-:0;63956:7;;64008:8;;64004:198;;64039:39;43355:5;64039:22;64048:12;;64039:4;:8;;:22;;;;:::i;:39::-;64033:45;-1:-1:-1;64095:30:0;-1:-1:-1;;;;;64095:3:0;:16;64112:7;64033:45;64095:16;:30::i;:::-;64177:7;-1:-1:-1;;;;;64145:45:0;64166:8;-1:-1:-1;;;;;64145:45:0;;64186:3;64145:45;;;;;;;;;;;;;;;;;;64004:198;64221:3;63819:413;-1:-1:-1;;;;63819:413:0:o;61854:1374::-;62048:19;62069;62141:27;62171:7;-1:-1:-1;;;;;62171:17:0;;62189:5;62171:24;;;;;;;;;;;;;-1:-1:-1;;;;;62171:24:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;62171:24:0;62236;;;-1:-1:-1;;;62236:24:0;;-1:-1:-1;;;;;62236:24:0;;;;;;;;;62171;;-1:-1:-1;62206:27:0;;62236:17;;;;;;:24;;;;;62171;;62236;;;;;;;;:17;:24;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;62236:24:0;62348:32;;;-1:-1:-1;;;62348:32:0;;62374:4;62348:32;;;;;;62236:24;;-1:-1:-1;62328:17:0;;-1:-1:-1;;;;;62348:17:0;;;;;:32;;;;;62236:24;;62348:32;;;;;;;:17;:32;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;62348:32:0;62411;;;-1:-1:-1;;;62411:32:0;;62437:4;62411:32;;;;;;62348;;-1:-1:-1;62391:17:0;;-1:-1:-1;;;;;62411:17:0;;;;;:32;;;;;62348;;62411;;;;;;;:17;:32;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;62411:32:0;;-1:-1:-1;62454:38:0;-1:-1:-1;;;;;62454:20:0;;62475:5;62482:9;62454:20;:38::i;:::-;62503;-1:-1:-1;;;;;62503:20:0;;62524:5;62531:9;62503:20;:38::i;:::-;62593:26;62622:7;-1:-1:-1;;;;;62622:17:0;;62640:5;62622:24;;;;;;;;;;;;;-1:-1:-1;;;;;62622:24:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;62622:24:0;62686;;;-1:-1:-1;;;62686:24:0;;-1:-1:-1;;;;;62686:24:0;;;;;;;;;62622;;-1:-1:-1;62657:26:0;;62686:17;;;;;;:24;;;;;62622;;62686;;;;;;;;:17;:24;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;62686:24:0;;-1:-1:-1;62819:43:0;:18;62842:19;62819:22;:43::i;:::-;62805:57;;62910:13;62895:11;:28;;62873:133;;;;-1:-1:-1;;;62873:133:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;63033:43;:18;63056:19;63033:22;:43::i;:::-;63019:57;;63124:13;63109:11;:28;;63087:133;;;;-1:-1:-1;;;63087:133:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;61854:1374;;;;;;;;;;;;;;:::o;31857:395::-;31959:14;31975;32025:6;-1:-1:-1;;;;;32015:16:0;:6;-1:-1:-1;;;;;32015:16:0;;;32007:60;;;;;-1:-1:-1;;;32007:60:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;32106:6;-1:-1:-1;;;;;32097:15:0;:6;-1:-1:-1;;;;;32097:15:0;;:79;;32161:6;32169;32097:79;;;32129:6;32137;32097:79;32078:98;;-1:-1:-1;32078:98:0;-1:-1:-1;;;;;;32195:20:0;;32187:57;;;;;-1:-1:-1;;;32187:57:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;31857:395;;;;;:::o;21390:761::-;21814:23;21840:69;21868:4;21840:69;;;;;;;;;;;;;;;;;21848:5;-1:-1:-1;;;;;21840:27:0;;;:69;;;;;:::i;:::-;21924:17;;21814:95;;-1:-1:-1;21924:21:0;21920:224;;22066:10;22055:30;;;;;;;;;;;;;;;-1:-1:-1;22055:30:0;22047:85;;;;-1:-1:-1;;;22047:85:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;33009:528;33167:16;33185;33215:14;33235:26;33246:6;33254;33235:10;:26::i;:::-;33214:47;;;33273:16;33291;33336:46;33344:7;33353:6;33361;33369:12;33336:7;:46::i;:::-;-1:-1:-1;;;;;33313:92:0;;:94;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;33313:94:0;;;;;;;33272:135;;;;;-1:-1:-1;33272:135:0;;-1:-1:-1;;;;;;33441:16:0;;;;;;;:88;;33510:8;33520;33441:88;;;33474:8;33484;33441:88;33418:111;;;;-1:-1:-1;33009:528:0;-1:-1:-1;;;;;;;;33009:528:0:o;38135:1070::-;38361:20;38383;38420:5;:18;;;;;38437:1;38429:5;:9;38420:18;38416:635;;;38455:13;38471:41;38487:24;:9;38501;38487:13;:24::i;:::-;38471:15;:41::i;:::-;38455:57;;38527:17;38547:22;38563:5;38547:15;:22::i;:::-;38527:42;;38596:9;38588:5;:17;38584:456;;;38647:11;38626:18;38698:20;:5;38708:9;38698;:20::i;:::-;38677:41;-1:-1:-1;38737:19:0;38759:27;38776:9;38759:12;:5;38769:1;38759:9;:12::i;:::-;:16;;:27::i;:::-;38737:49;;38805:20;38828:134;38866:10;38899;38932:11;38828:15;:134::i;:::-;38805:157;-1:-1:-1;38995:29:0;:11;38805:157;38995:15;:29::i;:::-;38981:43;;38584:456;;;;;38416:635;;;39116:11;39083:30;:9;39097:15;39083:13;:30::i;:::-;:44;;;;;;39175:11;39142:30;:9;39156:15;39142:13;:30::i;:::-;:44;;;;;;39061:136;;;;38135:1070;;;;;;;;;:::o;14076:195::-;14179:12;14211:52;14233:6;14241:4;14247:1;14250:12;14211:21;:52::i;34938:1239::-;34986:7;35010:6;35006:20;;-1:-1:-1;35025:1:0;35018:8;;35006:20;35204:1;35228;-1:-1:-1;;;35244:41:0;;35240:107;;35309:3;35302:10;;;;;35333:2;35327:8;35240:107;35367:19;35361:2;:25;35357:90;;35410:2;35403:9;;;;;35433:2;35427:8;35357:90;35467:11;35461:2;:17;35457:82;;35502:2;35495:9;;;;;35525:2;35519:8;35457:82;35559:7;35553:2;:13;35549:77;;35590:2;35583:9;;;;;35613:1;35607:7;35549:77;35646:5;35640:2;:11;35636:74;;35675:1;35668:8;;;;;35697:1;35691:7;35636:74;35730:4;35724:2;:10;35720:73;;35758:1;35751:8;;;;;35780:1;35774:7;35720:73;35813:3;35807:2;:9;35803:49;;35839:1;35833:7;35803:49;35881:1;35875;35871;:5;;;;;;35867:1;:9;35866:16;;35862:20;;35912:1;35906;35902;:5;;;;;;35898:1;:9;35897:16;;35893:20;;35943:1;35937;35933;:5;;;;;;35929:1;:9;35928:16;;35924:20;;35974:1;35968;35964;:5;;;;;;35960:1;:9;35959:16;;35955:20;;36005:1;35999;35995;:5;;;;;;35991:1;:9;35990:16;;35986:20;;36036:1;36030;36026;:5;;;;;;36022:1;:9;36021:16;;36017:20;;36067:1;36061;36057;:5;;;;;;36053:1;:9;36052:16;;36048:20;;36116:10;36133:1;36129;:5;;;;;;36116:18;;36157:2;36153:1;:6;:15;;36166:2;36153:15;;;36162:1;36153:15;36145:24;;;;;34938:1239;;;;:::o;37232:388::-;37338:7;37359:9;37370;37383:13;37391:1;37394;37383:7;:13::i;:::-;37358:38;;;;37409:10;37435:1;37422:15;;;;;37432:1;37429;37422:15;37409:28;;37457:1;37452:2;:6;37448:18;;;37465:1;37460:6;;;;37448:18;37477:7;;;;;37501:6;37497:24;;37520:1;37516;:5;;;;;;37509:12;;;;;;;37497:24;37546:1;37542;:5;37534:44;;;;;-1:-1:-1;;;37534:44:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;37596:16;37604:1;37607;37610;37596:7;:16::i;:::-;37589:23;37232:388;-1:-1:-1;;;;;;;37232:388:0:o;15128:530::-;15255:12;15313:5;15288:21;:30;;15280:81;;;;-1:-1:-1;;;15280:81:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;15380:18;15391:6;15380:10;:18::i;:::-;15372:60;;;;;-1:-1:-1;;;15372:60:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;15506:12;15520:23;15547:6;-1:-1:-1;;;;;15547:11:0;15567:5;15575:4;15547:33;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;15547:33:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;15505:75;;;;15598:52;15616:7;15625:10;15637:12;15598:17;:52::i;36491:243::-;36580:9;;;-1:-1:-1;;36641:1:0;36638;36631:25;36618:38;;36675:1;36671;:5;36667:9;;36696:1;36691:2;:6;36687:10;;36717:1;36712:2;:6;36708:18;;;36725:1;36720:6;;;;36708:18;36491:243;;;;;;:::o;36742:482::-;36848:7;36887:2;;;36883:6;;;36888:1;36883:6;36900:9;;;;;;;36925:4;36920:9;;;;;;;;;36960:4;36952;36951:5;;36950:14;;;;;37009:1;:9;;;37038:5;;;37034:9;;37029:14;37063:5;;;37059:9;;37054:14;37088:5;;;37084:9;;37079:14;37113:5;;;37109:9;;37104:14;37138:5;;;37134:9;;37129:14;37163:5;;;37159:9;;37154:14;37188:5;;;37184:9;;37179:14;;;36950;;36967:1;36950:18;36945:24;;;;36940:29;;;;37211:5;;36742:482;-1:-1:-1;;36742:482:0:o;11158:422::-;11525:20;11564:8;;;11158:422::o;17668:742::-;17783:12;17812:7;17808:595;;;-1:-1:-1;17843:10:0;17836:17;;17808:595;17957:17;;:21;17953:439;;18220:10;18214:17;18281:15;18268:10;18264:2;18260:19;18253:44;18168:148;18363:12;18356:20;;-1:-1:-1;;;18356:20:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

ipfs://8d7decf6cc7b50fb255cf6f418cace906204ceca3e695794ce484eb98c8917b5