Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

More Options

• Similar
• Submit Audit
• Compare

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.13;

import {ERC20Upgradeable} from "@openzeppelin-contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol";
import {Initializable} from "@openzeppelin-contracts-upgradeable/proxy/utils/Initializable.sol";
import {IFlapTaxToken} from "src/interfaces/Tax/IFlapTaxToken.sol";
import {PoolAddress} from "src/libraries/PoolAddress.sol";
import {ERC20PermitUpgradeable} from
    "@openzeppelin-contracts-upgradeable/token/ERC20/extensions/ERC20PermitUpgradeable.sol";
import {OwnableUpgradeable} from "@openzeppelin-contracts-upgradeable/access/OwnableUpgradeable.sol";

// revision:
//   v0.0.3: Add setMainPool method
//   v0.0.2: Make TAX_DURATION Confiurable
//   v0.0.1: initial version
//

/// @notice FlapTaxToken is an ERC20 token with tax functionality
/// Features:
///    - Anti-farmer tax: Tax is applied to all pools (including v3 pools). Doing
///                       so could restrict the farmers from draining trading fees by providing concentrated liquidity on Uni V3.
//     - Time-dependent tax: the tax is only applied for a certain period of time then it will be automatically removed.
//     - Dynamic Tax Liquidation Threshold: The tax liquidation threshold is dynamically adjusted.
contract FlapTaxToken is Initializable, ERC20PermitUpgradeable, OwnableUpgradeable, IFlapTaxToken {
    /// @notice Constructor parameters for initializing immutable variables
    struct ConstructorParams {
        /// @param PCS_V2_FACTORY The address of the PancakeSwap V2 factory contract
        address PCS_V2_FACTORY;
        /// @param PCS_V2_CODE_HASH The hash of the PancakeSwap V2 code
        bytes32 PCS_V2_CODE_HASH;
        /// @param PCS_V2_ROUTER The address of the PancakeSwap V2 router contract
        /// @dev obsolete
        address PCS_V2_ROUTER;
        /// @param PCS_SMART_ROUTER The address of the PancakeSwap V2 smart router
        /// @dev obsolete
        address PCS_SMART_ROUTER;
        /// @param WETH The address of the WETH contract
        address WETH;
        /// @param PCS_V3_FACTORY The address of the PancakeSwap V3 factory contract
        address PCS_V3_FACTORY;
        /// @param PCS_V3_CODE_HASH The hash of the PancakeSwap V3 code
        bytes32 PCS_V3_CODE_HASH;
        /// @param UNI_V2_FACTORY The address of the Uniswap V2 factory contract
        address UNI_V2_FACTORY;
        /// @param UNI_V2_CODE_HASH The hash of the Uniswap V2 code
        bytes32 UNI_V2_CODE_HASH;
        /// @param UNI_V3_FACTORY The address of the Uniswap V3 factory contract
        address UNI_V3_FACTORY;
        /// @param UNI_V3_CODE_HASH The hash of the Uniswap V3 code
        bytes32 UNI_V3_CODE_HASH;
        /// @param PCS_V4_VAULT The address of the PancakeSwap V4 vault
        address PCS_V4_VAULT;
        /// @param UNI_V4_POOL The address of the Uniswap V4 pool
        address UNI_V4_POOL;
        /// @param MIN_LIQ_THRESHOLD The minimum liquidation threshold
        uint256 MIN_LIQ_THRESHOLD;
        /// @param START_LIQ_THRESHOLD The starting liquidation threshold
        uint256 START_LIQ_THRESHOLD;
        /// @param ANTI_FARMER_DURATION The duration of the anti-farmer tax in seconds
        uint256 ANTI_FARMER_DURATION;
    }

    // Immutable variables
    /// @notice The address of the PancakeSwap V2 factory contract
    address private immutable PCS_V2_FACTORY;
    /// @notice The hash of the PancakeSwap V2 code
    bytes32 private immutable PCS_V2_CODE_HASH;
    /// @notice The address of the PancakeSwap V3 factory contract
    address private immutable PCS_V3_FACTORY;
    /// @notice The hash of the PancakeSwap V3 code
    bytes32 private immutable PCS_V3_CODE_HASH;
    /// @notice The address of the Uniswap V2 factory contract
    address private immutable UNI_V2_FACTORY;
    /// @notice The hash of the Uniswap V2 code
    bytes32 private immutable UNI_V2_CODE_HASH;
    /// @notice The address of the Uniswap V3 factory contract
    address private immutable UNI_V3_FACTORY;
    /// @notice The hash of the Uniswap V3 code
    bytes32 private immutable UNI_V3_CODE_HASH;
    /// @notice the address of the PancakeSwap V4 vault
    address private immutable PCS_V4_VAULT;
    /// @notice the address of the Uniswap V4 pool
    address private immutable UNI_V4_POOL;

    /// @notice The address of the WETH contract
    address private immutable WETH;

    /// @notice The address of the PancakeSwap V2 router (repurposed for default router)
    address private immutable PCS_V2_ROUTER;

    /// @notice The quote token used for pools (can be WETH or any ERC20)
    address public QUOTE_TOKEN;

    /// @notice The minimum liquidation threshold
    uint256 public immutable MIN_LIQ_THRESHOLD;
    /// @notice The starting liquidation threshold
    uint256 public immutable START_LIQ_THRESHOLD;
    /// @notice The expected output amount in each liquidation
    /// @dev i.e, the expected output QUOTE_TOKEN amount in each liquidation
    uint256 public liqExpectedOutputAmount;

    /// @notice The duration of the anti-farmer tax in seconds
    uint256 public immutable ANTI_FARMER_DURATION;

    // State variables
    /// @notice The metadata URI of the token
    string public override metaURI;
    /// @notice The tax rate for the token in basis points
    uint16 public taxRate;
    /// @notice The address of the tax splitter contract
    address public taxSplitter;
    /// @notice The threshold of tokens for liquidity
    uint256 public liquidationThreshold;
    /// @notice The address of the V2 pool
    address public mainPool;
    /// @notice the main pool router
    address public mainPoolRouter;
    /// @notice The maximum supply of the token
    uint256 public constant maxSupply = 1e9 ether; // 1 billion tokens
    /// @notice The duration of the tax in seconds
    uint256 public TAX_DURATION;

    /// @notice Indicates whether the contract is not in the middle of a tax liquidation
    /// @dev gas saving to use a default value of true.
    bool private notLiquidating;

    /// @notice Include all the pools related to this token
    /// Of course, this does not include all the pools, we only put some most
    /// used pools here.
    mapping(address => bool) public pools;

    /// @notice Enum to represent the state of the pool
    enum PoolState {
        BondingCurve, // state0: Token is trading on the bonding curve, no tax, no transfers to pools
        Migrating, // state1: Token is in the process of migration
        TaxEnforcedAntiFarmer, // state2: Token listed on DEX, tax applied for transfers involving any pool
        TaxEnforced, // state3: Token listed on DEX, tax applied for transfers involving mainPool
        TaxFree // state4: Token is free of tax

    }

    /// @notice Current state of the pool
    PoolState public state;

    /// @notice Timestamp when the tax expires
    uint256 public taxExpirationTime;

    /// @notice Timestamp when the anti-farmer tax expires
    uint256 public antiFarmerExpirationTime;

    /// @notice Constructor to initialize immutable variables
    /// @param params The constructor parameters
    constructor(ConstructorParams memory params) {
        PCS_V2_FACTORY = params.PCS_V2_FACTORY;
        PCS_V2_CODE_HASH = params.PCS_V2_CODE_HASH;
        PCS_V2_ROUTER = params.PCS_V2_ROUTER;
        WETH = params.WETH;
        PCS_V3_FACTORY = params.PCS_V3_FACTORY;
        PCS_V3_CODE_HASH = params.PCS_V3_CODE_HASH;
        UNI_V2_FACTORY = params.UNI_V2_FACTORY;
        UNI_V2_CODE_HASH = params.UNI_V2_CODE_HASH;
        UNI_V3_FACTORY = params.UNI_V3_FACTORY;
        UNI_V3_CODE_HASH = params.UNI_V3_CODE_HASH;
        MIN_LIQ_THRESHOLD = params.MIN_LIQ_THRESHOLD;
        START_LIQ_THRESHOLD = params.START_LIQ_THRESHOLD;

        // Initialize new immutable variables
        ANTI_FARMER_DURATION = params.ANTI_FARMER_DURATION;
        PCS_V4_VAULT = params.PCS_V4_VAULT;
        UNI_V4_POOL = params.UNI_V4_POOL;

        _disableInitializers();
    }

    /// @notice Starts the migration process by transitioning the state of the pool
    function startMigration() external override onlyOwner {
        if (state == PoolState.BondingCurve) {
            state = PoolState.Migrating;
            emit PoolStateChanged(uint8(PoolState.BondingCurve), uint8(state));
        }
    }

    /// @notice Finalizes the migration by transitioning the state of the pool
    function finalizeMigration() external override onlyOwner {
        if (state == PoolState.Migrating) {
            state = PoolState.TaxEnforcedAntiFarmer;
            taxExpirationTime = block.timestamp + TAX_DURATION;
            antiFarmerExpirationTime = block.timestamp + ANTI_FARMER_DURATION;
            emit PoolStateChanged(uint8(PoolState.Migrating), uint8(state));
        }
    }

    /// @notice Change the main pool address
    /// @dev Can only be called by owner
    /// @dev Can only be called in the state of BondingCurve
    /// @param newMainPool The new main pool address
    /// @param router The address of the router for the main pool
    function setMainPool(address newMainPool, address router) external override onlyOwner {
        require(state == PoolState.BondingCurve, "Can only set main pool in BondingCurve state");
        require(newMainPool != address(0), "Invalid pool address");
        require(router != address(0), "Invalid router address");

        // Remove old main pool from the pools mapping
        pools[mainPool] = false;

        // Update main pool
        mainPool = newMainPool;
        mainPoolRouter = router;

        // Add new main pool to the pools mapping
        pools[newMainPool] = true;
    }

    /// @notice Initializes the token with the given parameters
    /// @param params The initialization parameters
    function initialize(InitParams memory params) external initializer {
        // Validate that tax duration is at least as long as anti-farmer duration
        require(params.taxDuration >= ANTI_FARMER_DURATION, "Tax duration must be >= anti-farmer duration");

        __ERC20_init(params.name, params.symbol);
        __ERC20Permit_init(params.name);
        __Ownable_init();

        metaURI = params.meta;
        taxRate = params.tax;
        taxSplitter = params.taxSplitter;
        liquidationThreshold = START_LIQ_THRESHOLD;
        notLiquidating = true;
        TAX_DURATION = params.taxDuration;

        // mint 1B to the msg.sender
        _mint(msg.sender, maxSupply);

        // Set QUOTE_TOKEN
        QUOTE_TOKEN = params.quoteToken;

        // Set liqExpectedOutputAmount from params
        liqExpectedOutputAmount = params.liqExpectedOutputAmount;

        //
        // pre-compute all pool addresses related to this token
        //

        // This is our main pool, we are using the PancakeSwap V2 pool as the main pool
        mainPool = PoolAddress.computeV2Address(PCS_V2_FACTORY, PCS_V2_CODE_HASH, address(this), QUOTE_TOKEN);

        // Initialize mainPoolRouter with PCS_V2_ROUTER
        mainPoolRouter = PCS_V2_ROUTER;

        // v2 pools

        // add the main pool to the mapping
        pools[mainPool] = true;
        // add uniswap v2 pool to the mapping
        pools[PoolAddress.computeV2Address(UNI_V2_FACTORY, UNI_V2_CODE_HASH, address(this), QUOTE_TOKEN)] = true;

        // v3 pools

        uint24[5] memory fees = [uint24(100), 500, 2500, 3000, 10000];
        uint256 feesLength = fees.length; // gas saving, reading the slot only once

        for (uint256 i = 0; i < feesLength; i++) {
            uint24 fee = fees[i];
            // Add PancakeSwap V3 pools to the mapping
            pools[PoolAddress.computeV3Address(PCS_V3_FACTORY, PCS_V3_CODE_HASH, address(this), QUOTE_TOKEN, fee)] =
                true;
            // Add Uniswap V3 pools to the mapping
            pools[PoolAddress.computeV3Address(UNI_V3_FACTORY, UNI_V3_CODE_HASH, address(this), QUOTE_TOKEN, fee)] =
                true;
        }

        // Add PCS_V4_VAULT and UNI_V4_POOL to the mapping
        pools[PCS_V4_VAULT] = true;
        pools[UNI_V4_POOL] = true;
    }

    /// @notice Internal function to perform a plain (no tax) transfer
    /// @param from The address sending the tokens
    /// @param to The address receiving the tokens
    /// @param amount The amount of tokens to transfer
    function _plainTransfer(address from, address to, uint256 amount) internal {
        super._transfer(from, to, amount);
    }

    /// @notice Internal function to calculate the tax amount
    /// @param from The address sending the tokens
    /// @param to The address receiving the tokens
    /// @param amount The amount of tokens to transfer
    /// @return The tax amount
    function _getTax(address from, address to, uint256 amount) internal view returns (uint256) {
        if (notLiquidating) {
            if (state == PoolState.TaxEnforcedAntiFarmer) {
                // Apply tax if transfer involves any pool
                if (pools[from] || pools[to]) {
                    return (amount * taxRate) / 10000;
                }
            } else if (state == PoolState.TaxEnforced) {
                // Apply tax only if transfer involves v2Pool
                if (from == mainPool || to == mainPool) {
                    return (amount * taxRate) / 10000;
                }
            }
        }
        return 0;
    }

    /// @notice Internal function to perform a taxed transfer
    /// @param from The address sending the tokens
    /// @param to The address receiving the tokens
    /// @param amount The amount of tokens to transfer
    /// @param tax The tax amount for the transfer
    function _taxedTransfer(address from, address to, uint256 amount, uint256 tax) internal {
        uint256 remainingAmount = amount - tax;

        _plainTransfer(from, address(this), tax);
        _plainTransfer(from, to, remainingAmount);
    }

    /// @notice Overrides the _transfer function to handle tax and liquidation
    /// @param from The address sending the tokens
    /// @param to The address receiving the tokens
    /// @param amount The amount of tokens to transfer
    function _transfer(address from, address to, uint256 amount) internal override {
        _liquidateTax(to);

        if (state == PoolState.BondingCurve) {
            require(!pools[from] && !pools[to], "Transfers to/from pools are restricted in BondingCurve state");
            _plainTransfer(from, to, amount);
        } else if (state == PoolState.Migrating) {
            _plainTransfer(from, to, amount);
        } else if (state == PoolState.TaxEnforcedAntiFarmer || state == PoolState.TaxEnforced) {
            uint256 tax = _getTax(from, to, amount);
            if (tax > 0) {
                _taxedTransfer(from, to, amount, tax);
            } else {
                _plainTransfer(from, to, amount);
            }
        } else {
            // TaxFree state
            _plainTransfer(from, to, amount);
        }
    }

    /// @notice Internal function to liquidate the accrued tax amount
    /// @param to the recipient of the current transfer call
    function _liquidateTax(address to) internal {
        // Note: from == mainPool does not work and leads to a DOS vector.
        // Uniswap v2 pair has a lock, if the user swaps WETH for the token, the pair first locks the pair and then
        // transfers the token to the user (i.e from == mainPool).  We could not liquidate in that "transfer" as the pair is already locked.
        // Besides, the flash swap does not work even when swapping the token for WETH due to the same reason.
        // For the tax token, you should follow the normal flow:
        //  (1) transfer token/WETH to the pair
        //  (2) call the pair's swap function.

        if (
            (state == PoolState.TaxEnforced || state == PoolState.TaxEnforcedAntiFarmer) // only when tax is enforced
                && notLiquidating // not in the middle of liquidation
                && (to == mainPool) // possibly selling to the main v2 pool
        ) {
            // State transition
            if (block.timestamp > taxExpirationTime) {
                PoolState oldState = state;
                state = PoolState.TaxFree;
                taxRate = 0; // reset tax rate
                emit PoolStateChanged(uint8(oldState), uint8(state));
            } else if (block.timestamp > antiFarmerExpirationTime && state != PoolState.TaxEnforced) {
                PoolState oldState = state;
                state = PoolState.TaxEnforced;
                emit PoolStateChanged(uint8(oldState), uint8(state));
            }

            uint256 taxAmount = balanceOf(address(this));

            if (
                taxAmount > 0 // Tax to liquidate
                    && (state == PoolState.TaxFree || taxAmount >= liquidationThreshold) // Enough tax to liquidate or last liquidation
            ) {
                notLiquidating = false; // start liquidation

                // Approve the router to spend tax tokens if needed
                if (allowance(address(this), mainPoolRouter) < taxAmount) {
                    _approve(address(this), mainPoolRouter, type(uint256).max);
                }

                // Always swap to quote token (ERC20)
                address[] memory path = new address[](2);
                path[0] = address(this);
                path[1] = QUOTE_TOKEN;

                // Get expected output amount using getAmountsOut
                uint256[] memory amounts = IUniswapRouter02(mainPoolRouter).getAmountsOut(taxAmount, path);
                uint256 outputAmount = amounts[1];

                try IUniswapRouter02(mainPoolRouter).swapExactTokensForTokensSupportingFeeOnTransferTokens(
                    taxAmount, outputAmount, path, taxSplitter, block.timestamp
                ) {
                    _adjustLiquidationThreshold(taxAmount, outputAmount);
                    // emit an event for successful liquidation
                    // We intentionally make the event's name long to ease our indexer
                    emit FlapTaxLiquidationSuccess(QUOTE_TOKEN, taxAmount, outputAmount);
                } catch (bytes memory reason) {
                    emit TaxLiquidationError(reason);
                    _plainTransfer(address(this), taxSplitter, taxAmount);
                }

                notLiquidating = true; // end of liquidation
            }
        }
    }

    /// @notice Adjusts the liquidation threshold based on the tax amount and output amount
    /// @param taxAmount The amount of tax being liquidated
    /// @param outputAmount The output amount from the liquidation
    function _adjustLiquidationThreshold(uint256 taxAmount, uint256 outputAmount) internal {
        // We only monotonically reduce the liquidation threshold until it reaches the minimum threshold
        uint256 expectedOutputAmount = (outputAmount * liquidationThreshold) / taxAmount;
        if (expectedOutputAmount > liqExpectedOutputAmount) {
            liquidationThreshold = (liquidationThreshold * 99) / 100; // Reduce by 1%
            if (liquidationThreshold < MIN_LIQ_THRESHOLD) {
                liquidationThreshold = MIN_LIQ_THRESHOLD;
            }
        }
    }

    function _afterTokenTransfer(address from, address to, uint256 amount) internal override {
        emit TransferFlapToken(from, to, amount);
    }
}

/// @dev This is a stripped version of the Uniswap SwapRouter02 interface
/// https://github.com/Uniswap/swap-router-contracts/blob/v1.3.0/contracts/SwapRouter02.sol
/// In the context of PancakeSwap, it is named as SmartRouter:
/// https://bscscan.com/address/0x13f4EA83D0bd40E75C8222255bc855a974568Dd4#code
interface ISmartRouter {
    /// @notice Call multiple functions in the current contract and return the data from all of them if they all succeed
    /// @dev The `msg.value` should not be trusted for any method callable from multicall.
    /// @param data The encoded function data for each of the calls to make to this contract
    /// @return results The results from each of the calls passed in via data
    function multicall(bytes[] calldata data) external payable returns (bytes[] memory results);

    /// @notice Unwraps the contract's WETH9 balance and sends it to recipient as ETH.
    /// @dev The amountMinimum parameter prevents malicious contracts from stealing WETH9 from users.
    /// @param amountMinimum The minimum amount of WETH9 to unwrap
    /// @param recipient The address receiving ETH
    function unwrapWETH9(uint256 amountMinimum, address recipient) external payable;

    /// @notice Swaps `amountIn` of one token for as much as possible of another token
    /// @dev Setting `amountIn` to 0 will cause the contract to look up its own balance,
    /// and swap the entire amount, enabling contracts to send tokens before calling this function.
    /// @param amountIn The amount of token to swap
    /// @param amountOutMin The minimum amount of output that must be received
    /// @param path The ordered list of tokens to swap through
    /// @param to The recipient address
    /// @return amountOut The amount of the received token
    function swapExactTokensForTokens(uint256 amountIn, uint256 amountOutMin, address[] calldata path, address to)
        external
        payable
        returns (uint256 amountOut);

    /// @notice Transfers the full amount of a token held by this contract to recipient
    /// @dev The amountMinimum parameter prevents malicious contracts from stealing the token from users
    /// @param token The contract address of the token which will be transferred to `recipient`
    /// @param amountMinimum The minimum amount of token required for a transfer
    /// @param recipient The destination address of the token
    function sweepToken(address token, uint256 amountMinimum, address recipient) external payable;
}

interface IUniswapRouter02 {
    // @notice Swaps an exact amount of input tokens for as many output tokens as possible, with support for fee-on-transfer tokens
    function swapExactTokensForETHSupportingFeeOnTransferTokens(
        uint256 amountIn,
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external;

    // @notice Swaps an exact amount of input tokens for as many output tokens as possible, with support for fee-on-transfer tokens
    function swapExactTokensForTokensSupportingFeeOnTransferTokens(
        uint256 amountIn,
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external;

    // @notice Given an input amount of an asset and pair reserves, returns the maximum output amount of the other asset
    function getAmountsOut(uint256 amountIn, address[] calldata path)
        external
        view
        returns (uint256[] memory amounts);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/ERC20.sol)

pragma solidity ^0.8.0;

import "./IERC20Upgradeable.sol";
import "./extensions/IERC20MetadataUpgradeable.sol";
import "../../utils/ContextUpgradeable.sol";
import {Initializable} from "../../proxy/utils/Initializable.sol";

/**
 * @dev Implementation of the {IERC20} interface.
 *
 * This implementation is agnostic to the way tokens are created. This means
 * that a supply mechanism has to be added in a derived contract using {_mint}.
 * For a generic mechanism see {ERC20PresetMinterPauser}.
 *
 * TIP: For a detailed writeup see our guide
 * https://forum.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 ERC20
 * applications.
 *
 * Additionally, an {Approval} event is emitted on calls to {transferFrom}.
 * This allows applications to reconstruct the allowance for all accounts just
 * by listening to said events. Other implementations of the EIP may not emit
 * these events, as it isn't required by the specification.
 *
 * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}
 * functions have been added to mitigate the well-known issues around setting
 * allowances. See {IERC20-approve}.
 */
contract ERC20Upgradeable is Initializable, ContextUpgradeable, IERC20Upgradeable, IERC20MetadataUpgradeable {
    mapping(address => uint256) private _balances;

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

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;

    /**
     * @dev Sets the values for {name} and {symbol}.
     *
     * All two of these values are immutable: they can only be set once during
     * construction.
     */
    function __ERC20_init(string memory name_, string memory symbol_) internal onlyInitializing {
        __ERC20_init_unchained(name_, symbol_);
    }

    function __ERC20_init_unchained(string memory name_, string memory symbol_) internal onlyInitializing {
        _name = name_;
        _symbol = symbol_;
    }

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

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

    /**
     * @dev Returns the number of decimals used to get its user representation.
     * For example, if `decimals` equals `2`, a balance of `505` tokens should
     * be displayed to a user as `5.05` (`505 / 10 ** 2`).
     *
     * Tokens usually opt for a value of 18, imitating the relationship between
     * Ether and Wei. This is the 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 override returns (uint8) {
        return 18;
    }

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

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

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

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

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

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

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

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

        return true;
    }

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

        _beforeTokenTransfer(from, to, amount);

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

        emit Transfer(from, to, amount);

        _afterTokenTransfer(from, to, amount);
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    /**
     * @dev This empty reserved space is put in place to allow future versions to add new
     * variables without shifting down storage in the inheritance chain.
     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
     */
    uint256[45] private __gap;
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (proxy/utils/Initializable.sol)

pragma solidity ^0.8.2;

import "../../utils/AddressUpgradeable.sol";

/**
 * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed
 * behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an
 * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer
 * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.
 *
 * The initialization functions use a version number. Once a version number is used, it is consumed and cannot be
 * reused. This mechanism prevents re-execution of each "step" but allows the creation of new initialization steps in
 * case an upgrade adds a module that needs to be initialized.
 *
 * For example:
 *
 * [.hljs-theme-light.nopadding]
 * ```solidity
 * contract MyToken is ERC20Upgradeable {
 *     function initialize() initializer public {
 *         __ERC20_init("MyToken", "MTK");
 *     }
 * }
 *
 * contract MyTokenV2 is MyToken, ERC20PermitUpgradeable {
 *     function initializeV2() reinitializer(2) public {
 *         __ERC20Permit_init("MyToken");
 *     }
 * }
 * ```
 *
 * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as
 * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.
 *
 * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure
 * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.
 *
 * [CAUTION]
 * ====
 * Avoid leaving a contract uninitialized.
 *
 * An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation
 * contract, which may impact the proxy. To prevent the implementation contract from being used, you should invoke
 * the {_disableInitializers} function in the constructor to automatically lock it when it is deployed:
 *
 * [.hljs-theme-light.nopadding]
 * ```
 * /// @custom:oz-upgrades-unsafe-allow constructor
 * constructor() {
 *     _disableInitializers();
 * }
 * ```
 * ====
 */
abstract contract Initializable {
    /**
     * @dev Indicates that the contract has been initialized.
     * @custom:oz-retyped-from bool
     */
    uint8 private _initialized;

    /**
     * @dev Indicates that the contract is in the process of being initialized.
     */
    bool private _initializing;

    /**
     * @dev Triggered when the contract has been initialized or reinitialized.
     */
    event Initialized(uint8 version);

    /**
     * @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope,
     * `onlyInitializing` functions can be used to initialize parent contracts.
     *
     * Similar to `reinitializer(1)`, except that functions marked with `initializer` can be nested in the context of a
     * constructor.
     *
     * Emits an {Initialized} event.
     */
    modifier initializer() {
        bool isTopLevelCall = !_initializing;
        require(
            (isTopLevelCall && _initialized < 1) || (!AddressUpgradeable.isContract(address(this)) && _initialized == 1),
            "Initializable: contract is already initialized"
        );
        _initialized = 1;
        if (isTopLevelCall) {
            _initializing = true;
        }
        _;
        if (isTopLevelCall) {
            _initializing = false;
            emit Initialized(1);
        }
    }

    /**
     * @dev A modifier that defines a protected reinitializer function that can be invoked at most once, and only if the
     * contract hasn't been initialized to a greater version before. In its scope, `onlyInitializing` functions can be
     * used to initialize parent contracts.
     *
     * A reinitializer may be used after the original initialization step. This is essential to configure modules that
     * are added through upgrades and that require initialization.
     *
     * When `version` is 1, this modifier is similar to `initializer`, except that functions marked with `reinitializer`
     * cannot be nested. If one is invoked in the context of another, execution will revert.
     *
     * Note that versions can jump in increments greater than 1; this implies that if multiple reinitializers coexist in
     * a contract, executing them in the right order is up to the developer or operator.
     *
     * WARNING: setting the version to 255 will prevent any future reinitialization.
     *
     * Emits an {Initialized} event.
     */
    modifier reinitializer(uint8 version) {
        require(!_initializing && _initialized < version, "Initializable: contract is already initialized");
        _initialized = version;
        _initializing = true;
        _;
        _initializing = false;
        emit Initialized(version);
    }

    /**
     * @dev Modifier to protect an initialization function so that it can only be invoked by functions with the
     * {initializer} and {reinitializer} modifiers, directly or indirectly.
     */
    modifier onlyInitializing() {
        require(_initializing, "Initializable: contract is not initializing");
        _;
    }

    /**
     * @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call.
     * Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized
     * to any version. It is recommended to use this to lock implementation contracts that are designed to be called
     * through proxies.
     *
     * Emits an {Initialized} event the first time it is successfully executed.
     */
    function _disableInitializers() internal virtual {
        require(!_initializing, "Initializable: contract is initializing");
        if (_initialized != type(uint8).max) {
            _initialized = type(uint8).max;
            emit Initialized(type(uint8).max);
        }
    }

    /**
     * @dev Returns the highest version that has been initialized. See {reinitializer}.
     */
    function _getInitializedVersion() internal view returns (uint8) {
        return _initialized;
    }

    /**
     * @dev Returns `true` if the contract is currently initializing. See {onlyInitializing}.
     */
    function _isInitializing() internal view returns (bool) {
        return _initializing;
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.13;

import {IERC20MetadataUpgradeable} from
    "@openzeppelin-contracts-upgradeable/token/ERC20/extensions/IERC20MetadataUpgradeable.sol";

import {IERC20PermitUpgradeable} from
    "@openzeppelin-contracts-upgradeable/token/ERC20/extensions/IERC20PermitUpgradeable.sol";

interface IFlapTaxToken is IERC20MetadataUpgradeable, IERC20PermitUpgradeable {
    /// @notice Initialization parameters for setting up the token
    struct InitParams {
        /// @param name The name of the token
        string name;
        /// @param symbol The symbol of the token
        string symbol;
        /// @param meta The metadata of the token
        string meta;
        /// @param tax The tax rate for the token in basis points (1/100 of a percent)
        uint16 tax;
        /// @param taxSplitter The address of the tax splitter contract
        address taxSplitter;
        /// @param quoteToken The address of the quote token for pools (WETH or any ERC20)
        address quoteToken;
        /// @param liqExpectedOutputAmount The expected output amount in each liquidation
        uint256 liqExpectedOutputAmount;
        /// @param taxDuration The duration of the tax in seconds
        uint256 taxDuration;
    }

    /// @notice Initializes the token with the given parameters
    function initialize(InitParams memory params) external;

    /// @notice Returns the IPFS CID of the metadata JSON
    /// @return The metadata URI
    function metaURI() external view returns (string memory);

    /// @notice Returns the tax rate in basis points
    /// @return The tax rate (1/100 of a percent)
    function taxRate() external view returns (uint16);

    /// @notice Returns the main V2 pool address for this token
    /// @return The address of the main V2 pool
    function mainPool() external view returns (address);

    /// migration related functions

    /// @notice Starts the migration process used by the Portal Contract
    function startMigration() external;

    /// @notice Finalizes the migration process used by the Portal Contract
    function finalizeMigration() external;

    /// @notice Change the main pool
    /// @dev can only be called by owner
    /// @dev can only be called in the state of BondingCurve
    /// @dev This method may not exist on some chains
    /// Since this legacy tax token will be soon preceded by v2
    /// @param newMainPool The address of the new main pool
    /// @param router The address of the router for the main pool
    function setMainPool(address newMainPool, address router) external;

    /// @notice Custom transfer event for easier indexing
    /// @param from The address sending the tokens
    /// @param to The address receiving the tokens
    /// @param value The amount of tokens transferred
    event TransferFlapToken(address from, address to, uint256 value);

    /// @notice Emitted when tax liquidation fails
    event TaxLiquidationError(bytes reason);

    /// @notice Emitted when tax liquidation succeeds
    /// @param quoteToken The address of the quote token received
    /// @param taxAmount The amount of tax tokens liquidated
    /// @param outputAmount The amount of quote tokens received
    event FlapTaxLiquidationSuccess(address quoteToken, uint256 taxAmount, uint256 outputAmount);

    /// @notice Emitted when the pool state changes
    /// @param fromState The previous state
    /// @param toState The new state
    event PoolStateChanged(uint8 fromState, uint8 toState);
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.13;

/// @title Helper to predict uniswap v3/v2 pool address
/// @author The Flap Team
library PoolAddress {
    /// @notice Get the address of Uniswap V3 pool
    /// @param factory The address of the Uniswap V3 factory
    /// @param initCodeHash The init code hash of the Uniswap V3 pool
    /// @param token0 The address of token0
    /// @param token1 The address of token1
    /// @param fee The fee of the pool
    function computeV3Address(address factory, bytes32 initCodeHash, address token0, address token1, uint24 fee)
        internal
        pure
        returns (address)
    {
        // https://github.com/Uniswap/v3-periphery/blob/main/contracts/libraries/PoolAddress.sol

        (token0, token1) = token0 < token1 ? (token0, token1) : (token1, token0);
        return address(
            uint160(
                uint256(
                    keccak256(
                        abi.encodePacked(hex"ff", factory, keccak256(abi.encode(token0, token1, fee)), initCodeHash)
                    )
                )
            )
        );
    }

    /// @notice Get the address of Uniswap V2 pool
    /// @param factory The address of the Uniswap V2 factory
    /// @param initCodeHash The init code hash of the Uniswap V2 pool
    /// @param token0 The address of token0
    /// @param token1 The address of token1
    function computeV2Address(address factory, bytes32 initCodeHash, address token0, address token1)
        internal
        pure
        returns (address)
    {
        // https://github.com/Uniswap/v2-core/blob/ee547b17853e71ed4e0101ccfd52e70d5acded58/contracts/UniswapV2Factory.sol#L31

        (token0, token1) = token0 < token1 ? (token0, token1) : (token1, token0);

        return address(
            uint160(
                uint256(
                    keccak256(
                        abi.encodePacked(hex"ff", factory, keccak256(abi.encodePacked(token0, token1)), initCodeHash)
                    )
                )
            )
        );
    }

    /// @notice Get the address of a Camelot V3 (Algebra 1.9) Pool address
    /// @param deployer The address of the deployer
    /// @param initCodeHash The init code hash of the Camelot V3 pool
    /// @param token0 The address of token0
    /// @param token1 The address of token1
    /// @dev for Algebra 1.9, the fee tier and tickSpacing is constant
    function computeAlgebraV3Address(address deployer, bytes32 initCodeHash, address token0, address token1)
        internal
        pure
        returns (address)
    {
        (token0, token1) = token0 < token1 ? (token0, token1) : (token1, token0);
        // this is not the same as the Uniswap V3 pool address
        // algebra 1.9 is using abi.encode rather than abi.encodePacked
        return address(
            uint160(
                uint256(
                    keccak256(abi.encodePacked(hex"ff", deployer, keccak256(abi.encode(token0, token1)), initCodeHash))
                )
            )
        );
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.4) (token/ERC20/extensions/ERC20Permit.sol)

pragma solidity ^0.8.0;

import "./IERC20PermitUpgradeable.sol";
import "../ERC20Upgradeable.sol";
import "../../../utils/cryptography/ECDSAUpgradeable.sol";
import "../../../utils/cryptography/EIP712Upgradeable.sol";
import "../../../utils/CountersUpgradeable.sol";
import {Initializable} from "../../../proxy/utils/Initializable.sol";

/**
 * @dev Implementation of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in
 * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].
 *
 * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by
 * presenting a message signed by the account. By not relying on `{IERC20-approve}`, the token holder account doesn't
 * need to send a transaction, and thus is not required to hold Ether at all.
 *
 * _Available since v3.4._
 *
 * @custom:storage-size 51
 */
abstract contract ERC20PermitUpgradeable is Initializable, ERC20Upgradeable, IERC20PermitUpgradeable, EIP712Upgradeable {
    using CountersUpgradeable for CountersUpgradeable.Counter;

    mapping(address => CountersUpgradeable.Counter) private _nonces;

    // solhint-disable-next-line var-name-mixedcase
    bytes32 private constant _PERMIT_TYPEHASH =
        keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
    /**
     * @dev In previous versions `_PERMIT_TYPEHASH` was declared as `immutable`.
     * However, to ensure consistency with the upgradeable transpiler, we will continue
     * to reserve a slot.
     * @custom:oz-renamed-from _PERMIT_TYPEHASH
     */
    // solhint-disable-next-line var-name-mixedcase
    bytes32 private _PERMIT_TYPEHASH_DEPRECATED_SLOT;

    /**
     * @dev Initializes the {EIP712} domain separator using the `name` parameter, and setting `version` to `"1"`.
     *
     * It's a good idea to use the same `name` that is defined as the ERC20 token name.
     */
    function __ERC20Permit_init(string memory name) internal onlyInitializing {
        __EIP712_init_unchained(name, "1");
    }

    function __ERC20Permit_init_unchained(string memory) internal onlyInitializing {}

    /**
     * @inheritdoc IERC20PermitUpgradeable
     */
    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) public virtual override {
        require(block.timestamp <= deadline, "ERC20Permit: expired deadline");

        bytes32 structHash = keccak256(abi.encode(_PERMIT_TYPEHASH, owner, spender, value, _useNonce(owner), deadline));

        bytes32 hash = _hashTypedDataV4(structHash);

        address signer = ECDSAUpgradeable.recover(hash, v, r, s);
        require(signer == owner, "ERC20Permit: invalid signature");

        _approve(owner, spender, value);
    }

    /**
     * @inheritdoc IERC20PermitUpgradeable
     */
    function nonces(address owner) public view virtual override returns (uint256) {
        return _nonces[owner].current();
    }

    /**
     * @inheritdoc IERC20PermitUpgradeable
     */
    // solhint-disable-next-line func-name-mixedcase
    function DOMAIN_SEPARATOR() external view override returns (bytes32) {
        return _domainSeparatorV4();
    }

    /**
     * @dev "Consume a nonce": return the current value and increment.
     *
     * _Available since v4.1._
     */
    function _useNonce(address owner) internal virtual returns (uint256 current) {
        CountersUpgradeable.Counter storage nonce = _nonces[owner];
        current = nonce.current();
        nonce.increment();
    }

    /**
     * @dev This empty reserved space is put in place to allow future versions to add new
     * variables without shifting down storage in the inheritance chain.
     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
     */
    uint256[49] private __gap;
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (access/Ownable.sol)

pragma solidity ^0.8.0;

import "../utils/ContextUpgradeable.sol";
import {Initializable} from "../proxy/utils/Initializable.sol";

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

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

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    function __Ownable_init() internal onlyInitializing {
        __Ownable_init_unchained();
    }

    function __Ownable_init_unchained() internal onlyInitializing {
        _transferOwnership(_msgSender());
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        _checkOwner();
        _;
    }

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

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view virtual {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
    }

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

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

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

    /**
     * @dev This empty reserved space is put in place to allow future versions to add new
     * variables without shifting down storage in the inheritance chain.
     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
     */
    uint256[49] private __gap;
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20Upgradeable {
    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);

    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the amount of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves `amount` tokens from the caller's account to `to`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address to, uint256 amount) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 amount) external returns (bool);

    /**
     * @dev Moves `amount` tokens from `from` to `to` using the
     * allowance mechanism. `amount` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address from, address to, uint256 amount) external returns (bool);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol)

pragma solidity ^0.8.0;

import "../IERC20Upgradeable.sol";

/**
 * @dev Interface for the optional metadata functions from the ERC20 standard.
 *
 * _Available since v4.1._
 */
interface IERC20MetadataUpgradeable is IERC20Upgradeable {
    /**
     * @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 v4.9.4) (utils/Context.sol)

pragma solidity ^0.8.0;
import {Initializable} from "../proxy/utils/Initializable.sol";

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

    function __Context_init_unchained() internal onlyInitializing {
    }
    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;
    }

    /**
     * @dev This empty reserved space is put in place to allow future versions to add new
     * variables without shifting down storage in the inheritance chain.
     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
     */
    uint256[50] private __gap;
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/Address.sol)

pragma solidity ^0.8.1;

/**
 * @dev Collection of functions related to the address type
 */
library AddressUpgradeable {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     *
     * Furthermore, `isContract` will also return true if the target contract within
     * the same transaction is already scheduled for destruction by `SELFDESTRUCT`,
     * which only has an effect at the end of a transaction.
     * ====
     *
     * [IMPORTANT]
     * ====
     * You shouldn't rely on `isContract` to protect against flash loan attacks!
     *
     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
     * constructor.
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize/address.code.length, which returns 0
        // for contracts in construction, since the code is only stored at the end
        // of the constructor execution.

        return account.code.length > 0;
    }

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.8.0/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "Address: insufficient balance");

        (bool success, ) = recipient.call{value: amount}("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }

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

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

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

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

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

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

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

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

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

    /**
     * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason or using the provided one.
     *
     * _Available since v4.3._
     */
    function verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal pure returns (bytes memory) {
        if (success) {
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    function _revert(bytes memory returndata, string memory errorMessage) private pure {
        // Look for revert reason and bubble it up if present
        if (returndata.length > 0) {
            // The easiest way to bubble the revert reason is using memory via assembly
            /// @solidity memory-safe-assembly
            assembly {
                let returndata_size := mload(returndata)
                revert(add(32, returndata), returndata_size)
            }
        } else {
            revert(errorMessage);
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.4) (token/ERC20/extensions/IERC20Permit.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in
 * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].
 *
 * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by
 * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't
 * need to send a transaction, and thus is not required to hold Ether at all.
 *
 * ==== 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 IERC20PermitUpgradeable {
    /**
     * @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);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/cryptography/ECDSA.sol)

pragma solidity ^0.8.0;

import "../StringsUpgradeable.sol";

/**
 * @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations.
 *
 * These functions can be used to verify that a message was signed by the holder
 * of the private keys of a given address.
 */
library ECDSAUpgradeable {
    enum RecoverError {
        NoError,
        InvalidSignature,
        InvalidSignatureLength,
        InvalidSignatureS,
        InvalidSignatureV // Deprecated in v4.8
    }

    function _throwError(RecoverError error) private pure {
        if (error == RecoverError.NoError) {
            return; // no error: do nothing
        } else if (error == RecoverError.InvalidSignature) {
            revert("ECDSA: invalid signature");
        } else if (error == RecoverError.InvalidSignatureLength) {
            revert("ECDSA: invalid signature length");
        } else if (error == RecoverError.InvalidSignatureS) {
            revert("ECDSA: invalid signature 's' value");
        }
    }

    /**
     * @dev Returns the address that signed a hashed message (`hash`) with
     * `signature` or error string. This address can then be used for verification purposes.
     *
     * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:
     * this function rejects them by requiring the `s` value to be in the lower
     * half order, and the `v` value to be either 27 or 28.
     *
     * IMPORTANT: `hash` _must_ be the result of a hash operation for the
     * verification to be secure: it is possible to craft signatures that
     * recover to arbitrary addresses for non-hashed data. A safe way to ensure
     * this is by receiving a hash of the original message (which may otherwise
     * be too long), and then calling {toEthSignedMessageHash} on it.
     *
     * Documentation for signature generation:
     * - with https://web3js.readthedocs.io/en/v1.3.4/web3-eth-accounts.html#sign[Web3.js]
     * - with https://docs.ethers.io/v5/api/signer/#Signer-signMessage[ethers]
     *
     * _Available since v4.3._
     */
    function tryRecover(bytes32 hash, bytes memory signature) internal pure returns (address, RecoverError) {
        if (signature.length == 65) {
            bytes32 r;
            bytes32 s;
            uint8 v;
            // ecrecover takes the signature parameters, and the only way to get them
            // currently is to use assembly.
            /// @solidity memory-safe-assembly
            assembly {
                r := mload(add(signature, 0x20))
                s := mload(add(signature, 0x40))
                v := byte(0, mload(add(signature, 0x60)))
            }
            return tryRecover(hash, v, r, s);
        } else {
            return (address(0), RecoverError.InvalidSignatureLength);
        }
    }

    /**
     * @dev Returns the address that signed a hashed message (`hash`) with
     * `signature`. This address can then be used for verification purposes.
     *
     * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:
     * this function rejects them by requiring the `s` value to be in the lower
     * half order, and the `v` value to be either 27 or 28.
     *
     * IMPORTANT: `hash` _must_ be the result of a hash operation for the
     * verification to be secure: it is possible to craft signatures that
     * recover to arbitrary addresses for non-hashed data. A safe way to ensure
     * this is by receiving a hash of the original message (which may otherwise
     * be too long), and then calling {toEthSignedMessageHash} on it.
     */
    function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, signature);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Overload of {ECDSA-tryRecover} that receives the `r` and `vs` short-signature fields separately.
     *
     * See https://eips.ethereum.org/EIPS/eip-2098[EIP-2098 short signatures]
     *
     * _Available since v4.3._
     */
    function tryRecover(bytes32 hash, bytes32 r, bytes32 vs) internal pure returns (address, RecoverError) {
        bytes32 s = vs & bytes32(0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
        uint8 v = uint8((uint256(vs) >> 255) + 27);
        return tryRecover(hash, v, r, s);
    }

    /**
     * @dev Overload of {ECDSA-recover} that receives the `r and `vs` short-signature fields separately.
     *
     * _Available since v4.2._
     */
    function recover(bytes32 hash, bytes32 r, bytes32 vs) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, r, vs);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Overload of {ECDSA-tryRecover} that receives the `v`,
     * `r` and `s` signature fields separately.
     *
     * _Available since v4.3._
     */
    function tryRecover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal pure returns (address, RecoverError) {
        // EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature
        // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines
        // the valid range for s in (301): 0 < s < secp256k1n ÷ 2 + 1, and for v in (302): v ∈ {27, 28}. Most
        // signatures from current libraries generate a unique signature with an s-value in the lower half order.
        //
        // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value
        // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or
        // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept
        // these malleable signatures as well.
        if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {
            return (address(0), RecoverError.InvalidSignatureS);
        }

        // If the signature is valid (and not malleable), return the signer address
        address signer = ecrecover(hash, v, r, s);
        if (signer == address(0)) {
            return (address(0), RecoverError.InvalidSignature);
        }

        return (signer, RecoverError.NoError);
    }

    /**
     * @dev Overload of {ECDSA-recover} that receives the `v`,
     * `r` and `s` signature fields separately.
     */
    function recover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, v, r, s);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Returns an Ethereum Signed Message, created from a `hash`. This
     * produces hash corresponding to the one signed with the
     * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]
     * JSON-RPC method as part of EIP-191.
     *
     * See {recover}.
     */
    function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32 message) {
        // 32 is the length in bytes of hash,
        // enforced by the type signature above
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x00, "\x19Ethereum Signed Message:\n32")
            mstore(0x1c, hash)
            message := keccak256(0x00, 0x3c)
        }
    }

    /**
     * @dev Returns an Ethereum Signed Message, created from `s`. This
     * produces hash corresponding to the one signed with the
     * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]
     * JSON-RPC method as part of EIP-191.
     *
     * See {recover}.
     */
    function toEthSignedMessageHash(bytes memory s) internal pure returns (bytes32) {
        return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n", StringsUpgradeable.toString(s.length), s));
    }

    /**
     * @dev Returns an Ethereum Signed Typed Data, created from a
     * `domainSeparator` and a `structHash`. This produces hash corresponding
     * to the one signed with the
     * https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`]
     * JSON-RPC method as part of EIP-712.
     *
     * See {recover}.
     */
    function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32 data) {
        /// @solidity memory-safe-assembly
        assembly {
            let ptr := mload(0x40)
            mstore(ptr, "\x19\x01")
            mstore(add(ptr, 0x02), domainSeparator)
            mstore(add(ptr, 0x22), structHash)
            data := keccak256(ptr, 0x42)
        }
    }

    /**
     * @dev Returns an Ethereum Signed Data with intended validator, created from a
     * `validator` and `data` according to the version 0 of EIP-191.
     *
     * See {recover}.
     */
    function toDataWithIntendedValidatorHash(address validator, bytes memory data) internal pure returns (bytes32) {
        return keccak256(abi.encodePacked("\x19\x00", validator, data));
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/cryptography/EIP712.sol)

pragma solidity ^0.8.8;

import "./ECDSAUpgradeable.sol";
import "../../interfaces/IERC5267Upgradeable.sol";
import {Initializable} from "../../proxy/utils/Initializable.sol";

/**
 * @dev https://eips.ethereum.org/EIPS/eip-712[EIP 712] is a standard for hashing and signing of typed structured data.
 *
 * The encoding specified in the EIP is very generic, and such a generic implementation in Solidity is not feasible,
 * thus this contract does not implement the encoding itself. Protocols need to implement the type-specific encoding
 * they need in their contracts using a combination of `abi.encode` and `keccak256`.
 *
 * This contract implements the EIP 712 domain separator ({_domainSeparatorV4}) that is used as part of the encoding
 * scheme, and the final step of the encoding to obtain the message digest that is then signed via ECDSA
 * ({_hashTypedDataV4}).
 *
 * The implementation of the domain separator was designed to be as efficient as possible while still properly updating
 * the chain id to protect against replay attacks on an eventual fork of the chain.
 *
 * NOTE: This contract implements the version of the encoding known as "v4", as implemented by the JSON RPC method
 * https://docs.metamask.io/guide/signing-data.html[`eth_signTypedDataV4` in MetaMask].
 *
 * NOTE: In the upgradeable version of this contract, the cached values will correspond to the address, and the domain
 * separator of the implementation contract. This will cause the `_domainSeparatorV4` function to always rebuild the
 * separator from the immutable values, which is cheaper than accessing a cached version in cold storage.
 *
 * _Available since v3.4._
 *
 * @custom:storage-size 52
 */
abstract contract EIP712Upgradeable is Initializable, IERC5267Upgradeable {
    bytes32 private constant _TYPE_HASH =
        keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)");

    /// @custom:oz-renamed-from _HASHED_NAME
    bytes32 private _hashedName;
    /// @custom:oz-renamed-from _HASHED_VERSION
    bytes32 private _hashedVersion;

    string private _name;
    string private _version;

    /**
     * @dev Initializes the domain separator and parameter caches.
     *
     * The meaning of `name` and `version` is specified in
     * https://eips.ethereum.org/EIPS/eip-712#definition-of-domainseparator[EIP 712]:
     *
     * - `name`: the user readable name of the signing domain, i.e. the name of the DApp or the protocol.
     * - `version`: the current major version of the signing domain.
     *
     * NOTE: These parameters cannot be changed except through a xref:learn::upgrading-smart-contracts.adoc[smart
     * contract upgrade].
     */
    function __EIP712_init(string memory name, string memory version) internal onlyInitializing {
        __EIP712_init_unchained(name, version);
    }

    function __EIP712_init_unchained(string memory name, string memory version) internal onlyInitializing {
        _name = name;
        _version = version;

        // Reset prior values in storage if upgrading
        _hashedName = 0;
        _hashedVersion = 0;
    }

    /**
     * @dev Returns the domain separator for the current chain.
     */
    function _domainSeparatorV4() internal view returns (bytes32) {
        return _buildDomainSeparator();
    }

    function _buildDomainSeparator() private view returns (bytes32) {
        return keccak256(abi.encode(_TYPE_HASH, _EIP712NameHash(), _EIP712VersionHash(), block.chainid, address(this)));
    }

    /**
     * @dev Given an already https://eips.ethereum.org/EIPS/eip-712#definition-of-hashstruct[hashed struct], this
     * function returns the hash of the fully encoded EIP712 message for this domain.
     *
     * This hash can be used together with {ECDSA-recover} to obtain the signer of a message. For example:
     *
     * ```solidity
     * bytes32 digest = _hashTypedDataV4(keccak256(abi.encode(
     *     keccak256("Mail(address to,string contents)"),
     *     mailTo,
     *     keccak256(bytes(mailContents))
     * )));
     * address signer = ECDSA.recover(digest, signature);
     * ```
     */
    function _hashTypedDataV4(bytes32 structHash) internal view virtual returns (bytes32) {
        return ECDSAUpgradeable.toTypedDataHash(_domainSeparatorV4(), structHash);
    }

    /**
     * @dev See {EIP-5267}.
     *
     * _Available since v4.9._
     */
    function eip712Domain()
        public
        view
        virtual
        override
        returns (
            bytes1 fields,
            string memory name,
            string memory version,
            uint256 chainId,
            address verifyingContract,
            bytes32 salt,
            uint256[] memory extensions
        )
    {
        // If the hashed name and version in storage are non-zero, the contract hasn't been properly initialized
        // and the EIP712 domain is not reliable, as it will be missing name and version.
        require(_hashedName == 0 && _hashedVersion == 0, "EIP712: Uninitialized");

        return (
            hex"0f", // 01111
            _EIP712Name(),
            _EIP712Version(),
            block.chainid,
            address(this),
            bytes32(0),
            new uint256[](0)
        );
    }

    /**
     * @dev The name parameter for the EIP712 domain.
     *
     * NOTE: This function reads from storage by default, but can be redefined to return a constant value if gas costs
     * are a concern.
     */
    function _EIP712Name() internal virtual view returns (string memory) {
        return _name;
    }

    /**
     * @dev The version parameter for the EIP712 domain.
     *
     * NOTE: This function reads from storage by default, but can be redefined to return a constant value if gas costs
     * are a concern.
     */
    function _EIP712Version() internal virtual view returns (string memory) {
        return _version;
    }

    /**
     * @dev The hash of the name parameter for the EIP712 domain.
     *
     * NOTE: In previous versions this function was virtual. In this version you should override `_EIP712Name` instead.
     */
    function _EIP712NameHash() internal view returns (bytes32) {
        string memory name = _EIP712Name();
        if (bytes(name).length > 0) {
            return keccak256(bytes(name));
        } else {
            // If the name is empty, the contract may have been upgraded without initializing the new storage.
            // We return the name hash in storage if non-zero, otherwise we assume the name is empty by design.
            bytes32 hashedName = _hashedName;
            if (hashedName != 0) {
                return hashedName;
            } else {
                return keccak256("");
            }
        }
    }

    /**
     * @dev The hash of the version parameter for the EIP712 domain.
     *
     * NOTE: In previous versions this function was virtual. In this version you should override `_EIP712Version` instead.
     */
    function _EIP712VersionHash() internal view returns (bytes32) {
        string memory version = _EIP712Version();
        if (bytes(version).length > 0) {
            return keccak256(bytes(version));
        } else {
            // If the version is empty, the contract may have been upgraded without initializing the new storage.
            // We return the version hash in storage if non-zero, otherwise we assume the version is empty by design.
            bytes32 hashedVersion = _hashedVersion;
            if (hashedVersion != 0) {
                return hashedVersion;
            } else {
                return keccak256("");
            }
        }
    }

    /**
     * @dev This empty reserved space is put in place to allow future versions to add new
     * variables without shifting down storage in the inheritance chain.
     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
     */
    uint256[48] private __gap;
}

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

pragma solidity ^0.8.0;

/**
 * @title Counters
 * @author Matt Condon (@shrugs)
 * @dev Provides counters that can only be incremented, decremented or reset. This can be used e.g. to track the number
 * of elements in a mapping, issuing ERC721 ids, or counting request ids.
 *
 * Include with `using Counters for Counters.Counter;`
 */
library CountersUpgradeable {
    struct Counter {
        // This variable should never be directly accessed by users of the library: interactions must be restricted to
        // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add
        // this feature: see https://github.com/ethereum/solidity/issues/4637
        uint256 _value; // default: 0
    }

    function current(Counter storage counter) internal view returns (uint256) {
        return counter._value;
    }

    function increment(Counter storage counter) internal {
        unchecked {
            counter._value += 1;
        }
    }

    function decrement(Counter storage counter) internal {
        uint256 value = counter._value;
        require(value > 0, "Counter: decrement overflow");
        unchecked {
            counter._value = value - 1;
        }
    }

    function reset(Counter storage counter) internal {
        counter._value = 0;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/Strings.sol)

pragma solidity ^0.8.0;

import "./math/MathUpgradeable.sol";
import "./math/SignedMathUpgradeable.sol";

/**
 * @dev String operations.
 */
library StringsUpgradeable {
    bytes16 private constant _SYMBOLS = "0123456789abcdef";
    uint8 private constant _ADDRESS_LENGTH = 20;

    /**
     * @dev Converts a `uint256` to its ASCII `string` decimal representation.
     */
    function toString(uint256 value) internal pure returns (string memory) {
        unchecked {
            uint256 length = MathUpgradeable.log10(value) + 1;
            string memory buffer = new string(length);
            uint256 ptr;
            /// @solidity memory-safe-assembly
            assembly {
                ptr := add(buffer, add(32, length))
            }
            while (true) {
                ptr--;
                /// @solidity memory-safe-assembly
                assembly {
                    mstore8(ptr, byte(mod(value, 10), _SYMBOLS))
                }
                value /= 10;
                if (value == 0) break;
            }
            return buffer;
        }
    }

    /**
     * @dev Converts a `int256` to its ASCII `string` decimal representation.
     */
    function toString(int256 value) internal pure returns (string memory) {
        return string(abi.encodePacked(value < 0 ? "-" : "", toString(SignedMathUpgradeable.abs(value))));
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
     */
    function toHexString(uint256 value) internal pure returns (string memory) {
        unchecked {
            return toHexString(value, MathUpgradeable.log256(value) + 1);
        }
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
     */
    function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
        bytes memory buffer = new bytes(2 * length + 2);
        buffer[0] = "0";
        buffer[1] = "x";
        for (uint256 i = 2 * length + 1; i > 1; --i) {
            buffer[i] = _SYMBOLS[value & 0xf];
            value >>= 4;
        }
        require(value == 0, "Strings: hex length insufficient");
        return string(buffer);
    }

    /**
     * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation.
     */
    function toHexString(address addr) internal pure returns (string memory) {
        return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);
    }

    /**
     * @dev Returns true if the two strings are equal.
     */
    function equal(string memory a, string memory b) internal pure returns (bool) {
        return keccak256(bytes(a)) == keccak256(bytes(b));
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (interfaces/IERC5267.sol)

pragma solidity ^0.8.0;

interface IERC5267Upgradeable {
    /**
     * @dev MAY be emitted to signal that the domain could have changed.
     */
    event EIP712DomainChanged();

    /**
     * @dev returns the fields and values that describe the domain separator used by this contract for EIP-712
     * signature.
     */
    function eip712Domain()
        external
        view
        returns (
            bytes1 fields,
            string memory name,
            string memory version,
            uint256 chainId,
            address verifyingContract,
            bytes32 salt,
            uint256[] memory extensions
        );
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/math/Math.sol)

pragma solidity ^0.8.0;

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

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

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

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

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

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

            // Handle non-overflow cases, 256 by 256 division.
            if (prod1 == 0) {
                // 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^256. Also prevents denominator == 0.
            require(denominator > prod1, "Math: mulDiv 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.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    /**
     * @dev Return the log in base 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 + (rounding == Rounding.Up && 1 << (result << 3) < value ? 1 : 0);
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (utils/math/SignedMath.sol)

pragma solidity ^0.8.0;

/**
 * @dev Standard signed math utilities missing in the Solidity language.
 */
library SignedMathUpgradeable {
    /**
     * @dev Returns the largest of two signed numbers.
     */
    function max(int256 a, int256 b) internal pure returns (int256) {
        return a > b ? a : b;
    }

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

    /**
     * @dev Returns the average of two signed numbers without overflow.
     * The result is rounded towards zero.
     */
    function average(int256 a, int256 b) internal pure returns (int256) {
        // Formula from the book "Hacker's Delight"
        int256 x = (a & b) + ((a ^ b) >> 1);
        return x + (int256(uint256(x) >> 255) & (a ^ b));
    }

    /**
     * @dev Returns the absolute unsigned value of a signed value.
     */
    function abs(int256 n) internal pure returns (uint256) {
        unchecked {
            // must be unchecked in order to support `n = type(int256).min`
            return uint256(n >= 0 ? n : -n);
        }
    }
}

{
  "remappings": [
    "ds-test/=lib/openzeppelin-contracts/lib/forge-std/lib/ds-test/src/",
    "erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/",
    "forge-std/=lib/forge-std/src/",
    "@openzeppelin/=lib/openzeppelin-contracts/contracts/",
    "@openzeppelin-contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/contracts/",
    "@ozv5/=lib/ozv5/contracts/",
    "solady/=lib/solady/src/",
    "uni-v3-core/=lib/v3-core/contracts/",
    "uni-v4-core/=lib/v4-core/src/",
    "uni-v4-periphery/=lib/v4-periphery/contracts/",
    "uni-v2-core/=lib/v2-core/contracts/",
    "uni-v2-periphery/=lib/v2-periphery/contracts/",
    "pancake-v3-core/=lib/pancake-v3-contracts/projects/v3-core/contracts/",
    "izi-periphery/=lib/iZiSwap-periphery/contracts/",
    "@ensdomains/=lib/v4-core/node_modules/@ensdomains/",
    "@uniswap/v4-core/=lib/v4-periphery/lib/v4-core/",
    "forge-gas-snapshot/=lib/v4-periphery/lib/forge-gas-snapshot/src/",
    "halmos-cheatcodes/=lib/ozv5/lib/halmos-cheatcodes/src/",
    "hardhat/=lib/v4-core/node_modules/hardhat/",
    "iZiSwap-periphery/=lib/iZiSwap-periphery/contracts/",
    "openzeppelin-contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/",
    "openzeppelin-contracts/=lib/openzeppelin-contracts/",
    "openzeppelin/=lib/openzeppelin-contracts-upgradeable/contracts/",
    "ozv5/=lib/ozv5/",
    "pancake-v3-contracts/=lib/pancake-v3-contracts/",
    "solmate/=lib/v4-periphery/lib/solmate/src/",
    "v2-core/=lib/v2-core/contracts/",
    "v2-periphery/=lib/v2-periphery/contracts/",
    "v3-core/=lib/v3-core/",
    "v4-core/=lib/v4-core/src/",
    "v4-periphery/=lib/v4-periphery/contracts/"
  ],
  "optimizer": {
    "enabled": true,
    "runs": 99999
  },
  "metadata": {
    "useLiteralContent": false,
    "bytecodeHash": "ipfs",
    "appendCBOR": true
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "abi"
      ]
    }
  },
  "evmVersion": "cancun",
  "viaIR": false
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"components":[{"internalType":"address","name":"PCS_V2_FACTORY","type":"address"},{"internalType":"bytes32","name":"PCS_V2_CODE_HASH","type":"bytes32"},{"internalType":"address","name":"PCS_V2_ROUTER","type":"address"},{"internalType":"address","name":"PCS_SMART_ROUTER","type":"address"},{"internalType":"address","name":"WETH","type":"address"},{"internalType":"address","name":"PCS_V3_FACTORY","type":"address"},{"internalType":"bytes32","name":"PCS_V3_CODE_HASH","type":"bytes32"},{"internalType":"address","name":"UNI_V2_FACTORY","type":"address"},{"internalType":"bytes32","name":"UNI_V2_CODE_HASH","type":"bytes32"},{"internalType":"address","name":"UNI_V3_FACTORY","type":"address"},{"internalType":"bytes32","name":"UNI_V3_CODE_HASH","type":"bytes32"},{"internalType":"address","name":"PCS_V4_VAULT","type":"address"},{"internalType":"address","name":"UNI_V4_POOL","type":"address"},{"internalType":"uint256","name":"MIN_LIQ_THRESHOLD","type":"uint256"},{"internalType":"uint256","name":"START_LIQ_THRESHOLD","type":"uint256"},{"internalType":"uint256","name":"ANTI_FARMER_DURATION","type":"uint256"}],"internalType":"struct FlapTaxToken.ConstructorParams","name":"params","type":"tuple"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[],"name":"EIP712DomainChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"quoteToken","type":"address"},{"indexed":false,"internalType":"uint256","name":"taxAmount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"outputAmount","type":"uint256"}],"name":"FlapTaxLiquidationSuccess","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint8","name":"version","type":"uint8"}],"name":"Initialized","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint8","name":"fromState","type":"uint8"},{"indexed":false,"internalType":"uint8","name":"toState","type":"uint8"}],"name":"PoolStateChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"bytes","name":"reason","type":"bytes"}],"name":"TaxLiquidationError","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"from","type":"address"},{"indexed":false,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"TransferFlapToken","type":"event"},{"inputs":[],"name":"ANTI_FARMER_DURATION","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"DOMAIN_SEPARATOR","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MIN_LIQ_THRESHOLD","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"QUOTE_TOKEN","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"START_LIQ_THRESHOLD","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"TAX_DURATION","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"antiFarmerExpirationTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"subtractedValue","type":"uint256"}],"name":"decreaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"eip712Domain","outputs":[{"internalType":"bytes1","name":"fields","type":"bytes1"},{"internalType":"string","name":"name","type":"string"},{"internalType":"string","name":"version","type":"string"},{"internalType":"uint256","name":"chainId","type":"uint256"},{"internalType":"address","name":"verifyingContract","type":"address"},{"internalType":"bytes32","name":"salt","type":"bytes32"},{"internalType":"uint256[]","name":"extensions","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"finalizeMigration","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"addedValue","type":"uint256"}],"name":"increaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"string","name":"name","type":"string"},{"internalType":"string","name":"symbol","type":"string"},{"internalType":"string","name":"meta","type":"string"},{"internalType":"uint16","name":"tax","type":"uint16"},{"internalType":"address","name":"taxSplitter","type":"address"},{"internalType":"address","name":"quoteToken","type":"address"},{"internalType":"uint256","name":"liqExpectedOutputAmount","type":"uint256"},{"internalType":"uint256","name":"taxDuration","type":"uint256"}],"internalType":"struct IFlapTaxToken.InitParams","name":"params","type":"tuple"}],"name":"initialize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"liqExpectedOutputAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"liquidationThreshold","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"mainPool","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"mainPoolRouter","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"metaURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"nonces","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"uint256","name":"deadline","type":"uint256"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"permit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"pools","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newMainPool","type":"address"},{"internalType":"address","name":"router","type":"address"}],"name":"setMainPool","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"startMigration","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"state","outputs":[{"internalType":"enum FlapTaxToken.PoolState","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"taxExpirationTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"taxRate","outputs":[{"internalType":"uint16","name":"","type":"uint16"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"taxSplitter","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

000000000000000000000000182a927119d56008d921126764bf884221b10f5996e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f0000000000000000000000004b2ab38dbf28d31d467aa8993f6c2585981d680400000000000000000000000000000000000000000000000000000000000000000000000000000000000000003bd359c1119da7da1d913d1c4d2b7c461115433a000000000000000000000000204faca1764b154221e35c0d20abb3c525710498e34f199b19b2b4f47f68442619d555527d244f78a3297ea89325f843f87b8b5400000000000000000000000002a84c1b3bbd7401a5f7fa98a384ebc70bb5749e57224589c67f3f30a6b0d7a1b54cf3153ab84563bc609ef41dfb34f8b2974d2d00000000000000000000000041ff9aa7e16b8b1a8a8dc4f0efacd93d02d071c96ce8eb472fa82df5469c6ab6d485f17c3ad13c8cd7af59b3d4a8026c5ce0f7e2000000000000000000000000238a358808379702088667322f80ac48bad5e6c4000000000000000000000000188d586ddcf52439676ca21a244753fa19f9ea8e000000000000000000000000000000000000000000000a968163f0a57b4000000000000000000000000000000000000000000000000054b40b1f852bda0000000000000000000000000000000000000000000000000000000000000000015180

-----Decoded View---------------
Arg [0] : params (tuple): 
     Arg [1] : PCS_V2_FACTORY (address): 0x182a927119D56008d921126764bF884221b10f59
     Arg [2] : PCS_V2_CODE_HASH (bytes32): 0x96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f
     Arg [3] : PCS_V2_ROUTER (address): 0x4B2ab38DBF28D31D467aA8993f6c2585981D6804
     Arg [4] : PCS_SMART_ROUTER (address): 0x0000000000000000000000000000000000000000
     Arg [5] : WETH (address): 0x3bd359C1119dA7Da1D913D1C4D2B7c461115433A
     Arg [6] : PCS_V3_FACTORY (address): 0x204FAca1764B154221e35c0d20aBb3c525710498
     Arg [7] : PCS_V3_CODE_HASH (bytes32): 0xe34f199b19b2b4f47f68442619d555527d244f78a3297ea89325f843f87b8b54
     Arg [8] : UNI_V2_FACTORY (address): 0x02a84c1b3BBD7401a5f7fa98a384EBC70bB5749E
     Arg [9] : UNI_V2_CODE_HASH (bytes32): 0x57224589c67f3f30a6b0d7a1b54cf3153ab84563bc609ef41dfb34f8b2974d2d
     Arg [10] : UNI_V3_FACTORY (address): 0x41ff9AA7e16B8B1a8a8dc4f0eFacd93D02d071c9
     Arg [11] : UNI_V3_CODE_HASH (bytes32): 0x6ce8eb472fa82df5469c6ab6d485f17c3ad13c8cd7af59b3d4a8026c5ce0f7e2
     Arg [12] : PCS_V4_VAULT (address): 0x238a358808379702088667322f80aC48bAd5e6c4
     Arg [13] : UNI_V4_POOL (address): 0x188d586Ddcf52439676Ca21A244753fA19F9Ea8e
     Arg [14] : MIN_LIQ_THRESHOLD (uint256): 50000000000000000000000
     Arg [15] : START_LIQ_THRESHOLD (uint256): 400000000000000000000000
     Arg [16] : ANTI_FARMER_DURATION (uint256): 86400


-----Encoded View---------------
16 Constructor Arguments found :
Arg [0] : 000000000000000000000000182a927119d56008d921126764bf884221b10f59
Arg [1] : 96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f
Arg [2] : 0000000000000000000000004b2ab38dbf28d31d467aa8993f6c2585981d6804
Arg [3] : 0000000000000000000000000000000000000000000000000000000000000000
Arg [4] : 0000000000000000000000003bd359c1119da7da1d913d1c4d2b7c461115433a
Arg [5] : 000000000000000000000000204faca1764b154221e35c0d20abb3c525710498
Arg [6] : e34f199b19b2b4f47f68442619d555527d244f78a3297ea89325f843f87b8b54
Arg [7] : 00000000000000000000000002a84c1b3bbd7401a5f7fa98a384ebc70bb5749e
Arg [8] : 57224589c67f3f30a6b0d7a1b54cf3153ab84563bc609ef41dfb34f8b2974d2d
Arg [9] : 00000000000000000000000041ff9aa7e16b8b1a8a8dc4f0efacd93d02d071c9
Arg [10] : 6ce8eb472fa82df5469c6ab6d485f17c3ad13c8cd7af59b3d4a8026c5ce0f7e2
Arg [11] : 000000000000000000000000238a358808379702088667322f80ac48bad5e6c4
Arg [12] : 000000000000000000000000188d586ddcf52439676ca21a244753fa19f9ea8e
Arg [13] : 000000000000000000000000000000000000000000000a968163f0a57b400000
Arg [14] : 0000000000000000000000000000000000000000000054b40b1f852bda000000
Arg [15] : 0000000000000000000000000000000000000000000000000000000000015180

1256:18121:16:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2516:98:3;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;4802:197;;;;;;:::i;:::-;;:::i;:::-;;;1351:14:19;;1344:22;1326:41;;1314:2;1299:18;4802:197:3;1186:187:19;5825:27:16;;;;;;;;;1524:25:19;;;1512:2;1497:18;5825:27:16;1378:177:19;3613:106:3;3700:12;;3613:106;;8080:239:16;;;:::i;:::-;;5620:29;;;;;;;;;;;;1736:42:19;1724:55;;;1706:74;;1694:2;1679:18;5620:29:16;1560:226:19;5561:256:3;;;;;;:::i;:::-;;:::i;4976:38:16:-;;;;;;3462:91:3;;;3544:2;2266:36:19;;2254:2;2239:18;3462:91:3;2124:184:19;3287:113:5;;;:::i;6212:234:3:-;;;;;;:::i;:::-;;:::i;5470:35:16:-;;;;;;5384:26;;;;;;;;;;;;6969:39;;;;;;5205:30;;;:::i;3777:125:3:-;;;;;;:::i;:::-;3877:18;;3851:7;3877:18;;;:9;:18;;;;;;;3777:125;2085:101:0;;;:::i;5300:21:16:-;;;;;;;;;;;;2860:6:19;2848:19;;;2830:38;;2818:2;2803:18;5300:21:16;2686:188:19;4604:26:16;;;;;;;;;3043:126:5;;;;;;:::i;:::-;;:::i;4521:861:13:-;;;:::i;:::-;;;;;;;;;;;;;:::i;1462:85:0:-;1534:6;;;;1462:85;;2727:102:3;;;:::i;4786:44:16:-;;;;;6201:37;;;;;;:::i;:::-;;;;;;;;;;;;;;;;6933:427:3;;;;;;:::i;:::-;;:::i;5554:23:16:-;;;;;;;;;9067:593;;;;;;:::i;:::-;;:::i;4098:189:3:-;;;;;;:::i;:::-;;:::i;9782:2306:16:-;;;;;;:::i;:::-;;:::i;4687:42::-;;;;;8404:391;;;:::i;6871:32::-;;;;;;6795:22;;;;;;;;;;;;;;;;:::i;5084:45::-;;;;;2341:637:5;;;;;;:::i;:::-;;:::i;5703:45:16:-;;5739:9;5703:45;;4345:149:3;;;;;;:::i;:::-;4460:18;;;;4434:7;4460:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;4345:149;2335:198:0;;;;;;:::i;:::-;;:::i;2516:98:3:-;2570:13;2602:5;2595:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2516:98;:::o;4802:197::-;4885:4;965:10:9;4939:32:3;965:10:9;4955:7:3;4964:6;4939:8;:32::i;:::-;4988:4;4981:11;;;4802:197;;;;;:::o;8080:239:16:-;1355:13:0;:11;:13::i;:::-;8157:22:16::1;8148:5;::::0;::::1;;:31;::::0;::::1;;;;;;:::i;:::-;::::0;8144:169:::1;;8195:5;:27:::0;;;::::1;8203:19;8195:27;::::0;;8241:61:::1;-1:-1:-1::0;8258:29:16::1;8295:5;::::0;::::1;;8289:12;::::0;::::1;;;;;;:::i;:::-;8241:61;::::0;;9240:4:19;9228:17;;;9210:36;;9282:17;;;;9277:2;9262:18;;9255:45;9183:18;8241:61:16::1;;;;;;;8144:169;8080:239::o:0;5561:256:3:-;5658:4;965:10:9;5714:38:3;5730:4;965:10:9;5745:6:3;5714:15;:38::i;:::-;5762:27;5772:4;5778:2;5782:6;5762:9;:27::i;:::-;5806:4;5799:11;;;5561:256;;;;;;:::o;3287:113:5:-;3347:7;3373:20;:18;:20::i;:::-;3366:27;;3287:113;:::o;6212:234:3:-;965:10:9;6300:4:3;4460:18;;;:11;:18;;;;;;;;;:27;;;;;;;;;;6300:4;;965:10:9;6354:64:3;;965:10:9;;4460:27:3;;6379:38;;6407:10;;6379:38;:::i;:::-;6354:8;:64::i;5205:30:16:-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;2085:101:0:-;1355:13;:11;:13::i;:::-;2149:30:::1;2176:1;2149:18;:30::i;3043:126:5:-:0;3138:14;;;3112:7;3138:14;;;:7;:14;;;;;929::10;3138:24:5;838:112:10;4521:861:13;4636:13;4663:18;4695:21;4730:15;4759:25;4798:12;4824:27;5087:11;;5102:1;5087:16;;;:39;;;;-1:-1:-1;5107:14:13;;:19;5087:39;5079:73;;;;;;;9832:2:19;5079:73:13;;;9814:21:19;9871:2;9851:18;;;9844:30;9910:23;9890:18;;;9883:51;9951:18;;5079:73:13;;;;;;;;;5214:13;:11;:13::i;:::-;5241:16;:14;:16::i;:::-;5349;;;5333:1;5349:16;;;;;;;;;5163:212;;;;-1:-1:-1;5163:212:13;;-1:-1:-1;5271:13:13;;-1:-1:-1;5306:4:13;;-1:-1:-1;5333:1:13;-1:-1:-1;5349:16:13;-1:-1:-1;5163:212:13;-1:-1:-1;4521:861:13:o;2727:102:3:-;2783:13;2815:7;2808:14;;;;;:::i;6933:427::-;965:10:9;7026:4:3;4460:18;;;:11;:18;;;;;;;;;:27;;;;;;;;;;7026:4;;965:10:9;7170:15:3;7150:16;:35;;7142:85;;;;;;;10182:2:19;7142:85:3;;;10164:21:19;10221:2;10201:18;;;10194:30;10260:34;10240:18;;;10233:62;10331:7;10311:18;;;10304:35;10356:19;;7142:85:3;9980:401:19;7142:85:3;7261:60;7270:5;7277:7;7305:15;7286:16;:34;7261:8;:60::i;:::-;-1:-1:-1;7349:4:3;;6933:427;-1:-1:-1;;;;6933:427:3:o;9067:593:16:-;1355:13:0;:11;:13::i;:::-;9180:22:16::1;9171:5;::::0;::::1;;:31;::::0;::::1;;;;;;:::i;:::-;;9163:88;;;::::0;::::1;::::0;;10588:2:19;9163:88:16::1;::::0;::::1;10570:21:19::0;10627:2;10607:18;;;10600:30;10666:34;10646:18;;;10639:62;10737:14;10717:18;;;10710:42;10769:19;;9163:88:16::1;10386:408:19::0;9163:88:16::1;9269:25;::::0;::::1;9261:58;;;::::0;::::1;::::0;;11001:2:19;9261:58:16::1;::::0;::::1;10983:21:19::0;11040:2;11020:18;;;11013:30;11079:22;11059:18;;;11052:50;11119:18;;9261:58:16::1;10799:344:19::0;9261:58:16::1;9337:20;::::0;::::1;9329:55;;;::::0;::::1;::::0;;11350:2:19;9329:55:16::1;::::0;::::1;11332:21:19::0;11389:2;11369:18;;;11362:30;11428:24;11408:18;;;11401:52;11470:18;;9329:55:16::1;11148:346:19::0;9329:55:16::1;9456:8;::::0;;::::1;::::0;;::::1;9468:5;9450:15:::0;;;:5:::1;:15;::::0;;;;;:23;;;;;::::1;::::0;;;9512:22;;;;::::1;::::0;;;::::1;::::0;::::1;::::0;;;9544:14:::1;:23:::0;;;;;::::1;::::0;;;::::1;::::0;;;::::1;::::0;;;9628:18;;;;:25;;;;::::1;9456:8:::0;9628:25:::1;::::0;;9067:593::o;4098:189:3:-;4177:4;965:10:9;4231:28:3;965:10:9;4248:2:3;4252:6;4231:9;:28::i;9782:2306:16:-;3279:19:2;3302:13;;;;;;3301:14;;3347:34;;;;-1:-1:-1;3365:12:2;;3380:1;3365:12;;;;:16;3347:34;3346:108;;;-1:-1:-1;3426:4:2;1713:19:8;:23;;;3387:66:2;;-1:-1:-1;3436:12:2;;;;;:17;3387:66;3325:201;;;;;;;11701:2:19;3325:201:2;;;11683:21:19;11740:2;11720:18;;;11713:30;11779:34;11759:18;;;11752:62;11850:16;11830:18;;;11823:44;11884:19;;3325:201:2;11499:410:19;3325:201:2;3536:12;:16;;;;3551:1;3536:16;;;3562:65;;;;3596:13;:20;;;;;;;;3562:65;9971:20:16::1;9949:6;:18;;;:42;;9941:99;;;::::0;::::1;::::0;;12116:2:19;9941:99:16::1;::::0;::::1;12098:21:19::0;12155:2;12135:18;;;12128:30;12194:34;12174:18;;;12167:62;12265:14;12245:18;;;12238:42;12297:19;;9941:99:16::1;11914:408:19::0;9941:99:16::1;10051:40;10064:6;:11;;;10077:6;:13;;;10051:12;:40::i;:::-;10120:11:::0;;10101:31:::1;::::0;:18:::1;:31::i;:::-;10142:16;:14;:16::i;:::-;10179:11;::::0;::::1;::::0;10169:7:::1;::::0;:21:::1;::::0;:7;:21:::1;:::i;:::-;-1:-1:-1::0;10210:10:16::1;::::0;::::1;::::0;10200:7:::1;:20:::0;;10244:18:::1;::::0;::::1;::::0;10230:32:::1;;::::0;::::1;::::0;;;;10200:20:::1;::::0;;::::1;10230:32:::0;;;;;;;::::1;::::0;;10295:19:::1;10272:20;:42:::0;10324:14:::1;:21:::0;;;::::1;10200:20:::0;10324:21:::1;::::0;;10370:18:::1;::::0;::::1;::::0;10355:12:::1;:33:::0;10436:28:::1;10442:10;5739:9;10436:5;:28::i;:::-;10516:17;::::0;::::1;::::0;10502:11:::1;:31:::0;;;::::1;;::::0;;::::1;::::0;;::::1;::::0;;10621:30:::1;::::0;::::1;::::0;10595:23:::1;:56:::0;10848:90:::1;::::0;10877:14:::1;::::0;10893:16:::1;::::0;10919:4:::1;::::0;10848:28:::1;:90::i;:::-;10837:8;:101:::0;;;;;::::1;;::::0;;::::1;::::0;;::::1;::::0;;;11005:14:::1;:30:::0;;;;::::1;11022:13;11005:30:::0;::::1;;::::0;;-1:-1:-1;11111:15:16;;;:5:::1;:15;::::0;;;;;;:22;;;::::1;-1:-1:-1::0;11111:22:16;;::::1;::::0;;;11273:11:::1;::::0;-1:-1:-1;;11111:5:16;;-1:-1:-1;11195:90:16::1;::::0;11224:14:::1;::::0;11240:16:::1;::::0;11266:4:::1;::::0;11273:11:::1;11195:28;:90::i;:::-;11189:97;;::::0;;::::1;::::0;;::::1;::::0;;;;;;;;-1:-1:-1;11189:97:16;;;:104;;;::::1;::::0;::::1;;::::0;;;::::1;::::0;;;11325:61;;::::1;::::0;::::1;::::0;;11357:3:::1;11325:61:::0;;11363:3:::1;11325:61:::0;;::::1;::::0;;;;11368:4:::1;11325:61:::0;;;;11374:4:::1;11325:61:::0;;;;11380:5:::1;11325:61:::0;;;;;11417:11:::1;::::0;11481:470:::1;11505:10;11501:1;:14;11481:470;;;11536:10;11549:4;11554:1;11549:7;;;;;;;:::i;:::-;;;;;11536:20;;11746:4;11625:5;:102;11631:95;11660:14;11676:16;11702:4;11709:11;;;;;;;;;;;11722:3;11631:28;:95::i;:::-;11625:102;;;;;;;;;;;;;;;;:125;;;;;;;;;;;;;;;;;;11936:4;11815:5;:102;11821:95;11850:14;11866:16;11892:4;11899:11;;;;;;;;;;;11912:3;11821:28;:95::i;:::-;11815:102;;::::0;;::::1;::::0;::::1;::::0;;;;;;-1:-1:-1;11815:102:16;:125;;;::::1;::::0;::::1;;::::0;;;::::1;::::0;;-1:-1:-1;;11517:3:16::1;11481:470;;;-1:-1:-1::0;;;12020:19:16::1;12026:12;12020:19:::0;::::1;;::::0;;;:5:::1;:19;::::0;;;;;:26;;;;;::::1;12042:4;12020:26:::0;;::::1;::::0;;;12062:11:::1;12056:18:::0;;::::1;::::0;;;;:25;;;;::::1;;::::0;;3647:99:2;;;;3697:5;3681:21;;;;;;3721:14;;-1:-1:-1;2266:36:19;;3721:14:2;;2254:2:19;2239:18;3721:14:2;;;;;;;3647:99;3269:483;9782:2306:16;:::o;8404:391::-;1355:13:0;:11;:13::i;:::-;8484:19:16::1;8475:5;::::0;::::1;;:28;::::0;::::1;;;;;;:::i;:::-;::::0;8471:318:::1;;8519:5;:39:::0;;;::::1;8527:31;8519:39;::::0;;8610:12:::1;::::0;8592:30:::1;::::0;:15:::1;:30;:::i;:::-;8572:17;:50:::0;8663:38:::1;8681:20;8663:15;:38;:::i;:::-;8636:24;:65:::0;8720:58:::1;8743:19;8737:26;::::0;2341:637:5;2576:8;2557:15;:27;;2549:69;;;;;;;15266:2:19;2549:69:5;;;15248:21:19;15305:2;15285:18;;;15278:30;15344:31;15324:18;;;15317:59;15393:18;;2549:69:5;15064:353:19;2549:69:5;2629:18;1372:95;2689:5;2696:7;2705:5;2712:16;2722:5;2712:9;:16::i;:::-;2660:79;;;;;;15709:25:19;;;;15753:42;15831:15;;;15811:18;;;15804:43;15883:15;;;;15863:18;;;15856:43;15915:18;;;15908:34;15958:19;;;15951:35;16002:19;;;15995:35;;;15681:19;;2660:79:5;;;;;;;;;;;;2650:90;;;;;;2629:111;;2751:12;2766:28;2783:10;2766:16;:28::i;:::-;2751:43;;2805:14;2822:39;2847:4;2853:1;2856;2859;2822:24;:39::i;:::-;2805:56;;2889:5;2879:15;;:6;:15;;;2871:58;;;;;;;16243:2:19;2871:58:5;;;16225:21:19;16282:2;16262:18;;;16255:30;16321:32;16301:18;;;16294:60;16371:18;;2871:58:5;16041:354:19;2871:58:5;2940:31;2949:5;2956:7;2965:5;2940:8;:31::i;:::-;2539:439;;;2341:637;;;;;;;:::o;2335:198:0:-;1355:13;:11;:13::i;:::-;2423:22:::1;::::0;::::1;2415:73;;;::::0;::::1;::::0;;16602:2:19;2415:73:0::1;::::0;::::1;16584:21:19::0;16641:2;16621:18;;;16614:30;16680:34;16660:18;;;16653:62;16751:8;16731:18;;;16724:36;16777:19;;2415:73:0::1;16400:402:19::0;2415:73:0::1;2498:28;2517:8;2498:18;:28::i;:::-;2335:198:::0;:::o;10815:340:3:-;10916:19;;;10908:68;;;;;;;17009:2:19;10908:68:3;;;16991:21:19;17048:2;17028:18;;;17021:30;17087:34;17067:18;;;17060:62;17158:6;17138:18;;;17131:34;17182:19;;10908:68:3;16807:400:19;10908:68:3;10994:21;;;10986:68;;;;;;;17414:2:19;10986:68:3;;;17396:21:19;17453:2;17433:18;;;17426:30;17492:34;17472:18;;;17465:62;17563:4;17543:18;;;17536:32;17585:19;;10986:68:3;17212:398:19;10986:68:3;11065:18;;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;:36;;;11116:32;;1524:25:19;;;11116:32:3;;1497:18:19;11116:32:3;;;;;;;10815:340;;;:::o;1620:130:0:-;1534:6;;1683:23;1534:6;965:10:9;1683:23:0;1675:68;;;;;;;17817:2:19;1675:68:0;;;17799:21:19;;;17836:18;;;17829:30;17895:34;17875:18;;;17868:62;17947:18;;1675:68:0;17615:356:19;11436:411:3;4460:18;;;;11536:24;4460:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;11622:17;11602:37;;11598:243;;11683:6;11663:16;:26;;11655:68;;;;;;;18178:2:19;11655:68:3;;;18160:21:19;18217:2;18197:18;;;18190:30;18256:31;18236:18;;;18229:59;18305:18;;11655:68:3;17976:353:19;11655:68:3;11765:51;11774:5;11781:7;11809:6;11790:16;:25;11765:8;:51::i;:::-;11526:321;11436:411;;;:::o;14126:836:16:-;14215:17;14229:2;14215:13;:17::i;:::-;14256:22;14247:5;;;;:31;;;;;;;;:::i;:::-;;14243:713;;14303:11;;;;;;;:5;:11;;;;;;;;14302:12;:26;;;;-1:-1:-1;14319:9:16;;;;;;;:5;:9;;;;;;;;14318:10;14302:26;14294:99;;;;;;;18536:2:19;14294:99:16;;;18518:21:19;18575:2;18555:18;;;18548:30;18614:34;18594:18;;;18587:62;18685:30;18665:18;;;18658:58;18733:19;;14294:99:16;18334:424:19;14294:99:16;14407:32;14422:4;14428:2;14432:6;14407:14;:32::i;:::-;14126:836;;;:::o;14243:713::-;14469:19;14460:5;;;;:28;;;;;;;;:::i;:::-;;14456:500;;14504:32;14519:4;14525:2;14529:6;14504:14;:32::i;14456:500::-;14566:31;14557:5;;;;:40;;;;;;;;:::i;:::-;;:74;;;-1:-1:-1;14610:21:16;14601:5;;;;:30;;;;;;;;:::i;:::-;;14557:74;14553:403;;;14647:11;14661:25;14669:4;14675:2;14679:6;14661:7;:25::i;:::-;14647:39;-1:-1:-1;14704:7:16;;14700:154;;14731:37;14746:4;14752:2;14756:6;14764:3;14731:14;:37::i;:::-;14700:154;;;14807:32;14822:4;14828:2;14832:6;14807:14;:32::i;3325:109:13:-;3378:7;3404:23;:21;:23::i;2687:187:0:-;2779:6;;;;2795:17;;;;;;;;;;;2827:40;;2779:6;;;2795:17;2779:6;;2827:40;;2760:16;;2827:40;2750:124;2687:187;:::o;5606:98:13:-;5660:13;5692:5;5685:12;;;;;:::i;5931:104::-;5988:13;6020:8;6013:15;;;;;:::i;2139:147:3:-;5374:13:2;;;;;;;5366:69;;;;;;;18965:2:19;5366:69:2;;;18947:21:19;19004:2;18984:18;;;18977:30;19043:34;19023:18;;;19016:62;19114:13;19094:18;;;19087:41;19145:19;;5366:69:2;18763:407:19;5366:69:2;2241:38:3::1;2264:5;2271:7;2241:22;:38::i;2064:125:5:-:0;5374:13:2;;;;;;;5366:69;;;;;;;18965:2:19;5366:69:2;;;18947:21:19;19004:2;18984:18;;;18977:30;19043:34;19023:18;;;19016:62;19114:13;19094:18;;;19087:41;19145:19;;5366:69:2;18763:407:19;5366:69:2;2148:34:5::1;2172:4;2148:34;;;;;;;;;;;;;;;;::::0;:23:::1;:34::i;1024:95:0:-:0;5374:13:2;;;;;;;5366:69;;;;;;;18965:2:19;5366:69:2;;;18947:21:19;19004:2;18984:18;;;18977:30;19043:34;19023:18;;;19016:62;19114:13;19094:18;;;19087:41;19145:19;;5366:69:2;18763:407:19;5366:69:2;1086:26:0::1;:24;:26::i;8878:535:3:-:0;8961:21;;;8953:65;;;;;;;19377:2:19;8953:65:3;;;19359:21:19;19416:2;19396:18;;;19389:30;19455:33;19435:18;;;19428:61;19506:18;;8953:65:3;19175:355:19;8953:65:3;9105:6;9089:12;;:22;;;;;;;:::i;:::-;;;;-1:-1:-1;;9257:18:3;;;;;;;:9;:18;;;;;;;;:28;;;;;;9310:37;1524:25:19;;;9310:37:3;;1497:18:19;9310:37:3;;;;;;;9358:48;9386:1;9390:7;9399:6;9358:19;:48::i;1391:659:18:-;1535:7;1714:6;1705:15;;:6;:15;;;:53;;1743:6;1751;1705:53;;;1724:6;1732;1705:53;1931:32;;19702:66:19;19797:2;19793:15;;;19789:24;;1931:32:18;;;19777:37:19;19848:15;;;19844:24;19830:12;;;19823:46;1686:72:18;;-1:-1:-1;1686:72:18;-1:-1:-1;1912:7:18;;19885:12:19;;1931:32:18;;;;;;;;;;;;1921:43;;;;;;1966:12;1886:93;;;;;;;;;20206:66:19;20194:79;;20310:2;20306:15;;;;20323:66;20302:88;20298:1;20289:11;;20282:109;20416:2;20407:12;;20400:28;;;;20453:2;20444:12;;20437:28;20490:2;20481:12;;19908:591;1886:93:18;;;;;;;;;;;;;;1851:150;;1886:93;1851:150;;;;;1391:659;-1:-1:-1;;;;;1391:659:18:o;476:639::-;632:7;781:6;772:15;;:6;:15;;;:53;;810:6;818;772:53;;;791:6;799;772:53;997:31;;;20714:42:19;20783:15;;;997:31:18;;;20765:34:19;20835:15;;20815:18;;;20808:43;;;;20899:8;20887:21;;20867:18;;;20860:49;753:72:18;;-1:-1:-1;753:72:18;-1:-1:-1;978:7:18;;20677:18:19;;997:31:18;;;;;;;;;;;;987:42;;;;;;1031:12;952:92;;;;;;;;;20206:66:19;20194:79;;20310:2;20306:15;;;;20323:66;20302:88;20298:1;20289:11;;20282:109;20416:2;20407:12;;20400:28;;;;20453:2;20444:12;;20437:28;20490:2;20481:12;;19908:591;952:92:18;;;;;;;;;;;;;;917:149;;952:92;917:149;;;;;476:639;-1:-1:-1;;;;;;476:639:18:o;3531:214:5:-;3662:14;;;3591:15;3662:14;;;:7;:14;;;;;929::10;;1061:1;1043:19;;;;929:14;3721:17:5;3608:137;3531:214;;;:::o;4257:176:13:-;4334:7;4360:66;4393:20;:18;:20::i;:::-;4415:10;8569:4:12;8563:11;8599:10;8587:23;;8639:4;8630:14;;8623:39;;;;8691:4;8682:14;;8675:34;8745:4;8730:20;;;8369:397;6620:232;6705:7;6725:17;6744:18;6766:25;6777:4;6783:1;6786;6789;6766:10;:25::i;:::-;6724:67;;;;6801:18;6813:5;6801:11;:18::i;:::-;-1:-1:-1;6836:9:12;6620:232;-1:-1:-1;;;;;6620:232:12:o;15099:3320:16:-;15784:21;15775:5;;;;:30;;;;;;;;:::i;:::-;;:74;;;-1:-1:-1;15818:31:16;15809:5;;;;:40;;;;;;;;:::i;:::-;;15775:74;15774:139;;;;-1:-1:-1;15899:14:16;;;;15774:139;:211;;;;-1:-1:-1;15976:8:16;;;15970:14;;;15976:8;;15970:14;15774:211;15757:2656;;;16104:17;;16086:15;:35;16082:524;;;16162:5;;;16193:17;16185:25;;;;;;;;16228:7;:11;;;;;;16162:5;;;16280:47;;16162:5;;16297:15;;;;;;;:::i;:::-;16320:5;;;;16314:12;;;;;;;;:::i;:::-;16280:47;;;9240:4:19;9228:17;;;9210:36;;9282:17;;;;9277:2;9262:18;;9255:45;9183:18;16280:47:16;;;;;;;16123:219;16082:524;;;16370:24;;16352:15;:42;:76;;;;-1:-1:-1;16407:21:16;16398:5;;;;:30;;;;;;;;:::i;:::-;;;16352:76;16348:258;;;16469:5;;;16492:29;;;16500:21;16492:29;;;;16469:5;;16544:47;16469:5;16561:15;;;;;;;;:::i;:::-;16584:5;;;;16578:12;;;;;;;;:::i;:::-;16544:47;;;9240:4:19;9228:17;;;9210:36;;9282:17;;;;9277:2;9262:18;;9255:45;9183:18;16544:47:16;;;;;;;16430:176;16348:258;16658:4;16620:17;3877:18:3;;;:9;:18;;;;;;16700:13:16;;;;;:122;;-1:-1:-1;16767:17:16;16758:5;;;;:26;;;;;;;;:::i;:::-;;:63;;;;16801:20;;16788:9;:33;;16758:63;16679:1724;;;16902:14;:22;;;;;;17061:14;;17054:4;-1:-1:-1;4460:18:3;;;:11;:18;;;;;;;;17061:14:16;;;;4460:27:3;;;;;;;17079:9:16;-1:-1:-1;17032:157:16;;;17136:14;;17112:58;;17129:4;;17136:14;;17152:17;17112:8;:58::i;:::-;17285:16;;;17299:1;17285:16;;;;;;;;17261:21;;17285:16;;;;;;;;;;-1:-1:-1;17285:16:16;17261:40;;17337:4;17319;17324:1;17319:7;;;;;;;;:::i;:::-;:23;;;;:7;;;;;;;;;:23;17370:11;;17360:7;;17370:11;;;17360:4;;17370:11;;17360:7;;;;;;:::i;:::-;:21;;;;:7;;;;;;;;;:21;17510:14;;17493:63;;;;;17466:24;;17510:14;;;;;17493:46;;:63;;17540:9;;17551:4;;17493:63;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;17466:90;;17574:20;17597:7;17605:1;17597:10;;;;;;;;:::i;:::-;;;;;;;;;;;17647:14;;17769:11;;17630:185;;;;;17597:10;;-1:-1:-1;17647:14:16;;;;;17630:86;;:185;;17738:9;;17597:10;;17763:4;;17769:11;;;;;17782:15;;17630:185;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;17626:701;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;18206:27;18226:6;18206:27;;;;;;:::i;:::-;;;;;;;;18285:11;;18255:53;;18278:4;;18285:11;;;;;18298:9;18255:14;:53::i;:::-;18151:176;17626:701;;;17838:52;17866:9;17877:12;17838:27;:52::i;:::-;18094:11;;18068:63;;;18094:11;;;;23718:74:19;;23823:2;23808:18;;23801:34;;;23851:18;;23844:34;;;18068:63:16;;23706:2:19;23691:18;18068:63:16;;;;;;;17626:701;-1:-1:-1;;18345:14:16;:21;;;;18362:4;18345:21;;;-1:-1:-1;16036:2377:16;15099:3320;:::o;12322:125::-;12407:33;12423:4;12429:2;12433:6;12407:15;:33::i;12703:660::-;12808:14;;12785:7;;12808:14;;12804:535;;;12851:31;12842:5;;;;:40;;;;;;;;:::i;:::-;;12838:491;;12965:11;;;;;;;:5;:11;;;;;;;;;:24;;-1:-1:-1;12980:9:16;;;;;;;:5;:9;;;;;;;;12965:24;12961:104;;;13030:7;;13041:5;;13021:16;;13030:7;;13021:6;:16;:::i;:::-;13020:26;;;;:::i;:::-;13013:33;;;;12961:104;12838:491;;;13098:21;13089:5;;;;:30;;;;;;;;:::i;:::-;;13085:244;;13213:8;;;13205:16;;;13213:8;;13205:16;;:34;;-1:-1:-1;13231:8:16;;;13225:14;;;13231:8;;13225:14;13205:34;13201:114;;;13280:7;;13291:5;;13271:16;;13280:7;;13271:6;:16;:::i;13201:114::-;-1:-1:-1;13355:1:16;12703:660;;;;;:::o;13639:245::-;13737:23;13763:12;13772:3;13763:6;:12;:::i;:::-;13737:38;;13786:40;13801:4;13815;13822:3;13786:14;:40::i;:::-;13836:41;13851:4;13857:2;13861:15;13836:14;:41::i;:::-;13727:157;13639:245;;;;:::o;3440:192:13:-;3495:7;1934:95;3554:17;:15;:17::i;:::-;3573:20;:18;:20::i;:::-;3531:93;;;;;;24733:25:19;;;;24774:18;;24767:34;;;;24817:18;;;24810:34;3595:13:13;24860:18:19;;;24853:34;3618:4:13;24903:19:19;;;24896:84;24705:19;;3531:93:13;;;;;;;;;;;;3521:104;;;;;;3514:111;;3440:192;:::o;2292:159:3:-;5374:13:2;;;;;;;5366:69;;;;;;;18965:2:19;5366:69:2;;;18947:21:19;19004:2;18984:18;;;18977:30;19043:34;19023:18;;;19016:62;19114:13;19094:18;;;19087:41;19145:19;;5366:69:2;18763:407:19;5366:69:2;2404:5:3::1;:13;2412:5:::0;2404;:13:::1;:::i;:::-;-1:-1:-1::0;2427:7:3::1;:17;2437:7:::0;2427;:17:::1;:::i;2972:267:13:-:0;5374:13:2;;;;;;;5366:69;;;;;;;18965:2:19;5366:69:2;;;18947:21:19;19004:2;18984:18;;;18977:30;19043:34;19023:18;;;19016:62;19114:13;19094:18;;;19087:41;19145:19;;5366:69:2;18763:407:19;5366:69:2;3084:5:13::1;:12;3092:4:::0;3084:5;:12:::1;:::i;:::-;-1:-1:-1::0;3106:8:13::1;:18;3117:7:::0;3106:8;:18:::1;:::i;:::-;-1:-1:-1::0;;3203:1:13::1;3189:11;:15:::0;;;3214:14:::1;:18:::0;-1:-1:-1;2972:267:13:o;1125:111:0:-;5374:13:2;;;;;;;5366:69;;;;;;;18965:2:19;5366:69:2;;;18947:21:19;19004:2;18984:18;;;18977:30;19043:34;19023:18;;;19016:62;19114:13;19094:18;;;19087:41;19145:19;;5366:69:2;18763:407:19;5366:69:2;1197:32:0::1;965:10:9::0;1197:18:0::1;:32::i;19229:146:16:-:0;19333:35;;;25203:42:19;25272:15;;;25254:34;;25324:15;;25319:2;25304:18;;25297:43;25356:18;;;25349:34;;;19333:35:16;;25181:2:19;25166:18;19333:35:16;;;;;;;19229:146;;;:::o;5031:1456:12:-;5119:7;;6043:66;6030:79;;6026:161;;;-1:-1:-1;6141:1:12;;-1:-1:-1;6145:30:12;6125:51;;6026:161;6298:24;;;6281:14;6298:24;;;;;;;;;25621:25:19;;;25694:4;25682:17;;25662:18;;;25655:45;;;;25716:18;;;25709:34;;;25759:18;;;25752:34;;;6298:24:12;;25593:19:19;;6298:24:12;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;6298:24:12;;;;;;-1:-1:-1;;6336:20:12;;;6332:101;;6388:1;6392:29;6372:50;;;;;;;6332:101;6451:6;-1:-1:-1;6459:20:12;;-1:-1:-1;5031:1456:12;;;;;;;;:::o;592:511::-;669:20;660:5;:29;;;;;;;;:::i;:::-;;656:441;;592:511;:::o;656:441::-;765:29;756:5;:38;;;;;;;;:::i;:::-;;752:345;;810:34;;;;;25999:2:19;810:34:12;;;25981:21:19;26038:2;26018:18;;;26011:30;26077:26;26057:18;;;26050:54;26121:18;;810:34:12;25797:348:19;752:345:12;874:35;865:5;:44;;;;;;;;:::i;:::-;;861:236;;925:41;;;;;26352:2:19;925:41:12;;;26334:21:19;26391:2;26371:18;;;26364:30;26430:33;26410:18;;;26403:61;26481:18;;925:41:12;26150:355:19;861:236:12;996:30;987:5;:39;;;;;;;;:::i;:::-;;983:114;;1042:44;;;;;26712:2:19;1042:44:12;;;26694:21:19;26751:2;26731:18;;;26724:30;26790:34;26770:18;;;26763:62;26861:4;26841:18;;;26834:32;26883:19;;1042:44:12;26510:398:19;18644:579:16;18846:28;18917:9;18893:20;;18878:12;:35;;;;:::i;:::-;18877:49;;;;:::i;:::-;18846:80;;18963:23;;18940:20;:46;18936:281;;;19055:3;19026:20;;19049:2;19026:25;;;;:::i;:::-;19025:33;;;;:::i;:::-;19002:20;:56;;;19115:17;-1:-1:-1;19088:119:16;;;19175:17;19152:20;:40;18731:492;18644:579;;:::o;7814:788:3:-;7910:18;;;7902:68;;;;;;;27115:2:19;7902:68:3;;;27097:21:19;27154:2;27134:18;;;27127:30;27193:34;27173:18;;;27166:62;27264:7;27244:18;;;27237:35;27289:19;;7902:68:3;26913:401:19;7902:68:3;7988:16;;;7980:64;;;;;;;27521:2:19;7980:64:3;;;27503:21:19;27560:2;27540:18;;;27533:30;27599:34;27579:18;;;27572:62;27670:5;27650:18;;;27643:33;27693:19;;7980:64:3;27319:399:19;7980:64:3;8126:15;;;8104:19;8126:15;;;:9;:15;;;;;;8159:21;;;;8151:72;;;;;;;27925:2:19;8151:72:3;;;27907:21:19;27964:2;27944:18;;;27937:30;28003:34;27983:18;;;27976:62;28074:8;28054:18;;;28047:36;28100:19;;8151:72:3;27723:402:19;8151:72:3;8257:15;;;;;;;;:9;:15;;;;;;8275:20;;;8257:38;;8472:13;;;;;;;;;;:23;;;;;;8521:26;;;;;;8289:6;1524:25:19;;1512:2;1497:18;;1378:177;8521:26:3;;;;;;;;8558:37;8578:4;8584:2;8588:6;8558:19;:37::i;6250:630:13:-;6300:7;6319:18;6340:13;:11;:13::i;:::-;6367:18;;6319:34;;-1:-1:-1;6367:22:13;6363:511;;6412:22;;;;;;;;6250:630;-1:-1:-1;6250:630:13:o;6363:511::-;6709:11;;6738:15;;6734:130;;6780:10;6250:630;-1:-1:-1;;6250:630:13:o;6734:130::-;6836:13;6829:20;;;;6250:630;:::o;7101:666::-;7154:7;7173:21;7197:16;:14;:16::i;:::-;7227:21;;7173:40;;-1:-1:-1;7227:25:13;7223:538;;7275:25;;;;;;;;7101:666;-1:-1:-1;7101:666:13:o;7223:538::-;7587:14;;7619:18;;7615:136;;7664:13;7101:666;-1:-1:-1;;7101:666:13:o;14:482:19:-;56:3;94:5;88:12;121:6;116:3;109:19;146:1;156:162;170:6;167:1;164:13;156:162;;;232:4;288:13;;;284:22;;278:29;260:11;;;256:20;;249:59;185:12;156:162;;;160:3;363:1;356:4;347:6;342:3;338:16;334:27;327:38;485:4;415:66;410:2;402:6;398:15;394:88;389:3;385:98;381:109;374:116;;;14:482;;;;:::o;501:220::-;650:2;639:9;632:21;613:4;670:45;711:2;700:9;696:18;688:6;670:45;:::i;726:196::-;794:20;;854:42;843:54;;833:65;;823:93;;912:1;909;902:12;823:93;726:196;;;:::o;927:254::-;995:6;1003;1056:2;1044:9;1035:7;1031:23;1027:32;1024:52;;;1072:1;1069;1062:12;1024:52;1095:29;1114:9;1095:29;:::i;:::-;1085:39;1171:2;1156:18;;;;1143:32;;-1:-1:-1;;;927:254:19:o;1791:328::-;1868:6;1876;1884;1937:2;1925:9;1916:7;1912:23;1908:32;1905:52;;;1953:1;1950;1943:12;1905:52;1976:29;1995:9;1976:29;:::i;:::-;1966:39;;2024:38;2058:2;2047:9;2043:18;2024:38;:::i;:::-;2014:48;;2109:2;2098:9;2094:18;2081:32;2071:42;;1791:328;;;;;:::o;2495:186::-;2554:6;2607:2;2595:9;2586:7;2582:23;2578:32;2575:52;;;2623:1;2620;2613:12;2575:52;2646:29;2665:9;2646:29;:::i;2879:1335::-;3276:66;3268:6;3264:79;3253:9;3246:98;3227:4;3363:2;3401:3;3396:2;3385:9;3381:18;3374:31;3428:46;3469:3;3458:9;3454:19;3446:6;3428:46;:::i;:::-;3522:9;3514:6;3510:22;3505:2;3494:9;3490:18;3483:50;3556:33;3582:6;3574;3556:33;:::i;:::-;3620:2;3605:18;;3598:34;;;3681:42;3669:55;;3663:3;3648:19;;3641:84;3756:3;3741:19;;3734:35;;;3806:22;;;3800:3;3785:19;;3778:51;3878:13;;3900:22;;;3950:2;3976:15;;;;-1:-1:-1;3938:15:19;;;;-1:-1:-1;4019:169:19;4033:6;4030:1;4027:13;4019:169;;;4094:13;;4082:26;;4163:15;;;;4128:12;;;;4055:1;4048:9;4019:169;;;-1:-1:-1;4205:3:19;;2879:1335;-1:-1:-1;;;;;;;;;;;;2879:1335:19:o;4219:260::-;4287:6;4295;4348:2;4336:9;4327:7;4323:23;4319:32;4316:52;;;4364:1;4361;4354:12;4316:52;4387:29;4406:9;4387:29;:::i;:::-;4377:39;;4435:38;4469:2;4458:9;4454:18;4435:38;:::i;:::-;4425:48;;4219:260;;;;;:::o;4484:184::-;4536:77;4533:1;4526:88;4633:4;4630:1;4623:15;4657:4;4654:1;4647:15;4673:255;4745:2;4739:9;4787:6;4775:19;;4824:18;4809:34;;4845:22;;;4806:62;4803:88;;;4871:18;;:::i;:::-;4907:2;4900:22;4673:255;:::o;4933:334::-;5004:2;4998:9;5060:2;5050:13;;5065:66;5046:86;5034:99;;5163:18;5148:34;;5184:22;;;5145:62;5142:88;;;5210:18;;:::i;:::-;5246:2;5239:22;4933:334;;-1:-1:-1;4933:334:19:o;5272:590::-;5315:5;5368:3;5361:4;5353:6;5349:17;5345:27;5335:55;;5386:1;5383;5376:12;5335:55;5422:6;5409:20;5448:18;5444:2;5441:26;5438:52;;;5470:18;;:::i;:::-;5514:114;5622:4;5553:66;5546:4;5542:2;5538:13;5534:86;5530:97;5514:114;:::i;:::-;5653:2;5644:7;5637:19;5699:3;5692:4;5687:2;5679:6;5675:15;5671:26;5668:35;5665:55;;;5716:1;5713;5706:12;5665:55;5781:2;5774:4;5766:6;5762:17;5755:4;5746:7;5742:18;5729:55;5829:1;5804:16;;;5822:4;5800:27;5793:38;;;;5808:7;5272:590;-1:-1:-1;;;5272:590:19:o;5867:159::-;5934:20;;5994:6;5983:18;;5973:29;;5963:57;;6016:1;6013;6006:12;6031:1275;6118:6;6171:2;6159:9;6150:7;6146:23;6142:32;6139:52;;;6187:1;6184;6177:12;6139:52;6227:9;6214:23;6256:18;6297:2;6289:6;6286:14;6283:34;;;6313:1;6310;6303:12;6283:34;6336:22;;;;6392:6;6374:16;;;6370:29;6367:49;;;6412:1;6409;6402:12;6367:49;6438:22;;:::i;:::-;6498:2;6485:16;6526:2;6516:8;6513:16;6510:36;;;6542:1;6539;6532:12;6510:36;6569:45;6606:7;6595:8;6591:2;6587:17;6569:45;:::i;:::-;6562:5;6555:60;;6661:2;6657;6653:11;6640:25;6690:2;6680:8;6677:16;6674:36;;;6706:1;6703;6696:12;6674:36;6742:45;6779:7;6768:8;6764:2;6760:17;6742:45;:::i;:::-;6737:2;6730:5;6726:14;6719:69;;6834:2;6830;6826:11;6813:25;6863:2;6853:8;6850:16;6847:36;;;6879:1;6876;6869:12;6847:36;6915:45;6952:7;6941:8;6937:2;6933:17;6915:45;:::i;:::-;6910:2;6903:5;6899:14;6892:69;;6993:30;7019:2;7015;7011:11;6993:30;:::i;:::-;6988:2;6981:5;6977:14;6970:54;7057:32;7084:3;7080:2;7076:12;7057:32;:::i;:::-;7051:3;7044:5;7040:15;7033:57;7123:32;7150:3;7146:2;7142:12;7123:32;:::i;:::-;7117:3;7110:5;7106:15;7099:57;7210:3;7206:2;7202:12;7189:26;7183:3;7176:5;7172:15;7165:51;7270:3;7266:2;7262:12;7249:26;7243:3;7236:5;7232:15;7225:51;7295:5;7285:15;;;;;6031:1275;;;;:::o;7311:184::-;7363:77;7360:1;7353:88;7460:4;7457:1;7450:15;7484:4;7481:1;7474:15;7500:399;7646:2;7631:18;;7679:1;7668:13;;7658:201;;7715:77;7712:1;7705:88;7816:4;7813:1;7806:15;7844:4;7841:1;7834:15;7658:201;7868:25;;;7500:399;:::o;7904:693::-;8015:6;8023;8031;8039;8047;8055;8063;8116:3;8104:9;8095:7;8091:23;8087:33;8084:53;;;8133:1;8130;8123:12;8084:53;8156:29;8175:9;8156:29;:::i;:::-;8146:39;;8204:38;8238:2;8227:9;8223:18;8204:38;:::i;:::-;8194:48;;8289:2;8278:9;8274:18;8261:32;8251:42;;8340:2;8329:9;8325:18;8312:32;8302:42;;8394:3;8383:9;8379:19;8366:33;8439:4;8432:5;8428:16;8421:5;8418:27;8408:55;;8459:1;8456;8449:12;8408:55;7904:693;;;;-1:-1:-1;7904:693:19;;;;8482:5;8534:3;8519:19;;8506:33;;-1:-1:-1;8586:3:19;8571:19;;;8558:33;;7904:693;-1:-1:-1;;7904:693:19:o;8602:437::-;8681:1;8677:12;;;;8724;;;8745:61;;8799:4;8791:6;8787:17;8777:27;;8745:61;8852:2;8844:6;8841:14;8821:18;8818:38;8815:218;;8889:77;8886:1;8879:88;8990:4;8987:1;8980:15;9018:4;9015:1;9008:15;9311:184;9363:77;9360:1;9353:88;9460:4;9457:1;9450:15;9484:4;9481:1;9474:15;9500:125;9565:9;;;9586:10;;;9583:36;;;9599:18;;:::i;12453:518::-;12555:2;12550:3;12547:11;12544:421;;;12591:5;12588:1;12581:16;12635:4;12632:1;12622:18;12705:2;12693:10;12689:19;12686:1;12682:27;12676:4;12672:38;12741:4;12729:10;12726:20;12723:47;;;-1:-1:-1;12764:4:19;12723:47;12819:2;12814:3;12810:12;12807:1;12803:20;12797:4;12793:31;12783:41;;12874:81;12892:2;12885:5;12882:13;12874:81;;;12951:1;12937:16;;12918:1;12907:13;12874:81;;13207:1464;13333:3;13327:10;13360:18;13352:6;13349:30;13346:56;;;13382:18;;:::i;:::-;13411:97;13501:6;13461:38;13493:4;13487:11;13461:38;:::i;:::-;13455:4;13411:97;:::i;:::-;13563:4;;13620:2;13609:14;;13637:1;13632:782;;;;14458:1;14475:6;14472:89;;;-1:-1:-1;14527:19:19;;;14521:26;14472:89;13113:66;13104:1;13100:11;;;13096:84;13092:89;13082:100;13188:1;13184:11;;;13079:117;14574:81;;13602:1063;;13632:782;12400:1;12393:14;;;12437:4;12424:18;;13680:66;13668:79;;;13845:236;13859:7;13856:1;13853:14;13845:236;;;13948:19;;;13942:26;13927:42;;14040:27;;;;14008:1;13996:14;;;;13875:19;;13845:236;;;13849:3;14109:6;14100:7;14097:19;14094:261;;;14170:19;;;14164:26;14271:66;14253:1;14249:14;;;14265:3;14245:24;14241:97;14237:102;14222:118;14207:134;;14094:261;;;14401:1;14392:6;14389:1;14385:14;14381:22;14375:4;14368:36;13602:1063;;;;;13207:1464;;:::o;14676:184::-;14728:77;14725:1;14718:88;14825:4;14822:1;14815:15;14849:4;14846:1;14839:15;20920:488;20973:3;21011:5;21005:12;21038:6;21033:3;21026:19;21064:4;21093;21088:3;21084:14;21077:21;;21132:4;21125:5;21121:16;21155:1;21165:218;21179:6;21176:1;21173:13;21165:218;;;21244:13;;21259:42;21240:62;21228:75;;21323:12;;;;21358:15;;;;21201:1;21194:9;21165:218;;;-1:-1:-1;21399:3:19;;20920:488;-1:-1:-1;;;;;20920:488:19:o;21413:332::-;21620:6;21609:9;21602:25;21663:2;21658;21647:9;21643:18;21636:30;21583:4;21683:56;21735:2;21724:9;21720:18;21712:6;21683:56;:::i;:::-;21675:64;21413:332;-1:-1:-1;;;;21413:332:19:o;21750:936::-;21845:6;21876:2;21919;21907:9;21898:7;21894:23;21890:32;21887:52;;;21935:1;21932;21925:12;21887:52;21968:9;21962:16;21997:18;22038:2;22030:6;22027:14;22024:34;;;22054:1;22051;22044:12;22024:34;22092:6;22081:9;22077:22;22067:32;;22137:7;22130:4;22126:2;22122:13;22118:27;22108:55;;22159:1;22156;22149:12;22108:55;22188:2;22182:9;22210:2;22206;22203:10;22200:36;;;22216:18;;:::i;:::-;22262:2;22259:1;22255:10;22245:20;;22285:28;22309:2;22305;22301:11;22285:28;:::i;:::-;22347:15;;;22417:11;;;22413:20;;;22378:12;;;;22445:19;;;22442:39;;;22477:1;22474;22467:12;22442:39;22501:11;;;;22521:135;22537:6;22532:3;22529:15;22521:135;;;22603:10;;22591:23;;22554:12;;;;22634;;;;22521:135;;;22675:5;21750:936;-1:-1:-1;;;;;;;;21750:936:19:o;22691:597::-;22982:6;22971:9;22964:25;23025:6;23020:2;23009:9;23005:18;22998:34;23068:3;23063:2;23052:9;23048:18;23041:31;22945:4;23089:57;23141:3;23130:9;23126:19;23118:6;23089:57;:::i;:::-;23194:42;23182:55;;;;23177:2;23162:18;;23155:83;-1:-1:-1;23269:3:19;23254:19;23247:35;23081:65;22691:597;-1:-1:-1;;;22691:597:19:o;23889:168::-;23962:9;;;23993;;24010:15;;;24004:22;;23990:37;23980:71;;24031:18;;:::i;24062:274::-;24102:1;24128;24118:189;;24163:77;24160:1;24153:88;24264:4;24261:1;24254:15;24292:4;24289:1;24282:15;24118:189;-1:-1:-1;24321:9:19;;24062:274::o;24341:128::-;24408:9;;;24429:11;;;24426:37;;;24443:18;;:::i

ipfs://dfe961da7680e97aaf811e4a1fc98663db9fdca4825e0c6ea27b75fb85387166