Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

Outline

• interface IERC20
•    - function totalSupply()
•    - function balanceOf(address account)
•    - function transfer(address to, uint256 ...
•    - function allowance(address owner, add ...
•    - function approve(address spender, uin ...
•    - function transferFrom(
•    - function _msgSender()
•    - function _msgData()
• library Math
•    - function max(uint256 a, uint256 b)
•    - function min(uint256 a, uint256 b)
•    - function average(uint256 a, uint256 b ...
•    - function ceilDiv(uint256 a, uint256 b ...
•    - function mulDiv(
•    - function mulDiv(
•    - function sqrt(uint256 a)
•    - function sqrt(uint256 a, Rounding rou ...
•  contract OwnedV2
•    - function nominateNewOwner(address _ow ...
•    - function acceptOwnership()
• library TransferHelper
•    - function safeApprove(address token, a ...
•    - function safeTransfer(address token, ...
•    - function safeTransferFrom(address tok ...
•    - function safeTransferETH(address to, ...
• interface IERC20Metadata is IERC20
•    - function name()
•    - function symbol()
•    - function decimals()
•  contract ERC20 is Context, IERC20, ...
•    - function name()
•    - function symbol()
•    - function decimals()
•    - function totalSupply()
•    - function balanceOf(address account)
•    - function transfer(address to, uint256 ...
•    - function allowance(address owner, add ...
•    - function approve(address spender, uin ...
•    - function transferFrom(
•    - function increaseAllowance(address sp ...
•    - function decreaseAllowance(address sp ...
•    - function _transfer(
•    - function _mint(address account, uint2 ...
•    - function _burn(address account, uint2 ...
•    - function _approve(
•    - function _spendAllowance(
•    - function _beforeTokenTransfer(
•    - function _afterTokenTransfer(
•  contract TimedLocker is ERC20, Own ... *
•    - function availableToLock()
•    - function lastTimeRewardApplicable()
•    - function minAddlRewTknsForCapIncrease ...
•    - function rewardPerToken()
•    - function earned(address _account)
•    - function getRewardsRemaining()
•    - function _beforeTokenTransfer(address ...
•    - function bulkSyncEarnedUsers(address[ ...
•    - function sync()
•    - function _updateRewards(address accou ...
•    - function _syncEarnedInner(address _ac ...
•    - function _syncEarned(address _account ...
•    - function stake(uint256 _amount)
•    - function withdraw(
•    - function getReward(
•    - function notifyRewardAmounts(uint256[ ...
•    - function initiateWithdrawalOnlyShutdo ...
•    - function increaseCapWithRewards(uint2 ...
•    - function recoverERC20(address _tokenA ...
•    - function toggleExternalSyncEarning()
•    - function toggleStaking()
•    - function toggleRewardsCollection()
•    - function toggleRewardNotifier(address ...
•    - function toggleWithdrawals()
•    - function unlockStakes()

More Options

• Similar
• Submit Audit
• Compare

/**
 *Submitted for verification at fraxscan.com on 2024-06-25
*/

// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity >=0.8.0;


// node_modules/@openzeppelin/contracts/security/ReentrancyGuard.sol

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

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

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

    uint256 private _status;

    constructor() {
        _status = _NOT_ENTERED;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and making it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        // On the first call to nonReentrant, _notEntered will be true
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

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

        _;

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

// node_modules/@openzeppelin/contracts/token/ERC20/IERC20.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);
}

// node_modules/@openzeppelin/contracts/utils/Context.sol

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

// node_modules/@openzeppelin/contracts/utils/math/Math.sol

// OpenZeppelin Contracts (last updated v4.7.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. It 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)`.
        // We also know that `k`, the position of the most significant bit, is such that `msb(a) = 2**k`.
        // This gives `2**k < a <= 2**(k+1)` → `2**(k/2) <= sqrt(a) < 2 ** (k/2+1)`.
        // Using an algorithm similar to the msb conmputation, we are able to compute `result = 2**(k/2)` which is a
        // good first aproximation of `sqrt(a)` with at least 1 correct bit.
        uint256 result = 1;
        uint256 x = a;
        if (x >> 128 > 0) {
            x >>= 128;
            result <<= 64;
        }
        if (x >> 64 > 0) {
            x >>= 64;
            result <<= 32;
        }
        if (x >> 32 > 0) {
            x >>= 32;
            result <<= 16;
        }
        if (x >> 16 > 0) {
            x >>= 16;
            result <<= 8;
        }
        if (x >> 8 > 0) {
            x >>= 8;
            result <<= 4;
        }
        if (x >> 4 > 0) {
            x >>= 4;
            result <<= 2;
        }
        if (x >> 2 > 0) {
            result <<= 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) {
        uint256 result = sqrt(a);
        if (rounding == Rounding.Up && result * result < a) {
            result += 1;
        }
        return result;
    }
}

// src/contracts/Miscellany/OwnedV2.sol

// https://docs.synthetix.io/contracts/Owned
contract OwnedV2 {
    error OwnerCannotBeZero();
    error InvalidOwnershipAcceptance();
    error OnlyOwner();

    address public owner;
    address public nominatedOwner;

    constructor(address _owner) {
        // require(_owner != address(0), "Owner address cannot be 0");
        if (_owner == address(0)) revert OwnerCannotBeZero();
        owner = _owner;
        emit OwnerChanged(address(0), _owner);
    }

    function nominateNewOwner(address _owner) external onlyOwner {
        nominatedOwner = _owner;
        emit OwnerNominated(_owner);
    }

    function acceptOwnership() external {
        // require(msg.sender == nominatedOwner, "You must be nominated before you can accept ownership");
        if (msg.sender != nominatedOwner) revert InvalidOwnershipAcceptance();
        emit OwnerChanged(owner, nominatedOwner);
        owner = nominatedOwner;
        nominatedOwner = address(0);
    }

    modifier onlyOwner() {
        // require(msg.sender == owner, "Only the contract owner may perform this action");
        if (msg.sender != owner) revert OnlyOwner();
        _;
    }

    event OwnerNominated(address newOwner);
    event OwnerChanged(address oldOwner, address newOwner);
}

// src/contracts/VestedFXS-and-Flox/Flox/TransferHelper.sol

// helper methods for interacting with ERC20 tokens and sending ETH that do not consistently return true/false
library TransferHelper {
    error TransferHelperApproveFailed();
    error TransferHelperTransferFailed();
    error TransferHelperTransferFromFailed();
    error TransferHelperTransferETHFailed();

    function safeApprove(address token, address to, uint256 value) internal {
        // bytes4(keccak256(bytes('approve(address,uint256)')));
        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(0x095ea7b3, to, value));
        // require(success && (data.length == 0 || abi.decode(data, (bool))), 'TransferHelper: APPROVE_FAILED');
        if (!success || (data.length != 0 && !abi.decode(data, (bool)))) revert TransferHelperApproveFailed();
    }

    function safeTransfer(address token, address to, uint256 value) internal {
        // bytes4(keccak256(bytes('transfer(address,uint256)')));
        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(0xa9059cbb, to, value));
        // require(success && (data.length == 0 || abi.decode(data, (bool))), 'TransferHelper: TRANSFER_FAILED');
        if (!success || (data.length != 0 && !abi.decode(data, (bool)))) revert TransferHelperTransferFailed();
    }

    function safeTransferFrom(address token, address from, address to, uint256 value) internal {
        // bytes4(keccak256(bytes('transferFrom(address,address,uint256)')));
        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(0x23b872dd, from, to, value));
        // require(success && (data.length == 0 || abi.decode(data, (bool))), 'TransferHelper: TRANSFER_FROM_FAILED');
        if (!success || (data.length != 0 && !abi.decode(data, (bool)))) revert TransferHelperTransferFromFailed();
    }

    function safeTransferETH(address to, uint256 value) internal {
        (bool success, ) = to.call{ value: value }(new bytes(0));
        // require(success, 'TransferHelper: ETH_TRANSFER_FAILED');
        if (!success) revert TransferHelperTransferETHFailed();
    }
}

// node_modules/@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol

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

// node_modules/@openzeppelin/contracts/token/ERC20/ERC20.sol

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

/**
 * @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.zeppelin.solutions/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;
        }
        _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;
        _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;
        }
        _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 {}
}

// src/contracts/Miscellany/TimedLocker.sol

// @version 0.2.8

/**
 * ====================================================================
 * |     ______                   _______                             |
 * |    / _____________ __  __   / ____(_____  ____ _____  ________   |
 * |   / /_  / ___/ __ `| |/_/  / /_  / / __ \/ __ `/ __ \/ ___/ _ \  |
 * |  / __/ / /  / /_/ _>  <   / __/ / / / / / /_/ / / / / /__/  __/  |
 * | /_/   /_/   \__,_/_/|_|  /_/   /_/_/ /_/\__,_/_/ /_/\___/\___/   |
 * |                                                                  |
 * ====================================================================
 * =========================== TimedLocker ============================
 * ====================================================================
 * Fixed-rate FXS rewards for locking tokens.
 * Total amount of staking token lockable is capped
 * Locked positions are transferable as vault tokens
 * After a set ending timestamp, all positions are unlockable
 * Frax Finance: https://github.com/FraxFinance
 */

// import "forge-std/console2.sol";

contract TimedLocker is ERC20, OwnedV2, ReentrancyGuard {
    /* ========== STATE VARIABLES ========== */

    // Core variables
    // ----------------------------------------
    /// @notice When the locker was deployed
    uint256 public immutable deployTimestamp;

    /// @notice When the locker ends
    uint256 public immutable endingTimestamp;

    /// @notice Maximum amount of staking token that can be staked
    /// @dev Can be increased only if more reward tokens are simultaneously provided, to keep the new rewardPerSecondPerToken >= old rewardPerSecondPerToken
    uint256 public cap;

    /// @notice The token being staked
    ERC20 public stakingToken;

    // Global reward-related
    // ----------------------------------------

    /// @notice Helper to see if a token is a reward token on this locker
    mapping(address => bool) public isRewardToken;

    /// @notice The last time rewards were sent in
    uint256 public lastRewardPull;

    /// @notice The last time this contract was updated
    uint256 public lastUpdateTime;

    /// @notice The time the rewards period should finish. Should be endingTimestamp
    uint256 public immutable periodFinish;

    /// @notice The duration of the reward period. Should be endingTimestamp - deploy block.timestamp
    uint256 public immutable rewardsDuration;

    /// @notice Mapping of addresses that are allowed to deposit reward tokens
    mapping(address => bool) public rewardNotifiers;

    /// @notice Accumulator for rewardsPerToken
    // https://www.paradigm.xyz/2021/05/liquidity-mining-on-uniswap-v3
    uint256[] public rewardsPerTokenStored;

    /// @notice The reward tokens per second
    uint256[] public rewardRates;

    /// @notice Helper to get the reward token index, given the address of the token
    mapping(address => uint256) public rewardTokenAddrToIdx;

    /// @notice Array of all the reward tokens
    address[] public rewardTokens;

    // User reward-related
    // ----------------------------------------

    /// @notice The last time a farmer claimed their rewards
    mapping(address => uint256) public lastRewardClaimTime; // staker addr -> timestamp

    /// @notice Used for tracking stored/collectible rewards. earned()
    mapping(address => mapping(uint256 => uint256)) public rewards; // staker addr -> token id -> reward amount

    /// @notice Accumulator for userRewardsPerTokenPaid
    mapping(address => mapping(uint256 => uint256)) public userRewardsPerTokenPaid; // staker addr -> token id -> paid amount

    // Emergency variables
    // ----------------------------------------
    /// @notice If external syncEarned calls via bulkSyncEarnedUsers are allowed
    bool public externalSyncEarningPaused;

    /// @notice If reward collections are paused
    bool public rewardsCollectionPaused;

    /// @notice If staking is paused
    bool public stakingPaused;

    /// @notice Release locked stakes in case of system migration or emergency
    bool public stakesUnlocked;

    // For emergencies if a token is overemitted or something else. Only callable once.
    // Bypasses certain logic, which will cause reward calculations to be off
    // But the goal is for the users to recover LP, and they couldn't claim the erroneous rewards anyways.
    // Reward reimbursement claims would be handled with pre-issue earned() snapshots and a claim contract, or similar.
    bool public withdrawalOnlyShutdown;

    /// @notice If withdrawals are paused
    bool public withdrawalsPaused;

    /* ========== CONSTRUCTOR ========== */

    /// @notice Constructor
    /// @param _owner The owner of the locker
    /// @param _rewardTokens Array of reward tokens
    /// @param _name Name for the vault token
    /// @param _symbol Symbol for the vault token
    /// @param _stakingToken The token being staked
    /// @param _endingTimestamp Timestamp when all locks become unlocked
    /// @param _cap Maximum amount of staking tokens allowed to be locked
    /// @param _extraNotifier Additional reward notifier to add when constructing. Can add more / remove later
    constructor(
        address _owner,
        address[] memory _rewardTokens,
        address _stakingToken,
        string memory _name,
        string memory _symbol,
        uint256 _endingTimestamp,
        uint256 _cap,
        address _extraNotifier
    ) ERC20(_name, _symbol) OwnedV2(_owner) {
        // Set state variables
        stakingToken = ERC20(_stakingToken);
        rewardTokens = _rewardTokens;
        endingTimestamp = _endingTimestamp;
        cap = _cap;

        // Loop through the reward tokens
        for (uint256 i = 0; i < _rewardTokens.length; i++) {
            // For fast token address -> token ID lookups later
            rewardTokenAddrToIdx[_rewardTokens[i]] = i;

            // Add to the mapping
            isRewardToken[_rewardTokens[i]] = true;

            // Initialize the stored rewards
            rewardsPerTokenStored.push(0);

            // Initialize the reward rates
            rewardRates.push(0);
        }

        // Set the owner as an allowed reward notifier
        rewardNotifiers[_owner] = true;

        // Add the additional reward notifier, if present
        if (_extraNotifier != address(0)) rewardNotifiers[_extraNotifier] = true;

        // Other booleans
        stakesUnlocked = false;

        // For initialization
        deployTimestamp = block.timestamp;
        lastUpdateTime = block.timestamp;
        rewardsDuration = _endingTimestamp - block.timestamp;
        periodFinish = _endingTimestamp;
    }

    /* ========== MODIFIERS ========== */

    /// @notice Staking should not be paused
    modifier notStakingPaused() {
        require(!stakingPaused, "Staking paused");
        _;
    }

    /// @notice Update rewards and balances
    modifier updateRewards(address account) {
        _updateRewards(account);
        _;
    }

    /* ========== VIEWS ========== */

    /// @notice Remaining amount of stakingToken you can lock before hitting the cap
    /// @return _amount The amount
    function availableToLock() public view returns (uint256 _amount) {
        _amount = (cap - totalSupply());
    }

    /// @notice The last time rewards were applicable. Should be the lesser of the current timestamp, or the end of the last period
    /// @return uint256 The last timestamp where rewards were applicable
    function lastTimeRewardApplicable() internal view returns (uint256) {
        return Math.min(block.timestamp, periodFinish);
    }

    /// @notice Minimum amount of additional reward tokens needed so rewardPerSecondPerToken remains the same after a cap increase
    /// @param _newCap The new cap you want to increase to
    /// @return _minRewRates Minimum rewardRate needed after the cap is raised
    /// @return _minAddlTkns Minimum amount of additional reward tokens needed
    function minAddlRewTknsForCapIncrease(
        uint256 _newCap
    ) public view returns (uint256[] memory _minRewRates, uint256[] memory _minAddlTkns) {
        // Cap can only increase
        if (_newCap < cap) revert CapCanOnlyIncrease();

        // Initialize return arrays
        _minRewRates = new uint256[](rewardTokens.length);
        _minAddlTkns = new uint256[](rewardTokens.length);

        // See how much time is left
        uint256 _timeLeft = endingTimestamp - block.timestamp;

        // Loop through the reward tokens
        for (uint256 i = 0; i < rewardTokens.length; ) {
            // Solve for the new reward rate, assuming (Rate / Tokens) is constant
            // Round up by 1 wei
            _minRewRates[i] = ((rewardRates[i] * _newCap) + 1) / cap;

            // Calculate the additional tokens needed
            _minAddlTkns[i] = _timeLeft * (_minRewRates[i] - rewardRates[i]);

            unchecked {
                ++i;
            }
        }
    }

    /// @notice The calculated rewardPerTokenStored accumulator
    /// @return _rtnRewardsPerTokenStored Array of rewardsPerTokenStored
    function rewardPerToken() public view returns (uint256[] memory _rtnRewardsPerTokenStored) {
        // Prepare the return variable
        _rtnRewardsPerTokenStored = new uint256[](rewardTokens.length);

        // Calculate
        if (totalSupply() == 0) {
            // Return 0 if there are no vault tokens
            _rtnRewardsPerTokenStored = rewardsPerTokenStored;
        } else {
            // Loop through the reward tokens
            for (uint256 i = 0; i < rewardTokens.length; ) {
                _rtnRewardsPerTokenStored[i] =
                    rewardsPerTokenStored[i] +
                    (((lastTimeRewardApplicable() - lastUpdateTime) * rewardRates[i] * 1e18) / totalSupply());
                unchecked {
                    ++i;
                }
            }
        }
    }

    /// @notice The currently earned rewards for a user
    /// @param _account The staker's address
    /// @return _rtnEarned Array of the amounts of reward tokens the staker can currently collect
    function earned(address _account) public view returns (uint256[] memory _rtnEarned) {
        // Prepare the return variable
        _rtnEarned = new uint256[](rewardTokens.length);

        // Get the reward rate per token
        uint256[] memory _rtnRewardsPerToken = rewardPerToken();

        // Loop through the reward tokens
        for (uint256 i = 0; i < rewardTokens.length; ) {
            _rtnEarned[i] =
                rewards[_account][i] +
                ((balanceOf(_account) * ((_rtnRewardsPerToken[i] - userRewardsPerTokenPaid[_account][i]))) / 1e18);

            unchecked {
                ++i;
            }
        }
    }

    /// @notice Amount of rewards remaining
    /// @return _rtnRewardsRemaining Array of the amounts of the reward tokens
    function getRewardsRemaining() external view returns (uint256[] memory _rtnRewardsRemaining) {
        // Prepare the return variable
        _rtnRewardsRemaining = new uint256[](rewardTokens.length);

        // Return 0 if the locker has already ended
        if (endingTimestamp <= block.timestamp) return _rtnRewardsRemaining;

        // See how much time is left
        uint256 _timeLeft = endingTimestamp - block.timestamp;

        // Calculate the duration rewards
        for (uint256 i = 0; i < rewardTokens.length; ) {
            _rtnRewardsRemaining[i] = rewardRates[i] * _timeLeft;

            unchecked {
                ++i;
            }
        }
    }

    /* ========== ERC20 OVERRIDES ========== */

    /// @notice Override the _update logic to claim/sync earnings before transferring.
    /**
     * @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 value) internal override {
        // TODO for auditors: Make sure this is not manipulatable
        // If you aren't minting, sync rewards first so the owner doesn't lose them after transferring
        // Also so the recipient doesn't get free rewards
        // withdrawalOnlyShutdown sacrifices rewards buts lets the token move, for emergencies only.
        if (!withdrawalOnlyShutdown && (from != address(0))) {
            sync();
            _syncEarnedInner(from);
            _syncEarnedInner(to);
        }
    }

    /* ========== MUTATIVE FUNCTIONS ========== */

    /// @notice Sync earnings for many users. Convenience function
    /// @param _users The account to sync
    /// @dev _beforeTokenTransfer essentially does this
    function bulkSyncEarnedUsers(address[] memory _users) external {
        // Check for withdrawal-only shutdown as well as the pause
        if (withdrawalOnlyShutdown || externalSyncEarningPaused) revert ExternalSyncEarningPaused();

        // Sync normally first
        sync();

        // Loop through the users and sync them. Skip global sync() to save gas
        for (uint256 i = 0; i < _users.length; ) {
            _syncEarnedInner(_users[i]);

            unchecked {
                ++i;
            }
        }
    }

    /// @notice Sync contract-wide variables
    function sync() public {
        // Update rewardsPerTokenStored
        rewardsPerTokenStored = rewardPerToken();

        // Update the last update time
        lastUpdateTime = lastTimeRewardApplicable();
    }

    /// @notice Update the reward and balance state for a staker
    /// @param account The address of the user
    function _updateRewards(address account) internal {
        if (account != address(0)) {
            // Calculate the earnings first
            // Skip if we are in emergency shutdown
            if (!withdrawalOnlyShutdown) _syncEarned(account);
        }
    }

    /// @notice [MUST be proceeded by global sync()] Sync earnings for a specific staker. Skips the global sync() to save gas (mainly for bulkSyncEarnedUsers())
    /// @param _account The account to sync
    function _syncEarnedInner(address _account) internal {
        if (_account != address(0)) {
            // Calculate the earnings
            uint256[] memory _earneds = earned(_account);

            // Update the stake
            for (uint256 i = 0; i < rewardTokens.length; ) {
                rewards[_account][i] = _earneds[i];
                userRewardsPerTokenPaid[_account][i] = rewardsPerTokenStored[i];

                unchecked {
                    ++i;
                }
            }
        }
    }

    /// @notice Sync earnings for a specific staker
    /// @param _account The account to sync
    function _syncEarned(address _account) internal {
        // Update rewardsPerTokenStored and last update time
        sync();

        // Sync the account's earnings
        _syncEarnedInner(_account);
    }

    /// @notice Stake stakingToken for vault tokens
    /// @param _amount The amount of stakingToken
    function stake(uint256 _amount) public nonReentrant updateRewards(msg.sender) {
        // Do checks
        if (block.timestamp >= endingTimestamp) revert LockerHasEnded();
        if (stakingPaused) revert StakingPaused();
        if (stakesUnlocked) revert StakesAreUnlocked();
        if (withdrawalOnlyShutdown) revert OnlyWithdrawalsAllowed();
        if (_amount == 0) revert MustBeNonZero();
        if ((totalSupply() + _amount) > cap) revert Capped();

        // Pull the staking tokens from the msg.sender
        TransferHelper.safeTransferFrom(address(stakingToken), msg.sender, address(this), _amount);

        // Mint an equal amount of vault tokens to the staker
        _mint(msg.sender, _amount);

        // Update rewards
        _updateRewards(msg.sender);

        emit Stake(msg.sender, _amount, msg.sender);
    }

    /// @notice Withdraw stakingToken from vault tokens.
    /// @param _vaultTknAmount Amount of vault tokens to use
    /// @param _collectRewards Whether to also collect rewards
    function withdraw(
        uint256 _vaultTknAmount,
        bool _collectRewards
    ) public nonReentrant returns (uint256[] memory _rtnRewards) {
        if ((block.timestamp < endingTimestamp) && !(stakesUnlocked || withdrawalOnlyShutdown)) {
            revert LockerStillActive();
        }
        if (withdrawalsPaused) revert WithdrawalsPaused();

        // Burn the vault token from the sender
        _burn(msg.sender, _vaultTknAmount);

        // Give the stakingToken to the msg.sender
        // Should throw if insufficient balance
        TransferHelper.safeTransfer(address(stakingToken), msg.sender, _vaultTknAmount);

        // Collect rewards
        _rtnRewards = new uint256[](rewardTokens.length);
        if (_collectRewards) _rtnRewards = getReward(msg.sender);

        emit Withdrawal(msg.sender, _vaultTknAmount);
    }

    /// @notice Collect rewards
    /// @param _destinationAddress Destination address for the rewards
    /// @return _rtnRewards The amounts of collected reward tokens
    function getReward(
        address _destinationAddress
    ) public updateRewards(msg.sender) returns (uint256[] memory _rtnRewards) {
        // Make sure you are not in shutdown
        if (withdrawalOnlyShutdown) revert OnlyWithdrawalsAllowed();

        // Make sure reward collections are not paused
        if (rewardsCollectionPaused) revert RewardCollectionIsPaused();

        // Prepare the return variable
        _rtnRewards = new uint256[](rewardTokens.length);

        // Loop through the rewards
        for (uint256 i = 0; i < rewardTokens.length; ) {
            _rtnRewards[i] = rewards[msg.sender][i];

            // Do reward accounting
            if (_rtnRewards[i] > 0) {
                rewards[msg.sender][i] = 0;
                TransferHelper.safeTransfer(rewardTokens[i], _destinationAddress, _rtnRewards[i]);

                emit RewardPaid(msg.sender, _rtnRewards[i], rewardTokens[i], _destinationAddress);
            }

            unchecked {
                ++i;
            }
        }

        // Update the last reward claim time
        lastRewardClaimTime[msg.sender] = block.timestamp;
    }

    /// @notice Supply rewards. Only callable by whitelisted addresses.
    /// @param _amounts Amount of each reward token to add
    function notifyRewardAmounts(uint256[] memory _amounts) public {
        // Only the owner and the whitelisted addresses can notify rewards
        if (!((owner == msg.sender) || rewardNotifiers[msg.sender])) revert SenderNotOwnerOrRewarder();

        // Make sure the locker has not ended
        if (block.timestamp >= endingTimestamp) revert LockerHasEnded();

        // Pull in the reward tokens from the sender
        for (uint256 i = 0; i < rewardTokens.length; ) {
            // Handle the transfer of emission tokens via `transferFrom` to reduce the number
            // of transactions required and ensure correctness of the emission amount
            TransferHelper.safeTransferFrom(rewardTokens[i], msg.sender, address(this), _amounts[i]);

            unchecked {
                ++i;
            }
        }

        // Update rewardsPerTokenStored and last update time
        sync();

        // Calculate the reward rate
        for (uint256 i = 0; i < rewardTokens.length; ) {
            // Account for unemitted tokens
            uint256 remainingTime = periodFinish - block.timestamp;
            uint256 leftoverRwd = remainingTime * rewardRates[i];

            // Replace rewardsDuration with remainingTime here since we only have one big period
            // rewardRates[i] = (_amounts[i] + leftoverRwd) / rewardsDuration;
            rewardRates[i] = (_amounts[i] + leftoverRwd) / remainingTime;

            emit RewardAdded(rewardTokens[i], _amounts[i], rewardRates[i]);

            unchecked {
                ++i;
            }
        }

        // Update rewardsPerTokenStored and last update time (again)
        sync();
    }

    /* ========== RESTRICTED FUNCTIONS ========== */

    /// @notice Only settable to true
    function initiateWithdrawalOnlyShutdown() external onlyOwner {
        withdrawalOnlyShutdown = true;
    }

    /// @notice Increase the staking token cap. Can be increased only if more reward tokens are simultaneously provided, to keep the new rewardPerSecondPerToken >= old rewardPerSecondPerToken.
    /// @param _newCap The address of the token
    /// @param _addlRewTknAmounts The amount(s) of reward tokens being supplied as part of this cap increase.
    function increaseCapWithRewards(uint256 _newCap, uint256[] memory _addlRewTknAmounts) external onlyOwner {
        // Cap can only increase
        if (_newCap < cap) revert CapCanOnlyIncrease();

        // Sync first
        sync();

        // Fetch the calculated new rewardRates as well as the amount of additional tokens needed
        (uint256[] memory _minRewRates, uint256[] memory _minAddlTkns) = minAddlRewTknsForCapIncrease(_newCap);

        // Make sure enough reward tokens were supplied
        for (uint256 i = 0; i < rewardTokens.length; i++) {
            if (_addlRewTknAmounts[i] < _minAddlTkns[i]) revert NotEnoughAddlRewTkns();
        }

        // Increase the cap
        cap = _newCap;

        // Add in the new rewards
        notifyRewardAmounts(_addlRewTknAmounts);

        // Compare the new rewardRate with the calculated minimum
        // New must be >= old
        for (uint256 i = 0; i < rewardTokens.length; i++) {
            if (rewardRates[i] < _minRewRates[i]) {
                revert NotEnoughAddlRewTkns();
            }
        }
    }

    /// @notice Added to support recovering LP Rewards and other mistaken tokens from other systems to be distributed to holders
    /// @param _tokenAddress The address of the token
    /// @param _tokenAmount The amount of the token
    function recoverERC20(address _tokenAddress, uint256 _tokenAmount) external onlyOwner {
        // Only the owner address can ever receive the recovery withdrawal
        TransferHelper.safeTransfer(_tokenAddress, owner, _tokenAmount);

        emit Recovered(_tokenAddress, _tokenAmount);
    }

    /// @notice Toggle the ability to syncEarned externally via bulkSyncEarnedUsers
    function toggleExternalSyncEarning() external onlyOwner {
        externalSyncEarningPaused = !externalSyncEarningPaused;
    }

    /// @notice Toggle the ability to stake
    function toggleStaking() external onlyOwner {
        stakingPaused = !stakingPaused;
    }

    /// @notice Toggle the ability to collect rewards
    function toggleRewardsCollection() external onlyOwner {
        rewardsCollectionPaused = !rewardsCollectionPaused;
    }

    /// @notice Toggle an address as being able to be a reward notifier
    /// @param _notifierAddr The address to toggle
    function toggleRewardNotifier(address _notifierAddr) external onlyOwner {
        rewardNotifiers[_notifierAddr] = !rewardNotifiers[_notifierAddr];
    }

    /// @notice Toggle the ability to withdraw
    function toggleWithdrawals() external onlyOwner {
        withdrawalsPaused = !withdrawalsPaused;
    }

    /// @notice Unlock all stakes, in the case of an emergency
    function unlockStakes() external onlyOwner {
        stakesUnlocked = !stakesUnlocked;
    }

    /* ========== ERRORS ========== */

    /// @notice When you are trying to lower the cap, which is not allowed
    error CapCanOnlyIncrease();

    /// @notice When you are trying to lock more tokens than are allowed
    error Capped();

    /// @notice If syncEarned should only be callable indirectly through methods or internally. Also occurs if in a withdrawal-only shutdown
    error ExternalSyncEarningPaused();

    /// @notice If the locker ending timestamp has passed
    error LockerHasEnded();

    /// @notice If the locker ending timestamp has not yet passed
    error LockerStillActive();

    /// @notice If an input value must be non-zero
    error MustBeNonZero();

    /// @notice If only withdrawals are allowed
    error OnlyWithdrawalsAllowed();

    /// @notice If reward collections are paused
    error RewardCollectionIsPaused();

    /// @notice When the cap is increased, the rewardPerSecondPerToken must either increase or stay the same
    error NotEnoughAddlRewTkns();

    /// @notice If the sender is not the owner or a rewarder
    error SenderNotOwnerOrRewarder();

    /// @notice If staking has been paused
    error StakingPaused();

    /// @notice If you are trying to stake after stakes have been unlock
    error StakesAreUnlocked();

    /// @notice If you didn't acknowledge the notifyRewardAmounts sync warning
    error MustSyncAllUsersBeforeNotifying();

    /// @notice If withdrawals have been paused
    error WithdrawalsPaused();

    /* ========== EVENTS ========== */

    /// @notice When LP tokens are locked
    /// @param user The staker
    /// @param amount Amount of LP staked
    /// @param source_address The origin address of the LP tokens. Usually the same as the user unless there is a migration in progress
    event Stake(address indexed user, uint256 amount, address source_address);

    /// @notice When LP tokens are withdrawn
    /// @param user The staker
    /// @param amount Amount of LP withdrawn
    event Withdrawal(address indexed user, uint256 amount);

    /// @notice When tokens are recovered, in the case of an emergency
    /// @param token Address of the token
    /// @param amount Amount of the recovered tokens
    event Recovered(address token, uint256 amount);

    /// @notice When a reward is deposited
    /// @param reward_address The address of the reward token
    /// @param reward Amount of tokens deposited
    /// @param yieldRate The resultant yield/emission rate
    event RewardAdded(address indexed reward_address, uint256 reward, uint256 yieldRate);

    /// @notice When a staker collects rewards
    /// @param user The staker
    /// @param reward Amount of reward tokens
    /// @param token_address Address of the reward token
    /// @param destination_address Destination address of the reward tokens
    event RewardPaid(address indexed user, uint256 reward, address token_address, address destination_address);
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_owner","type":"address"},{"internalType":"address[]","name":"_rewardTokens","type":"address[]"},{"internalType":"address","name":"_stakingToken","type":"address"},{"internalType":"string","name":"_name","type":"string"},{"internalType":"string","name":"_symbol","type":"string"},{"internalType":"uint256","name":"_endingTimestamp","type":"uint256"},{"internalType":"uint256","name":"_cap","type":"uint256"},{"internalType":"address","name":"_extraNotifier","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"CapCanOnlyIncrease","type":"error"},{"inputs":[],"name":"Capped","type":"error"},{"inputs":[],"name":"ExternalSyncEarningPaused","type":"error"},{"inputs":[],"name":"InvalidOwnershipAcceptance","type":"error"},{"inputs":[],"name":"LockerHasEnded","type":"error"},{"inputs":[],"name":"LockerStillActive","type":"error"},{"inputs":[],"name":"MustBeNonZero","type":"error"},{"inputs":[],"name":"MustSyncAllUsersBeforeNotifying","type":"error"},{"inputs":[],"name":"NotEnoughAddlRewTkns","type":"error"},{"inputs":[],"name":"OnlyOwner","type":"error"},{"inputs":[],"name":"OnlyWithdrawalsAllowed","type":"error"},{"inputs":[],"name":"OwnerCannotBeZero","type":"error"},{"inputs":[],"name":"RewardCollectionIsPaused","type":"error"},{"inputs":[],"name":"SenderNotOwnerOrRewarder","type":"error"},{"inputs":[],"name":"StakesAreUnlocked","type":"error"},{"inputs":[],"name":"StakingPaused","type":"error"},{"inputs":[],"name":"TransferHelperTransferFailed","type":"error"},{"inputs":[],"name":"TransferHelperTransferFromFailed","type":"error"},{"inputs":[],"name":"WithdrawalsPaused","type":"error"},{"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":false,"internalType":"address","name":"oldOwner","type":"address"},{"indexed":false,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnerChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnerNominated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"token","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Recovered","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"reward_address","type":"address"},{"indexed":false,"internalType":"uint256","name":"reward","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"yieldRate","type":"uint256"}],"name":"RewardAdded","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"reward","type":"uint256"},{"indexed":false,"internalType":"address","name":"token_address","type":"address"},{"indexed":false,"internalType":"address","name":"destination_address","type":"address"}],"name":"RewardPaid","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"address","name":"source_address","type":"address"}],"name":"Stake","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":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Withdrawal","type":"event"},{"inputs":[],"name":"acceptOwnership","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":[{"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":"availableToLock","outputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"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":"address[]","name":"_users","type":"address[]"}],"name":"bulkSyncEarnedUsers","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"cap","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":[],"name":"deployTimestamp","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_account","type":"address"}],"name":"earned","outputs":[{"internalType":"uint256[]","name":"_rtnEarned","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"endingTimestamp","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"externalSyncEarningPaused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_destinationAddress","type":"address"}],"name":"getReward","outputs":[{"internalType":"uint256[]","name":"_rtnRewards","type":"uint256[]"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"getRewardsRemaining","outputs":[{"internalType":"uint256[]","name":"_rtnRewardsRemaining","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":"uint256","name":"_newCap","type":"uint256"},{"internalType":"uint256[]","name":"_addlRewTknAmounts","type":"uint256[]"}],"name":"increaseCapWithRewards","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"initiateWithdrawalOnlyShutdown","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"isRewardToken","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"lastRewardClaimTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lastRewardPull","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lastUpdateTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_newCap","type":"uint256"}],"name":"minAddlRewTknsForCapIncrease","outputs":[{"internalType":"uint256[]","name":"_minRewRates","type":"uint256[]"},{"internalType":"uint256[]","name":"_minAddlTkns","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_owner","type":"address"}],"name":"nominateNewOwner","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"nominatedOwner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"_amounts","type":"uint256[]"}],"name":"notifyRewardAmounts","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"periodFinish","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_tokenAddress","type":"address"},{"internalType":"uint256","name":"_tokenAmount","type":"uint256"}],"name":"recoverERC20","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"rewardNotifiers","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rewardPerToken","outputs":[{"internalType":"uint256[]","name":"_rtnRewardsPerTokenStored","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"rewardRates","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"rewardTokenAddrToIdx","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"rewardTokens","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"}],"name":"rewards","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rewardsCollectionPaused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rewardsDuration","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"rewardsPerTokenStored","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"stake","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"stakesUnlocked","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"stakingPaused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"stakingToken","outputs":[{"internalType":"contract ERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"sync","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"toggleExternalSyncEarning","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_notifierAddr","type":"address"}],"name":"toggleRewardNotifier","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"toggleRewardsCollection","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"toggleStaking","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"toggleWithdrawals","outputs":[],"stateMutability":"nonpayable","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":"unlockStakes","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"}],"name":"userRewardsPerTokenPaid","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_vaultTknAmount","type":"uint256"},{"internalType":"bool","name":"_collectRewards","type":"bool"}],"name":"withdraw","outputs":[{"internalType":"uint256[]","name":"_rtnRewards","type":"uint256[]"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdrawalOnlyShutdown","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"withdrawalsPaused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"}]

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

33839:26232:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;43107:664;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;46161:544;;;;;;:::i;:::-;;:::i;:::-;;21938:100;;;:::i;:::-;;;;;;;:::i;24289:201::-;;;;;;:::i;:::-;;:::i;:::-;;;3662:14:1;;3655:22;3637:41;;3625:2;3610:18;24289:201:0;3497:187:1;54237:1110:0;;;;;;:::i;:::-;;:::i;16128:141::-;;;;;;:::i;:::-;;:::i;23058:108::-;23146:12;;23058:108;;;5030:25:1;;;5018:2;5003:18;23058:108:0;4884:177:1;25070:295:0;;;;;;:::i;:::-;;:::i;22900:93::-;;;22983:2;5587:36:1;;5575:2;5560:18;22900:93:0;5445:184:1;36696:35:0;;;;;;;;;;;;34433:18;;;;;;35164:40;;;;;49598:870;;;;;;:::i;:::-;;:::i;25774:238::-;;;;;;:::i;:::-;;:::i;56168:93::-;;;:::i;56580:155::-;;;;;;:::i;:::-;;:::i;40084:115::-;;;:::i;40907:1019::-;;;;;;:::i;:::-;;:::i;:::-;;;;;;;;:::i;43904:691::-;;;:::i;15838:29::-;;;;;;;;;;;;7000:42:1;6988:55;;;6970:74;;6958:2;6943:18;15838:29:0;6824:226:1;36600:37:0;;;;;;;;;34158:40;;;;;34071;;;;;36312:78;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;35470:38;;;;;;:::i;:::-;;:::i;53766:109::-;;;:::i;35686:55::-;;;;;;:::i;:::-;;;;;;;;;;;;;;35977:54;;;;;;:::i;:::-;;;;;;;;;;;;;;34796:29;;;;;;23229:127;;;;;;:::i;:::-;23330:18;;23303:7;23330:18;;;;;;;;;;;;23229:127;34500:25;;;;;;;;;16277:354;;;:::i;56324:123::-;;;:::i;35798:29::-;;;;;;:::i;:::-;;:::i;55593:300::-;;;;;;:::i;:::-;;:::i;37324:34::-;;;;;;;;;;;;15811:20;;;;;;;;;22157:104;;;:::i;51956:1707::-;;;;;;:::i;:::-;;:::i;36892:26::-;;;;;;;;;;;;26515:436;;;;;;:::i;:::-;;:::i;48548:858::-;;;;;;:::i;:::-;;:::i;23562:193::-;;;;;;:::i;:::-;;:::i;34690:45::-;;;;;;:::i;:::-;;;;;;;;;;;;;;;;36140:62;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;36778:25;;;;;;;;;;;;50649:1166;;;;;;:::i;:::-;;:::i;34891:29::-;;;;;;42073:824;;;:::i;35293:47::-;;;;;;:::i;:::-;;;;;;;;;;;;;;;;56791:105;;;:::i;23818:151::-;;;;;;:::i;:::-;23934:18;;;;23907:7;23934:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;23818:151;55986:129;;;:::i;56968:94::-;;;:::i;37410:29::-;;;;;;;;;;;;35015:37;;;;;35563:28;;;;;;:::i;:::-;;:::i;46759:219::-;;;:::i;43107:664::-;43269:12;:19;43162:27;;43255:34;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;43255:34:0;;43242:47;;43344:36;43383:16;:14;:16::i;:::-;43344:55;;43460:9;43455:309;43479:12;:19;43475:23;;43455:309;;;43641:33;;;;;;;:23;:33;;;;;;;;:36;;;;;;;;;43616:22;;43683:4;;43641:36;43616:19;;43675:1;;43616:22;;;;;;:::i;:::-;;;;;;;:61;;;;:::i;:::-;23330:18;;;23303:7;23330:18;;;;;;;;;;;43592:87;;;;:::i;:::-;43591:96;;;;:::i;:::-;43550:17;;;;;;;:7;:17;;;;;;;;:20;;;;;;;;;:138;;;;:::i;:::-;43517:10;43528:1;43517:13;;;;;;;;:::i;:::-;;;;;;;;;;:171;43734:3;;43455:309;;;;43191:580;43107:664;;;:::o;46161:544::-;46307:22;;;;;;;;:51;;-1:-1:-1;46333:25:0;;;;46307:51;46303:91;;;46367:27;;;;;;;;;;;;;;46303:91;46439:6;:4;:6::i;:::-;46544:9;46539:159;46563:6;:13;46559:1;:17;46539:159;;;46595:27;46612:6;46619:1;46612:9;;;;;;;;:::i;:::-;;;;;;;46595:16;:27::i;:::-;46668:3;;46539:159;;;;46161:544;:::o;21938:100::-;21992:13;22025:5;22018:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;21938:100;:::o;24289:201::-;24372:4;6407:10;24428:32;6407:10;24444:7;24453:6;24428:8;:32::i;:::-;24478:4;24471:11;;;24289:201;;;;;:::o;54237:1110::-;16782:5;;;;16768:10;:19;16764:43;;16796:11;;;;;;;;;;;;;;16764:43;54401:3:::1;;54391:7;:13;54387:46;;;54413:20;;;;;;;;;;;;;;54387:46;54469:6;:4;:6::i;:::-;54588:29;54619::::0;54652:37:::1;54681:7;54652:28;:37::i;:::-;54587:102;;;;54764:9;54759:151;54783:12;:19:::0;54779:23;::::1;54759:151;;;54852:12;54865:1;54852:15;;;;;;;;:::i;:::-;;;;;;;54828:18;54847:1;54828:21;;;;;;;;:::i;:::-;;;;;;;:39;54824:74;;;54876:22;;;;;;;;;;;;;;54824:74;54804:3;;54759:151;;;-1:-1:-1::0;54951:3:0::1;:13:::0;;;55012:39:::1;55032:18:::0;55012:19:::1;:39::i;:::-;55167:9;55162:178;55186:12;:19:::0;55182:23;::::1;55162:178;;;55248:12;55261:1;55248:15;;;;;;;;:::i;:::-;;;;;;;55231:11;55243:1;55231:14;;;;;;;;:::i;:::-;;;;;;;;;:32;55227:102;;;55291:22;;;;;;;;;;;;;;55227:102;55207:3;;55162:178;;;;54342:1005;;54237:1110:::0;;:::o;16128:141::-;16782:5;;;;16768:10;:19;16764:43;;16796:11;;;;;;;;;;;;;;16764:43;16200:14:::1;:23:::0;;;::::1;;::::0;::::1;::::0;;::::1;::::0;;;16239:22:::1;::::0;6970:74:1;;;16239:22:0::1;::::0;6958:2:1;6943:18;16239:22:0::1;;;;;;;16128:141:::0;:::o;25070:295::-;25201:4;6407:10;25259:38;25275:4;6407:10;25290:6;25259:15;:38::i;:::-;25308:27;25318:4;25324:2;25328:6;25308:9;:27::i;:::-;-1:-1:-1;25353:4:0;;25070:295;-1:-1:-1;;;;25070:295:0:o;49598:870::-;49717:28;1866:1;2464:7;;:19;2456:63;;;;;;;9655:2:1;2456:63:0;;;9637:21:1;9694:2;9674:18;;;9667:30;9733:33;9713:18;;;9706:61;9784:18;;2456:63:0;;;;;;;;;1866:1;2597:7;:18;49781:15:::1;49763;:33;49762:82:::0;::::1;;;-1:-1:-1::0;49803:14:0::1;::::0;;;::::1;;;::::0;:40:::1;;-1:-1:-1::0;49821:22:0::1;::::0;;;::::1;;;49803:40;49801:43;49762:82;49758:141;;;49868:19;;;;;;;;;;;;;;49758:141;49913:17;::::0;;;::::1;;;49909:49;;;49939:19;;;;;;;;;;;;;;49909:49;50020:34;50026:10;50038:15;50020:5;:34::i;:::-;50204:12;::::0;50168:79:::1;::::0;50204:12:::1;;50219:10;50231:15:::0;50168:27:::1;:79::i;:::-;50316:12;:19:::0;50302:34:::1;::::0;::::1;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;-1:-1:-1;50302:34:0::1;;50288:48;;50351:15;50347:56;;;50382:21;50392:10;50382:9;:21::i;:::-;50368:35;;50347:56;50421:39;::::0;5030:25:1;;;50432:10:0::1;::::0;50421:39:::1;::::0;5018:2:1;5003:18;50421:39:0::1;;;;;;;1822:1:::0;2776:7;:22;49598:870;;-1:-1:-1;;49598:870:0:o;25774:238::-;6407:10;25862:4;23934:18;;;:11;:18;;;;;;;;;:27;;;;;;;;;;25862:4;;6407:10;25918:64;;6407:10;;23934:27;;25943:38;;25971:10;;25943:38;:::i;:::-;25918:8;:64::i;56168:93::-;16782:5;;;;16768:10;:19;16764:43;;16796:11;;;;;;;;;;;;;;16764:43;56240:13:::1;::::0;;56223:30;;::::1;56240:13:::0;;;;::::1;;;56239:14;56223:30:::0;;::::1;;::::0;;56168:93::o;56580:155::-;16782:5;;;;16768:10;:19;16764:43;;16796:11;;;;;;;;;;;;;;16764:43;56697:30:::1;;;::::0;;;:15:::1;:30;::::0;;;;;;56663:64;;::::1;56697:30;::::0;;::::1;56696:31;56663:64;::::0;;56580:155::o;40084:115::-;40132:15;40177:13;23146:12;;;23058:108;40177:13;40171:3;;:19;;;;:::i;:::-;40160:31;;40084:115;:::o;40907:1019::-;40999:29;41030;41120:3;;41110:7;:13;41106:46;;;41132:20;;;;;;;;;;;;;;41106:46;41231:12;:19;41217:34;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;41217:34:0;-1:-1:-1;41291:12:0;:19;41202:49;;-1:-1:-1;41277:34:0;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;41277:34:0;-1:-1:-1;41262:49:0;-1:-1:-1;41362:17:0;41382:33;41400:15;41382;:33;:::i;:::-;41362:53;;41476:9;41471:448;41495:12;:19;41491:23;;41471:448;;;41704:3;;41688:7;41671:11;41683:1;41671:14;;;;;;;;:::i;:::-;;;;;;;;;:24;;;;:::i;:::-;41670:30;;41699:1;41670:30;:::i;:::-;41669:38;;;;:::i;:::-;41651:12;41664:1;41651:15;;;;;;;;:::i;:::-;;;;;;:56;;;;;41828:11;41840:1;41828:14;;;;;;;;:::i;:::-;;;;;;;;;41810:12;41823:1;41810:15;;;;;;;;:::i;:::-;;;;;;;:32;;;;:::i;:::-;41797:46;;:9;:46;:::i;:::-;41779:12;41792:1;41779:15;;;;;;;;:::i;:::-;;;;;;;;;;:64;41889:3;;41471:448;;;;41061:865;40907:1019;;;:::o;43904:691::-;44085:12;:19;43958:37;;44071:34;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;44071:34:0;;44048:57;;44194:15;44175;:34;44171:67;;43904:691;:::o;44171:67::-;44289:17;44309:33;44327:15;44309;:33;:::i;:::-;44289:53;;44403:9;44398:190;44422:12;:19;44418:23;;44398:190;;;44503:9;44486:11;44498:1;44486:14;;;;;;;;:::i;:::-;;;;;;;;;:26;;;;:::i;:::-;44460:20;44481:1;44460:23;;;;;;;;:::i;:::-;;;;;;;;;;:52;44558:3;;44398:190;;;;43997:598;43904:691;:::o;35470:38::-;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;35470:38:0;:::o;53766:109::-;16782:5;;;;16768:10;:19;16764:43;;16796:11;;;;;;;;;;;;;;16764:43;53838:22:::1;:29:::0;;;::::1;::::0;::::1;::::0;;53766:109::o;16277:354::-;16450:14;;;;16436:10;:28;16432:69;;16473:28;;;;;;;;;;;;;;16432:69;16530:5;;16537:14;;16517:35;;;16530:5;;;;9987:74:1;;16537:14:0;;;;10092:2:1;10077:18;;10070:83;16517:35:0;;9960:18:1;16517:35:0;;;;;;;16571:14;;;16563:5;:22;;;;;;16571:14;;;16563:22;;;;16596:27;;;16277:354::o;56324:123::-;16782:5;;;;16768:10;:19;16764:43;;16796:11;;;;;;;;;;;;;;16764:43;56416:23:::1;::::0;;56389:50;;::::1;56416:23;::::0;;;::::1;;;56415:24;56389:50:::0;;::::1;;::::0;;56324:123::o;35798:29::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;35798:29:0;:::o;55593:300::-;16782:5;;;;16768:10;:19;16764:43;;16796:11;;;;;;;;;;;;;;16764:43;55809:5:::1;::::0;55766:63:::1;::::0;55794:13;;55809:5:::1;;55816:12:::0;55766:27:::1;:63::i;:::-;55847:38;::::0;;10368:42:1;10356:55;;10338:74;;10443:2;10428:18;;10421:34;;;55847:38:0::1;::::0;10311:18:1;55847:38:0::1;;;;;;;55593:300:::0;;:::o;22157:104::-;22213:13;22246:7;22239:14;;;;;:::i;51956:1707::-;52113:5;;:19;:5;52122:10;52113:19;;52112:52;;-1:-1:-1;52153:10:0;52137:27;;;;:15;:27;;;;;;;;52112:52;52106:94;;52174:26;;;;;;;;;;;;;;52106:94;52283:15;52264;:34;52260:63;;52307:16;;;;;;;;;;;;;;52260:63;52395:9;52390:408;52414:12;:19;52410:23;;52390:408;;;52634:88;52666:12;52679:1;52666:15;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;52683:10;52703:4;52710:8;52719:1;52710:11;;;;;;;;:::i;:::-;;;;;;;52634:31;:88::i;:::-;52768:3;;52390:408;;;;52872:6;:4;:6::i;:::-;52934:9;52929:638;52953:12;:19;52949:23;;52929:638;;;53036:21;53060:30;53075:15;53060:12;:30;:::i;:::-;53036:54;;53105:19;53143:11;53155:1;53143:14;;;;;;;;:::i;:::-;;;;;;;;;53127:13;:30;;;;:::i;:::-;53105:52;;53399:13;53384:11;53370:8;53379:1;53370:11;;;;;;;;:::i;:::-;;;;;;;:25;;;;:::i;:::-;53369:43;;;;:::i;:::-;53352:11;53364:1;53352:14;;;;;;;;:::i;:::-;;;;;;;;:60;;;;53446:12;53459:1;53446:15;;;;;;;;:::i;:::-;;;;;;;;;;;53463:11;;53446:15;;;;;53434:57;;53463:8;;53472:1;;53463:11;;;;;;:::i;:::-;;;;;;;53476;53488:1;53476:14;;;;;;;;:::i;:::-;;;;;;;;;;;;53434:57;;;10640:25:1;;;10681:18;;;10674:34;10613:18;53434:57:0;;;;;;;-1:-1:-1;;53537:3:0;;52929:638;;;;53649:6;:4;:6::i;:::-;51956:1707;:::o;26515:436::-;6407:10;26608:4;23934:18;;;:11;:18;;;;;;;;;:27;;;;;;;;;;26608:4;;6407:10;26755:15;26735:16;:35;;26727:85;;;;;;;10921:2:1;26727:85:0;;;10903:21:1;10960:2;10940:18;;;10933:30;10999:34;10979:18;;;10972:62;11070:7;11050:18;;;11043:35;11095:19;;26727:85:0;10719:401:1;26727:85:0;26848:60;26857:5;26864:7;26892:15;26873:16;:34;26848:8;:60::i;48548:858::-;1866:1;2464:7;;:19;2456:63;;;;;;;9655:2:1;2456:63:0;;;9637:21:1;9694:2;9674:18;;;9667:30;9733:33;9713:18;;;9706:61;9784:18;;2456:63:0;9453:355:1;2456:63:0;1866:1;2597:7;:18;48614:10:::1;39870:23;48614:10:::0;39870:14:::1;:23::i;:::-;48682:15:::2;48663;:34;48659:63;;48706:16;;;;;;;;;;;;;;48659:63;48737:13;::::0;;;::::2;;;48733:41;;;48759:15;;;;;;;;;;;;;;48733:41;48789:14;::::0;;;::::2;;;48785:46;;;48812:19;;;;;;;;;;;;;;48785:46;48846:22;::::0;;;::::2;;;48842:59;;;48877:24;;;;;;;;;;;;;;48842:59;48916:7;48927:1;48916:12:::0;48912:40:::2;;48937:15;;;;;;;;;;;;;;48912:40;48995:3;;48984:7;48968:13;23146:12:::0;;;23058:108;48968:13:::2;:23;;;;:::i;:::-;48967:31;48963:52;;;49007:8;;;;;;;;;;;;;;48963:52;49124:12;::::0;49084:90:::2;::::0;49124:12:::2;;49139:10;49159:4;49166:7:::0;49084:31:::2;:90::i;:::-;49250:26;49256:10;49268:7;49250:5;:26::i;:::-;49316;49331:10;49316:14;:26::i;:::-;49360:38;::::0;;11299:25:1;;;49366:10:0::2;11355:2:1::0;11340:18;;11333:83;;;49366:10:0;49360:38:::2;::::0;11272:18:1;49360:38:0::2;;;;;;;-1:-1:-1::0;;1822:1:0;2776:7;:22;48548:858::o;23562:193::-;23641:4;6407:10;23697:28;6407:10;23714:2;23718:6;23697:9;:28::i;50649:1166::-;50755:28;50734:10;39870:23;39885:7;39870:14;:23::i;:::-;50846:22:::1;::::0;;;::::1;;;50842:59;;;50877:24;;;;;;;;;;;;;;50842:59;50974:23;::::0;::::1;::::0;::::1;;;50970:62;;;51006:26;;;;;;;;;;;;;;50970:62;51113:12;:19:::0;51099:34:::1;::::0;::::1;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;-1:-1:-1;51099:34:0::1;;51085:48;;51188:9;51183:517;51207:12;:19:::0;51203:23;::::1;51183:517;;;51270:10;51262:19;::::0;;;:7:::1;:19;::::0;;;;;;;:22;;;;;;;;;51245:14;;:11;;51282:1;;51245:14;::::1;;;;;:::i;:::-;;;;;;:39;;;::::0;::::1;51359:1;51342:11;51354:1;51342:14;;;;;;;;:::i;:::-;;;;;;;:18;51338:287;;;51389:10;51406:1;51381:19:::0;;;:7:::1;:19;::::0;;;;;;;:22;;;;;;;;:26;51454:12:::1;:15:::0;;51426:81:::1;::::0;51454:12;51401:1;;51454:15;::::1;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;51471:19;51492:11;51504:1;51492:14;;;;;;;;:::i;:::-;;;;;;;51426:27;:81::i;:::-;51544:10;51533:76;;;51556:11;51568:1;51556:14;;;;;;;;:::i;:::-;;;;;;;51572:12;51585:1;51572:15;;;;;;;;:::i;:::-;;::::0;;;::::1;::::0;;;;::::1;::::0;51533:76:::1;::::0;;11629:25:1;;;51572:15:0::1;::::0;;::::1;11670:18:1::0;;;11663:83;;;;11782:55;;11762:18;;;11755:83;11617:2;11602:18;51533:76:0::1;;;;;;;51338:287;51670:3;;51183:517;;;-1:-1:-1::0;;51778:10:0::1;51758:31;::::0;;;:19:::1;:31;::::0;;;;51792:15:::1;51758:49:::0;;50649:1166;;-1:-1:-1;50649:1166:0:o;42073:824::-;42257:12;:19;42120:42;;42243:34;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;42243:34:0;;42215:62;;42316:13;23146:12;;;23058:108;42316:13;42333:1;42316:18;42312:578;;42433:21;42405:49;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;42073:824;:::o;42312:578::-;42539:9;42534:345;42558:12;:19;42554:23;;42534:345;;;23146:12;;42750:11;42762:1;42750:14;;;;;;;;:::i;:::-;;;;;;;;;42732;;42703:26;:24;:26::i;:::-;:43;;;;:::i;:::-;42702:62;;;;:::i;:::-;:69;;42767:4;42702:69;:::i;:::-;42701:87;;;;:::i;:::-;42652:21;42674:1;42652:24;;;;;;;;:::i;:::-;;;;;;;;;:137;;;;:::i;:::-;42600:25;42626:1;42600:28;;;;;;;;:::i;:::-;;;;;;;;;;:189;42841:3;;42534:345;;;;42073:824;:::o;56791:105::-;16782:5;;;;16768:10;:19;16764:43;;16796:11;;;;;;;;;;;;;;16764:43;56871:17:::1;::::0;;56850:38;;::::1;56871:17:::0;;;;::::1;;;56870:18;56850:38:::0;;::::1;;::::0;;56791:105::o;55986:129::-;16782:5;;;;16768:10;:19;16764:43;;16796:11;;;;;;;;;;;;;;16764:43;56082:25:::1;::::0;;56053:54;;::::1;56082:25;::::0;;::::1;56081:26;56053:54;::::0;;55986:129::o;56968:94::-;16782:5;;;;16768:10;:19;16764:43;;16796:11;;;;;;;;;;;;;;16764:43;57040:14:::1;::::0;;57022:32;;::::1;57040:14:::0;;;;::::1;;;57039:15;57022:32:::0;;::::1;;::::0;;56968:94::o;35563:28::-;;;;;;;;;;;;46759:219;46858:16;:14;:16::i;:::-;46834:40;;;;:21;;:40;;;;;;:::i;:::-;;46944:26;:24;:26::i;:::-;46927:14;:43;46759:219::o;47584:532::-;47652:22;;;;47648:461;;47730:25;47758:16;47765:8;47758:6;:16::i;:::-;47730:44;;47829:9;47824:274;47848:12;:19;47844:23;;47824:274;;;47913:8;47922:1;47913:11;;;;;;;;:::i;:::-;;;;;;;;;;;;47890:17;;;;;;;:7;:17;;;;;;:20;;;;;;;;;;:34;47982:21;:24;;47908:1;;47982:24;;;;;;:::i;:::-;;;;;;;;;;;;;47943:33;;;;;:23;:33;;;;;;:36;;;;;;;;:63;48060:3;;47824:274;;;;47676:433;47584:532;:::o;30140:380::-;30276:19;;;30268:68;;;;;;;12051:2:1;30268:68:0;;;12033:21:1;12090:2;12070:18;;;12063:30;12129:34;12109:18;;;12102:62;12200:6;12180:18;;;12173:34;12224:19;;30268:68:0;11849:400:1;30268:68:0;30355:21;;;30347:68;;;;;;;12456:2:1;30347:68:0;;;12438:21:1;12495:2;12475:18;;;12468:30;12534:34;12514:18;;;12507:62;12605:4;12585:18;;;12578:32;12627:19;;30347:68:0;12254:398:1;30347:68:0;30428:18;;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;:36;;;30480:32;;5030:25:1;;;30480:32:0;;5003:18:1;30480:32:0;;;;;;;30140:380;;;:::o;30811:453::-;23934:18;;;;30946:24;23934:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;31033:17;31013:37;;31009:248;;31095:6;31075:16;:26;;31067:68;;;;;;;12859:2:1;31067:68:0;;;12841:21:1;12898:2;12878:18;;;12871:30;12937:31;12917:18;;;12910:59;12986:18;;31067:68:0;12657:353:1;31067:68:0;31179:51;31188:5;31195:7;31223:6;31204:16;:25;31179:8;:51::i;:::-;30935:329;30811:453;;;:::o;27421:671::-;27552:18;;;27544:68;;;;;;;13217:2:1;27544:68:0;;;13199:21:1;13256:2;13236:18;;;13229:30;13295:34;13275:18;;;13268:62;13366:7;13346:18;;;13339:35;13391:19;;27544:68:0;13015:401:1;27544:68:0;27631:16;;;27623:64;;;;;;;13623:2:1;27623:64:0;;;13605:21:1;13662:2;13642:18;;;13635:30;13701:34;13681:18;;;13674:62;13772:5;13752:18;;;13745:33;13795:19;;27623:64:0;13421:399:1;27623:64:0;27700:38;27721:4;27727:2;27731:6;27700:20;:38::i;:::-;27773:15;;;27751:19;27773:15;;;;;;;;;;;27807:21;;;;27799:72;;;;;;;14027:2:1;27799:72:0;;;14009:21:1;14066:2;14046:18;;;14039:30;14105:34;14085:18;;;14078:62;14176:8;14156:18;;;14149:36;14202:19;;27799:72:0;13825:402:1;27799:72:0;27907:15;;;;:9;:15;;;;;;;;;;;27925:20;;;27907:38;;27967:13;;;;;;;;:23;;27939:6;;27907:9;27967:23;;27939:6;;27967:23;:::i;:::-;;;;;;;;28023:2;28008:26;;28017:4;28008:26;;;28027:6;28008:26;;;;5030:25:1;;5018:2;5003:18;;4884:177;28008:26:0;;;;;;;;28047:37;47584:532;29111:591;29195:21;;;29187:67;;;;;;;14434:2:1;29187:67:0;;;14416:21:1;14473:2;14453:18;;;14446:30;14512:34;14492:18;;;14485:62;14583:3;14563:18;;;14556:31;14604:19;;29187:67:0;14232:397:1;29187:67:0;29267:49;29288:7;29305:1;29309:6;29267:20;:49::i;:::-;29354:18;;;29329:22;29354:18;;;;;;;;;;;29391:24;;;;29383:71;;;;;;;14836:2:1;29383:71:0;;;14818:21:1;14875:2;14855:18;;;14848:30;14914:34;14894:18;;;14887:62;14985:4;14965:18;;;14958:32;15007:19;;29383:71:0;14634:398:1;29383:71:0;29490:18;;;:9;:18;;;;;;;;;;29511:23;;;29490:44;;29556:12;:22;;29528:6;;29490:9;29556:22;;29528:6;;29556:22;:::i;:::-;;;;-1:-1:-1;;29596:37:0;;5030:25:1;;;29622:1:0;;29596:37;;;;;;5018:2:1;5003:18;29596:37:0;;;;;;;47824:274;47676:433;47584:532;:::o;17811:480::-;18009:45;;;17998:10;10356:55:1;;;18009:45:0;;;10338:74:1;10428:18;;;;10421:34;;;18009:45:0;;;;;;;;;;10311:18:1;;;;18009:45:0;;;;;;;;;;;;;17998:57;;-1:-1:-1;;;;17998:10:0;;;;:57;;18009:45;17998:57;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;17962:93;;;;18186:7;18185:8;:59;;;-1:-1:-1;18198:11:0;;:16;;;;:45;;;18230:4;18219:24;;;;;;;;;;;;:::i;:::-;18218:25;18198:45;18181:102;;;18253:30;;;;;;;;;;;;;;18299:525;18527:51;;;18516:10;15813:55:1;;;18527:51:0;;;15795:74:1;15905:55;;;15885:18;;;15878:83;15977:18;;;;15970:34;;;18527:51:0;;;;;;;;;;15768:18:1;;;;18527:51:0;;;;;;;;;;;;;18516:63;;-1:-1:-1;;;;18516:10:0;;;;:63;;18527:51;18516:63;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;18480:99;;;;18715:7;18714:8;:59;;;-1:-1:-1;18727:11:0;;:16;;;;:45;;;18759:4;18748:24;;;;;;;;;;;;:::i;:::-;18747:25;18727:45;18710:106;;;18782:34;;;;;;;;;;;;;;18710:106;18390:434;;18299:525;;;;:::o;47100:269::-;47165:21;;;;47161:201;;47306:22;;;;;;;47301:49;;47330:20;47342:7;47330:11;:20::i;28379:399::-;28463:21;;;28455:65;;;;;;;16217:2:1;28455:65:0;;;16199:21:1;16256:2;16236:18;;;16229:30;16295:33;16275:18;;;16268:61;16346:18;;28455:65:0;16015:355:1;28455:65:0;28533:49;28562:1;28566:7;28575:6;28533:20;:49::i;:::-;28611:6;28595:12;;:22;;;;;;;:::i;:::-;;;;-1:-1:-1;;28628:18:0;;;:9;:18;;;;;;;;;;:28;;28650:6;;28628:9;:28;;28650:6;;28628:28;:::i;:::-;;;;-1:-1:-1;;28672:37:0;;5030:25:1;;;28672:37:0;;;;28689:1;;28672:37;;5018:2:1;5003:18;28672:37:0;;;;;;;46539:159;46161:544;:::o;40414:133::-;40473:7;40500:39;40509:15;40526:12;40500:8;:39::i;45334:597::-;45771:22;;;;;;;45770:23;:47;;;;-1:-1:-1;45798:18:0;;;;;45770:47;45766:158;;;45834:6;:4;:6::i;:::-;45855:22;45872:4;45855:16;:22::i;:::-;45892:20;45909:2;45892:16;:20::i;48222:214::-;48343:6;:4;:6::i;:::-;48402:26;48419:8;48402:16;:26::i;7158:106::-;7216:7;7247:1;7243;:5;:13;;7255:1;7243:13;;;7251:1;7243:13;7236:20;7158:106;-1:-1:-1;;;7158:106:0:o;-1:-1:-1:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14:196:1;82:20;;142:42;131:54;;121:65;;111:93;;200:1;197;190:12;111:93;14:196;;;:::o;215:186::-;274:6;327:2;315:9;306:7;302:23;298:32;295:52;;;343:1;340;333:12;295:52;366:29;385:9;366:29;:::i;406:420::-;459:3;497:5;491:12;524:6;519:3;512:19;556:4;551:3;547:14;540:21;;595:4;588:5;584:16;618:1;628:173;642:6;639:1;636:13;628:173;;;703:13;;691:26;;746:4;737:14;;;;774:17;;;;664:1;657:9;628:173;;;-1:-1:-1;817:3:1;;406:420;-1:-1:-1;;;;406:420:1:o;831:261::-;1010:2;999:9;992:21;973:4;1030:56;1082:2;1071:9;1067:18;1059:6;1030:56;:::i;1097:184::-;1149:77;1146:1;1139:88;1246:4;1243:1;1236:15;1270:4;1267:1;1260:15;1286:334;1357:2;1351:9;1413:2;1403:13;;1418:66;1399:86;1387:99;;1516:18;1501:34;;1537:22;;;1498:62;1495:88;;;1563:18;;:::i;:::-;1599:2;1592:22;1286:334;;-1:-1:-1;1286:334:1:o;1625:183::-;1685:4;1718:18;1710:6;1707:30;1704:56;;;1740:18;;:::i;:::-;-1:-1:-1;1785:1:1;1781:14;1797:4;1777:25;;1625:183::o;1813:892::-;1897:6;1950:2;1938:9;1929:7;1925:23;1921:32;1918:52;;;1966:1;1963;1956:12;1918:52;2006:9;1993:23;2039:18;2031:6;2028:30;2025:50;;;2071:1;2068;2061:12;2025:50;2094:22;;2147:4;2139:13;;2135:27;-1:-1:-1;2125:55:1;;2176:1;2173;2166:12;2125:55;2216:2;2203:16;2239:64;2255:47;2295:6;2255:47;:::i;:::-;2239:64;:::i;:::-;2325:3;2349:6;2344:3;2337:19;2381:2;2376:3;2372:12;2365:19;;2436:2;2426:6;2423:1;2419:14;2415:2;2411:23;2407:32;2393:46;;2462:7;2454:6;2451:19;2448:39;;;2483:1;2480;2473:12;2448:39;2515:2;2511;2507:11;2496:22;;2527:148;2543:6;2538:3;2535:15;2527:148;;;2609:23;2628:3;2609:23;:::i;:::-;2597:36;;2662:2;2560:12;;;;2653;;;;2527:148;;;2694:5;1813:892;-1:-1:-1;;;;;;1813:892:1:o;2710:477::-;2859:2;2848:9;2841:21;2822:4;2891:6;2885:13;2934:6;2929:2;2918:9;2914:18;2907:34;2993:6;2988:2;2980:6;2976:15;2971:2;2960:9;2956:18;2950:50;3049:1;3044:2;3035:6;3024:9;3020:22;3016:31;3009:42;3178:2;3108:66;3103:2;3095:6;3091:15;3087:88;3076:9;3072:104;3068:113;3060:121;;;2710:477;;;;:::o;3192:300::-;3260:6;3268;3321:2;3309:9;3300:7;3296:23;3292:32;3289:52;;;3337:1;3334;3327:12;3289:52;3360:29;3379:9;3360:29;:::i;:::-;3350:39;3458:2;3443:18;;;;3430:32;;-1:-1:-1;;;3192:300:1:o;3689:723::-;3743:5;3796:3;3789:4;3781:6;3777:17;3773:27;3763:55;;3814:1;3811;3804:12;3763:55;3854:6;3841:20;3881:64;3897:47;3937:6;3897:47;:::i;3881:64::-;3969:3;3993:6;3988:3;3981:19;4025:4;4020:3;4016:14;4009:21;;4086:4;4076:6;4073:1;4069:14;4061:6;4057:27;4053:38;4039:52;;4114:3;4106:6;4103:15;4100:35;;;4131:1;4128;4121:12;4100:35;4167:4;4159:6;4155:17;4181:200;4197:6;4192:3;4189:15;4181:200;;;4289:17;;4319:18;;4366:4;4357:14;;;;4214;4181:200;;;-1:-1:-1;4399:7:1;3689:723;-1:-1:-1;;;;;3689:723:1:o;4417:462::-;4510:6;4518;4571:2;4559:9;4550:7;4546:23;4542:32;4539:52;;;4587:1;4584;4577:12;4539:52;4632:23;;;-1:-1:-1;4730:2:1;4715:18;;4702:32;4757:18;4746:30;;4743:50;;;4789:1;4786;4779:12;4743:50;4812:61;4865:7;4856:6;4845:9;4841:22;4812:61;:::i;:::-;4802:71;;;4417:462;;;;;:::o;5066:374::-;5143:6;5151;5159;5212:2;5200:9;5191:7;5187:23;5183:32;5180:52;;;5228:1;5225;5218:12;5180:52;5251:29;5270:9;5251:29;:::i;:::-;5241:39;;5299:38;5333:2;5322:9;5318:18;5299:38;:::i;:::-;5066:374;;5289:48;;-1:-1:-1;;;5406:2:1;5391:18;;;;5378:32;;5066:374::o;5634:118::-;5720:5;5713:13;5706:21;5699:5;5696:32;5686:60;;5742:1;5739;5732:12;5757:361;5822:6;5830;5883:2;5871:9;5862:7;5858:23;5854:32;5851:52;;;5899:1;5896;5889:12;5851:52;5944:23;;;-1:-1:-1;6043:2:1;6028:18;;6015:32;6056:30;6015:32;6056:30;:::i;:::-;6105:7;6095:17;;;5757:361;;;;;:::o;6123:226::-;6182:6;6235:2;6223:9;6214:7;6210:23;6206:32;6203:52;;;6251:1;6248;6241:12;6203:52;-1:-1:-1;6296:23:1;;6123:226;-1:-1:-1;6123:226:1:o;6354:465::-;6611:2;6600:9;6593:21;6574:4;6637:56;6689:2;6678:9;6674:18;6666:6;6637:56;:::i;:::-;6741:9;6733:6;6729:22;6724:2;6713:9;6709:18;6702:50;6769:44;6806:6;6798;6769:44;:::i;:::-;6761:52;6354:465;-1:-1:-1;;;;;6354:465:1:o;7300:348::-;7384:6;7437:2;7425:9;7416:7;7412:23;7408:32;7405:52;;;7453:1;7450;7443:12;7405:52;7493:9;7480:23;7526:18;7518:6;7515:30;7512:50;;;7558:1;7555;7548:12;7512:50;7581:61;7634:7;7625:6;7614:9;7610:22;7581:61;:::i;:::-;7571:71;7300:348;-1:-1:-1;;;;7300:348:1:o;7653:260::-;7721:6;7729;7782:2;7770:9;7761:7;7757:23;7753:32;7750:52;;;7798:1;7795;7788:12;7750:52;7821:29;7840:9;7821:29;:::i;:::-;7811:39;;7869:38;7903:2;7892:9;7888:18;7869:38;:::i;:::-;7859:48;;7653:260;;;;;:::o;7918:184::-;7970:77;7967:1;7960:88;8067:4;8064:1;8057:15;8091:4;8088:1;8081:15;8107:184;8159:77;8156:1;8149:88;8256:4;8253:1;8246:15;8280:4;8277:1;8270:15;8296:128;8363:9;;;8384:11;;;8381:37;;;8398:18;;:::i;8429:168::-;8502:9;;;8533;;8550:15;;;8544:22;;8530:37;8520:71;;8571:18;;:::i;8602:274::-;8642:1;8668;8658:189;;8703:77;8700:1;8693:88;8804:4;8801:1;8794:15;8832:4;8829:1;8822:15;8658:189;-1:-1:-1;8861:9:1;;8602:274::o;8881:125::-;8946:9;;;8967:10;;;8964:36;;;8980:18;;:::i;9011:437::-;9090:1;9086:12;;;;9133;;;9154:61;;9208:4;9200:6;9196:17;9186:27;;9154:61;9261:2;9253:6;9250:14;9230:18;9227:38;9224:218;;9298:77;9295:1;9288:88;9399:4;9396:1;9389:15;9427:4;9424:1;9417:15;9224:218;;9011:437;;;:::o;15037:301::-;15166:3;15204:6;15198:13;15250:6;15243:4;15235:6;15231:17;15226:3;15220:37;15312:1;15276:16;;15301:13;;;-1:-1:-1;15276:16:1;15037:301;-1:-1:-1;15037:301:1:o;15343:245::-;15410:6;15463:2;15451:9;15442:7;15438:23;15434:32;15431:52;;;15479:1;15476;15469:12;15431:52;15511:9;15505:16;15530:28;15552:5;15530:28;:::i

ipfs://3c43f4485264ff3f496a7288d7cf91bb6e20fae22d654a7614e25bce26c2eb83