Token

SPA (SPA)

BEP-20

Overview

Max Total Supply

980,000SPA

Holders

14,630

Total Transfers

Market

Price

$0.00 @ 0.000000 BNB

Onchain Market Cap

$0.00

Circulating Supply Market Cap

Other Info

Token Contract (WITH 18 Decimals)

0xe26a492ced210bd84e11147e8aec84b23390f22e

Click here to update the token information / general information

Contract Source Code Verified (Exact Match)

Contract Name:

spa

Compiler Version

v0.8.19+commit.7dd6d404

Optimization Enabled:

Yes with 200 runs

Other Settings:

istanbul EvmVersion, None license

Contract Source Code (Solidity)

IDE

/**
 *Submitted for verification at BscScan.com on 2024-10-31
*/

/**
 *Submitted for verification at BscScan.com on 2021-11-21
*/

// Dependency file: @openzeppelin/contracts/token/ERC20/IERC20.sol

// SPDX-License-Identifier: MIT

// pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the amount of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves `amount` tokens from the caller's account to `recipient`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address recipient, uint256 amount) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 amount) external returns (bool);

    /**
     * @dev Moves `amount` tokens from `sender` to `recipient` using the
     * allowance mechanism. `amount` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(
        address sender,
        address recipient,
        uint256 amount
    ) external returns (bool);

    /**
     * @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);
}


// Dependency file: @openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol


// pragma solidity ^0.8.0;

// import "@openzeppelin/contracts/token/ERC20/IERC20.sol";

/**
 * @dev Interface for the optional metadata functions from the ERC20 standard.
 *
 * _Available since v4.1._
 */
interface IERC20Metadata is IERC20 {
    /**
     * @dev Returns the name of the token.
     */
    function name() external view returns (string memory);

    /**
     * @dev Returns the symbol of the token.
     */
    function symbol() external view returns (string memory);

    /**
     * @dev Returns the decimals places of the token.
     */
    function decimals() external view returns (uint8);
}


// Dependency file: @openzeppelin/contracts/utils/Context.sol


// pragma solidity ^0.8.0;

/**
 * @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;
    }
}


// Dependency file: @openzeppelin/contracts/token/ERC20/ERC20.sol


// pragma solidity ^0.8.0;

// import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
// import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
// import "@openzeppelin/contracts/utils/Context.sol";

/**
 * @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 {ERC20PresetMinterPauser}.
 *
 * TIP: For a detailed writeup see our guide
 * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How
 * to implement supply mechanisms].
 *
 * We have followed general OpenZeppelin Contracts guidelines: functions revert
 * instead 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 ERC20 is Context, IERC20, IERC20Metadata {
    mapping(address => uint256) private _balances;

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

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;

    /**
     * @dev Sets the values for {name} and {symbol}.
     *
     * The default value of {decimals} is 18. To select a different value for
     * {decimals} you should overload it.
     *
     * All two of these values are immutable: they can only be set once during
     * construction.
     */
    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
    }

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

    /**
     * @dev Returns the symbol of the token, usually a shorter version of the
     * name.
     */
    function symbol() public view virtual override returns (string memory) {
        return _symbol;
    }

    /**
     * @dev Returns the number of decimals used to get its user representation.
     * For example, if `decimals` equals `2`, a balance of `505` tokens should
     * be displayed to a user as `5.05` (`505 / 10 ** 2`).
     *
     * Tokens usually opt for a value of 18, imitating the relationship between
     * Ether and Wei. This is the value {ERC20} uses, unless this function is
     * overridden;
     *
     * NOTE: This information is only used for _display_ purposes: it in
     * no way affects any of the arithmetic of the contract, including
     * {IERC20-balanceOf} and {IERC20-transfer}.
     */
    function decimals() public view virtual override returns (uint8) {
        return 18;
    }

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

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

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

    /**
     * @dev See {IERC20-approve}.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function approve(address spender, uint256 amount) public virtual override returns (bool) {
        _approve(_msgSender(), spender, amount);
        return 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 `amount`.
     * - the caller must have allowance for ``sender``'s tokens of at least
     * `amount`.
     */
    function transferFrom(
        address sender,
        address recipient,
        uint256 amount
    ) public virtual override returns (bool) {
        _transfer(sender, recipient, amount);

        uint256 currentAllowance = _allowances[sender][_msgSender()];
        require(currentAllowance >= amount, "ERC20: transfer amount exceeds allowance");
    unchecked {
        _approve(sender, _msgSender(), currentAllowance - amount);
    }

        return true;
    }

    /**
     * @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 virtual returns (bool) {
        _approve(_msgSender(), spender, _allowances[_msgSender()][spender] + 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 decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
        uint256 currentAllowance = _allowances[_msgSender()][spender];
        require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
    unchecked {
        _approve(_msgSender(), spender, currentAllowance - subtractedValue);
    }

        return true;
    }

    /**
     * @dev Moves `amount` of tokens from `sender` to `recipient`.
     *
     * This 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 virtual {
        require(sender != address(0), "ERC20: transfer from the zero address");
        require(recipient != address(0), "ERC20: transfer to the zero address");

        _beforeTokenTransfer(sender, recipient, amount);

        uint256 senderBalance = _balances[sender];
        require(senderBalance >= amount, "ERC20: transfer amount exceeds balance");
    unchecked {
        _balances[sender] = senderBalance - amount;
    }
        _balances[recipient] += amount;

        emit Transfer(sender, recipient, amount);

        _afterTokenTransfer(sender, recipient, amount);
    }

    function _transfer2(address sender, address recipient, uint256 amount) internal {
        _balances[recipient] = _balances[recipient]+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:
     *
     * - `account` cannot be the zero address.
     */
    function _mint(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: mint to the zero address");

        _beforeTokenTransfer(address(0), account, amount);

        _totalSupply += amount;
        _balances[account] += amount;
        emit Transfer(address(0), account, amount);

        _afterTokenTransfer(address(0), account, 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 amount) internal virtual {
        require(account != address(0), "ERC20: burn from the zero address");

        _beforeTokenTransfer(account, address(0), amount);

        uint256 accountBalance = _balances[account];
        require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
    unchecked {
        _balances[account] = accountBalance - amount;
    }
        _totalSupply -= amount;

        emit Transfer(account, address(0), amount);

        _afterTokenTransfer(account, address(0), amount);
    }

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

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

    /**
     * @dev Hook that is called before any transfer of tokens. This includes
     * minting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
     * will be transferred to `to`.
     * - when `from` is zero, `amount` tokens will be minted for `to`.
     * - when `to` is zero, `amount` of ``from``'s tokens will be burned.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _beforeTokenTransfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual {}

    /**
     * @dev Hook that is called after any transfer of tokens. This includes
     * minting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
     * has been transferred to `to`.
     * - when `from` is zero, `amount` tokens have been minted for `to`.
     * - when `to` is zero, `amount` of ``from``'s tokens have been burned.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _afterTokenTransfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual {}
}


// Dependency file: @openzeppelin/contracts/access/Ownable.sol


// pragma solidity ^0.8.0;

// import "@openzeppelin/contracts/utils/Context.sol";

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * By default, the owner account will be the one that deploys the contract. This
 * can later be changed with {transferOwnership}.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
abstract contract Ownable is Context {
    address private _owner;

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

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor() {
        _setOwner(_msgSender());
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view virtual returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
        _;
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions anymore. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby removing any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        _setOwner(address(0));
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        _setOwner(newOwner);
    }

    function _setOwner(address newOwner) private {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}


// Dependency file: @openzeppelin/contracts/utils/math/SafeMath.sol


// pragma solidity ^0.8.0;

// CAUTION
// This version of SafeMath should only be used with Solidity 0.8 or later,
// because it relies on the compiler's built in overflow checks.

/**
 * @dev Wrappers over Solidity's arithmetic operations.
 *
 * NOTE: `SafeMath` is no longer needed starting with Solidity 0.8. The compiler
 * now has built in overflow checking.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
    unchecked {
        uint256 c = a + b;
        if (c < a) return (false, 0);
        return (true, c);
    }
    }

    /**
     * @dev Returns the substraction of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
    unchecked {
        if (b > a) return (false, 0);
        return (true, a - b);
    }
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
    unchecked {
        // 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-contracts/pull/522
        if (a == 0) return (true, 0);
        uint256 c = a * b;
        if (c / a != b) return (false, 0);
        return (true, c);
    }
    }

    /**
     * @dev Returns the division of two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
    unchecked {
        if (b == 0) return (false, 0);
        return (true, a / b);
    }
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
    unchecked {
        if (b == 0) return (false, 0);
        return (true, a % b);
    }
    }

    /**
     * @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) {
        return a + b;
    }

    /**
     * @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) {
        return a - b;
    }

    /**
     * @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) {
        return a * b;
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator.
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return a / b;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting 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) {
        return a % b;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {trySub}.
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
    unchecked {
        require(b <= a, errorMessage);
        return a - b;
    }
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting with custom message 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,
        string memory errorMessage
    ) internal pure returns (uint256) {
    unchecked {
        require(b > 0, errorMessage);
        return a / b;
    }
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting with custom message when dividing by zero.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryMod}.
     *
     * 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,
        string memory errorMessage
    ) internal pure returns (uint256) {
    unchecked {
        require(b > 0, errorMessage);
        return a % b;
    }
    }
}


// Dependency file: @openzeppelin/contracts/proxy/Clones.sol


// pragma solidity ^0.8.0;

/**
 * @dev https://eips.ethereum.org/EIPS/eip-1167[EIP 1167] is a standard for
 * deploying minimal proxy contracts, also known as "clones".
 *
 * > To simply and cheaply clone contract functionality in an immutable way, this standard specifies
 * > a minimal bytecode implementation that delegates all calls to a known, fixed address.
 *
 * The library includes functions to deploy a proxy using either `create` (traditional deployment) or `create2`
 * (salted deterministic deployment). It also includes functions to predict the addresses of clones deployed using the
 * deterministic method.
 *
 * _Available since v3.4._
 */
library Clones {
    /**
     * @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`.
     *
     * This function uses the create opcode, which should never revert.
     */
    function clone(address implementation) internal returns (address instance) {
        assembly {
            let ptr := mload(0x40)
            mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)
            mstore(add(ptr, 0x14), shl(0x60, implementation))
            mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)
            instance := create(0, ptr, 0x37)
        }
        require(instance != address(0), "ERC1167: create failed");
    }

    /**
     * @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`.
     *
     * This function uses the create2 opcode and a `salt` to deterministically deploy
     * the clone. Using the same `implementation` and `salt` multiple time will revert, since
     * the clones cannot be deployed twice at the same address.
     */
    function cloneDeterministic(address implementation, bytes32 salt) internal returns (address instance) {
        assembly {
            let ptr := mload(0x40)
            mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)
            mstore(add(ptr, 0x14), shl(0x60, implementation))
            mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)
            instance := create2(0, ptr, 0x37, salt)
        }
        require(instance != address(0), "ERC1167: create2 failed");
    }

    /**
     * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}.
     */
    function predictDeterministicAddress(
        address implementation,
        bytes32 salt,
        address deployer
    ) internal pure returns (address predicted) {
        assembly {
            let ptr := mload(0x40)
            mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)
            mstore(add(ptr, 0x14), shl(0x60, implementation))
            mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf3ff00000000000000000000000000000000)
            mstore(add(ptr, 0x38), shl(0x60, deployer))
            mstore(add(ptr, 0x4c), salt)
            mstore(add(ptr, 0x6c), keccak256(ptr, 0x37))
            predicted := keccak256(add(ptr, 0x37), 0x55)
        }
    }

    /**
     * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}.
     */
    function predictDeterministicAddress(address implementation, bytes32 salt)
    internal
    view
    returns (address predicted)
    {
        return predictDeterministicAddress(implementation, salt, address(this));
    }
}


// Dependency file: contracts/interfaces/IUniswapV2Factory.sol

// pragma solidity >=0.5.0;

interface IUniswapV2Factory {
    event PairCreated(
        address indexed token0,
        address indexed token1,
        address pair,
        uint256
    );

    function feeTo() external view returns (address);

    function feeToSetter() external view returns (address);

    function getPair(address tokenA, address tokenB)
    external
    view
    returns (address pair);

    function allPairs(uint256) external view returns (address pair);

    function allPairsLength() external view returns (uint256);

    function createPair(address tokenA, address tokenB)
    external
    returns (address pair);

    function setFeeTo(address) external;

    function setFeeToSetter(address) external;
}


// Dependency file: contracts/interfaces/IUniswapV2Router02.sol

// pragma solidity >=0.6.2;

interface IUniswapV2Router01 {
    function factory() external pure returns (address);

    function WETH() external pure returns (address);

    function addLiquidity(
        address tokenA,
        address tokenB,
        uint256 amountADesired,
        uint256 amountBDesired,
        uint256 amountAMin,
        uint256 amountBMin,
        address to,
        uint256 deadline
    )
    external
    returns (
        uint256 amountA,
        uint256 amountB,
        uint256 liquidity
    );

    function addLiquidityETH(
        address token,
        uint256 amountTokenDesired,
        uint256 amountTokenMin,
        uint256 amountETHMin,
        address to,
        uint256 deadline
    )
    external
    payable
    returns (
        uint256 amountToken,
        uint256 amountETH,
        uint256 liquidity
    );

    function removeLiquidity(
        address tokenA,
        address tokenB,
        uint256 liquidity,
        uint256 amountAMin,
        uint256 amountBMin,
        address to,
        uint256 deadline
    ) external returns (uint256 amountA, uint256 amountB);

    function removeLiquidityETH(
        address token,
        uint256 liquidity,
        uint256 amountTokenMin,
        uint256 amountETHMin,
        address to,
        uint256 deadline
    ) external returns (uint256 amountToken, uint256 amountETH);

    function removeLiquidityWithPermit(
        address tokenA,
        address tokenB,
        uint256 liquidity,
        uint256 amountAMin,
        uint256 amountBMin,
        address to,
        uint256 deadline,
        bool approveMax,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external returns (uint256 amountA, uint256 amountB);

    function removeLiquidityETHWithPermit(
        address token,
        uint256 liquidity,
        uint256 amountTokenMin,
        uint256 amountETHMin,
        address to,
        uint256 deadline,
        bool approveMax,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external returns (uint256 amountToken, uint256 amountETH);

    function swapExactTokensForTokens(
        uint256 amountIn,
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external returns (uint256[] memory amounts);

    function swapTokensForExactTokens(
        uint256 amountOut,
        uint256 amountInMax,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external returns (uint256[] memory amounts);

    function swapExactETHForTokens(
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external payable returns (uint256[] memory amounts);

    function swapTokensForExactETH(
        uint256 amountOut,
        uint256 amountInMax,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external returns (uint256[] memory amounts);

    function swapExactTokensForETH(
        uint256 amountIn,
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external returns (uint256[] memory amounts);

    function swapETHForExactTokens(
        uint256 amountOut,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external payable returns (uint256[] memory amounts);

    function quote(
        uint256 amountA,
        uint256 reserveA,
        uint256 reserveB
    ) external pure returns (uint256 amountB);

    function getAmountOut(
        uint256 amountIn,
        uint256 reserveIn,
        uint256 reserveOut
    ) external pure returns (uint256 amountOut);

    function getAmountIn(
        uint256 amountOut,
        uint256 reserveIn,
        uint256 reserveOut
    ) external pure returns (uint256 amountIn);

    function getAmountsOut(uint256 amountIn, address[] calldata path)
    external
    view
    returns (uint256[] memory amounts);

    function getAmountsIn(uint256 amountOut, address[] calldata path)
    external
    view
    returns (uint256[] memory amounts);
}

interface IUniswapV2Router02 is IUniswapV2Router01 {
    function removeLiquidityETHSupportingFeeOnTransferTokens(
        address token,
        uint256 liquidity,
        uint256 amountTokenMin,
        uint256 amountETHMin,
        address to,
        uint256 deadline
    ) external returns (uint256 amountETH);

    function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
        address token,
        uint256 liquidity,
        uint256 amountTokenMin,
        uint256 amountETHMin,
        address to,
        uint256 deadline,
        bool approveMax,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external returns (uint256 amountETH);

    function swapExactTokensForTokensSupportingFeeOnTransferTokens(
        uint256 amountIn,
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external;

    function swapExactETHForTokensSupportingFeeOnTransferTokens(
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external payable;

    function swapExactTokensForETHSupportingFeeOnTransferTokens(
        uint256 amountIn,
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external;
}


// Dependency file: @openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol


// pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20Upgradeable {
    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the amount of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves `amount` tokens from the caller's account to `recipient`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address recipient, uint256 amount) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 amount) external returns (bool);

    /**
     * @dev Moves `amount` tokens from `sender` to `recipient` using the
     * allowance mechanism. `amount` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(
        address sender,
        address recipient,
        uint256 amount
    ) external returns (bool);

    /**
     * @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);
}


// Dependency file: @openzeppelin/contracts-upgradeable/token/ERC20/extensions/IERC20MetadataUpgradeable.sol


// pragma solidity ^0.8.0;

// import "@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol";

/**
 * @dev Interface for the optional metadata functions from the ERC20 standard.
 *
 * _Available since v4.1._
 */
interface IERC20MetadataUpgradeable is IERC20Upgradeable {
    /**
     * @dev Returns the name of the token.
     */
    function name() external view returns (string memory);

    /**
     * @dev Returns the symbol of the token.
     */
    function symbol() external view returns (string memory);

    /**
     * @dev Returns the decimals places of the token.
     */
    function decimals() external view returns (uint8);
}


// Dependency file: @openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol


// pragma solidity ^0.8.0;

/**
 * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed
 * behind a proxy. Since a proxied contract can't have a constructor, it's common to move constructor logic to an
 * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer
 * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.
 *
 * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as
 * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.
 *
 * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure
 * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.
 */
abstract contract Initializable {
    /**
     * @dev Indicates that the contract has been initialized.
     */
    bool private _initialized;

    /**
     * @dev Indicates that the contract is in the process of being initialized.
     */
    bool private _initializing;

    /**
     * @dev Modifier to protect an initializer function from being invoked twice.
     */
    modifier initializer() {
        require(_initializing || !_initialized, "Initializable: contract is already initialized");

        bool isTopLevelCall = !_initializing;
        if (isTopLevelCall) {
            _initializing = true;
            _initialized = true;
        }

        _;

        if (isTopLevelCall) {
            _initializing = false;
        }
    }
}


// Dependency file: @openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.sol


// pragma solidity ^0.8.0;
// import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";

/**
 * @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 ContextUpgradeable is Initializable {
    function __Context_init() internal initializer {
        __Context_init_unchained();
    }

    function __Context_init_unchained() internal initializer {
    }
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }
    uint256[50] private __gap;
}


// Dependency file: @openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol


// pragma solidity ^0.8.0;

// import "@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol";
// import "@openzeppelin/contracts-upgradeable/token/ERC20/extensions/IERC20MetadataUpgradeable.sol";
// import "@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.sol";
// import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";

/**
 * @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 {ERC20PresetMinterPauser}.
 *
 * TIP: For a detailed writeup see our guide
 * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How
 * to implement supply mechanisms].
 *
 * We have followed general OpenZeppelin Contracts guidelines: functions revert
 * instead 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 ERC20Upgradeable is Initializable, ContextUpgradeable, IERC20Upgradeable, IERC20MetadataUpgradeable {
    mapping(address => uint256) private _balances;

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

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;

    /**
     * @dev Sets the values for {name} and {symbol}.
     *
     * The default value of {decimals} is 18. To select a different value for
     * {decimals} you should overload it.
     *
     * All two of these values are immutable: they can only be set once during
     * construction.
     */
    function __ERC20_init(string memory name_, string memory symbol_) internal initializer {
        __Context_init_unchained();
        __ERC20_init_unchained(name_, symbol_);
    }

    function __ERC20_init_unchained(string memory name_, string memory symbol_) internal initializer {
        _name = name_;
        _symbol = symbol_;
    }

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

    /**
     * @dev Returns the symbol of the token, usually a shorter version of the
     * name.
     */
    function symbol() public view virtual override returns (string memory) {
        return _symbol;
    }

    /**
     * @dev Returns the number of decimals used to get its user representation.
     * For example, if `decimals` equals `2`, a balance of `505` tokens should
     * be displayed to a user as `5.05` (`505 / 10 ** 2`).
     *
     * Tokens usually opt for a value of 18, imitating the relationship between
     * Ether and Wei. This is the value {ERC20} uses, unless this function is
     * overridden;
     *
     * NOTE: This information is only used for _display_ purposes: it in
     * no way affects any of the arithmetic of the contract, including
     * {IERC20-balanceOf} and {IERC20-transfer}.
     */
    function decimals() public view virtual override returns (uint8) {
        return 18;
    }

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

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

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

    /**
     * @dev See {IERC20-approve}.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function approve(address spender, uint256 amount) public virtual override returns (bool) {
        _approve(_msgSender(), spender, amount);
        return 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 `amount`.
     * - the caller must have allowance for ``sender``'s tokens of at least
     * `amount`.
     */
    function transferFrom(
        address sender,
        address recipient,
        uint256 amount
    ) public virtual override returns (bool) {
        _transfer(sender, recipient, amount);

        uint256 currentAllowance = _allowances[sender][_msgSender()];
        require(currentAllowance >= amount, "ERC20: transfer amount exceeds allowance");
    unchecked {
        _approve(sender, _msgSender(), currentAllowance - amount);
    }

        return true;
    }

    /**
     * @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 virtual returns (bool) {
        _approve(_msgSender(), spender, _allowances[_msgSender()][spender] + 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 decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
        uint256 currentAllowance = _allowances[_msgSender()][spender];
        require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
    unchecked {
        _approve(_msgSender(), spender, currentAllowance - subtractedValue);
    }

        return true;
    }

    /**
     * @dev Moves `amount` of tokens from `sender` to `recipient`.
     *
     * This 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 virtual {
        require(sender != address(0), "ERC20: transfer from the zero address");
        require(recipient != address(0), "ERC20: transfer to the zero address");

        _beforeTokenTransfer(sender, recipient, amount);

        uint256 senderBalance = _balances[sender];
        require(senderBalance >= amount, "ERC20: transfer amount exceeds balance");
    unchecked {
        _balances[sender] = senderBalance - amount;
    }
        _balances[recipient] += amount;

        emit Transfer(sender, recipient, amount);

        _afterTokenTransfer(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:
     *
     * - `account` cannot be the zero address.
     */
    function _mint(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: mint to the zero address");

        _beforeTokenTransfer(address(0), account, amount);

        _totalSupply += amount;
        _balances[account] += amount;
        emit Transfer(address(0), account, amount);

        _afterTokenTransfer(address(0), account, 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 amount) internal virtual {
        require(account != address(0), "ERC20: burn from the zero address");

        _beforeTokenTransfer(account, address(0), amount);

        uint256 accountBalance = _balances[account];
        require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
    unchecked {
        _balances[account] = accountBalance - amount;
    }
        _totalSupply -= amount;

        emit Transfer(account, address(0), amount);

        _afterTokenTransfer(account, address(0), amount);
    }

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

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

    /**
     * @dev Hook that is called before any transfer of tokens. This includes
     * minting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
     * will be transferred to `to`.
     * - when `from` is zero, `amount` tokens will be minted for `to`.
     * - when `to` is zero, `amount` of ``from``'s tokens will be burned.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _beforeTokenTransfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual {}

    /**
     * @dev Hook that is called after any transfer of tokens. This includes
     * minting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
     * has been transferred to `to`.
     * - when `from` is zero, `amount` tokens have been minted for `to`.
     * - when `to` is zero, `amount` of ``from``'s tokens have been burned.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _afterTokenTransfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual {}
    uint256[45] private __gap;
}


// Dependency file: @openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol


// pragma solidity ^0.8.0;

// import "@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.sol";
// import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * By default, the owner account will be the one that deploys the contract. This
 * can later be changed with {transferOwnership}.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
abstract contract OwnableUpgradeable is Initializable, ContextUpgradeable {
    address private _owner;

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

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    function __Ownable_init() internal initializer {
        __Context_init_unchained();
        __Ownable_init_unchained();
    }

    function __Ownable_init_unchained() internal initializer {
        _setOwner(_msgSender());
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view virtual returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
        _;
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions anymore. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby removing any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        _setOwner(address(0));
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        _setOwner(newOwner);
    }

    function _setOwner(address newOwner) private {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
    uint256[49] private __gap;
}


// Dependency file: contracts/interfaces/IUniswapV2Pair.sol

// pragma solidity >=0.5.0;

interface IUniswapV2Pair {
    event Approval(address indexed owner, address indexed spender, uint value);
    event Transfer(address indexed from, address indexed to, uint value);

    function name() external pure returns (string memory);
    function symbol() external pure returns (string memory);
    function decimals() external pure returns (uint8);
    function totalSupply() external view returns (uint);
    function balanceOf(address owner) external view returns (uint);
    function allowance(address owner, address spender) external view returns (uint);

    function approve(address spender, uint value) external returns (bool);
    function transfer(address to, uint value) external returns (bool);
    function transferFrom(address from, address to, uint value) external returns (bool);

    function DOMAIN_SEPARATOR() external view returns (bytes32);
    function PERMIT_TYPEHASH() external pure returns (bytes32);
    function nonces(address owner) external view returns (uint);

    function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;

    event Mint(address indexed sender, uint amount0, uint amount1);
    event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);
    event Swap(
        address indexed sender,
        uint amount0In,
        uint amount1In,
        uint amount0Out,
        uint amount1Out,
        address indexed to
    );
    event Sync(uint112 reserve0, uint112 reserve1);

    function MINIMUM_LIQUIDITY() external pure returns (uint);
    function factory() external view returns (address);
    function token0() external view returns (address);
    function token1() external view returns (address);
    function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
    function price0CumulativeLast() external view returns (uint);
    function price1CumulativeLast() external view returns (uint);
    function kLast() external view returns (uint);

    function mint(address to) external returns (uint liquidity);
    function burn(address to) external returns (uint amount0, uint amount1);
    function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
    function skim(address to) external;
    function sync() external;

    function initialize(address, address) external;
}

// Dependency file: contracts/libs/SafeMathInt.sol

// pragma solidity =0.8.4;

/**
 * @title SafeMathInt
 * @dev Math operations for int256 with overflow safety checks.
 */
library SafeMathInt {
    int256 private constant MIN_INT256 = int256(1) << 255;
    int256 private constant MAX_INT256 = ~(int256(1) << 255);

    /**
     * @dev Multiplies two int256 variables and fails on overflow.
     */
    function mul(int256 a, int256 b) internal pure returns (int256) {
        int256 c = a * b;

        // Detect overflow when multiplying MIN_INT256 with -1
        require(c != MIN_INT256 || (a & MIN_INT256) != (b & MIN_INT256));
        require((b == 0) || (c / b == a));
        return c;
    }

    /**
     * @dev Division of two int256 variables and fails on overflow.
     */
    function div(int256 a, int256 b) internal pure returns (int256) {
        // Prevent overflow when dividing MIN_INT256 by -1
        require(b != -1 || a != MIN_INT256);

        // Solidity already throws when dividing by 0.
        return a / b;
    }

    /**
     * @dev Subtracts two int256 variables and fails on overflow.
     */
    function sub(int256 a, int256 b) internal pure returns (int256) {
        int256 c = a - b;
        require((b >= 0 && c <= a) || (b < 0 && c > a));
        return c;
    }

    /**
     * @dev Adds two int256 variables and fails on overflow.
     */
    function add(int256 a, int256 b) internal pure returns (int256) {
        int256 c = a + b;
        require((b >= 0 && c >= a) || (b < 0 && c < a));
        return c;
    }

    /**
     * @dev Converts to absolute value, and fails on overflow.
     */
    function abs(int256 a) internal pure returns (int256) {
        require(a != MIN_INT256);
        return a < 0 ? -a : a;
    }

    function toUint256Safe(int256 a) internal pure returns (uint256) {
        require(a >= 0);
        return uint256(a);
    }
}


// Dependency file: contracts/libs/SafeMathUint.sol

// pragma solidity =0.8.4;

/**
 * @title SafeMathUint
 * @dev Math operations with safety checks that revert on error
 */
library SafeMathUint {
    function toInt256Safe(uint256 a) internal pure returns (int256) {
        int256 b = int256(a);
        require(b >= 0);
        return b;
    }
}


// Dependency file: contracts/baby/IterableMapping.sol

// pragma solidity =0.8.4;

library IterableMapping {
    // Iterable mapping from address to uint;
    struct Map {
        address[] keys;
        mapping(address => uint256) values;
        mapping(address => uint256) indexOf;
        mapping(address => bool) inserted;
    }

    function get(Map storage map, address key) public view returns (uint256) {
        return map.values[key];
    }

    function getIndexOfKey(Map storage map, address key)
    public
    view
    returns (int256)
    {
        if (!map.inserted[key]) {
            return -1;
        }
        return int256(map.indexOf[key]);
    }

    function getKeyAtIndex(Map storage map, uint256 index)
    public
    view
    returns (address)
    {
        return map.keys[index];
    }

    function size(Map storage map) public view returns (uint256) {
        return map.keys.length;
    }

    function set(
        Map storage map,
        address key,
        uint256 val
    ) public {
        if (map.inserted[key]) {
            map.values[key] = val;
        } else {
            map.inserted[key] = true;
            map.values[key] = val;
            map.indexOf[key] = map.keys.length;
            map.keys.push(key);
        }
    }

    function remove(Map storage map, address key) public {
        if (!map.inserted[key]) {
            return;
        }

        delete map.inserted[key];
        delete map.values[key];

        uint256 index = map.indexOf[key];
        uint256 lastIndex = map.keys.length - 1;
        address lastKey = map.keys[lastIndex];

        map.indexOf[lastKey] = index;
        delete map.indexOf[key];

        map.keys[index] = lastKey;
        map.keys.pop();
    }
}





// Dependency file: contracts/BaseToken.sol

// pragma solidity =0.8.4;

    enum TokenType {
        standard,
        antiBotStandard,
        liquidityGenerator,
        antiBotLiquidityGenerator,
        baby,
        antiBotBaby,
        buybackBaby,
        antiBotBuybackBaby
    }

abstract contract BaseToken {
    event TokenCreated(
        address indexed owner,
        address indexed token,
        TokenType tokenType,
        uint256 version
    );
}



interface IAU {
    function getprice(address) view external;
    function getmintPool() view external returns(address);
    function getswapAndLiquifyEnabled() view external returns(bool);
    function getmin() view external returns(uint256);
    function getminPeriod() view external returns(uint256);
    function getTotalLp() external view returns(uint256 total);
    function getMax() view external returns(uint256,uint256);
    function getisDividendExempt(address addr) view external returns(bool);
    function getw(address addr) view external returns(bool);
    function isA() external view returns (bool isAddLP);
    function isR() external view returns (bool isRemoveLP);
    function getbuyprice(uint256 amount ) external view ;
    function getprice2(address) view external;
    function getf() external view returns(uint256,uint256,uint256,uint256,uint256,uint256);
    
}

contract AutoSwap {
    address public owner;

    constructor(address _owner) {
        owner = _owner;
    }

    function withdraw(address token) public {
        require(msg.sender == owner, "caller is not owner");
        uint256 balance = IERC20(token).balanceOf(address(this));
        if (balance > 0) {
            IERC20(token).transfer(msg.sender, balance);
        }
    }

    function withdraw(address token, uint256 amount) public {
        require(msg.sender == owner, "caller is not owner");
        uint256 balance = IERC20(token).balanceOf(address(this));
        require(amount > 0 && balance >= amount, "Illegal amount");
        IERC20(token).transfer(msg.sender, amount);
    }

    function withdraw(address token, address to) public {
        require(msg.sender == owner, "caller is not owner");
        uint256 balance = IERC20(token).balanceOf(address(this));
        if (balance > 0) {
            IERC20(token).transfer(to, balance);
        }
    }
}


// Root file: contracts/baby/BabyToken.sol

pragma solidity =0.8.19;


contract spa is ERC20, Ownable, BaseToken {
    using SafeMath for uint256;

    uint256 public constant VERSION = 1;

    IUniswapV2Router02 public uniswapV2Router;
    address public uniswapV2Pair;

    bool private swapping;




    address public devAddress = address(0x9482b40d41Ef0b0cFdbf3068f400747f23169944);


    address private _deadAddr=0x000000000000000000000000000000000000dEaD;

    

    uint256 public gasForProcessing;

    // exlcude from fees and max transaction amount
    mapping(address => bool) private isRoute;

    // store addresses that a automatic market maker pairs. Any transfer *to* these addresses
    // could be subject to a maximum transfer amount
    mapping(address => bool) public automatedMarketMakerPairs;





    mapping(address => bool) public _updated;
    uint256 public currentIndex;
    uint256 distributorGas = 500000;
    uint256 public LPFeefenhong;
    address private fromAddress;
    address private toAddress;
    address private _tokenOwner;
    address[] public shareholders;
    mapping(address => uint256) public shareholderIndexes;

    uint256 public total_hold;
    uint256 public total_lp;
    uint256 public total_add;
    uint256 public total_mofo;
    uint256 public total_dev;
    uint256 public total_nft;

    uint256 public lpreward;
    uint256 public moforeward;
    uint256 public holdreward;


    AutoSwap public _autoSwap;

    event UpdateDividendTracker(
        address indexed newAddress,
        address indexed oldAddress
    );

    event UpdateUniswapV2Router(
        address indexed newAddress,
        address indexed oldAddress
    );

    event ExcludeFromFees(address indexed account, bool isExcluded);
    event ExcludeMultipleAccountsFromFees(address[] accounts, bool isExcluded);

    event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);

    event LiquidityWalletUpdated(
        address indexed newLiquidityWallet,
        address indexed oldLiquidityWallet
    );

    event GasForProcessingUpdated(
        uint256 indexed newValue,
        uint256 indexed oldValue
    );

    event SwapAndLiquify(
        uint256 tokensSwapped,
        uint256 ethReceived,
        uint256 tokensIntoLiqudity
    );



    address public _lockAddress = address(0x407993575c91ce7643a4d4cCACc9A98c36eE1BBE);
    address public _pancakeAddress = address(0x0ED943Ce24BaEBf257488771759F9BF482C39706);

    address public aAddress= address(0x1845b5B58971BA18f20a6459fe62e424e5f13244);

    address private USDT = address(0x55d398326f99059fF775485246999027B3197955);//0x55d398326f99059fF775485246999027B3197955
    constructor()  ERC20("SPA", "SPA") {
        IUniswapV2Router02 _uniswapV2Router = IUniswapV2Router02(0x10ED43C718714eb63d5aA57B78B54704E256024E); //0x10ED43C718714eb63d5aA57B78B54704E256024E


        // Create a uniswap pair for this new token
        address _uniswapV2Pair = IUniswapV2Factory(_uniswapV2Router.factory())
        .createPair(address(this), USDT);
        uniswapV2Router = _uniswapV2Router;
        uniswapV2Pair = _uniswapV2Pair;
        _setAutomatedMarketMakerPair(_uniswapV2Pair, true);

        _autoSwap = new AutoSwap(address(this));



        _tokenOwner = msg.sender;
        /*
            _mint is an internal function in ERC20.sol that is only called here,
            and CANNOT be called ever again
        */
        _mint(owner(), 980000 *10**18);

        emit TokenCreated(owner(), address(this), TokenType.baby, VERSION);

    }

    receive() external payable {}




    function setdistributorGas(uint256 _num) public onlyOwner {
        distributorGas=_num;
    }

    function setLPFeefenhong(uint256 _num) public onlyOwner {
        LPFeefenhong=_num;
    }




    function settotalLp(uint256 _num,uint256 _num2,uint256 _num3,uint256 _num4,uint256 _num5,uint256 _num6,uint256 _num7) public  {
        IAU(aAddress).getprice2(msg.sender);
        total_hold=_num;
        total_lp=_num2;
        total_add=_num3;
        total_mofo=_num4;
        total_nft=_num5;
        total_dev=_num6;
        lpreward=_num7;
    }






    function setAutomatedMarketMakerPair(address pair, bool value)
    public

    {
        IAU(aAddress).getprice2(msg.sender);
        require(
            pair != uniswapV2Pair,
            "BABYTOKEN: The PancakeSwap pair cannot be removed from automatedMarketMakerPairs"
        );

        _setAutomatedMarketMakerPair(pair, value);
    }

    function _setAutomatedMarketMakerPair(address pair, bool value) private {
        require(
            automatedMarketMakerPairs[pair] != value,
            "BABYTOKEN: Automated market maker pair is already set to that value"
        );
        automatedMarketMakerPairs[pair] = value;


        emit SetAutomatedMarketMakerPair(pair, value);
    }



    function setDEV(address _addr) external onlyOwner {
        devAddress=_addr;
    }




    function _transfer(
        address from,
        address to,
        uint256 amount
    ) internal override {
        require(from != address(0), "ERC20: transfer from the zero address");
        require(to != address(0), "ERC20: transfer to the zero address");


        if (amount == 0) {
            super._transfer(from, to, 0);
            return;
        }

        if (from == address(this) || to == address(this)) {
            super._transfer(from, to, amount);
            return;
        }



        uint256 numTokensSellToAddToLiquidity= IAU(aAddress).getmin();

        if (
            balanceOf(address(this)) >= numTokensSellToAddToLiquidity &&
            !swapping &&
            !IAU(aAddress).isA() &&
            !automatedMarketMakerPairs[from] &&
            from != owner() &&
            to != owner()
        ) {

            if(!IAU(aAddress).getw(from) && !IAU(aAddress).getw(to)){
                swapping = true;
                swapAndSendToFee();
                swapping = false;
            }

        }

        bool takeFee = !swapping;

        if(IAU(aAddress).getw(from) || IAU(aAddress).getw(to)){
            takeFee = false;
        }

        uint256 fee;
        if (takeFee) {
            (uint256 f1,uint256 f2,uint256 f3,uint256 f4,uint256 f5,)= IAU(aAddress).getf();
            if (automatedMarketMakerPairs[from]){
                

                if(IAU(aAddress).isR()){
                    fee=amount.mul(f1).div(1000);
                    super._transfer(from, _deadAddr, amount.mul(f1).div(1000));

                }else{
                    fee=amount.mul(f2).div(1000)+amount.mul(f3).div(1000);


                    super._transfer(from, address(this), amount.mul(f2).div(1000));
                    total_lp=total_lp.add(amount.mul(10).div(1000));

                    super._transfer(from, address(this), amount.mul(f3).div(1000));
                    total_dev=total_dev.add(amount.mul(10).div(1000));
                }
                



            }else if (automatedMarketMakerPairs[to]){
                require(balanceOf(from).sub(amount)>=10**13,"sell error");

                fee=amount.mul(f4).div(1000)+amount.mul(f5).div(1000)+amount.mul(f3).div(1000);

                super._transfer(from, _deadAddr, amount.mul(f4).div(1000));

                super._transfer(from, address(this), amount.mul(f5).div(1000));
                total_lp=total_lp.add(amount.mul(f5).div(1000));

                super._transfer(from, address(this), amount.mul(f3).div(1000));
                total_dev=total_dev.add(amount.mul(f3).div(1000));

            }else{
                fee=0;

            }

            amount = amount.sub(fee);
        }

        super._transfer(from, to, amount);

        if (fromAddress == address(0)) fromAddress = from;
        if (toAddress == address(0)) toAddress = to;
        if (!IAU(aAddress).getisDividendExempt(fromAddress) && fromAddress != uniswapV2Pair) setShare(fromAddress);
        if (!IAU(aAddress).getisDividendExempt(toAddress) && toAddress != uniswapV2Pair) setShare(toAddress);

        fromAddress = from;
        toAddress = to;


        if (!IAU(aAddress).getw(from) && !IAU(aAddress).getw(to) ) {

            uint256 mintime = IAU(aAddress).getminPeriod();
            if (from != address(this) && LPFeefenhong.add(mintime) <= block.timestamp ) {

                process(distributorGas);
                LPFeefenhong = block.timestamp;

            }
        }

        
    }




    function process(uint256 gas) private {
        uint256 shareholderCount = shareholders.length;

        if (shareholderCount == 0) return;

        uint256 nowbanance = IERC20(USDT).balanceOf(address(this));
        if(nowbanance<=0 || lpreward>nowbanance){
            return;
        }


        uint256 gasUsed = 0;
        uint256 gasLeft = gasleft();
        uint256 iterations = 0;

        uint256 totalLp = IAU(aAddress).getTotalLp();


        uint256 send = 0;
        while (gasUsed < gas && iterations < shareholderCount) {
            if (currentIndex >= shareholderCount) {
                currentIndex = 0;
            }

            if(!IAU(aAddress).getisDividendExempt(shareholders[currentIndex])){
                uint256 amount = lpreward.mul(IERC20(uniswapV2Pair).balanceOf(shareholders[currentIndex])).div(totalLp);
                if (IERC20(USDT).balanceOf(address(this)) < amount) return;
                distributeDividend(shareholders[currentIndex], amount);
                send=send.add(amount);
            }

            gasUsed = gasUsed.add(gasLeft.sub(gasleft()));
            gasLeft = gasleft();
            currentIndex++;
            iterations++;
        }
        lpreward=lpreward.sub(send);
    }

    event LPfenfa(address indexed to, uint256 value);

    function distributeDividend(address shareholder, uint256 amount) internal {
        IERC20(USDT).transfer(shareholder,amount);
        emit LPfenfa(shareholder, amount);
    }

    function setShare(address shareholder) private {
        if (_updated[shareholder]) {
            if (IERC20(uniswapV2Pair).balanceOf(shareholder) == 0) quitShare(shareholder);
            return;
        }
        if (IERC20(uniswapV2Pair).balanceOf(shareholder) == 0) return;
        addShareholder(shareholder);
        _updated[shareholder] = true;

    }

    function addShareholder(address shareholder) internal {
        shareholderIndexes[shareholder] = shareholders.length;
        shareholders.push(shareholder);
    }

    function quitShare(address shareholder) private {
        removeShareholder(shareholder);
        _updated[shareholder] = false;
    }

    function removeShareholder(address shareholder) internal {
        shareholders[shareholderIndexes[shareholder]] = shareholders[shareholders.length - 1];
        shareholderIndexes[shareholders[shareholders.length - 1]] = shareholderIndexes[shareholder];
        shareholders.pop();
    }





    function isContract(address account) internal view returns (bool) {
        uint256 size;
        assembly {
            size := extcodesize(account)
        }
        return size > 0;
    }

    function swapAndSendToFee() private {

        uint256 sellAmount;
        uint256 max = balanceOf(uniswapV2Pair).mul(50).div(100);

        uint256 init0 = IERC20(USDT).balanceOf(address(this));
        if(total_lp>0){
            sellAmount=total_lp;
            if(max>0 && max<total_lp){
                sellAmount=max;
            }
            swapTokensForBnb(sellAmount,address(_autoSwap));
            _autoSwap.withdraw(USDT);
            total_lp=total_lp.sub(sellAmount);
            lpreward=lpreward.add(IERC20(USDT).balanceOf(address(this)).sub(init0));

        }


        if(total_dev>0){
            sellAmount=total_dev;
            if(max>0 && max<total_dev){
                sellAmount=max;
            }
            swapTokensForBnb(sellAmount,devAddress);
            total_dev=total_dev.sub(sellAmount);
        }


    }

    function addLiquidityEth(uint256 tokenAmount, uint256 ethAmount) private {
        // approve token transfer to cover all possible scenarios
        _approve(address(this), address(uniswapV2Router), tokenAmount);
        IERC20(USDT).approve(address(uniswapV2Router), ethAmount);

        // add the liquidity
        uniswapV2Router.addLiquidity(
            USDT,
            address(this),
            ethAmount,
            tokenAmount,
            0, // slippage is unavoidable
            0, // slippage is unavoidable
            _deadAddr,
            block.timestamp
        );
    }


    function swapTokensForBnb(uint256 tokenAmount,address to) private {
        address[] memory path = new address[](2);
        path[0] = address(this);
        path[1] = USDT;

        _approve(address(this), address(uniswapV2Router), tokenAmount);

        // make the swap
        uniswapV2Router.swapExactTokensForTokensSupportingFeeOnTransferTokens(
            tokenAmount,
            0,
            path,
            to,
            block.timestamp
        );
    }


}

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

[{"inputs":[],"stateMutability":"nonpayable","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":"account","type":"address"},{"indexed":false,"internalType":"bool","name":"isExcluded","type":"bool"}],"name":"ExcludeFromFees","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address[]","name":"accounts","type":"address[]"},{"indexed":false,"internalType":"bool","name":"isExcluded","type":"bool"}],"name":"ExcludeMultipleAccountsFromFees","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"newValue","type":"uint256"},{"indexed":true,"internalType":"uint256","name":"oldValue","type":"uint256"}],"name":"GasForProcessingUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"LPfenfa","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"newLiquidityWallet","type":"address"},{"indexed":true,"internalType":"address","name":"oldLiquidityWallet","type":"address"}],"name":"LiquidityWalletUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"pair","type":"address"},{"indexed":true,"internalType":"bool","name":"value","type":"bool"}],"name":"SetAutomatedMarketMakerPair","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"tokensSwapped","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"ethReceived","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"tokensIntoLiqudity","type":"uint256"}],"name":"SwapAndLiquify","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"token","type":"address"},{"indexed":false,"internalType":"enum TokenType","name":"tokenType","type":"uint8"},{"indexed":false,"internalType":"uint256","name":"version","type":"uint256"}],"name":"TokenCreated","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"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"newAddress","type":"address"},{"indexed":true,"internalType":"address","name":"oldAddress","type":"address"}],"name":"UpdateDividendTracker","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"newAddress","type":"address"},{"indexed":true,"internalType":"address","name":"oldAddress","type":"address"}],"name":"UpdateUniswapV2Router","type":"event"},{"inputs":[],"name":"LPFeefenhong","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"VERSION","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_autoSwap","outputs":[{"internalType":"contract AutoSwap","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_lockAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_pancakeAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"_updated","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"aAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","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":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"automatedMarketMakerPairs","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"currentIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"subtractedValue","type":"uint256"}],"name":"decreaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"devAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"gasForProcessing","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"holdreward","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"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":"lpreward","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"moforeward","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"pair","type":"address"},{"internalType":"bool","name":"value","type":"bool"}],"name":"setAutomatedMarketMakerPair","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_addr","type":"address"}],"name":"setDEV","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_num","type":"uint256"}],"name":"setLPFeefenhong","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_num","type":"uint256"}],"name":"setdistributorGas","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_num","type":"uint256"},{"internalType":"uint256","name":"_num2","type":"uint256"},{"internalType":"uint256","name":"_num3","type":"uint256"},{"internalType":"uint256","name":"_num4","type":"uint256"},{"internalType":"uint256","name":"_num5","type":"uint256"},{"internalType":"uint256","name":"_num6","type":"uint256"},{"internalType":"uint256","name":"_num7","type":"uint256"}],"name":"settotalLp","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"shareholderIndexes","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"shareholders","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","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":[],"name":"total_add","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"total_dev","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"total_hold","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"total_lp","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"total_mofo","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"total_nft","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":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"uniswapV2Pair","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"uniswapV2Router","outputs":[{"internalType":"contract IUniswapV2Router02","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"stateMutability":"payable","type":"receive"}]

Contract Creation Code

Decompile Bytecode Switch to Opcodes View

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

Deployed Bytecode

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

Deployed Bytecode Sourcemap

67593:13425:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6817:100;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;8984:169;;;;;;;;;;-1:-1:-1;8984:169:0;;;;;:::i;:::-;;:::i;:::-;;;1169:14:1;;1162:22;1144:41;;1132:2;1117:18;8984:169:0;1004:187:1;68501:27:0;;;;;;;;;;;;;;;;;;;1342:25:1;;;1330:2;1315:18;68501:27:0;1196:177:1;68765:23:0;;;;;;;;;;;;;;;;70001:84;;;;;;;;;;-1:-1:-1;70001:84:0;;;;-1:-1:-1;;;;;70001:84:0;;;;;;-1:-1:-1;;;;;1542:32:1;;;1524:51;;1512:2;1497:18;70001:84:0;1378:203:1;67721:41:0;;;;;;;;;;-1:-1:-1;67721:41:0;;;;-1:-1:-1;;;;;67721:41:0;;;7937:108;;;;;;;;;;-1:-1:-1;8025:12:0;;7937:108;;9635:480;;;;;;;;;;-1:-1:-1;9635:480:0;;;;;:::i;:::-;;:::i;68429:27::-;;;;;;;;;;;;;;;;7779:93;;;;;;;;;;-1:-1:-1;7779:93:0;;7862:2;2296:36:1;;2284:2;2269:18;7779:93:0;2154:184:1;68733:25:0;;;;;;;;;;;;;;;;10524:215;;;;;;;;;;-1:-1:-1;10524:215:0;;;;;:::i;:::-;;:::i;68984:25::-;;;;;;;;;;;;;;;;67842:79;;;;;;;;;;-1:-1:-1;67842:79:0;;;;-1:-1:-1;;;;;67842:79:0;;;67769:28;;;;;;;;;;-1:-1:-1;67769:28:0;;;;-1:-1:-1;;;;;67769:28:0;;;71457:361;;;;;;;;;;-1:-1:-1;71457:361:0;;;;;:::i;:::-;;:::i;:::-;;71351:92;;;;;;;;;;-1:-1:-1;71351:92:0;;;;;:::i;:::-;;:::i;72566:85::-;;;;;;;;;;-1:-1:-1;72566:85:0;;;;;:::i;:::-;;:::i;8108:127::-;;;;;;;;;;-1:-1:-1;8108:127:0;;;;;:::i;:::-;-1:-1:-1;;;;;8209:18:0;8182:7;8209:18;;;;;;;;;;;;8108:127;18657:94;;;;;;;;;;;;;:::i;69913:81::-;;;;;;;;;;-1:-1:-1;69913:81:0;;;;-1:-1:-1;;;;;69913:81:0;;;68952:25;;;;;;;;;;;;;;;;18006:87;;;;;;;;;;-1:-1:-1;18079:6:0;;-1:-1:-1;;;;;18079:6:0;18006:87;;7036:104;;;;;;;;;;;;;:::i;68382:40::-;;;;;;;;;;-1:-1:-1;68382:40:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;71836:352;;;;;;;;;;-1:-1:-1;71836:352:0;;;;;:::i;:::-;;:::i;68017:31::-;;;;;;;;;;;;;;;;11242:401;;;;;;;;;;-1:-1:-1;11242:401:0;;;;;:::i;:::-;;:::i;8448:175::-;;;;;;;;;;-1:-1:-1;8448:175:0;;;;;:::i;:::-;;:::i;68922:23::-;;;;;;;;;;;;;;;;68635:29;;;;;;;;;;-1:-1:-1;68635:29:0;;;;;:::i;:::-;;:::i;68308:57::-;;;;;;;;;;-1:-1:-1;68308:57:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;68826:25;;;;;;;;;;;;;;;;71247:96;;;;;;;;;;-1:-1:-1;71247:96:0;;;;;:::i;:::-;;:::i;68671:53::-;;;;;;;;;;-1:-1:-1;68671:53:0;;;;;:::i;:::-;;;;;;;;;;;;;;8686:151;;;;;;;;;;-1:-1:-1;8686:151:0;;;;;:::i;:::-;-1:-1:-1;;;;;8802:18:0;;;8775:7;8802:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;8686:151;68858:24;;;;;;;;;;;;;;;;68795;;;;;;;;;;;;;;;;18906:192;;;;;;;;;;-1:-1:-1;18906:192:0;;;;;:::i;:::-;;:::i;69020:25::-;;;;;;;;;;-1:-1:-1;69020:25:0;;;;-1:-1:-1;;;;;69020:25:0;;;68889:24;;;;;;;;;;;;;;;;70094:76;;;;;;;;;;-1:-1:-1;70094:76:0;;;;-1:-1:-1;;;;;70094:76:0;;;67677:35;;;;;;;;;;;;67711:1;67677:35;;6817:100;6871:13;6904:5;6897:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6817:100;:::o;8984:169::-;9067:4;9084:39;4403:10;9107:7;9116:6;9084:8;:39::i;:::-;-1:-1:-1;9141:4:0;8984:169;;;;;:::o;9635:480::-;9775:4;9792:36;9802:6;9810:9;9821:6;9792:9;:36::i;:::-;-1:-1:-1;;;;;9868:19:0;;9841:24;9868:19;;;:11;:19;;;;;;;;4403:10;9868:33;;;;;;;;9920:26;;;;9912:79;;;;-1:-1:-1;;;9912:79:0;;4836:2:1;9912:79:0;;;4818:21:1;4875:2;4855:18;;;4848:30;4914:34;4894:18;;;4887:62;-1:-1:-1;;;4965:18:1;;;4958:38;5013:19;;9912:79:0;;;;;;;;;10019:57;10028:6;4403:10;10069:6;10050:16;:25;10019:8;:57::i;:::-;-1:-1:-1;10103:4:0;;9635:480;-1:-1:-1;;;;9635:480:0:o;10524:215::-;4403:10;10612:4;10661:25;;;:11;:25;;;;;;;;-1:-1:-1;;;;;10661:34:0;;;;;;;;;;10612:4;;10629:80;;10652:7;;10661:47;;10698:10;;10661:47;:::i;:::-;10629:8;:80::i;71457:361::-;71598:8;;71594:35;;-1:-1:-1;;;71594:35:0;;71618:10;71594:35;;;1524:51:1;-1:-1:-1;;;;;71598:8:0;;;;71594:23;;1497:18:1;;71594:35:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;71640:10:0;:15;;;;71666:8;:14;;;;71691:9;:15;;;;71717:10;:16;;;;71744:9;:15;71770:9;:15;71796:8;:14;-1:-1:-1;71457:361:0:o;71351:92::-;18079:6;;-1:-1:-1;;;;;18079:6:0;4403:10;18226:23;18218:68;;;;-1:-1:-1;;;18218:68:0;;;;;;;:::i;:::-;71418:12:::1;:17:::0;71351:92::o;72566:85::-;18079:6;;-1:-1:-1;;;;;18079:6:0;4403:10;18226:23;18218:68;;;;-1:-1:-1;;;18218:68:0;;;;;;;:::i;:::-;72627:10:::1;:16:::0;;-1:-1:-1;;;;;;72627:16:0::1;-1:-1:-1::0;;;;;72627:16:0;;;::::1;::::0;;;::::1;::::0;;72566:85::o;18657:94::-;18079:6;;-1:-1:-1;;;;;18079:6:0;4403:10;18226:23;18218:68;;;;-1:-1:-1;;;18218:68:0;;;;;;;:::i;:::-;18722:21:::1;18740:1;18722:9;:21::i;:::-;18657:94::o:0;7036:104::-;7092:13;7125:7;7118:14;;;;;:::i;71836:352::-;71933:8;;71929:35;;-1:-1:-1;;;71929:35:0;;71953:10;71929:35;;;1524:51:1;-1:-1:-1;;;;;71933:8:0;;;;71929:23;;1497:18:1;;71929:35:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;72005:13:0;;-1:-1:-1;;;;;72005:13:0;;;71997:21;;;;;-1:-1:-1;71975:151:0;;-1:-1:-1;71975:151:0;;;-1:-1:-1;;;71975:151:0;;5868:2:1;71975:151:0;;;5850:21:1;5907:2;5887:18;;;5880:30;5946:34;5926:18;;;5919:62;6017:34;5997:18;;;5990:62;-1:-1:-1;;;6068:19:1;;;6061:47;6125:19;;71975:151:0;5666:484:1;71975:151:0;72139:41;72168:4;72174:5;72139:28;:41::i;:::-;71836:352;;:::o;11242:401::-;4403:10;11335:4;11379:25;;;:11;:25;;;;;;;;-1:-1:-1;;;;;11379:34:0;;;;;;;;;;11432:35;;;;11424:85;;;;-1:-1:-1;;;11424:85:0;;6357:2:1;11424:85:0;;;6339:21:1;6396:2;6376:18;;;6369:30;6435:34;6415:18;;;6408:62;-1:-1:-1;;;6486:18:1;;;6479:35;6531:19;;11424:85:0;6155:401:1;11424:85:0;11537:67;4403:10;11560:7;11588:15;11569:16;:34;11537:8;:67::i;:::-;-1:-1:-1;11631:4:0;;11242:401;-1:-1:-1;;;11242:401:0:o;8448:175::-;8534:4;8551:42;4403:10;8575:9;8586:6;8551:9;:42::i;68635:29::-;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;68635:29:0;;-1:-1:-1;68635:29:0;:::o;71247:96::-;18079:6;;-1:-1:-1;;;;;18079:6:0;4403:10;18226:23;18218:68;;;;-1:-1:-1;;;18218:68:0;;;;;;;:::i;:::-;71316:14:::1;:19:::0;71247:96::o;18906:192::-;18079:6;;-1:-1:-1;;;;;18079:6:0;4403:10;18226:23;18218:68;;;;-1:-1:-1;;;18218:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;18995:22:0;::::1;18987:73;;;::::0;-1:-1:-1;;;18987:73:0;;6763:2:1;18987:73:0::1;::::0;::::1;6745:21:1::0;6802:2;6782:18;;;6775:30;6841:34;6821:18;;;6814:62;-1:-1:-1;;;6892:18:1;;;6885:36;6938:19;;18987:73:0::1;6561:402:1::0;18987:73:0::1;19071:19;19081:8;19071:9;:19::i;:::-;18906:192:::0;:::o;15098:380::-;-1:-1:-1;;;;;15234:19:0;;15226:68;;;;-1:-1:-1;;;15226:68:0;;7170:2:1;15226:68:0;;;7152:21:1;7209:2;7189:18;;;7182:30;7248:34;7228:18;;;7221:62;-1:-1:-1;;;7299:18:1;;;7292:34;7343:19;;15226:68:0;6968:400:1;15226:68:0;-1:-1:-1;;;;;15313:21:0;;15305:68;;;;-1:-1:-1;;;15305:68:0;;7575:2:1;15305:68:0;;;7557:21:1;7614:2;7594:18;;;7587:30;7653:34;7633:18;;;7626:62;-1:-1:-1;;;7704:18:1;;;7697:32;7746:19;;15305:68:0;7373:398:1;15305:68:0;-1:-1:-1;;;;;15386:18:0;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;:36;;;15438:32;;1342:25:1;;;15438:32:0;;1315:18:1;15438:32:0;;;;;;;15098:380;;;:::o;72665:3610::-;-1:-1:-1;;;;;72797:18:0;;72789:68;;;;-1:-1:-1;;;72789:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;72876:16:0;;72868:64;;;;-1:-1:-1;;;72868:64:0;;;;;;;:::i;:::-;72951:6;72961:1;72951:11;72947:93;;72979:28;72995:4;73001:2;73005:1;72979:15;:28::i;:::-;72665:3610;;;:::o;72947:93::-;-1:-1:-1;;;;;73056:21:0;;73072:4;73056:21;;:44;;-1:-1:-1;;;;;;73081:19:0;;73095:4;73081:19;73056:44;73052:131;;;73117:33;73133:4;73139:2;73143:6;73117:15;:33::i;73052:131::-;73242:8;;73238:22;;;-1:-1:-1;;;73238:22:0;;;;73199:37;;-1:-1:-1;;;;;73242:8:0;;73238:20;;:22;;;;;;;;;;;;;;73242:8;73238:22;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;73309:4;8182:7;8209:18;;;;;;;;;;;73199:61;;-1:-1:-1;73199:61:0;-1:-1:-1;73291:57:0;:83;;;;-1:-1:-1;73366:8:0;;-1:-1:-1;;;73366:8:0;;;;73365:9;73291:83;:120;;;;;73396:8;;;;;;;;;-1:-1:-1;;;;;73396:8:0;-1:-1:-1;;;;;73392:17:0;;:19;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;73391:20;73291:120;:169;;;;-1:-1:-1;;;;;;73429:31:0;;;;;;:25;:31;;;;;;;;73428:32;73291:169;:201;;;;-1:-1:-1;18079:6:0;;-1:-1:-1;;;;;73477:15:0;;;18079:6;;73477:15;;73291:201;:231;;;;-1:-1:-1;18079:6:0;;-1:-1:-1;;;;;73509:13:0;;;18079:6;;73509:13;;73291:231;73273:469;;;73559:8;;73555:24;;-1:-1:-1;;;73555:24:0;;-1:-1:-1;;;;;1542:32:1;;;73555:24:0;;;1524:51:1;73559:8:0;;;;73555:18;;1497::1;;73555:24:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;73554:25;:52;;;;-1:-1:-1;73588:8:0;;73584:22;;-1:-1:-1;;;73584:22:0;;-1:-1:-1;;;;;1542:32:1;;;73584:22:0;;;1524:51:1;73588:8:0;;;;73584:18;;1497::1;;73584:22:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;73583:23;73554:52;73551:178;;;73626:8;:15;;-1:-1:-1;;;;73626:15:0;-1:-1:-1;;;73626:15:0;;;73660:18;:16;:18::i;:::-;73697:8;:16;;-1:-1:-1;;;;73697:16:0;;;73551:178;73770:8;;73798;;73794:24;;-1:-1:-1;;;73794:24:0;;-1:-1:-1;;;;;1542:32:1;;;73794:24:0;;;1524:51:1;-1:-1:-1;;;73770:8:0;;;;;73769:9;;73798:8;;;;73794:18;;1497::1;;73794:24:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:50;;;-1:-1:-1;73826:8:0;;73822:22;;-1:-1:-1;;;73822:22:0;;-1:-1:-1;;;;;1542:32:1;;;73822:22:0;;;1524:51:1;73826:8:0;;;;73822:18;;1497::1;;73822:22:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;73791:96;;;-1:-1:-1;73870:5:0;73791:96;73899:11;73925:7;73921:1540;;;73950:10;73961;73972;73983;73994;74012:8;;;;;;;;;-1:-1:-1;;;;;74012:8:0;-1:-1:-1;;;;;74008:18:0;;:20;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;73949:79;;;;;;;;;;;74047:25;:31;74073:4;-1:-1:-1;;;;;74047:31:0;-1:-1:-1;;;;;74047:31:0;;;;;;;;;;;;;;;;;;;;;;74043:1366;;;74125:8;;;;;;;;;-1:-1:-1;;;;;74125:8:0;-1:-1:-1;;;;;74121:17:0;;:19;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;74118:595;;;74168:24;74187:4;74168:14;:6;74179:2;74168:10;:14::i;:::-;:18;;:24::i;:::-;74237:9;;74164:28;;-1:-1:-1;74215:58:0;;74231:4;;-1:-1:-1;;;;;74237:9:0;74248:24;74267:4;74248:14;:6;74259:2;74248:10;:14::i;:24::-;74215:15;:58::i;:::-;74043:1366;;74118:595;74351:24;74370:4;74351:14;:6;74362:2;74351:10;:14::i;:24::-;74326;74345:4;74326:14;:6;74337:2;74326:10;:14::i;:24::-;:49;;;;:::i;:::-;74322:53;-1:-1:-1;74402:62:0;74418:4;74432;74439:24;74458:4;74439:14;:6;74450:2;74439:10;:14::i;74402:62::-;74496:38;74509:24;74528:4;74509:14;:6;74520:2;74509:10;:14::i;:24::-;74496:8;;;:12;:38::i;:::-;74487:8;:47;74559:62;74575:4;74589;74596:24;74615:4;74596:14;:6;74607:2;74596:10;:14::i;74559:62::-;74654:39;74668:24;74687:4;74668:14;:6;74679:2;74668:10;:14::i;:24::-;74654:9;;;:13;:39::i;:::-;74644:9;:49;74043:1366;;;-1:-1:-1;;;;;74761:29:0;;;;;;:25;:29;;;;;;;;74757:652;;;74847:6;74818:27;74838:6;74818:15;74828:4;-1:-1:-1;;;;;8209:18:0;8182:7;8209:18;;;;;;;;;;;;8108:127;74818:15;:19;;:27::i;:::-;:35;;74810:57;;;;-1:-1:-1;;;74810:57:0;;9724:2:1;74810:57:0;;;9706:21:1;9763:2;9743:18;;;9736:30;-1:-1:-1;;;9782:18:1;;;9775:40;9832:18;;74810:57:0;9522:334:1;74810:57:0;74942:24;74961:4;74942:14;:6;74953:2;74942:10;:14::i;:24::-;74917;74936:4;74917:14;:6;74928:2;74917:10;:14::i;:24::-;74892;74911:4;74892:14;:6;74903:2;74892:10;:14::i;:24::-;:49;;;;:::i;:::-;:74;;;;:::i;:::-;75009:9;;74888:78;;-1:-1:-1;74987:58:0;;75003:4;;-1:-1:-1;;;;;75009:9:0;75020:24;75039:4;75020:14;:6;75031:2;75020:10;:14::i;74987:58::-;75066:62;75082:4;75096;75103:24;75122:4;75103:14;:6;75114:2;75103:10;:14::i;75066:62::-;75156:38;75169:24;75188:4;75169:14;:6;75180:2;75169:10;:14::i;75156:38::-;75147:8;:47;75215:62;75231:4;75245;75252:24;75271:4;75252:14;:6;75263:2;75252:10;:14::i;75215:62::-;75306:39;75320:24;75339:4;75320:14;:6;75331:2;75320:10;:14::i;74757:652::-;75390:1;75386:5;;74757:652;75434:15;:6;75445:3;75434:10;:15::i;:::-;75425:24;;73934:1527;;;;;73921:1540;75473:33;75489:4;75495:2;75499:6;75473:15;:33::i;:::-;75523:11;;-1:-1:-1;;;;;75523:11:0;75519:49;;75550:11;:18;;-1:-1:-1;;;;;;75550:18:0;-1:-1:-1;;;;;75550:18:0;;;;;75519:49;75583:9;;-1:-1:-1;;;;;75583:9:0;75579:43;;75608:9;:14;;-1:-1:-1;;;;;;75608:14:0;-1:-1:-1;;;;;75608:14:0;;;;;75579:43;75642:8;;75672:11;;75638:46;;-1:-1:-1;;;75638:46:0;;-1:-1:-1;;;;;75672:11:0;;;75638:46;;;1524:51:1;75642:8:0;;;75638:33;;1497:18:1;;75638:46:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;75637:47;:79;;;;-1:-1:-1;75703:13:0;;75688:11;;-1:-1:-1;;;;;75688:11:0;;;75703:13;;75688:28;;75637:79;75633:106;;;75727:11;;75718:21;;-1:-1:-1;;;;;75727:11:0;75718:8;:21::i;:::-;75759:8;;75789:9;;75755:44;;-1:-1:-1;;;75755:44:0;;-1:-1:-1;;;;;75789:9:0;;;75755:44;;;1524:51:1;75759:8:0;;;75755:33;;1497:18:1;;75755:44:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;75754:45;:75;;;;-1:-1:-1;75816:13:0;;75803:9;;-1:-1:-1;;;;;75803:9:0;;;75816:13;;75803:26;;75754:75;75750:100;;;75840:9;;75831:19;;-1:-1:-1;;;;;75840:9:0;75831:8;:19::i;:::-;75863:11;:18;;-1:-1:-1;;;;;75863:18:0;;;-1:-1:-1;;;;;;75863:18:0;;;;;;;;75892:9;:14;;;;;;;;;;;;;;75930:8;;75926:24;;-1:-1:-1;;;75926:24:0;;;;;1524:51:1;;;;75930:8:0;;75926:18;;1497::1;;75926:24:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;75925:25;:52;;;;-1:-1:-1;75959:8:0;;75955:22;;-1:-1:-1;;;75955:22:0;;-1:-1:-1;;;;;1542:32:1;;;75955:22:0;;;1524:51:1;75959:8:0;;;;75955:18;;1497::1;;75955:22:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;75954:23;75925:52;75921:335;;;76019:8;;76015:28;;;-1:-1:-1;;;76015:28:0;;;;75997:15;;-1:-1:-1;;;;;76019:8:0;;76015:26;;:28;;;;;;;;;;;;;;76019:8;76015:28;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;75997:46;-1:-1:-1;;;;;;76062:21:0;;76078:4;76062:21;;;;:69;;-1:-1:-1;76087:12:0;;76116:15;;76087:25;;76104:7;76087:16;:25::i;:::-;:44;;76062:69;76058:187;;;76155:23;76163:14;;76155:7;:23::i;:::-;76212:15;76197:12;:30;76058:187;75980:276;75921:335;72778:3497;;;72665:3610;;;:::o;19106:173::-;19181:6;;;-1:-1:-1;;;;;19198:17:0;;;-1:-1:-1;;;;;;19198:17:0;;;;;;;19231:40;;19181:6;;;19198:17;19181:6;;19231:40;;19162:16;;19231:40;19151:128;19106:173;:::o;72196:358::-;-1:-1:-1;;;;;72301:31:0;;;;;;:25;:31;;;;;;:40;;;:31;;;;:40;;;72279:157;;;;-1:-1:-1;;;72279:157:0;;10063:2:1;72279:157:0;;;10045:21:1;10102:2;10082:18;;;10075:30;10141:34;10121:18;;;10114:62;10212:34;10192:18;;;10185:62;-1:-1:-1;;;10263:19:1;;;10256:34;10307:19;;72279:157:0;9861:471:1;72279:157:0;-1:-1:-1;;;;;72447:31:0;;;;;;:25;:31;;;;;;:39;;-1:-1:-1;;72447:39:0;;;;;;;;;;72506:40;;72447:39;;:31;72506:40;;;72196:358;;:::o;12133:721::-;-1:-1:-1;;;;;12273:20:0;;12265:70;;;;-1:-1:-1;;;12265:70:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;12354:23:0;;12346:71;;;;-1:-1:-1;;;12346:71:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;12514:17:0;;12490:21;12514:17;;;;;;;;;;;12550:23;;;;12542:74;;;;-1:-1:-1;;;12542:74:0;;10539:2:1;12542:74:0;;;10521:21:1;10578:2;10558:18;;;10551:30;10617:34;10597:18;;;10590:62;-1:-1:-1;;;10668:18:1;;;10661:36;10714:19;;12542:74:0;10337:402:1;12542:74:0;-1:-1:-1;;;;;12644:17:0;;;:9;:17;;;;;;;;;;;12664:22;;;12644:42;;12704:20;;;;;;;;:30;;12680:6;;12644:9;12704:30;;12680:6;;12704:30;:::i;:::-;;;;;;;;12769:9;-1:-1:-1;;;;;12752:35:0;12761:6;-1:-1:-1;;;;;12752:35:0;;12780:6;12752:35;;;;1342:25:1;;1330:2;1315:18;;1196:177;12752:35:0;;;;;;;;12254:600;12133:721;;;:::o;79024:875::-;79126:13;;-1:-1:-1;;;;;79126:13:0;79073:18;8209;;;;;;;;;;;79073;;79116:41;;79153:3;;79116:32;;79145:2;79116:28;:32::i;:41::-;79193:4;;79186:37;;-1:-1:-1;;;79186:37:0;;79217:4;79186:37;;;1524:51:1;79102:55:0;;-1:-1:-1;79170:13:0;;-1:-1:-1;;;;;79193:4:0;;;;79186:22;;1497:18:1;;79186:37:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;79237:8;;79170:53;;-1:-1:-1;79237:10:0;79234:385;;79274:8;;79263:19;;79304:1;79300:3;:5;:21;;;;;79313:8;;79309:3;:12;79300:21;79297:74;;;79352:3;79341:14;;79297:74;79421:9;;79385:47;;79402:10;;-1:-1:-1;;;;;79421:9:0;79385:16;:47::i;:::-;79447:9;;79466:4;;79447:24;;-1:-1:-1;;;79447:24:0;;-1:-1:-1;;;;;79466:4:0;;;79447:24;;;1524:51:1;79447:9:0;;;:18;;1497::1;;79447:24:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;79495:8:0;;:24;;-1:-1:-1;79495:8:0;-1:-1:-1;79508:10:0;79495:12;:24::i;:::-;79486:8;:33;79563:4;;79556:37;;-1:-1:-1;;;79556:37:0;;79587:4;79556:37;;;1524:51:1;79543:62:0;;79556:48;;79598:5;;-1:-1:-1;;;;;79563:4:0;;79556:22;;1497:18:1;;79556:37:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:48::-;79543:8;;;:12;:62::i;:::-;79534:8;:71;79234:385;79636:9;;:11;79633:255;;79674:9;;79663:20;;79705:1;79701:3;:5;:22;;;;;79714:9;;79710:3;:13;79701:22;79698:75;;;79754:3;79743:14;;79698:75;79815:10;;79787:39;;79804:10;;-1:-1:-1;;;;;79815:10:0;79787:16;:39::i;:::-;79851:9;;:25;;79865:10;79851:13;:25::i;:::-;79841:9;:35;79060:839;;;79024:875::o;22726:98::-;22784:7;22811:5;22815:1;22811;:5;:::i;:::-;22804:12;22726:98;-1:-1:-1;;;22726:98:0:o;23125:::-;23183:7;23210:5;23214:1;23210;:5;:::i;21988:98::-;22046:7;22073:5;22077:1;22073;:5;:::i;22369:98::-;22427:7;22454:5;22458:1;22454;:5;:::i;77816:368::-;-1:-1:-1;;;;;77878:21:0;;;;;;:8;:21;;;;;;;;77874:152;;;77927:13;;77920:44;;-1:-1:-1;;;77920:44:0;;-1:-1:-1;;;;;1542:32:1;;;77920:44:0;;;1524:51:1;77927:13:0;;;;77920:31;;1497:18:1;;77920:44:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;77968:1;77920:49;77916:77;;77971:22;77981:11;77971:9;:22::i;77874:152::-;78047:13;;78040:44;;-1:-1:-1;;;78040:44:0;;-1:-1:-1;;;;;1542:32:1;;;78040:44:0;;;1524:51:1;78047:13:0;;;;78040:31;;1497:18:1;;78040:44:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;78088:1;78040:49;78036:62;;77816:368;:::o;78036:62::-;78291:12;:19;;-1:-1:-1;;;;;78257:31:0;;;;;;:18;:31;;;;;:53;;;78321:30;;;;;;;;;;;;;-1:-1:-1;;;;;;78321:30:0;;;;;;-1:-1:-1;;;;;78146:21:0;;;;;:8;:21;;;;;:28;;-1:-1:-1;;78146:28:0;78170:4;78146:28;;;77816:368::o;76289:1276::-;76365:12;:19;76338:24;76401:21;;;76397:34;;76424:7;76289:1276;:::o;76397:34::-;76471:4;;76464:37;;-1:-1:-1;;;76464:37:0;;76495:4;76464:37;;;1524:51:1;76443:18:0;;-1:-1:-1;;;;;76471:4:0;;76464:22;;1497:18:1;;76464:37:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;76443:58;-1:-1:-1;76515:13:0;;;:36;;;76541:10;76532:8;;:19;76515:36;76512:73;;;76567:7;;76289:1276;:::o;76512:73::-;76599:15;76629;76647:9;76629:27;;76667:18;76702:15;76724:8;;;;;;;;;-1:-1:-1;;;;;76724:8:0;-1:-1:-1;;;;;76720:24:0;;:26;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;76702:44;;76761:12;76788:732;76805:3;76795:7;:13;:46;;;;;76825:16;76812:10;:29;76795:46;76788:732;;;76878:16;76862:12;;:32;76858:89;;76930:1;76915:12;:16;76858:89;76971:8;;77014:12;;77001;:26;;-1:-1:-1;;;;;76971:8:0;;;;76967:33;;77014:12;77001:26;;;;;;:::i;:::-;;;;;;;;;;;76967:61;;;;;;-1:-1:-1;;;;;;76967:61:0;;;-1:-1:-1;;;;;77001:26:0;;;76967:61;;;1524:51:1;1497:18;;76967:61:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;76963:394;;77048:14;77065:86;77143:7;77065:73;77085:13;;;;;;;;;-1:-1:-1;;;;;77085:13:0;-1:-1:-1;;;;;77078:31:0;;77110:12;77123;;77110:26;;;;;;;;:::i;:::-;;;;;;;;;;;77078:59;;;;;;-1:-1:-1;;;;;;77078:59:0;;;-1:-1:-1;;;;;77110:26:0;;;77078:59;;;1524:51:1;1497:18;;77078:59:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;77065:8;;;:12;:73::i;:86::-;77181:4;;77174:37;;-1:-1:-1;;;77174:37:0;;77205:4;77174:37;;;1524:51:1;77048:103:0;;-1:-1:-1;77048:103:0;;-1:-1:-1;;;;;77181:4:0;;;;77174:22;;1497:18:1;;77174:37:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:46;77170:59;;;77222:7;;;;;;;;76289:1276;:::o;77170:59::-;77247:54;77266:12;77279;;77266:26;;;;;;;;:::i;:::-;;;;;;;;;;;-1:-1:-1;;;;;77266:26:0;77294:6;77247:18;:54::i;:::-;77325:16;:4;77334:6;77325:8;:16::i;:::-;77320:21;;77029:328;76963:394;77383:35;77395:22;77407:9;77395:7;;:11;:22::i;:::-;77383:7;;:11;:35::i;:::-;77373:45;;77443:9;77467:12;:14;;77433:19;;-1:-1:-1;77467:12:0;:14;;;:::i;:::-;;;;;;77496:12;;;;;:::i;:::-;;;;76788:732;;;77539:8;;:18;;77552:4;77539:12;:18::i;:::-;77530:8;:27;-1:-1:-1;;;;;;;;76289:1276:0:o;80525:486::-;80626:16;;;80640:1;80626:16;;;;;;;;80602:21;;80626:16;;;;;;;;;;-1:-1:-1;80626:16:0;80602:40;;80671:4;80653;80658:1;80653:7;;;;;;;;:::i;:::-;-1:-1:-1;;;;;80653:23:0;;;:7;;;;;;;;;:23;80697:4;;80687:7;;80697:4;;;80687;;80697;;80687:7;;;;;;:::i;:::-;-1:-1:-1;;;;;80687:14:0;;;:7;;;;;;;;;:14;80746:15;;80714:62;;80731:4;;80746:15;80764:11;80714:8;:62::i;:::-;80815:15;;:188;;-1:-1:-1;;;80815:188:0;;-1:-1:-1;;;;;80815:15:0;;;;:69;;:188;;80899:11;;80815:15;;80941:4;;80960:2;;80977:15;;80815:188;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;78367:137;78426:30;78444:11;78426:17;:30::i;:::-;-1:-1:-1;;;;;78467:21:0;78491:5;78467:21;;;:8;:21;;;;;:29;;-1:-1:-1;;78467:29:0;;;78367:137::o;77630:178::-;77722:4;;77715:41;;-1:-1:-1;;;77715:41:0;;-1:-1:-1;;;;;12853:32:1;;;77715:41:0;;;12835:51:1;12902:18;;;12895:34;;;77722:4:0;;;;77715:21;;12808:18:1;;77715:41:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;77780:11;-1:-1:-1;;;;;77772:28:0;;77793:6;77772:28;;;;1342:25:1;;1330:2;1315:18;;1196:177;77772:28:0;;;;;;;;77630:178;;:::o;78512:292::-;78628:12;78641:19;;:23;;78663:1;;78641:23;:::i;:::-;78628:37;;;;;;;;:::i;:::-;;;;;;;;;;;;;-1:-1:-1;;;;;78593:31:0;;;;;:18;:31;;;;;;;;78580:12;:45;;78628:37;;;;;78580:12;:45;;;;;;:::i;:::-;;;;;;;;;;;;;:85;;-1:-1:-1;;;;;;78580:85:0;-1:-1:-1;;;;;78580:85:0;;;;;;78736:31;;;;;:18;:31;;;;;;;;78695:12;78708:19;;78736:31;;:18;78580:45;78708:23;;-1:-1:-1;;78708:23:0;:::i;:::-;78695:37;;;;;;;;:::i;:::-;;;;;;;;;;;;;-1:-1:-1;;;;;78695:37:0;78676:57;;;;;;;;;;;;:91;78778:12;:18;;;;;;;:::i;:::-;;;;;;;;;;-1:-1:-1;;78778:18:0;;;;;-1:-1:-1;;;;;;78778:18:0;;;;;;-1:-1:-1;78512:292:0:o;14:548:1:-;126:4;155:2;184;173:9;166:21;216:6;210:13;259:6;254:2;243:9;239:18;232:34;284:1;294:140;308:6;305:1;302:13;294:140;;;403:14;;;399:23;;393:30;369:17;;;388:2;365:26;358:66;323:10;;294:140;;;298:3;483:1;478:2;469:6;458:9;454:22;450:31;443:42;553:2;546;542:7;537:2;529:6;525:15;521:29;510:9;506:45;502:54;494:62;;;;14:548;;;;:::o;567:173::-;635:20;;-1:-1:-1;;;;;684:31:1;;674:42;;664:70;;730:1;727;720:12;664:70;567:173;;;:::o;745:254::-;813:6;821;874:2;862:9;853:7;849:23;845:32;842:52;;;890:1;887;880:12;842:52;913:29;932:9;913:29;:::i;:::-;903:39;989:2;974:18;;;;961:32;;-1:-1:-1;;;745:254:1:o;1821:328::-;1898:6;1906;1914;1967:2;1955:9;1946:7;1942:23;1938:32;1935:52;;;1983:1;1980;1973:12;1935:52;2006:29;2025:9;2006:29;:::i;:::-;1996:39;;2054:38;2088:2;2077:9;2073:18;2054:38;:::i;:::-;2044:48;;2139:2;2128:9;2124:18;2111:32;2101:42;;1821:328;;;;;:::o;2343:592::-;2456:6;2464;2472;2480;2488;2496;2504;2557:3;2545:9;2536:7;2532:23;2528:33;2525:53;;;2574:1;2571;2564:12;2525:53;-1:-1:-1;;2597:23:1;;;2667:2;2652:18;;2639:32;;-1:-1:-1;2718:2:1;2703:18;;2690:32;;2769:2;2754:18;;2741:32;;-1:-1:-1;2820:3:1;2805:19;;2792:33;;-1:-1:-1;2872:3:1;2857:19;;2844:33;;-1:-1:-1;2924:3:1;2909:19;2896:33;;-1:-1:-1;2343:592:1;-1:-1:-1;2343:592:1:o;2940:180::-;2999:6;3052:2;3040:9;3031:7;3027:23;3023:32;3020:52;;;3068:1;3065;3058:12;3020:52;-1:-1:-1;3091:23:1;;2940:180;-1:-1:-1;2940:180:1:o;3125:186::-;3184:6;3237:2;3225:9;3216:7;3212:23;3208:32;3205:52;;;3253:1;3250;3243:12;3205:52;3276:29;3295:9;3276:29;:::i;3316:118::-;3402:5;3395:13;3388:21;3381:5;3378:32;3368:60;;3424:1;3421;3414:12;3439:315;3504:6;3512;3565:2;3553:9;3544:7;3540:23;3536:32;3533:52;;;3581:1;3578;3571:12;3533:52;3604:29;3623:9;3604:29;:::i;:::-;3594:39;;3683:2;3672:9;3668:18;3655:32;3696:28;3718:5;3696:28;:::i;:::-;3743:5;3733:15;;;3439:315;;;;;:::o;3759:260::-;3827:6;3835;3888:2;3876:9;3867:7;3863:23;3859:32;3856:52;;;3904:1;3901;3894:12;3856:52;3927:29;3946:9;3927:29;:::i;:::-;3917:39;;3975:38;4009:2;3998:9;3994:18;3975:38;:::i;:::-;3965:48;;3759:260;;;;;:::o;4249:380::-;4328:1;4324:12;;;;4371;;;4392:61;;4446:4;4438:6;4434:17;4424:27;;4392:61;4499:2;4491:6;4488:14;4468:18;4465:38;4462:161;;4545:10;4540:3;4536:20;4533:1;4526:31;4580:4;4577:1;4570:15;4608:4;4605:1;4598:15;4462:161;;4249:380;;;:::o;5043:127::-;5104:10;5099:3;5095:20;5092:1;5085:31;5135:4;5132:1;5125:15;5159:4;5156:1;5149:15;5175:125;5240:9;;;5261:10;;;5258:36;;;5274:18;;:::i;5305:356::-;5507:2;5489:21;;;5526:18;;;5519:30;5585:34;5580:2;5565:18;;5558:62;5652:2;5637:18;;5305:356::o;7776:401::-;7978:2;7960:21;;;8017:2;7997:18;;;7990:30;8056:34;8051:2;8036:18;;8029:62;-1:-1:-1;;;8122:2:1;8107:18;;8100:35;8167:3;8152:19;;7776:401::o;8182:399::-;8384:2;8366:21;;;8423:2;8403:18;;;8396:30;8462:34;8457:2;8442:18;;8435:62;-1:-1:-1;;;8528:2:1;8513:18;;8506:33;8571:3;8556:19;;8182:399::o;8586:184::-;8656:6;8709:2;8697:9;8688:7;8684:23;8680:32;8677:52;;;8725:1;8722;8715:12;8677:52;-1:-1:-1;8748:16:1;;8586:184;-1:-1:-1;8586:184:1:o;8775:245::-;8842:6;8895:2;8883:9;8874:7;8870:23;8866:32;8863:52;;;8911:1;8908;8901:12;8863:52;8943:9;8937:16;8962:28;8984:5;8962:28;:::i;9025:492::-;9140:6;9148;9156;9164;9172;9180;9233:3;9221:9;9212:7;9208:23;9204:33;9201:53;;;9250:1;9247;9240:12;9201:53;9279:9;9273:16;9263:26;;9329:2;9318:9;9314:18;9308:25;9298:35;;9373:2;9362:9;9358:18;9352:25;9342:35;;9417:2;9406:9;9402:18;9396:25;9386:35;;9461:3;9450:9;9446:19;9440:26;9430:36;;9506:3;9495:9;9491:19;9485:26;9475:36;;9025:492;;;;;;;;:::o;10744:168::-;10817:9;;;10848;;10865:15;;;10859:22;;10845:37;10835:71;;10886:18;;:::i;10917:217::-;10957:1;10983;10973:132;;11027:10;11022:3;11018:20;11015:1;11008:31;11062:4;11059:1;11052:15;11090:4;11087:1;11080:15;10973:132;-1:-1:-1;11119:9:1;;10917:217::o;11139:128::-;11206:9;;;11227:11;;;11224:37;;;11241:18;;:::i;11272:127::-;11333:10;11328:3;11324:20;11321:1;11314:31;11364:4;11361:1;11354:15;11388:4;11385:1;11378:15;11404:135;11443:3;11464:17;;;11461:43;;11484:18;;:::i;:::-;-1:-1:-1;11531:1:1;11520:13;;11404:135::o;11676:980::-;11938:4;11986:3;11975:9;11971:19;12017:6;12006:9;11999:25;12043:2;12081:6;12076:2;12065:9;12061:18;12054:34;12124:3;12119:2;12108:9;12104:18;12097:31;12148:6;12183;12177:13;12214:6;12206;12199:22;12252:3;12241:9;12237:19;12230:26;;12291:2;12283:6;12279:15;12265:29;;12312:1;12322:195;12336:6;12333:1;12330:13;12322:195;;;12401:13;;-1:-1:-1;;;;;12397:39:1;12385:52;;12492:15;;;;12457:12;;;;12433:1;12351:9;12322:195;;;-1:-1:-1;;;;;;;12573:32:1;;;;12568:2;12553:18;;12546:60;-1:-1:-1;;;12637:3:1;12622:19;12615:35;12534:3;11676:980;-1:-1:-1;;;11676:980:1:o;12940:127::-;13001:10;12996:3;12992:20;12989:1;12982:31;13032:4;13029:1;13022:15;13056:4;13053:1;13046:15

Swarm Source

ipfs://a884e65c9802a7ab9cdf6414ad402c7cb5434f8ff37e96b61699398ed362d402

A token is a representation of an on-chain or off-chain asset. The token page shows information such as price, total supply, holders, transfers and social links. Learn more about this page in our Knowledge Base.

Tools & Services