Token

SFOG (SFOG)

ERC-20

Overview

Max Total Supply

99,928 SFOG

Holders

Market

Price

$0.00 @ 0.000000 S

Onchain Market Cap

$0.00

Circulating Supply Market Cap

Other Info

Token Contract (WITH 18 Decimals)

0xa2ba99a35f8cd750cea3b49a47b7ba1c6ceb0780

Filtered by Token Holder

0x200FE795b77BE0d06Cb6FE9e0de1A034CabbCBB5

Balance

49,802.686716791979949873 SFOG

Value

$0.00

0x200fe795b77be0d06cb6fe9e0de1a034cabbcbb5

Click here to update the token information / general information

Contract Source Code Verified (Exact Match)

Contract Name:

SFOG

Compiler Version

v0.8.25+commit.b61c2a91

Optimization Enabled:

No with 200 runs

Other Settings:

default evmVersion, MIT license

Contract Source Code (Solidity)

IDE

/**
 *Submitted for verification at SonicScan.org on 2025-02-22
*/

/**                                                                                   



**/

pragma solidity ^0.8.17;

abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
        return msg.data;
    }
}

interface IERC20 {
    function totalSupply() external view returns (uint256);

    function balanceOf(address account) external view returns (uint256);

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

    function approve(address spender, uint256 amount) external returns (bool);

    function transferFrom(
        address sender,
        address recipient,
        uint256 amount
    ) external returns (bool);

    event Transfer(address indexed from, address indexed to, uint256 value);

    event Approval(
        address indexed owner,
        address indexed spender,
        uint256 value
    );
}

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

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;

    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
    }

    function name() public view virtual override returns (string memory) {
        return _name;
    }

    function symbol() public view virtual override returns (string memory) {
        return _symbol;
    }

    function decimals() public view virtual override returns (uint8) {
        return 18;
    }

    function totalSupply() public view virtual override returns (uint256) {
        return _totalSupply;
    }

    function balanceOf(
        address account
    ) public view virtual override returns (uint256) {
        return _balances[account];
    }

    function transfer(
        address to,
        uint256 amount
    ) public virtual override returns (bool) {
        address owner = _msgSender();
        _transfer(owner, to, amount);
        return true;
    }

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

    function approve(
        address spender,
        uint256 amount
    ) public virtual override returns (bool) {
        address owner = _msgSender();
        _approve(owner, spender, amount);
        return true;
    }

    function transferFrom(
        address from,
        address to,
        uint256 amount
    ) public virtual override returns (bool) {
        address spender = _msgSender();
        _spendAllowance(from, spender, amount);
        _transfer(from, to, amount);
        return true;
    }

    function increaseAllowance(
        address spender,
        uint256 addedValue
    ) public virtual returns (bool) {
        address owner = _msgSender();
        _approve(owner, spender, allowance(owner, spender) + addedValue);
        return true;
    }

    function decreaseAllowance(
        address spender,
        uint256 subtractedValue
    ) public virtual returns (bool) {
        address owner = _msgSender();
        uint256 currentAllowance = allowance(owner, spender);
        require(
            currentAllowance >= subtractedValue,
            "ERC20: decreased allowance below zero"
        );
        unchecked {
            _approve(owner, spender, currentAllowance - subtractedValue);
        }

        return true;
    }

    function _transfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual {
        require(from != address(0), "ERC20: transfer from the zero address");
        require(to != address(0), "ERC20: transfer to the zero address");

        _beforeTokenTransfer(from, to, amount);

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

        emit Transfer(from, to, amount);

        _afterTokenTransfer(from, to, amount);
    }

    function _mint(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: mint to the zero address");

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

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

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

    function _burn(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: burn from the zero address");

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

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

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

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

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

    function _spendAllowance(
        address owner,
        address spender,
        uint256 amount
    ) internal virtual {
        uint256 currentAllowance = allowance(owner, spender);
        if (currentAllowance != type(uint256).max) {
            require(
                currentAllowance >= amount,
                "ERC20: insufficient allowance"
            );
            unchecked {
                _approve(owner, spender, currentAllowance - amount);
            }
        }
    }

    function _beforeTokenTransfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual {}

    function _afterTokenTransfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual {}
}

library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryAdd(
        uint256 a,
        uint256 b
    ) internal pure returns (bool, uint256) {
        unchecked {
            uint256 c = a + b;
            if (c < a) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function trySub(
        uint256 a,
        uint256 b
    ) internal pure returns (bool, uint256) {
        unchecked {
            if (b > a) return (false, 0);
            return (true, a - b);
        }
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryMul(
        uint256 a,
        uint256 b
    ) internal pure returns (bool, uint256) {
        unchecked {
            // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
            // benefit is lost if 'b' is also tested.
            // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
            if (a == 0) return (true, 0);
            uint256 c = a * b;
            if (c / a != b) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the division of two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryDiv(
        uint256 a,
        uint256 b
    ) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a / b);
        }
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryMod(
        uint256 a,
        uint256 b
    ) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a % b);
        }
    }

    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     *
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        return a + b;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        return a - b;
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     *
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        return a * b;
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator.
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return a / b;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        return a % b;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {trySub}.
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        unchecked {
            require(b <= a, errorMessage);
            return a - b;
        }
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting with custom message on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        unchecked {
            require(b > 0, errorMessage);
            return a / b;
        }
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting with custom message when dividing by zero.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryMod}.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        unchecked {
            require(b > 0, errorMessage);
            return a % b;
        }
    }
}

contract Ownable is Context {
    address private _owner;

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

    constructor() {
        address msgSender = _msgSender();
        _owner = msgSender;
        emit OwnershipTransferred(address(0), msgSender);
    }

    function owner() public view returns (address) {
        return _owner;
    }

    modifier onlyOwner() {
        require(_owner == _msgSender(), "Ownable: caller is not the owner");
        _;
    }

    function renounceOwnership() external virtual onlyOwner {
        emit OwnershipTransferred(_owner, address(0));
        _owner = address(0);
    }

    function transferOwnership(address newOwner) public virtual onlyOwner {
        require(
            newOwner != address(0),
            "Ownable: new owner is the zero address"
        );
        emit OwnershipTransferred(_owner, newOwner);
        _owner = newOwner;
    }
}

interface IRouter {
    error EXPIRED();
    error IDENTICAL();
    error ZERO_ADDRESS();
    error INSUFFICIENT_AMOUNT();
    error INSUFFICIENT_LIQUIDITY();
    error INSUFFICIENT_OUTPUT_AMOUNT();
    error INVALID_PATH();
    error INSUFFICIENT_B_AMOUNT();
    error INSUFFICIENT_A_AMOUNT();
    error EXCESSIVE_INPUT_AMOUNT();
    error ETH_TRANSFER_FAILED();
    error INVALID_RESERVES();

    struct route {
        /// @dev token from
        address from;
        /// @dev token to
        address to;
        /// @dev is stable route
        bool stable;
    }
    function WETH() external pure returns (address);

    function factory() external pure returns (address);
    /// @notice sorts the tokens to see what the expected LP output would be for token0 and token1 (A/B)
    /// @param tokenA the address of tokenA
    /// @param tokenB the address of tokenB
    /// @return token0 address of which becomes token0
    /// @return token1 address of which becomes token1
    function sortTokens(
        address tokenA,
        address tokenB
    ) external pure returns (address token0, address token1);

    /// @notice calculates the CREATE2 address for a pair without making any external calls
    /// @param tokenA the address of tokenA
    /// @param tokenB the address of tokenB
    /// @param stable if the pair is using the stable curve
    /// @return pair address of the pair
    function pairFor(
        address tokenA,
        address tokenB,
        bool stable
    ) external view returns (address pair);

    /// @notice fetches and sorts the reserves for a pair
    /// @param tokenA the address of tokenA
    /// @param tokenB the address of tokenB
    /// @param stable if the pair is using the stable curve
    /// @return reserveA get the reserves for tokenA
    /// @return reserveB get the reserves for tokenB
    function getReserves(
        address tokenA,
        address tokenB,
        bool stable
    ) external view returns (uint256 reserveA, uint256 reserveB);

    /// @notice performs chained getAmountOut calculations on any number of pairs
    /// @param amountIn the amount of tokens of routes[0] to swap
    /// @param routes the struct of the hops the swap should take
    /// @return amounts uint array of the amounts out
    function getAmountsOut(
        uint256 amountIn,
        route[] memory routes
    ) external view returns (uint256[] memory amounts);

    /// @notice performs chained getAmountOut calculations on any number of pairs
    /// @param amountIn amount of tokenIn
    /// @param tokenIn address of the token going in
    /// @param tokenOut address of the token coming out
    /// @return amount uint amount out
    /// @return stable if the curve used is stable or not
    function getAmountOut(
        uint256 amountIn,
        address tokenIn,
        address tokenOut
    ) external view returns (uint256 amount, bool stable);

    /// @notice performs calculations to determine the expected state when adding liquidity
    /// @param tokenA the address of tokenA
    /// @param tokenB the address of tokenB
    /// @param stable if the pair is using the stable curve
    /// @param amountADesired amount of tokenA desired to be added
    /// @param amountBDesired amount of tokenB desired to be added
    /// @return amountA amount of tokenA added
    /// @return amountB amount of tokenB added
    /// @return liquidity liquidity value added
    function quoteAddLiquidity(
        address tokenA,
        address tokenB,
        bool stable,
        uint256 amountADesired,
        uint256 amountBDesired
    )
        external
        view
        returns (uint256 amountA, uint256 amountB, uint256 liquidity);

    /// @param tokenA the address of tokenA
    /// @param tokenB the address of tokenB
    /// @param stable if the pair is using the stable curve
    /// @param liquidity liquidity value to remove
    /// @return amountA amount of tokenA removed
    /// @return amountB amount of tokenB removed
    function quoteRemoveLiquidity(
        address tokenA,
        address tokenB,
        bool stable,
        uint256 liquidity
    ) external view returns (uint256 amountA, uint256 amountB);

    /// @param tokenA the address of tokenA
    /// @param tokenB the address of tokenB
    /// @param stable if the pair is using the stable curve
    /// @param amountADesired amount of tokenA desired to be added
    /// @param amountBDesired amount of tokenB desired to be added
    /// @param amountAMin slippage for tokenA calculated from this param
    /// @param amountBMin slippage for tokenB calculated from this param
    /// @param to the address the liquidity tokens should be minted to
    /// @param deadline timestamp deadline
    /// @return amountA amount of tokenA used
    /// @return amountB amount of tokenB used
    /// @return liquidity amount of liquidity minted
    function addLiquidity(
        address tokenA,
        address tokenB,
        bool stable,
        uint256 amountADesired,
        uint256 amountBDesired,
        uint256 amountAMin,
        uint256 amountBMin,
        address to,
        uint256 deadline
    ) external returns (uint256 amountA, uint256 amountB, uint256 liquidity);

    /// @param token the address of token
    /// @param stable if the pair is using the stable curve
    /// @param amountTokenDesired desired amount for token
    /// @param amountTokenMin slippage for token
    /// @param amountETHMin minimum amount of ETH added (slippage)
    /// @param to the address the liquidity tokens should be minted to
    /// @param deadline timestamp deadline
    /// @return amountToken amount of the token used
    /// @return amountETH amount of ETH used
    /// @return liquidity amount of liquidity minted
    function addLiquidityETH(
        address token,
        bool stable,
        uint256 amountTokenDesired,
        uint256 amountTokenMin,
        uint256 amountETHMin,
        address to,
        uint256 deadline
    )
        external
        payable
        returns (uint256 amountToken, uint256 amountETH, uint256 liquidity);
    /// @param tokenA the address of tokenA
    /// @param tokenB the address of tokenB
    /// @param stable if the pair is using the stable curve
    /// @param amountADesired amount of tokenA desired to be added
    /// @param amountBDesired amount of tokenB desired to be added
    /// @param amountAMin slippage for tokenA calculated from this param
    /// @param amountBMin slippage for tokenB calculated from this param
    /// @param to the address the liquidity tokens should be minted to
    /// @param deadline timestamp deadline
    /// @return amountA amount of tokenA used
    /// @return amountB amount of tokenB used
    /// @return liquidity amount of liquidity minted
    function addLiquidityAndStake(
        address tokenA,
        address tokenB,
        bool stable,
        uint256 amountADesired,
        uint256 amountBDesired,
        uint256 amountAMin,
        uint256 amountBMin,
        address to,
        uint256 deadline
    ) external returns (uint256 amountA, uint256 amountB, uint256 liquidity);

    /// @notice adds liquidity to a legacy pair using ETH, and stakes it into a gauge on "to's" behalf
    /// @param token the address of token
    /// @param stable if the pair is using the stable curve
    /// @param amountTokenDesired amount of token to be used
    /// @param amountTokenMin slippage of token
    /// @param amountETHMin slippage of ETH
    /// @param to the address the liquidity tokens should be minted to
    /// @param deadline timestamp deadline
    /// @return amountA amount of tokenA used
    /// @return amountB amount of tokenB used
    /// @return liquidity amount of liquidity minted
    function addLiquidityETHAndStake(
        address token,
        bool stable,
        uint256 amountTokenDesired,
        uint256 amountTokenMin,
        uint256 amountETHMin,
        address to,
        uint256 deadline
    )
        external
        payable
        returns (uint256 amountA, uint256 amountB, uint256 liquidity);
    /// @param tokenA the address of tokenA
    /// @param tokenB the address of tokenB
    /// @param stable if the pair is using the stable curve
    /// @param liquidity amount of LP tokens to remove
    /// @param amountAMin slippage of tokenA
    /// @param amountBMin slippage of tokenB
    /// @param to the address the liquidity tokens should be minted to
    /// @param deadline timestamp deadline
    /// @return amountA amount of tokenA used
    /// @return amountB amount of tokenB used
    function removeLiquidity(
        address tokenA,
        address tokenB,
        bool stable,
        uint256 liquidity,
        uint256 amountAMin,
        uint256 amountBMin,
        address to,
        uint256 deadline
    ) external returns (uint256 amountA, uint256 amountB);
    /// @param token address of the token
    /// @param stable if the pair is using the stable curve
    /// @param liquidity liquidity tokens to remove
    /// @param amountTokenMin slippage of token
    /// @param amountETHMin slippage of ETH
    /// @param to the address the liquidity tokens should be minted to
    /// @param deadline timestamp deadline
    /// @return amountToken amount of token used
    /// @return amountETH amount of ETH used
    function removeLiquidityETH(
        address token,
        bool stable,
        uint256 liquidity,
        uint256 amountTokenMin,
        uint256 amountETHMin,
        address to,
        uint256 deadline
    ) external returns (uint256 amountToken, uint256 amountETH);
    /// @param amountIn amount to send ideally
    /// @param amountOutMin slippage of amount out
    /// @param routes the hops the swap should take
    /// @param to the address the liquidity tokens should be minted to
    /// @param deadline timestamp deadline
    /// @return amounts amounts returned
    function swapExactTokensForTokens(
        uint256 amountIn,
        uint256 amountOutMin,
        route[] calldata routes,
        address to,
        uint256 deadline
    ) external returns (uint256[] memory amounts);
    /// @param routes the hops the swap should take
    /// @param to the address the liquidity tokens should be minted to
    /// @param deadline timestamp deadline
    /// @return amounts amounts returned
    function swapTokensForExactTokens(
        uint amountOut,
        uint amountInMax,
        route[] memory routes,
        address to,
        uint deadline
    ) external returns (uint256[] memory amounts);
    /// @param amountOutMin slippage of token
    /// @param routes the hops the swap should take
    /// @param to the address the liquidity tokens should be minted to
    /// @param deadline timestamp deadline
    /// @return amounts amounts returned
    function swapExactETHForTokens(
        uint256 amountOutMin,
        route[] calldata routes,
        address to,
        uint256 deadline
    ) external payable returns (uint256[] memory amounts);
    /// @param amountOut amount of tokens to get out
    /// @param amountInMax max amount of tokens to put in to achieve amountOut (slippage)
    /// @param routes the hops the swap should take
    /// @param to the address the liquidity tokens should be minted to
    /// @param deadline timestamp deadline
    /// @return amounts amounts returned
    function swapTokensForExactETH(
        uint amountOut,
        uint amountInMax,
        route[] calldata routes,
        address to,
        uint deadline
    ) external returns (uint256[] memory amounts);
    /// @param amountIn amount of tokens to swap
    /// @param amountOutMin slippage of token
    /// @param routes the hops the swap should take
    /// @param to the address the liquidity tokens should be minted to
    /// @param deadline timestamp deadline
    /// @return amounts amounts returned
    function swapExactTokensForETH(
        uint256 amountIn,
        uint256 amountOutMin,
        route[] calldata routes,
        address to,
        uint256 deadline
    ) external returns (uint256[] memory amounts);
    /// @param amountOut exact amount out or revert
    /// @param routes the hops the swap should take
    /// @param to the address the liquidity tokens should be minted to
    /// @param deadline timestamp deadline
    /// @return amounts amounts returned
    function swapETHForExactTokens(
        uint amountOut,
        route[] calldata routes,
        address to,
        uint deadline
    ) external payable returns (uint256[] memory amounts);

    /// @param amountIn token amount to swap
    /// @param amountOutMin slippage of token
    /// @param routes the hops the swap should take
    /// @param to the address the liquidity tokens should be minted to
    /// @param deadline timestamp deadline
    function swapExactTokensForTokensSupportingFeeOnTransferTokens(
        uint256 amountIn,
        uint256 amountOutMin,
        route[] calldata routes,
        address to,
        uint256 deadline
    ) external;

    /// @param amountOutMin slippage of token
    /// @param routes the hops the swap should take
    /// @param to the address the liquidity tokens should be minted to
    /// @param deadline timestamp deadline
    function swapExactETHForTokensSupportingFeeOnTransferTokens(
        uint256 amountOutMin,
        route[] calldata routes,
        address to,
        uint256 deadline
    ) external payable;

    /// @param amountIn token amount to swap
    /// @param amountOutMin slippage of token
    /// @param routes the hops the swap should take
    /// @param to the address the liquidity tokens should be minted to
    /// @param deadline timestamp deadline
    function swapExactTokensForETHSupportingFeeOnTransferTokens(
        uint256 amountIn,
        uint256 amountOutMin,
        route[] calldata routes,
        address to,
        uint256 deadline
    ) external;

    /// @notice **** REMOVE LIQUIDITY (supporting fee-on-transfer tokens)****
    /// @param token address of the token
    /// @param stable if the swap curve is stable
    /// @param liquidity liquidity value (lp tokens)
    /// @param amountTokenMin slippage of token
    /// @param amountETHMin slippage of ETH
    /// @param to address to send to
    /// @param deadline timestamp deadline
    /// @return amountToken amount of token received
    /// @return amountETH amount of ETH received
    function removeLiquidityETHSupportingFeeOnTransferTokens(
        address token,
        bool stable,
        uint256 liquidity,
        uint256 amountTokenMin,
        uint256 amountETHMin,
        address to,
        uint256 deadline
    ) external returns (uint256 amountToken, uint256 amountETH);
}

interface IPairFactory {
    function createPair(
        address tokenA,
        address tokenB,
        bool stable
    ) external returns (address pair);
}

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

        return account.code.length > 0;
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

interface IERC20Permit {
    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external;

    function nonces(address owner) external view returns (uint256);

    function DOMAIN_SEPARATOR() external view returns (bytes32);
}

library SafeERC20 {
    using Address for address;

    function safeTransfer(IERC20 token, address to, uint256 value) internal {
        _callOptionalReturn(
            token,
            abi.encodeWithSelector(token.transfer.selector, to, value)
        );
    }

    function safeTransferFrom(
        IERC20 token,
        address from,
        address to,
        uint256 value
    ) internal {
        _callOptionalReturn(
            token,
            abi.encodeWithSelector(token.transferFrom.selector, from, to, value)
        );
    }

    function safeApprove(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        require(
            (value == 0) || (token.allowance(address(this), spender) == 0),
            "SafeERC20: approve from non-zero to non-zero allowance"
        );
        _callOptionalReturn(
            token,
            abi.encodeWithSelector(token.approve.selector, spender, value)
        );
    }

    function safeIncreaseAllowance(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        uint256 newAllowance = token.allowance(address(this), spender) + value;
        _callOptionalReturn(
            token,
            abi.encodeWithSelector(
                token.approve.selector,
                spender,
                newAllowance
            )
        );
    }

    function safeDecreaseAllowance(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        unchecked {
            uint256 oldAllowance = token.allowance(address(this), spender);
            require(
                oldAllowance >= value,
                "SafeERC20: decreased allowance below zero"
            );
            uint256 newAllowance = oldAllowance - value;
            _callOptionalReturn(
                token,
                abi.encodeWithSelector(
                    token.approve.selector,
                    spender,
                    newAllowance
                )
            );
        }
    }

    function safePermit(
        IERC20Permit token,
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal {
        uint256 nonceBefore = token.nonces(owner);
        token.permit(owner, spender, value, deadline, v, r, s);
        uint256 nonceAfter = token.nonces(owner);
        require(
            nonceAfter == nonceBefore + 1,
            "SafeERC20: permit did not succeed"
        );
    }

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     */
    function _callOptionalReturn(IERC20 token, bytes memory data) private {
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
        // we're implementing it ourselves. We use {Address-functionCall} to perform this call, which verifies that
        // the target address contains contract code and also asserts for success in the low-level call.

        bytes memory returndata = address(token).functionCall(
            data,
            "SafeERC20: low-level call failed"
        );
        if (returndata.length > 0) {
            // Return data is optional
            require(
                abi.decode(returndata, (bool)),
                "SafeERC20: ERC20 operation did not succeed"
            );
        }
    }
}

interface ISFOG is IERC20 {
    function burn(address from, uint256 amount) external;

    function mint(address to, uint256 amount) external;
}

contract SFOG is ISFOG, ERC20, Ownable {
    uint256 private initialSupply;
    uint256 public maxSupply;
    address public uniswapPair;
    IRouter public uniswapRouter;

    using SafeMath for uint256;
    using SafeERC20 for ERC20;

    mapping(address => bool) private isController;

    bool public tradingEnabled = false;
    address public treasuryAddress;

    uint256 public taxSellForMarketing = 30;
    uint256 public taxBuyForMarketing = 30;

    uint256 private _marketingReserves = 0;
    uint256 private _numTokensSellToAddToETH = 0;

    uint256 _decimals = 18;

    uint256 public maxWalletAmount = 2_000 * 10 ** _decimals;

    address public marketingWallet = 0xE5BA248f5F1FC18Dd2A1f3ceb5c8FbFa9414F84f;

    mapping(address => bool) private _isExcludedFromFee;

    bool inSwapAndLiquify;


    constructor() ERC20("SFOG", "SFOG") {
        IRouter _uniswapRouter = IRouter(
            0x1D368773735ee1E678950B7A97bcA2CafB330CDc
        );
        uniswapRouter = _uniswapRouter;
        // address _factory = _uniswapRouter.factory();
        
        // uniswapPair = IPairFactory(_factory).createPair(
        //     address(this),
        //     _uniswapRouter.WETH(),
        //     false
        // );

        _isExcludedFromFee[address(uniswapRouter)] = true;
        _isExcludedFromFee[marketingWallet] = true;
        _isExcludedFromFee[address(this)] = true;
        _isExcludedFromFee[msg.sender] = true;

        initialSupply = 100_000 * 10 ** _decimals;
        maxSupply = 1_000_000 * 10 ** _decimals;

        _numTokensSellToAddToETH = 50 * 10 ** _decimals;

        treasuryAddress = msg.sender;
        isController[msg.sender] = true;
        _mint(msg.sender, initialSupply);
    }

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

    function mint(
        address to_,
        uint256 amount_
    ) external override onlyController {
        require(
            totalSupply().add(amount_) <= maxSupply,
            "Maximum supply reached"
        );
        _mint(to_, amount_);
    }

    function burn(
        address from_,
        uint256 amount_
    ) external override onlyController {
        _burn(from_, amount_);
    }

    event ControllerAdded(address newController);

    function addController(address toAdd_) external onlyOwner {
        isController[toAdd_] = true;
        emit ControllerAdded(toAdd_);
    }

    event ControllerRemoved(address controllerRemoved);

    function removeController(address toRemove_) external onlyOwner {
        isController[toRemove_] = false;
        emit ControllerRemoved(toRemove_);
    }

    modifier onlyController() {
        require(isController[_msgSender()], "CallerNotController");
        _;
    }

    function pause_trading() public onlyOwner {
        tradingEnabled = false;
    }

    function enable_trading() public onlyOwner {
        tradingEnabled = true;
    }

    function getPair() public view returns (address) {
        return uniswapPair;
    }

    function _transfer(
        address from,
        address to,
        uint256 amount
    ) internal override {
        require(
            tradingEnabled || _isExcludedFromFee[from],
            "Transfer is disabled"
        );
        if ((from == uniswapPair || to == uniswapPair) && !inSwapAndLiquify) {
            if (from != uniswapPair) {
                uint256 balanceContract = balanceOf(address(this));
                if (_marketingReserves >= _numTokensSellToAddToETH) {
                    _swapTokensForEth(balanceContract);
                    _marketingReserves = 0;
                }
            }

            uint256 transferAmount;
            if (_isExcludedFromFee[from] || _isExcludedFromFee[to]) {
                transferAmount = amount;
            } else {
                if (from == uniswapPair) {
                    require(
                        (amount + balanceOf(to)) <= maxWalletAmount,
                        "ERC20: balance amount exceeded max wallet amount limit"
                    );
                }
                uint256 marketingShare = 0;
                if (from == uniswapPair) {
                    marketingShare = ((amount * taxBuyForMarketing) / 100);
                } else if (to == uniswapPair) {
                    marketingShare = ((amount * taxSellForMarketing) / 100);
                }
                transferAmount = amount - (marketingShare);
                _marketingReserves += marketingShare;
                super._transfer(from, address(this), marketingShare);
            }
            super._transfer(from, to, transferAmount);
        } else {
            super._transfer(from, to, amount);
        }
    }

    function _swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
        address[] memory path = new address[](2);
        path[0] = address(this);
        path[1] = uniswapRouter.WETH();

        _approve(address(this), address(uniswapRouter), tokenAmount);
        IRouter.route[] memory routes;
        routes[0].from = path[0];
        routes[0].to = path[1];
        routes[0].stable = false;

        uniswapRouter.swapExactTokensForETHSupportingFeeOnTransferTokens(
            tokenAmount,
            0,
            routes,
            marketingWallet,
            block.timestamp + 2000
        );
    }

    function changeTaxForMarketing(
        uint256 _taxBuyForMarketing,
        uint256 _taxSellForMarketing
    ) public onlyOwner returns (bool) {
        require(
            _taxBuyForMarketing <= 99 && _taxSellForMarketing <= 99,
            "ERC20: total tax must not be greater than 100"
        );
        taxBuyForMarketing = _taxBuyForMarketing;
        taxSellForMarketing = _taxSellForMarketing;

        return true;
    }

    function changeNumSellAddToETH(
        uint256 _numSell
    ) public onlyOwner returns (bool) {
        _numTokensSellToAddToETH = _numSell;
        return true;
    }

    function changeMarketingWallet(
        address _address
    ) public onlyOwner returns (bool) {
        marketingWallet = _address;

        return true;
    }

    function changeLimitWallet(
        uint256 _maxWallet
    ) public onlyOwner returns (bool) {
        maxWalletAmount = _maxWallet;

        return true;
    }

    function setIsExcludeFee(
        address[] memory _address,
        bool state
    ) public onlyOwner returns (bool) {
        for (uint256 i = 0; i < _address.length; i++) {
            _isExcludedFromFee[_address[i]] = state;
        }
        return true;
    }

    function setPair(
        address _pair
    ) public onlyOwner returns (bool) {
        uniswapPair = _pair;
    }
}

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"newController","type":"address"}],"name":"ControllerAdded","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"controllerRemoved","type":"address"}],"name":"ControllerRemoved","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":"toAdd_","type":"address"}],"name":"addController","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from_","type":"address"},{"internalType":"uint256","name":"amount_","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_maxWallet","type":"uint256"}],"name":"changeLimitWallet","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_address","type":"address"}],"name":"changeMarketingWallet","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_numSell","type":"uint256"}],"name":"changeNumSellAddToETH","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_taxBuyForMarketing","type":"uint256"},{"internalType":"uint256","name":"_taxSellForMarketing","type":"uint256"}],"name":"changeTaxForMarketing","outputs":[{"internalType":"bool","name":"","type":"bool"}],"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":[],"name":"enable_trading","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"getPair","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"addedValue","type":"uint256"}],"name":"increaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"marketingWallet","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxWalletAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to_","type":"address"},{"internalType":"uint256","name":"amount_","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pause_trading","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"toRemove_","type":"address"}],"name":"removeController","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address[]","name":"_address","type":"address[]"},{"internalType":"bool","name":"state","type":"bool"}],"name":"setIsExcludeFee","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_pair","type":"address"}],"name":"setPair","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"taxBuyForMarketing","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"taxSellForMarketing","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"tradingEnabled","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"treasuryAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"uniswapPair","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"uniswapRouter","outputs":[{"internalType":"contract IRouter","name":"","type":"address"}],"stateMutability":"view","type":"function"}]

Contract Creation Code

Decompile Bytecode Switch to Opcodes View

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

Deployed Bytecode

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

Deployed Bytecode Sourcemap

45411:6925:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2425:100;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;3478:226;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2746:108;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;3712:295;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;51760:166;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2645:93;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;50953:444;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;4015:263;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;47321:262;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;51934:273;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;45715:34;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2862:143;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;15276:150;;;:::i;:::-;;45557:28;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;46082:75;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;51405:173;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;52215:118;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;15062:79;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2533:104;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;47591:144;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;4286:498;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;47796:143;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;3013:218;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;46017:56;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;48295:83;;;:::i;:::-;;45841:38;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;51586:166;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;48477:86;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;45756:30;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;45524:26;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;48386:83;;;:::i;:::-;;45795:39;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;45493:24;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;3294:176;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;15434:281;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;48006:158;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;2425:100;2479:13;2512:5;2505:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2425:100;:::o;3478:226::-;3586:4;3603:13;3619:12;:10;:12::i;:::-;3603:28;;3642:32;3651:5;3658:7;3667:6;3642:8;:32::i;:::-;3692:4;3685:11;;;3478:226;;;;:::o;2746:108::-;2807:7;2834:12;;2827:19;;2746:108;:::o;3712:295::-;3843:4;3860:15;3878:12;:10;:12::i;:::-;3860:30;;3901:38;3917:4;3923:7;3932:6;3901:15;:38::i;:::-;3950:27;3960:4;3966:2;3970:6;3950:9;:27::i;:::-;3995:4;3988:11;;;3712:295;;;;;:::o;51760:166::-;51849:4;15199:12;:10;:12::i;:::-;15189:22;;:6;;;;;;;;;;;:22;;;15181:67;;;;;;;;;;;;:::i;:::-;;;;;;;;;51884:10:::1;51866:15;:28;;;;51914:4;51907:11;;51760:166:::0;;;:::o;2645:93::-;2703:5;2728:2;2721:9;;2645:93;:::o;50953:444::-;51094:4;15199:12;:10;:12::i;:::-;15189:22;;:6;;;;;;;;;;;:22;;;15181:67;;;;;;;;;;;;:::i;:::-;;;;;;;;;51156:2:::1;51133:19;:25;;:55;;;;;51186:2;51162:20;:26;;51133:55;51111:150;;;;;;;;;;;;:::i;:::-;;;;;;;;;51293:19;51272:18;:40;;;;51345:20;51323:19;:42;;;;51385:4;51378:11;;50953:444:::0;;;;:::o;4015:263::-;4128:4;4145:13;4161:12;:10;:12::i;:::-;4145:28;;4184:64;4193:5;4200:7;4237:10;4209:25;4219:5;4226:7;4209:9;:25::i;:::-;:38;;;;:::i;:::-;4184:8;:64::i;:::-;4266:4;4259:11;;;4015:263;;;;:::o;47321:262::-;48217:12;:26;48230:12;:10;:12::i;:::-;48217:26;;;;;;;;;;;;;;;;;;;;;;;;;48209:58;;;;;;;;;;;;:::i;:::-;;;;;;;;;47486:9:::1;;47456:26;47474:7;47456:13;:11;:13::i;:::-;:17;;:26;;;;:::i;:::-;:39;;47434:111;;;;;;;;;;;;:::i;:::-;;;;;;;;;47556:19;47562:3;47567:7;47556:5;:19::i;:::-;47321:262:::0;;:::o;51934:273::-;52049:4;15199:12;:10;:12::i;:::-;15189:22;;:6;;;;;;;;;;;:22;;;15181:67;;;;;;;;;;;;:::i;:::-;;;;;;;;;52071:9:::1;52066:112;52090:8;:15;52086:1;:19;52066:112;;;52161:5;52127:18;:31;52146:8;52155:1;52146:11;;;;;;;;:::i;:::-;;;;;;;;52127:31;;;;;;;;;;;;;;;;:39;;;;;;;;;;;;;;;;;;52107:3;;;;;;;52066:112;;;;52195:4;52188:11;;51934:273:::0;;;;:::o;45715:34::-;;;;;;;;;;;;;:::o;2862:143::-;2952:7;2979:9;:18;2989:7;2979:18;;;;;;;;;;;;;;;;2972:25;;2862:143;;;:::o;15276:150::-;15199:12;:10;:12::i;:::-;15189:22;;:6;;;;;;;;;;;:22;;;15181:67;;;;;;;;;;;;:::i;:::-;;;;;;;;;15385:1:::1;15348:40;;15369:6;;;;;;;;;;;15348:40;;;;;;;;;;;;15416:1;15399:6;;:19;;;;;;;;;;;;;;;;;;15276:150::o:0;45557:28::-;;;;;;;;;;;;;:::o;46082:75::-;;;;;;;;;;;;;:::o;51405:173::-;51496:4;15199:12;:10;:12::i;:::-;15189:22;;:6;;;;;;;;;;;:22;;;15181:67;;;;;;;;;;;;:::i;:::-;;;;;;;;;51540:8:::1;51513:24;:35;;;;51566:4;51559:11;;51405:173:::0;;;:::o;52215:118::-;52289:4;15199:12;:10;:12::i;:::-;15189:22;;:6;;;;;;;;;;;:22;;;15181:67;;;;;;;;;;;;:::i;:::-;;;;;;;;;52320:5:::1;52306:11;;:19;;;;;;;;;;;;;;;;;;52215:118:::0;;;:::o;15062:79::-;15100:7;15127:6;;;;;;;;;;;15120:13;;15062:79;:::o;2533:104::-;2589:13;2622:7;2615:14;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2533:104;:::o;47591:144::-;48217:12;:26;48230:12;:10;:12::i;:::-;48217:26;;;;;;;;;;;;;;;;;;;;;;;;;48209:58;;;;;;;;;;;;:::i;:::-;;;;;;;;;47706:21:::1;47712:5;47719:7;47706:5;:21::i;:::-;47591:144:::0;;:::o;4286:498::-;4404:4;4421:13;4437:12;:10;:12::i;:::-;4421:28;;4460:24;4487:25;4497:5;4504:7;4487:9;:25::i;:::-;4460:52;;4565:15;4545:16;:35;;4523:122;;;;;;;;;;;;:::i;:::-;;;;;;;;;4681:60;4690:5;4697:7;4725:15;4706:16;:34;4681:8;:60::i;:::-;4772:4;4765:11;;;;4286:498;;;;:::o;47796:143::-;15199:12;:10;:12::i;:::-;15189:22;;:6;;;;;;;;;;;:22;;;15181:67;;;;;;;;;;;;:::i;:::-;;;;;;;;;47888:4:::1;47865:12;:20;47878:6;47865:20;;;;;;;;;;;;;;;;:27;;;;;;;;;;;;;;;;;;47908:23;47924:6;47908:23;;;;;;:::i;:::-;;;;;;;;47796:143:::0;:::o;3013:218::-;3117:4;3134:13;3150:12;:10;:12::i;:::-;3134:28;;3173;3183:5;3190:2;3194:6;3173:9;:28::i;:::-;3219:4;3212:11;;;3013:218;;;;:::o;46017:56::-;;;;:::o;48295:83::-;15199:12;:10;:12::i;:::-;15189:22;;:6;;;;;;;;;;;:22;;;15181:67;;;;;;;;;;;;:::i;:::-;;;;;;;;;48365:5:::1;48348:14;;:22;;;;;;;;;;;;;;;;;;48295:83::o:0;45841:38::-;;;;:::o;51586:166::-;51677:4;15199:12;:10;:12::i;:::-;15189:22;;:6;;;;;;;;;;;:22;;;15181:67;;;;;;;;;;;;:::i;:::-;;;;;;;;;51712:8:::1;51694:15;;:26;;;;;;;;;;;;;;;;;;51740:4;51733:11;;51586:166:::0;;;:::o;48477:86::-;48517:7;48544:11;;;;;;;;;;;48537:18;;48477:86;:::o;45756:30::-;;;;;;;;;;;;;:::o;45524:26::-;;;;;;;;;;;;;:::o;48386:83::-;15199:12;:10;:12::i;:::-;15189:22;;:6;;;;;;;;;;;:22;;;15181:67;;;;;;;;;;;;:::i;:::-;;;;;;;;;48457:4:::1;48440:14;;:21;;;;;;;;;;;;;;;;;;48386:83::o:0;45795:39::-;;;;:::o;45493:24::-;;;;:::o;3294:176::-;3408:7;3435:11;:18;3447:5;3435:18;;;;;;;;;;;;;;;:27;3454:7;3435:27;;;;;;;;;;;;;;;;3428:34;;3294:176;;;;:::o;15434:281::-;15199:12;:10;:12::i;:::-;15189:22;;:6;;;;;;;;;;;:22;;;15181:67;;;;;;;;;;;;:::i;:::-;;;;;;;;;15557:1:::1;15537:22;;:8;:22;;::::0;15515:110:::1;;;;;;;;;;;;:::i;:::-;;;;;;;;;15670:8;15641:38;;15662:6;;;;;;;;;;;15641:38;;;;;;;;;;;;15699:8;15690:6;;:17;;;;;;;;;;;;;;;;;;15434:281:::0;:::o;48006:158::-;15199:12;:10;:12::i;:::-;15189:22;;:6;;;;;;;;;;;:22;;;15181:67;;;;;;;;;;;;:::i;:::-;;;;;;;;;48107:5:::1;48081:12;:23;48094:9;48081:23;;;;;;;;;;;;;;;;:31;;;;;;;;;;;;;;;;;;48128:28;48146:9;48128:28;;;;;;:::i;:::-;;;;;;;;48006:158:::0;:::o;162:98::-;215:7;242:10;235:17;;162:98;:::o;6916:380::-;7069:1;7052:19;;:5;:19;;;7044:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;7150:1;7131:21;;:7;:21;;;7123:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;7234:6;7204:11;:18;7216:5;7204:18;;;;;;;;;;;;;;;:27;7223:7;7204:27;;;;;;;;;;;;;;;:36;;;;7272:7;7256:32;;7265:5;7256:32;;;7281:6;7256:32;;;;;;:::i;:::-;;;;;;;;6916:380;;;:::o;7304:502::-;7439:24;7466:25;7476:5;7483:7;7466:9;:25::i;:::-;7439:52;;7526:17;7506:16;:37;7502:297;;7606:6;7586:16;:26;;7560:117;;;;;;;;;;;;:::i;:::-;;;;;;;;;7721:51;7730:5;7737:7;7765:6;7746:16;:25;7721:8;:51::i;:::-;7502:297;7428:378;7304:502;;;:::o;48571:1730::-;48717:14;;;;;;;;;;;:42;;;;48735:18;:24;48754:4;48735:24;;;;;;;;;;;;;;;;;;;;;;;;;48717:42;48695:112;;;;;;;;;;;;:::i;:::-;;;;;;;;;48831:11;;;;;;;;;;;48823:19;;:4;:19;;;:40;;;;48852:11;;;;;;;;;;;48846:17;;:2;:17;;;48823:40;48822:63;;;;;48869:16;;;;;;;;;;;48868:17;48822:63;48818:1476;;;48914:11;;;;;;;;;;;48906:19;;:4;:19;;;48902:302;;48946:23;48972:24;48990:4;48972:9;:24::i;:::-;48946:50;;49041:24;;49019:18;;:46;49015:174;;49090:34;49108:15;49090:17;:34::i;:::-;49168:1;49147:18;:22;;;;49015:174;48927:277;48902:302;49220:22;49261:18;:24;49280:4;49261:24;;;;;;;;;;;;;;;;;;;;;;;;;:50;;;;49289:18;:22;49308:2;49289:22;;;;;;;;;;;;;;;;;;;;;;;;;49261:50;49257:904;;;49349:6;49332:23;;49257:904;;;49408:11;;;;;;;;;;;49400:19;;:4;:19;;;49396:251;;49506:15;;49488:13;49498:2;49488:9;:13::i;:::-;49479:6;:22;;;;:::i;:::-;49478:43;;49444:183;;;;;;;;;;;;:::i;:::-;;;;;;;;;49396:251;49665:22;49722:11;;;;;;;;;;;49714:19;;:4;:19;;;49710:249;;49808:3;49786:18;;49777:6;:27;;;;:::i;:::-;49776:35;;;;:::i;:::-;49758:54;;49710:249;;;49848:11;;;;;;;;;;;49842:17;;:2;:17;;;49838:121;;49935:3;49912:19;;49903:6;:28;;;;:::i;:::-;49902:36;;;;:::i;:::-;49884:55;;49838:121;49710:249;50004:14;49994:6;:25;;;;:::i;:::-;49977:42;;50060:14;50038:18;;:36;;;;;;;:::i;:::-;;;;;;;;50093:52;50109:4;50123;50130:14;50093:15;:52::i;:::-;49377:784;49257:904;50175:41;50191:4;50197:2;50201:14;50175:15;:41::i;:::-;48887:1341;48818:1476;;;50249:33;50265:4;50271:2;50275:6;50249:15;:33::i;:::-;48818:1476;48571:1730;;;:::o;10553:98::-;10611:7;10642:1;10638;:5;;;;:::i;:::-;10631:12;;10553:98;;;;:::o;5677:548::-;5780:1;5761:21;;:7;:21;;;5753:65;;;;;;;;;;;;:::i;:::-;;;;;;;;;5831:49;5860:1;5864:7;5873:6;5831:20;:49::i;:::-;5909:6;5893:12;;:22;;;;;;;:::i;:::-;;;;;;;;6086:6;6064:9;:18;6074:7;6064:18;;;;;;;;;;;;;;;;:28;;;;;;;;;;;6140:7;6119:37;;6136:1;6119:37;;;6149:6;6119:37;;;;;;:::i;:::-;;;;;;;;6169:48;6197:1;6201:7;6210:6;6169:19;:48::i;:::-;5677:548;;:::o;6233:675::-;6336:1;6317:21;;:7;:21;;;6309:67;;;;;;;;;;;;:::i;:::-;;;;;;;;;6389:49;6410:7;6427:1;6431:6;6389:20;:49::i;:::-;6451:22;6476:9;:18;6486:7;6476:18;;;;;;;;;;;;;;;;6451:43;;6531:6;6513:14;:24;;6505:71;;;;;;;;;;;;:::i;:::-;;;;;;;;;6650:6;6633:14;:23;6612:9;:18;6622:7;6612:18;;;;;;;;;;;;;;;:44;;;;6767:6;6751:12;;:22;;;;;;;;;;;6828:1;6802:37;;6811:7;6802:37;;;6832:6;6802:37;;;;;;:::i;:::-;;;;;;;;6852:48;6872:7;6889:1;6893:6;6852:19;:48::i;:::-;6298:610;6233:675;;:::o;50309:636::-;47254:4;47235:16;;:23;;;;;;;;;;;;;;;;;;50388:21:::1;50426:1;50412:16;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;50388:40;;50457:4;50439;50444:1;50439:7;;;;;;;;:::i;:::-;;;;;;;:23;;;;;;;;;::::0;::::1;50483:13;;;;;;;;;;;:18;;;:20;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;50473:4;50478:1;50473:7;;;;;;;;:::i;:::-;;;;;;;:30;;;;;;;;;::::0;::::1;50516:60;50533:4;50548:13;;;;;;;;;;;50564:11;50516:8;:60::i;:::-;50587:29;50644:4;50649:1;50644:7;;;;;;;;:::i;:::-;;;;;;;;50627:6;50634:1;50627:9;;;;;;;;:::i;:::-;;;;;;;;:14;;:24;;;;;;;;;::::0;::::1;50677:4;50682:1;50677:7;;;;;;;;:::i;:::-;;;;;;;;50662:6;50669:1;50662:9;;;;;;;;:::i;:::-;;;;;;;;:12;;:22;;;;;;;;;::::0;::::1;50714:5;50695:6;50702:1;50695:9;;;;;;;;:::i;:::-;;;;;;;;:16;;:24;;;;;;;;;::::0;::::1;50732:13;;;;;;;;;;;:64;;;50811:11;50837:1;50853:6;50874:15;;;;;;;;;;;50922:4;50904:15;:22;;;;:::i;:::-;50732:205;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;50377:568;;47300:5:::0;47281:16;;:24;;;;;;;;;;;;;;;;;;50309:636;:::o;4792:877::-;4939:1;4923:18;;:4;:18;;;4915:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;5016:1;5002:16;;:2;:16;;;4994:64;;;;;;;;;;;;:::i;:::-;;;;;;;;;5071:38;5092:4;5098:2;5102:6;5071:20;:38::i;:::-;5122:19;5144:9;:15;5154:4;5144:15;;;;;;;;;;;;;;;;5122:37;;5207:6;5192:11;:21;;5170:109;;;;;;;;;;;;:::i;:::-;;;;;;;;;5347:6;5333:11;:20;5315:9;:15;5325:4;5315:15;;;;;;;;;;;;;;;:38;;;;5550:6;5533:9;:13;5543:2;5533:13;;;;;;;;;;;;;;;;:23;;;;;;;;;;;5600:2;5585:26;;5594:4;5585:26;;;5604:6;5585:26;;;;;;:::i;:::-;;;;;;;;5624:37;5644:4;5650:2;5654:6;5624:19;:37::i;:::-;4904:765;4792:877;;;:::o;7814:125::-;;;;:::o;7947:124::-;;;;:::o;7:99:1:-;59:6;93:5;87:12;77:22;;7:99;;;:::o;112:169::-;196:11;230:6;225:3;218:19;270:4;265:3;261:14;246:29;;112:169;;;;:::o;287:139::-;376:6;371:3;366;360:23;417:1;408:6;403:3;399:16;392:27;287:139;;;:::o;432:102::-;473:6;524:2;520:7;515:2;508:5;504:14;500:28;490:38;;432:102;;;:::o;540:377::-;628:3;656:39;689:5;656:39;:::i;:::-;711:71;775:6;770:3;711:71;:::i;:::-;704:78;;791:65;849:6;844:3;837:4;830:5;826:16;791:65;:::i;:::-;881:29;903:6;881:29;:::i;:::-;876:3;872:39;865:46;;632:285;540:377;;;;:::o;923:313::-;1036:4;1074:2;1063:9;1059:18;1051:26;;1123:9;1117:4;1113:20;1109:1;1098:9;1094:17;1087:47;1151:78;1224:4;1215:6;1151:78;:::i;:::-;1143:86;;923:313;;;;:::o;1242:75::-;1275:6;1308:2;1302:9;1292:19;;1242:75;:::o;1323:117::-;1432:1;1429;1422:12;1446:117;1555:1;1552;1545:12;1569:126;1606:7;1646:42;1639:5;1635:54;1624:65;;1569:126;;;:::o;1701:96::-;1738:7;1767:24;1785:5;1767:24;:::i;:::-;1756:35;;1701:96;;;:::o;1803:122::-;1876:24;1894:5;1876:24;:::i;:::-;1869:5;1866:35;1856:63;;1915:1;1912;1905:12;1856:63;1803:122;:::o;1931:139::-;1977:5;2015:6;2002:20;1993:29;;2031:33;2058:5;2031:33;:::i;:::-;1931:139;;;;:::o;2076:77::-;2113:7;2142:5;2131:16;;2076:77;;;:::o;2159:122::-;2232:24;2250:5;2232:24;:::i;:::-;2225:5;2222:35;2212:63;;2271:1;2268;2261:12;2212:63;2159:122;:::o;2287:139::-;2333:5;2371:6;2358:20;2349:29;;2387:33;2414:5;2387:33;:::i;:::-;2287:139;;;;:::o;2432:474::-;2500:6;2508;2557:2;2545:9;2536:7;2532:23;2528:32;2525:119;;;2563:79;;:::i;:::-;2525:119;2683:1;2708:53;2753:7;2744:6;2733:9;2729:22;2708:53;:::i;:::-;2698:63;;2654:117;2810:2;2836:53;2881:7;2872:6;2861:9;2857:22;2836:53;:::i;:::-;2826:63;;2781:118;2432:474;;;;;:::o;2912:90::-;2946:7;2989:5;2982:13;2975:21;2964:32;;2912:90;;;:::o;3008:109::-;3089:21;3104:5;3089:21;:::i;:::-;3084:3;3077:34;3008:109;;:::o;3123:210::-;3210:4;3248:2;3237:9;3233:18;3225:26;;3261:65;3323:1;3312:9;3308:17;3299:6;3261:65;:::i;:::-;3123:210;;;;:::o;3339:118::-;3426:24;3444:5;3426:24;:::i;:::-;3421:3;3414:37;3339:118;;:::o;3463:222::-;3556:4;3594:2;3583:9;3579:18;3571:26;;3607:71;3675:1;3664:9;3660:17;3651:6;3607:71;:::i;:::-;3463:222;;;;:::o;3691:619::-;3768:6;3776;3784;3833:2;3821:9;3812:7;3808:23;3804:32;3801:119;;;3839:79;;:::i;:::-;3801:119;3959:1;3984:53;4029:7;4020:6;4009:9;4005:22;3984:53;:::i;:::-;3974:63;;3930:117;4086:2;4112:53;4157:7;4148:6;4137:9;4133:22;4112:53;:::i;:::-;4102:63;;4057:118;4214:2;4240:53;4285:7;4276:6;4265:9;4261:22;4240:53;:::i;:::-;4230:63;;4185:118;3691:619;;;;;:::o;4316:329::-;4375:6;4424:2;4412:9;4403:7;4399:23;4395:32;4392:119;;;4430:79;;:::i;:::-;4392:119;4550:1;4575:53;4620:7;4611:6;4600:9;4596:22;4575:53;:::i;:::-;4565:63;;4521:117;4316:329;;;;:::o;4651:86::-;4686:7;4726:4;4719:5;4715:16;4704:27;;4651:86;;;:::o;4743:112::-;4826:22;4842:5;4826:22;:::i;:::-;4821:3;4814:35;4743:112;;:::o;4861:214::-;4950:4;4988:2;4977:9;4973:18;4965:26;;5001:67;5065:1;5054:9;5050:17;5041:6;5001:67;:::i;:::-;4861:214;;;;:::o;5081:474::-;5149:6;5157;5206:2;5194:9;5185:7;5181:23;5177:32;5174:119;;;5212:79;;:::i;:::-;5174:119;5332:1;5357:53;5402:7;5393:6;5382:9;5378:22;5357:53;:::i;:::-;5347:63;;5303:117;5459:2;5485:53;5530:7;5521:6;5510:9;5506:22;5485:53;:::i;:::-;5475:63;;5430:118;5081:474;;;;;:::o;5561:117::-;5670:1;5667;5660:12;5684:180;5732:77;5729:1;5722:88;5829:4;5826:1;5819:15;5853:4;5850:1;5843:15;5870:281;5953:27;5975:4;5953:27;:::i;:::-;5945:6;5941:40;6083:6;6071:10;6068:22;6047:18;6035:10;6032:34;6029:62;6026:88;;;6094:18;;:::i;:::-;6026:88;6134:10;6130:2;6123:22;5913:238;5870:281;;:::o;6157:129::-;6191:6;6218:20;;:::i;:::-;6208:30;;6247:33;6275:4;6267:6;6247:33;:::i;:::-;6157:129;;;:::o;6292:311::-;6369:4;6459:18;6451:6;6448:30;6445:56;;;6481:18;;:::i;:::-;6445:56;6531:4;6523:6;6519:17;6511:25;;6591:4;6585;6581:15;6573:23;;6292:311;;;:::o;6609:117::-;6718:1;6715;6708:12;6749:710;6845:5;6870:81;6886:64;6943:6;6886:64;:::i;:::-;6870:81;:::i;:::-;6861:90;;6971:5;7000:6;6993:5;6986:21;7034:4;7027:5;7023:16;7016:23;;7087:4;7079:6;7075:17;7067:6;7063:30;7116:3;7108:6;7105:15;7102:122;;;7135:79;;:::i;:::-;7102:122;7250:6;7233:220;7267:6;7262:3;7259:15;7233:220;;;7342:3;7371:37;7404:3;7392:10;7371:37;:::i;:::-;7366:3;7359:50;7438:4;7433:3;7429:14;7422:21;;7309:144;7293:4;7288:3;7284:14;7277:21;;7233:220;;;7237:21;6851:608;;6749:710;;;;;:::o;7482:370::-;7553:5;7602:3;7595:4;7587:6;7583:17;7579:27;7569:122;;7610:79;;:::i;:::-;7569:122;7727:6;7714:20;7752:94;7842:3;7834:6;7827:4;7819:6;7815:17;7752:94;:::i;:::-;7743:103;;7559:293;7482:370;;;;:::o;7858:116::-;7928:21;7943:5;7928:21;:::i;:::-;7921:5;7918:32;7908:60;;7964:1;7961;7954:12;7908:60;7858:116;:::o;7980:133::-;8023:5;8061:6;8048:20;8039:29;;8077:30;8101:5;8077:30;:::i;:::-;7980:133;;;;:::o;8119:678::-;8209:6;8217;8266:2;8254:9;8245:7;8241:23;8237:32;8234:119;;;8272:79;;:::i;:::-;8234:119;8420:1;8409:9;8405:17;8392:31;8450:18;8442:6;8439:30;8436:117;;;8472:79;;:::i;:::-;8436:117;8577:78;8647:7;8638:6;8627:9;8623:22;8577:78;:::i;:::-;8567:88;;8363:302;8704:2;8730:50;8772:7;8763:6;8752:9;8748:22;8730:50;:::i;:::-;8720:60;;8675:115;8119:678;;;;;:::o;8803:329::-;8862:6;8911:2;8899:9;8890:7;8886:23;8882:32;8879:119;;;8917:79;;:::i;:::-;8879:119;9037:1;9062:53;9107:7;9098:6;9087:9;9083:22;9062:53;:::i;:::-;9052:63;;9008:117;8803:329;;;;:::o;9138:60::-;9166:3;9187:5;9180:12;;9138:60;;;:::o;9204:142::-;9254:9;9287:53;9305:34;9314:24;9332:5;9314:24;:::i;:::-;9305:34;:::i;:::-;9287:53;:::i;:::-;9274:66;;9204:142;;;:::o;9352:126::-;9402:9;9435:37;9466:5;9435:37;:::i;:::-;9422:50;;9352:126;;;:::o;9484:142::-;9550:9;9583:37;9614:5;9583:37;:::i;:::-;9570:50;;9484:142;;;:::o;9632:163::-;9735:53;9782:5;9735:53;:::i;:::-;9730:3;9723:66;9632:163;;:::o;9801:254::-;9910:4;9948:2;9937:9;9933:18;9925:26;;9961:87;10045:1;10034:9;10030:17;10021:6;9961:87;:::i;:::-;9801:254;;;;:::o;10061:118::-;10148:24;10166:5;10148:24;:::i;:::-;10143:3;10136:37;10061:118;;:::o;10185:222::-;10278:4;10316:2;10305:9;10301:18;10293:26;;10329:71;10397:1;10386:9;10382:17;10373:6;10329:71;:::i;:::-;10185:222;;;;:::o;10413:474::-;10481:6;10489;10538:2;10526:9;10517:7;10513:23;10509:32;10506:119;;;10544:79;;:::i;:::-;10506:119;10664:1;10689:53;10734:7;10725:6;10714:9;10710:22;10689:53;:::i;:::-;10679:63;;10635:117;10791:2;10817:53;10862:7;10853:6;10842:9;10838:22;10817:53;:::i;:::-;10807:63;;10762:118;10413:474;;;;;:::o;10893:180::-;10941:77;10938:1;10931:88;11038:4;11035:1;11028:15;11062:4;11059:1;11052:15;11079:320;11123:6;11160:1;11154:4;11150:12;11140:22;;11207:1;11201:4;11197:12;11228:18;11218:81;;11284:4;11276:6;11272:17;11262:27;;11218:81;11346:2;11338:6;11335:14;11315:18;11312:38;11309:84;;11365:18;;:::i;:::-;11309:84;11130:269;11079:320;;;:::o;11405:182::-;11545:34;11541:1;11533:6;11529:14;11522:58;11405:182;:::o;11593:366::-;11735:3;11756:67;11820:2;11815:3;11756:67;:::i;:::-;11749:74;;11832:93;11921:3;11832:93;:::i;:::-;11950:2;11945:3;11941:12;11934:19;;11593:366;;;:::o;11965:419::-;12131:4;12169:2;12158:9;12154:18;12146:26;;12218:9;12212:4;12208:20;12204:1;12193:9;12189:17;12182:47;12246:131;12372:4;12246:131;:::i;:::-;12238:139;;11965:419;;;:::o;12390:232::-;12530:34;12526:1;12518:6;12514:14;12507:58;12599:15;12594:2;12586:6;12582:15;12575:40;12390:232;:::o;12628:366::-;12770:3;12791:67;12855:2;12850:3;12791:67;:::i;:::-;12784:74;;12867:93;12956:3;12867:93;:::i;:::-;12985:2;12980:3;12976:12;12969:19;;12628:366;;;:::o;13000:419::-;13166:4;13204:2;13193:9;13189:18;13181:26;;13253:9;13247:4;13243:20;13239:1;13228:9;13224:17;13217:47;13281:131;13407:4;13281:131;:::i;:::-;13273:139;;13000:419;;;:::o;13425:180::-;13473:77;13470:1;13463:88;13570:4;13567:1;13560:15;13594:4;13591:1;13584:15;13611:191;13651:3;13670:20;13688:1;13670:20;:::i;:::-;13665:25;;13704:20;13722:1;13704:20;:::i;:::-;13699:25;;13747:1;13744;13740:9;13733:16;;13768:3;13765:1;13762:10;13759:36;;;13775:18;;:::i;:::-;13759:36;13611:191;;;;:::o;13808:169::-;13948:21;13944:1;13936:6;13932:14;13925:45;13808:169;:::o;13983:366::-;14125:3;14146:67;14210:2;14205:3;14146:67;:::i;:::-;14139:74;;14222:93;14311:3;14222:93;:::i;:::-;14340:2;14335:3;14331:12;14324:19;;13983:366;;;:::o;14355:419::-;14521:4;14559:2;14548:9;14544:18;14536:26;;14608:9;14602:4;14598:20;14594:1;14583:9;14579:17;14572:47;14636:131;14762:4;14636:131;:::i;:::-;14628:139;;14355:419;;;:::o;14780:172::-;14920:24;14916:1;14908:6;14904:14;14897:48;14780:172;:::o;14958:366::-;15100:3;15121:67;15185:2;15180:3;15121:67;:::i;:::-;15114:74;;15197:93;15286:3;15197:93;:::i;:::-;15315:2;15310:3;15306:12;15299:19;;14958:366;;;:::o;15330:419::-;15496:4;15534:2;15523:9;15519:18;15511:26;;15583:9;15577:4;15573:20;15569:1;15558:9;15554:17;15547:47;15611:131;15737:4;15611:131;:::i;:::-;15603:139;;15330:419;;;:::o;15755:180::-;15803:77;15800:1;15793:88;15900:4;15897:1;15890:15;15924:4;15921:1;15914:15;15941:224;16081:34;16077:1;16069:6;16065:14;16058:58;16150:7;16145:2;16137:6;16133:15;16126:32;15941:224;:::o;16171:366::-;16313:3;16334:67;16398:2;16393:3;16334:67;:::i;:::-;16327:74;;16410:93;16499:3;16410:93;:::i;:::-;16528:2;16523:3;16519:12;16512:19;;16171:366;;;:::o;16543:419::-;16709:4;16747:2;16736:9;16732:18;16724:26;;16796:9;16790:4;16786:20;16782:1;16771:9;16767:17;16760:47;16824:131;16950:4;16824:131;:::i;:::-;16816:139;;16543:419;;;:::o;16968:225::-;17108:34;17104:1;17096:6;17092:14;17085:58;17177:8;17172:2;17164:6;17160:15;17153:33;16968:225;:::o;17199:366::-;17341:3;17362:67;17426:2;17421:3;17362:67;:::i;:::-;17355:74;;17438:93;17527:3;17438:93;:::i;:::-;17556:2;17551:3;17547:12;17540:19;;17199:366;;;:::o;17571:419::-;17737:4;17775:2;17764:9;17760:18;17752:26;;17824:9;17818:4;17814:20;17810:1;17799:9;17795:17;17788:47;17852:131;17978:4;17852:131;:::i;:::-;17844:139;;17571:419;;;:::o;17996:223::-;18136:34;18132:1;18124:6;18120:14;18113:58;18205:6;18200:2;18192:6;18188:15;18181:31;17996:223;:::o;18225:366::-;18367:3;18388:67;18452:2;18447:3;18388:67;:::i;:::-;18381:74;;18464:93;18553:3;18464:93;:::i;:::-;18582:2;18577:3;18573:12;18566:19;;18225:366;;;:::o;18597:419::-;18763:4;18801:2;18790:9;18786:18;18778:26;;18850:9;18844:4;18840:20;18836:1;18825:9;18821:17;18814:47;18878:131;19004:4;18878:131;:::i;:::-;18870:139;;18597:419;;;:::o;19022:221::-;19162:34;19158:1;19150:6;19146:14;19139:58;19231:4;19226:2;19218:6;19214:15;19207:29;19022:221;:::o;19249:366::-;19391:3;19412:67;19476:2;19471:3;19412:67;:::i;:::-;19405:74;;19488:93;19577:3;19488:93;:::i;:::-;19606:2;19601:3;19597:12;19590:19;;19249:366;;;:::o;19621:419::-;19787:4;19825:2;19814:9;19810:18;19802:26;;19874:9;19868:4;19864:20;19860:1;19849:9;19845:17;19838:47;19902:131;20028:4;19902:131;:::i;:::-;19894:139;;19621:419;;;:::o;20046:179::-;20186:31;20182:1;20174:6;20170:14;20163:55;20046:179;:::o;20231:366::-;20373:3;20394:67;20458:2;20453:3;20394:67;:::i;:::-;20387:74;;20470:93;20559:3;20470:93;:::i;:::-;20588:2;20583:3;20579:12;20572:19;;20231:366;;;:::o;20603:419::-;20769:4;20807:2;20796:9;20792:18;20784:26;;20856:9;20850:4;20846:20;20842:1;20831:9;20827:17;20820:47;20884:131;21010:4;20884:131;:::i;:::-;20876:139;;20603:419;;;:::o;21028:170::-;21168:22;21164:1;21156:6;21152:14;21145:46;21028:170;:::o;21204:366::-;21346:3;21367:67;21431:2;21426:3;21367:67;:::i;:::-;21360:74;;21443:93;21532:3;21443:93;:::i;:::-;21561:2;21556:3;21552:12;21545:19;;21204:366;;;:::o;21576:419::-;21742:4;21780:2;21769:9;21765:18;21757:26;;21829:9;21823:4;21819:20;21815:1;21804:9;21800:17;21793:47;21857:131;21983:4;21857:131;:::i;:::-;21849:139;;21576:419;;;:::o;22001:241::-;22141:34;22137:1;22129:6;22125:14;22118:58;22210:24;22205:2;22197:6;22193:15;22186:49;22001:241;:::o;22248:366::-;22390:3;22411:67;22475:2;22470:3;22411:67;:::i;:::-;22404:74;;22487:93;22576:3;22487:93;:::i;:::-;22605:2;22600:3;22596:12;22589:19;;22248:366;;;:::o;22620:419::-;22786:4;22824:2;22813:9;22809:18;22801:26;;22873:9;22867:4;22863:20;22859:1;22848:9;22844:17;22837:47;22901:131;23027:4;22901:131;:::i;:::-;22893:139;;22620:419;;;:::o;23045:410::-;23085:7;23108:20;23126:1;23108:20;:::i;:::-;23103:25;;23142:20;23160:1;23142:20;:::i;:::-;23137:25;;23197:1;23194;23190:9;23219:30;23237:11;23219:30;:::i;:::-;23208:41;;23398:1;23389:7;23385:15;23382:1;23379:22;23359:1;23352:9;23332:83;23309:139;;23428:18;;:::i;:::-;23309:139;23093:362;23045:410;;;;:::o;23461:180::-;23509:77;23506:1;23499:88;23606:4;23603:1;23596:15;23630:4;23627:1;23620:15;23647:185;23687:1;23704:20;23722:1;23704:20;:::i;:::-;23699:25;;23738:20;23756:1;23738:20;:::i;:::-;23733:25;;23777:1;23767:35;;23782:18;;:::i;:::-;23767:35;23824:1;23821;23817:9;23812:14;;23647:185;;;;:::o;23838:194::-;23878:4;23898:20;23916:1;23898:20;:::i;:::-;23893:25;;23932:20;23950:1;23932:20;:::i;:::-;23927:25;;23976:1;23973;23969:9;23961:17;;24000:1;23994:4;23991:11;23988:37;;;24005:18;;:::i;:::-;23988:37;23838:194;;;;:::o;24038:181::-;24178:33;24174:1;24166:6;24162:14;24155:57;24038:181;:::o;24225:366::-;24367:3;24388:67;24452:2;24447:3;24388:67;:::i;:::-;24381:74;;24464:93;24553:3;24464:93;:::i;:::-;24582:2;24577:3;24573:12;24566:19;;24225:366;;;:::o;24597:419::-;24763:4;24801:2;24790:9;24786:18;24778:26;;24850:9;24844:4;24840:20;24836:1;24825:9;24821:17;24814:47;24878:131;25004:4;24878:131;:::i;:::-;24870:139;;24597:419;;;:::o;25022:220::-;25162:34;25158:1;25150:6;25146:14;25139:58;25231:3;25226:2;25218:6;25214:15;25207:28;25022:220;:::o;25248:366::-;25390:3;25411:67;25475:2;25470:3;25411:67;:::i;:::-;25404:74;;25487:93;25576:3;25487:93;:::i;:::-;25605:2;25600:3;25596:12;25589:19;;25248:366;;;:::o;25620:419::-;25786:4;25824:2;25813:9;25809:18;25801:26;;25873:9;25867:4;25863:20;25859:1;25848:9;25844:17;25837:47;25901:131;26027:4;25901:131;:::i;:::-;25893:139;;25620:419;;;:::o;26045:221::-;26185:34;26181:1;26173:6;26169:14;26162:58;26254:4;26249:2;26241:6;26237:15;26230:29;26045:221;:::o;26272:366::-;26414:3;26435:67;26499:2;26494:3;26435:67;:::i;:::-;26428:74;;26511:93;26600:3;26511:93;:::i;:::-;26629:2;26624:3;26620:12;26613:19;;26272:366;;;:::o;26644:419::-;26810:4;26848:2;26837:9;26833:18;26825:26;;26897:9;26891:4;26887:20;26883:1;26872:9;26868:17;26861:47;26925:131;27051:4;26925:131;:::i;:::-;26917:139;;26644:419;;;:::o;27069:143::-;27126:5;27157:6;27151:13;27142:22;;27173:33;27200:5;27173:33;:::i;:::-;27069:143;;;;:::o;27218:351::-;27288:6;27337:2;27325:9;27316:7;27312:23;27308:32;27305:119;;;27343:79;;:::i;:::-;27305:119;27463:1;27488:64;27544:7;27535:6;27524:9;27520:22;27488:64;:::i;:::-;27478:74;;27434:128;27218:351;;;;:::o;27575:85::-;27620:7;27649:5;27638:16;;27575:85;;;:::o;27666:158::-;27724:9;27757:61;27775:42;27784:32;27810:5;27784:32;:::i;:::-;27775:42;:::i;:::-;27757:61;:::i;:::-;27744:74;;27666:158;;;:::o;27830:147::-;27925:45;27964:5;27925:45;:::i;:::-;27920:3;27913:58;27830:147;;:::o;27983:137::-;28073:6;28107:5;28101:12;28091:22;;27983:137;;;:::o;28126:207::-;28248:11;28282:6;28277:3;28270:19;28322:4;28317:3;28313:14;28298:29;;28126:207;;;;:::o;28339:155::-;28429:4;28452:3;28444:11;;28482:4;28477:3;28473:14;28465:22;;28339:155;;;:::o;28500:108::-;28577:24;28595:5;28577:24;:::i;:::-;28572:3;28565:37;28500:108;;:::o;28614:99::-;28685:21;28700:5;28685:21;:::i;:::-;28680:3;28673:34;28614:99;;:::o;28771:661::-;28904:4;28899:3;28895:14;28991:4;28984:5;28980:16;28974:23;29010:63;29067:4;29062:3;29058:14;29044:12;29010:63;:::i;:::-;28919:164;29163:4;29156:5;29152:16;29146:23;29182:63;29239:4;29234:3;29230:14;29216:12;29182:63;:::i;:::-;29093:162;29339:4;29332:5;29328:16;29322:23;29358:57;29409:4;29404:3;29400:14;29386:12;29358:57;:::i;:::-;29265:160;28873:559;28771:661;;:::o;29438:271::-;29553:10;29574:92;29662:3;29654:6;29574:92;:::i;:::-;29698:4;29693:3;29689:14;29675:28;;29438:271;;;;:::o;29715:136::-;29808:4;29840;29835:3;29831:14;29823:22;;29715:136;;;:::o;29913:916::-;30078:3;30107:77;30178:5;30107:77;:::i;:::-;30200:109;30302:6;30297:3;30200:109;:::i;:::-;30193:116;;30333:79;30406:5;30333:79;:::i;:::-;30435:7;30466:1;30451:353;30476:6;30473:1;30470:13;30451:353;;;30552:6;30546:13;30579:109;30684:3;30669:13;30579:109;:::i;:::-;30572:116;;30711:83;30787:6;30711:83;:::i;:::-;30701:93;;30511:293;30498:1;30495;30491:9;30486:14;;30451:353;;;30455:14;30820:3;30813:10;;30083:746;;;29913:916;;;;:::o;30835:923::-;31144:4;31182:3;31171:9;31167:19;31159:27;;31196:71;31264:1;31253:9;31249:17;31240:6;31196:71;:::i;:::-;31277:80;31353:2;31342:9;31338:18;31329:6;31277:80;:::i;:::-;31404:9;31398:4;31394:20;31389:2;31378:9;31374:18;31367:48;31432:154;31581:4;31572:6;31432:154;:::i;:::-;31424:162;;31596:72;31664:2;31653:9;31649:18;31640:6;31596:72;:::i;:::-;31678:73;31746:3;31735:9;31731:19;31722:6;31678:73;:::i;:::-;30835:923;;;;;;;;:::o;31764:224::-;31904:34;31900:1;31892:6;31888:14;31881:58;31973:7;31968:2;31960:6;31956:15;31949:32;31764:224;:::o;31994:366::-;32136:3;32157:67;32221:2;32216:3;32157:67;:::i;:::-;32150:74;;32233:93;32322:3;32233:93;:::i;:::-;32351:2;32346:3;32342:12;32335:19;;31994:366;;;:::o;32366:419::-;32532:4;32570:2;32559:9;32555:18;32547:26;;32619:9;32613:4;32609:20;32605:1;32594:9;32590:17;32583:47;32647:131;32773:4;32647:131;:::i;:::-;32639:139;;32366:419;;;:::o;32791:222::-;32931:34;32927:1;32919:6;32915:14;32908:58;33000:5;32995:2;32987:6;32983:15;32976:30;32791:222;:::o;33019:366::-;33161:3;33182:67;33246:2;33241:3;33182:67;:::i;:::-;33175:74;;33258:93;33347:3;33258:93;:::i;:::-;33376:2;33371:3;33367:12;33360:19;;33019:366;;;:::o;33391:419::-;33557:4;33595:2;33584:9;33580:18;33572:26;;33644:9;33638:4;33634:20;33630:1;33619:9;33615:17;33608:47;33672:131;33798:4;33672:131;:::i;:::-;33664:139;;33391:419;;;:::o;33816:225::-;33956:34;33952:1;33944:6;33940:14;33933:58;34025:8;34020:2;34012:6;34008:15;34001:33;33816:225;:::o;34047:366::-;34189:3;34210:67;34274:2;34269:3;34210:67;:::i;:::-;34203:74;;34286:93;34375:3;34286:93;:::i;:::-;34404:2;34399:3;34395:12;34388:19;;34047:366;;;:::o;34419:419::-;34585:4;34623:2;34612:9;34608:18;34600:26;;34672:9;34666:4;34662:20;34658:1;34647:9;34643:17;34636:47;34700:131;34826:4;34700:131;:::i;:::-;34692:139;;34419:419;;;:::o

Swarm Source

ipfs://3abe46da0e493ec9e4809694d6b3887527eefb1a2d7b4665774fd56ffd5cf95b

A token is a representation of an on-chain or off-chain asset. The token page shows information such as price, total supply, holders, transfers and social links. Learn more about this page in our Knowledge Base.

Tools & Services