creation_sourcecode: // SPDX-License-Identifier: MIT
  pragma solidity 0.8.25;
  
  /**
   * @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);
  }
  
  // CAUTION
  // This version of SafeMath should only be used with Solidity 0.8 or later,
  // because it relies on the compiler's built in overflow checks.
  
  /**
   * @dev Wrappers over Solidity's arithmetic operations.
   *
   * NOTE: `SafeMath` is generally not needed starting with Solidity 0.8, since the compiler
   * now has built in overflow checking.
   */
  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;
          }
      }
  }
  
  
  /**
   * @dev Collection of functions related to the address type
   */
  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
       *
       * Furthermore, `isContract` will also return true if the target contract within
       * the same transaction is already scheduled for destruction by `SELFDESTRUCT`,
       * which only has an effect at the end of a transaction.
       * ====
       *
       * [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://consensys.net/diligence/blog/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.8.0/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);
          }
      }
  }
  
  
  /**
   * @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;
      }
  }
  
  /**
   * @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. Can only be called by the current owner.
       *
       * NOTE: Renouncing ownership will leave the contract without an owner,
       * thereby disabling 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);
      }
  }
  
  
  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;
  }
  
  
  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);
  }
  
  
  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;
  }
  
  
  // file: FXA.sol
  contract FXA is Context, IERC20, Ownable {
      using SafeMath for uint256;
      using Address for address;
  
      mapping(address => uint256) private _rOwned;
      mapping(address => uint256) private _tOwned;
      mapping(address => mapping(address => uint256)) private _allowances;
  
      mapping(address => bool) private _isExcludedFromFee;
      mapping(address => bool) private _isExcluded;
      mapping(address => bool) private _isMarketMaker;
      address private constant USDT = 0xdAC17F958D2ee523a2206206994597C13D831ec7;
      bool isTradingEnabled;
  
      address[] private _excluded;
  
      uint256 private constant MAX = ~uint256(0);
      uint256 private _tTotal = 1000000 * 1e18; // 1 million supply
      uint256 private _rTotal = (MAX - (MAX % _tTotal));
      uint256 private _tFeeTotal;
      uint256 public maxWallet = 1000000 * 1e18; //  100% of the supply
  
      string private _name = "FXA";
      string private _symbol = "FXA";
      uint8 private _decimals = 18;
  
      struct BuyFee {
          uint16 marketingFee;
          uint16 reflectionFee;
          uint16 teamFee;
      }
  
      struct SellFee {
          uint16 marketingFee;
          uint16 reflectionFee;
          uint16 teamFee;
      }
  
      BuyFee public buyFee;
      SellFee public sellFee;
  
      uint16 private _reflectionFee;
      uint16 private _marketingFee;
      uint16 private _teamFee;
  
      IUniswapV2Router02 public uniswapV2Router;
      address public uniswapV2Pair;
      address public teamWallet;
      address public marketingWallet;
      address public presaleAddress;
  
      bool internal inSwapAndLiquify;
      bool public swapAndLiquifyEnabled = true;
      bool public feesInEth;
  
      uint256 private swapThreshold = 10 * 1e18;
  
      event MinTokensBeforeSwapUpdated(uint256 minTokensBeforeSwap);
      event SwapAndLiquifyEnabledUpdated(bool enabled);
      event SwapAndLiquify(uint256 tokensSwapped, uint256 ethReceived);
      event MaxWalletUpdated(uint256 amount);
      event BuyFeesUpdated(
          uint256 marketingFee,
          uint256 ReflectionFee,
          uint256 teamFee
      );
      event SellFeesUpdated(
          uint256 marketingFee,
          uint256 ReflectionFee,
          uint256 teamFee
      );
      event TokensClaimed(address indexed token, uint256 amount);
      event ETHClaimed(uint256 amount);
  
  
      modifier lockTheSwap() {
          inSwapAndLiquify = true;
          _;
          inSwapAndLiquify = false;
      }
  
      constructor() {
          _rOwned[_msgSender()] = _rTotal;
  
          buyFee.reflectionFee = 5;
          buyFee.marketingFee = 3;
          buyFee.teamFee = 2;
  
          sellFee.reflectionFee = 5;
          sellFee.marketingFee = 3;
          sellFee.teamFee = 2;
  
          IUniswapV2Router02 _uniswapV2Router = IUniswapV2Router02(
              0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D // uniswap v2 Router
          );
          // Create a uniswap pair for this new token
          uniswapV2Pair = IUniswapV2Factory(_uniswapV2Router.factory())
              .createPair(address(this), USDT);
          _isMarketMaker[uniswapV2Pair] = true;    
  
          // set the rest of the contract variables
          uniswapV2Router = _uniswapV2Router;
  
          // set your wallets below
          teamWallet = address(0xC047c46dF5ae043EF885b462E7e9849Dd588776A);
          marketingWallet = address(0x0b8aF020077eAFB29c0ACBe200fCA32AF29073c7);
          //exclude owner and this contract from fee
          _isExcludedFromFee[owner()] = true;
          _isExcludedFromFee[address(this)] = true;
  
          emit Transfer(address(0), _msgSender(), _tTotal);
      }
  
      function name() public view returns (string memory) {
          return _name;
      }
  
      function symbol() public view returns (string memory) {
          return _symbol;
      }
  
      function decimals() public view returns (uint8) {
          return _decimals;
      }
  
      function totalSupply() public view override returns (uint256) {
          return _tTotal;
      }
  
      function balanceOf(address account) public view override returns (uint256) {
          if (_isExcluded[account]) return _tOwned[account];
          return tokenFromReflection(_rOwned[account]);
      }
  
      function transfer(address recipient, uint256 amount)
          public
          override
          returns (bool)
      {
          _transfer(_msgSender(), recipient, amount);
          return true;
      }
  
      function allowance(address owner, address spender)
          public
          view
          override
          returns (uint256)
      {
          return _allowances[owner][spender];
      }
  
      function approve(address spender, uint256 amount)
          public
          override
          returns (bool)
      {
          _approve(_msgSender(), spender, amount);
          return true;
      }
  
      function transferFrom(
          address sender,
          address recipient,
          uint256 amount
      ) public override returns (bool) {
          _transfer(sender, recipient, amount);
          _approve(
              sender,
              _msgSender(),
              _allowances[sender][_msgSender()].sub(
                  amount,
                  "ERC20: transfer amount exceeds allowance"
              )
          );
          return true;
      }
  
      function increaseAllowance(address spender, uint256 addedValue)
          public
          virtual
          returns (bool)
      {
          _approve(
              _msgSender(),
              spender,
              _allowances[_msgSender()][spender].add(addedValue)
          );
          return true;
      }
  
      function decreaseAllowance(address spender, uint256 subtractedValue)
          public
          virtual
          returns (bool)
      {
          _approve(
              _msgSender(),
              spender,
              _allowances[_msgSender()][spender].sub(
                  subtractedValue,
                  "ERC20: decreased allowance below zero"
              )
          );
          return true;
      }
  
      function deliver(uint256 tAmount) public {
          address sender = _msgSender();
          require(
              !_isExcluded[sender],
              "Excluded addresses cannot call this function"
          );
          (uint256 rAmount, , , , , ) = _getValues(tAmount);
          _rOwned[sender] = _rOwned[sender].sub(rAmount);
          _rTotal = _rTotal.sub(rAmount);
          _tFeeTotal = _tFeeTotal.add(tAmount);
      }
  
      function reflectionFromToken(uint256 tAmount, bool deductTransferFee)
          public
          view
          returns (uint256)
      {
          require(tAmount <= _tTotal, "Amount must be less than supply");
          if (!deductTransferFee) {
              (uint256 rAmount, , , , , ) = _getValues(tAmount);
              return rAmount;
          } else {
              (, uint256 rTransferAmount, , , , ) = _getValues(tAmount);
              return rTransferAmount;
          }
      }
  
      function tokenFromReflection(uint256 rAmount)
          public
          view
          returns (uint256)
      {
          require(
              rAmount <= _rTotal,
              "Amount must be less than total reflections"
          );
          uint256 currentRate = _getRate();
          return rAmount.div(currentRate);
      }
  
      
      ///@dev set presale address (useful incase using pinksale or similiar platform for presale)
      ///@param _presaleAddress: presale address
      function setPresaleAddress(address _presaleAddress) external onlyOwner {
          require(_presaleAddress != address(0));
          presaleAddress = _presaleAddress;
          _isExcludedFromFee[_presaleAddress] = true;
      }
  
      ///@dev update max wallet amount
      ///@param percent: new maxWallet amount, must be greator than equal to 1 percent of the supply
      function updateMaxWalletAmount(uint256 percent) external onlyOwner {
          require(percent >= 1);
          maxWallet = (_tTotal * percent) / 100;
          emit MaxWalletUpdated(maxWallet);
      }
  
      ///@notice Returns if an address is excluded or not from reflection
      function isExcludedFromReward(address account) public view returns (bool) {
          return _isExcluded[account];
      }
  
      ///@notice Returns total reflection distributed so far
      function totalFees() public view returns (uint256) {
          return _tFeeTotal;
      }
  
      ///@dev exclude a particular address from reward
      ///@param account: address to be excluded from reward
      function excludeFromReward(address account) public onlyOwner {
          require(!_isExcluded[account]); /// account must not be excluded before
          if (_rOwned[account] > 0) {
              _tOwned[account] = tokenFromReflection(_rOwned[account]);
          }
          _isExcluded[account] = true;
          _excluded.push(account);
      }
  
      ///@dev include a address in reward
      ///@param account: address to be added in reward mapping again
      function includeInReward(address account) external onlyOwner {
  
          require(_isExcluded[account]); // account must be excluded before
          for (uint256 i = 0; i < _excluded.length; i++) {
              if (_excluded[i] == account) {
                  
                  if (_tOwned[account] > 0) {
                      uint256 newrOwned = _tOwned[account].mul(_getRate());
                      _rTotal = _rTotal.sub(_rOwned[account] - newrOwned);
                      _rOwned[account] = newrOwned;
                  } else {
                      _rOwned[account] = 0;
                  }
                  _tOwned[account] = 0;
                  _excluded[i] = _excluded[_excluded.length - 1];
                  _isExcluded[account] = false;
                  _excluded.pop();
                  break;
              }
          }
      }
  
      ///@dev manage exclude and include fee
      ///@param account: account to be excluded or included
      ///@param excluded: boolean value, true means excluded, false means included
      function excludeFromFee(address account, bool excluded) external onlyOwner {
          if (excluded) {
              require(!_isExcludedFromFee[account], "already excluded");
          }
          _isExcludedFromFee[account] = excluded;
      }
  
      ///@dev set buy fees
      ///@param market: new marketing fee on buy
      ///@param reflection: new reflection fee on buy
      ///@param team: new team fee on buy
      function setBuyFee(
          uint16 market,
          uint16 reflection,
          uint16 team
      ) external onlyOwner {
          buyFee.marketingFee = market;
          buyFee.reflectionFee = reflection;
          buyFee.teamFee = team;
          uint256 totalBuyFee = market + reflection + team;
          require(totalBuyFee <= 10);
  
          emit BuyFeesUpdated(market, reflection, team);
      }
  
      ///@dev set sell fees
      ///@param market: new marketing fee on sell
      ///@param reflection: new reflection fee on sell
      ///@param team: new team fee on sell
      function setSellFee(
          uint16 market,
          uint16 reflection,
          uint16 team
      ) external onlyOwner {
          sellFee.marketingFee = market;
          sellFee.reflectionFee = reflection;
          sellFee.teamFee = team;
          uint256 totalSellFee = market + reflection + team;
          require(totalSellFee <= 10);
          emit SellFeesUpdated(market, reflection, team);
      }
  
      ///@dev set swap amount after which collected tax should be swappped for ether
      ///@param numTokens: new token amount
      function setSwapTokensAtAmount(uint256 numTokens) external onlyOwner {
          swapThreshold = numTokens * 1e18;
          emit MinTokensBeforeSwapUpdated(numTokens);
      }
  
      /// @dev change fee mode
      /// true for eth, false for usdt
      /// main pair must be usdt
      function feeModeInEth (bool value) external onlyOwner {
          feesInEth = value;
      }
  
      ///@dev claim stucked tokens from contract
      ///@param _token: token address to be rescued
      ///@param value: amount to be claimed
      function claimStuckTokens(address _token, uint256 value) external onlyOwner {
          // bytes4(keccak256(bytes('transfer(address,uint256)')));
          (bool success, bytes memory data) = _token.call(abi.encodeWithSelector(0xa9059cbb, owner(), value));
          require(success && (data.length == 0 || abi.decode(data, (bool))), 'FXA: TOKEN_CLAIM_FAILED');
          emit TokensClaimed(_token, value);
      }
  
      ///@dev owner can claim any stucked ETH from contract
      function claimETH() external onlyOwner {
          (bool sent, ) = owner().call{value: address(this).balance}("");
          require(sent, "eth transfer failed");
          emit ETHClaimed(address(this).balance);
      }
  
      /// @dev add or remove pair
      /// can't remove main pair
      function setAutomatedMarketMakerPair(address newPair, bool value) external onlyOwner {
          require(newPair != uniswapV2Pair);
          _isMarketMaker[newPair] = value;
      }
  
      //to recieve ETH from uniswapV2Router when swaping
      receive() external payable {}
      
  
      function _reflectFee(uint256 rFee, uint256 tFee) private {
          _rTotal = _rTotal.sub(rFee);
          _tFeeTotal = _tFeeTotal.add(tFee);
      }
  
      function _getValues(uint256 tAmount)
          private
          view
          returns (
              uint256,
              uint256,
              uint256,
              uint256,
              uint256,
              uint256
          )
      {
          (
              uint256 tTransferAmount,
              uint256 tFee,
              uint256 tMarketing,
              uint256 tTeam
          ) = _getTValues(tAmount);
          (uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(
              tAmount,
              tFee,
              tMarketing,
              tTeam,
              _getRate()
          );
          return (
              rAmount,
              rTransferAmount,
              rFee,
              tTransferAmount,
              tFee,
              tMarketing
          );
      }
  
      function _getTValues(uint256 tAmount)
          private
          view
          returns (
              uint256,
              uint256,
              uint256,
              uint256
          )
      {
          uint256 tFee = calculateReflectionFee(tAmount);
          uint256 tMarketing = calculateMarketingFee(tAmount);
          uint256 tTeam = calculateTeamFee(tAmount);
          uint256 tTransferAmount = tAmount.sub(tFee).sub(tMarketing);
          tTransferAmount = tTransferAmount.sub(tTeam);
          return (tTransferAmount, tFee, tMarketing, tTeam);
      }
  
      function _getRValues(
          uint256 tAmount,
          uint256 tFee,
          uint256 tMarketing,
          uint256 tTeam,
          uint256 currentRate
      )
          private
          pure
          returns (
              uint256,
              uint256,
              uint256
          )
      {
          uint256 rAmount = tAmount.mul(currentRate);
          uint256 rFee = tFee.mul(currentRate);
          uint256 rMarketing = tMarketing.mul(currentRate);
          uint256 rTeam = tTeam.mul(currentRate);
          uint256 rTransferAmount = rAmount.sub(rFee).sub(rMarketing).sub(rTeam);
          return (rAmount, rTransferAmount, rFee);
      }
  
      function _getRate() private view returns (uint256) {
          (uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
          return rSupply.div(tSupply);
      }
  
      function _getCurrentSupply() private view returns (uint256, uint256) {
          uint256 rSupply = _rTotal;
          uint256 tSupply = _tTotal;
          for (uint256 i = 0; i < _excluded.length; i++) {
              if (
                  _rOwned[_excluded[i]] > rSupply ||
                  _tOwned[_excluded[i]] > tSupply
              ) return (_rTotal, _tTotal);
              rSupply = rSupply.sub(_rOwned[_excluded[i]]);
              tSupply = tSupply.sub(_tOwned[_excluded[i]]);
          }
          if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
          return (rSupply, tSupply);
      }
  
      function _takeMarketing(uint256 tMarketing) private {
          uint256 currentRate = _getRate();
          uint256 rMarketing = tMarketing.mul(currentRate);
          _rOwned[address(this)] = _rOwned[address(this)].add(rMarketing);
          if (_isExcluded[address(this)])
              _tOwned[address(this)] = _tOwned[address(this)].add(tMarketing);
      }
  
      function _takeTeam(uint256 tTeam) private {
          uint256 currentRate = _getRate();
          uint256 rTeam = tTeam.mul(currentRate);
  
          _rOwned[address(this)] = _rOwned[address(this)].add(rTeam);
          if (_isExcluded[address(this)]) {
              _tOwned[address(this)] = _tOwned[address(this)].add(tTeam);
          }
      }
  
      ///@notice enabled trading globally,
      ///can be called once and can never be turned off.
      function enableTrading() external onlyOwner {
          require(!isTradingEnabled);
          isTradingEnabled = true;
      }
  
      function calculateReflectionFee(uint256 _amount)
          private
          view
          returns (uint256)
      {
          return _amount.mul(_reflectionFee).div(10**2);
      }
  
      function calculateMarketingFee(uint256 _amount)
          private
          view
          returns (uint256)
      {
          return _amount.mul(_marketingFee).div(10**2);
      }
  
      function calculateTeamFee(uint256 _amount) private view returns (uint256) {
          return _amount.mul(_teamFee).div(10**2);
      }
  
      function removeAllFee() private {
          _reflectionFee = 0;
          _marketingFee = 0;
          _teamFee = 0;
      }
  
      function setBuy() private {
          _reflectionFee = buyFee.reflectionFee;
          _marketingFee = buyFee.marketingFee;
          _teamFee = buyFee.teamFee;
      }
  
      function setSell() private {
          _reflectionFee = sellFee.reflectionFee;
          _marketingFee = sellFee.marketingFee;
          _teamFee = sellFee.teamFee;
      }
  
      function isExcludedFromFee(address account) public view returns (bool) {
          return _isExcludedFromFee[account];
      }
  
      function _approve(
          address owner,
          address spender,
          uint256 amount
      ) private {
          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 _transfer(
          address from,
          address to,
          uint256 amount
      ) private {
          require(from != address(0), "ERC20: transfer from the zero address");
          require(to != address(0), "ERC20: transfer to the zero address");
          require(amount > 0, "Transfer amount must be greater than zero");
  
          if (from != owner() || from != presaleAddress) {
              require(isTradingEnabled, "trading is not live");
          }
  
          // is the token balance of this contract address over the min number of
          // tokens that we need to initiate a swap + liquidity lock?
          // also, don't get caught in a circular liquidity event.
          // also, don't swap & liquify if sender is uniswap pair.
          uint256 contractTokenBalance = balanceOf(address(this));
  
          bool overMinTokenBalance = contractTokenBalance >= swapThreshold;
          if (
              overMinTokenBalance &&
              !inSwapAndLiquify &&
              from != uniswapV2Pair &&
              swapAndLiquifyEnabled
          ) {
              swapAndLiquify(contractTokenBalance);
          }
  
          //indicates if fee should be deducted from transfer
          bool takeFee = true;
  
          //if any account belongs to _isExcludedFromFee account then remove the fee
          if (_isExcludedFromFee[from] || _isExcludedFromFee[to]) {
              takeFee = false;
          }
  
          //transfer amount, it will take reflection, liquidity fee
          _tokenTransfer(from, to, amount, takeFee);
      }
  
      function swapAndLiquify(uint256 tokens) private lockTheSwap {
          uint256 oldBalance = address(this).balance;
          // swap tokens for ETH
          if(feesInEth){
          swapTokensForEth(tokens);
          } else {
              swapTokensForUsdt(tokens);
          }
          // how much ETH did we just swap into?
          uint256 newBalance = address(this).balance.sub(oldBalance);
          if(!feesInEth){
              newBalance = IERC20(USDT).balanceOf(address(this));
          }
          uint256 divisor = buyFee.marketingFee +
              buyFee.teamFee +
              sellFee.marketingFee +
              sellFee.teamFee;
          if(divisor > 0){
          /// when fees is in eth    
          uint256 marketingShare = newBalance
              .mul(buyFee.marketingFee + sellFee.marketingFee)
              .div(divisor);
          if(feesInEth){    
          bool sent;
          (sent, ) = marketingWallet.call{value: marketingShare}("");
          (sent, ) = teamWallet.call{value: address(this).balance}("");
  
          /// When fees is in usdt
          } else {
              bool success;
               marketingShare = newBalance.mul(buyFee.marketingFee + sellFee.marketingFee)
              .div(divisor);
               (success,) = USDT.call(abi.encodeWithSelector(0xa9059cbb, marketingWallet, marketingShare));
               uint256 teamShare = IERC20(USDT).balanceOf(address(this));
               (success,) = USDT.call(abi.encodeWithSelector(0xa9059cbb, teamWallet, teamShare));
          
          }
          emit SwapAndLiquify(tokens, newBalance);
          }
      }
  
      ///@notice swap given tokens input for ETH
      function swapTokensForEth(uint256 tokenAmount) private {
          // generate the uniswap pair path of token -> weth
          address[] memory path = new address[](3);
          path[0] = address(this);
          path[1] = USDT;
          path[2] = uniswapV2Router.WETH();
  
          _approve(address(this), address(uniswapV2Router), tokenAmount);
  
          // make the swap
          uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens(
              tokenAmount,
              0, // accept any amount of ETH
              path,
              address(this),
              block.timestamp + 360
          );
      }
  
      function swapTokensForUsdt(uint256 tokens) private {
           // generate the uniswap pair path of token -> weth
          address[] memory path = new address[](2);
          path[0] = address(this);
          path[1] = USDT;
          
  
          _approve(address(this), address(uniswapV2Router), tokens);
          uniswapV2Router.swapExactTokensForTokensSupportingFeeOnTransferTokens(
              tokens,
              0,
              path,
              address(this),
              block.timestamp + 360
          );
      }
  
      ///@dev update the fee wallets
      function updateFeeWallets(address marketing, address team) external onlyOwner {
          //zero address is not allowed
          require(marketing != address(0) && team != address(0));
          marketingWallet = marketing;
          teamWallet = team;
      }
  
      //this method is responsible for taking all fee, if takeFee is true
      function _tokenTransfer(
          address sender,
          address recipient,
          uint256 amount,
          bool takeFee
      ) private {
          removeAllFee();
  
          if (takeFee) {
              if (_isMarketMaker[sender]) {
                  setBuy();
              }
              if (_isMarketMaker[recipient]) {
                  setSell();
              }
  
              if (!_isMarketMaker[recipient]) {
                  require(
                      balanceOf(recipient) + amount <= maxWallet,
                      "max wallet limit exceed"
                  );
              }
          }
  
          if (_isExcluded[sender] && !_isExcluded[recipient]) {
              _transferFromExcluded(sender, recipient, amount);
          } else if (!_isExcluded[sender] && _isExcluded[recipient]) {
              _transferToExcluded(sender, recipient, amount);
          } else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
              _transferStandard(sender, recipient, amount);
          } else if (_isExcluded[sender] && _isExcluded[recipient]) {
              _transferBothExcluded(sender, recipient, amount);
          } else {
              _transferStandard(sender, recipient, amount);
          }
      }
  
      function _transferStandard(
          address sender,
          address recipient,
          uint256 tAmount
      ) private {
          (
              uint256 rAmount,
              uint256 rTransferAmount,
              uint256 rFee,
              uint256 tTransferAmount,
              uint256 tFee,
              uint256 tMarketing
          ) = _getValues(tAmount);
          _rOwned[sender] = _rOwned[sender].sub(rAmount);
          _rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
          _takeMarketing(tMarketing);
          _takeTeam(calculateTeamFee(tAmount));
          _reflectFee(rFee, tFee);
          emit Transfer(sender, recipient, tTransferAmount);
      }
  
      function _transferToExcluded(
          address sender,
          address recipient,
          uint256 tAmount
      ) private {
          (
              uint256 rAmount,
              uint256 rTransferAmount,
              uint256 rFee,
              uint256 tTransferAmount,
              uint256 tFee,
              uint256 tMarketing
          ) = _getValues(tAmount);
          _rOwned[sender] = _rOwned[sender].sub(rAmount);
          _tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
          _rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
          _takeMarketing(tMarketing);
          _takeTeam(calculateTeamFee(tAmount));
  
          _reflectFee(rFee, tFee);
          emit Transfer(sender, recipient, tTransferAmount);
      }
  
      function _transferFromExcluded(
          address sender,
          address recipient,
          uint256 tAmount
      ) private {
          (
              uint256 rAmount,
              uint256 rTransferAmount,
              uint256 rFee,
              uint256 tTransferAmount,
              uint256 tFee,
              uint256 tMarketing
          ) = _getValues(tAmount);
          _tOwned[sender] = _tOwned[sender].sub(tAmount);
          _rOwned[sender] = _rOwned[sender].sub(rAmount);
          _rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
          _takeMarketing(tMarketing);
          _takeTeam(calculateTeamFee(tAmount));
  
          _reflectFee(rFee, tFee);
          emit Transfer(sender, recipient, tTransferAmount);
      }
  
      function _transferBothExcluded(
          address sender,
          address recipient,
          uint256 tAmount
      ) private {
          (
              uint256 rAmount,
              uint256 rTransferAmount,
              uint256 rFee,
              uint256 tTransferAmount,
              uint256 tFee,
              uint256 tMarketing
          ) = _getValues(tAmount);
          _tOwned[sender] = _tOwned[sender].sub(tAmount);
          _rOwned[sender] = _rOwned[sender].sub(rAmount);
          _tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
          _rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
          _takeMarketing(tMarketing);
          _takeTeam(calculateTeamFee(tAmount));
  
          _reflectFee(rFee, tFee);
          emit Transfer(sender, recipient, tTransferAmount);
      }
  }