S Price: $0.494346 (+9.60%)
    /

    Contract Diff Checker

    Contract Name:
    Pair

    Contract Source Code:

    // SPDX-License-Identifier: MIT
    pragma solidity ^0.8.26;
    
    import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
    import {ReentrancyGuard} from "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
    import {Math} from "@openzeppelin/contracts/utils/math/Math.sol";
    import {IERC20Extended} from "./interfaces/IERC20Extended.sol";
    import {UQ112x112} from "./libraries/UQ112x112.sol";
    import {IPairCallee} from "./interfaces/IPairCallee.sol";
    import {IPairFactory} from "./interfaces/IPairFactory.sol";
    import {IPair} from "./interfaces/IPair.sol";
    
    contract Pair is IPair, ERC20, ReentrancyGuard {
        using UQ112x112 for uint224;
    
        /// @dev Structure to capture time period obervations every 30 minutes, used for local oracles
        struct Observation {
            uint256 timestamp;
            uint256 reserve0Cumulative;
            uint256 reserve1Cumulative;
        }
    
        Observation[] public observations;
    
        uint256 internal _unlocked;
    
        /// @notice Capture oracle reading every 30 minutes
        uint256 constant periodSize = 1800;
    
        /// @notice min liquidity amount which is burned on creation
        uint256 public constant MINIMUM_LIQUIDITY = 10 ** 3;
    
        /// @notice legacy factory address
        address public immutable factory;
        /// @notice token0 in the pool
        address public token0;
        /// @notice token1 in the pool
        address public token1;
        /// @notice where the swap fees accrue to
        address public feeRecipient;
    
        /// @dev uses single storage slot, accessible via getReserves
        uint112 private reserve0;
        /// @dev uses single storage slot, accessible via getReserves
        uint112 private reserve1;
        /// @dev uses single storage slot, accessible via getReserves
        uint32 private blockTimestampLast;
    
        uint256 public reserve0CumulativeLast;
        uint256 public reserve1CumulativeLast;
        /// @dev reserve0 * reserve1, as of immediately after the most recent liquidity event
        uint256 public kLast;
        /// @dev the portion that goes to feeRecipient, rest goes to LPs. 100% of the fees goes to feeRecipient if it's set to 10000
        uint256 public feeSplit;
        uint256 public fee;
    
        uint256 internal decimals0;
        uint256 internal decimals1;
        /// @dev first MINIMUM_LIQUIDITY tokens are permanently locked
        uint256 internal constant MINIMUM_K = 10 ** 9;
        /// @dev 1m = 100%
        uint256 internal constant FEE_DENOM = 1_000_000;
    
        /// @notice whether the pool uses the xy(x^2 * y + y^2 * x) >= k swap curve
        bool public stable;
    
        string internal _name;
        string internal _symbol;
        constructor() ERC20("", "") {
            /// @dev initialize the factory address
            factory = msg.sender;
        }
    
        /// @inheritdoc IPair
        function initialize(
            address _token0,
            address _token1,
            bool _stable
        ) external {
            /// @dev prevent anyone other than the factory from calling
            require(msg.sender == factory, NOT_AUTHORIZED());
            token0 = _token0;
            token1 = _token1;
    
            string memory __name;
            string memory __symbol;
            stable = _stable;
            if (_stable) {
                __name = string(
                    string.concat(
                        "Legacy Correlated- ",
                        IERC20Extended(token0).symbol(),
                        "/",
                        IERC20Extended(token1).symbol()
                    )
                );
                __symbol = string(
                    string.concat(
                        "cAMM-",
                        IERC20Extended(token0).symbol(),
                        "/",
                        IERC20Extended(token1).symbol()
                    )
                );
            } else {
                __name = string(
                    string.concat(
                        "Legacy Volatile- ",
                        IERC20Extended(token0).symbol(),
                        "/",
                        IERC20Extended(token1).symbol()
                    )
                );
                __symbol = string(
                    string.concat(
                        "vAMM-",
                        IERC20Extended(token0).symbol(),
                        "/",
                        IERC20Extended(token1).symbol()
                    )
                );
            }
    
            _name = __name;
            _symbol = __symbol;
    
            observations.push(Observation(block.timestamp, 0, 0));
    
            decimals0 = 10 ** IERC20Extended(token0).decimals();
            decimals1 = 10 ** IERC20Extended(token1).decimals();
        }
        /// @inheritdoc IPair
        function getReserves()
            public
            view
            returns (
                uint112 _reserve0,
                uint112 _reserve1,
                uint32 _blockTimestampLast
            )
        {
            _reserve0 = reserve0;
            _reserve1 = reserve1;
            _blockTimestampLast = blockTimestampLast;
        }
    
        function _safeTransfer(address token, address to, uint256 value) private {
            require(token.code.length > 0);
            (bool success, bytes memory data) = token.call(
                abi.encodeCall(IERC20Extended.transfer, (to, value))
            );
            if (!(success && (data.length == 0 || abi.decode(data, (bool))))) {
                revert STF();
            }
        }
    
        /// @dev update reserves and, on the first call per block, reserve accumulators
        function _update(
            uint256 balance0,
            uint256 balance1,
            uint112 _reserve0,
            uint112 _reserve1
        ) private {
            /// @dev ensure no overflow
            require(
                balance0 <= type(uint112).max && balance1 <= type(uint112).max,
                OVERFLOW()
            );
            /// @dev store blockstamp
            uint256 blockTimestamp = block.timestamp;
            /// @dev declare
            uint256 timeElapsed;
    
            /// @dev overflow is desired
            unchecked {
                /// @dev time elapsed since the last update
                timeElapsed = blockTimestamp - uint256(blockTimestampLast);
                /// @dev if timeElapsed is gt 0 and the reserves are not 0
                if (timeElapsed > 0 && _reserve0 != 0 && _reserve1 != 0) {
                    /// @dev update the cumulatives
                    reserve0CumulativeLast += _reserve0 * timeElapsed;
                    reserve1CumulativeLast += _reserve1 * timeElapsed;
                }
            }
            /// @dev fetch the last observation
            Observation memory _point = lastObservation();
            /// @dev compare the last observation with current timestamp, if greater than 30 minutes, record a new event
            timeElapsed = blockTimestamp - _point.timestamp;
            /// @dev if > the periodSize (usually 30m twap)
            if (timeElapsed > periodSize) {
                observations.push(
                    Observation(
                        blockTimestamp,
                        reserve0CumulativeLast,
                        reserve1CumulativeLast
                    )
                );
            }
    
            reserve0 = uint112(balance0);
            reserve1 = uint112(balance1);
            blockTimestampLast = uint32(blockTimestamp);
            emit Sync(reserve0, reserve1);
        }
    
        /// @dev if fee is on, mint liquidity up to the entire growth in sqrt(k)
        function _mintFee(
            uint112 _reserve0,
            uint112 _reserve1
        ) private returns (bool feeOn) {
            /// @dev gas savings
            address _feeRecipient = feeRecipient;
            /// @dev gas savings
            uint256 _kLast = kLast;
            /// @dev we define fee being on as the existence of the fee recipient
            feeOn = _feeRecipient != address(0);
            /// @dev if there are any fees not going to LP providers
            if (feeOn) {
                /// @dev portion of fees that go to feeRecipient
                uint256 _feeSplit = feeSplit;
                /// @dev if the reserve calculation is not 0
                if (_kLast != 0) {
                    /// @dev if a stableswap/correlated pair with curve: xy(x^2y + y^2x) >= k
                    if (stable) {
                        /// @dev fetch current k value
                        uint256 k = _k(_reserve0, _reserve1);
                        /// @dev if k is greater than the _kLast variable
                        if (k > _kLast) {
                            uint256 fourthRoot_e18 = Math.sqrt(
                                Math.mulDiv(Math.sqrt(_kLast), 1e36, Math.sqrt(k))
                            );
    
                            uint256 numerator = _feeSplit *
                                (1e18 - fourthRoot_e18) *
                                1e18;
                            uint256 denominator = ((10_000 * 1e18) -
                                (_feeSplit * (1e18 - fourthRoot_e18)));
    
                            /// @dev new liquidity to be minted
                            uint256 feeAsLiquidity = (totalSupply() * numerator) /
                                denominator /
                                1e18;
    
                            if (feeAsLiquidity > 0) {
                                _mint(_feeRecipient, feeAsLiquidity);
                            }
                        }
                    }
                    /// @dev if !stable
                    else {
                        uint256 rootK = Math.sqrt(
                            _k(uint256(_reserve0), uint256(_reserve1))
                        );
                        uint256 rootKLast = Math.sqrt(_kLast);
                        if (rootK > rootKLast) {
                            /// @dev calculate fee amounts to send
                            uint256 diffK = rootK - rootKLast;
                            uint256 dueToProtocol = (diffK * _feeSplit) / 10_000;
                            uint256 dueToLp = rootKLast + diffK - dueToProtocol;
    
                            /// @dev new liquidity to be minted
                            /// @dev n = s*P/d
                            uint256 feeAsLiquidity = (totalSupply() *
                                dueToProtocol) / dueToLp;
    
                            if (feeAsLiquidity > 0) {
                                _mint(_feeRecipient, feeAsLiquidity);
                            }
                        }
                    }
                }
            }
            /// @dev if !feeOn
            else if (_kLast != 0) {
                /// @dev update kLast to reflect reserves
                kLast = _k(reserve0, reserve1);
            }
        }
        /// @inheritdoc IPair
        /// @dev this low-level function should be called from a contract which performs important safety checks
        function mint(
            address to
        ) external nonReentrant returns (uint256 liquidity) {
            /// @dev gas savings
            (uint112 _reserve0, uint112 _reserve1, ) = getReserves();
            uint256 balance0 = IERC20Extended(token0).balanceOf(address(this));
            uint256 balance1 = IERC20Extended(token1).balanceOf(address(this));
            uint256 amount0 = balance0 - _reserve0;
            uint256 amount1 = balance1 - _reserve1;
    
            bool feeOn = _mintFee(_reserve0, _reserve1);
            /// @dev gas savings, must be defined here since totalSupply can update in _mintFee
            uint256 _totalSupply = totalSupply();
            if (_totalSupply == 0) {
                liquidity = Math.sqrt(amount0 * amount1) - MINIMUM_LIQUIDITY;
                /// @dev permanently lock the first MINIMUM_LIQUIDITY tokens
                _mint(address(0xdead), MINIMUM_LIQUIDITY);
                if (stable) {
                    require(_k(amount0, amount1) >= MINIMUM_K, K());
                    require(
                        ((amount0 * 1e18) / decimals0 ==
                            (amount1 * 1e18) / decimals1),
                        UNSTABLE_RATIO()
                    );
                }
            } else {
                liquidity = Math.min(
                    (amount0 * _totalSupply) / _reserve0,
                    (amount1 * _totalSupply) / _reserve1
                );
            }
            require(liquidity != 0, ILM());
            _mint(to, liquidity);
    
            _update(balance0, balance1, _reserve0, _reserve1);
            /// @dev reserve0 and reserve1 are up-to-date
            if (feeOn) kLast = _k(uint256(reserve0), uint256(reserve1));
            emit Mint(msg.sender, amount0, amount1);
        }
        /// @inheritdoc IPair
        /// @dev this low-level function should be called from a contract which performs important safety checks
        function burn(
            address to
        ) external nonReentrant returns (uint256 amount0, uint256 amount1) {
            /// @dev gas savings
            (uint112 _reserve0, uint112 _reserve1, ) = getReserves();
            /// @dev gas savings
            address _token0 = token0;
            /// @dev gas savings
            address _token1 = token1;
            uint256 balance0 = IERC20Extended(_token0).balanceOf(address(this));
            uint256 balance1 = IERC20Extended(_token1).balanceOf(address(this));
            /// @dev fetch the balance of the liquidity of the Pair
            uint256 liquidity = balanceOf(address(this));
            /// @dev attempt to mint fees and calculate if feeOn is active
            bool feeOn = _mintFee(_reserve0, _reserve1);
            /// @dev gas savings, must be defined here since totalSupply can update in _mintFee
            uint256 _totalSupply = totalSupply();
            /// @dev using balances ensures pro-rata distribution
            amount0 = (liquidity * balance0) / _totalSupply;
            /// @dev using balances ensures pro-rata distribution
            amount1 = (liquidity * balance1) / _totalSupply;
            /// @dev require the amounts are not zero, else it's insufficient liquidity burned and revert
            require(amount0 != 0 && amount1 != 0, ILB());
            /// @dev burn the liquidity tokens
            _burn(address(this), liquidity);
            /// @dev safe transfer the two underlying tokens (incase of tax tokens etc)
            _safeTransfer(_token0, to, amount0);
            _safeTransfer(_token1, to, amount1);
            /// @dev fetch updated balances
            balance0 = IERC20Extended(_token0).balanceOf(address(this));
            balance1 = IERC20Extended(_token1).balanceOf(address(this));
            /// @dev update with the new balances
            _update(balance0, balance1, _reserve0, _reserve1);
            /// @dev reserve0 and reserve1 are up-to-date
            if (feeOn) kLast = _k(reserve0, reserve1);
            emit Burn(msg.sender, amount0, amount1, to);
        }
        /// @inheritdoc IPair
        /// @dev this low-level function should be called from a contract which performs important safety checks
        function swap(
            uint256 amount0Out,
            uint256 amount1Out,
            address to,
            bytes calldata data
        ) external nonReentrant {
            /// @dev require at least one is not 0, else revert for Insufficient Output Amount
            require(amount0Out != 0 || amount1Out != 0, IOA());
    
            /// @dev gas savings
            (uint112 _reserve0, uint112 _reserve1, ) = getReserves();
            /// @dev ensure there is enough liquidity for the swap
            require(amount0Out < _reserve0 && amount1Out < _reserve1, IL());
            /// @dev gas savings
            address _token0 = token0;
            address _token1 = token1;
    
            require(to != _token0 && to != _token1, IT());
            /// @dev optimistically transfer tokens
            if (amount0Out > 0) _safeTransfer(_token0, to, amount0Out);
            /// @dev optimistically transfer tokens
            if (amount1Out > 0) _safeTransfer(_token1, to, amount1Out);
            if (data.length > 0)
                IPairCallee(to).hook(msg.sender, amount0Out, amount1Out, data);
            uint256 balance0 = IERC20Extended(_token0).balanceOf(address(this));
            uint256 balance1 = IERC20Extended(_token1).balanceOf(address(this));
    
            uint256 amount0In;
            uint256 amount1In;
            unchecked {
                amount0In = balance0 > _reserve0 - amount0Out
                    ? balance0 - (_reserve0 - amount0Out)
                    : 0;
                amount1In = balance1 > _reserve1 - amount1Out
                    ? balance1 - (_reserve1 - amount1Out)
                    : 0;
            }
            require(amount0In != 0 || amount1In != 0, IIA());
    
            /// @dev FEE_DENOM as the denominator invariant for calculating swap fees
            uint256 balance0Adjusted = balance0 - ((amount0In * fee) / FEE_DENOM);
            uint256 balance1Adjusted = balance1 - ((amount1In * fee) / FEE_DENOM);
    
            require(
                _k(balance0Adjusted, balance1Adjusted) >=
                    _k(uint256(_reserve0), uint256(_reserve1)),
                K()
            );
    
            _update(balance0, balance1, _reserve0, _reserve1);
            emit Swap(msg.sender, amount0In, amount1In, amount0Out, amount1Out, to);
        }
    
        /// @inheritdoc IPair
        function skim(address to) external nonReentrant {
            /// @dev if skim disabled, revert
            /// @dev by default it is disabled as it uses a mapping in the pair factory contract
            require((IPairFactory(factory).skimEnabled(address(this))), SD());
            /// @dev gas savings
            address _token0 = token0;
            /// @dev gas savings
            address _token1 = token1;
            _safeTransfer(
                _token0,
                to,
                IERC20Extended(_token0).balanceOf(address(this)) - reserve0
            );
            _safeTransfer(
                _token1,
                to,
                IERC20Extended(_token1).balanceOf(address(this)) - reserve1
            );
        }
    
        /// @inheritdoc IPair
        function sync() external nonReentrant {
            /// @dev update the reserves to match balances
            _update(
                IERC20Extended(token0).balanceOf(address(this)),
                IERC20Extended(token1).balanceOf(address(this)),
                reserve0,
                reserve1
            );
        }
        /// @inheritdoc IPair
        function setFeeRecipient(address _feeRecipient) external {
            /// @dev gate to the PairFactory
            require(msg.sender == factory, NOT_AUTHORIZED());
            feeRecipient = _feeRecipient;
        }
        /// @inheritdoc IPair
        function setFeeSplit(uint256 _feeSplit) external {
            /// @dev gate to the PairFactory
            require(msg.sender == factory, NOT_AUTHORIZED());
            feeSplit = _feeSplit;
        }
        /// @inheritdoc IPair
        function setFee(uint256 _fee) external {
            /// @dev gate to the PairFactory
            require(msg.sender == factory, NOT_AUTHORIZED());
            fee = _fee;
        }
        /// @inheritdoc IPair
        function mintFee() external nonReentrant {
            /// @dev fetch the current public reserves
            uint112 _reserve0 = reserve0;
            uint112 _reserve1 = reserve1;
            /// @dev mint the accumulated fees
            bool feeOn = _mintFee(_reserve0, _reserve1);
            /// @dev if minting was successful
            if (feeOn) kLast = _k(uint256(_reserve0), uint256(_reserve1));
        }
    
        function _k(uint256 x, uint256 y) internal view returns (uint256) {
            if (stable) {
                uint256 _x = (x * 10 ** 18) / decimals0;
                uint256 _y = (y * 10 ** 18) / decimals1;
                uint256 _a = (_x * _y) / 10 ** 18;
                uint256 _b = ((_x * _x) / 10 ** 18 + (_y * _y) / 10 ** 18);
                /// @dev x3y+y3x >= k
                return (_a * _b) / 10 ** 18;
            } else {
                /// @dev xy >= k
                return x * y;
            }
        }
    
        function _f(uint256 x0, uint256 y) internal pure returns (uint256) {
            return
                (x0 * ((((y * y) / 1e18) * y) / 1e18)) /
                1e18 +
                (((((x0 * x0) / 1e18) * x0) / 1e18) * y) /
                1e18;
        }
    
        function _d(uint256 x0, uint256 y) internal pure returns (uint256) {
            return
                (3 * x0 * ((y * y) / 1e18)) /
                1e18 +
                ((((x0 * x0) / 1e18) * x0) / 1e18);
        }
    
        function _get_y(
            uint256 x0,
            uint256 xy,
            uint256 y
        ) internal pure returns (uint256) {
            for (uint256 i = 0; i < 255; ++i) {
                uint256 y_prev = y;
                uint256 k = _f(x0, y);
                if (k < xy) {
                    uint256 dy = ((xy - k) * 1e18) / _d(x0, y);
                    y = y + dy;
                } else {
                    uint256 dy = ((k - xy) * 1e18) / _d(x0, y);
                    y = y - dy;
                }
                if (y > y_prev) {
                    if (y - y_prev <= 1) {
                        return y;
                    }
                } else {
                    if (y_prev - y <= 1) {
                        return y;
                    }
                }
            }
            return y;
        }
        /// @inheritdoc IPair
        function getAmountOut(
            uint256 amountIn,
            address tokenIn
        ) external view returns (uint256) {
            (uint256 _reserve0, uint256 _reserve1) = (reserve0, reserve1);
            /// @dev remove fee from amount received
            amountIn -= (amountIn * fee) / FEE_DENOM;
    
            return _getAmountOut(amountIn, tokenIn, _reserve0, _reserve1) - 1;
        }
    
        function _getAmountOut(
            uint256 amountIn,
            address tokenIn,
            uint256 _reserve0,
            uint256 _reserve1
        ) internal view returns (uint256) {
            if (stable) {
                uint256 xy = _k(_reserve0, _reserve1);
                _reserve0 = (_reserve0 * 1e18) / decimals0;
                _reserve1 = (_reserve1 * 1e18) / decimals1;
                (uint256 reserveA, uint256 reserveB) = tokenIn == token0
                    ? (_reserve0, _reserve1)
                    : (_reserve1, _reserve0);
                amountIn = tokenIn == token0
                    ? (amountIn * 1e18) / decimals0
                    : (amountIn * 1e18) / decimals1;
                uint256 y = reserveB - _get_y(amountIn + reserveA, xy, reserveB);
                return (y * (tokenIn == token0 ? decimals1 : decimals0)) / 1e18;
            } else {
                (uint256 reserveA, uint256 reserveB) = tokenIn == token0
                    ? (_reserve0, _reserve1)
                    : (_reserve1, _reserve0);
                return (amountIn * reserveB) / (reserveA + amountIn);
            }
        }
    
        function metadata()
            external
            view
            returns (
                uint256 _decimals0,
                uint256 _decimals1,
                uint256 _reserve0,
                uint256 _reserve1,
                bool _stable,
                address _token0,
                address _token1
            )
        {
            return (
                decimals0,
                decimals1,
                reserve0,
                reserve1,
                stable,
                token0,
                token1
            );
        }
    
        function observationLength() external view returns (uint256) {
            return observations.length;
        }
    
        function lastObservation() public view returns (Observation memory) {
            return observations[observations.length - 1];
        }
    
        /// @dev produces the cumulative price using counterfactuals to save gas and avoid a call to sync.
        function currentCumulativePrices()
            public
            view
            returns (
                uint256 reserve0Cumulative,
                uint256 reserve1Cumulative,
                uint256 blockTimestamp
            )
        {
            blockTimestamp = block.timestamp;
            reserve0Cumulative = reserve0CumulativeLast;
            reserve1Cumulative = reserve1CumulativeLast;
    
            /// @dev if time has elapsed since the last update on the pair, mock the accumulated price values
            (
                uint112 _reserve0,
                uint112 _reserve1,
                uint32 _blockTimestampLast
            ) = getReserves();
            if (_blockTimestampLast != uint32(blockTimestamp)) {
                /// @dev subtraction overflow is desired
                uint256 timeElapsed = blockTimestamp - uint256(_blockTimestampLast);
                reserve0Cumulative += _reserve0 * timeElapsed;
                reserve1Cumulative += _reserve1 * timeElapsed;
            }
        }
    
        /// @dev gives the current twap price measured from amountIn * tokenIn gives amountOut
        function current(
            address tokenIn,
            uint256 amountIn
        ) external view returns (uint256 amountOut) {
            Observation memory _observation = lastObservation();
            (
                uint256 reserve0Cumulative,
                uint256 reserve1Cumulative,
    
            ) = currentCumulativePrices();
            if (block.timestamp == _observation.timestamp) {
                _observation = observations[observations.length - 2];
            }
    
            uint256 timeElapsed = block.timestamp - _observation.timestamp;
            uint256 _reserve0 = (reserve0Cumulative -
                _observation.reserve0Cumulative) / timeElapsed;
            uint256 _reserve1 = (reserve1Cumulative -
                _observation.reserve1Cumulative) / timeElapsed;
            amountOut = _getAmountOut(amountIn, tokenIn, _reserve0, _reserve1);
        }
    
        /// @dev as per `current`, however allows user configured granularity, up to the full window size
        function quote(
            address tokenIn,
            uint256 amountIn,
            uint256 granularity
        ) external view returns (uint256 amountOut) {
            uint256[] memory _prices = sample(tokenIn, amountIn, granularity, 1);
            uint256 priceAverageCumulative;
            for (uint256 i = 0; i < _prices.length; ++i) {
                priceAverageCumulative += _prices[i];
            }
            return priceAverageCumulative / granularity;
        }
    
        /// @dev returns a memory set of twap prices
        function prices(
            address tokenIn,
            uint256 amountIn,
            uint256 points
        ) external view returns (uint256[] memory) {
            return sample(tokenIn, amountIn, points, 1);
        }
    
        function sample(
            address tokenIn,
            uint256 amountIn,
            uint256 points,
            uint256 window
        ) public view returns (uint256[] memory) {
            uint256[] memory _prices = new uint256[](points);
    
            uint256 length = observations.length - 1;
            uint256 i = length - (points * window);
            uint256 nextIndex = 0;
            uint256 index = 0;
    
            for (; i < length; i += window) {
                nextIndex = i + window;
                uint256 timeElapsed = observations[nextIndex].timestamp -
                    observations[i].timestamp;
                uint256 _reserve0 = (observations[nextIndex].reserve0Cumulative -
                    observations[i].reserve0Cumulative) / timeElapsed;
                uint256 _reserve1 = (observations[nextIndex].reserve1Cumulative -
                    observations[i].reserve1Cumulative) / timeElapsed;
                _prices[index] = _getAmountOut(
                    amountIn,
                    tokenIn,
                    _reserve0,
                    _reserve1
                );
                /// @dev index < length; length cannot overflow
                unchecked {
                    index = index + 1;
                }
            }
            return _prices;
        }
    }

    // SPDX-License-Identifier: MIT
    // OpenZeppelin Contracts (last updated v5.1.0) (token/ERC20/ERC20.sol)
    
    pragma solidity ^0.8.20;
    
    import {IERC20} from "./IERC20.sol";
    import {IERC20Metadata} from "./extensions/IERC20Metadata.sol";
    import {Context} from "../../utils/Context.sol";
    import {IERC20Errors} from "../../interfaces/draft-IERC6093.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}.
     *
     * TIP: For a detailed writeup see our guide
     * https://forum.openzeppelin.com/t/how-to-implement-erc20-supply-mechanisms/226[How
     * to implement supply mechanisms].
     *
     * The default value of {decimals} is 18. To change this, you should override
     * this function so it returns a different value.
     *
     * 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 ERC-20
     * applications.
     */
    abstract contract ERC20 is Context, IERC20, IERC20Metadata, IERC20Errors {
        mapping(address account => uint256) private _balances;
    
        mapping(address account => mapping(address spender => uint256)) private _allowances;
    
        uint256 private _totalSupply;
    
        string private _name;
        string private _symbol;
    
        /**
         * @dev Sets the values for {name} and {symbol}.
         *
         * 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 returns (string memory) {
            return _name;
        }
    
        /**
         * @dev Returns the symbol of the token, usually a shorter version of the
         * name.
         */
        function symbol() public view virtual 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 default value returned by this function, unless
         * it's 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 returns (uint8) {
            return 18;
        }
    
        /**
         * @dev See {IERC20-totalSupply}.
         */
        function totalSupply() public view virtual returns (uint256) {
            return _totalSupply;
        }
    
        /**
         * @dev See {IERC20-balanceOf}.
         */
        function balanceOf(address account) public view virtual 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 `value`.
         */
        function transfer(address to, uint256 value) public virtual returns (bool) {
            address owner = _msgSender();
            _transfer(owner, to, value);
            return true;
        }
    
        /**
         * @dev See {IERC20-allowance}.
         */
        function allowance(address owner, address spender) public view virtual returns (uint256) {
            return _allowances[owner][spender];
        }
    
        /**
         * @dev See {IERC20-approve}.
         *
         * NOTE: If `value` 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 value) public virtual returns (bool) {
            address owner = _msgSender();
            _approve(owner, spender, value);
            return true;
        }
    
        /**
         * @dev See {IERC20-transferFrom}.
         *
         * Skips emitting an {Approval} event indicating an allowance update. This is not
         * required by the ERC. See {xref-ERC20-_approve-address-address-uint256-bool-}[_approve].
         *
         * 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 `value`.
         * - the caller must have allowance for ``from``'s tokens of at least
         * `value`.
         */
        function transferFrom(address from, address to, uint256 value) public virtual returns (bool) {
            address spender = _msgSender();
            _spendAllowance(from, spender, value);
            _transfer(from, to, value);
            return true;
        }
    
        /**
         * @dev Moves a `value` 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.
         *
         * NOTE: This function is not virtual, {_update} should be overridden instead.
         */
        function _transfer(address from, address to, uint256 value) internal {
            if (from == address(0)) {
                revert ERC20InvalidSender(address(0));
            }
            if (to == address(0)) {
                revert ERC20InvalidReceiver(address(0));
            }
            _update(from, to, value);
        }
    
        /**
         * @dev Transfers a `value` amount of tokens from `from` to `to`, or alternatively mints (or burns) if `from`
         * (or `to`) is the zero address. All customizations to transfers, mints, and burns should be done by overriding
         * this function.
         *
         * Emits a {Transfer} event.
         */
        function _update(address from, address to, uint256 value) internal virtual {
            if (from == address(0)) {
                // Overflow check required: The rest of the code assumes that totalSupply never overflows
                _totalSupply += value;
            } else {
                uint256 fromBalance = _balances[from];
                if (fromBalance < value) {
                    revert ERC20InsufficientBalance(from, fromBalance, value);
                }
                unchecked {
                    // Overflow not possible: value <= fromBalance <= totalSupply.
                    _balances[from] = fromBalance - value;
                }
            }
    
            if (to == address(0)) {
                unchecked {
                    // Overflow not possible: value <= totalSupply or value <= fromBalance <= totalSupply.
                    _totalSupply -= value;
                }
            } else {
                unchecked {
                    // Overflow not possible: balance + value is at most totalSupply, which we know fits into a uint256.
                    _balances[to] += value;
                }
            }
    
            emit Transfer(from, to, value);
        }
    
        /**
         * @dev Creates a `value` amount of tokens and assigns them to `account`, by transferring it from address(0).
         * Relies on the `_update` mechanism
         *
         * Emits a {Transfer} event with `from` set to the zero address.
         *
         * NOTE: This function is not virtual, {_update} should be overridden instead.
         */
        function _mint(address account, uint256 value) internal {
            if (account == address(0)) {
                revert ERC20InvalidReceiver(address(0));
            }
            _update(address(0), account, value);
        }
    
        /**
         * @dev Destroys a `value` amount of tokens from `account`, lowering the total supply.
         * Relies on the `_update` mechanism.
         *
         * Emits a {Transfer} event with `to` set to the zero address.
         *
         * NOTE: This function is not virtual, {_update} should be overridden instead
         */
        function _burn(address account, uint256 value) internal {
            if (account == address(0)) {
                revert ERC20InvalidSender(address(0));
            }
            _update(account, address(0), value);
        }
    
        /**
         * @dev Sets `value` 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.
         *
         * Overrides to this logic should be done to the variant with an additional `bool emitEvent` argument.
         */
        function _approve(address owner, address spender, uint256 value) internal {
            _approve(owner, spender, value, true);
        }
    
        /**
         * @dev Variant of {_approve} with an optional flag to enable or disable the {Approval} event.
         *
         * By default (when calling {_approve}) the flag is set to true. On the other hand, approval changes made by
         * `_spendAllowance` during the `transferFrom` operation set the flag to false. This saves gas by not emitting any
         * `Approval` event during `transferFrom` operations.
         *
         * Anyone who wishes to continue emitting `Approval` events on the`transferFrom` operation can force the flag to
         * true using the following override:
         *
         * ```solidity
         * function _approve(address owner, address spender, uint256 value, bool) internal virtual override {
         *     super._approve(owner, spender, value, true);
         * }
         * ```
         *
         * Requirements are the same as {_approve}.
         */
        function _approve(address owner, address spender, uint256 value, bool emitEvent) internal virtual {
            if (owner == address(0)) {
                revert ERC20InvalidApprover(address(0));
            }
            if (spender == address(0)) {
                revert ERC20InvalidSpender(address(0));
            }
            _allowances[owner][spender] = value;
            if (emitEvent) {
                emit Approval(owner, spender, value);
            }
        }
    
        /**
         * @dev Updates `owner` s allowance for `spender` based on spent `value`.
         *
         * Does not update the allowance value in case of infinite allowance.
         * Revert if not enough allowance is available.
         *
         * Does not emit an {Approval} event.
         */
        function _spendAllowance(address owner, address spender, uint256 value) internal virtual {
            uint256 currentAllowance = allowance(owner, spender);
            if (currentAllowance != type(uint256).max) {
                if (currentAllowance < value) {
                    revert ERC20InsufficientAllowance(spender, currentAllowance, value);
                }
                unchecked {
                    _approve(owner, spender, currentAllowance - value, false);
                }
            }
        }
    }

    // SPDX-License-Identifier: MIT
    // OpenZeppelin Contracts (last updated v5.1.0) (utils/ReentrancyGuard.sol)
    
    pragma solidity ^0.8.20;
    
    /**
     * @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 EIP-1153 (transient storage) is available on the chain you're deploying at,
     * consider using {ReentrancyGuardTransient} instead.
     *
     * 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;
    
        /**
         * @dev Unauthorized reentrant call.
         */
        error ReentrancyGuardReentrantCall();
    
        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() {
            _nonReentrantBefore();
            _;
            _nonReentrantAfter();
        }
    
        function _nonReentrantBefore() private {
            // On the first call to nonReentrant, _status will be NOT_ENTERED
            if (_status == ENTERED) {
                revert ReentrancyGuardReentrantCall();
            }
    
            // Any calls to nonReentrant after this point will fail
            _status = ENTERED;
        }
    
        function _nonReentrantAfter() private {
            // By storing the original value once again, a refund is triggered (see
            // https://eips.ethereum.org/EIPS/eip-2200)
            _status = NOT_ENTERED;
        }
    
        /**
         * @dev Returns true if the reentrancy guard is currently set to "entered", which indicates there is a
         * `nonReentrant` function in the call stack.
         */
        function _reentrancyGuardEntered() internal view returns (bool) {
            return _status == ENTERED;
        }
    }

    // SPDX-License-Identifier: MIT
    // OpenZeppelin Contracts (last updated v5.1.0) (utils/math/Math.sol)
    
    pragma solidity ^0.8.20;
    
    import {Panic} from "../Panic.sol";
    import {SafeCast} from "./SafeCast.sol";
    
    /**
     * @dev Standard math utilities missing in the Solidity language.
     */
    library Math {
        enum Rounding {
            Floor, // Toward negative infinity
            Ceil, // Toward positive infinity
            Trunc, // Toward zero
            Expand // Away from zero
        }
    
        /**
         * @dev Returns the addition of two unsigned integers, with an success flag (no overflow).
         */
        function tryAdd(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {
            unchecked {
                uint256 c = a + b;
                if (c < a) return (false, 0);
                return (true, c);
            }
        }
    
        /**
         * @dev Returns the subtraction of two unsigned integers, with an success flag (no overflow).
         */
        function trySub(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {
            unchecked {
                if (b > a) return (false, 0);
                return (true, a - b);
            }
        }
    
        /**
         * @dev Returns the multiplication of two unsigned integers, with an success flag (no overflow).
         */
        function tryMul(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {
            unchecked {
                // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
                // benefit is lost if 'b' is also tested.
                // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
                if (a == 0) return (true, 0);
                uint256 c = a * b;
                if (c / a != b) return (false, 0);
                return (true, c);
            }
        }
    
        /**
         * @dev Returns the division of two unsigned integers, with a success flag (no division by zero).
         */
        function tryDiv(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {
            unchecked {
                if (b == 0) return (false, 0);
                return (true, a / b);
            }
        }
    
        /**
         * @dev Returns the remainder of dividing two unsigned integers, with a success flag (no division by zero).
         */
        function tryMod(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {
            unchecked {
                if (b == 0) return (false, 0);
                return (true, a % b);
            }
        }
    
        /**
         * @dev Branchless ternary evaluation for `a ? b : c`. Gas costs are constant.
         *
         * IMPORTANT: This function may reduce bytecode size and consume less gas when used standalone.
         * However, the compiler may optimize Solidity ternary operations (i.e. `a ? b : c`) to only compute
         * one branch when needed, making this function more expensive.
         */
        function ternary(bool condition, uint256 a, uint256 b) internal pure returns (uint256) {
            unchecked {
                // branchless ternary works because:
                // b ^ (a ^ b) == a
                // b ^ 0 == b
                return b ^ ((a ^ b) * SafeCast.toUint(condition));
            }
        }
    
        /**
         * @dev Returns the largest of two numbers.
         */
        function max(uint256 a, uint256 b) internal pure returns (uint256) {
            return ternary(a > b, a, b);
        }
    
        /**
         * @dev Returns the smallest of two numbers.
         */
        function min(uint256 a, uint256 b) internal pure returns (uint256) {
            return ternary(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 towards infinity instead
         * of rounding towards zero.
         */
        function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
            if (b == 0) {
                // Guarantee the same behavior as in a regular Solidity division.
                Panic.panic(Panic.DIVISION_BY_ZERO);
            }
    
            // The following calculation ensures accurate ceiling division without overflow.
            // Since a is non-zero, (a - 1) / b will not overflow.
            // The largest possible result occurs when (a - 1) / b is type(uint256).max,
            // but the largest value we can obtain is type(uint256).max - 1, which happens
            // when a = type(uint256).max and b = 1.
            unchecked {
                return SafeCast.toUint(a > 0) * ((a - 1) / b + 1);
            }
        }
    
        /**
         * @dev Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or
         * denominator == 0.
         *
         * 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²⁵⁶ and mod 2²⁵⁶ - 1, then use
                // the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256
                // variables such that product = prod1 * 2²⁵⁶ + prod0.
                uint256 prod0 = x * y; // Least significant 256 bits of the product
                uint256 prod1; // Most significant 256 bits of the product
                assembly {
                    let mm := mulmod(x, y, not(0))
                    prod1 := sub(sub(mm, prod0), lt(mm, prod0))
                }
    
                // Handle non-overflow cases, 256 by 256 division.
                if (prod1 == 0) {
                    // Solidity will revert if denominator == 0, unlike the div opcode on its own.
                    // The surrounding unchecked block does not change this fact.
                    // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.
                    return prod0 / denominator;
                }
    
                // Make sure the result is less than 2²⁵⁶. Also prevents denominator == 0.
                if (denominator <= prod1) {
                    Panic.panic(ternary(denominator == 0, Panic.DIVISION_BY_ZERO, Panic.UNDER_OVERFLOW));
                }
    
                ///////////////////////////////////////////////
                // 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.
    
                uint256 twos = denominator & (0 - denominator);
                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²⁵⁶ / 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²⁵⁶. Now that denominator is an odd number, it has an inverse modulo 2²⁵⁶ such
                // that denominator * inv ≡ 1 mod 2²⁵⁶. Compute the inverse by starting with a seed that is correct for
                // four bits. That is, denominator * inv ≡ 1 mod 2⁴.
                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⁸
                inverse *= 2 - denominator * inverse; // inverse mod 2¹⁶
                inverse *= 2 - denominator * inverse; // inverse mod 2³²
                inverse *= 2 - denominator * inverse; // inverse mod 2⁶⁴
                inverse *= 2 - denominator * inverse; // inverse mod 2¹²⁸
                inverse *= 2 - denominator * inverse; // inverse mod 2²⁵⁶
    
                // 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²⁵⁶. Since the preconditions guarantee that the outcome is
                // less than 2²⁵⁶, 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;
            }
        }
    
        /**
         * @dev 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) {
            return mulDiv(x, y, denominator) + SafeCast.toUint(unsignedRoundsUp(rounding) && mulmod(x, y, denominator) > 0);
        }
    
        /**
         * @dev Calculate the modular multiplicative inverse of a number in Z/nZ.
         *
         * If n is a prime, then Z/nZ is a field. In that case all elements are inversible, except 0.
         * If n is not a prime, then Z/nZ is not a field, and some elements might not be inversible.
         *
         * If the input value is not inversible, 0 is returned.
         *
         * NOTE: If you know for sure that n is (big) a prime, it may be cheaper to use Fermat's little theorem and get the
         * inverse using `Math.modExp(a, n - 2, n)`. See {invModPrime}.
         */
        function invMod(uint256 a, uint256 n) internal pure returns (uint256) {
            unchecked {
                if (n == 0) return 0;
    
                // The inverse modulo is calculated using the Extended Euclidean Algorithm (iterative version)
                // Used to compute integers x and y such that: ax + ny = gcd(a, n).
                // When the gcd is 1, then the inverse of a modulo n exists and it's x.
                // ax + ny = 1
                // ax = 1 + (-y)n
                // ax ≡ 1 (mod n) # x is the inverse of a modulo n
    
                // If the remainder is 0 the gcd is n right away.
                uint256 remainder = a % n;
                uint256 gcd = n;
    
                // Therefore the initial coefficients are:
                // ax + ny = gcd(a, n) = n
                // 0a + 1n = n
                int256 x = 0;
                int256 y = 1;
    
                while (remainder != 0) {
                    uint256 quotient = gcd / remainder;
    
                    (gcd, remainder) = (
                        // The old remainder is the next gcd to try.
                        remainder,
                        // Compute the next remainder.
                        // Can't overflow given that (a % gcd) * (gcd // (a % gcd)) <= gcd
                        // where gcd is at most n (capped to type(uint256).max)
                        gcd - remainder * quotient
                    );
    
                    (x, y) = (
                        // Increment the coefficient of a.
                        y,
                        // Decrement the coefficient of n.
                        // Can overflow, but the result is casted to uint256 so that the
                        // next value of y is "wrapped around" to a value between 0 and n - 1.
                        x - y * int256(quotient)
                    );
                }
    
                if (gcd != 1) return 0; // No inverse exists.
                return ternary(x < 0, n - uint256(-x), uint256(x)); // Wrap the result if it's negative.
            }
        }
    
        /**
         * @dev Variant of {invMod}. More efficient, but only works if `p` is known to be a prime greater than `2`.
         *
         * From https://en.wikipedia.org/wiki/Fermat%27s_little_theorem[Fermat's little theorem], we know that if p is
         * prime, then `a**(p-1) ≡ 1 mod p`. As a consequence, we have `a * a**(p-2) ≡ 1 mod p`, which means that
         * `a**(p-2)` is the modular multiplicative inverse of a in Fp.
         *
         * NOTE: this function does NOT check that `p` is a prime greater than `2`.
         */
        function invModPrime(uint256 a, uint256 p) internal view returns (uint256) {
            unchecked {
                return Math.modExp(a, p - 2, p);
            }
        }
    
        /**
         * @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m)
         *
         * Requirements:
         * - modulus can't be zero
         * - underlying staticcall to precompile must succeed
         *
         * IMPORTANT: The result is only valid if the underlying call succeeds. When using this function, make
         * sure the chain you're using it on supports the precompiled contract for modular exponentiation
         * at address 0x05 as specified in https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise,
         * the underlying function will succeed given the lack of a revert, but the result may be incorrectly
         * interpreted as 0.
         */
        function modExp(uint256 b, uint256 e, uint256 m) internal view returns (uint256) {
            (bool success, uint256 result) = tryModExp(b, e, m);
            if (!success) {
                Panic.panic(Panic.DIVISION_BY_ZERO);
            }
            return result;
        }
    
        /**
         * @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m).
         * It includes a success flag indicating if the operation succeeded. Operation will be marked as failed if trying
         * to operate modulo 0 or if the underlying precompile reverted.
         *
         * IMPORTANT: The result is only valid if the success flag is true. When using this function, make sure the chain
         * you're using it on supports the precompiled contract for modular exponentiation at address 0x05 as specified in
         * https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise, the underlying function will succeed given the lack
         * of a revert, but the result may be incorrectly interpreted as 0.
         */
        function tryModExp(uint256 b, uint256 e, uint256 m) internal view returns (bool success, uint256 result) {
            if (m == 0) return (false, 0);
            assembly ("memory-safe") {
                let ptr := mload(0x40)
                // | Offset    | Content    | Content (Hex)                                                      |
                // |-----------|------------|--------------------------------------------------------------------|
                // | 0x00:0x1f | size of b  | 0x0000000000000000000000000000000000000000000000000000000000000020 |
                // | 0x20:0x3f | size of e  | 0x0000000000000000000000000000000000000000000000000000000000000020 |
                // | 0x40:0x5f | size of m  | 0x0000000000000000000000000000000000000000000000000000000000000020 |
                // | 0x60:0x7f | value of b | 0x<.............................................................b> |
                // | 0x80:0x9f | value of e | 0x<.............................................................e> |
                // | 0xa0:0xbf | value of m | 0x<.............................................................m> |
                mstore(ptr, 0x20)
                mstore(add(ptr, 0x20), 0x20)
                mstore(add(ptr, 0x40), 0x20)
                mstore(add(ptr, 0x60), b)
                mstore(add(ptr, 0x80), e)
                mstore(add(ptr, 0xa0), m)
    
                // Given the result < m, it's guaranteed to fit in 32 bytes,
                // so we can use the memory scratch space located at offset 0.
                success := staticcall(gas(), 0x05, ptr, 0xc0, 0x00, 0x20)
                result := mload(0x00)
            }
        }
    
        /**
         * @dev Variant of {modExp} that supports inputs of arbitrary length.
         */
        function modExp(bytes memory b, bytes memory e, bytes memory m) internal view returns (bytes memory) {
            (bool success, bytes memory result) = tryModExp(b, e, m);
            if (!success) {
                Panic.panic(Panic.DIVISION_BY_ZERO);
            }
            return result;
        }
    
        /**
         * @dev Variant of {tryModExp} that supports inputs of arbitrary length.
         */
        function tryModExp(
            bytes memory b,
            bytes memory e,
            bytes memory m
        ) internal view returns (bool success, bytes memory result) {
            if (_zeroBytes(m)) return (false, new bytes(0));
    
            uint256 mLen = m.length;
    
            // Encode call args in result and move the free memory pointer
            result = abi.encodePacked(b.length, e.length, mLen, b, e, m);
    
            assembly ("memory-safe") {
                let dataPtr := add(result, 0x20)
                // Write result on top of args to avoid allocating extra memory.
                success := staticcall(gas(), 0x05, dataPtr, mload(result), dataPtr, mLen)
                // Overwrite the length.
                // result.length > returndatasize() is guaranteed because returndatasize() == m.length
                mstore(result, mLen)
                // Set the memory pointer after the returned data.
                mstore(0x40, add(dataPtr, mLen))
            }
        }
    
        /**
         * @dev Returns whether the provided byte array is zero.
         */
        function _zeroBytes(bytes memory byteArray) private pure returns (bool) {
            for (uint256 i = 0; i < byteArray.length; ++i) {
                if (byteArray[i] != 0) {
                    return false;
                }
            }
            return true;
        }
    
        /**
         * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded
         * towards zero.
         *
         * This method is based on Newton's method for computing square roots; the algorithm is restricted to only
         * using integer operations.
         */
        function sqrt(uint256 a) internal pure returns (uint256) {
            unchecked {
                // Take care of easy edge cases when a == 0 or a == 1
                if (a <= 1) {
                    return a;
                }
    
                // In this function, we use Newton's method to get a root of `f(x) := x² - a`. It involves building a
                // sequence x_n that converges toward sqrt(a). For each iteration x_n, we also define the error between
                // the current value as `ε_n = | x_n - sqrt(a) |`.
                //
                // For our first estimation, we consider `e` the smallest power of 2 which is bigger than the square root
                // of the target. (i.e. `2**(e-1) ≤ sqrt(a) < 2**e`). We know that `e ≤ 128` because `(2¹²⁸)² = 2²⁵⁶` is
                // bigger than any uint256.
                //
                // By noticing that
                // `2**(e-1) ≤ sqrt(a) < 2**e → (2**(e-1))² ≤ a < (2**e)² → 2**(2*e-2) ≤ a < 2**(2*e)`
                // we can deduce that `e - 1` is `log2(a) / 2`. We can thus compute `x_n = 2**(e-1)` using a method similar
                // to the msb function.
                uint256 aa = a;
                uint256 xn = 1;
    
                if (aa >= (1 << 128)) {
                    aa >>= 128;
                    xn <<= 64;
                }
                if (aa >= (1 << 64)) {
                    aa >>= 64;
                    xn <<= 32;
                }
                if (aa >= (1 << 32)) {
                    aa >>= 32;
                    xn <<= 16;
                }
                if (aa >= (1 << 16)) {
                    aa >>= 16;
                    xn <<= 8;
                }
                if (aa >= (1 << 8)) {
                    aa >>= 8;
                    xn <<= 4;
                }
                if (aa >= (1 << 4)) {
                    aa >>= 4;
                    xn <<= 2;
                }
                if (aa >= (1 << 2)) {
                    xn <<= 1;
                }
    
                // We now have x_n such that `x_n = 2**(e-1) ≤ sqrt(a) < 2**e = 2 * x_n`. This implies ε_n ≤ 2**(e-1).
                //
                // We can refine our estimation by noticing that the middle of that interval minimizes the error.
                // If we move x_n to equal 2**(e-1) + 2**(e-2), then we reduce the error to ε_n ≤ 2**(e-2).
                // This is going to be our x_0 (and ε_0)
                xn = (3 * xn) >> 1; // ε_0 := | x_0 - sqrt(a) | ≤ 2**(e-2)
    
                // From here, Newton's method give us:
                // x_{n+1} = (x_n + a / x_n) / 2
                //
                // One should note that:
                // x_{n+1}² - a = ((x_n + a / x_n) / 2)² - a
                //              = ((x_n² + a) / (2 * x_n))² - a
                //              = (x_n⁴ + 2 * a * x_n² + a²) / (4 * x_n²) - a
                //              = (x_n⁴ + 2 * a * x_n² + a² - 4 * a * x_n²) / (4 * x_n²)
                //              = (x_n⁴ - 2 * a * x_n² + a²) / (4 * x_n²)
                //              = (x_n² - a)² / (2 * x_n)²
                //              = ((x_n² - a) / (2 * x_n))²
                //              ≥ 0
                // Which proves that for all n ≥ 1, sqrt(a) ≤ x_n
                //
                // This gives us the proof of quadratic convergence of the sequence:
                // ε_{n+1} = | x_{n+1} - sqrt(a) |
                //         = | (x_n + a / x_n) / 2 - sqrt(a) |
                //         = | (x_n² + a - 2*x_n*sqrt(a)) / (2 * x_n) |
                //         = | (x_n - sqrt(a))² / (2 * x_n) |
                //         = | ε_n² / (2 * x_n) |
                //         = ε_n² / | (2 * x_n) |
                //
                // For the first iteration, we have a special case where x_0 is known:
                // ε_1 = ε_0² / | (2 * x_0) |
                //     ≤ (2**(e-2))² / (2 * (2**(e-1) + 2**(e-2)))
                //     ≤ 2**(2*e-4) / (3 * 2**(e-1))
                //     ≤ 2**(e-3) / 3
                //     ≤ 2**(e-3-log2(3))
                //     ≤ 2**(e-4.5)
                //
                // For the following iterations, we use the fact that, 2**(e-1) ≤ sqrt(a) ≤ x_n:
                // ε_{n+1} = ε_n² / | (2 * x_n) |
                //         ≤ (2**(e-k))² / (2 * 2**(e-1))
                //         ≤ 2**(2*e-2*k) / 2**e
                //         ≤ 2**(e-2*k)
                xn = (xn + a / xn) >> 1; // ε_1 := | x_1 - sqrt(a) | ≤ 2**(e-4.5)  -- special case, see above
                xn = (xn + a / xn) >> 1; // ε_2 := | x_2 - sqrt(a) | ≤ 2**(e-9)    -- general case with k = 4.5
                xn = (xn + a / xn) >> 1; // ε_3 := | x_3 - sqrt(a) | ≤ 2**(e-18)   -- general case with k = 9
                xn = (xn + a / xn) >> 1; // ε_4 := | x_4 - sqrt(a) | ≤ 2**(e-36)   -- general case with k = 18
                xn = (xn + a / xn) >> 1; // ε_5 := | x_5 - sqrt(a) | ≤ 2**(e-72)   -- general case with k = 36
                xn = (xn + a / xn) >> 1; // ε_6 := | x_6 - sqrt(a) | ≤ 2**(e-144)  -- general case with k = 72
    
                // Because e ≤ 128 (as discussed during the first estimation phase), we know have reached a precision
                // ε_6 ≤ 2**(e-144) < 1. Given we're operating on integers, then we can ensure that xn is now either
                // sqrt(a) or sqrt(a) + 1.
                return xn - SafeCast.toUint(xn > a / xn);
            }
        }
    
        /**
         * @dev Calculates sqrt(a), following the selected rounding direction.
         */
        function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
            unchecked {
                uint256 result = sqrt(a);
                return result + SafeCast.toUint(unsignedRoundsUp(rounding) && result * result < a);
            }
        }
    
        /**
         * @dev Return the log in base 2 of a positive value rounded towards zero.
         * Returns 0 if given 0.
         */
        function log2(uint256 value) internal pure returns (uint256) {
            uint256 result = 0;
            uint256 exp;
            unchecked {
                exp = 128 * SafeCast.toUint(value > (1 << 128) - 1);
                value >>= exp;
                result += exp;
    
                exp = 64 * SafeCast.toUint(value > (1 << 64) - 1);
                value >>= exp;
                result += exp;
    
                exp = 32 * SafeCast.toUint(value > (1 << 32) - 1);
                value >>= exp;
                result += exp;
    
                exp = 16 * SafeCast.toUint(value > (1 << 16) - 1);
                value >>= exp;
                result += exp;
    
                exp = 8 * SafeCast.toUint(value > (1 << 8) - 1);
                value >>= exp;
                result += exp;
    
                exp = 4 * SafeCast.toUint(value > (1 << 4) - 1);
                value >>= exp;
                result += exp;
    
                exp = 2 * SafeCast.toUint(value > (1 << 2) - 1);
                value >>= exp;
                result += exp;
    
                result += SafeCast.toUint(value > 1);
            }
            return result;
        }
    
        /**
         * @dev Return the log in base 2, following the selected rounding direction, of a positive value.
         * Returns 0 if given 0.
         */
        function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
            unchecked {
                uint256 result = log2(value);
                return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 1 << result < value);
            }
        }
    
        /**
         * @dev Return the log in base 10 of a positive value rounded towards zero.
         * Returns 0 if given 0.
         */
        function log10(uint256 value) internal pure returns (uint256) {
            uint256 result = 0;
            unchecked {
                if (value >= 10 ** 64) {
                    value /= 10 ** 64;
                    result += 64;
                }
                if (value >= 10 ** 32) {
                    value /= 10 ** 32;
                    result += 32;
                }
                if (value >= 10 ** 16) {
                    value /= 10 ** 16;
                    result += 16;
                }
                if (value >= 10 ** 8) {
                    value /= 10 ** 8;
                    result += 8;
                }
                if (value >= 10 ** 4) {
                    value /= 10 ** 4;
                    result += 4;
                }
                if (value >= 10 ** 2) {
                    value /= 10 ** 2;
                    result += 2;
                }
                if (value >= 10 ** 1) {
                    result += 1;
                }
            }
            return result;
        }
    
        /**
         * @dev Return the log in base 10, following the selected rounding direction, of a positive value.
         * Returns 0 if given 0.
         */
        function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
            unchecked {
                uint256 result = log10(value);
                return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 10 ** result < value);
            }
        }
    
        /**
         * @dev Return the log in base 256 of a positive value rounded towards zero.
         * Returns 0 if given 0.
         *
         * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.
         */
        function log256(uint256 value) internal pure returns (uint256) {
            uint256 result = 0;
            uint256 isGt;
            unchecked {
                isGt = SafeCast.toUint(value > (1 << 128) - 1);
                value >>= isGt * 128;
                result += isGt * 16;
    
                isGt = SafeCast.toUint(value > (1 << 64) - 1);
                value >>= isGt * 64;
                result += isGt * 8;
    
                isGt = SafeCast.toUint(value > (1 << 32) - 1);
                value >>= isGt * 32;
                result += isGt * 4;
    
                isGt = SafeCast.toUint(value > (1 << 16) - 1);
                value >>= isGt * 16;
                result += isGt * 2;
    
                result += SafeCast.toUint(value > (1 << 8) - 1);
            }
            return result;
        }
    
        /**
         * @dev Return the log in base 256, following the selected rounding direction, of a positive value.
         * Returns 0 if given 0.
         */
        function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
            unchecked {
                uint256 result = log256(value);
                return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 1 << (result << 3) < value);
            }
        }
    
        /**
         * @dev Returns whether a provided rounding mode is considered rounding up for unsigned integers.
         */
        function unsignedRoundsUp(Rounding rounding) internal pure returns (bool) {
            return uint8(rounding) % 2 == 1;
        }
    }

    // SPDX-License-Identifier: MIT
    pragma solidity ^0.8.26;
    
    import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
    import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
    import {IERC20Permit} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Permit.sol";
    
    interface IERC20Extended is IERC20, IERC20Metadata, IERC20Permit {
        function mint(address account, uint256 amount) external;
    
        function burn(uint256 amount) external;
    
        function transfer(address to, uint256 value) external returns (bool);
    
        function transferFrom(
            address from,
            address to,
            uint256 value
        ) external returns (bool);
    
        function burnFrom(address account, uint256 value) external;
    }

    // SPDX-License-Identifier: MIT
    pragma solidity ^0.8.26;
    
    // a library for handling binary fixed point numbers (https://en.wikipedia.org/wiki/Q_(number_format))
    
    // range: [0, 2**112 - 1]
    // resolution: 1 / 2**112
    
    library UQ112x112 {
        uint224 constant Q112 = 2 ** 112;
    
        // encode a uint112 as a UQ112x112
        function encode(uint112 y) internal pure returns (uint224 z) {
            unchecked {
                z = uint224(y) * Q112; // never overflows
            }
        }
    
        // divide a UQ112x112 by a uint112, returning a UQ112x112
        function uqdiv(uint224 x, uint112 y) internal pure returns (uint224 z) {
            unchecked {
                z = x / uint224(y);
            }
        }
    }

    // SPDX-License-Identifier: MIT
    pragma solidity ^0.8.26;
    
    interface IPairCallee {
        function hook(
            address sender,
            uint256 amount0,
            uint256 amount1,
            bytes calldata data
        ) external;
    }

    // SPDX-License-Identifier: GPL-2.0-or-later
    pragma solidity ^0.8.26;
    
    interface IPairFactory {
        error FEE_TOO_HIGH();
        error ZERO_FEE();
        /// @dev invalid assortment
        error IA();
        /// @dev zero address
        error ZA();
        /// @dev pair exists
        error PE();
        error NOT_AUTHORIZED();
        error INVALID_FEE_SPLIT();
    
        event PairCreated(
            address indexed token0,
            address indexed token1,
            address pair,
            uint256
        );
    
        event SetFee(uint256 indexed fee);
    
        event SetPairFee(address indexed pair, uint256 indexed fee);
    
        event SetFeeSplit(uint256 indexed _feeSplit);
    
        event SetPairFeeSplit(address indexed pair, uint256 indexed _feeSplit);
    
        event SkimStatus(address indexed _pair, bool indexed _status);
    
        event NewTreasury(address indexed _caller, address indexed _newTreasury);
    
        event FeeSplitWhenNoGauge(address indexed _caller, bool indexed _status);
    
        event SetFeeRecipient(address indexed pair, address indexed feeRecipient);
    
        /// @notice returns the total length of legacy pairs
        /// @return _length the length
        function allPairsLength() external view returns (uint256 _length);
    
        /// @notice calculates if the address is a legacy pair
        /// @param pair the address to check
        /// @return _boolean the bool return
        function isPair(address pair) external view returns (bool _boolean);
    
        /// @notice calculates the pairCodeHash
        /// @return _hash the pair code hash
        function pairCodeHash() external view returns (bytes32 _hash);
    
        /// @param tokenA address of tokenA
        /// @param tokenB address of tokenB
        /// @param stable whether it uses the stable curve
        /// @return _pair the address of the pair
        function getPair(
            address tokenA,
            address tokenB,
            bool stable
        ) external view returns (address _pair);
    
        /// @notice creates a new legacy pair
        /// @param tokenA address of tokenA
        /// @param tokenB address of tokenB
        /// @param stable whether it uses the stable curve
        /// @return pair the address of the created pair
        function createPair(
            address tokenA,
            address tokenB,
            bool stable
        ) external returns (address pair);
    
        /// @notice the address of the voter
        /// @return _voter the address of the voter
        function voter() external view returns (address _voter);
    
        /// @notice returns the address of a pair based on the index
        /// @param _index the index to check for a pair
        /// @return _pair the address of the pair at the index
        function allPairs(uint256 _index) external view returns (address _pair);
    
        /// @notice the swap fee of a pair
        /// @param _pair the address of the pair
        /// @return _fee the fee
        function pairFee(address _pair) external view returns (uint256 _fee);
    
        /// @notice the split of fees
        /// @return _split the feeSplit
        function feeSplit() external view returns (uint256 _split);
    
        /// @notice sets the swap fee for a pair
        /// @param _pair the address of the pair
        /// @param _fee the fee for the pair
        function setPairFee(address _pair, uint256 _fee) external;
    
        /// @notice set the swap fees of the pair
        /// @param _fee the fee, scaled to MAX 10% of 100_000
        function setFee(uint256 _fee) external;
    
        /// @notice the address for the treasury
        /// @return _treasury address of the treasury
        function treasury() external view returns (address _treasury);
    
        /// @notice sets the pairFees contract
        /// @param _pair the address of the pair
        /// @param _pairFees the address of the new Pair Fees
        function setFeeRecipient(address _pair, address _pairFees) external;
    
        /// @notice sets the feeSplit for a pair
        /// @param _pair the address of the pair
        /// @param _feeSplit the feeSplit
        function setPairFeeSplit(address _pair, uint256 _feeSplit) external;
    
        /// @notice whether there is feeSplit when there's no gauge
        /// @return _boolean whether there is a feesplit when no gauge
        function feeSplitWhenNoGauge() external view returns (bool _boolean);
    
        /// @notice whether a pair can be skimmed
        /// @param _pair the pair address
        /// @return _boolean whether skim is enabled
        function skimEnabled(address _pair) external view returns (bool _boolean);
    
        /// @notice set whether skim is enabled for a specific pair
        function setSkimEnabled(address _pair, bool _status) external;
    
        /// @notice sets a new treasury address
        /// @param _treasury the new treasury address
        function setTreasury(address _treasury) external;
    
        /// @notice set whether there should be a feesplit without gauges
        /// @param status whether enabled or not
        function setFeeSplitWhenNoGauge(bool status) external;
    
        /// @notice sets the feesSplit globally
        /// @param _feeSplit the fee split
        function setFeeSplit(uint256 _feeSplit) external;
    }

    // SPDX-License-Identifier: GPL-2.0-or-later
    pragma solidity ^0.8.26;
    
    interface IPair {
        error NOT_AUTHORIZED();
        error UNSTABLE_RATIO();
        /// @dev safe transfer failed
        error STF();
        error OVERFLOW();
        /// @dev skim disabled
        error SD();
        /// @dev insufficient liquidity minted
        error ILM();
        /// @dev insufficient liquidity burned
        error ILB();
        /// @dev insufficient output amount
        error IOA();
        /// @dev insufficient input amount
        error IIA();
        error IL();
        error IT();
        error K();
    
        event Mint(address indexed sender, uint256 amount0, uint256 amount1);
        event Burn(
            address indexed sender,
            uint256 amount0,
            uint256 amount1,
            address indexed to
        );
        event Swap(
            address indexed sender,
            uint256 amount0In,
            uint256 amount1In,
            uint256 amount0Out,
            uint256 amount1Out,
            address indexed to
        );
        event Sync(uint112 reserve0, uint112 reserve1);
    
        /// @notice initialize the pool, called only once programatically
        function initialize(
            address _token0,
            address _token1,
            bool _stable
        ) external;
    
        /// @notice calculate the current reserves of the pool and their last 'seen' timestamp
        /// @return _reserve0 amount of token0 in reserves
        /// @return _reserve1 amount of token1 in reserves
        /// @return _blockTimestampLast the timestamp when the pool was last updated
        function getReserves()
            external
            view
            returns (
                uint112 _reserve0,
                uint112 _reserve1,
                uint32 _blockTimestampLast
            );
    
        /// @notice mint the pair tokens (LPs)
        /// @param to where to mint the LP tokens to
        /// @return liquidity amount of LP tokens to mint
        function mint(address to) external returns (uint256 liquidity);
    
        /// @notice burn the pair tokens (LPs)
        /// @param to where to send the underlying
        /// @return amount0 amount of amount0
        /// @return amount1 amount of amount1
        function burn(
            address to
        ) external returns (uint256 amount0, uint256 amount1);
    
        /// @notice direct swap through the pool
        function swap(
            uint256 amount0Out,
            uint256 amount1Out,
            address to,
            bytes calldata data
        ) external;
    
        /// @notice force balances to match reserves, can be used to harvest rebases from rebasing tokens or other external factors
        /// @param to where to send the excess tokens to
        function skim(address to) external;
    
        /// @notice force reserves to match balances, prevents skim excess if skim is enabled
        function sync() external;
    
        /// @notice set the pair fees contract address
        function setFeeRecipient(address _pairFees) external;
    
        /// @notice set the feesplit variable
        function setFeeSplit(uint256 _feeSplit) external;
    
        /// @notice sets the swap fee of the pair
        /// @dev max of 10_000 (10%)
        /// @param _fee the fee
        function setFee(uint256 _fee) external;
    
        /// @notice 'mint' the fees as LP tokens
        /// @dev this is used for protocol/voter fees
        function mintFee() external;
    
        /// @notice calculates the amount of tokens to receive post swap
        /// @param amountIn the token amount
        /// @param tokenIn the address of the token
        function getAmountOut(
            uint256 amountIn,
            address tokenIn
        ) external view returns (uint256 amountOut);
    
        /// @notice returns various metadata about the pair
        function metadata()
            external
            view
            returns (
                uint256 _decimals0,
                uint256 _decimals1,
                uint256 _reserve0,
                uint256 _reserve1,
                bool _stable,
                address _token0,
                address _token1
            );
    
        /// @notice returns the feeSplit of the pair
        function feeSplit() external view returns (uint256);
    
        /// @notice returns the fee of the pair
        function fee() external view returns (uint256);
    
        /// @notice returns the feeRecipient of the pair
        function feeRecipient() external view returns (address);
    
    }

    // SPDX-License-Identifier: MIT
    // OpenZeppelin Contracts (last updated v5.1.0) (token/ERC20/IERC20.sol)
    
    pragma solidity ^0.8.20;
    
    /**
     * @dev Interface of the ERC-20 standard as defined in the ERC.
     */
    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 value of tokens in existence.
         */
        function totalSupply() external view returns (uint256);
    
        /**
         * @dev Returns the value of tokens owned by `account`.
         */
        function balanceOf(address account) external view returns (uint256);
    
        /**
         * @dev Moves a `value` amount of 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 value) 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 a `value` amount of tokens 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 value) external returns (bool);
    
        /**
         * @dev Moves a `value` amount of tokens from `from` to `to` using the
         * allowance mechanism. `value` 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 value) external returns (bool);
    }

    // SPDX-License-Identifier: MIT
    // OpenZeppelin Contracts (last updated v5.1.0) (token/ERC20/extensions/IERC20Metadata.sol)
    
    pragma solidity ^0.8.20;
    
    import {IERC20} from "../IERC20.sol";
    
    /**
     * @dev Interface for the optional metadata functions from the ERC-20 standard.
     */
    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);
    }

    // SPDX-License-Identifier: MIT
    // OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol)
    
    pragma solidity ^0.8.20;
    
    /**
     * @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;
        }
    
        function _contextSuffixLength() internal view virtual returns (uint256) {
            return 0;
        }
    }

    // SPDX-License-Identifier: MIT
    // OpenZeppelin Contracts (last updated v5.1.0) (interfaces/draft-IERC6093.sol)
    pragma solidity ^0.8.20;
    
    /**
     * @dev Standard ERC-20 Errors
     * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC-20 tokens.
     */
    interface IERC20Errors {
        /**
         * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.
         * @param sender Address whose tokens are being transferred.
         * @param balance Current balance for the interacting account.
         * @param needed Minimum amount required to perform a transfer.
         */
        error ERC20InsufficientBalance(address sender, uint256 balance, uint256 needed);
    
        /**
         * @dev Indicates a failure with the token `sender`. Used in transfers.
         * @param sender Address whose tokens are being transferred.
         */
        error ERC20InvalidSender(address sender);
    
        /**
         * @dev Indicates a failure with the token `receiver`. Used in transfers.
         * @param receiver Address to which tokens are being transferred.
         */
        error ERC20InvalidReceiver(address receiver);
    
        /**
         * @dev Indicates a failure with the `spender`’s `allowance`. Used in transfers.
         * @param spender Address that may be allowed to operate on tokens without being their owner.
         * @param allowance Amount of tokens a `spender` is allowed to operate with.
         * @param needed Minimum amount required to perform a transfer.
         */
        error ERC20InsufficientAllowance(address spender, uint256 allowance, uint256 needed);
    
        /**
         * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
         * @param approver Address initiating an approval operation.
         */
        error ERC20InvalidApprover(address approver);
    
        /**
         * @dev Indicates a failure with the `spender` to be approved. Used in approvals.
         * @param spender Address that may be allowed to operate on tokens without being their owner.
         */
        error ERC20InvalidSpender(address spender);
    }
    
    /**
     * @dev Standard ERC-721 Errors
     * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC-721 tokens.
     */
    interface IERC721Errors {
        /**
         * @dev Indicates that an address can't be an owner. For example, `address(0)` is a forbidden owner in ERC-20.
         * Used in balance queries.
         * @param owner Address of the current owner of a token.
         */
        error ERC721InvalidOwner(address owner);
    
        /**
         * @dev Indicates a `tokenId` whose `owner` is the zero address.
         * @param tokenId Identifier number of a token.
         */
        error ERC721NonexistentToken(uint256 tokenId);
    
        /**
         * @dev Indicates an error related to the ownership over a particular token. Used in transfers.
         * @param sender Address whose tokens are being transferred.
         * @param tokenId Identifier number of a token.
         * @param owner Address of the current owner of a token.
         */
        error ERC721IncorrectOwner(address sender, uint256 tokenId, address owner);
    
        /**
         * @dev Indicates a failure with the token `sender`. Used in transfers.
         * @param sender Address whose tokens are being transferred.
         */
        error ERC721InvalidSender(address sender);
    
        /**
         * @dev Indicates a failure with the token `receiver`. Used in transfers.
         * @param receiver Address to which tokens are being transferred.
         */
        error ERC721InvalidReceiver(address receiver);
    
        /**
         * @dev Indicates a failure with the `operator`’s approval. Used in transfers.
         * @param operator Address that may be allowed to operate on tokens without being their owner.
         * @param tokenId Identifier number of a token.
         */
        error ERC721InsufficientApproval(address operator, uint256 tokenId);
    
        /**
         * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
         * @param approver Address initiating an approval operation.
         */
        error ERC721InvalidApprover(address approver);
    
        /**
         * @dev Indicates a failure with the `operator` to be approved. Used in approvals.
         * @param operator Address that may be allowed to operate on tokens without being their owner.
         */
        error ERC721InvalidOperator(address operator);
    }
    
    /**
     * @dev Standard ERC-1155 Errors
     * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC-1155 tokens.
     */
    interface IERC1155Errors {
        /**
         * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.
         * @param sender Address whose tokens are being transferred.
         * @param balance Current balance for the interacting account.
         * @param needed Minimum amount required to perform a transfer.
         * @param tokenId Identifier number of a token.
         */
        error ERC1155InsufficientBalance(address sender, uint256 balance, uint256 needed, uint256 tokenId);
    
        /**
         * @dev Indicates a failure with the token `sender`. Used in transfers.
         * @param sender Address whose tokens are being transferred.
         */
        error ERC1155InvalidSender(address sender);
    
        /**
         * @dev Indicates a failure with the token `receiver`. Used in transfers.
         * @param receiver Address to which tokens are being transferred.
         */
        error ERC1155InvalidReceiver(address receiver);
    
        /**
         * @dev Indicates a failure with the `operator`’s approval. Used in transfers.
         * @param operator Address that may be allowed to operate on tokens without being their owner.
         * @param owner Address of the current owner of a token.
         */
        error ERC1155MissingApprovalForAll(address operator, address owner);
    
        /**
         * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
         * @param approver Address initiating an approval operation.
         */
        error ERC1155InvalidApprover(address approver);
    
        /**
         * @dev Indicates a failure with the `operator` to be approved. Used in approvals.
         * @param operator Address that may be allowed to operate on tokens without being their owner.
         */
        error ERC1155InvalidOperator(address operator);
    
        /**
         * @dev Indicates an array length mismatch between ids and values in a safeBatchTransferFrom operation.
         * Used in batch transfers.
         * @param idsLength Length of the array of token identifiers
         * @param valuesLength Length of the array of token amounts
         */
        error ERC1155InvalidArrayLength(uint256 idsLength, uint256 valuesLength);
    }

    // SPDX-License-Identifier: MIT
    // OpenZeppelin Contracts (last updated v5.1.0) (utils/Panic.sol)
    
    pragma solidity ^0.8.20;
    
    /**
     * @dev Helper library for emitting standardized panic codes.
     *
     * ```solidity
     * contract Example {
     *      using Panic for uint256;
     *
     *      // Use any of the declared internal constants
     *      function foo() { Panic.GENERIC.panic(); }
     *
     *      // Alternatively
     *      function foo() { Panic.panic(Panic.GENERIC); }
     * }
     * ```
     *
     * Follows the list from https://github.com/ethereum/solidity/blob/v0.8.24/libsolutil/ErrorCodes.h[libsolutil].
     *
     * _Available since v5.1._
     */
    // slither-disable-next-line unused-state
    library Panic {
        /// @dev generic / unspecified error
        uint256 internal constant GENERIC = 0x00;
        /// @dev used by the assert() builtin
        uint256 internal constant ASSERT = 0x01;
        /// @dev arithmetic underflow or overflow
        uint256 internal constant UNDER_OVERFLOW = 0x11;
        /// @dev division or modulo by zero
        uint256 internal constant DIVISION_BY_ZERO = 0x12;
        /// @dev enum conversion error
        uint256 internal constant ENUM_CONVERSION_ERROR = 0x21;
        /// @dev invalid encoding in storage
        uint256 internal constant STORAGE_ENCODING_ERROR = 0x22;
        /// @dev empty array pop
        uint256 internal constant EMPTY_ARRAY_POP = 0x31;
        /// @dev array out of bounds access
        uint256 internal constant ARRAY_OUT_OF_BOUNDS = 0x32;
        /// @dev resource error (too large allocation or too large array)
        uint256 internal constant RESOURCE_ERROR = 0x41;
        /// @dev calling invalid internal function
        uint256 internal constant INVALID_INTERNAL_FUNCTION = 0x51;
    
        /// @dev Reverts with a panic code. Recommended to use with
        /// the internal constants with predefined codes.
        function panic(uint256 code) internal pure {
            assembly ("memory-safe") {
                mstore(0x00, 0x4e487b71)
                mstore(0x20, code)
                revert(0x1c, 0x24)
            }
        }
    }

    // SPDX-License-Identifier: MIT
    // OpenZeppelin Contracts (last updated v5.1.0) (utils/math/SafeCast.sol)
    // This file was procedurally generated from scripts/generate/templates/SafeCast.js.
    
    pragma solidity ^0.8.20;
    
    /**
     * @dev Wrappers over Solidity's uintXX/intXX/bool casting operators with added overflow
     * checks.
     *
     * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can
     * easily result in undesired exploitation or bugs, since developers usually
     * assume that overflows raise errors. `SafeCast` restores this intuition by
     * reverting the transaction when such an operation overflows.
     *
     * Using this library instead of the unchecked operations eliminates an entire
     * class of bugs, so it's recommended to use it always.
     */
    library SafeCast {
        /**
         * @dev Value doesn't fit in an uint of `bits` size.
         */
        error SafeCastOverflowedUintDowncast(uint8 bits, uint256 value);
    
        /**
         * @dev An int value doesn't fit in an uint of `bits` size.
         */
        error SafeCastOverflowedIntToUint(int256 value);
    
        /**
         * @dev Value doesn't fit in an int of `bits` size.
         */
        error SafeCastOverflowedIntDowncast(uint8 bits, int256 value);
    
        /**
         * @dev An uint value doesn't fit in an int of `bits` size.
         */
        error SafeCastOverflowedUintToInt(uint256 value);
    
        /**
         * @dev Returns the downcasted uint248 from uint256, reverting on
         * overflow (when the input is greater than largest uint248).
         *
         * Counterpart to Solidity's `uint248` operator.
         *
         * Requirements:
         *
         * - input must fit into 248 bits
         */
        function toUint248(uint256 value) internal pure returns (uint248) {
            if (value > type(uint248).max) {
                revert SafeCastOverflowedUintDowncast(248, value);
            }
            return uint248(value);
        }
    
        /**
         * @dev Returns the downcasted uint240 from uint256, reverting on
         * overflow (when the input is greater than largest uint240).
         *
         * Counterpart to Solidity's `uint240` operator.
         *
         * Requirements:
         *
         * - input must fit into 240 bits
         */
        function toUint240(uint256 value) internal pure returns (uint240) {
            if (value > type(uint240).max) {
                revert SafeCastOverflowedUintDowncast(240, value);
            }
            return uint240(value);
        }
    
        /**
         * @dev Returns the downcasted uint232 from uint256, reverting on
         * overflow (when the input is greater than largest uint232).
         *
         * Counterpart to Solidity's `uint232` operator.
         *
         * Requirements:
         *
         * - input must fit into 232 bits
         */
        function toUint232(uint256 value) internal pure returns (uint232) {
            if (value > type(uint232).max) {
                revert SafeCastOverflowedUintDowncast(232, value);
            }
            return uint232(value);
        }
    
        /**
         * @dev Returns the downcasted uint224 from uint256, reverting on
         * overflow (when the input is greater than largest uint224).
         *
         * Counterpart to Solidity's `uint224` operator.
         *
         * Requirements:
         *
         * - input must fit into 224 bits
         */
        function toUint224(uint256 value) internal pure returns (uint224) {
            if (value > type(uint224).max) {
                revert SafeCastOverflowedUintDowncast(224, value);
            }
            return uint224(value);
        }
    
        /**
         * @dev Returns the downcasted uint216 from uint256, reverting on
         * overflow (when the input is greater than largest uint216).
         *
         * Counterpart to Solidity's `uint216` operator.
         *
         * Requirements:
         *
         * - input must fit into 216 bits
         */
        function toUint216(uint256 value) internal pure returns (uint216) {
            if (value > type(uint216).max) {
                revert SafeCastOverflowedUintDowncast(216, value);
            }
            return uint216(value);
        }
    
        /**
         * @dev Returns the downcasted uint208 from uint256, reverting on
         * overflow (when the input is greater than largest uint208).
         *
         * Counterpart to Solidity's `uint208` operator.
         *
         * Requirements:
         *
         * - input must fit into 208 bits
         */
        function toUint208(uint256 value) internal pure returns (uint208) {
            if (value > type(uint208).max) {
                revert SafeCastOverflowedUintDowncast(208, value);
            }
            return uint208(value);
        }
    
        /**
         * @dev Returns the downcasted uint200 from uint256, reverting on
         * overflow (when the input is greater than largest uint200).
         *
         * Counterpart to Solidity's `uint200` operator.
         *
         * Requirements:
         *
         * - input must fit into 200 bits
         */
        function toUint200(uint256 value) internal pure returns (uint200) {
            if (value > type(uint200).max) {
                revert SafeCastOverflowedUintDowncast(200, value);
            }
            return uint200(value);
        }
    
        /**
         * @dev Returns the downcasted uint192 from uint256, reverting on
         * overflow (when the input is greater than largest uint192).
         *
         * Counterpart to Solidity's `uint192` operator.
         *
         * Requirements:
         *
         * - input must fit into 192 bits
         */
        function toUint192(uint256 value) internal pure returns (uint192) {
            if (value > type(uint192).max) {
                revert SafeCastOverflowedUintDowncast(192, value);
            }
            return uint192(value);
        }
    
        /**
         * @dev Returns the downcasted uint184 from uint256, reverting on
         * overflow (when the input is greater than largest uint184).
         *
         * Counterpart to Solidity's `uint184` operator.
         *
         * Requirements:
         *
         * - input must fit into 184 bits
         */
        function toUint184(uint256 value) internal pure returns (uint184) {
            if (value > type(uint184).max) {
                revert SafeCastOverflowedUintDowncast(184, value);
            }
            return uint184(value);
        }
    
        /**
         * @dev Returns the downcasted uint176 from uint256, reverting on
         * overflow (when the input is greater than largest uint176).
         *
         * Counterpart to Solidity's `uint176` operator.
         *
         * Requirements:
         *
         * - input must fit into 176 bits
         */
        function toUint176(uint256 value) internal pure returns (uint176) {
            if (value > type(uint176).max) {
                revert SafeCastOverflowedUintDowncast(176, value);
            }
            return uint176(value);
        }
    
        /**
         * @dev Returns the downcasted uint168 from uint256, reverting on
         * overflow (when the input is greater than largest uint168).
         *
         * Counterpart to Solidity's `uint168` operator.
         *
         * Requirements:
         *
         * - input must fit into 168 bits
         */
        function toUint168(uint256 value) internal pure returns (uint168) {
            if (value > type(uint168).max) {
                revert SafeCastOverflowedUintDowncast(168, value);
            }
            return uint168(value);
        }
    
        /**
         * @dev Returns the downcasted uint160 from uint256, reverting on
         * overflow (when the input is greater than largest uint160).
         *
         * Counterpart to Solidity's `uint160` operator.
         *
         * Requirements:
         *
         * - input must fit into 160 bits
         */
        function toUint160(uint256 value) internal pure returns (uint160) {
            if (value > type(uint160).max) {
                revert SafeCastOverflowedUintDowncast(160, value);
            }
            return uint160(value);
        }
    
        /**
         * @dev Returns the downcasted uint152 from uint256, reverting on
         * overflow (when the input is greater than largest uint152).
         *
         * Counterpart to Solidity's `uint152` operator.
         *
         * Requirements:
         *
         * - input must fit into 152 bits
         */
        function toUint152(uint256 value) internal pure returns (uint152) {
            if (value > type(uint152).max) {
                revert SafeCastOverflowedUintDowncast(152, value);
            }
            return uint152(value);
        }
    
        /**
         * @dev Returns the downcasted uint144 from uint256, reverting on
         * overflow (when the input is greater than largest uint144).
         *
         * Counterpart to Solidity's `uint144` operator.
         *
         * Requirements:
         *
         * - input must fit into 144 bits
         */
        function toUint144(uint256 value) internal pure returns (uint144) {
            if (value > type(uint144).max) {
                revert SafeCastOverflowedUintDowncast(144, value);
            }
            return uint144(value);
        }
    
        /**
         * @dev Returns the downcasted uint136 from uint256, reverting on
         * overflow (when the input is greater than largest uint136).
         *
         * Counterpart to Solidity's `uint136` operator.
         *
         * Requirements:
         *
         * - input must fit into 136 bits
         */
        function toUint136(uint256 value) internal pure returns (uint136) {
            if (value > type(uint136).max) {
                revert SafeCastOverflowedUintDowncast(136, value);
            }
            return uint136(value);
        }
    
        /**
         * @dev Returns the downcasted uint128 from uint256, reverting on
         * overflow (when the input is greater than largest uint128).
         *
         * Counterpart to Solidity's `uint128` operator.
         *
         * Requirements:
         *
         * - input must fit into 128 bits
         */
        function toUint128(uint256 value) internal pure returns (uint128) {
            if (value > type(uint128).max) {
                revert SafeCastOverflowedUintDowncast(128, value);
            }
            return uint128(value);
        }
    
        /**
         * @dev Returns the downcasted uint120 from uint256, reverting on
         * overflow (when the input is greater than largest uint120).
         *
         * Counterpart to Solidity's `uint120` operator.
         *
         * Requirements:
         *
         * - input must fit into 120 bits
         */
        function toUint120(uint256 value) internal pure returns (uint120) {
            if (value > type(uint120).max) {
                revert SafeCastOverflowedUintDowncast(120, value);
            }
            return uint120(value);
        }
    
        /**
         * @dev Returns the downcasted uint112 from uint256, reverting on
         * overflow (when the input is greater than largest uint112).
         *
         * Counterpart to Solidity's `uint112` operator.
         *
         * Requirements:
         *
         * - input must fit into 112 bits
         */
        function toUint112(uint256 value) internal pure returns (uint112) {
            if (value > type(uint112).max) {
                revert SafeCastOverflowedUintDowncast(112, value);
            }
            return uint112(value);
        }
    
        /**
         * @dev Returns the downcasted uint104 from uint256, reverting on
         * overflow (when the input is greater than largest uint104).
         *
         * Counterpart to Solidity's `uint104` operator.
         *
         * Requirements:
         *
         * - input must fit into 104 bits
         */
        function toUint104(uint256 value) internal pure returns (uint104) {
            if (value > type(uint104).max) {
                revert SafeCastOverflowedUintDowncast(104, value);
            }
            return uint104(value);
        }
    
        /**
         * @dev Returns the downcasted uint96 from uint256, reverting on
         * overflow (when the input is greater than largest uint96).
         *
         * Counterpart to Solidity's `uint96` operator.
         *
         * Requirements:
         *
         * - input must fit into 96 bits
         */
        function toUint96(uint256 value) internal pure returns (uint96) {
            if (value > type(uint96).max) {
                revert SafeCastOverflowedUintDowncast(96, value);
            }
            return uint96(value);
        }
    
        /**
         * @dev Returns the downcasted uint88 from uint256, reverting on
         * overflow (when the input is greater than largest uint88).
         *
         * Counterpart to Solidity's `uint88` operator.
         *
         * Requirements:
         *
         * - input must fit into 88 bits
         */
        function toUint88(uint256 value) internal pure returns (uint88) {
            if (value > type(uint88).max) {
                revert SafeCastOverflowedUintDowncast(88, value);
            }
            return uint88(value);
        }
    
        /**
         * @dev Returns the downcasted uint80 from uint256, reverting on
         * overflow (when the input is greater than largest uint80).
         *
         * Counterpart to Solidity's `uint80` operator.
         *
         * Requirements:
         *
         * - input must fit into 80 bits
         */
        function toUint80(uint256 value) internal pure returns (uint80) {
            if (value > type(uint80).max) {
                revert SafeCastOverflowedUintDowncast(80, value);
            }
            return uint80(value);
        }
    
        /**
         * @dev Returns the downcasted uint72 from uint256, reverting on
         * overflow (when the input is greater than largest uint72).
         *
         * Counterpart to Solidity's `uint72` operator.
         *
         * Requirements:
         *
         * - input must fit into 72 bits
         */
        function toUint72(uint256 value) internal pure returns (uint72) {
            if (value > type(uint72).max) {
                revert SafeCastOverflowedUintDowncast(72, value);
            }
            return uint72(value);
        }
    
        /**
         * @dev Returns the downcasted uint64 from uint256, reverting on
         * overflow (when the input is greater than largest uint64).
         *
         * Counterpart to Solidity's `uint64` operator.
         *
         * Requirements:
         *
         * - input must fit into 64 bits
         */
        function toUint64(uint256 value) internal pure returns (uint64) {
            if (value > type(uint64).max) {
                revert SafeCastOverflowedUintDowncast(64, value);
            }
            return uint64(value);
        }
    
        /**
         * @dev Returns the downcasted uint56 from uint256, reverting on
         * overflow (when the input is greater than largest uint56).
         *
         * Counterpart to Solidity's `uint56` operator.
         *
         * Requirements:
         *
         * - input must fit into 56 bits
         */
        function toUint56(uint256 value) internal pure returns (uint56) {
            if (value > type(uint56).max) {
                revert SafeCastOverflowedUintDowncast(56, value);
            }
            return uint56(value);
        }
    
        /**
         * @dev Returns the downcasted uint48 from uint256, reverting on
         * overflow (when the input is greater than largest uint48).
         *
         * Counterpart to Solidity's `uint48` operator.
         *
         * Requirements:
         *
         * - input must fit into 48 bits
         */
        function toUint48(uint256 value) internal pure returns (uint48) {
            if (value > type(uint48).max) {
                revert SafeCastOverflowedUintDowncast(48, value);
            }
            return uint48(value);
        }
    
        /**
         * @dev Returns the downcasted uint40 from uint256, reverting on
         * overflow (when the input is greater than largest uint40).
         *
         * Counterpart to Solidity's `uint40` operator.
         *
         * Requirements:
         *
         * - input must fit into 40 bits
         */
        function toUint40(uint256 value) internal pure returns (uint40) {
            if (value > type(uint40).max) {
                revert SafeCastOverflowedUintDowncast(40, value);
            }
            return uint40(value);
        }
    
        /**
         * @dev Returns the downcasted uint32 from uint256, reverting on
         * overflow (when the input is greater than largest uint32).
         *
         * Counterpart to Solidity's `uint32` operator.
         *
         * Requirements:
         *
         * - input must fit into 32 bits
         */
        function toUint32(uint256 value) internal pure returns (uint32) {
            if (value > type(uint32).max) {
                revert SafeCastOverflowedUintDowncast(32, value);
            }
            return uint32(value);
        }
    
        /**
         * @dev Returns the downcasted uint24 from uint256, reverting on
         * overflow (when the input is greater than largest uint24).
         *
         * Counterpart to Solidity's `uint24` operator.
         *
         * Requirements:
         *
         * - input must fit into 24 bits
         */
        function toUint24(uint256 value) internal pure returns (uint24) {
            if (value > type(uint24).max) {
                revert SafeCastOverflowedUintDowncast(24, value);
            }
            return uint24(value);
        }
    
        /**
         * @dev Returns the downcasted uint16 from uint256, reverting on
         * overflow (when the input is greater than largest uint16).
         *
         * Counterpart to Solidity's `uint16` operator.
         *
         * Requirements:
         *
         * - input must fit into 16 bits
         */
        function toUint16(uint256 value) internal pure returns (uint16) {
            if (value > type(uint16).max) {
                revert SafeCastOverflowedUintDowncast(16, value);
            }
            return uint16(value);
        }
    
        /**
         * @dev Returns the downcasted uint8 from uint256, reverting on
         * overflow (when the input is greater than largest uint8).
         *
         * Counterpart to Solidity's `uint8` operator.
         *
         * Requirements:
         *
         * - input must fit into 8 bits
         */
        function toUint8(uint256 value) internal pure returns (uint8) {
            if (value > type(uint8).max) {
                revert SafeCastOverflowedUintDowncast(8, value);
            }
            return uint8(value);
        }
    
        /**
         * @dev Converts a signed int256 into an unsigned uint256.
         *
         * Requirements:
         *
         * - input must be greater than or equal to 0.
         */
        function toUint256(int256 value) internal pure returns (uint256) {
            if (value < 0) {
                revert SafeCastOverflowedIntToUint(value);
            }
            return uint256(value);
        }
    
        /**
         * @dev Returns the downcasted int248 from int256, reverting on
         * overflow (when the input is less than smallest int248 or
         * greater than largest int248).
         *
         * Counterpart to Solidity's `int248` operator.
         *
         * Requirements:
         *
         * - input must fit into 248 bits
         */
        function toInt248(int256 value) internal pure returns (int248 downcasted) {
            downcasted = int248(value);
            if (downcasted != value) {
                revert SafeCastOverflowedIntDowncast(248, value);
            }
        }
    
        /**
         * @dev Returns the downcasted int240 from int256, reverting on
         * overflow (when the input is less than smallest int240 or
         * greater than largest int240).
         *
         * Counterpart to Solidity's `int240` operator.
         *
         * Requirements:
         *
         * - input must fit into 240 bits
         */
        function toInt240(int256 value) internal pure returns (int240 downcasted) {
            downcasted = int240(value);
            if (downcasted != value) {
                revert SafeCastOverflowedIntDowncast(240, value);
            }
        }
    
        /**
         * @dev Returns the downcasted int232 from int256, reverting on
         * overflow (when the input is less than smallest int232 or
         * greater than largest int232).
         *
         * Counterpart to Solidity's `int232` operator.
         *
         * Requirements:
         *
         * - input must fit into 232 bits
         */
        function toInt232(int256 value) internal pure returns (int232 downcasted) {
            downcasted = int232(value);
            if (downcasted != value) {
                revert SafeCastOverflowedIntDowncast(232, value);
            }
        }
    
        /**
         * @dev Returns the downcasted int224 from int256, reverting on
         * overflow (when the input is less than smallest int224 or
         * greater than largest int224).
         *
         * Counterpart to Solidity's `int224` operator.
         *
         * Requirements:
         *
         * - input must fit into 224 bits
         */
        function toInt224(int256 value) internal pure returns (int224 downcasted) {
            downcasted = int224(value);
            if (downcasted != value) {
                revert SafeCastOverflowedIntDowncast(224, value);
            }
        }
    
        /**
         * @dev Returns the downcasted int216 from int256, reverting on
         * overflow (when the input is less than smallest int216 or
         * greater than largest int216).
         *
         * Counterpart to Solidity's `int216` operator.
         *
         * Requirements:
         *
         * - input must fit into 216 bits
         */
        function toInt216(int256 value) internal pure returns (int216 downcasted) {
            downcasted = int216(value);
            if (downcasted != value) {
                revert SafeCastOverflowedIntDowncast(216, value);
            }
        }
    
        /**
         * @dev Returns the downcasted int208 from int256, reverting on
         * overflow (when the input is less than smallest int208 or
         * greater than largest int208).
         *
         * Counterpart to Solidity's `int208` operator.
         *
         * Requirements:
         *
         * - input must fit into 208 bits
         */
        function toInt208(int256 value) internal pure returns (int208 downcasted) {
            downcasted = int208(value);
            if (downcasted != value) {
                revert SafeCastOverflowedIntDowncast(208, value);
            }
        }
    
        /**
         * @dev Returns the downcasted int200 from int256, reverting on
         * overflow (when the input is less than smallest int200 or
         * greater than largest int200).
         *
         * Counterpart to Solidity's `int200` operator.
         *
         * Requirements:
         *
         * - input must fit into 200 bits
         */
        function toInt200(int256 value) internal pure returns (int200 downcasted) {
            downcasted = int200(value);
            if (downcasted != value) {
                revert SafeCastOverflowedIntDowncast(200, value);
            }
        }
    
        /**
         * @dev Returns the downcasted int192 from int256, reverting on
         * overflow (when the input is less than smallest int192 or
         * greater than largest int192).
         *
         * Counterpart to Solidity's `int192` operator.
         *
         * Requirements:
         *
         * - input must fit into 192 bits
         */
        function toInt192(int256 value) internal pure returns (int192 downcasted) {
            downcasted = int192(value);
            if (downcasted != value) {
                revert SafeCastOverflowedIntDowncast(192, value);
            }
        }
    
        /**
         * @dev Returns the downcasted int184 from int256, reverting on
         * overflow (when the input is less than smallest int184 or
         * greater than largest int184).
         *
         * Counterpart to Solidity's `int184` operator.
         *
         * Requirements:
         *
         * - input must fit into 184 bits
         */
        function toInt184(int256 value) internal pure returns (int184 downcasted) {
            downcasted = int184(value);
            if (downcasted != value) {
                revert SafeCastOverflowedIntDowncast(184, value);
            }
        }
    
        /**
         * @dev Returns the downcasted int176 from int256, reverting on
         * overflow (when the input is less than smallest int176 or
         * greater than largest int176).
         *
         * Counterpart to Solidity's `int176` operator.
         *
         * Requirements:
         *
         * - input must fit into 176 bits
         */
        function toInt176(int256 value) internal pure returns (int176 downcasted) {
            downcasted = int176(value);
            if (downcasted != value) {
                revert SafeCastOverflowedIntDowncast(176, value);
            }
        }
    
        /**
         * @dev Returns the downcasted int168 from int256, reverting on
         * overflow (when the input is less than smallest int168 or
         * greater than largest int168).
         *
         * Counterpart to Solidity's `int168` operator.
         *
         * Requirements:
         *
         * - input must fit into 168 bits
         */
        function toInt168(int256 value) internal pure returns (int168 downcasted) {
            downcasted = int168(value);
            if (downcasted != value) {
                revert SafeCastOverflowedIntDowncast(168, value);
            }
        }
    
        /**
         * @dev Returns the downcasted int160 from int256, reverting on
         * overflow (when the input is less than smallest int160 or
         * greater than largest int160).
         *
         * Counterpart to Solidity's `int160` operator.
         *
         * Requirements:
         *
         * - input must fit into 160 bits
         */
        function toInt160(int256 value) internal pure returns (int160 downcasted) {
            downcasted = int160(value);
            if (downcasted != value) {
                revert SafeCastOverflowedIntDowncast(160, value);
            }
        }
    
        /**
         * @dev Returns the downcasted int152 from int256, reverting on
         * overflow (when the input is less than smallest int152 or
         * greater than largest int152).
         *
         * Counterpart to Solidity's `int152` operator.
         *
         * Requirements:
         *
         * - input must fit into 152 bits
         */
        function toInt152(int256 value) internal pure returns (int152 downcasted) {
            downcasted = int152(value);
            if (downcasted != value) {
                revert SafeCastOverflowedIntDowncast(152, value);
            }
        }
    
        /**
         * @dev Returns the downcasted int144 from int256, reverting on
         * overflow (when the input is less than smallest int144 or
         * greater than largest int144).
         *
         * Counterpart to Solidity's `int144` operator.
         *
         * Requirements:
         *
         * - input must fit into 144 bits
         */
        function toInt144(int256 value) internal pure returns (int144 downcasted) {
            downcasted = int144(value);
            if (downcasted != value) {
                revert SafeCastOverflowedIntDowncast(144, value);
            }
        }
    
        /**
         * @dev Returns the downcasted int136 from int256, reverting on
         * overflow (when the input is less than smallest int136 or
         * greater than largest int136).
         *
         * Counterpart to Solidity's `int136` operator.
         *
         * Requirements:
         *
         * - input must fit into 136 bits
         */
        function toInt136(int256 value) internal pure returns (int136 downcasted) {
            downcasted = int136(value);
            if (downcasted != value) {
                revert SafeCastOverflowedIntDowncast(136, value);
            }
        }
    
        /**
         * @dev Returns the downcasted int128 from int256, reverting on
         * overflow (when the input is less than smallest int128 or
         * greater than largest int128).
         *
         * Counterpart to Solidity's `int128` operator.
         *
         * Requirements:
         *
         * - input must fit into 128 bits
         */
        function toInt128(int256 value) internal pure returns (int128 downcasted) {
            downcasted = int128(value);
            if (downcasted != value) {
                revert SafeCastOverflowedIntDowncast(128, value);
            }
        }
    
        /**
         * @dev Returns the downcasted int120 from int256, reverting on
         * overflow (when the input is less than smallest int120 or
         * greater than largest int120).
         *
         * Counterpart to Solidity's `int120` operator.
         *
         * Requirements:
         *
         * - input must fit into 120 bits
         */
        function toInt120(int256 value) internal pure returns (int120 downcasted) {
            downcasted = int120(value);
            if (downcasted != value) {
                revert SafeCastOverflowedIntDowncast(120, value);
            }
        }
    
        /**
         * @dev Returns the downcasted int112 from int256, reverting on
         * overflow (when the input is less than smallest int112 or
         * greater than largest int112).
         *
         * Counterpart to Solidity's `int112` operator.
         *
         * Requirements:
         *
         * - input must fit into 112 bits
         */
        function toInt112(int256 value) internal pure returns (int112 downcasted) {
            downcasted = int112(value);
            if (downcasted != value) {
                revert SafeCastOverflowedIntDowncast(112, value);
            }
        }
    
        /**
         * @dev Returns the downcasted int104 from int256, reverting on
         * overflow (when the input is less than smallest int104 or
         * greater than largest int104).
         *
         * Counterpart to Solidity's `int104` operator.
         *
         * Requirements:
         *
         * - input must fit into 104 bits
         */
        function toInt104(int256 value) internal pure returns (int104 downcasted) {
            downcasted = int104(value);
            if (downcasted != value) {
                revert SafeCastOverflowedIntDowncast(104, value);
            }
        }
    
        /**
         * @dev Returns the downcasted int96 from int256, reverting on
         * overflow (when the input is less than smallest int96 or
         * greater than largest int96).
         *
         * Counterpart to Solidity's `int96` operator.
         *
         * Requirements:
         *
         * - input must fit into 96 bits
         */
        function toInt96(int256 value) internal pure returns (int96 downcasted) {
            downcasted = int96(value);
            if (downcasted != value) {
                revert SafeCastOverflowedIntDowncast(96, value);
            }
        }
    
        /**
         * @dev Returns the downcasted int88 from int256, reverting on
         * overflow (when the input is less than smallest int88 or
         * greater than largest int88).
         *
         * Counterpart to Solidity's `int88` operator.
         *
         * Requirements:
         *
         * - input must fit into 88 bits
         */
        function toInt88(int256 value) internal pure returns (int88 downcasted) {
            downcasted = int88(value);
            if (downcasted != value) {
                revert SafeCastOverflowedIntDowncast(88, value);
            }
        }
    
        /**
         * @dev Returns the downcasted int80 from int256, reverting on
         * overflow (when the input is less than smallest int80 or
         * greater than largest int80).
         *
         * Counterpart to Solidity's `int80` operator.
         *
         * Requirements:
         *
         * - input must fit into 80 bits
         */
        function toInt80(int256 value) internal pure returns (int80 downcasted) {
            downcasted = int80(value);
            if (downcasted != value) {
                revert SafeCastOverflowedIntDowncast(80, value);
            }
        }
    
        /**
         * @dev Returns the downcasted int72 from int256, reverting on
         * overflow (when the input is less than smallest int72 or
         * greater than largest int72).
         *
         * Counterpart to Solidity's `int72` operator.
         *
         * Requirements:
         *
         * - input must fit into 72 bits
         */
        function toInt72(int256 value) internal pure returns (int72 downcasted) {
            downcasted = int72(value);
            if (downcasted != value) {
                revert SafeCastOverflowedIntDowncast(72, value);
            }
        }
    
        /**
         * @dev Returns the downcasted int64 from int256, reverting on
         * overflow (when the input is less than smallest int64 or
         * greater than largest int64).
         *
         * Counterpart to Solidity's `int64` operator.
         *
         * Requirements:
         *
         * - input must fit into 64 bits
         */
        function toInt64(int256 value) internal pure returns (int64 downcasted) {
            downcasted = int64(value);
            if (downcasted != value) {
                revert SafeCastOverflowedIntDowncast(64, value);
            }
        }
    
        /**
         * @dev Returns the downcasted int56 from int256, reverting on
         * overflow (when the input is less than smallest int56 or
         * greater than largest int56).
         *
         * Counterpart to Solidity's `int56` operator.
         *
         * Requirements:
         *
         * - input must fit into 56 bits
         */
        function toInt56(int256 value) internal pure returns (int56 downcasted) {
            downcasted = int56(value);
            if (downcasted != value) {
                revert SafeCastOverflowedIntDowncast(56, value);
            }
        }
    
        /**
         * @dev Returns the downcasted int48 from int256, reverting on
         * overflow (when the input is less than smallest int48 or
         * greater than largest int48).
         *
         * Counterpart to Solidity's `int48` operator.
         *
         * Requirements:
         *
         * - input must fit into 48 bits
         */
        function toInt48(int256 value) internal pure returns (int48 downcasted) {
            downcasted = int48(value);
            if (downcasted != value) {
                revert SafeCastOverflowedIntDowncast(48, value);
            }
        }
    
        /**
         * @dev Returns the downcasted int40 from int256, reverting on
         * overflow (when the input is less than smallest int40 or
         * greater than largest int40).
         *
         * Counterpart to Solidity's `int40` operator.
         *
         * Requirements:
         *
         * - input must fit into 40 bits
         */
        function toInt40(int256 value) internal pure returns (int40 downcasted) {
            downcasted = int40(value);
            if (downcasted != value) {
                revert SafeCastOverflowedIntDowncast(40, value);
            }
        }
    
        /**
         * @dev Returns the downcasted int32 from int256, reverting on
         * overflow (when the input is less than smallest int32 or
         * greater than largest int32).
         *
         * Counterpart to Solidity's `int32` operator.
         *
         * Requirements:
         *
         * - input must fit into 32 bits
         */
        function toInt32(int256 value) internal pure returns (int32 downcasted) {
            downcasted = int32(value);
            if (downcasted != value) {
                revert SafeCastOverflowedIntDowncast(32, value);
            }
        }
    
        /**
         * @dev Returns the downcasted int24 from int256, reverting on
         * overflow (when the input is less than smallest int24 or
         * greater than largest int24).
         *
         * Counterpart to Solidity's `int24` operator.
         *
         * Requirements:
         *
         * - input must fit into 24 bits
         */
        function toInt24(int256 value) internal pure returns (int24 downcasted) {
            downcasted = int24(value);
            if (downcasted != value) {
                revert SafeCastOverflowedIntDowncast(24, value);
            }
        }
    
        /**
         * @dev Returns the downcasted int16 from int256, reverting on
         * overflow (when the input is less than smallest int16 or
         * greater than largest int16).
         *
         * Counterpart to Solidity's `int16` operator.
         *
         * Requirements:
         *
         * - input must fit into 16 bits
         */
        function toInt16(int256 value) internal pure returns (int16 downcasted) {
            downcasted = int16(value);
            if (downcasted != value) {
                revert SafeCastOverflowedIntDowncast(16, value);
            }
        }
    
        /**
         * @dev Returns the downcasted int8 from int256, reverting on
         * overflow (when the input is less than smallest int8 or
         * greater than largest int8).
         *
         * Counterpart to Solidity's `int8` operator.
         *
         * Requirements:
         *
         * - input must fit into 8 bits
         */
        function toInt8(int256 value) internal pure returns (int8 downcasted) {
            downcasted = int8(value);
            if (downcasted != value) {
                revert SafeCastOverflowedIntDowncast(8, value);
            }
        }
    
        /**
         * @dev Converts an unsigned uint256 into a signed int256.
         *
         * Requirements:
         *
         * - input must be less than or equal to maxInt256.
         */
        function toInt256(uint256 value) internal pure returns (int256) {
            // Note: Unsafe cast below is okay because `type(int256).max` is guaranteed to be positive
            if (value > uint256(type(int256).max)) {
                revert SafeCastOverflowedUintToInt(value);
            }
            return int256(value);
        }
    
        /**
         * @dev Cast a boolean (false or true) to a uint256 (0 or 1) with no jump.
         */
        function toUint(bool b) internal pure returns (uint256 u) {
            assembly ("memory-safe") {
                u := iszero(iszero(b))
            }
        }
    }

    // SPDX-License-Identifier: MIT
    // OpenZeppelin Contracts (last updated v5.1.0) (token/ERC20/extensions/IERC20Permit.sol)
    
    pragma solidity ^0.8.20;
    
    /**
     * @dev Interface of the ERC-20 Permit extension allowing approvals to be made via signatures, as defined in
     * https://eips.ethereum.org/EIPS/eip-2612[ERC-2612].
     *
     * Adds the {permit} method, which can be used to change an account's ERC-20 allowance (see {IERC20-allowance}) by
     * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't
     * need to send a transaction, and thus is not required to hold Ether at all.
     *
     * ==== Security Considerations
     *
     * There are two important considerations concerning the use of `permit`. The first is that a valid permit signature
     * expresses an allowance, and it should not be assumed to convey additional meaning. In particular, it should not be
     * considered as an intention to spend the allowance in any specific way. The second is that because permits have
     * built-in replay protection and can be submitted by anyone, they can be frontrun. A protocol that uses permits should
     * take this into consideration and allow a `permit` call to fail. Combining these two aspects, a pattern that may be
     * generally recommended is:
     *
     * ```solidity
     * function doThingWithPermit(..., uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) public {
     *     try token.permit(msg.sender, address(this), value, deadline, v, r, s) {} catch {}
     *     doThing(..., value);
     * }
     *
     * function doThing(..., uint256 value) public {
     *     token.safeTransferFrom(msg.sender, address(this), value);
     *     ...
     * }
     * ```
     *
     * Observe that: 1) `msg.sender` is used as the owner, leaving no ambiguity as to the signer intent, and 2) the use of
     * `try/catch` allows the permit to fail and makes the code tolerant to frontrunning. (See also
     * {SafeERC20-safeTransferFrom}).
     *
     * Additionally, note that smart contract wallets (such as Argent or Safe) are not able to produce permit signatures, so
     * contracts should have entry points that don't rely on permit.
     */
    interface IERC20Permit {
        /**
         * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,
         * given ``owner``'s signed approval.
         *
         * IMPORTANT: The same issues {IERC20-approve} has related to transaction
         * ordering also apply here.
         *
         * Emits an {Approval} event.
         *
         * Requirements:
         *
         * - `spender` cannot be the zero address.
         * - `deadline` must be a timestamp in the future.
         * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`
         * over the EIP712-formatted function arguments.
         * - the signature must use ``owner``'s current nonce (see {nonces}).
         *
         * For more information on the signature format, see the
         * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP
         * section].
         *
         * CAUTION: See Security Considerations above.
         */
        function permit(
            address owner,
            address spender,
            uint256 value,
            uint256 deadline,
            uint8 v,
            bytes32 r,
            bytes32 s
        ) external;
    
        /**
         * @dev Returns the current nonce for `owner`. This value must be
         * included whenever a signature is generated for {permit}.
         *
         * Every successful call to {permit} increases ``owner``'s nonce by one. This
         * prevents a signature from being used multiple times.
         */
        function nonces(address owner) external view returns (uint256);
    
        /**
         * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.
         */
        // solhint-disable-next-line func-name-mixedcase
        function DOMAIN_SEPARATOR() external view returns (bytes32);
    }

    Contract Name:
    Pair

    Contract Source Code:

    // SPDX-License-Identifier: MIT
    pragma solidity ^0.8.26;
    
    import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
    import {ReentrancyGuard} from "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
    import {Math} from "@openzeppelin/contracts/utils/math/Math.sol";
    import {IERC20Extended} from "./interfaces/IERC20Extended.sol";
    import {UQ112x112} from "./libraries/UQ112x112.sol";
    import {IPairCallee} from "./interfaces/IPairCallee.sol";
    import {IPairFactory} from "./interfaces/IPairFactory.sol";
    import {IPair} from "./interfaces/IPair.sol";
    
    contract Pair is IPair, ERC20, ReentrancyGuard {
        using UQ112x112 for uint224;
    
        /// @dev Structure to capture time period obervations every 30 minutes, used for local oracles
        struct Observation {
            uint256 timestamp;
            uint256 reserve0Cumulative;
            uint256 reserve1Cumulative;
        }
    
        Observation[] public observations;
    
        uint256 internal _unlocked;
    
        /// @notice Capture oracle reading every 30 minutes
        uint256 constant periodSize = 1800;
    
        /// @notice min liquidity amount which is burned on creation
        uint256 public constant MINIMUM_LIQUIDITY = 10 ** 3;
    
        /// @notice legacy factory address
        address public immutable factory;
        /// @notice token0 in the pool
        address public token0;
        /// @notice token1 in the pool
        address public token1;
        /// @notice where the swap fees accrue to
        address public feeRecipient;
    
        /// @dev uses single storage slot, accessible via getReserves
        uint112 private reserve0;
        /// @dev uses single storage slot, accessible via getReserves
        uint112 private reserve1;
        /// @dev uses single storage slot, accessible via getReserves
        uint32 private blockTimestampLast;
    
        uint256 public reserve0CumulativeLast;
        uint256 public reserve1CumulativeLast;
        /// @dev reserve0 * reserve1, as of immediately after the most recent liquidity event
        uint256 public kLast;
        /// @dev the portion that goes to feeRecipient, rest goes to LPs. 100% of the fees goes to feeRecipient if it's set to 10000
        uint256 public feeSplit;
        uint256 public fee;
    
        uint256 internal decimals0;
        uint256 internal decimals1;
        /// @dev first MINIMUM_LIQUIDITY tokens are permanently locked
        uint256 internal constant MINIMUM_K = 10 ** 9;
        /// @dev 1m = 100%
        uint256 internal constant FEE_DENOM = 1_000_000;
    
        /// @notice whether the pool uses the xy(x^2 * y + y^2 * x) >= k swap curve
        bool public stable;
    
        string internal _name;
        string internal _symbol;
        constructor() ERC20("", "") {
            /// @dev initialize the factory address
            factory = msg.sender;
        }
    
        /// @inheritdoc IPair
        function initialize(
            address _token0,
            address _token1,
            bool _stable
        ) external {
            /// @dev prevent anyone other than the factory from calling
            require(msg.sender == factory, NOT_AUTHORIZED());
            token0 = _token0;
            token1 = _token1;
    
            string memory __name;
            string memory __symbol;
            stable = _stable;
            if (_stable) {
                __name = string(
                    string.concat(
                        "Legacy Correlated- ",
                        IERC20Extended(token0).symbol(),
                        "/",
                        IERC20Extended(token1).symbol()
                    )
                );
                __symbol = string(
                    string.concat(
                        "cAMM-",
                        IERC20Extended(token0).symbol(),
                        "/",
                        IERC20Extended(token1).symbol()
                    )
                );
            } else {
                __name = string(
                    string.concat(
                        "Legacy Volatile- ",
                        IERC20Extended(token0).symbol(),
                        "/",
                        IERC20Extended(token1).symbol()
                    )
                );
                __symbol = string(
                    string.concat(
                        "vAMM-",
                        IERC20Extended(token0).symbol(),
                        "/",
                        IERC20Extended(token1).symbol()
                    )
                );
            }
    
            _name = __name;
            _symbol = __symbol;
    
            observations.push(Observation(block.timestamp, 0, 0));
    
            decimals0 = 10 ** IERC20Extended(token0).decimals();
            decimals1 = 10 ** IERC20Extended(token1).decimals();
        }
        /// @inheritdoc IPair
        function getReserves()
            public
            view
            returns (
                uint112 _reserve0,
                uint112 _reserve1,
                uint32 _blockTimestampLast
            )
        {
            _reserve0 = reserve0;
            _reserve1 = reserve1;
            _blockTimestampLast = blockTimestampLast;
        }
    
        function _safeTransfer(address token, address to, uint256 value) private {
            require(token.code.length > 0);
            (bool success, bytes memory data) = token.call(
                abi.encodeCall(IERC20Extended.transfer, (to, value))
            );
            if (!(success && (data.length == 0 || abi.decode(data, (bool))))) {
                revert STF();
            }
        }
    
        /// @dev update reserves and, on the first call per block, reserve accumulators
        function _update(
            uint256 balance0,
            uint256 balance1,
            uint112 _reserve0,
            uint112 _reserve1
        ) private {
            /// @dev ensure no overflow
            require(
                balance0 <= type(uint112).max && balance1 <= type(uint112).max,
                OVERFLOW()
            );
            /// @dev store blockstamp
            uint256 blockTimestamp = block.timestamp;
            /// @dev declare
            uint256 timeElapsed;
    
            /// @dev overflow is desired
            unchecked {
                /// @dev time elapsed since the last update
                timeElapsed = blockTimestamp - uint256(blockTimestampLast);
                /// @dev if timeElapsed is gt 0 and the reserves are not 0
                if (timeElapsed > 0 && _reserve0 != 0 && _reserve1 != 0) {
                    /// @dev update the cumulatives
                    reserve0CumulativeLast += _reserve0 * timeElapsed;
                    reserve1CumulativeLast += _reserve1 * timeElapsed;
                }
            }
            /// @dev fetch the last observation
            Observation memory _point = lastObservation();
            /// @dev compare the last observation with current timestamp, if greater than 30 minutes, record a new event
            timeElapsed = blockTimestamp - _point.timestamp;
            /// @dev if > the periodSize (usually 30m twap)
            if (timeElapsed > periodSize) {
                observations.push(
                    Observation(
                        blockTimestamp,
                        reserve0CumulativeLast,
                        reserve1CumulativeLast
                    )
                );
            }
    
            reserve0 = uint112(balance0);
            reserve1 = uint112(balance1);
            blockTimestampLast = uint32(blockTimestamp);
            emit Sync(reserve0, reserve1);
        }
    
        /// @dev if fee is on, mint liquidity up to the entire growth in sqrt(k)
        function _mintFee(
            uint112 _reserve0,
            uint112 _reserve1
        ) private returns (bool feeOn) {
            /// @dev gas savings
            address _feeRecipient = feeRecipient;
            /// @dev gas savings
            uint256 _kLast = kLast;
            /// @dev we define fee being on as the existence of the fee recipient
            feeOn = _feeRecipient != address(0);
            /// @dev if there are any fees not going to LP providers
            if (feeOn) {
                /// @dev portion of fees that go to feeRecipient
                uint256 _feeSplit = feeSplit;
                /// @dev if the reserve calculation is not 0
                if (_kLast != 0) {
                    /// @dev if a stableswap/correlated pair with curve: xy(x^2y + y^2x) >= k
                    if (stable) {
                        /// @dev fetch current k value
                        uint256 k = _k(_reserve0, _reserve1);
                        /// @dev if k is greater than the _kLast variable
                        if (k > _kLast) {
                            uint256 fourthRoot_e18 = Math.sqrt(
                                Math.mulDiv(Math.sqrt(_kLast), 1e36, Math.sqrt(k))
                            );
    
                            uint256 numerator = _feeSplit *
                                (1e18 - fourthRoot_e18) *
                                1e18;
                            uint256 denominator = ((10_000 * 1e18) -
                                (_feeSplit * (1e18 - fourthRoot_e18)));
    
                            /// @dev new liquidity to be minted
                            uint256 feeAsLiquidity = (totalSupply() * numerator) /
                                denominator /
                                1e18;
    
                            if (feeAsLiquidity > 0) {
                                _mint(_feeRecipient, feeAsLiquidity);
                            }
                        }
                    }
                    /// @dev if !stable
                    else {
                        uint256 rootK = Math.sqrt(
                            _k(uint256(_reserve0), uint256(_reserve1))
                        );
                        uint256 rootKLast = Math.sqrt(_kLast);
                        if (rootK > rootKLast) {
                            /// @dev calculate fee amounts to send
                            uint256 diffK = rootK - rootKLast;
                            uint256 dueToProtocol = (diffK * _feeSplit) / 10_000;
                            uint256 dueToLp = rootKLast + diffK - dueToProtocol;
    
                            /// @dev new liquidity to be minted
                            /// @dev n = s*P/d
                            uint256 feeAsLiquidity = (totalSupply() *
                                dueToProtocol) / dueToLp;
    
                            if (feeAsLiquidity > 0) {
                                _mint(_feeRecipient, feeAsLiquidity);
                            }
                        }
                    }
                }
            }
            /// @dev if !feeOn
            else if (_kLast != 0) {
                /// @dev update kLast to reflect reserves
                kLast = _k(reserve0, reserve1);
            }
        }
        /// @inheritdoc IPair
        /// @dev this low-level function should be called from a contract which performs important safety checks
        function mint(
            address to
        ) external nonReentrant returns (uint256 liquidity) {
            /// @dev gas savings
            (uint112 _reserve0, uint112 _reserve1, ) = getReserves();
            uint256 balance0 = IERC20Extended(token0).balanceOf(address(this));
            uint256 balance1 = IERC20Extended(token1).balanceOf(address(this));
            uint256 amount0 = balance0 - _reserve0;
            uint256 amount1 = balance1 - _reserve1;
    
            bool feeOn = _mintFee(_reserve0, _reserve1);
            /// @dev gas savings, must be defined here since totalSupply can update in _mintFee
            uint256 _totalSupply = totalSupply();
            if (_totalSupply == 0) {
                liquidity = Math.sqrt(amount0 * amount1) - MINIMUM_LIQUIDITY;
                /// @dev permanently lock the first MINIMUM_LIQUIDITY tokens
                _mint(address(0xdead), MINIMUM_LIQUIDITY);
                if (stable) {
                    require(_k(amount0, amount1) >= MINIMUM_K, K());
                    require(
                        ((amount0 * 1e18) / decimals0 ==
                            (amount1 * 1e18) / decimals1),
                        UNSTABLE_RATIO()
                    );
                }
            } else {
                liquidity = Math.min(
                    (amount0 * _totalSupply) / _reserve0,
                    (amount1 * _totalSupply) / _reserve1
                );
            }
            require(liquidity != 0, ILM());
            _mint(to, liquidity);
    
            _update(balance0, balance1, _reserve0, _reserve1);
            /// @dev reserve0 and reserve1 are up-to-date
            if (feeOn) kLast = _k(uint256(reserve0), uint256(reserve1));
            emit Mint(msg.sender, amount0, amount1);
        }
        /// @inheritdoc IPair
        /// @dev this low-level function should be called from a contract which performs important safety checks
        function burn(
            address to
        ) external nonReentrant returns (uint256 amount0, uint256 amount1) {
            /// @dev gas savings
            (uint112 _reserve0, uint112 _reserve1, ) = getReserves();
            /// @dev gas savings
            address _token0 = token0;
            /// @dev gas savings
            address _token1 = token1;
            uint256 balance0 = IERC20Extended(_token0).balanceOf(address(this));
            uint256 balance1 = IERC20Extended(_token1).balanceOf(address(this));
            /// @dev fetch the balance of the liquidity of the Pair
            uint256 liquidity = balanceOf(address(this));
            /// @dev attempt to mint fees and calculate if feeOn is active
            bool feeOn = _mintFee(_reserve0, _reserve1);
            /// @dev gas savings, must be defined here since totalSupply can update in _mintFee
            uint256 _totalSupply = totalSupply();
            /// @dev using balances ensures pro-rata distribution
            amount0 = (liquidity * balance0) / _totalSupply;
            /// @dev using balances ensures pro-rata distribution
            amount1 = (liquidity * balance1) / _totalSupply;
            /// @dev require the amounts are not zero, else it's insufficient liquidity burned and revert
            require(amount0 != 0 && amount1 != 0, ILB());
            /// @dev burn the liquidity tokens
            _burn(address(this), liquidity);
            /// @dev safe transfer the two underlying tokens (incase of tax tokens etc)
            _safeTransfer(_token0, to, amount0);
            _safeTransfer(_token1, to, amount1);
            /// @dev fetch updated balances
            balance0 = IERC20Extended(_token0).balanceOf(address(this));
            balance1 = IERC20Extended(_token1).balanceOf(address(this));
            /// @dev update with the new balances
            _update(balance0, balance1, _reserve0, _reserve1);
            /// @dev reserve0 and reserve1 are up-to-date
            if (feeOn) kLast = _k(reserve0, reserve1);
            emit Burn(msg.sender, amount0, amount1, to);
        }
        /// @inheritdoc IPair
        /// @dev this low-level function should be called from a contract which performs important safety checks
        function swap(
            uint256 amount0Out,
            uint256 amount1Out,
            address to,
            bytes calldata data
        ) external nonReentrant {
            /// @dev require at least one is not 0, else revert for Insufficient Output Amount
            require(amount0Out != 0 || amount1Out != 0, IOA());
    
            /// @dev gas savings
            (uint112 _reserve0, uint112 _reserve1, ) = getReserves();
            /// @dev ensure there is enough liquidity for the swap
            require(amount0Out < _reserve0 && amount1Out < _reserve1, IL());
            /// @dev gas savings
            address _token0 = token0;
            address _token1 = token1;
    
            require(to != _token0 && to != _token1, IT());
            /// @dev optimistically transfer tokens
            if (amount0Out > 0) _safeTransfer(_token0, to, amount0Out);
            /// @dev optimistically transfer tokens
            if (amount1Out > 0) _safeTransfer(_token1, to, amount1Out);
            if (data.length > 0)
                IPairCallee(to).hook(msg.sender, amount0Out, amount1Out, data);
            uint256 balance0 = IERC20Extended(_token0).balanceOf(address(this));
            uint256 balance1 = IERC20Extended(_token1).balanceOf(address(this));
    
            uint256 amount0In;
            uint256 amount1In;
            unchecked {
                amount0In = balance0 > _reserve0 - amount0Out
                    ? balance0 - (_reserve0 - amount0Out)
                    : 0;
                amount1In = balance1 > _reserve1 - amount1Out
                    ? balance1 - (_reserve1 - amount1Out)
                    : 0;
            }
            require(amount0In != 0 || amount1In != 0, IIA());
    
            /// @dev FEE_DENOM as the denominator invariant for calculating swap fees
            uint256 balance0Adjusted = balance0 - ((amount0In * fee) / FEE_DENOM);
            uint256 balance1Adjusted = balance1 - ((amount1In * fee) / FEE_DENOM);
    
            require(
                _k(balance0Adjusted, balance1Adjusted) >=
                    _k(uint256(_reserve0), uint256(_reserve1)),
                K()
            );
    
            _update(balance0, balance1, _reserve0, _reserve1);
            emit Swap(msg.sender, amount0In, amount1In, amount0Out, amount1Out, to);
        }
    
        /// @inheritdoc IPair
        function skim(address to) external nonReentrant {
            /// @dev if skim disabled, revert
            /// @dev by default it is disabled as it uses a mapping in the pair factory contract
            require((IPairFactory(factory).skimEnabled(address(this))), SD());
            /// @dev gas savings
            address _token0 = token0;
            /// @dev gas savings
            address _token1 = token1;
            _safeTransfer(
                _token0,
                to,
                IERC20Extended(_token0).balanceOf(address(this)) - reserve0
            );
            _safeTransfer(
                _token1,
                to,
                IERC20Extended(_token1).balanceOf(address(this)) - reserve1
            );
        }
    
        /// @inheritdoc IPair
        function sync() external nonReentrant {
            /// @dev update the reserves to match balances
            _update(
                IERC20Extended(token0).balanceOf(address(this)),
                IERC20Extended(token1).balanceOf(address(this)),
                reserve0,
                reserve1
            );
        }
        /// @inheritdoc IPair
        function setFeeRecipient(address _feeRecipient) external {
            /// @dev gate to the PairFactory
            require(msg.sender == factory, NOT_AUTHORIZED());
            feeRecipient = _feeRecipient;
        }
        /// @inheritdoc IPair
        function setFeeSplit(uint256 _feeSplit) external {
            /// @dev gate to the PairFactory
            require(msg.sender == factory, NOT_AUTHORIZED());
            feeSplit = _feeSplit;
        }
        /// @inheritdoc IPair
        function setFee(uint256 _fee) external {
            /// @dev gate to the PairFactory
            require(msg.sender == factory, NOT_AUTHORIZED());
            fee = _fee;
        }
        /// @inheritdoc IPair
        function mintFee() external nonReentrant {
            /// @dev fetch the current public reserves
            uint112 _reserve0 = reserve0;
            uint112 _reserve1 = reserve1;
            /// @dev mint the accumulated fees
            bool feeOn = _mintFee(_reserve0, _reserve1);
            /// @dev if minting was successful
            if (feeOn) kLast = _k(uint256(_reserve0), uint256(_reserve1));
        }
    
        function _k(uint256 x, uint256 y) internal view returns (uint256) {
            if (stable) {
                uint256 _x = (x * 10 ** 18) / decimals0;
                uint256 _y = (y * 10 ** 18) / decimals1;
                uint256 _a = (_x * _y) / 10 ** 18;
                uint256 _b = ((_x * _x) / 10 ** 18 + (_y * _y) / 10 ** 18);
                /// @dev x3y+y3x >= k
                return (_a * _b) / 10 ** 18;
            } else {
                /// @dev xy >= k
                return x * y;
            }
        }
    
        function _f(uint256 x0, uint256 y) internal pure returns (uint256) {
            return
                (x0 * ((((y * y) / 1e18) * y) / 1e18)) /
                1e18 +
                (((((x0 * x0) / 1e18) * x0) / 1e18) * y) /
                1e18;
        }
    
        function _d(uint256 x0, uint256 y) internal pure returns (uint256) {
            return
                (3 * x0 * ((y * y) / 1e18)) /
                1e18 +
                ((((x0 * x0) / 1e18) * x0) / 1e18);
        }
    
        function _get_y(
            uint256 x0,
            uint256 xy,
            uint256 y
        ) internal pure returns (uint256) {
            for (uint256 i = 0; i < 255; ++i) {
                uint256 y_prev = y;
                uint256 k = _f(x0, y);
                if (k < xy) {
                    uint256 dy = ((xy - k) * 1e18) / _d(x0, y);
                    y = y + dy;
                } else {
                    uint256 dy = ((k - xy) * 1e18) / _d(x0, y);
                    y = y - dy;
                }
                if (y > y_prev) {
                    if (y - y_prev <= 1) {
                        return y;
                    }
                } else {
                    if (y_prev - y <= 1) {
                        return y;
                    }
                }
            }
            return y;
        }
        /// @inheritdoc IPair
        function getAmountOut(
            uint256 amountIn,
            address tokenIn
        ) external view returns (uint256) {
            (uint256 _reserve0, uint256 _reserve1) = (reserve0, reserve1);
            /// @dev remove fee from amount received
            amountIn -= (amountIn * fee) / FEE_DENOM;
    
            return _getAmountOut(amountIn, tokenIn, _reserve0, _reserve1) - 1;
        }
    
        function _getAmountOut(
            uint256 amountIn,
            address tokenIn,
            uint256 _reserve0,
            uint256 _reserve1
        ) internal view returns (uint256) {
            if (stable) {
                uint256 xy = _k(_reserve0, _reserve1);
                _reserve0 = (_reserve0 * 1e18) / decimals0;
                _reserve1 = (_reserve1 * 1e18) / decimals1;
                (uint256 reserveA, uint256 reserveB) = tokenIn == token0
                    ? (_reserve0, _reserve1)
                    : (_reserve1, _reserve0);
                amountIn = tokenIn == token0
                    ? (amountIn * 1e18) / decimals0
                    : (amountIn * 1e18) / decimals1;
                uint256 y = reserveB - _get_y(amountIn + reserveA, xy, reserveB);
                return (y * (tokenIn == token0 ? decimals1 : decimals0)) / 1e18;
            } else {
                (uint256 reserveA, uint256 reserveB) = tokenIn == token0
                    ? (_reserve0, _reserve1)
                    : (_reserve1, _reserve0);
                return (amountIn * reserveB) / (reserveA + amountIn);
            }
        }
    
        function metadata()
            external
            view
            returns (
                uint256 _decimals0,
                uint256 _decimals1,
                uint256 _reserve0,
                uint256 _reserve1,
                bool _stable,
                address _token0,
                address _token1
            )
        {
            return (
                decimals0,
                decimals1,
                reserve0,
                reserve1,
                stable,
                token0,
                token1
            );
        }
    
        function observationLength() external view returns (uint256) {
            return observations.length;
        }
    
        function lastObservation() public view returns (Observation memory) {
            return observations[observations.length - 1];
        }
    
        /// @dev produces the cumulative price using counterfactuals to save gas and avoid a call to sync.
        function currentCumulativePrices()
            public
            view
            returns (
                uint256 reserve0Cumulative,
                uint256 reserve1Cumulative,
                uint256 blockTimestamp
            )
        {
            blockTimestamp = block.timestamp;
            reserve0Cumulative = reserve0CumulativeLast;
            reserve1Cumulative = reserve1CumulativeLast;
    
            /// @dev if time has elapsed since the last update on the pair, mock the accumulated price values
            (
                uint112 _reserve0,
                uint112 _reserve1,
                uint32 _blockTimestampLast
            ) = getReserves();
            if (_blockTimestampLast != uint32(blockTimestamp)) {
                /// @dev subtraction overflow is desired
                uint256 timeElapsed = blockTimestamp - uint256(_blockTimestampLast);
                reserve0Cumulative += _reserve0 * timeElapsed;
                reserve1Cumulative += _reserve1 * timeElapsed;
            }
        }
    
        /// @dev gives the current twap price measured from amountIn * tokenIn gives amountOut
        function current(
            address tokenIn,
            uint256 amountIn
        ) external view returns (uint256 amountOut) {
            Observation memory _observation = lastObservation();
            (
                uint256 reserve0Cumulative,
                uint256 reserve1Cumulative,
    
            ) = currentCumulativePrices();
            if (block.timestamp == _observation.timestamp) {
                _observation = observations[observations.length - 2];
            }
    
            uint256 timeElapsed = block.timestamp - _observation.timestamp;
            uint256 _reserve0 = (reserve0Cumulative -
                _observation.reserve0Cumulative) / timeElapsed;
            uint256 _reserve1 = (reserve1Cumulative -
                _observation.reserve1Cumulative) / timeElapsed;
            amountOut = _getAmountOut(amountIn, tokenIn, _reserve0, _reserve1);
        }
    
        /// @dev as per `current`, however allows user configured granularity, up to the full window size
        function quote(
            address tokenIn,
            uint256 amountIn,
            uint256 granularity
        ) external view returns (uint256 amountOut) {
            uint256[] memory _prices = sample(tokenIn, amountIn, granularity, 1);
            uint256 priceAverageCumulative;
            for (uint256 i = 0; i < _prices.length; ++i) {
                priceAverageCumulative += _prices[i];
            }
            return priceAverageCumulative / granularity;
        }
    
        /// @dev returns a memory set of twap prices
        function prices(
            address tokenIn,
            uint256 amountIn,
            uint256 points
        ) external view returns (uint256[] memory) {
            return sample(tokenIn, amountIn, points, 1);
        }
    
        function sample(
            address tokenIn,
            uint256 amountIn,
            uint256 points,
            uint256 window
        ) public view returns (uint256[] memory) {
            uint256[] memory _prices = new uint256[](points);
    
            uint256 length = observations.length - 1;
            uint256 i = length - (points * window);
            uint256 nextIndex = 0;
            uint256 index = 0;
    
            for (; i < length; i += window) {
                nextIndex = i + window;
                uint256 timeElapsed = observations[nextIndex].timestamp -
                    observations[i].timestamp;
                uint256 _reserve0 = (observations[nextIndex].reserve0Cumulative -
                    observations[i].reserve0Cumulative) / timeElapsed;
                uint256 _reserve1 = (observations[nextIndex].reserve1Cumulative -
                    observations[i].reserve1Cumulative) / timeElapsed;
                _prices[index] = _getAmountOut(
                    amountIn,
                    tokenIn,
                    _reserve0,
                    _reserve1
                );
                /// @dev index < length; length cannot overflow
                unchecked {
                    index = index + 1;
                }
            }
            return _prices;
        }
    }

    // SPDX-License-Identifier: MIT
    // OpenZeppelin Contracts (last updated v5.1.0) (token/ERC20/ERC20.sol)
    
    pragma solidity ^0.8.20;
    
    import {IERC20} from "./IERC20.sol";
    import {IERC20Metadata} from "./extensions/IERC20Metadata.sol";
    import {Context} from "../../utils/Context.sol";
    import {IERC20Errors} from "../../interfaces/draft-IERC6093.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}.
     *
     * TIP: For a detailed writeup see our guide
     * https://forum.openzeppelin.com/t/how-to-implement-erc20-supply-mechanisms/226[How
     * to implement supply mechanisms].
     *
     * The default value of {decimals} is 18. To change this, you should override
     * this function so it returns a different value.
     *
     * 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 ERC-20
     * applications.
     */
    abstract contract ERC20 is Context, IERC20, IERC20Metadata, IERC20Errors {
        mapping(address account => uint256) private _balances;
    
        mapping(address account => mapping(address spender => uint256)) private _allowances;
    
        uint256 private _totalSupply;
    
        string private _name;
        string private _symbol;
    
        /**
         * @dev Sets the values for {name} and {symbol}.
         *
         * 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 returns (string memory) {
            return _name;
        }
    
        /**
         * @dev Returns the symbol of the token, usually a shorter version of the
         * name.
         */
        function symbol() public view virtual 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 default value returned by this function, unless
         * it's 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 returns (uint8) {
            return 18;
        }
    
        /**
         * @dev See {IERC20-totalSupply}.
         */
        function totalSupply() public view virtual returns (uint256) {
            return _totalSupply;
        }
    
        /**
         * @dev See {IERC20-balanceOf}.
         */
        function balanceOf(address account) public view virtual 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 `value`.
         */
        function transfer(address to, uint256 value) public virtual returns (bool) {
            address owner = _msgSender();
            _transfer(owner, to, value);
            return true;
        }
    
        /**
         * @dev See {IERC20-allowance}.
         */
        function allowance(address owner, address spender) public view virtual returns (uint256) {
            return _allowances[owner][spender];
        }
    
        /**
         * @dev See {IERC20-approve}.
         *
         * NOTE: If `value` 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 value) public virtual returns (bool) {
            address owner = _msgSender();
            _approve(owner, spender, value);
            return true;
        }
    
        /**
         * @dev See {IERC20-transferFrom}.
         *
         * Skips emitting an {Approval} event indicating an allowance update. This is not
         * required by the ERC. See {xref-ERC20-_approve-address-address-uint256-bool-}[_approve].
         *
         * 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 `value`.
         * - the caller must have allowance for ``from``'s tokens of at least
         * `value`.
         */
        function transferFrom(address from, address to, uint256 value) public virtual returns (bool) {
            address spender = _msgSender();
            _spendAllowance(from, spender, value);
            _transfer(from, to, value);
            return true;
        }
    
        /**
         * @dev Moves a `value` 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.
         *
         * NOTE: This function is not virtual, {_update} should be overridden instead.
         */
        function _transfer(address from, address to, uint256 value) internal {
            if (from == address(0)) {
                revert ERC20InvalidSender(address(0));
            }
            if (to == address(0)) {
                revert ERC20InvalidReceiver(address(0));
            }
            _update(from, to, value);
        }
    
        /**
         * @dev Transfers a `value` amount of tokens from `from` to `to`, or alternatively mints (or burns) if `from`
         * (or `to`) is the zero address. All customizations to transfers, mints, and burns should be done by overriding
         * this function.
         *
         * Emits a {Transfer} event.
         */
        function _update(address from, address to, uint256 value) internal virtual {
            if (from == address(0)) {
                // Overflow check required: The rest of the code assumes that totalSupply never overflows
                _totalSupply += value;
            } else {
                uint256 fromBalance = _balances[from];
                if (fromBalance < value) {
                    revert ERC20InsufficientBalance(from, fromBalance, value);
                }
                unchecked {
                    // Overflow not possible: value <= fromBalance <= totalSupply.
                    _balances[from] = fromBalance - value;
                }
            }
    
            if (to == address(0)) {
                unchecked {
                    // Overflow not possible: value <= totalSupply or value <= fromBalance <= totalSupply.
                    _totalSupply -= value;
                }
            } else {
                unchecked {
                    // Overflow not possible: balance + value is at most totalSupply, which we know fits into a uint256.
                    _balances[to] += value;
                }
            }
    
            emit Transfer(from, to, value);
        }
    
        /**
         * @dev Creates a `value` amount of tokens and assigns them to `account`, by transferring it from address(0).
         * Relies on the `_update` mechanism
         *
         * Emits a {Transfer} event with `from` set to the zero address.
         *
         * NOTE: This function is not virtual, {_update} should be overridden instead.
         */
        function _mint(address account, uint256 value) internal {
            if (account == address(0)) {
                revert ERC20InvalidReceiver(address(0));
            }
            _update(address(0), account, value);
        }
    
        /**
         * @dev Destroys a `value` amount of tokens from `account`, lowering the total supply.
         * Relies on the `_update` mechanism.
         *
         * Emits a {Transfer} event with `to` set to the zero address.
         *
         * NOTE: This function is not virtual, {_update} should be overridden instead
         */
        function _burn(address account, uint256 value) internal {
            if (account == address(0)) {
                revert ERC20InvalidSender(address(0));
            }
            _update(account, address(0), value);
        }
    
        /**
         * @dev Sets `value` 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.
         *
         * Overrides to this logic should be done to the variant with an additional `bool emitEvent` argument.
         */
        function _approve(address owner, address spender, uint256 value) internal {
            _approve(owner, spender, value, true);
        }
    
        /**
         * @dev Variant of {_approve} with an optional flag to enable or disable the {Approval} event.
         *
         * By default (when calling {_approve}) the flag is set to true. On the other hand, approval changes made by
         * `_spendAllowance` during the `transferFrom` operation set the flag to false. This saves gas by not emitting any
         * `Approval` event during `transferFrom` operations.
         *
         * Anyone who wishes to continue emitting `Approval` events on the`transferFrom` operation can force the flag to
         * true using the following override:
         *
         * ```solidity
         * function _approve(address owner, address spender, uint256 value, bool) internal virtual override {
         *     super._approve(owner, spender, value, true);
         * }
         * ```
         *
         * Requirements are the same as {_approve}.
         */
        function _approve(address owner, address spender, uint256 value, bool emitEvent) internal virtual {
            if (owner == address(0)) {
                revert ERC20InvalidApprover(address(0));
            }
            if (spender == address(0)) {
                revert ERC20InvalidSpender(address(0));
            }
            _allowances[owner][spender] = value;
            if (emitEvent) {
                emit Approval(owner, spender, value);
            }
        }
    
        /**
         * @dev Updates `owner` s allowance for `spender` based on spent `value`.
         *
         * Does not update the allowance value in case of infinite allowance.
         * Revert if not enough allowance is available.
         *
         * Does not emit an {Approval} event.
         */
        function _spendAllowance(address owner, address spender, uint256 value) internal virtual {
            uint256 currentAllowance = allowance(owner, spender);
            if (currentAllowance != type(uint256).max) {
                if (currentAllowance < value) {
                    revert ERC20InsufficientAllowance(spender, currentAllowance, value);
                }
                unchecked {
                    _approve(owner, spender, currentAllowance - value, false);
                }
            }
        }
    }

    // SPDX-License-Identifier: MIT
    // OpenZeppelin Contracts (last updated v5.1.0) (utils/ReentrancyGuard.sol)
    
    pragma solidity ^0.8.20;
    
    /**
     * @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 EIP-1153 (transient storage) is available on the chain you're deploying at,
     * consider using {ReentrancyGuardTransient} instead.
     *
     * 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;
    
        /**
         * @dev Unauthorized reentrant call.
         */
        error ReentrancyGuardReentrantCall();
    
        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() {
            _nonReentrantBefore();
            _;
            _nonReentrantAfter();
        }
    
        function _nonReentrantBefore() private {
            // On the first call to nonReentrant, _status will be NOT_ENTERED
            if (_status == ENTERED) {
                revert ReentrancyGuardReentrantCall();
            }
    
            // Any calls to nonReentrant after this point will fail
            _status = ENTERED;
        }
    
        function _nonReentrantAfter() private {
            // By storing the original value once again, a refund is triggered (see
            // https://eips.ethereum.org/EIPS/eip-2200)
            _status = NOT_ENTERED;
        }
    
        /**
         * @dev Returns true if the reentrancy guard is currently set to "entered", which indicates there is a
         * `nonReentrant` function in the call stack.
         */
        function _reentrancyGuardEntered() internal view returns (bool) {
            return _status == ENTERED;
        }
    }

    // SPDX-License-Identifier: MIT
    // OpenZeppelin Contracts (last updated v5.1.0) (utils/math/Math.sol)
    
    pragma solidity ^0.8.20;
    
    import {Panic} from "../Panic.sol";
    import {SafeCast} from "./SafeCast.sol";
    
    /**
     * @dev Standard math utilities missing in the Solidity language.
     */
    library Math {
        enum Rounding {
            Floor, // Toward negative infinity
            Ceil, // Toward positive infinity
            Trunc, // Toward zero
            Expand // Away from zero
        }
    
        /**
         * @dev Returns the addition of two unsigned integers, with an success flag (no overflow).
         */
        function tryAdd(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {
            unchecked {
                uint256 c = a + b;
                if (c < a) return (false, 0);
                return (true, c);
            }
        }
    
        /**
         * @dev Returns the subtraction of two unsigned integers, with an success flag (no overflow).
         */
        function trySub(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {
            unchecked {
                if (b > a) return (false, 0);
                return (true, a - b);
            }
        }
    
        /**
         * @dev Returns the multiplication of two unsigned integers, with an success flag (no overflow).
         */
        function tryMul(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {
            unchecked {
                // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
                // benefit is lost if 'b' is also tested.
                // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
                if (a == 0) return (true, 0);
                uint256 c = a * b;
                if (c / a != b) return (false, 0);
                return (true, c);
            }
        }
    
        /**
         * @dev Returns the division of two unsigned integers, with a success flag (no division by zero).
         */
        function tryDiv(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {
            unchecked {
                if (b == 0) return (false, 0);
                return (true, a / b);
            }
        }
    
        /**
         * @dev Returns the remainder of dividing two unsigned integers, with a success flag (no division by zero).
         */
        function tryMod(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {
            unchecked {
                if (b == 0) return (false, 0);
                return (true, a % b);
            }
        }
    
        /**
         * @dev Branchless ternary evaluation for `a ? b : c`. Gas costs are constant.
         *
         * IMPORTANT: This function may reduce bytecode size and consume less gas when used standalone.
         * However, the compiler may optimize Solidity ternary operations (i.e. `a ? b : c`) to only compute
         * one branch when needed, making this function more expensive.
         */
        function ternary(bool condition, uint256 a, uint256 b) internal pure returns (uint256) {
            unchecked {
                // branchless ternary works because:
                // b ^ (a ^ b) == a
                // b ^ 0 == b
                return b ^ ((a ^ b) * SafeCast.toUint(condition));
            }
        }
    
        /**
         * @dev Returns the largest of two numbers.
         */
        function max(uint256 a, uint256 b) internal pure returns (uint256) {
            return ternary(a > b, a, b);
        }
    
        /**
         * @dev Returns the smallest of two numbers.
         */
        function min(uint256 a, uint256 b) internal pure returns (uint256) {
            return ternary(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 towards infinity instead
         * of rounding towards zero.
         */
        function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
            if (b == 0) {
                // Guarantee the same behavior as in a regular Solidity division.
                Panic.panic(Panic.DIVISION_BY_ZERO);
            }
    
            // The following calculation ensures accurate ceiling division without overflow.
            // Since a is non-zero, (a - 1) / b will not overflow.
            // The largest possible result occurs when (a - 1) / b is type(uint256).max,
            // but the largest value we can obtain is type(uint256).max - 1, which happens
            // when a = type(uint256).max and b = 1.
            unchecked {
                return SafeCast.toUint(a > 0) * ((a - 1) / b + 1);
            }
        }
    
        /**
         * @dev Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or
         * denominator == 0.
         *
         * 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²⁵⁶ and mod 2²⁵⁶ - 1, then use
                // the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256
                // variables such that product = prod1 * 2²⁵⁶ + prod0.
                uint256 prod0 = x * y; // Least significant 256 bits of the product
                uint256 prod1; // Most significant 256 bits of the product
                assembly {
                    let mm := mulmod(x, y, not(0))
                    prod1 := sub(sub(mm, prod0), lt(mm, prod0))
                }
    
                // Handle non-overflow cases, 256 by 256 division.
                if (prod1 == 0) {
                    // Solidity will revert if denominator == 0, unlike the div opcode on its own.
                    // The surrounding unchecked block does not change this fact.
                    // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.
                    return prod0 / denominator;
                }
    
                // Make sure the result is less than 2²⁵⁶. Also prevents denominator == 0.
                if (denominator <= prod1) {
                    Panic.panic(ternary(denominator == 0, Panic.DIVISION_BY_ZERO, Panic.UNDER_OVERFLOW));
                }
    
                ///////////////////////////////////////////////
                // 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.
    
                uint256 twos = denominator & (0 - denominator);
                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²⁵⁶ / 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²⁵⁶. Now that denominator is an odd number, it has an inverse modulo 2²⁵⁶ such
                // that denominator * inv ≡ 1 mod 2²⁵⁶. Compute the inverse by starting with a seed that is correct for
                // four bits. That is, denominator * inv ≡ 1 mod 2⁴.
                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⁸
                inverse *= 2 - denominator * inverse; // inverse mod 2¹⁶
                inverse *= 2 - denominator * inverse; // inverse mod 2³²
                inverse *= 2 - denominator * inverse; // inverse mod 2⁶⁴
                inverse *= 2 - denominator * inverse; // inverse mod 2¹²⁸
                inverse *= 2 - denominator * inverse; // inverse mod 2²⁵⁶
    
                // 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²⁵⁶. Since the preconditions guarantee that the outcome is
                // less than 2²⁵⁶, 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;
            }
        }
    
        /**
         * @dev 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) {
            return mulDiv(x, y, denominator) + SafeCast.toUint(unsignedRoundsUp(rounding) && mulmod(x, y, denominator) > 0);
        }
    
        /**
         * @dev Calculate the modular multiplicative inverse of a number in Z/nZ.
         *
         * If n is a prime, then Z/nZ is a field. In that case all elements are inversible, except 0.
         * If n is not a prime, then Z/nZ is not a field, and some elements might not be inversible.
         *
         * If the input value is not inversible, 0 is returned.
         *
         * NOTE: If you know for sure that n is (big) a prime, it may be cheaper to use Fermat's little theorem and get the
         * inverse using `Math.modExp(a, n - 2, n)`. See {invModPrime}.
         */
        function invMod(uint256 a, uint256 n) internal pure returns (uint256) {
            unchecked {
                if (n == 0) return 0;
    
                // The inverse modulo is calculated using the Extended Euclidean Algorithm (iterative version)
                // Used to compute integers x and y such that: ax + ny = gcd(a, n).
                // When the gcd is 1, then the inverse of a modulo n exists and it's x.
                // ax + ny = 1
                // ax = 1 + (-y)n
                // ax ≡ 1 (mod n) # x is the inverse of a modulo n
    
                // If the remainder is 0 the gcd is n right away.
                uint256 remainder = a % n;
                uint256 gcd = n;
    
                // Therefore the initial coefficients are:
                // ax + ny = gcd(a, n) = n
                // 0a + 1n = n
                int256 x = 0;
                int256 y = 1;
    
                while (remainder != 0) {
                    uint256 quotient = gcd / remainder;
    
                    (gcd, remainder) = (
                        // The old remainder is the next gcd to try.
                        remainder,
                        // Compute the next remainder.
                        // Can't overflow given that (a % gcd) * (gcd // (a % gcd)) <= gcd
                        // where gcd is at most n (capped to type(uint256).max)
                        gcd - remainder * quotient
                    );
    
                    (x, y) = (
                        // Increment the coefficient of a.
                        y,
                        // Decrement the coefficient of n.
                        // Can overflow, but the result is casted to uint256 so that the
                        // next value of y is "wrapped around" to a value between 0 and n - 1.
                        x - y * int256(quotient)
                    );
                }
    
                if (gcd != 1) return 0; // No inverse exists.
                return ternary(x < 0, n - uint256(-x), uint256(x)); // Wrap the result if it's negative.
            }
        }
    
        /**
         * @dev Variant of {invMod}. More efficient, but only works if `p` is known to be a prime greater than `2`.
         *
         * From https://en.wikipedia.org/wiki/Fermat%27s_little_theorem[Fermat's little theorem], we know that if p is
         * prime, then `a**(p-1) ≡ 1 mod p`. As a consequence, we have `a * a**(p-2) ≡ 1 mod p`, which means that
         * `a**(p-2)` is the modular multiplicative inverse of a in Fp.
         *
         * NOTE: this function does NOT check that `p` is a prime greater than `2`.
         */
        function invModPrime(uint256 a, uint256 p) internal view returns (uint256) {
            unchecked {
                return Math.modExp(a, p - 2, p);
            }
        }
    
        /**
         * @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m)
         *
         * Requirements:
         * - modulus can't be zero
         * - underlying staticcall to precompile must succeed
         *
         * IMPORTANT: The result is only valid if the underlying call succeeds. When using this function, make
         * sure the chain you're using it on supports the precompiled contract for modular exponentiation
         * at address 0x05 as specified in https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise,
         * the underlying function will succeed given the lack of a revert, but the result may be incorrectly
         * interpreted as 0.
         */
        function modExp(uint256 b, uint256 e, uint256 m) internal view returns (uint256) {
            (bool success, uint256 result) = tryModExp(b, e, m);
            if (!success) {
                Panic.panic(Panic.DIVISION_BY_ZERO);
            }
            return result;
        }
    
        /**
         * @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m).
         * It includes a success flag indicating if the operation succeeded. Operation will be marked as failed if trying
         * to operate modulo 0 or if the underlying precompile reverted.
         *
         * IMPORTANT: The result is only valid if the success flag is true. When using this function, make sure the chain
         * you're using it on supports the precompiled contract for modular exponentiation at address 0x05 as specified in
         * https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise, the underlying function will succeed given the lack
         * of a revert, but the result may be incorrectly interpreted as 0.
         */
        function tryModExp(uint256 b, uint256 e, uint256 m) internal view returns (bool success, uint256 result) {
            if (m == 0) return (false, 0);
            assembly ("memory-safe") {
                let ptr := mload(0x40)
                // | Offset    | Content    | Content (Hex)                                                      |
                // |-----------|------------|--------------------------------------------------------------------|
                // | 0x00:0x1f | size of b  | 0x0000000000000000000000000000000000000000000000000000000000000020 |
                // | 0x20:0x3f | size of e  | 0x0000000000000000000000000000000000000000000000000000000000000020 |
                // | 0x40:0x5f | size of m  | 0x0000000000000000000000000000000000000000000000000000000000000020 |
                // | 0x60:0x7f | value of b | 0x<.............................................................b> |
                // | 0x80:0x9f | value of e | 0x<.............................................................e> |
                // | 0xa0:0xbf | value of m | 0x<.............................................................m> |
                mstore(ptr, 0x20)
                mstore(add(ptr, 0x20), 0x20)
                mstore(add(ptr, 0x40), 0x20)
                mstore(add(ptr, 0x60), b)
                mstore(add(ptr, 0x80), e)
                mstore(add(ptr, 0xa0), m)
    
                // Given the result < m, it's guaranteed to fit in 32 bytes,
                // so we can use the memory scratch space located at offset 0.
                success := staticcall(gas(), 0x05, ptr, 0xc0, 0x00, 0x20)
                result := mload(0x00)
            }
        }
    
        /**
         * @dev Variant of {modExp} that supports inputs of arbitrary length.
         */
        function modExp(bytes memory b, bytes memory e, bytes memory m) internal view returns (bytes memory) {
            (bool success, bytes memory result) = tryModExp(b, e, m);
            if (!success) {
                Panic.panic(Panic.DIVISION_BY_ZERO);
            }
            return result;
        }
    
        /**
         * @dev Variant of {tryModExp} that supports inputs of arbitrary length.
         */
        function tryModExp(
            bytes memory b,
            bytes memory e,
            bytes memory m
        ) internal view returns (bool success, bytes memory result) {
            if (_zeroBytes(m)) return (false, new bytes(0));
    
            uint256 mLen = m.length;
    
            // Encode call args in result and move the free memory pointer
            result = abi.encodePacked(b.length, e.length, mLen, b, e, m);
    
            assembly ("memory-safe") {
                let dataPtr := add(result, 0x20)
                // Write result on top of args to avoid allocating extra memory.
                success := staticcall(gas(), 0x05, dataPtr, mload(result), dataPtr, mLen)
                // Overwrite the length.
                // result.length > returndatasize() is guaranteed because returndatasize() == m.length
                mstore(result, mLen)
                // Set the memory pointer after the returned data.
                mstore(0x40, add(dataPtr, mLen))
            }
        }
    
        /**
         * @dev Returns whether the provided byte array is zero.
         */
        function _zeroBytes(bytes memory byteArray) private pure returns (bool) {
            for (uint256 i = 0; i < byteArray.length; ++i) {
                if (byteArray[i] != 0) {
                    return false;
                }
            }
            return true;
        }
    
        /**
         * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded
         * towards zero.
         *
         * This method is based on Newton's method for computing square roots; the algorithm is restricted to only
         * using integer operations.
         */
        function sqrt(uint256 a) internal pure returns (uint256) {
            unchecked {
                // Take care of easy edge cases when a == 0 or a == 1
                if (a <= 1) {
                    return a;
                }
    
                // In this function, we use Newton's method to get a root of `f(x) := x² - a`. It involves building a
                // sequence x_n that converges toward sqrt(a). For each iteration x_n, we also define the error between
                // the current value as `ε_n = | x_n - sqrt(a) |`.
                //
                // For our first estimation, we consider `e` the smallest power of 2 which is bigger than the square root
                // of the target. (i.e. `2**(e-1) ≤ sqrt(a) < 2**e`). We know that `e ≤ 128` because `(2¹²⁸)² = 2²⁵⁶` is
                // bigger than any uint256.
                //
                // By noticing that
                // `2**(e-1) ≤ sqrt(a) < 2**e → (2**(e-1))² ≤ a < (2**e)² → 2**(2*e-2) ≤ a < 2**(2*e)`
                // we can deduce that `e - 1` is `log2(a) / 2`. We can thus compute `x_n = 2**(e-1)` using a method similar
                // to the msb function.
                uint256 aa = a;
                uint256 xn = 1;
    
                if (aa >= (1 << 128)) {
                    aa >>= 128;
                    xn <<= 64;
                }
                if (aa >= (1 << 64)) {
                    aa >>= 64;
                    xn <<= 32;
                }
                if (aa >= (1 << 32)) {
                    aa >>= 32;
                    xn <<= 16;
                }
                if (aa >= (1 << 16)) {
                    aa >>= 16;
                    xn <<= 8;
                }
                if (aa >= (1 << 8)) {
                    aa >>= 8;
                    xn <<= 4;
                }
                if (aa >= (1 << 4)) {
                    aa >>= 4;
                    xn <<= 2;
                }
                if (aa >= (1 << 2)) {
                    xn <<= 1;
                }
    
                // We now have x_n such that `x_n = 2**(e-1) ≤ sqrt(a) < 2**e = 2 * x_n`. This implies ε_n ≤ 2**(e-1).
                //
                // We can refine our estimation by noticing that the middle of that interval minimizes the error.
                // If we move x_n to equal 2**(e-1) + 2**(e-2), then we reduce the error to ε_n ≤ 2**(e-2).
                // This is going to be our x_0 (and ε_0)
                xn = (3 * xn) >> 1; // ε_0 := | x_0 - sqrt(a) | ≤ 2**(e-2)
    
                // From here, Newton's method give us:
                // x_{n+1} = (x_n + a / x_n) / 2
                //
                // One should note that:
                // x_{n+1}² - a = ((x_n + a / x_n) / 2)² - a
                //              = ((x_n² + a) / (2 * x_n))² - a
                //              = (x_n⁴ + 2 * a * x_n² + a²) / (4 * x_n²) - a
                //              = (x_n⁴ + 2 * a * x_n² + a² - 4 * a * x_n²) / (4 * x_n²)
                //              = (x_n⁴ - 2 * a * x_n² + a²) / (4 * x_n²)
                //              = (x_n² - a)² / (2 * x_n)²
                //              = ((x_n² - a) / (2 * x_n))²
                //              ≥ 0
                // Which proves that for all n ≥ 1, sqrt(a) ≤ x_n
                //
                // This gives us the proof of quadratic convergence of the sequence:
                // ε_{n+1} = | x_{n+1} - sqrt(a) |
                //         = | (x_n + a / x_n) / 2 - sqrt(a) |
                //         = | (x_n² + a - 2*x_n*sqrt(a)) / (2 * x_n) |
                //         = | (x_n - sqrt(a))² / (2 * x_n) |
                //         = | ε_n² / (2 * x_n) |
                //         = ε_n² / | (2 * x_n) |
                //
                // For the first iteration, we have a special case where x_0 is known:
                // ε_1 = ε_0² / | (2 * x_0) |
                //     ≤ (2**(e-2))² / (2 * (2**(e-1) + 2**(e-2)))
                //     ≤ 2**(2*e-4) / (3 * 2**(e-1))
                //     ≤ 2**(e-3) / 3
                //     ≤ 2**(e-3-log2(3))
                //     ≤ 2**(e-4.5)
                //
                // For the following iterations, we use the fact that, 2**(e-1) ≤ sqrt(a) ≤ x_n:
                // ε_{n+1} = ε_n² / | (2 * x_n) |
                //         ≤ (2**(e-k))² / (2 * 2**(e-1))
                //         ≤ 2**(2*e-2*k) / 2**e
                //         ≤ 2**(e-2*k)
                xn = (xn + a / xn) >> 1; // ε_1 := | x_1 - sqrt(a) | ≤ 2**(e-4.5)  -- special case, see above
                xn = (xn + a / xn) >> 1; // ε_2 := | x_2 - sqrt(a) | ≤ 2**(e-9)    -- general case with k = 4.5
                xn = (xn + a / xn) >> 1; // ε_3 := | x_3 - sqrt(a) | ≤ 2**(e-18)   -- general case with k = 9
                xn = (xn + a / xn) >> 1; // ε_4 := | x_4 - sqrt(a) | ≤ 2**(e-36)   -- general case with k = 18
                xn = (xn + a / xn) >> 1; // ε_5 := | x_5 - sqrt(a) | ≤ 2**(e-72)   -- general case with k = 36
                xn = (xn + a / xn) >> 1; // ε_6 := | x_6 - sqrt(a) | ≤ 2**(e-144)  -- general case with k = 72
    
                // Because e ≤ 128 (as discussed during the first estimation phase), we know have reached a precision
                // ε_6 ≤ 2**(e-144) < 1. Given we're operating on integers, then we can ensure that xn is now either
                // sqrt(a) or sqrt(a) + 1.
                return xn - SafeCast.toUint(xn > a / xn);
            }
        }
    
        /**
         * @dev Calculates sqrt(a), following the selected rounding direction.
         */
        function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
            unchecked {
                uint256 result = sqrt(a);
                return result + SafeCast.toUint(unsignedRoundsUp(rounding) && result * result < a);
            }
        }
    
        /**
         * @dev Return the log in base 2 of a positive value rounded towards zero.
         * Returns 0 if given 0.
         */
        function log2(uint256 value) internal pure returns (uint256) {
            uint256 result = 0;
            uint256 exp;
            unchecked {
                exp = 128 * SafeCast.toUint(value > (1 << 128) - 1);
                value >>= exp;
                result += exp;
    
                exp = 64 * SafeCast.toUint(value > (1 << 64) - 1);
                value >>= exp;
                result += exp;
    
                exp = 32 * SafeCast.toUint(value > (1 << 32) - 1);
                value >>= exp;
                result += exp;
    
                exp = 16 * SafeCast.toUint(value > (1 << 16) - 1);
                value >>= exp;
                result += exp;
    
                exp = 8 * SafeCast.toUint(value > (1 << 8) - 1);
                value >>= exp;
                result += exp;
    
                exp = 4 * SafeCast.toUint(value > (1 << 4) - 1);
                value >>= exp;
                result += exp;
    
                exp = 2 * SafeCast.toUint(value > (1 << 2) - 1);
                value >>= exp;
                result += exp;
    
                result += SafeCast.toUint(value > 1);
            }
            return result;
        }
    
        /**
         * @dev Return the log in base 2, following the selected rounding direction, of a positive value.
         * Returns 0 if given 0.
         */
        function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
            unchecked {
                uint256 result = log2(value);
                return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 1 << result < value);
            }
        }
    
        /**
         * @dev Return the log in base 10 of a positive value rounded towards zero.
         * Returns 0 if given 0.
         */
        function log10(uint256 value) internal pure returns (uint256) {
            uint256 result = 0;
            unchecked {
                if (value >= 10 ** 64) {
                    value /= 10 ** 64;
                    result += 64;
                }
                if (value >= 10 ** 32) {
                    value /= 10 ** 32;
                    result += 32;
                }
                if (value >= 10 ** 16) {
                    value /= 10 ** 16;
                    result += 16;
                }
                if (value >= 10 ** 8) {
                    value /= 10 ** 8;
                    result += 8;
                }
                if (value >= 10 ** 4) {
                    value /= 10 ** 4;
                    result += 4;
                }
                if (value >= 10 ** 2) {
                    value /= 10 ** 2;
                    result += 2;
                }
                if (value >= 10 ** 1) {
                    result += 1;
                }
            }
            return result;
        }
    
        /**
         * @dev Return the log in base 10, following the selected rounding direction, of a positive value.
         * Returns 0 if given 0.
         */
        function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
            unchecked {
                uint256 result = log10(value);
                return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 10 ** result < value);
            }
        }
    
        /**
         * @dev Return the log in base 256 of a positive value rounded towards zero.
         * Returns 0 if given 0.
         *
         * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.
         */
        function log256(uint256 value) internal pure returns (uint256) {
            uint256 result = 0;
            uint256 isGt;
            unchecked {
                isGt = SafeCast.toUint(value > (1 << 128) - 1);
                value >>= isGt * 128;
                result += isGt * 16;
    
                isGt = SafeCast.toUint(value > (1 << 64) - 1);
                value >>= isGt * 64;
                result += isGt * 8;
    
                isGt = SafeCast.toUint(value > (1 << 32) - 1);
                value >>= isGt * 32;
                result += isGt * 4;
    
                isGt = SafeCast.toUint(value > (1 << 16) - 1);
                value >>= isGt * 16;
                result += isGt * 2;
    
                result += SafeCast.toUint(value > (1 << 8) - 1);
            }
            return result;
        }
    
        /**
         * @dev Return the log in base 256, following the selected rounding direction, of a positive value.
         * Returns 0 if given 0.
         */
        function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
            unchecked {
                uint256 result = log256(value);
                return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 1 << (result << 3) < value);
            }
        }
    
        /**
         * @dev Returns whether a provided rounding mode is considered rounding up for unsigned integers.
         */
        function unsignedRoundsUp(Rounding rounding) internal pure returns (bool) {
            return uint8(rounding) % 2 == 1;
        }
    }

    // SPDX-License-Identifier: MIT
    pragma solidity ^0.8.26;
    
    import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
    import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
    import {IERC20Permit} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Permit.sol";
    
    interface IERC20Extended is IERC20, IERC20Metadata, IERC20Permit {
        function mint(address account, uint256 amount) external;
    
        function burn(uint256 amount) external;
    
        function transfer(address to, uint256 value) external returns (bool);
    
        function transferFrom(
            address from,
            address to,
            uint256 value
        ) external returns (bool);
    
        function burnFrom(address account, uint256 value) external;
    }

    // SPDX-License-Identifier: MIT
    pragma solidity ^0.8.26;
    
    // a library for handling binary fixed point numbers (https://en.wikipedia.org/wiki/Q_(number_format))
    
    // range: [0, 2**112 - 1]
    // resolution: 1 / 2**112
    
    library UQ112x112 {
        uint224 constant Q112 = 2 ** 112;
    
        // encode a uint112 as a UQ112x112
        function encode(uint112 y) internal pure returns (uint224 z) {
            unchecked {
                z = uint224(y) * Q112; // never overflows
            }
        }
    
        // divide a UQ112x112 by a uint112, returning a UQ112x112
        function uqdiv(uint224 x, uint112 y) internal pure returns (uint224 z) {
            unchecked {
                z = x / uint224(y);
            }
        }
    }

    // SPDX-License-Identifier: MIT
    pragma solidity ^0.8.26;
    
    interface IPairCallee {
        function hook(
            address sender,
            uint256 amount0,
            uint256 amount1,
            bytes calldata data
        ) external;
    }

    // SPDX-License-Identifier: GPL-2.0-or-later
    pragma solidity ^0.8.26;
    
    interface IPairFactory {
        error FEE_TOO_HIGH();
        error ZERO_FEE();
        /// @dev invalid assortment
        error IA();
        /// @dev zero address
        error ZA();
        /// @dev pair exists
        error PE();
        error NOT_AUTHORIZED();
        error INVALID_FEE_SPLIT();
    
        event PairCreated(
            address indexed token0,
            address indexed token1,
            address pair,
            uint256
        );
    
        event SetFee(uint256 indexed fee);
    
        event SetPairFee(address indexed pair, uint256 indexed fee);
    
        event SetFeeSplit(uint256 indexed _feeSplit);
    
        event SetPairFeeSplit(address indexed pair, uint256 indexed _feeSplit);
    
        event SkimStatus(address indexed _pair, bool indexed _status);
    
        event NewTreasury(address indexed _caller, address indexed _newTreasury);
    
        event FeeSplitWhenNoGauge(address indexed _caller, bool indexed _status);
    
        event SetFeeRecipient(address indexed pair, address indexed feeRecipient);
    
        /// @notice returns the total length of legacy pairs
        /// @return _length the length
        function allPairsLength() external view returns (uint256 _length);
    
        /// @notice calculates if the address is a legacy pair
        /// @param pair the address to check
        /// @return _boolean the bool return
        function isPair(address pair) external view returns (bool _boolean);
    
        /// @notice calculates the pairCodeHash
        /// @return _hash the pair code hash
        function pairCodeHash() external view returns (bytes32 _hash);
    
        /// @param tokenA address of tokenA
        /// @param tokenB address of tokenB
        /// @param stable whether it uses the stable curve
        /// @return _pair the address of the pair
        function getPair(
            address tokenA,
            address tokenB,
            bool stable
        ) external view returns (address _pair);
    
        /// @notice creates a new legacy pair
        /// @param tokenA address of tokenA
        /// @param tokenB address of tokenB
        /// @param stable whether it uses the stable curve
        /// @return pair the address of the created pair
        function createPair(
            address tokenA,
            address tokenB,
            bool stable
        ) external returns (address pair);
    
        /// @notice the address of the voter
        /// @return _voter the address of the voter
        function voter() external view returns (address _voter);
    
        /// @notice returns the address of a pair based on the index
        /// @param _index the index to check for a pair
        /// @return _pair the address of the pair at the index
        function allPairs(uint256 _index) external view returns (address _pair);
    
        /// @notice the swap fee of a pair
        /// @param _pair the address of the pair
        /// @return _fee the fee
        function pairFee(address _pair) external view returns (uint256 _fee);
    
        /// @notice the split of fees
        /// @return _split the feeSplit
        function feeSplit() external view returns (uint256 _split);
    
        /// @notice sets the swap fee for a pair
        /// @param _pair the address of the pair
        /// @param _fee the fee for the pair
        function setPairFee(address _pair, uint256 _fee) external;
    
        /// @notice set the swap fees of the pair
        /// @param _fee the fee, scaled to MAX 10% of 100_000
        function setFee(uint256 _fee) external;
    
        /// @notice the address for the treasury
        /// @return _treasury address of the treasury
        function treasury() external view returns (address _treasury);
    
        /// @notice sets the pairFees contract
        /// @param _pair the address of the pair
        /// @param _pairFees the address of the new Pair Fees
        function setFeeRecipient(address _pair, address _pairFees) external;
    
        /// @notice sets the feeSplit for a pair
        /// @param _pair the address of the pair
        /// @param _feeSplit the feeSplit
        function setPairFeeSplit(address _pair, uint256 _feeSplit) external;
    
        /// @notice whether there is feeSplit when there's no gauge
        /// @return _boolean whether there is a feesplit when no gauge
        function feeSplitWhenNoGauge() external view returns (bool _boolean);
    
        /// @notice whether a pair can be skimmed
        /// @param _pair the pair address
        /// @return _boolean whether skim is enabled
        function skimEnabled(address _pair) external view returns (bool _boolean);
    
        /// @notice set whether skim is enabled for a specific pair
        function setSkimEnabled(address _pair, bool _status) external;
    
        /// @notice sets a new treasury address
        /// @param _treasury the new treasury address
        function setTreasury(address _treasury) external;
    
        /// @notice set whether there should be a feesplit without gauges
        /// @param status whether enabled or not
        function setFeeSplitWhenNoGauge(bool status) external;
    
        /// @notice sets the feesSplit globally
        /// @param _feeSplit the fee split
        function setFeeSplit(uint256 _feeSplit) external;
    }

    // SPDX-License-Identifier: GPL-2.0-or-later
    pragma solidity ^0.8.26;
    
    interface IPair {
        error NOT_AUTHORIZED();
        error UNSTABLE_RATIO();
        /// @dev safe transfer failed
        error STF();
        error OVERFLOW();
        /// @dev skim disabled
        error SD();
        /// @dev insufficient liquidity minted
        error ILM();
        /// @dev insufficient liquidity burned
        error ILB();
        /// @dev insufficient output amount
        error IOA();
        /// @dev insufficient input amount
        error IIA();
        error IL();
        error IT();
        error K();
    
        event Mint(address indexed sender, uint256 amount0, uint256 amount1);
        event Burn(
            address indexed sender,
            uint256 amount0,
            uint256 amount1,
            address indexed to
        );
        event Swap(
            address indexed sender,
            uint256 amount0In,
            uint256 amount1In,
            uint256 amount0Out,
            uint256 amount1Out,
            address indexed to
        );
        event Sync(uint112 reserve0, uint112 reserve1);
    
        /// @notice initialize the pool, called only once programatically
        function initialize(
            address _token0,
            address _token1,
            bool _stable
        ) external;
    
        /// @notice calculate the current reserves of the pool and their last 'seen' timestamp
        /// @return _reserve0 amount of token0 in reserves
        /// @return _reserve1 amount of token1 in reserves
        /// @return _blockTimestampLast the timestamp when the pool was last updated
        function getReserves()
            external
            view
            returns (
                uint112 _reserve0,
                uint112 _reserve1,
                uint32 _blockTimestampLast
            );
    
        /// @notice mint the pair tokens (LPs)
        /// @param to where to mint the LP tokens to
        /// @return liquidity amount of LP tokens to mint
        function mint(address to) external returns (uint256 liquidity);
    
        /// @notice burn the pair tokens (LPs)
        /// @param to where to send the underlying
        /// @return amount0 amount of amount0
        /// @return amount1 amount of amount1
        function burn(
            address to
        ) external returns (uint256 amount0, uint256 amount1);
    
        /// @notice direct swap through the pool
        function swap(
            uint256 amount0Out,
            uint256 amount1Out,
            address to,
            bytes calldata data
        ) external;
    
        /// @notice force balances to match reserves, can be used to harvest rebases from rebasing tokens or other external factors
        /// @param to where to send the excess tokens to
        function skim(address to) external;
    
        /// @notice force reserves to match balances, prevents skim excess if skim is enabled
        function sync() external;
    
        /// @notice set the pair fees contract address
        function setFeeRecipient(address _pairFees) external;
    
        /// @notice set the feesplit variable
        function setFeeSplit(uint256 _feeSplit) external;
    
        /// @notice sets the swap fee of the pair
        /// @dev max of 10_000 (10%)
        /// @param _fee the fee
        function setFee(uint256 _fee) external;
    
        /// @notice 'mint' the fees as LP tokens
        /// @dev this is used for protocol/voter fees
        function mintFee() external;
    
        /// @notice calculates the amount of tokens to receive post swap
        /// @param amountIn the token amount
        /// @param tokenIn the address of the token
        function getAmountOut(
            uint256 amountIn,
            address tokenIn
        ) external view returns (uint256 amountOut);
    
        /// @notice returns various metadata about the pair
        function metadata()
            external
            view
            returns (
                uint256 _decimals0,
                uint256 _decimals1,
                uint256 _reserve0,
                uint256 _reserve1,
                bool _stable,
                address _token0,
                address _token1
            );
    
        /// @notice returns the feeSplit of the pair
        function feeSplit() external view returns (uint256);
    
        /// @notice returns the fee of the pair
        function fee() external view returns (uint256);
    
        /// @notice returns the feeRecipient of the pair
        function feeRecipient() external view returns (address);
    
    }

    // SPDX-License-Identifier: MIT
    // OpenZeppelin Contracts (last updated v5.1.0) (token/ERC20/IERC20.sol)
    
    pragma solidity ^0.8.20;
    
    /**
     * @dev Interface of the ERC-20 standard as defined in the ERC.
     */
    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 value of tokens in existence.
         */
        function totalSupply() external view returns (uint256);
    
        /**
         * @dev Returns the value of tokens owned by `account`.
         */
        function balanceOf(address account) external view returns (uint256);
    
        /**
         * @dev Moves a `value` amount of 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 value) 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 a `value` amount of tokens 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 value) external returns (bool);
    
        /**
         * @dev Moves a `value` amount of tokens from `from` to `to` using the
         * allowance mechanism. `value` 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 value) external returns (bool);
    }

    // SPDX-License-Identifier: MIT
    // OpenZeppelin Contracts (last updated v5.1.0) (token/ERC20/extensions/IERC20Metadata.sol)
    
    pragma solidity ^0.8.20;
    
    import {IERC20} from "../IERC20.sol";
    
    /**
     * @dev Interface for the optional metadata functions from the ERC-20 standard.
     */
    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);
    }

    // SPDX-License-Identifier: MIT
    // OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol)
    
    pragma solidity ^0.8.20;
    
    /**
     * @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;
        }
    
        function _contextSuffixLength() internal view virtual returns (uint256) {
            return 0;
        }
    }

    // SPDX-License-Identifier: MIT
    // OpenZeppelin Contracts (last updated v5.1.0) (interfaces/draft-IERC6093.sol)
    pragma solidity ^0.8.20;
    
    /**
     * @dev Standard ERC-20 Errors
     * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC-20 tokens.
     */
    interface IERC20Errors {
        /**
         * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.
         * @param sender Address whose tokens are being transferred.
         * @param balance Current balance for the interacting account.
         * @param needed Minimum amount required to perform a transfer.
         */
        error ERC20InsufficientBalance(address sender, uint256 balance, uint256 needed);
    
        /**
         * @dev Indicates a failure with the token `sender`. Used in transfers.
         * @param sender Address whose tokens are being transferred.
         */
        error ERC20InvalidSender(address sender);
    
        /**
         * @dev Indicates a failure with the token `receiver`. Used in transfers.
         * @param receiver Address to which tokens are being transferred.
         */
        error ERC20InvalidReceiver(address receiver);
    
        /**
         * @dev Indicates a failure with the `spender`’s `allowance`. Used in transfers.
         * @param spender Address that may be allowed to operate on tokens without being their owner.
         * @param allowance Amount of tokens a `spender` is allowed to operate with.
         * @param needed Minimum amount required to perform a transfer.
         */
        error ERC20InsufficientAllowance(address spender, uint256 allowance, uint256 needed);
    
        /**
         * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
         * @param approver Address initiating an approval operation.
         */
        error ERC20InvalidApprover(address approver);
    
        /**
         * @dev Indicates a failure with the `spender` to be approved. Used in approvals.
         * @param spender Address that may be allowed to operate on tokens without being their owner.
         */
        error ERC20InvalidSpender(address spender);
    }
    
    /**
     * @dev Standard ERC-721 Errors
     * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC-721 tokens.
     */
    interface IERC721Errors {
        /**
         * @dev Indicates that an address can't be an owner. For example, `address(0)` is a forbidden owner in ERC-20.
         * Used in balance queries.
         * @param owner Address of the current owner of a token.
         */
        error ERC721InvalidOwner(address owner);
    
        /**
         * @dev Indicates a `tokenId` whose `owner` is the zero address.
         * @param tokenId Identifier number of a token.
         */
        error ERC721NonexistentToken(uint256 tokenId);
    
        /**
         * @dev Indicates an error related to the ownership over a particular token. Used in transfers.
         * @param sender Address whose tokens are being transferred.
         * @param tokenId Identifier number of a token.
         * @param owner Address of the current owner of a token.
         */
        error ERC721IncorrectOwner(address sender, uint256 tokenId, address owner);
    
        /**
         * @dev Indicates a failure with the token `sender`. Used in transfers.
         * @param sender Address whose tokens are being transferred.
         */
        error ERC721InvalidSender(address sender);
    
        /**
         * @dev Indicates a failure with the token `receiver`. Used in transfers.
         * @param receiver Address to which tokens are being transferred.
         */
        error ERC721InvalidReceiver(address receiver);
    
        /**
         * @dev Indicates a failure with the `operator`’s approval. Used in transfers.
         * @param operator Address that may be allowed to operate on tokens without being their owner.
         * @param tokenId Identifier number of a token.
         */
        error ERC721InsufficientApproval(address operator, uint256 tokenId);
    
        /**
         * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
         * @param approver Address initiating an approval operation.
         */
        error ERC721InvalidApprover(address approver);
    
        /**
         * @dev Indicates a failure with the `operator` to be approved. Used in approvals.
         * @param operator Address that may be allowed to operate on tokens without being their owner.
         */
        error ERC721InvalidOperator(address operator);
    }
    
    /**
     * @dev Standard ERC-1155 Errors
     * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC-1155 tokens.
     */
    interface IERC1155Errors {
        /**
         * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.
         * @param sender Address whose tokens are being transferred.
         * @param balance Current balance for the interacting account.
         * @param needed Minimum amount required to perform a transfer.
         * @param tokenId Identifier number of a token.
         */
        error ERC1155InsufficientBalance(address sender, uint256 balance, uint256 needed, uint256 tokenId);
    
        /**
         * @dev Indicates a failure with the token `sender`. Used in transfers.
         * @param sender Address whose tokens are being transferred.
         */
        error ERC1155InvalidSender(address sender);
    
        /**
         * @dev Indicates a failure with the token `receiver`. Used in transfers.
         * @param receiver Address to which tokens are being transferred.
         */
        error ERC1155InvalidReceiver(address receiver);
    
        /**
         * @dev Indicates a failure with the `operator`’s approval. Used in transfers.
         * @param operator Address that may be allowed to operate on tokens without being their owner.
         * @param owner Address of the current owner of a token.
         */
        error ERC1155MissingApprovalForAll(address operator, address owner);
    
        /**
         * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
         * @param approver Address initiating an approval operation.
         */
        error ERC1155InvalidApprover(address approver);
    
        /**
         * @dev Indicates a failure with the `operator` to be approved. Used in approvals.
         * @param operator Address that may be allowed to operate on tokens without being their owner.
         */
        error ERC1155InvalidOperator(address operator);
    
        /**
         * @dev Indicates an array length mismatch between ids and values in a safeBatchTransferFrom operation.
         * Used in batch transfers.
         * @param idsLength Length of the array of token identifiers
         * @param valuesLength Length of the array of token amounts
         */
        error ERC1155InvalidArrayLength(uint256 idsLength, uint256 valuesLength);
    }

    // SPDX-License-Identifier: MIT
    // OpenZeppelin Contracts (last updated v5.1.0) (utils/Panic.sol)
    
    pragma solidity ^0.8.20;
    
    /**
     * @dev Helper library for emitting standardized panic codes.
     *
     * ```solidity
     * contract Example {
     *      using Panic for uint256;
     *
     *      // Use any of the declared internal constants
     *      function foo() { Panic.GENERIC.panic(); }
     *
     *      // Alternatively
     *      function foo() { Panic.panic(Panic.GENERIC); }
     * }
     * ```
     *
     * Follows the list from https://github.com/ethereum/solidity/blob/v0.8.24/libsolutil/ErrorCodes.h[libsolutil].
     *
     * _Available since v5.1._
     */
    // slither-disable-next-line unused-state
    library Panic {
        /// @dev generic / unspecified error
        uint256 internal constant GENERIC = 0x00;
        /// @dev used by the assert() builtin
        uint256 internal constant ASSERT = 0x01;
        /// @dev arithmetic underflow or overflow
        uint256 internal constant UNDER_OVERFLOW = 0x11;
        /// @dev division or modulo by zero
        uint256 internal constant DIVISION_BY_ZERO = 0x12;
        /// @dev enum conversion error
        uint256 internal constant ENUM_CONVERSION_ERROR = 0x21;
        /// @dev invalid encoding in storage
        uint256 internal constant STORAGE_ENCODING_ERROR = 0x22;
        /// @dev empty array pop
        uint256 internal constant EMPTY_ARRAY_POP = 0x31;
        /// @dev array out of bounds access
        uint256 internal constant ARRAY_OUT_OF_BOUNDS = 0x32;
        /// @dev resource error (too large allocation or too large array)
        uint256 internal constant RESOURCE_ERROR = 0x41;
        /// @dev calling invalid internal function
        uint256 internal constant INVALID_INTERNAL_FUNCTION = 0x51;
    
        /// @dev Reverts with a panic code. Recommended to use with
        /// the internal constants with predefined codes.
        function panic(uint256 code) internal pure {
            assembly ("memory-safe") {
                mstore(0x00, 0x4e487b71)
                mstore(0x20, code)
                revert(0x1c, 0x24)
            }
        }
    }

    // SPDX-License-Identifier: MIT
    // OpenZeppelin Contracts (last updated v5.1.0) (utils/math/SafeCast.sol)
    // This file was procedurally generated from scripts/generate/templates/SafeCast.js.
    
    pragma solidity ^0.8.20;
    
    /**
     * @dev Wrappers over Solidity's uintXX/intXX/bool casting operators with added overflow
     * checks.
     *
     * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can
     * easily result in undesired exploitation or bugs, since developers usually
     * assume that overflows raise errors. `SafeCast` restores this intuition by
     * reverting the transaction when such an operation overflows.
     *
     * Using this library instead of the unchecked operations eliminates an entire
     * class of bugs, so it's recommended to use it always.
     */
    library SafeCast {
        /**
         * @dev Value doesn't fit in an uint of `bits` size.
         */
        error SafeCastOverflowedUintDowncast(uint8 bits, uint256 value);
    
        /**
         * @dev An int value doesn't fit in an uint of `bits` size.
         */
        error SafeCastOverflowedIntToUint(int256 value);
    
        /**
         * @dev Value doesn't fit in an int of `bits` size.
         */
        error SafeCastOverflowedIntDowncast(uint8 bits, int256 value);
    
        /**
         * @dev An uint value doesn't fit in an int of `bits` size.
         */
        error SafeCastOverflowedUintToInt(uint256 value);
    
        /**
         * @dev Returns the downcasted uint248 from uint256, reverting on
         * overflow (when the input is greater than largest uint248).
         *
         * Counterpart to Solidity's `uint248` operator.
         *
         * Requirements:
         *
         * - input must fit into 248 bits
         */
        function toUint248(uint256 value) internal pure returns (uint248) {
            if (value > type(uint248).max) {
                revert SafeCastOverflowedUintDowncast(248, value);
            }
            return uint248(value);
        }
    
        /**
         * @dev Returns the downcasted uint240 from uint256, reverting on
         * overflow (when the input is greater than largest uint240).
         *
         * Counterpart to Solidity's `uint240` operator.
         *
         * Requirements:
         *
         * - input must fit into 240 bits
         */
        function toUint240(uint256 value) internal pure returns (uint240) {
            if (value > type(uint240).max) {
                revert SafeCastOverflowedUintDowncast(240, value);
            }
            return uint240(value);
        }
    
        /**
         * @dev Returns the downcasted uint232 from uint256, reverting on
         * overflow (when the input is greater than largest uint232).
         *
         * Counterpart to Solidity's `uint232` operator.
         *
         * Requirements:
         *
         * - input must fit into 232 bits
         */
        function toUint232(uint256 value) internal pure returns (uint232) {
            if (value > type(uint232).max) {
                revert SafeCastOverflowedUintDowncast(232, value);
            }
            return uint232(value);
        }
    
        /**
         * @dev Returns the downcasted uint224 from uint256, reverting on
         * overflow (when the input is greater than largest uint224).
         *
         * Counterpart to Solidity's `uint224` operator.
         *
         * Requirements:
         *
         * - input must fit into 224 bits
         */
        function toUint224(uint256 value) internal pure returns (uint224) {
            if (value > type(uint224).max) {
                revert SafeCastOverflowedUintDowncast(224, value);
            }
            return uint224(value);
        }
    
        /**
         * @dev Returns the downcasted uint216 from uint256, reverting on
         * overflow (when the input is greater than largest uint216).
         *
         * Counterpart to Solidity's `uint216` operator.
         *
         * Requirements:
         *
         * - input must fit into 216 bits
         */
        function toUint216(uint256 value) internal pure returns (uint216) {
            if (value > type(uint216).max) {
                revert SafeCastOverflowedUintDowncast(216, value);
            }
            return uint216(value);
        }
    
        /**
         * @dev Returns the downcasted uint208 from uint256, reverting on
         * overflow (when the input is greater than largest uint208).
         *
         * Counterpart to Solidity's `uint208` operator.
         *
         * Requirements:
         *
         * - input must fit into 208 bits
         */
        function toUint208(uint256 value) internal pure returns (uint208) {
            if (value > type(uint208).max) {
                revert SafeCastOverflowedUintDowncast(208, value);
            }
            return uint208(value);
        }
    
        /**
         * @dev Returns the downcasted uint200 from uint256, reverting on
         * overflow (when the input is greater than largest uint200).
         *
         * Counterpart to Solidity's `uint200` operator.
         *
         * Requirements:
         *
         * - input must fit into 200 bits
         */
        function toUint200(uint256 value) internal pure returns (uint200) {
            if (value > type(uint200).max) {
                revert SafeCastOverflowedUintDowncast(200, value);
            }
            return uint200(value);
        }
    
        /**
         * @dev Returns the downcasted uint192 from uint256, reverting on
         * overflow (when the input is greater than largest uint192).
         *
         * Counterpart to Solidity's `uint192` operator.
         *
         * Requirements:
         *
         * - input must fit into 192 bits
         */
        function toUint192(uint256 value) internal pure returns (uint192) {
            if (value > type(uint192).max) {
                revert SafeCastOverflowedUintDowncast(192, value);
            }
            return uint192(value);
        }
    
        /**
         * @dev Returns the downcasted uint184 from uint256, reverting on
         * overflow (when the input is greater than largest uint184).
         *
         * Counterpart to Solidity's `uint184` operator.
         *
         * Requirements:
         *
         * - input must fit into 184 bits
         */
        function toUint184(uint256 value) internal pure returns (uint184) {
            if (value > type(uint184).max) {
                revert SafeCastOverflowedUintDowncast(184, value);
            }
            return uint184(value);
        }
    
        /**
         * @dev Returns the downcasted uint176 from uint256, reverting on
         * overflow (when the input is greater than largest uint176).
         *
         * Counterpart to Solidity's `uint176` operator.
         *
         * Requirements:
         *
         * - input must fit into 176 bits
         */
        function toUint176(uint256 value) internal pure returns (uint176) {
            if (value > type(uint176).max) {
                revert SafeCastOverflowedUintDowncast(176, value);
            }
            return uint176(value);
        }
    
        /**
         * @dev Returns the downcasted uint168 from uint256, reverting on
         * overflow (when the input is greater than largest uint168).
         *
         * Counterpart to Solidity's `uint168` operator.
         *
         * Requirements:
         *
         * - input must fit into 168 bits
         */
        function toUint168(uint256 value) internal pure returns (uint168) {
            if (value > type(uint168).max) {
                revert SafeCastOverflowedUintDowncast(168, value);
            }
            return uint168(value);
        }
    
        /**
         * @dev Returns the downcasted uint160 from uint256, reverting on
         * overflow (when the input is greater than largest uint160).
         *
         * Counterpart to Solidity's `uint160` operator.
         *
         * Requirements:
         *
         * - input must fit into 160 bits
         */
        function toUint160(uint256 value) internal pure returns (uint160) {
            if (value > type(uint160).max) {
                revert SafeCastOverflowedUintDowncast(160, value);
            }
            return uint160(value);
        }
    
        /**
         * @dev Returns the downcasted uint152 from uint256, reverting on
         * overflow (when the input is greater than largest uint152).
         *
         * Counterpart to Solidity's `uint152` operator.
         *
         * Requirements:
         *
         * - input must fit into 152 bits
         */
        function toUint152(uint256 value) internal pure returns (uint152) {
            if (value > type(uint152).max) {
                revert SafeCastOverflowedUintDowncast(152, value);
            }
            return uint152(value);
        }
    
        /**
         * @dev Returns the downcasted uint144 from uint256, reverting on
         * overflow (when the input is greater than largest uint144).
         *
         * Counterpart to Solidity's `uint144` operator.
         *
         * Requirements:
         *
         * - input must fit into 144 bits
         */
        function toUint144(uint256 value) internal pure returns (uint144) {
            if (value > type(uint144).max) {
                revert SafeCastOverflowedUintDowncast(144, value);
            }
            return uint144(value);
        }
    
        /**
         * @dev Returns the downcasted uint136 from uint256, reverting on
         * overflow (when the input is greater than largest uint136).
         *
         * Counterpart to Solidity's `uint136` operator.
         *
         * Requirements:
         *
         * - input must fit into 136 bits
         */
        function toUint136(uint256 value) internal pure returns (uint136) {
            if (value > type(uint136).max) {
                revert SafeCastOverflowedUintDowncast(136, value);
            }
            return uint136(value);
        }
    
        /**
         * @dev Returns the downcasted uint128 from uint256, reverting on
         * overflow (when the input is greater than largest uint128).
         *
         * Counterpart to Solidity's `uint128` operator.
         *
         * Requirements:
         *
         * - input must fit into 128 bits
         */
        function toUint128(uint256 value) internal pure returns (uint128) {
            if (value > type(uint128).max) {
                revert SafeCastOverflowedUintDowncast(128, value);
            }
            return uint128(value);
        }
    
        /**
         * @dev Returns the downcasted uint120 from uint256, reverting on
         * overflow (when the input is greater than largest uint120).
         *
         * Counterpart to Solidity's `uint120` operator.
         *
         * Requirements:
         *
         * - input must fit into 120 bits
         */
        function toUint120(uint256 value) internal pure returns (uint120) {
            if (value > type(uint120).max) {
                revert SafeCastOverflowedUintDowncast(120, value);
            }
            return uint120(value);
        }
    
        /**
         * @dev Returns the downcasted uint112 from uint256, reverting on
         * overflow (when the input is greater than largest uint112).
         *
         * Counterpart to Solidity's `uint112` operator.
         *
         * Requirements:
         *
         * - input must fit into 112 bits
         */
        function toUint112(uint256 value) internal pure returns (uint112) {
            if (value > type(uint112).max) {
                revert SafeCastOverflowedUintDowncast(112, value);
            }
            return uint112(value);
        }
    
        /**
         * @dev Returns the downcasted uint104 from uint256, reverting on
         * overflow (when the input is greater than largest uint104).
         *
         * Counterpart to Solidity's `uint104` operator.
         *
         * Requirements:
         *
         * - input must fit into 104 bits
         */
        function toUint104(uint256 value) internal pure returns (uint104) {
            if (value > type(uint104).max) {
                revert SafeCastOverflowedUintDowncast(104, value);
            }
            return uint104(value);
        }
    
        /**
         * @dev Returns the downcasted uint96 from uint256, reverting on
         * overflow (when the input is greater than largest uint96).
         *
         * Counterpart to Solidity's `uint96` operator.
         *
         * Requirements:
         *
         * - input must fit into 96 bits
         */
        function toUint96(uint256 value) internal pure returns (uint96) {
            if (value > type(uint96).max) {
                revert SafeCastOverflowedUintDowncast(96, value);
            }
            return uint96(value);
        }
    
        /**
         * @dev Returns the downcasted uint88 from uint256, reverting on
         * overflow (when the input is greater than largest uint88).
         *
         * Counterpart to Solidity's `uint88` operator.
         *
         * Requirements:
         *
         * - input must fit into 88 bits
         */
        function toUint88(uint256 value) internal pure returns (uint88) {
            if (value > type(uint88).max) {
                revert SafeCastOverflowedUintDowncast(88, value);
            }
            return uint88(value);
        }
    
        /**
         * @dev Returns the downcasted uint80 from uint256, reverting on
         * overflow (when the input is greater than largest uint80).
         *
         * Counterpart to Solidity's `uint80` operator.
         *
         * Requirements:
         *
         * - input must fit into 80 bits
         */
        function toUint80(uint256 value) internal pure returns (uint80) {
            if (value > type(uint80).max) {
                revert SafeCastOverflowedUintDowncast(80, value);
            }
            return uint80(value);
        }
    
        /**
         * @dev Returns the downcasted uint72 from uint256, reverting on
         * overflow (when the input is greater than largest uint72).
         *
         * Counterpart to Solidity's `uint72` operator.
         *
         * Requirements:
         *
         * - input must fit into 72 bits
         */
        function toUint72(uint256 value) internal pure returns (uint72) {
            if (value > type(uint72).max) {
                revert SafeCastOverflowedUintDowncast(72, value);
            }
            return uint72(value);
        }
    
        /**
         * @dev Returns the downcasted uint64 from uint256, reverting on
         * overflow (when the input is greater than largest uint64).
         *
         * Counterpart to Solidity's `uint64` operator.
         *
         * Requirements:
         *
         * - input must fit into 64 bits
         */
        function toUint64(uint256 value) internal pure returns (uint64) {
            if (value > type(uint64).max) {
                revert SafeCastOverflowedUintDowncast(64, value);
            }
            return uint64(value);
        }
    
        /**
         * @dev Returns the downcasted uint56 from uint256, reverting on
         * overflow (when the input is greater than largest uint56).
         *
         * Counterpart to Solidity's `uint56` operator.
         *
         * Requirements:
         *
         * - input must fit into 56 bits
         */
        function toUint56(uint256 value) internal pure returns (uint56) {
            if (value > type(uint56).max) {
                revert SafeCastOverflowedUintDowncast(56, value);
            }
            return uint56(value);
        }
    
        /**
         * @dev Returns the downcasted uint48 from uint256, reverting on
         * overflow (when the input is greater than largest uint48).
         *
         * Counterpart to Solidity's `uint48` operator.
         *
         * Requirements:
         *
         * - input must fit into 48 bits
         */
        function toUint48(uint256 value) internal pure returns (uint48) {
            if (value > type(uint48).max) {
                revert SafeCastOverflowedUintDowncast(48, value);
            }
            return uint48(value);
        }
    
        /**
         * @dev Returns the downcasted uint40 from uint256, reverting on
         * overflow (when the input is greater than largest uint40).
         *
         * Counterpart to Solidity's `uint40` operator.
         *
         * Requirements:
         *
         * - input must fit into 40 bits
         */
        function toUint40(uint256 value) internal pure returns (uint40) {
            if (value > type(uint40).max) {
                revert SafeCastOverflowedUintDowncast(40, value);
            }
            return uint40(value);
        }
    
        /**
         * @dev Returns the downcasted uint32 from uint256, reverting on
         * overflow (when the input is greater than largest uint32).
         *
         * Counterpart to Solidity's `uint32` operator.
         *
         * Requirements:
         *
         * - input must fit into 32 bits
         */
        function toUint32(uint256 value) internal pure returns (uint32) {
            if (value > type(uint32).max) {
                revert SafeCastOverflowedUintDowncast(32, value);
            }
            return uint32(value);
        }
    
        /**
         * @dev Returns the downcasted uint24 from uint256, reverting on
         * overflow (when the input is greater than largest uint24).
         *
         * Counterpart to Solidity's `uint24` operator.
         *
         * Requirements:
         *
         * - input must fit into 24 bits
         */
        function toUint24(uint256 value) internal pure returns (uint24) {
            if (value > type(uint24).max) {
                revert SafeCastOverflowedUintDowncast(24, value);
            }
            return uint24(value);
        }
    
        /**
         * @dev Returns the downcasted uint16 from uint256, reverting on
         * overflow (when the input is greater than largest uint16).
         *
         * Counterpart to Solidity's `uint16` operator.
         *
         * Requirements:
         *
         * - input must fit into 16 bits
         */
        function toUint16(uint256 value) internal pure returns (uint16) {
            if (value > type(uint16).max) {
                revert SafeCastOverflowedUintDowncast(16, value);
            }
            return uint16(value);
        }
    
        /**
         * @dev Returns the downcasted uint8 from uint256, reverting on
         * overflow (when the input is greater than largest uint8).
         *
         * Counterpart to Solidity's `uint8` operator.
         *
         * Requirements:
         *
         * - input must fit into 8 bits
         */
        function toUint8(uint256 value) internal pure returns (uint8) {
            if (value > type(uint8).max) {
                revert SafeCastOverflowedUintDowncast(8, value);
            }
            return uint8(value);
        }
    
        /**
         * @dev Converts a signed int256 into an unsigned uint256.
         *
         * Requirements:
         *
         * - input must be greater than or equal to 0.
         */
        function toUint256(int256 value) internal pure returns (uint256) {
            if (value < 0) {
                revert SafeCastOverflowedIntToUint(value);
            }
            return uint256(value);
        }
    
        /**
         * @dev Returns the downcasted int248 from int256, reverting on
         * overflow (when the input is less than smallest int248 or
         * greater than largest int248).
         *
         * Counterpart to Solidity's `int248` operator.
         *
         * Requirements:
         *
         * - input must fit into 248 bits
         */
        function toInt248(int256 value) internal pure returns (int248 downcasted) {
            downcasted = int248(value);
            if (downcasted != value) {
                revert SafeCastOverflowedIntDowncast(248, value);
            }
        }
    
        /**
         * @dev Returns the downcasted int240 from int256, reverting on
         * overflow (when the input is less than smallest int240 or
         * greater than largest int240).
         *
         * Counterpart to Solidity's `int240` operator.
         *
         * Requirements:
         *
         * - input must fit into 240 bits
         */
        function toInt240(int256 value) internal pure returns (int240 downcasted) {
            downcasted = int240(value);
            if (downcasted != value) {
                revert SafeCastOverflowedIntDowncast(240, value);
            }
        }
    
        /**
         * @dev Returns the downcasted int232 from int256, reverting on
         * overflow (when the input is less than smallest int232 or
         * greater than largest int232).
         *
         * Counterpart to Solidity's `int232` operator.
         *
         * Requirements:
         *
         * - input must fit into 232 bits
         */
        function toInt232(int256 value) internal pure returns (int232 downcasted) {
            downcasted = int232(value);
            if (downcasted != value) {
                revert SafeCastOverflowedIntDowncast(232, value);
            }
        }
    
        /**
         * @dev Returns the downcasted int224 from int256, reverting on
         * overflow (when the input is less than smallest int224 or
         * greater than largest int224).
         *
         * Counterpart to Solidity's `int224` operator.
         *
         * Requirements:
         *
         * - input must fit into 224 bits
         */
        function toInt224(int256 value) internal pure returns (int224 downcasted) {
            downcasted = int224(value);
            if (downcasted != value) {
                revert SafeCastOverflowedIntDowncast(224, value);
            }
        }
    
        /**
         * @dev Returns the downcasted int216 from int256, reverting on
         * overflow (when the input is less than smallest int216 or
         * greater than largest int216).
         *
         * Counterpart to Solidity's `int216` operator.
         *
         * Requirements:
         *
         * - input must fit into 216 bits
         */
        function toInt216(int256 value) internal pure returns (int216 downcasted) {
            downcasted = int216(value);
            if (downcasted != value) {
                revert SafeCastOverflowedIntDowncast(216, value);
            }
        }
    
        /**
         * @dev Returns the downcasted int208 from int256, reverting on
         * overflow (when the input is less than smallest int208 or
         * greater than largest int208).
         *
         * Counterpart to Solidity's `int208` operator.
         *
         * Requirements:
         *
         * - input must fit into 208 bits
         */
        function toInt208(int256 value) internal pure returns (int208 downcasted) {
            downcasted = int208(value);
            if (downcasted != value) {
                revert SafeCastOverflowedIntDowncast(208, value);
            }
        }
    
        /**
         * @dev Returns the downcasted int200 from int256, reverting on
         * overflow (when the input is less than smallest int200 or
         * greater than largest int200).
         *
         * Counterpart to Solidity's `int200` operator.
         *
         * Requirements:
         *
         * - input must fit into 200 bits
         */
        function toInt200(int256 value) internal pure returns (int200 downcasted) {
            downcasted = int200(value);
            if (downcasted != value) {
                revert SafeCastOverflowedIntDowncast(200, value);
            }
        }
    
        /**
         * @dev Returns the downcasted int192 from int256, reverting on
         * overflow (when the input is less than smallest int192 or
         * greater than largest int192).
         *
         * Counterpart to Solidity's `int192` operator.
         *
         * Requirements:
         *
         * - input must fit into 192 bits
         */
        function toInt192(int256 value) internal pure returns (int192 downcasted) {
            downcasted = int192(value);
            if (downcasted != value) {
                revert SafeCastOverflowedIntDowncast(192, value);
            }
        }
    
        /**
         * @dev Returns the downcasted int184 from int256, reverting on
         * overflow (when the input is less than smallest int184 or
         * greater than largest int184).
         *
         * Counterpart to Solidity's `int184` operator.
         *
         * Requirements:
         *
         * - input must fit into 184 bits
         */
        function toInt184(int256 value) internal pure returns (int184 downcasted) {
            downcasted = int184(value);
            if (downcasted != value) {
                revert SafeCastOverflowedIntDowncast(184, value);
            }
        }
    
        /**
         * @dev Returns the downcasted int176 from int256, reverting on
         * overflow (when the input is less than smallest int176 or
         * greater than largest int176).
         *
         * Counterpart to Solidity's `int176` operator.
         *
         * Requirements:
         *
         * - input must fit into 176 bits
         */
        function toInt176(int256 value) internal pure returns (int176 downcasted) {
            downcasted = int176(value);
            if (downcasted != value) {
                revert SafeCastOverflowedIntDowncast(176, value);
            }
        }
    
        /**
         * @dev Returns the downcasted int168 from int256, reverting on
         * overflow (when the input is less than smallest int168 or
         * greater than largest int168).
         *
         * Counterpart to Solidity's `int168` operator.
         *
         * Requirements:
         *
         * - input must fit into 168 bits
         */
        function toInt168(int256 value) internal pure returns (int168 downcasted) {
            downcasted = int168(value);
            if (downcasted != value) {
                revert SafeCastOverflowedIntDowncast(168, value);
            }
        }
    
        /**
         * @dev Returns the downcasted int160 from int256, reverting on
         * overflow (when the input is less than smallest int160 or
         * greater than largest int160).
         *
         * Counterpart to Solidity's `int160` operator.
         *
         * Requirements:
         *
         * - input must fit into 160 bits
         */
        function toInt160(int256 value) internal pure returns (int160 downcasted) {
            downcasted = int160(value);
            if (downcasted != value) {
                revert SafeCastOverflowedIntDowncast(160, value);
            }
        }
    
        /**
         * @dev Returns the downcasted int152 from int256, reverting on
         * overflow (when the input is less than smallest int152 or
         * greater than largest int152).
         *
         * Counterpart to Solidity's `int152` operator.
         *
         * Requirements:
         *
         * - input must fit into 152 bits
         */
        function toInt152(int256 value) internal pure returns (int152 downcasted) {
            downcasted = int152(value);
            if (downcasted != value) {
                revert SafeCastOverflowedIntDowncast(152, value);
            }
        }
    
        /**
         * @dev Returns the downcasted int144 from int256, reverting on
         * overflow (when the input is less than smallest int144 or
         * greater than largest int144).
         *
         * Counterpart to Solidity's `int144` operator.
         *
         * Requirements:
         *
         * - input must fit into 144 bits
         */
        function toInt144(int256 value) internal pure returns (int144 downcasted) {
            downcasted = int144(value);
            if (downcasted != value) {
                revert SafeCastOverflowedIntDowncast(144, value);
            }
        }
    
        /**
         * @dev Returns the downcasted int136 from int256, reverting on
         * overflow (when the input is less than smallest int136 or
         * greater than largest int136).
         *
         * Counterpart to Solidity's `int136` operator.
         *
         * Requirements:
         *
         * - input must fit into 136 bits
         */
        function toInt136(int256 value) internal pure returns (int136 downcasted) {
            downcasted = int136(value);
            if (downcasted != value) {
                revert SafeCastOverflowedIntDowncast(136, value);
            }
        }
    
        /**
         * @dev Returns the downcasted int128 from int256, reverting on
         * overflow (when the input is less than smallest int128 or
         * greater than largest int128).
         *
         * Counterpart to Solidity's `int128` operator.
         *
         * Requirements:
         *
         * - input must fit into 128 bits
         */
        function toInt128(int256 value) internal pure returns (int128 downcasted) {
            downcasted = int128(value);
            if (downcasted != value) {
                revert SafeCastOverflowedIntDowncast(128, value);
            }
        }
    
        /**
         * @dev Returns the downcasted int120 from int256, reverting on
         * overflow (when the input is less than smallest int120 or
         * greater than largest int120).
         *
         * Counterpart to Solidity's `int120` operator.
         *
         * Requirements:
         *
         * - input must fit into 120 bits
         */
        function toInt120(int256 value) internal pure returns (int120 downcasted) {
            downcasted = int120(value);
            if (downcasted != value) {
                revert SafeCastOverflowedIntDowncast(120, value);
            }
        }
    
        /**
         * @dev Returns the downcasted int112 from int256, reverting on
         * overflow (when the input is less than smallest int112 or
         * greater than largest int112).
         *
         * Counterpart to Solidity's `int112` operator.
         *
         * Requirements:
         *
         * - input must fit into 112 bits
         */
        function toInt112(int256 value) internal pure returns (int112 downcasted) {
            downcasted = int112(value);
            if (downcasted != value) {
                revert SafeCastOverflowedIntDowncast(112, value);
            }
        }
    
        /**
         * @dev Returns the downcasted int104 from int256, reverting on
         * overflow (when the input is less than smallest int104 or
         * greater than largest int104).
         *
         * Counterpart to Solidity's `int104` operator.
         *
         * Requirements:
         *
         * - input must fit into 104 bits
         */
        function toInt104(int256 value) internal pure returns (int104 downcasted) {
            downcasted = int104(value);
            if (downcasted != value) {
                revert SafeCastOverflowedIntDowncast(104, value);
            }
        }
    
        /**
         * @dev Returns the downcasted int96 from int256, reverting on
         * overflow (when the input is less than smallest int96 or
         * greater than largest int96).
         *
         * Counterpart to Solidity's `int96` operator.
         *
         * Requirements:
         *
         * - input must fit into 96 bits
         */
        function toInt96(int256 value) internal pure returns (int96 downcasted) {
            downcasted = int96(value);
            if (downcasted != value) {
                revert SafeCastOverflowedIntDowncast(96, value);
            }
        }
    
        /**
         * @dev Returns the downcasted int88 from int256, reverting on
         * overflow (when the input is less than smallest int88 or
         * greater than largest int88).
         *
         * Counterpart to Solidity's `int88` operator.
         *
         * Requirements:
         *
         * - input must fit into 88 bits
         */
        function toInt88(int256 value) internal pure returns (int88 downcasted) {
            downcasted = int88(value);
            if (downcasted != value) {
                revert SafeCastOverflowedIntDowncast(88, value);
            }
        }
    
        /**
         * @dev Returns the downcasted int80 from int256, reverting on
         * overflow (when the input is less than smallest int80 or
         * greater than largest int80).
         *
         * Counterpart to Solidity's `int80` operator.
         *
         * Requirements:
         *
         * - input must fit into 80 bits
         */
        function toInt80(int256 value) internal pure returns (int80 downcasted) {
            downcasted = int80(value);
            if (downcasted != value) {
                revert SafeCastOverflowedIntDowncast(80, value);
            }
        }
    
        /**
         * @dev Returns the downcasted int72 from int256, reverting on
         * overflow (when the input is less than smallest int72 or
         * greater than largest int72).
         *
         * Counterpart to Solidity's `int72` operator.
         *
         * Requirements:
         *
         * - input must fit into 72 bits
         */
        function toInt72(int256 value) internal pure returns (int72 downcasted) {
            downcasted = int72(value);
            if (downcasted != value) {
                revert SafeCastOverflowedIntDowncast(72, value);
            }
        }
    
        /**
         * @dev Returns the downcasted int64 from int256, reverting on
         * overflow (when the input is less than smallest int64 or
         * greater than largest int64).
         *
         * Counterpart to Solidity's `int64` operator.
         *
         * Requirements:
         *
         * - input must fit into 64 bits
         */
        function toInt64(int256 value) internal pure returns (int64 downcasted) {
            downcasted = int64(value);
            if (downcasted != value) {
                revert SafeCastOverflowedIntDowncast(64, value);
            }
        }
    
        /**
         * @dev Returns the downcasted int56 from int256, reverting on
         * overflow (when the input is less than smallest int56 or
         * greater than largest int56).
         *
         * Counterpart to Solidity's `int56` operator.
         *
         * Requirements:
         *
         * - input must fit into 56 bits
         */
        function toInt56(int256 value) internal pure returns (int56 downcasted) {
            downcasted = int56(value);
            if (downcasted != value) {
                revert SafeCastOverflowedIntDowncast(56, value);
            }
        }
    
        /**
         * @dev Returns the downcasted int48 from int256, reverting on
         * overflow (when the input is less than smallest int48 or
         * greater than largest int48).
         *
         * Counterpart to Solidity's `int48` operator.
         *
         * Requirements:
         *
         * - input must fit into 48 bits
         */
        function toInt48(int256 value) internal pure returns (int48 downcasted) {
            downcasted = int48(value);
            if (downcasted != value) {
                revert SafeCastOverflowedIntDowncast(48, value);
            }
        }
    
        /**
         * @dev Returns the downcasted int40 from int256, reverting on
         * overflow (when the input is less than smallest int40 or
         * greater than largest int40).
         *
         * Counterpart to Solidity's `int40` operator.
         *
         * Requirements:
         *
         * - input must fit into 40 bits
         */
        function toInt40(int256 value) internal pure returns (int40 downcasted) {
            downcasted = int40(value);
            if (downcasted != value) {
                revert SafeCastOverflowedIntDowncast(40, value);
            }
        }
    
        /**
         * @dev Returns the downcasted int32 from int256, reverting on
         * overflow (when the input is less than smallest int32 or
         * greater than largest int32).
         *
         * Counterpart to Solidity's `int32` operator.
         *
         * Requirements:
         *
         * - input must fit into 32 bits
         */
        function toInt32(int256 value) internal pure returns (int32 downcasted) {
            downcasted = int32(value);
            if (downcasted != value) {
                revert SafeCastOverflowedIntDowncast(32, value);
            }
        }
    
        /**
         * @dev Returns the downcasted int24 from int256, reverting on
         * overflow (when the input is less than smallest int24 or
         * greater than largest int24).
         *
         * Counterpart to Solidity's `int24` operator.
         *
         * Requirements:
         *
         * - input must fit into 24 bits
         */
        function toInt24(int256 value) internal pure returns (int24 downcasted) {
            downcasted = int24(value);
            if (downcasted != value) {
                revert SafeCastOverflowedIntDowncast(24, value);
            }
        }
    
        /**
         * @dev Returns the downcasted int16 from int256, reverting on
         * overflow (when the input is less than smallest int16 or
         * greater than largest int16).
         *
         * Counterpart to Solidity's `int16` operator.
         *
         * Requirements:
         *
         * - input must fit into 16 bits
         */
        function toInt16(int256 value) internal pure returns (int16 downcasted) {
            downcasted = int16(value);
            if (downcasted != value) {
                revert SafeCastOverflowedIntDowncast(16, value);
            }
        }
    
        /**
         * @dev Returns the downcasted int8 from int256, reverting on
         * overflow (when the input is less than smallest int8 or
         * greater than largest int8).
         *
         * Counterpart to Solidity's `int8` operator.
         *
         * Requirements:
         *
         * - input must fit into 8 bits
         */
        function toInt8(int256 value) internal pure returns (int8 downcasted) {
            downcasted = int8(value);
            if (downcasted != value) {
                revert SafeCastOverflowedIntDowncast(8, value);
            }
        }
    
        /**
         * @dev Converts an unsigned uint256 into a signed int256.
         *
         * Requirements:
         *
         * - input must be less than or equal to maxInt256.
         */
        function toInt256(uint256 value) internal pure returns (int256) {
            // Note: Unsafe cast below is okay because `type(int256).max` is guaranteed to be positive
            if (value > uint256(type(int256).max)) {
                revert SafeCastOverflowedUintToInt(value);
            }
            return int256(value);
        }
    
        /**
         * @dev Cast a boolean (false or true) to a uint256 (0 or 1) with no jump.
         */
        function toUint(bool b) internal pure returns (uint256 u) {
            assembly ("memory-safe") {
                u := iszero(iszero(b))
            }
        }
    }

    // SPDX-License-Identifier: MIT
    // OpenZeppelin Contracts (last updated v5.1.0) (token/ERC20/extensions/IERC20Permit.sol)
    
    pragma solidity ^0.8.20;
    
    /**
     * @dev Interface of the ERC-20 Permit extension allowing approvals to be made via signatures, as defined in
     * https://eips.ethereum.org/EIPS/eip-2612[ERC-2612].
     *
     * Adds the {permit} method, which can be used to change an account's ERC-20 allowance (see {IERC20-allowance}) by
     * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't
     * need to send a transaction, and thus is not required to hold Ether at all.
     *
     * ==== Security Considerations
     *
     * There are two important considerations concerning the use of `permit`. The first is that a valid permit signature
     * expresses an allowance, and it should not be assumed to convey additional meaning. In particular, it should not be
     * considered as an intention to spend the allowance in any specific way. The second is that because permits have
     * built-in replay protection and can be submitted by anyone, they can be frontrun. A protocol that uses permits should
     * take this into consideration and allow a `permit` call to fail. Combining these two aspects, a pattern that may be
     * generally recommended is:
     *
     * ```solidity
     * function doThingWithPermit(..., uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) public {
     *     try token.permit(msg.sender, address(this), value, deadline, v, r, s) {} catch {}
     *     doThing(..., value);
     * }
     *
     * function doThing(..., uint256 value) public {
     *     token.safeTransferFrom(msg.sender, address(this), value);
     *     ...
     * }
     * ```
     *
     * Observe that: 1) `msg.sender` is used as the owner, leaving no ambiguity as to the signer intent, and 2) the use of
     * `try/catch` allows the permit to fail and makes the code tolerant to frontrunning. (See also
     * {SafeERC20-safeTransferFrom}).
     *
     * Additionally, note that smart contract wallets (such as Argent or Safe) are not able to produce permit signatures, so
     * contracts should have entry points that don't rely on permit.
     */
    interface IERC20Permit {
        /**
         * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,
         * given ``owner``'s signed approval.
         *
         * IMPORTANT: The same issues {IERC20-approve} has related to transaction
         * ordering also apply here.
         *
         * Emits an {Approval} event.
         *
         * Requirements:
         *
         * - `spender` cannot be the zero address.
         * - `deadline` must be a timestamp in the future.
         * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`
         * over the EIP712-formatted function arguments.
         * - the signature must use ``owner``'s current nonce (see {nonces}).
         *
         * For more information on the signature format, see the
         * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP
         * section].
         *
         * CAUTION: See Security Considerations above.
         */
        function permit(
            address owner,
            address spender,
            uint256 value,
            uint256 deadline,
            uint8 v,
            bytes32 r,
            bytes32 s
        ) external;
    
        /**
         * @dev Returns the current nonce for `owner`. This value must be
         * included whenever a signature is generated for {permit}.
         *
         * Every successful call to {permit} increases ``owner``'s nonce by one. This
         * prevents a signature from being used multiple times.
         */
        function nonces(address owner) external view returns (uint256);
    
        /**
         * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.
         */
        // solhint-disable-next-line func-name-mixedcase
        function DOMAIN_SEPARATOR() external view returns (bytes32);
    }

    Context size (optional):