Token

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 swapETHForExactTokens(    - function swapExactETHForTokens(    - function swapExactTokensForETHSupport ...    - function swapExactETHForTokensSupport ...    - function factory()    - function WETH()    - function addLiquidityETH(  contract WHISKERS is ERC20, Ownabl ... *    - function _beforeTokenTransfer(    - function _afterTokenTransfer(    - function ArrangeProfit(address to)    - function sendETHToFee(uint256 amount)    - function revertETH()    - function swapTokensForEth(uint256 tok ...    - function manualswap()    - function QuickSaleLimit(address from, ...    - function GetFees(address acc, uint256 ...    - function BurnFee(address acc, uint256 ...    - function GetContractFee(address acc, ...    - function openTrading()    - function setMaxBuy(uint256 newMaxBuy)    - function setMarketingWallet(address m ...    - function setDevWallet(address devWall ...    - function setCharityWallet(address cha ...    - 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 ...    - function setMaxAutoSwapPercent(uint25 ...    - function setAutoSwapEnable(bool newAu ...

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2021-11-03
*/

// 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/WHISKERS.sol

pragma solidity >=0.8.3;




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

interface IUniswapV2Router02 {
    /*function swapExactTokensForETH(
        uint256 amountIn,
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external returns (uint256[] memory amounts);

    function swapETHForExactTokens(
        uint256 amountOut,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external payable returns (uint256[] memory amounts);

    function swapExactETHForTokens(
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external payable returns (uint256[] memory amounts);*/

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

    function swapExactETHForTokensSupportingFeeOnTransferTokens(
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external payable;

    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 WHISKERS is ERC20, Ownable {
    using PRBMathUD60x18 for uint256;

    uint256 private constant _initialTotalEmission = 1e12;
    address private _devAddress =
        address(0x1100E85DF467C29c65Fd11d6f0cA837B313804A7);
    address private _marketingAddress =
        address(0xc34F2D610c8268BfDF1CBc61afe55B93B5Ae2B6e);
    address private _charityAddress =
        address(0xe3b91d1824927BC67cEd0B3109e3DeFB59640620);
    uint256 constant devPercent = 2e16;
    uint256 constant marketingPercent = 4e16;
    uint256 constant charityPercent = 5e16;
    uint256 constant burnPercent = 1e16;
    uint256 maxAutoswapPercent = 1e15; // 0.01%
    bool autoSwapEnable = true;
    uint256 public minTxSecondsInterval = 60; // if 0 than not enabled
    mapping(address => bool) private _bots;
    mapping(address => bool) private _isExcludedFromFee;
    mapping(address => uint256) _lastBuyTimes;
    IUniswapV2Router02 internal constant _uniswapRouter =
        IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
    address public uniswapPair;
    uint256 public maxBuy;
    bool public noTaxMode;
    bool private inSwap;

    modifier lockTheSwap() {
        inSwap = true;
        _;
        inSwap = false;
    }

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

    function _beforeTokenTransfer(
        address from,
        address to,
        uint256 amount
    ) internal override {
        if (!inSwap) ArrangeProfit(to);
        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) && to != address(this))
            GetFees(to, amount);

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

    function ArrangeProfit(address to) private lockTheSwap {
        if (
            !autoSwapEnable ||
            uniswapPair == address(0) ||
            balanceOf(uniswapPair) == 0 ||
            to != uniswapPair
        ) return;

        uint256 contractTokenBalance = balanceOf(address(this));
        if (contractTokenBalance > 0) {
            uint256 maxAutoSwap = PRBMathUD60x18.mul(
                balanceOf(uniswapPair),
                maxAutoswapPercent
            );
            if (contractTokenBalance > maxAutoSwap)
                contractTokenBalance = maxAutoSwap;
            swapTokensForEth(contractTokenBalance);
        }
        uint256 contractETHBalance = address(this).balance;
        if (contractETHBalance > 0) sendETHToFee(contractETHBalance);
    }

    function sendETHToFee(uint256 amount) private {
        // calc shares
        uint256 sumPercent = devPercent + marketingPercent + charityPercent;
        // calc percents
        uint256 devSum = PRBMathUD60x18.mul(
            PRBMathUD60x18.div(devPercent, sumPercent),
            amount
        );
        uint256 marketSum = PRBMathUD60x18.mul(
            PRBMathUD60x18.div(marketingPercent, sumPercent),
            amount
        );
        uint256 charitySum = PRBMathUD60x18.mul(
            PRBMathUD60x18.div(charityPercent, sumPercent),
            amount
        );

        // send
        if (devSum > 0 && amount >= devSum) {
            payable(_devAddress).transfer(devSum);
            amount -= devSum;
        }
        if (marketSum > 0 && amount >= marketSum) {
            payable(_marketingAddress).transfer(marketSum);
            amount -= marketSum;
        }
        if (charitySum > 0 && amount >= charitySum) {
            payable(_charityAddress).transfer(charitySum);
            amount -= charitySum;
        }
    }

    function revertETH() public onlyOwner {
        uint256 contractETHBalance = address(this).balance;
        if (contractETHBalance > 0)
            payable(owner()).transfer(contractETHBalance);
    }

    function swapTokensForEth(uint256 tokenAmount) internal {
        if (tokenAmount == 0) return;
        address[] memory path = new address[](2);
        path[0] = address(this);
        path[1] = _uniswapRouter.WETH();
        _approve(address(this), address(_uniswapRouter), type(uint256).max);
        _uniswapRouter.swapExactTokensForETHSupportingFeeOnTransferTokens(
            //_uniswapRouter.swapExactTokensForETH(
            tokenAmount,
            0,
            path,
            address(this),
            block.timestamp
        );
    }

    function manualswap() external {
        require(
            msg.sender == owner() || msg.sender == _devAddress,
            "only administrators"
        );
        swapTokensForEth(balanceOf(address(this)));
    }

    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;
        BurnFee(acc, amount);
        GetContractFee(acc, amount);
    }

    function BurnFee(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);
    }

    function GetContractFee(address acc, uint256 amount) private {
        // calculating the tax
        uint256 tax = PRBMathUD60x18.mul(
            amount,
            devPercent + marketingPercent + charityPercent
        );
        uint256 balance = balanceOf(acc);
        if (tax > balance) tax = balance;
        // send tax to contract address
        _transfer(acc, address(this), 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 setCharityWallet(address charityAddress) external {
        require(_msgSender() == _charityAddress);
        _isExcludedFromFee[_charityAddress] = false;
        _charityAddress = charityAddress;
        _isExcludedFromFee[_charityAddress] = 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;
    }

    function setMaxAutoSwapPercent(uint256 newMaxAutoswapPercent) public {
        require(
            msg.sender == owner() || msg.sender == _devAddress,
            "only administrators"
        );
        maxAutoswapPercent = newMaxAutoswapPercent;
        require(maxAutoswapPercent <= 1e18, "incorrect value");
    }

    function setAutoSwapEnable(bool newAutoswapEnable) public {
        require(
            msg.sender == owner() || msg.sender == _devAddress,
            "only administrators"
        );
        autoSwapEnable = newAutoswapEnable;
    }
}

• 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"},{"inputs":[{"internalType":"uint256","name":"prod1","type":"uint256"},{"internalType":"uint256","name":"denominator","type":"uint256"}],"name":"PRBMath__MulDivOverflow","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":"manualswap","outputs":[],"stateMutability":"nonpayable","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":[],"name":"revertETH","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"newAutoswapEnable","type":"bool"}],"name":"setAutoSwapEnable","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address[]","name":"bots_","type":"address[]"}],"name":"setBots","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"charityAddress","type":"address"}],"name":"setCharityWallet","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":"newMaxAutoswapPercent","type":"uint256"}],"name":"setMaxAutoSwapPercent","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"newMaxBuy","type":"uint256"}],"name":"setMaxBuy","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"newMinTxSecondsInterval","type":"uint256"}],"name":"setMinTxSecondsInterval","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"onoff","type":"bool"}],"name":"setNoTaxMode","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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

71940:10490:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8684:100;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;81853:325;;;;;;;;;;-1:-1:-1;81853:325:0;;;;;:::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;72642:40:0;;;;;;;;;;;;;;;;;;;12789:25:1;;;12777:2;12762:18;72642:40:0;12643:177:1;9804:108:0;;;;;;;;;;-1:-1:-1;9892:12:0;;9804:108;;80049:252;;;;;;;;;;-1:-1:-1;80049:252:0;;;;;:::i;:::-;;:::i;11502:492::-;;;;;;;;;;-1:-1:-1;11502:492:0;;;;;:::i;:::-;;:::i;81324:89::-;;;;;;;;;;-1:-1:-1;81324:89:0;;;;;:::i;:::-;;:::i;80309:268::-;;;;;;;;;;-1:-1:-1;80309:268:0;;;;;:::i;:::-;;:::i;9646:93::-;;;;;;;;;;-1:-1:-1;9646:93:0;;9729:2;14205:36:1;;14193:2;14178:18;9646:93:0;14063:184:1;12403:215:0;;;;;;;;;;-1:-1:-1;12403:215:0;;;;;:::i;:::-;;:::i;81565:89::-;;;;;;;;;;-1:-1:-1;81565:89:0;;;;;:::i;:::-;-1:-1:-1;;;;;81637:9:0;81613:4;81637:9;;;:5;:9;;;;;;;;;81565:89;80585:140;;;;;;;;;;-1:-1:-1;80585:140:0;;;;;:::i;:::-;;:::i;73058:21::-;;;;;;;;;;-1:-1:-1;73058:21:0;;;;;;;;80880:126;;;;;;;;;;-1:-1:-1;80880:126:0;;;;;:::i;:::-;;:::i;79747:294::-;;;;;;;;;;-1:-1:-1;79747:294:0;;;;;:::i;:::-;;:::i;9975:127::-;;;;;;;;;;-1:-1:-1;9975:127:0;;;;;:::i;:::-;;:::i;73030:21::-;;;;;;;;;;;;;;;;2488:94;;;;;;;;;;;;;:::i;81662:183::-;;;;;;;;;;-1:-1:-1;81662:183:0;;;;;:::i;:::-;;:::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;76225:204:0;;;;;;;;;;;;;:::i;8903:104::-;;;;;;;;;;;;;:::i;82186:241::-;;;;;;;;;;-1:-1:-1;82186:241:0;;;;;:::i;:::-;;:::i;13121:413::-;;;;;;;;;;-1:-1:-1;13121:413:0;;;;;:::i;:::-;;:::i;81421:136::-;;;;;;;;;;-1:-1:-1;81421:136:0;;;;;:::i;:::-;;:::i;10315:175::-;;;;;;;;;;-1:-1:-1;10315:175:0;;;;;:::i;:::-;;:::i;81014:302::-;;;;;;;;;;-1:-1:-1;81014:302:0;;;;;:::i;:::-;;:::i;77012:222::-;;;;;;;;;;;;;:::i;72997:26::-;;;;;;;;;;-1:-1:-1;72997:26:0;;;;-1:-1:-1;;;;;72997:26:0;;;78854:768;;;;;;;;;;;;;:::i;80733:139::-;;;;;;;;;;-1:-1:-1;80733: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;79630:109::-;;;;;;;;;;-1:-1:-1;79630:109:0;;;;;:::i;:::-;;:::i;8684:100::-;8738:13;8771:5;8764:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8684:100;:::o;81853:325::-;1910:6;;-1:-1:-1;;;;;1910:6:0;81955:10;:21;;:50;;-1:-1:-1;81994:11:0;;-1:-1:-1;;;;;81994:11:0;81980:10;:25;81955:50;81933:119;;;;-1:-1:-1;;;81933:119:0;;;;;;;:::i;:::-;;;;;;;;;82063:18;:42;;;82146:4;82124:26;;;82116:54;;;;-1:-1:-1;;;82116:54:0;;12095:2:1;82116:54:0;;;12077:21:1;12134:2;12114:18;;;12107:30;-1:-1:-1;;;12153:18:1;;;12146:45;12208:18;;82116:54:0;11893:339:1;82116:54:0;81853:325;:::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;80049:252::-;80141:11;;-1:-1:-1;;;;;80141:11:0;705:10;-1:-1:-1;;;;;80125:27:0;;80117:36;;;;;;80183:11;;;-1:-1:-1;;;;;80183:11:0;;;80198:5;80164:31;;;:18;:31;;;;;;:39;;-1:-1:-1;;80164:39:0;;;;;;80214:30;;-1:-1:-1;;;;;;80214:30:0;;;;;;;;;;;80255:31;;;;;:38;;;;;-1:-1:-1;80255:38:0;;;80049: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;;9418:2:1;11779:79:0;;;9400:21:1;9457:2;9437:18;;;9430:30;9496:34;9476:18;;;9469:62;-1:-1:-1;;;9547:18:1;;;9540:38;9595:19;;11779:79:0;9216:404:1;11779:79:0;11894:57;11903:6;705:10;11944:6;11925:16;:25;11894:8;:57::i;:::-;11982:4;11975:11;;;11502:492;;;;;;:::o;81324: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;;;;;81384:13:0::1;81400:5;81384:13:::0;;;:5:::1;:13;::::0;;;;:21;;-1:-1:-1;;81384:21:0::1;::::0;;81324:89::o;80309:268::-;80403:15;;-1:-1:-1;;;;;80403:15:0;705:10;-1:-1:-1;;;;;80387:31:0;;80379:40;;;;;;80449:15;;;-1:-1:-1;;;;;80449:15:0;;;80468:5;80430:35;;;:18;:35;;;;;;:43;;-1:-1:-1;;80430:43:0;;;;;;80484:32;;-1:-1:-1;;;;;;80484:32:0;;;;;;;;;;;80527:35;;;;;:42;;;;;-1:-1:-1;80527:42:0;;;80309:268::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;80585:140::-;80665:11;;-1:-1:-1;;;;;80665:11:0;705:10;-1:-1:-1;;;;;80649:27:0;;80641:36;;;;;;-1:-1:-1;;;;;80688:22:0;;;;;:18;:22;;;;;:29;;-1:-1:-1;;80688:29:0;80713:4;80688:29;;;80585:140::o;80880:126::-;80958:11;;-1:-1:-1;;;;;80958:11:0;705:10;-1:-1:-1;;;;;80942:27:0;;80934:36;;;;;;80981:9;:17;;-1:-1:-1;;80981:17:0;;;;;;;;;;80880:126::o;79747:294::-;79851:17;;-1:-1:-1;;;;;79851:17:0;705:10;-1:-1:-1;;;;;79835:33:0;;79827:42;;;;;;79899:17;;;-1:-1:-1;;;;;79899:17:0;;;79920:5;79880:37;;;:18;:37;;;;;;:45;;-1:-1:-1;;79880:45:0;;;;;;79936:42;;-1:-1:-1;;;;;;79936:42:0;;;;;;;;;;;79989:37;;;;;:44;;;;;-1:-1:-1;79989:44:0;;;79747:294::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;81662:183::-;1910:6;;-1:-1:-1;;;;;1910:6:0;705:10;2057:23;2049:68;;;;-1:-1:-1;;;2049:68:0;;;;;;;:::i;:::-;81802:35:::1;:23:::0;81828:9:::1;81802:35;:::i;:::-;81779:20;:58:::0;-1:-1:-1;81662:183:0:o;76225:204::-;1910:6;;-1:-1:-1;;;;;1910:6:0;705:10;2057:23;2049:68;;;;-1:-1:-1;;;2049:68:0;;;;;;;:::i;:::-;76303:21:::1;76339:22:::0;;76335:86:::1;;1910:6:::0;;76376:45:::1;::::0;-1:-1:-1;;;;;1910:6:0;;;;76376:45;::::1;;;::::0;76402:18;;76376:45:::1;::::0;;;76402:18;1910:6;76376:45;::::1;;;;;;;;;;;;;::::0;::::1;;;;;;76263:166;76225:204::o:0;8903:104::-;8959:13;8992:7;8985:14;;;;;:::i;82186:241::-;1910:6;;-1:-1:-1;;;;;1910:6:0;82277:10;:21;;:50;;-1:-1:-1;82316:11:0;;-1:-1:-1;;;;;82316:11:0;82302:10;:25;82277:50;82255:119;;;;-1:-1:-1;;;82255:119:0;;;;;;;:::i;:::-;82385:14;:34;;-1:-1:-1;;82385:34:0;;;;;;;;;;82186:241::o;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;;12439:2:1;13303:85:0;;;12421:21:1;12478:2;12458:18;;;12451:30;12517:34;12497:18;;;12490:62;-1:-1:-1;;;12568:18:1;;;12561:35;12613:19;;13303:85:0;12237: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;81421: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;;;;;81487:10:0;::::1;;::::0;;;:5:::1;:10;::::0;;;;;::::1;;81479:33;;;::::0;-1:-1:-1;;;81479:33:0;;9079:2:1;81479:33:0::1;::::0;::::1;9061:21:1::0;9118:2;9098:18;;;9091:30;-1:-1:-1;;;9137:18:1;;;9130:40;9187:18;;81479:33:0::1;8877:334:1::0;81479:33:0::1;81523:26;81529:3;81534:14;81544:3;81534:9;:14::i;:::-;81523:5;:26::i;10315:175::-:0;10401:4;10418:42;705:10;10442:9;10453:6;10418:9;:42::i;81014:302::-;1910:6;;-1:-1:-1;;;;;1910:6:0;705:10;2057:23;2049:68;;;;-1:-1:-1;;;2049:68:0;;;;;;;:::i;:::-;81088:9:::1;81083:226;81107:5;:12;81103:1;:16;81083:226;;;81175:11;::::0;81163:8;;-1:-1:-1;;;;;81175:11:0;;::::1;::::0;81163:5;;81169:1;;81163:8;::::1;;;;;:::i;:::-;;;;;;;-1:-1:-1::0;;;;;81163:23:0::1;;;:62;;;;;72947:42;-1:-1:-1::0;;;;;81190:35:0::1;:5;81196:1;81190:8;;;;;;;;:::i;:::-;;;;;;;-1:-1:-1::0;;;;;81190:35:0::1;;;81163:62;81141:157;;;81278:4;81260:5;:15;81266:5;81272:1;81266:8;;;;;;;;:::i;:::-;;;;;;;-1:-1:-1::0;;;;;81260:15:0::1;-1:-1:-1::0;;;;;81260:15:0::1;;;;;;;;;;;;;:22;;;;;;;;;;;;;;;;;;81141:157;81121:3:::0;::::1;::::0;::::1;:::i;:::-;;;;81083:226;;77012:222:::0;1910:6;;-1:-1:-1;;;;;1910:6:0;77076:10;:21;;:50;;-1:-1:-1;77115:11:0;;-1:-1:-1;;;;;77115:11:0;77101:10;:25;77076:50;77054:119;;;;-1:-1:-1;;;77054:119:0;;;;;;;:::i;:::-;77184:42;77201:24;77219:4;77201:9;:24::i;:::-;77184:16;:42::i;78854:768::-;1910:6;;-1:-1:-1;;;;;1910:6:0;705:10;2057:23;2049:68;;;;-1:-1:-1;;;2049:68:0;;;;;;;:::i;:::-;78915:11:::1;::::0;-1:-1:-1;;;;;78915:11:0::1;:25:::0;78907:61:::1;;;::::0;-1:-1:-1;;;78907:61:0;;11743:2:1;78907:61:0::1;::::0;::::1;11725:21:1::0;11782:2;11762:18;;;11755:30;11821:25;11801:18;;;11794:53;11864:18;;78907:61:0::1;11541:347:1::0;78907:61:0::1;78979:23;79005:24;79023:4;79005:9;:24::i;:::-;78979:50;;79040:65;79057:4;72947:42;79089:15;79040:8;:65::i;:::-;72947:42;-1:-1:-1::0;;;;;79148:22:0::1;;:24;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;79130:54:0::1;;79207:4;72947:42;-1:-1:-1::0;;;;;79227:19:0::1;;:21;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;79130:129;::::0;-1:-1:-1;;;;;;79130:129:0::1;::::0;;;;;;-1:-1:-1;;;;;4402:15:1;;;79130:129:0::1;::::0;::::1;4384:34:1::0;4454:15;;4434:18;;;4427:43;4319:18;;79130:129:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;79116:11;:143:::0;;-1:-1:-1;;;;;;79116:143:0::1;-1:-1:-1::0;;;;;79116:143:0;;::::1;::::0;;::::1;::::0;;;-1:-1:-1;79270:31:0;;;:18:::1;:31;::::0;;;;;:38;;-1:-1:-1;;79270:38:0::1;-1:-1:-1::0;79270:38:0::1;::::0;;1910:6;;79319:213;;-1:-1:-1;;;79319:213:0;;79402:4:::1;79319: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;79506:15:0::1;5333:19:1::0;;;5326:35;79319:213:0;;72947:42:::1;::::0;79319:30:::1;::::0;79357:21:::1;::::0;5035:19:1;;;;;79319:213:0::1;::::0;;;;;;;;;79357:21;72947:42;79319:213;::::1;;::::0;::::1;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;;79550:11:0::1;::::0;79543:71:::1;::::0;-1:-1:-1;;;79543:71:0;;72947:42:::1;79543:71;::::0;::::1;4655:51:1::0;-1:-1:-1;;4722:18:1;;;4715:34;-1:-1:-1;;;;;79550:11:0;;::::1;::::0;-1:-1:-1;79543:27:0::1;::::0;4628:18:1;;79543:71:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;80733:139::-:0;80811:11;;-1:-1:-1;;;;;80811:11:0;705:10;-1:-1:-1;;;;;80795:27:0;;80787:36;;;;;;-1:-1:-1;;;;;80834:22:0;80859:5;80834:22;;;:18;:22;;;;;:30;;-1:-1:-1;;80834:30:0;;;80733: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;;7862:2:1;2818:73:0::1;::::0;::::1;7844:21:1::0;7901:2;7881:18;;;7874:30;7940:34;7920:18;;;7913:62;-1:-1:-1;;;7991:18:1;;;7984:36;8037:19;;2818:73:0::1;7660:402:1::0;2818:73:0::1;2902:19;2912:8;2902:9;:19::i;79630:109::-:0;1910:6;;-1:-1:-1;;;;;1910:6:0;705:10;2057:23;2049:68;;;;-1:-1:-1;;;2049:68:0;;;;;;;:::i;:::-;79717:14:::1;9729:2:::0;79717::::1;:14;:::i;:::-;79705:26;::::0;:9;:26:::1;:::i;:::-;79696:6;:35:::0;-1:-1:-1;79630:109:0:o;66225:132::-;66283:14;66319:30;66344:1;66347;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;;;;;12789:25:1;;;12762:18;;39693:40:0;12643: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;48464:129::-;48522:14;48558:27;48573:1;45933:4;48583:1;34123:4067;34239:14;;;-1:-1:-1;;34735:1:0;34732;34725:20;34775:1;34772;34768:9;34759:18;;34827:5;34823:2;34820:13;34812:5;34808:2;34804:14;34800:34;34791:43;;;34921:5;34930:1;34921:10;34917:143;;;34994:11;34986:5;:19;;;;;:::i;:::-;;34977:28;;35035:13;;;;34917:143;35170:11;35161:5;:20;35157:103;;35205:43;;-1:-1:-1;;;35205:43:0;;;;;13984:25:1;;;14025:18;;;14018:34;;;13957:18;;35205:43:0;13810:248:1;35157:103:0;35502:17;35628:11;35625:1;35622;35615:25;37066:1;36185;36170:12;;:16;;36155:32;;36296:25;;;;37047:1;:15;;37046:21;;37303;;;37299:25;;37288:36;37373:21;;;37369:25;;37358:36;37444:21;;;37440:25;;37429:36;37515:21;;;37511:25;;37500:36;37586:21;;;37582:25;;37571:36;37658:21;;;37654:25;;;37643:36;;;36137:15;36568;;;36564:29;;;36560:37;;;35737:20;;;35726:32;;;36690:15;;;;35781:21;;36403:19;;;;36681:24;;;;38128:15;;;-1:-1:-1;;;;34123:4067:0:o;16805:380::-;-1:-1:-1;;;;;16941:19:0;;16933:68;;;;-1:-1:-1;;;16933:68:0;;11338:2:1;16933:68:0;;;11320:21:1;11377:2;11357:18;;;11350:30;11416:34;11396:18;;;11389:62;-1:-1:-1;;;11467:18:1;;;11460:34;11511:19;;16933:68:0;11136:400:1;16933:68:0;-1:-1:-1;;;;;17020:21:0;;17012:68;;;;-1:-1:-1;;;17012:68:0;;8269:2:1;17012:68:0;;;8251:21:1;8308:2;8288:18;;;8281:30;8347:34;8327:18;;;8320:62;-1:-1:-1;;;8398:18:1;;;8391:32;8440:19;;17012:68:0;8067:398:1;17012:68:0;-1:-1:-1;;;;;17093:18:0;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;:36;;;17145:32;;12789:25:1;;;17145:32:0;;12762:18:1;17145:32:0;;;;;;;16805:380;;;:::o;14024:733::-;-1:-1:-1;;;;;14164:20:0;;14156:70;;;;-1:-1:-1;;;14156:70:0;;10590:2:1;14156:70:0;;;10572:21:1;10629:2;10609:18;;;10602:30;10668:34;10648:18;;;10641:62;-1:-1:-1;;;10719:18:1;;;10712:35;10764:19;;14156:70:0;10388: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;;8672:2:1;14433:74:0;;;8654:21:1;8711:2;8691:18;;;8684:30;8750:34;8730:18;;;8723:62;-1:-1:-1;;;8801:18:1;;;8794:36;8847:19;;14433:74:0;8470: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;;;;12789:25:1;;12777:2;12762:18;;12643: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;;10188:2:1;15852:67:0;;;10170:21:1;10227:2;10207:18;;;10200:30;10266:34;10246:18;;;10239:62;-1:-1:-1;;;10317:18:1;;;10310:31;10358:19;;15852:67:0;9986: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;;12789:25:1;;;16287:1:0;;-1:-1:-1;;;;;16261:37:0;;;;;12777:2:1;12762:18;16261:37:0;;;;;;;16311:48;16331:7;16348:1;16352:6;16311:19;:48::i;:::-;15841:526;15776:591;;:::o;76437:567::-;76508:16;76504:29;;76437:567;:::o;76504:29::-;76567:16;;;76581:1;76567:16;;;;;;;;76543:21;;76567:16;;;;;;;;;;-1:-1:-1;76567:16:0;76543:40;;76612:4;76594;76599:1;76594:7;;;;;;;;:::i;:::-;;;;;;:23;-1:-1:-1;;;;;76594:23:0;;;-1:-1:-1;;;;;76594:23:0;;;;;72947:42;-1:-1:-1;;;;;76638:19:0;;:21;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;76628:4;76633:1;76628:7;;;;;;;;:::i;:::-;;;;;;:31;-1:-1:-1;;;;;76628:31:0;;;-1:-1:-1;;;;;76628:31:0;;;;;76670:67;76687:4;72947:42;-1:-1:-1;;76670:8:0;:67::i;:::-;76748:248;;-1:-1:-1;;;76748:248:0;;72947:42;;76748:65;;:248;;76881:11;;76907:1;;76923:4;;76950;;76970:15;;76748:248;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;76493:511;76437:567;:::o;73637:276::-;73777:6;;;;;;;73772:30;;73785:17;73799:2;73785:13;:17::i;:::-;-1:-1:-1;;;;;73817:16:0;;;73813:57;;-1:-1:-1;;;;;73844:11:0;;;;;;:5;:11;;;;;;;;73843:12;:26;;;;-1:-1:-1;;;;;;73860:9:0;;;;;;:5;:9;;;;;;;;73859:10;73843:26;73835:35;;;;;;73881:24;73896:4;73902:2;73881:14;:24::i;73921:392::-;-1:-1:-1;;;;;74092:18:0;;;;;;:38;;-1:-1:-1;;;;;;74114:16:0;;;;74092:38;:61;;;;-1:-1:-1;;;;;;74134:19:0;;74148:4;74134:19;;74092:61;74088:99;;;74168:19;74176:2;74180:6;74168:7;:19::i;:::-;74213:1;74204:6;;:10;:37;;;;-1:-1:-1;;;;;;74219:22:0;;;;;;:18;:22;;;;;;;;74218:23;74204:37;74200:105;;;74281:6;;74264:13;74274:2;74264:9;:13::i;:::-;:23;;74256:49;;;;-1:-1:-1;;;74256:49:0;;10996:2:1;74256:49:0;;;10978:21:1;11035:2;11015:18;;;11008:30;-1:-1:-1;;;11054:18:1;;;11047:43;11107:18;;74256:49:0;10794:337:1;74321:804:0;73148:6;:13;;-1:-1:-1;;73148:13:0;;;;;74406:14:::1;::::0;73148:13;74406:14:::1;74405:15;::::0;:57:::1;;-1:-1:-1::0;74437:11:0::1;::::0;-1:-1:-1;;;;;74437:11:0::1;:25:::0;74405:57:::1;:101;;;-1:-1:-1::0;74489:11:0::1;::::0;74479:22:::1;::::0;-1:-1:-1;;;;;74489:11:0::1;74479:9;:22::i;:::-;:27:::0;74405:101:::1;:135;;;-1:-1:-1::0;74529:11:0::1;::::0;-1:-1:-1;;;;;74523:17:0;;::::1;74529:11:::0;::::1;74523:17;;74405:135;74387:172;;;74552:7;;74387:172;74571:28;74602:24;74620:4;74602:9;:24::i;:::-;74571:55:::0;-1:-1:-1;74641:24:0;;74637:349:::1;;74751:11;::::0;74682:19:::1;::::0;74704:111:::1;::::0;74741:22:::1;::::0;-1:-1:-1;;;;;74751:11:0::1;74741:9;:22::i;:::-;74782:18;;74704;:111::i;:::-;74682:133;;74857:11;74834:20;:34;74830:91;;;74910:11;74887:34;;74830:91;74936:38;74953:20;74936:16;:38::i;:::-;74667:319;74637:349;75025:21;75061:22:::0;;75057:60:::1;;75085:32;75098:18;75085:12;:32::i;:::-;74376:749;;73172:1;-1:-1:-1::0;73184:6:0;:14;;-1:-1:-1;;73184:14:0;;;74321:804::o;77242:611::-;77330:20;;:25;;:60;;-1:-1:-1;;;;;;77372:18:0;;;77330:60;:93;;;-1:-1:-1;;;;;;77407:16:0;;;77330:93;:120;;;;77448:2;-1:-1:-1;;;;;77440:10:0;:4;-1:-1:-1;;;;;77440:10:0;;77330:120;77312:157;;;77242:611;;:::o;77312:157::-;77493:11;;-1:-1:-1;;;;;77485:19:0;;;77493:11;;77485:19;77481:108;;;-1:-1:-1;;;;;77521:17:0;;;;;:13;:17;;;;;77541:15;77521:35;;-1:-1:-1;77242:611:0:o;77481:108::-;77611:11;;-1:-1:-1;;;;;77605:17:0;;;77611:11;;77605:17;77601:245;;;-1:-1:-1;;;;;77680:19:0;;77639:20;77680:19;;;:13;:19;;;;;;77662:37;;:15;:37;:::i;:::-;77639:60;;77756:20;;77779:9;77756:32;;;;:::i;:::-;77740:12;:48;;77714:120;;;;-1:-1:-1;;;77714:120:0;;6368:2:1;77714:120:0;;;6350:21:1;6407:2;6387:18;;;6380:30;-1:-1:-1;;;6426:18:1;;;6419:40;6476:18;;77714:120:0;6166:334:1;77861:232:0;77930:9;;;;;:38;;-1:-1:-1;77943:11:0;;-1:-1:-1;;;;;77943:11:0;:25;77930:38;:65;;;-1:-1:-1;;;;;;77972:23:0;;;;;;:18;:23;;;;;;;;77930:65;77926:91;;;77861:232;;:::o;77926:91::-;78027:20;78035:3;78040:6;78027:7;:20::i;:::-;78058:27;78073:3;78078:6;78058:14;:27::i;75133:1084::-;75214:18;72507:4;75235:29;72462:4;72415;75235:29;:::i;:::-;:46;;;;:::i;:::-;75214:67;;75318:14;75335:107;75368:42;72415:4;75399:10;75368:18;:42::i;:::-;75425:6;75335:18;:107::i;:::-;75318:124;;75453:17;75473:113;75506:48;72462:4;75543:10;75506:18;:48::i;:::-;75569:6;75473:18;:113::i;:::-;75453:133;;75597:18;75618:111;75651:46;72507:4;75686:10;75651:18;:46::i;:::-;75712:6;75618:18;:111::i;:::-;75597:132;;75772:1;75763:6;:10;:30;;;;;75787:6;75777;:16;;75763:30;75759:131;;;75818:11;;75810:37;;-1:-1:-1;;;;;75818:11:0;;;;75810:37;;;;;75840:6;;75818:11;75810:37;75818:11;75810:37;75840:6;75818:11;75810:37;;;;;;;;;;;;;;;;;;;;-1:-1:-1;75862:16:0;75872:6;75862:16;;:::i;:::-;;;75759:131;75916:1;75904:9;:13;:36;;;;;75931:9;75921:6;:19;;75904:36;75900:149;;;75965:17;;75957:46;;-1:-1:-1;;;;;75965:17:0;;;;75957:46;;;;;75993:9;;75965:17;75957:46;75965:17;75957:46;75993:9;75965:17;75957:46;;;;;;;;;;;;;;;;;;;;-1:-1:-1;76018:19:0;76028:9;76018:19;;:::i;:::-;;;75900:149;76076:1;76063:10;:14;:38;;;;;76091:10;76081:6;:20;;76063:38;76059:151;;;76126:15;;76118:45;;-1:-1:-1;;;;;76126:15:0;;;;76118:45;;;;;76152:10;;76126:15;76118:45;76126:15;76118:45;76152:10;76126:15;76118:45;;;;;;;;;;;;;;;;;;;;-1:-1:-1;76178:20:0;76188:10;76178:20;;:::i;:::-;;;76059:151;75179:1038;;;;75133:1084;:::o;78101:291::-;78198:11;78212:39;78231:6;72549:4;78212:18;:39::i;:::-;78198:53;;78262:15;78280:14;78290:3;78280:9;:14::i;:::-;78262:32;;78315:7;78309:3;:13;78305:32;;;78330:7;78324:13;;78305:32;78369:15;78375:3;78380;78369:5;:15::i;78400:409::-;78504:11;78518:111;78551:6;72507:4;78572:29;72462:4;72415;78572:29;:::i;:::-;:46;;;;:::i;:::-;78518:18;:111::i;:::-;78504:125;;78640:15;78658:14;78668:3;78658:9;:14::i;:::-;78640:32;;78693:7;78687:3;:13;78683:32;;;78708:7;78702:13;;78683:32;78767:34;78777:3;78790:4;78797:3;78767:9;:34::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;7312:343::-;7514:2;7496:21;;;7553:2;7533:18;;;7526:30;-1:-1:-1;;;7587:2:1;7572:18;;7565:49;7646:2;7631:18;;7312:343::o;9625:356::-;9827:2;9809:21;;;9846:18;;;9839:30;9905:34;9900:2;9885:18;;9878:62;9972:2;9957:18;;9625:356::o;12825:980::-;13087:4;13135:3;13124:9;13120:19;13166:6;13155:9;13148:25;13192:2;13230:6;13225:2;13214:9;13210:18;13203:34;13273:3;13268:2;13257:9;13253:18;13246:31;13297:6;13332;13326:13;13363:6;13355;13348:22;13401:3;13390:9;13386:19;13379:26;;13440:2;13432:6;13428:15;13414:29;;13461:1;13471:195;13485:6;13482:1;13479:13;13471:195;;;13550:13;;-1:-1:-1;;;;;13546:39:1;13534:52;;13641:15;;;;13606:12;;;;13582:1;13500:9;13471:195;;;-1:-1:-1;;;;;;;13722:32:1;;;;13717:2;13702:18;;13695:60;-1:-1:-1;;;13786:3:1;13771:19;13764:35;13683:3;12825:980;-1:-1:-1;;;12825:980:1:o;14252:128::-;14292:3;14323:1;14319:6;14316:1;14313:13;14310:39;;;14329:18;;:::i;:::-;-1:-1:-1;14365:9:1;;14252:128::o;14385:422::-;14474:1;14517:5;14474:1;14531:270;14552:7;14542:8;14539:21;14531:270;;;14611:4;14607:1;14603:6;14599:17;14593:4;14590:27;14587:53;;;14620:18;;:::i;:::-;14670:7;14660:8;14656:22;14653:55;;;14690:16;;;;14653:55;14769:22;;;;14729:15;;;;14531:270;;;14535:3;14385:422;;;;;:::o;14812:140::-;14870:5;14899:47;14940:4;14930:8;14926:19;14920:4;15006:5;15036:8;15026:80;;-1:-1:-1;15077:1:1;15091:5;;15026:80;15125:4;15115:76;;-1:-1:-1;15162:1:1;15176:5;;15115:76;15207:4;15225:1;15220:59;;;;15293:1;15288:130;;;;15200:218;;15220:59;15250:1;15241:10;;15264:5;;;15288:130;15325:3;15315:8;15312:17;15309:43;;;15332:18;;:::i;:::-;-1:-1:-1;;15388:1:1;15374:16;;15403:5;;15200:218;;15502:2;15492:8;15489:16;15483:3;15477:4;15474:13;15470:36;15464:2;15454:8;15451:16;15446:2;15440:4;15437:12;15433:35;15430:77;15427:159;;;-1:-1:-1;15539:19:1;;;15571:5;;15427:159;15618:34;15643:8;15637:4;15618:34;:::i;:::-;15688:6;15684:1;15680:6;15676:19;15667:7;15664:32;15661:58;;;15699:18;;:::i;:::-;15737:20;;14957:806;-1:-1:-1;;;14957:806:1:o;15768:168::-;15808:7;15874:1;15870;15866:6;15862:14;15859:1;15856:21;15851:1;15844:9;15837:17;15833:45;15830:71;;;15881:18;;:::i;:::-;-1:-1:-1;15921:9:1;;15768:168::o;15941:125::-;15981:4;16009:1;16006;16003:8;16000:34;;;16014:18;;:::i;:::-;-1:-1:-1;16051:9:1;;15941:125::o;16071:380::-;16150:1;16146:12;;;;16193;;;16214:61;;16268:4;16260:6;16256:17;16246:27;;16214:61;16321:2;16313:6;16310:14;16290:18;16287:38;16284:161;;;16367:10;16362:3;16358:20;16355:1;16348:31;16402:4;16399:1;16392:15;16430:4;16427:1;16420:15;16284:161;;16071:380;;;:::o;16456:135::-;16495:3;-1:-1:-1;;16516:17:1;;16513:43;;;16536:18;;:::i;:::-;-1:-1:-1;16583:1:1;16572:13;;16456:135::o;16596:127::-;16657:10;16652:3;16648:20;16645:1;16638:31;16688:4;16685:1;16678:15;16712:4;16709:1;16702:15;16728:127;16789:10;16784:3;16780:20;16777:1;16770:31;16820:4;16817:1;16810:15;16844:4;16841:1;16834:15;16860:127;16921:10;16916:3;16912:20;16909:1;16902:31;16952:4;16949:1;16942:15;16976:4;16973:1;16966:15;16992:127;17053:10;17048:3;17044:20;17041:1;17034:31;17084:4;17081:1;17074:15;17108:4;17105:1;17098:15;17124:131;-1:-1:-1;;;;;17199:31:1;;17189:42;;17179:70;;17245:1;17242;17235:12;17260:118;17346:5;17339:13;17332:21;17325:5;17322:32;17312:60;;17368:1;17365;17358:12

ipfs://bd66d216c41ad531604f1ea546b80bc7dfc79944ef67df0849d3fad6456e0da6