Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

   - function _msgSender()    - function _msgData()    - function owner()    - function renounceOwnership()    - function transferOwnership(address ne ...    - function _setOwner(address newOwner) interface IERC20    - function totalSupply()    - function balanceOf(address account)    - function transfer(address recipient, ...    - function allowance(address owner, add ...    - function approve(address spender, uin ...    - function transferFrom( interface IERC20Metadata is IERC20    - function name()    - function symbol()    - function decimals()  contract ERC20 is Context, IERC20, ...    - function name()    - function symbol()    - function decimals()    - function totalSupply()    - function balanceOf(address account)    - function transfer(address recipient, ...    - function allowance(address owner, add ...    - function approve(address spender, uin ...    - function transferFrom(    - function increaseAllowance(address sp ...    - function decreaseAllowance(address sp ...    - function _transfer(    - function _mint(address account, uint2 ...    - function _burn(address account, uint2 ...    - function _approve(    - function _beforeTokenTransfer(    - function _afterTokenTransfer( library PRBMath    - function exp2(uint256 x)    - function mostSignificantBit(uint256 x ...    - function mulDiv(    - function mulDivFixedPoint(uint256 x, ...    - function mulDivSigned(    - function sqrt(uint256 x) library PRBMathUD60x18    - function avg(uint256 x, uint256 y)    - function ceil(uint256 x)    - function div(uint256 x, uint256 y)    - function e()    - function exp(uint256 x)    - function exp2(uint256 x)    - function floor(uint256 x)    - function frac(uint256 x)    - function fromUint(uint256 x)    - function gm(uint256 x, uint256 y)    - function inv(uint256 x)    - function ln(uint256 x)    - function log10(uint256 x)    - function log2(uint256 x)    - function mul(uint256 x, uint256 y)    - function pi()    - function pow(uint256 x, uint256 y)    - function powu(uint256 x, uint256 y)    - function scale()    - function sqrt(uint256 x)    - function toUint(uint256 x) interface IUniswapV2Factory    - function createPair(address tokenA, a ... interface IUniswapV2Router02    - function swapExactTokensForETHSupport ...    - function factory()    - function WETH()    - function addLiquidityETH(  contract Mittens is ERC20, Ownable *    - function _beforeTokenTransfer(    - function _afterTokenTransfer(    - function QuickSaleLimit(address from, ...    - function GetFees(address acc, uint256 ...    - function GetDevFee(address acc, uint2 ...    - function GetMarketingFee(address acc, ...    - function GetBurnFee(address acc, uint ...    - function openTrading()    - function setMaxBuy(uint256 newMaxBuy)    - function setMarketingWallet(address m ...    - function setDevWallet(address devWall ...    - function excludeFromFee(address ad)    - function includeToFee(address ad)    - function setNoTaxMode(bool onoff)    - function setBots(address[] memory bot ...    - function delBot(address notbot)    - function burnBot(address bot)    - function isBot(address ad)    - function setminTxSecondsInterval(uint ...

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2021-10-31
*/

// File: @openzeppelin/contracts/utils/Context.sol



pragma solidity ^0.8.0;

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

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

// File: @openzeppelin/contracts/access/Ownable.sol



pragma solidity ^0.8.0;


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

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

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor() {
        _setOwner(_msgSender());
    }

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

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
        _;
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions anymore. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby removing any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        _setOwner(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");
        _setOwner(newOwner);
    }

    function _setOwner(address newOwner) private {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}

// File: @openzeppelin/contracts/token/ERC20/IERC20.sol



pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

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

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

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

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

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

    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

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

// File: @openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol



pragma solidity ^0.8.0;


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

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

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

// File: @openzeppelin/contracts/token/ERC20/ERC20.sol



pragma solidity ^0.8.0;




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

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

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;

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

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

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

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

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

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

    /**
     * @dev See {IERC20-transfer}.
     *
     * Requirements:
     *
     * - `recipient` cannot be the zero address.
     * - the caller must have a balance of at least `amount`.
     */
    function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
        _transfer(_msgSender(), recipient, 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}.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function approve(address spender, uint256 amount) public virtual override returns (bool) {
        _approve(_msgSender(), 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}.
     *
     * Requirements:
     *
     * - `sender` and `recipient` cannot be the zero address.
     * - `sender` must have a balance of at least `amount`.
     * - the caller must have allowance for ``sender``'s tokens of at least
     * `amount`.
     */
    function transferFrom(
        address sender,
        address recipient,
        uint256 amount
    ) public virtual override returns (bool) {
        _transfer(sender, recipient, amount);

        uint256 currentAllowance = _allowances[sender][_msgSender()];
        require(currentAllowance >= amount, "ERC20: transfer amount exceeds allowance");
        unchecked {
            _approve(sender, _msgSender(), currentAllowance - 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) {
        _approve(_msgSender(), spender, _allowances[_msgSender()][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) {
        uint256 currentAllowance = _allowances[_msgSender()][spender];
        require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
        unchecked {
            _approve(_msgSender(), spender, currentAllowance - subtractedValue);
        }

        return true;
    }

    /**
     * @dev Moves `amount` of tokens from `sender` to `recipient`.
     *
     * 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:
     *
     * - `sender` cannot be the zero address.
     * - `recipient` cannot be the zero address.
     * - `sender` must have a balance of at least `amount`.
     */
    function _transfer(
        address sender,
        address recipient,
        uint256 amount
    ) internal virtual {
        require(sender != address(0), "ERC20: transfer from the zero address");
        require(recipient != address(0), "ERC20: transfer to the zero address");

        _beforeTokenTransfer(sender, recipient, amount);

        uint256 senderBalance = _balances[sender];
        require(senderBalance >= amount, "ERC20: transfer amount exceeds balance");
        unchecked {
            _balances[sender] = senderBalance - amount;
        }
        _balances[recipient] += amount;

        emit Transfer(sender, recipient, amount);

        _afterTokenTransfer(sender, recipient, amount);
    }

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

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

        _totalSupply += amount;
        _balances[account] += amount;
        emit Transfer(address(0), account, amount);

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

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

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

        uint256 accountBalance = _balances[account];
        require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
        unchecked {
            _balances[account] = accountBalance - amount;
        }
        _totalSupply -= amount;

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

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

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

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

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

// File: prb-math/contracts/PRBMath.sol


pragma solidity >=0.8.4;

/// @notice Emitted when the result overflows uint256.
error PRBMath__MulDivFixedPointOverflow(uint256 prod1);

/// @notice Emitted when the result overflows uint256.
error PRBMath__MulDivOverflow(uint256 prod1, uint256 denominator);

/// @notice Emitted when one of the inputs is type(int256).min.
error PRBMath__MulDivSignedInputTooSmall();

/// @notice Emitted when the intermediary absolute result overflows int256.
error PRBMath__MulDivSignedOverflow(uint256 rAbs);

/// @notice Emitted when the input is MIN_SD59x18.
error PRBMathSD59x18__AbsInputTooSmall();

/// @notice Emitted when ceiling a number overflows SD59x18.
error PRBMathSD59x18__CeilOverflow(int256 x);

/// @notice Emitted when one of the inputs is MIN_SD59x18.
error PRBMathSD59x18__DivInputTooSmall();

/// @notice Emitted when one of the intermediary unsigned results overflows SD59x18.
error PRBMathSD59x18__DivOverflow(uint256 rAbs);

/// @notice Emitted when the input is greater than 133.084258667509499441.
error PRBMathSD59x18__ExpInputTooBig(int256 x);

/// @notice Emitted when the input is greater than 192.
error PRBMathSD59x18__Exp2InputTooBig(int256 x);

/// @notice Emitted when flooring a number underflows SD59x18.
error PRBMathSD59x18__FloorUnderflow(int256 x);

/// @notice Emitted when converting a basic integer to the fixed-point format overflows SD59x18.
error PRBMathSD59x18__FromIntOverflow(int256 x);

/// @notice Emitted when converting a basic integer to the fixed-point format underflows SD59x18.
error PRBMathSD59x18__FromIntUnderflow(int256 x);

/// @notice Emitted when the product of the inputs is negative.
error PRBMathSD59x18__GmNegativeProduct(int256 x, int256 y);

/// @notice Emitted when multiplying the inputs overflows SD59x18.
error PRBMathSD59x18__GmOverflow(int256 x, int256 y);

/// @notice Emitted when the input is less than or equal to zero.
error PRBMathSD59x18__LogInputTooSmall(int256 x);

/// @notice Emitted when one of the inputs is MIN_SD59x18.
error PRBMathSD59x18__MulInputTooSmall();

/// @notice Emitted when the intermediary absolute result overflows SD59x18.
error PRBMathSD59x18__MulOverflow(uint256 rAbs);

/// @notice Emitted when the intermediary absolute result overflows SD59x18.
error PRBMathSD59x18__PowuOverflow(uint256 rAbs);

/// @notice Emitted when the input is negative.
error PRBMathSD59x18__SqrtNegativeInput(int256 x);

/// @notice Emitted when the calculating the square root overflows SD59x18.
error PRBMathSD59x18__SqrtOverflow(int256 x);

/// @notice Emitted when addition overflows UD60x18.
error PRBMathUD60x18__AddOverflow(uint256 x, uint256 y);

/// @notice Emitted when ceiling a number overflows UD60x18.
error PRBMathUD60x18__CeilOverflow(uint256 x);

/// @notice Emitted when the input is greater than 133.084258667509499441.
error PRBMathUD60x18__ExpInputTooBig(uint256 x);

/// @notice Emitted when the input is greater than 192.
error PRBMathUD60x18__Exp2InputTooBig(uint256 x);

/// @notice Emitted when converting a basic integer to the fixed-point format format overflows UD60x18.
error PRBMathUD60x18__FromUintOverflow(uint256 x);

/// @notice Emitted when multiplying the inputs overflows UD60x18.
error PRBMathUD60x18__GmOverflow(uint256 x, uint256 y);

/// @notice Emitted when the input is less than 1.
error PRBMathUD60x18__LogInputTooSmall(uint256 x);

/// @notice Emitted when the calculating the square root overflows UD60x18.
error PRBMathUD60x18__SqrtOverflow(uint256 x);

/// @notice Emitted when subtraction underflows UD60x18.
error PRBMathUD60x18__SubUnderflow(uint256 x, uint256 y);

/// @dev Common mathematical functions used in both PRBMathSD59x18 and PRBMathUD60x18. Note that this shared library
/// does not always assume the signed 59.18-decimal fixed-point or the unsigned 60.18-decimal fixed-point
/// representation. When it does not, it is explicitly mentioned in the NatSpec documentation.
library PRBMath {
    /// STRUCTS ///

    struct SD59x18 {
        int256 value;
    }

    struct UD60x18 {
        uint256 value;
    }

    /// STORAGE ///

    /// @dev How many trailing decimals can be represented.
    uint256 internal constant SCALE = 1e18;

    /// @dev Largest power of two divisor of SCALE.
    uint256 internal constant SCALE_LPOTD = 262144;

    /// @dev SCALE inverted mod 2^256.
    uint256 internal constant SCALE_INVERSE =
        78156646155174841979727994598816262306175212592076161876661_508869554232690281;

    /// FUNCTIONS ///

    /// @notice Calculates the binary exponent of x using the binary fraction method.
    /// @dev Has to use 192.64-bit fixed-point numbers.
    /// See https://ethereum.stackexchange.com/a/96594/24693.
    /// @param x The exponent as an unsigned 192.64-bit fixed-point number.
    /// @return result The result as an unsigned 60.18-decimal fixed-point number.
    function exp2(uint256 x) internal pure returns (uint256 result) {
        unchecked {
            // Start from 0.5 in the 192.64-bit fixed-point format.
            result = 0x800000000000000000000000000000000000000000000000;

            // Multiply the result by root(2, 2^-i) when the bit at position i is 1. None of the intermediary results overflows
            // because the initial result is 2^191 and all magic factors are less than 2^65.
            if (x & 0x8000000000000000 > 0) {
                result = (result * 0x16A09E667F3BCC909) >> 64;
            }
            if (x & 0x4000000000000000 > 0) {
                result = (result * 0x1306FE0A31B7152DF) >> 64;
            }
            if (x & 0x2000000000000000 > 0) {
                result = (result * 0x1172B83C7D517ADCE) >> 64;
            }
            if (x & 0x1000000000000000 > 0) {
                result = (result * 0x10B5586CF9890F62A) >> 64;
            }
            if (x & 0x800000000000000 > 0) {
                result = (result * 0x1059B0D31585743AE) >> 64;
            }
            if (x & 0x400000000000000 > 0) {
                result = (result * 0x102C9A3E778060EE7) >> 64;
            }
            if (x & 0x200000000000000 > 0) {
                result = (result * 0x10163DA9FB33356D8) >> 64;
            }
            if (x & 0x100000000000000 > 0) {
                result = (result * 0x100B1AFA5ABCBED61) >> 64;
            }
            if (x & 0x80000000000000 > 0) {
                result = (result * 0x10058C86DA1C09EA2) >> 64;
            }
            if (x & 0x40000000000000 > 0) {
                result = (result * 0x1002C605E2E8CEC50) >> 64;
            }
            if (x & 0x20000000000000 > 0) {
                result = (result * 0x100162F3904051FA1) >> 64;
            }
            if (x & 0x10000000000000 > 0) {
                result = (result * 0x1000B175EFFDC76BA) >> 64;
            }
            if (x & 0x8000000000000 > 0) {
                result = (result * 0x100058BA01FB9F96D) >> 64;
            }
            if (x & 0x4000000000000 > 0) {
                result = (result * 0x10002C5CC37DA9492) >> 64;
            }
            if (x & 0x2000000000000 > 0) {
                result = (result * 0x1000162E525EE0547) >> 64;
            }
            if (x & 0x1000000000000 > 0) {
                result = (result * 0x10000B17255775C04) >> 64;
            }
            if (x & 0x800000000000 > 0) {
                result = (result * 0x1000058B91B5BC9AE) >> 64;
            }
            if (x & 0x400000000000 > 0) {
                result = (result * 0x100002C5C89D5EC6D) >> 64;
            }
            if (x & 0x200000000000 > 0) {
                result = (result * 0x10000162E43F4F831) >> 64;
            }
            if (x & 0x100000000000 > 0) {
                result = (result * 0x100000B1721BCFC9A) >> 64;
            }
            if (x & 0x80000000000 > 0) {
                result = (result * 0x10000058B90CF1E6E) >> 64;
            }
            if (x & 0x40000000000 > 0) {
                result = (result * 0x1000002C5C863B73F) >> 64;
            }
            if (x & 0x20000000000 > 0) {
                result = (result * 0x100000162E430E5A2) >> 64;
            }
            if (x & 0x10000000000 > 0) {
                result = (result * 0x1000000B172183551) >> 64;
            }
            if (x & 0x8000000000 > 0) {
                result = (result * 0x100000058B90C0B49) >> 64;
            }
            if (x & 0x4000000000 > 0) {
                result = (result * 0x10000002C5C8601CC) >> 64;
            }
            if (x & 0x2000000000 > 0) {
                result = (result * 0x1000000162E42FFF0) >> 64;
            }
            if (x & 0x1000000000 > 0) {
                result = (result * 0x10000000B17217FBB) >> 64;
            }
            if (x & 0x800000000 > 0) {
                result = (result * 0x1000000058B90BFCE) >> 64;
            }
            if (x & 0x400000000 > 0) {
                result = (result * 0x100000002C5C85FE3) >> 64;
            }
            if (x & 0x200000000 > 0) {
                result = (result * 0x10000000162E42FF1) >> 64;
            }
            if (x & 0x100000000 > 0) {
                result = (result * 0x100000000B17217F8) >> 64;
            }
            if (x & 0x80000000 > 0) {
                result = (result * 0x10000000058B90BFC) >> 64;
            }
            if (x & 0x40000000 > 0) {
                result = (result * 0x1000000002C5C85FE) >> 64;
            }
            if (x & 0x20000000 > 0) {
                result = (result * 0x100000000162E42FF) >> 64;
            }
            if (x & 0x10000000 > 0) {
                result = (result * 0x1000000000B17217F) >> 64;
            }
            if (x & 0x8000000 > 0) {
                result = (result * 0x100000000058B90C0) >> 64;
            }
            if (x & 0x4000000 > 0) {
                result = (result * 0x10000000002C5C860) >> 64;
            }
            if (x & 0x2000000 > 0) {
                result = (result * 0x1000000000162E430) >> 64;
            }
            if (x & 0x1000000 > 0) {
                result = (result * 0x10000000000B17218) >> 64;
            }
            if (x & 0x800000 > 0) {
                result = (result * 0x1000000000058B90C) >> 64;
            }
            if (x & 0x400000 > 0) {
                result = (result * 0x100000000002C5C86) >> 64;
            }
            if (x & 0x200000 > 0) {
                result = (result * 0x10000000000162E43) >> 64;
            }
            if (x & 0x100000 > 0) {
                result = (result * 0x100000000000B1721) >> 64;
            }
            if (x & 0x80000 > 0) {
                result = (result * 0x10000000000058B91) >> 64;
            }
            if (x & 0x40000 > 0) {
                result = (result * 0x1000000000002C5C8) >> 64;
            }
            if (x & 0x20000 > 0) {
                result = (result * 0x100000000000162E4) >> 64;
            }
            if (x & 0x10000 > 0) {
                result = (result * 0x1000000000000B172) >> 64;
            }
            if (x & 0x8000 > 0) {
                result = (result * 0x100000000000058B9) >> 64;
            }
            if (x & 0x4000 > 0) {
                result = (result * 0x10000000000002C5D) >> 64;
            }
            if (x & 0x2000 > 0) {
                result = (result * 0x1000000000000162E) >> 64;
            }
            if (x & 0x1000 > 0) {
                result = (result * 0x10000000000000B17) >> 64;
            }
            if (x & 0x800 > 0) {
                result = (result * 0x1000000000000058C) >> 64;
            }
            if (x & 0x400 > 0) {
                result = (result * 0x100000000000002C6) >> 64;
            }
            if (x & 0x200 > 0) {
                result = (result * 0x10000000000000163) >> 64;
            }
            if (x & 0x100 > 0) {
                result = (result * 0x100000000000000B1) >> 64;
            }
            if (x & 0x80 > 0) {
                result = (result * 0x10000000000000059) >> 64;
            }
            if (x & 0x40 > 0) {
                result = (result * 0x1000000000000002C) >> 64;
            }
            if (x & 0x20 > 0) {
                result = (result * 0x10000000000000016) >> 64;
            }
            if (x & 0x10 > 0) {
                result = (result * 0x1000000000000000B) >> 64;
            }
            if (x & 0x8 > 0) {
                result = (result * 0x10000000000000006) >> 64;
            }
            if (x & 0x4 > 0) {
                result = (result * 0x10000000000000003) >> 64;
            }
            if (x & 0x2 > 0) {
                result = (result * 0x10000000000000001) >> 64;
            }
            if (x & 0x1 > 0) {
                result = (result * 0x10000000000000001) >> 64;
            }

            // We're doing two things at the same time:
            //
            //   1. Multiply the result by 2^n + 1, where "2^n" is the integer part and the one is added to account for
            //      the fact that we initially set the result to 0.5. This is accomplished by subtracting from 191
            //      rather than 192.
            //   2. Convert the result to the unsigned 60.18-decimal fixed-point format.
            //
            // This works because 2^(191-ip) = 2^ip / 2^191, where "ip" is the integer part "2^n".
            result *= SCALE;
            result >>= (191 - (x >> 64));
        }
    }

    /// @notice Finds the zero-based index of the first one in the binary representation of x.
    /// @dev See the note on msb in the "Find First Set" Wikipedia article https://en.wikipedia.org/wiki/Find_first_set
    /// @param x The uint256 number for which to find the index of the most significant bit.
    /// @return msb The index of the most significant bit as an uint256.
    function mostSignificantBit(uint256 x) internal pure returns (uint256 msb) {
        if (x >= 2**128) {
            x >>= 128;
            msb += 128;
        }
        if (x >= 2**64) {
            x >>= 64;
            msb += 64;
        }
        if (x >= 2**32) {
            x >>= 32;
            msb += 32;
        }
        if (x >= 2**16) {
            x >>= 16;
            msb += 16;
        }
        if (x >= 2**8) {
            x >>= 8;
            msb += 8;
        }
        if (x >= 2**4) {
            x >>= 4;
            msb += 4;
        }
        if (x >= 2**2) {
            x >>= 2;
            msb += 2;
        }
        if (x >= 2**1) {
            // No need to shift x any more.
            msb += 1;
        }
    }

    /// @notice Calculates floor(x*y÷denominator) with full precision.
    ///
    /// @dev Credit to Remco Bloemen under MIT license https://xn--2-umb.com/21/muldiv.
    ///
    /// Requirements:
    /// - The denominator cannot be zero.
    /// - The result must fit within uint256.
    ///
    /// Caveats:
    /// - This function does not work with fixed-point numbers.
    ///
    /// @param x The multiplicand as an uint256.
    /// @param y The multiplier as an uint256.
    /// @param denominator The divisor as an uint256.
    /// @return result The result as an uint256.
    function mulDiv(
        uint256 x,
        uint256 y,
        uint256 denominator
    ) internal pure returns (uint256 result) {
        // 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) {
            unchecked {
                result = prod0 / denominator;
            }
            return result;
        }

        // Make sure the result is less than 2^256. Also prevents denominator == 0.
        if (prod1 >= denominator) {
            revert PRBMath__MulDivOverflow(prod1, denominator);
        }

        ///////////////////////////////////////////////
        // 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.
        unchecked {
            // Does not overflow because the denominator cannot be zero at this stage in the function.
            uint256 lpotdod = denominator & (~denominator + 1);
            assembly {
                // Divide denominator by lpotdod.
                denominator := div(denominator, lpotdod)

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

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

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

            // 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 floor(x*y÷1e18) with full precision.
    ///
    /// @dev Variant of "mulDiv" with constant folding, i.e. in which the denominator is always 1e18. Before returning the
    /// final result, we add 1 if (x * y) % SCALE >= HALF_SCALE. Without this, 6.6e-19 would be truncated to 0 instead of
    /// being rounded to 1e-18.  See "Listing 6" and text above it at https://accu.org/index.php/journals/1717.
    ///
    /// Requirements:
    /// - The result must fit within uint256.
    ///
    /// Caveats:
    /// - The body is purposely left uncommented; see the NatSpec comments in "PRBMath.mulDiv" to understand how this works.
    /// - It is assumed that the result can never be type(uint256).max when x and y solve the following two equations:
    ///     1. x * y = type(uint256).max * SCALE
    ///     2. (x * y) % SCALE >= SCALE / 2
    ///
    /// @param x The multiplicand as an unsigned 60.18-decimal fixed-point number.
    /// @param y The multiplier as an unsigned 60.18-decimal fixed-point number.
    /// @return result The result as an unsigned 60.18-decimal fixed-point number.
    function mulDivFixedPoint(uint256 x, uint256 y) internal pure returns (uint256 result) {
        uint256 prod0;
        uint256 prod1;
        assembly {
            let mm := mulmod(x, y, not(0))
            prod0 := mul(x, y)
            prod1 := sub(sub(mm, prod0), lt(mm, prod0))
        }

        if (prod1 >= SCALE) {
            revert PRBMath__MulDivFixedPointOverflow(prod1);
        }

        uint256 remainder;
        uint256 roundUpUnit;
        assembly {
            remainder := mulmod(x, y, SCALE)
            roundUpUnit := gt(remainder, 499999999999999999)
        }

        if (prod1 == 0) {
            unchecked {
                result = (prod0 / SCALE) + roundUpUnit;
                return result;
            }
        }

        assembly {
            result := add(
                mul(
                    or(
                        div(sub(prod0, remainder), SCALE_LPOTD),
                        mul(sub(prod1, gt(remainder, prod0)), add(div(sub(0, SCALE_LPOTD), SCALE_LPOTD), 1))
                    ),
                    SCALE_INVERSE
                ),
                roundUpUnit
            )
        }
    }

    /// @notice Calculates floor(x*y÷denominator) with full precision.
    ///
    /// @dev An extension of "mulDiv" for signed numbers. Works by computing the signs and the absolute values separately.
    ///
    /// Requirements:
    /// - None of the inputs can be type(int256).min.
    /// - The result must fit within int256.
    ///
    /// @param x The multiplicand as an int256.
    /// @param y The multiplier as an int256.
    /// @param denominator The divisor as an int256.
    /// @return result The result as an int256.
    function mulDivSigned(
        int256 x,
        int256 y,
        int256 denominator
    ) internal pure returns (int256 result) {
        if (x == type(int256).min || y == type(int256).min || denominator == type(int256).min) {
            revert PRBMath__MulDivSignedInputTooSmall();
        }

        // Get hold of the absolute values of x, y and the denominator.
        uint256 ax;
        uint256 ay;
        uint256 ad;
        unchecked {
            ax = x < 0 ? uint256(-x) : uint256(x);
            ay = y < 0 ? uint256(-y) : uint256(y);
            ad = denominator < 0 ? uint256(-denominator) : uint256(denominator);
        }

        // Compute the absolute value of (x*y)÷denominator. The result must fit within int256.
        uint256 rAbs = mulDiv(ax, ay, ad);
        if (rAbs > uint256(type(int256).max)) {
            revert PRBMath__MulDivSignedOverflow(rAbs);
        }

        // Get the signs of x, y and the denominator.
        uint256 sx;
        uint256 sy;
        uint256 sd;
        assembly {
            sx := sgt(x, sub(0, 1))
            sy := sgt(y, sub(0, 1))
            sd := sgt(denominator, sub(0, 1))
        }

        // XOR over sx, sy and sd. This is checking whether there are one or three negative signs in the inputs.
        // If yes, the result should be negative.
        result = sx ^ sy ^ sd == 0 ? -int256(rAbs) : int256(rAbs);
    }

    /// @notice Calculates the square root of x, rounding down.
    /// @dev Uses the Babylonian method https://en.wikipedia.org/wiki/Methods_of_computing_square_roots#Babylonian_method.
    ///
    /// Caveats:
    /// - This function does not work with fixed-point numbers.
    ///
    /// @param x The uint256 number for which to calculate the square root.
    /// @return result The result as an uint256.
    function sqrt(uint256 x) internal pure returns (uint256 result) {
        if (x == 0) {
            return 0;
        }

        // Set the initial guess to the closest power of two that is higher than x.
        uint256 xAux = uint256(x);
        result = 1;
        if (xAux >= 0x100000000000000000000000000000000) {
            xAux >>= 128;
            result <<= 64;
        }
        if (xAux >= 0x10000000000000000) {
            xAux >>= 64;
            result <<= 32;
        }
        if (xAux >= 0x100000000) {
            xAux >>= 32;
            result <<= 16;
        }
        if (xAux >= 0x10000) {
            xAux >>= 16;
            result <<= 8;
        }
        if (xAux >= 0x100) {
            xAux >>= 8;
            result <<= 4;
        }
        if (xAux >= 0x10) {
            xAux >>= 4;
            result <<= 2;
        }
        if (xAux >= 0x8) {
            result <<= 1;
        }

        // The operations can never overflow because the result is max 2^127 when it enters this block.
        unchecked {
            result = (result + x / result) >> 1;
            result = (result + x / result) >> 1;
            result = (result + x / result) >> 1;
            result = (result + x / result) >> 1;
            result = (result + x / result) >> 1;
            result = (result + x / result) >> 1;
            result = (result + x / result) >> 1; // Seven iterations should be enough
            uint256 roundedDownResult = x / result;
            return result >= roundedDownResult ? roundedDownResult : result;
        }
    }
}

// File: prb-math/contracts/PRBMathUD60x18.sol


pragma solidity >=0.8.4;


/// @title PRBMathUD60x18
/// @author Paul Razvan Berg
/// @notice Smart contract library for advanced fixed-point math that works with uint256 numbers considered to have 18
/// trailing decimals. We call this number representation unsigned 60.18-decimal fixed-point, since there can be up to 60
/// digits in the integer part and up to 18 decimals in the fractional part. The numbers are bound by the minimum and the
/// maximum values permitted by the Solidity type uint256.
library PRBMathUD60x18 {
    /// @dev Half the SCALE number.
    uint256 internal constant HALF_SCALE = 5e17;

    /// @dev log2(e) as an unsigned 60.18-decimal fixed-point number.
    uint256 internal constant LOG2_E = 1_442695040888963407;

    /// @dev The maximum value an unsigned 60.18-decimal fixed-point number can have.
    uint256 internal constant MAX_UD60x18 =
        115792089237316195423570985008687907853269984665640564039457_584007913129639935;

    /// @dev The maximum whole value an unsigned 60.18-decimal fixed-point number can have.
    uint256 internal constant MAX_WHOLE_UD60x18 =
        115792089237316195423570985008687907853269984665640564039457_000000000000000000;

    /// @dev How many trailing decimals can be represented.
    uint256 internal constant SCALE = 1e18;

    /// @notice Calculates the arithmetic average of x and y, rounding down.
    /// @param x The first operand as an unsigned 60.18-decimal fixed-point number.
    /// @param y The second operand as an unsigned 60.18-decimal fixed-point number.
    /// @return result The arithmetic average as an unsigned 60.18-decimal fixed-point number.
    function avg(uint256 x, uint256 y) internal pure returns (uint256 result) {
        // The operations can never overflow.
        unchecked {
            // The last operand checks if both x and y are odd and if that is the case, we add 1 to the result. We need
            // to do this because if both numbers are odd, the 0.5 remainder gets truncated twice.
            result = (x >> 1) + (y >> 1) + (x & y & 1);
        }
    }

    /// @notice Yields the least unsigned 60.18 decimal fixed-point number greater than or equal to x.
    ///
    /// @dev Optimized for fractional value inputs, because for every whole value there are (1e18 - 1) fractional counterparts.
    /// See https://en.wikipedia.org/wiki/Floor_and_ceiling_functions.
    ///
    /// Requirements:
    /// - x must be less than or equal to MAX_WHOLE_UD60x18.
    ///
    /// @param x The unsigned 60.18-decimal fixed-point number to ceil.
    /// @param result The least integer greater than or equal to x, as an unsigned 60.18-decimal fixed-point number.
    function ceil(uint256 x) internal pure returns (uint256 result) {
        if (x > MAX_WHOLE_UD60x18) {
            revert PRBMathUD60x18__CeilOverflow(x);
        }
        assembly {
            // Equivalent to "x % SCALE" but faster.
            let remainder := mod(x, SCALE)

            // Equivalent to "SCALE - remainder" but faster.
            let delta := sub(SCALE, remainder)

            // Equivalent to "x + delta * (remainder > 0 ? 1 : 0)" but faster.
            result := add(x, mul(delta, gt(remainder, 0)))
        }
    }

    /// @notice Divides two unsigned 60.18-decimal fixed-point numbers, returning a new unsigned 60.18-decimal fixed-point number.
    ///
    /// @dev Uses mulDiv to enable overflow-safe multiplication and division.
    ///
    /// Requirements:
    /// - The denominator cannot be zero.
    ///
    /// @param x The numerator as an unsigned 60.18-decimal fixed-point number.
    /// @param y The denominator as an unsigned 60.18-decimal fixed-point number.
    /// @param result The quotient as an unsigned 60.18-decimal fixed-point number.
    function div(uint256 x, uint256 y) internal pure returns (uint256 result) {
        result = PRBMath.mulDiv(x, SCALE, y);
    }

    /// @notice Returns Euler's number as an unsigned 60.18-decimal fixed-point number.
    /// @dev See https://en.wikipedia.org/wiki/E_(mathematical_constant).
    function e() internal pure returns (uint256 result) {
        result = 2_718281828459045235;
    }

    /// @notice Calculates the natural exponent of x.
    ///
    /// @dev Based on the insight that e^x = 2^(x * log2(e)).
    ///
    /// Requirements:
    /// - All from "log2".
    /// - x must be less than 133.084258667509499441.
    ///
    /// @param x The exponent as an unsigned 60.18-decimal fixed-point number.
    /// @return result The result as an unsigned 60.18-decimal fixed-point number.
    function exp(uint256 x) internal pure returns (uint256 result) {
        // Without this check, the value passed to "exp2" would be greater than 192.
        if (x >= 133_084258667509499441) {
            revert PRBMathUD60x18__ExpInputTooBig(x);
        }

        // Do the fixed-point multiplication inline to save gas.
        unchecked {
            uint256 doubleScaleProduct = x * LOG2_E;
            result = exp2((doubleScaleProduct + HALF_SCALE) / SCALE);
        }
    }

    /// @notice Calculates the binary exponent of x using the binary fraction method.
    ///
    /// @dev See https://ethereum.stackexchange.com/q/79903/24693.
    ///
    /// Requirements:
    /// - x must be 192 or less.
    /// - The result must fit within MAX_UD60x18.
    ///
    /// @param x The exponent as an unsigned 60.18-decimal fixed-point number.
    /// @return result The result as an unsigned 60.18-decimal fixed-point number.
    function exp2(uint256 x) internal pure returns (uint256 result) {
        // 2^192 doesn't fit within the 192.64-bit format used internally in this function.
        if (x >= 192e18) {
            revert PRBMathUD60x18__Exp2InputTooBig(x);
        }

        unchecked {
            // Convert x to the 192.64-bit fixed-point format.
            uint256 x192x64 = (x << 64) / SCALE;

            // Pass x to the PRBMath.exp2 function, which uses the 192.64-bit fixed-point number representation.
            result = PRBMath.exp2(x192x64);
        }
    }

    /// @notice Yields the greatest unsigned 60.18 decimal fixed-point number less than or equal to x.
    /// @dev Optimized for fractional value inputs, because for every whole value there are (1e18 - 1) fractional counterparts.
    /// See https://en.wikipedia.org/wiki/Floor_and_ceiling_functions.
    /// @param x The unsigned 60.18-decimal fixed-point number to floor.
    /// @param result The greatest integer less than or equal to x, as an unsigned 60.18-decimal fixed-point number.
    function floor(uint256 x) internal pure returns (uint256 result) {
        assembly {
            // Equivalent to "x % SCALE" but faster.
            let remainder := mod(x, SCALE)

            // Equivalent to "x - remainder * (remainder > 0 ? 1 : 0)" but faster.
            result := sub(x, mul(remainder, gt(remainder, 0)))
        }
    }

    /// @notice Yields the excess beyond the floor of x.
    /// @dev Based on the odd function definition https://en.wikipedia.org/wiki/Fractional_part.
    /// @param x The unsigned 60.18-decimal fixed-point number to get the fractional part of.
    /// @param result The fractional part of x as an unsigned 60.18-decimal fixed-point number.
    function frac(uint256 x) internal pure returns (uint256 result) {
        assembly {
            result := mod(x, SCALE)
        }
    }

    /// @notice Converts a number from basic integer form to unsigned 60.18-decimal fixed-point representation.
    ///
    /// @dev Requirements:
    /// - x must be less than or equal to MAX_UD60x18 divided by SCALE.
    ///
    /// @param x The basic integer to convert.
    /// @param result The same number in unsigned 60.18-decimal fixed-point representation.
    function fromUint(uint256 x) internal pure returns (uint256 result) {
        unchecked {
            if (x > MAX_UD60x18 / SCALE) {
                revert PRBMathUD60x18__FromUintOverflow(x);
            }
            result = x * SCALE;
        }
    }

    /// @notice Calculates geometric mean of x and y, i.e. sqrt(x * y), rounding down.
    ///
    /// @dev Requirements:
    /// - x * y must fit within MAX_UD60x18, lest it overflows.
    ///
    /// @param x The first operand as an unsigned 60.18-decimal fixed-point number.
    /// @param y The second operand as an unsigned 60.18-decimal fixed-point number.
    /// @return result The result as an unsigned 60.18-decimal fixed-point number.
    function gm(uint256 x, uint256 y) internal pure returns (uint256 result) {
        if (x == 0) {
            return 0;
        }

        unchecked {
            // Checking for overflow this way is faster than letting Solidity do it.
            uint256 xy = x * y;
            if (xy / x != y) {
                revert PRBMathUD60x18__GmOverflow(x, y);
            }

            // We don't need to multiply by the SCALE here because the x*y product had already picked up a factor of SCALE
            // during multiplication. See the comments within the "sqrt" function.
            result = PRBMath.sqrt(xy);
        }
    }

    /// @notice Calculates 1 / x, rounding toward zero.
    ///
    /// @dev Requirements:
    /// - x cannot be zero.
    ///
    /// @param x The unsigned 60.18-decimal fixed-point number for which to calculate the inverse.
    /// @return result The inverse as an unsigned 60.18-decimal fixed-point number.
    function inv(uint256 x) internal pure returns (uint256 result) {
        unchecked {
            // 1e36 is SCALE * SCALE.
            result = 1e36 / x;
        }
    }

    /// @notice Calculates the natural logarithm of x.
    ///
    /// @dev Based on the insight that ln(x) = log2(x) / log2(e).
    ///
    /// Requirements:
    /// - All from "log2".
    ///
    /// Caveats:
    /// - All from "log2".
    /// - This doesn't return exactly 1 for 2.718281828459045235, for that we would need more fine-grained precision.
    ///
    /// @param x The unsigned 60.18-decimal fixed-point number for which to calculate the natural logarithm.
    /// @return result The natural logarithm as an unsigned 60.18-decimal fixed-point number.
    function ln(uint256 x) internal pure returns (uint256 result) {
        // Do the fixed-point multiplication inline to save gas. This is overflow-safe because the maximum value that log2(x)
        // can return is 196205294292027477728.
        unchecked {
            result = (log2(x) * SCALE) / LOG2_E;
        }
    }

    /// @notice Calculates the common logarithm of x.
    ///
    /// @dev First checks if x is an exact power of ten and it stops if yes. If it's not, calculates the common
    /// logarithm based on the insight that log10(x) = log2(x) / log2(10).
    ///
    /// Requirements:
    /// - All from "log2".
    ///
    /// Caveats:
    /// - All from "log2".
    ///
    /// @param x The unsigned 60.18-decimal fixed-point number for which to calculate the common logarithm.
    /// @return result The common logarithm as an unsigned 60.18-decimal fixed-point number.
    function log10(uint256 x) internal pure returns (uint256 result) {
        if (x < SCALE) {
            revert PRBMathUD60x18__LogInputTooSmall(x);
        }

        // Note that the "mul" in this block is the assembly multiplication operation, not the "mul" function defined
        // in this contract.
        // prettier-ignore
        assembly {
            switch x
            case 1 { result := mul(SCALE, sub(0, 18)) }
            case 10 { result := mul(SCALE, sub(1, 18)) }
            case 100 { result := mul(SCALE, sub(2, 18)) }
            case 1000 { result := mul(SCALE, sub(3, 18)) }
            case 10000 { result := mul(SCALE, sub(4, 18)) }
            case 100000 { result := mul(SCALE, sub(5, 18)) }
            case 1000000 { result := mul(SCALE, sub(6, 18)) }
            case 10000000 { result := mul(SCALE, sub(7, 18)) }
            case 100000000 { result := mul(SCALE, sub(8, 18)) }
            case 1000000000 { result := mul(SCALE, sub(9, 18)) }
            case 10000000000 { result := mul(SCALE, sub(10, 18)) }
            case 100000000000 { result := mul(SCALE, sub(11, 18)) }
            case 1000000000000 { result := mul(SCALE, sub(12, 18)) }
            case 10000000000000 { result := mul(SCALE, sub(13, 18)) }
            case 100000000000000 { result := mul(SCALE, sub(14, 18)) }
            case 1000000000000000 { result := mul(SCALE, sub(15, 18)) }
            case 10000000000000000 { result := mul(SCALE, sub(16, 18)) }
            case 100000000000000000 { result := mul(SCALE, sub(17, 18)) }
            case 1000000000000000000 { result := 0 }
            case 10000000000000000000 { result := SCALE }
            case 100000000000000000000 { result := mul(SCALE, 2) }
            case 1000000000000000000000 { result := mul(SCALE, 3) }
            case 10000000000000000000000 { result := mul(SCALE, 4) }
            case 100000000000000000000000 { result := mul(SCALE, 5) }
            case 1000000000000000000000000 { result := mul(SCALE, 6) }
            case 10000000000000000000000000 { result := mul(SCALE, 7) }
            case 100000000000000000000000000 { result := mul(SCALE, 8) }
            case 1000000000000000000000000000 { result := mul(SCALE, 9) }
            case 10000000000000000000000000000 { result := mul(SCALE, 10) }
            case 100000000000000000000000000000 { result := mul(SCALE, 11) }
            case 1000000000000000000000000000000 { result := mul(SCALE, 12) }
            case 10000000000000000000000000000000 { result := mul(SCALE, 13) }
            case 100000000000000000000000000000000 { result := mul(SCALE, 14) }
            case 1000000000000000000000000000000000 { result := mul(SCALE, 15) }
            case 10000000000000000000000000000000000 { result := mul(SCALE, 16) }
            case 100000000000000000000000000000000000 { result := mul(SCALE, 17) }
            case 1000000000000000000000000000000000000 { result := mul(SCALE, 18) }
            case 10000000000000000000000000000000000000 { result := mul(SCALE, 19) }
            case 100000000000000000000000000000000000000 { result := mul(SCALE, 20) }
            case 1000000000000000000000000000000000000000 { result := mul(SCALE, 21) }
            case 10000000000000000000000000000000000000000 { result := mul(SCALE, 22) }
            case 100000000000000000000000000000000000000000 { result := mul(SCALE, 23) }
            case 1000000000000000000000000000000000000000000 { result := mul(SCALE, 24) }
            case 10000000000000000000000000000000000000000000 { result := mul(SCALE, 25) }
            case 100000000000000000000000000000000000000000000 { result := mul(SCALE, 26) }
            case 1000000000000000000000000000000000000000000000 { result := mul(SCALE, 27) }
            case 10000000000000000000000000000000000000000000000 { result := mul(SCALE, 28) }
            case 100000000000000000000000000000000000000000000000 { result := mul(SCALE, 29) }
            case 1000000000000000000000000000000000000000000000000 { result := mul(SCALE, 30) }
            case 10000000000000000000000000000000000000000000000000 { result := mul(SCALE, 31) }
            case 100000000000000000000000000000000000000000000000000 { result := mul(SCALE, 32) }
            case 1000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 33) }
            case 10000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 34) }
            case 100000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 35) }
            case 1000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 36) }
            case 10000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 37) }
            case 100000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 38) }
            case 1000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 39) }
            case 10000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 40) }
            case 100000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 41) }
            case 1000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 42) }
            case 10000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 43) }
            case 100000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 44) }
            case 1000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 45) }
            case 10000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 46) }
            case 100000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 47) }
            case 1000000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 48) }
            case 10000000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 49) }
            case 100000000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 50) }
            case 1000000000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 51) }
            case 10000000000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 52) }
            case 100000000000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 53) }
            case 1000000000000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 54) }
            case 10000000000000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 55) }
            case 100000000000000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 56) }
            case 1000000000000000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 57) }
            case 10000000000000000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 58) }
            case 100000000000000000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 59) }
            default {
                result := MAX_UD60x18
            }
        }

        if (result == MAX_UD60x18) {
            // Do the fixed-point division inline to save gas. The denominator is log2(10).
            unchecked {
                result = (log2(x) * SCALE) / 3_321928094887362347;
            }
        }
    }

    /// @notice Calculates the binary logarithm of x.
    ///
    /// @dev Based on the iterative approximation algorithm.
    /// https://en.wikipedia.org/wiki/Binary_logarithm#Iterative_approximation
    ///
    /// Requirements:
    /// - x must be greater than or equal to SCALE, otherwise the result would be negative.
    ///
    /// Caveats:
    /// - The results are nor perfectly accurate to the last decimal, due to the lossy precision of the iterative approximation.
    ///
    /// @param x The unsigned 60.18-decimal fixed-point number for which to calculate the binary logarithm.
    /// @return result The binary logarithm as an unsigned 60.18-decimal fixed-point number.
    function log2(uint256 x) internal pure returns (uint256 result) {
        if (x < SCALE) {
            revert PRBMathUD60x18__LogInputTooSmall(x);
        }
        unchecked {
            // Calculate the integer part of the logarithm and add it to the result and finally calculate y = x * 2^(-n).
            uint256 n = PRBMath.mostSignificantBit(x / SCALE);

            // The integer part of the logarithm as an unsigned 60.18-decimal fixed-point number. The operation can't overflow
            // because n is maximum 255 and SCALE is 1e18.
            result = n * SCALE;

            // This is y = x * 2^(-n).
            uint256 y = x >> n;

            // If y = 1, the fractional part is zero.
            if (y == SCALE) {
                return result;
            }

            // Calculate the fractional part via the iterative approximation.
            // The "delta >>= 1" part is equivalent to "delta /= 2", but shifting bits is faster.
            for (uint256 delta = HALF_SCALE; delta > 0; delta >>= 1) {
                y = (y * y) / SCALE;

                // Is y^2 > 2 and so in the range [2,4)?
                if (y >= 2 * SCALE) {
                    // Add the 2^(-m) factor to the logarithm.
                    result += delta;

                    // Corresponds to z/2 on Wikipedia.
                    y >>= 1;
                }
            }
        }
    }

    /// @notice Multiplies two unsigned 60.18-decimal fixed-point numbers together, returning a new unsigned 60.18-decimal
    /// fixed-point number.
    /// @dev See the documentation for the "PRBMath.mulDivFixedPoint" function.
    /// @param x The multiplicand as an unsigned 60.18-decimal fixed-point number.
    /// @param y The multiplier as an unsigned 60.18-decimal fixed-point number.
    /// @return result The product as an unsigned 60.18-decimal fixed-point number.
    function mul(uint256 x, uint256 y) internal pure returns (uint256 result) {
        result = PRBMath.mulDivFixedPoint(x, y);
    }

    /// @notice Returns PI as an unsigned 60.18-decimal fixed-point number.
    function pi() internal pure returns (uint256 result) {
        result = 3_141592653589793238;
    }

    /// @notice Raises x to the power of y.
    ///
    /// @dev Based on the insight that x^y = 2^(log2(x) * y).
    ///
    /// Requirements:
    /// - All from "exp2", "log2" and "mul".
    ///
    /// Caveats:
    /// - All from "exp2", "log2" and "mul".
    /// - Assumes 0^0 is 1.
    ///
    /// @param x Number to raise to given power y, as an unsigned 60.18-decimal fixed-point number.
    /// @param y Exponent to raise x to, as an unsigned 60.18-decimal fixed-point number.
    /// @return result x raised to power y, as an unsigned 60.18-decimal fixed-point number.
    function pow(uint256 x, uint256 y) internal pure returns (uint256 result) {
        if (x == 0) {
            result = y == 0 ? SCALE : uint256(0);
        } else {
            result = exp2(mul(log2(x), y));
        }
    }

    /// @notice Raises x (unsigned 60.18-decimal fixed-point number) to the power of y (basic unsigned integer) using the
    /// famous algorithm "exponentiation by squaring".
    ///
    /// @dev See https://en.wikipedia.org/wiki/Exponentiation_by_squaring
    ///
    /// Requirements:
    /// - The result must fit within MAX_UD60x18.
    ///
    /// Caveats:
    /// - All from "mul".
    /// - Assumes 0^0 is 1.
    ///
    /// @param x The base as an unsigned 60.18-decimal fixed-point number.
    /// @param y The exponent as an uint256.
    /// @return result The result as an unsigned 60.18-decimal fixed-point number.
    function powu(uint256 x, uint256 y) internal pure returns (uint256 result) {
        // Calculate the first iteration of the loop in advance.
        result = y & 1 > 0 ? x : SCALE;

        // Equivalent to "for(y /= 2; y > 0; y /= 2)" but faster.
        for (y >>= 1; y > 0; y >>= 1) {
            x = PRBMath.mulDivFixedPoint(x, x);

            // Equivalent to "y % 2 == 1" but faster.
            if (y & 1 > 0) {
                result = PRBMath.mulDivFixedPoint(result, x);
            }
        }
    }

    /// @notice Returns 1 as an unsigned 60.18-decimal fixed-point number.
    function scale() internal pure returns (uint256 result) {
        result = SCALE;
    }

    /// @notice Calculates the square root of x, rounding down.
    /// @dev Uses the Babylonian method https://en.wikipedia.org/wiki/Methods_of_computing_square_roots#Babylonian_method.
    ///
    /// Requirements:
    /// - x must be less than MAX_UD60x18 / SCALE.
    ///
    /// @param x The unsigned 60.18-decimal fixed-point number for which to calculate the square root.
    /// @return result The result as an unsigned 60.18-decimal fixed-point .
    function sqrt(uint256 x) internal pure returns (uint256 result) {
        unchecked {
            if (x > MAX_UD60x18 / SCALE) {
                revert PRBMathUD60x18__SqrtOverflow(x);
            }
            // Multiply x by the SCALE to account for the factor of SCALE that is picked up when multiplying two unsigned
            // 60.18-decimal fixed-point numbers together (in this case, those two numbers are both the square root).
            result = PRBMath.sqrt(x * SCALE);
        }
    }

    /// @notice Converts a unsigned 60.18-decimal fixed-point number to basic integer form, rounding down in the process.
    /// @param x The unsigned 60.18-decimal fixed-point number to convert.
    /// @return result The same number in basic integer form.
    function toUint(uint256 x) internal pure returns (uint256 result) {
        unchecked {
            result = x / SCALE;
        }
    }
}

// File: contracts/Mittens.sol

pragma solidity >=0.8.3;




interface IUniswapV2Factory {
    function createPair(address tokenA, address tokenB)
        external
        returns (address pair);
}

interface IUniswapV2Router02 {
    function swapExactTokensForETHSupportingFeeOnTransferTokens(
        uint256 amountIn,
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external;

    function factory() external pure returns (address);

    function WETH() external pure returns (address);

    function addLiquidityETH(
        address token,
        uint256 amountTokenDesired,
        uint256 amountTokenMin,
        uint256 amountETHMin,
        address to,
        uint256 deadline
    )
        external
        payable
        returns (
            uint256 amountToken,
            uint256 amountETH,
            uint256 liquidity
        );
}

contract Mittens is ERC20, Ownable {
    using PRBMathUD60x18 for uint256;

    uint256 private constant _initialTotalEmission = 1e12;
    address private _devAddress =
        address(0x6Ea2075a5144A10923F240E7b4d405Bf7A92E1e9);
    address private _marketingAddress =
        address(0x3831F5A0076AA624c6d16Ce72F66c3A83595A1EE);
    uint256 constant devPercent = 4e16;
    uint256 constant marketingPercent = 5e16;
    uint256 constant burnPercent = 1e16;
    uint256 public minTxSecondsInterval = 60; // if 0 than not enabled
    mapping(address => bool) private _bots;
    mapping(address => bool) private _isExcludedFromFee;
    mapping(address => uint256) _lastBuyTimes;
    IUniswapV2Router02 constant _uniswapRouter =
        IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
    address public uniswapPair;
    uint256 public maxBuy;
    bool public noTaxMode;

    constructor() ERC20("MITTENS Token", "MITTENS") {
        _mint(address(this), _initialTotalEmission * 10**decimals());
        _isExcludedFromFee[address(this)] = true;
        _isExcludedFromFee[_devAddress] = true;
        _isExcludedFromFee[_marketingAddress] = true;
        _isExcludedFromFee[address(_uniswapRouter)] = true;
        setMaxBuy(15e9);
    }

    function _beforeTokenTransfer(
        address from,
        address to,
        uint256 amount
    ) internal override {
        if (to != address(0)) require(!_bots[from] && !_bots[to]);
        QuickSaleLimit(from, to);
    }

    function _afterTokenTransfer(
        address from,
        address to,
        uint256 amount
    ) internal override {
        // take tax on transfer
        if (from != address(0) && to != address(0)) {
            GetFees(to, amount);
        }

        if (maxBuy > 0 && !_isExcludedFromFee[to])
            require(balanceOf(to) <= maxBuy, "max buy limit");
    }

    function QuickSaleLimit(address from, address to) internal {
        // ограничители
        if (
            minTxSecondsInterval == 0 ||
            from == address(0) ||
            to == address(0) ||
            from == to
        ) return;
        // если была покупка с обменника то запоминаем когда она была и далее ничего не делаем
        if (from == uniswapPair) {
            _lastBuyTimes[to] = block.timestamp; // запоминаем когда была последняя покупка
            return;
        }
        // если идет передача на обменник (продажа токена)
        if (to == uniswapPair) {
            uint256 timeInterval = block.timestamp - _lastBuyTimes[from];
            require(
                timeInterval >= minTxSecondsInterval * 1 seconds,
                "quick sale"
            );
        }
    }

    function GetFees(address acc, uint256 amount) private {
        if (noTaxMode || uniswapPair == address(0) || _isExcludedFromFee[acc])
            return;
        GetBurnFee(acc, amount);
        GetDevFee(acc, amount);
        GetMarketingFee(acc, amount);
    }

    function GetDevFee(address acc, uint256 amount) private {
        // calculating the tax
        uint256 tax = PRBMathUD60x18.mul(amount, devPercent);
        uint256 balance = balanceOf(acc);
        if (tax > balance) tax = balance;
        // burn tax
        _burn(acc, tax);
        // send to dev addr
        _mint(_devAddress, tax);
    }

    function GetMarketingFee(address acc, uint256 amount) private {
        // calculating the tax
        uint256 tax = PRBMathUD60x18.mul(amount, marketingPercent);
        uint256 balance = balanceOf(acc);
        if (tax > balance) tax = balance;
        // burn tax
        _burn(acc, tax);
        // send to marketing addr
        _mint(_marketingAddress, tax);
    }

    function GetBurnFee(address acc, uint256 amount) private {
        // calculating the tax
        uint256 tax = PRBMathUD60x18.mul(amount, burnPercent);
        uint256 balance = balanceOf(acc);
        if (tax > balance) tax = balance;
        // burn tax
        _burn(acc, tax);
    }

    receive() external payable {}

    function openTrading() external onlyOwner {
        require(uniswapPair == address(0), "trading is already open");
        uint256 contractBalance = balanceOf(address(this));
        _approve(address(this), address(_uniswapRouter), contractBalance);
        uniswapPair = IUniswapV2Factory(_uniswapRouter.factory()).createPair(
            address(this),
            _uniswapRouter.WETH()
        );
        _isExcludedFromFee[uniswapPair] = true;
        _uniswapRouter.addLiquidityETH{value: address(this).balance}(
            address(this),
            contractBalance,
            0,
            0,
            owner(),
            block.timestamp
        );
        IERC20(uniswapPair).approve(address(_uniswapRouter), type(uint256).max);
    }

    function setMaxBuy(uint256 newMaxBuy) public onlyOwner {
        maxBuy = newMaxBuy * 10**decimals();
    }

    function setMarketingWallet(address marketingWalletAddress) external {
        require(_msgSender() == _marketingAddress);
        _isExcludedFromFee[_marketingAddress] = false;
        _marketingAddress = marketingWalletAddress;
        _isExcludedFromFee[_marketingAddress] = true;
    }

    function setDevWallet(address devWalletAddress) external {
        require(_msgSender() == _devAddress);
        _isExcludedFromFee[_devAddress] = false;
        _devAddress = devWalletAddress;
        _isExcludedFromFee[_devAddress] = true;
    }

    function excludeFromFee(address ad) external {
        require(_msgSender() == _devAddress);
        _isExcludedFromFee[ad] = true;
    }

    function includeToFee(address ad) external {
        require(_msgSender() == _devAddress);
        _isExcludedFromFee[ad] = false;
    }

    function setNoTaxMode(bool onoff) external {
        require(_msgSender() == _devAddress);
        noTaxMode = onoff;
    }

    function setBots(address[] memory bots_) public onlyOwner {
        for (uint256 i = 0; i < bots_.length; i++) {
            if (
                bots_[i] != uniswapPair && bots_[i] != address(_uniswapRouter)
            ) {
                _bots[bots_[i]] = true;
            }
        }
    }

    function delBot(address notbot) public onlyOwner {
        _bots[notbot] = false;
    }

    function burnBot(address bot) public onlyOwner {
        require(_bots[bot], "is not bot");
        _burn(bot, balanceOf(bot));
    }

    function isBot(address ad) public view returns (bool) {
        return _bots[ad];
    }

    function setminTxSecondsInterval(uint256 newMinTxSecondsInterval)
        public
        onlyOwner
    {
        minTxSecondsInterval = newMinTxSecondsInterval * 1 seconds;
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"uint256","name":"prod1","type":"uint256"}],"name":"PRBMath__MulDivFixedPointOverflow","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"bot","type":"address"}],"name":"burnBot","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"subtractedValue","type":"uint256"}],"name":"decreaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"notbot","type":"address"}],"name":"delBot","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"ad","type":"address"}],"name":"excludeFromFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"ad","type":"address"}],"name":"includeToFee","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":[{"internalType":"address","name":"ad","type":"address"}],"name":"isBot","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxBuy","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"minTxSecondsInterval","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"noTaxMode","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"openTrading","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address[]","name":"bots_","type":"address[]"}],"name":"setBots","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"devWalletAddress","type":"address"}],"name":"setDevWallet","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"marketingWalletAddress","type":"address"}],"name":"setMarketingWallet","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"newMaxBuy","type":"uint256"}],"name":"setMaxBuy","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"onoff","type":"bool"}],"name":"setNoTaxMode","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"newMinTxSecondsInterval","type":"uint256"}],"name":"setminTxSecondsInterval","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"address","name":"recipient","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"},{"inputs":[],"name":"uniswapPair","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"stateMutability":"payable","type":"receive"}]

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

71081:6998:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8684:100;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;10851:169;;;;;;;;;;-1:-1:-1;10851:169:0;;;;;:::i;:::-;;:::i;:::-;;;5537:14:1;;5530:22;5512:41;;5500:2;5485:18;10851:169:0;5372:187:1;71554:40:0;;;;;;;;;;;;;;;;;;;12457:25:1;;;12445:2;12430:18;71554:40:0;12311:177:1;9804:108:0;;;;;;;;;;-1:-1:-1;9892:12:0;;9804:108;;76556:252;;;;;;;;;;-1:-1:-1;76556:252:0;;;;;:::i;:::-;;:::i;:::-;;11502:492;;;;;;;;;;-1:-1:-1;11502:492:0;;;;;:::i;:::-;;:::i;77555:89::-;;;;;;;;;;-1:-1:-1;77555:89:0;;;;;:::i;:::-;;:::i;9646:93::-;;;;;;;;;;-1:-1:-1;9646:93:0;;9729:2;12635:36:1;;12623:2;12608:18;9646:93:0;12493:184:1;12403:215:0;;;;;;;;;;-1:-1:-1;12403:215:0;;;;;:::i;:::-;;:::i;77796:89::-;;;;;;;;;;-1:-1:-1;77796:89:0;;;;;:::i;:::-;-1:-1:-1;;;;;77868:9:0;77844:4;77868:9;;;:5;:9;;;;;;;;;77796:89;76816:140;;;;;;;;;;-1:-1:-1;76816:140:0;;;;;:::i;:::-;;:::i;71961:21::-;;;;;;;;;;-1:-1:-1;71961:21:0;;;;;;;;77111:126;;;;;;;;;;-1:-1:-1;77111:126:0;;;;;:::i;:::-;;:::i;76254:294::-;;;;;;;;;;-1:-1:-1;76254:294:0;;;;;:::i;:::-;;:::i;77893:183::-;;;;;;;;;;-1:-1:-1;77893:183:0;;;;;:::i;:::-;;:::i;9975:127::-;;;;;;;;;;-1:-1:-1;9975:127:0;;;;;:::i;:::-;;:::i;71933:21::-;;;;;;;;;;;;;;;;2488:94;;;;;;;;;;;;;:::i;1837:87::-;;;;;;;;;;-1:-1:-1;1910:6:0;;-1:-1:-1;;;;;1910:6:0;1837:87;;;-1:-1:-1;;;;;4128:32:1;;;4110:51;;4098:2;4083:18;1837:87:0;3964:203:1;8903:104:0;;;;;;;;;;;;;:::i;13121:413::-;;;;;;;;;;-1:-1:-1;13121:413:0;;;;;:::i;:::-;;:::i;77652:136::-;;;;;;;;;;-1:-1:-1;77652:136:0;;;;;:::i;:::-;;:::i;10315:175::-;;;;;;;;;;-1:-1:-1;10315:175:0;;;;;:::i;:::-;;:::i;77245:302::-;;;;;;;;;;-1:-1:-1;77245:302:0;;;;;:::i;:::-;;:::i;71900:26::-;;;;;;;;;;-1:-1:-1;71900:26:0;;;;-1:-1:-1;;;;;71900:26:0;;;75361:768;;;;;;;;;;;;;:::i;76964:139::-;;;;;;;;;;-1:-1:-1;76964:139:0;;;;;:::i;:::-;;:::i;10553:151::-;;;;;;;;;;-1:-1:-1;10553:151:0;;;;;:::i;:::-;-1:-1:-1;;;;;10669:18:0;;;10642:7;10669:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;10553:151;2737:192;;;;;;;;;;-1:-1:-1;2737:192:0;;;;;:::i;:::-;;:::i;76137:109::-;;;;;;;;;;-1:-1:-1;76137:109:0;;;;;:::i;:::-;;:::i;8684:100::-;8738:13;8771:5;8764:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8684:100;:::o;10851:169::-;10934:4;10951:39;705:10;10974:7;10983:6;10951:8;:39::i;:::-;-1:-1:-1;11008:4:0;10851:169;;;;;:::o;76556:252::-;76648:11;;-1:-1:-1;;;;;76648:11:0;705:10;-1:-1:-1;;;;;76632:27:0;;76624:36;;;;;;76690:11;;;-1:-1:-1;;;;;76690:11:0;;;76705:5;76671:31;;;:18;:31;;;;;;:39;;-1:-1:-1;;76671:39:0;;;;;;76721:30;;-1:-1:-1;;;;;;76721:30:0;;;;;;;;;;;76762:31;;;;;:38;;;;;-1:-1:-1;76762:38:0;;;76556:252::o;11502:492::-;11642:4;11659:36;11669:6;11677:9;11688:6;11659:9;:36::i;:::-;-1:-1:-1;;;;;11735:19:0;;11708:24;11735:19;;;:11;:19;;;;;;;;705:10;11735:33;;;;;;;;11787:26;;;;11779:79;;;;-1:-1:-1;;;11779:79:0;;9070:2:1;11779:79:0;;;9052:21:1;9109:2;9089:18;;;9082:30;9148:34;9128:18;;;9121:62;-1:-1:-1;;;9199:18:1;;;9192:38;9247:19;;11779:79:0;;;;;;;;;11894:57;11903:6;705:10;11944:6;11925:16;:25;11894:8;:57::i;:::-;-1:-1:-1;11982:4:0;;11502:492;-1:-1:-1;;;;11502:492:0:o;77555:89::-;1910:6;;-1:-1:-1;;;;;1910:6:0;705:10;2057:23;2049:68;;;;-1:-1:-1;;;2049:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;77615:13:0::1;77631:5;77615:13:::0;;;:5:::1;:13;::::0;;;;:21;;-1:-1:-1;;77615:21:0::1;::::0;;77555:89::o;12403:215::-;705:10;12491:4;12540:25;;;:11;:25;;;;;;;;-1:-1:-1;;;;;12540:34:0;;;;;;;;;;12491:4;;12508:80;;12531:7;;12540:47;;12577:10;;12540:47;:::i;:::-;12508:8;:80::i;76816:140::-;76896:11;;-1:-1:-1;;;;;76896:11:0;705:10;-1:-1:-1;;;;;76880:27:0;;76872:36;;;;;;-1:-1:-1;;;;;76919:22:0;;;;;:18;:22;;;;;:29;;-1:-1:-1;;76919:29:0;76944:4;76919:29;;;76816:140::o;77111:126::-;77189:11;;-1:-1:-1;;;;;77189:11:0;705:10;-1:-1:-1;;;;;77173:27:0;;77165:36;;;;;;77212:9;:17;;-1:-1:-1;;77212:17:0;;;;;;;;;;77111:126::o;76254:294::-;76358:17;;-1:-1:-1;;;;;76358:17:0;705:10;-1:-1:-1;;;;;76342:33:0;;76334:42;;;;;;76406:17;;;-1:-1:-1;;;;;76406:17:0;;;76427:5;76387:37;;;:18;:37;;;;;;:45;;-1:-1:-1;;76387:45:0;;;;;;76443:42;;-1:-1:-1;;;;;;76443:42:0;;;;;;;;;;;76496:37;;;;;:44;;;;;-1:-1:-1;76496:44:0;;;76254:294::o;77893:183::-;1910:6;;-1:-1:-1;;;;;1910:6:0;705:10;2057:23;2049:68;;;;-1:-1:-1;;;2049:68:0;;;;;;;:::i;:::-;78033:35:::1;:23:::0;78059:9:::1;78033:35;:::i;:::-;78010:20;:58:::0;-1:-1:-1;77893:183:0:o;9975:127::-;-1:-1:-1;;;;;10076:18:0;10049:7;10076:18;;;;;;;;;;;;9975:127::o;2488:94::-;1910:6;;-1:-1:-1;;;;;1910:6:0;705:10;2057:23;2049:68;;;;-1:-1:-1;;;2049:68:0;;;;;;;:::i;:::-;2553:21:::1;2571:1;2553:9;:21::i;:::-;2488:94::o:0;8903:104::-;8959:13;8992:7;8985:14;;;;;:::i;13121:413::-;705:10;13214:4;13258:25;;;:11;:25;;;;;;;;-1:-1:-1;;;;;13258:34:0;;;;;;;;;;13311:35;;;;13303:85;;;;-1:-1:-1;;;13303:85:0;;11747:2:1;13303:85:0;;;11729:21:1;11786:2;11766:18;;;11759:30;11825:34;11805:18;;;11798:62;-1:-1:-1;;;11876:18:1;;;11869:35;11921:19;;13303:85:0;11545:401:1;13303:85:0;13424:67;705:10;13447:7;13475:15;13456:16;:34;13424:8;:67::i;:::-;-1:-1:-1;13522:4:0;;13121:413;-1:-1:-1;;;13121:413:0:o;77652:136::-;1910:6;;-1:-1:-1;;;;;1910:6:0;705:10;2057:23;2049:68;;;;-1:-1:-1;;;2049:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;77718:10:0;::::1;;::::0;;;:5:::1;:10;::::0;;;;;::::1;;77710:33;;;::::0;-1:-1:-1;;;77710:33:0;;8731:2:1;77710:33:0::1;::::0;::::1;8713:21:1::0;8770:2;8750:18;;;8743:30;-1:-1:-1;;;8789:18:1;;;8782:40;8839:18;;77710:33:0::1;8529:334:1::0;77710:33:0::1;77754:26;77760:3;77765:14;77775:3;77765:9;:14::i;:::-;77754:5;:26::i;:::-;77652:136:::0;:::o;10315:175::-;10401:4;10418:42;705:10;10442:9;10453:6;10418:9;:42::i;77245:302::-;1910:6;;-1:-1:-1;;;;;1910:6:0;705:10;2057:23;2049:68;;;;-1:-1:-1;;;2049:68:0;;;;;;;:::i;:::-;77319:9:::1;77314:226;77338:5;:12;77334:1;:16;77314:226;;;77406:11;::::0;77394:8;;-1:-1:-1;;;;;77406:11:0;;::::1;::::0;77394:5;;77400:1;;77394:8;::::1;;;;;:::i;:::-;;;;;;;-1:-1:-1::0;;;;;77394:23:0::1;;;:62;;;;;71850:42;-1:-1:-1::0;;;;;77421:35:0::1;:5;77427:1;77421:8;;;;;;;;:::i;:::-;;;;;;;-1:-1:-1::0;;;;;77421:35:0::1;;;77394:62;77372:157;;;77509:4;77491:5;:15;77497:5;77503:1;77497:8;;;;;;;;:::i;:::-;;;;;;;-1:-1:-1::0;;;;;77491:15:0::1;-1:-1:-1::0;;;;;77491:15:0::1;;;;;;;;;;;;;:22;;;;;;;;;;;;;;;;;;77372:157;77352:3:::0;::::1;::::0;::::1;:::i;:::-;;;;77314:226;;;;77245:302:::0;:::o;75361:768::-;1910:6;;-1:-1:-1;;;;;1910:6:0;705:10;2057:23;2049:68;;;;-1:-1:-1;;;2049:68:0;;;;;;;:::i;:::-;75422:11:::1;::::0;-1:-1:-1;;;;;75422:11:0::1;:25:::0;75414:61:::1;;;::::0;-1:-1:-1;;;75414:61:0;;11395:2:1;75414:61:0::1;::::0;::::1;11377:21:1::0;11434:2;11414:18;;;11407:30;11473:25;11453:18;;;11446:53;11516:18;;75414:61:0::1;11193:347:1::0;75414:61:0::1;75486:23;75512:24;75530:4;75512:9;:24::i;:::-;75486:50;;75547:65;75564:4;71850:42;75596:15;75547:8;:65::i;:::-;71850:42;-1:-1:-1::0;;;;;75655:22:0::1;;:24;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;75637:54:0::1;;75714:4;71850:42;-1:-1:-1::0;;;;;75734:19:0::1;;:21;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;75637:129;::::0;-1:-1:-1;;;;;;75637:129:0::1;::::0;;;;;;-1:-1:-1;;;;;4402:15:1;;;75637:129:0::1;::::0;::::1;4384:34:1::0;4454:15;;4434:18;;;4427:43;4319:18;;75637:129:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;75623:11;:143:::0;;-1:-1:-1;;;;;;75623:143:0::1;-1:-1:-1::0;;;;;75623:143:0;;::::1;::::0;;::::1;::::0;;;-1:-1:-1;75777:31:0;;;:18:::1;:31;::::0;;;;;:38;;-1:-1:-1;;75777:38:0::1;-1:-1:-1::0;75777:38:0::1;::::0;;1910:6;;75826:213;;-1:-1:-1;;;75826:213:0;;75909:4:::1;75826:213;::::0;::::1;5101:34:1::0;5151:18;;;5144:34;;;5194:18;;;5187:34;;;5237:18;;;5230:34;;;;1910:6:0;;;5280:19:1;;;5273:44;76013:15:0::1;5333:19:1::0;;;5326:35;75826:213:0;;71850:42:::1;::::0;75826:30:::1;::::0;75864:21:::1;::::0;5035:19:1;;;;;75826:213:0::1;::::0;;;;;;;;;75864:21;71850:42;75826:213;::::1;;::::0;::::1;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;;76057:11:0::1;::::0;76050:71:::1;::::0;-1:-1:-1;;;76050:71:0;;71850:42:::1;76050:71;::::0;::::1;4655:51:1::0;-1:-1:-1;;4722:18:1;;;4715:34;-1:-1:-1;;;;;76057:11:0;;::::1;::::0;-1:-1:-1;76050:27:0::1;::::0;4628:18:1;;76050:71:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;76964:139::-:0;77042:11;;-1:-1:-1;;;;;77042:11:0;705:10;-1:-1:-1;;;;;77026:27:0;;77018:36;;;;;;-1:-1:-1;;;;;77065:22:0;77090:5;77065:22;;;:18;:22;;;;;:30;;-1:-1:-1;;77065:30:0;;;76964:139::o;2737:192::-;1910:6;;-1:-1:-1;;;;;1910:6:0;705:10;2057:23;2049:68;;;;-1:-1:-1;;;2049:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;2826:22:0;::::1;2818:73;;;::::0;-1:-1:-1;;;2818:73:0;;7514:2:1;2818:73:0::1;::::0;::::1;7496:21:1::0;7553:2;7533:18;;;7526:30;7592:34;7572:18;;;7565:62;-1:-1:-1;;;7643:18:1;;;7636:36;7689:19;;2818:73:0::1;7312:402:1::0;2818:73:0::1;2902:19;2912:8;2902:9;:19::i;76137:109::-:0;1910:6;;-1:-1:-1;;;;;1910:6:0;705:10;2057:23;2049:68;;;;-1:-1:-1;;;2049:68:0;;;;;;;:::i;:::-;76224:14:::1;9729:2:::0;76224::::1;:14;:::i;:::-;76212:26;::::0;:9;:26:::1;:::i;:::-;76203:6;:35:::0;-1:-1:-1;76137:109:0:o;66225:132::-;66283:14;66319:30;66344:1;66347;66319:24;:30::i;:::-;66310:39;66225:132;-1:-1:-1;;;66225:132:0:o;39339:1188::-;39410:14;;;-1:-1:-1;;39529:1:0;39526;39519:20;39569:1;39566;39562:9;39553:18;;39621:5;39617:2;39614:13;39606:5;39602:2;39598:14;39594:34;39585:43;;;22971:4;39655:5;:14;39651:94;;39693:40;;-1:-1:-1;;;39693:40:0;;;;;12457:25:1;;;12430:18;;39693:40:0;12311:177:1;39651:94:0;39757:17;39785:19;39865:5;39862:1;39859;39852:19;39839:32;-1:-1:-1;;39914:18:0;39900:33;;39960:10;39956:157;;40043:11;22971:4;40026:5;:13;40025:29;40016:38;;40073:13;;;;;;39956:157;40369:11;40240:21;;;40236:39;40317:20;;;;40306:32;;;-1:-1:-1;;;40302:84:0;40207:202;;;;40432:13;40181:283;40159:350;;-1:-1:-1;39339:1188:0;;;;:::o;16805:380::-;-1:-1:-1;;;;;16941:19:0;;16933:68;;;;-1:-1:-1;;;16933:68:0;;10990:2:1;16933:68:0;;;10972:21:1;11029:2;11009:18;;;11002:30;11068:34;11048:18;;;11041:62;-1:-1:-1;;;11119:18:1;;;11112:34;11163:19;;16933:68:0;10788:400:1;16933:68:0;-1:-1:-1;;;;;17020:21:0;;17012:68;;;;-1:-1:-1;;;17012:68:0;;7921:2:1;17012:68:0;;;7903:21:1;7960:2;7940:18;;;7933:30;7999:34;7979:18;;;7972:62;-1:-1:-1;;;8050:18:1;;;8043:32;8092:19;;17012:68:0;7719:398:1;17012:68:0;-1:-1:-1;;;;;17093:18:0;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;:36;;;17145:32;;12457:25:1;;;17145:32:0;;12430:18:1;17145:32:0;;;;;;;16805:380;;;:::o;14024:733::-;-1:-1:-1;;;;;14164:20:0;;14156:70;;;;-1:-1:-1;;;14156:70:0;;10242:2:1;14156:70:0;;;10224:21:1;10281:2;10261:18;;;10254:30;10320:34;10300:18;;;10293:62;-1:-1:-1;;;10371:18:1;;;10364:35;10416:19;;14156:70:0;10040:401:1;14156:70:0;-1:-1:-1;;;;;14245:23:0;;14237:71;;;;-1:-1:-1;;;14237:71:0;;6707:2:1;14237:71:0;;;6689:21:1;6746:2;6726:18;;;6719:30;6785:34;6765:18;;;6758:62;-1:-1:-1;;;6836:18:1;;;6829:33;6879:19;;14237:71:0;6505:399:1;14237:71:0;14321:47;14342:6;14350:9;14361:6;14321:20;:47::i;:::-;-1:-1:-1;;;;;14405:17:0;;14381:21;14405:17;;;;;;;;;;;14441:23;;;;14433:74;;;;-1:-1:-1;;;14433:74:0;;8324:2:1;14433:74:0;;;8306:21:1;8363:2;8343:18;;;8336:30;8402:34;8382:18;;;8375:62;-1:-1:-1;;;8453:18:1;;;8446:36;8499:19;;14433:74:0;8122:402:1;14433:74:0;-1:-1:-1;;;;;14543:17:0;;;:9;:17;;;;;;;;;;;14563:22;;;14543:42;;14607:20;;;;;;;;:30;;14579:6;;14543:9;14607:30;;14579:6;;14607:30;:::i;:::-;;;;;;;;14672:9;-1:-1:-1;;;;;14655:35:0;14664:6;-1:-1:-1;;;;;14655:35:0;;14683:6;14655:35;;;;12457:25:1;;12445:2;12430:18;;12311:177;14655:35:0;;;;;;;;14703:46;14723:6;14731:9;14742:6;14703:19;:46::i;:::-;14145:612;14024:733;;;:::o;2937:173::-;3012:6;;;-1:-1:-1;;;;;3029:17:0;;;-1:-1:-1;;;;;;3029:17:0;;;;;;;3062:40;;3012:6;;;3029:17;3012:6;;3062:40;;2993:16;;3062:40;2982:128;2937:173;:::o;15776:591::-;-1:-1:-1;;;;;15860:21:0;;15852:67;;;;-1:-1:-1;;;15852:67:0;;9840:2:1;15852:67:0;;;9822:21:1;9879:2;9859:18;;;9852:30;9918:34;9898:18;;;9891:62;-1:-1:-1;;;9969:18:1;;;9962:31;10010:19;;15852:67:0;9638:397:1;15852:67:0;15932:49;15953:7;15970:1;15974:6;15932:20;:49::i;:::-;-1:-1:-1;;;;;16019:18:0;;15994:22;16019:18;;;;;;;;;;;16056:24;;;;16048:71;;;;-1:-1:-1;;;16048:71:0;;7111:2:1;16048:71:0;;;7093:21:1;7150:2;7130:18;;;7123:30;7189:34;7169:18;;;7162:62;-1:-1:-1;;;7240:18:1;;;7233:32;7282:19;;16048:71:0;6909:398:1;16048:71:0;-1:-1:-1;;;;;16155:18:0;;:9;:18;;;;;;;;;;16176:23;;;16155:44;;16221:12;:22;;16193:6;;16155:9;16221:22;;16193:6;;16221:22;:::i;:::-;;;;-1:-1:-1;;16261:37:0;;12457:25:1;;;16287:1:0;;-1:-1:-1;;;;;16261:37:0;;;;;12445:2:1;12430:18;16261:37:0;;;;;;;16311:48;16331:7;16348:1;16352:6;16311:19;:48::i;:::-;15841:526;15776:591;;:::o;72368:235::-;-1:-1:-1;;;;;72507:16:0;;;72503:57;;-1:-1:-1;;;;;72534:11:0;;;;;;:5;:11;;;;;;;;72533:12;:26;;;;-1:-1:-1;;;;;;72550:9:0;;;;;;:5;:9;;;;;;;;72549:10;72533:26;72525:35;;;;;;72571:24;72586:4;72592:2;72571:14;:24::i;72611:382::-;-1:-1:-1;;;;;72782:18:0;;;;;;:38;;-1:-1:-1;;;;;;72804:16:0;;;;72782:38;72778:90;;;72837:19;72845:2;72849:6;72837:7;:19::i;:::-;72893:1;72884:6;;:10;:37;;;;-1:-1:-1;;;;;;72899:22:0;;;;;;:18;:22;;;;;;;;72898:23;72884:37;72880:105;;;72961:6;;72944:13;72954:2;72944:9;:13::i;:::-;:23;;72936:49;;;;-1:-1:-1;;;72936:49:0;;10648:2:1;72936:49:0;;;10630:21:1;10687:2;10667:18;;;10660:30;-1:-1:-1;;;10706:18:1;;;10699:43;10759:18;;72936:49:0;10446:337:1;73001:986:0;73126:20;;:25;;:60;;-1:-1:-1;;;;;;73168:18:0;;;73126:60;:93;;;-1:-1:-1;;;;;;73203:16:0;;;73126:93;:120;;;;73244:2;-1:-1:-1;;;;;73236:10:0;:4;-1:-1:-1;;;;;73236:10:0;;73126:120;73108:157;;;73001:986;;:::o;73108:157::-;73452:11;;-1:-1:-1;;;;;73444:19:0;;;73452:11;;73444:19;73440:186;;;-1:-1:-1;;;;;73480:17:0;;;;;:13;:17;;;;;73500:15;73480:35;;-1:-1:-1;73001:986:0:o;73440:186::-;73745:11;;-1:-1:-1;;;;;73739:17:0;;;73745:11;;73739:17;73735:245;;;-1:-1:-1;;;;;73814:19:0;;73773:20;73814:19;;;:13;:19;;;;;;73796:37;;:15;:37;:::i;:::-;73773:60;;73890:20;;73913:9;73890:32;;;;:::i;:::-;73874:12;:48;;73848:120;;;;-1:-1:-1;;;73848:120:0;;6368:2:1;73848:120:0;;;6350:21:1;6407:2;6387:18;;;6380:30;-1:-1:-1;;;6426:18:1;;;6419:40;6476:18;;73848:120:0;6166:334:1;73995:269:0;74064:9;;;;;:38;;-1:-1:-1;74077:11:0;;-1:-1:-1;;;;;74077:11:0;:25;74064:38;:65;;;-1:-1:-1;;;;;;74106:23:0;;;;;;:18;:23;;;;;;;;74064:65;74060:91;;;73995:269;;:::o;74060:91::-;74161:23;74172:3;74177:6;74161:10;:23::i;:::-;74195:22;74205:3;74210:6;74195:9;:22::i;:::-;74228:28;74244:3;74249:6;74228:15;:28::i;75022:294::-;75122:11;75136:39;75155:6;71543:4;75136:18;:39::i;:::-;75122:53;;75186:15;75204:14;75214:3;75204:9;:14::i;:::-;75186:32;;75239:7;75233:3;:13;75229:32;;;75254:7;75248:13;;75229:32;75293:15;75299:3;75304;75293:5;:15::i;74272:355::-;74371:11;74385:38;74404:6;71454:4;74385:18;:38::i;:::-;74371:52;;74434:15;74452:14;74462:3;74452:9;:14::i;:::-;74434:32;;74487:7;74481:3;:13;74477:32;;;74502:7;74496:13;;74477:32;74541:15;74547:3;74552;74541:5;:15::i;:::-;74602:11;;74596:23;;-1:-1:-1;;;;;74602:11:0;74615:3;74596:5;:23::i;74635:379::-;74740:11;74754:44;74773:6;71501:4;74754:18;:44::i;:::-;74740:58;;74809:15;74827:14;74837:3;74827:9;:14::i;:::-;74809:32;;74862:7;74856:3;:13;74852:32;;;74877:7;74871:13;;74852:32;74916:15;74922:3;74927;74916:5;:15::i;:::-;74983:17;;74977:29;;-1:-1:-1;;;;;74983:17:0;75002:3;15044:399;-1:-1:-1;;;;;15128:21:0;;15120:65;;;;-1:-1:-1;;;15120:65:0;;12153:2:1;15120:65:0;;;12135:21:1;12192:2;12172:18;;;12165:30;12231:33;12211:18;;;12204:61;12282:18;;15120:65:0;11951:355:1;15120:65:0;15198:49;15227:1;15231:7;15240:6;15198:20;:49::i;:::-;15276:6;15260:12;;:22;;;;;;;:::i;:::-;;;;-1:-1:-1;;;;;;;15293:18:0;;:9;:18;;;;;;;;;;:28;;15315:6;;15293:9;:28;;15315:6;;15293:28;:::i;:::-;;;;-1:-1:-1;;15337:37:0;;12457:25:1;;;-1:-1:-1;;;;;15337:37:0;;;15354:1;;15337:37;;12445:2:1;12430:18;15337:37:0;;;;;;;15387:48;15415:1;15419:7;15428:6;15387:19;:48::i;14:134:1:-;82:20;;111:31;82:20;111:31;:::i;:::-;14:134;;;:::o;153:247::-;212:6;265:2;253:9;244:7;240:23;236:32;233:52;;;281:1;278;271:12;233:52;320:9;307:23;339:31;364:5;339:31;:::i;405:251::-;475:6;528:2;516:9;507:7;503:23;499:32;496:52;;;544:1;541;534:12;496:52;576:9;570:16;595:31;620:5;595:31;:::i;661:388::-;729:6;737;790:2;778:9;769:7;765:23;761:32;758:52;;;806:1;803;796:12;758:52;845:9;832:23;864:31;889:5;864:31;:::i;:::-;914:5;-1:-1:-1;971:2:1;956:18;;943:32;984:33;943:32;984:33;:::i;:::-;1036:7;1026:17;;;661:388;;;;;:::o;1054:456::-;1131:6;1139;1147;1200:2;1188:9;1179:7;1175:23;1171:32;1168:52;;;1216:1;1213;1206:12;1168:52;1255:9;1242:23;1274:31;1299:5;1274:31;:::i;:::-;1324:5;-1:-1:-1;1381:2:1;1366:18;;1353:32;1394:33;1353:32;1394:33;:::i;:::-;1054:456;;1446:7;;-1:-1:-1;;;1500:2:1;1485:18;;;;1472:32;;1054:456::o;1515:315::-;1583:6;1591;1644:2;1632:9;1623:7;1619:23;1615:32;1612:52;;;1660:1;1657;1650:12;1612:52;1699:9;1686:23;1718:31;1743:5;1718:31;:::i;:::-;1768:5;1820:2;1805:18;;;;1792:32;;-1:-1:-1;;;1515:315:1:o;1835:1132::-;1919:6;1950:2;1993;1981:9;1972:7;1968:23;1964:32;1961:52;;;2009:1;2006;1999:12;1961:52;2049:9;2036:23;2078:18;2119:2;2111:6;2108:14;2105:34;;;2135:1;2132;2125:12;2105:34;2173:6;2162:9;2158:22;2148:32;;2218:7;2211:4;2207:2;2203:13;2199:27;2189:55;;2240:1;2237;2230:12;2189:55;2276:2;2263:16;2298:2;2294;2291:10;2288:36;;;2304:18;;:::i;:::-;2350:2;2347:1;2343:10;2382:2;2376:9;2445:2;2441:7;2436:2;2432;2428:11;2424:25;2416:6;2412:38;2500:6;2488:10;2485:22;2480:2;2468:10;2465:18;2462:46;2459:72;;;2511:18;;:::i;:::-;2547:2;2540:22;2597:18;;;2631:15;;;;-1:-1:-1;2666:11:1;;;2696;;;2692:20;;2689:33;-1:-1:-1;2686:53:1;;;2735:1;2732;2725:12;2686:53;2757:1;2748:10;;2767:169;2781:2;2778:1;2775:9;2767:169;;;2838:23;2857:3;2838:23;:::i;:::-;2826:36;;2799:1;2792:9;;;;;2882:12;;;;2914;;2767:169;;;-1:-1:-1;2955:6:1;1835:1132;-1:-1:-1;;;;;;;;1835:1132:1:o;2972:241::-;3028:6;3081:2;3069:9;3060:7;3056:23;3052:32;3049:52;;;3097:1;3094;3087:12;3049:52;3136:9;3123:23;3155:28;3177:5;3155:28;:::i;3218:245::-;3285:6;3338:2;3326:9;3317:7;3313:23;3309:32;3306:52;;;3354:1;3351;3344:12;3306:52;3386:9;3380:16;3405:28;3427:5;3405:28;:::i;3468:180::-;3527:6;3580:2;3568:9;3559:7;3555:23;3551:32;3548:52;;;3596:1;3593;3586:12;3548:52;-1:-1:-1;3619:23:1;;3468:180;-1:-1:-1;3468:180:1:o;3653:306::-;3741:6;3749;3757;3810:2;3798:9;3789:7;3785:23;3781:32;3778:52;;;3826:1;3823;3816:12;3778:52;3855:9;3849:16;3839:26;;3905:2;3894:9;3890:18;3884:25;3874:35;;3949:2;3938:9;3934:18;3928:25;3918:35;;3653:306;;;;;:::o;5564:597::-;5676:4;5705:2;5734;5723:9;5716:21;5766:6;5760:13;5809:6;5804:2;5793:9;5789:18;5782:34;5834:1;5844:140;5858:6;5855:1;5852:13;5844:140;;;5953:14;;;5949:23;;5943:30;5919:17;;;5938:2;5915:26;5908:66;5873:10;;5844:140;;;6002:6;5999:1;5996:13;5993:91;;;6072:1;6067:2;6058:6;6047:9;6043:22;6039:31;6032:42;5993:91;-1:-1:-1;6145:2:1;6124:15;-1:-1:-1;;6120:29:1;6105:45;;;;6152:2;6101:54;;5564:597;-1:-1:-1;;;5564:597:1:o;9277:356::-;9479:2;9461:21;;;9498:18;;;9491:30;9557:34;9552:2;9537:18;;9530:62;9624:2;9609:18;;9277:356::o;12682:128::-;12722:3;12753:1;12749:6;12746:1;12743:13;12740:39;;;12759:18;;:::i;:::-;-1:-1:-1;12795:9:1;;12682:128::o;12815:422::-;12904:1;12947:5;12904:1;12961:270;12982:7;12972:8;12969:21;12961:270;;;13041:4;13037:1;13033:6;13029:17;13023:4;13020:27;13017:53;;;13050:18;;:::i;:::-;13100:7;13090:8;13086:22;13083:55;;;13120:16;;;;13083:55;13199:22;;;;13159:15;;;;12961:270;;;12965:3;12815:422;;;;;:::o;13242:140::-;13300:5;13329:47;13370:4;13360:8;13356:19;13350:4;13436:5;13466:8;13456:80;;-1:-1:-1;13507:1:1;13521:5;;13456:80;13555:4;13545:76;;-1:-1:-1;13592:1:1;13606:5;;13545:76;13637:4;13655:1;13650:59;;;;13723:1;13718:130;;;;13630:218;;13650:59;13680:1;13671:10;;13694:5;;;13718:130;13755:3;13745:8;13742:17;13739:43;;;13762:18;;:::i;:::-;-1:-1:-1;;13818:1:1;13804:16;;13833:5;;13630:218;;13932:2;13922:8;13919:16;13913:3;13907:4;13904:13;13900:36;13894:2;13884:8;13881:16;13876:2;13870:4;13867:12;13863:35;13860:77;13857:159;;;-1:-1:-1;13969:19:1;;;14001:5;;13857:159;14048:34;14073:8;14067:4;14048:34;:::i;:::-;14118:6;14114:1;14110:6;14106:19;14097:7;14094:32;14091:58;;;14129:18;;:::i;:::-;14167:20;;13387:806;-1:-1:-1;;;13387:806:1:o;14198:168::-;14238:7;14304:1;14300;14296:6;14292:14;14289:1;14286:21;14281:1;14274:9;14267:17;14263:45;14260:71;;;14311:18;;:::i;:::-;-1:-1:-1;14351:9:1;;14198:168::o;14371:125::-;14411:4;14439:1;14436;14433:8;14430:34;;;14444:18;;:::i;:::-;-1:-1:-1;14481:9:1;;14371:125::o;14501:380::-;14580:1;14576:12;;;;14623;;;14644:61;;14698:4;14690:6;14686:17;14676:27;;14644:61;14751:2;14743:6;14740:14;14720:18;14717:38;14714:161;;;14797:10;14792:3;14788:20;14785:1;14778:31;14832:4;14829:1;14822:15;14860:4;14857:1;14850:15;14714:161;;14501:380;;;:::o;14886:135::-;14925:3;-1:-1:-1;;14946:17:1;;14943:43;;;14966:18;;:::i;:::-;-1:-1:-1;15013:1:1;15002:13;;14886:135::o;15026:127::-;15087:10;15082:3;15078:20;15075:1;15068:31;15118:4;15115:1;15108:15;15142:4;15139:1;15132:15;15290:127;15351:10;15346:3;15342:20;15339:1;15332:31;15382:4;15379:1;15372:15;15406:4;15403:1;15396:15;15422:127;15483:10;15478:3;15474:20;15471:1;15464:31;15514:4;15511:1;15504:15;15538:4;15535:1;15528:15;15554:131;-1:-1:-1;;;;;15629:31:1;;15619:42;;15609:70;;15675:1;15672;15665:12;15690:118;15776:5;15769:13;15762:21;15755:5;15752:32;15742:60;;15798:1;15795;15788:12

ipfs://8f7aa7b5adb12bbe558060d7741c83c3a35d53aa7f19640fa736294ce667b77e