Contract Address Details

// SPDX-License-Identifier: MIT License
// File: contracts/SafeMath.sol



pragma solidity ^0.8.6;

library SafeMath {
  /**
   * @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) {
    uint256 c = a + b;
    require(c >= a, "SafeMath: addition overflow");

    return c;
  }

  /**
   * @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 sub(a, b, "SafeMath: subtraction overflow");
  }

  /**
   * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
   * overflow (when the result is negative).
   *
   * Counterpart to Solidity's `-` operator.
   *
   * Requirements:
   *
   * - Subtraction cannot overflow.
   */
  function sub(
    uint256 a,
    uint256 b,
    string memory errorMessage
  ) internal pure returns (uint256) {
    require(b <= a, errorMessage);
    uint256 c = a - b;

    return c;
  }

  /**
   * @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) {
    // 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 0;
    }

    uint256 c = a * b;
    require(c / a == b, "SafeMath: multiplication overflow");

    return c;
  }

  /**
   * @dev Returns the integer division of two unsigned integers. Reverts 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) internal pure returns (uint256) {
    return div(a, b, "SafeMath: division by zero");
  }

  /**
   * @dev Returns the integer division of two unsigned integers. Reverts 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) {
    require(b > 0, errorMessage);
    uint256 c = a / b;
    // assert(a == b * c + a % b); // There is no case in which this doesn't hold

    return c;
  }

  /**
   * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
   * Reverts 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 mod(a, b, "SafeMath: modulo by zero");
  }

  /**
   * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
   * Reverts with custom message 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,
    string memory errorMessage
  ) internal pure returns (uint256) {
    require(b != 0, errorMessage);
    return a % b;
  }
}

// File: contracts/Context.sol



pragma solidity ^0.8.6;

/*
 * @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) {
    this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
    return msg.data;
  }
}

// File: contracts/Ownable.sol



pragma solidity ^0.8.6;


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() {
    address msgSender = _msgSender();
    _owner = msgSender;
    emit OwnershipTransferred(address(0), msgSender);
  }

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

  /**
   * @dev Throws if called by any account other than the owner.
   */
  modifier onlyOwner() {
    require(_owner == _msgSender(), "Ownable: caller is not the owner");
    _;
  }

  /**
   * @dev Leaves the contract without owner. It will not be possible to call
   * `onlyOwner` functions anymore. Can only be called by the current owner.
   *
   * NOTE: Renouncing ownership will leave the contract without an owner,
   * thereby removing any functionality that is only available to the owner.
   */
  function renounceOwnership() public virtual onlyOwner {
    emit OwnershipTransferred(_owner, address(0));
    _owner = 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");
    emit OwnershipTransferred(_owner, newOwner);
    _owner = newOwner;
  }
}

// File: contracts/IERC20.sol



pragma solidity ^0.8.6;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
  /**
   * @dev Returns the amount of tokens in existence.
   */
  function totalSupply() external view returns (uint256);

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

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

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

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

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

  /**
   * @dev Emitted when `value` tokens are moved from one account (`from`) to
   * another (`to`).
   *
   * Note that `value` may be zero.
   */
  event Transfer(address indexed from, address indexed to, uint256 value);

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

// File: contracts/IERC20Metadata.sol



pragma solidity ^0.8.6;


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

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

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

// File: contracts/ERC20.sol



pragma solidity ^0.8.6;





/**
 * @dev Implementation of the {IERC20} interface.
 *
 * This implementation is agnostic to the way tokens are created. This means
 * that a supply mechanism has to be added in a derived contract using {_mint}.
 * For a generic mechanism see {ERC20PresetMinterPauser}.
 *
 * TIP: For a detailed writeup see our guide
 * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How
 * to implement supply mechanisms].
 *
 * We have followed general OpenZeppelin guidelines: functions revert instead
 * of 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 {
  using SafeMath for uint256;

  mapping(address => uint256) private _balances;

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

  uint256 private _totalSupply;

  string private _name;
  string private _symbol;

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

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

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

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

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

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

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

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

  /**
   * @dev See {IERC20-approve}.
   *
   * Requirements:
   *
   * - `spender` cannot be the zero address.
   */
  function approve(address spender, uint256 amount)
    public
    virtual
    override
    returns (bool)
  {
    _approve(_msgSender(), spender, amount);
    return true;
  }

  /**
   * @dev See {IERC20-transferFrom}.
   *
   * Emits an {Approval} event indicating the updated allowance. This is not
   * required by the EIP. See the note at the beginning of {ERC20}.
   *
   * Requirements:
   *
   * - `sender` and `recipient` cannot be the zero address.
   * - `sender` must have a balance of at least `amount`.
   * - the caller must have allowance for ``sender``'s tokens of at least
   * `amount`.
   */
  function transferFrom(
    address sender,
    address recipient,
    uint256 amount
  ) public virtual override returns (bool) {
    _transfer(sender, recipient, amount);
    _approve(
      sender,
      _msgSender(),
      _allowances[sender][_msgSender()].sub(
        amount,
        "ERC20: transfer amount exceeds allowance"
      )
    );
    return true;
  }

  /**
   * @dev Atomically increases the allowance granted to `spender` by the caller.
   *
   * This is an alternative to {approve} that can be used as a mitigation for
   * problems described in {IERC20-approve}.
   *
   * Emits an {Approval} event indicating the updated allowance.
   *
   * Requirements:
   *
   * - `spender` cannot be the zero address.
   */
  function increaseAllowance(address spender, uint256 addedValue)
    public
    virtual
    returns (bool)
  {
    _approve(
      _msgSender(),
      spender,
      _allowances[_msgSender()][spender].add(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)
  {
    _approve(
      _msgSender(),
      spender,
      _allowances[_msgSender()][spender].sub(
        subtractedValue,
        "ERC20: decreased allowance below zero"
      )
    );
    return true;
  }

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

    _beforeTokenTransfer(sender, recipient, amount);

    _balances[sender] = _balances[sender].sub(
      amount,
      "ERC20: transfer amount exceeds balance"
    );
    _balances[recipient] = _balances[recipient].add(amount);
    emit Transfer(sender, recipient, amount);
  }

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

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

    _totalSupply = _totalSupply.add(amount);
    _balances[account] = _balances[account].add(amount);
    emit Transfer(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);

    _balances[account] = _balances[account].sub(
      amount,
      "ERC20: burn amount exceeds balance"
    );
    _totalSupply = _totalSupply.sub(amount);
    emit Transfer(account, address(0), amount);
  }

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

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

  /**
   * @dev Hook that is called before any transfer of tokens. This includes
   * minting and burning.
   *
   * Calling conditions:
   *
   * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
   * will be to 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 {}
}

// File: contracts/IUniswapV2Factory.sol



pragma solidity ^0.8.6;

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

  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(uint256) external view returns (address pair);

  function allPairsLength() external view returns (uint256);

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

  function setFeeTo(address) external;

  function setFeeToSetter(address) external;
}

// File: contracts/IUniswapRouter.sol



pragma solidity ^0.8.6;

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

  function WETH() external pure returns (address);

  function addLiquidity(
    address tokenA,
    address tokenB,
    uint256 amountADesired,
    uint256 amountBDesired,
    uint256 amountAMin,
    uint256 amountBMin,
    address to,
    uint256 deadline
  )
    external
    returns (
      uint256 amountA,
      uint256 amountB,
      uint256 liquidity
    );

  function addLiquidityETH(
    address token,
    uint256 amountTokenDesired,
    uint256 amountTokenMin,
    uint256 amountETHMin,
    address to,
    uint256 deadline
  )
    external
    payable
    returns (
      uint256 amountToken,
      uint256 amountETH,
      uint256 liquidity
    );

  function removeLiquidity(
    address tokenA,
    address tokenB,
    uint256 liquidity,
    uint256 amountAMin,
    uint256 amountBMin,
    address to,
    uint256 deadline
  ) external returns (uint256 amountA, uint256 amountB);

  function removeLiquidityETH(
    address token,
    uint256 liquidity,
    uint256 amountTokenMin,
    uint256 amountETHMin,
    address to,
    uint256 deadline
  ) external returns (uint256 amountToken, uint256 amountETH);

  function removeLiquidityWithPermit(
    address tokenA,
    address tokenB,
    uint256 liquidity,
    uint256 amountAMin,
    uint256 amountBMin,
    address to,
    uint256 deadline,
    bool approveMax,
    uint8 v,
    bytes32 r,
    bytes32 s
  ) external returns (uint256 amountA, uint256 amountB);

  function removeLiquidityETHWithPermit(
    address token,
    uint256 liquidity,
    uint256 amountTokenMin,
    uint256 amountETHMin,
    address to,
    uint256 deadline,
    bool approveMax,
    uint8 v,
    bytes32 r,
    bytes32 s
  ) external returns (uint256 amountToken, uint256 amountETH);

  function swapExactTokensForTokens(
    uint256 amountIn,
    uint256 amountOutMin,
    address[] calldata path,
    address to,
    uint256 deadline
  ) external returns (uint256[] memory amounts);

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

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

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

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

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

  function quote(
    uint256 amountA,
    uint256 reserveA,
    uint256 reserveB
  ) external pure returns (uint256 amountB);

  function getAmountOut(
    uint256 amountIn,
    uint256 reserveIn,
    uint256 reserveOut
  ) external pure returns (uint256 amountOut);

  function getAmountIn(
    uint256 amountOut,
    uint256 reserveIn,
    uint256 reserveOut
  ) external pure returns (uint256 amountIn);

  function getAmountsOut(uint256 amountIn, address[] calldata path)
    external
    view
    returns (uint256[] memory amounts);

  function getAmountsIn(uint256 amountOut, address[] calldata path)
    external
    view
    returns (uint256[] memory amounts);
}

// pragma solidity >=0.6.2;

interface IUniswapV2Router02 is IUniswapV2Router01 {
  function removeLiquidityETHSupportingFeeOnTransferTokens(
    address token,
    uint256 liquidity,
    uint256 amountTokenMin,
    uint256 amountETHMin,
    address to,
    uint256 deadline
  ) external returns (uint256 amountETH);

  function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
    address token,
    uint256 liquidity,
    uint256 amountTokenMin,
    uint256 amountETHMin,
    address to,
    uint256 deadline,
    bool approveMax,
    uint8 v,
    bytes32 r,
    bytes32 s
  ) external returns (uint256 amountETH);

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

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

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

// File: contracts/IUniswapV2Pair.sol



pragma solidity ^0.8.6;

interface IUniswapV2Pair {
  event Approval(address indexed owner, address indexed spender, uint256 value);
  event Transfer(address indexed from, address indexed to, uint256 value);

  function name() external pure returns (string memory);

  function symbol() external pure returns (string memory);

  function decimals() external pure returns (uint8);

  function totalSupply() external view returns (uint256);

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

  function allowance(address owner, address spender)
    external
    view
    returns (uint256);

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

  function transfer(address to, uint256 value) external returns (bool);

  function transferFrom(
    address from,
    address to,
    uint256 value
  ) external returns (bool);

  function DOMAIN_SEPARATOR() external view returns (bytes32);

  function PERMIT_TYPEHASH() external pure returns (bytes32);

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

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

  event Mint(address indexed sender, uint256 amount0, uint256 amount1);
  event Burn(
    address indexed sender,
    uint256 amount0,
    uint256 amount1,
    address indexed to
  );
  event Swap(
    address indexed sender,
    uint256 amount0In,
    uint256 amount1In,
    uint256 amount0Out,
    uint256 amount1Out,
    address indexed to
  );
  event Sync(uint112 reserve0, uint112 reserve1);

  function MINIMUM_LIQUIDITY() external pure returns (uint256);

  function factory() external view returns (address);

  function token0() external view returns (address);

  function token1() external view returns (address);

  function getReserves()
    external
    view
    returns (
      uint112 reserve0,
      uint112 reserve1,
      uint32 blockTimestampLast
    );

  function price0CumulativeLast() external view returns (uint256);

  function price1CumulativeLast() external view returns (uint256);

  function kLast() external view returns (uint256);

  function mint(address to) external returns (uint256 liquidity);

  function burn(address to) external returns (uint256 amount0, uint256 amount1);

  function swap(
    uint256 amount0Out,
    uint256 amount1Out,
    address to,
    bytes calldata data
  ) external;

  function skim(address to) external;

  function sync() external;

  function initialize(address, address) external;
}

// File: contracts/DoKEN.sol



//import "./DoKENDividendTracker.sol";
//import "./DividendPayingToken.sol";






pragma solidity ^0.8.6;

contract DoKEN is ERC20, Ownable {
  using SafeMath for uint256;
  // Events Declarations

  event EnableTrading(uint256 indexed blockNumber);

  event UpdateDividendTracker(
    address indexed newAddress,
    address indexed oldAddress
  );
  event UpdateUniswapV2Router(
    address indexed newAddress,
    address indexed oldAddress
  );
  event UpdateMarketingWallet(
    address indexed newWallet,
    address indexed oldWallet
  );
  event UpdateBuybackWallet(
    address indexed newWallet,
    address indexed oldWallet
  );
  event UpdatePresaleWallet(
    address indexed newWallet,
    address indexed oldWallet
  );
  event UpdateGasForProcessing(
    uint256 indexed newValue,
    uint256 indexed oldValue
  );

  event UpdateMarketingFee(uint256 indexed newValue, uint256 indexed oldValue);
  event UpdateBuybackFee(uint256 indexed newValue, uint256 indexed oldValue);
  event UpdateLiquidityFee(uint256 indexed newValue, uint256 indexed oldValue);
  event UpdateRewardsFee(uint256 indexed newValue, uint256 indexed oldValue);
  event UpdateSellFee(uint256 indexed newValue, uint256 indexed oldValue);

  event UpdateMaxBuyTransactionAmount(
    uint256 indexed newValue,
    uint256 indexed oldValue
  );
  event UpdateMaxSellTransactionAmount(
    uint256 indexed newValue,
    uint256 indexed oldValue
  );
  event UpdateSwapTokensAtAmount(
    uint256 indexed newValue,
    uint256 indexed oldValue
  );
  event UpdateSwapAndLiquify(bool enabled);

  event WhitelistAccount(address indexed account, bool isWhitelisted);
  event ExcludeFromFees(address indexed account, bool isExcluded);
  event ExcludeMultipleAccountsFromFees(address[] accounts, bool isExcluded);
  event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);

  event SwapAndLiquify(
    uint256 tokensSwapped,
    uint256 ethReceived,
    uint256 tokensIntoLiqudity
  );

  event SendDividends(uint256 tokensSwapped, uint256 amount);

  event ProcessedDividendTracker(
    uint256 iterations,
    uint256 claims,
    uint256 lastProcessedIndex,
    bool indexed automatic,
    uint256 gas,
    address indexed processor
  );

  event TransferETHToMarketingWallet(address indexed wallet, uint256 amount);
  event TransferETHToDevWallet(address indexed wallet, uint256 amount);
  event TransferTokensToMarketingWallet(address indexed wallet, uint256 amount);
  event TransferTokensToDevWallet(address indexed wallet, uint256 amount);
  event TransferETHToBuybackWallet(address indexed wallet, uint256 amount);
  event TransferTokensToBuybackWallet(address indexed wallet, uint256 amount);
  event ExcludeAccountFromDividends(address indexed account);

  //
  IUniswapV2Router02 public uniswapV2Router;
  address public immutable uniswapV2Pair;

  bool private swapping;
  bool public swapAndLiquifyEnabled = true;

  // DoKENDividendTracker public dividendTracker;

  // Constraints for changing various buy/sell thresholds - in practice
  // actual values should be reasonable
  uint256 public immutable MIN_BUY_TRANSACTION_AMOUNT = 500000000 * (10**18); // 0.05% of supply
  uint256 public immutable MAX_BUY_TRANSACTION_AMOUNT = 50000000000 * (10**18); // 5% of supply
  uint256 public immutable MIN_SELL_TRANSACTION_AMOUNT = 100000000 * (10**18); // 0.01% of total supply
  uint256 public immutable MAX_SELL_TRANSACTION_AMOUNT = 50000000000 * (10**18); // 5% of total supply
  uint256 public immutable MIN_SWAP_TOKENS_AT_AMOUNT = 200000000 * (10**18); // 0.02% of total supply
  uint256 public immutable MAX_SWAP_TOKENS_AT_AMOUNT = 20000000000 * (10**18); // 2% of total supply

  uint256 public maxBuyTransactionAmount = 10000000000 * (10**18); // 1% of supply
  uint256 public maxSellTransactionAmount = 10000000000 * (10**18); // 1% of supply
  uint256 public swapTokensAtAmount = 200000000 * (10**18); // 0.02 % of supply

  // Max fees to avoid owner greed - in practice the actual fees should be much lower
  uint256 public immutable MAX_MARKETING_FEE = 10;
  uint256 public immutable MAX_DEV_FEE = 10;
  uint256 public immutable MAX_BUYBACK_FEE = 10;
  uint256 public immutable MAX_REWARDS_FEE = 10;
  uint256 public immutable MAX_LIQUIDITY_FEE = 5;
  uint256 public immutable MAX_TOTAL_FEES = 30;
  uint256 public immutable MAX_SELL_FEE = 5;

  uint256 public marketingFee = 2;
  uint256 public devFee = 2;
  uint256 public buybackFee = 7;
  uint256 public rewardsFee = 0;
  uint256 public liquidityFee = 2;
  uint256 public sellFee = 0; // fees are increased by 3% for sells

  // Trading can only be enabled, not disabled. Used so that contract can be deployed / liq added
  // without bots interfering.
  bool internal tradingEnabled = false;

  address payable public marketingWallet =
    payable(0x53cA2a894406848fbB34444859013F068F52FBe1);
  address payable public devWallet =
    payable(0x5311c06B4cde0e823d9821DE1fFd24485e9c3F2f);
  address payable public buybackWallet =
    payable(0xD92167036635E11931c0b9c08Ff3c2cDB0F46E2D);
  address payable public preSaleWallet =
    payable(0xE5988df0403E635349423838d99234515cA0a162);

  // BUSD Token
  address public rewardToken = 0xc21223249CA28397B4B6541dfFaEcC539BfF0c59; // mainnet BUSD
  //address public rewardToken = 0x78867BbEeF44f2326bF8DDd1941a4439382EF2A7; // testnet BUSD

  // use by default 300,000 gas to process auto-claiming dividends
  uint256 public gasForProcessing = 300000;

  // Absolute max gas amount for processing dividends
  uint256 public immutable MAX_GAS_FOR_PROCESSING = 5000000;

  // exclude from fees
  mapping(address => bool) private _isExcludedFromFees;

  // Can add LP before trading is enabled
  mapping(address => bool) public isWhitelisted;

  uint256 public totalFeesCollected;

  // store addresses that a automatic market maker pairs. Any transfer *to* these addresses
  // could be subject to a maximum transfer amount
  mapping(address => bool) public automatedMarketMakerPairs;

  constructor() ERC20("DoKEN", "DoKEN") {
    // dividendTracker = new DoKENDividendTracker();
    IUniswapV2Router02 _uniswapV2Router = IUniswapV2Router02(
      0x145677FC4d9b8F19B5D56d1820c48e0443049a30 // mainnet
      //0x9Ac64Cc6e4415144C455BD8E4837Fea55603e5c3 // testnet
    );

    // Create a uniswap pair for this new token
    address _uniswapV2Pair = IUniswapV2Factory(_uniswapV2Router.factory())
      .createPair(address(this), _uniswapV2Router.WETH());

    uniswapV2Router = _uniswapV2Router;
    uniswapV2Pair = _uniswapV2Pair;

    _setAutomatedMarketMakerPair(_uniswapV2Pair, true);

    // exclude from receiving dividends. We purposely don't exclude
    // the marketing wallet from dividends since we're going to use
    // those dividends for things like giveaways and marketing. These
    // dividends are more useful than tokens in some cases since selling
    // them doesnt impact token price.
    // dividendTracker.excludeFromDividends(address(dividendTracker));
    // dividendTracker.excludeFromDividends(address(this));
    // dividendTracker.excludeFromDividends(address(_uniswapV2Router));
    // dividendTracker.excludeFromDividends(address(0xdEaD));
    // dividendTracker.excludeFromDividends(address(0));
    // dividendTracker.excludeFromDividends(owner());
    // dividendTracker.excludeFromDividends(buybackWallet);
    // dividendTracker.excludeFromDividends(devWallet);
    // dividendTracker.excludeFromDividends(preSaleWallet);

    // exclude from paying fees or having max transaction amount
    excludeFromFees(address(this), true);
    excludeFromFees(marketingWallet, true);
    excludeFromFees(devWallet, true);
    excludeFromFees(buybackWallet, true);
    excludeFromFees(preSaleWallet, true);
    excludeFromFees(owner(), true);
    excludeFromFees(address(0xdEaD), true);
    excludeFromFees(address(0), true);

    // Whitelist accounts so they can transfer tokens before trading is enabled
    whitelistAccount(address(this), true);
    whitelistAccount(owner(), true);
    whitelistAccount(address(uniswapV2Router), true);
    whitelistAccount(preSaleWallet, true);

    /*
    _mint is an internal function in ERC20.sol that is only called here,
    and CANNOT be called ever again
    */
    _mint(owner(), 1000000000000 * (10**18)); // 1,000,000,000,000
  }

  receive() external payable {}

  function updateSwapAndLiquify(bool enabled) external onlyOwner {
    swapAndLiquifyEnabled = enabled;
    emit UpdateSwapAndLiquify(enabled);
  }

  function isTradingEnabled() public view returns (bool) {
    return tradingEnabled;
  }

  function whitelistAccount(address account, bool whitelisted)
    public
    onlyOwner
  {
    isWhitelisted[account] = whitelisted;
    emit WhitelistAccount(account, whitelisted);
  }

  function isWhitelistedAccount(address account) public view returns (bool) {
    return isWhitelisted[account];
  }

  function enableTrading() external onlyOwner {
    require(!tradingEnabled, "trading is already enabled");
    tradingEnabled = true;
    emit EnableTrading(block.number);
  }

  function getTotalFees() public view returns (uint256) {
    return
      marketingFee.add(buybackFee).add(liquidityFee).add(rewardsFee).add(
        devFee
      );
  }

  function updateMarketingWallet(address payable newAddress)
    external
    onlyOwner
  {
    require(marketingWallet != newAddress, "new address required");
    address oldWallet = marketingWallet;
    marketingWallet = newAddress;
    excludeFromFees(newAddress, true);
    emit UpdateMarketingWallet(marketingWallet, oldWallet);
  }

  function updateDevWallet(address payable newAddress) external onlyOwner {
    require(devWallet != newAddress, "new address required");
    address oldWallet = devWallet;
    devWallet = newAddress;
    excludeFromFees(newAddress, true);
    emit UpdateMarketingWallet(devWallet, oldWallet);
  }

  function updateBuybackWallet(address payable newAddress) external onlyOwner {
    require(buybackWallet != newAddress, "new address required");
    address oldWallet = buybackWallet;
    buybackWallet = newAddress;
    excludeFromFees(newAddress, true);
    emit UpdateBuybackWallet(buybackWallet, oldWallet);
  }

  // function updatePreSaleWallet(address payable newAddress) external onlyOwner {
  //   require(preSaleWallet != newAddress, "new address required");
  //   address oldWallet = preSaleWallet;
  //   preSaleWallet = newAddress;
  //   excludeFromFees(newAddress, true);
  //   dividendTracker.excludeFromDividends(preSaleWallet);
  //   whitelistAccount(preSaleWallet, true);
  //   emit UpdatePresaleWallet(newAddress, oldWallet);
  // }

  // function updateDividendTracker(address newAddress) public onlyOwner {
  //   require(
  //     newAddress != address(dividendTracker),
  //     "DoKEN: The dividend tracker already has that address"
  //   );

  //   DoKENDividendTracker newDividendTracker = DoKENDividendTracker(
  //     payable(newAddress)
  //   );

  //   require(
  //     newDividendTracker.owner() == address(this),
  //     "DoKEN: The new dividend tracker must be owned by the DoKEN token contract"
  //   );

  //   newDividendTracker.excludeFromDividends(address(newDividendTracker));
  //   newDividendTracker.excludeFromDividends(address(this));
  //   newDividendTracker.excludeFromDividends(address(uniswapV2Router));
  //   newDividendTracker.excludeFromDividends(address(0xdEaD));
  //   newDividendTracker.excludeFromDividends(address(0));
  //   newDividendTracker.excludeFromDividends(owner());
  //   newDividendTracker.excludeFromDividends(buybackWallet);
  //   newDividendTracker.excludeFromDividends(preSaleWallet);

  //   emit UpdateDividendTracker(newAddress, address(dividendTracker));

  //   dividendTracker = newDividendTracker;
  // }

  function updateUniswapV2Router(address newAddress) public onlyOwner {
    require(
      newAddress != address(uniswapV2Router),
      "DoKEN: The router already has that address"
    );
    emit UpdateUniswapV2Router(newAddress, address(uniswapV2Router));
    uniswapV2Router = IUniswapV2Router02(newAddress);
  }

  // function excludeAccountFromDividends(address account) public onlyOwner {
  //   dividendTracker.excludeFromDividends(account);
  //   emit ExcludeAccountFromDividends(account);
  // }

  // function isExcludedFromDividends(address account) public view returns (bool) {
  //   return dividendTracker.isExcludedFromDividends(account);
  // }

  function excludeFromFees(address account, bool excluded) public onlyOwner {
    _isExcludedFromFees[account] = excluded;

    emit ExcludeFromFees(account, excluded);
  }

  function excludeMultipleAccountsFromFees(
    address[] calldata accounts,
    bool excluded
  ) public onlyOwner {
    for (uint256 i = 0; i < accounts.length; i++) {
      _isExcludedFromFees[accounts[i]] = excluded;
    }

    emit ExcludeMultipleAccountsFromFees(accounts, excluded);
  }

  function setAutomatedMarketMakerPair(address pair, bool value)
    public
    onlyOwner
  {
    _setAutomatedMarketMakerPair(pair, value);
  }

  function _setAutomatedMarketMakerPair(address pair, bool value) private {
    automatedMarketMakerPairs[pair] = value;

    // if (value) {
    //   dividendTracker.excludeFromDividends(pair);
    // }

    emit SetAutomatedMarketMakerPair(pair, value);
  }

  function _validateFees() private view {
    require(getTotalFees() <= MAX_TOTAL_FEES, "total fees too high");
  }

  function updateMarketingFee(uint256 newFee) external onlyOwner {
    require(marketingFee != newFee, "new fee required");
    require(newFee <= MAX_MARKETING_FEE, "new fee too high");
    uint256 oldFee = marketingFee;
    marketingFee = newFee;
    _validateFees();
    emit UpdateMarketingFee(newFee, oldFee);
  }

  function updateDevFee(uint256 newFee) external onlyOwner {
    require(devFee != newFee, "new fee required");
    require(newFee <= MAX_DEV_FEE, "new fee too high");
    uint256 oldFee = devFee;
    devFee = newFee;
    _validateFees();
    emit UpdateMarketingFee(newFee, oldFee);
  }

  function updateBuybackFee(uint256 newFee) external onlyOwner {
    require(buybackFee != newFee, "new fee required");
    require(newFee <= MAX_BUYBACK_FEE, "new fee too high");
    uint256 oldFee = buybackFee;
    buybackFee = newFee;
    _validateFees();
    emit UpdateBuybackFee(newFee, oldFee);
  }

  function updateLiquidityFee(uint256 newFee) external onlyOwner {
    require(liquidityFee != newFee, "new fee required");
    require(newFee <= MAX_LIQUIDITY_FEE, "new fee too high");
    uint256 oldFee = liquidityFee;
    liquidityFee = newFee;
    _validateFees();
    emit UpdateLiquidityFee(newFee, oldFee);
  }

  function updateRewardsFee(uint256 newFee) external onlyOwner {
    require(rewardsFee != newFee, "new fee required");
    require(newFee <= MAX_REWARDS_FEE, "new fee too high");
    uint256 oldFee = rewardsFee;
    rewardsFee = newFee;
    _validateFees();
    emit UpdateRewardsFee(newFee, oldFee);
  }

  function updateSellFee(uint256 newFee) external onlyOwner {
    require(sellFee != newFee, "new fee required");
    require(newFee <= MAX_SELL_FEE, "new fee too high");
    uint256 oldFee = sellFee;
    sellFee = newFee;
    emit UpdateSellFee(newFee, oldFee);
  }

  function updateMaxBuyTransactionAmount(uint256 newValue) external onlyOwner {
    require(maxBuyTransactionAmount != newValue, "new value required");
    require(
      newValue >= MIN_BUY_TRANSACTION_AMOUNT &&
        newValue <= MAX_BUY_TRANSACTION_AMOUNT,
      "new value must be >= MIN_BUY_TRANSACTION_AMOUNT and <= MAX_BUY_TRANSACTION_AMOUNT"
    );
    uint256 oldValue = maxBuyTransactionAmount;
    maxBuyTransactionAmount = newValue;
    emit UpdateMaxBuyTransactionAmount(newValue, oldValue);
  }

  function updateMaxSellTransactionAmount(uint256 newValue) external onlyOwner {
    require(maxSellTransactionAmount != newValue, "new value required");
    require(
      newValue >= MIN_SELL_TRANSACTION_AMOUNT &&
        newValue <= MAX_SELL_TRANSACTION_AMOUNT,
      "new value must be >= MIN_SELL_TRANSACTION_AMOUNT and <= MAX_SELL_TRANSACTION_AMOUNT"
    );
    uint256 oldValue = maxSellTransactionAmount;
    maxSellTransactionAmount = newValue;
    emit UpdateMaxSellTransactionAmount(newValue, oldValue);
  }

  function updateSwapTokensAtAmount(uint256 newValue) external onlyOwner {
    require(swapTokensAtAmount != newValue, "new value required");
    require(
      newValue >= MIN_SWAP_TOKENS_AT_AMOUNT &&
        newValue <= MAX_SWAP_TOKENS_AT_AMOUNT,
      "new value must be >= MIN_SWAP_TOKENS_AT_AMOUNT and <= MAX_SWAP_TOKENS_AT_AMOUNT"
    );
    uint256 oldValue = swapTokensAtAmount;
    swapTokensAtAmount = newValue;
    emit UpdateSwapTokensAtAmount(newValue, oldValue);
  }

  function updateGasForProcessing(uint256 newValue) public onlyOwner {
    require(
      newValue >= 200000 && newValue <= MAX_GAS_FOR_PROCESSING,
      "DoKEN: gasForProcessing must be between 200,000 and MAX_GAS_FOR_PROCESSING"
    );
    require(
      newValue != gasForProcessing,
      "DoKEN: Cannot update gasForProcessing to same value"
    );
    emit UpdateGasForProcessing(newValue, gasForProcessing);
    gasForProcessing = newValue;
  }

  // function updateClaimWait(uint256 claimWait) external onlyOwner {
  //   dividendTracker.updateClaimWait(claimWait);
  // }

  // function getClaimWait() external view returns (uint256) {
  //   return dividendTracker.claimWait();
  // }

  // function getTotalDividendsDistributed() external view returns (uint256) {
  //   return dividendTracker.totalDividendsDistributed();
  // }

  function isExcludedFromFees(address account) public view returns (bool) {
    return _isExcludedFromFees[account];
  }

  // function processDividendTracker(uint256 gas) external onlyOwner {
  //   (
  //     uint256 iterations,
  //     uint256 claims,
  //     uint256 lastProcessedIndex
  //   ) = dividendTracker.process(gas);
  //   emit ProcessedDividendTracker(
  //     iterations,
  //     claims,
  //     lastProcessedIndex,
  //     false,
  //     gas,
  //     tx.origin
  //   );
  // }

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

    // Prohibit buys/sells before trading is enabled. This is useful for fair launches for obvious reasons
    if (from == uniswapV2Pair) {
      require(
        tradingEnabled || isWhitelisted[to],
        "trading isnt enabled or account isnt whitelisted"
      );
    } else if (to == uniswapV2Pair) {
      require(
        tradingEnabled || isWhitelisted[from],
        "trading isnt enabled or account isnt whitelisted"
      );
    }

    // Enforce max buy
    if (
      automatedMarketMakerPairs[from] &&
      // No max buy when removing liq
      to != address(uniswapV2Router)
    ) {
      require(
        amount <= maxBuyTransactionAmount,
        "Transfer amount exceeds the maxTxAmount."
      );
    }

    if (amount == 0) {
      super._transfer(from, to, 0);
      return;
    }

    // Enforce max sell
    if (
      !swapping &&
      automatedMarketMakerPairs[to] && // sells only by detecting transfer to automated market maker pair
      tradingEnabled // we need to be able to add liq before trading is enabled
    ) {
      require(
        amount <= maxSellTransactionAmount,
        "Sell transfer amount exceeds the maxSellTransactionAmount."
      );
    }

    uint256 contractTokenBalance = balanceOf(address(this));
    bool canSwap = (contractTokenBalance >= swapTokensAtAmount) &&
      swapAndLiquifyEnabled;
    uint256 totalFees = getTotalFees();

    // Swap and liq for sells
    if (canSwap && !swapping && automatedMarketMakerPairs[to]) {
      swapping = true;
      uint256 liquidityAndTeamTokens = contractTokenBalance
        .mul(liquidityFee.add(marketingFee).add(buybackFee).add(devFee))
        .div(totalFees);
      swapAndLiquifyAndFundTeam(liquidityAndTeamTokens);

      // uint256 rewardTokens = balanceOf(address(this));
      // if (rewardTokens > 0) {
      //   swapAndSendDividends(rewardTokens);
      // }

      swapping = false;
    }

    // Only take taxes for buys/sells (and obviously dont take taxes during swap and liquify)
    bool takeFee = !swapping &&
      (automatedMarketMakerPairs[from] || automatedMarketMakerPairs[to]);

    // if any account belongs to _isExcludedFromFee account then remove the fee
    if (_isExcludedFromFees[from] || _isExcludedFromFees[to]) {
      takeFee = false;
    }

    if (takeFee) {
      uint256 fees = amount.mul(totalFees).div(100);

      // If sell, add extra fee
      if (automatedMarketMakerPairs[to]) {
        fees += amount.mul(sellFee).div(100);
      }

      totalFeesCollected += fees;

      amount = amount.sub(fees);

      super._transfer(from, address(this), fees);
    }

    super._transfer(from, to, amount);

    // Trigger dividends to be paid out
    //try dividendTracker.setBalance(payable(from), balanceOf(from)) {} catch {}
    //try dividendTracker.setBalance(payable(to), balanceOf(to)) {} catch {}

    if (!swapping) {
      // uint256 gas = gasForProcessing;
      // try dividendTracker.process(gas) returns (
      //   uint256 iterations,
      //   uint256 claims,
      //   uint256 lastProcessedIndex
      // ) {
      //   emit ProcessedDividendTracker(
      //     iterations,
      //     claims,
      //     lastProcessedIndex,
      //     true,
      //     gas,
      //     tx.origin
      //   );
      // } catch {}
    }
  }

  function swapAndLiquifyAndFundTeam(uint256 tokens) private {
    // split the contract balance into halves
    uint256 half = tokens.div(2);
    uint256 otherHalf = tokens.sub(half);

    // capture the contract's current ETH balance.
    // this is so that we can capture exactly the amount of ETH that the
    // swap creates, and not make the liquidity event include any ETH that
    // has been manually sent to the contract
    uint256 initialBalance = address(this).balance;

    // swap tokens for ETH
    swapTokensForEth(half); // <- this breaks the ETH -> HATE swap when swap+liquify is triggered

    // how much ETH did we just swap into?
    uint256 newBalance = address(this).balance.sub(initialBalance);

    // All fees except rewards fee
    uint256 totalFees = marketingFee.add(buybackFee).add(liquidityFee).add(
      devFee
    );

    uint256 liquidityTokens = otherHalf.mul(liquidityFee).div(totalFees);
    uint256 liquidityETH = newBalance.mul(liquidityFee).div(totalFees);

    uint256 marketingTokens = otherHalf.mul(marketingFee).div(totalFees);
    uint256 marketingETH = newBalance.mul(marketingFee).div(totalFees);

    uint256 devTokens = otherHalf.mul(devFee).div(totalFees);
    uint256 devETH = newBalance.mul(devFee).div(totalFees);

    uint256 buybackTokens = otherHalf.mul(buybackFee).div(totalFees);
    uint256 buybackETH = newBalance.mul(buybackFee).div(totalFees);

    // add liquidity to uniswap (really PCS, duh)
    addLiquidity(liquidityTokens, liquidityETH);
    emit SwapAndLiquify(half, newBalance, otherHalf);

    // Transfer tokens and ETH to marketing wallet
    _safeTransfer(address(this), marketingWallet, marketingTokens);
    emit TransferTokensToMarketingWallet(marketingWallet, marketingTokens);
    marketingWallet.transfer(marketingETH);
    emit TransferETHToMarketingWallet(marketingWallet, marketingETH);

    // Transfer tokens and ETH to dev wallet
    _safeTransfer(address(this), devWallet, devTokens);
    emit TransferTokensToDevWallet(devWallet, devTokens);
    devWallet.transfer(devETH);
    emit TransferETHToMarketingWallet(devWallet, devETH);

    // Transfer tokens and ETH to buyback wallet
    _safeTransfer(address(this), buybackWallet, buybackTokens);
    emit TransferTokensToBuybackWallet(buybackWallet, buybackTokens);
    buybackWallet.transfer(buybackETH);
    emit TransferETHToBuybackWallet(buybackWallet, buybackETH);
  }

  function swapTokensForEth(uint256 tokenAmount) private {
    // generate the uniswap pair path of token -> weth
    address[] memory path = new address[](2);
    path[0] = address(this);
    path[1] = 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
    );
  }

  function swapTokensForETH(uint256 tokenAmount, address recipient) private {
    // generate the uniswap pair path of tokens -> WETH
    address[] memory path = new address[](2);
    path[0] = address(this);
    path[1] = uniswapV2Router.WETH();

    _approve(address(this), address(uniswapV2Router), tokenAmount);

    // make the swap
    uniswapV2Router.swapExactTokensForETH(
      tokenAmount,
      0, // accept any amount of the reward token
      path,
      recipient,
      block.timestamp
    );
  }

  function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
    // approve token transfer to cover all possible scenarios
    _approve(address(this), address(uniswapV2Router), tokenAmount);

    // add the liquidity
    uniswapV2Router.addLiquidityETH{ value: ethAmount }(
      address(this),
      tokenAmount,
      0, // slippage is unavoidable
      0, // slippage is unavoidable
      address(this), // lock LP tokens in this contract forever - no rugpull, SAFU!!
      block.timestamp
    );
  }

  function swapTokensForRewards(uint256 tokenAmount, address recipient)
    private
  {
    // generate the uniswap pair path of weth -> reward token
    address[] memory path = new address[](3);
    path[0] = address(this);
    path[1] = uniswapV2Router.WETH();
    path[2] = rewardToken;

    _approve(address(this), address(uniswapV2Router), tokenAmount);

    // make the swap
    uniswapV2Router.swapExactTokensForTokensSupportingFeeOnTransferTokens(
      tokenAmount,
      0, // accept any amount of the reward token
      path,
      recipient,
      block.timestamp
    );
  }

  // function sendDividends() private returns (bool, uint256) {
  //   uint256 dividends = IERC20(rewardToken).balanceOf(address(this));
  //   bool success = IERC20(rewardToken).transfer(
  //     address(dividendTracker),
  //     dividends
  //   );

  //   if (success) {
  //     dividendTracker.distributeRewardTokenDividends(dividends);
  //   }

  //   return (success, dividends);
  // }

  // function swapAndSendDividends(uint256 tokens) private {
  //   // Locks the LP tokens in this contract forever
  //   swapTokensForRewards(tokens, address(this));
  //   (bool success, uint256 dividends) = sendDividends();
  //   if (success) {
  //     emit SendDividends(tokens, dividends);
  //   }
  // }

  // For withdrawing ETH accidentally sent to the contract so senders can be refunded
  function getETHBalance() public view returns (uint256) {
    return address(this).balance;
  }

  function withdrawOverFlowETH() external onlyOwner {
    address payable to = payable(msg.sender);
    to.transfer(getETHBalance());
  }

  function _safeTransfer(
    address token,
    address to,
    uint256 value
  ) private {
    bytes4 SELECTOR = bytes4(keccak256(bytes("transfer(address,uint256)")));
    (bool success, bytes memory data) = token.call(
      abi.encodeWithSelector(SELECTOR, to, value)
    );
    require(
      success && (data.length == 0 || abi.decode(data, (bool))),
      "TRANSFER_FAILED"
    );
  }

  // DoKEN Interface for Rewards

  /**
  DoKENRewardAddress expect returns the address of your reward
  for example if its a cake token, then it should return the cake token address
   */
  function DoKENRewardAddress() external view returns (address) {
    return rewardToken;
  }

  /**
  DoKENRewardOnPool expect returns the balance of reward on the dividend pool
   */
  // function DoKENRewardOnPool() external view returns (uint256) {
  //   return IERC20(rewardToken).balanceOf(address(dividendTracker));
  // }

  /**
   * DoKENTokenFees expect returns a multiple uint256
   * in a precentage , example : 10% the its 10, 20% then its 20, etc
   * Which represent the fees on your tokens

   * totalFee,rewardFee,liquidityFee,marketingFee,developerFee,additionalSellingFee
   
   * if you're not implementing one of these fee, just return 0
   */
  function DoKENTokenFees()
    external
    view
    returns (
      uint256,
      uint256,
      uint256,
      uint256,
      uint256,
      uint256
    )
  {
    return (
      getTotalFees(),
      rewardsFee,
      liquidityFee,
      marketingFee,
      devFee,
      sellFee
    );
  }

  /**
   * DoKENRewardDistributed
   * Should return the amount of distributed Reward
   */
  // function DoKENRewardDistributed() external view returns (uint256) {
  //   return dividendTracker.getTotalDividendsDistributed();
  // }

  /**
    DoKENGetAccountDividendsInfo 
    Expect returns a dividend information by address,
    the return values should in these order
    
    address account,
    int256 index,
    int256 iterationsUntilProcessed,
    uint256 withdrawableDividends,
    uint256 withdrawnDividends,
    uint256 totalDividends,
    uint256 lastClaimTime,
    uint256 nextClaimTime,
    uint256 secondsUntilAutoClaimAvailable
   */

  // function DoKENGetAccountDividendsInfo(address account)
  //   public
  //   view
  //   returns (
  //     address,
  //     int256,
  //     int256,
  //     uint256,
  //     uint256,
  //     uint256,
  //     uint256,
  //     uint256,
  //     uint256
  //   )
  // {
  //   return dividendTracker.getAccount(account);
  // }

  /**
    DoKENGetAccountDividendsInfoAtIndex 
    Expect returns a dividend information by index,
    the return values should in these order
    
    address account,
    int256 index,
    int256 iterationsUntilProcessed,
    uint256 withdrawableDividends,
    uint256 withdrawnDividends,
    uint256 totalDividends,
    uint256 lastClaimTime,
    uint256 nextClaimTime,
    uint256 secondsUntilAutoClaimAvailable
   */
  // function DoKENGetAccountDividendsInfoAtIndex(uint256 index)
  //   public
  //   view
  //   returns (
  //     address,
  //     int256,
  //     int256,
  //     uint256,
  //     uint256,
  //     uint256,
  //     uint256,
  //     uint256,
  //     uint256
  //   )
  // {
  //   return dividendTracker.getAccountAtIndex(index);
  // }

  /** 
    DoKENRewardPaid expect return a uint256 value of the paid reward
  */
  // function DoKENRewardPaid(address holder) external view returns (uint256) {
  //   (, , , , uint256 paidAmount, , , , ) = DoKENGetAccountDividendsInfo(holder);
  //   return paidAmount;
  // }

  /** 
    DoKENRewardPaid expect return a uint256 value of the unpaid reward
  */
  // function DoKENRewardUnPaid(address holder) external view returns (uint256) {
  //   (, , , uint256 unpaidAmount, , , , , ) = DoKENGetAccountDividendsInfo(
  //     holder
  //   );
  //   return unpaidAmount;
  // }

  /** Claim Interface  */
  // function DoKENRewardClaim() external {
  //   dividendTracker.processAccount(payable(msg.sender), false);
  // }

  /** Last processed index */
  // function DoKENLastProcessedIndex() external view returns (uint256) {
  //   return dividendTracker.getLastProcessedIndex();
  // }

  /** Expect to returns the total holders of the dividend */
  // function DoKENNumberOfDividendTokenHolders() external view returns (uint256) {
  //   return dividendTracker.getNumberOfTokenHolders();
  // }

  /** Expect to returns the balance of dividend token of an account */
  // function DoKENDividendBalanceOf(address account)
  //   public
  //   view
  //   returns (uint256)
  // {
  //   return dividendTracker.balanceOf(account);
  // }
}