// Contract: Puff
// Target function: function functionCall(
// .S_sSSs     .S       S.     sSSs    sSSs        sdSS_SSSSSSbs   .S    S.     sSSs         .S_SsS_S.    .S_SSSs      sSSSSs   .S    sSSs         .S_sSSs     .S_sSSs     .S_SSSs      sSSSSs    sSSs_sSSs     .S_sSSs    
//.SS~YS%%b   .SS       SS.   d%%SP   d%%SP        YSSS~S%SSSSSP  .SS    SS.   d%%SP        .SS~S*S~SS.  .SS~SSSSS    d%%%%SP  .SS   d%%SP        .SS~YS%%b   .SS~YS%%b   .SS~SSSSS    d%%%%SP   d%%SP~YS%%b   .SS~YS%%b   
//S%S   `S%b  S%S       S%S  d%S'    d%S'               S%S       S%S    S%S  d%S'          S%S `Y' S%S  S%S   SSSS  d%S'      S%S  d%S'          S%S   `S%b  S%S   `S%b  S%S   SSSS  d%S'      d%S'     `S%b  S%S   `S%b  
//S%S    S%S  S%S       S%S  S%S     S%S                S%S       S%S    S%S  S%S           S%S     S%S  S%S    S%S  S%S       S%S  S%S           S%S    S%S  S%S    S%S  S%S    S%S  S%S       S%S       S%S  S%S    S%S  
//S%S    d*S  S&S       S&S  S&S     S&S                S&S       S%S SSSS%S  S&S           S%S     S%S  S%S SSSS%S  S&S       S&S  S&S           S%S    S&S  S%S    d*S  S%S SSSS%S  S&S       S&S       S&S  S%S    S&S  
//S&S   .S*S  S&S       S&S  S&S_Ss  S&S_Ss             S&S       S&S  SSS&S  S&S_Ss        S&S     S&S  S&S  SSS%S  S&S       S&S  S&S           S&S    S&S  S&S   .S*S  S&S  SSS%S  S&S       S&S       S&S  S&S    S&S  
//S&S_sdSSS   S&S       S&S  S&S~SP  S&S~SP             S&S       S&S    S&S  S&S~SP        S&S     S&S  S&S    S&S  S&S       S&S  S&S           S&S    S&S  S&S_sdSSS   S&S    S&S  S&S       S&S       S&S  S&S    S&S  
//S&S~YSSY    S&S       S&S  S&S     S&S                S&S       S&S    S&S  S&S           S&S     S&S  S&S    S&S  S&S sSSs  S&S  S&S           S&S    S&S  S&S~YSY%b   S&S    S&S  S&S sSSs  S&S       S&S  S&S    S&S  
//S*S         S*b       d*S  S*b     S*b                S*S       S*S    S*S  S*b           S*S     S*S  S*S    S&S  S*b `S%%  S*S  S*b           S*S    d*S  S*S   `S%b  S*S    S&S  S*b `S%%  S*b       d*S  S*S    S*S  
//S*S         S*S.     .S*S  S*S     S*S                S*S       S*S    S*S  S*S.          S*S     S*S  S*S    S*S  S*S   S%  S*S  S*S.          S*S   .S*S  S*S    S%S  S*S    S*S  S*S   S%  S*S.     .S*S  S*S    S*S  
//S*S          SSSbs_sdSSS   S*S     S*S                S*S       S*S    S*S   SSSbs        S*S     S*S  S*S    S*S   SS_sSSS  S*S   SSSbs        S*S_sdSSS   S*S    S&S  S*S    S*S   SS_sSSS   SSSbs_sdSSS   S*S    S*S  
//S*S           YSSP~YSSY    S*S     S*S                S*S       SSS    S*S    YSSP        SSS     S*S  SSS    S*S    Y~YSSY  S*S    YSSP        SSS~YSSY    S*S    SSS  SSS    S*S    Y~YSSY    YSSP~YSSY    S*S    SSS  
//SP                         SP      SP                 SP               SP                         SP          SP             SP                             SP                 SP                            SP          
//Y                          Y       Y                  Y                Y                          Y           Y              Y                              Y                  Y                             Y           
                                                                                                                                                                                                                         
/**
https://twitter.com/puffthegas420
https://t.me/PufftheMagicDragonETH
**/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.19;

interface IUniswapRouter01 {
    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);

    function getAmountsOut(
        uint256 amountIn,
        address[] calldata path
    ) external view returns (uint256[] memory amounts);
}

interface IUniswapRouter02 is IUniswapRouter01 {
    function swapExactTokensForETHSupportingFeeOnTransferTokens(
        uint256 amountIn,
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external;
}

interface IFactory {
    event PairCreated(
        address indexed token0,
        address indexed token1,
        address pair,
        uint256
    );

    function getPair(
        address tokenA,
        address tokenB
    ) external view returns (address pair);

    function allPairs(uint256) external view returns (address pair);

    function createPair(
        address tokenA,
        address tokenB
    ) external returns (address pair);
}

abstract contract Context {
    //function _msgSender() internal view virtual returns (address payable) {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes memory) {
        this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
        return msg.data;
    }
}

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() {
        _transferOwnership(_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 {
        _transferOwnership(address(0));
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        require(
            newOwner != address(0),
            "Ownable: new owner is the zero address"
        );
        _transferOwnership(newOwner);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Internal function without access restriction.
     */
    function _transferOwnership(address newOwner) internal virtual {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}

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"
        );
    }