Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

More Options

• Similar
• Submit Audit
• Compare

/**
 *Submitted for verification at moonbeam.moonscan.io on 2022-02-07
*/

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

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)

pragma solidity ^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 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) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }
}


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


// OpenZeppelin Contracts v4.4.1 (access/Ownable.sol)

pragma solidity ^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() {
        _transferOwnership(_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 {
        _transferOwnership(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");
        _transferOwnership(newOwner);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Internal function without access restriction.
     */
    function _transferOwnership(address newOwner) internal virtual {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}


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


// OpenZeppelin Contracts v4.4.1 (token/ERC20/IERC20.sol)

pragma solidity ^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]


// OpenZeppelin Contracts v4.4.1 (utils/Address.sol)

pragma solidity ^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;
        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");

        (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");

        (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");

        (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");

        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason using the provided one.
     *
     * _Available since v4.3._
     */
    function verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal 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

                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}


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


// OpenZeppelin Contracts v4.4.1 (token/ERC20/utils/SafeERC20.sol)

pragma solidity ^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 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'
        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) + value;
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
    }

    function safeDecreaseAllowance(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        unchecked {
            uint256 oldAllowance = token.allowance(address(this), spender);
            require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
            uint256 newAllowance = oldAllowance - value;
            _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
        }
    }

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must 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
            require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
        }
    }
}


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


// OpenZeppelin Contracts v4.4.1 (security/ReentrancyGuard.sol)

pragma solidity ^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() {
        _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 making 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 @openzeppelin/contracts/utils/structs/[email protected]


// OpenZeppelin Contracts v4.4.1 (utils/structs/EnumerableSet.sol)

pragma solidity ^0.8.0;

/**
 * @dev Library for managing
 * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive
 * types.
 *
 * Sets have the following properties:
 *
 * - Elements are added, removed, and checked for existence in constant time
 * (O(1)).
 * - Elements are enumerated in O(n). No guarantees are made on the ordering.
 *
 * ```
 * contract Example {
 *     // Add the library methods
 *     using EnumerableSet for EnumerableSet.AddressSet;
 *
 *     // Declare a set state variable
 *     EnumerableSet.AddressSet private mySet;
 * }
 * ```
 *
 * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)
 * and `uint256` (`UintSet`) are supported.
 */
library EnumerableSet {
    // To implement this library for multiple types with as little code
    // repetition as possible, we write it in terms of a generic Set type with
    // bytes32 values.
    // The Set implementation uses private functions, and user-facing
    // implementations (such as AddressSet) are just wrappers around the
    // underlying Set.
    // This means that we can only create new EnumerableSets for types that fit
    // in bytes32.

    struct Set {
        // Storage of set values
        bytes32[] _values;
        // Position of the value in the `values` array, plus 1 because index 0
        // means a value is not in the set.
        mapping(bytes32 => uint256) _indexes;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function _add(Set storage set, bytes32 value) private returns (bool) {
        if (!_contains(set, value)) {
            set._values.push(value);
            // The value is stored at length-1, but we add 1 to all indexes
            // and use 0 as a sentinel value
            set._indexes[value] = set._values.length;
            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function _remove(Set storage set, bytes32 value) private returns (bool) {
        // We read and store the value's index to prevent multiple reads from the same storage slot
        uint256 valueIndex = set._indexes[value];

        if (valueIndex != 0) {
            // Equivalent to contains(set, value)
            // To delete an element from the _values array in O(1), we swap the element to delete with the last one in
            // the array, and then remove the last element (sometimes called as 'swap and pop').
            // This modifies the order of the array, as noted in {at}.

            uint256 toDeleteIndex = valueIndex - 1;
            uint256 lastIndex = set._values.length - 1;

            if (lastIndex != toDeleteIndex) {
                bytes32 lastvalue = set._values[lastIndex];

                // Move the last value to the index where the value to delete is
                set._values[toDeleteIndex] = lastvalue;
                // Update the index for the moved value
                set._indexes[lastvalue] = valueIndex; // Replace lastvalue's index to valueIndex
            }

            // Delete the slot where the moved value was stored
            set._values.pop();

            // Delete the index for the deleted slot
            delete set._indexes[value];

            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function _contains(Set storage set, bytes32 value) private view returns (bool) {
        return set._indexes[value] != 0;
    }

    /**
     * @dev Returns the number of values on the set. O(1).
     */
    function _length(Set storage set) private view returns (uint256) {
        return set._values.length;
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function _at(Set storage set, uint256 index) private view returns (bytes32) {
        return set._values[index];
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function _values(Set storage set) private view returns (bytes32[] memory) {
        return set._values;
    }

    // Bytes32Set

    struct Bytes32Set {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {
        return _add(set._inner, value);
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {
        return _remove(set._inner, value);
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {
        return _contains(set._inner, value);
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(Bytes32Set storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {
        return _at(set._inner, index);
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(Bytes32Set storage set) internal view returns (bytes32[] memory) {
        return _values(set._inner);
    }

    // AddressSet

    struct AddressSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(AddressSet storage set, address value) internal returns (bool) {
        return _add(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(AddressSet storage set, address value) internal returns (bool) {
        return _remove(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(AddressSet storage set, address value) internal view returns (bool) {
        return _contains(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(AddressSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(AddressSet storage set, uint256 index) internal view returns (address) {
        return address(uint160(uint256(_at(set._inner, index))));
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(AddressSet storage set) internal view returns (address[] memory) {
        bytes32[] memory store = _values(set._inner);
        address[] memory result;

        assembly {
            result := store
        }

        return result;
    }

    // UintSet

    struct UintSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(UintSet storage set, uint256 value) internal returns (bool) {
        return _add(set._inner, bytes32(value));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(UintSet storage set, uint256 value) internal returns (bool) {
        return _remove(set._inner, bytes32(value));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(UintSet storage set, uint256 value) internal view returns (bool) {
        return _contains(set._inner, bytes32(value));
    }

    /**
     * @dev Returns the number of values on the set. O(1).
     */
    function length(UintSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(UintSet storage set, uint256 index) internal view returns (uint256) {
        return uint256(_at(set._inner, index));
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(UintSet storage set) internal view returns (uint256[] memory) {
        bytes32[] memory store = _values(set._inner);
        uint256[] memory result;

        assembly {
            result := store
        }

        return result;
    }
}


// File contracts/autocompounder/interfaces/IYieldOwlStrategy.sol



pragma solidity 0.8.4;

interface IYieldOwlStrategy {
    function stakeToken() external view returns (address);

    function sharesTotal() external view returns (uint256);

    function earn(address _bountyHunter) external returns (uint256);

    function deposit(uint256 _depositAmount) external returns (uint256);

    function withdraw(
        uint256 _withdrawAmount,
        address _withdrawTo,
        address _bountyHunter,
        uint256 _ruleFeeAmount
    ) external returns (uint256);

    function router() external view returns (address);

    function token0() external view returns (address);

    function token1() external view returns (address);

    function totalStakeTokens() external view returns (uint256);

    function setSwapRouterEnabled(bool _enabled) external;

    function setSwapPath(
        address _token0,
        address _token1,
        address[] calldata _path
    ) external;

    function setExtraEarnTokens(address[] calldata _extraEarnTokens) external;
}


// File contracts/autocompounder/interfaces/IYieldOwlCondition.sol



pragma solidity 0.8.4;

interface IYieldOwlCondition {
    function isCondition() external view returns (bool);

    function check(
        address strategy,
        address user,
        uint256 pid,
        uint256[] memory intInputs,
        address[] memory addrInputs
    ) external view returns (bool);
}


// File contracts/autocompounder/interfaces/IYieldOwlAction.sol



pragma solidity 0.8.4;

interface IYieldOwlAction {
    function isAction() external view returns (bool);

    function execute(
        address strategy,
        address user,
        uint256 pid,
        uint256[] memory intInputs,
        address[] memory addrInputs
    ) external view returns (uint256, address);

    function callback(
        address strategy,
        address user,
        uint256 pid,
        uint256[] memory intInputs,
        address[] memory addrInputs
    ) external;
}


// File contracts/autocompounder/yieldowl.sol



pragma solidity 0.8.4;
/**
 * @title YieldOwl Staking Contract
 * @notice handles deposits, withdraws, strategy execution and bounty rewards
 * @author YieldOwl
 */
contract YieldOwl is Ownable, ReentrancyGuard {
    using SafeERC20 for IERC20;
    using EnumerableSet for EnumerableSet.UintSet;

    struct Rule {
        address condition; // address of the rule condition
        uint256[] conditionIntInputs; // numeric inputs sent to the rule condition
        address[] conditionAddrInputs; // address inputs sent to the rule condition
        address action; // address of the rule action
        uint256[] actionIntInputs; // numeric inputs sent to the rule action
        address[] actionAddrInputs; // address inputs sent to the rule action
    }

    struct UserInfo {
        uint256 shares; // total of shares the user has on the pool
        Rule[] rules; // list of rules applied to the pool
    }

    struct PoolInfo {
        IERC20 stakeToken; // address of the token staked on the underlying farm
        IYieldOwlStrategy strategy; // address of the strategy for the pool
    }

    PoolInfo[] public poolInfo; // info of each pool
    mapping(uint256 => mapping(address => UserInfo)) public userInfo; // info of each user that stakes tokens
    mapping(address => EnumerableSet.UintSet) private userStakedPools; // all pools in which a user has tokens staked
    mapping(address => bool) public strategyExists; // map used to ensure strategies cannot be added twice

    uint256 constant DEPOSIT_FEE_CAP = 500;
    uint256 public depositFee = 0;

    uint256 constant WITHDRAW_FEE_CAP = 500;
    uint256 public withdrawFee = 50;

    uint256 constant PERFORMANCE_FEE_CAP = 500;
    uint256 public performanceFee = 100;
    uint256 public performanceFeeBountyPct = 1000;

    uint256 constant RULE_EXECUTION_FEE_CAP = 500;
    uint256 public ruleFee = 20;
    uint256 public ruleFeeBountyPct = 5000;

    uint256 constant MAX_USER_RULES_PER_POOL = 50;

    address public feeAddress;
    address public feeAddressSetter;

    bool private executeRuleLocked;

    // addresses allowed to operate the strategy, including pausing and unpausing it in case of emergency
    mapping(address => bool) public operators;

    event Add(IERC20 stakeToken, IYieldOwlStrategy strategy);
    event Deposit(address indexed user, uint256 indexed pid, uint256 amount);
    event Withdraw(address indexed user, address indexed to, uint256 indexed pid, uint256 amount);
    event AddRule(address indexed user, uint256 indexed pid);
    event RemoveRule(address indexed user, uint256 indexed pid, uint256 ruleIndex);
    event Earn(address indexed user, uint256 indexed pid, uint256 bountyReward);
    event ExecuteRule(uint256 indexed pid, address indexed user, uint256 ruleIndex);
    event SetOperator(address addr, bool isOperator);
    event SetDepositFee(uint256 depositFee);
    event SetWithdrawFee(uint256 withdrawFee);
    event SetPerformanceFee(uint256 performanceFee);
    event SetPerformanceFeeBountyPct(uint256 performanceFeeBountyPct);
    event SetRuleFee(uint256 ruleFee);
    event SetRuleFeeBountyPct(uint256 ruleFeeBountyPct);
    event SetStrategyRouter(IYieldOwlStrategy strategy, address router);
    event SetStrategySwapRouterEnabled(IYieldOwlStrategy strategy, bool enabled);
    event SetStrategySwapPath(IYieldOwlStrategy _strategy, address _token0, address _token1, address[] _path);
    event SetStrategyExtraEarnTokens(IYieldOwlStrategy _strategy, address[] _extraEarnTokens);
    event SetFeeAddress(address feeAddress);
    event SetFeeAddressSetter(address feeAddressSetter);

    modifier onlyOperator() {
        require(operators[msg.sender], 'onlyOperator: NOT_ALLOWED');
        _;
    }

    modifier onlyEndUser() {
        require(!Address.isContract(msg.sender) && tx.origin == msg.sender);
        _;
    }

    constructor(address _feeAddress) {
        operators[msg.sender] = true;
        feeAddressSetter = msg.sender;
        feeAddress = _feeAddress;
    }

    /**
     * @notice returns how many pools have been added
     */
    function poolLength() external view returns (uint256) {
        return poolInfo.length;
    }

    /**
     * @notice returns in how many pools a user has tokens staked
     * @param _user address of the user
     */
    function userStakedPoolLength(address _user) external view returns (uint256) {
        return userStakedPools[_user].length();
    }

    /**
     * @notice returns the pid of a pool in which the user has tokens staked
     * @dev helper for iterating over the array of user staked pools
     * @param _user address of the user
     * @param _index the index in the array of user staked pools
     */
    function userStakedPoolAt(address _user, uint256 _index) external view returns (uint256) {
        return userStakedPools[_user].at(_index);
    }

    /**
     * @notice returns a rule by pid, user and index
     * @dev helper for iterating over all the rules
     * @param _pid the pool id
     * @param _user address of the user
     * @param _ruleIndex the index of the rule
     */
    function userPoolRule(
        uint256 _pid,
        address _user,
        uint256 _ruleIndex
    ) external view returns (Rule memory rule) {
        rule = userInfo[_pid][_user].rules[_ruleIndex];
    }

    /**
     * @notice returns the number of rule a user has for a given pool
     * @param _pid the pool id
     * @param _user address of the user
     */
    function userRuleLength(uint256 _pid, address _user) external view returns (uint256) {
        return userInfo[_pid][_user].rules.length;
    }

    /**
     * @notice returns the amount of staked tokens by a user
     * @param _pid the pool id
     * @param _user address of the user
     */
    function stakedTokens(uint256 _pid, address _user) public view returns (uint256) {
        PoolInfo memory pool = poolInfo[_pid];
        UserInfo memory user = userInfo[_pid][_user];
        IYieldOwlStrategy strategy = pool.strategy;

        uint256 sharesTotal = strategy.sharesTotal();
        return sharesTotal > 0 ? (user.shares * strategy.totalStakeTokens()) / sharesTotal : 0;
    }

    /**
     * @notice adds a new pool with a given strategy
     * @dev can only be called by an operator
     * @param _strategy address of the strategy
     */
    function add(IYieldOwlStrategy _strategy) public onlyOperator {
        require(!strategyExists[address(_strategy)], 'add: STRATEGY_ALREADY_EXISTS');
        IERC20 stakeToken = IERC20(_strategy.stakeToken());
        poolInfo.push(PoolInfo({stakeToken: stakeToken, strategy: _strategy}));
        strategyExists[address(_strategy)] = true;
        emit Add(stakeToken, _strategy);
    }

    /**
     * @notice adds multiple new pools
     * @dev helper to add many pools at once
     * @param _strategies array of strategy addresses
     */
    function addMany(IYieldOwlStrategy[] calldata _strategies) external onlyOperator {
        for (uint256 i; i < _strategies.length; i++) {
            add(_strategies[i]);
        }
    }

    /**
     * @notice transfers tokens from the user and stakes them in the underlying farm
     * @dev tokens are transferred from msg.sender directly to the strategy
     * @param _pid the pool id
     * @param _depositAmount amount of tokens to transfer from msg.sender
     */
    function deposit(uint256 _pid, uint256 _depositAmount) external {
        _deposit(_pid, _depositAmount, msg.sender);
    }

    /**
     * @notice deposits stake tokens on behalf of another user
     * @param _pid the pool id
     * @param _depositAmount amount of tokens to transfer from msg.sender
     * @param _to address of the beneficiary
     */
    function depositTo(
        uint256 _pid,
        uint256 _depositAmount,
        address _to
    ) external {
        _deposit(_pid, _depositAmount, _to);
    }

    /**
     * @notice unstakes tokens from the underlying farm and transfers them to the user
     * @dev tokens are transferred directly from the strategy to the user
     * @param _pid the pool id
     * @param _withdrawAmount maximum amount of tokens to transfer to msg.sender
     */
    function withdraw(uint256 _pid, uint256 _withdrawAmount) external {
        _withdrawFrom(msg.sender, msg.sender, _pid, _withdrawAmount, address(0), 0, false);
    }

    /**
     * @notice withdraws all the token from msg.sender without harvesting first
     * @dev only for emergencies
     * @param _pid the pool id
     */
    function emergencyWithdraw(uint256 _pid) external {
        _withdrawFrom(msg.sender, msg.sender, _pid, type(uint256).max, address(0), 0, true);
    }

    /**
     * @notice adds a new rule
     * @dev each user can have multiple rules for each pool
     * @param _pid the pool id
     * @param _condition address of the condition contract
     * @param _conditionIntInputs array of integer inputs to be sent to the condition
     * @param _conditionAddrInputs array of address inputs to be sent to the condition
     * @param _action address of the action contract
     * @param _actionIntInputs array of integer inputs to be sent to the action
     * @param _actionAddrInputs array of address inputs to be sent to the action
     */
    function addRule(
        uint256 _pid,
        address _condition,
        uint256[] calldata _conditionIntInputs,
        address[] calldata _conditionAddrInputs,
        address _action,
        uint256[] calldata _actionIntInputs,
        address[] calldata _actionAddrInputs
    ) external {
        UserInfo storage user = userInfo[_pid][msg.sender];

        require(user.rules.length <= MAX_USER_RULES_PER_POOL, 'addRule: CAP_EXCEEDED');
        require(IYieldOwlCondition(_condition).isCondition(), 'addRule: BAD_CONDITION');
        require(IYieldOwlAction(_action).isAction(), 'addRule: BAD_ACTION');

        Rule memory rule;
        rule.condition = _condition;
        rule.conditionIntInputs = _conditionIntInputs;
        rule.conditionAddrInputs = _conditionAddrInputs;
        rule.action = _action;
        rule.actionIntInputs = _actionIntInputs;
        rule.actionAddrInputs = _actionAddrInputs;
        user.rules.push(rule);
        emit AddRule(msg.sender, _pid);
    }

    /**
     * @notice removes a given rule
     * @param _pid the pool id
     * @param _ruleIndex the index of the rule in the user info for the given pool
     */
    function removeRule(uint256 _pid, uint256 _ruleIndex) external {
        UserInfo storage user = userInfo[_pid][msg.sender];
        require(_ruleIndex < user.rules.length, 'removeRule: BAD_INDEX');
        user.rules[_ruleIndex] = user.rules[user.rules.length - 1];
        user.rules.pop();
        emit RemoveRule(msg.sender, _pid, _ruleIndex);
    }

    /**
     * @notice runs the strategy and pays the bounty reward
     * @param _pid the pool id
     */
    function earn(uint256 _pid) external nonReentrant returns (uint256) {
        return _earn(_pid);
    }

    /**
     * @notice runs multiple strategies and pays multiple rewards
     * @param _pids array of pool ids
     */
    function earnMany(uint256[] calldata _pids) external nonReentrant {
        for (uint256 i; i < _pids.length; i++) {
            _earn(_pids[i]);
        }
    }

    /**
     * @notice checks wheter a rule passes its condition
     * @param _pid the pool id
     * @param _user address of the user
     * @param _ruleIndex the index of the rule
     */
    function checkRule(
        uint256 _pid,
        address _user,
        uint256 _ruleIndex
    ) external view returns (bool) {
        Rule memory rule = userInfo[_pid][_user].rules[_ruleIndex];
        return
            IYieldOwlCondition(rule.condition).check(
                address(poolInfo[_pid].strategy),
                _user,
                _pid,
                rule.conditionIntInputs,
                rule.conditionAddrInputs
            );
    }

    /**
     * @notice executes the rule action if the condition passes and sends the bounty reward to msg.sender
     * @param _pid the pool id
     * @param _user address of the user
     * @param _ruleIndex the index of the rule
     */
    function executeRule(
        uint256 _pid,
        address _user,
        uint256 _ruleIndex
    ) external onlyEndUser {
        require(!executeRuleLocked, 'executeRule: LOCKED');
        executeRuleLocked = true;
        UserInfo memory user = userInfo[_pid][_user];
        Rule memory rule = user.rules[_ruleIndex];
        IYieldOwlStrategy strategy = poolInfo[_pid].strategy;

        require(
            IYieldOwlCondition(rule.condition).check(
                address(strategy),
                _user,
                _pid,
                rule.conditionIntInputs,
                rule.conditionAddrInputs
            ),
            'executeAction: CONDITION_NOT_MET'
        );

        _tryEarn(strategy);
        IYieldOwlAction action = IYieldOwlAction(rule.action);
        (uint256 withdrawAmount, address withdrawTo) = action.execute(
            address(strategy),
            _user,
            _pid,
            rule.actionIntInputs,
            rule.actionAddrInputs
        );

        uint256 staked = stakedTokens(_pid, _user);
        if (withdrawAmount > staked) {
            withdrawAmount = staked;
        }

        if (withdrawAmount > 0) {
            uint256 ruleFeeAmount = (withdrawAmount * ruleFee) / 10000;
            _withdrawFrom(_user, withdrawTo, _pid, withdrawAmount, msg.sender, ruleFeeAmount, true);
        }
        action.callback(address(strategy), _user, _pid, rule.actionIntInputs, rule.actionAddrInputs);
        executeRuleLocked = false;
        emit ExecuteRule(_pid, _user, _ruleIndex);
    }

    /**
     * @notice adds or removes an operator
     * @dev can only be called by the owner
     * @param _addr address of the operator
     * @param _isOperator whether the given address will be set as an operator
     */
    function setOperator(address _addr, bool _isOperator) external onlyOwner {
        operators[_addr] = _isOperator;
        emit SetOperator(_addr, _isOperator);
    }

    /**
     * @notice updates the deposit fee
     * @dev can only be called by the owner
     * @param _depositFee new deposit fee in basis points
     */
    function setDepositFee(uint256 _depositFee) external onlyOwner {
        require(_depositFee <= DEPOSIT_FEE_CAP, 'setDepositFee: CAP_EXCEEDED');
        depositFee = _depositFee;
        emit SetDepositFee(_depositFee);
    }

    /**
     * @notice updates the withdraw fee
     * @dev can only be called by the owner
     * @param _withdrawFee new withdraw fee in basis points
     */
    function setWithdrawFee(uint256 _withdrawFee) external onlyOwner {
        require(_withdrawFee <= WITHDRAW_FEE_CAP, 'setWithdrawFee: CAP_EXCEEDED');
        withdrawFee = _withdrawFee;
        emit SetWithdrawFee(_withdrawFee);
    }

    /**
     * @notice updates the performance fee
     * @dev can only be called by the owner
     * @param _performanceFee new performance fee fee in basis points
     */
    function setPerformanceFee(uint256 _performanceFee) external onlyOwner {
        require(_performanceFee <= PERFORMANCE_FEE_CAP, 'setPerformanceFee: CAP_EXCEEDED');
        performanceFee = _performanceFee;
        emit SetPerformanceFee(_performanceFee);
    }

    /**
     * @notice updates the percentage of the performance fee sent to the bounty hunter
     * @dev can only be called by the owner
     * @param _performanceFeeBountyPct percentage of the performance fee for the bounty hunter in basis points
     */
    function setPerformanceFeeBountyPct(uint256 _performanceFeeBountyPct) external onlyOwner {
        require(_performanceFeeBountyPct <= 10000, 'setPerformanceFeeBountyPct: CAP_EXCEEDED');
        performanceFeeBountyPct = _performanceFeeBountyPct;
        emit SetPerformanceFeeBountyPct(_performanceFeeBountyPct);
    }

    /**
     * @notice updates the rule execution fee
     * @dev can only be called by the owner
     * @param _ruleFee new rule fee fee in basis points
     */
    function setRuleFee(uint256 _ruleFee) external onlyOwner {
        require(_ruleFee <= RULE_EXECUTION_FEE_CAP, 'setRuleFee: CAP_EXCEEDED');
        ruleFee = _ruleFee;
        emit SetRuleFee(_ruleFee);
    }

    /**
     * @notice updates the percentage of the rule execution fee sent to the bounty hunter
     * @dev can only be called by the owner
     * @param _ruleFeeBountyPct percentage of the rule execution fee for the bounty hunter in basis points
     */
    function setRuleFeeBountyPct(uint256 _ruleFeeBountyPct) external onlyOwner {
        require(_ruleFeeBountyPct <= 10000, 'setRuleFeeBountyPct: CAP_EXCEEDED');
        ruleFeeBountyPct = _ruleFeeBountyPct;
        emit SetRuleFeeBountyPct(_ruleFeeBountyPct);
    }

    /**
     * @notice updates the swap router used by a given strategy
     * @dev can only be called by the owner
     * @param _strategy address of the strategy
     * @param _enabled whether to enable or disable the swap router
     */
    function setStrategySwapRouterEnabled(IYieldOwlStrategy _strategy, bool _enabled) external onlyOwner {
        _strategy.setSwapRouterEnabled(_enabled);
        emit SetStrategySwapRouterEnabled(_strategy, _enabled);
    }

    /**
     * @notice updates the swap path for a given pair
     * @dev can only be called by the owner
     * @param _strategy address of the strategy
     * @param _token0 address of token swap from
     * @param _token1 address of token swap to
     * @param _path swap path from token0 to token1
     */
    function setStrategySwapPath(
        IYieldOwlStrategy _strategy,
        address _token0,
        address _token1,
        address[] calldata _path
    ) external onlyOwner {
        require(_path.length != 1, 'setStrategySwapPath: INVALID_PATH');
        if (_path.length > 0) {
            // the first element must be token0 and the last one token1
            require(_path[0] == _token0 && _path[_path.length - 1] == _token1, 'setStrategySwapPath: INVALID_PATH');
        }
        _strategy.setSwapPath(_token0, _token1, _path);
        emit SetStrategySwapPath(_strategy, _token0, _token1, _path);
    }

    /**
     * @notice updates the swap path for a given pair
     * @dev can only be called by the owner
     * @param _strategy address of the strategy
     * @param _extraEarnTokens list of extra earn tokens for farms rewarding more than one token
     */
    function setStrategyExtraEarnTokens(IYieldOwlStrategy _strategy, address[] calldata _extraEarnTokens)
        external
        onlyOwner
    {
        require(_extraEarnTokens.length <= 5, 'setStrategyExtraEarnTokens: CAP_EXCEEDED');

        // tokens sanity check
        for (uint256 i; i < _extraEarnTokens.length; i++) {
            IERC20(_extraEarnTokens[i]).balanceOf(address(this));
        }

        _strategy.setExtraEarnTokens(_extraEarnTokens);
        emit SetStrategyExtraEarnTokens(_strategy, _extraEarnTokens);
    }

    /**
     * @notice updates the fee address
     * @dev can only be called by the fee address setter
     * @param _feeAddress new fee address
     */
    function setFeeAddress(address _feeAddress) external {
        require(msg.sender == feeAddressSetter && _feeAddress != address(0), 'setFeeAddress: NOT_ALLOWED');
        feeAddress = _feeAddress;
        emit SetFeeAddress(_feeAddress);
    }

    /**
     * @notice updates the fee address setter
     * @dev can only be called by the previous fee address setter
     * @param _feeAddressSetter new fee address setter
     */
    function setFeeAddressSetter(address _feeAddressSetter) external {
        require(msg.sender == feeAddressSetter && _feeAddressSetter != address(0), 'setFeeAddressSetter: NOT_ALLOWED');
        feeAddressSetter = _feeAddressSetter;
        emit SetFeeAddressSetter(_feeAddressSetter);
    }

    function _deposit(
        uint256 _pid,
        uint256 _depositAmount,
        address _to
    ) internal nonReentrant {
        require(_depositAmount > 0, 'deposit: MUST_BE_GREATER_THAN_ZERO');
        PoolInfo memory pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][_to];

        if (pool.strategy.sharesTotal() > 0) {
            _tryEarn(pool.strategy);
        }

        // calculate deposit amount from balance before and after the transfer in order to support tokens with tax
        uint256 balanceBefore = pool.stakeToken.balanceOf(address(pool.strategy));
        pool.stakeToken.safeTransferFrom(address(msg.sender), address(pool.strategy), _depositAmount);
        _depositAmount = pool.stakeToken.balanceOf(address(pool.strategy)) - balanceBefore;

        uint256 sharesAdded = pool.strategy.deposit(_depositAmount);
        user.shares = user.shares + sharesAdded;
        userStakedPools[_to].add(_pid);

        emit Deposit(_to, _pid, _depositAmount);
    }

    function _withdrawFrom(
        address _user,
        address _to,
        uint256 _pid,
        uint256 _withdrawAmount,
        address _bountyHunter,
        uint256 _ruleFeeAmount,
        bool _skipEarn
    ) internal nonReentrant {
        require(_withdrawAmount > 0, '_withdrawFrom: MUST_BE_GREATER_THAN_ZERO');
        UserInfo storage user = userInfo[_pid][_user];
        IYieldOwlStrategy strategy = poolInfo[_pid].strategy;

        if (!_skipEarn) {
            _tryEarn(strategy);
        }

        uint256 sharesTotal = strategy.sharesTotal();

        require(user.shares > 0 && sharesTotal > 0, 'withdraw: NO_SHARES');

        uint256 maxAmount = (user.shares * strategy.totalStakeTokens()) / sharesTotal;
        if (_withdrawAmount > maxAmount) {
            _withdrawAmount = maxAmount;
        }
        uint256 sharesRemoved = strategy.withdraw(_withdrawAmount, _to, _bountyHunter, _ruleFeeAmount);
        user.shares = user.shares > sharesRemoved ? user.shares - sharesRemoved : 0;
        if (user.shares == 0) {
            userStakedPools[_user].remove(_pid);
        }

        emit Withdraw(_user, _to, _pid, _withdrawAmount);
    }

    function _earn(uint256 _pid) internal returns (uint256 bountyRewarded) {
        bountyRewarded = poolInfo[_pid].strategy.earn(msg.sender);
        emit Earn(msg.sender, _pid, bountyRewarded);
    }

    function _tryEarn(IYieldOwlStrategy _strategy) internal {
        try _strategy.earn(address(0)) {} catch {}
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_feeAddress","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"contract IERC20","name":"stakeToken","type":"address"},{"indexed":false,"internalType":"contract IYieldOwlStrategy","name":"strategy","type":"address"}],"name":"Add","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"uint256","name":"pid","type":"uint256"}],"name":"AddRule","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"uint256","name":"pid","type":"uint256"},{"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":"uint256","name":"pid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"bountyReward","type":"uint256"}],"name":"Earn","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"pid","type":"uint256"},{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"ruleIndex","type":"uint256"}],"name":"ExecuteRule","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":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"uint256","name":"pid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"ruleIndex","type":"uint256"}],"name":"RemoveRule","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"depositFee","type":"uint256"}],"name":"SetDepositFee","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"feeAddress","type":"address"}],"name":"SetFeeAddress","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"feeAddressSetter","type":"address"}],"name":"SetFeeAddressSetter","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"addr","type":"address"},{"indexed":false,"internalType":"bool","name":"isOperator","type":"bool"}],"name":"SetOperator","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"performanceFee","type":"uint256"}],"name":"SetPerformanceFee","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"performanceFeeBountyPct","type":"uint256"}],"name":"SetPerformanceFeeBountyPct","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"ruleFee","type":"uint256"}],"name":"SetRuleFee","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"ruleFeeBountyPct","type":"uint256"}],"name":"SetRuleFeeBountyPct","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"contract IYieldOwlStrategy","name":"_strategy","type":"address"},{"indexed":false,"internalType":"address[]","name":"_extraEarnTokens","type":"address[]"}],"name":"SetStrategyExtraEarnTokens","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"contract IYieldOwlStrategy","name":"strategy","type":"address"},{"indexed":false,"internalType":"address","name":"router","type":"address"}],"name":"SetStrategyRouter","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"contract IYieldOwlStrategy","name":"_strategy","type":"address"},{"indexed":false,"internalType":"address","name":"_token0","type":"address"},{"indexed":false,"internalType":"address","name":"_token1","type":"address"},{"indexed":false,"internalType":"address[]","name":"_path","type":"address[]"}],"name":"SetStrategySwapPath","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"contract IYieldOwlStrategy","name":"strategy","type":"address"},{"indexed":false,"internalType":"bool","name":"enabled","type":"bool"}],"name":"SetStrategySwapRouterEnabled","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"withdrawFee","type":"uint256"}],"name":"SetWithdrawFee","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"pid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Withdraw","type":"event"},{"inputs":[{"internalType":"contract IYieldOwlStrategy","name":"_strategy","type":"address"}],"name":"add","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IYieldOwlStrategy[]","name":"_strategies","type":"address[]"}],"name":"addMany","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"address","name":"_condition","type":"address"},{"internalType":"uint256[]","name":"_conditionIntInputs","type":"uint256[]"},{"internalType":"address[]","name":"_conditionAddrInputs","type":"address[]"},{"internalType":"address","name":"_action","type":"address"},{"internalType":"uint256[]","name":"_actionIntInputs","type":"uint256[]"},{"internalType":"address[]","name":"_actionAddrInputs","type":"address[]"}],"name":"addRule","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"address","name":"_user","type":"address"},{"internalType":"uint256","name":"_ruleIndex","type":"uint256"}],"name":"checkRule","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_depositAmount","type":"uint256"}],"name":"deposit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"depositFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_depositAmount","type":"uint256"},{"internalType":"address","name":"_to","type":"address"}],"name":"depositTo","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"}],"name":"earn","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"_pids","type":"uint256[]"}],"name":"earnMany","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"}],"name":"emergencyWithdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"address","name":"_user","type":"address"},{"internalType":"uint256","name":"_ruleIndex","type":"uint256"}],"name":"executeRule","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"feeAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"feeAddressSetter","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"operators","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"performanceFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"performanceFeeBountyPct","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"poolInfo","outputs":[{"internalType":"contract IERC20","name":"stakeToken","type":"address"},{"internalType":"contract IYieldOwlStrategy","name":"strategy","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"poolLength","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_ruleIndex","type":"uint256"}],"name":"removeRule","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"ruleFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"ruleFeeBountyPct","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_depositFee","type":"uint256"}],"name":"setDepositFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_feeAddress","type":"address"}],"name":"setFeeAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_feeAddressSetter","type":"address"}],"name":"setFeeAddressSetter","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_addr","type":"address"},{"internalType":"bool","name":"_isOperator","type":"bool"}],"name":"setOperator","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_performanceFee","type":"uint256"}],"name":"setPerformanceFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_performanceFeeBountyPct","type":"uint256"}],"name":"setPerformanceFeeBountyPct","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_ruleFee","type":"uint256"}],"name":"setRuleFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_ruleFeeBountyPct","type":"uint256"}],"name":"setRuleFeeBountyPct","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IYieldOwlStrategy","name":"_strategy","type":"address"},{"internalType":"address[]","name":"_extraEarnTokens","type":"address[]"}],"name":"setStrategyExtraEarnTokens","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IYieldOwlStrategy","name":"_strategy","type":"address"},{"internalType":"address","name":"_token0","type":"address"},{"internalType":"address","name":"_token1","type":"address"},{"internalType":"address[]","name":"_path","type":"address[]"}],"name":"setStrategySwapPath","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IYieldOwlStrategy","name":"_strategy","type":"address"},{"internalType":"bool","name":"_enabled","type":"bool"}],"name":"setStrategySwapRouterEnabled","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_withdrawFee","type":"uint256"}],"name":"setWithdrawFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"address","name":"_user","type":"address"}],"name":"stakedTokens","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"strategyExists","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"address","name":"","type":"address"}],"name":"userInfo","outputs":[{"internalType":"uint256","name":"shares","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"address","name":"_user","type":"address"},{"internalType":"uint256","name":"_ruleIndex","type":"uint256"}],"name":"userPoolRule","outputs":[{"components":[{"internalType":"address","name":"condition","type":"address"},{"internalType":"uint256[]","name":"conditionIntInputs","type":"uint256[]"},{"internalType":"address[]","name":"conditionAddrInputs","type":"address[]"},{"internalType":"address","name":"action","type":"address"},{"internalType":"uint256[]","name":"actionIntInputs","type":"uint256[]"},{"internalType":"address[]","name":"actionAddrInputs","type":"address[]"}],"internalType":"struct YieldOwl.Rule","name":"rule","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"address","name":"_user","type":"address"}],"name":"userRuleLength","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_user","type":"address"},{"internalType":"uint256","name":"_index","type":"uint256"}],"name":"userStakedPoolAt","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_user","type":"address"}],"name":"userStakedPoolLength","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_withdrawAmount","type":"uint256"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdrawFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"}]

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

000000000000000000000000afa4141e10707a095a88c4097df7cbaba5714ba5

-----Decoded View---------------
Arg [0] : _feeAddress (address): 0xafa4141E10707a095a88c4097Df7CBaBa5714Ba5

-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 000000000000000000000000afa4141e10707a095a88c4097df7cbaba5714ba5

36285:22826:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;40299:95;40371:8;:15;40299:95;;;26739:25:1;;;26727:2;26712:18;40299:95:0;;;;;;;;42607:393;;;;;;:::i;:::-;;:::i;:::-;;40528:134;;;;;;:::i;:::-;;:::i;38360:41::-;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;13308:14:1;;13301:22;13283:41;;13271:2;13256:18;38360:41:0;13238:92:1;37247:26:0;;;;;;:::i;:::-;;:::i;:::-;;;;-1:-1:-1;;;;;13605:15:1;;;13587:34;;13657:15;;;;13652:2;13637:18;;13630:43;13522:18;37247:26:0;13504:175:1;55086:547:0;;;;;;:::i;:::-;;:::i;37901:45::-;;;;;;47499:165;;;;;;:::i;:::-;;:::i;41726:145::-;;;;;;:::i;:::-;41802:7;41829:14;;;:8;:14;;;;;;;;-1:-1:-1;;;;;41829:21:0;;;;;;;;;;;:27;;:34;;41726:145;38041:38;;;;;;38142:25;;;;;-1:-1:-1;;;;;38142:25:0;;;;;;-1:-1:-1;;;;;10904:32:1;;;10886:51;;10874:2;10859:18;38142:25:0;10841:102:1;44491:167:0;;;;;;:::i;:::-;;:::i;50774:229::-;;;;;;:::i;:::-;;:::i;44831:152::-;;;;;;:::i;:::-;;:::i;50435:169::-;;;;;;:::i;:::-;;:::i;42032:399::-;;;;;;:::i;:::-;;:::i;38174:31::-;;;;;-1:-1:-1;;;;;38174:31:0;;;52634:212;;;;;;:::i;:::-;;:::i;37686:29::-;;;;;;51600:265;;;;;;:::i;:::-;;:::i;2713:103::-;;;:::i;52136:323::-;;;;;;:::i;:::-;;:::i;53637:225::-;;;;;;:::i;:::-;;:::i;54188:625::-;;;;;;:::i;:::-;;:::i;55800:247::-;;;;;;:::i;:::-;;:::i;37859:35::-;;;;;;53116:267;;;;;;:::i;:::-;;:::i;2062:87::-;2108:7;2135:6;-1:-1:-1;;;;;2135:6:0;2062:87;;37301:64;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;44021:167;;;;;;:::i;:::-;;:::i;41345:211::-;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;43167:190::-;;;;;;:::i;:::-;;:::i;51176:238::-;;;;;;:::i;:::-;;:::i;40943:148::-;;;;;;:::i;:::-;;:::i;46784:359::-;;;;;;:::i;:::-;;:::i;56243:295::-;;;;;;:::i;:::-;;:::i;38007:27::-;;;;;;43653:125;;;;;;:::i;:::-;;:::i;37531:46::-;;;;;;:::i;:::-;;;;;;;;;;;;;;;;48600:1595;;;;;;:::i;:::-;;:::i;47262:105::-;;;;;;:::i;:::-;;:::i;37770:31::-;;;;;;45586:1019;;;;;;:::i;:::-;;:::i;2971:201::-;;;;;;:::i;:::-;;:::i;47869:477::-;;;;;;:::i;:::-;;:::i;42607:393::-;39865:10;39855:21;;;;:9;:21;;;;;;;;39847:59;;;;-1:-1:-1;;;39847:59:0;;15954:2:1;39847:59:0;;;15936:21:1;15993:2;15973:18;;;15966:30;-1:-1:-1;;;16012:18:1;;;16005:55;16077:18;;39847:59:0;;;;;;;;;-1:-1:-1;;;;;42689:34:0;::::1;;::::0;;;:14:::1;:34;::::0;;;;;::::1;;42688:35;42680:76;;;::::0;-1:-1:-1;;;42680:76:0;;20109:2:1;42680:76:0::1;::::0;::::1;20091:21:1::0;20148:2;20128:18;;;20121:30;20187;20167:18;;;20160:58;20235:18;;42680:76:0::1;20081:178:1::0;42680:76:0::1;42767:17;42794:9;-1:-1:-1::0;;;;;42794:20:0::1;;:22;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;42842:55;::::0;;;;::::1;::::0;;-1:-1:-1;;;;;42842:55:0;;::::1;::::0;;;;;::::1;;::::0;;::::1;::::0;;;42828:8:::1;:70:::0;;::::1;::::0;;::::1;::::0;;-1:-1:-1;42828:70:0;;;;;;;;::::1;::::0;;::::1;::::0;;;;::::1;-1:-1:-1::0;;;;;;42828:70:0;;::::1;;::::0;;;;;;;;;;;;;::::1;::::0;::::1;::::0;;;::::1;::::0;;;42909:34;;;:14:::1;:34:::0;;;;;;:41;;-1:-1:-1;;42909:41:0::1;::::0;;::::1;::::0;;;42966:26;;13587:34:1;;;13637:18;;;13630:43;42842:55:0;;-1:-1:-1;42966:26:0::1;::::0;13522:18:1;42966:26:0::1;;;;;;;;39917:1;42607:393:::0;:::o;40528:134::-;-1:-1:-1;;;;;40623:22:0;;40596:7;40623:22;;;:15;:22;;;;;:31;;:29;:31::i;:::-;40616:38;40528:134;-1:-1:-1;;40528:134:0:o;37247:26::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;37247:26:0;;;;-1:-1:-1;37247:26:0;;:::o;55086:547::-;2108:7;2135:6;-1:-1:-1;;;;;2135:6:0;860:10;2282:23;2274:68;;;;-1:-1:-1;;;2274:68:0;;;;;;;:::i;:::-;55276:1:::1;55249:28:::0;::::1;;55241:81;;;::::0;-1:-1:-1;;;55241:81:0;;16308:2:1;55241:81:0::1;::::0;::::1;16290:21:1::0;16347:2;16327:18;;;16320:30;16386:34;16366:18;;;16359:62;-1:-1:-1;;;16437:18:1;;;16430:38;16485:19;;55241:81:0::1;16280:230:1::0;55241:81:0::1;55372:9;55367:129;55383:27:::0;;::::1;55367:129;;;55439:16;;55456:1;55439:19;;;;;-1:-1:-1::0;;;55439:19:0::1;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;55432:52;::::0;-1:-1:-1;;;55432:52:0;;55478:4:::1;55432:52;::::0;::::1;10886:51:1::0;-1:-1:-1;;;;;55432:37:0;;;::::1;::::0;::::1;::::0;10859:18:1;;55432:52:0::1;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;55412:3:0;::::1;::::0;::::1;:::i;:::-;;;;55367:129;;;-1:-1:-1::0;55508:46:0::1;::::0;-1:-1:-1;;;55508:46:0;;-1:-1:-1;;;;;55508:28:0;::::1;::::0;::::1;::::0;:46:::1;::::0;55537:16;;;;55508:46:::1;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;55570:55;55597:9;55608:16;;55570:55;;;;;;;;:::i;:::-;;;;;;;;55086:547:::0;;;:::o;47499:165::-;20412:1;21010:7;;:19;;21002:63;;;;-1:-1:-1;;;21002:63:0;;;;;;;:::i;:::-;20412:1;21143:7;:18;47581:9:::1;47576:81;47592:16:::0;;::::1;47576:81;;;47630:15;47636:5;;47642:1;47636:8;;;;;-1:-1:-1::0;;;47636:8:0::1;;;;;;;;;;;;;;;47630:5;:15::i;:::-;-1:-1:-1::0;47610:3:0;::::1;::::0;::::1;:::i;:::-;;;;47576:81;;;-1:-1:-1::0;;20368:1:0;21322:22;;-1:-1:-1;47499:165:0:o;44491:167::-;44568:82;44582:10;44594;44606:4;44612:15;44637:1;44641;44644:5;44568:13;:82::i;:::-;44491:167;;:::o;50774:229::-;2108:7;2135:6;-1:-1:-1;;;;;2135:6:0;860:10;2282:23;2274:68;;;;-1:-1:-1;;;2274:68:0;;;;;;;:::i;:::-;37676:3:::1;50856:11;:30;;50848:70;;;::::0;-1:-1:-1;;;50848:70:0;;17883:2:1;50848:70:0::1;::::0;::::1;17865:21:1::0;17922:2;17902:18;;;17895:30;17961:29;17941:18;;;17934:57;18008:18;;50848:70:0::1;17855:177:1::0;50848:70:0::1;50929:10;:24:::0;;;50969:26:::1;::::0;26739:25:1;;;50969:26:0::1;::::0;26727:2:1;26712:18;50969:26:0::1;;;;;;;;50774:229:::0;:::o;44831:152::-;44892:83;44906:10;44918;44930:4;-1:-1:-1;;44963:1:0;44967;44970:4;44892:13;:83::i;:::-;44831:152;:::o;50435:169::-;2108:7;2135:6;-1:-1:-1;;;;;2135:6:0;860:10;2282:23;2274:68;;;;-1:-1:-1;;;2274:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;50519:16:0;::::1;;::::0;;;:9:::1;:16;::::0;;;;;;;;:30;;-1:-1:-1;;50519:30:0::1;::::0;::::1;;::::0;;::::1;::::0;;;50565:31;;12729:51:1;;;12796:18;;;12789:50;50565:31:0::1;::::0;12702:18:1;50565:31:0::1;12684:161:1::0;42032:399:0;42104:7;42124:20;42147:8;42156:4;42147:14;;;;;;-1:-1:-1;;;42147:14:0;;;;;;;;;;;;;;;;;42124:37;;;;;;;;42147:14;;;;;;;42124:37;;-1:-1:-1;;;;;42124:37:0;;;;;;;;;;;;;;;;42195:14;;;:8;:14;;;;;:21;;;;;;;;;;42172:44;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;42124:37;;-1:-1:-1;42172:44:0;;42195:21;;42172:44;;;;;;;42147:14;;42172:44;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;42172:44:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;42172:44:0;;;;;;;;;;;;;;;;-1:-1:-1;;;42172:44:0;;;-1:-1:-1;;42172:44:0;;;;-1:-1:-1;;;;;42172:44:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;42172:44:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;42227:26;42256:4;:13;;;42227:42;;42282:19;42304:8;-1:-1:-1;;;;;42304:20:0;;:22;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;42282:44;;42358:1;42344:11;:15;:79;;42422:1;42344:79;;;42408:11;42377:8;-1:-1:-1;;;;;42377:25:0;;:27;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;42363:11;;:41;;;;:::i;:::-;42362:57;;;;:::i;:::-;42337:86;42032:399;-1:-1:-1;;;;;;;42032:399:0:o;52634:212::-;2108:7;2135:6;-1:-1:-1;;;;;2135:6:0;860:10;2282:23;2274:68;;;;-1:-1:-1;;;2274:68:0;;;;;;;:::i;:::-;37997:3:::1;52710:8;:34;;52702:71;;;::::0;-1:-1:-1;;;52702:71:0;;21230:2:1;52702:71:0::1;::::0;::::1;21212:21:1::0;21269:2;21249:18;;;21242:30;21308:26;21288:18;;;21281:54;21352:18;;52702:71:0::1;21202:174:1::0;52702:71:0::1;52784:7;:18:::0;;;52818:20:::1;::::0;26739:25:1;;;52818:20:0::1;::::0;26727:2:1;26712:18;52818:20:0::1;26694:76:1::0;51600:265:0;2108:7;2135:6;-1:-1:-1;;;;;2135:6:0;860:10;2282:23;2274:68;;;;-1:-1:-1;;;2274:68:0;;;;;;;:::i;:::-;37849:3:::1;51690:15;:38;;51682:82;;;::::0;-1:-1:-1;;;51682:82:0;;21944:2:1;51682:82:0::1;::::0;::::1;21926:21:1::0;21983:2;21963:18;;;21956:30;22022:33;22002:18;;;21995:61;22073:18;;51682:82:0::1;21916:181:1::0;51682:82:0::1;51775:14;:32:::0;;;51823:34:::1;::::0;26739:25:1;;;51823:34:0::1;::::0;26727:2:1;26712:18;51823:34:0::1;26694:76:1::0;2713:103:0;2108:7;2135:6;-1:-1:-1;;;;;2135:6:0;860:10;2282:23;2274:68;;;;-1:-1:-1;;;2274:68:0;;;;;;;:::i;:::-;2778:30:::1;2805:1;2778:18;:30::i;:::-;2713:103::o:0;52136:323::-;2108:7;2135:6;-1:-1:-1;;;;;2135:6:0;860:10;2282:23;2274:68;;;;-1:-1:-1;;;2274:68:0;;;;;;;:::i;:::-;52272:5:::1;52244:24;:33;;52236:86;;;::::0;-1:-1:-1;;;52236:86:0;;20466:2:1;52236:86:0::1;::::0;::::1;20448:21:1::0;20505:2;20485:18;;;20478:30;20544:34;20524:18;;;20517:62;-1:-1:-1;;;20595:18:1;;;20588:38;20643:19;;52236:86:0::1;20438:230:1::0;52236:86:0::1;52333:23;:50:::0;;;52399:52:::1;::::0;26739:25:1;;;52399:52:0::1;::::0;26727:2:1;26712:18;52399:52:0::1;26694:76:1::0;53637:225:0;2108:7;2135:6;-1:-1:-1;;;;;2135:6:0;860:10;2282:23;2274:68;;;;-1:-1:-1;;;2274:68:0;;;;;;;:::i;:::-;53749:40:::1;::::0;-1:-1:-1;;;53749:40:0;;13308:14:1;;13301:22;53749:40:0::1;::::0;::::1;13283:41:1::0;-1:-1:-1;;;;;53749:30:0;::::1;::::0;::::1;::::0;13256:18:1;;53749:40:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;-1:-1:-1::0;;53805:49:0::1;::::0;;-1:-1:-1;;;;;12747:32:1;;12729:51;;12823:14;;12816:22;12811:2;12796:18;;12789:50;53805:49:0::1;::::0;-1:-1:-1;12702:18:1;;-1:-1:-1;53805:49:0::1;12684:161:1::0;54188:625:0;2108:7;2135:6;-1:-1:-1;;;;;2135:6:0;860:10;2282:23;2274:68;;;;-1:-1:-1;;;2274:68:0;;;;;;;:::i;:::-;54403:1:::1;54387:17:::0;::::1;;54379:63;;;;-1:-1:-1::0;;;54379:63:0::1;;;;;;;:::i;:::-;54457:16:::0;;54453:225:::1;;54583:7;-1:-1:-1::0;;;;;54571:19:0::1;:5;;54577:1;54571:8;;;;;-1:-1:-1::0;;;54571:8:0::1;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;54571:19:0::1;;:57;;;;-1:-1:-1::0;;;;;;54594:34:0;::::1;:5:::0;;54600:16:::1;54615:1;54594:5:::0;54600:16:::1;:::i;:::-;54594:23;;;;;-1:-1:-1::0;;;54594:23:0::1;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;54594:34:0::1;;54571:57;54563:103;;;;-1:-1:-1::0;;;54563:103:0::1;;;;;;;:::i;:::-;54688:46;::::0;-1:-1:-1;;;54688:46:0;;-1:-1:-1;;;;;54688:21:0;::::1;::::0;::::1;::::0;:46:::1;::::0;54710:7;;54719;;54728:5;;;;54688:46:::1;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;54750:55;54770:9;54781:7;54790;54799:5;;54750:55;;;;;;;;;;:::i;:::-;;;;;;;;54188:625:::0;;;;;:::o;55800:247::-;55886:16;;-1:-1:-1;;;;;55886:16:0;55872:10;:30;:59;;;;-1:-1:-1;;;;;;55906:25:0;;;;55872:59;55864:98;;;;-1:-1:-1;;;55864:98:0;;20875:2:1;55864:98:0;;;20857:21:1;20914:2;20894:18;;;20887:30;20953:28;20933:18;;;20926:56;20999:18;;55864:98:0;20847:176:1;55864:98:0;55973:10;:24;;-1:-1:-1;;;;;;55973:24:0;-1:-1:-1;;;;;55973:24:0;;;;;;;;56013:26;;10886:51:1;;;56013:26:0;;10874:2:1;10859:18;56013:26:0;10841:102:1;53116:267:0;2108:7;2135:6;-1:-1:-1;;;;;2135:6:0;860:10;2282:23;2274:68;;;;-1:-1:-1;;;2274:68:0;;;;;;;:::i;:::-;53231:5:::1;53210:17;:26;;53202:72;;;::::0;-1:-1:-1;;;53202:72:0;;23000:2:1;53202:72:0::1;::::0;::::1;22982:21:1::0;23039:2;23019:18;;;23012:30;23078:34;23058:18;;;23051:62;-1:-1:-1;;;23129:18:1;;;23122:31;23170:19;;53202:72:0::1;22972:223:1::0;53202:72:0::1;53285:16;:36:::0;;;53337:38:::1;::::0;26739:25:1;;;53337:38:0::1;::::0;26727:2:1;26712:18;53337:38:0::1;26694:76:1::0;44021:167:0;44145:35;44154:4;44160:14;44176:3;44145:8;:35::i;:::-;44021:167;;;:::o;41345:211::-;41473:16;;:::i;:::-;41509:14;;;;:8;:14;;;;;;;;-1:-1:-1;;;;;41509:21:0;;;;;;;;;:27;;:39;;41537:10;;41509:39;;;;-1:-1:-1;;;41509:39:0;;;;;;;;;;;;;;;;;;41502:46;;;;;;;;41509:39;;;;;;;41502:46;;-1:-1:-1;;;;;41502:46:0;;;;;;;;;;;;;;;;;;;;;;;;;41509:39;;41502:46;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;41502:46:0;;;;;;;;;;;;;;;;-1:-1:-1;;;41502:46:0;;;-1:-1:-1;;41502:46:0;;;;-1:-1:-1;;;;;41502:46:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;41502:46:0;;;;;;;;;;;;;;;;;;;;;;;;;;;41345:211;;;;;:::o;43167:190::-;39865:10;39855:21;;;;:9;:21;;;;;;;;39847:59;;;;-1:-1:-1;;;39847:59:0;;15954:2:1;39847:59:0;;;15936:21:1;15993:2;15973:18;;;15966:30;-1:-1:-1;;;16012:18:1;;;16005:55;16077:18;;39847:59:0;15926:175:1;39847:59:0;43264:9:::1;43259:91;43275:22:::0;;::::1;43259:91;;;43319:19;43323:11;;43335:1;43323:14;;;;;-1:-1:-1::0;;;43323:14:0::1;;;;;;;;;;;;;;;;;;;;;;:::i;43319:19::-;43299:3:::0;::::1;::::0;::::1;:::i;:::-;;;;43259:91;;51176:238:::0;2108:7;2135:6;-1:-1:-1;;;;;2135:6:0;860:10;2282:23;2274:68;;;;-1:-1:-1;;;2274:68:0;;;;;;;:::i;:::-;37760:3:::1;51260:12;:32;;51252:73;;;::::0;-1:-1:-1;;;51252:73:0;;17526:2:1;51252:73:0::1;::::0;::::1;17508:21:1::0;17565:2;17545:18;;;17538:30;17604;17584:18;;;17577:58;17652:18;;51252:73:0::1;17498:178:1::0;51252:73:0::1;51336:11;:26:::0;;;51378:28:::1;::::0;26739:25:1;;;51378:28:0::1;::::0;26727:2:1;26712:18;51378:28:0::1;26694:76:1::0;40943:148:0;-1:-1:-1;;;;;41050:22:0;;41023:7;41050:22;;;:15;:22;;;;;:33;;41076:6;41050:25;:33::i;:::-;41043:40;40943:148;-1:-1:-1;;;40943:148:0:o;46784:359::-;46858:21;46882:14;;;:8;:14;;;;;;;;46897:10;46882:26;;;;;;;46940:10;;;:17;46927:30;;46919:64;;;;-1:-1:-1;;;46919:64:0;;25301:2:1;46919:64:0;;;25283:21:1;25340:2;25320:18;;;25313:30;-1:-1:-1;;;25359:18:1;;;25352:51;25420:18;;46919:64:0;25273:171:1;46919:64:0;47019:10;;;;47030:17;;47019:10;;47030:21;;;:::i;:::-;47019:33;;;;;;-1:-1:-1;;;47019:33:0;;;;;;;;;;;;;;;;;;;46994:4;:10;;47005;46994:22;;;;;;-1:-1:-1;;;46994:22:0;;;;;;;;;;;;;;;;;:58;;:22;;;;;:58;;-1:-1:-1;;;;;;46994:58:0;-1:-1:-1;;;;;46994:58:0;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;46994:58:0;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;46994:58:0;;;;;;;;;;-1:-1:-1;;;;;;46994:58:0;-1:-1:-1;;;;;46994:58:0;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;46994:58:0;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;47063:10:0;;;:16;;;;;-1:-1:-1;;;47063:16:0;;;;;;;;;;;;;;;;;-1:-1:-1;;47063:16:0;;;;;;;;;-1:-1:-1;;;;;;47063:16:0;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;-1:-1:-1;;;;;;47063:16:0;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;-1:-1:-1;;47063:16:0;;47095:40;;26739:25:1;;;47118:4:0;;47106:10;;47095:40;;26727:2:1;26712:18;47095:40:0;;;;;;;46784:359;;;:::o;56243:295::-;56341:16;;-1:-1:-1;;;;;56341:16:0;56327:10;:30;:65;;;;-1:-1:-1;;;;;;56361:31:0;;;;56327:65;56319:110;;;;-1:-1:-1;;;56319:110:0;;24580:2:1;56319:110:0;;;24562:21:1;;;24599:18;;;24592:30;24658:34;24638:18;;;24631:62;24710:18;;56319:110:0;24552:182:1;56319:110:0;56440:16;:36;;-1:-1:-1;;;;;;56440:36:0;-1:-1:-1;;;;;56440:36:0;;;;;;;;56492:38;;10886:51:1;;;56492:38:0;;10874:2:1;10859:18;56492:38:0;10841:102:1;43653:125:0;43728:42;43737:4;43743:14;43759:10;43728:8;:42::i;48600:1595::-;39996:10;7585:20;7633:8;;;39976:58;;-1:-1:-1;40011:9:0;40024:10;40011:23;39976:58;39968:67;;;;;;48745:17:::1;::::0;-1:-1:-1;;;48745:17:0;::::1;;;48744:18;48736:50;;;::::0;-1:-1:-1;;;48736:50:0;;18642:2:1;48736:50:0::1;::::0;::::1;18624:21:1::0;18681:2;18661:18;;;18654:30;-1:-1:-1;;;18700:18:1;;;18693:49;18759:18;;48736:50:0::1;18614:169:1::0;48736:50:0::1;48797:17;:24:::0;;-1:-1:-1;;;;48797:24:0::1;-1:-1:-1::0;;;48797:24:0::1;::::0;;;48855:14;;;:8:::1;:14;::::0;;;;;;;-1:-1:-1;;;;;48855:21:0;::::1;::::0;;;;;;;48832:44;;;;::::1;::::0;;;;;;48817:4:::1;48832:44:::0;::::1;::::0;;;;;;::::1;::::0;;;;;;;;;;;;48855:21;;48832:44;;::::1;::::0;;;;48797:24;;48832:44;::::1;;;;;;;;;::::0;;;::::1;::::0;;;;::::1;::::0;;::::1;::::0;::::1;::::0;;::::1;::::0;::::1;::::0;;::::1;::::0;;-1:-1:-1;;;;;48832:44:0::1;::::0;;;;::::1;::::0;;;;;;::::1;::::0;;;;;;;;;;;;;;;;::::1;::::0;;;::::1;::::0;;;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;;-1:-1:-1;;;;;48832:44:0::1;::::0;;;;;::::1;::::0;::::1;;::::0;;::::1;;;;-1:-1:-1::0;;;48832:44:0;;;-1:-1:-1;;48832:44:0::1;::::0;::::1;::::0;-1:-1:-1;;;;;48832:44:0::1;;::::0;;::::1;::::0;;;;::::1;::::0;::::1;::::0;;;;;;;::::1;::::0;;;;;;;;;;;;;;::::1;::::0;;;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;;-1:-1:-1;;;;;48832:44:0::1;::::0;;;;;::::1;::::0;::::1;;::::0;;::::1;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;::::0;::::1;;;48887:16;48906:4;:10;;;48917;48906:22;;;;;;-1:-1:-1::0;;;48906:22:0::1;;;;;;;;;;;;;;;48887:41;;48939:26;48968:8;48977:4;48968:14;;;;;;-1:-1:-1::0;;;48968:14:0::1;;;;;;;;;;::::0;;;::::1;::::0;;;;:23:::1;:14;::::0;;::::1;;:23;::::0;49045:14;;49168:23;;::::1;::::0;49210:24:::1;::::0;;::::1;::::0;49026:223;;-1:-1:-1;;;49026:223:0;;-1:-1:-1;;;;;48968:23:0;;::::1;::::0;-1:-1:-1;49026:40:0;;;::::1;::::0;::::1;::::0;:223:::1;::::0;48968:23;;49121:5;;49145:4;;49168:23;49026:223:::1;;;:::i;:::-;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;49004:305;;;::::0;-1:-1:-1;;;49004:305:0;;18990:2:1;49004:305:0::1;::::0;::::1;18972:21:1::0;;;19009:18;;;19002:30;19068:34;19048:18;;;19041:62;19120:18;;49004:305:0::1;18962:182:1::0;49004:305:0::1;49322:18;49331:8;49322;:18::i;:::-;49351:22;49392:4;:11;;;49351:53;;49416:22;49440:18:::0;49462:6:::1;-1:-1:-1::0;;;;;49462:14:0::1;;49499:8;49523:5;49543:4;49562;:20;;;49597:4;:21;;;49462:167;;;;;;;;;;;;;;;;;;;:::i;:::-;;::::0;::::1;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;49415:214;;;;49642:14;49659:25;49672:4;49678:5;49659:12;:25::i;:::-;49642:42;;49716:6;49699:14;:23;49695:79;;;49756:6;49739:23;;49695:79;49790:18:::0;;49786:211:::1;;49825:21;49878:5;49867:7;;49850:14;:24;;;;:::i;:::-;49849:34;;;;:::i;:::-;49825:58;;49898:87;49912:5;49919:10;49931:4;49937:14;49953:10;49965:13;49980:4;49898:13;:87::i;:::-;49786:211;;50007:6;-1:-1:-1::0;;;;;50007:15:0::1;;50031:8;50042:5;50049:4;50055;:20;;;50077:4;:21;;;50007:92;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;-1:-1:-1::0;;50110:17:0::1;:25:::0;;-1:-1:-1;;;;50110:25:0::1;::::0;;-1:-1:-1;;50151:36:0::1;::::0;26739:25:1;;;-1:-1:-1;;;;;50151:36:0;::::1;::::0;50163:4;;50151:36:::1;::::0;26727:2:1;26712:18;50151:36:0::1;;;;;;;40046:1;;;;;;;48600:1595:::0;;;:::o;47262:105::-;47321:7;20412:1;21010:7;;:19;;21002:63;;;;-1:-1:-1;;;21002:63:0;;;;;;;:::i;:::-;20412:1;21143:7;:18;47348:11:::1;47354:4:::0;47348:5:::1;:11::i;:::-;20368:1:::0;21322:22;;47341:18;47262:105;-1:-1:-1;;47262:105:0:o;45586:1019::-;45900:21;45924:14;;;:8;:14;;;;;;;;45939:10;45924:26;;;;;;;45971:10;;;:17;38131:2;-1:-1:-1;45971:44:0;45963:78;;;;-1:-1:-1;;;45963:78:0;;15604:2:1;45963:78:0;;;15586:21:1;15643:2;15623:18;;;15616:30;-1:-1:-1;;;15662:18:1;;;15655:51;15723:18;;45963:78:0;15576:171:1;45963:78:0;46079:10;-1:-1:-1;;;;;46060:42:0;;:44;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;46052:79;;;;-1:-1:-1;;;46052:79:0;;19758:2:1;46052:79:0;;;19740:21:1;19797:2;19777:18;;;19770:30;-1:-1:-1;;;19816:18:1;;;19809:52;19878:18;;46052:79:0;19730:172:1;46052:79:0;46166:7;-1:-1:-1;;;;;46150:33:0;;:35;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;46142:67;;;;-1:-1:-1;;;46142:67:0;;22652:2:1;46142:67:0;;;22634:21:1;22691:2;22671:18;;;22664:30;-1:-1:-1;;;22710:18:1;;;22703:49;22769:18;;46142:67:0;22624:169:1;46142:67:0;46222:16;;:::i;:::-;-1:-1:-1;;;;;46249:27:0;;;;46287:45;;;;;;;;;;;;;;;;;;;;46313:19;;;;;;46287:45;;;46313:19;;46287:45;46313:19;46287:45;;;;;;;;;-1:-1:-1;;;;46287:23:0;;;;:45;;;;46343:47;;;;;;;;;;;;;;;;;;46370:20;;;;;;46343:47;;;;46370:20;;46343:47;46370:20;46343:47;;;;;;;;;-1:-1:-1;;;;46343:24:0;;;;:47;;;;-1:-1:-1;;;;;46401:21:0;;:11;;;:21;46433:39;;;;;;;;;;;;;;;;;;;46456:16;;;;;;46433:39;;;46456:16;;46433:39;46456:16;46433:39;;;;;;;;;-1:-1:-1;;;;46433:20:0;;;:39;46483:41;;;;;;;;;;;;;;;;;;;;46507:17;;;;;;46483:41;;;46507:17;;46483:41;46507:17;46483:41;;;;;;;;-1:-1:-1;46483:21:0;;;:41;;;;-1:-1:-1;;;46535:10:0;;;;:21;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;46535:21:0;-1:-1:-1;;;;;46535:21:0;;;;;;;;;;;;;;;46483;;46535;;;;;;;;;;;:::i;:::-;-1:-1:-1;46535:21:0;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;46535:21:0;;;;;;;;;-1:-1:-1;;;;;;46535:21:0;-1:-1:-1;;;;;46535:21:0;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;46535:21:0;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;46572:25:0;;46592:4;;-1:-1:-1;46580:10:0;;46572:25;;;;;45586:1019;;;;;;;;;;;;;:::o;2971:201::-;2108:7;2135:6;-1:-1:-1;;;;;2135:6:0;860:10;2282:23;2274:68;;;;-1:-1:-1;;;2274:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;3060:22:0;::::1;3052:73;;;::::0;-1:-1:-1;;;3052:73:0;;16717:2:1;3052:73:0::1;::::0;::::1;16699:21:1::0;16756:2;16736:18;;;16729:30;16795:34;16775:18;;;16768:62;-1:-1:-1;;;16846:18:1;;;16839:36;16892:19;;3052:73:0::1;16689:228:1::0;3052:73:0::1;3136:28;3155:8;3136:18;:28::i;47869:477::-:0;47994:4;48030:14;;;:8;:14;;;;;;;;-1:-1:-1;;;;;48030:21:0;;;;;;;;;:27;;:39;;47994:4;;48030:27;48058:10;;48030:39;;;;-1:-1:-1;;;48030:39:0;;;;;;;;;;;;;;;;;;48011:58;;;;;;;;48030:39;;;;;;;48011:58;;-1:-1:-1;;;;;48011:58:0;;;;;;;;;;;;;;;;;;;;;;;;;48030:39;;48011:58;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;48011:58:0;;;;;;;;;;;;;;;;-1:-1:-1;;;48011:58:0;;;-1:-1:-1;;48011:58:0;;;;-1:-1:-1;;;;;48011:58:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;48011:58:0;;;;;;;;;;;;;;;;;;;;;;;;;;;48119:4;:14;;;-1:-1:-1;;;;;48100:40:0;;48167:8;48176:4;48167:14;;;;;;-1:-1:-1;;;48167:14:0;;;;;;;;;;;;;;;;;;:23;:14;;;;;:23;;48257;;;;48299:24;;;;;48100:238;;-1:-1:-1;;;;;;48100:238:0;;;;;;;;;-1:-1:-1;;;;;48167:23:0;;48210:5;;48234:4;;48100:238;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;48080:258;47869:477;-1:-1:-1;;;;;47869:477:0:o;32519:114::-;32579:7;32606:19;32614:3;25548:18;;25465:109;58783:201;58830:22;58882:8;58891:4;58882:14;;;;;;-1:-1:-1;;;58882:14:0;;;;;;;;;;;;;;;;;;;;;;:23;;;:40;;-1:-1:-1;;;58882:40:0;;58911:10;58882:40;;;10886:51:1;-1:-1:-1;;;;;58882:23:0;;;;:28;;10859:18:1;;58882:40:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;58865:57;;58955:4;58943:10;-1:-1:-1;;;;;58938:38:0;;58961:14;58938:38;;;;26739:25:1;;26727:2;26712:18;;26694:76;58938:38:0;;;;;;;;58783:201;;;:::o;57578:1197::-;20412:1;21010:7;;:19;;21002:63;;;;-1:-1:-1;;;21002:63:0;;;;;;;:::i;:::-;20412:1;21143:7;:18;57842:19;57834:72:::1;;;::::0;-1:-1:-1;;;57834:72:0;;23760:2:1;57834:72:0::1;::::0;::::1;23742:21:1::0;23799:2;23779:18;;;23772:30;23838:34;23818:18;;;23811:62;-1:-1:-1;;;23889:18:1;;;23882:38;23937:19;;57834:72:0::1;23732:230:1::0;57834:72:0::1;57917:21;57941:14:::0;;;:8:::1;:14;::::0;;;;;;;-1:-1:-1;;;;;57941:21:0;::::1;::::0;;;;;;;58002:8:::1;:14:::0;;57941:21;;57917;57950:4;;58002:14;::::1;;;-1:-1:-1::0;;;58002:14:0::1;;;;;;;;;;::::0;;;::::1;::::0;;;:23:::1;:14;::::0;;::::1;;:23;::::0;-1:-1:-1;;;;;58002:23:0::1;::::0;-1:-1:-1;58043:9:0;58038:61:::1;;58069:18;58078:8;58069;:18::i;:::-;58111:19;58133:8;-1:-1:-1::0;;;;;58133:20:0::1;;:22;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;58176:11:::0;;58111:44;;-1:-1:-1;58176:15:0;;;;:34:::1;;;58209:1;58195:11;:15;58176:34;58168:66;;;::::0;-1:-1:-1;;;58168:66:0;;22304:2:1;58168:66:0::1;::::0;::::1;22286:21:1::0;22343:2;22323:18;;;22316:30;-1:-1:-1;;;22362:18:1;;;22355:49;22421:18;;58168:66:0::1;22276:169:1::0;58168:66:0::1;58247:17;58313:11;58282:8;-1:-1:-1::0;;;;;58282:25:0::1;;:27;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;58268:11:::0;;:41:::1;::::0;;::::1;:::i;:::-;58267:57;;;;:::i;:::-;58247:77;;58357:9;58339:15;:27;58335:87;;;58401:9;58383:27;;58335:87;58456:70;::::0;-1:-1:-1;;;58456:70:0;;::::1;::::0;::::1;27006:25:1::0;;;-1:-1:-1;;;;;27105:15:1;;;27085:18;;;27078:43;27157:15;;;27137:18;;;27130:43;27189:18;;;27182:34;;;58432:21:0::1;::::0;58456:17;;::::1;::::0;::::1;::::0;26978:19:1;;58456:70:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;58432:94;;58565:13;58551:4;:11;;;:27;:61;;58611:1;58551:61;;;58581:11:::0;;:27:::1;::::0;58595:13;;58581:27:::1;:::i;:::-;58537:75:::0;;;58623:84:::1;;-1:-1:-1::0;;;;;58660:22:0;::::1;;::::0;;;:15:::1;:22;::::0;;;;:35:::1;::::0;58690:4;58660:29:::1;:35::i;:::-;;58623:84;58745:4;58740:3;-1:-1:-1::0;;;;;58724:43:0::1;58733:5;-1:-1:-1::0;;;;;58724:43:0::1;;58751:15;58724:43;;;;26739:25:1::0;;26727:2;26712:18;;26694:76;58724:43:0::1;;;;;;;;-1:-1:-1::0;;20368:1:0;21322:22;;-1:-1:-1;;;;;;;;;;57578:1197:0:o;3332:191::-;3406:16;3425:6;;-1:-1:-1;;;;;3442:17:0;;;-1:-1:-1;;;;;;3442:17:0;;;;;;3475:40;;3425:6;;;;;;;3475:40;;3406:16;3475:40;3332:191;;:::o;56546:1024::-;20412:1;21010:7;;:19;;21002:63;;;;-1:-1:-1;;;21002:63:0;;;;;;;:::i;:::-;20412:1;21143:7;:18;56690;56682:65:::1;;;::::0;-1:-1:-1;;;56682:65:0;;18239:2:1;56682:65:0::1;::::0;::::1;18221:21:1::0;18278:2;18258:18;;;18251:30;18317:34;18297:18;;;18290:62;-1:-1:-1;;;18368:18:1;;;18361:32;18410:19;;56682:65:0::1;18211:224:1::0;56682:65:0::1;56758:20;56781:8;56790:4;56781:14;;;;;;-1:-1:-1::0;;;56781:14:0::1;;;;;;;;;;::::0;;;::::1;::::0;;;56758:37:::1;::::0;;;;::::1;::::0;;56781:14:::1;::::0;;::::1;::::0;;::::1;56758:37:::0;;-1:-1:-1;;;;;56758:37:0;;::::1;::::0;;;;;::::1;::::0;;::::1;::::0;;::::1;::::0;;;56830:14;;;:8:::1;:14:::0;;;;;:19;;::::1;::::0;;;;;;;56866:13;;:27;;-1:-1:-1;;;56866:27:0;;;;56758:37;;-1:-1:-1;56830:19:0;;56781:14;56866:25;::::1;::::0;::::1;::::0;:27:::1;::::0;;::::1;::::0;;;;;;;:25;:27;::::1;;::::0;::::1;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:31;56862:87;;;56914:23;56923:4;:13;;;56914:8;:23::i;:::-;57101:15:::0;;57135:13:::1;::::0;::::1;::::0;57101:49:::1;::::0;-1:-1:-1;;;57101:49:0;;-1:-1:-1;;;;;10904:32:1;;;57101:49:0::1;::::0;::::1;10886:51:1::0;57077:21:0::1;::::0;57101:25;;;::::1;::::0;::::1;::::0;10859:18:1;;57101:49:0::1;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;57223:13;::::0;::::1;::::0;57161:15;;57077:73;;-1:-1:-1;57161:93:0::1;::::0;-1:-1:-1;;;;;57161:32:0::1;::::0;57202:10:::1;::::0;57239:14;57161:32:::1;:93::i;:::-;57282:15:::0;;57316:13:::1;::::0;::::1;::::0;57282:49:::1;::::0;-1:-1:-1;;;57282:49:0;;-1:-1:-1;;;;;10904:32:1;;;57282:49:0::1;::::0;::::1;10886:51:1::0;57334:13:0;;57282:25;;;::::1;::::0;::::1;::::0;10859:18:1;;57282:49:0::1;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:65;;;;:::i;:::-;57265:82;;57360:19;57382:4;:13;;;-1:-1:-1::0;;;;;57382:21:0::1;;57404:14;57382:37;;;;;;;;;;;;;26739:25:1::0;;26727:2;26712:18;;26694:76;57382:37:0::1;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;57444:11:::0;;57360:59;;-1:-1:-1;57444:25:0::1;::::0;57360:59;;57444:25:::1;:::i;:::-;57430:39:::0;;-1:-1:-1;;;;;57480:20:0;::::1;57430:11;57480:20:::0;;;:15:::1;:20;::::0;;;;:30:::1;::::0;57505:4;57480:24:::1;:30::i;:::-;;57541:4;57536:3;-1:-1:-1::0;;;;;57528:34:0::1;;57547:14;57528:34;;;;26739:25:1::0;;26727:2;26712:18;;26694:76;57528:34:0::1;;;;;;;;-1:-1:-1::0;;20368:1:0;21322:22;;-1:-1:-1;;;;;56546:1024:0:o;32987:137::-;33058:7;33093:22;33097:3;33109:5;33093:3;:22::i;58992:116::-;59063:26;;-1:-1:-1;;;59063:26:0;;59086:1;59063:26;;;10886:51:1;-1:-1:-1;;;;;59063:14:0;;;;;10859:18:1;;59063:26:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;59063:26:0;;;;;;;;-1:-1:-1;;59063:26:0;;;;;;;;;;;;:::i;:::-;;;59059:42;;44831:152;:::o;32064:137::-;32134:4;32158:35;32166:3;32186:5;32158:7;:35::i;15515:248::-;15686:68;;;-1:-1:-1;;;;;11697:15:1;;;15686:68:0;;;11679:34:1;11749:15;;11729:18;;;11722:43;11781:18;;;;11774:34;;;15686:68:0;;;;;;;;;;11614:18:1;;;;15686:68:0;;;;;;;;-1:-1:-1;;;;;15686:68:0;-1:-1:-1;;;15686:68:0;;;15659:96;;15679:5;;15659:19;:96::i;:::-;15515:248;;;;:::o;31757:131::-;31824:4;31848:32;31853:3;31873:5;31848:4;:32::i;25928:120::-;25995:7;26022:3;:11;;26034:5;26022:18;;;;;;-1:-1:-1;;;26022:18:0;;;;;;;;;;;;;;;;;26015:25;;25928:120;;;;:::o;23744:1420::-;23810:4;23949:19;;;:12;;;:19;;;;;;23985:15;;23981:1176;;24360:21;24384:14;24397:1;24384:10;:14;:::i;:::-;24433:18;;24360:38;;-1:-1:-1;24413:17:0;;24433:22;;24454:1;;24433:22;:::i;:::-;24413:42;;24489:13;24476:9;:26;24472:405;;24523:17;24543:3;:11;;24555:9;24543:22;;;;;;-1:-1:-1;;;24543:22:0;;;;;;;;;;;;;;;;;24523:42;;24697:9;24668:3;:11;;24680:13;24668:26;;;;;;-1:-1:-1;;;24668:26:0;;;;;;;;;;;;;;;;;;;;:38;;;;24782:23;;;:12;;;:23;;;;;:36;;;24472:405;24958:17;;:3;;:17;;;-1:-1:-1;;;24958:17:0;;;;;;;;;;;;;;;;;;;;;;;;;;25053:3;:12;;:19;25066:5;25053:19;;;;;;;;;;;25046:26;;;25096:4;25089:11;;;;;;;23981:1176;25140:5;25133:12;;;;;17869:716;18293:23;18319:69;18347:4;18319:69;;;;;;;;;;;;;;;;;18327:5;-1:-1:-1;;;;;18319:27:0;;;:69;;;;;:::i;:::-;18403:17;;18293:95;;-1:-1:-1;18403:21:0;18399:179;;18500:10;18489:30;;;;;;;;;;;;:::i;:::-;18481:85;;;;-1:-1:-1;;;18481:85:0;;24169:2:1;18481:85:0;;;24151:21:1;24208:2;24188:18;;;24181:30;24247:34;24227:18;;;24220:62;-1:-1:-1;;;24298:18:1;;;24291:40;24348:19;;18481:85:0;24141:232:1;23154:414:0;23217:4;25347:19;;;:12;;;:19;;;;;;23234:327;;-1:-1:-1;23277:23:0;;;;;;;;:11;:23;;;;;;;;;;;;;23460:18;;23438:19;;;:12;;;:19;;;;;;:40;;;;23493:11;;23234:327;-1:-1:-1;23544:5:0;23537:12;;10068:229;10205:12;10237:52;10259:6;10267:4;10273:1;10276:12;10237:21;:52::i;:::-;10230:59;10068:229;-1:-1:-1;;;;10068:229:0:o;11188:510::-;11358:12;11416:5;11391:21;:30;;11383:81;;;;-1:-1:-1;;;11383:81:0;;19351:2:1;11383:81:0;;;19333:21:1;19390:2;19370:18;;;19363:30;19429:34;19409:18;;;19402:62;-1:-1:-1;;;19480:18:1;;;19473:36;19526:19;;11383:81:0;19323:228:1;11383:81:0;7585:20;;11475:60;;;;-1:-1:-1;;;11475:60:0;;23402:2:1;11475:60:0;;;23384:21:1;23441:2;23421:18;;;23414:30;23480:31;23460:18;;;23453:59;23529:18;;11475:60:0;23374:179:1;11475:60:0;11549:12;11563:23;11590:6;-1:-1:-1;;;;;11590:11:0;11609:5;11616:4;11590:31;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;11548:73;;;;11639:51;11656:7;11665:10;11677:12;14024;14053:7;14049:530;;;-1:-1:-1;14084:10:0;14077:17;;14049:530;14198:17;;:21;14194:374;;14396:10;14390:17;14457:15;14444:10;14440:2;14436:19;14429:44;14344:148;14539:12;14532:20;;-1:-1:-1;;;14532:20:0;;;;;;;;:::i;-1:-1:-1:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14:134:1;82:20;;111:31;82:20;111:31;:::i;:::-;63:85;;;:::o;153:395::-;216:8;226:6;280:3;273:4;265:6;261:17;257:27;247:2;;305:8;295;288:26;247:2;-1:-1:-1;335:20:1;;378:18;367:30;;364:2;;;417:8;407;400:26;364:2;461:4;453:6;449:17;437:29;;521:3;514:4;504:6;501:1;497:14;489:6;485:27;481:38;478:47;475:2;;;538:1;535;528:12;475:2;237:311;;;;;:::o;553:257::-;612:6;665:2;653:9;644:7;640:23;636:32;633:2;;;686:6;678;671:22;633:2;730:9;717:23;749:31;774:5;749:31;:::i;815:261::-;885:6;938:2;926:9;917:7;913:23;909:32;906:2;;;959:6;951;944:22;906:2;996:9;990:16;1015:31;1040:5;1015:31;:::i;1081:392::-;1146:6;1154;1207:2;1195:9;1186:7;1182:23;1178:32;1175:2;;;1228:6;1220;1213:22;1175:2;1272:9;1259:23;1291:31;1316:5;1291:31;:::i;:::-;1341:5;-1:-1:-1;1398:2:1;1383:18;;1370:32;1411:30;1370:32;1411:30;:::i;:::-;1460:7;1450:17;;;1165:308;;;;;:::o;1478:325::-;1546:6;1554;1607:2;1595:9;1586:7;1582:23;1578:32;1575:2;;;1628:6;1620;1613:22;1575:2;1672:9;1659:23;1691:31;1716:5;1691:31;:::i;:::-;1741:5;1793:2;1778:18;;;;1765:32;;-1:-1:-1;;;1565:238:1:o;1808:483::-;1920:6;1928;1981:2;1969:9;1960:7;1956:23;1952:32;1949:2;;;2002:6;1994;1987:22;1949:2;2047:9;2034:23;2080:18;2072:6;2069:30;2066:2;;;2117:6;2109;2102:22;2066:2;2161:70;2223:7;2214:6;2203:9;2199:22;2161:70;:::i;:::-;2250:8;;2135:96;;-1:-1:-1;1939:352:1;-1:-1:-1;;;;1939:352:1:o;2758:255::-;2825:6;2878:2;2866:9;2857:7;2853:23;2849:32;2846:2;;;2899:6;2891;2884:22;2846:2;2936:9;2930:16;2955:28;2977:5;2955:28;:::i;3306:901::-;3445:6;3453;3461;3469;3477;3530:3;3518:9;3509:7;3505:23;3501:33;3498:2;;;3552:6;3544;3537:22;3498:2;3596:9;3583:23;3615:31;3640:5;3615:31;:::i;:::-;3665:5;-1:-1:-1;3722:2:1;3707:18;;3694:32;3735:33;3694:32;3735:33;:::i;:::-;3787:7;-1:-1:-1;3846:2:1;3831:18;;3818:32;3859:33;3818:32;3859:33;:::i;:::-;3911:7;-1:-1:-1;3969:2:1;3954:18;;3941:32;3996:18;3985:30;;3982:2;;;4033:6;4025;4018:22;3982:2;4077:70;4139:7;4130:6;4119:9;4115:22;4077:70;:::i;:::-;3488:719;;;;-1:-1:-1;3488:719:1;;-1:-1:-1;4166:8:1;;4051:96;3488:719;-1:-1:-1;;;3488:719:1:o;4212:618::-;4333:6;4341;4349;4402:2;4390:9;4381:7;4377:23;4373:32;4370:2;;;4423:6;4415;4408:22;4370:2;4467:9;4454:23;4486:31;4511:5;4486:31;:::i;:::-;4536:5;-1:-1:-1;4592:2:1;4577:18;;4564:32;4619:18;4608:30;;4605:2;;;4656:6;4648;4641:22;4605:2;4700:70;4762:7;4753:6;4742:9;4738:22;4700:70;:::i;:::-;4360:470;;4789:8;;-1:-1:-1;4674:96:1;;-1:-1:-1;;;;4360:470:1:o;4835:418::-;4926:6;4934;4987:2;4975:9;4966:7;4962:23;4958:32;4955:2;;;5008:6;5000;4993:22;5258:190;5317:6;5370:2;5358:9;5349:7;5345:23;5341:32;5338:2;;;5391:6;5383;5376:22;5338:2;-1:-1:-1;5419:23:1;;5328:120;-1:-1:-1;5328:120:1:o;5453:194::-;5523:6;5576:2;5564:9;5555:7;5551:23;5547:32;5544:2;;;5597:6;5589;5582:22;5544:2;-1:-1:-1;5625:16:1;;5534:113;-1:-1:-1;5534:113:1:o;5652:325::-;5720:6;5728;5781:2;5769:9;5760:7;5756:23;5752:32;5749:2;;;5802:6;5794;5787:22;5749:2;5843:9;5830:23;5820:33;;5903:2;5892:9;5888:18;5875:32;5916:31;5941:5;5916:31;:::i;5982:322::-;6061:6;6069;6122:2;6110:9;6101:7;6097:23;6093:32;6090:2;;;6143:6;6135;6128:22;6090:2;6177:9;6171:16;6161:26;;6230:2;6219:9;6215:18;6209:25;6243:31;6268:5;6243:31;:::i;6309:1649::-;6530:6;6538;6546;6554;6562;6570;6578;6586;6594;6602;6610:7;6664:3;6652:9;6643:7;6639:23;6635:33;6632:2;;;6686:6;6678;6671:22;6632:2;6727:9;6714:23;6704:33;;6756:38;6790:2;6779:9;6775:18;6756:38;:::i;:::-;6746:48;;6813:18;6880:2;6874;6863:9;6859:18;6846:32;6843:40;6840:2;;;6901:6;6893;6886:22;6840:2;6945:96;7033:7;7026:2;7015:9;7011:18;6998:32;6987:9;6983:48;6945:96;:::i;:::-;7060:8;;-1:-1:-1;7087:8:1;-1:-1:-1;7138:2:1;7123:18;;7110:32;7107:40;-1:-1:-1;7104:2:1;;;7165:6;7157;7150:22;7104:2;7209:96;7297:7;7290:2;7279:9;7275:18;7262:32;7251:9;7247:48;7209:96;:::i;:::-;7324:8;;-1:-1:-1;7351:8:1;-1:-1:-1;7378:39:1;7412:3;7397:19;;7378:39;:::i;:::-;7368:49;;7467:2;7460:3;7449:9;7445:19;7432:33;7429:41;7426:2;;;7488:6;7480;7473:22;7426:2;7532:97;7621:7;7613:3;7602:9;7598:19;7585:33;7574:9;7570:49;7532:97;:::i;:::-;7648:8;;-1:-1:-1;7675:8:1;-1:-1:-1;7726:3:1;7711:19;;7698:33;7695:41;-1:-1:-1;7692:2:1;;;7754:6;7746;7739:22;7692:2;;7799:97;7888:7;7880:3;7869:9;7865:19;7852:33;7841:9;7837:49;7799:97;:::i;:::-;7915:8;7905:18;;7943:9;7932:20;;;;6622:1336;;;;;;;;;;;;;;:::o;7963:393::-;8040:6;8048;8056;8109:2;8097:9;8088:7;8084:23;8080:32;8077:2;;;8130:6;8122;8115:22;8077:2;8171:9;8158:23;8148:33;;8231:2;8220:9;8216:18;8203:32;8244:31;8269:5;8244:31;:::i;:::-;8067:289;;8294:5;;-1:-1:-1;;;8346:2:1;8331:18;;;;8318:32;;8067:289::o;8361:258::-;8429:6;8437;8490:2;8478:9;8469:7;8465:23;8461:32;8458:2;;;8511:6;8503;8496:22;8458:2;-1:-1:-1;;8539:23:1;;;8609:2;8594:18;;;8581:32;;-1:-1:-1;8448:171:1:o;8624:393::-;8701:6;8709;8717;8770:2;8758:9;8749:7;8745:23;8741:32;8738:2;;;8791:6;8783;8776:22;8738:2;8832:9;8819:23;8809:33;;8889:2;8878:9;8874:18;8861:32;8851:42;;8943:2;8932:9;8928:18;8915:32;8956:31;8981:5;8956:31;:::i;:::-;9006:5;8996:15;;;8728:289;;;;;:::o;9022:524::-;9122:6;9117:3;9110:19;9092:3;9148:4;9177:2;9172:3;9168:12;9161:19;;9203:5;9226:3;9238:283;9252:6;9249:1;9246:13;9238:283;;;9329:6;9316:20;9349:33;9374:7;9349:33;:::i;:::-;-1:-1:-1;;;;;9407:33:1;9395:46;;9461:12;;;;9496:15;;;;9437:1;9267:9;9238:283;;;-1:-1:-1;9537:3:1;;9100:446;-1:-1:-1;;;;;9100:446:1:o;9551:463::-;9604:3;9642:5;9636:12;9669:6;9664:3;9657:19;9695:4;9724:2;9719:3;9715:12;9708:19;;9761:2;9754:5;9750:14;9782:3;9794:195;9808:6;9805:1;9802:13;9794:195;;;9873:13;;-1:-1:-1;;;;;9869:39:1;9857:52;;9929:12;;;;9964:15;;;;9905:1;9823:9;9794:195;;10019:437;10072:3;10110:5;10104:12;10137:6;10132:3;10125:19;10163:4;10192:2;10187:3;10183:12;10176:19;;10229:2;10222:5;10218:14;10250:3;10262:169;10276:6;10273:1;10270:13;10262:169;;;10337:13;;10325:26;;10371:12;;;;10406:15;;;;10298:1;10291:9;10262:169;;10461:274;10590:3;10628:6;10622:13;10644:53;10690:6;10685:3;10678:4;10670:6;10666:17;10644:53;:::i;:::-;10713:16;;;;;10598:137;-1:-1:-1;;10598:137:1:o;10948:486::-;-1:-1:-1;;;;;11231:15:1;;;11213:34;;11283:15;;11278:2;11263:18;;11256:43;11335:2;11330;11315:18;;11308:30;;;11156:4;;11355:73;;11409:18;;11401:6;11393;11355:73;:::i;:::-;11347:81;11165:269;-1:-1:-1;;;;;;11165:269:1:o;11819:737::-;-1:-1:-1;;;;;12198:15:1;;;12180:34;;12250:15;;12245:2;12230:18;;12223:43;12297:2;12282:18;;12275:34;;;12160:3;12340:2;12325:18;;12318:31;;;12123:4;;12372:57;;12409:19;;12401:6;12372:57;:::i;:::-;12478:9;12470:6;12466:22;12460:3;12449:9;12445:19;12438:51;12506:44;12543:6;12535;12506:44;:::i;:::-;12498:52;12132:424;-1:-1:-1;;;;;;;;12132:424:1:o;12850:288::-;13039:2;13028:9;13021:21;13002:4;13059:73;13128:2;13117:9;13113:18;13105:6;13097;13059:73;:::i;13684:594::-;-1:-1:-1;;;;;14021:15:1;;;14003:34;;14073:15;;;14068:2;14053:18;;14046:43;14125:15;;14120:2;14105:18;;14098:43;14177:3;14172:2;14157:18;;14150:31;;;13946:4;;14198:74;;14252:19;;14244:6;14236;14198:74;:::i;14283:411::-;-1:-1:-1;;;;;14526:32:1;;14508:51;;14595:2;14590;14575:18;;14568:30;;;-1:-1:-1;;14615:73:1;;14669:18;;14661:6;14653;14615:73;:::i;15014:383::-;15163:2;15152:9;15145:21;15126:4;15195:6;15189:13;15238:6;15233:2;15222:9;15218:18;15211:34;15254:66;15313:6;15308:2;15297:9;15293:18;15288:2;15280:6;15276:15;15254:66;:::i;:::-;15381:2;15360:15;-1:-1:-1;;15356:29:1;15341:45;;;;15388:2;15337:54;;15135:262;-1:-1:-1;;15135:262:1:o;16922:397::-;17124:2;17106:21;;;17163:2;17143:18;;;17136:30;17202:34;17197:2;17182:18;;17175:62;-1:-1:-1;;;17268:2:1;17253:18;;17246:31;17309:3;17294:19;;17096:223::o;21381:356::-;21583:2;21565:21;;;21602:18;;;21595:30;21661:34;21656:2;21641:18;;21634:62;21728:2;21713:18;;21555:182::o;24739:355::-;24941:2;24923:21;;;24980:2;24960:18;;;24953:30;25019:33;25014:2;24999:18;;24992:61;25085:2;25070:18;;24913:181::o;25449:1139::-;25622:2;25611:9;25604:21;25585:4;25661:1;25657;25652:3;25648:11;25644:19;25718:2;25709:6;25703:13;25699:22;25694:2;25683:9;25679:18;25672:50;25769:2;25761:6;25757:15;25751:22;25809:4;25804:2;25793:9;25789:18;25782:32;25837:63;25895:3;25884:9;25880:19;25866:12;25837:63;:::i;:::-;25823:77;;25949:2;25941:6;25937:15;25931:22;25976:2;25972:7;26043:2;26031:9;26023:6;26019:22;26015:31;26010:2;25999:9;25995:18;25988:59;26070:52;26115:6;26099:14;26070:52;:::i;:::-;26056:66;;26187:2;26181;26173:6;26169:15;26163:22;26159:31;26153:3;26142:9;26138:19;26131:60;26240:3;26232:6;26228:16;26222:23;26200:45;;26310:2;26298:9;26290:6;26286:22;26282:31;26276:3;26265:9;26261:19;26254:60;26337:52;26382:6;26366:14;26337:52;:::i;:::-;26323:66;;26438:3;26430:6;26426:16;26420:23;26398:45;;26509:2;26497:9;26489:6;26485:22;26481:31;26474:4;26463:9;26459:20;26452:61;;;26530:52;26575:6;26559:14;26530:52;:::i;27227:128::-;27267:3;27298:1;27294:6;27291:1;27288:13;27285:2;;;27304:18;;:::i;:::-;-1:-1:-1;27340:9:1;;27275:80::o;27360:217::-;27400:1;27426;27416:2;;-1:-1:-1;;;27451:31:1;;27505:4;27502:1;27495:15;27533:4;27458:1;27523:15;27416:2;-1:-1:-1;27562:9:1;;27406:171::o;27582:168::-;27622:7;27688:1;27684;27680:6;27676:14;27673:1;27670:21;27665:1;27658:9;27651:17;27647:45;27644:2;;;27695:18;;:::i;:::-;-1:-1:-1;27735:9:1;;27634:116::o;27755:125::-;27795:4;27823:1;27820;27817:8;27814:2;;;27828:18;;:::i;:::-;-1:-1:-1;27865:9:1;;27804:76::o;27885:258::-;27957:1;27967:113;27981:6;27978:1;27975:13;27967:113;;;28057:11;;;28051:18;28038:11;;;28031:39;28003:2;27996:10;27967:113;;;28098:6;28095:1;28092:13;28089:2;;;-1:-1:-1;;28133:1:1;28115:16;;28108:27;27938:205::o;28148:135::-;28187:3;-1:-1:-1;;28208:17:1;;28205:2;;;28228:18;;:::i;:::-;-1:-1:-1;28275:1:1;28264:13;;28195:88::o;28288:127::-;28349:10;28344:3;28340:20;28337:1;28330:31;28380:4;28377:1;28370:15;28404:4;28401:1;28394:15;28420:131;-1:-1:-1;;;;;28495:31:1;;28485:42;;28475:2;;28541:1;28538;28531:12;28556:118;28642:5;28635:13;28628:21;28621:5;28618:32;28608:2;;28664:1;28661;28654:12

ipfs://d1b28f56b7b53fbad6676127bad2cf52da093cfb269a66efd81e19903514ce7d