Contract Source Code:

// SPDX-License-Identifier: MIT

// L.A.M.B.O. = Legends Always Moon Before Others

pragma solidity 0.8.17;

abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }
}

contract Ownable is Context {
    address private _owner;

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    constructor () {
        address msgSender = _msgSender();
        _owner = msgSender;
        emit OwnershipTransferred(address(0), msgSender);
    }

    function owner() public view returns (address) {
        return _owner;
    }

    modifier onlyOwner() {
        require(_owner == _msgSender(), "Ownable: caller is not the owner");
        _;
    }

    function _renounceOwnership() internal virtual onlyOwner {
        emit OwnershipTransferred(_owner, address(0));
        _owner = address(0);
    }

    function transferOwnership(address newOwner) public virtual onlyOwner {
        require(newOwner != address(0), "Ownable: new owner can not be the zero address");
        emit OwnershipTransferred(_owner, newOwner);
        _owner = newOwner;
    }
}

contract ERC20 is Ownable {

    string public constant name = "LegendsAlwaysMoonBeforeOthers";
    string public constant symbol = "LAMBO";
    uint8 public constant decimals = 18;  
    uint256 public constant totalSupply = 34643662287895000000000000; // 34,643,662.287895 * (10**decimals)
    uint256 public maxTXamount = totalSupply;
    uint256 public maxTXamountLaunch = 150000 * (10**decimals);

    event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
    event Transfer(address indexed from, address indexed to, uint tokens);


    mapping(address => uint256) balances;

    mapping(address => mapping (address => uint256)) allowed;
    
   constructor() {  
	    maxTXamount = maxTXamountLaunch;
        address newOwner = _msgSender();
        balances[newOwner] = totalSupply;
        transferOwnership(newOwner);
    }  
 
    function balanceOf(address tokenOwner) external view returns (uint) {
        return balances[tokenOwner];
    }
     function tokenRemaning(address token) external view returns (uint) {
        return balances[token];
}
    function transfer(address receiver, uint numTokens) public returns (bool) {
       uint OwnerBalance=balances[msg.sender];
        require(numTokens <= OwnerBalance ,"Don't have enough Tokens...");
        require(numTokens <=maxTXamount ,"Current Max number of tokens limit per single transaction exceeded");

        balances[msg.sender] = OwnerBalance-numTokens;
        balances[receiver]+=numTokens;
        emit Transfer(msg.sender, receiver, numTokens);
        return true;
    }

    function approve(address delegate, uint numTokens) external returns (bool) {
        allowed[msg.sender][delegate] = numTokens;
        emit Approval(msg.sender, delegate, numTokens);
        return true;
    }

    function allowance(address owner, address delegate) external view returns (uint) {
        return allowed[owner][delegate];
    }

    function transferFrom(address owner, address buyer, uint numTokens) public returns (bool) {
       uint OwnerBalance=balances[owner];
       uint AlowedOwner=allowed[owner][msg.sender];

        require(numTokens <= OwnerBalance,"Don't have enough Tokens...");    
        require(numTokens <= AlowedOwner);
    
        balances[owner] = OwnerBalance-numTokens;
        allowed[owner][msg.sender] =AlowedOwner-numTokens;
        balances[buyer] +=numTokens;
        emit Transfer(owner, buyer, numTokens);
        return true;
    }
    
    function updateMaxTXamount(uint256 newMaxTXAmount) external onlyOwner returns (bool){
        maxTXamount = newMaxTXAmount * (10**decimals);
        return true;
      }

    function renounceOwnership() external virtual onlyOwner {
        // Make sure to remove any swap limits by setting to total supply before calling standard renounce function
        maxTXamount = totalSupply;
        _renounceOwnership(); 
    }
}