Loteraa

{{
  "language": "Solidity",
  "sources": {
    "contracts/Loteraa.sol": {
      "content": "/**\r
 *Submitted for verification at basescan.org on 2025-08-28\r
*/\r
\r
// SPDX-License-Identifier: MIT\r
\r
pragma solidity ^0.8.1;\r
\r
library Address {\r
    function isContract(address account) internal view returns (bool) {\r
        // This method relies on extcodesize/address.code.length, which returns 0\r
        // for contracts in construction, since the code is only stored at the end\r
        // of the constructor execution.\r
\r
        return account.code.length > 0;\r
    }\r
    function sendValue(address payable recipient, uint256 amount) internal {\r
        require(address(this).balance >= amount, "Address: insufficient balance");\r
\r
        (bool success, ) = recipient.call{value: amount}("");\r
        require(success, "Address: unable to send value, recipient may have reverted");\r
    }\r
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {\r
        return functionCallWithValue(target, data, 0, "Address: low-level call failed");\r
    }\r
    function functionCall(\r
        address target,\r
        bytes memory data,\r
        string memory errorMessage\r
    ) internal returns (bytes memory) {\r
        return functionCallWithValue(target, data, 0, errorMessage);\r
    }\r
    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\r
        return functionCallWithValue(target, data, value, "Address: low-level call with value failed");\r
    }\r
    function functionCallWithValue(\r
        address target,\r
        bytes memory data,\r
        uint256 value,\r
        string memory errorMessage\r
    ) internal returns (bytes memory) {\r
        require(address(this).balance >= value, "Address: insufficient balance for call");\r
        (bool success, bytes memory returndata) = target.call{value: value}(data);\r
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);\r
    }\r
    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\r
        return functionStaticCall(target, data, "Address: low-level static call failed");\r
    }\r
    function functionStaticCall(\r
        address target,\r
        bytes memory data,\r
        string memory errorMessage\r
    ) internal view returns (bytes memory) {\r
        (bool success, bytes memory returndata) = target.staticcall(data);\r
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);\r
    }\r
    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\r
        return functionDelegateCall(target, data, "Address: low-level delegate call failed");\r
    }\r
    function functionDelegateCall(\r
        address target,\r
        bytes memory data,\r
        string memory errorMessage\r
    ) internal returns (bytes memory) {\r
        (bool success, bytes memory returndata) = target.delegatecall(data);\r
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);\r
    }\r
    function verifyCallResultFromTarget(\r
        address target,\r
        bool success,\r
        bytes memory returndata,\r
        string memory errorMessage\r
    ) internal view returns (bytes memory) {\r
        if (success) {\r
            if (returndata.length == 0) {\r
                // only check isContract if the call was successful and the return data is empty\r
                // otherwise we already know that it was a contract\r
                require(isContract(target), "Address: call to non-contract");\r
            }\r
            return returndata;\r
        } else {\r
            _revert(returndata, errorMessage);\r
        }\r
    }\r
    function verifyCallResult(\r
        bool success,\r
        bytes memory returndata,\r
        string memory errorMessage\r
    ) internal pure returns (bytes memory) {\r
        if (success) {\r
            return returndata;\r
        } else {\r
            _revert(returndata, errorMessage);\r
        }\r
    }\r
    function _revert(bytes memory returndata, string memory errorMessage) private pure {\r
        // Look for revert reason and bubble it up if present\r
        if (returndata.length > 0) {\r
            // The easiest way to bubble the revert reason is using memory via assembly\r
            /// @solidity memory-safe-assembly\r
            assembly {\r
                let returndata_size := mload(returndata)\r
                revert(add(32, returndata), returndata_size)\r
            }\r
        } else {\r
            revert(errorMessage);\r
        }\r
    }\r
}\r
\r
pragma solidity ^0.8.0;\r
\r
interface IERC20 {\r
    event Transfer(address indexed from, address indexed to, uint256 value);\r
    event Approval(address indexed owner, address indexed spender, uint256 value);\r
    function totalSupply() external view returns (uint256);\r
    function balanceOf(address account) external view returns (uint256);\r
    function transfer(address to, uint256 amount) external returns (bool);\r
    function allowance(address owner, address spender) external view returns (uint256);\r
    function approve(address spender, uint256 amount) external returns (bool);\r
    function transferFrom(address from, address to, uint256 amount) external returns (bool);\r
}\r
\r
interface IERC20Metadata is IERC20 {\r
    function name() external view returns (string memory);\r
    function symbol() external view returns (string memory);\r
    function decimals() external view returns (uint8);\r
}\r
\r
abstract contract Context {\r
    function _msgSender() internal view virtual returns (address) {\r
        return msg.sender;\r
    }\r
\r
    function _msgData() internal view virtual returns (bytes calldata) {\r
        return msg.data;\r
    }\r
}\r
\r
contract ERC20 is Context, IERC20, IERC20Metadata {\r
    mapping(address => uint256) private _balances;\r
\r
    mapping(address => mapping(address => uint256)) private _allowances;\r
\r
    uint256 private _totalSupply;\r
\r
    string private _name;\r
    string private _symbol;\r
    constructor(string memory name_, string memory symbol_) {\r
        _name = name_;\r
        _symbol = symbol_;\r
    }\r
    function name() public view virtual override returns (string memory) {\r
        return _name;\r
    }\r
    function symbol() public view virtual override returns (string memory) {\r
        return _symbol;\r
    }\r
    function decimals() public view virtual override returns (uint8) {\r
        return 18;\r
    }\r
    function totalSupply() public view virtual override returns (uint256) {\r
        return _totalSupply;\r
    }\r
    function balanceOf(address account) public view virtual override returns (uint256) {\r
        return _balances[account];\r
    }\r
    function transfer(address to, uint256 amount) public virtual override returns (bool) {\r
        address owner = _msgSender();\r
        _transfer(owner, to, amount);\r
        return true;\r
    }\r
    function allowance(address owner, address spender) public view virtual override returns (uint256) {\r
        return _allowances[owner][spender];\r
    }\r
    function approve(address spender, uint256 amount) public virtual override returns (bool) {\r
        address owner = _msgSender();\r
        _approve(owner, spender, amount);\r
        return true;\r
    }\r
    function transferFrom(address from, address to, uint256 amount) public virtual override returns (bool) {\r
        address spender = _msgSender();\r
        _spendAllowance(from, spender, amount);\r
        _transfer(from, to, amount);\r
        return true;\r
    }\r
    function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\r
        address owner = _msgSender();\r
        _approve(owner, spender, allowance(owner, spender) + addedValue);\r
        return true;\r
    }\r
    function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\r
        address owner = _msgSender();\r
        uint256 currentAllowance = allowance(owner, spender);\r
        require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");\r
        unchecked {\r
            _approve(owner, spender, currentAllowance - subtractedValue);\r
        }\r
\r
        return true;\r
    }\r
    function _transfer(address from, address to, uint256 amount) internal virtual {\r
        require(from != address(0), "ERC20: transfer from the zero address");\r
        require(to != address(0), "ERC20: transfer to the zero address");\r
\r
        _beforeTokenTransfer(from, to, amount);\r
\r
        uint256 fromBalance = _balances[from];\r
        require(fromBalance >= amount, "ERC20: transfer amount exceeds balance");\r
        unchecked {\r
            _balances[from] = fromBalance - amount;\r
            // Overflow not possible: the sum of all balances is capped by totalSupply, and the sum is preserved by\r
            // decrementing then incrementing.\r
            _balances[to] += amount;\r
        }\r
\r
        emit Transfer(from, to, amount);\r
\r
        _afterTokenTransfer(from, to, amount);\r
    }\r
    function _mint(address account, uint256 amount) internal virtual {\r
        require(account != address(0), "ERC20: mint to the zero address");\r
\r
        _beforeTokenTransfer(address(0), account, amount);\r
\r
        _totalSupply += amount;\r
        unchecked {\r
            // Overflow not possible: balance + amount is at most totalSupply + amount, which is checked above.\r
            _balances[account] += amount;\r
        }\r
        emit Transfer(address(0), account, amount);\r
\r
        _afterTokenTransfer(address(0), account, amount);\r
    }\r
    function _burn(address account, uint256 amount) internal virtual {\r
        require(account != address(0), "ERC20: burn from the zero address");\r
\r
        _beforeTokenTransfer(account, address(0), amount);\r
\r
        uint256 accountBalance = _balances[account];\r
        require(accountBalance >= amount, "ERC20: burn amount exceeds balance");\r
        unchecked {\r
            _balances[account] = accountBalance - amount;\r
            // Overflow not possible: amount <= accountBalance <= totalSupply.\r
            _totalSupply -= amount;\r
        }\r
\r
        emit Transfer(account, address(0), amount);\r
\r
        _afterTokenTransfer(account, address(0), amount);\r
    }\r
    function _approve(address owner, address spender, uint256 amount) internal virtual {\r
        require(owner != address(0), "ERC20: approve from the zero address");\r
        require(spender != address(0), "ERC20: approve to the zero address");\r
\r
        _allowances[owner][spender] = amount;\r
        emit Approval(owner, spender, amount);\r
    }\r
    function _spendAllowance(address owner, address spender, uint256 amount) internal virtual {\r
        uint256 currentAllowance = allowance(owner, spender);\r
        if (currentAllowance != type(uint256).max) {\r
            require(currentAllowance >= amount, "ERC20: insufficient allowance");\r
            unchecked {\r
                _approve(owner, spender, currentAllowance - amount);\r
            }\r
        }\r
    }\r
    function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual {}\r
    function _afterTokenTransfer(address from, address to, uint256 amount) internal virtual {}\r
}\r
\r
abstract contract Ownable is Context {\r
    address private _owner;\r
\r
    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\r
    constructor() {\r
        _transferOwnership(_msgSender());\r
    }\r
    modifier onlyOwner() {\r
        _checkOwner();\r
        _;\r
    }\r
    function owner() public view virtual returns (address) {\r
        return _owner;\r
    }\r
    function _checkOwner() internal view virtual {\r
        require(owner() == _msgSender(), "Ownable: caller is not the owner");\r
    }\r
    function renounceOwnership() public virtual onlyOwner {\r
        _transferOwnership(address(0));\r
    }\r
    function transferOwnership(address newOwner) public virtual onlyOwner {\r
        require(newOwner != address(0), "Ownable: new owner is the zero address");\r
        _transferOwnership(newOwner);\r
    }\r
    function _transferOwnership(address newOwner) internal virtual {\r
        address oldOwner = _owner;\r
        _owner = newOwner;\r
        emit OwnershipTransferred(oldOwner, newOwner);\r
    }\r
}\r
\r
interface IERC20Permit {\r
    function permit(\r
        address owner,\r
        address spender,\r
        uint256 value,\r
        uint256 deadline,\r
        uint8 v,\r
        bytes32 r,\r
        bytes32 s\r
    ) external;\r
    function nonces(address owner) external view returns (uint256);\r
    function DOMAIN_SEPARATOR() external view returns (bytes32);\r
}\r
\r
library SafeERC20 {\r
    using Address for address;\r
    function safeTransfer(IERC20 token, address to, uint256 value) internal {\r
        _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));\r
    }\r
    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {\r
        _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));\r
    }\r
    function safeApprove(IERC20 token, address spender, uint256 value) internal {\r
        // safeApprove should only be called when setting an initial allowance,\r
        // or when resetting it to zero. To increase and decrease it, use\r
        // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'\r
        require(\r
            (value == 0) || (token.allowance(address(this), spender) == 0),\r
            "SafeERC20: approve from non-zero to non-zero allowance"\r
        );\r
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));\r
    }\r
    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {\r
        uint256 oldAllowance = token.allowance(address(this), spender);\r
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, oldAllowance + value));\r
    }\r
    function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {\r
        unchecked {\r
            uint256 oldAllowance = token.allowance(address(this), spender);\r
            require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");\r
            _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, oldAllowance - value));\r
        }\r
    }\r
    function forceApprove(IERC20 token, address spender, uint256 value) internal {\r
        bytes memory approvalCall = abi.encodeWithSelector(token.approve.selector, spender, value);\r
\r
        if (!_callOptionalReturnBool(token, approvalCall)) {\r
            _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, 0));\r
            _callOptionalReturn(token, approvalCall);\r
        }\r
    }\r
    function safePermit(\r
        IERC20Permit token,\r
        address owner,\r
        address spender,\r
        uint256 value,\r
        uint256 deadline,\r
        uint8 v,\r
        bytes32 r,\r
        bytes32 s\r
    ) internal {\r
        uint256 nonceBefore = token.nonces(owner);\r
        token.permit(owner, spender, value, deadline, v, r, s);\r
        uint256 nonceAfter = token.nonces(owner);\r
        require(nonceAfter == nonceBefore + 1, "SafeERC20: permit did not succeed");\r
    }\r
    function _callOptionalReturn(IERC20 token, bytes memory data) private {\r
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since\r
        // we're implementing it ourselves. We use {Address-functionCall} to perform this call, which verifies that\r
        // the target address contains contract code and also asserts for success in the low-level call.\r
\r
        bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");\r
        require(returndata.length == 0 || abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");\r
    }\r
\r
    function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {\r
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since\r
        // we're implementing it ourselves. We cannot use {Address-functionCall} here since this should return false\r
        // and not revert is the subcall reverts.\r
\r
        (bool success, bytes memory returndata) = address(token).call(data);\r
        return\r
            success && (returndata.length == 0 || abi.decode(returndata, (bool))) && Address.isContract(address(token));\r
    }\r
}\r
\r
library Math {\r
    enum Rounding {\r
        Down, // Toward negative infinity\r
        Up, // Toward infinity\r
        Zero // Toward zero\r
    }\r
    function max(uint256 a, uint256 b) internal pure returns (uint256) {\r
        return a > b ? a : b;\r
    }\r
    function min(uint256 a, uint256 b) internal pure returns (uint256) {\r
        return a < b ? a : b;\r
    }\r
    function average(uint256 a, uint256 b) internal pure returns (uint256) {\r
        // (a + b) / 2 can overflow.\r
        return (a & b) + (a ^ b) / 2;\r
    }\r
    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {\r
        // (a + b - 1) / b can overflow on addition, so we distribute.\r
        return a == 0 ? 0 : (a - 1) / b + 1;\r
    }\r
    function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {\r
        unchecked {\r
            // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use\r
            // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256\r
            // variables such that product = prod1 * 2^256 + prod0.\r
            uint256 prod0; // Least significant 256 bits of the product\r
            uint256 prod1; // Most significant 256 bits of the product\r
            assembly {\r
                let mm := mulmod(x, y, not(0))\r
                prod0 := mul(x, y)\r
                prod1 := sub(sub(mm, prod0), lt(mm, prod0))\r
            }\r
\r
            // Handle non-overflow cases, 256 by 256 division.\r
            if (prod1 == 0) {\r
                // Solidity will revert if denominator == 0, unlike the div opcode on its own.\r
                // The surrounding unchecked block does not change this fact.\r
                // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.\r
                return prod0 / denominator;\r
            }\r
\r
            // Make sure the result is less than 2^256. Also prevents denominator == 0.\r
            require(denominator > prod1, "Math: mulDiv overflow");\r
\r
            uint256 remainder;\r
            assembly {\r
                // Compute remainder using mulmod.\r
                remainder := mulmod(x, y, denominator)\r
\r
                // Subtract 256 bit number from 512 bit number.\r
                prod1 := sub(prod1, gt(remainder, prod0))\r
                prod0 := sub(prod0, remainder)\r
            }\r
\r
            // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1.\r
            // See https://cs.stackexchange.com/q/138556/92363.\r
\r
            // Does not overflow because the denominator cannot be zero at this stage in the function.\r
            uint256 twos = denominator & (~denominator + 1);\r
            assembly {\r
                // Divide denominator by twos.\r
                denominator := div(denominator, twos)\r
\r
                // Divide [prod1 prod0] by twos.\r
                prod0 := div(prod0, twos)\r
\r
                // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.\r
                twos := add(div(sub(0, twos), twos), 1)\r
            }\r
\r
            // Shift in bits from prod1 into prod0.\r
            prod0 |= prod1 * twos;\r
\r
            // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such\r
            // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for\r
            // four bits. That is, denominator * inv = 1 mod 2^4.\r
            uint256 inverse = (3 * denominator) ^ 2;\r
\r
            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works\r
            // in modular arithmetic, doubling the correct bits in each step.\r
            inverse *= 2 - denominator * inverse; // inverse mod 2^8\r
            inverse *= 2 - denominator * inverse; // inverse mod 2^16\r
            inverse *= 2 - denominator * inverse; // inverse mod 2^32\r
            inverse *= 2 - denominator * inverse; // inverse mod 2^64\r
            inverse *= 2 - denominator * inverse; // inverse mod 2^128\r
            inverse *= 2 - denominator * inverse; // inverse mod 2^256\r
\r
            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.\r
            // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is\r
            // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1\r
            // is no longer required.\r
            result = prod0 * inverse;\r
            return result;\r
        }\r
    }\r
    function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {\r
        uint256 result = mulDiv(x, y, denominator);\r
        if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {\r
            result += 1;\r
        }\r
        return result;\r
    }\r
    function sqrt(uint256 a) internal pure returns (uint256) {\r
        if (a == 0) {\r
            return 0;\r
        }\r
\r
        // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.\r
        //\r
        // We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have\r
        // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.\r
        //\r
        // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`\r
        // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`\r
        // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`\r
        //\r
        // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.\r
        uint256 result = 1 << (log2(a) >> 1);\r
\r
        // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,\r
        // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at\r
        // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision\r
        // into the expected uint128 result.\r
        unchecked {\r
            result = (result + a / result) >> 1;\r
            result = (result + a / result) >> 1;\r
            result = (result + a / result) >> 1;\r
            result = (result + a / result) >> 1;\r
            result = (result + a / result) >> 1;\r
            result = (result + a / result) >> 1;\r
            result = (result + a / result) >> 1;\r
            return min(result, a / result);\r
        }\r
    }\r
    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {\r
        unchecked {\r
            uint256 result = sqrt(a);\r
            return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);\r
        }\r
    }\r
    function log2(uint256 value) internal pure returns (uint256) {\r
        uint256 result = 0;\r
        unchecked {\r
            if (value >> 128 > 0) {\r
                value >>= 128;\r
                result += 128;\r
            }\r
            if (value >> 64 > 0) {\r
                value >>= 64;\r
                result += 64;\r
            }\r
            if (value >> 32 > 0) {\r
                value >>= 32;\r
                result += 32;\r
            }\r
            if (value >> 16 > 0) {\r
                value >>= 16;\r
                result += 16;\r
            }\r
            if (value >> 8 > 0) {\r
                value >>= 8;\r
                result += 8;\r
            }\r
            if (value >> 4 > 0) {\r
                value >>= 4;\r
                result += 4;\r
            }\r
            if (value >> 2 > 0) {\r
                value >>= 2;\r
                result += 2;\r
            }\r
            if (value >> 1 > 0) {\r
                result += 1;\r
            }\r
        }\r
        return result;\r
    }\r
    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {\r
        unchecked {\r
            uint256 result = log2(value);\r
            return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);\r
        }\r
    }\r
    function log10(uint256 value) internal pure returns (uint256) {\r
        uint256 result = 0;\r
        unchecked {\r
            if (value >= 10 ** 64) {\r
                value /= 10 ** 64;\r
                result += 64;\r
            }\r
            if (value >= 10 ** 32) {\r
                value /= 10 ** 32;\r
                result += 32;\r
            }\r
            if (value >= 10 ** 16) {\r
                value /= 10 ** 16;\r
                result += 16;\r
            }\r
            if (value >= 10 ** 8) {\r
                value /= 10 ** 8;\r
                result += 8;\r
            }\r
            if (value >= 10 ** 4) {\r
                value /= 10 ** 4;\r
                result += 4;\r
            }\r
            if (value >= 10 ** 2) {\r
                value /= 10 ** 2;\r
                result += 2;\r
            }\r
            if (value >= 10 ** 1) {\r
                result += 1;\r
            }\r
        }\r
        return result;\r
    }\r
    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {\r
        unchecked {\r
            uint256 result = log10(value);\r
            return result + (rounding == Rounding.Up && 10 ** result < value ? 1 : 0);\r
        }\r
    }\r
    function log256(uint256 value) internal pure returns (uint256) {\r
        uint256 result = 0;\r
        unchecked {\r
            if (value >> 128 > 0) {\r
                value >>= 128;\r
                result += 16;\r
            }\r
            if (value >> 64 > 0) {\r
                value >>= 64;\r
                result += 8;\r
            }\r
            if (value >> 32 > 0) {\r
                value >>= 32;\r
                result += 4;\r
            }\r
            if (value >> 16 > 0) {\r
                value >>= 16;\r
                result += 2;\r
            }\r
            if (value >> 8 > 0) {\r
                result += 1;\r
            }\r
        }\r
        return result;\r
    }\r
    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {\r
        unchecked {\r
            uint256 result = log256(value);\r
            return result + (rounding == Rounding.Up && 1 << (result << 3) < value ? 1 : 0);\r
        }\r
    }\r
}\r
\r
pragma solidity >=0.5.0;\r
\r
interface IUniswapV2Factory {\r
    event PairCreated(\r
        address indexed token0,\r
        address indexed token1,\r
        address pair,\r
        uint256\r
    );\r
\r
    function feeTo() external view returns (address);\r
\r
    function feeToSetter() external view returns (address);\r
\r
    function getPair(address tokenA, address tokenB)\r
        external\r
        view\r
        returns (address pair);\r
\r
    function allPairs(uint256) external view returns (address pair);\r
\r
    function allPairsLength() external view returns (uint256);\r
\r
    function createPair(address tokenA, address tokenB)\r
        external\r
        returns (address pair);\r
\r
    function setFeeTo(address) external;\r
\r
    function setFeeToSetter(address) external;\r
}\r
interface IUniswapV2Pair {\r
    event Approval(address indexed owner, address indexed spender, uint value);\r
    event Transfer(address indexed from, address indexed to, uint value);\r
\r
    function name() external pure returns (string memory);\r
    function symbol() external pure returns (string memory);\r
    function decimals() external pure returns (uint8);\r
    function totalSupply() external view returns (uint);\r
    function balanceOf(address owner) external view returns (uint);\r
    function allowance(address owner, address spender) external view returns (uint);\r
\r
    function approve(address spender, uint value) external returns (bool);\r
    function transfer(address to, uint value) external returns (bool);\r
    function transferFrom(address from, address to, uint value) external returns (bool);\r
\r
    function DOMAIN_SEPARATOR() external view returns (bytes32);\r
    function PERMIT_TYPEHASH() external pure returns (bytes32);\r
    function nonces(address owner) external view returns (uint);\r
\r
    function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;\r
\r
    event Mint(address indexed sender, uint amount0, uint amount1);\r
    event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);\r
    event Swap(\r
        address indexed sender,\r
        uint amount0In,\r
        uint amount1In,\r
        uint amount0Out,\r
        uint amount1Out,\r
        address indexed to\r
    );\r
    event Sync(uint112 reserve0, uint112 reserve1);\r
\r
    function MINIMUM_LIQUIDITY() external pure returns (uint);\r
    function factory() external view returns (address);\r
    function token0() external view returns (address);\r
    function token1() external view returns (address);\r
    function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);\r
    function price0CumulativeLast() external view returns (uint);\r
    function price1CumulativeLast() external view returns (uint);\r
    function kLast() external view returns (uint);\r
\r
    function mint(address to) external returns (uint liquidity);\r
    function burn(address to) external returns (uint amount0, uint amount1);\r
    function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;\r
    function skim(address to) external;\r
    function sync() external;\r
\r
    function initialize(address, address) external;\r
}\r
\r
pragma solidity >=0.6.2;\r
\r
interface IUniswapV2Router01 {\r
    function factory() external pure returns (address);\r
\r
    function WETH() external pure returns (address);\r
\r
    function addLiquidity(\r
        address tokenA,\r
        address tokenB,\r
        uint256 amountADesired,\r
        uint256 amountBDesired,\r
        uint256 amountAMin,\r
        uint256 amountBMin,\r
        address to,\r
        uint256 deadline\r
    )\r
        external\r
        returns (\r
            uint256 amountA,\r
            uint256 amountB,\r
            uint256 liquidity\r
        );\r
\r
    function addLiquidityETH(\r
        address token,\r
        uint256 amountTokenDesired,\r
        uint256 amountTokenMin,\r
        uint256 amountETHMin,\r
        address to,\r
        uint256 deadline\r
    )\r
        external\r
        payable\r
        returns (\r
            uint256 amountToken,\r
            uint256 amountETH,\r
            uint256 liquidity\r
        );\r
\r
    function removeLiquidity(\r
        address tokenA,\r
        address tokenB,\r
        uint256 liquidity,\r
        uint256 amountAMin,\r
        uint256 amountBMin,\r
        address to,\r
        uint256 deadline\r
    ) external returns (uint256 amountA, uint256 amountB);\r
\r
    function removeLiquidityETH(\r
        address token,\r
        uint256 liquidity,\r
        uint256 amountTokenMin,\r
        uint256 amountETHMin,\r
        address to,\r
        uint256 deadline\r
    ) external returns (uint256 amountToken, uint256 amountETH);\r
\r
    function removeLiquidityWithPermit(\r
        address tokenA,\r
        address tokenB,\r
        uint256 liquidity,\r
        uint256 amountAMin,\r
        uint256 amountBMin,\r
        address to,\r
        uint256 deadline,\r
        bool approveMax,\r
        uint8 v,\r
        bytes32 r,\r
        bytes32 s\r
    ) external returns (uint256 amountA, uint256 amountB);\r
\r
    function removeLiquidityETHWithPermit(\r
        address token,\r
        uint256 liquidity,\r
        uint256 amountTokenMin,\r
        uint256 amountETHMin,\r
        address to,\r
        uint256 deadline,\r
        bool approveMax,\r
        uint8 v,\r
        bytes32 r,\r
        bytes32 s\r
    ) external returns (uint256 amountToken, uint256 amountETH);\r
\r
    function swapExactTokensForTokens(\r
        uint256 amountIn,\r
        uint256 amountOutMin,\r
        address[] calldata path,\r
        address to,\r
        uint256 deadline\r
    ) external returns (uint256[] memory amounts);\r
\r
    function swapTokensForExactTokens(\r
        uint256 amountOut,\r
        uint256 amountInMax,\r
        address[] calldata path,\r
        address to,\r
        uint256 deadline\r
    ) external returns (uint256[] memory amounts);\r
\r
    function swapExactETHForTokens(\r
        uint256 amountOutMin,\r
        address[] calldata path,\r
        address to,\r
        uint256 deadline\r
    ) external payable returns (uint256[] memory amounts);\r
\r
    function swapTokensForExactETH(\r
        uint256 amountOut,\r
        uint256 amountInMax,\r
        address[] calldata path,\r
        address to,\r
        uint256 deadline\r
    ) external returns (uint256[] memory amounts);\r
\r
    function swapExactTokensForETH(\r
        uint256 amountIn,\r
        uint256 amountOutMin,\r
        address[] calldata path,\r
        address to,\r
        uint256 deadline\r
    ) external returns (uint256[] memory amounts);\r
\r
    function swapETHForExactTokens(\r
        uint256 amountOut,\r
        address[] calldata path,\r
        address to,\r
        uint256 deadline\r
    ) external payable returns (uint256[] memory amounts);\r
\r
    function quote(\r
        uint256 amountA,\r
        uint256 reserveA,\r
        uint256 reserveB\r
    ) external pure returns (uint256 amountB);\r
\r
    function getAmountOut(\r
        uint256 amountIn,\r
        uint256 reserveIn,\r
        uint256 reserveOut\r
    ) external pure returns (uint256 amountOut);\r
\r
    function getAmountIn(\r
        uint256 amountOut,\r
        uint256 reserveIn,\r
        uint256 reserveOut\r
    ) external pure returns (uint256 amountIn);\r
\r
    function getAmountsOut(uint256 amountIn, address[] calldata path)\r
        external\r
        view\r
        returns (uint256[] memory amounts);\r
\r
    function getAmountsIn(uint256 amountOut, address[] calldata path)\r
        external\r
        view\r
        returns (uint256[] memory amounts);\r
}\r
interface IUniswapV2Router02 is IUniswapV2Router01 {\r
    function removeLiquidityETHSupportingFeeOnTransferTokens(\r
        address token,\r
        uint256 liquidity,\r
        uint256 amountTokenMin,\r
        uint256 amountETHMin,\r
        address to,\r
        uint256 deadline\r
    ) external returns (uint256 amountETH);\r
\r
    function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(\r
        address token,\r
        uint256 liquidity,\r
        uint256 amountTokenMin,\r
        uint256 amountETHMin,\r
        address to,\r
        uint256 deadline,\r
        bool approveMax,\r
        uint8 v,\r
        bytes32 r,\r
        bytes32 s\r
    ) external returns (uint256 amountETH);\r
\r
    function swapExactTokensForTokensSupportingFeeOnTransferTokens(\r
        uint256 amountIn,\r
        uint256 amountOutMin,\r
        address[] calldata path,\r
        address to,\r
        uint256 deadline\r
    ) external;\r
\r
    function swapExactETHForTokensSupportingFeeOnTransferTokens(\r
        uint256 amountOutMin,\r
        address[] calldata path,\r
        address to,\r
        uint256 deadline\r
    ) external payable;\r
\r
    function swapExactTokensForETHSupportingFeeOnTransferTokens(\r
        uint256 amountIn,\r
        uint256 amountOutMin,\r
        address[] calldata path,\r
        address to,\r
        uint256 deadline\r
    ) external;\r
}\r
pragma solidity ^0.8.19;\r
\r
contract Loteraa is ERC20, Ownable {\r
    using SafeERC20 for IERC20;\r
\r
    uint256 private constant MAX = ~uint256(0);\r
\r
    uint8 private _decimals;\r
    ///////////////////////////////////////////////////////////////////////////\r
    bool private inSwapAndLiquify;\r
    \r
    uint256 public tradingEnabledTimeStamp;\r
    uint256 public tax;\r
\r
    address public developmentWallet;\r
    address public deployerWallet;\r
    address public incubatorWallet;\r
\r
    uint256 public minAmountToTakeFee;\r
\r
    mapping(address => bool) public isWhitelisted;\r
\r
    address public mainRouter;\r
    address public mainPair;\r
\r
\r
    mapping(address => bool) public isExcludedFromMaxTransactionAmount;\r
    mapping(address => bool) public isExcludedFromFee;\r
    mapping(address => bool) public automatedMarketMakerPairs;\r
\r
    event TradingEnabled();\r
    \r
\r
    event ExcludedFromMaxTransactionAmount(address indexed account, bool isExcluded);\r
    event UpdateMinAmountToTakeFee(uint256 newMinAmountToTakeFee, uint256 oldMinAmountToTakeFee);\r
    event SetAutomatedMarketMakerPair(address indexed pair, bool value);\r
    event ExcludedFromFee(address indexed account, bool isEx);\r
    event MainRouterUpdated(\r
        address mainRouter, address mainPair\r
    );\r
    event TaxUpdated(uint256 tax);\r
    event DevelopmentWalletUpdated(address indexed developmentWallet);\r
    event DeployerWalletUpdated(address indexed newDeployerWallet);\r
    event IncubatorWalletUpdated(address indexed newIncubatorWallet);\r
    event WhitelistPeriodUpdated(uint256 newWhitelistPeriod);\r
    event Whitelisted(address[] account, bool[] isWhitelisted);\r
    event DevelopmentWalletFeeTaken(uint256 amount);\r
    event DeployerWalletFeeTaken(uint256 amount);\r
    event IncubatorWalletFeeTaken(uint256 amount);\r
    ///////////////////////////////////////////////////////////////////////////////\r
 \r
    constructor(\r
        string memory _name,\r
        string memory _symbol,\r
        address _mainRouter\r
    ) ERC20(_name, _symbol) {\r
        _decimals = 18;\r
        _mint(msg.sender, 300000000000000000000000000);\r
        require(_mainRouter!=address(0), "Router address can not be 0");\r
        \r
        mainRouter=_mainRouter;\r
              \r
        _approve(address(this), mainRouter, MAX);\r
        mainPair = IUniswapV2Factory(IUniswapV2Router02(mainRouter).factory()).createPair(\r
            address(this),\r
            IUniswapV2Router02(mainRouter).WETH()\r
        );\r
        emit MainRouterUpdated(mainRouter, mainPair);\r
        \r
\r
        tax = 50000;\r
\r
        developmentWallet = 0x3baf67436f73B978D0F8d5Be3c9C1dC08e5B4451;\r
        deployerWallet = 0x1CD9349ae932A580C102962d0bc9FDd250613298;\r
        incubatorWallet = 0x5bf4E928a73e9B9a14623aC679c705537734169B;\r
\r
        minAmountToTakeFee=30000000000000000000000;\r
        emit UpdateMinAmountToTakeFee(minAmountToTakeFee, 0);\r
        isExcludedFromFee[address(this)]=true;\r
        isExcludedFromFee[developmentWallet]=true;\r
        isExcludedFromFee[deployerWallet]=true;\r
        isExcludedFromFee[incubatorWallet]=true;\r
        isExcludedFromFee[_msgSender()]=true;\r
        isExcludedFromFee[address(0xdead)] = true;\r
        isExcludedFromMaxTransactionAmount[address(0xdead)]=true;\r
        isExcludedFromMaxTransactionAmount[address(this)]=true;\r
        isExcludedFromMaxTransactionAmount[developmentWallet]=true;\r
        isExcludedFromMaxTransactionAmount[deployerWallet]=true;\r
        isExcludedFromMaxTransactionAmount[incubatorWallet]=true;\r
        isExcludedFromMaxTransactionAmount[_msgSender()]=true;        \r
        _setAutomatedMarketMakerPair(mainPair, true);\r
    }\r
\r
    function updateDevelopmentWallet(address _developmentWallet) external onlyOwner {\r
        require(_developmentWallet != address(0), "developmentWallet can't be 0");\r
        developmentWallet = _developmentWallet;\r
        isExcludedFromFee[developmentWallet]=true;\r
        isExcludedFromMaxTransactionAmount[developmentWallet]=true;\r
        emit DevelopmentWalletUpdated(_developmentWallet);\r
    }\r
    function updateDeployerWallet(address _deployerWallet) external onlyOwner {\r
        require(_deployerWallet != address(0), "deployerWallet can't be 0");\r
        deployerWallet = _deployerWallet;\r
        isExcludedFromFee[deployerWallet]=true;\r
        isExcludedFromMaxTransactionAmount[deployerWallet]=true;\r
        emit DeployerWalletUpdated(_deployerWallet);\r
    }\r
    function updateIncubatorWallet(address _incubatorWallet) external onlyOwner {\r
        require(_incubatorWallet != address(0), "incubatorWallet can't be 0");\r
        incubatorWallet = _incubatorWallet;\r
        isExcludedFromFee[incubatorWallet]=true;\r
        isExcludedFromMaxTransactionAmount[incubatorWallet]=true;\r
        emit IncubatorWalletUpdated(_incubatorWallet);\r
    }\r
\r
    function addToWhitelist(address[] memory _address, bool[] memory _isWhitelisted) external onlyOwner {\r
        require(tradingEnabledTimeStamp == 0, "Enabled!");\r
        require(_address.length > 0 && _address.length == _isWhitelisted.length, "!address length");\r
        uint256 length = _address.length;\r
        for(uint256 i = 0; i < length;){\r
            require(_address[i] != address(0), "address can't be 0");\r
            isWhitelisted[_address[i]] = _isWhitelisted[i];\r
            unchecked{\r
                ++i;\r
            }\r
        }\r
        \r
        emit Whitelisted(_address, _isWhitelisted);\r
    }\r
    \r
\r
    function decimals() public view override returns (uint8) {\r
        return _decimals;\r
    }\r
\r
    function updateMainPair(\r
        address _mainRouter\r
    ) external onlyOwner {\r
        if(mainRouter != _mainRouter){\r
            _approve(address(this), _mainRouter, MAX);\r
            mainRouter = _mainRouter;\r
        } \r
        mainPair = IUniswapV2Factory(IUniswapV2Router02(mainRouter).factory()).createPair(\r
            address(this),\r
            IUniswapV2Router02(mainRouter).WETH()\r
        );\r
     \r
        emit MainRouterUpdated(mainRouter, mainPair);\r
        _setAutomatedMarketMakerPair(mainPair, true);\r
    }\r
\r
    function startTrading() external onlyOwner {\r
        require(tradingEnabledTimeStamp == 0, "Enabled!");\r
        tradingEnabledTimeStamp = block.timestamp;\r
        emit TradingEnabled();\r
    }\r
\r
    /////////////////////////////////////////////////////////////////////////////////\r
    modifier lockTheSwap() {\r
        inSwapAndLiquify = true;\r
        _;\r
        inSwapAndLiquify = false;\r
    }\r
\r
    function updateMinAmountToTakeFee(uint256 _minAmountToTakeFee)\r
        external\r
        onlyOwner\r
    {\r
        require(_minAmountToTakeFee > 0, "minAmountToTakeFee > 0");\r
        emit UpdateMinAmountToTakeFee(_minAmountToTakeFee, minAmountToTakeFee);\r
        minAmountToTakeFee = _minAmountToTakeFee;     \r
    }\r
\r
    function setAutomatedMarketMakerPair(address pair, bool value)\r
        public\r
        onlyOwner\r
    {\r
        require(\r
            automatedMarketMakerPairs[pair] != value,\r
            "Automated market maker pair is already set to that value"\r
        );\r
        _setAutomatedMarketMakerPair(pair, value);\r
    }\r
\r
    function _setAutomatedMarketMakerPair(address pair, bool value) private {        \r
        automatedMarketMakerPairs[pair] = value;\r
        isExcludedFromMaxTransactionAmount[pair] = value;\r
        emit SetAutomatedMarketMakerPair(pair, value);\r
    }\r
\r
    function excludeFromFee(address account, bool isEx) external onlyOwner {\r
        require(isExcludedFromFee[account] != isEx, "already");\r
        isExcludedFromFee[account] = isEx;\r
        emit ExcludedFromFee(account, isEx);\r
    }\r
\r
    function updateTax(uint256 _tax) external onlyOwner {\r
        require(_tax >= 0, "tax > 0");\r
        require(tax <= 250000, "tax < 25%");\r
        emit TaxUpdated(_tax);\r
        tax = _tax;\r
    }\r
\r
    function excludeFromMaxTransactionAmount(address account, bool isEx)\r
        external\r
        onlyOwner\r
    {\r
        require(isExcludedFromMaxTransactionAmount[account]!=isEx, "already");\r
        isExcludedFromMaxTransactionAmount[account] = isEx;\r
        emit ExcludedFromMaxTransactionAmount(account, isEx);\r
    }\r
\r
    function _transfer(\r
        address from,\r
        address to,\r
        uint256 amount\r
    ) internal override {\r
        require(from != address(0), "ERC20: transfer from the zero address");\r
        require(to != address(0), "ERC20: transfer to the zero address");\r
        if(!inSwapAndLiquify){     \r
            bool overMinimumTokenBalance = minAmountToTakeFee <= balanceOf(address(this));\r
            // Take Fee\r
            if (\r
                balanceOf(mainPair) > 0 &&\r
                overMinimumTokenBalance &&\r
                automatedMarketMakerPairs[to]\r
            ) {\r
                takeFee();\r
            }  \r
            if (\r
                !isExcludedFromFee[from] &&\r
                !isExcludedFromFee[to]\r
            ) {\r
                require(tradingEnabledTimeStamp > 0, "not enabled");\r
                if(block.timestamp - tradingEnabledTimeStamp < 300){\r
                    if(automatedMarketMakerPairs[from]){\r
                        require(isWhitelisted[to], "not whitelisted");\r
                    }else if(automatedMarketMakerPairs[to]){\r
                        require(isWhitelisted[from], "not whitelisted");\r
                    }else {\r
                        require(isWhitelisted[from] && isWhitelisted[to], "not whitelisted");\r
                    }\r
                }\r
                uint256 _tax;\r
                // Buy & Sell\r
                if (automatedMarketMakerPairs[from] || automatedMarketMakerPairs[to]) {\r
                    _tax = amount * calculateTax() / 1000000;\r
                }\r
\r
                if (_tax > 0) super._transfer(from, address(this), _tax);\r
                amount = amount - _tax;\r
            }\r
            uint256 _maxWallet= calculateMaxLimit();\r
            \r
            if (!isExcludedFromMaxTransactionAmount[from]) {\r
                require(\r
                    amount <= _maxWallet,\r
                    "ERC20: exceeds transfer limit"\r
                );\r
            }\r
            if (!isExcludedFromMaxTransactionAmount[to]) {\r
                require(\r
                    balanceOf(to) + amount <= _maxWallet,\r
                    "ERC20: exceeds max wallet limit"\r
                );\r
            }            \r
        }\r
        super._transfer(from, to, amount);\r
    }\r
    function calculateTax() private view returns (uint256) {\r
        uint256 timePassed = block.timestamp - tradingEnabledTimeStamp;\r
        if(timePassed > 1200){\r
            return tax;\r
        }else{\r
            return 250000 - 200000 * timePassed / 1200;\r
        }\r
    }\r
    function calculateMaxLimit() private view returns (uint256) {\r
        uint256 timePassed = block.timestamp - tradingEnabledTimeStamp;\r
        if(timePassed < 300){\r
            uint256 limit = totalSupply() * (timePassed / 60 + 1) / 1000;\r
            return limit;\r
        }else if(timePassed < 900){\r
            uint256 limit = totalSupply() * ((timePassed - 300) / 120 + 6) / 1000;\r
            return limit;\r
        }else{\r
            return totalSupply();\r
        }\r
    }\r
    function takeFee() private lockTheSwap {\r
\r
        swapTokensForETH(balanceOf(address(this)));\r
        uint256 DevelopmentTax = address(this).balance / 4;\r
        uint256 deployerTax = address(this).balance * 3 / 8;\r
\r
        (bool success, )=address(developmentWallet).call{value: DevelopmentTax}("");\r
        if(success){\r
            emit DevelopmentWalletFeeTaken(DevelopmentTax);\r
        }       \r
        (success, )=address(deployerWallet).call{value: deployerTax}("");\r
        if(success){\r
            emit DeployerWalletFeeTaken(deployerTax);\r
        }   \r
        (success, )=address(incubatorWallet).call{value: deployerTax}("");\r
        if(success){\r
            emit IncubatorWalletFeeTaken(deployerTax);\r
        }     \r
    }\r
\r
    function swapTokensForETH(uint256 tokenAmount) private {\r
        address[] memory path = new address[](2);\r
        path[0] = address(this);\r
        path[1] = IUniswapV2Router02(mainRouter).WETH();     \r
        IUniswapV2Router02(mainRouter).swapExactTokensForETHSupportingFeeOnTransferTokens(\r
            tokenAmount,\r
            0, // accept any amount of ETH\r
            path,\r
            address(this),\r
            block.timestamp\r
        );    \r
    }\r
\r
    function withdrawETH() external onlyOwner {\r
        (bool success, )=address(owner()).call{value: address(this).balance}("");\r
        require(success, "Failed in withdrawal");\r
    }\r
    function withdrawToken(address token) external onlyOwner{\r
        require(address(this) != token, "Not allowed");\r
        IERC20(token).safeTransfer(owner(), IERC20(token).balanceOf(address(this)));\r
    }\r
    receive() external payable {}\r
}"
    }
  },
  "settings": {
    "optimizer": {
      "enabled": true,
      "runs": 20000
    },
    "outputSelection": {
      "*": {
        "*": [
          "evm.bytecode",
          "evm.deployedBytecode",
          "devdoc",
          "userdoc",
          "metadata",
          "abi"
        ]
      }
    },
    "remappings": []
  }
}}