Token ArbiGoat

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

pragma solidity ^0.8.0;

import "../utils/Context.sol";

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * By default, the owner account will be the one that deploys the contract. This
 * can later be changed with {transferOwnership}.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
abstract contract 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 Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        _checkOwner();
        _;
    }

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

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

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions 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);
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (security/ReentrancyGuard.sol)

pragma solidity ^0.8.0;

/**
 * @dev Contract module that helps prevent reentrant calls to a function.
 *
 * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
 * available, which can be applied to functions to make sure there are no nested
 * (reentrant) calls to them.
 *
 * Note that because there is a single `nonReentrant` guard, functions marked as
 * `nonReentrant` may not call one another. This can be worked around by making
 * those functions `private`, and then adding `external` `nonReentrant` entry
 * points to them.
 *
 * TIP: If you would like to learn more about reentrancy and alternative ways
 * to protect against it, check out our blog post
 * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
 */
abstract contract ReentrancyGuard {
    // Booleans are more expensive than uint256 or any type that takes up a full
    // word because each write operation emits an extra SLOAD to first read the
    // slot's contents, replace the bits taken up by the boolean, and then write
    // back. This is the compiler's defense against contract upgrades and
    // pointer aliasing, and it cannot be disabled.

    // The values being non-zero value makes deployment a bit more expensive,
    // but in exchange the refund on every call to nonReentrant will be lower in
    // amount. Since refunds are capped to a percentage of the total
    // transaction's gas, it is best to keep them low in cases like this one, to
    // increase the likelihood of the full refund coming into effect.
    uint256 private constant _NOT_ENTERED = 1;
    uint256 private constant _ENTERED = 2;

    uint256 private _status;

    constructor() {
        _status = _NOT_ENTERED;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and making it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        _nonReentrantBefore();
        _;
        _nonReentrantAfter();
    }

    function _nonReentrantBefore() private {
        // On the first call to nonReentrant, _status will be _NOT_ENTERED
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

        // Any calls to nonReentrant after this point will fail
        _status = _ENTERED;
    }

    function _nonReentrantAfter() private {
        // By storing the original value once again, a refund is triggered (see
        // https://eips.ethereum.org/EIPS/eip-2200)
        _status = _NOT_ENTERED;
    }
}

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

pragma solidity ^0.8.0;

import "./IERC20.sol";
import "./extensions/IERC20Metadata.sol";
import "../../utils/Context.sol";

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

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

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;

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

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

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

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

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

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

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

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

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

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

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

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

        return true;
    }

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

        _beforeTokenTransfer(from, to, amount);

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

        emit Transfer(from, to, amount);

        _afterTokenTransfer(from, to, amount);
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

pragma solidity ^0.8.0;

import "../IERC20.sol";

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

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

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

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

pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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

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

pragma solidity ^0.8.0;

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

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

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

pragma solidity ^0.8.0;

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

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

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

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

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

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

            // Handle non-overflow cases, 256 by 256 division.
            if (prod1 == 0) {
                return prod0 / denominator;
            }

            // Make sure the result is less than 2^256. Also prevents denominator == 0.
            require(denominator > prod1);

            ///////////////////////////////////////////////
            // 512 by 256 division.
            ///////////////////////////////////////////////

            // Make division exact by subtracting the remainder from [prod1 prod0].
            uint256 remainder;
            assembly {
                // Compute remainder using mulmod.
                remainder := mulmod(x, y, denominator)

                // Subtract 256 bit number from 512 bit number.
                prod1 := sub(prod1, gt(remainder, prod0))
                prod0 := sub(prod0, remainder)
            }

            // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1.
            // See https://cs.stackexchange.com/q/138556/92363.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

pragma solidity >=0.5.0;

interface IUniswapV2Factory {
    event PairCreated(address indexed token0, address indexed token1, address pair, uint);

    function feeTo() external view returns (address);
    function feeToSetter() external view returns (address);

    function getPair(address tokenA, address tokenB) external view returns (address pair);
    function allPairs(uint) external view returns (address pair);
    function allPairsLength() external view returns (uint);

    function createPair(address tokenA, address tokenB) external returns (address pair);

    function setFeeTo(address) external;
    function setFeeToSetter(address) external;
}

pragma solidity >=0.6.2;

interface IUniswapV2Router01 {
    function factory() external pure returns (address);
    function WETH() external pure returns (address);

    function addLiquidity(
        address tokenA,
        address tokenB,
        uint amountADesired,
        uint amountBDesired,
        uint amountAMin,
        uint amountBMin,
        address to,
        uint deadline
    ) external returns (uint amountA, uint amountB, uint liquidity);
    function addLiquidityETH(
        address token,
        uint amountTokenDesired,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline
    ) external payable returns (uint amountToken, uint amountETH, uint liquidity);
    function removeLiquidity(
        address tokenA,
        address tokenB,
        uint liquidity,
        uint amountAMin,
        uint amountBMin,
        address to,
        uint deadline
    ) external returns (uint amountA, uint amountB);
    function removeLiquidityETH(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline
    ) external returns (uint amountToken, uint amountETH);
    function removeLiquidityWithPermit(
        address tokenA,
        address tokenB,
        uint liquidity,
        uint amountAMin,
        uint amountBMin,
        address to,
        uint deadline,
        bool approveMax, uint8 v, bytes32 r, bytes32 s
    ) external returns (uint amountA, uint amountB);
    function removeLiquidityETHWithPermit(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline,
        bool approveMax, uint8 v, bytes32 r, bytes32 s
    ) external returns (uint amountToken, uint amountETH);
    function swapExactTokensForTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external returns (uint[] memory amounts);
    function swapTokensForExactTokens(
        uint amountOut,
        uint amountInMax,
        address[] calldata path,
        address to,
        uint deadline
    ) external returns (uint[] memory amounts);
    function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
        external
        payable
        returns (uint[] memory amounts);
    function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
        external
        returns (uint[] memory amounts);
    function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
        external
        returns (uint[] memory amounts);
    function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
        external
        payable
        returns (uint[] memory amounts);

    function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
    function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
    function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
    function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
    function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}

pragma solidity >=0.6.2;

import './IUniswapV2Router01.sol';

interface IUniswapV2Router02 is IUniswapV2Router01 {
    function removeLiquidityETHSupportingFeeOnTransferTokens(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline
    ) external returns (uint amountETH);
    function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline,
        bool approveMax, uint8 v, bytes32 r, bytes32 s
    ) external returns (uint amountETH);

    function swapExactTokensForTokensSupportingFeeOnTransferTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external;
    function swapExactETHForTokensSupportingFeeOnTransferTokens(
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external payable;
    function swapExactTokensForETHSupportingFeeOnTransferTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external;
}

// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.4;

import "@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol";
import "@uniswap/v2-core/contracts/interfaces/IUniswapV2Factory.sol";

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/math/Math.sol";

contract ArbiGoat is ERC20, Ownable, ReentrancyGuard {
    error MaxWalletLimitReached(address receiver, uint256 limit);

    IUniswapV2Router02 public uniswapV2Router;
    address public uniswapV2Pair;
    address public gameDeposit;
    address public vault;

    address public devWallet;
    address public goatWallet;

    uint256 public constant DENOMINATOR = 10000;

    uint256 public liquidityBuyFee;
    uint256 public devBuyFee;
    uint256 public goatBuyFee;
    uint256 public totalBuyFees;
    
    uint256 public totalSellFees;
    uint256 public liquiditySellFee;
    uint256 public devSellFee;
    uint256 public goatSellFee;

    uint256 public liquidityTokens;
    uint256 public devTokens;
    uint256 public goatTokens;

    uint256 public maxWalletLimit;
    uint256 public swapTokensThreshold;

    bool public launchLimitsActive = true;
    bool public liquifySwap;

    mapping(address => bool) private _addressesWithoutFees;
    mapping(address => bool) public addressesWithoutMaxWallet;

    mapping(address => bool) public amm;

    event SwapTokensForETH(uint256 amount, address[] path);
    event SwapAndRepartitionExecuted(uint256 total, uint256 timestamp);
    event AddLiquidity(uint256 amountTokens, uint256 amountEth, uint256 liquidity, uint256 timestamp);

    modifier reentrancySwap() {
        liquifySwap = true;
        _;
        liquifySwap = false;
    }

    constructor() ERC20("ArbiGoat", "AGT") {
        addressesWithoutMaxWallet[_msgSender()] = true;
        addressesWithoutMaxWallet[address(this)] = true;

        _addressesWithoutFees[_msgSender()] = true;
        _addressesWithoutFees[address(this)] = true;

        liquidityBuyFee = 10000;
        devBuyFee = 20000;
        goatBuyFee = 0;
        
        liquiditySellFee = 10000;
        devSellFee = 20000;
        goatSellFee = 0;

        totalBuyFees = liquidityBuyFee + devBuyFee + goatBuyFee;
        totalSellFees = liquiditySellFee + devSellFee + goatSellFee;

        uint256 maxTotalSupply = 2100000 ether;
        maxWalletLimit = Math.mulDiv(
            maxTotalSupply,
            30000,
            100 * DENOMINATOR
        );
        swapTokensThreshold = Math.mulDiv(
            maxTotalSupply,
            10000,
            100 * DENOMINATOR
        );
        _mint(_msgSender(), maxTotalSupply);
    }

    receive() external payable {}


    function setMaxWalletLimitAmount(uint256 amount) external onlyOwner {
        maxWalletLimit = amount;
    }

    function disableLauchLimits() external onlyOwner {
        launchLimitsActive = false;
    }

    function setBuyFees(
        uint256 liquidity,
        uint256 dev,
        uint256 goat
    ) external onlyOwner {
        liquidityBuyFee = liquidity;
        devBuyFee = dev;
        goatBuyFee = goat;
        totalBuyFees = liquidityBuyFee + devBuyFee + goatBuyFee;
    }
    function setSellFees(
        uint256 liquidity,
        uint256 dev,
        uint256 goat
    ) external onlyOwner {
        liquiditySellFee = liquidity;
        devSellFee = dev;
        goatSellFee = goat;
        totalSellFees = liquiditySellFee + devSellFee + goatSellFee;
    }

    function setVault(address _vault) external onlyOwner {
        vault = _vault;
        _addressesWithoutFees[_vault] = true;
        addressesWithoutMaxWallet[_vault] = true;
    }

    function setGameDeposit(address _gameDeposit) external onlyOwner {
        gameDeposit = _gameDeposit;
        _addressesWithoutFees[_gameDeposit] = true;
        addressesWithoutMaxWallet[_gameDeposit] = true;
    }

    function setDevWallet(address wallet) external onlyOwner {
        devWallet = wallet;
        _addressesWithoutFees[wallet] = true;
        addressesWithoutMaxWallet[wallet] = true;
    }

    function setGoatWallet(address wallet) external onlyOwner {
        goatWallet = wallet;
        _addressesWithoutFees[wallet] = true;
        addressesWithoutMaxWallet[wallet] = true;
    }

    function setSwapTokensThreshold(uint256 amount) external onlyOwner {
        swapTokensThreshold = amount;
    }

    function setAddressWithoutMaxWallet(
        address account,
        bool excluded
    ) external onlyOwner {
        addressesWithoutMaxWallet[account] = excluded;
    }

    function setAddressWithoutFees(
        address account,
        bool excluded
    ) external onlyOwner {
        _addressesWithoutFees[account] = excluded;
    }

    function setAMM(address pair, bool active) external onlyOwner {
        amm[pair] = active;
        addressesWithoutMaxWallet[pair];
    }

    function setUniswapV2Pair(address pair) external onlyOwner {
      uniswapV2Pair = pair;
    }

    function setRouter(address router) external onlyOwner {
        uniswapV2Router = IUniswapV2Router02(router);
        addressesWithoutMaxWallet[router] = true;
    }

    function createUniswapV2Pair() external onlyOwner {
        uniswapV2Pair = IUniswapV2Factory(uniswapV2Router.factory()).createPair(
                address(this),
                uniswapV2Router.WETH()
            );
        addressesWithoutMaxWallet[uniswapV2Pair] = true;
        amm[uniswapV2Pair] = true;
    }

    function addressWithoutFees(address account) external view returns (bool) {
        return _addressesWithoutFees[account];
    }

    function payout() external onlyOwner {
        payable(msg.sender).transfer(address(this).balance);
    }

    function withdrawToken() external onlyOwner {
        transfer(owner(), balanceOf(address(this)));
    }

    function _getAmountFromFee(
        uint256 _fee,
        uint256 _amount
    ) internal pure returns (uint256) {
        return
            Math.mulDiv(
                _fee,
                _amount,
                100 * DENOMINATOR
            );
    }

    function _transfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual override {
        if(launchLimitsActive) {
          if(from != owner() && to != owner() && to != address(0) && !liquifySwap){
            if(amm[from ] && !addressesWithoutMaxWallet[to] && balanceOf(to) + amount > maxWalletLimit) {
              revert MaxWalletLimitReached(to, maxWalletLimit);
            }
            else if(!addressesWithoutMaxWallet[to] && balanceOf(to) + amount > maxWalletLimit) {
              revert MaxWalletLimitReached(to, maxWalletLimit);
            }
          }
        }
        uint256 totalTokensToSwap = liquidityTokens + devTokens + goatTokens;
        if(amount == 0) {
          super._transfer(from, to, 0);
          return;
        }
        bool executeSwap = totalTokensToSwap >= swapTokensThreshold &&
            !liquifySwap &&
            to == uniswapV2Pair && balanceOf(address(this))>= swapTokensThreshold;
        if (executeSwap) {
            _executeSwapAndRepartition(totalTokensToSwap);
        }
        bool hasFees = true;
        if (_addressesWithoutFees[from] || _addressesWithoutFees[to]) {
          hasFees = false;
        }
        uint256 fees = 0;
        if (hasFees) {
          if (amm[to] && totalSellFees > 0) {
              fees = _getSellTokensFees(amount);
          } else if (amm[from] && totalBuyFees > 0){
                fees = _getBuyTokensFees(amount);
          }
          if(fees > 0) {
            super._transfer(from, address(this), fees);
            amount -= fees;
          }
        }
        super._transfer(from, to, amount);
    }

    function _getBuyTokensFees(uint256 amount) internal returns (uint256) {
        liquidityTokens += _getAmountFromFee(amount, liquidityBuyFee);
        devTokens += _getAmountFromFee(amount, devBuyFee);
        goatTokens += _getAmountFromFee(amount, goatBuyFee);
        uint256 totalFeesAmount = _getAmountFromFee(amount, totalBuyFees);
        return totalFeesAmount;
    }

    function _getSellTokensFees(uint256 amount) internal returns (uint256) {
        liquidityTokens += _getAmountFromFee(amount, liquiditySellFee);
        devTokens += _getAmountFromFee(amount, devSellFee);
        goatTokens += _getAmountFromFee(amount, goatSellFee);
        uint256 totalFeesAmount = _getAmountFromFee(amount, totalSellFees);
        return totalFeesAmount;
    }

    function _executeSwapAndRepartition(uint256 tokensToSwap) internal {
      if(balanceOf(address(this)) > tokensToSwap) {
        tokensToSwap = _checkAndAdjustTokens(tokensToSwap);
      }
      uint256 tokensForLiquidity = liquidityTokens / 2;
      uint256 tokensInEth = tokensToSwap - tokensForLiquidity;
      _swapTokensForEth(tokensInEth);
      uint256 ethBalance = address(this).balance;
      uint256 devEth = Math.mulDiv(ethBalance, devTokens, tokensInEth);
      uint256 goatEth = Math.mulDiv(ethBalance, goatTokens, tokensInEth);
      uint256 liquidityEth = ethBalance - devEth - goatEth;
      (bool successDev, ) = address(devWallet).call{value: devEth}("");
      if(successDev) {
        devTokens = 0;
      }
      (bool successGoat, ) = address(goatWallet).call{value: goatEth}("");
      if(successGoat) {
        goatTokens = 0;
      }
      _addLiquidity(tokensForLiquidity, liquidityEth);
      liquidityTokens = 0;
      emit SwapAndRepartitionExecuted(tokensToSwap, block.timestamp);
    }

    function _checkAndAdjustTokens(uint256 tokensToShare) internal returns (uint256){
      uint256 balance = balanceOf(address(this));
      uint256 liquidity = Math.mulDiv(liquidityTokens, balance, tokensToShare);
      uint256 dev = Math.mulDiv(devTokens, balance, tokensToShare);
      uint256 goat = Math.mulDiv(goatTokens, balance, tokensToShare);
      if(goat + liquidity + dev <= balance) {
        liquidityTokens = liquidity;
        devTokens = dev;
        goatTokens = goat;
        return balance;
      }
      return tokensToShare;
    }

    function _addLiquidity(uint256 _amountTokens, uint256 _amountEth) internal reentrancySwap {
      _approve(address(this), address(uniswapV2Router), _amountTokens);
      (uint256 amountTokens, uint256 amountEth, uint256 liquidity) = uniswapV2Router.addLiquidityETH{value: _amountEth}(
        address(this),
        _amountTokens,
        0,
        0,
        owner(),
        block.timestamp
      );
      emit AddLiquidity(amountTokens, amountEth, liquidity, block.timestamp);
    }

    function _swapTokensForEth(
        uint256 _amount
    ) internal reentrancySwap {
        address[] memory path = new address[](2);
        path[0] = address(this);
        path[1] = uniswapV2Router.WETH();
        _approve(address(this), address(uniswapV2Router), _amount);
        uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens(
            _amount,
            0,
            path,
            address(this),
            block.timestamp
        );
        emit SwapTokensForETH(_amount, path);
    }
}

{
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  },
  "libraries": {}
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"address","name":"receiver","type":"address"},{"internalType":"uint256","name":"limit","type":"uint256"}],"name":"MaxWalletLimitReached","type":"error"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"amountTokens","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amountEth","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"liquidity","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"timestamp","type":"uint256"}],"name":"AddLiquidity","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"total","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"timestamp","type":"uint256"}],"name":"SwapAndRepartitionExecuted","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"address[]","name":"path","type":"address[]"}],"name":"SwapTokensForETH","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":[],"name":"DENOMINATOR","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"addressWithoutFees","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"addressesWithoutMaxWallet","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"amm","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"createUniswapV2Pair","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"subtractedValue","type":"uint256"}],"name":"decreaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"devBuyFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"devSellFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"devTokens","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"devWallet","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"disableLauchLimits","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"gameDeposit","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"goatBuyFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"goatSellFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"goatTokens","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"goatWallet","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":"launchLimitsActive","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"liquidityBuyFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"liquiditySellFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"liquidityTokens","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"liquifySwap","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxWalletLimit","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"payout","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"pair","type":"address"},{"internalType":"bool","name":"active","type":"bool"}],"name":"setAMM","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"bool","name":"excluded","type":"bool"}],"name":"setAddressWithoutFees","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"bool","name":"excluded","type":"bool"}],"name":"setAddressWithoutMaxWallet","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"liquidity","type":"uint256"},{"internalType":"uint256","name":"dev","type":"uint256"},{"internalType":"uint256","name":"goat","type":"uint256"}],"name":"setBuyFees","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"wallet","type":"address"}],"name":"setDevWallet","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_gameDeposit","type":"address"}],"name":"setGameDeposit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"wallet","type":"address"}],"name":"setGoatWallet","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"setMaxWalletLimitAmount","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"router","type":"address"}],"name":"setRouter","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"liquidity","type":"uint256"},{"internalType":"uint256","name":"dev","type":"uint256"},{"internalType":"uint256","name":"goat","type":"uint256"}],"name":"setSellFees","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"setSwapTokensThreshold","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"pair","type":"address"}],"name":"setUniswapV2Pair","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_vault","type":"address"}],"name":"setVault","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"swapTokensThreshold","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalBuyFees","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSellFees","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"uniswapV2Pair","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"uniswapV2Router","outputs":[{"internalType":"contract IUniswapV2Router02","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"vault","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"withdrawToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}]

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