Token

Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

// SPDX-License-Identifier: MIT


// OpenZeppelin Contracts (last updated v5.0.0) (utils/Context.sol)

pragma solidity ^0.8.23;

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






// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/IERC20.sol)


/**
 * @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 value of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

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

    /**
     * @dev Moves a `value` amount of 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 value) 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 a `value` amount of tokens 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 value) external returns (bool);

    /**
     * @dev Moves a `value` amount of tokens from `from` to `to` using the
     * allowance mechanism. `value` 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 value) external returns (bool);
}



// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/extensions/IERC20Metadata.sol)



/**
 * @dev Interface for the optional metadata functions from the ERC20 standard.
 */
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);
}





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



/**
 * @dev Implementation of the {IERC20} interface.
 *
 * This implementation is agnostic to the way tokens are created. This means
 * that a supply mechanism has to be added in a derived contract using {_mint}.
 * For a generic mechanism see {ERC20PresetMinterPauser}.
 *
 * TIP: For a detailed writeup see our guide
 * https://forum.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 {}
}




abstract contract ERC20Base is ERC20 {
    uint8 private immutable _decimals;
    uint256 public immutable TOKEN_CODE;

    constructor(
        string memory name_,
        string memory symbol_,
        uint8 decimals_
            ) ERC20(name_, symbol_) {
        _decimals = decimals_;
    }

    function decimals() public view override returns (uint8) {
        return _decimals;
    }
}







/*
 * AntiWhaleToken: Limit the max wallet size
 */
abstract contract AntiWhaleToken is ERC20Base {
    uint256 public maxTokenPerWallet; // anti whale: max token per wallet (default to 1% of supply)

    event MaxTokenPerWalletUpdated(uint256 amount);

    modifier antiWhale(
        address sender,
        address recipient,
        uint256 amount
    ) {
        if (maxTokenPerWallet != 0 && !isExcludedFromAntiWhale(recipient)) {
            require(balanceOf(recipient) + amount <= maxTokenPerWallet, "Wallet exceeds max");
        }
        _;
    }

    constructor(uint256 maxTokenPerWallet_) {
        maxTokenPerWallet = maxTokenPerWallet_;
    }

    function isExcludedFromAntiWhale(address account) public view virtual returns (bool);

    /**
     * @dev Update the max token per wallet
     * set to 0 to disable
     */
    function _setMaxTokenPerWallet(uint256 amount) internal {
        require(amount == 0 || amount > (totalSupply() * 5) / 1000, "Amount too low"); // min 0.5% of supply

        maxTokenPerWallet = amount;
        emit MaxTokenPerWalletUpdated(amount);
    }

    function _beforeTokenTransfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual override antiWhale(from, to, amount) {
        super._beforeTokenTransfer(from, to, amount);
    }
}










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



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

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

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor() {
        _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);
    }
}







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





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




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

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


/**
 * @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.
 *
 * ```solidity
 * 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 is the index of the value in the `values` array plus 1.
        // Position 0 is used to mean a value is not in the set.
        mapping(bytes32 value => uint256) _positions;
    }

    /**
     * @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._positions[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 cache the value's position to prevent multiple reads from the same storage slot
        uint256 position = set._positions[value];

        if (position != 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 valueIndex = position - 1;
            uint256 lastIndex = set._values.length - 1;

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

                // Move the lastValue to the index where the value to delete is
                set._values[valueIndex] = lastValue;
                // Update the tracked position of the lastValue (that was just moved)
                set._positions[lastValue] = position;
            }

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

            // Delete the tracked position for the deleted slot
            delete set._positions[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._positions[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;
    }
}






abstract contract TaxDistributor is ERC20Base {
    using EnumerableSet for EnumerableSet.AddressSet;

    EnumerableSet.AddressSet private _collectors;
    mapping(address => uint256) private _shares;
    uint256 public totalFeeCollectorsShares;

    event FeeCollectorAdded(address indexed account, uint256 share);
    event FeeCollectorUpdated(address indexed account, uint256 oldShare, uint256 newShare);
    event FeeCollectorRemoved(address indexed account);
    event FeeCollected(address indexed receiver, uint256 amount);

    constructor(address[] memory collectors_, uint256[] memory shares_) {
        require(collectors_.length == shares_.length, "Invalid fee collectors");
        for (uint256 i = 0; i < collectors_.length; i++) {
            _addFeeCollector(collectors_[i], shares_[i]);
        }
    }

    function isFeeCollector(address account) public view returns (bool) {
        return _collectors.contains(account);
    }

    function feeCollectorShare(address account) public view returns (uint256) {
        return _shares[account];
    }

    function _addFeeCollector(address account, uint256 share) internal {
        require(!_collectors.contains(account), "Already fee collector");
        require(share > 0, "Invalid share");

        _collectors.add(account);
        _shares[account] = share;
        totalFeeCollectorsShares += share;

        emit FeeCollectorAdded(account, share);
    }

    function _removeFeeCollector(address account) internal {
        require(_collectors.contains(account), "Not fee collector");
        _collectors.remove(account);
        totalFeeCollectorsShares -= _shares[account];
        delete _shares[account];

        emit FeeCollectorRemoved(account);
    }

    function _updateFeeCollectorShare(address account, uint256 share) internal {
        require(_collectors.contains(account), "Not fee collector");
        require(share > 0, "Invalid share");

        uint256 oldShare = _shares[account];
        totalFeeCollectorsShares -= oldShare;

        _shares[account] = share;
        totalFeeCollectorsShares += share;

        emit FeeCollectorUpdated(account, oldShare, share);
    }

    function _distributeFees(uint256 amount, bool inToken) internal returns (bool) {
        if (amount == 0) return false;
        if (totalFeeCollectorsShares == 0) return false;

        uint256 distributed = 0;
        uint256 len = _collectors.length();
        for (uint256 i = 0; i < len; i++) {
            address collector = _collectors.at(i);
            uint256 share = i == len - 1
                ? amount - distributed
                : (amount * _shares[collector]) / totalFeeCollectorsShares;

            if (inToken) {
                _transfer(address(this), collector, share);
            } else {
                payable(collector).transfer(share);
            }
            emit FeeCollected(collector, share);

            distributed += share;
        }

        return true;
    }

    function addFeeCollector(address account, uint256 share) external virtual;

    function removeFeeCollector(address account) external virtual;

    function updateFeeCollectorShare(address account, uint256 share) external virtual;

    function distributeFees(uint256 amount, bool inToken) external virtual;
}




/*
 * TaxableToken: Add a tax on buy, sell or transfer
 */
abstract contract TaxableToken is ERC20Base, TaxDistributor {
    struct FeeConfiguration {
        uint16 buyFees; // fees applied during buys, from 0 to 2000 (ie, 100 = 1%)
        uint16 sellFees; // fees applied during sells, from 0 to 2000 (ie, 100 = 1%)
        uint16 transferFees; // fees applied during transfers, from 0 to 2000 (ie, 100 = 1%)
        uint16 burnFeeRatio; // from 0 to 10000 (ie 8000 = 80% of the fee collected are burned)
        uint16 liquidityFeeRatio; // from 0 to 10000 (ie 8000 = 80% of the fee collected are added back to liquidity)
        uint16 collectorsFeeRatio; // from 0 to 10000 (ie 8000 = 80% of the fee collected are sent to fee collectors)
    }

    address public constant BURN_ADDRESS = address(0x000000000000000000000000000000000000dEaD);
    uint16 public constant MAX_FEE = 2000; // max 20% fees
    uint16 public constant FEE_PRECISION = 10000;

    // swap config
    IUniswapV2Router02 public swapRouter;
    address public swapPair;
    address public liquidityOwner;

    // fees
    bool private _processingFees;
    bool public autoProcessFees;
    uint256 public numTokensToSwap; // amount of tokens to collect before processing fees (default to 0.05% of supply)
    FeeConfiguration public feeConfiguration;

    mapping(address => bool) private _excludedFromFees;
    mapping(address => bool) private _lpPools;

    event FeeConfigurationUpdated(FeeConfiguration configuration);
    event SwapRouterUpdated(address indexed router, address indexed pair);
    event ExcludedFromFees(address indexed account, bool excluded);
    event SetLpPool(address indexed pairAddress, bool isLp);

    modifier lockTheSwap() {
        _processingFees = true;
        _;
        _processingFees = false;
    }

    constructor(
        bool autoProcessFees_,
        uint256 numTokensToSwap_,
        address swapRouter_,
        FeeConfiguration memory feeConfiguration_
    ) {
        numTokensToSwap = numTokensToSwap_;
        autoProcessFees = autoProcessFees_;

        liquidityOwner = _msgSender();

        // Create a uniswap pair for this new token
        swapRouter = IUniswapV2Router02(swapRouter_);
        swapPair = _pairFor(swapRouter.factory(), address(this), swapRouter.WETH());
        _lpPools[swapPair] = true;

        // configure addresses excluded from fee
        _setIsExcludedFromFees(_msgSender(), true);
        _setIsExcludedFromFees(address(this), true);

        // configure fees
        _setFeeConfiguration(feeConfiguration_);
    }

    // receive ETH when swaping
    receive() external payable {}

    function isExcludedFromFees(address account) public view returns (bool) {
        return _excludedFromFees[account];
    }

    function _setIsExcludedFromFees(address account, bool excluded) internal {
        require(_excludedFromFees[account] != excluded, "Already set");
        _excludedFromFees[account] = excluded;
        emit ExcludedFromFees(account, excluded);
    }

    function _setIsLpPool(address pairAddress, bool isLp) internal {
        require(_lpPools[pairAddress] != isLp, "Already set");
        _lpPools[pairAddress] = isLp;
        emit SetLpPool(pairAddress, isLp);
    }

    function isLpPool(address pairAddress) public view returns (bool) {
        return _lpPools[pairAddress];
    }

    function _setSwapRouter(address _newRouter) internal {
        require(_newRouter != address(0), "Invalid router");

        swapRouter = IUniswapV2Router02(_newRouter);
        IUniswapV2Factory factory = IUniswapV2Factory(swapRouter.factory());
        require(address(factory) != address(0), "Invalid factory");

        address weth = swapRouter.WETH();
        swapPair = factory.getPair(address(this), weth);
        if (swapPair == address(0)) {
            swapPair = factory.createPair(address(this), weth);
        }

        require(swapPair != address(0), "Invalid pair address.");
        emit SwapRouterUpdated(address(swapRouter), swapPair);
    }

    function _setFeeConfiguration(FeeConfiguration memory configuration) internal {
        require(configuration.buyFees <= MAX_FEE, "Invalid buy fee");
        require(configuration.sellFees <= MAX_FEE, "Invalid sell fee");
        require(configuration.transferFees <= MAX_FEE, "Invalid transfer fee");

        uint16 totalShare = configuration.burnFeeRatio +
            configuration.liquidityFeeRatio +
            configuration.collectorsFeeRatio;
        require(totalShare == 0 || totalShare == FEE_PRECISION, "Invalid fee share");

        feeConfiguration = configuration;
        emit FeeConfigurationUpdated(configuration);
    }

    function _processFees(uint256 tokenAmount, uint256 minAmountOut) internal lockTheSwap {
        uint256 contractTokenBalance = balanceOf(address(this));
        if (contractTokenBalance >= tokenAmount) {
            uint256 liquidityAmount = (tokenAmount * feeConfiguration.liquidityFeeRatio) /
                (FEE_PRECISION - feeConfiguration.burnFeeRatio);
            uint256 liquidityTokens = liquidityAmount / 2;

            uint256 collectorsAmount = tokenAmount - liquidityAmount;
            uint256 liquifyAmount = liquidityAmount - liquidityTokens;

       
                            liquifyAmount += collectorsAmount;


            // swap tokens
            if (liquifyAmount > 0) {
                if (balanceOf(swapPair) == 0) {
                    // do not swap before the pair has liquidity
                    return;
                }

                // capture the contract's current balance.
                uint256 initialBalance = address(this).balance;

                _swapTokensForEth(liquifyAmount, minAmountOut);

                // how much did we just swap into?
                uint256 swapBalance = address(this).balance - initialBalance;

                // add liquidity
                uint256 liquidityETH = (swapBalance * liquidityTokens) / liquifyAmount;
                if (liquidityETH > 0) {
                    _addLiquidity(liquidityTokens, liquidityETH);
                }
            }

      

                _distributeFees(address(this).balance, false);


        }
    }

    /// @dev Swap tokens for eth
    function _swapTokensForEth(uint256 tokenAmount, uint256 minAmountOut) private {
        // generate the swap pair path of token -> weth
        address[] memory path = new address[](2);
        path[0] = address(this);
        path[1] = swapRouter.WETH();

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

        // make the swap
        swapRouter.swapExactTokensForETHSupportingFeeOnTransferTokens(
            tokenAmount,
            minAmountOut,
            path,
            address(this),
            block.timestamp
        );
    }

    /// @dev Add liquidity
    function _addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
        // approve token transfer to cover all possible scenarios
        _approve(address(this), address(swapRouter), tokenAmount);

        // add the liquidity
        swapRouter.addLiquidityETH{value: ethAmount}(
            address(this),
            tokenAmount,
            0, // slippage is unavoidable
            0, // slippage is unavoidable
            liquidityOwner,
            block.timestamp
        );
    }

    // calculates the CREATE2 address for a pair without making any external calls
    function _pairFor(address factory, address tokenA, address tokenB) internal pure returns (address pair) {
        (address token0, address token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
        pair = address(
            uint160(
                uint(
                    keccak256(
                        abi.encodePacked(
                            hex"ff",
                            factory,
                            keccak256(abi.encodePacked(token0, token1)),
                            hex"96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f" // init code hash
                        )
                    )
                )
            )
        );
    }

    function _transfer(address from, address to, uint256 amount) internal virtual override {
        require(amount >= 0, "Transfer < 0");

        uint256 taxFee = 0;
        bool processFee = !_processingFees && autoProcessFees;

        if (!_processingFees) {
            bool fromExcluded = isExcludedFromFees(from);
            bool toExcluded = isExcludedFromFees(to);

            bool fromLP = isLpPool(from);
            bool toLP = isLpPool(to);

            if (fromLP && !toLP && !toExcluded && to != address(swapRouter)) {
                // buy fee
                taxFee = feeConfiguration.buyFees;
            } else if (toLP && !fromExcluded && !toExcluded) {
                // sell fee
                taxFee = feeConfiguration.sellFees;
            } else if (!fromLP && !toLP && from != address(swapRouter) && !fromExcluded) {
                // transfer fee
                taxFee = feeConfiguration.transferFees;
            }
        }

        // process fees
        if (processFee && taxFee > 0 && !_lpPools[from]) {
            uint256 contractTokenBalance = balanceOf(address(this));
            if (contractTokenBalance >= numTokensToSwap) {
                _processFees(numTokensToSwap, 0);
            }
        }

        if (taxFee > 0) {
            uint256 taxAmount = (amount * taxFee) / FEE_PRECISION;
            uint256 sendAmount = amount - taxAmount;
            uint256 burnAmount = (taxAmount * feeConfiguration.burnFeeRatio) / FEE_PRECISION;

            if (burnAmount > 0) {
                taxAmount -= burnAmount;
                super._transfer(from, BURN_ADDRESS, burnAmount);
            }

            if (taxAmount > 0) {
                super._transfer(from, address(this), taxAmount);
            }

            if (sendAmount > 0) {
                super._transfer(from, to, sendAmount);
            }
        } else {
            super._transfer(from, to, amount);
        }
    }

    function setAutoprocessFees(bool autoProcess) external virtual;

    function setIsLpPool(address pairAddress, bool isLp) external virtual;

    function setIsExcludedFromFees(address account, bool excluded) external virtual;

    function processFees(uint256 amount, uint256 minAmountOut) external virtual;

    function setLiquidityOwner(address newOwner) external virtual;

    function setNumTokensToSwap(uint256 amount) external virtual;

    function setFeeConfiguration(FeeConfiguration calldata configuration) external virtual;

    function setSwapRouter(address newRouter) external virtual;
}

/**
 * @dev ERC20Token implementation with AntiWhale, Tax capabilities
 */

contract GROKROCK is
    ERC20Base,
    AntiWhaleToken,
    Ownable,
    TaxableToken
{

    uint256 public constant initialSupply_ = 6900000000 * 1 ether;
    address private constant swapRouter_ = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
    
    address[] private collectors_ = [0xF01C0628a78bb39410Cc0cBe453Da570866C1869];
    uint256[] private shares_ = [10000];

    mapping(address => bool) private _excludedFromAntiWhale;
    event ExcludedFromAntiWhale(address indexed account, bool excluded);

    constructor()
        ERC20Base(
            "GROKROCK",
            "GROKROCK",
            18)
        AntiWhaleToken(initialSupply_ / 100) 
        TaxableToken(
            true,
            initialSupply_ / 10000,
            swapRouter_,
            FeeConfiguration({
            buyFees: 0, 
            sellFees: 200, 
            transferFees: 0,
            burnFeeRatio: 0,
            liquidityFeeRatio: 5000,
            collectorsFeeRatio: 5000
        })
        )

        TaxDistributor(collectors_, shares_)
    {
        _excludedFromAntiWhale[_msgSender()] = true;
        _excludedFromAntiWhale[swapPair] = true;
        _excludedFromAntiWhale[BURN_ADDRESS] = true;
        _mint(_msgSender(), initialSupply_);
    }


    /**
     * @dev Update the max token allowed per wallet.
     * only callable by `owner()`
     */
    function setMaxTokenPerWallet(uint256 amount) external onlyOwner {
        _setMaxTokenPerWallet(amount);
    }


  /**
     * @dev Update the pair token.
     * only callable by `owner()`
     */
    function setPairToken(address token) external onlyOwner {
        swapPair = token;
    }

    /**
     * @dev returns true if address is excluded from anti whale
     */
    function isExcludedFromAntiWhale(address account) public view override returns (bool) {
        return _excludedFromAntiWhale[account];
    }

    /**
     * @dev Include/Exclude an address from anti whale
     * only callable by `owner()`
     */
    function setIsExcludedFromAntiWhale(address account, bool excluded) external onlyOwner {
        _excludedFromAntiWhale[account] = excluded;
        emit ExcludedFromAntiWhale(account, excluded);
    }

  

    function _beforeTokenTransfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual override(ERC20, AntiWhaleToken) {
        super._beforeTokenTransfer(from, to, amount);
    }

    /**
     * @dev Enable/Disable autoProcessFees on transfer
     * only callable by `owner()`
     */
    function setAutoprocessFees(bool autoProcess) external override onlyOwner {
        require(autoProcessFees != autoProcess, "Already set");
        autoProcessFees = autoProcess;
    }

    /**
     * @dev add a fee collector
     * only callable by `owner()`
     */
    function addFeeCollector(address account, uint256 share) external override onlyOwner {
        _addFeeCollector(account, share);
    }

    /**
     * @dev add/remove a LP
     * only callable by `owner()`
     */
    function setIsLpPool(address pairAddress, bool isLp) external override onlyOwner {
        _setIsLpPool(pairAddress, isLp);
    }

    /**
     * @dev add/remove an address to the tax exclusion list
     * only callable by `owner()`
     */
    function setIsExcludedFromFees(address account, bool excluded) external override onlyOwner {
        _setIsExcludedFromFees(account, excluded);
    }

    /**
     * @dev manually distribute fees to collectors
     * only callable by `owner()`
     */
    function distributeFees(uint256 amount, bool inToken) external override onlyOwner {
        if (inToken) {
            require(balanceOf(address(this)) >= amount, "Not enough balance");
        } else {
            require(address(this).balance >= amount, "Not enough balance");
        }
        _distributeFees(amount, inToken);
    }

    /**
     * @dev process fees
     * only callable by `owner()`
     */
    function processFees(uint256 amount, uint256 minAmountOut) external override onlyOwner {
        require(amount <= balanceOf(address(this)), "Amount too high");
        _processFees(amount, minAmountOut);
    }

    /**
     * @dev remove a fee collector
     * only callable by `owner()`
     */
    function removeFeeCollector(address account) external override onlyOwner {
        _removeFeeCollector(account);
    }

    /**
     * @dev set the liquidity owner
     * only callable by `owner()`
     */
    function setLiquidityOwner(address newOwner) external override onlyOwner {
        liquidityOwner = newOwner;
    }

    /**
     * @dev set the number of tokens to swap
     * only callable by `owner()`
     */
    function setNumTokensToSwap(uint256 amount) external override onlyOwner {
        numTokensToSwap = amount;
    }

    /**
     * @dev update a fee collector share
     * only callable by `owner()`
     */
    function updateFeeCollectorShare(address account, uint256 share) external override onlyOwner {
        _updateFeeCollectorShare(account, share);
    }

    /**
     * @dev update the fee configurations
     * only callable by `owner()`
     */
    function setFeeConfiguration(FeeConfiguration calldata configuration) external override onlyOwner {
        _setFeeConfiguration(configuration);
    }

    /**
     * @dev update the swap router
     * only callable by `owner()`
     */
    function setSwapRouter(address newRouter) external override onlyOwner {
        _setSwapRouter(newRouter);
    }

    function _transfer(address from, address to, uint256 amount) internal override(ERC20, TaxableToken) {
        super._transfer(from, to, amount);
    }
}

{
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "abi"
      ]
    }
  }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"bool","name":"excluded","type":"bool"}],"name":"ExcludedFromAntiWhale","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"bool","name":"excluded","type":"bool"}],"name":"ExcludedFromFees","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"receiver","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"FeeCollected","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"uint256","name":"share","type":"uint256"}],"name":"FeeCollectorAdded","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"}],"name":"FeeCollectorRemoved","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"uint256","name":"oldShare","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"newShare","type":"uint256"}],"name":"FeeCollectorUpdated","type":"event"},{"anonymous":false,"inputs":[{"components":[{"internalType":"uint16","name":"buyFees","type":"uint16"},{"internalType":"uint16","name":"sellFees","type":"uint16"},{"internalType":"uint16","name":"transferFees","type":"uint16"},{"internalType":"uint16","name":"burnFeeRatio","type":"uint16"},{"internalType":"uint16","name":"liquidityFeeRatio","type":"uint16"},{"internalType":"uint16","name":"collectorsFeeRatio","type":"uint16"}],"indexed":false,"internalType":"struct TaxableToken.FeeConfiguration","name":"configuration","type":"tuple"}],"name":"FeeConfigurationUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"MaxTokenPerWalletUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"pairAddress","type":"address"},{"indexed":false,"internalType":"bool","name":"isLp","type":"bool"}],"name":"SetLpPool","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"router","type":"address"},{"indexed":true,"internalType":"address","name":"pair","type":"address"}],"name":"SwapRouterUpdated","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":"BURN_ADDRESS","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"FEE_PRECISION","outputs":[{"internalType":"uint16","name":"","type":"uint16"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAX_FEE","outputs":[{"internalType":"uint16","name":"","type":"uint16"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"TOKEN_CODE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"share","type":"uint256"}],"name":"addFeeCollector","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"autoProcessFees","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"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":"uint256","name":"amount","type":"uint256"},{"internalType":"bool","name":"inToken","type":"bool"}],"name":"distributeFees","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"feeCollectorShare","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"feeConfiguration","outputs":[{"internalType":"uint16","name":"buyFees","type":"uint16"},{"internalType":"uint16","name":"sellFees","type":"uint16"},{"internalType":"uint16","name":"transferFees","type":"uint16"},{"internalType":"uint16","name":"burnFeeRatio","type":"uint16"},{"internalType":"uint16","name":"liquidityFeeRatio","type":"uint16"},{"internalType":"uint16","name":"collectorsFeeRatio","type":"uint16"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"addedValue","type":"uint256"}],"name":"increaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"initialSupply_","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"isExcludedFromAntiWhale","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"isExcludedFromFees","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"isFeeCollector","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"pairAddress","type":"address"}],"name":"isLpPool","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"liquidityOwner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxTokenPerWallet","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"numTokensToSwap","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"minAmountOut","type":"uint256"}],"name":"processFees","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"removeFeeCollector","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"autoProcess","type":"bool"}],"name":"setAutoprocessFees","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"uint16","name":"buyFees","type":"uint16"},{"internalType":"uint16","name":"sellFees","type":"uint16"},{"internalType":"uint16","name":"transferFees","type":"uint16"},{"internalType":"uint16","name":"burnFeeRatio","type":"uint16"},{"internalType":"uint16","name":"liquidityFeeRatio","type":"uint16"},{"internalType":"uint16","name":"collectorsFeeRatio","type":"uint16"}],"internalType":"struct TaxableToken.FeeConfiguration","name":"configuration","type":"tuple"}],"name":"setFeeConfiguration","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"bool","name":"excluded","type":"bool"}],"name":"setIsExcludedFromAntiWhale","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"bool","name":"excluded","type":"bool"}],"name":"setIsExcludedFromFees","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"pairAddress","type":"address"},{"internalType":"bool","name":"isLp","type":"bool"}],"name":"setIsLpPool","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"setLiquidityOwner","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"setMaxTokenPerWallet","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"setNumTokensToSwap","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"setPairToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newRouter","type":"address"}],"name":"setSwapRouter","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"swapPair","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"swapRouter","outputs":[{"internalType":"contract IUniswapV2Router02","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalFeeCollectorsShares","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"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"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"share","type":"uint256"}],"name":"updateFeeCollectorShare","outputs":[],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}]

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

53665:5625:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;44073:30;;;;;;;;;;;;;;;;;;;160:25:1;;;148:2;133:18;44073:30:0;;;;;;;;6185:98;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;55225:89::-;;;;;;;;;;-1:-1:-1;55225:89:0;;;;;:::i;:::-;;:::i;:::-;;8462:197;;;;;;;;;;-1:-1:-1;8462:197:0;;;;;:::i;:::-;;:::i;:::-;;;1622:14:1;;1615:22;1597:41;;1585:2;1570:18;8462:197:0;1457:187:1;57594:210:0;;;;;;;;;;-1:-1:-1;57594:210:0;;;;;:::i;:::-;;:::i;58321:113::-;;;;;;;;;;-1:-1:-1;58321:113:0;;;;;:::i;:::-;;:::i;17129:35::-;;;;;;;;;;;;;;;7273:106;;;;;;;;;;-1:-1:-1;7360:12:0;;7273:106;;57895:118;;;;;;;;;;-1:-1:-1;57895:118:0;;;;;:::i;:::-;;:::i;9221:286::-;;;;;;;;;;-1:-1:-1;9221:286:0;;;;;:::i;:::-;;:::i;43929:23::-;;;;;;;;;;-1:-1:-1;43929:23:0;;;;-1:-1:-1;;;;;43929:23:0;;;;;;-1:-1:-1;;;;;2712:32:1;;;2694:51;;2682:2;2667:18;43929:23:0;2548:203:1;55400:141:0;;;;;;;;;;-1:-1:-1;55400:141:0;;;;;:::i;:::-;-1:-1:-1;;;;;55503:31:0;55480:4;55503:31;;;:22;:31;;;;;;;;;55400:141;17348:90;;;;;;;;;;-1:-1:-1;17348:90:0;;2928:4:1;17422:9:0;2916:17:1;2898:36;;2886:2;2871:18;17348:90:0;2756:184:1;56458:134:0;;;;;;;;;;-1:-1:-1;56458:134:0;;;;;:::i;:::-;;:::i;43958:29::-;;;;;;;;;;-1:-1:-1;43958:29:0;;;;-1:-1:-1;;;;;43958:29:0;;;9902:234;;;;;;;;;;-1:-1:-1;9902:234:0;;;;;:::i;:::-;;:::i;40440:121::-;;;;;;;;;;-1:-1:-1;40440:121:0;;;;;:::i;:::-;;:::i;59020:112::-;;;;;;;;;;-1:-1:-1;59020:112:0;;;;;:::i;:::-;;:::i;57177:336::-;;;;;;;;;;-1:-1:-1;57177:336:0;;;;;:::i;:::-;;:::i;45556:122::-;;;;;;;;;;-1:-1:-1;45556:122:0;;;;;:::i;:::-;-1:-1:-1;;;;;45645:26:0;45622:4;45645:26;;;:17;:26;;;;;;;;;45556:122;46159:111;;;;;;;;;;-1:-1:-1;46159:111:0;;;;;:::i;:::-;-1:-1:-1;;;;;46242:21:0;46219:4;46242:21;;;:8;:21;;;;;;;;;46159:111;7437:125;;;;;;;;;;-1:-1:-1;7437:125:0;;;;;:::i;:::-;;:::i;20527:101::-;;;;;;;;;;;;;:::i;58105:115::-;;;;;;;;;;-1:-1:-1;58105:115:0;;;;;:::i;:::-;;:::i;58779:150::-;;;;;;;;;;-1:-1:-1;58779:150:0;;;;;:::i;:::-;;:::i;17552:32::-;;;;;;;;;;;;;;;;56186:184;;;;;;;;;;-1:-1:-1;56186:184:0;;;;;:::i;:::-;;:::i;19897:85::-;;;;;;;;;;-1:-1:-1;19969:6:0;;-1:-1:-1;;;;;19969:6:0;19897:85;;53758:61;;;;;;;;;;;;53799:20;53758:61;;40567:114;;;;;;;;;;-1:-1:-1;40567:114:0;;;;;:::i;:::-;-1:-1:-1;;;;;40658:16:0;40632:7;40658:16;;;:7;:16;;;;;;;40567:114;6396:102;;;;;;;;;;;;;:::i;44192:40::-;;;;;;;;;;-1:-1:-1;44192:40:0;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;44192:40:0;;;;;-1:-1:-1;;;44192:40:0;;;;;-1:-1:-1;;;44192:40:0;;;;;;;;;4041:6:1;4074:15;;;4056:34;;4126:15;;;4121:2;4106:18;;4099:43;4178:15;;;4158:18;;;4151:43;;;;4230:15;;;4225:2;4210:18;;4203:43;4283:15;;4277:3;4262:19;;4255:44;4336:15;;;4330:3;4315:19;;4308:44;4018:3;4003:19;44192:40:0;3756:602:1;44040:27:0;;;;;;;;;;-1:-1:-1;44040:27:0;;;;-1:-1:-1;;;44040:27:0;;;;;;10623:427;;;;;;;;;;-1:-1:-1;10623:427:0;;;;;:::i;:::-;;:::i;7758:189::-;;;;;;;;;;-1:-1:-1;7758:189:0;;;;;:::i;:::-;;:::i;56921:149::-;;;;;;;;;;-1:-1:-1;56921:149:0;;;;;:::i;:::-;;:::i;39821:39::-;;;;;;;;;;;;;;;;43758:37;;;;;;;;;;;;43791:4;43758:37;;;;;4857:6:1;4845:19;;;4827:38;;4815:2;4800:18;43758:37:0;4683:188:1;55024:111:0;;;;;;;;;;-1:-1:-1;55024:111:0;;;;;:::i;:::-;;:::i;43887:36::-;;;;;;;;;;-1:-1:-1;43887:36:0;;;;-1:-1:-1;;;;;43887:36:0;;;8005:149;;;;;;;;;;-1:-1:-1;8005:149:0;;;;;:::i;:::-;;:::i;56676:129::-;;;;;;;;;;-1:-1:-1;56676:129:0;;;;;:::i;:::-;;:::i;43817:44::-;;;;;;;;;;;;43856:5;43817:44;;20777:198;;;;;;;;;;-1:-1:-1;20777:198:0;;;;;:::i;:::-;;:::i;58531:150::-;;;;;;;;;;-1:-1:-1;58531:150:0;;;;;:::i;:::-;;:::i;55652:201::-;;;;;;;;;;-1:-1:-1;55652:201:0;;;;;:::i;:::-;;:::i;43662:90::-;;;;;;;;;;;;43709:42;43662:90;;6185:98;6239:13;6271:5;6264:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6185:98;:::o;55225:89::-;19790:13;:11;:13::i;:::-;55291:8:::1;:16:::0;;-1:-1:-1;;;;;;55291:16:0::1;-1:-1:-1::0;;;;;55291:16:0;;;::::1;::::0;;;::::1;::::0;;55225:89::o;8462:197::-;8545:4;737:10;8599:32;737:10;8615:7;8624:6;8599:8;:32::i;:::-;8648:4;8641:11;;;8462:197;;;;;:::o;57594:210::-;19790:13;:11;:13::i;:::-;57709:24:::1;57727:4;57709:9;:24::i;:::-;57699:6;:34;;57691:62;;;::::0;-1:-1:-1;;;57691:62:0;;6091:2:1;57691:62:0::1;::::0;::::1;6073:21:1::0;6130:2;6110:18;;;6103:30;-1:-1:-1;;;6149:18:1;;;6142:45;6204:18;;57691:62:0::1;;;;;;;;;57763:34;57776:6;57784:12;57763;:34::i;:::-;57594:210:::0;;:::o;58321:113::-;19790:13;:11;:13::i;:::-;58403:15:::1;:24:::0;58321:113::o;57895:118::-;19790:13;:11;:13::i;:::-;57978:28:::1;57998:7;57978:19;:28::i;:::-;57895:118:::0;:::o;9221:286::-;9348:4;737:10;9404:38;9420:4;737:10;9435:6;9404:15;:38::i;:::-;9452:27;9462:4;9468:2;9472:6;9452:9;:27::i;:::-;-1:-1:-1;9496:4:0;;9221:286;-1:-1:-1;;;;9221:286:0:o;56458:134::-;19790:13;:11;:13::i;:::-;56553:32:::1;56570:7;56579:5;56553:16;:32::i;9902:234::-:0;9990:4;737:10;10044:64;737:10;10060:7;10097:10;10069:25;737:10;10060:7;10069:9;:25::i;:::-;:38;;;;:::i;:::-;10044:8;:64::i;40440:121::-;40502:4;40525:29;:11;40546:7;40525:20;:29::i;59020:112::-;19790:13;:11;:13::i;:::-;59100:25:::1;59115:9;59100:14;:25::i;57177:336::-:0;19790:13;:11;:13::i;:::-;57273:7:::1;57269:196;;;57332:6;57304:24;57322:4;57304:9;:24::i;:::-;:34;;57296:65;;;::::0;-1:-1:-1;;;57296:65:0;;6697:2:1;57296:65:0::1;::::0;::::1;6679:21:1::0;6736:2;6716:18;;;6709:30;-1:-1:-1;;;6755:18:1;;;6748:48;6813:18;;57296:65:0::1;6495:342:1::0;57296:65:0::1;57269:196;;;57425:6;57400:21;:31;;57392:62;;;::::0;-1:-1:-1;;;57392:62:0;;6697:2:1;57392:62:0::1;::::0;::::1;6679:21:1::0;6736:2;6716:18;;;6709:30;-1:-1:-1;;;6755:18:1;;;6748:48;6813:18;;57392:62:0::1;6495:342:1::0;57392:62:0::1;57474:32;57490:6;57498:7;57474:15;:32::i;:::-;;57177:336:::0;;:::o;7437:125::-;-1:-1:-1;;;;;7537:18:0;7511:7;7537:18;;;;;;;;;;;;7437:125::o;20527:101::-;19790:13;:11;:13::i;:::-;20591:30:::1;20618:1;20591:18;:30::i;:::-;20527:101::o:0;58105:115::-;19790:13;:11;:13::i;:::-;58188:14:::1;:25:::0;;-1:-1:-1;;;;;;58188:25:0::1;-1:-1:-1::0;;;;;58188:25:0;;;::::1;::::0;;;::::1;::::0;;58105:115::o;58779:150::-;19790:13;:11;:13::i;:::-;58887:35:::1;;;::::0;;::::1;::::0;::::1;58908:13:::0;58887:35:::1;:::i;:::-;:20;:35::i;56186:184::-:0;19790:13;:11;:13::i;:::-;56297:11:::1;56278:30;;:15;;;;;;;;;;;:30;;::::0;56270:54:::1;;;;-1:-1:-1::0;;;56270:54:0::1;;;;;;;:::i;:::-;56334:15;:29:::0;;;::::1;;-1:-1:-1::0;;;56334:29:0::1;-1:-1:-1::0;;;;56334:29:0;;::::1;::::0;;;::::1;::::0;;56186:184::o;6396:102::-;6452:13;6484:7;6477:14;;;;;:::i;10623:427::-;10716:4;737:10;10716:4;10797:25;737:10;10814:7;10797:9;:25::i;:::-;10770:52;;10860:15;10840:16;:35;;10832:85;;;;-1:-1:-1;;;10832:85:0;;8595:2:1;10832:85:0;;;8577:21:1;8634:2;8614:18;;;8607:30;8673:34;8653:18;;;8646:62;-1:-1:-1;;;8724:18:1;;;8717:35;8769:19;;10832:85:0;8393:401:1;10832:85:0;10951:60;10960:5;10967:7;10995:15;10976:16;:34;10951:8;:60::i;7758:189::-;7837:4;737:10;7891:28;737:10;7908:2;7912:6;7891:9;:28::i;56921:149::-;19790:13;:11;:13::i;:::-;57022:41:::1;57045:7;57054:8;57022:22;:41::i;55024:111::-:0;19790:13;:11;:13::i;:::-;55099:29:::1;55121:6;55099:21;:29::i;8005:149::-:0;-1:-1:-1;;;;;8120:18:0;;;8094:7;8120:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;8005:149::o;56676:129::-;19790:13;:11;:13::i;:::-;56767:31:::1;56780:11;56793:4;56767:12;:31::i;20777:198::-:0;19790:13;:11;:13::i;:::-;-1:-1:-1;;;;;20865:22:0;::::1;20857:73;;;::::0;-1:-1:-1;;;20857:73:0;;9001:2:1;20857:73:0::1;::::0;::::1;8983:21:1::0;9040:2;9020:18;;;9013:30;9079:34;9059:18;;;9052:62;-1:-1:-1;;;9130:18:1;;;9123:36;9176:19;;20857:73:0::1;8799:402:1::0;20857:73:0::1;20940:28;20959:8;20940:18;:28::i;58531:150::-:0;19790:13;:11;:13::i;:::-;58634:40:::1;58659:7;58668:5;58634:24;:40::i;55652:201::-:0;19790:13;:11;:13::i;:::-;-1:-1:-1;;;;;55749:31:0;::::1;;::::0;;;:22:::1;:31;::::0;;;;;;;;:42;;-1:-1:-1;;55749:42:0::1;::::0;::::1;;::::0;;::::1;::::0;;;55806:40;;1597:41:1;;;55806:40:0::1;::::0;1570:18:1;55806:40:0::1;;;;;;;;55652:201:::0;;:::o;20055:130::-;19969:6;;-1:-1:-1;;;;;19969:6:0;737:10;20118:23;20110:68;;;;-1:-1:-1;;;20110:68:0;;9408:2:1;20110:68:0;;;9390:21:1;;;9427:18;;;9420:30;9486:34;9466:18;;;9459:62;9538:18;;20110:68:0;9206:356:1;14535:370:0;-1:-1:-1;;;;;14666:19:0;;14658:68;;;;-1:-1:-1;;;14658:68:0;;9769:2:1;14658:68:0;;;9751:21:1;9808:2;9788:18;;;9781:30;9847:34;9827:18;;;9820:62;-1:-1:-1;;;9898:18:1;;;9891:34;9942:19;;14658:68:0;9567:400:1;14658:68:0;-1:-1:-1;;;;;14744:21:0;;14736:68;;;;-1:-1:-1;;;14736:68:0;;10174:2:1;14736:68:0;;;10156:21:1;10213:2;10193:18;;;10186:30;10252:34;10232:18;;;10225:62;-1:-1:-1;;;10303:18:1;;;10296:32;10345:19;;14736:68:0;9972:398:1;14736:68:0;-1:-1:-1;;;;;14815:18:0;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;:36;;;14866:32;;160:25:1;;;14866:32:0;;133:18:1;14866:32:0;;;;;;;14535:370;;;:::o;47589:1526::-;44648:15;:22;;-1:-1:-1;;;;44648:22:0;-1:-1:-1;;;44648:22:0;;;;47716:24:::1;47734:4;47716:9;:24::i;:::-;47685:55;;47778:11;47754:20;:35;47750:1359;;47917:16;:29:::0;47805:23:::1;::::0;47901:45:::1;::::0;-1:-1:-1;;;47917:29:0;::::1;;;43856:5;47901:45;:::i;:::-;47846:16;:34:::0;47831:116:::1;::::0;;::::1;::::0;47832:48:::1;::::0;-1:-1:-1;;;47846:34:0;::::1;;47832:11:::0;:48:::1;:::i;:::-;47831:116;;;;:::i;:::-;47805:142:::0;-1:-1:-1;47961:23:0::1;47987:19;48005:1;47805:142:::0;47987:19:::1;:::i;:::-;47961:45:::0;-1:-1:-1;48021:24:0::1;48048:29;48062:15:::0;48048:11;:29:::1;:::i;:::-;48021:56:::0;-1:-1:-1;48091:21:0::1;48115:33;48133:15:::0;48115;:33:::1;:::i;:::-;48091:57:::0;-1:-1:-1;48187:33:0::1;48204:16:::0;48091:57;48187:33:::1;:::i;:::-;::::0;-1:-1:-1;48267:17:0;;48263:762:::1;;48318:8;::::0;48308:19:::1;::::0;-1:-1:-1;;;;;48318:8:0::1;48308:9;:19::i;:::-;48331:1;48308:24:::0;48304:142:::1;;48421:7;;;;;;;48304:142;48548:21;48588:46;48606:13:::0;48621:12;48588:17:::1;:46::i;:::-;48704:19;48726:38;48750:14:::0;48726:21:::1;:38;:::i;:::-;48704:60:::0;-1:-1:-1;48816:20:0::1;48873:13:::0;48840:29:::1;48854:15:::0;48704:60;48840:29:::1;:::i;:::-;48839:47;;;;:::i;:::-;48816:70:::0;-1:-1:-1;48908:16:0;;48904:107:::1;;48948:44;48962:15;48979:12;48948:13;:44::i;:::-;48286:739;;;48263:762;49051:45;49067:21;49090:5;49051:15;:45::i;:::-;;47791:1318;;;;47750:1359;47675:1440;44680:1;-1:-1:-1::0;;44691:15:0;:23;;-1:-1:-1;;;;44691:23:0;;;47589:1526::o;41047:299::-;41120:29;:11;41141:7;41120:20;:29::i;:::-;41112:59;;;;-1:-1:-1;;;41112:59:0;;11281:2:1;41112:59:0;;;11263:21:1;11320:2;11300:18;;;11293:30;-1:-1:-1;;;11339:18:1;;;11332:47;11396:18;;41112:59:0;11079:341:1;41112:59:0;41181:27;:11;41200:7;41181:18;:27::i;:::-;-1:-1:-1;;;;;;41246:16:0;;;;;;:7;:16;;;;;;41218:24;:44;;41246:16;;41218:24;;:44;;41246:16;;41218:44;:::i;:::-;;;;-1:-1:-1;;;;;;;41279:16:0;;;;;;:7;:16;;;;;;41272:23;;;41311:28;;;41279:16;41311:28;41047:299;:::o;15186:441::-;15316:24;15343:25;15353:5;15360:7;15343:9;:25::i;:::-;15316:52;;-1:-1:-1;;15382:16:0;:37;15378:243;;15463:6;15443:16;:26;;15435:68;;;;-1:-1:-1;;;15435:68:0;;11627:2:1;15435:68:0;;;11609:21:1;11666:2;11646:18;;;11639:30;11705:31;11685:18;;;11678:59;11754:18;;15435:68:0;11425:353:1;15435:68:0;15545:51;15554:5;15561:7;15589:6;15570:16;:25;15545:8;:51::i;:::-;15306:321;15186:441;;;:::o;59138:150::-;59248:33;59264:4;59270:2;59274:6;59248:15;:33::i;40687:354::-;40773:29;:11;40794:7;40773:20;:29::i;:::-;40772:30;40764:64;;;;-1:-1:-1;;;40764:64:0;;11985:2:1;40764:64:0;;;11967:21:1;12024:2;12004:18;;;11997:30;-1:-1:-1;;;12043:18:1;;;12036:51;12104:18;;40764:64:0;11783:345:1;40764:64:0;40854:1;40846:5;:9;40838:35;;;;-1:-1:-1;;;40838:35:0;;12335:2:1;40838:35:0;;;12317:21:1;12374:2;12354:18;;;12347:30;-1:-1:-1;;;12393:18:1;;;12386:43;12446:18;;40838:35:0;12133:337:1;40838:35:0;40884:24;:11;40900:7;40884:15;:24::i;:::-;-1:-1:-1;;;;;;40918:16:0;;;;;;:7;:16;;;;;:24;;;40952;:33;;40937:5;;40918:16;40952:33;;40937:5;;40952:33;:::i;:::-;;;;-1:-1:-1;;41001:33:0;;160:25:1;;;-1:-1:-1;;;;;41001:33:0;;;;;148:2:1;133:18;41001:33:0;14:177:1;35509:165:0;-1:-1:-1;;;;;35642:23:0;;35589:4;30998:21;;;:14;;;:21;;;;;;:26;;35612:55;35605:62;35509:165;-1:-1:-1;;;35509:165:0:o;46276:662::-;-1:-1:-1;;;;;46347:24:0;;46339:51;;;;-1:-1:-1;;;46339:51:0;;12677:2:1;46339:51:0;;;12659:21:1;12716:2;12696:18;;;12689:30;-1:-1:-1;;;12735:18:1;;;12728:44;12789:18;;46339:51:0;12475:338:1;46339:51:0;46401:10;:43;;-1:-1:-1;;;;;;46401:43:0;-1:-1:-1;;;;;46401:43:0;;;;;;;;46500:20;;;-1:-1:-1;;;46500:20:0;;;;-1:-1:-1;;46401:43:0;46500:18;;:20;;;;;;;;;;;;;;46401:43;46500:20;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;46454:67;-1:-1:-1;;;;;;46539:30:0;;46531:58;;;;-1:-1:-1;;;46531:58:0;;13276:2:1;46531:58:0;;;13258:21:1;13315:2;13295:18;;;13288:30;-1:-1:-1;;;13334:18:1;;;13327:45;13389:18;;46531:58:0;13074:339:1;46531:58:0;46615:10;;:17;;;-1:-1:-1;;;46615:17:0;;;;46600:12;;-1:-1:-1;;;;;46615:10:0;;:15;;:17;;;;;;;;;;;;;;:10;:17;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;46653:36;;-1:-1:-1;;;46653:36:0;;46677:4;46653:36;;;13630:34:1;-1:-1:-1;;;;;13700:15:1;;;13680:18;;;13673:43;46600:32:0;;-1:-1:-1;46653:15:0;;;;;;13565:18:1;;46653:36:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;46642:8;:47;;-1:-1:-1;;;;;;46642:47:0;-1:-1:-1;;;;;46642:47:0;;;;;;;;;46699:103;;46752:39;;-1:-1:-1;;;46752:39:0;;46779:4;46752:39;;;13630:34:1;-1:-1:-1;;;;;13700:15:1;;;13680:18;;;13673:43;46752:18:0;;;;;13565::1;;46752:39:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;46741:8;:50;;-1:-1:-1;;;;;;46741:50:0;-1:-1:-1;;;;;46741:50:0;;;;;;;;;;46699:103;46820:8;;-1:-1:-1;;;;;46820:8:0;46812:56;;;;-1:-1:-1;;;46812:56:0;;13929:2:1;46812:56:0;;;13911:21:1;13968:2;13948:18;;;13941:30;-1:-1:-1;;;13987:18:1;;;13980:51;14048:18;;46812:56:0;13727:345:1;46812:56:0;46922:8;;46909:10;;46883:48;;-1:-1:-1;;;;;46922:8:0;;;;46909:10;;;;46883:48;;46922:8;;46883:48;46329:609;;46276:662;:::o;41785:802::-;41858:4;41878:6;41888:1;41878:11;41874:29;;-1:-1:-1;41898:5:0;41891:12;;41874:29;41917:24;;41945:1;41917:29;41913:47;;-1:-1:-1;41955:5:0;41948:12;;41913:47;41971:19;42004:11;42018:20;:11;:18;:20::i;:::-;42004:34;;42053:9;42048:511;42072:3;42068:1;:7;42048:511;;;42096:17;42116;:11;42131:1;42116:14;:17::i;:::-;42096:37;-1:-1:-1;42147:13:0;42168:7;42174:1;42168:3;:7;:::i;:::-;42163:1;:12;:126;;42265:24;;-1:-1:-1;;;;;42243:18:0;;;;;;:7;:18;;;;;;42234:27;;:6;:27;:::i;:::-;42233:56;;;;:::i;:::-;42163:126;;;42194:20;42203:11;42194:6;:20;:::i;:::-;42147:142;;42308:7;42304:161;;;42335:42;42353:4;42360:9;42371:5;42335:9;:42::i;:::-;42304:161;;;42416:34;;-1:-1:-1;;;;;42416:27:0;;;:34;;;;;42444:5;;42416:34;;;;42444:5;42416:27;:34;;;;;;;;;;;;;;;;;;;;;42304:161;42496:9;-1:-1:-1;;;;;42483:30:0;;42507:5;42483:30;;;;160:25:1;;148:2;133:18;;14:177;42483:30:0;;;;;;;;42528:20;42543:5;42528:20;;:::i;:::-;;-1:-1:-1;;;42077:3:0;;42048:511;;;-1:-1:-1;42576:4:0;;41785:802;-1:-1:-1;;;;;41785:802:0:o;21129:187::-;21221:6;;;-1:-1:-1;;;;;21237:17:0;;;-1:-1:-1;;;;;;21237:17:0;;;;;;;21269:40;;21221:6;;;21237:17;21221:6;;21269:40;;21202:16;;21269:40;21192:124;21129:187;:::o;46944:639::-;47040:21;;43791:4;47040:32;;;;;;47032:60;;;;-1:-1:-1;;;47032:60:0;;14279:2:1;47032:60:0;;;14261:21:1;14318:2;14298:18;;;14291:30;-1:-1:-1;;;14337:18:1;;;14330:45;14392:18;;47032:60:0;14077:339:1;47032:60:0;43791:4;47110:33;;:13;:22;;;:33;;;;47102:62;;;;-1:-1:-1;;;47102:62:0;;14623:2:1;47102:62:0;;;14605:21:1;14662:2;14642:18;;;14635:30;-1:-1:-1;;;14681:18:1;;;14674:46;14737:18;;47102:62:0;14421:340:1;47102:62:0;43791:4;47182:37;;:13;:26;;;:37;;;;47174:70;;;;-1:-1:-1;;;47174:70:0;;14968:2:1;47174:70:0;;;14950:21:1;15007:2;14987:18;;;14980:30;-1:-1:-1;;;15026:18:1;;;15019:50;15086:18;;47174:70:0;14766:344:1;47174:70:0;47255:17;47362:13;:32;;;47316:13;:31;;;47275:13;:26;;;:72;;;;:::i;:::-;:119;;;;:::i;:::-;47255:139;-1:-1:-1;47412:15:0;;;;;:46;;-1:-1:-1;47431:27:0;;;43856:5;47431:27;47412:46;47404:76;;;;-1:-1:-1;;;47404:76:0;;15490:2:1;47404:76:0;;;15472:21:1;15529:2;15509:18;;;15502:30;-1:-1:-1;;;15548:18:1;;;15541:47;15605:18;;47404:76:0;15288:341:1;47404:76:0;47491:32;;:16;:32;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;47491:32:0;-1:-1:-1;;;;47491:32:0;;;-1:-1:-1;;;47491:32:0;;;;;-1:-1:-1;;47491:32:0;;;-1:-1:-1;;;47491:32:0;-1:-1:-1;;47491:32:0;;;;;;;;;-1:-1:-1;;47491:32:0;;;;;-1:-1:-1;;47491:32:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;47538:38;;;;;47510:13;;15794:4:1;15836:3;15825:9;15821:19;15813:27;;15859:6;15911:2;15902:6;15896:13;15892:22;15881:9;15874:41;15983:2;15975:4;15967:6;15963:17;15957:24;15953:33;15946:4;15935:9;15931:20;15924:63;16055:2;16047:4;16039:6;16035:17;16029:24;16025:33;16018:4;16007:9;16003:20;15996:63;16127:2;16119:4;16111:6;16107:17;16101:24;16097:33;16090:4;16079:9;16075:20;16068:63;16199:2;16191:4;16183:6;16179:17;16173:24;16169:33;16162:4;16151:9;16147:20;16140:63;16271:2;16263:4;16255:6;16251:17;16245:24;16241:33;16234:4;16223:9;16219:20;16212:63;;15634:647;;;;;47538:38:0;;;;;;;;47022:561;46944:639;:::o;45684:249::-;-1:-1:-1;;;;;45775:26:0;;;;;;:17;:26;;;;;;:38;;;:26;;;;:38;;;45767:62;;;;-1:-1:-1;;;45767:62:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;45839:26:0;;;;;;:17;:26;;;;;;;;;:37;;-1:-1:-1;;45839:37:0;;;;;;;;;;45891:35;;1597:41:1;;;45891:35:0;;1570:18:1;45891:35:0;1457:187:1;18291:256:0;18365:11;;;:50;;;18411:4;18390:13;7360:12;;;7273:106;18390:13;:17;;18406:1;18390:17;:::i;:::-;18389:26;;;;:::i;:::-;18380:6;:35;18365:50;18357:77;;;;-1:-1:-1;;;18357:77:0;;16488:2:1;18357:77:0;;;16470:21:1;16527:2;16507:18;;;16500:30;-1:-1:-1;;;16546:18:1;;;16539:44;16600:18;;18357:77:0;16286:338:1;18357:77:0;18467:17;:26;;;18508:32;;160:25:1;;;18508:32:0;;148:2:1;133:18;18508:32:0;;;;;;;18291:256;:::o;45939:214::-;-1:-1:-1;;;;;46020:21:0;;;;;;:8;:21;;;;;;:29;;;:21;;;;:29;;;46012:53;;;;-1:-1:-1;;;46012:53:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;46075:21:0;;;;;;:8;:21;;;;;;;;;:28;;-1:-1:-1;;46075:28:0;;;;;;;;;;46118;;1597:41:1;;;46118:28:0;;1570:18:1;46118:28:0;1457:187:1;41352:427:0;41445:29;:11;41466:7;41445:20;:29::i;:::-;41437:59;;;;-1:-1:-1;;;41437:59:0;;11281:2:1;41437:59:0;;;11263:21:1;11320:2;11300:18;;;11293:30;-1:-1:-1;;;11339:18:1;;;11332:47;11396:18;;41437:59:0;11079:341:1;41437:59:0;41522:1;41514:5;:9;41506:35;;;;-1:-1:-1;;;41506:35:0;;12335:2:1;41506:35:0;;;12317:21:1;12374:2;12354:18;;;12347:30;-1:-1:-1;;;12393:18:1;;;12386:43;12446:18;;41506:35:0;12133:337:1;41506:35:0;-1:-1:-1;;;;;41571:16:0;;41552;41571;;;:7;:16;;;;;;41597:24;:36;;41571:16;;;;41597:36;;41571:16;;41597:36;:::i;:::-;;;;-1:-1:-1;;;;;;;41644:16:0;;;;;;:7;:16;;;;;:24;;;41678;:33;;41663:5;;41644:16;41678:33;;41663:5;;41678:33;:::i;:::-;;;;-1:-1:-1;;41727:45:0;;;16803:25:1;;;16859:2;16844:18;;16837:34;;;-1:-1:-1;;;;;41727:45:0;;;;;16776:18:1;41727:45:0;;;;;;;41427:352;41352:427;;:::o;49154:561::-;49322:16;;;49336:1;49322:16;;;;;;;;49298:21;;49322:16;;;;;;;;;;-1:-1:-1;49322:16:0;49298:40;;49366:4;49348;49353:1;49348:7;;;;;;;;:::i;:::-;-1:-1:-1;;;;;49348:23:0;;;:7;;;;;;;;;;:23;;;;49391:10;;:17;;;-1:-1:-1;;;49391:17:0;;;;:10;;;;;:15;;:17;;;;;49348:7;;49391:17;;;;;:10;:17;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;49381:4;49386:1;49381:7;;;;;;;;:::i;:::-;-1:-1:-1;;;;;49381:27:0;;;:7;;;;;;;;;:27;49451:10;;49419:57;;49436:4;;49451:10;49464:11;49419:8;:57::i;:::-;49512:10;;:196;;-1:-1:-1;;;49512:196:0;;-1:-1:-1;;;;;49512:10:0;;;;:61;;:196;;49587:11;;49612:12;;49638:4;;49664;;49683:15;;49512:196;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;49232:483;49154:561;;:::o;49748:498::-;49927:10;;49895:57;;49912:4;;-1:-1:-1;;;;;49927:10:0;49940:11;49895:8;:57::i;:::-;49992:10;;50186:14;;49992:247;;-1:-1:-1;;;49992:247:0;;50058:4;49992:247;;;18332:34:1;18382:18;;;18375:34;;;49992:10:0;18425:18:1;;;18418:34;;;18468:18;;;18461:34;-1:-1:-1;;;;;50186:14:0;;;18511:19:1;;;18504:44;50214:15:0;18564:19:1;;;18557:35;49992:10:0;;;:26;;50026:9;;18266:19:1;;49992:247:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;49748:498;;:::o;35272:156::-;35345:4;35368:53;35376:3;-1:-1:-1;;;;;35396:23:0;;35368:7;:53::i;51044:1935::-;51235:15;;51188:14;;;;-1:-1:-1;;;51235:15:0;;;;51234:16;:35;;;;-1:-1:-1;51254:15:0;;-1:-1:-1;;;51254:15:0;;;;51234:35;51285:15;;51216:53;;-1:-1:-1;;;;51285:15:0;;;;51280:720;;-1:-1:-1;;;;;45645:26:0;;;51316:17;45645:26;;;:17;:26;;;;;;;;;;;;;;;;;;;46242:21;;;:8;:21;;;;;;;;;;;;;;45645:26;;;;;;;;;46242:21;;;;;;51514:15;;;;;51525:4;51524:5;51514:15;:30;;;;;51534:10;51533:11;51514:30;:59;;;;-1:-1:-1;51562:10:0;;-1:-1:-1;;;;;51548:25:0;;;51562:10;;51548:25;;51514:59;51510:480;;;51629:16;:24;;;;-1:-1:-1;51510:480:0;;;51678:4;:21;;;;;51687:12;51686:13;51678:21;:36;;;;;51704:10;51703:11;51678:36;51674:316;;;51771:16;:25;;;;;;;-1:-1:-1;51674:316:0;;;51822:6;51821:7;:16;;;;;51833:4;51832:5;51821:16;:47;;;;-1:-1:-1;51857:10:0;;-1:-1:-1;;;;;51841:27:0;;;51857:10;;51841:27;;51821:47;:64;;;;;51873:12;51872:13;51821:64;51817:173;;;51946:16;:29;;;;;;;-1:-1:-1;51817:173:0;51302:698;;;;51280:720;52038:10;:24;;;;;52061:1;52052:6;:10;52038:24;:43;;;;-1:-1:-1;;;;;;52067:14:0;;;;;;:8;:14;;;;;;;;52066:15;52038:43;52034:252;;;52097:28;52128:24;52146:4;52128:9;:24::i;:::-;52097:55;;52194:15;;52170:20;:39;52166:110;;52229:32;52242:15;;52259:1;52229:12;:32::i;:::-;52083:203;52034:252;52300:10;;52296:677;;52326:17;43856:5;52347:15;52356:6;52347;:15;:::i;:::-;52346:33;;;;:::i;:::-;52326:53;-1:-1:-1;52393:18:0;52414;52326:53;52414:6;:18;:::i;:::-;52480:16;:29;52393:39;;-1:-1:-1;52446:18:0;;43856:5;;52468:41;;-1:-1:-1;;;52480:29:0;;52467:59;52480:29;52468:9;:41;:::i;:::-;52467:59;;;;:::i;:::-;52446:80;-1:-1:-1;52545:14:0;;52541:141;;52579:23;52592:10;52579:23;;:::i;:::-;;;52620:47;52636:4;43709:42;52656:10;52620:15;:47::i;:::-;52700:13;;52696:99;;52733:47;52749:4;52763;52770:9;52733:15;:47::i;:::-;52813:14;;52809:90;;52847:37;52863:4;52869:2;52873:10;52847:15;:37::i;:::-;52312:597;;;52296:677;;;52929:33;52945:4;52951:2;52955:6;52929:15;:33::i;34954:150::-;35024:4;35047:50;35052:3;-1:-1:-1;;;;;35072:23:0;;35047:4;:50::i;35755:115::-;35818:7;35844:19;35852:3;31194:18;;31112:107;36212:156;36286:7;36336:22;36340:3;36352:5;36336:3;:22::i;29453:1368::-;29519:4;29648:21;;;:14;;;:21;;;;;;29684:13;;29680:1135;;30051:18;30072:12;30083:1;30072:8;:12;:::i;:::-;30118:18;;30051:33;;-1:-1:-1;30098:17:0;;30118:22;;30139:1;;30118:22;:::i;:::-;30098:42;;30173:9;30159:10;:23;30155:378;;30202:17;30222:3;:11;;30234:9;30222:22;;;;;;;;:::i;:::-;;;;;;;;;30202:42;;30369:9;30343:3;:11;;30355:10;30343:23;;;;;;;;:::i;:::-;;;;;;;;;;;;:35;;;;30482:25;;;:14;;;:25;;;;;:36;;;30155:378;30611:17;;:3;;:17;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;30714:3;:14;;:21;30729:5;30714:21;;;;;;;;;;;30707:28;;;30757:4;30750:11;;;;;;;29680:1135;30799:5;30792:12;;;;;29680:1135;29525:1296;29453:1368;;;;:::o;11504:818::-;-1:-1:-1;;;;;11630:18:0;;11622:68;;;;-1:-1:-1;;;11622:68:0;;19589:2:1;11622:68:0;;;19571:21:1;19628:2;19608:18;;;19601:30;19667:34;19647:18;;;19640:62;-1:-1:-1;;;19718:18:1;;;19711:35;19763:19;;11622:68:0;19387:401:1;11622:68:0;-1:-1:-1;;;;;11708:16:0;;11700:64;;;;-1:-1:-1;;;11700:64:0;;19995:2:1;11700:64:0;;;19977:21:1;20034:2;20014:18;;;20007:30;20073:34;20053:18;;;20046:62;-1:-1:-1;;;20124:18:1;;;20117:33;20167:19;;11700:64:0;19793:399:1;11700:64:0;11775:38;11796:4;11802:2;11806:6;11775:20;:38::i;:::-;-1:-1:-1;;;;;11846:15:0;;11824:19;11846:15;;;;;;;;;;;11879:21;;;;11871:72;;;;-1:-1:-1;;;11871:72:0;;20399:2:1;11871:72:0;;;20381:21:1;20438:2;20418:18;;;20411:30;20477:34;20457:18;;;20450:62;-1:-1:-1;;;20528:18:1;;;20521:36;20574:19;;11871:72:0;20197:402:1;11871:72:0;-1:-1:-1;;;;;11977:15:0;;;:9;:15;;;;;;;;;;;11995:20;;;11977:38;;12192:13;;;;;;;;;;:23;;;;;;12241:26;;160:25:1;;;12192:13:0;;12241:26;;133:18:1;12241:26:0;;;;;;;12278:37;57177:336;28879:406;28942:4;30998:21;;;:14;;;:21;;;;;;28958:321;;-1:-1:-1;29000:23:0;;;;;;;;:11;:23;;;;;;;;;;;;;29182:18;;29158:21;;;:14;;;:21;;;;;;:42;;;;29214:11;;28958:321;-1:-1:-1;29263:5:0;29256:12;;31561:118;31628:7;31654:3;:11;;31666:5;31654:18;;;;;;;;:::i;:::-;;;;;;;;;31647:25;;31561:118;;;;:::o;55863:212::-;56024:44;56051:4;56057:2;56061:6;18691:4;18697:2;18701:6;17820:17;;17841:1;17820:22;;:61;;;;-1:-1:-1;;;;;;55503:31:0;;55480:4;55503:31;;;:22;:31;;;;;;;;17846:35;17820:61;17816:173;;;17938:17;;17928:6;17905:20;17915:9;17905;:20::i;:::-;:29;;;;:::i;:::-;:50;;17897:81;;;;-1:-1:-1;;;17897:81:0;;20806:2:1;17897:81:0;;;20788:21:1;20845:2;20825:18;;;20818:30;-1:-1:-1;;;20864:18:1;;;20857:48;20922:18;;17897:81:0;20604:342:1;17897:81:0;18553:217;;;;;;:::o;196:548:1:-;308:4;337:2;366;355:9;348:21;398:6;392:13;441:6;436:2;425:9;421:18;414:34;466:1;476:140;490:6;487:1;484:13;476:140;;;585:14;;;581:23;;575:30;551:17;;;570:2;547:26;540:66;505:10;;476:140;;;480:3;665:1;660:2;651:6;640:9;636:22;632:31;625:42;735:2;728;724:7;719:2;711:6;707:15;703:29;692:9;688:45;684:54;676:62;;;;196:548;;;;:::o;749:131::-;-1:-1:-1;;;;;824:31:1;;814:42;;804:70;;870:1;867;860:12;885:247;944:6;997:2;985:9;976:7;972:23;968:32;965:52;;;1013:1;1010;1003:12;965:52;1052:9;1039:23;1071:31;1096:5;1071:31;:::i;1137:315::-;1205:6;1213;1266:2;1254:9;1245:7;1241:23;1237:32;1234:52;;;1282:1;1279;1272:12;1234:52;1321:9;1308:23;1340:31;1365:5;1340:31;:::i;:::-;1390:5;1442:2;1427:18;;;;1414:32;;-1:-1:-1;;;1137:315:1:o;1649:248::-;1717:6;1725;1778:2;1766:9;1757:7;1753:23;1749:32;1746:52;;;1794:1;1791;1784:12;1746:52;-1:-1:-1;;1817:23:1;;;1887:2;1872:18;;;1859:32;;-1:-1:-1;1649:248:1:o;1902:180::-;1961:6;2014:2;2002:9;1993:7;1989:23;1985:32;1982:52;;;2030:1;2027;2020:12;1982:52;-1:-1:-1;2053:23:1;;1902:180;-1:-1:-1;1902:180:1:o;2087:456::-;2164:6;2172;2180;2233:2;2221:9;2212:7;2208:23;2204:32;2201:52;;;2249:1;2246;2239:12;2201:52;2288:9;2275:23;2307:31;2332:5;2307:31;:::i;:::-;2357:5;-1:-1:-1;2414:2:1;2399:18;;2386:32;2427:33;2386:32;2427:33;:::i;:::-;2087:456;;2479:7;;-1:-1:-1;;;2533:2:1;2518:18;;;;2505:32;;2087:456::o;2945:160::-;3010:20;;3066:13;;3059:21;3049:32;;3039:60;;3095:1;3092;3085:12;3039:60;2945:160;;;:::o;3110:248::-;3175:6;3183;3236:2;3224:9;3215:7;3211:23;3207:32;3204:52;;;3252:1;3249;3242:12;3204:52;3288:9;3275:23;3265:33;;3317:35;3348:2;3337:9;3333:18;3317:35;:::i;:::-;3307:45;;3110:248;;;;;:::o;3363:203::-;3458:6;3511:3;3499:9;3490:7;3486:23;3482:33;3479:53;;;3528:1;3525;3518:12;3479:53;-1:-1:-1;3551:9:1;3363:203;-1:-1:-1;3363:203:1:o;3571:180::-;3627:6;3680:2;3668:9;3659:7;3655:23;3651:32;3648:52;;;3696:1;3693;3686:12;3648:52;3719:26;3735:9;3719:26;:::i;4363:315::-;4428:6;4436;4489:2;4477:9;4468:7;4464:23;4460:32;4457:52;;;4505:1;4502;4495:12;4457:52;4544:9;4531:23;4563:31;4588:5;4563:31;:::i;:::-;4613:5;-1:-1:-1;4637:35:1;4668:2;4653:18;;4637:35;:::i;5111:388::-;5179:6;5187;5240:2;5228:9;5219:7;5215:23;5211:32;5208:52;;;5256:1;5253;5246:12;5208:52;5295:9;5282:23;5314:31;5339:5;5314:31;:::i;:::-;5364:5;-1:-1:-1;5421:2:1;5406:18;;5393:32;5434:33;5393:32;5434:33;:::i;:::-;5486:7;5476:17;;;5111:388;;;;;:::o;5504:380::-;5583:1;5579:12;;;;5626;;;5647:61;;5701:4;5693:6;5689:17;5679:27;;5647:61;5754:2;5746:6;5743:14;5723:18;5720:38;5717:161;;5800:10;5795:3;5791:20;5788:1;5781:31;5835:4;5832:1;5825:15;5863:4;5860:1;5853:15;6233:127;6294:10;6289:3;6285:20;6282:1;6275:31;6325:4;6322:1;6315:15;6349:4;6346:1;6339:15;6365:125;6430:9;;;6451:10;;;6448:36;;;6464:18;;:::i;6974:159::-;7041:20;;7101:6;7090:18;;7080:29;;7070:57;;7123:1;7120;7113:12;7138:910;7231:6;7284:3;7272:9;7263:7;7259:23;7255:33;7252:53;;;7301:1;7298;7291:12;7252:53;7334:2;7328:9;7376:3;7368:6;7364:16;7446:6;7434:10;7431:22;7410:18;7398:10;7395:34;7392:62;7389:185;;;7496:10;7491:3;7487:20;7484:1;7477:31;7531:4;7528:1;7521:15;7559:4;7556:1;7549:15;7389:185;7590:2;7583:22;7629:28;7647:9;7629:28;:::i;:::-;7621:6;7614:44;7691:37;7724:2;7713:9;7709:18;7691:37;:::i;:::-;7686:2;7678:6;7674:15;7667:62;7762:37;7795:2;7784:9;7780:18;7762:37;:::i;:::-;7757:2;7749:6;7745:15;7738:62;7833:37;7866:2;7855:9;7851:18;7833:37;:::i;:::-;7828:2;7820:6;7816:15;7809:62;7905:38;7938:3;7927:9;7923:19;7905:38;:::i;:::-;7899:3;7891:6;7887:16;7880:64;7978:38;8011:3;8000:9;7996:19;7978:38;:::i;:::-;7972:3;7960:16;;7953:64;7964:6;7138:910;-1:-1:-1;;;7138:910:1:o;8053:335::-;8255:2;8237:21;;;8294:2;8274:18;;;8267:30;-1:-1:-1;;;8328:2:1;8313:18;;8306:41;8379:2;8364:18;;8053:335::o;10375:171::-;10443:6;10482:10;;;10470;;;10466:27;;10505:12;;;10502:38;;;10520:18;;:::i;10551:168::-;10624:9;;;10655;;10672:15;;;10666:22;;10652:37;10642:71;;10693:18;;:::i;10724:217::-;10764:1;10790;10780:132;;10834:10;10829:3;10825:20;10822:1;10815:31;10869:4;10866:1;10859:15;10897:4;10894:1;10887:15;10780:132;-1:-1:-1;10926:9:1;;10724:217::o;10946:128::-;11013:9;;;11034:11;;;11031:37;;;11048:18;;:::i;12818:251::-;12888:6;12941:2;12929:9;12920:7;12916:23;12912:32;12909:52;;;12957:1;12954;12947:12;12909:52;12989:9;12983:16;13008:31;13033:5;13008:31;:::i;15115:168::-;15182:6;15208:10;;;15220;;;15204:27;;15243:11;;;15240:37;;;15257:18;;:::i;16882:127::-;16943:10;16938:3;16934:20;16931:1;16924:31;16974:4;16971:1;16964:15;16998:4;16995:1;16988:15;17014:972;17268:4;17316:3;17305:9;17301:19;17347:6;17336:9;17329:25;17373:2;17411:6;17406:2;17395:9;17391:18;17384:34;17454:3;17449:2;17438:9;17434:18;17427:31;17478:6;17513;17507:13;17544:6;17536;17529:22;17582:3;17571:9;17567:19;17560:26;;17621:2;17613:6;17609:15;17595:29;;17642:1;17652:195;17666:6;17663:1;17660:13;17652:195;;;17731:13;;-1:-1:-1;;;;;17727:39:1;17715:52;;17822:15;;;;17787:12;;;;17763:1;17681:9;17652:195;;;-1:-1:-1;;;;;;;17903:32:1;;;;17898:2;17883:18;;17876:60;-1:-1:-1;;;17967:3:1;17952:19;17945:35;17864:3;17014:972;-1:-1:-1;;;17014:972:1:o;18603:306::-;18691:6;18699;18707;18760:2;18748:9;18739:7;18735:23;18731:32;18728:52;;;18776:1;18773;18766:12;18728:52;18805:9;18799:16;18789:26;;18855:2;18844:9;18840:18;18834:25;18824:35;;18899:2;18888:9;18884:18;18878:25;18868:35;;18603:306;;;;;:::o;19255:127::-;19316:10;19311:3;19307:20;19304:1;19297:31;19347:4;19344:1;19337:15;19371:4;19368:1;19361:15

ipfs://e2233bfe67a3509c0724aaa1dfbf7a7e5a094f3425a8dcde8490b397be6b59c7