Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2023-10-19
*/

// SPDX-License-Identifier: AGPL-3.0
pragma solidity 0.8.18;

/**$$$$$$$$$$$$$$$$$$$$$$$$$$$&Mr/|1+~>>iiiiiiiiiii>~+{|tuMW$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
$$$$$$$$$$$$$$$$$$$$$$$$$B#j]->iiiiiiiiiiiiiiiiiiiiiiiiiiii>-?f*B$$$$$$$$$$$$$$$$$$$$$$$$$
$$$$$$$$$$$$$$$$$$$$$@zj}~iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii~}fv@$$$$$$$$$$$$$$$$$$$$$
$$$$$$$$$$$$$$$$$$@z(+iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii+)zB$$$$$$$$$$$$$$$$$$
$$$$$$$$$$$$$$$$Mf~iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii~t#@$$$$$$$$$$$$$$$
$$$$$$$$$$$$$@u[iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii?n@$$$$$$$$$$$$$
$$$$$$$$$$$@z]iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii?u@$$$$$$$$$$$
$$$$$$$$$$v]iiiiiiiiiiiiiiii,.';iiiiiiiiiiiiiiiiiiiiiiiiii;'."iiiiiiiiiiiiiiii?u$$$$$$$$$$
$$$$$$$$%)>iiiiiiiiiiiiiii,.    ';iiiiiiiiiiiiiiiiiiiiii;'    ."iiiiiiiiiiiiiiii1%$$$$$$$$
$$$$$$$c~iiiiiiiiiiiiiii,.        ';iiiiiiiiiiiiiiiiii;'        ."iiiiiiiiiiiiiii~u$$$$$$$
$$$$$B/>iiiiiiiiiiiiii!'            `IiiiiiiiiiiiiiiI`            .Iiiiiiiiiiiiiii>|%$$$$$
$$$$@)iiiiiiiiiiiiiiiii;'             `Iiiiiiiiiiil`             ';iiiiiiiiiiiiiiiii}@$$$$
$$$B|iiiiiiiiiiiiiiiiiiii;'             `Iiiiiiil`             ';iiiiiiiiiiiiiiiiiiii1B$$$
$$@)iiiiiiiiiiiiiiiiiiiiiii:'             `;iiI`             ':iiiiiiiiiiiiiiiiiiiiiii{B$$
$$|iiiiiiiiiiiiiiiiiiiiiiiiii;'             ``             ':iiiiiiiiiiiiiiiiiiiiiiiiii1$$
$v>iiiiiiiiiiiiiiiiiiiiiiiiiiii:'                        ':iiiiiiiiiiiiiiiiiiiiiiiiiiii>x$
&?iiiiiiiiiiiiiiiiiiiiiiiiiiiiiii:'                    .,iiiiiiiiiiiiiiiiiiiiiiiiiiiiiii-W
ziiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii:'                .,iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiv
-iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii:'            .,iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii-
<iiiiiiiiiiiiiiiiiiii!.':iiiiiiiiiiiiii,          "iiiiiiiiiiiiii;'.Iiiiiiiiiiiiiiiiiiiii<
iiiiiiiiiiiiiiiiiiiii'   ';iiiiiiiiiiiii          Iiiiiiiiiiiii;'   .iiiiiiiiiiiiiiiiiiiii
iiiiiiiiiiiiiiiiiiii,      ';iiiiiiiiiii          IiiiiiiiiiiI`      `iiiiiiiiiiiiiiiiiiii
iiiiiiiiiiiiiiiiiiii.        `Iiiiiiiiii          Iiiiiiiii!`         !iiiiiiiiiiiiiiiiiii
iiiiiiiiiiiiiiiiiii;          :iiiiiiiii          Iiiiiiiii!          ,iiiiiiiiiiiiiiiiiii
iiiiiiiiiiiiiiiiiii,          iiiiiiiiii          Iiiiiiiiii.         ^iiiiiiiiiiiiiiiiiii
<iiiiiiiiiiiiiiiiii,          iiiiiiiiii          Iiiiiiiiii'         ^iiiiiiiiiiiiiiiiii<
-iiiiiiiiiiiiiiiiii;          Iiiiiiiiii          Iiiiiiiiii.         "iiiiiiiiiiiiiiiiii-
ziiiiiiiiiiiiiiiiiii.         'iiiiiiiii''''''''''liiiiiiii^          liiiiiiiiiiiiiiiiiiv
&?iiiiiiiiiiiiiiiiii^          ^iiiiiiiiiiiiiiiiiiiiiiiiii,          `iiiiiiiiiiiiiiiiii_W
$u>iiiiiiiiiiiiiiiiii.          `!iiiiiiiiiiiiiiiiiiiiiii^          .liiiiiiiiiiiiiiiiiir$
$$(iiiiiiiiiiiiiiiiii;.          ."iiiiiiiiiiiiiiiiiiii,.           :iiiiiiiiiiiiiiiiii}$$
$$@{iiiiiiiiiiiiiiiiii;.           .`:iiiiiiiiiiiiii;^.            :iiiiiiiiiiiiiiiiii}B$$
$$$B)iiiiiiiiiiiiiiiiii!'              '`",::::,"`'.             .Iiiiiiiiiiiiiiiiiii{%$$$
$$$$@1iiiiiiiiiiiiiiiiiii,.                                     ^iiiiiiiiiiiiiiiiiii[@$$$$
$$$$$B|>iiiiiiiiiiiiiiiiii!^.                                 `liiiiiiiiiiiiiiiiii>)%$$$$$
$$$$$$$c~iiiiiiiiiiiiiiiiiiii"'                            ."!iiiiiiiiiiiiiiiiiii~n$$$$$$$
$$$$$$$$B)iiiiiiiiiiiiiiiiiiiii!,`.                    .'"liiiiiiiiiiiiiiiiiiiii1%$$$$$$$$
$$$$$$$$$@u]iiiiiiiiiiiiiiiiiiiiiiil,^`'..      ..''^,liiiiiiiiiiiiiiiiiiiiiii-x@$$$$$$$$$
$$$$$$$$$$$@v?iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii-x$$$$$$$$$$$$
$$$$$$$$$$$$$@n?iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii-rB$$$$$$$$$$$$$
$$$$$$$$$$$$$$$$/~iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii<\*@$$$$$$$$$$$$$$$$
$$$$$$$$$$$$$$$$$$Bc1~iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii~{v%$$$$$$$$$$$$$$$$$$
$$$$$$$$$$$$$$$$$$$$$Bvf]<iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii<]tuB$$$$$$$$$$$$$$$$$$$$$
$$$$$$$$$$$$$$$$$$$$$$$$$%zt-+>iiiiiiiiiiiiiiiiiiiiiiiiiiiii+_tc%$$$$$$$$$$$$$$$$$$$$$$$$$
$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$W#u/|{+~>iiiiiiiiiiii><+{|/n#W$$$$$$$$$$$$$$$$$$$$$$$$$$$$*/

// OpenZeppelin Contracts (last updated v4.8.0) (utils/math/Math.sol)

/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    enum Rounding {
        Down, // Toward negative infinity
        Up, // Toward infinity
        Zero // Toward zero
    }

    /**
     * @dev Returns the largest of two numbers.
     */
    function max(uint256 a, uint256 b) internal pure returns (uint256) {
        return a > b ? a : b;
    }

    /**
     * @dev Returns the smallest of two numbers.
     */
    function min(uint256 a, uint256 b) internal pure returns (uint256) {
        return a < b ? a : b;
    }

    /**
     * @dev Returns the average of two numbers. The result is rounded towards
     * zero.
     */
    function average(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b) / 2 can overflow.
        return (a & b) + (a ^ b) / 2;
    }

    /**
     * @dev Returns the ceiling of the division of two numbers.
     *
     * This differs from standard division with `/` in that it rounds up instead
     * of rounding down.
     */
    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b - 1) / b can overflow on addition, so we distribute.
        return a == 0 ? 0 : (a - 1) / b + 1;
    }

    /**
     * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0
     * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv)
     * with further edits by Uniswap Labs also under MIT license.
     */
    function mulDiv(
        uint256 x,
        uint256 y,
        uint256 denominator
    ) internal pure returns (uint256 result) {
        unchecked {
            // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use
            // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256
            // variables such that product = prod1 * 2^256 + prod0.
            uint256 prod0; // Least significant 256 bits of the product
            uint256 prod1; // Most significant 256 bits of the product
            assembly {
                let mm := mulmod(x, y, not(0))
                prod0 := mul(x, y)
                prod1 := sub(sub(mm, prod0), lt(mm, prod0))
            }

            // Handle non-overflow cases, 256 by 256 division.
            if (prod1 == 0) {
                return prod0 / denominator;
            }

            // Make sure the result is less than 2^256. Also prevents denominator == 0.
            require(denominator > prod1);

            ///////////////////////////////////////////////
            // 512 by 256 division.
            ///////////////////////////////////////////////

            // Make division exact by subtracting the remainder from [prod1 prod0].
            uint256 remainder;
            assembly {
                // Compute remainder using mulmod.
                remainder := mulmod(x, y, denominator)

                // Subtract 256 bit number from 512 bit number.
                prod1 := sub(prod1, gt(remainder, prod0))
                prod0 := sub(prod0, remainder)
            }

            // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1.
            // See https://cs.stackexchange.com/q/138556/92363.

            // Does not overflow because the denominator cannot be zero at this stage in the function.
            uint256 twos = denominator & (~denominator + 1);
            assembly {
                // Divide denominator by twos.
                denominator := div(denominator, twos)

                // Divide [prod1 prod0] by twos.
                prod0 := div(prod0, twos)

                // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.
                twos := add(div(sub(0, twos), twos), 1)
            }

            // Shift in bits from prod1 into prod0.
            prod0 |= prod1 * twos;

            // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such
            // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for
            // four bits. That is, denominator * inv = 1 mod 2^4.
            uint256 inverse = (3 * denominator) ^ 2;

            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works
            // in modular arithmetic, doubling the correct bits in each step.
            inverse *= 2 - denominator * inverse; // inverse mod 2^8
            inverse *= 2 - denominator * inverse; // inverse mod 2^16
            inverse *= 2 - denominator * inverse; // inverse mod 2^32
            inverse *= 2 - denominator * inverse; // inverse mod 2^64
            inverse *= 2 - denominator * inverse; // inverse mod 2^128
            inverse *= 2 - denominator * inverse; // inverse mod 2^256

            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.
            // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is
            // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1
            // is no longer required.
            result = prod0 * inverse;
            return result;
        }
    }

    /**
     * @notice Calculates x * y / denominator with full precision, following the selected rounding direction.
     */
    function mulDiv(
        uint256 x,
        uint256 y,
        uint256 denominator,
        Rounding rounding
    ) internal pure returns (uint256) {
        uint256 result = mulDiv(x, y, denominator);
        if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {
            result += 1;
        }
        return result;
    }

    /**
     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down.
     *
     * Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11).
     */
    function sqrt(uint256 a) internal pure returns (uint256) {
        if (a == 0) {
            return 0;
        }

        // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.
        //
        // We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have
        // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.
        //
        // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`
        // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`
        // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`
        //
        // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.
        uint256 result = 1 << (log2(a) >> 1);

        // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,
        // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at
        // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision
        // into the expected uint128 result.
        unchecked {
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            return min(result, a / result);
        }
    }

    /**
     * @notice Calculates sqrt(a), following the selected rounding direction.
     */
    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = sqrt(a);
            return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 2, rounded down, of a positive value.
     * Returns 0 if given 0.
     */
    function log2(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 128;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 64;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 32;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 16;
            }
            if (value >> 8 > 0) {
                value >>= 8;
                result += 8;
            }
            if (value >> 4 > 0) {
                value >>= 4;
                result += 4;
            }
            if (value >> 2 > 0) {
                value >>= 2;
                result += 2;
            }
            if (value >> 1 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log2(value);
            return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 10, rounded down, of a positive value.
     * Returns 0 if given 0.
     */
    function log10(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >= 10**64) {
                value /= 10**64;
                result += 64;
            }
            if (value >= 10**32) {
                value /= 10**32;
                result += 32;
            }
            if (value >= 10**16) {
                value /= 10**16;
                result += 16;
            }
            if (value >= 10**8) {
                value /= 10**8;
                result += 8;
            }
            if (value >= 10**4) {
                value /= 10**4;
                result += 4;
            }
            if (value >= 10**2) {
                value /= 10**2;
                result += 2;
            }
            if (value >= 10**1) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log10(value);
            return result + (rounding == Rounding.Up && 10**result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 256, rounded down, of a positive value.
     * Returns 0 if given 0.
     *
     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.
     */
    function log256(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 16;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 8;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 4;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 2;
            }
            if (value >> 8 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log256(value);
            return result + (rounding == Rounding.Up && 1 << (result * 8) < value ? 1 : 0);
        }
    }
}

// OpenZeppelin Contracts (last updated v4.8.0) (token/ERC20/ERC20.sol)

// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol)

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @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);

    /**
     * @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 `to`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address to, 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 `from` to `to` 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 from,
        address to,
        uint256 amount
    ) external returns (bool);
}

// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol)

/**
 * @dev Interface for the optional metadata functions from the ERC20 standard.
 *
 * _Available since v4.1._
 */
interface IERC20Metadata is IERC20 {
    /**
     * @dev Returns the name of the token.
     */
    function name() external view returns (string memory);

    /**
     * @dev Returns the symbol of the token.
     */
    function symbol() external view returns (string memory);

    /**
     * @dev Returns the decimals places of the token.
     */
    function decimals() external view returns (uint8);
}

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

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

/**
 * @dev Implementation of the {IERC20} interface.
 *
 * This implementation is agnostic to the way tokens are created. This means
 * that a supply mechanism has to be added in a derived contract using {_mint}.
 * For a generic mechanism see {ERC20PresetMinterPauser}.
 *
 * TIP: For a detailed writeup see our guide
 * https://forum.openzeppelin.com/t/how-to-implement-erc20-supply-mechanisms/226[How
 * to implement supply mechanisms].
 *
 * We have followed general OpenZeppelin Contracts guidelines: functions revert
 * instead returning `false` on failure. This behavior is nonetheless
 * conventional and does not conflict with the expectations of ERC20
 * applications.
 *
 * Additionally, an {Approval} event is emitted on calls to {transferFrom}.
 * This allows applications to reconstruct the allowance for all accounts just
 * by listening to said events. Other implementations of the EIP may not emit
 * these events, as it isn't required by the specification.
 *
 * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}
 * functions have been added to mitigate the well-known issues around setting
 * allowances. See {IERC20-approve}.
 */
contract ERC20 is Context, IERC20, IERC20Metadata {
    mapping(address => uint256) private _balances;

    mapping(address => mapping(address => uint256)) private _allowances;

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;

    /**
     * @dev Sets the values for {name} and {symbol}.
     *
     * The default value of {decimals} is 18. To select a different value for
     * {decimals} you should overload it.
     *
     * All two of these values are immutable: they can only be set once during
     * construction.
     */
    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
    }

    /**
     * @dev Returns the name of the token.
     */
    function name() public view virtual override returns (string memory) {
        return _name;
    }

    /**
     * @dev Returns the symbol of the token, usually a shorter version of the
     * name.
     */
    function symbol() public view virtual override returns (string memory) {
        return _symbol;
    }

    /**
     * @dev Returns the number of decimals used to get its user representation.
     * For example, if `decimals` equals `2`, a balance of `505` tokens should
     * be displayed to a user as `5.05` (`505 / 10 ** 2`).
     *
     * Tokens usually opt for a value of 18, imitating the relationship between
     * Ether and Wei. This is the value {ERC20} uses, unless this function is
     * overridden;
     *
     * NOTE: This information is only used for _display_ purposes: it in
     * no way affects any of the arithmetic of the contract, including
     * {IERC20-balanceOf} and {IERC20-transfer}.
     */
    function decimals() public view virtual override returns (uint8) {
        return 18;
    }

    /**
     * @dev See {IERC20-totalSupply}.
     */
    function totalSupply() public view virtual override returns (uint256) {
        return _totalSupply;
    }

    /**
     * @dev See {IERC20-balanceOf}.
     */
    function balanceOf(address account) public view virtual override returns (uint256) {
        return _balances[account];
    }

    /**
     * @dev See {IERC20-transfer}.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - the caller must have a balance of at least `amount`.
     */
    function transfer(address to, uint256 amount) public virtual override returns (bool) {
        address owner = _msgSender();
        _transfer(owner, to, amount);
        return true;
    }

    /**
     * @dev See {IERC20-allowance}.
     */
    function allowance(address owner, address spender) public view virtual override returns (uint256) {
        return _allowances[owner][spender];
    }

    /**
     * @dev See {IERC20-approve}.
     *
     * NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on
     * `transferFrom`. This is semantically equivalent to an infinite approval.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function approve(address spender, uint256 amount) public virtual override returns (bool) {
        address owner = _msgSender();
        _approve(owner, spender, amount);
        return true;
    }

    /**
     * @dev See {IERC20-transferFrom}.
     *
     * Emits an {Approval} event indicating the updated allowance. This is not
     * required by the EIP. See the note at the beginning of {ERC20}.
     *
     * NOTE: Does not update the allowance if the current allowance
     * is the maximum `uint256`.
     *
     * Requirements:
     *
     * - `from` and `to` cannot be the zero address.
     * - `from` must have a balance of at least `amount`.
     * - the caller must have allowance for ``from``'s tokens of at least
     * `amount`.
     */
    function transferFrom(
        address from,
        address to,
        uint256 amount
    ) public virtual override returns (bool) {
        address spender = _msgSender();
        _spendAllowance(from, spender, amount);
        _transfer(from, to, amount);
        return true;
    }

    /**
     * @dev Atomically increases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
        address owner = _msgSender();
        _approve(owner, spender, allowance(owner, spender) + addedValue);
        return true;
    }

    /**
     * @dev Atomically decreases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `spender` must have allowance for the caller of at least
     * `subtractedValue`.
     */
    function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
        address owner = _msgSender();
        uint256 currentAllowance = allowance(owner, spender);
        require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
        unchecked {
            _approve(owner, spender, currentAllowance - subtractedValue);
        }

        return true;
    }

    /**
     * @dev Moves `amount` of tokens from `from` to `to`.
     *
     * This internal function is equivalent to {transfer}, and can be used to
     * e.g. implement automatic token fees, slashing mechanisms, etc.
     *
     * Emits a {Transfer} event.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `from` must have a balance of at least `amount`.
     */
    function _transfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual {
        require(from != address(0), "ERC20: transfer from the zero address");
        require(to != address(0), "ERC20: transfer to the zero address");

        _beforeTokenTransfer(from, to, amount);

        uint256 fromBalance = _balances[from];
        require(fromBalance >= amount, "ERC20: transfer amount exceeds balance");
        unchecked {
            _balances[from] = fromBalance - amount;
            // Overflow not possible: the sum of all balances is capped by totalSupply, and the sum is preserved by
            // decrementing then incrementing.
            _balances[to] += amount;
        }

        emit Transfer(from, to, amount);

        _afterTokenTransfer(from, to, amount);
    }

    /** @dev Creates `amount` tokens and assigns them to `account`, increasing
     * the total supply.
     *
     * Emits a {Transfer} event with `from` set to the zero address.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     */
    function _mint(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: mint to the zero address");

        _beforeTokenTransfer(address(0), account, amount);

        _totalSupply += amount;
        unchecked {
            // Overflow not possible: balance + amount is at most totalSupply + amount, which is checked above.
            _balances[account] += amount;
        }
        emit Transfer(address(0), account, amount);

        _afterTokenTransfer(address(0), account, amount);
    }

    /**
     * @dev Destroys `amount` tokens from `account`, reducing the
     * total supply.
     *
     * Emits a {Transfer} event with `to` set to the zero address.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     * - `account` must have at least `amount` tokens.
     */
    function _burn(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: burn from the zero address");

        _beforeTokenTransfer(account, address(0), amount);

        uint256 accountBalance = _balances[account];
        require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
        unchecked {
            _balances[account] = accountBalance - amount;
            // Overflow not possible: amount <= accountBalance <= totalSupply.
            _totalSupply -= amount;
        }

        emit Transfer(account, address(0), amount);

        _afterTokenTransfer(account, address(0), amount);
    }

    /**
     * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
     *
     * This internal function is equivalent to `approve`, and can be used to
     * e.g. set automatic allowances for certain subsystems, etc.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `owner` cannot be the zero address.
     * - `spender` cannot be the zero address.
     */
    function _approve(
        address owner,
        address spender,
        uint256 amount
    ) internal virtual {
        require(owner != address(0), "ERC20: approve from the zero address");
        require(spender != address(0), "ERC20: approve to the zero address");

        _allowances[owner][spender] = amount;
        emit Approval(owner, spender, amount);
    }

    /**
     * @dev Updates `owner` s allowance for `spender` based on spent `amount`.
     *
     * Does not update the allowance amount in case of infinite allowance.
     * Revert if not enough allowance is available.
     *
     * Might emit an {Approval} event.
     */
    function _spendAllowance(
        address owner,
        address spender,
        uint256 amount
    ) internal virtual {
        uint256 currentAllowance = allowance(owner, spender);
        if (currentAllowance != type(uint256).max) {
            require(currentAllowance >= amount, "ERC20: insufficient allowance");
            unchecked {
                _approve(owner, spender, currentAllowance - amount);
            }
        }
    }

    /**
     * @dev Hook that is called before any transfer of tokens. This includes
     * minting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
     * will be transferred to `to`.
     * - when `from` is zero, `amount` tokens will be minted for `to`.
     * - when `to` is zero, `amount` of ``from``'s tokens will be burned.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _beforeTokenTransfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual {}

    /**
     * @dev Hook that is called after any transfer of tokens. This includes
     * minting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
     * has been transferred to `to`.
     * - when `from` is zero, `amount` tokens have been minted for `to`.
     * - when `to` is zero, `amount` of ``from``'s tokens have been burned.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _afterTokenTransfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual {}
}

// OpenZeppelin Contracts (last updated v4.8.0) (token/ERC20/utils/SafeERC20.sol)

// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/draft-IERC20Permit.sol)

/**
 * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in
 * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].
 *
 * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by
 * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't
 * need to send a transaction, and thus is not required to hold Ether at all.
 */
interface IERC20Permit {
    /**
     * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,
     * given ``owner``'s signed approval.
     *
     * IMPORTANT: The same issues {IERC20-approve} has related to transaction
     * ordering also apply here.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `deadline` must be a timestamp in the future.
     * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`
     * over the EIP712-formatted function arguments.
     * - the signature must use ``owner``'s current nonce (see {nonces}).
     *
     * For more information on the signature format, see the
     * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP
     * section].
     */
    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external;

    /**
     * @dev Returns the current nonce for `owner`. This value must be
     * included whenever a signature is generated for {permit}.
     *
     * Every successful call to {permit} increases ``owner``'s nonce by one. This
     * prevents a signature from being used multiple times.
     */
    function nonces(address owner) external view returns (uint256);

    /**
     * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.
     */
    // solhint-disable-next-line func-name-mixedcase
    function DOMAIN_SEPARATOR() external view returns (bytes32);
}

// OpenZeppelin Contracts (last updated v4.8.0) (utils/Address.sol)

/**
 * @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
     * ====
     *
     * [IMPORTANT]
     * ====
     * You shouldn't rely on `isContract` to protect against flash loan attacks!
     *
     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
     * constructor.
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize/address.code.length, which returns 0
        // for contracts in construction, since the code is only stored at the end
        // of the constructor execution.

        return account.code.length > 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 functionCallWithValue(target, data, 0, "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");
        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResultFromTarget(target, 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) {
        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResultFromTarget(target, 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) {
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

    /**
     * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling
     * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.
     *
     * _Available since v4.8._
     */
    function verifyCallResultFromTarget(
        address target,
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        if (success) {
            if (returndata.length == 0) {
                // only check isContract if the call was successful and the return data is empty
                // otherwise we already know that it was a contract
                require(isContract(target), "Address: call to non-contract");
            }
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    /**
     * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason or 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 {
            _revert(returndata, errorMessage);
        }
    }

    function _revert(bytes memory returndata, string memory errorMessage) private pure {
        // 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
            /// @solidity memory-safe-assembly
            assembly {
                let returndata_size := mload(returndata)
                revert(add(32, returndata), returndata_size)
            }
        } else {
            revert(errorMessage);
        }
    }
}

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

    function safePermit(
        IERC20Permit token,
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal {
        uint256 nonceBefore = token.nonces(owner);
        token.permit(owner, spender, value, deadline, v, r, s);
        uint256 nonceAfter = token.nonces(owner);
        require(nonceAfter == nonceBefore + 1, "SafeERC20: permit did not succeed");
    }

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

interface IFactory {
    function protocol_fee_config() external view returns (uint16, address);
}

interface IBaseStrategy {
    function tokenizedStrategyAddress() external view returns (address);

    /*//////////////////////////////////////////////////////////////
                            IMMUTABLE FUNCTIONS
    //////////////////////////////////////////////////////////////*/

    function availableDepositLimit(
        address _owner
    ) external view returns (uint256);

    function availableWithdrawLimit(
        address _owner
    ) external view returns (uint256);

    function deployFunds(uint256 _assets) external;

    function freeFunds(uint256 _amount) external;

    function harvestAndReport() external returns (uint256);

    function tendThis(uint256 _totalIdle) external;

    function shutdownWithdraw(uint256 _amount) external;

    function tendTrigger() external view returns (bool, bytes memory);
}

/**
 * @title Yearn Tokenized Strategy
 * @author yearn.finance
 * @notice
 *  This TokenizedStrategy can be used by anyone wishing to easily build
 *  and deploy their own custom ERC4626 compliant single strategy Vault.
 *
 *  The TokenizedStrategy contract is meant to be used as a proxy style
 *  implementation contract that will handle all logic, storage and
 *  management for a custom strategy that inherits the `BaseStrategy`.
 *  Any function calls to the strategy that are not defined within that
 *  strategy will be forwarded through a delegateCall to this contract.

 *  A strategist only needs to override a few simple functions that are
 *  focused entirely on the strategy specific needs to easily and cheaply
 *  deploy their own permissionless 4626 compliant vault.
 */
contract TokenizedStrategy {
    using Math for uint256;
    using SafeERC20 for ERC20;

    /*//////////////////////////////////////////////////////////////
                                 EVENTS
    //////////////////////////////////////////////////////////////*/

    /**
     * @notice Emitted when the 'pendingManagement' address is updated to 'newPendingManagement'.
     */
    event UpdatePendingManagement(address indexed newPendingManagement);

    /**
     * @notice Emitted when the 'management' address is updated to 'newManagement'.
     */
    event UpdateManagement(address indexed newManagement);

    /**
     * @notice Emitted when the 'keeper' address is updated to 'newKeeper'.
     */
    event UpdateKeeper(address indexed newKeeper);

    /**
     * @notice Emitted when the 'emergencyAdmin' address is updated to 'newEmergencyAdmin'.
     */
    event UpdateEmergencyAdmin(address indexed newEmergencyAdmin);

    /**
     * @notice Emitted when the 'performanceFee' is updated to 'newPerformanceFee'.
     */
    event UpdatePerformanceFee(uint16 newPerformanceFee);

    /**
     * @notice Emitted when the 'performanceFeeRecipient' address is
     * updated to 'newPerformanceFeeRecipient'.
     */
    event UpdatePerformanceFeeRecipient(
        address indexed newPerformanceFeeRecipient
    );

    /**
     * @notice Emitted when the 'profitMaxUnlockTime' is updated to 'newProfitMaxUnlockTime'.
     */
    event UpdateProfitMaxUnlockTime(uint256 newProfitMaxUnlockTime);

    /**
     * @notice Emitted when a strategy is shutdown.
     */
    event StrategyShutdown();

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

    /**
     * @dev Emitted when the `caller` has exchanged `assets` for `shares`,
     * and transferred those `shares` to `owner`.
     */
    event Deposit(
        address indexed caller,
        address indexed owner,
        uint256 assets,
        uint256 shares
    );

    /**
     * @dev Emitted when the `caller` has exchanged `owner`s `shares` for `assets`,
     * and transferred those `assets` to `receiver`.
     */
    event Withdraw(
        address indexed caller,
        address indexed receiver,
        address indexed owner,
        uint256 assets,
        uint256 shares
    );

    /**
     * @dev Emitted when the strategy reports `profit` or `loss` and
     * `performanceFees` and `protocolFees` are paid out.
     */
    event Reported(
        uint256 profit,
        uint256 loss,
        uint256 protocolFees,
        uint256 performanceFees
    );

    /**
     * @dev Emitted on the initialization of any new `strategy` that uses `asset`
     * with this specific `apiVersion`.
     */
    event NewTokenizedStrategy(
        address indexed strategy,
        address indexed asset,
        string apiVersion
    );

    /*//////////////////////////////////////////////////////////////
                        STORAGE STRUCT
    //////////////////////////////////////////////////////////////*/

    /**
     * @dev The struct that will hold all the data for each strategy that
     * uses this implementation.
     *
     * This replaces all state variables for a traditional contract. This
     * full struct will be initialized on the creation of the strategy
     * and continually updated and read from for the life of the contract.
     *
     * We combine all the variables into one struct to limit the amount of
     * times the custom storage slots need to be loaded during complex functions.
     *
     * Loading the corresponding storage slot for the struct does not
     * load any of the contents of the struct into memory. So the size
     * has no effect on gas usage.
     */
    // prettier-ignore
    struct StrategyData {
        // The ERC20 compliant underlying asset that will be
        // used by the Strategy
        ERC20 asset;

        // These are the corresponding ERC20 variables needed for the
        // strategies token that is issued and burned on each deposit or withdraw.
        uint8 decimals; // The amount of decimals that `asset` and strategy use.
        string name; // The name of the token for the strategy.
        uint256 totalSupply; // The total amount of shares currently issued.
        uint256 INITIAL_CHAIN_ID; // The initial chain id when the strategy was created.
        bytes32 INITIAL_DOMAIN_SEPARATOR; // The domain separator used for permits on the initial chain.
        mapping(address => uint256) nonces; // Mapping of nonces used for permit functions.
        mapping(address => uint256) balances; // Mapping to track current balances for each account that holds shares.
        mapping(address => mapping(address => uint256)) allowances; // Mapping to track the allowances for the strategies shares.

        // Assets data to track totals the strategy holds.
        // We manually track idle instead of relying on asset.balanceOf(address(this))
        // to prevent PPS manipulation through airdrops.
        uint256 totalIdle; // The total amount of loose `asset` the strategy holds.
        uint256 totalDebt; // The total amount `asset` that is currently deployed by the strategy.

        // Variables for profit reporting and locking.
        // We use uint128 for time stamps which is 1,025 years in the future.
        uint256 profitUnlockingRate; // The rate at which locked profit is unlocking.
        uint128 fullProfitUnlockDate; // The timestamp at which all locked shares will unlock.
        uint128 lastReport; // The last time a {report} was called.
        uint32 profitMaxUnlockTime; // The amount of seconds that the reported profit unlocks over.
        uint16 performanceFee; // The percent in basis points of profit that is charged as a fee.
        address performanceFeeRecipient; // The address to pay the `performanceFee` to.

        // Access management variables.
        address management; // Main address that can set all configurable variables.
        address keeper; // Address given permission to call {report} and {tend}.
        address pendingManagement; // Address that is pending to take over `management`.
        address emergencyAdmin; // Address to act in emergencies as well as `management`.
        bool entered; // Bool to prevent reentrancy.
        bool shutdown; // Bool that can be used to stop deposits into the strategy.
    }

    /*//////////////////////////////////////////////////////////////
                            MODIFIERS
    //////////////////////////////////////////////////////////////*/

    /**
     * @dev Require that the call is coming from the strategies management.
     */
    modifier onlyManagement() {
        isManagement(msg.sender);
        _;
    }

    /**
     * @dev Require that the call is coming from either the strategies
     * management or the keeper.
     */
    modifier onlyKeepers() {
        isKeeperOrManagement(msg.sender);
        _;
    }

    modifier onlyEmergencyAuthorized() {
        isEmergencyAuthorized(msg.sender);
        _;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Placed over all state changing functions for increased safety.
     */
    modifier nonReentrant() {
        StrategyData storage S = _strategyStorage();
        // On the first call to nonReentrant, `entered` will be false
        require(!S.entered, "ReentrancyGuard: reentrant call");

        // Any calls to nonReentrant after this point will fail
        S.entered = true;

        _;

        // Reset to false once call has finished
        S.entered = false;
    }

    /**
     * @notice To check if a sender is the management for a specific strategy.
     * @dev Is left public so that it can be used by the Strategy.
     *
     * When the Strategy calls this the msg.sender would be the
     * address of the strategy so we need to specify the sender.
     *
     * Will return `true` if the check passed.
     *
     * @param _sender The original msg.sender.
     */
    function isManagement(address _sender) public view returns (bool) {
        require(_sender == _strategyStorage().management, "!management");
        return true;
    }

    /**
     * @notice To check if a sender is the keeper or management
     * for a specific strategy.
     * @dev Is left public so that it can be used by the Strategy.
     *
     * When the Strategy calls this the msg.sender would be the
     * address of the strategy so we need to specify the sender.
     *
     * Will return `true` if the check passed.
     *
     * @param _sender The original msg.sender.
     */
    function isKeeperOrManagement(address _sender) public view returns (bool) {
        StrategyData storage S = _strategyStorage();
        require(_sender == S.keeper || _sender == S.management, "!keeper");
        return true;
    }

    /**
     * @notice To check if a sender is the keeper or emergency admin
     * for a specific strategy.
     * @dev Is left public so that it can be used by the Strategy.
     *
     * When the Strategy calls this the msg.sender would be the
     * address of the strategy so we need to specify the sender.
     *
     * Will return `true` if the check passed.
     *
     * @param _sender The original msg.sender.
     */
    function isEmergencyAuthorized(address _sender) public view returns (bool) {
        StrategyData storage S = _strategyStorage();
        require(
            _sender == S.emergencyAdmin || _sender == S.management,
            "!emergency authorized"
        );
        return true;
    }

    /*//////////////////////////////////////////////////////////////
                               CONSTANTS
    //////////////////////////////////////////////////////////////*/

    // API version this TokenizedStrategy implements.
    string private constant API_VERSION = "3.0.1";

    // Used for fee calculations.
    uint256 private constant MAX_BPS = 10_000;
    // Used for profit unlocking rate calculations.
    uint256 private constant MAX_BPS_EXTENDED = 1_000_000_000_000;

    // Minimum in Basis points the Performance fee can be set to.
    // Used to disincentive forking strategies just to lower fees.
    uint16 public constant MIN_FEE = 500; // 5%
    // Maximum in Basis Points the Performance Fee can be set to.
    uint16 public constant MAX_FEE = 5_000; // 50%

    // Seconds per year for max profit unlocking time.
    uint256 private constant SECONDS_PER_YEAR = 31_556_952; // 365.2425 days

    // Address of the previously deployed Vault factory that the
    // protocol fee config is retrieved from.
    address public constant FACTORY =
        0xE9E8C89c8Fc7E8b8F23425688eb68987231178e5;

    /**
     * @dev Custom storage slot that will be used to store the
     * `StrategyData` struct that holds each strategies
     * specific storage variables.
     *
     * Any storage updates done by the TokenizedStrategy actually update
     * the storage of the calling contract. This variable points
     * to the specific location that will be used to store the
     * struct that holds all that data.
     *
     * We use a custom string in order to get a random
     * storage slot that will allow for strategists to use any
     * amount of storage in their strategy without worrying
     * about collisions.
     */
    bytes32 private constant BASE_STRATEGY_STORAGE =
        bytes32(uint256(keccak256("yearn.base.strategy.storage")) - 1);

    /*//////////////////////////////////////////////////////////////
                    STORAGE GETTER FUNCTION
    //////////////////////////////////////////////////////////////*/

    /**
     * @dev will return the actual storage slot where the strategy
     * specific `StrategyData` struct is stored for both read
     * and write operations.
     *
     * This loads just the slot location, not the full struct
     * so it can be used in a gas efficient manner.
     */
    function _strategyStorage() private pure returns (StrategyData storage S) {
        // Since STORAGE_SLOT is a constant, we have to put a variable
        // on the stack to access it from an inline assembly block.
        bytes32 slot = BASE_STRATEGY_STORAGE;
        assembly {
            S.slot := slot
        }
    }

    /*//////////////////////////////////////////////////////////////
                INITIALIZATION OF DEFAULT STORAGE
    //////////////////////////////////////////////////////////////*/

    /**
     * @notice Used to initialize storage for a newly deployed strategy.
     * @dev This should be called atomically whenever a new strategy is
     * deployed and can only be called once for each strategy.
     *
     * This will set all the default storage that must be set for a
     * strategy to function. Any changes can be made post deployment
     * through external calls from `management`.
     *
     * The function will also emit an event that off chain indexers can
     * look for to track any new deployments using this TokenizedStrategy.
     *
     * This is called through a low level call in the BaseStrategy
     * so any reverts will return the "init failed" string.
     *
     * @param _asset Address of the underlying asset.
     * @param _name Name the strategy will use.
     * @param _management Address to set as the strategies `management`.
     * @param _performanceFeeRecipient Address to receive performance fees.
     * @param _keeper Address to set as strategies `keeper`.
     */
    function init(
        address _asset,
        string memory _name,
        address _management,
        address _performanceFeeRecipient,
        address _keeper
    ) external {
        // Cache storage pointer
        StrategyData storage S = _strategyStorage();

        // Make sure we aren't initialized.
        require(address(S.asset) == address(0), "initialized");

        // Set the strategy's underlying asset
        S.asset = ERC20(_asset);
        // Set the Strategy Tokens name.
        S.name = _name;
        // Set decimals based off the `asset`.
        S.decimals = ERC20(_asset).decimals();
        // Set initial chain id for permit replay protection
        S.INITIAL_CHAIN_ID = block.chainid;
        // Set the initial domain separator for permit functions
        S.INITIAL_DOMAIN_SEPARATOR = _computeDomainSeparator();

        // Default to a 10 day profit unlock period
        S.profitMaxUnlockTime = 10 days;
        // Set address to receive performance fees.
        // Can't be address(0) or we will be burning fees.
        require(_performanceFeeRecipient != address(0), "ZERO ADDRESS");
        // Can't mint shares to its self because of profit locking.
        require(_performanceFeeRecipient != address(this), "self");
        S.performanceFeeRecipient = _performanceFeeRecipient;
        // Default to a 10% performance fee.
        S.performanceFee = 1_000;
        // Set last report to this block.
        S.lastReport = uint128(block.timestamp);

        // Set the default management address. Can't be 0.
        require(_management != address(0), "ZERO ADDRESS");
        S.management = _management;
        // Set the keeper address
        S.keeper = _keeper;

        // Emit event to signal a new strategy has been initialized.
        emit NewTokenizedStrategy(address(this), _asset, API_VERSION);
    }

    /*//////////////////////////////////////////////////////////////
                        ERC4626 FUNCTIONS
    //////////////////////////////////////////////////////////////*/

    /**
     * @notice Mints `shares` of strategy shares to `receiver` by
     * depositing exactly `assets` of underlying tokens.
     * @param assets The amount of underlying to deposit in.
     * @param receiver The address to receive the `shares`.
     * @return shares The actual amount of shares issued.
     */
    function deposit(
        uint256 assets,
        address receiver
    ) external nonReentrant returns (uint256 shares) {
        // Checking max deposit will also check if shutdown.
        require(
            assets <= maxDeposit(receiver),
            "ERC4626: deposit more than max"
        );
        // Check for rounding error.
        require((shares = previewDeposit(assets)) != 0, "ZERO_SHARES");

        _deposit(receiver, assets, shares);
    }

    /**
     * @notice Mints exactly `shares` of strategy shares to
     * `receiver` by depositing `assets` of underlying tokens.
     * @param shares The amount of strategy shares mint.
     * @param receiver The address to receive the `shares`.
     * @return assets The actual amount of asset deposited.
     */
    function mint(
        uint256 shares,
        address receiver
    ) external nonReentrant returns (uint256 assets) {
        // Checking max mint will also check if shutdown.
        require(shares <= maxMint(receiver), "ERC4626: mint more than max");
        // Check for rounding error.
        require((assets = previewMint(shares)) != 0, "ZERO_ASSETS");

        _deposit(receiver, assets, shares);
    }

    /**
     * @notice Withdraws exactly `assets` from `owners` shares and sends
     * the underlying tokens to `receiver`.
     * @dev This will default to not allowing any loss to be taken.
     * @param assets The amount of underlying to withdraw.
     * @param receiver The address to receive `assets`.
     * @param owner The address whose shares are burnt.
     * @return shares The actual amount of shares burnt.
     */
    function withdraw(
        uint256 assets,
        address receiver,
        address owner
    ) external returns (uint256 shares) {
        return withdraw(assets, receiver, owner, 0);
    }

    /**
     * @notice Withdraws `assets` from `owners` shares and sends
     * the underlying tokens to `receiver`.
     * @dev This includes an added parameter to allow for losses.
     * @param assets The amount of underlying to withdraw.
     * @param receiver The address to receive `assets`.
     * @param owner The address whose shares are burnt.
     * @param maxLoss The amount of acceptable loss in Basis points.
     * @return shares The actual amount of shares burnt.
     */
    function withdraw(
        uint256 assets,
        address receiver,
        address owner,
        uint256 maxLoss
    ) public nonReentrant returns (uint256 shares) {
        require(
            assets <= maxWithdraw(owner),
            "ERC4626: withdraw more than max"
        );
        // Check for rounding error or 0 value.
        require((shares = previewWithdraw(assets)) != 0, "ZERO_SHARES");

        // Withdraw and track the actual amount withdrawn for loss check.
        _withdraw(receiver, owner, assets, shares, maxLoss);
    }

    /**
     * @notice Redeems exactly `shares` from `owner` and
     * sends `assets` of underlying tokens to `receiver`.
     * @dev This will default to allowing any loss passed to be realized.
     * @param shares The amount of shares burnt.
     * @param receiver The address to receive `assets`.
     * @param owner The address whose shares are burnt.
     * @return assets The actual amount of underlying withdrawn.
     */
    function redeem(
        uint256 shares,
        address receiver,
        address owner
    ) external returns (uint256) {
        // We default to not limiting a potential loss.
        return redeem(shares, receiver, owner, MAX_BPS);
    }

    /**
     * @notice Redeems exactly `shares` from `owner` and
     * sends `assets` of underlying tokens to `receiver`.
     * @dev This includes an added parameter to allow for losses.
     * @param shares The amount of shares burnt.
     * @param receiver The address to receive `assets`.
     * @param owner The address whose shares are burnt.
     * @param maxLoss The amount of acceptable loss in Basis points.
     * @return . The actual amount of underlying withdrawn.
     */
    function redeem(
        uint256 shares,
        address receiver,
        address owner,
        uint256 maxLoss
    ) public nonReentrant returns (uint256) {
        require(shares <= maxRedeem(owner), "ERC4626: redeem more than max");
        uint256 assets;
        // Check for rounding error or 0 value.
        require((assets = previewRedeem(shares)) != 0, "ZERO_ASSETS");

        // We need to return the actual amount withdrawn in case of a loss.
        return _withdraw(receiver, owner, assets, shares, maxLoss);
    }

    /**
     * @notice The amount of shares that the strategy would
     *  exchange for the amount of assets provided, in an
     * ideal scenario where all the conditions are met.
     *
     * @param assets The amount of underlying.
     * @return . Expected shares that `assets` represents.
     */
    function convertToShares(uint256 assets) public view returns (uint256) {
        // Saves an extra SLOAD if totalAssets() is non-zero.
        uint256 _totalAssets = totalAssets();
        uint256 _totalSupply = totalSupply();

        // If assets are 0 but supply is not PPS = 0.
        if (_totalAssets == 0) return _totalSupply == 0 ? assets : 0;

        return assets.mulDiv(_totalSupply, _totalAssets, Math.Rounding.Down);
    }

    /**
     * @notice The amount of assets that the strategy would
     * exchange for the amount of shares provided, in an
     * ideal scenario where all the conditions are met.
     *
     * @param shares The amount of the strategies shares.
     * @return . Expected amount of `asset` the shares represents.
     */
    function convertToAssets(uint256 shares) public view returns (uint256) {
        // Saves an extra SLOAD if totalSupply() is non-zero.
        uint256 supply = totalSupply();

        return
            supply == 0
                ? shares
                : shares.mulDiv(totalAssets(), supply, Math.Rounding.Down);
    }

    /**
     * @notice Allows an on-chain or off-chain user to simulate
     * the effects of their deposit at the current block, given
     * current on-chain conditions.
     * @dev This will round down.
     *
     * @param assets The amount of `asset` to deposits.
     * @return . Expected shares that would be issued.
     */
    function previewDeposit(uint256 assets) public view returns (uint256) {
        return convertToShares(assets);
    }

    /**
     * @notice Allows an on-chain or off-chain user to simulate
     * the effects of their mint at the current block, given
     * current on-chain conditions.
     * @dev This is used instead of convertToAssets so that it can
     * round up for safer mints.
     *
     * @param shares The amount of shares to mint.
     * @return . The needed amount of `asset` for the mint.
     */
    function previewMint(uint256 shares) public view returns (uint256) {
        // Saves an extra SLOAD if totalSupply() is non-zero.
        uint256 supply = totalSupply();

        return
            supply == 0
                ? shares
                : shares.mulDiv(totalAssets(), supply, Math.Rounding.Up);
    }

    /**
     * @notice Allows an on-chain or off-chain user to simulate
     * the effects of their withdrawal at the current block,
     * given current on-chain conditions.
     * @dev This is used instead of convertToShares so that it can
     * round up for safer withdraws.
     *
     * @param assets The amount of `asset` that would be withdrawn.
     * @return . The amount of shares that would be burnt.
     */
    function previewWithdraw(uint256 assets) public view returns (uint256) {
        // Saves an extra SLOAD if totalAssets() is non-zero.
        uint256 _totalAssets = totalAssets();
        uint256 _totalSupply = totalSupply();

        // If assets are 0 but supply is not, then PPS = 0.
        if (_totalAssets == 0) return _totalSupply == 0 ? assets : 0;

        return assets.mulDiv(_totalSupply, _totalAssets, Math.Rounding.Up);
    }

    /**
     * @notice Allows an on-chain or off-chain user to simulate
     * the effects of their redemption at the current block,
     * given current on-chain conditions.
     * @dev This will round down.
     *
     * @param shares The amount of shares that would be redeemed.
     * @return . The amount of `asset` that would be returned.
     */
    function previewRedeem(uint256 shares) public view returns (uint256) {
        return convertToAssets(shares);
    }

    /**
     * @notice Total number of underlying assets that can
     * be deposited by `_owner` into the strategy, where `owner`
     * corresponds to the receiver of a {deposit} call.
     *
     * @param owner The address depositing.
     * @return . The max that `owner` can deposit in `asset`.
     */
    function maxDeposit(address owner) public view returns (uint256) {
        if (_strategyStorage().shutdown) return 0;

        return IBaseStrategy(address(this)).availableDepositLimit(owner);
    }

    /**
     * @notice Total number of shares that can be minted by `owner`
     * into the strategy, where `_owner` corresponds to the receiver
     * of a {mint} call.
     *
     * @param owner The address minting.
     * @return _maxMint The max that `owner` can mint in shares.
     */
    function maxMint(address owner) public view returns (uint256 _maxMint) {
        if (_strategyStorage().shutdown) return 0;

        _maxMint = IBaseStrategy(address(this)).availableDepositLimit(owner);
        if (_maxMint != type(uint256).max) {
            _maxMint = convertToShares(_maxMint);
        }
    }

    /**
     * @notice Total number of underlying assets that can be
     * withdrawn from the strategy by `owner`, where `owner`
     * corresponds to the msg.sender of a {redeem} call.
     *
     * @param owner The owner of the shares.
     * @return _maxWithdraw Max amount of `asset` that can be withdrawn.
     */
    function maxWithdraw(
        address owner
    ) public view returns (uint256 _maxWithdraw) {
        _maxWithdraw = IBaseStrategy(address(this)).availableWithdrawLimit(
            owner
        );
        if (_maxWithdraw == type(uint256).max) {
            // Saves a min check if there is no withdrawal limit.
            _maxWithdraw = convertToAssets(balanceOf(owner));
        } else {
            _maxWithdraw = Math.min(
                convertToAssets(balanceOf(owner)),
                _maxWithdraw
            );
        }
    }

    /**
     * @notice Total number of strategy shares that can be
     * redeemed from the strategy by `owner`, where `owner`
     * corresponds to the msg.sender of a {redeem} call.
     *
     * @param owner The owner of the shares.
     * @return _maxRedeem Max amount of shares that can be redeemed.
     */
    function maxRedeem(address owner) public view returns (uint256 _maxRedeem) {
        _maxRedeem = IBaseStrategy(address(this)).availableWithdrawLimit(owner);
        // Conversion would overflow and saves a min check if there is no withdrawal limit.
        if (_maxRedeem == type(uint256).max) {
            _maxRedeem = balanceOf(owner);
        } else {
            _maxRedeem = Math.min(
                // Use preview withdraw to round up
                previewWithdraw(_maxRedeem),
                balanceOf(owner)
            );
        }
    }

    /*//////////////////////////////////////////////////////////////
                            ACCOUNTING LOGIC
    //////////////////////////////////////////////////////////////*/

    /**
     * @notice Get the total amount of assets this strategy holds
     * as of the last report.
     *
     * We manually track debt and idle to avoid any PPS manipulation
     * from donations, touch values of debt etc.
     *
     * @return . Total assets the strategy holds.
     */
    function totalAssets() public view returns (uint256) {
        StrategyData storage S = _strategyStorage();
        unchecked {
            return S.totalIdle + S.totalDebt;
        }
    }

    /**
     * @notice Get the current supply of the strategies shares.
     *
     * Locked shares issued to the strategy from profits are not
     * counted towards the full supply until they are unlocked.
     *
     * As more shares slowly unlock the totalSupply will decrease
     * causing the PPS of the strategy to increase.
     *
     * @return . Total amount of shares issued.
     */
    function totalSupply() public view returns (uint256) {
        return _strategyStorage().totalSupply - _unlockedShares();
    }

    /**
     * @dev Function to be called during {deposit} and {mint}.
     *
     * This function handles all logic including transfers,
     * minting and accounting.
     *
     * We do all external calls before updating any internal
     * values to prevent view reentrancy issues from the token
     * transfers or the _deployFunds() calls.
     */
    function _deposit(
        address receiver,
        uint256 assets,
        uint256 shares
    ) private {
        require(receiver != address(this), "ERC4626: mint to self");

        // Cache storage variables used more than once.
        StrategyData storage S = _strategyStorage();
        ERC20 _asset = S.asset;

        // Need to transfer before minting or ERC777s could reenter.
        _asset.safeTransferFrom(msg.sender, address(this), assets);

        // We will deposit up to current idle plus the new amount added
        uint256 toDeploy = S.totalIdle + assets;

        // Cache for post {deployFunds} checks.
        uint256 beforeBalance = _asset.balanceOf(address(this));

        // Deploy up to all loose funds.
        IBaseStrategy(address(this)).deployFunds(toDeploy);

        // Always get the actual amount deployed. We double check the
        // diff against toDeploy for complete accuracy.
        uint256 deployed = Math.min(
            beforeBalance - _asset.balanceOf(address(this)),
            toDeploy
        );

        // Adjust total Assets.
        S.totalDebt += deployed;
        unchecked {
            // Cant't underflow due to previous min check.
            S.totalIdle = toDeploy - deployed;
        }

        // mint shares
        _mint(receiver, shares);

        emit Deposit(msg.sender, receiver, assets, shares);
    }

    /**
     * @dev To be called during {redeem} and {withdraw}.
     *
     * This will handle all logic, transfers and accounting
     * in order to service the withdraw request.
     *
     * If we are not able to withdraw the full amount needed, it will
     * be counted as a loss and passed on to the user.
     */
    function _withdraw(
        address receiver,
        address owner,
        uint256 assets,
        uint256 shares,
        uint256 maxLoss
    ) private returns (uint256) {
        require(receiver != address(0), "ZERO ADDRESS");
        require(maxLoss <= MAX_BPS, "exceeds MAX_BPS");

        // Spend allowance if applicable.
        if (msg.sender != owner) {
            _spendAllowance(owner, msg.sender, shares);
        }

        StrategyData storage S = _strategyStorage();
        // Expected behavior is to need to free funds so we cache `_asset`.
        ERC20 _asset = S.asset;

        uint256 idle = S.totalIdle;

        // Check if we need to withdraw funds.
        if (idle < assets) {
            // Cache before balance for diff checks.
            uint256 before = _asset.balanceOf(address(this));

            // Tell Strategy to free what we need.
            unchecked {
                IBaseStrategy(address(this)).freeFunds(assets - idle);
            }

            // Return the actual amount withdrawn. Adjust for potential over withdraws.
            uint256 withdrawn = Math.min(
                _asset.balanceOf(address(this)) - before,
                S.totalDebt
            );

            unchecked {
                idle += withdrawn;
            }

            uint256 loss;
            // If we didn't get enough out then we have a loss.
            if (idle < assets) {
                unchecked {
                    loss = assets - idle;
                }
                // If a non-default max loss parameter was set.
                if (maxLoss < MAX_BPS) {
                    // Make sure we are within the acceptable range.
                    require(
                        loss <= (assets * maxLoss) / MAX_BPS,
                        "too much loss"
                    );
                }
                // Lower the amount to be withdrawn.
                assets = idle;
            }

            // Update debt storage.
            S.totalDebt -= (withdrawn + loss);
        }

        // Update idle based on how much we took.
        S.totalIdle = idle - assets;

        _burn(owner, shares);

        _asset.safeTransfer(receiver, assets);

        emit Withdraw(msg.sender, receiver, owner, assets, shares);

        // Return the actual amount of assets withdrawn.
        return assets;
    }

    /*//////////////////////////////////////////////////////////////
                        PROFIT LOCKING
    //////////////////////////////////////////////////////////////*/

    /**
     * @notice Function for keepers to call to harvest and record all
     * profits accrued.
     *
     * @dev This should be called through protected relays if swaps
     * are likely occur.
     *
     * This will account for any gains/losses since the last report
     * and charge fees accordingly.
     *
     * Any profit over the fees charged will be immediately locked
     * so there is no change in PricePerShare. Then slowly unlocked
     * over the `maxProfitUnlockTime` each second based on the
     * calculated `profitUnlockingRate`.
     *
     * In case of a loss it will first attempt to offset the loss
     * with any remaining locked shares from the last report in
     * order to reduce any negative impact to PPS.
     *
     * Will then recalculate the new time to unlock profits over and the
     * rate based on a weighted average of any remaining time from the
     * last report and the new amount of shares to be locked.
     *
     * @return profit The notional amount of gain if any since the last
     * report in terms of `asset`.
     * @return loss The notional amount of loss if any since the last
     * report in terms of `asset`.
     */
    function report()
        external
        nonReentrant
        onlyKeepers
        returns (uint256 profit, uint256 loss)
    {
        // Cache storage pointer since its used repeatedly.
        StrategyData storage S = _strategyStorage();

        uint256 oldTotalAssets;
        unchecked {
            // Manually calculate totalAssets to save a SLOAD.
            oldTotalAssets = S.totalIdle + S.totalDebt;
        }

        // Tell the strategy to report the real total assets it has.
        // It should do all reward selling and redepositing now and
        // account for deployed and loose `asset` so we can accurately
        // account for all funds including those potentially airdropped
        // by a trade factory. It is safe here to use asset.balanceOf()
        // instead of totalIdle because any profits are immediately locked.
        uint256 newTotalAssets = IBaseStrategy(address(this))
            .harvestAndReport();

        // Burn unlocked shares.
        _burnUnlockedShares();

        // Initialize variables needed throughout.
        uint256 totalFees;
        uint256 protocolFees;
        uint256 sharesToLock;
        uint256 _profitMaxUnlockTime = S.profitMaxUnlockTime;
        // Calculate profit/loss.
        if (newTotalAssets > oldTotalAssets) {
            // We have a profit.
            unchecked {
                profit = newTotalAssets - oldTotalAssets;
                // Asses performance fees.
                totalFees = (profit * S.performanceFee) / MAX_BPS;
            }

            address protocolFeesRecipient;
            uint256 performanceFeeShares;
            uint256 protocolFeeShares;
            // If performance fees are 0 so will protocol fees.
            if (totalFees != 0) {
                // Get the config from the factory.
                uint16 protocolFeeBps;
                (protocolFeeBps, protocolFeesRecipient) = IFactory(FACTORY)
                    .protocol_fee_config();

                // Check if there is a protocol fee to charge.
                if (protocolFeeBps != 0) {
                    // Calculate protocol fees based on the performance Fees.
                    protocolFees = (totalFees * protocolFeeBps) / MAX_BPS;
                }

                // We need to get the shares to issue for the fees at
                // current PPS before any minting or burning.
                unchecked {
                    performanceFeeShares = convertToShares(
                        totalFees - protocolFees
                    );
                }
                if (protocolFees != 0) {
                    protocolFeeShares = convertToShares(protocolFees);
                }
            }

            // we have a net profit. Check if we are locking profit.
            if (_profitMaxUnlockTime != 0) {
                // lock (profit - fees)
                unchecked {
                    sharesToLock = convertToShares(profit - totalFees);
                }
                // Mint the shares to lock the strategy.
                _mint(address(this), sharesToLock);
            }

            // Mint fees shares to recipients.
            if (performanceFeeShares != 0) {
                _mint(S.performanceFeeRecipient, performanceFeeShares);
            }

            if (protocolFeeShares != 0) {
                _mint(protocolFeesRecipient, protocolFeeShares);
            }
        } else {
            // We have a loss.
            unchecked {
                loss = oldTotalAssets - newTotalAssets;
            }

            // Check in case else was due to being equal.
            if (loss != 0) {
                // We will try and burn shares from any pending profit still unlocking
                // to offset the loss to prevent any PPS decline post report.
                uint256 sharesToBurn = Math.min(
                    S.balances[address(this)],
                    convertToShares(loss)
                );

                // Check if there is anything to burn.
                if (sharesToBurn != 0) {
                    _burn(address(this), sharesToBurn);
                }
            }
        }

        // Update unlocking rate and time to fully unlocked.
        uint256 totalLockedShares = S.balances[address(this)];
        if (totalLockedShares != 0) {
            uint256 previouslyLockedTime;
            uint128 _fullProfitUnlockDate = S.fullProfitUnlockDate;
            // Check if we need to account for shares still unlocking.
            if (_fullProfitUnlockDate > block.timestamp) {
                unchecked {
                    // There will only be previously locked shares if time remains.
                    // We calculate this here since it should be rare.
                    previouslyLockedTime =
                        (_fullProfitUnlockDate - block.timestamp) *
                        (totalLockedShares - sharesToLock);
                }
            }

            // newProfitLockingPeriod is a weighted average between the remaining
            // time of the previously locked shares and the profitMaxUnlockTime.
            uint256 newProfitLockingPeriod = (previouslyLockedTime +
                sharesToLock *
                _profitMaxUnlockTime) / totalLockedShares;

            // Calculate how many shares unlock per second.
            S.profitUnlockingRate =
                (totalLockedShares * MAX_BPS_EXTENDED) /
                newProfitLockingPeriod;

            // Calculate how long until the full amount of shares is unlocked.
            S.fullProfitUnlockDate = uint128(
                block.timestamp + newProfitLockingPeriod
            );
        } else {
            // Only setting this to 0 will turn in the desired effect,
            // no need to update fullProfitUnlockDate.
            S.profitUnlockingRate = 0;
        }

        // Update storage we use the actual loose here since it should have
        // been accounted for in `harvestAndReport` and any airdropped amounts
        // would have been locked to prevent PPS manipulation.
        uint256 newIdle = S.asset.balanceOf(address(this));
        S.totalIdle = newIdle;
        S.totalDebt = newTotalAssets - newIdle;

        S.lastReport = uint128(block.timestamp);

        // Emit event with info
        emit Reported(
            profit,
            loss,
            protocolFees, // Protocol fees
            totalFees - protocolFees // Performance Fees
        );
    }

    /**
     * @dev Called during reports to burn shares that have been unlocked
     * since the last report.
     *
     * Will reset the `lastReport` if haven't unlocked the full amount yet
     * so future calculations remain correct.
     */
    function _burnUnlockedShares() private {
        uint256 unlocked = _unlockedShares();
        if (unlocked == 0) {
            return;
        }

        // update variables (done here to keep _unlockedShares() as a view function)
        if (_strategyStorage().fullProfitUnlockDate > block.timestamp) {
            _strategyStorage().lastReport = uint128(block.timestamp);
        }

        _burn(address(this), unlocked);
    }

    /**
     * @notice Get how many shares have been unlocked since last report.
     * @return . The amount of shares that have unlocked.
     */
    function unlockedShares() external view returns (uint256) {
        return _unlockedShares();
    }

    /**
     * @dev To determine how many of the shares that were locked during the last
     * report have since unlocked.
     *
     * If the `fullProfitUnlockDate` has passed the full strategy's balance will
     * count as unlocked.
     *
     * @return unlocked The amount of shares that have unlocked.
     */
    function _unlockedShares() private view returns (uint256 unlocked) {
        // should save 2 extra calls for most scenarios.
        StrategyData storage S = _strategyStorage();
        uint128 _fullProfitUnlockDate = S.fullProfitUnlockDate;
        if (_fullProfitUnlockDate > block.timestamp) {
            unchecked {
                unlocked =
                    (S.profitUnlockingRate * (block.timestamp - S.lastReport)) /
                    MAX_BPS_EXTENDED;
            }
        } else if (_fullProfitUnlockDate != 0) {
            // All shares have been unlocked.
            unlocked = S.balances[address(this)];
        }
    }

    /*//////////////////////////////////////////////////////////////
                        TENDING LOGIC
    //////////////////////////////////////////////////////////////*/

    /**
     * @notice For a 'keeper' to 'tend' the strategy if a custom
     * tendTrigger() is implemented.
     *
     * @dev Both 'tendTrigger' and '_tend' will need to be overridden
     * for this to be used.
     *
     * This will callback the internal '_tend' call in the BaseStrategy
     * with the total current amount available to the strategy to deploy.
     *
     * Keepers are expected to use protected relays in tend calls so this
     * can be used for illiquid or manipulatable strategies to compound
     * rewards, perform maintenance or deposit/withdraw funds.
     *
     * All accounting for totalDebt and totalIdle updates will be done
     * here post '_tend'.
     *
     * This should never cause an increase in PPS. Total assets should
     * be the same before and after
     *
     * A report() call will be needed to record the profit.
     */
    function tend() external nonReentrant onlyKeepers {
        // Tend the strategy with the current totalIdle.
        IBaseStrategy(address(this)).tendThis(_strategyStorage().totalIdle);

        // Update balances based on ending state.
        _updateBalances();
    }

    /**
     * @notice Update the internal balances that make up `totalAssets`.
     * @dev This will update the ratio of debt and idle that make up
     * totalAssets based on the actual current loose amount of `asset`
     * in a safe way. But will keep `totalAssets` the same, thus having
     * no effect on Price Per Share.
     */
    function _updateBalances() internal {
        StrategyData storage S = _strategyStorage();

        // Get the current loose balance.
        uint256 assetBalance = S.asset.balanceOf(address(this));

        // If its already accurate do nothing.
        if (S.totalIdle == assetBalance) return;

        // Get the total assets the strategy should have.
        uint256 _totalAssets = totalAssets();

        // If we have enough loose to cover all assets.
        if (assetBalance >= _totalAssets) {
            // Set idle to totalAssets.
            S.totalIdle = _totalAssets;
            // Set debt to 0.
            S.totalDebt = 0;
        } else {
            // Otherwise idle is the actual loose balance.
            S.totalIdle = assetBalance;
            unchecked {
                // And debt is the difference.
                S.totalDebt = _totalAssets - assetBalance;
            }
        }

        // Enforce the invariant.
        require(_totalAssets == totalAssets(), "!totalAssets");
    }

    /*//////////////////////////////////////////////////////////////
                        STRATEGY SHUTDOWN
    //////////////////////////////////////////////////////////////*/

    /**
     * @notice Used to shutdown the strategy preventing any further deposits.
     * @dev Can only be called by the current `management` or `emergencyAdmin`.
     *
     * This will stop any new {deposit} or {mint} calls but will
     * not prevent {withdraw} or {redeem}. It will also still allow for
     * {tend} and {report} so that management can report any last losses
     * in an emergency as well as provide any maintenance to allow for full
     * withdraw.
     *
     * This is a one way switch and can never be set back once shutdown.
     */
    function shutdownStrategy() external onlyEmergencyAuthorized {
        _strategyStorage().shutdown = true;

        emit StrategyShutdown();
    }

    /**
     * @notice To manually withdraw funds from the yield source after a
     * strategy has been shutdown.
     * @dev This can only be called post {shutdownStrategy}.
     *
     * This will update totalDebt and totalIdle based on the amount of
     * loose `asset` after the withdraw leaving `totalAssets` unchanged.
     *
     * A strategist will need to override the {_emergencyWithdraw} function
     * in their strategy for this to work.
     *
     * @param amount The amount of asset to attempt to free.
     */
    function emergencyWithdraw(
        uint256 amount
    ) external nonReentrant onlyEmergencyAuthorized {
        // Make sure the strategy has been shutdown.
        require(_strategyStorage().shutdown, "not shutdown");

        // Withdraw from the yield source.
        IBaseStrategy(address(this)).shutdownWithdraw(amount);

        // Record the updated balances based on the new amounts.
        _updateBalances();
    }

    /*//////////////////////////////////////////////////////////////
                        GETTER FUNCTIONS
    //////////////////////////////////////////////////////////////*/

    /**
     * @notice Get the underlying asset for the strategy.
     * @return . The underlying asset.
     */
    function asset() external view returns (address) {
        return address(_strategyStorage().asset);
    }

    /**
     * @notice Get the API version for this TokenizedStrategy.
     * @return . The API version for this TokenizedStrategy
     */
    function apiVersion() external pure returns (string memory) {
        return API_VERSION;
    }

    /**
     * @notice Get the current total idle for a strategy.
     * @return . The current amount of idle funds.
     */
    function totalIdle() external view returns (uint256) {
        return _strategyStorage().totalIdle;
    }

    /**
     * @notice Get the current total debt for a strategy.
     * @return . The current amount of debt.
     */
    function totalDebt() external view returns (uint256) {
        return _strategyStorage().totalDebt;
    }

    /**
     * @notice Get the current address that controls the strategy.
     * @return . Address of management
     */
    function management() external view returns (address) {
        return _strategyStorage().management;
    }

    /**
     * @notice Get the current pending management address if any.
     * @return . Address of pendingManagement
     */
    function pendingManagement() external view returns (address) {
        return _strategyStorage().pendingManagement;
    }

    /**
     * @notice Get the current address that can call tend and report.
     * @return . Address of the keeper
     */
    function keeper() external view returns (address) {
        return _strategyStorage().keeper;
    }

    /**
     * @notice Get the current address that can shutdown and emergency withdraw.
     * @return . Address of the emergencyAdmin
     */
    function emergencyAdmin() external view returns (address) {
        return _strategyStorage().emergencyAdmin;
    }

    /**
     * @notice Get the current performance fee charged on profits.
     * denominated in Basis Points where 10_000 == 100%
     * @return . Current performance fee.
     */
    function performanceFee() external view returns (uint16) {
        return _strategyStorage().performanceFee;
    }

    /**
     * @notice Get the current address that receives the performance fees.
     * @return . Address of performanceFeeRecipient
     */
    function performanceFeeRecipient() external view returns (address) {
        return _strategyStorage().performanceFeeRecipient;
    }

    /**
     * @notice Gets the timestamp at which all profits will be unlocked.
     * @return . The full profit unlocking timestamp
     */
    function fullProfitUnlockDate() external view returns (uint256) {
        return uint256(_strategyStorage().fullProfitUnlockDate);
    }

    /**
     * @notice The per second rate at which profits are unlocking.
     * @dev This is denominated in EXTENDED_BPS decimals.
     * @return . The current profit unlocking rate.
     */
    function profitUnlockingRate() external view returns (uint256) {
        return _strategyStorage().profitUnlockingRate;
    }

    /**
     * @notice Gets the current time profits are set to unlock over.
     * @return . The current profit max unlock time.
     */
    function profitMaxUnlockTime() external view returns (uint256) {
        return _strategyStorage().profitMaxUnlockTime;
    }

    /**
     * @notice The timestamp of the last time protocol fees were charged.
     * @return . The last report.
     */
    function lastReport() external view returns (uint256) {
        return uint256(_strategyStorage().lastReport);
    }

    /**
     * @notice Get the price per share.
     * @dev This value offers limited precision. Integrations that require
     * exact precision should use convertToAssets or convertToShares instead.
     *
     * @return . The price per share.
     */
    function pricePerShare() external view returns (uint256) {
        return convertToAssets(10 ** _strategyStorage().decimals);
    }

    /**
     * @notice To check if the strategy has been shutdown.
     * @return . Whether or not the strategy is shutdown.
     */
    function isShutdown() public view returns (bool) {
        return _strategyStorage().shutdown;
    }

    /*//////////////////////////////////////////////////////////////
                        SETTER FUNCTIONS
    //////////////////////////////////////////////////////////////*/

    /**
     * @notice Step one of two to set a new address to be in charge of the strategy.
     * @dev Can only be called by the current `management`. The address is
     * set to pending management and will then have to call {acceptManagement}
     * in order for the 'management' to officially change.
     *
     * Cannot set `management` to address(0).
     *
     * @param _management New address to set `pendingManagement` to.
     */
    function setPendingManagement(address _management) external onlyManagement {
        require(_management != address(0), "ZERO ADDRESS");
        _strategyStorage().pendingManagement = _management;

        emit UpdatePendingManagement(_management);
    }

    /**
     * @notice Step two of two to set a new 'management' of the strategy.
     * @dev Can only be called by the current `pendingManagement`.
     */
    function acceptManagement() external {
        require(msg.sender == _strategyStorage().pendingManagement, "!pending");
        _strategyStorage().management = msg.sender;
        _strategyStorage().pendingManagement = address(0);

        emit UpdateManagement(msg.sender);
    }

    /**
     * @notice Sets a new address to be in charge of tend and reports.
     * @dev Can only be called by the current `management`.
     *
     * @param _keeper New address to set `keeper` to.
     */
    function setKeeper(address _keeper) external onlyManagement {
        _strategyStorage().keeper = _keeper;

        emit UpdateKeeper(_keeper);
    }

    /**
     * @notice Sets a new address to be able to shutdown the strategy.
     * @dev Can only be called by the current `management`.
     *
     * @param _emergencyAdmin New address to set `emergencyAdmin` to.
     */
    function setEmergencyAdmin(
        address _emergencyAdmin
    ) external onlyManagement {
        _strategyStorage().emergencyAdmin = _emergencyAdmin;

        emit UpdateEmergencyAdmin(_emergencyAdmin);
    }

    /**
     * @notice Sets the performance fee to be charged on reported gains.
     * @dev Can only be called by the current `management`.
     *
     * Denominated in Basis Points. So 100% == 10_000.
     * Cannot be set less than the MIN_FEE.
     * Cannot set greater than to MAX_FEE.
     *
     * @param _performanceFee New performance fee.
     */
    function setPerformanceFee(uint16 _performanceFee) external onlyManagement {
        require(_performanceFee >= MIN_FEE, "MIN FEE");
        require(_performanceFee <= MAX_FEE, "MAX FEE");
        _strategyStorage().performanceFee = _performanceFee;

        emit UpdatePerformanceFee(_performanceFee);
    }

    /**
     * @notice Sets a new address to receive performance fees.
     * @dev Can only be called by the current `management`.
     *
     * Cannot set to address(0).
     *
     * @param _performanceFeeRecipient New address to set `management` to.
     */
    function setPerformanceFeeRecipient(
        address _performanceFeeRecipient
    ) external onlyManagement {
        require(_performanceFeeRecipient != address(0), "ZERO ADDRESS");
        require(_performanceFeeRecipient != address(this), "Cannot be self");
        _strategyStorage().performanceFeeRecipient = _performanceFeeRecipient;

        emit UpdatePerformanceFeeRecipient(_performanceFeeRecipient);
    }

    /**
     * @notice Sets the time for profits to be unlocked over.
     * @dev Can only be called by the current `management`.
     *
     * Denominated in seconds and cannot be greater than 1 year.
     *
     * NOTE: Setting to 0 will cause all currently locked profit
     * to be unlocked instantly and should be done with care.
     *
     * `profitMaxUnlockTime` is stored as a uint32 for packing but can
     * be passed in as uint256 for simplicity.
     *
     * @param _profitMaxUnlockTime New `profitMaxUnlockTime`.
     */
    function setProfitMaxUnlockTime(
        uint256 _profitMaxUnlockTime
    ) external onlyManagement {
        // Must be less than a year.
        require(_profitMaxUnlockTime <= SECONDS_PER_YEAR, "too long");
        StrategyData storage S = _strategyStorage();

        // If we are setting to 0 we need to adjust amounts.
        if (_profitMaxUnlockTime == 0) {
            // Burn all shares if applicable.
            _burn(address(this), S.balances[address(this)]);
            // Reset unlocking variables
            S.profitUnlockingRate = 0;
            S.fullProfitUnlockDate = 0;
        }

        S.profitMaxUnlockTime = uint32(_profitMaxUnlockTime);

        emit UpdateProfitMaxUnlockTime(_profitMaxUnlockTime);
    }

    /*//////////////////////////////////////////////////////////////
                        ERC20 FUNCTIONS
    //////////////////////////////////////////////////////////////*/

    /**
     * @notice Returns the name of the token.
     * @return . The name the strategy is using for its token.
     */
    function name() external view returns (string memory) {
        return _strategyStorage().name;
    }

    /**
     * @notice Returns the symbol of the strategies token.
     * @dev Will be 'ys + asset symbol'.
     * @return . The symbol the strategy is using for its tokens.
     */
    function symbol() public view returns (string memory) {
        return
            string(abi.encodePacked("ys", _strategyStorage().asset.symbol()));
    }

    /**
     * @notice Returns the number of decimals used to get its user representation.
     * @return . The decimals used for the strategy and `asset`.
     */
    function decimals() public view returns (uint8) {
        return _strategyStorage().decimals;
    }

    /**
     * @notice Returns the current balance for a given '_account'.
     * @dev If the '_account` is the strategy then this will subtract
     * the amount of shares that have been unlocked since the last profit first.
     * @param account the address to return the balance for.
     * @return . The current balance in y shares of the '_account'.
     */
    function balanceOf(address account) public view returns (uint256) {
        if (account == address(this)) {
            return _strategyStorage().balances[account] - _unlockedShares();
        }
        return _strategyStorage().balances[account];
    }

    /**
     * @notice Transfer '_amount` of shares from `msg.sender` to `to`.
     * @dev
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - `to` cannot be the address of the strategy.
     * - the caller must have a balance of at least `_amount`.
     *
     * @param to The address shares will be transferred to.
     * @param amount The amount of shares to be transferred from sender.
     * @return . a boolean value indicating whether the operation succeeded.
     */
    function transfer(address to, uint256 amount) external returns (bool) {
        _transfer(msg.sender, to, amount);
        return true;
    }

    /**
     * @notice 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.
     * @param owner The address who owns the shares.
     * @param spender The address who would be moving the owners shares.
     * @return . The remaining amount of shares of `owner` that could be moved by `spender`.
     */
    function allowance(
        address owner,
        address spender
    ) public view returns (uint256) {
        return _strategyStorage().allowances[owner][spender];
    }

    /**
     * @notice Sets `amount` as the allowance of `spender` over the caller's tokens.
     * @dev
     *
     * NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on
     * `transferFrom`. This is semantically equivalent to an infinite approval.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     *
     * 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.
     *
     * @param spender the address to allow the shares to be moved by.
     * @param amount the amount of shares to allow `spender` to move.
     * @return . a boolean value indicating whether the operation succeeded.
     */
    function approve(address spender, uint256 amount) external returns (bool) {
        _approve(msg.sender, spender, amount);
        return true;
    }

    /**
     * @notice `amount` tokens from `from` to `to` using the
     * allowance mechanism. `amount` is then deducted from the caller's
     * allowance.
     *
     * @dev
     * Emits an {Approval} event indicating the updated allowance. This is not
     * required by the EIP.
     *
     * NOTE: Does not update the allowance if the current allowance
     * is the maximum `uint256`.
     *
     * Requirements:
     *
     * - `from` and `to` cannot be the zero address.
     * - `to` cannot be the address of the strategy.
     * - `from` must have a balance of at least `amount`.
     * - the caller must have allowance for ``from``'s tokens of at least
     * `amount`.
     *
     * Emits a {Transfer} event.
     *
     * @param from the address to be moving shares from.
     * @param to the address to be moving shares to.
     * @param amount the quantity of shares to move.
     * @return . a boolean value indicating whether the operation succeeded.
     */
    function transferFrom(
        address from,
        address to,
        uint256 amount
    ) public returns (bool) {
        _spendAllowance(from, msg.sender, amount);
        _transfer(from, to, amount);
        return true;
    }

    /**
     * @notice Atomically increases the allowance granted to `spender` by the caller.
     *
     * @dev This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - cannot give spender over uint256.max allowance
     *
     * @param spender the account that will be able to move the senders shares.
     * @param addedValue the extra amount to add to the current allowance.
     * @return . a boolean value indicating whether the operation succeeded.
     */
    function increaseAllowance(
        address spender,
        uint256 addedValue
    ) external returns (bool) {
        address owner = msg.sender;
        _approve(owner, spender, allowance(owner, spender) + addedValue);
        return true;
    }

    /**
     * @notice Atomically decreases the allowance granted to `spender` by the caller.
     *
     * @dev This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `spender` must have allowance for the caller of at least
     * `subtractedValue`.
     *
     * @param spender the account that will be able to move less of the senders shares.
     * @param subtractedValue the amount to decrease the current allowance by.
     * @return . a boolean value indicating whether the operation succeeded.
     */
    function decreaseAllowance(
        address spender,
        uint256 subtractedValue
    ) external returns (bool) {
        address owner = msg.sender;
        _approve(owner, spender, allowance(owner, spender) - subtractedValue);
        return true;
    }

    /**
     * @dev Moves `amount` of tokens from `from` to `to`.
     *
     * This internal function is equivalent to {transfer}, and can be used to
     * e.g. implement automatic token fees, slashing mechanisms, etc.
     *
     * Emits a {Transfer} event.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `to` cannot be the strategies address
     * - `from` must have a balance of at least `amount`.
     *
     */
    function _transfer(address from, address to, uint256 amount) private {
        require(from != address(0), "ERC20: transfer from the zero address");
        require(to != address(0), "ERC20: transfer to the zero address");
        require(to != address(this), "ERC20 transfer to strategy");
        StrategyData storage S = _strategyStorage();

        S.balances[from] -= amount;
        unchecked {
            S.balances[to] += amount;
        }

        emit Transfer(from, to, amount);
    }

    /** @dev Creates `amount` tokens and assigns them to `account`, increasing
     * the total supply.
     *
     * Emits a {Transfer} event with `from` set to the zero address.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     *
     */
    function _mint(address account, uint256 amount) private {
        require(account != address(0), "ERC20: mint to the zero address");
        StrategyData storage S = _strategyStorage();

        S.totalSupply += amount;
        unchecked {
            S.balances[account] += amount;
        }
        emit Transfer(address(0), account, amount);
    }

    /**
     * @dev Destroys `amount` tokens from `account`, reducing the
     * total supply.
     *
     * Emits a {Transfer} event with `to` set to the zero address.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     * - `account` must have at least `amount` tokens.
     */
    function _burn(address account, uint256 amount) private {
        require(account != address(0), "ERC20: burn from the zero address");
        StrategyData storage S = _strategyStorage();

        S.balances[account] -= amount;
        unchecked {
            S.totalSupply -= amount;
        }
        emit Transfer(account, address(0), amount);
    }

    /**
     * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
     *
     * This internal function is equivalent to `approve`, and can be used to
     * e.g. set automatic allowances for certain subsystems, etc.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `owner` cannot be the zero address.
     * - `spender` cannot be the zero address.
     */
    function _approve(address owner, address spender, uint256 amount) private {
        require(owner != address(0), "ERC20: approve from the zero address");
        require(spender != address(0), "ERC20: approve to the zero address");

        _strategyStorage().allowances[owner][spender] = amount;
        emit Approval(owner, spender, amount);
    }

    /**
     * @dev Updates `owner` s allowance for `spender` based on spent `amount`.
     *
     * Does not update the allowance amount in case of infinite allowance.
     * Revert if not enough allowance is available.
     *
     * Might emit an {Approval} event.
     */
    function _spendAllowance(
        address owner,
        address spender,
        uint256 amount
    ) private {
        uint256 currentAllowance = allowance(owner, spender);
        if (currentAllowance != type(uint256).max) {
            require(
                currentAllowance >= amount,
                "ERC20: insufficient allowance"
            );
            unchecked {
                _approve(owner, spender, currentAllowance - amount);
            }
        }
    }

    /*//////////////////////////////////////////////////////////////
                             EIP-2612 LOGIC
    //////////////////////////////////////////////////////////////*/

    /**
     * @notice Returns the current nonce for `owner`. This value must be
     * included whenever a signature is generated for {permit}.
     *
     * @dev Every successful call to {permit} increases ``owner``'s nonce by one. This
     * prevents a signature from being used multiple times.
     *
     * @param _owner the address of the account to return the nonce for.
     * @return . the current nonce for the account.
     */
    function nonces(address _owner) external view returns (uint256) {
        return _strategyStorage().nonces[_owner];
    }

    /**
     * @notice Sets `value` as the allowance of `spender` over ``owner``'s tokens,
     * given ``owner``'s signed approval.
     *
     * @dev IMPORTANT: The same issues {IERC20-approve} has related to transaction
     * ordering also apply here.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `deadline` must be a timestamp in the future.
     * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`
     * over the EIP712-formatted function arguments.
     * - the signature must use ``owner``'s current nonce (see {nonces}).
     *
     * For more information on the signature format, see the
     * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP
     * section].
     */
    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external {
        require(deadline >= block.timestamp, "ERC20: PERMIT_DEADLINE_EXPIRED");

        // Unchecked because the only math done is incrementing
        // the owner's nonce which cannot realistically overflow.
        unchecked {
            address recoveredAddress = ecrecover(
                keccak256(
                    abi.encodePacked(
                        "\x19\x01",
                        DOMAIN_SEPARATOR(),
                        keccak256(
                            abi.encode(
                                keccak256(
                                    "Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)"
                                ),
                                owner,
                                spender,
                                value,
                                _strategyStorage().nonces[owner]++,
                                deadline
                            )
                        )
                    )
                ),
                v,
                r,
                s
            );

            require(
                recoveredAddress != address(0) && recoveredAddress == owner,
                "ERC20: INVALID_SIGNER"
            );

            _approve(recoveredAddress, spender, value);
        }
    }

    /**
     * @notice Returns the domain separator used in the encoding of the signature
     * for {permit}, as defined by {EIP712}.
     *
     * @dev This checks that the current chain id is the same as when the contract
     * was deployed to prevent replay attacks. If false it will calculate a new
     * domain separator based on the new chain id.
     *
     * @return . The domain separator that will be used for any {permit} calls.
     */
    function DOMAIN_SEPARATOR() public view returns (bytes32) {
        StrategyData storage S = _strategyStorage();
        return
            block.chainid == S.INITIAL_CHAIN_ID
                ? S.INITIAL_DOMAIN_SEPARATOR
                : _computeDomainSeparator();
    }

    /**
     * @dev Calculates and returns the domain separator to be used in any
     * permit functions for the strategies {permit} calls.
     *
     * This will be used at the initialization of each new strategies storage.
     * It would then be used in the future in the case of any forks in which
     * the current chain id is not the same as the original.
     *
     */
    function _computeDomainSeparator() private view returns (bytes32) {
        return
            keccak256(
                abi.encode(
                    keccak256(
                        "EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"
                    ),
                    keccak256(bytes(_strategyStorage().name)),
                    keccak256(bytes(API_VERSION)),
                    block.chainid,
                    address(this)
                )
            );
    }

    /*//////////////////////////////////////////////////////////////
                            DEPLOYMENT
    //////////////////////////////////////////////////////////////*/

    /**
     * @dev On contract creation we set `asset` for this contract to address(1).
     * This prevents it from ever being initialized in the future.
     */
    constructor() {
        _strategyStorage().asset = ERC20(address(1));
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"caller","type":"address"},{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":false,"internalType":"uint256","name":"assets","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"shares","type":"uint256"}],"name":"Deposit","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"strategy","type":"address"},{"indexed":true,"internalType":"address","name":"asset","type":"address"},{"indexed":false,"internalType":"string","name":"apiVersion","type":"string"}],"name":"NewTokenizedStrategy","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"profit","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"loss","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"protocolFees","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"performanceFees","type":"uint256"}],"name":"Reported","type":"event"},{"anonymous":false,"inputs":[],"name":"StrategyShutdown","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"newEmergencyAdmin","type":"address"}],"name":"UpdateEmergencyAdmin","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"newKeeper","type":"address"}],"name":"UpdateKeeper","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"newManagement","type":"address"}],"name":"UpdateManagement","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"newPendingManagement","type":"address"}],"name":"UpdatePendingManagement","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint16","name":"newPerformanceFee","type":"uint16"}],"name":"UpdatePerformanceFee","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"newPerformanceFeeRecipient","type":"address"}],"name":"UpdatePerformanceFeeRecipient","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"newProfitMaxUnlockTime","type":"uint256"}],"name":"UpdateProfitMaxUnlockTime","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"caller","type":"address"},{"indexed":true,"internalType":"address","name":"receiver","type":"address"},{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":false,"internalType":"uint256","name":"assets","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"shares","type":"uint256"}],"name":"Withdraw","type":"event"},{"inputs":[],"name":"DOMAIN_SEPARATOR","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"FACTORY","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAX_FEE","outputs":[{"internalType":"uint16","name":"","type":"uint16"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MIN_FEE","outputs":[{"internalType":"uint16","name":"","type":"uint16"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"acceptManagement","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"apiVersion","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"asset","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"shares","type":"uint256"}],"name":"convertToAssets","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"assets","type":"uint256"}],"name":"convertToShares","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"subtractedValue","type":"uint256"}],"name":"decreaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"assets","type":"uint256"},{"internalType":"address","name":"receiver","type":"address"}],"name":"deposit","outputs":[{"internalType":"uint256","name":"shares","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"emergencyAdmin","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"emergencyWithdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"fullProfitUnlockDate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"addedValue","type":"uint256"}],"name":"increaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_asset","type":"address"},{"internalType":"string","name":"_name","type":"string"},{"internalType":"address","name":"_management","type":"address"},{"internalType":"address","name":"_performanceFeeRecipient","type":"address"},{"internalType":"address","name":"_keeper","type":"address"}],"name":"init","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_sender","type":"address"}],"name":"isEmergencyAuthorized","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_sender","type":"address"}],"name":"isKeeperOrManagement","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_sender","type":"address"}],"name":"isManagement","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"isShutdown","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"keeper","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lastReport","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"management","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"maxDeposit","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"maxMint","outputs":[{"internalType":"uint256","name":"_maxMint","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"maxRedeem","outputs":[{"internalType":"uint256","name":"_maxRedeem","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"maxWithdraw","outputs":[{"internalType":"uint256","name":"_maxWithdraw","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"shares","type":"uint256"},{"internalType":"address","name":"receiver","type":"address"}],"name":"mint","outputs":[{"internalType":"uint256","name":"assets","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_owner","type":"address"}],"name":"nonces","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pendingManagement","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"performanceFee","outputs":[{"internalType":"uint16","name":"","type":"uint16"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"performanceFeeRecipient","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"uint256","name":"deadline","type":"uint256"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"permit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"assets","type":"uint256"}],"name":"previewDeposit","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"shares","type":"uint256"}],"name":"previewMint","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"shares","type":"uint256"}],"name":"previewRedeem","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"assets","type":"uint256"}],"name":"previewWithdraw","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pricePerShare","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"profitMaxUnlockTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"profitUnlockingRate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"shares","type":"uint256"},{"internalType":"address","name":"receiver","type":"address"},{"internalType":"address","name":"owner","type":"address"},{"internalType":"uint256","name":"maxLoss","type":"uint256"}],"name":"redeem","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"shares","type":"uint256"},{"internalType":"address","name":"receiver","type":"address"},{"internalType":"address","name":"owner","type":"address"}],"name":"redeem","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"report","outputs":[{"internalType":"uint256","name":"profit","type":"uint256"},{"internalType":"uint256","name":"loss","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_emergencyAdmin","type":"address"}],"name":"setEmergencyAdmin","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_keeper","type":"address"}],"name":"setKeeper","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_management","type":"address"}],"name":"setPendingManagement","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint16","name":"_performanceFee","type":"uint16"}],"name":"setPerformanceFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_performanceFeeRecipient","type":"address"}],"name":"setPerformanceFeeRecipient","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_profitMaxUnlockTime","type":"uint256"}],"name":"setProfitMaxUnlockTime","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"shutdownStrategy","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"tend","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"totalAssets","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalDebt","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalIdle","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"unlockedShares","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"assets","type":"uint256"},{"internalType":"address","name":"receiver","type":"address"},{"internalType":"address","name":"owner","type":"address"},{"internalType":"uint256","name":"maxLoss","type":"uint256"}],"name":"withdraw","outputs":[{"internalType":"uint256","name":"shares","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"assets","type":"uint256"},{"internalType":"address","name":"receiver","type":"address"},{"internalType":"address","name":"owner","type":"address"}],"name":"withdraw","outputs":[{"internalType":"uint256","name":"shares","type":"uint256"}],"stateMutability":"nonpayable","type":"function"}]

60806040523480156200001157600080fd5b5060016200001e62000042565b80546001600160a01b0319166001600160a01b03929092169190911790556200009a565b6000806200007260017fd2841a5d2692465040bd5e06a6f3b37483952c866e0f304dc0e03f76a1f8a0b162000078565b92915050565b818103818111156200007257634e487b7160e01b600052601160045260246000fd5b613ff080620000aa6000396000f3fe608060405234801561001057600080fd5b50600436106103e65760003560e01c806388a8d6021161020a578063be8f166811610125578063d905777e116100b8578063ec0c7e2811610087578063ec0c7e28146107f0578063ed27f7c914610803578063ef8b30f71461080b578063f629b7901461081e578063fc7b9c181461083157600080fd5b8063d905777e146107af578063d9a0e97a146107c2578063dd62ed3e146107ca578063df69b22a146107dd57600080fd5b8063c6e6f592116100f4578063c6e6f5921461076e578063c8c2fe6c14610781578063ce96cb7714610789578063d505accf1461079c57600080fd5b8063be8f166814610743578063bf86d6901461074b578063c3535b5214610753578063c63d75b61461075b57600080fd5b8063a457c2d71161019d578063b3d7f6b91161016c578063b3d7f6b914610701578063b460af9414610714578063ba08765214610727578063bc063e1a1461073a57600080fd5b8063a457c2d7146106c0578063a9059cbb146106d3578063aa290e6d146106e6578063aced1661146106f957600080fd5b80639aa7df94116101d95780639aa7df941461067f5780639d6fdde7146106875780639f40a7b31461069a578063a318c1a4146106ad57600080fd5b806388a8d6021461065457806394bf804d1461065c57806395d89b411461066f57806399530b061461067757600080fd5b806335da3394116103055780635312ea8e1161029857806370a082311161026757806370a08231146105f7578063748747e61461060a57806376c7a3c71461061d5780637ecebe0014610639578063877887821461064c57600080fd5b80635312ea8e146105b65780636a5f1aa2146105c95780636e553f65146105dc57806370905dce146105ef57600080fd5b8063402d267d116102d4578063402d267d14610580578063440368a3146105935780634cdad5061461059b5780635141eebb146105ae57600080fd5b806335da33941461054a5780633644e5151461055d57806338d52e0f14610565578063395093511461056d57600080fd5b80631d3b72271161037d5780632d6326921161034c5780632d632692146104f85780632dd31000146105005780632ecfe3151461051b578063313ce5671461053057600080fd5b80631d3b72271461049457806323b872dd146104a757806325829410146104ba5780632606a10b146104db57600080fd5b8063095ea7b3116103b9578063095ea7b3146104365780630a28a477146104595780630b68f46f1461046c57806318160ddd1461048c57600080fd5b806301e1d114146103eb57806306fdde031461040657806307a2d13a1461041b5780630952864e1461042e575b600080fd5b6103f3610839565b6040519081526020015b60405180910390f35b61040e610856565b6040516103fd9190613711565b6103f3610429366004613744565b6108f1565b6103f3610927565b61044961044436600461377d565b610940565b60405190151581526020016103fd565b6103f3610467366004613744565b610957565b61047461099c565b6040516001600160a01b0390911681526020016103fd565b6103f36109b8565b6104496104a23660046137a9565b6109dd565b6104496104b53660046137c6565b610a53565b604080518082019091526005815264332e302e3160d81b602082015261040e565b6104e3610a75565b604080519283526020830191909152016103fd565b6103f3610ed4565b61047473e9e8c89c8fc7e8b8f23425688eb68987231178e581565b61052e610529366004613876565b610ef0565b005b610538611182565b60405160ff90911681526020016103fd565b61052e6105583660046137a9565b61119c565b6103f36111fc565b61047461122d565b61044961057b36600461377d565b611246565b6103f361058e3660046137a9565b611268565b61052e6112f5565b6103f36105a9366004613744565b6113c7565b6103f36113d2565b61052e6105c4366004613744565b6113e5565b61052e6105d73660046137a9565b6114f8565b6103f36105ea36600461393b565b6115d3565b6104746116e2565b6103f36106053660046137a9565b6116fe565b61052e6106183660046137a9565b611771565b6106266101f481565b60405161ffff90911681526020016103fd565b6103f36106473660046137a9565b6117d1565b6106266117fd565b61047461181c565b6103f361066a36600461393b565b611838565b61040e611933565b6103f36119d1565b6103f36119f4565b6104496106953660046137a9565b611a07565b6103f36106a836600461396b565b611a86565b6103f36106bb36600461396b565b611b9e565b6104496106ce36600461377d565b611cb2565b6104496106e136600461377d565b611ccf565b61052e6106f43660046139c3565b611cdc565b610474611dc5565b6103f361070f366004613744565b611de1565b6103f36107223660046139e0565b611e09565b6103f36107353660046139e0565b611e18565b61062661138881565b61052e611e28565b610449611e84565b6103f3611ea1565b6103f36107693660046137a9565b611ec4565b6103f361077c366004613744565b611f6a565b61052e611fa5565b6103f36107973660046137a9565b612075565b61052e6107aa366004613a31565b61210c565b6103f36107bd3660046137a9565b612312565b6103f36123a6565b6103f36107d8366004613aa2565b6123b0565b61052e6107eb366004613744565b6123ea565b6104496107fe3660046137a9565b6124cb565b610474612529565b6103f3610819366004613744565b61254c565b61052e61082c3660046137a9565b612557565b6103f36125dd565b6000806108446125f0565b60098101546008909101540192915050565b60606108606125f0565b600101805461086e90613ad0565b80601f016020809104026020016040519081016040528092919081815260200182805461089a90613ad0565b80156108e75780601f106108bc576101008083540402835291602001916108e7565b820191906000526020600020905b8154815290600101906020018083116108ca57829003601f168201915b5050505050905090565b6000806108fc6109b8565b9050801561091e5761091961090f610839565b849083600061261e565b610920565b825b9392505050565b60006109316125f0565b600c015463ffffffff16919050565b600061094d33848461267b565b5060015b92915050565b600080610962610839565b9050600061096e6109b8565b90508160000361098f578015610985576000610987565b835b949350505050565b610987848284600161261e565b60006109a66125f0565b600f01546001600160a01b0316919050565b60006109c26127b0565b6109ca6125f0565b600201546109d89190613b20565b905090565b6000806109e86125f0565b600e8101549091506001600160a01b0384811691161480610a185750600d8101546001600160a01b038481169116145b61094d5760405162461bcd60e51b815260206004820152600760248201526610b5b2b2b832b960c91b60448201526064015b60405180910390fd5b6000610a60843384612829565b610a6b8484846128a3565b5060019392505050565b6000806000610a826125f0565b6010810154909150600160a01b900460ff1615610ab15760405162461bcd60e51b8152600401610a4a90613b33565b60108101805460ff60a01b1916600160a01b179055610acf336109dd565b506000610ada6125f0565b90506000816009015482600801540190506000306001600160a01b03166349317f1d6040518163ffffffff1660e01b81526004016020604051808303816000875af1158015610b2d573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610b519190613b6a565b9050610b5b612a65565b600c8301546000908190819063ffffffff1685851115610cbc57600c8701548686039a5061271090640100000000900461ffff168b02049350600080808615610c6257600073e9e8c89c8fc7e8b8f23425688eb68987231178e56001600160a01b0316635153b1996040518163ffffffff1660e01b81526004016040805180830381865afa158015610bf1573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610c159190613b99565b9450905061ffff811615610c4157612710610c3461ffff83168a613bc8565b610c3e9190613bdf565b96505b610c4c878903611f6a565b92508615610c6057610c5d87611f6a565b91505b505b8315610c7f57610c73878e03611f6a565b9450610c7f3086612acd565b8115610ca457600c8a0154610ca490600160301b90046001600160a01b031683612acd565b8015610cb457610cb48382612acd565b505050610d01565b848603985088600014610d0157306000908152600688016020526040812054610ced90610ce88c611f6a565b612b97565b90508015610cff57610cff3082612ba6565b505b3060009081526006880160205260409020548015610dbc57600b8801546000906001600160801b031642811115610d455784830342826001600160801b0316030291505b600083610d528688613bc8565b610d5c9085613c01565b610d669190613bdf565b905080610d7864e8d4a5100086613bc8565b610d829190613bdf565b600a8c0155610d918142613c01565b600b8c0180546001600160801b0319166001600160801b039290921691909117905550610dc4915050565b6000600a8901555b87546040516370a0823160e01b81523060048201526000916001600160a01b0316906370a0823190602401602060405180830381865afa158015610e0c573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610e309190613b6a565b60088a018190559050610e438188613b20565b60098a0155600b890180546001600160801b03428116600160801b0291161790557fecdd072e4d5bd913a75a37f02daedcea7e2dc0281f9942c0063cfd1cfe5c4c4f8c8c87610e92818b613b20565b60408051948552602085019390935291830152606082015260800160405180910390a15050506010909601805460ff60a01b1916905550959694955050505050565b6000610ede6125f0565b600b01546001600160801b0316919050565b6000610efa6125f0565b80549091506001600160a01b031615610f435760405162461bcd60e51b815260206004820152600b60248201526a1a5b9a5d1a585b1a5e995960aa1b6044820152606401610a4a565b80546001600160a01b0319166001600160a01b03871617815560018101610f6a8682613c62565b50856001600160a01b031663313ce5676040518163ffffffff1660e01b8152600401602060405180830381865afa158015610fa9573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610fcd9190613d22565b815460ff91909116600160a01b0260ff60a01b19909116178155466003820155610ff5612c8d565b6004820155600c8101805463ffffffff1916620d2f001790556001600160a01b0383166110345760405162461bcd60e51b8152600401610a4a90613d3f565b306001600160a01b038416036110755760405162461bcd60e51b8152600401610a4a9060208082526004908201526339b2b63360e11b604082015260600190565b600c810180546503e80000000065ffff00000000196001600160a01b03808816600160301b0291909116640100000000600160d01b03199093169290921717909155600b820180546001600160801b03428116600160801b02911617905584166110f15760405162461bcd60e51b8152600401610a4a90613d3f565b600d810180546001600160a01b038087166001600160a01b031992831617909255600e8301805485841692169190911790556040805180820182526005815264332e302e3160d81b602082015290519188169130917ffb1616746b8474b6b7c67f2fe5ada156ed24774d0efe8bfe529cf537ba173330916111729190613711565b60405180910390a3505050505050565b600061118c6125f0565b54600160a01b900460ff16919050565b6111a5336124cb565b50806111af6125f0565b60100180546001600160a01b0319166001600160a01b03928316179055604051908216907f2bf242d027263e45fab022c28b4144255c97b30b8e54c30f1f5757906d487f0990600090a250565b6000806112076125f0565b9050806003015446146112215761121c612c8d565b611227565b80600401545b91505090565b60006112376125f0565b546001600160a01b0316919050565b600033610a6b81858561125983836123b0565b6112639190613c01565b61267b565b60006112726125f0565b60100154600160a81b900460ff161561128d57506000919050565b604051632355178960e11b81526001600160a01b038316600482015230906346aa2f1290602401602060405180830381865afa1580156112d1573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906109519190613b6a565b60006112ff6125f0565b6010810154909150600160a01b900460ff161561132e5760405162461bcd60e51b8152600401610a4a90613b33565b60108101805460ff60a01b1916600160a01b17905561134c336109dd565b5030639d7fb70c61135b6125f0565b600801546040518263ffffffff1660e01b815260040161137d91815260200190565b600060405180830381600087803b15801561139757600080fd5b505af11580156113ab573d6000803e3d6000fd5b505050506113b7612d49565b601001805460ff60a01b19169055565b6000610951826108f1565b60006113dc6125f0565b600a0154905090565b60006113ef6125f0565b6010810154909150600160a01b900460ff161561141e5760405162461bcd60e51b8152600401610a4a90613b33565b60108101805460ff60a01b1916600160a01b17905561143c33611a07565b506114456125f0565b60100154600160a81b900460ff1661148e5760405162461bcd60e51b815260206004820152600c60248201526b3737ba1039b43aba3237bbb760a11b6044820152606401610a4a565b604051631fbd027560e31b815260048101839052309063fde813a890602401600060405180830381600087803b1580156114c757600080fd5b505af11580156114db573d6000803e3d6000fd5b505050506114e7612d49565b601001805460ff60a01b1916905550565b611501336124cb565b506001600160a01b0381166115285760405162461bcd60e51b8152600401610a4a90613d3f565b306001600160a01b038216036115715760405162461bcd60e51b815260206004820152600e60248201526d21b0b73737ba1031329039b2b63360911b6044820152606401610a4a565b8061157a6125f0565b600c0180546601000000000000600160d01b031916600160301b6001600160a01b0393841602179055604051908216907f9ebbf695dd251e855d9d15a146a72f5f654dc6f8630fbc11212f27e0c88ba11a90600090a250565b6000806115de6125f0565b6010810154909150600160a01b900460ff161561160d5760405162461bcd60e51b8152600401610a4a90613b33565b60108101805460ff60a01b1916600160a01b17905561162b83611268565b84111561167a5760405162461bcd60e51b815260206004820152601e60248201527f455243343632363a206465706f736974206d6f7265207468616e206d617800006044820152606401610a4a565b6116838461254c565b9150816000036116c35760405162461bcd60e51b815260206004820152600b60248201526a5a45524f5f53484152455360a81b6044820152606401610a4a565b6116ce838584612e55565b601001805460ff60a01b1916905592915050565b60006116ec6125f0565b601001546001600160a01b0316919050565b6000306001600160a01b03831603611747576117186127b0565b6117206125f0565b6001600160a01b038416600090815260069190910160205260409020546109519190613b20565b61174f6125f0565b6001600160a01b03909216600090815260069290920160205250604090205490565b61177a336124cb565b50806117846125f0565b600e0180546001600160a01b0319166001600160a01b03928316179055604051908216907fd7f49e282c36d417b290d4181a56943f6d670aaa2987c0d40e60d39919c6888290600090a250565b60006117db6125f0565b6001600160a01b03909216600090815260059290920160205250604090205490565b60006118076125f0565b600c0154640100000000900461ffff16919050565b60006118266125f0565b600d01546001600160a01b0316919050565b6000806118436125f0565b6010810154909150600160a01b900460ff16156118725760405162461bcd60e51b8152600401610a4a90613b33565b60108101805460ff60a01b1916600160a01b17905561189083611ec4565b8411156118df5760405162461bcd60e51b815260206004820152601b60248201527f455243343632363a206d696e74206d6f7265207468616e206d617800000000006044820152606401610a4a565b6118e884611de1565b9150816000036119285760405162461bcd60e51b815260206004820152600b60248201526a5a45524f5f41535345545360a81b6044820152606401610a4a565b6116ce838386612e55565b606061193d6125f0565b54604080516395d89b4160e01b815290516001600160a01b03909216916395d89b41916004808201926000929091908290030181865afa158015611985573d6000803e3d6000fd5b505050506040513d6000823e601f3d908101601f191682016040526119ad9190810190613d65565b6040516020016119bd9190613dd3565b604051602081830303815290604052905090565b60006109d86119de6125f0565b5461042990600160a01b900460ff16600a613ee1565b60006119fe6125f0565b60080154905090565b600080611a126125f0565b60108101549091506001600160a01b0384811691161480611a425750600d8101546001600160a01b038481169116145b61094d5760405162461bcd60e51b815260206004820152601560248201527408595b595c99d95b98de48185d5d1a1bdc9a5e9959605a1b6044820152606401610a4a565b600080611a916125f0565b6010810154909150600160a01b900460ff1615611ac05760405162461bcd60e51b8152600401610a4a90613b33565b60108101805460ff60a01b1916600160a01b179055611ade84612312565b861115611b2d5760405162461bcd60e51b815260206004820152601d60248201527f455243343632363a2072656465656d206d6f7265207468616e206d61780000006044820152606401610a4a565b6000611b38876113c7565b905080600003611b785760405162461bcd60e51b815260206004820152600b60248201526a5a45524f5f41535345545360a81b6044820152606401610a4a565b611b858686838a88613099565b925050601001805460ff60a01b19169055949350505050565b600080611ba96125f0565b6010810154909150600160a01b900460ff1615611bd85760405162461bcd60e51b8152600401610a4a90613b33565b60108101805460ff60a01b1916600160a01b179055611bf684612075565b861115611c455760405162461bcd60e51b815260206004820152601f60248201527f455243343632363a207769746864726177206d6f7265207468616e206d6178006044820152606401610a4a565b611c4e86610957565b915081600003611c8e5760405162461bcd60e51b815260206004820152600b60248201526a5a45524f5f53484152455360a81b6044820152606401610a4a565b611c9b8585888587613099565b50601001805460ff60a01b19169055949350505050565b600033610a6b818585611cc583836123b0565b6112639190613b20565b600061094d3384846128a3565b611ce5336124cb565b506101f461ffff82161015611d265760405162461bcd60e51b81526020600482015260076024820152664d494e2046454560c81b6044820152606401610a4a565b61138861ffff82161115611d665760405162461bcd60e51b81526020600482015260076024820152664d41582046454560c81b6044820152606401610a4a565b80611d6f6125f0565b600c01805465ffff00000000191664010000000061ffff9384160217905560405190821681527fdc843735e683348ec21c302ffff45462399c5c46f75f67b0a1a5395c535997539060200160405180910390a150565b6000611dcf6125f0565b600e01546001600160a01b0316919050565b600080611dec6109b8565b9050801561091e57610919611dff610839565b849083600161261e565b60006109878484846000611b9e565b6000610987848484612710611a86565b611e3133611a07565b506001611e3c6125f0565b6010018054911515600160a81b0260ff60a81b199092169190911790556040517ffc1249757a7f27c510c8173c55d03ba442e0d33d9223e06ceb416feac8c7693f90600090a1565b6000611e8e6125f0565b60100154600160a81b900460ff16919050565b6000611eab6125f0565b600b0154600160801b90046001600160801b0316919050565b6000611ece6125f0565b60100154600160a81b900460ff1615611ee957506000919050565b604051632355178960e11b81526001600160a01b038316600482015230906346aa2f1290602401602060405180830381865afa158015611f2d573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190611f519190613b6a565b90506000198114611f655761095181611f6a565b919050565b600080611f75610839565b90506000611f816109b8565b905081600003611f98578015610985576000610987565b610987848284600061261e565b611fad6125f0565b600f01546001600160a01b03163314611ff35760405162461bcd60e51b81526020600482015260086024820152672170656e64696e6760c01b6044820152606401610a4a565b33611ffc6125f0565b600d0180546001600160a01b0319166001600160a01b039290921691909117905560006120276125f0565b600f0180546001600160a01b0319166001600160a01b039290921691909117905560405133907fff54978127edd34aec0f9061fb3b155fbe0ededdfa881ee3e0d541d3a1eef43890600090a2565b6040516304bd462960e01b81526001600160a01b038216600482015260009030906304bd462990602401602060405180830381865afa1580156120bc573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906120e09190613b6a565b905060001981036120f757610951610429836116fe565b610951612106610429846116fe565b82612b97565b4284101561215c5760405162461bcd60e51b815260206004820152601e60248201527f45524332303a205045524d49545f444541444c494e455f4558504952454400006044820152606401610a4a565b600060016121686111fc565b7f6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c98a8a8a6121946125f0565b6001600160a01b038f8116600090815260059290920160209081526040928390208054600181019091558351808301989098529582168784015293166060860152608085019190915260a084019290925260c08084018b90528251808503909101815260e08401909252815191012061190160f01b6101008301526101028201929092526101228101919091526101420160408051601f198184030181528282528051602091820120600084529083018083525260ff871690820152606081018590526080810184905260a0016020604051602081039080840390855afa158015612283573d6000803e3d6000fd5b5050604051601f1901519150506001600160a01b038116158015906122b95750876001600160a01b0316816001600160a01b0316145b6122fd5760405162461bcd60e51b815260206004820152601560248201527422a92199181d1024a72b20a624a22fa9a4a3a722a960591b6044820152606401610a4a565b61230881888861267b565b5050505050505050565b6040516304bd462960e01b81526001600160a01b038216600482015260009030906304bd462990602401602060405180830381865afa158015612359573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061237d9190613b6a565b9050600019810361239157610951826116fe565b61095161239d82610957565b610ce8846116fe565b60006109d86127b0565b60006123ba6125f0565b6001600160a01b039384166000908152600791909101602090815260408083209490951682529290925250205490565b6123f3336124cb565b506301e185588111156124335760405162461bcd60e51b8152602060048201526008602482015267746f6f206c6f6e6760c01b6044820152606401610a4a565b600061243d6125f0565b90508160000361247d573060008181526006830160205260409020546124639190612ba6565b6000600a820155600b810180546001600160801b03191690555b600c8101805463ffffffff191663ffffffff84161790556040518281527ff361aed463da6fa20358e45c6209f1d3e16d4eca706e6eab0b0aeb338729c77a9060200160405180910390a15050565b60006124d56125f0565b600d01546001600160a01b038381169116146125215760405162461bcd60e51b815260206004820152600b60248201526a085b585b9859d95b595b9d60aa1b6044820152606401610a4a565b506001919050565b60006125336125f0565b600c0154600160301b90046001600160a01b0316919050565b600061095182611f6a565b612560336124cb565b506001600160a01b0381166125875760405162461bcd60e51b8152600401610a4a90613d3f565b806125906125f0565b600f0180546001600160a01b0319166001600160a01b03928316179055604051908216907fd74668a8c80a07cc56d7c3318a06439eaa815e740d97dcd83487e1fc75076b8b90600090a250565b60006125e76125f0565b60090154905090565b60008061095160017fd2841a5d2692465040bd5e06a6f3b37483952c866e0f304dc0e03f76a1f8a0b1613b20565b60008061262c8686866133ae565b9050600183600281111561264257612642613ef0565b14801561265f57506000848061265a5761265a613b83565b868809115b156126725761266f600182613c01565b90505b95945050505050565b6001600160a01b0383166126dd5760405162461bcd60e51b8152602060048201526024808201527f45524332303a20617070726f76652066726f6d20746865207a65726f206164646044820152637265737360e01b6064820152608401610a4a565b6001600160a01b03821661273e5760405162461bcd60e51b815260206004820152602260248201527f45524332303a20617070726f766520746f20746865207a65726f206164647265604482015261737360f01b6064820152608401610a4a565b806127476125f0565b6001600160a01b038581166000818152600793909301602090815260408085209388168086529382529384902094909455915184815290927f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b92591015b60405180910390a3505050565b6000806127bb6125f0565b600b8101549091506001600160801b03164281111561280057600b820154600a83015464e8d4a5100091600160801b90046001600160801b0316420302049250505090565b6001600160801b038116156128245730600090815260068301602052604090205492505b505090565b600061283584846123b0565b9050600019811461289d57818110156128905760405162461bcd60e51b815260206004820152601d60248201527f45524332303a20696e73756666696369656e7420616c6c6f77616e63650000006044820152606401610a4a565b61289d848484840361267b565b50505050565b6001600160a01b0383166129075760405162461bcd60e51b815260206004820152602560248201527f45524332303a207472616e736665722066726f6d20746865207a65726f206164604482015264647265737360d81b6064820152608401610a4a565b6001600160a01b0382166129695760405162461bcd60e51b815260206004820152602360248201527f45524332303a207472616e7366657220746f20746865207a65726f206164647260448201526265737360e81b6064820152608401610a4a565b306001600160a01b038316036129c15760405162461bcd60e51b815260206004820152601a60248201527f4552433230207472616e7366657220746f2073747261746567790000000000006044820152606401610a4a565b60006129cb6125f0565b6001600160a01b03851660009081526006820160205260408120805492935084929091906129fa908490613b20565b90915550506001600160a01b038084166000818152600684016020526040908190208054860190555190918616907fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef90612a579086815260200190565b60405180910390a350505050565b6000612a6f6127b0565b905080600003612a7c5750565b42612a856125f0565b600b01546001600160801b03161115612ac05742612aa16125f0565b600b0180546001600160801b03928316600160801b0292169190911790555b612aca3082612ba6565b50565b6001600160a01b038216612b235760405162461bcd60e51b815260206004820152601f60248201527f45524332303a206d696e7420746f20746865207a65726f2061646472657373006044820152606401610a4a565b6000612b2d6125f0565b905081816002016000828254612b439190613c01565b90915550506001600160a01b03831660008181526006830160209081526040808320805487019055518581527fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef91016127a3565b600081831061091e5781610920565b6001600160a01b038216612c065760405162461bcd60e51b815260206004820152602160248201527f45524332303a206275726e2066726f6d20746865207a65726f206164647265736044820152607360f81b6064820152608401610a4a565b6000612c106125f0565b6001600160a01b0384166000908152600682016020526040812080549293508492909190612c3f908490613b20565b909155505060028101805483900390556040518281526000906001600160a01b038516907fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef906020016127a3565b60007f8b73c3c69bb8fe3d512ecc4cf759cc79239f7b179b0ffacaa9a75d522b39400f612cb86125f0565b600101604051612cc89190613f06565b6040805191829003822082820182526005835264332e302e3160d81b6020938401528151928301939093528101919091527fc63fef2293a1f92e82ea14ecff0fffda4a757b8c20dd61198c8b9ebef0985ef460608201524660808201523060a082015260c00160405160208183030381529060405280519060200120905090565b6000612d536125f0565b80546040516370a0823160e01b81523060048201529192506000916001600160a01b03909116906370a0823190602401602060405180830381865afa158015612da0573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190612dc49190613b6a565b905080826008015403612dd5575050565b6000612ddf610839565b9050808210612dfb576008830181905560006009840155612e0b565b6008830182905581810360098401555b612e13610839565b8114612e505760405162461bcd60e51b815260206004820152600c60248201526b21746f74616c41737365747360a01b6044820152606401610a4a565b505050565b306001600160a01b03841603612ea55760405162461bcd60e51b815260206004820152601560248201527422a9219a1b191b1d1036b4b73a103a379039b2b63360591b6044820152606401610a4a565b6000612eaf6125f0565b80549091506001600160a01b0316612ec98133308761345d565b6000848360080154612edb9190613c01565b6040516370a0823160e01b81523060048201529091506000906001600160a01b038416906370a0823190602401602060405180830381865afa158015612f25573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190612f499190613b6a565b60405163503160d960e01b815260048101849052909150309063503160d990602401600060405180830381600087803b158015612f8557600080fd5b505af1158015612f99573d6000803e3d6000fd5b50506040516370a0823160e01b81523060048201526000925061301c91506001600160a01b038616906370a0823190602401602060405180830381865afa158015612fe8573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061300c9190613b6a565b6130169084613b20565b84612b97565b9050808560090160008282546130329190613c01565b909155505080830360088601556130498887612acd565b60408051888152602081018890526001600160a01b038a169133917fdcbc1c05240f31ff3ad067ef1ee35ce4997762752e3a095284754544f4c709d7910160405180910390a35050505050505050565b60006001600160a01b0386166130c15760405162461bcd60e51b8152600401610a4a90613d3f565b6127108211156131055760405162461bcd60e51b815260206004820152600f60248201526e65786365656473204d41585f42505360881b6044820152606401610a4a565b336001600160a01b0386161461312057613120853385612829565b600061312a6125f0565b805460088201549192506001600160a01b03169086811015613329576040516370a0823160e01b81523060048201526000906001600160a01b038416906370a0823190602401602060405180830381865afa15801561318d573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906131b19190613b6a565b604051633d6cb57560e01b8152838a0360048201529091503090633d6cb57590602401600060405180830381600087803b1580156131ee57600080fd5b505af1158015613202573d6000803e3d6000fd5b50506040516370a0823160e01b81523060048201526000925061328b915083906001600160a01b038716906370a0823190602401602060405180830381865afa158015613253573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906132779190613b6a565b6132819190613b20565b8660090154612b97565b92830192905060008984101561330357508289036127108810156132ff576127106132b6898c613bc8565b6132c09190613bdf565b8111156132ff5760405162461bcd60e51b815260206004820152600d60248201526c746f6f206d756368206c6f737360981b6044820152606401610a4a565b8399505b61330d8183613c01565b8660090160008282546133209190613b20565b90915550505050505b6133338782613b20565b60088401556133428887612ba6565b6133566001600160a01b0383168a896134c8565b60408051888152602081018890526001600160a01b03808b1692908c169133917ffbde797d201c681b91056529119e0b02407c7bb96a4a2c75c01fc9667232c8db910160405180910390a45094979650505050505050565b60008080600019858709858702925082811083820303915050806000036133e8578382816133de576133de613b83565b0492505050610920565b8084116133f457600080fd5b60008486880960026001871981018816978890046003810283188082028403028082028403028082028403028082028403028082028403029081029092039091026000889003889004909101858311909403939093029303949094049190911702949350505050565b6040516001600160a01b038085166024830152831660448201526064810182905261289d9085906323b872dd60e01b906084015b60408051601f198184030181529190526020810180516001600160e01b03166001600160e01b0319909316929092179091526134f8565b6040516001600160a01b038316602482015260448101829052612e5090849063a9059cbb60e01b90606401613491565b600061354d826040518060400160405280602081526020017f5361666545524332303a206c6f772d6c6576656c2063616c6c206661696c6564815250856001600160a01b03166135ca9092919063ffffffff16565b805190915015612e50578080602001905181019061356b9190613f7c565b612e505760405162461bcd60e51b815260206004820152602a60248201527f5361666545524332303a204552433230206f7065726174696f6e20646964206e6044820152691bdd081cdd58d8d9595960b21b6064820152608401610a4a565b6060610987848460008585600080866001600160a01b031685876040516135f19190613f9e565b60006040518083038185875af1925050503d806000811461362e576040519150601f19603f3d011682016040523d82523d6000602084013e613633565b606091505b50915091506136448783838761364f565b979650505050505050565b606083156136be5782516000036136b7576001600160a01b0385163b6136b75760405162461bcd60e51b815260206004820152601d60248201527f416464726573733a2063616c6c20746f206e6f6e2d636f6e74726163740000006044820152606401610a4a565b5081610987565b61098783838151156136d35781518083602001fd5b8060405162461bcd60e51b8152600401610a4a9190613711565b60005b838110156137085781810151838201526020016136f0565b50506000910152565b60208152600082518060208401526137308160408501602087016136ed565b601f01601f19169190910160400192915050565b60006020828403121561375657600080fd5b5035919050565b6001600160a01b0381168114612aca57600080fd5b8035611f658161375d565b6000806040838503121561379057600080fd5b823561379b8161375d565b946020939093013593505050565b6000602082840312156137bb57600080fd5b81356109208161375d565b6000806000606084860312156137db57600080fd5b83356137e68161375d565b925060208401356137f68161375d565b929592945050506040919091013590565b634e487b7160e01b600052604160045260246000fd5b604051601f8201601f1916810167ffffffffffffffff8111828210171561384657613846613807565b604052919050565b600067ffffffffffffffff82111561386857613868613807565b50601f01601f191660200190565b600080600080600060a0868803121561388e57600080fd5b85356138998161375d565b9450602086013567ffffffffffffffff8111156138b557600080fd5b8601601f810188136138c657600080fd5b80356138d96138d48261384e565b61381d565b8181528960208385010111156138ee57600080fd5b8160208401602083013760006020838301015280965050505061391360408701613772565b925061392160608701613772565b915061392f60808701613772565b90509295509295909350565b6000806040838503121561394e57600080fd5b8235915060208301356139608161375d565b809150509250929050565b6000806000806080858703121561398157600080fd5b8435935060208501356139938161375d565b925060408501356139a38161375d565b9396929550929360600135925050565b61ffff81168114612aca57600080fd5b6000602082840312156139d557600080fd5b8135610920816139b3565b6000806000606084860312156139f557600080fd5b833592506020840135613a078161375d565b91506040840135613a178161375d565b809150509250925092565b60ff81168114612aca57600080fd5b600080600080600080600060e0888a031215613a4c57600080fd5b8735613a578161375d565b96506020880135613a678161375d565b955060408801359450606088013593506080880135613a8581613a22565b9699959850939692959460a0840135945060c09093013592915050565b60008060408385031215613ab557600080fd5b8235613ac08161375d565b915060208301356139608161375d565b600181811c90821680613ae457607f821691505b602082108103613b0457634e487b7160e01b600052602260045260246000fd5b50919050565b634e487b7160e01b600052601160045260246000fd5b8181038181111561095157610951613b0a565b6020808252601f908201527f5265656e7472616e637947756172643a207265656e7472616e742063616c6c00604082015260600190565b600060208284031215613b7c57600080fd5b5051919050565b634e487b7160e01b600052601260045260246000fd5b60008060408385031215613bac57600080fd5b8251613bb7816139b3565b60208401519092506139608161375d565b808202811582820484141761095157610951613b0a565b600082613bfc57634e487b7160e01b600052601260045260246000fd5b500490565b8082018082111561095157610951613b0a565b601f821115612e5057600081815260208120601f850160051c81016020861015613c3b5750805b601f850160051c820191505b81811015613c5a57828155600101613c47565b505050505050565b815167ffffffffffffffff811115613c7c57613c7c613807565b613c9081613c8a8454613ad0565b84613c14565b602080601f831160018114613cc55760008415613cad5750858301515b600019600386901b1c1916600185901b178555613c5a565b600085815260208120601f198616915b82811015613cf457888601518255948401946001909101908401613cd5565b5085821015613d125787850151600019600388901b60f8161c191681555b5050505050600190811b01905550565b600060208284031215613d3457600080fd5b815161092081613a22565b6020808252600c908201526b5a45524f204144445245535360a01b604082015260600190565b600060208284031215613d7757600080fd5b815167ffffffffffffffff811115613d8e57600080fd5b8201601f81018413613d9f57600080fd5b8051613dad6138d48261384e565b818152856020838501011115613dc257600080fd5b6126728260208301602086016136ed565b61797360f01b815260008251613df08160028501602087016136ed565b9190910160020192915050565b600181815b80851115613e38578160001904821115613e1e57613e1e613b0a565b80851615613e2b57918102915b93841c9390800290613e02565b509250929050565b600082613e4f57506001610951565b81613e5c57506000610951565b8160018114613e725760028114613e7c57613e98565b6001915050610951565b60ff841115613e8d57613e8d613b0a565b50506001821b610951565b5060208310610133831016604e8410600b8410161715613ebb575081810a610951565b613ec58383613dfd565b8060001904821115613ed957613ed9613b0a565b029392505050565b600061092060ff841683613e40565b634e487b7160e01b600052602160045260246000fd5b6000808354613f1481613ad0565b60018281168015613f2c5760018114613f4157613f70565b60ff1984168752821515830287019450613f70565b8760005260208060002060005b85811015613f675781548a820152908401908201613f4e565b50505082870194505b50929695505050505050565b600060208284031215613f8e57600080fd5b8151801515811461092057600080fd5b60008251613fb08184602087016136ed565b919091019291505056fea2646970667358221220a32d9b4163fbbdc0998c038789f9392c6e248cd860adef34f18696c4171a158e64736f6c63430008120033

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

52238:74973:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;81041:194;;;:::i;:::-;;;160:25:1;;;148:2;133:18;81041:194:0;;;;;;;;110769:103;;;:::i;:::-;;;;;;;:::i;74695:329::-;;;;;;:::i;:::-;;:::i;104528:127::-;;;:::i;114579:152::-;;;;;;:::i;:::-;;:::i;:::-;;;1797:14:1;;1790:22;1772:41;;1760:2;1745:18;114579:152:0;1632:187:1;76667:449:0;;;;;;:::i;:::-;;:::i;102519:123::-;;;:::i;:::-;;;-1:-1:-1;;;;;1988:32:1;;;1970:51;;1958:2;1943:18;102519:123:0;1824:203:1;81650:129:0;;;:::i;61522:235::-;;;;;;:::i;:::-;;:::i;115744:240::-;;;;;;:::i;:::-;;:::i;101557:97::-;101635:11;;;;;;;;;;;;-1:-1:-1;;;101635:11:0;;;;101557:97;;87748:6621;;;:::i;:::-;;;;2919:25:1;;;2975:2;2960:18;;2953:34;;;;2892:18;87748:6621:0;2745:248:1;103907:138:0;;;:::i;63561:85::-;;63604:42;63561:85;;66492:1904;;;;;;:::i;:::-;;:::i;:::-;;111401:101;;;:::i;:::-;;;4811:4:1;4799:17;;;4781:36;;4769:2;4754:18;111401:101:0;4639:184:1;107530:217:0;;;;;;:::i;:::-;;:::i;125568:277::-;;;:::i;101298:108::-;;;:::i;116701:255::-;;;;;;:::i;:::-;;:::i;77928:202::-;;;;;;:::i;:::-;;:::i;97413:275::-;;;:::i;77486:118::-;;;;;;:::i;:::-;;:::i;104251:127::-;;;:::i;100553:436::-;;;;;;:::i;:::-;;:::i;108712:424::-;;;;;;:::i;:::-;;:::i;68914:472::-;;;;;;:::i;:::-;;:::i;103036:117::-;;;:::i;111880:258::-;;;;;;:::i;:::-;;:::i;107139:153::-;;;;;;:::i;:::-;;:::i;63142:36::-;;63175:3;63142:36;;;;;5504:6:1;5492:19;;;5474:38;;5462:2;5447:18;63142:36:0;5330:188:1;122590:123:0;;;;;;:::i;:::-;;:::i;103347:116::-;;;:::i;102270:109::-;;;:::i;69717:420::-;;;;;;:::i;:::-;;:::i;111067:158::-;;;:::i;105178:133::-;;;:::i;101791:107::-;;;:::i;62205:295::-;;;;;;:::i;:::-;;:::i;73050:544::-;;;;;;:::i;:::-;;:::i;71286:562::-;;;;;;:::i;:::-;;:::i;117722:265::-;;;;;;:::i;:::-;;:::i;112661:144::-;;;;;;:::i;:::-;;:::i;108121:314::-;;;;;;:::i;:::-;;:::i;102779:101::-;;;:::i;75905:323::-;;;;;;:::i;:::-;;:::i;70583:197::-;;;;;;:::i;:::-;;:::i;72296:249::-;;;;;;:::i;:::-;;:::i;63258:38::-;;63291:5;63258:38;;99853:150;;;:::i;105456:102::-;;;:::i;104791:118::-;;;:::i;78437:320::-;;;;;;:::i;:::-;;:::i;73913:445::-;;;;;;:::i;:::-;;:::i;106631:286::-;;;:::i;79093:556::-;;;;;;:::i;:::-;;:::i;123547:1552::-;;;;;;:::i;:::-;;:::i;79978:564::-;;;;;;:::i;:::-;;:::i;95233:101::-;;;:::i;113314:177::-;;;;;;:::i;:::-;;:::i;109696:753::-;;;;;;:::i;:::-;;:::i;60908:171::-;;;;;;:::i;:::-;;:::i;103618:135::-;;;:::i;75373:119::-;;;;;;:::i;:::-;;:::i;106203:259::-;;;;;;:::i;:::-;;:::i;102029:107::-;;;:::i;81041:194::-;81085:7;81105:22;81130:18;:16;:18::i;:::-;81205:11;;;;81191;;;;;:25;;81041:194;-1:-1:-1;;81041:194:0:o;110769:103::-;110808:13;110841:18;:16;:18::i;:::-;:23;;110834:30;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;110769:103;:::o;74695:329::-;74757:7;74840:14;74857:13;:11;:13::i;:::-;74840:30;-1:-1:-1;74903:11:0;;:113;;74960:56;74974:13;:11;:13::i;:::-;74960:6;;74989;74997:18;74960:13;:56::i;:::-;74903:113;;;74934:6;74903:113;74883:133;74695:329;-1:-1:-1;;;74695:329:0:o;104528:127::-;104582:7;104609:18;:16;:18::i;:::-;:38;;;;;;104528:127;-1:-1:-1;104528:127:0:o;114579:152::-;114647:4;114664:37;114673:10;114685:7;114694:6;114664:8;:37::i;:::-;-1:-1:-1;114719:4:0;114579:152;;;;;:::o;76667:449::-;76729:7;76812:20;76835:13;:11;:13::i;:::-;76812:36;;76859:20;76882:13;:11;:13::i;:::-;76859:36;;76973:12;76989:1;76973:17;76969:60;;76999:17;;:30;;77028:1;76999:30;;;77019:6;76999:30;76992:37;76667:449;-1:-1:-1;;;;76667:449:0:o;76969:60::-;77049:59;:6;77063:12;77077;77091:16;77049:13;:59::i;102519:123::-;102571:7;102598:18;:16;:18::i;:::-;:36;;;-1:-1:-1;;;;;102598:36:0;;102519:123;-1:-1:-1;102519:123:0:o;81650:129::-;81694:7;81754:17;:15;:17::i;:::-;81721:18;:16;:18::i;:::-;:30;;;:50;;;;:::i;:::-;81714:57;;81650:129;:::o;61522:235::-;61590:4;61607:22;61632:18;:16;:18::i;:::-;61680:8;;;;61607:43;;-1:-1:-1;;;;;;61669:19:0;;;61680:8;;61669:19;;:46;;-1:-1:-1;61703:12:0;;;;-1:-1:-1;;;;;61692:23:0;;;61703:12;;61692:23;61669:46;61661:66;;;;-1:-1:-1;;;61661:66:0;;9056:2:1;61661:66:0;;;9038:21:1;9095:1;9075:18;;;9068:29;-1:-1:-1;;;9113:18:1;;;9106:37;9160:18;;61661:66:0;;;;;;;;115744:240;115858:4;115875:41;115891:4;115897:10;115909:6;115875:15;:41::i;:::-;115927:27;115937:4;115943:2;115947:6;115927:9;:27::i;:::-;-1:-1:-1;115972:4:0;115744:240;;;;;:::o;87748:6621::-;87845:14;87861:12;60108:22;60133:18;:16;:18::i;:::-;60242:9;;;;;;-1:-1:-1;;;;60242:9:0;;;;60241:10;60233:54;;;;-1:-1:-1;;;60233:54:0;;;;;;;:::i;:::-;60365:9;;;:16;;-1:-1:-1;;;;60365:16:0;-1:-1:-1;;;60365:16:0;;;59739:32:::1;59760:10;59739:20;:32::i;:::-;;87952:22:::2;87977:18;:16;:18::i;:::-;87952:43;;88008:22;88161:1;:11;;;88147:1;:11;;;:25;88130:42;;88630:22;88677:4;-1:-1:-1::0;;;;;88655:59:0::2;;:61;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;88630:86;;88763:21;:19;:21::i;:::-;88970;::::0;::::2;::::0;88849:17:::2;::::0;;;;;88970:21:::2;;89041:31:::0;;::::2;89037:2962;;;89277:16;::::0;::::2;::::0;89161:31;;::::2;::::0;-1:-1:-1;62871:6:0::2;::::0;89277:16;;::::2;;;89268:25:::0;::::2;89267:37;::::0;-1:-1:-1;89336:29:0::2;::::0;;89532:14;;89528:987:::2;;89620:21;63604:42;-1:-1:-1::0;;;;;89702:59:0::2;;:61;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;89660:103:::0;-1:-1:-1;89660:103:0;-1:-1:-1;89852:19:0::2;::::0;::::2;::::0;89848:200:::2;;62871:6;89991:26;;::::0;::::2;:9:::0;:26:::2;:::i;:::-;89990:38;;;;:::i;:::-;89975:53;;89848:200;90258:89;90312:12;90300:9;:24;90258:15;:89::i;:::-;90235:112:::0;-1:-1:-1;90389:17:0;;90385:115:::2;;90451:29;90467:12;90451:15;:29::i;:::-;90431:49;;90385:115;89548:967;89528:987;90605:25:::0;;90601:320:::2;;90740:35;90765:9;90756:6;:18;90740:15;:35::i;:::-;90725:50;;90871:34;90885:4;90892:12;90871:5;:34::i;:::-;90989:25:::0;;90985:120:::2;;91041:25;::::0;::::2;::::0;91035:54:::2;::::0;-1:-1:-1;;;91041:25:0;::::2;-1:-1:-1::0;;;;;91041:25:0::2;91068:20:::0;91035:5:::2;:54::i;:::-;91125:22:::0;;91121:110:::2;;91168:47;91174:21;91197:17;91168:5;:47::i;:::-;89074:2168;;;89037:2962;;;91348:14;91331;:31;91324:38;;91457:4;91465:1;91457:9;91453:535;;91727:4;91654:20;91708:25:::0;;;:10:::2;::::0;::::2;:25;::::0;;;;;91677:119:::2;::::0;91756:21:::2;91772:4:::0;91756:15:::2;:21::i;:::-;91677:8;:119::i;:::-;91654:142:::0;-1:-1:-1;91877:17:0;;91873:100:::2;;91919:34;91933:4;91940:12;91919:5;:34::i;:::-;91468:520;91453:535;92120:4;92073:25;92101::::0;;;:10:::2;::::0;::::2;:25;::::0;;;;;92141:22;;92137:1595:::2;;92255:22;::::0;::::2;::::0;92180:28:::2;::::0;-1:-1:-1;;;;;92255:22:0::2;92392:15;92368:39:::0;::::2;92364:440;;;92756:12;92736:17;:32;92691:15;92667:21;-1:-1:-1::0;;;;;92667:39:0::2;;92666:103;92618:151;;92364:440;92985:30;93115:17:::0;93059:52:::2;93091:20:::0;93059:12;:52:::2;:::i;:::-;93019:92;::::0;:20;:92:::2;:::i;:::-;93018:114;;;;:::i;:::-;92985:147:::0;-1:-1:-1;92985:147:0;93252:36:::2;62981:17;93252::::0;:36:::2;:::i;:::-;93251:80;;;;:::i;:::-;93210:21;::::0;::::2;:121:::0;93479:40:::2;93497:22:::0;93479:15:::2;:40;:::i;:::-;93428:22;::::0;::::2;:106:::0;;-1:-1:-1;;;;;;93428:106:0::2;-1:-1:-1::0;;;;;93428:106:0;;;::::2;::::0;;;::::2;::::0;;-1:-1:-1;92137:1595:0::2;::::0;-1:-1:-1;;92137:1595:0::2;;93719:1;93695:21;::::0;::::2;:25:::0;92137:1595:::2;93983:7:::0;;:32:::2;::::0;-1:-1:-1;;;93983:32:0;;94009:4:::2;93983:32;::::0;::::2;1970:51:1::0;93965:15:0::2;::::0;-1:-1:-1;;;;;93983:7:0::2;::::0;:17:::2;::::0;1943:18:1;;93983:32:0::2;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;94026:11;::::0;::::2;:21:::0;;;93965:50;-1:-1:-1;94072:24:0::2;93965:50:::0;94072:14;:24:::2;:::i;:::-;94058:11;::::0;::::2;:38:::0;94109:12:::2;::::0;::::2;:39:::0;;-1:-1:-1;;;;;94132:15:0::2;94109:39:::0;::::2;-1:-1:-1::0;;;94109:39:0::2;::::0;::::2;;::::0;;94199:162:::2;94222:6:::0;94243:4;94262:12;94306:24:::2;94262:12:::0;94306:9;:24:::2;:::i;:::-;94199:162;::::0;;11014:25:1;;;11070:2;11055:18;;11048:34;;;;11098:18;;;11091:34;11156:2;11141:18;;11134:34;11001:3;10986:19;94199:162:0::2;;;;;;;-1:-1:-1::0;;;60458:9:0;;;;:17;;-1:-1:-1;;;;60458:17:0;;;-1:-1:-1;87748:6621:0;;;;-1:-1:-1;;;;;87748:6621:0:o;103907:138::-;103962:7;103997:18;:16;:18::i;:::-;:39;;;-1:-1:-1;;;;;103997:39:0;;103907:138;-1:-1:-1;103907:138:0:o;66492:1904::-;66721:22;66746:18;:16;:18::i;:::-;66838:7;;66721:43;;-1:-1:-1;;;;;;66838:7:0;66830:30;66822:54;;;;-1:-1:-1;;;66822:54:0;;11381:2:1;66822:54:0;;;11363:21:1;11420:2;11400:18;;;11393:30;-1:-1:-1;;;11439:18:1;;;11432:41;11490:18;;66822:54:0;11179:335:1;66822:54:0;66937:23;;-1:-1:-1;;;;;;66937:23:0;-1:-1:-1;;;;;66937:23:0;;;;;-1:-1:-1;67013:6:0;;:14;67022:5;67013:6;:14;:::i;:::-;;67105:6;-1:-1:-1;;;;;67099:22:0;;:24;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;67086:37;;;;;;;-1:-1:-1;;;67086:37:0;-1:-1:-1;;;;67086:37:0;;;;;;67217:13;67196:18;;;:34;67336:25;:23;:25::i;:::-;67307:26;;;:54;67427:21;;;:31;;-1:-1:-1;;67427:31:0;67451:7;67427:31;;;-1:-1:-1;;;;;67590:38:0;;67582:63;;;;-1:-1:-1;;;67582:63:0;;;;;;;:::i;:::-;67769:4;-1:-1:-1;;;;;67733:41:0;;;67725:58;;;;-1:-1:-1;;;67725:58:0;;;;;;14518:2:1;14500:21;;;14557:1;14537:18;;;14530:29;-1:-1:-1;;;14590:2:1;14575:18;;14568:34;14634:2;14619:18;;14316:327;67725:58:0;67794:25;;;:52;;67903:24;-1:-1:-1;;;;;;;67794:52:0;;;-1:-1:-1;;;67794:52:0;67903:24;;;;-1:-1:-1;;;;;;67903:24:0;;;;;;;;;;;67981:12;;;:39;;-1:-1:-1;;;;;68004:15:0;67981:39;;-1:-1:-1;;;67981:39:0;;;;;;68101:25;;68093:50;;;;-1:-1:-1;;;68093:50:0;;;;;;;:::i;:::-;68154:12;;;:26;;-1:-1:-1;;;;;68154:26:0;;;-1:-1:-1;;;;;;68154:26:0;;;;;;;68226:8;;;:18;;;;;;;;;;;;;68376:11;;;;;;;;;;;-1:-1:-1;;;68376:11:0;;;;68332:56;;;;;;68361:4;;68332:56;;;;68376:11;68332:56;:::i;:::-;;;;;;;;66676:1720;66492:1904;;;;;:::o;111401:101::-;111442:5;111467:18;:16;:18::i;:::-;:27;-1:-1:-1;;;111467:27:0;;;;;;-1:-1:-1;111401:101:0:o;107530:217::-;59529:24;59542:10;59529:12;:24::i;:::-;;107669:15:::1;107633:18;:16;:18::i;:::-;:33;;:51:::0;;-1:-1:-1;;;;;;107633:51:0::1;-1:-1:-1::0;;;;;107633:51:0;;::::1;;::::0;;107702:37:::1;::::0;;;::::1;::::0;::::1;::::0;-1:-1:-1;;107702:37:0::1;107530:217:::0;:::o;125568:277::-;125617:7;125637:22;125662:18;:16;:18::i;:::-;125637:43;;125728:1;:18;;;125711:13;:35;:126;;125812:25;:23;:25::i;:::-;125711:126;;;125766:1;:26;;;125711:126;125691:146;;;125568:277;:::o;101298:108::-;101338:7;101373:18;:16;:18::i;:::-;:24;-1:-1:-1;;;;;101373:24:0;;101298:108;-1:-1:-1;101298:108:0:o;116701:255::-;116808:4;116841:10;116862:64;116841:10;116878:7;116915:10;116887:25;116841:10;116878:7;116887:9;:25::i;:::-;:38;;;;:::i;:::-;116862:8;:64::i;77928:202::-;77984:7;78008:18;:16;:18::i;:::-;:27;;;-1:-1:-1;;;78008:27:0;;;;78004:41;;;-1:-1:-1;78044:1:0;;77928:202;-1:-1:-1;77928:202:0:o;78004:41::-;78065:57;;-1:-1:-1;;;78065:57:0;;-1:-1:-1;;;;;1988:32:1;;78065:57:0;;;1970:51:1;78087:4:0;;78065:50;;1943:18:1;;78065:57:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;97413:275::-;60108:22;60133:18;:16;:18::i;:::-;60242:9;;;;;;-1:-1:-1;;;;60242:9:0;;;;60241:10;60233:54;;;;-1:-1:-1;;;60233:54:0;;;;;;;:::i;:::-;60365:9;;;:16;;-1:-1:-1;;;;60365:16:0;-1:-1:-1;;;60365:16:0;;;59739:32:::1;59760:10;59739:20;:32::i;:::-;-1:-1:-1::0;97554:4:0::2;97532:37;97570:18;:16;:18::i;:::-;:28;;;97532:67;;;;;;;;;;;;;160:25:1::0;;148:2;133:18;;14:177;97532:67:0::2;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;97663:17;:15;:17::i;:::-;60458:9:::0;;:17;;-1:-1:-1;;;;60458:17:0;;;97413:275::o;77486:118::-;77546:7;77573:23;77589:6;77573:15;:23::i;104251:127::-;104305:7;104332:18;:16;:18::i;:::-;:38;;;104325:45;;104251:127;:::o;100553:436::-;60108:22;60133:18;:16;:18::i;:::-;60242:9;;;;;;-1:-1:-1;;;;60242:9:0;;;;60241:10;60233:54;;;;-1:-1:-1;;;60233:54:0;;;;;;;:::i;:::-;60365:9;;;:16;;-1:-1:-1;;;;60365:16:0;-1:-1:-1;;;60365:16:0;;;59845:33:::1;59867:10;59845:21;:33::i;:::-;;100731:18:::2;:16;:18::i;:::-;:27;;::::0;-1:-1:-1;;;100731:27:0;::::2;;;100723:52;;;::::0;-1:-1:-1;;;100723:52:0;;14850:2:1;100723:52:0::2;::::0;::::2;14832:21:1::0;14889:2;14869:18;;;14862:30;-1:-1:-1;;;14908:18:1;;;14901:42;14960:18;;100723:52:0::2;14648:336:1::0;100723:52:0::2;100832:53;::::0;-1:-1:-1;;;100832:53:0;;::::2;::::0;::::2;160:25:1::0;;;100854:4:0::2;::::0;100832:45:::2;::::0;133:18:1;;100832:53:0::2;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;100964:17;:15;:17::i;:::-;60458:9:::0;;:17;;-1:-1:-1;;;;60458:17:0;;;-1:-1:-1;100553:436:0:o;108712:424::-;59529:24;59542:10;59529:12;:24::i;:::-;-1:-1:-1;;;;;;108841:38:0;::::1;108833:63;;;;-1:-1:-1::0;;;108833:63:0::1;;;;;;;:::i;:::-;108951:4;-1:-1:-1::0;;;;;108915:41:0;::::1;::::0;108907:68:::1;;;::::0;-1:-1:-1;;;108907:68:0;;15191:2:1;108907:68:0::1;::::0;::::1;15173:21:1::0;15230:2;15210:18;;;15203:30;-1:-1:-1;;;15249:18:1;;;15242:44;15303:18;;108907:68:0::1;14989:338:1::0;108907:68:0::1;109031:24;108986:18;:16;:18::i;:::-;:42;;:69:::0;;-1:-1:-1;;;;;;108986:69:0::1;-1:-1:-1::0;;;;;;;;108986:69:0;;::::1;;;::::0;;109073:55:::1;::::0;;;::::1;::::0;::::1;::::0;-1:-1:-1;;109073:55:0::1;108712:424:::0;:::o;68914:472::-;69021:14;60108:22;60133:18;:16;:18::i;:::-;60242:9;;;;;;-1:-1:-1;;;;60242:9:0;;;;60241:10;60233:54;;;;-1:-1:-1;;;60233:54:0;;;;;;;:::i;:::-;60365:9;;;:16;;-1:-1:-1;;;;60365:16:0;-1:-1:-1;;;60365:16:0;;;69142:20:::1;69153:8:::0;69142:10:::1;:20::i;:::-;69132:6;:30;;69110:110;;;::::0;-1:-1:-1;;;69110:110:0;;15534:2:1;69110:110:0::1;::::0;::::1;15516:21:1::0;15573:2;15553:18;;;15546:30;15612:32;15592:18;;;15585:60;15662:18;;69110:110:0::1;15332:354:1::0;69110:110:0::1;69287:22;69302:6;69287:14;:22::i;:::-;69278:31;;;69314:1;69277:38:::0;69269:62:::1;;;::::0;-1:-1:-1;;;69269:62:0;;15893:2:1;69269:62:0::1;::::0;::::1;15875:21:1::0;15932:2;15912:18;;;15905:30;-1:-1:-1;;;15951:18:1;;;15944:41;16002:18;;69269:62:0::1;15691:335:1::0;69269:62:0::1;69344:34;69353:8;69363:6;69371;69344:8;:34::i;:::-;60458:9:::0;;:17;;-1:-1:-1;;;;60458:17:0;;;68914:472;;-1:-1:-1;;68914:472:0:o;103036:117::-;103085:7;103112:18;:16;:18::i;:::-;:33;;;-1:-1:-1;;;;;103112:33:0;;103036:117;-1:-1:-1;103036:117:0:o;111880:258::-;111937:7;111980:4;-1:-1:-1;;;;;111961:24:0;;;111957:120;;112048:17;:15;:17::i;:::-;112009:18;:16;:18::i;:::-;-1:-1:-1;;;;;112009:36:0;;;;;;:27;;;;;:36;;;;;;:56;;;;:::i;111957:120::-;112094:18;:16;:18::i;:::-;-1:-1:-1;;;;;112094:36:0;;;;;;;:27;;;;;:36;;-1:-1:-1;112094:36:0;;;;;111880:258::o;107139:153::-;59529:24;59542:10;59529:12;:24::i;:::-;;107238:7:::1;107210:18;:16;:18::i;:::-;:25;;:35:::0;;-1:-1:-1;;;;;;107210:35:0::1;-1:-1:-1::0;;;;;107210:35:0;;::::1;;::::0;;107263:21:::1;::::0;;;::::1;::::0;::::1;::::0;-1:-1:-1;;107263:21:0::1;107139:153:::0;:::o;122590:123::-;122645:7;122672:18;:16;:18::i;:::-;-1:-1:-1;;;;;122672:33:0;;;;;;;:25;;;;;:33;;-1:-1:-1;122672:33:0;;;;;122590:123::o;103347:116::-;103396:6;103422:18;:16;:18::i;:::-;:33;;;;;;;;;;-1:-1:-1;103347:116:0:o;102270:109::-;102315:7;102342:18;:16;:18::i;:::-;:29;;;-1:-1:-1;;;;;102342:29:0;;102270:109;-1:-1:-1;102270:109:0:o;69717:420::-;69821:14;60108:22;60133:18;:16;:18::i;:::-;60242:9;;;;;;-1:-1:-1;;;;60242:9:0;;;;60241:10;60233:54;;;;-1:-1:-1;;;60233:54:0;;;;;;;:::i;:::-;60365:9;;;:16;;-1:-1:-1;;;;60365:16:0;-1:-1:-1;;;60365:16:0;;;69925:17:::1;69933:8:::0;69925:7:::1;:17::i;:::-;69915:6;:27;;69907:67;;;::::0;-1:-1:-1;;;69907:67:0;;16233:2:1;69907:67:0::1;::::0;::::1;16215:21:1::0;16272:2;16252:18;;;16245:30;16311:29;16291:18;;;16284:57;16358:18;;69907:67:0::1;16031:351:1::0;69907:67:0::1;70041:19;70053:6;70041:11;:19::i;:::-;70032:28;;;70065:1;70031:35:::0;70023:59:::1;;;::::0;-1:-1:-1;;;70023:59:0;;16589:2:1;70023:59:0::1;::::0;::::1;16571:21:1::0;16628:2;16608:18;;;16601:30;-1:-1:-1;;;16647:18:1;;;16640:41;16698:18;;70023:59:0::1;16387:335:1::0;70023:59:0::1;70095:34;70104:8;70114:6;70122;70095:8;:34::i;111067:158::-:0;111106:13;111182:18;:16;:18::i;:::-;:24;:33;;;-1:-1:-1;;;111182:33:0;;;;-1:-1:-1;;;;;111182:24:0;;;;:31;;:33;;;;;:24;;:33;;;;;;;;:24;:33;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;111182:33:0;;;;;;;;;;;;:::i;:::-;111159:57;;;;;;;;:::i;:::-;;;;;;;;;;;;;111132:85;;111067:158;:::o;105178:133::-;105226:7;105253:50;105275:18;:16;:18::i;:::-;:27;105269:33;;-1:-1:-1;;;105275:27:0;;;;105269:2;:33;:::i;101791:107::-;101835:7;101862:18;:16;:18::i;:::-;:28;;;101855:35;;101791:107;:::o;62205:295::-;62274:4;62291:22;62316:18;:16;:18::i;:::-;62378:16;;;;62291:43;;-1:-1:-1;;;;;;62367:27:0;;;62378:16;;62367:27;;:54;;-1:-1:-1;62409:12:0;;;;-1:-1:-1;;;;;62398:23:0;;;62409:12;;62398:23;62367:54;62345:125;;;;-1:-1:-1;;;62345:125:0;;19403:2:1;62345:125:0;;;19385:21:1;19442:2;19422:18;;;19415:30;-1:-1:-1;;;19461:18:1;;;19454:51;19522:18;;62345:125:0;19201:345:1;73050:544:0;73204:7;60108:22;60133:18;:16;:18::i;:::-;60242:9;;;;;;-1:-1:-1;;;;60242:9:0;;;;60241:10;60233:54;;;;-1:-1:-1;;;60233:54:0;;;;;;;:::i;:::-;60365:9;;;:16;;-1:-1:-1;;;;60365:16:0;-1:-1:-1;;;60365:16:0;;;73242::::1;73252:5:::0;73242:9:::1;:16::i;:::-;73232:6;:26;;73224:68;;;::::0;-1:-1:-1;;;73224:68:0;;19753:2:1;73224:68:0::1;::::0;::::1;19735:21:1::0;19792:2;19772:18;;;19765:30;19831:31;19811:18;;;19804:59;19880:18;;73224:68:0::1;19551:353:1::0;73224:68:0::1;73303:14;73395:21;73409:6;73395:13;:21::i;:::-;73386:30;;;73421:1;73385:37:::0;73377:61:::1;;;::::0;-1:-1:-1;;;73377:61:0;;16589:2:1;73377:61:0::1;::::0;::::1;16571:21:1::0;16628:2;16608:18;;;16601:30;-1:-1:-1;;;16647:18:1;;;16640:41;16698:18;;73377:61:0::1;16387:335:1::0;73377:61:0::1;73535:51;73545:8;73555:5;73562:6;73570;73578:7;73535:9;:51::i;:::-;73528:58;;;60458:9:::0;;:17;;-1:-1:-1;;;;60458:17:0;;;73050:544;;-1:-1:-1;;;;73050:544:0:o;71286:562::-;71442:14;60108:22;60133:18;:16;:18::i;:::-;60242:9;;;;;;-1:-1:-1;;;;60242:9:0;;;;60241:10;60233:54;;;;-1:-1:-1;;;60233:54:0;;;;;;;:::i;:::-;60365:9;;;:16;;-1:-1:-1;;;;60365:16:0;-1:-1:-1;;;60365:16:0;;;71501:18:::1;71513:5:::0;71501:11:::1;:18::i;:::-;71491:6;:28;;71469:109;;;::::0;-1:-1:-1;;;71469:109:0;;20111:2:1;71469:109:0::1;::::0;::::1;20093:21:1::0;20150:2;20130:18;;;20123:30;20189:33;20169:18;;;20162:61;20240:18;;71469:109:0::1;19909:355:1::0;71469:109:0::1;71656:23;71672:6;71656:15;:23::i;:::-;71647:32;;;71684:1;71646:39:::0;71638:63:::1;;;::::0;-1:-1:-1;;;71638:63:0;;15893:2:1;71638:63:0::1;::::0;::::1;15875:21:1::0;15932:2;15912:18;;;15905:30;-1:-1:-1;;;15951:18:1;;;15944:41;16002:18;;71638:63:0::1;15691:335:1::0;71638:63:0::1;71789:51;71799:8;71809:5;71816:6;71824;71832:7;71789:9;:51::i;:::-;-1:-1:-1::0;60458:9:0;;:17;;-1:-1:-1;;;;60458:17:0;;;71286:562;;-1:-1:-1;;;;71286:562:0:o;117722:265::-;117834:4;117867:10;117888:69;117867:10;117904:7;117941:15;117913:25;117867:10;117904:7;117913:9;:25::i;:::-;:43;;;;:::i;112661:144::-;112725:4;112742:33;112752:10;112764:2;112768:6;112742:9;:33::i;108121:314::-;59529:24;59542:10;59529:12;:24::i;:::-;-1:-1:-1;63175:3:0::1;108215:26;::::0;::::1;;;108207:46;;;::::0;-1:-1:-1;;;108207:46:0;;20471:2:1;108207:46:0::1;::::0;::::1;20453:21:1::0;20510:1;20490:18;;;20483:29;-1:-1:-1;;;20528:18:1;;;20521:37;20575:18;;108207:46:0::1;20269:330:1::0;108207:46:0::1;63291:5;108272:26;::::0;::::1;;;108264:46;;;::::0;-1:-1:-1;;;108264:46:0;;20806:2:1;108264:46:0::1;::::0;::::1;20788:21:1::0;20845:1;20825:18;;;20818:29;-1:-1:-1;;;20863:18:1;;;20856:37;20910:18;;108264:46:0::1;20604:330:1::0;108264:46:0::1;108357:15;108321:18;:16;:18::i;:::-;:33;;:51:::0;;-1:-1:-1;;108321:51:0::1;::::0;::::1;::::0;;::::1;;;::::0;;108390:37:::1;::::0;5492:19:1;;;5474:38;;108390:37:0::1;::::0;5462:2:1;5447:18;108390:37:0::1;;;;;;;108121:314:::0;:::o;102779:101::-;102820:7;102847:18;:16;:18::i;:::-;:25;;;-1:-1:-1;;;;;102847:25:0;;102779:101;-1:-1:-1;102779:101:0:o;75905:323::-;75963:7;76046:14;76063:13;:11;:13::i;:::-;76046:30;-1:-1:-1;76109:11:0;;:111;;76166:54;76180:13;:11;:13::i;:::-;76166:6;;76195;76203:16;76166:13;:54::i;70583:197::-;70702:14;70736:36;70745:6;70753:8;70763:5;70770:1;70736:8;:36::i;72296:249::-;72413:7;72497:40;72504:6;72512:8;72522:5;62871:6;72497;:40::i;99853:150::-;59845:33;59867:10;59845:21;:33::i;:::-;;99955:4:::1;99925:18;:16;:18::i;:::-;:27;;:34:::0;;;::::1;;-1:-1:-1::0;;;99925:34:0::1;-1:-1:-1::0;;;;99925:34:0;;::::1;::::0;;;::::1;::::0;;99977:18:::1;::::0;::::1;::::0;-1:-1:-1;;99977:18:0::1;99853:150::o:0;105456:102::-;105499:4;105523:18;:16;:18::i;:::-;:27;;;-1:-1:-1;;;105523:27:0;;;;;;-1:-1:-1;105456:102:0:o;104791:118::-;104836:7;104871:18;:16;:18::i;:::-;:29;;;-1:-1:-1;;;104871:29:0;;-1:-1:-1;;;;;104871:29:0;;;-1:-1:-1;104791:118:0:o;78437:320::-;78490:16;78523:18;:16;:18::i;:::-;:27;;;-1:-1:-1;;;78523:27:0;;;;78519:41;;;-1:-1:-1;78559:1:0;;78437:320;-1:-1:-1;78437:320:0:o;78519:41::-;78584:57;;-1:-1:-1;;;78584:57:0;;-1:-1:-1;;;;;1988:32:1;;78584:57:0;;;1970:51:1;78606:4:0;;78584:50;;1943:18:1;;78584:57:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;78573:68;;-1:-1:-1;;78656:8:0;:29;78652:98;;78713:25;78729:8;78713:15;:25::i;78652:98::-;78437:320;;;:::o;73913:445::-;73975:7;74058:20;74081:13;:11;:13::i;:::-;74058:36;;74105:20;74128:13;:11;:13::i;:::-;74105:36;;74213:12;74229:1;74213:17;74209:60;;74239:17;;:30;;74268:1;74239:30;;74209:60;74289:61;:6;74303:12;74317;74331:18;74289:13;:61::i;106631:286::-;106701:18;:16;:18::i;:::-;:36;;;-1:-1:-1;;;;;106701:36:0;106687:10;:50;106679:71;;;;-1:-1:-1;;;106679:71:0;;21141:2:1;106679:71:0;;;21123:21:1;21180:1;21160:18;;;21153:29;-1:-1:-1;;;21198:18:1;;;21191:38;21246:18;;106679:71:0;20939:331:1;106679:71:0;106793:10;106761:18;:16;:18::i;:::-;:29;;:42;;-1:-1:-1;;;;;;106761:42:0;-1:-1:-1;;;;;106761:42:0;;;;;;;;;;-1:-1:-1;106814:18:0;:16;:18::i;:::-;:36;;:49;;-1:-1:-1;;;;;;106814:49:0;-1:-1:-1;;;;;106814:49:0;;;;;;;;;;106881:28;;106898:10;;106881:28;;-1:-1:-1;;106881:28:0;106631:286::o;79093:556::-;79214:82;;-1:-1:-1;;;79214:82:0;;-1:-1:-1;;;;;1988:32:1;;79214:82:0;;;1970:51:1;79166:20:0;;79236:4;;79214:51;;1943:18:1;;79214:82:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;79199:97;;-1:-1:-1;;79311:12:0;:33;79307:335;;79443:33;79459:16;79469:5;79459:9;:16::i;79307:335::-;79524:106;79551:33;79567:16;79577:5;79567:9;:16::i;79551:33::-;79603:12;79524:8;:106::i;123547:1552::-;123769:15;123757:8;:27;;123749:70;;;;-1:-1:-1;;;123749:70:0;;21477:2:1;123749:70:0;;;21459:21:1;21516:2;21496:18;;;21489:30;21555:32;21535:18;;;21528:60;21605:18;;123749:70:0;21275:354:1;123749:70:0;123989:24;124016:846;124156:18;:16;:18::i;:::-;124286:167;124488:5;124528:7;124570:5;124610:18;:16;:18::i;:::-;-1:-1:-1;;;;;124610:32:0;;;;;;;:25;;;;;:32;;;;;;;;;:34;;;;;;;;124241:477;;;;;21921:25:1;;;;22020:15;;;22000:18;;;21993:43;22072:15;;22052:18;;;22045:43;22104:18;;;22097:34;;;;22147:19;;;22140:35;;;;22191:19;;;;22184:35;;;124241:477:0;;;;;;;;;;21893:19:1;;;124241:477:0;;;124201:544;;;;;-1:-1:-1;;;124076:692:0;;;22488:27:1;22531:11;;;22524:27;;;;22567:12;;;22560:28;;;;22604:12;;124076:692:0;;;-1:-1:-1;;124076:692:0;;;;;;;;;124044:743;;124076:692;124044:743;;;;124016:846;;;;;;;;;22854:25:1;22927:4;22915:17;;22895:18;;;22888:45;22949:18;;;22942:34;;;22992:18;;;22985:34;;;22826:19;;124016:846:0;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;124016:846:0;;-1:-1:-1;;124016:846:0;;;-1:-1:-1;;;;;;;124905:30:0;;;;;;:59;;;124959:5;-1:-1:-1;;;;;124939:25:0;:16;-1:-1:-1;;;;;124939:25:0;;124905:59;124879:142;;;;-1:-1:-1;;;124879:142:0;;23232:2:1;124879:142:0;;;23214:21:1;23271:2;23251:18;;;23244:30;-1:-1:-1;;;23290:18:1;;;23283:51;23351:18;;124879:142:0;23030:345:1;124879:142:0;125038:42;125047:16;125065:7;125074:5;125038:8;:42::i;:::-;123964:1128;123547:1552;;;;;;;:::o;79978:564::-;80077:58;;-1:-1:-1;;;80077:58:0;;-1:-1:-1;;;;;1988:32:1;;80077:58:0;;;1970:51:1;80033:18:0;;80099:4;;80077:51;;1943:18:1;;80077:58:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;80064:71;;-1:-1:-1;;80243:10:0;:31;80239:296;;80304:16;80314:5;80304:9;:16::i;80239:296::-;80366:157;80446:27;80462:10;80446:15;:27::i;:::-;80492:16;80502:5;80492:9;:16::i;95233:101::-;95282:7;95309:17;:15;:17::i;113314:177::-;113411:7;113438:18;:16;:18::i;:::-;-1:-1:-1;;;;;113438:36:0;;;;;;;:29;;;;;:36;;;;;;;;:45;;;;;;;;;;-1:-1:-1;113438:45:0;;;113314:177::o;109696:753::-;59529:24;59542:10;59529:12;:24::i;:::-;;63412:10:::1;109855:20;:40;;109847:61;;;::::0;-1:-1:-1;;;109847:61:0;;23582:2:1;109847:61:0::1;::::0;::::1;23564:21:1::0;23621:1;23601:18;;;23594:29;-1:-1:-1;;;23639:18:1;;;23632:38;23687:18;;109847:61:0::1;23380:331:1::0;109847:61:0::1;109919:22;109944:18;:16;:18::i;:::-;109919:43;;110041:20;110065:1;110041:25:::0;110037:275:::1;;110144:4;110151:25;::::0;;;:10:::1;::::0;::::1;:25;::::0;;;;;110130:47:::1;::::0;110144:4;110130:5:::1;:47::i;:::-;110258:1;110234:21;::::0;::::1;:25:::0;110274:22:::1;::::0;::::1;:26:::0;;-1:-1:-1;;;;;;110274:26:0::1;::::0;;110037:275:::1;110324:21;::::0;::::1;:52:::0;;-1:-1:-1;;110324:52:0::1;;::::0;::::1;;::::0;;110394:47:::1;::::0;160:25:1;;;110394:47:0::1;::::0;148:2:1;133:18;110394:47:0::1;;;;;;;109798:651;109696:753:::0;:::o;60908:171::-;60968:4;61004:18;:16;:18::i;:::-;:29;;;-1:-1:-1;;;;;60993:40:0;;;61004:29;;60993:40;60985:64;;;;-1:-1:-1;;;60985:64:0;;23918:2:1;60985:64:0;;;23900:21:1;23957:2;23937:18;;;23930:30;-1:-1:-1;;;23976:18:1;;;23969:41;24027:18;;60985:64:0;23716:335:1;60985:64:0;-1:-1:-1;61067:4:0;;60908:171;-1:-1:-1;60908:171:0:o;103618:135::-;103676:7;103703:18;:16;:18::i;:::-;:42;;;-1:-1:-1;;;103703:42:0;;-1:-1:-1;;;;;103703:42:0;;;-1:-1:-1;103618:135:0:o;75373:119::-;75434:7;75461:23;75477:6;75461:15;:23::i;106203:259::-;59529:24;59542:10;59529:12;:24::i;:::-;-1:-1:-1;;;;;;106297:25:0;::::1;106289:50;;;;-1:-1:-1::0;;;106289:50:0::1;;;;;;;:::i;:::-;106389:11;106350:18;:16;:18::i;:::-;:36;;:50:::0;;-1:-1:-1;;;;;;106350:50:0::1;-1:-1:-1::0;;;;;106350:50:0;;::::1;;::::0;;106418:36:::1;::::0;;;::::1;::::0;::::1;::::0;-1:-1:-1;;106418:36:0::1;106203:259:::0;:::o;102029:107::-;102073:7;102100:18;:16;:18::i;:::-;:28;;;102093:35;;102029:107;:::o;64917:329::-;64967:22;;64364:53;64416:1;64372:40;64364:53;:::i;10010:348::-;10154:7;10174:14;10191:25;10198:1;10201;10204:11;10191:6;:25::i;:::-;10174:42;-1:-1:-1;10243:11:0;10231:8;:23;;;;;;;;:::i;:::-;;:56;;;;;10286:1;10271:11;10258:25;;;;;:::i;:::-;10268:1;10265;10258:25;:29;10231:56;10227:100;;;10304:11;10314:1;10304:11;;:::i;:::-;;;10227:100;10344:6;10010:348;-1:-1:-1;;;;;10010:348:0:o;120807:355::-;-1:-1:-1;;;;;120900:19:0;;120892:68;;;;-1:-1:-1;;;120892:68:0;;24390:2:1;120892:68:0;;;24372:21:1;24429:2;24409:18;;;24402:30;24468:34;24448:18;;;24441:62;-1:-1:-1;;;24519:18:1;;;24512:34;24563:19;;120892:68:0;24188:400:1;120892:68:0;-1:-1:-1;;;;;120979:21:0;;120971:68;;;;-1:-1:-1;;;120971:68:0;;24795:2:1;120971:68:0;;;24777:21:1;24834:2;24814:18;;;24807:30;24873:34;24853:18;;;24846:62;-1:-1:-1;;;24924:18:1;;;24917:32;24966:19;;120971:68:0;24593:398:1;120971:68:0;121100:6;121052:18;:16;:18::i;:::-;-1:-1:-1;;;;;121052:36:0;;;;;;;:29;;;;;:36;;;;;;;;:45;;;;;;;;;;;;;:54;;;;121122:32;;160:25:1;;;121052:45:0;;121122:32;;133:18:1;121122:32:0;;;;;;;;120807:355;;;:::o;95669:656::-;95718:16;95805:22;95830:18;:16;:18::i;:::-;95891:22;;;;95805:43;;-1:-1:-1;;;;;;95891:22:0;95952:15;95928:39;;95924:394;;;96089:12;;;;96046:21;;;;62981:17;;-1:-1:-1;;;96089:12:0;;-1:-1:-1;;;;;96089:12:0;96071:15;:30;96046:56;96045:98;96013:130;;95736:589;;95669:656;:::o;95924:394::-;-1:-1:-1;;;;;96180:26:0;;;96176:142;;96300:4;96281:25;;;;:10;;;:25;;;;;;;-1:-1:-1;96176:142:0;95736:589;;95669:656;:::o;121453:493::-;121579:24;121606:25;121616:5;121623:7;121606:9;:25::i;:::-;121579:52;;-1:-1:-1;;121646:16:0;:37;121642:297;;121746:6;121726:16;:26;;121700:117;;;;-1:-1:-1;;;121700:117:0;;25198:2:1;121700:117:0;;;25180:21:1;25237:2;25217:18;;;25210:30;25276:31;25256:18;;;25249:59;25325:18;;121700:117:0;24996:353:1;121700:117:0;121861:51;121870:5;121877:7;121905:6;121886:16;:25;121861:8;:51::i;:::-;121568:378;121453:493;;;:::o;118513:508::-;-1:-1:-1;;;;;118601:18:0;;118593:68;;;;-1:-1:-1;;;118593:68:0;;25556:2:1;118593:68:0;;;25538:21:1;25595:2;25575:18;;;25568:30;25634:34;25614:18;;;25607:62;-1:-1:-1;;;25685:18:1;;;25678:35;25730:19;;118593:68:0;25354:401:1;118593:68:0;-1:-1:-1;;;;;118680:16:0;;118672:64;;;;-1:-1:-1;;;118672:64:0;;25962:2:1;118672:64:0;;;25944:21:1;26001:2;25981:18;;;25974:30;26040:34;26020:18;;;26013:62;-1:-1:-1;;;26091:18:1;;;26084:33;26134:19;;118672:64:0;25760:399:1;118672:64:0;118769:4;-1:-1:-1;;;;;118755:19:0;;;118747:58;;;;-1:-1:-1;;;118747:58:0;;26366:2:1;118747:58:0;;;26348:21:1;26405:2;26385:18;;;26378:30;26444:28;26424:18;;;26417:56;26490:18;;118747:58:0;26164:350:1;118747:58:0;118816:22;118841:18;:16;:18::i;:::-;-1:-1:-1;;;;;118872:16:0;;;;;;:10;;;:16;;;;;:26;;118816:43;;-1:-1:-1;118892:6:0;;118872:16;;;:26;;118892:6;;118872:26;:::i;:::-;;;;-1:-1:-1;;;;;;;118934:14:0;;;;;;;:10;;;:14;;;;;;;:24;;;;;;118987:26;118934:14;;118987:26;;;;;;;118952:6;160:25:1;;148:2;133:18;;14:177;118987:26:0;;;;;;;;118582:439;118513:508;;;:::o;94631:443::-;94681:16;94700:17;:15;:17::i;:::-;94681:36;;94732:8;94744:1;94732:13;94728:52;;94762:7;94631:443::o;94728:52::-;94924:15;94882:18;:16;:18::i;:::-;:39;;;-1:-1:-1;;;;;94882:39:0;:57;94878:146;;;94996:15;94956:18;:16;:18::i;:::-;:29;;:56;;-1:-1:-1;;;;;94956:56:0;;;-1:-1:-1;;;94956:56:0;;;;;;;;;94878:146;95036:30;95050:4;95057:8;95036:5;:30::i;:::-;94670:404;94631:443::o;119316:359::-;-1:-1:-1;;;;;119391:21:0;;119383:65;;;;-1:-1:-1;;;119383:65:0;;26721:2:1;119383:65:0;;;26703:21:1;26760:2;26740:18;;;26733:30;26799:33;26779:18;;;26772:61;26850:18;;119383:65:0;26519:355:1;119383:65:0;119459:22;119484:18;:16;:18::i;:::-;119459:43;;119532:6;119515:1;:13;;;:23;;;;;;;:::i;:::-;;;;-1:-1:-1;;;;;;;119574:19:0;;;;;;:10;;;:19;;;;;;;;:29;;;;;;119630:37;160:25:1;;;119630:37:0;;133:18:1;119630:37:0;14:177:1;4760:106:0;4818:7;4849:1;4845;:5;:13;;4857:1;4845:13;;120008:361;-1:-1:-1;;;;;120083:21:0;;120075:67;;;;-1:-1:-1;;;120075:67:0;;27081:2:1;120075:67:0;;;27063:21:1;27120:2;27100:18;;;27093:30;27159:34;27139:18;;;27132:62;-1:-1:-1;;;27210:18:1;;;27203:31;27251:19;;120075:67:0;26879:397:1;120075:67:0;120153:22;120178:18;:16;:18::i;:::-;-1:-1:-1;;;;;120209:19:0;;;;;;:10;;;:19;;;;;:29;;120153:43;;-1:-1:-1;120232:6:0;;120209:19;;;:29;;120232:6;;120209:29;:::i;:::-;;;;-1:-1:-1;;120274:13:0;;;:23;;;;;;;120324:37;;160:25:1;;;-1:-1:-1;;;;;;;120324:37:0;;;;;148:2:1;133:18;120324:37:0;14:177:1;126242:531:0;126299:7;126400:143;126582:18;:16;:18::i;:::-;:23;;126566:41;;;;;;:::i;:::-;;;;;;;;;;126646:11;;;;;;;;-1:-1:-1;;;126646:11:0;;;;;126367:383;;;;;28389:25:1;;;;28430:18;;28423:34;;;;126630:29:0;28473:18:1;;;28466:34;126682:13:0;28516:18:1;;;28509:34;126726:4:0;28559:19:1;;;28552:61;28361:19;;126367:383:0;;;;;;;;;;;;126339:426;;;;;;126319:446;;126242:531;:::o;98040:1044::-;98087:22;98112:18;:16;:18::i;:::-;98209:7;;:32;;-1:-1:-1;;;98209:32:0;;98235:4;98209:32;;;1970:51:1;98209:7:0;;-1:-1:-1;98186:20:0;;-1:-1:-1;;;;;98209:7:0;;;;:17;;1943:18:1;;98209:32:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;98186:55;;98321:12;98306:1;:11;;;:27;98302:40;;98335:7;;98040:1044::o;98302:40::-;98413:20;98436:13;:11;:13::i;:::-;98413:36;;98539:12;98523;:28;98519:456;;98609:11;;;:26;;;98695:1;98681:11;;;:15;98519:456;;;98789:11;;;:26;;;98921:27;;;98907:11;;;:41;98519:456;99046:13;:11;:13::i;:::-;99030:12;:29;99022:54;;;;-1:-1:-1;;;99022:54:0;;28826:2:1;99022:54:0;;;28808:21:1;28865:2;28845:18;;;28838:30;-1:-1:-1;;;28884:18:1;;;28877:42;28936:18;;99022:54:0;28624:336:1;99022:54:0;98076:1008;;;98040:1044::o;82151:1418::-;82300:4;-1:-1:-1;;;;;82280:25:0;;;82272:59;;;;-1:-1:-1;;;82272:59:0;;29167:2:1;82272:59:0;;;29149:21:1;29206:2;29186:18;;;29179:30;-1:-1:-1;;;29225:18:1;;;29218:51;29286:18;;82272:59:0;28965:345:1;82272:59:0;82401:22;82426:18;:16;:18::i;:::-;82470:7;;82401:43;;-1:-1:-1;;;;;;82470:7:0;82560:58;82470:7;82584:10;82604:4;82611:6;82560:23;:58::i;:::-;82704:16;82737:6;82723:1;:11;;;:20;;;;:::i;:::-;82829:31;;-1:-1:-1;;;82829:31:0;;82854:4;82829:31;;;1970:51:1;82704:39:0;;-1:-1:-1;82805:21:0;;-1:-1:-1;;;;;82829:16:0;;;;;1943:18:1;;82829:31:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;82915:50;;-1:-1:-1;;;82915:50:0;;;;;160:25:1;;;82805:55:0;;-1:-1:-1;82937:4:0;;82915:40;;133:18:1;;82915:50:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;83164:31:0;;-1:-1:-1;;;83164:31:0;;83189:4;83164:31;;;1970:51:1;83106:16:0;;-1:-1:-1;83125:104:0;;-1:-1:-1;;;;;;83164:16:0;;;;;1943:18:1;;83164:31:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;83148:47;;:13;:47;:::i;:::-;83210:8;83125;:104::i;:::-;83106:123;;83290:8;83275:1;:11;;;:23;;;;;;;:::i;:::-;;;;-1:-1:-1;;83408:19:0;;;83394:11;;;:33;83475:23;83481:8;83491:6;83475:5;:23::i;:::-;83516:45;;;2919:25:1;;;2975:2;2960:18;;2953:34;;;-1:-1:-1;;;;;83516:45:0;;;83524:10;;83516:45;;2892:18:1;83516:45:0;;;;;;;82261:1308;;;;;82151:1418;;;:::o;83907:2436::-;84077:7;-1:-1:-1;;;;;84105:22:0;;84097:47;;;;-1:-1:-1;;;84097:47:0;;;;;;;:::i;:::-;62871:6;84163:7;:18;;84155:46;;;;-1:-1:-1;;;84155:46:0;;29517:2:1;84155:46:0;;;29499:21:1;29556:2;29536:18;;;29529:30;-1:-1:-1;;;29575:18:1;;;29568:45;29630:18;;84155:46:0;29315:339:1;84155:46:0;84261:10;-1:-1:-1;;;;;84261:19:0;;;84257:94;;84297:42;84313:5;84320:10;84332:6;84297:15;:42::i;:::-;84363:22;84388:18;:16;:18::i;:::-;84509:7;;84544:11;;;;84363:43;;-1:-1:-1;;;;;;84509:7:0;;84620:13;;;84616:1391;;;84721:31;;-1:-1:-1;;;84721:31:0;;84746:4;84721:31;;;1970:51:1;84704:14:0;;-1:-1:-1;;;;;84721:16:0;;;;;1943:18:1;;84721:31:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;84850:53;;-1:-1:-1;;;84850:53:0;;84889:13;;;84850:53;;;160:25:1;84704:48:0;;-1:-1:-1;84872:4:0;;84850:38;;133:18:1;;84850:53:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;85071:31:0;;-1:-1:-1;;;85071:31:0;;85096:4;85071:31;;;1970:51:1;85024:17:0;;-1:-1:-1;85044:112:0;;-1:-1:-1;85105:6:0;;-1:-1:-1;;;;;85071:16:0;;;;;1943:18:1;;85071:31:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:40;;;;:::i;:::-;85130:1;:11;;;85044:8;:112::i;:::-;85202:17;;;;85024:132;-1:-1:-1;85251:12:0;85347:13;;;85343:566;;;-1:-1:-1;85421:13:0;;;62871:6;85541:17;;85537:271;;;62871:6;85696:16;85705:7;85696:6;:16;:::i;:::-;85695:28;;;;:::i;:::-;85687:4;:36;;85653:135;;;;-1:-1:-1;;;85653:135:0;;29861:2:1;85653:135:0;;;29843:21:1;29900:2;29880:18;;;29873:30;-1:-1:-1;;;29919:18:1;;;29912:43;29972:18;;85653:135:0;29659:337:1;85653:135:0;85889:4;85880:13;;85343:566;85978:16;85990:4;85978:9;:16;:::i;:::-;85962:1;:11;;;:33;;;;;;;:::i;:::-;;;;-1:-1:-1;;;;;84616:1391:0;86084:13;86091:6;86084:4;:13;:::i;:::-;86070:11;;;:27;86110:20;86116:5;86123:6;86110:5;:20::i;:::-;86143:37;-1:-1:-1;;;;;86143:19:0;;86163:8;86173:6;86143:19;:37::i;:::-;86198:53;;;2919:25:1;;;2975:2;2960:18;;2953:34;;;-1:-1:-1;;;;;86198:53:0;;;;;;;;86207:10;;86198:53;;2892:18:1;86198:53:0;;;;;;;-1:-1:-1;86329:6:0;;83907:2436;-1:-1:-1;;;;;;;83907:2436:0:o;5868:4005::-;5984:14;;;-1:-1:-1;;6529:1:0;6526;6519:20;6573:1;6570;6566:9;6557:18;;6629:5;6625:2;6622:13;6614:5;6610:2;6606:14;6602:34;6593:43;;;6735:5;6744:1;6735:10;6731:77;;6781:11;6773:5;:19;;;;;:::i;:::-;;6766:26;;;;;;6731:77;6935:5;6921:11;:19;6913:28;;;;;;7204:17;7342:11;7339:1;7336;7329:25;8749:1;7901;7886:12;;:16;;7871:32;;8009:22;;;;8730:1;:15;;8729:21;;8986;;;8982:25;;8971:36;9056:21;;;9052:25;;9041:36;9127:21;;;9123:25;;9112:36;9198:21;;;9194:25;;9183:36;9269:21;;;9265:25;;9254:36;9341:21;;;9337:25;;;9326:36;;;7856:12;8260;;;8256:23;;;8252:31;;;7459:20;;;7448:32;;;8376:12;;;;7507:21;;8110:16;;;;8367:21;;;;9811:15;;;-1:-1:-1;;;;5868:4005:0:o;46894:248::-;47065:68;;-1:-1:-1;;;;;30259:15:1;;;47065:68:0;;;30241:34:1;30311:15;;30291:18;;;30284:43;30343:18;;;30336:34;;;47038:96:0;;47058:5;;-1:-1:-1;;;47088:27:0;30176:18:1;;47065:68:0;;;;-1:-1:-1;;47065:68:0;;;;;;;;;;;;;;-1:-1:-1;;;;;47065:68:0;-1:-1:-1;;;;;;47065:68:0;;;;;;;;;;47038:19;:96::i;46675:211::-;46819:58;;-1:-1:-1;;;;;30573:32:1;;46819:58:0;;;30555:51:1;30622:18;;;30615:34;;;46792:86:0;;46812:5;;-1:-1:-1;;;46842:23:0;30528:18:1;;46819:58:0;30381:274:1;49742:716:0;50166:23;50192:69;50220:4;50192:69;;;;;;;;;;;;;;;;;50200:5;-1:-1:-1;;;;;50192:27:0;;;:69;;;;;:::i;:::-;50276:17;;50166:95;;-1:-1:-1;50276:21:0;50272:179;;50373:10;50362:30;;;;;;;;;;;;:::i;:::-;50354:85;;;;-1:-1:-1;;;50354:85:0;;31144:2:1;50354:85:0;;;31126:21:1;31183:2;31163:18;;;31156:30;31222:34;31202:18;;;31195:62;-1:-1:-1;;;31273:18:1;;;31266:40;31323:19;;50354:85:0;30942:406:1;40711:229:0;40848:12;40880:52;40902:6;40910:4;40916:1;40919:12;40848;42119;42133:23;42160:6;-1:-1:-1;;;;;42160:11:0;42179:5;42186:4;42160:31;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;42118:73;;;;42209:69;42236:6;42244:7;42253:10;42265:12;42209:26;:69::i;:::-;42202:76;41831:455;-1:-1:-1;;;;;;;41831:455:0:o;44404:644::-;44589:12;44618:7;44614:427;;;44646:10;:17;44667:1;44646:22;44642:290;;-1:-1:-1;;;;;38249:19:0;;;44856:60;;;;-1:-1:-1;;;44856:60:0;;32254:2:1;44856:60:0;;;32236:21:1;32293:2;32273:18;;;32266:30;32332:31;32312:18;;;32305:59;32381:18;;44856:60:0;32052:353:1;44856:60:0;-1:-1:-1;44953:10:0;44946:17;;44614:427;44996:33;45004:10;45016:12;45751:17;;:21;45747:388;;45983:10;45977:17;46040:15;46027:10;46023:2;46019:19;46012:44;45747:388;46110:12;46103:20;;-1:-1:-1;;;46103:20:0;;;;;;;;:::i;196:250:1:-;281:1;291:113;305:6;302:1;299:13;291:113;;;381:11;;;375:18;362:11;;;355:39;327:2;320:10;291:113;;;-1:-1:-1;;438:1:1;420:16;;413:27;196:250::o;451:396::-;600:2;589:9;582:21;563:4;632:6;626:13;675:6;670:2;659:9;655:18;648:34;691:79;763:6;758:2;747:9;743:18;738:2;730:6;726:15;691:79;:::i;:::-;831:2;810:15;-1:-1:-1;;806:29:1;791:45;;;;838:2;787:54;;451:396;-1:-1:-1;;451:396:1:o;852:180::-;911:6;964:2;952:9;943:7;939:23;935:32;932:52;;;980:1;977;970:12;932:52;-1:-1:-1;1003:23:1;;852:180;-1:-1:-1;852:180:1:o;1037:131::-;-1:-1:-1;;;;;1112:31:1;;1102:42;;1092:70;;1158:1;1155;1148:12;1173:134;1241:20;;1270:31;1241:20;1270:31;:::i;1312:315::-;1380:6;1388;1441:2;1429:9;1420:7;1416:23;1412:32;1409:52;;;1457:1;1454;1447:12;1409:52;1496:9;1483:23;1515:31;1540:5;1515:31;:::i;:::-;1565:5;1617:2;1602:18;;;;1589:32;;-1:-1:-1;;;1312:315:1:o;2032:247::-;2091:6;2144:2;2132:9;2123:7;2119:23;2115:32;2112:52;;;2160:1;2157;2150:12;2112:52;2199:9;2186:23;2218:31;2243:5;2218:31;:::i;2284:456::-;2361:6;2369;2377;2430:2;2418:9;2409:7;2405:23;2401:32;2398:52;;;2446:1;2443;2436:12;2398:52;2485:9;2472:23;2504:31;2529:5;2504:31;:::i;:::-;2554:5;-1:-1:-1;2611:2:1;2596:18;;2583:32;2624:33;2583:32;2624:33;:::i;:::-;2284:456;;2676:7;;-1:-1:-1;;;2730:2:1;2715:18;;;;2702:32;;2284:456::o;2998:127::-;3059:10;3054:3;3050:20;3047:1;3040:31;3090:4;3087:1;3080:15;3114:4;3111:1;3104:15;3130:275;3201:2;3195:9;3266:2;3247:13;;-1:-1:-1;;3243:27:1;3231:40;;3301:18;3286:34;;3322:22;;;3283:62;3280:88;;;3348:18;;:::i;:::-;3384:2;3377:22;3130:275;;-1:-1:-1;3130:275:1:o;3410:187::-;3459:4;3492:18;3484:6;3481:30;3478:56;;;3514:18;;:::i;:::-;-1:-1:-1;3580:2:1;3559:15;-1:-1:-1;;3555:29:1;3586:4;3551:40;;3410:187::o;3602:1032::-;3707:6;3715;3723;3731;3739;3792:3;3780:9;3771:7;3767:23;3763:33;3760:53;;;3809:1;3806;3799:12;3760:53;3848:9;3835:23;3867:31;3892:5;3867:31;:::i;:::-;3917:5;-1:-1:-1;3973:2:1;3958:18;;3945:32;4000:18;3989:30;;3986:50;;;4032:1;4029;4022:12;3986:50;4055:22;;4108:4;4100:13;;4096:27;-1:-1:-1;4086:55:1;;4137:1;4134;4127:12;4086:55;4173:2;4160:16;4198:49;4214:32;4243:2;4214:32;:::i;:::-;4198:49;:::i;:::-;4270:2;4263:5;4256:17;4310:7;4305:2;4300;4296;4292:11;4288:20;4285:33;4282:53;;;4331:1;4328;4321:12;4282:53;4386:2;4381;4377;4373:11;4368:2;4361:5;4357:14;4344:45;4430:1;4425:2;4420;4413:5;4409:14;4405:23;4398:34;4451:5;4441:15;;;;;4475:38;4509:2;4498:9;4494:18;4475:38;:::i;:::-;4465:48;;4532:38;4566:2;4555:9;4551:18;4532:38;:::i;:::-;4522:48;;4589:39;4623:3;4612:9;4608:19;4589:39;:::i;:::-;4579:49;;3602:1032;;;;;;;;:::o;5010:315::-;5078:6;5086;5139:2;5127:9;5118:7;5114:23;5110:32;5107:52;;;5155:1;5152;5145:12;5107:52;5191:9;5178:23;5168:33;;5251:2;5240:9;5236:18;5223:32;5264:31;5289:5;5264:31;:::i;:::-;5314:5;5304:15;;;5010:315;;;;;:::o;5523:525::-;5609:6;5617;5625;5633;5686:3;5674:9;5665:7;5661:23;5657:33;5654:53;;;5703:1;5700;5693:12;5654:53;5739:9;5726:23;5716:33;;5799:2;5788:9;5784:18;5771:32;5812:31;5837:5;5812:31;:::i;:::-;5862:5;-1:-1:-1;5919:2:1;5904:18;;5891:32;5932:33;5891:32;5932:33;:::i;:::-;5523:525;;;;-1:-1:-1;5984:7:1;;6038:2;6023:18;6010:32;;-1:-1:-1;;5523:525:1:o;6053:117::-;6138:6;6131:5;6127:18;6120:5;6117:29;6107:57;;6160:1;6157;6150:12;6175:245;6233:6;6286:2;6274:9;6265:7;6261:23;6257:32;6254:52;;;6302:1;6299;6292:12;6254:52;6341:9;6328:23;6360:30;6384:5;6360:30;:::i;6425:456::-;6502:6;6510;6518;6571:2;6559:9;6550:7;6546:23;6542:32;6539:52;;;6587:1;6584;6577:12;6539:52;6623:9;6610:23;6600:33;;6683:2;6672:9;6668:18;6655:32;6696:31;6721:5;6696:31;:::i;:::-;6746:5;-1:-1:-1;6803:2:1;6788:18;;6775:32;6816:33;6775:32;6816:33;:::i;:::-;6868:7;6858:17;;;6425:456;;;;;:::o;6886:114::-;6970:4;6963:5;6959:16;6952:5;6949:27;6939:55;;6990:1;6987;6980:12;7005:801;7116:6;7124;7132;7140;7148;7156;7164;7217:3;7205:9;7196:7;7192:23;7188:33;7185:53;;;7234:1;7231;7224:12;7185:53;7273:9;7260:23;7292:31;7317:5;7292:31;:::i;:::-;7342:5;-1:-1:-1;7399:2:1;7384:18;;7371:32;7412:33;7371:32;7412:33;:::i;:::-;7464:7;-1:-1:-1;7518:2:1;7503:18;;7490:32;;-1:-1:-1;7569:2:1;7554:18;;7541:32;;-1:-1:-1;7625:3:1;7610:19;;7597:33;7639:31;7597:33;7639:31;:::i;:::-;7005:801;;;;-1:-1:-1;7005:801:1;;;;7689:7;7743:3;7728:19;;7715:33;;-1:-1:-1;7795:3:1;7780:19;;;7767:33;;7005:801;-1:-1:-1;;7005:801:1:o;7811:388::-;7879:6;7887;7940:2;7928:9;7919:7;7915:23;7911:32;7908:52;;;7956:1;7953;7946:12;7908:52;7995:9;7982:23;8014:31;8039:5;8014:31;:::i;:::-;8064:5;-1:-1:-1;8121:2:1;8106:18;;8093:32;8134:33;8093:32;8134:33;:::i;8204:380::-;8283:1;8279:12;;;;8326;;;8347:61;;8401:4;8393:6;8389:17;8379:27;;8347:61;8454:2;8446:6;8443:14;8423:18;8420:38;8417:161;;8500:10;8495:3;8491:20;8488:1;8481:31;8535:4;8532:1;8525:15;8563:4;8560:1;8553:15;8417:161;;8204:380;;;:::o;8589:127::-;8650:10;8645:3;8641:20;8638:1;8631:31;8681:4;8678:1;8671:15;8705:4;8702:1;8695:15;8721:128;8788:9;;;8809:11;;;8806:37;;;8823:18;;:::i;9189:355::-;9391:2;9373:21;;;9430:2;9410:18;;;9403:30;9469:33;9464:2;9449:18;;9442:61;9535:2;9520:18;;9189:355::o;9549:184::-;9619:6;9672:2;9660:9;9651:7;9647:23;9643:32;9640:52;;;9688:1;9685;9678:12;9640:52;-1:-1:-1;9711:16:1;;9549:184;-1:-1:-1;9549:184:1:o;9738:127::-;9799:10;9794:3;9790:20;9787:1;9780:31;9830:4;9827:1;9820:15;9854:4;9851:1;9844:15;9870:383;9948:6;9956;10009:2;9997:9;9988:7;9984:23;9980:32;9977:52;;;10025:1;10022;10015:12;9977:52;10057:9;10051:16;10076:30;10100:5;10076:30;:::i;:::-;10175:2;10160:18;;10154:25;10125:5;;-1:-1:-1;10188:33:1;10154:25;10188:33;:::i;10258:168::-;10331:9;;;10362;;10379:15;;;10373:22;;10359:37;10349:71;;10400:18;;:::i;10431:217::-;10471:1;10497;10487:132;;10541:10;10536:3;10532:20;10529:1;10522:31;10576:4;10573:1;10566:15;10604:4;10601:1;10594:15;10487:132;-1:-1:-1;10633:9:1;;10431:217::o;10653:125::-;10718:9;;;10739:10;;;10736:36;;;10752:18;;:::i;11645:545::-;11747:2;11742:3;11739:11;11736:448;;;11783:1;11808:5;11804:2;11797:17;11853:4;11849:2;11839:19;11923:2;11911:10;11907:19;11904:1;11900:27;11894:4;11890:38;11959:4;11947:10;11944:20;11941:47;;;-1:-1:-1;11982:4:1;11941:47;12037:2;12032:3;12028:12;12025:1;12021:20;12015:4;12011:31;12001:41;;12092:82;12110:2;12103:5;12100:13;12092:82;;;12155:17;;;12136:1;12125:13;12092:82;;;12096:3;;;11645:545;;;:::o;12366:1352::-;12492:3;12486:10;12519:18;12511:6;12508:30;12505:56;;;12541:18;;:::i;:::-;12570:97;12660:6;12620:38;12652:4;12646:11;12620:38;:::i;:::-;12614:4;12570:97;:::i;:::-;12722:4;;12786:2;12775:14;;12803:1;12798:663;;;;13505:1;13522:6;13519:89;;;-1:-1:-1;13574:19:1;;;13568:26;13519:89;-1:-1:-1;;12323:1:1;12319:11;;;12315:24;12311:29;12301:40;12347:1;12343:11;;;12298:57;13621:81;;12768:944;;12798:663;11592:1;11585:14;;;11629:4;11616:18;;-1:-1:-1;;12834:20:1;;;12952:236;12966:7;12963:1;12960:14;12952:236;;;13055:19;;;13049:26;13034:42;;13147:27;;;;13115:1;13103:14;;;;12982:19;;12952:236;;;12956:3;13216:6;13207:7;13204:19;13201:201;;;13277:19;;;13271:26;-1:-1:-1;;13360:1:1;13356:14;;;13372:3;13352:24;13348:37;13344:42;13329:58;13314:74;;13201:201;-1:-1:-1;;;;;13448:1:1;13432:14;;;13428:22;13415:36;;-1:-1:-1;12366:1352:1:o;13723:247::-;13791:6;13844:2;13832:9;13823:7;13819:23;13815:32;13812:52;;;13860:1;13857;13850:12;13812:52;13892:9;13886:16;13911:29;13934:5;13911:29;:::i;13975:336::-;14177:2;14159:21;;;14216:2;14196:18;;;14189:30;-1:-1:-1;;;14250:2:1;14235:18;;14228:42;14302:2;14287:18;;13975:336::o;16727:649::-;16807:6;16860:2;16848:9;16839:7;16835:23;16831:32;16828:52;;;16876:1;16873;16866:12;16828:52;16909:9;16903:16;16942:18;16934:6;16931:30;16928:50;;;16974:1;16971;16964:12;16928:50;16997:22;;17050:4;17042:13;;17038:27;-1:-1:-1;17028:55:1;;17079:1;17076;17069:12;17028:55;17108:2;17102:9;17133:49;17149:32;17178:2;17149:32;:::i;17133:49::-;17205:2;17198:5;17191:17;17245:7;17240:2;17235;17231;17227:11;17223:20;17220:33;17217:53;;;17266:1;17263;17256:12;17217:53;17279:67;17343:2;17338;17331:5;17327:14;17322:2;17318;17314:11;17279:67;:::i;17381:432::-;-1:-1:-1;;;17638:3:1;17631:17;17613:3;17677:6;17671:13;17693:74;17760:6;17756:1;17751:3;17747:11;17740:4;17732:6;17728:17;17693:74;:::i;:::-;17787:16;;;;17805:1;17783:24;;17381:432;-1:-1:-1;;17381:432:1:o;17818:422::-;17907:1;17950:5;17907:1;17964:270;17985:7;17975:8;17972:21;17964:270;;;18044:4;18040:1;18036:6;18032:17;18026:4;18023:27;18020:53;;;18053:18;;:::i;:::-;18103:7;18093:8;18089:22;18086:55;;;18123:16;;;;18086:55;18202:22;;;;18162:15;;;;17964:270;;;17968:3;17818:422;;;;;:::o;18245:806::-;18294:5;18324:8;18314:80;;-1:-1:-1;18365:1:1;18379:5;;18314:80;18413:4;18403:76;;-1:-1:-1;18450:1:1;18464:5;;18403:76;18495:4;18513:1;18508:59;;;;18581:1;18576:130;;;;18488:218;;18508:59;18538:1;18529:10;;18552:5;;;18576:130;18613:3;18603:8;18600:17;18597:43;;;18620:18;;:::i;:::-;-1:-1:-1;;18676:1:1;18662:16;;18691:5;;18488:218;;18790:2;18780:8;18777:16;18771:3;18765:4;18762:13;18758:36;18752:2;18742:8;18739:16;18734:2;18728:4;18725:12;18721:35;18718:77;18715:159;;;-1:-1:-1;18827:19:1;;;18859:5;;18715:159;18906:34;18931:8;18925:4;18906:34;:::i;:::-;18976:6;18972:1;18968:6;18964:19;18955:7;18952:32;18949:58;;;18987:18;;:::i;:::-;19025:20;;18245:806;-1:-1:-1;;;18245:806:1:o;19056:140::-;19114:5;19143:47;19184:4;19174:8;19170:19;19164:4;19143:47;:::i;24056:127::-;24117:10;24112:3;24108:20;24105:1;24098:31;24148:4;24145:1;24138:15;24172:4;24169:1;24162:15;27281:844;27411:3;27440:1;27473:6;27467:13;27503:36;27529:9;27503:36;:::i;:::-;27558:1;27575:18;;;27602:133;;;;27749:1;27744:356;;;;27568:532;;27602:133;-1:-1:-1;;27635:24:1;;27623:37;;27708:14;;27701:22;27689:35;;27680:45;;;-1:-1:-1;27602:133:1;;27744:356;27775:6;27772:1;27765:17;27805:4;27850:2;27847:1;27837:16;27875:1;27889:165;27903:6;27900:1;27897:13;27889:165;;;27981:14;;27968:11;;;27961:35;28024:16;;;;27918:10;;27889:165;;;27893:3;;;28083:6;28078:3;28074:16;28067:23;;27568:532;-1:-1:-1;28116:3:1;;27281:844;-1:-1:-1;;;;;;27281:844:1:o;30660:277::-;30727:6;30780:2;30768:9;30759:7;30755:23;30751:32;30748:52;;;30796:1;30793;30786:12;30748:52;30828:9;30822:16;30881:5;30874:13;30867:21;30860:5;30857:32;30847:60;;30903:1;30900;30893:12;31760:287;31889:3;31927:6;31921:13;31943:66;32002:6;31997:3;31990:4;31982:6;31978:17;31943:66;:::i;:::-;32025:16;;;;;31760:287;-1:-1:-1;;31760:287:1:o

ipfs://a32d9b4163fbbdc0998c038789f9392c6e248cd860adef34f18696c4171a158e