Token

Potato Farm ($POTATO)

Feature Tip: Add private address tag to any address under My Name Tag !

ERC-20

Overview

Max Total Supply

86,872,562.177234611888036665 $POTATO

Holders

Market

Onchain Market Cap

$0.00

Circulating Supply Market Cap

Other Info

Token Contract (WITH 18 Decimals)

0xd2eedb0a785a64f478b2741ba4e81426c6b2fd5d

Filtered by Token Holder

0xd898eE3d8476C90aEC8fEf49A4038F06A078F126

Balance

7,585.010847932283611744 $POTATO

Value

$0.00

0xd898ee3d8476c90aec8fef49a4038f06a078f126

Click here to update the token information / general information

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

DebaseToken

Compiler Version

v0.8.14+commit.80d49f37

Optimization Enabled:

Yes with 200 runs

Other Settings:

default evmVersion, MIT license

Contract Source Code (Solidity)

IDE

/**
 *Submitted for verification at Etherscan.io on 2023-10-13
*/

// Potato Farm Socials:
// Twitter: https://twitter.com/PotatoFarmETH
// Telegram: https://t.me/PotatoFarmETH
// Dapp: https://potatoes.farm/
// Docs: https://docs.potatoes.farm/

// Sources flattened with hardhat v2.7.1 https://hardhat.org
// SPDX-License-Identifier: MIT
// File @uniswap/v2-periphery/contracts/interfaces/[email protected]

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,
        uint amountADesired,
        uint amountBDesired,
        uint amountAMin,
        uint amountBMin,
        address to,
        uint deadline
    ) external returns (uint amountA, uint amountB, uint liquidity);
    function addLiquidityETH(
        address token,
        uint amountTokenDesired,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline
    ) external payable returns (uint amountToken, uint amountETH, uint liquidity);
    function removeLiquidity(
        address tokenA,
        address tokenB,
        uint liquidity,
        uint amountAMin,
        uint amountBMin,
        address to,
        uint deadline
    ) external returns (uint amountA, uint amountB);
    function removeLiquidityETH(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline
    ) external returns (uint amountToken, uint amountETH);
    function removeLiquidityWithPermit(
        address tokenA,
        address tokenB,
        uint liquidity,
        uint amountAMin,
        uint amountBMin,
        address to,
        uint deadline,
        bool approveMax, uint8 v, bytes32 r, bytes32 s
    ) external returns (uint amountA, uint amountB);
    function removeLiquidityETHWithPermit(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline,
        bool approveMax, uint8 v, bytes32 r, bytes32 s
    ) external returns (uint amountToken, uint amountETH);
    function swapExactTokensForTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external returns (uint[] memory amounts);
    function swapTokensForExactTokens(
        uint amountOut,
        uint amountInMax,
        address[] calldata path,
        address to,
        uint deadline
    ) external returns (uint[] memory amounts);
    function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
        external
        payable
        returns (uint[] memory amounts);
    function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
        external
        returns (uint[] memory amounts);
    function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
        external
        returns (uint[] memory amounts);
    function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
        external
        payable
        returns (uint[] memory amounts);

    function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
    function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
    function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
    function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
    function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}


// File @uniswap/v2-periphery/contracts/interfaces/[email protected]

pragma solidity >=0.6.2;

interface IUniswapV2Router02 is IUniswapV2Router01 {
    function removeLiquidityETHSupportingFeeOnTransferTokens(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline
    ) external returns (uint amountETH);
    function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline,
        bool approveMax, uint8 v, bytes32 r, bytes32 s
    ) external returns (uint amountETH);

    function swapExactTokensForTokensSupportingFeeOnTransferTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external;
    function swapExactETHForTokensSupportingFeeOnTransferTokens(
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external payable;
    function swapExactTokensForETHSupportingFeeOnTransferTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external;
}


// File @uniswap/v2-core/contracts/interfaces/[email protected]

pragma solidity >=0.5.0;

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

    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(uint) external view returns (address pair);
    function allPairsLength() external view returns (uint);

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

    function setFeeTo(address) external;
    function setFeeToSetter(address) external;
}


// File @uniswap/v2-core/contracts/interfaces/[email protected]

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;
}


// File @openzeppelin/contracts/utils/[email protected]


// OpenZeppelin Contracts v4.4.1 (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;
    }
}


// File @openzeppelin/contracts/access/[email protected]


// OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)

pragma solidity ^0.8.0;

/**
 * @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() {
        _transferOwnership(_msgSender());
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        _checkOwner();
        _;
    }

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

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view virtual {
        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 {
        _transferOwnership(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");
        _transferOwnership(newOwner);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Internal function without access restriction.
     */
    function _transferOwnership(address newOwner) internal virtual {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}


// File @openzeppelin/contracts/token/ERC20/[email protected]


// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);

    /**
     * @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 `to`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address to, 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 `from` to `to` 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 from,
        address to,
        uint256 amount
    ) external returns (bool);
}


// File @openzeppelin/contracts/token/ERC20/extensions/[email protected]


// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol)

pragma solidity ^0.8.0;

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


// File @openzeppelin/contracts/token/ERC20/[email protected]


// OpenZeppelin Contracts (last updated v4.8.0) (token/ERC20/ERC20.sol)

pragma solidity ^0.8.0;



/**
 * @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.openzeppelin.com/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:
     *
     * - `to` cannot be the zero address.
     * - the caller must have a balance of at least `amount`.
     */
    function transfer(address to, uint256 amount) public virtual override returns (bool) {
        address owner = _msgSender();
        _transfer(owner, to, 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}.
     *
     * NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on
     * `transferFrom`. This is semantically equivalent to an infinite approval.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function approve(address spender, uint256 amount) public virtual override returns (bool) {
        address owner = _msgSender();
        _approve(owner, 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}.
     *
     * NOTE: Does not update the allowance if the current allowance
     * is the maximum `uint256`.
     *
     * Requirements:
     *
     * - `from` and `to` cannot be the zero address.
     * - `from` must have a balance of at least `amount`.
     * - the caller must have allowance for ``from``'s tokens of at least
     * `amount`.
     */
    function transferFrom(
        address from,
        address to,
        uint256 amount
    ) public virtual override returns (bool) {
        address spender = _msgSender();
        _spendAllowance(from, spender, amount);
        _transfer(from, to, 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) {
        address owner = _msgSender();
        _approve(owner, spender, allowance(owner, 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) {
        address owner = _msgSender();
        uint256 currentAllowance = allowance(owner, spender);
        require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
        unchecked {
            _approve(owner, spender, currentAllowance - subtractedValue);
        }

        return true;
    }

    /**
     * @dev Moves `amount` of tokens from `from` to `to`.
     *
     * 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:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `from` must have a balance of at least `amount`.
     */
    function _transfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual {
        require(from != address(0), "ERC20: transfer from the zero address");
        require(to != address(0), "ERC20: transfer to the zero address");

        _beforeTokenTransfer(from, to, amount);

        uint256 fromBalance = _balances[from];
        require(fromBalance >= amount, "ERC20: transfer amount exceeds balance");
        unchecked {
            _balances[from] = fromBalance - amount;
            // Overflow not possible: the sum of all balances is capped by totalSupply, and the sum is preserved by
            // decrementing then incrementing.
            _balances[to] += amount;
        }

        emit Transfer(from, to, amount);

        _afterTokenTransfer(from, to, 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;
        unchecked {
            // Overflow not possible: balance + amount is at most totalSupply + amount, which is checked above.
            _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;
            // Overflow not possible: amount <= accountBalance <= totalSupply.
            _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 Updates `owner` s allowance for `spender` based on spent `amount`.
     *
     * Does not update the allowance amount in case of infinite allowance.
     * Revert if not enough allowance is available.
     *
     * Might emit an {Approval} event.
     */
    function _spendAllowance(
        address owner,
        address spender,
        uint256 amount
    ) internal virtual {
        uint256 currentAllowance = allowance(owner, spender);
        if (currentAllowance != type(uint256).max) {
            require(currentAllowance >= amount, "ERC20: insufficient allowance");
            unchecked {
                _approve(owner, spender, currentAllowance - 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 {}
}


// File @openzeppelin/contracts/token/ERC20/extensions/[email protected]


// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC20/extensions/ERC20Burnable.sol)

pragma solidity ^0.8.0;


/**
 * @dev Extension of {ERC20} that allows token holders to destroy both their own
 * tokens and those that they have an allowance for, in a way that can be
 * recognized off-chain (via event analysis).
 */
abstract contract ERC20Burnable is Context, ERC20 {
    /**
     * @dev Destroys `amount` tokens from the caller.
     *
     * See {ERC20-_burn}.
     */
    function burn(uint256 amount) public virtual {
        _burn(_msgSender(), amount);
    }

    /**
     * @dev Destroys `amount` tokens from `account`, deducting from the caller's
     * allowance.
     *
     * See {ERC20-_burn} and {ERC20-allowance}.
     *
     * Requirements:
     *
     * - the caller must have allowance for ``accounts``'s tokens of at least
     * `amount`.
     */
    function burnFrom(address account, uint256 amount) public virtual {
        _spendAllowance(account, _msgSender(), amount);
        _burn(account, amount);
    }
}


// File @openzeppelin/contracts/access/[email protected]


// OpenZeppelin Contracts v4.4.1 (access/IAccessControl.sol)

pragma solidity ^0.8.0;

/**
 * @dev External interface of AccessControl declared to support ERC165 detection.
 */
interface IAccessControl {
    /**
     * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`
     *
     * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite
     * {RoleAdminChanged} not being emitted signaling this.
     *
     * _Available since v3.1._
     */
    event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);

    /**
     * @dev Emitted when `account` is granted `role`.
     *
     * `sender` is the account that originated the contract call, an admin role
     * bearer except when using {AccessControl-_setupRole}.
     */
    event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);

    /**
     * @dev Emitted when `account` is revoked `role`.
     *
     * `sender` is the account that originated the contract call:
     *   - if using `revokeRole`, it is the admin role bearer
     *   - if using `renounceRole`, it is the role bearer (i.e. `account`)
     */
    event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);

    /**
     * @dev Returns `true` if `account` has been granted `role`.
     */
    function hasRole(bytes32 role, address account) external view returns (bool);

    /**
     * @dev Returns the admin role that controls `role`. See {grantRole} and
     * {revokeRole}.
     *
     * To change a role's admin, use {AccessControl-_setRoleAdmin}.
     */
    function getRoleAdmin(bytes32 role) external view returns (bytes32);

    /**
     * @dev Grants `role` to `account`.
     *
     * If `account` had not been already granted `role`, emits a {RoleGranted}
     * event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     */
    function grantRole(bytes32 role, address account) external;

    /**
     * @dev Revokes `role` from `account`.
     *
     * If `account` had been granted `role`, emits a {RoleRevoked} event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     */
    function revokeRole(bytes32 role, address account) external;

    /**
     * @dev Revokes `role` from the calling account.
     *
     * Roles are often managed via {grantRole} and {revokeRole}: this function's
     * purpose is to provide a mechanism for accounts to lose their privileges
     * if they are compromised (such as when a trusted device is misplaced).
     *
     * If the calling account had been granted `role`, emits a {RoleRevoked}
     * event.
     *
     * Requirements:
     *
     * - the caller must be `account`.
     */
    function renounceRole(bytes32 role, address account) external;
}


// File @openzeppelin/contracts/access/[email protected]


// OpenZeppelin Contracts v4.4.1 (access/IAccessControlEnumerable.sol)

pragma solidity ^0.8.0;

/**
 * @dev External interface of AccessControlEnumerable declared to support ERC165 detection.
 */
interface IAccessControlEnumerable is IAccessControl {
    /**
     * @dev Returns one of the accounts that have `role`. `index` must be a
     * value between 0 and {getRoleMemberCount}, non-inclusive.
     *
     * Role bearers are not sorted in any particular way, and their ordering may
     * change at any point.
     *
     * WARNING: When using {getRoleMember} and {getRoleMemberCount}, make sure
     * you perform all queries on the same block. See the following
     * https://forum.openzeppelin.com/t/iterating-over-elements-on-enumerableset-in-openzeppelin-contracts/2296[forum post]
     * for more information.
     */
    function getRoleMember(bytes32 role, uint256 index) external view returns (address);

    /**
     * @dev Returns the number of accounts that have `role`. Can be used
     * together with {getRoleMember} to enumerate all bearers of a role.
     */
    function getRoleMemberCount(bytes32 role) external view returns (uint256);
}


// File @openzeppelin/contracts/utils/math/[email protected]


// OpenZeppelin Contracts (last updated v4.8.0) (utils/math/Math.sol)

pragma solidity ^0.8.0;

/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    enum Rounding {
        Down, // Toward negative infinity
        Up, // Toward infinity
        Zero // Toward zero
    }

    /**
     * @dev Returns the largest of two numbers.
     */
    function max(uint256 a, uint256 b) internal pure returns (uint256) {
        return a > b ? a : b;
    }

    /**
     * @dev Returns the smallest of two numbers.
     */
    function min(uint256 a, uint256 b) internal pure returns (uint256) {
        return a < b ? a : b;
    }

    /**
     * @dev Returns the average of two numbers. The result is rounded towards
     * zero.
     */
    function average(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b) / 2 can overflow.
        return (a & b) + (a ^ b) / 2;
    }

    /**
     * @dev Returns the ceiling of the division of two numbers.
     *
     * This differs from standard division with `/` in that it rounds up instead
     * of rounding down.
     */
    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b - 1) / b can overflow on addition, so we distribute.
        return a == 0 ? 0 : (a - 1) / b + 1;
    }

    /**
     * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0
     * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv)
     * with further edits by Uniswap Labs also under MIT license.
     */
    function mulDiv(
        uint256 x,
        uint256 y,
        uint256 denominator
    ) internal pure returns (uint256 result) {
        unchecked {
            // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use
            // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256
            // variables such that product = prod1 * 2^256 + prod0.
            uint256 prod0; // Least significant 256 bits of the product
            uint256 prod1; // Most significant 256 bits of the product
            assembly {
                let mm := mulmod(x, y, not(0))
                prod0 := mul(x, y)
                prod1 := sub(sub(mm, prod0), lt(mm, prod0))
            }

            // Handle non-overflow cases, 256 by 256 division.
            if (prod1 == 0) {
                return prod0 / denominator;
            }

            // Make sure the result is less than 2^256. Also prevents denominator == 0.
            require(denominator > prod1);

            ///////////////////////////////////////////////
            // 512 by 256 division.
            ///////////////////////////////////////////////

            // Make division exact by subtracting the remainder from [prod1 prod0].
            uint256 remainder;
            assembly {
                // Compute remainder using mulmod.
                remainder := mulmod(x, y, denominator)

                // Subtract 256 bit number from 512 bit number.
                prod1 := sub(prod1, gt(remainder, prod0))
                prod0 := sub(prod0, remainder)
            }

            // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1.
            // See https://cs.stackexchange.com/q/138556/92363.

            // Does not overflow because the denominator cannot be zero at this stage in the function.
            uint256 twos = denominator & (~denominator + 1);
            assembly {
                // Divide denominator by twos.
                denominator := div(denominator, twos)

                // Divide [prod1 prod0] by twos.
                prod0 := div(prod0, twos)

                // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.
                twos := add(div(sub(0, twos), twos), 1)
            }

            // Shift in bits from prod1 into prod0.
            prod0 |= prod1 * twos;

            // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such
            // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for
            // four bits. That is, denominator * inv = 1 mod 2^4.
            uint256 inverse = (3 * denominator) ^ 2;

            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works
            // in modular arithmetic, doubling the correct bits in each step.
            inverse *= 2 - denominator * inverse; // inverse mod 2^8
            inverse *= 2 - denominator * inverse; // inverse mod 2^16
            inverse *= 2 - denominator * inverse; // inverse mod 2^32
            inverse *= 2 - denominator * inverse; // inverse mod 2^64
            inverse *= 2 - denominator * inverse; // inverse mod 2^128
            inverse *= 2 - denominator * inverse; // inverse mod 2^256

            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.
            // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is
            // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1
            // is no longer required.
            result = prod0 * inverse;
            return result;
        }
    }

    /**
     * @notice Calculates x * y / denominator with full precision, following the selected rounding direction.
     */
    function mulDiv(
        uint256 x,
        uint256 y,
        uint256 denominator,
        Rounding rounding
    ) internal pure returns (uint256) {
        uint256 result = mulDiv(x, y, denominator);
        if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {
            result += 1;
        }
        return result;
    }

    /**
     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down.
     *
     * Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11).
     */
    function sqrt(uint256 a) internal pure returns (uint256) {
        if (a == 0) {
            return 0;
        }

        // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.
        //
        // We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have
        // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.
        //
        // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`
        // Ôćĺ `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`
        // Ôćĺ `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`
        //
        // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.
        uint256 result = 1 << (log2(a) >> 1);

        // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,
        // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at
        // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision
        // into the expected uint128 result.
        unchecked {
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            return min(result, a / result);
        }
    }

    /**
     * @notice Calculates sqrt(a), following the selected rounding direction.
     */
    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = sqrt(a);
            return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 2, rounded down, of a positive value.
     * Returns 0 if given 0.
     */
    function log2(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 128;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 64;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 32;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 16;
            }
            if (value >> 8 > 0) {
                value >>= 8;
                result += 8;
            }
            if (value >> 4 > 0) {
                value >>= 4;
                result += 4;
            }
            if (value >> 2 > 0) {
                value >>= 2;
                result += 2;
            }
            if (value >> 1 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log2(value);
            return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 10, rounded down, of a positive value.
     * Returns 0 if given 0.
     */
    function log10(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >= 10**64) {
                value /= 10**64;
                result += 64;
            }
            if (value >= 10**32) {
                value /= 10**32;
                result += 32;
            }
            if (value >= 10**16) {
                value /= 10**16;
                result += 16;
            }
            if (value >= 10**8) {
                value /= 10**8;
                result += 8;
            }
            if (value >= 10**4) {
                value /= 10**4;
                result += 4;
            }
            if (value >= 10**2) {
                value /= 10**2;
                result += 2;
            }
            if (value >= 10**1) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log10(value);
            return result + (rounding == Rounding.Up && 10**result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 256, rounded down, of a positive value.
     * Returns 0 if given 0.
     *
     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.
     */
    function log256(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 16;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 8;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 4;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 2;
            }
            if (value >> 8 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log256(value);
            return result + (rounding == Rounding.Up && 1 << (result * 8) < value ? 1 : 0);
        }
    }
}


// File @openzeppelin/contracts/utils/[email protected]


// OpenZeppelin Contracts (last updated v4.8.0) (utils/Strings.sol)

pragma solidity ^0.8.0;

/**
 * @dev String operations.
 */
library Strings {
    bytes16 private constant _SYMBOLS = "0123456789abcdef";
    uint8 private constant _ADDRESS_LENGTH = 20;

    /**
     * @dev Converts a `uint256` to its ASCII `string` decimal representation.
     */
    function toString(uint256 value) internal pure returns (string memory) {
        unchecked {
            uint256 length = Math.log10(value) + 1;
            string memory buffer = new string(length);
            uint256 ptr;
            /// @solidity memory-safe-assembly
            assembly {
                ptr := add(buffer, add(32, length))
            }
            while (true) {
                ptr--;
                /// @solidity memory-safe-assembly
                assembly {
                    mstore8(ptr, byte(mod(value, 10), _SYMBOLS))
                }
                value /= 10;
                if (value == 0) break;
            }
            return buffer;
        }
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
     */
    function toHexString(uint256 value) internal pure returns (string memory) {
        unchecked {
            return toHexString(value, Math.log256(value) + 1);
        }
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
     */
    function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
        bytes memory buffer = new bytes(2 * length + 2);
        buffer[0] = "0";
        buffer[1] = "x";
        for (uint256 i = 2 * length + 1; i > 1; --i) {
            buffer[i] = _SYMBOLS[value & 0xf];
            value >>= 4;
        }
        require(value == 0, "Strings: hex length insufficient");
        return string(buffer);
    }

    /**
     * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation.
     */
    function toHexString(address addr) internal pure returns (string memory) {
        return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);
    }
}


// File @openzeppelin/contracts/utils/introspection/[email protected]


// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC165 standard, as defined in the
 * https://eips.ethereum.org/EIPS/eip-165[EIP].
 *
 * Implementers can declare support of contract interfaces, which can then be
 * queried by others ({ERC165Checker}).
 *
 * For an implementation, see {ERC165}.
 */
interface IERC165 {
    /**
     * @dev Returns true if this contract implements the interface defined by
     * `interfaceId`. See the corresponding
     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
     * to learn more about how these ids are created.
     *
     * This function call must use less than 30 000 gas.
     */
    function supportsInterface(bytes4 interfaceId) external view returns (bool);
}


// File @openzeppelin/contracts/utils/introspection/[email protected]


// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol)

pragma solidity ^0.8.0;

/**
 * @dev Implementation of the {IERC165} interface.
 *
 * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check
 * for the additional interface id that will be supported. For example:
 *
 * ```solidity
 * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
 *     return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);
 * }
 * ```
 *
 * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.
 */
abstract contract ERC165 is IERC165 {
    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
        return interfaceId == type(IERC165).interfaceId;
    }
}


// File @openzeppelin/contracts/access/[email protected]


// OpenZeppelin Contracts (last updated v4.8.0) (access/AccessControl.sol)

pragma solidity ^0.8.0;




/**
 * @dev Contract module that allows children to implement role-based access
 * control mechanisms. This is a lightweight version that doesn't allow enumerating role
 * members except through off-chain means by accessing the contract event logs. Some
 * applications may benefit from on-chain enumerability, for those cases see
 * {AccessControlEnumerable}.
 *
 * Roles are referred to by their `bytes32` identifier. These should be exposed
 * in the external API and be unique. The best way to achieve this is by
 * using `public constant` hash digests:
 *
 * ```
 * bytes32 public constant MY_ROLE = keccak256("MY_ROLE");
 * ```
 *
 * Roles can be used to represent a set of permissions. To restrict access to a
 * function call, use {hasRole}:
 *
 * ```
 * function foo() public {
 *     require(hasRole(MY_ROLE, msg.sender));
 *     ...
 * }
 * ```
 *
 * Roles can be granted and revoked dynamically via the {grantRole} and
 * {revokeRole} functions. Each role has an associated admin role, and only
 * accounts that have a role's admin role can call {grantRole} and {revokeRole}.
 *
 * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means
 * that only accounts with this role will be able to grant or revoke other
 * roles. More complex role relationships can be created by using
 * {_setRoleAdmin}.
 *
 * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to
 * grant and revoke this role. Extra precautions should be taken to secure
 * accounts that have been granted it.
 */
abstract contract AccessControl is Context, IAccessControl, ERC165 {
    struct RoleData {
        mapping(address => bool) members;
        bytes32 adminRole;
    }

    mapping(bytes32 => RoleData) private _roles;

    bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;

    /**
     * @dev Modifier that checks that an account has a specific role. Reverts
     * with a standardized message including the required role.
     *
     * The format of the revert reason is given by the following regular expression:
     *
     *  /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/
     *
     * _Available since v4.1._
     */
    modifier onlyRole(bytes32 role) {
        _checkRole(role);
        _;
    }

    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
        return interfaceId == type(IAccessControl).interfaceId || super.supportsInterface(interfaceId);
    }

    /**
     * @dev Returns `true` if `account` has been granted `role`.
     */
    function hasRole(bytes32 role, address account) public view virtual override returns (bool) {
        return _roles[role].members[account];
    }

    /**
     * @dev Revert with a standard message if `_msgSender()` is missing `role`.
     * Overriding this function changes the behavior of the {onlyRole} modifier.
     *
     * Format of the revert message is described in {_checkRole}.
     *
     * _Available since v4.6._
     */
    function _checkRole(bytes32 role) internal view virtual {
        _checkRole(role, _msgSender());
    }

    /**
     * @dev Revert with a standard message if `account` is missing `role`.
     *
     * The format of the revert reason is given by the following regular expression:
     *
     *  /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/
     */
    function _checkRole(bytes32 role, address account) internal view virtual {
        if (!hasRole(role, account)) {
            revert(
                string(
                    abi.encodePacked(
                        "AccessControl: account ",
                        Strings.toHexString(account),
                        " is missing role ",
                        Strings.toHexString(uint256(role), 32)
                    )
                )
            );
        }
    }

    /**
     * @dev Returns the admin role that controls `role`. See {grantRole} and
     * {revokeRole}.
     *
     * To change a role's admin, use {_setRoleAdmin}.
     */
    function getRoleAdmin(bytes32 role) public view virtual override returns (bytes32) {
        return _roles[role].adminRole;
    }

    /**
     * @dev Grants `role` to `account`.
     *
     * If `account` had not been already granted `role`, emits a {RoleGranted}
     * event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     *
     * May emit a {RoleGranted} event.
     */
    function grantRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {
        _grantRole(role, account);
    }

    /**
     * @dev Revokes `role` from `account`.
     *
     * If `account` had been granted `role`, emits a {RoleRevoked} event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     *
     * May emit a {RoleRevoked} event.
     */
    function revokeRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {
        _revokeRole(role, account);
    }

    /**
     * @dev Revokes `role` from the calling account.
     *
     * Roles are often managed via {grantRole} and {revokeRole}: this function's
     * purpose is to provide a mechanism for accounts to lose their privileges
     * if they are compromised (such as when a trusted device is misplaced).
     *
     * If the calling account had been revoked `role`, emits a {RoleRevoked}
     * event.
     *
     * Requirements:
     *
     * - the caller must be `account`.
     *
     * May emit a {RoleRevoked} event.
     */
    function renounceRole(bytes32 role, address account) public virtual override {
        require(account == _msgSender(), "AccessControl: can only renounce roles for self");

        _revokeRole(role, account);
    }

    /**
     * @dev Grants `role` to `account`.
     *
     * If `account` had not been already granted `role`, emits a {RoleGranted}
     * event. Note that unlike {grantRole}, this function doesn't perform any
     * checks on the calling account.
     *
     * May emit a {RoleGranted} event.
     *
     * [WARNING]
     * ====
     * This function should only be called from the constructor when setting
     * up the initial roles for the system.
     *
     * Using this function in any other way is effectively circumventing the admin
     * system imposed by {AccessControl}.
     * ====
     *
     * NOTE: This function is deprecated in favor of {_grantRole}.
     */
    function _setupRole(bytes32 role, address account) internal virtual {
        _grantRole(role, account);
    }

    /**
     * @dev Sets `adminRole` as ``role``'s admin role.
     *
     * Emits a {RoleAdminChanged} event.
     */
    function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {
        bytes32 previousAdminRole = getRoleAdmin(role);
        _roles[role].adminRole = adminRole;
        emit RoleAdminChanged(role, previousAdminRole, adminRole);
    }

    /**
     * @dev Grants `role` to `account`.
     *
     * Internal function without access restriction.
     *
     * May emit a {RoleGranted} event.
     */
    function _grantRole(bytes32 role, address account) internal virtual {
        if (!hasRole(role, account)) {
            _roles[role].members[account] = true;
            emit RoleGranted(role, account, _msgSender());
        }
    }

    /**
     * @dev Revokes `role` from `account`.
     *
     * Internal function without access restriction.
     *
     * May emit a {RoleRevoked} event.
     */
    function _revokeRole(bytes32 role, address account) internal virtual {
        if (hasRole(role, account)) {
            _roles[role].members[account] = false;
            emit RoleRevoked(role, account, _msgSender());
        }
    }
}


// File @openzeppelin/contracts/utils/structs/[email protected]


// OpenZeppelin Contracts (last updated v4.8.0) (utils/structs/EnumerableSet.sol)
// This file was procedurally generated from scripts/generate/templates/EnumerableSet.js.

pragma solidity ^0.8.0;

/**
 * @dev Library for managing
 * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive
 * types.
 *
 * Sets have the following properties:
 *
 * - Elements are added, removed, and checked for existence in constant time
 * (O(1)).
 * - Elements are enumerated in O(n). No guarantees are made on the ordering.
 *
 * ```
 * contract Example {
 *     // Add the library methods
 *     using EnumerableSet for EnumerableSet.AddressSet;
 *
 *     // Declare a set state variable
 *     EnumerableSet.AddressSet private mySet;
 * }
 * ```
 *
 * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)
 * and `uint256` (`UintSet`) are supported.
 *
 * [WARNING]
 * ====
 * Trying to delete such a structure from storage will likely result in data corruption, rendering the structure
 * unusable.
 * See https://github.com/ethereum/solidity/pull/11843[ethereum/solidity#11843] for more info.
 *
 * In order to clean an EnumerableSet, you can either remove all elements one by one or create a fresh instance using an
 * array of EnumerableSet.
 * ====
 */
library EnumerableSet {
    // To implement this library for multiple types with as little code
    // repetition as possible, we write it in terms of a generic Set type with
    // bytes32 values.
    // The Set implementation uses private functions, and user-facing
    // implementations (such as AddressSet) are just wrappers around the
    // underlying Set.
    // This means that we can only create new EnumerableSets for types that fit
    // in bytes32.

    struct Set {
        // Storage of set values
        bytes32[] _values;
        // Position of the value in the `values` array, plus 1 because index 0
        // means a value is not in the set.
        mapping(bytes32 => uint256) _indexes;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function _add(Set storage set, bytes32 value) private returns (bool) {
        if (!_contains(set, value)) {
            set._values.push(value);
            // The value is stored at length-1, but we add 1 to all indexes
            // and use 0 as a sentinel value
            set._indexes[value] = set._values.length;
            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function _remove(Set storage set, bytes32 value) private returns (bool) {
        // We read and store the value's index to prevent multiple reads from the same storage slot
        uint256 valueIndex = set._indexes[value];

        if (valueIndex != 0) {
            // Equivalent to contains(set, value)
            // To delete an element from the _values array in O(1), we swap the element to delete with the last one in
            // the array, and then remove the last element (sometimes called as 'swap and pop').
            // This modifies the order of the array, as noted in {at}.

            uint256 toDeleteIndex = valueIndex - 1;
            uint256 lastIndex = set._values.length - 1;

            if (lastIndex != toDeleteIndex) {
                bytes32 lastValue = set._values[lastIndex];

                // Move the last value to the index where the value to delete is
                set._values[toDeleteIndex] = lastValue;
                // Update the index for the moved value
                set._indexes[lastValue] = valueIndex; // Replace lastValue's index to valueIndex
            }

            // Delete the slot where the moved value was stored
            set._values.pop();

            // Delete the index for the deleted slot
            delete set._indexes[value];

            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function _contains(Set storage set, bytes32 value) private view returns (bool) {
        return set._indexes[value] != 0;
    }

    /**
     * @dev Returns the number of values on the set. O(1).
     */
    function _length(Set storage set) private view returns (uint256) {
        return set._values.length;
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function _at(Set storage set, uint256 index) private view returns (bytes32) {
        return set._values[index];
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function _values(Set storage set) private view returns (bytes32[] memory) {
        return set._values;
    }

    // Bytes32Set

    struct Bytes32Set {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {
        return _add(set._inner, value);
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {
        return _remove(set._inner, value);
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {
        return _contains(set._inner, value);
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(Bytes32Set storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {
        return _at(set._inner, index);
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(Bytes32Set storage set) internal view returns (bytes32[] memory) {
        bytes32[] memory store = _values(set._inner);
        bytes32[] memory result;

        /// @solidity memory-safe-assembly
        assembly {
            result := store
        }

        return result;
    }

    // AddressSet

    struct AddressSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(AddressSet storage set, address value) internal returns (bool) {
        return _add(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(AddressSet storage set, address value) internal returns (bool) {
        return _remove(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(AddressSet storage set, address value) internal view returns (bool) {
        return _contains(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(AddressSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(AddressSet storage set, uint256 index) internal view returns (address) {
        return address(uint160(uint256(_at(set._inner, index))));
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(AddressSet storage set) internal view returns (address[] memory) {
        bytes32[] memory store = _values(set._inner);
        address[] memory result;

        /// @solidity memory-safe-assembly
        assembly {
            result := store
        }

        return result;
    }

    // UintSet

    struct UintSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(UintSet storage set, uint256 value) internal returns (bool) {
        return _add(set._inner, bytes32(value));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(UintSet storage set, uint256 value) internal returns (bool) {
        return _remove(set._inner, bytes32(value));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(UintSet storage set, uint256 value) internal view returns (bool) {
        return _contains(set._inner, bytes32(value));
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(UintSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(UintSet storage set, uint256 index) internal view returns (uint256) {
        return uint256(_at(set._inner, index));
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(UintSet storage set) internal view returns (uint256[] memory) {
        bytes32[] memory store = _values(set._inner);
        uint256[] memory result;

        /// @solidity memory-safe-assembly
        assembly {
            result := store
        }

        return result;
    }
}


// File @openzeppelin/contracts/access/[email protected]


// OpenZeppelin Contracts (last updated v4.5.0) (access/AccessControlEnumerable.sol)

pragma solidity ^0.8.0;



/**
 * @dev Extension of {AccessControl} that allows enumerating the members of each role.
 */
abstract contract AccessControlEnumerable is IAccessControlEnumerable, AccessControl {
    using EnumerableSet for EnumerableSet.AddressSet;

    mapping(bytes32 => EnumerableSet.AddressSet) private _roleMembers;

    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
        return interfaceId == type(IAccessControlEnumerable).interfaceId || super.supportsInterface(interfaceId);
    }

    /**
     * @dev Returns one of the accounts that have `role`. `index` must be a
     * value between 0 and {getRoleMemberCount}, non-inclusive.
     *
     * Role bearers are not sorted in any particular way, and their ordering may
     * change at any point.
     *
     * WARNING: When using {getRoleMember} and {getRoleMemberCount}, make sure
     * you perform all queries on the same block. See the following
     * https://forum.openzeppelin.com/t/iterating-over-elements-on-enumerableset-in-openzeppelin-contracts/2296[forum post]
     * for more information.
     */
    function getRoleMember(bytes32 role, uint256 index) public view virtual override returns (address) {
        return _roleMembers[role].at(index);
    }

    /**
     * @dev Returns the number of accounts that have `role`. Can be used
     * together with {getRoleMember} to enumerate all bearers of a role.
     */
    function getRoleMemberCount(bytes32 role) public view virtual override returns (uint256) {
        return _roleMembers[role].length();
    }

    /**
     * @dev Overload {_grantRole} to track enumerable memberships
     */
    function _grantRole(bytes32 role, address account) internal virtual override {
        super._grantRole(role, account);
        _roleMembers[role].add(account);
    }

    /**
     * @dev Overload {_revokeRole} to track enumerable memberships
     */
    function _revokeRole(bytes32 role, address account) internal virtual override {
        super._revokeRole(role, account);
        _roleMembers[role].remove(account);
    }
}


// File contracts/BaseToken.sol


pragma solidity =0.8.14;
/**
 * @notice An abstract token contract that provides core functionalities, that can be further extended.
 * @author iHux3
 */
abstract contract BaseToken is 
    ERC20Burnable, 
    Ownable,
    AccessControlEnumerable
{
    uint32 constant public HUNDRED_PERCENT = 1e6;
    address constant internal ETH = address(0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE);
    uint32 constant internal MAX_TOTAL_FEE = 22e4;
    uint32 constant internal DEFAULT_MIN_BALANCE_PERCENTAGE = 1e2;
    
    bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
    
    struct BaseParameters {
        string name;
        string symbol;
        IUniswapV2Router02 router;
        IERC20 pairToken;
        uint32[] feePercentages;
        address teamWallet;
        uint initSupply;
    }

    IUniswapV2Router02 public router;
    IERC20 public pairToken;
    IUniswapV2Pair public pair;
    uint32[] public feePercentages; // team, farm rewards
    address public teamWallet;
    address public farmAddress;
    
    uint32 public minBalancePercentage;

    mapping(address => bool) public isExcludedFromFees;

    bool internal _processingFee;
    bool internal _totalSupplyInitialized;

    event InitTotalSupply(
        uint totalSupply
    );
    
    event ExcludeFromFees(
        address targetAddress, 
        bool state
    );

    event SetMinBalancePercentage(
        uint minBalancePercentage
    );

    event SetTeamWallet(
        address teamWallet
    );
    
    event SetFarmAddress(
        address farmAddress
    );

    /**
     * @notice Initializes the BaseToken contract.
     * @param baseParameters The parameters to initialize the contract with.
     */
    constructor(
        BaseParameters memory baseParameters
    ) ERC20(baseParameters.name, baseParameters.symbol) {
        router = baseParameters.router;
        pairToken = address(baseParameters.pairToken) == ETH ? 
            IERC20(router.WETH()) : baseParameters.pairToken;

        pair = IUniswapV2Pair(IUniswapV2Factory(
            baseParameters.router.factory()).createPair(address(this), address(pairToken)
        ));

        feePercentages = baseParameters.feePercentages;
        require(feePercentages.length >= 2, "invalid fees length");
        require(
            getTotalFeePercentage() <= MAX_TOTAL_FEE, 
            "total fees greater than the max fee"
        );

        require(baseParameters.teamWallet != address(0));
        teamWallet = baseParameters.teamWallet;

        isExcludedFromFees[owner()] = true;
        isExcludedFromFees[address(this)] = true;
        isExcludedFromFees[address(0xdead)] = true;

        minBalancePercentage = DEFAULT_MIN_BALANCE_PERCENTAGE;

        _approve(address(this), address(router), 2 ** 256 - 1);

        _initTotalSupply(baseParameters.initSupply);

        _setupRole(DEFAULT_ADMIN_ROLE, _msgSender());
        _setupRole(MINTER_ROLE, _msgSender());
    }

    // ================ OWNER FUNCTIONS ================ //

    /**
     * @notice Transfers ownership of the contract to a new owner.
     * @dev Overrides parent function by swapping `isExcludedFromFees`.
     * 
     * @param newOwner The address of the new owner.
     *
     * Requirements:
     * - The caller must be the current owner.
     *
     * Emits an {OwnershipTransferred} event.
     */
    function transferOwnership(
        address newOwner
    ) public override onlyOwner {
        isExcludedFromFees[owner()] = false;
        super.transferOwnership(newOwner);
        isExcludedFromFees[newOwner] = true;
    }

    /**
     * @notice Allows the contract owner to exclude or include an address from fees on transfer.
     * 
     * @param targetAddress The address to exclude or include.
     * @param state A boolean indicating whether the address should be excluded (true) or included (false).
     * 
     * Requirements:
     * - The caller must be the contract owner.
     * 
     * Emits an {ExcludeFromFees} event.
     */
    function excludeFromFees(
        address targetAddress, 
        bool state
    ) external onlyOwner {
        isExcludedFromFees[targetAddress] = state;
        emit ExcludeFromFees(targetAddress, state);
    }

    /**
     * @notice Sets the farm address that receives tx fees.
     * @param _farmAddress The farm address.
     */
    function setFarmAddress(address _farmAddress) external onlyOwner {
        farmAddress = _farmAddress;
        isExcludedFromFees[_farmAddress] = true;
        emit SetFarmAddress(_farmAddress);
    }

    /**
     * @notice Allows to mint tokens if the sender has the minter role.
     * @param account The account to mint tokens for
     * @param amount Amount of tokens to mint
     */
    function mint(address account, uint amount) external returns (bool) {
        require(hasRole(MINTER_ROLE, msg.sender), "unauthorized"); 
        _mint(account, amount);
        return true;
    }

    // ================ TEAM WALLET FUNCTIONS ================ //

    /**
     * @notice Allows to change team wallet to set a new team wallet address.
     * @param newTeamWallet The address of the new team wallet
     */
    function setTeamWallet(
        address newTeamWallet
    ) external {
        require(msg.sender == teamWallet || msg.sender == owner(), "unauthorized");
        require(newTeamWallet != address(0), "zero address");
        teamWallet = newTeamWallet;
        emit SetTeamWallet(newTeamWallet);
    }

    /**
     * @notice Allows the team wallet to swap to eth manually rather than waiting for minimum balance.
     */
    function swapTokensToETHManual() external {
        require(msg.sender == teamWallet || msg.sender == owner(), "unauthorized");
        _swapTokensForETH();
    }

    /**
     * @notice Sets new percentage for required minimum balance for swapping team tokens to ETH.
     * @param newMinBalancePercentage the new percentage
     */
    function setMinBalancePercentage(uint32 newMinBalancePercentage) external {
        require(msg.sender == teamWallet || msg.sender == owner(), "unauthorized");
        require(newMinBalancePercentage <= HUNDRED_PERCENT, "too high");

        minBalancePercentage = newMinBalancePercentage;
        emit SetMinBalancePercentage(newMinBalancePercentage);
    }

    // ================ INTERNAL FUNCTIONS ================ //

    /**
     * @notice Transfers tokens from one address to another address.
     * @param from The address to transfer tokens from
     * @param to The address to transfer tokens to
     * @param amount The amount of tokens to transfer
     * 
     * Requirements:
     * - from and to cannot be the zero address
     * - The from address must have a balance of at least amount
     * - The contract must have sufficient allowance from from to spend amount 
     * 
     * Emits a {Transfer} event.
     */
    function _transfer(
        address from, 
        address to, 
        uint amount
    ) internal virtual override {
        (uint fee,) = _processFee(from, to, amount);
        amount -= fee;
        super._transfer(from, to, amount);
    }

    /**
     * @notice Processes the fees for the transaction and returns the total fee and a flag indicating if the fee was taken.
     * 
     * @param from The address from which the tokens are transferred
     * @param to The address to which the tokens are transferred
     * @param amount The amount of tokens being transferred
     * 
     * @return fee The total fee amount
     * @return tookFee A boolean indicating if the fee was taken
     * 
     * Emits a {Transfer} event if any fee is transferred to another address.
     */
    function _processFee(
        address from, 
        address to, 
        uint amount
    ) internal virtual returns (
        uint fee, 
        bool tookFee
    ) {
        if (
            isExcludedFromFees[from] || 
            isExcludedFromFees[to] || 
            _processingFee
        ) {
            return (0, false);
        }

        _processingFee = true;
        
        uint teamAmount = _applyPercentage(amount, feePercentages[0]);
        if (teamAmount > 0 && teamWallet != address(0)) {
            fee += teamAmount;
            _transfer(from, address(this), teamAmount);
        }

        uint farmRewardAmount = _applyPercentage(amount, feePercentages[1]);
        if (farmRewardAmount > 0 && farmAddress != address(0)) {
            fee += farmRewardAmount;
            _transfer(from, farmAddress, farmRewardAmount);
        }

        uint minBalance = _applyPercentage(totalSupply(), minBalancePercentage);
        if (
            balanceOf(address(this)) >= minBalance &&
            from != address(pair)
        ) {
            _swapTokensForETH();
        }

        _processingFee = false;

        return (fee, true);
    }

    /**
     * @notice Swaps accumulated team fee tokens for ETH tokens.
     */
    function _swapTokensForETH() internal {
        uint swapAmount = balanceOf(address(this));
        if (swapAmount == 0) return;

        address[] memory swapPath = new address[](2);
        swapPath[0] = address(this);
        swapPath[1] = router.WETH();

        try 
            router.swapExactTokensForETH(
                swapAmount,
                0,
                swapPath,
                teamWallet,
                block.timestamp
            )
        {} catch {}
    }

    /**
     * @notice Initializes total supply of the token.
     * @param initSupply The initial total supply.
     */
    function _initTotalSupply(uint initSupply) internal virtual {
        require(!_totalSupplyInitialized, "initialized already");
        require(initSupply > 0, "0 total supply");

        _mint(owner(), initSupply);
        emit InitTotalSupply(initSupply);

        _totalSupplyInitialized = true;
    }

    // ================ VIEW FUNCTIONS ================ //

    /**
     * @notice Returns the total fee percentage applied to transactions.
     * @return totalFeePercentage The total fee percentage.
     */
    function getTotalFeePercentage() public view returns (
        uint totalFeePercentage
    ) {
        for (uint i; i < feePercentages.length; i++) {
            totalFeePercentage += feePercentages[i];
        }
    }

    /**
     * @notice This function is used to calculate the result of applying a percentage to a given value.
     * 
     * @param value The value to which the percentage will be applied.
     * @param percentage The percentage to apply to the value.
     * 
     * @return The result of applying the percentage to the value.
    */
    function _applyPercentage(
        uint value, 
        uint percentage
    ) internal pure returns (uint) {
        return value * percentage / HUNDRED_PERCENT;
    }
}


// File contracts/DebaseProtect.sol


pragma solidity =0.8.14;
/**
 * @notice An abstract contract for `DebaseToken` which adds functions to protect tokens from debasing.
 * @author iHux3
 */
abstract contract DebaseProtect {
    struct Depositor {
        uint amount;
        uint lockEndsAt;
    }

    uint public lockDuration;
    uint public totalDeposited;
    mapping(address => bool) public isExcludedFromDebase;

    mapping(address => Depositor) public depositors;

    event Deposit(address indexed depositor, uint amount);
    event Withdraw(address indexed depositor, uint amount);

    function _burn(address account, uint amount) internal virtual;
    function _mint(address account, uint amount) internal virtual;

    /**
     * @notice Allows users to deposit tokens and burn them in order to protect them from debasing.
     * 
     * @param amount The amount of tokens to deposit and burn.
     * 
     * @dev The deposited tokens are burned, reducing the total supply of tokens in circulation.
     * @dev The user's deposit amount is recorded, and the tokens are locked for a period of time, after which the user can withdraw them.
     * 
     * Requirements:
     * - The amount must be greater than 0.
     * - The user must not be excluded from debase in order to make a deposit.
     * 
     * @dev Emits a {Deposit} event with the user's address and deposit amount.
     */
    function deposit(uint amount) external {
        require(amount > 0, "zero amount");
        require(!isExcludedFromDebase[msg.sender], "excluded from debase");

        Depositor storage depositor = depositors[msg.sender];
        depositor.lockEndsAt = block.timestamp + lockDuration;
        _burn(msg.sender, amount);

        totalDeposited += amount;
        depositor.amount += amount;
        emit Deposit(msg.sender, amount);
    }

    /**
    * @notice Allows users to withdraw their protected deposited tokens by minting them.
    * 
    * @param amount The amount of tokens to withdraw.
    * 
    * Requirements:
    * - amount must be greater than 0.
    * - The depositor must have unlocked their deposit.
    * - The depositor must have enough deposited tokens.
    * 
    * Emits a {Withdraw} event.
    */
    function withdraw(uint amount) external {
        require(amount > 0, "zero amount");

        Depositor storage depositor = depositors[msg.sender];
        require(depositor.lockEndsAt <= block.timestamp, "locked");
        require(depositor.amount >= amount, "not enough amount");

        depositor.lockEndsAt = block.timestamp + lockDuration;
        depositor.amount -= amount;
        totalDeposited -= amount;
        _mint(address(msg.sender), amount);

        emit Withdraw(msg.sender, amount);
    }
}


// File contracts/DebaseToken.sol


pragma solidity =0.8.14;
/**
 * @dev `DebaseToken` extends `BaseToken` by adding decreasing (debasing) wallet balances.
 * @author iHux3
 */
contract DebaseToken is 
    BaseToken
{

    uint64 public constant BASE = 1e18;

    struct Parameters {
        uint32 startTime;
        uint32 debasePeriod;
        uint64 debaseRate;
    }

    uint private _underlyingTotalSupply;
    uint private _totalSupplyExcluded;
    mapping(address => uint) private _balances;

    uint32 public startTime;
    uint32 public debasePeriod;
    uint64 public debaseRate;
    uint64 public debaseFactor; 
    uint public lastDebaseTimestamp;

    mapping(address => bool) public isExcludedFromDebase;

    event ExcludeFromDebase(
        address addr, 
        bool excluded
    );

    event Debase(
        uint periodsPassed,
        uint debaseFactor
    );

    modifier withDebase() {
        _;
        debase();
    }

    /**
     * @notice Initializes the contract with the given parameters.
     * 
     * @param baseParameters The base token parameters.
     * @param parameters The debase token parameters.
    */
    constructor(
        BaseParameters memory baseParameters,
        Parameters memory parameters
    ) BaseToken(baseParameters) {
        require(parameters.startTime >= block.timestamp, "starts in past");
        require(parameters.debasePeriod > 0, "debase period zero");
        require(parameters.debaseRate > 0 && parameters.debaseRate < BASE / 2, "debase rate range");

        startTime = parameters.startTime;
        debasePeriod = parameters.debasePeriod;
        debaseRate = parameters.debaseRate;

        lastDebaseTimestamp = startTime;
        debaseFactor = BASE;

        isExcludedFromDebase[address(this)] = true;
        isExcludedFromDebase[address(pair)] = true;
    }

    // ================ EXTERNAL FUNCTIONS ================ //

    /**
     * @notice This function debases the token based on the `debaseRate` and `debasePeriod`.
     * 
     * @dev Decreases debaseFactor, resulting in a decrease of all wallets' non-underlying balances.
     * @dev If `debaseFactor` equals 1 or the current timestamp is less than `startTime`, this function will not execute.
     * @dev This function calculates the number of periods that have passed since the last time debase was called,
     * and updates debaseFactor accordingly. It limits the maximum number of periods to 1000.
     * 
     * Emits a {Debase} event with the number of periods passed and the updated `debaseFactor`.
     */
    function debase() public {
        uint currentTimestamp = block.timestamp;
        if (currentTimestamp < startTime || debaseFactor == 1) {
            return;
        }

        uint periodsPassed = (currentTimestamp - lastDebaseTimestamp) / debasePeriod;
        if (periodsPassed > 1000) {
            periodsPassed = 1000;
        }

        uint totalSupplyBefore = totalSupply();

        if (periodsPassed > 0) {
            uint64 _debaseFactor = debaseFactor;
            uint64 _debaseRate = debaseRate;

            for (uint i = 0; i < periodsPassed; i++) {
                _debaseFactor = uint64(uint(_debaseFactor) * (BASE - _debaseRate) / BASE);
            }

            debaseFactor = _debaseFactor;
            lastDebaseTimestamp += periodsPassed * debasePeriod;
            
            if (debaseFactor == 0) debaseFactor = 1;

            emit Debase(
                periodsPassed,
                debaseFactor
            );
        }

        uint totalSupplyAfter = totalSupply();

        uint debasedTokens = totalSupplyBefore - totalSupplyAfter;

        if (debasedTokens > 1) {
            _mint(farmAddress, debasedTokens / 2); // mint 50% as rewards for stakers
        }   
    }

    // ================ INTERNAL FUNCTIONS ================ //

    /**
     * @notice Transfer tokens from one address to another.
     * 
     * @param from The address to transfer tokens from
     * @param to The address to transfer tokens to
     * @param amount The amount of tokens to be transferred
     * 
     * @dev This function is internal and will only be called from within the contract.
     * It processes the transfer fees, converts the amount and fees to underlying, checks the balance of the from address,
     * updates the balances and total supply based on whether the addresses are excluded from debase or not.
     * 
     * Emits a {Transfer} event.
     */
    function _transfer(
        address from, 
        address to, 
        uint amount
    ) internal override withDebase {
        require(from != address(0), "ERC20: transfer from the zero address");
        require(to != address(0), "ERC20: transfer to the zero address");

        (uint fee, ) = _processFee(from, to, amount);

        uint underlyingAmount = convertToUnderlying(amount);
        uint underlyingFee = convertToUnderlying(fee);

        amount -= fee;
        underlyingAmount -= underlyingFee;

        uint fromBalance = _balances[from];
        if (!isExcludedFromDebase[from]) {
            require(
                fromBalance >= underlyingAmount, 
                "ERC20: transfer amount exceeds balance"
            );
            _balances[from] -= underlyingAmount;
        } else {
            require(
                fromBalance >= amount, 
                "ERC20: transfer amount exceeds balance"
            );
            _balances[from] -= amount;
            _totalSupplyExcluded -= amount;
            _underlyingTotalSupply += underlyingAmount;
        }

        if (!isExcludedFromDebase[to]) {
            _balances[to] += underlyingAmount;
        } else {
            _balances[to] += amount;
            _totalSupplyExcluded += amount;
            _underlyingTotalSupply -= underlyingAmount;
        }

        emit Transfer(from, to, amount);
    }

    /**
     * @notice Destroys amount tokens from account, reducing the total supply of the token.
     * 
     * @dev Decreases underlying balances (or non-underlying if the account is excluded from debase).
     * 
     * @param account The address of the account to burn tokens from.
     * @param amount The amount of tokens to burn.
     * 
     * Requirements:
     * - The account cannot be the zero address.
     * - The account must have at least amount tokens.
     * 
     * Emits a {Transfer} event with to set to the zero address.
     */
    function _burn(address account, uint amount) internal override withDebase {
        require(account != address(0), "ERC20: burn from the zero address");

        uint underlyingAmount = convertToUnderlying(amount);
        uint accountBalance = _balances[account];

        if (!isExcludedFromDebase[account]) {
            require(accountBalance >= underlyingAmount, "ERC20: burn amount exceeds balance");
            _balances[account] -= underlyingAmount;
            _underlyingTotalSupply -= underlyingAmount;
        } else {
            require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
            _balances[account] -= amount;
            _totalSupplyExcluded -= amount;
        }

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

    /** 
     * @notice Mints new tokens to the specified account.
     * 
     * @dev Increases the balance of account and the underlying total supply by underlyingAmount.
     * 
     * @param account The account to receive the minted tokens.
     * @param amount The amount of tokens to mint.
     * 
     * Requirements:
     * - The account cannot be the zero address.
     * - The account must not be excluded from debase.
     * 
     * Emits a {Transfer} event with from address as the zero address and to address as the account address.
     */
    function _mint(address account, uint amount) internal override withDebase {
        require(account != address(0), "ERC20: burn from the zero address");

        uint underlyingAmount = convertToUnderlying(amount);

        if (!isExcludedFromDebase[account]) {
            _balances[account] += underlyingAmount;
            _underlyingTotalSupply += underlyingAmount;
        } else {
            _balances[account] += amount;
            _totalSupplyExcluded += amount;
        }

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

     /**
     * @notice Initializes total supply of the token.
     * @param initSupply The initial total supply.
     */
    function _initTotalSupply(
        uint initSupply
    ) internal override {
        require(!_totalSupplyInitialized, "initialized already");
        require(initSupply > 0, "0 total supply");
        
        _underlyingTotalSupply = initSupply;
        _balances[owner()] = _underlyingTotalSupply;

        emit Transfer(address(0), owner(), initSupply);
        emit InitTotalSupply(initSupply);

        _totalSupplyInitialized = true;
    }
    
    // ================ VIEW FUNCTIONS ================ //

    /**
     * @notice Converts given amount of tokens to underlying asset units.
     * @param amount Amount of tokens to convert.
     * @return The equivalent amount of underlying asset units.
     */
    function convertToUnderlying(uint amount) public view returns (uint) {
        return amount * BASE / debaseFactor;
    }

    /**
     * @notice Converts a given amount of underlying token to its corresponding amount of token based on the current debase factor.
     * @param underlyingAmount The amount of underlying token to convert to token.
     * @return The corresponding amount of token based on the current debase factor.
     */
    function convertFromUnderlying(uint underlyingAmount) public view returns (uint) {
        return underlyingAmount * debaseFactor / BASE;
    }

    /**
     * @notice Get the balance of an address.
     * 
     * @dev If the address is excluded from debase, their balance is stored directly in the _balances mapping.
     * Otherwise, the balance is converted from underlying units to token units using the current debase factor.
     * 
     * @param account The address to get the balance for.
     * 
     * @return The balance of the address.
     */
    function balanceOf(
        address account
    ) public view override returns (uint) {
        if (isExcludedFromDebase[account]) {
            return _balances[account];
        }

        return convertFromUnderlying(_balances[account]);
    }

    /**
     * @notice Gets the token total supply.
     * @dev Gets total supply by converting underlying total supply and adding debase-excluded total supply.
     * @return The token total supply.
     */
    function totalSupply() public view override returns (uint) {
        return convertFromUnderlying(_underlyingTotalSupply) + _totalSupplyExcluded;
    }
}

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

[{"inputs":[{"components":[{"internalType":"string","name":"name","type":"string"},{"internalType":"string","name":"symbol","type":"string"},{"internalType":"contract IUniswapV2Router02","name":"router","type":"address"},{"internalType":"contract IERC20","name":"pairToken","type":"address"},{"internalType":"uint32[]","name":"feePercentages","type":"uint32[]"},{"internalType":"address","name":"teamWallet","type":"address"},{"internalType":"uint256","name":"initSupply","type":"uint256"}],"internalType":"struct BaseToken.BaseParameters","name":"baseParameters","type":"tuple"},{"components":[{"internalType":"uint32","name":"startTime","type":"uint32"},{"internalType":"uint32","name":"debasePeriod","type":"uint32"},{"internalType":"uint64","name":"debaseRate","type":"uint64"}],"internalType":"struct DebaseToken.Parameters","name":"parameters","type":"tuple"}],"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":false,"internalType":"uint256","name":"periodsPassed","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"debaseFactor","type":"uint256"}],"name":"Debase","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"addr","type":"address"},{"indexed":false,"internalType":"bool","name":"excluded","type":"bool"}],"name":"ExcludeFromDebase","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"targetAddress","type":"address"},{"indexed":false,"internalType":"bool","name":"state","type":"bool"}],"name":"ExcludeFromFees","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"totalSupply","type":"uint256"}],"name":"InitTotalSupply","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":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"bytes32","name":"previousAdminRole","type":"bytes32"},{"indexed":true,"internalType":"bytes32","name":"newAdminRole","type":"bytes32"}],"name":"RoleAdminChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"RoleGranted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"RoleRevoked","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"farmAddress","type":"address"}],"name":"SetFarmAddress","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"minBalancePercentage","type":"uint256"}],"name":"SetMinBalancePercentage","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"teamWallet","type":"address"}],"name":"SetTeamWallet","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"BASE","outputs":[{"internalType":"uint64","name":"","type":"uint64"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"DEFAULT_ADMIN_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"HUNDRED_PERCENT","outputs":[{"internalType":"uint32","name":"","type":"uint32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MINTER_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"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":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"burnFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"underlyingAmount","type":"uint256"}],"name":"convertFromUnderlying","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"convertToUnderlying","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"debase","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"debaseFactor","outputs":[{"internalType":"uint64","name":"","type":"uint64"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"debasePeriod","outputs":[{"internalType":"uint32","name":"","type":"uint32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"debaseRate","outputs":[{"internalType":"uint64","name":"","type":"uint64"}],"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":"targetAddress","type":"address"},{"internalType":"bool","name":"state","type":"bool"}],"name":"excludeFromFees","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"farmAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"feePercentages","outputs":[{"internalType":"uint32","name":"","type":"uint32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"}],"name":"getRoleAdmin","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"uint256","name":"index","type":"uint256"}],"name":"getRoleMember","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"}],"name":"getRoleMemberCount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getTotalFeePercentage","outputs":[{"internalType":"uint256","name":"totalFeePercentage","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"grantRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"hasRole","outputs":[{"internalType":"bool","name":"","type":"bool"}],"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":[{"internalType":"address","name":"","type":"address"}],"name":"isExcludedFromDebase","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"isExcludedFromFees","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lastDebaseTimestamp","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"minBalancePercentage","outputs":[{"internalType":"uint32","name":"","type":"uint32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"mint","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":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pair","outputs":[{"internalType":"contract IUniswapV2Pair","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pairToken","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"renounceRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"revokeRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"router","outputs":[{"internalType":"contract IUniswapV2Router02","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_farmAddress","type":"address"}],"name":"setFarmAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint32","name":"newMinBalancePercentage","type":"uint32"}],"name":"setMinBalancePercentage","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newTeamWallet","type":"address"}],"name":"setTeamWallet","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"startTime","outputs":[{"internalType":"uint32","name":"","type":"uint32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"swapTokensToETHManual","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"teamWallet","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","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"}]

Contract Creation Code

Decompile Bytecode Switch to Opcodes View

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

Deployed Bytecode

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

Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)

000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000652985a00000000000000000000000000000000000000000000000000000000000000e100000000000000000000000000000000000000000000000000005420d5a44800000000000000000000000000000000000000000000000000000000000000000e000000000000000000000000000000000000000000000000000000000000001200000000000000000000000007a250d5630b4cf539739df2c5dacb4c659f2488d000000000000000000000000eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee000000000000000000000000000000000000000000000000000000000000016000000000000000000000000074ea61d3b671dcd3ee7a758cf9c873049937a22400000000000000000000000000000000000000000052b7d2dcc80cd2e4000000000000000000000000000000000000000000000000000000000000000000000b506f7461746f204661726d000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000724504f5441544f0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000004e200000000000000000000000000000000000000000000000000000000000002710

-----Decoded View---------------
Arg [0] : baseParameters (tuple): System.Collections.Generic.List`1[Nethereum.ABI.FunctionEncoding.ParameterOutput]
Arg [1] : parameters (tuple): System.Collections.Generic.List`1[Nethereum.ABI.FunctionEncoding.ParameterOutput]

-----Encoded View---------------
18 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000000000080
Arg [1] : 00000000000000000000000000000000000000000000000000000000652985a0
Arg [2] : 0000000000000000000000000000000000000000000000000000000000000e10
Arg [3] : 0000000000000000000000000000000000000000000000000005420d5a448000
Arg [4] : 00000000000000000000000000000000000000000000000000000000000000e0
Arg [5] : 0000000000000000000000000000000000000000000000000000000000000120
Arg [6] : 0000000000000000000000007a250d5630b4cf539739df2c5dacb4c659f2488d
Arg [7] : 000000000000000000000000eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee
Arg [8] : 0000000000000000000000000000000000000000000000000000000000000160
Arg [9] : 00000000000000000000000074ea61d3b671dcd3ee7a758cf9c873049937a224
Arg [10] : 00000000000000000000000000000000000000000052b7d2dcc80cd2e4000000
Arg [11] : 000000000000000000000000000000000000000000000000000000000000000b
Arg [12] : 506f7461746f204661726d000000000000000000000000000000000000000000
Arg [13] : 0000000000000000000000000000000000000000000000000000000000000007
Arg [14] : 24504f5441544f00000000000000000000000000000000000000000000000000
Arg [15] : 0000000000000000000000000000000000000000000000000000000000000002
Arg [16] : 0000000000000000000000000000000000000000000000000000000000004e20
Arg [17] : 0000000000000000000000000000000000000000000000000000000000002710

Deployed Bytecode Sourcemap

90146:10886:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;74158:214;;;;;;:::i;:::-;;:::i;:::-;;;470:14:1;;463:22;445:41;;433:2;418:18;74158:214:0;;;;;;;;86371:224;;;:::i;:::-;;;643:25:1;;;631:2;616:18;86371:224:0;497:177:1;18082:100:0;;;:::i;:::-;;;;;;;:::i;20433:201::-;;;;;;:::i;:::-;;:::i;76959:30::-;;;;;;:::i;:::-;;:::i;:::-;;;2145:10:1;2133:23;;;2115:42;;2103:2;2088:18;76959:30:0;1971:192:1;81350:308:0;;;;;;:::i;:::-;;:::i;:::-;;100876:153;;;:::i;90585:26::-;;;;;-1:-1:-1;;;90585:26:0;;-1:-1:-1;;;;;90585:26:0;;;;;;-1:-1:-1;;;;;2582:31:1;;;2564:50;;2552:2;2537:18;90585:26:0;2420:200:1;99375:123:0;;;;;;:::i;:::-;;:::i;21214:295::-;;;;;;:::i;:::-;;:::i;56350:131::-;;;;;;:::i;:::-;56424:7;56451:12;;;:6;:12;;;;;:22;;;;56350:131;90554:24;;;;;-1:-1:-1;;;90554:24:0;;-1:-1:-1;;;;;90554:24:0;;;56791:147;;;;;;:::i;:::-;;:::i;19044:93::-;;;19127:2;3915:36:1;;3903:2;3888:18;19044:93:0;3773:184:1;57935:218:0;;;;;;:::i;:::-;;:::i;21918:238::-;;;;;;:::i;:::-;;:::i;76896:23::-;;;;;-1:-1:-1;;;;;76896:23:0;;;;;;-1:-1:-1;;;;;4140:32:1;;;4122:51;;4110:2;4095:18;76896:23:0;3962:217:1;80912:200:0;;;;;;:::i;:::-;;:::i;29859:91::-;;;;;;:::i;:::-;;:::i;77132:50::-;;;;;;:::i;:::-;;;;;;;;;;;;;;;;90619:31;;;;;;77018:25;;;;;-1:-1:-1;;;;;77018:25:0;;;92612:1254;;;:::i;76279:44::-;;76320:3;76279:44;;99827:145;;;;;;:::i;:::-;;:::i;100401:254::-;;;;;;:::i;:::-;;:::i;90659:52::-;;;;;;:::i;:::-;;;;;;;;;;;;;;;;11487:103;;;:::i;90491:23::-;;;;;;;;;30269:164;;;;;;:::i;:::-;;:::i;10839:87::-;10912:6;;-1:-1:-1;;;;;10912:6:0;10839:87;;74971:153;;;;;;:::i;:::-;;:::i;54823:147::-;;;;;;:::i;:::-;;:::i;18301:104::-;;;:::i;53928:49::-;;53973:4;53928:49;;22659:436;;;;;;:::i;:::-;;:::i;76926:26::-;;;;;-1:-1:-1;;;;;76926:26:0;;;19706:193;;;;;;:::i;:::-;;:::i;82135:364::-;;;;;;:::i;:::-;;:::i;80157:218::-;;;;;;:::i;:::-;;:::i;77089:34::-;;;;;-1:-1:-1;;;77089:34:0;;;;;;75298:142;;;;;;:::i;:::-;;:::i;76546:62::-;;76584:24;76546:62;;57231:149;;;;;;:::i;:::-;;:::i;80508:204::-;;;;;;:::i;:::-;;:::i;19962:151::-;;;;;;:::i;:::-;;:::i;90196:34::-;;90226:4;90196:34;;79489:231;;;;;;:::i;:::-;;:::i;76857:32::-;;;;;-1:-1:-1;;;;;76857:32:0;;;77050:26;;;;;-1:-1:-1;;;;;77050:26:0;;;81788:165;;;:::i;90521:26::-;;;;;;;;;;;;74158:214;74243:4;-1:-1:-1;;;;;;74267:57:0;;-1:-1:-1;;;74267:57:0;;:97;;;74328:36;74352:11;74328:23;:36::i;:::-;74260:104;74158:214;-1:-1:-1;;74158:214:0:o;86371:224::-;86435:23;86482:6;86477:111;86494:14;:21;86490:25;;86477:111;;;86559:14;86574:1;86559:17;;;;;;;;:::i;:::-;;;;;;;;;;;;;;86537:39;;86559:17;;;;;;;;;;86537:39;;:::i;:::-;;-1:-1:-1;86517:3:0;;;;:::i;:::-;;;;86477:111;;;;86371:224;:::o;18082:100::-;18136:13;18169:5;18162:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;18082:100;:::o;20433:201::-;20516:4;9464:10;20572:32;9464:10;20588:7;20597:6;20572:8;:32::i;:::-;-1:-1:-1;20622:4:0;;20433:201;-1:-1:-1;;;20433:201:0:o;76959:30::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;81350:308::-;81454:10;;-1:-1:-1;;;;;81454:10:0;81440;:24;;:49;;-1:-1:-1;10912:6:0;;-1:-1:-1;;;;;10912:6:0;81468:10;:21;81440:49;81432:74;;;;-1:-1:-1;;;81432:74:0;;;;;;;:::i;:::-;;;;;;;;;-1:-1:-1;;;;;81525:27:0;;81517:52;;;;-1:-1:-1;;;81517:52:0;;7669:2:1;81517:52:0;;;7651:21:1;7708:2;7688:18;;;7681:30;-1:-1:-1;;;7727:18:1;;;7720:42;7779:18;;81517:52:0;7467:336:1;81517:52:0;81580:10;:26;;-1:-1:-1;;;;;;81580:26:0;-1:-1:-1;;;;;81580:26:0;;;;;;;;81622:28;;4122:51:1;;;81622:28:0;;4110:2:1;4095:18;81622:28:0;;;;;;;;81350:308;:::o;100876:153::-;100929:4;101001:20;;100953:45;100975:22;;100953:21;:45::i;:::-;:68;;;;:::i;:::-;100946:75;;100876:153;:::o;99375:123::-;99478:12;;99438:4;;-1:-1:-1;;;99478:12:0;;-1:-1:-1;;;;;99478:12:0;99462:13;90226:4;99462:6;:13;:::i;:::-;:28;;;;:::i;21214:295::-;21345:4;9464:10;21403:38;21419:4;9464:10;21434:6;21403:15;:38::i;:::-;21452:27;21462:4;21468:2;21472:6;21452:9;:27::i;:::-;-1:-1:-1;21497:4:0;;21214:295;-1:-1:-1;;;;21214:295:0:o;56791:147::-;56424:7;56451:12;;;:6;:12;;;;;:22;;;54419:16;54430:4;54419:10;:16::i;:::-;56905:25:::1;56916:4;56922:7;56905:10;:25::i;:::-;56791:147:::0;;;:::o;57935:218::-;-1:-1:-1;;;;;58031:23:0;;9464:10;58031:23;58023:83;;;;-1:-1:-1;;;58023:83:0;;8405:2:1;58023:83:0;;;8387:21:1;8444:2;8424:18;;;8417:30;8483:34;8463:18;;;8456:62;-1:-1:-1;;;8534:18:1;;;8527:45;8589:19;;58023:83:0;8203:411:1;58023:83:0;58119:26;58131:4;58137:7;58119:11;:26::i;:::-;57935:218;;:::o;21918:238::-;22006:4;9464:10;22062:64;9464:10;22078:7;22115:10;22087:25;9464:10;22078:7;22087:9;:25::i;:::-;:38;;;;:::i;:::-;22062:8;:64::i;80912:200::-;80974:4;80999:32;76584:24;81020:10;80999:7;:32::i;:::-;80991:57;;;;-1:-1:-1;;;80991:57:0;;;;;;;:::i;:::-;81060:22;81066:7;81075:6;81060:5;:22::i;:::-;-1:-1:-1;81100:4:0;80912:200;;;;:::o;29859:91::-;29915:27;9464:10;29935:6;29915:5;:27::i;:::-;29859:91;:::o;92612:1254::-;92721:9;;92672:15;;92721:9;;92702:28;;;:49;;-1:-1:-1;92734:12:0;;-1:-1:-1;;;92734:12:0;;-1:-1:-1;;;;;92734:12:0;92750:1;92734:17;92702:49;92698:88;;;92768:7;92612:1254::o;92698:88::-;92862:12;;92839:19;;92798:18;;92862:12;;;;;;92820:38;;:16;:38;:::i;:::-;92819:55;;;;:::i;:::-;92798:76;;92905:4;92889:13;:20;92885:73;;;-1:-1:-1;92942:4:0;92885:73;92970:22;92995:13;:11;:13::i;:::-;92970:38;-1:-1:-1;93025:17:0;;93021:581;;93082:12;;-1:-1:-1;;;;;;;;93082:12:0;;;;;-1:-1:-1;;;93130:10:0;;;93059:20;93157:149;93178:13;93174:1;:17;93157:149;;;90226:4;93263:18;93270:11;90226:4;93263:18;:::i;:::-;-1:-1:-1;;;;;93240:42:0;93245:13;-1:-1:-1;;;;;93240:19:0;:42;;;;:::i;:::-;:49;;;;:::i;:::-;93217:73;-1:-1:-1;93193:3:0;;;;:::i;:::-;;;;93157:149;;;-1:-1:-1;93322:12:0;:28;;-1:-1:-1;;;;93322:28:0;-1:-1:-1;;;;;;;;93322:28:0;;;;;;;;93388;;93404:12;;;;;93388:13;:28;:::i;:::-;93365:19;;:51;;;;;;;:::i;:::-;;;;-1:-1:-1;;93449:12:0;;-1:-1:-1;;;93449:12:0;;-1:-1:-1;;;;;93449:12:0;93465:1;93449:17;93445:39;;93468:12;:16;;-1:-1:-1;;;;93468:16:0;-1:-1:-1;;;93468:16:0;;;93445:39;93563:12;;93506:84;;;9156:25:1;;;-1:-1:-1;;;93563:12:0;;;-1:-1:-1;;;;;93563:12:0;9212:2:1;9197:18;;9190:59;93506:84:0;;9129:18:1;93506:84:0;;;;;;;93044:558;;93021:581;93614:21;93638:13;:11;:13::i;:::-;93614:37;-1:-1:-1;93664:18:0;93685:36;93614:37;93685:17;:36;:::i;:::-;93664:57;;93754:1;93738:13;:17;93734:122;;;93778:11;;93772:37;;-1:-1:-1;;;;;93778:11:0;93791:17;93807:1;93791:13;:17;:::i;:::-;93772:5;:37::i;:::-;92637:1229;;;;;92612:1254::o;99827:145::-;99945:12;;99902:4;;90226;;99926:31;;-1:-1:-1;;;99945:12:0;;-1:-1:-1;;;;;99945:12:0;99926:16;:31;:::i;100401:254::-;-1:-1:-1;;;;;100504:29:0;;100483:4;100504:29;;;:20;:29;;;;;;;;100500:87;;;-1:-1:-1;;;;;;100557:18:0;;;;;:9;:18;;;;;;;100401:254::o;100500:87::-;-1:-1:-1;;;;;100628:18:0;;;;;;:9;:18;;;;;;100606:41;;:21;:41::i;11487:103::-;10725:13;:11;:13::i;:::-;11552:30:::1;11579:1;11552:18;:30::i;:::-;11487:103::o:0;30269:164::-;30346:46;30362:7;9464:10;30385:6;30346:15;:46::i;:::-;30403:22;30409:7;30418:6;30403:5;:22::i;74971:153::-;75061:7;75088:18;;;:12;:18;;;;;:28;;75110:5;75088:21;:28::i;:::-;75081:35;74971:153;-1:-1:-1;;;74971:153:0:o;54823:147::-;54909:4;54933:12;;;:6;:12;;;;;;;;-1:-1:-1;;;;;54933:29:0;;;;;;;;;;;;;;;54823:147::o;18301:104::-;18357:13;18390:7;18383:14;;;;;:::i;22659:436::-;22752:4;9464:10;22752:4;22835:25;9464:10;22852:7;22835:9;:25::i;:::-;22808:52;;22899:15;22879:16;:35;;22871:85;;;;-1:-1:-1;;;22871:85:0;;9462:2:1;22871:85:0;;;9444:21:1;9501:2;9481:18;;;9474:30;9540:34;9520:18;;;9513:62;-1:-1:-1;;;9591:18:1;;;9584:35;9636:19;;22871:85:0;9260:401:1;22871:85:0;22992:60;23001:5;23008:7;23036:15;23017:16;:34;22992:8;:60::i;19706:193::-;19785:4;9464:10;19841:28;9464:10;19858:2;19862:6;19841:9;:28::i;82135:364::-;82242:10;;-1:-1:-1;;;;;82242:10:0;82228;:24;;:49;;-1:-1:-1;10912:6:0;;-1:-1:-1;;;;;10912:6:0;82256:10;:21;82228:49;82220:74;;;;-1:-1:-1;;;82220:74:0;;;;;;;:::i;:::-;76320:3;82313:42;;;;;82305:63;;;;-1:-1:-1;;;82305:63:0;;9868:2:1;82305:63:0;;;9850:21:1;9907:1;9887:18;;;9880:29;-1:-1:-1;;;9925:18:1;;;9918:38;9973:18;;82305:63:0;9666:331:1;82305:63:0;82381:20;:46;;-1:-1:-1;;;;82381:46:0;-1:-1:-1;;;82381:46:0;;;;;;;;;;;;;82443:48;;2115:42:1;;;82443:48:0;;2103:2:1;2088:18;82443:48:0;1971:192:1;80157:218:0;10725:13;:11;:13::i;:::-;-1:-1:-1;;;;;80273:33:0;::::1;;::::0;;;:18:::1;:33;::::0;;;;;;;;:41;;-1:-1:-1;;80273:41:0::1;::::0;::::1;;::::0;;::::1;::::0;;;80330:37;;10368:51:1;;;10435:18;;;10428:50;80330:37:0::1;::::0;10341:18:1;80330:37:0::1;;;;;;;80157:218:::0;;:::o;75298:142::-;75378:7;75405:18;;;:12;:18;;;;;:27;;:25;:27::i;57231:149::-;56424:7;56451:12;;;:6;:12;;;;;:22;;;54419:16;54430:4;54419:10;:16::i;:::-;57346:26:::1;57358:4;57364:7;57346:11;:26::i;80508:204::-:0;10725:13;:11;:13::i;:::-;80584:11:::1;:26:::0;;-1:-1:-1;;;;;;80584:26:0::1;-1:-1:-1::0;;;;;80584:26:0;::::1;::::0;;::::1;::::0;;;-1:-1:-1;80621:32:0;;;:18:::1;:32;::::0;;;;;;;;:39;;-1:-1:-1;;80621:39:0::1;-1:-1:-1::0;80621:39:0::1;::::0;;80676:28;;4122:51:1;;;80676:28:0::1;::::0;4095:18:1;80676:28:0::1;3962:217:1::0;19962:151:0;-1:-1:-1;;;;;20078:18:0;;;20051:7;20078:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;19962:151::o;79489:231::-;10725:13;:11;:13::i;:::-;79617:5:::1;79587:18;:27;79606:7;10912:6:::0;;-1:-1:-1;;;;;10912:6:0;;10839:87;79606:7:::1;-1:-1:-1::0;;;;;79587:27:0::1;::::0;;::::1;::::0;::::1;::::0;;;;;;-1:-1:-1;79587:27:0;:35;;-1:-1:-1;;79587:35:0::1;::::0;::::1;;::::0;;;::::1;::::0;;79633:33:::1;79657:8:::0;79633:23:::1;:33::i;:::-;-1:-1:-1::0;;;;;79677:28:0::1;;::::0;;;:18:::1;:28;::::0;;;;:35;;-1:-1:-1;;79677:35:0::1;79708:4;79677:35;::::0;;79489:231::o;81788:165::-;81863:10;;-1:-1:-1;;;;;81863:10:0;81849;:24;;:49;;-1:-1:-1;10912:6:0;;-1:-1:-1;;;;;10912:6:0;81877:10;:21;81849:49;81841:74;;;;-1:-1:-1;;;81841:74:0;;;;;;;:::i;:::-;81926:19;:17;:19::i;59532:238::-;59616:22;59624:4;59630:7;59616;:22::i;:::-;59611:152;;59655:12;;;;:6;:12;;;;;;;;-1:-1:-1;;;;;59655:29:0;;;;;;;;;:36;;-1:-1:-1;;59655:36:0;59687:4;59655:36;;;59738:12;9464:10;;9384:98;59738:12;-1:-1:-1;;;;;59711:40:0;59729:7;-1:-1:-1;;;;;59711:40:0;59723:4;59711:40;;;;;;;;;;59532:238;;:::o;68780:152::-;68850:4;68874:50;68879:3;-1:-1:-1;;;;;68899:23:0;;68874:4;:50::i;54527:204::-;54612:4;-1:-1:-1;;;;;;54636:47:0;;-1:-1:-1;;;54636:47:0;;:87;;-1:-1:-1;;;;;;;;;;51889:40:0;;;54687:36;51780:157;26686:380;-1:-1:-1;;;;;26822:19:0;;26814:68;;;;-1:-1:-1;;;26814:68:0;;10691:2:1;26814:68:0;;;10673:21:1;10730:2;10710:18;;;10703:30;10769:34;10749:18;;;10742:62;-1:-1:-1;;;10820:18:1;;;10813:34;10864:19;;26814:68:0;10489:400:1;26814:68:0;-1:-1:-1;;;;;26901:21:0;;26893:68;;;;-1:-1:-1;;;26893:68:0;;11096:2:1;26893:68:0;;;11078:21:1;11135:2;11115:18;;;11108:30;11174:34;11154:18;;;11147:62;-1:-1:-1;;;11225:18:1;;;11218:32;11267:19;;26893:68:0;10894:398:1;26893:68:0;-1:-1:-1;;;;;26974:18:0;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;:36;;;27026:32;;643:25:1;;;27026:32:0;;616:18:1;27026:32:0;;;;;;;26686:380;;;:::o;27357:453::-;27492:24;27519:25;27529:5;27536:7;27519:9;:25::i;:::-;27492:52;;-1:-1:-1;;27559:16:0;:37;27555:248;;27641:6;27621:16;:26;;27613:68;;;;-1:-1:-1;;;27613:68:0;;11499:2:1;27613:68:0;;;11481:21:1;11538:2;11518:18;;;11511:30;11577:31;11557:18;;;11550:59;11626:18;;27613:68:0;11297:353:1;27613:68:0;27725:51;27734:5;27741:7;27769:6;27750:16;:25;27725:8;:51::i;:::-;27481:329;27357:453;;;:::o;94572:1433::-;-1:-1:-1;;;;;94714:18:0;::::1;94706:68;;;::::0;-1:-1:-1;;;94706:68:0;;11857:2:1;94706:68:0::1;::::0;::::1;11839:21:1::0;11896:2;11876:18;;;11869:30;11935:34;11915:18;;;11908:62;-1:-1:-1;;;11986:18:1;;;11979:35;12031:19;;94706:68:0::1;11655:401:1::0;94706:68:0::1;-1:-1:-1::0;;;;;94793:16:0;::::1;94785:64;;;::::0;-1:-1:-1;;;94785:64:0;;12263:2:1;94785:64:0::1;::::0;::::1;12245:21:1::0;12302:2;12282:18;;;12275:30;12341:34;12321:18;;;12314:62;-1:-1:-1;;;12392:18:1;;;12385:33;12435:19;;94785:64:0::1;12061:399:1::0;94785:64:0::1;94863:8;94877:29;94889:4;94895:2;94899:6;94877:11;:29::i;:::-;94862:44;;;94919:21;94943:27;94963:6;94943:19;:27::i;:::-;94919:51;;94981:18;95002:24;95022:3;95002:19;:24::i;:::-;94981:45:::0;-1:-1:-1;95039:13:0::1;95049:3:::0;95039:13;::::1;:::i;:::-;::::0;-1:-1:-1;95063:33:0::1;95083:13:::0;95063:33;::::1;:::i;:::-;-1:-1:-1::0;;;;;95128:15:0;::::1;95109:16;95128:15:::0;;;:9:::1;:15;::::0;;;;;;;;95159:20:::1;:26:::0;;;;;;;95063:33;;-1:-1:-1;95128:15:0;95159:26:::1;;95154:539;;95243:16;95228:11;:31;;95202:132;;;;-1:-1:-1::0;;;95202:132:0::1;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;95349:15:0;::::1;;::::0;;;:9:::1;:15;::::0;;;;:35;;95368:16;;95349:15;:35:::1;::::0;95368:16;;95349:35:::1;:::i;:::-;::::0;;;-1:-1:-1;95154:539:0::1;::::0;-1:-1:-1;95154:539:0::1;;95458:6;95443:11;:21;;95417:122;;;;-1:-1:-1::0;;;95417:122:0::1;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;95554:15:0;::::1;;::::0;;;:9:::1;:15;::::0;;;;:25;;95573:6;;95554:15;:25:::1;::::0;95573:6;;95554:25:::1;:::i;:::-;;;;;;;;95618:6;95594:20;;:30;;;;;;;:::i;:::-;;;;;;;;95665:16;95639:22;;:42;;;;;;;:::i;:::-;::::0;;;-1:-1:-1;;95154:539:0::1;-1:-1:-1::0;;;;;95710:24:0;::::1;;::::0;;;:20:::1;:24;::::0;;;;;::::1;;95705:249;;-1:-1:-1::0;;;;;95751:13:0;::::1;;::::0;;;:9:::1;:13;::::0;;;;:33;;95768:16;;95751:13;:33:::1;::::0;95768:16;;95751:33:::1;:::i;:::-;::::0;;;-1:-1:-1;95705:249:0::1;::::0;-1:-1:-1;95705:249:0::1;;-1:-1:-1::0;;;;;95817:13:0;::::1;;::::0;;;:9:::1;:13;::::0;;;;:23;;95834:6;;95817:13;:23:::1;::::0;95834:6;;95817:23:::1;:::i;:::-;;;;;;;;95879:6;95855:20;;:30;;;;;;;:::i;:::-;;;;;;;;95926:16;95900:22;;:42;;;;;;;:::i;:::-;::::0;;;-1:-1:-1;;95705:249:0::1;95986:2;-1:-1:-1::0;;;;;95971:26:0::1;95980:4;-1:-1:-1::0;;;;;95971:26:0::1;;95990:6;95971:26;;;;643:25:1::0;;631:2;616:18;;497:177;95971:26:0::1;;;;;;;;94695:1310;;;;90937:8:::0;:6;:8::i;55274:105::-;55341:30;55352:4;9464:10;55341;:30::i;75533:169::-;75621:31;75638:4;75644:7;75621:16;:31::i;:::-;75663:18;;;;:12;:18;;;;;:31;;75686:7;75663:22;:31::i;75796:174::-;75885:32;75903:4;75909:7;75885:17;:32::i;:::-;75928:18;;;;:12;:18;;;;;:34;;75954:7;75928:25;:34::i;97944:555::-;-1:-1:-1;;;;;98037:21:0;::::1;98029:67;;;;-1:-1:-1::0;;;98029:67:0::1;;;;;;;:::i;:::-;98109:21;98133:27;98153:6;98133:19;:27::i;:::-;-1:-1:-1::0;;;;;98178:29:0;::::1;;::::0;;;:20:::1;:29;::::0;;;;;98109:51;;-1:-1:-1;98178:29:0::1;;98173:264;;-1:-1:-1::0;;;;;98224:18:0;::::1;;::::0;;;:9:::1;:18;::::0;;;;:38;;98246:16;;98224:18;:38:::1;::::0;98246:16;;98224:38:::1;:::i;:::-;;;;;;;;98303:16;98277:22;;:42;;;;;;;:::i;:::-;::::0;;;-1:-1:-1;98173:264:0::1;::::0;-1:-1:-1;98173:264:0::1;;-1:-1:-1::0;;;;;98352:18:0;::::1;;::::0;;;:9:::1;:18;::::0;;;;:28;;98374:6;;98352:18;:28:::1;::::0;98374:6;;98352:28:::1;:::i;:::-;;;;;;;;98419:6;98395:20;;:30;;;;;;;:::i;:::-;::::0;;;-1:-1:-1;;98173:264:0::1;98454:37;::::0;643:25:1;;;-1:-1:-1;;;;;98454:37:0;::::1;::::0;98471:1:::1;::::0;98454:37:::1;::::0;631:2:1;616:18;98454:37:0::1;;;;;;;98018:481;90937:8:::0;:6;:8::i;96580:788::-;-1:-1:-1;;;;;96673:21:0;::::1;96665:67;;;;-1:-1:-1::0;;;96665:67:0::1;;;;;;;:::i;:::-;96745:21;96769:27;96789:6;96769:19;:27::i;:::-;-1:-1:-1::0;;;;;96829:18:0;::::1;96807:19;96829:18:::0;;;:9:::1;:18;::::0;;;;;;;;96865:20:::1;:29:::0;;;;;;;96745:51;;-1:-1:-1;96829:18:0;96865:29:::1;;96860:446;;96937:16;96919:14;:34;;96911:81;;;;-1:-1:-1::0;;;96911:81:0::1;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;97007:18:0;::::1;;::::0;;;:9:::1;:18;::::0;;;;:38;;97029:16;;97007:18;:38:::1;::::0;97029:16;;97007:38:::1;:::i;:::-;;;;;;;;97086:16;97060:22;;:42;;;;;;;:::i;:::-;::::0;;;-1:-1:-1;96860:446:0::1;::::0;-1:-1:-1;96860:446:0::1;;97161:6;97143:14;:24;;97135:71;;;;-1:-1:-1::0;;;97135:71:0::1;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;97221:18:0;::::1;;::::0;;;:9:::1;:18;::::0;;;;:28;;97243:6;;97221:18;:28:::1;::::0;97243:6;;97221:28:::1;:::i;:::-;;;;;;;;97288:6;97264:20;;:30;;;;;;;:::i;:::-;::::0;;;-1:-1:-1;;96860:446:0::1;97323:37;::::0;643:25:1;;;97349:1:0::1;::::0;-1:-1:-1;;;;;97323:37:0;::::1;::::0;::::1;::::0;631:2:1;616:18;97323:37:0::1;;;;;;;96654:714;;90937:8:::0;:6;:8::i;11004:132::-;10912:6;;-1:-1:-1;;;;;10912:6:0;9464:10;11068:23;11060:68;;;;-1:-1:-1;;;11060:68:0;;13879:2:1;11060:68:0;;;13861:21:1;;;13898:18;;;13891:30;13957:34;13937:18;;;13930:62;14009:18;;11060:68:0;13677:356:1;12106:191:0;12199:6;;;-1:-1:-1;;;;;12216:17:0;;;-1:-1:-1;;;;;;12216:17:0;;;;;;;12249:40;;12199:6;;;12216:17;12199:6;;12249:40;;12180:16;;12249:40;12169:128;12106:191;:::o;70076:158::-;70150:7;70201:22;70205:3;70217:5;70201:3;:22::i;69605:117::-;69668:7;69695:19;69703:3;64905:18;;64822:109;11745:201;10725:13;:11;:13::i;:::-;-1:-1:-1;;;;;11834:22:0;::::1;11826:73;;;::::0;-1:-1:-1;;;11826:73:0;;14240:2:1;11826:73:0::1;::::0;::::1;14222:21:1::0;14279:2;14259:18;;;14252:30;14318:34;14298:18;;;14291:62;-1:-1:-1;;;14369:18:1;;;14362:36;14415:19;;11826:73:0::1;14038:402:1::0;11826:73:0::1;11910:28;11929:8;11910:18;:28::i;85200:503::-:0;85249:15;85267:24;85285:4;85267:9;:24::i;:::-;85249:42;;85306:10;85320:1;85306:15;85302:28;;85323:7;85200:503::o;85302:28::-;85370:16;;;85384:1;85370:16;;;;;;;;85342:25;;85370:16;;;;;;;;;;-1:-1:-1;85370:16:0;85342:44;;85419:4;85397:8;85406:1;85397:11;;;;;;;;:::i;:::-;-1:-1:-1;;;;;85397:27:0;;;:11;;;;;;;;;;:27;;;;85449:6;;:13;;;-1:-1:-1;;;85449:13:0;;;;:6;;;;;:11;;:13;;;;;85397:11;;85449:13;;;;;:6;:13;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;85435:8;85444:1;85435:11;;;;;;;;:::i;:::-;-1:-1:-1;;;;;85435:27:0;;;:11;;;;;;;;;:27;85493:6;;85616:10;;85493:182;;-1:-1:-1;;;85493:182:0;;:6;;;;:28;;:182;;85540:10;;85493:6;;85589:8;;85616:10;;;;85645:15;;85493:182;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;85493:182:0;;;;;;;;;;;;:::i;:::-;;;85475:221;;;;85238:465;;85200:503::o;62511:414::-;62574:4;64704:19;;;:12;;;:19;;;;;;62591:327;;-1:-1:-1;62634:23:0;;;;;;;;:11;:23;;;;;;;;;;;;;62817:18;;62795:19;;;:12;;;:19;;;;;;:40;;;;62850:11;;62591:327;-1:-1:-1;62901:5:0;62894:12;;83905:1203;-1:-1:-1;;;;;84106:24:0;;84037:8;84106:24;;;:18;:24;;;;;;84037:8;;84106:24;;;:64;;-1:-1:-1;;;;;;84148:22:0;;;;;;:18;:22;;;;;;;;84106:64;:96;;;-1:-1:-1;84188:14:0;;;;84106:96;84088:170;;;-1:-1:-1;84237:1:0;;-1:-1:-1;84237:1:0;84229:17;;84088:170;84270:14;:21;;-1:-1:-1;;84270:21:0;84287:4;84270:21;;;84355:14;:17;;84270:14;;84330:43;;84347:6;;84355:14;84270;;84355:17;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;84330:16;:43::i;:::-;84312:61;;84401:1;84388:10;:14;:42;;;;-1:-1:-1;84406:10:0;;-1:-1:-1;;;;;84406:10:0;:24;;84388:42;84384:149;;;84447:17;84454:10;84447:17;;:::i;:::-;;;84479:42;84489:4;84503;84510:10;84479:9;:42::i;:::-;84545:21;84569:43;84586:6;84594:14;84609:1;84594:17;;;;;;;;:::i;84569:43::-;84545:67;;84646:1;84627:16;:20;:49;;;;-1:-1:-1;84651:11:0;;-1:-1:-1;;;;;84651:11:0;:25;;84627:49;84623:166;;;84693:23;84700:16;84693:23;;:::i;:::-;84747:11;;84693:23;;-1:-1:-1;84731:46:0;;84741:4;;-1:-1:-1;;;;;84747:11:0;84760:16;84731:9;:46::i;:::-;84801:15;84819:53;84836:13;:11;:13::i;:::-;84851:20;;-1:-1:-1;;;84851:20:0;;;;84819:16;:53::i;:::-;84801:71;;84929:10;84901:24;84919:4;84901:9;:24::i;:::-;:38;;:76;;;;-1:-1:-1;84972:4:0;;-1:-1:-1;;;;;84956:21:0;;;84972:4;;84956:21;;84901:76;84883:152;;;85004:19;:17;:19::i;:::-;-1:-1:-1;;85047:14:0;:22;;-1:-1:-1;;85047:22:0;;;-1:-1:-1;85047:22:0;;-1:-1:-1;83905:1203:0;;;;;;;:::o;55669:492::-;55758:22;55766:4;55772:7;55758;:22::i;:::-;55753:401;;55946:28;55966:7;55946:19;:28::i;:::-;56047:38;56075:4;56082:2;56047:19;:38::i;:::-;55851:257;;;;;;;;;:::i;:::-;;;;-1:-1:-1;;55851:257:0;;;;;;;;;;-1:-1:-1;;;55797:345:0;;;;;;;:::i;59950:239::-;60034:22;60042:4;60048:7;60034;:22::i;:::-;60030:152;;;60105:5;60073:12;;;:6;:12;;;;;;;;-1:-1:-1;;;;;60073:29:0;;;;;;;;;;:37;;-1:-1:-1;;60073:37:0;;;60130:40;9464:10;;60073:12;;60130:40;;60105:5;60130:40;59950:239;;:::o;69108:158::-;69181:4;69205:53;69213:3;-1:-1:-1;;;;;69233:23:0;;69205:7;:53::i;65285:120::-;65352:7;65379:3;:11;;65391:5;65379:18;;;;;;;;:::i;:::-;;;;;;;;;65372:25;;65285:120;;;;:::o;86947:172::-;87051:4;76320:3;87075:18;87083:10;87075:5;:18;:::i;:::-;:36;;;;:::i;49826:151::-;49884:13;49917:52;-1:-1:-1;;;;;49929:22:0;;47981:2;49222:447;49297:13;49323:19;49355:10;49359:6;49355:1;:10;:::i;:::-;:14;;49368:1;49355:14;:::i;:::-;-1:-1:-1;;;;;49345:25:0;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;49345:25:0;;49323:47;;-1:-1:-1;;;49381:6:0;49388:1;49381:9;;;;;;;;:::i;:::-;;;;:15;-1:-1:-1;;;;;49381:15:0;;;;;;;;;-1:-1:-1;;;49407:6:0;49414:1;49407:9;;;;;;;;:::i;:::-;;;;:15;-1:-1:-1;;;;;49407:15:0;;;;;;;;-1:-1:-1;49438:9:0;49450:10;49454:6;49450:1;:10;:::i;:::-;:14;;49463:1;49450:14;:::i;:::-;49438:26;;49433:131;49470:1;49466;:5;49433:131;;;-1:-1:-1;;;49514:5:0;49522:3;49514:11;49505:21;;;;;;;:::i;:::-;;;;49493:6;49500:1;49493:9;;;;;;;;:::i;:::-;;;;:33;-1:-1:-1;;;;;49493:33:0;;;;;;;;-1:-1:-1;49551:1:0;49541:11;;;;;49473:3;;;:::i;:::-;;;49433:131;;;-1:-1:-1;49582:10:0;;49574:55;;;;-1:-1:-1;;;49574:55:0;;18062:2:1;49574:55:0;;;18044:21:1;;;18081:18;;;18074:30;18140:34;18120:18;;;18113:62;18192:18;;49574:55:0;17860:356:1;63101:1420:0;63167:4;63306:19;;;:12;;;:19;;;;;;63342:15;;63338:1176;;63717:21;63741:14;63754:1;63741:10;:14;:::i;:::-;63790:18;;63717:38;;-1:-1:-1;63770:17:0;;63790:22;;63811:1;;63790:22;:::i;:::-;63770:42;;63846:13;63833:9;:26;63829:405;;63880:17;63900:3;:11;;63912:9;63900:22;;;;;;;;:::i;:::-;;;;;;;;;63880:42;;64054:9;64025:3;:11;;64037:13;64025:26;;;;;;;;:::i;:::-;;;;;;;;;;;;:38;;;;64139:23;;;:12;;;:23;;;;;:36;;;63829:405;64315:17;;:3;;:17;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;64410:3;:12;;:19;64423:5;64410:19;;;;;;;;;;;64403:26;;;64453:4;64446:11;;;;;;;63338:1176;64497:5;64490:12;;;;;14:286:1;72:6;125:2;113:9;104:7;100:23;96:32;93:52;;;141:1;138;131:12;93:52;167:23;;-1:-1:-1;;;;;;219:32:1;;209:43;;199:71;;266:1;263;256:12;679:258;751:1;761:113;775:6;772:1;769:13;761:113;;;851:11;;;845:18;832:11;;;825:39;797:2;790:10;761:113;;;892:6;889:1;886:13;883:48;;;-1:-1:-1;;927:1:1;909:16;;902:27;679:258::o;942:383::-;1091:2;1080:9;1073:21;1054:4;1123:6;1117:13;1166:6;1161:2;1150:9;1146:18;1139:34;1182:66;1241:6;1236:2;1225:9;1221:18;1216:2;1208:6;1204:15;1182:66;:::i;:::-;1309:2;1288:15;-1:-1:-1;;1284:29:1;1269:45;;;;1316:2;1265:54;;942:383;-1:-1:-1;;942:383:1:o;1330:131::-;-1:-1:-1;;;;;1405:31:1;;1395:42;;1385:70;;1451:1;1448;1441:12;1466:315;1534:6;1542;1595:2;1583:9;1574:7;1570:23;1566:32;1563:52;;;1611:1;1608;1601:12;1563:52;1650:9;1637:23;1669:31;1694:5;1669:31;:::i;:::-;1719:5;1771:2;1756:18;;;;1743:32;;-1:-1:-1;;;1466:315:1:o;1786:180::-;1845:6;1898:2;1886:9;1877:7;1873:23;1869:32;1866:52;;;1914:1;1911;1904:12;1866:52;-1:-1:-1;1937:23:1;;1786:180;-1:-1:-1;1786:180:1:o;2168:247::-;2227:6;2280:2;2268:9;2259:7;2255:23;2251:32;2248:52;;;2296:1;2293;2286:12;2248:52;2335:9;2322:23;2354:31;2379:5;2354:31;:::i;2625:456::-;2702:6;2710;2718;2771:2;2759:9;2750:7;2746:23;2742:32;2739:52;;;2787:1;2784;2777:12;2739:52;2826:9;2813:23;2845:31;2870:5;2845:31;:::i;:::-;2895:5;-1:-1:-1;2952:2:1;2937:18;;2924:32;2965:33;2924:32;2965:33;:::i;:::-;2625:456;;3017:7;;-1:-1:-1;;;3071:2:1;3056:18;;;;3043:32;;2625:456::o;3453:315::-;3521:6;3529;3582:2;3570:9;3561:7;3557:23;3553:32;3550:52;;;3598:1;3595;3588:12;3550:52;3634:9;3621:23;3611:33;;3694:2;3683:9;3679:18;3666:32;3707:31;3732:5;3707:31;:::i;:::-;3757:5;3747:15;;;3453:315;;;;;:::o;4392:248::-;4460:6;4468;4521:2;4509:9;4500:7;4496:23;4492:32;4489:52;;;4537:1;4534;4527:12;4489:52;-1:-1:-1;;4560:23:1;;;4630:2;4615:18;;;4602:32;;-1:-1:-1;4392:248:1:o;4875:276::-;4933:6;4986:2;4974:9;4965:7;4961:23;4957:32;4954:52;;;5002:1;4999;4992:12;4954:52;5041:9;5028:23;5091:10;5084:5;5080:22;5073:5;5070:33;5060:61;;5117:1;5114;5107:12;5156:416;5221:6;5229;5282:2;5270:9;5261:7;5257:23;5253:32;5250:52;;;5298:1;5295;5288:12;5250:52;5337:9;5324:23;5356:31;5381:5;5356:31;:::i;:::-;5406:5;-1:-1:-1;5463:2:1;5448:18;;5435:32;5505:15;;5498:23;5486:36;;5476:64;;5536:1;5533;5526:12;5577:388;5645:6;5653;5706:2;5694:9;5685:7;5681:23;5677:32;5674:52;;;5722:1;5719;5712:12;5674:52;5761:9;5748:23;5780:31;5805:5;5780:31;:::i;:::-;5830:5;-1:-1:-1;5887:2:1;5872:18;;5859:32;5900:33;5859:32;5900:33;:::i;6204:127::-;6265:10;6260:3;6256:20;6253:1;6246:31;6296:4;6293:1;6286:15;6320:4;6317:1;6310:15;6336:127;6397:10;6392:3;6388:20;6385:1;6378:31;6428:4;6425:1;6418:15;6452:4;6449:1;6442:15;6468:128;6508:3;6539:1;6535:6;6532:1;6529:13;6526:39;;;6545:18;;:::i;:::-;-1:-1:-1;6581:9:1;;6468:128::o;6601:135::-;6640:3;6661:17;;;6658:43;;6681:18;;:::i;:::-;-1:-1:-1;6728:1:1;6717:13;;6601:135::o;6741:380::-;6820:1;6816:12;;;;6863;;;6884:61;;6938:4;6930:6;6926:17;6916:27;;6884:61;6991:2;6983:6;6980:14;6960:18;6957:38;6954:161;;7037:10;7032:3;7028:20;7025:1;7018:31;7072:4;7069:1;7062:15;7100:4;7097:1;7090:15;6954:161;;6741:380;;;:::o;7126:336::-;7328:2;7310:21;;;7367:2;7347:18;;;7340:30;-1:-1:-1;;;7401:2:1;7386:18;;7379:42;7453:2;7438:18;;7126:336::o;7808:168::-;7848:7;7914:1;7910;7906:6;7902:14;7899:1;7896:21;7891:1;7884:9;7877:17;7873:45;7870:71;;;7921:18;;:::i;:::-;-1:-1:-1;7961:9:1;;7808:168::o;7981:217::-;8021:1;8047;8037:132;;8091:10;8086:3;8082:20;8079:1;8072:31;8126:4;8123:1;8116:15;8154:4;8151:1;8144:15;8037:132;-1:-1:-1;8183:9:1;;7981:217::o;8619:125::-;8659:4;8687:1;8684;8681:8;8678:34;;;8692:18;;:::i;:::-;-1:-1:-1;8729:9:1;;8619:125::o;8749:229::-;8788:4;-1:-1:-1;;;;;8885:10:1;;;;8855;;8907:12;;;8904:38;;;8922:18;;:::i;:::-;8959:13;;8749:229;-1:-1:-1;;;8749:229:1:o;12465:402::-;12667:2;12649:21;;;12706:2;12686:18;;;12679:30;12745:34;12740:2;12725:18;;12718:62;-1:-1:-1;;;12811:2:1;12796:18;;12789:36;12857:3;12842:19;;12465:402::o;12872:397::-;13074:2;13056:21;;;13113:2;13093:18;;;13086:30;13152:34;13147:2;13132:18;;13125:62;-1:-1:-1;;;13218:2:1;13203:18;;13196:31;13259:3;13244:19;;12872:397::o;13274:398::-;13476:2;13458:21;;;13515:2;13495:18;;;13488:30;13554:34;13549:2;13534:18;;13527:62;-1:-1:-1;;;13620:2:1;13605:18;;13598:32;13662:3;13647:19;;13274:398::o;14445:127::-;14506:10;14501:3;14497:20;14494:1;14487:31;14537:4;14534:1;14527:15;14561:4;14558:1;14551:15;14577:251;14647:6;14700:2;14688:9;14679:7;14675:23;14671:32;14668:52;;;14716:1;14713;14706:12;14668:52;14748:9;14742:16;14767:31;14792:5;14767:31;:::i;14833:980::-;15095:4;15143:3;15132:9;15128:19;15174:6;15163:9;15156:25;15200:2;15238:6;15233:2;15222:9;15218:18;15211:34;15281:3;15276:2;15265:9;15261:18;15254:31;15305:6;15340;15334:13;15371:6;15363;15356:22;15409:3;15398:9;15394:19;15387:26;;15448:2;15440:6;15436:15;15422:29;;15469:1;15479:195;15493:6;15490:1;15487:13;15479:195;;;15558:13;;-1:-1:-1;;;;;15554:39:1;15542:52;;15649:15;;;;15614:12;;;;15590:1;15508:9;15479:195;;;-1:-1:-1;;;;;;;15730:32:1;;;;15725:2;15710:18;;15703:60;-1:-1:-1;;;15794:3:1;15779:19;15772:35;15691:3;14833:980;-1:-1:-1;;;14833:980:1:o;15818:1105::-;15913:6;15944:2;15987;15975:9;15966:7;15962:23;15958:32;15955:52;;;16003:1;16000;15993:12;15955:52;16036:9;16030:16;-1:-1:-1;;;;;16106:2:1;16098:6;16095:14;16092:34;;;16122:1;16119;16112:12;16092:34;16160:6;16149:9;16145:22;16135:32;;16205:7;16198:4;16194:2;16190:13;16186:27;16176:55;;16227:1;16224;16217:12;16176:55;16256:2;16250:9;16278:2;16274;16271:10;16268:36;;;16284:18;;:::i;:::-;16330:2;16327:1;16323:10;16362:2;16356:9;16425:2;16421:7;16416:2;16412;16408:11;16404:25;16396:6;16392:38;16480:6;16468:10;16465:22;16460:2;16448:10;16445:18;16442:46;16439:72;;;16491:18;;:::i;:::-;16527:2;16520:22;16577:18;;;16611:15;;;;-1:-1:-1;16653:11:1;;;16649:20;;;16681:19;;;16678:39;;;16713:1;16710;16703:12;16678:39;16737:11;;;;16757:135;16773:6;16768:3;16765:15;16757:135;;;16839:10;;16827:23;;16790:12;;;;16870;;;;16757:135;;;16911:6;15818:1105;-1:-1:-1;;;;;;;;15818:1105:1:o;16928:786::-;17339:25;17334:3;17327:38;17309:3;17394:6;17388:13;17410:62;17465:6;17460:2;17455:3;17451:12;17444:4;17436:6;17432:17;17410:62;:::i;:::-;-1:-1:-1;;;17531:2:1;17491:16;;;17523:11;;;17516:40;17581:13;;17603:63;17581:13;17652:2;17644:11;;17637:4;17625:17;;17603:63;:::i;:::-;17686:17;17705:2;17682:26;;16928:786;-1:-1:-1;;;;16928:786:1:o;17719:136::-;17758:3;17786:5;17776:39;;17795:18;;:::i;:::-;-1:-1:-1;;;17831:18:1;;17719:136::o;18221:127::-;18282:10;18277:3;18273:20;18270:1;18263:31;18313:4;18310:1;18303:15;18337:4;18334:1;18327:15

Swarm Source

ipfs://c6707968d7bb11f6d55ce37e95a617bfdb87b8f627764beaf177186aba133c98

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