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: UNLICENSED
pragma solidity =0.8.26;
pragma abicoder v2;

import "@uniswap/v3-periphery/contracts/libraries/TransferHelper.sol";
// import "@uniswap/v3-periphery/contracts/interfaces/ISwapRouter.sol";
import "@uniswap/v3-periphery/contracts/interfaces/IQuoterV2.sol";
import "@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";

interface ISwapRouter {
    struct ExactInputSingleParams {
        address tokenIn;
        address tokenOut;
        uint24 fee;
        address recipient;
        uint256 amountIn;
        uint256 amountOutMinimum;
        uint160 sqrtPriceLimitX96;
    }

    function exactInputSingle(ExactInputSingleParams calldata params)
        external
        payable
        returns (uint256 amountOut);

    struct ExactOutputSingleParams {
        address tokenIn;
        address tokenOut;
        uint24 fee;
        address recipient;
        uint256 amountOut;
        uint256 amountInMaximum;
        uint160 sqrtPriceLimitX96;
    }

    function exactOutputSingle(ExactOutputSingleParams calldata params)
        external
        payable
        returns (uint256 amountIn);
}

/// @title Interface for WETH9
interface IWETH is IERC20 {
    /// @notice Deposit ether to get wrapped ether
    function deposit() external payable;

    /// @notice Withdraw wrapped ether to get ether
    function withdraw(uint256) external;
}

interface IUniswapV3Factory {
    function getPool(address tokenA, address tokenB, uint24 fee) external view returns (address);
}

interface IUniswapV3Pool {
    function fee() external view returns (uint24);
}

contract Baseswap is Ownable {
    // Uniswap Router Address
    address private constant UNISWAP_V2_ROUTER_ADDRESS =
        0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
    address private constant UNISWAP_V3_ROUTER_ADDRESS =
        0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45;

    address private WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;

    uint256 BOT_FEE = 100;

    uint256 REF_FEE = 5;

    uint24[4] public feeTiers = [100, 500, 3000, 10000]; // Possible Uniswap V3 fee tiers

    // Uniswap Router
    ISwapRouter public immutable uniswapV3Router; // V3
    IUniswapV2Router02 public immutable uniswapV2Router; // V2

    address BOT_FEE_WALLET;

    constructor(address BOT_FEE_WALLET_) Ownable(msg.sender) {
        BOT_FEE_WALLET = BOT_FEE_WALLET_;
        uniswapV2Router = IUniswapV2Router02(UNISWAP_V2_ROUTER_ADDRESS);
        uniswapV3Router = ISwapRouter(UNISWAP_V3_ROUTER_ADDRESS);
    }

    function BaseBuy(
        uint256 amountOutMin,
        uint24 feeTier,
        address[] calldata path,
        address router,
        address to,
        address referral
    ) external payable {
        require(msg.value > 0, "Must send ETH to swap");
        require(path.length >= 2, "Invalid path");
        require(router != address(0), "Invalid router address");
        require(to != address(0), "Invalid recipient");

        uint256 bot_fee = (msg.value * BOT_FEE) / 1000;
        uint256 ref_fee = 0;
        uint256 amountIn = msg.value - bot_fee;
        uint256 deadline = block.timestamp + 1200;

        if (referral != address(0)) {
            ref_fee = (msg.value * REF_FEE) / 1000;
            amountIn = msg.value - bot_fee - ref_fee;
            payable(referral).transfer(ref_fee);
        }

        if (router == UNISWAP_V2_ROUTER_ADDRESS) {
            // Uniswap V2
            uniswapV2Router.swapExactETHForTokens{value: amountIn}(
                amountOutMin,
                path,
                to,
                deadline
            );
        } else if (router == UNISWAP_V3_ROUTER_ADDRESS) {
            // Note: To use this example, you should explicitly set slippage limits, omitting for simplicity
            // uint256 minOut = /* Calculate min output */ 0;
            // uint160 priceLimit = /* Calculate price limit */ 0;
            // Create the params that will be used to execute the swap
            ISwapRouter.ExactInputSingleParams memory params = ISwapRouter.ExactInputSingleParams({
                    tokenIn: path[0],
                    tokenOut: path[1],
                    fee: feeTier,
                    recipient: to,
                    amountIn: amountIn,
                    amountOutMinimum: amountOutMin,
                    sqrtPriceLimitX96: 0
                });
            // The call to `exactInputSingle` executes the swap.
            uniswapV3Router.exactInputSingle{value: amountIn}(params);
        }

        payable(BOT_FEE_WALLET).transfer(bot_fee);
    }

    function BaseSell_1(
        uint256 amountIn,
        uint256 amountOutMin,
        uint24 feeTier,
        address[] calldata path,
        address router,
        address to,
        address referral
    ) external {
        require(amountIn > 0, "Must send ETH to swap");
        require(path.length >= 2, "Invalid path");
        require(router != address(0), "Invalid router address");
        require(to != address(0), "Invalid recipient");        

        uint256 deadline = block.timestamp + 1200;
        uint256 amountOut_ = 0;

        if (router == UNISWAP_V2_ROUTER_ADDRESS) {
            // Transfer the specified amount of tokens from the sender to this contract
            IERC20(path[0]).transferFrom(msg.sender, address(this), amountIn);

            // Approve the Uniswap router to spend the tokens
            IERC20(path[0]).approve(address(uniswapV2Router), amountIn);            
            // Uniswap V2
            uint256[] memory amounts = uniswapV2Router.swapExactTokensForETH(
                amountIn,
                amountOutMin,
                path,
                address(this),
                deadline
            );

            amountOut_ = amounts[1];
        } else if (router == UNISWAP_V3_ROUTER_ADDRESS) {
            // Transfer the specified amount of WETH9 to this contract.
            TransferHelper.safeTransferFrom(
                path[0],
                msg.sender,
                address(this),
                amountIn
            );
            // Approve the router to spend WETH9.
            TransferHelper.safeApprove(
                path[0],
                address(uniswapV3Router),
                amountIn
            );                    
            // Note: To use this example, you should explicitly set slippage limits, omitting for simplicity
            // uint256 minOut = /* Calculate min output */ 0;
            // uint160 priceLimit = /* Calculate price limit */ 0;
            // Create the params that will be used to execute the swap
            ISwapRouter.ExactInputSingleParams memory params = ISwapRouter
                .ExactInputSingleParams({
                    tokenIn: path[0],
                    tokenOut: path[1],
                    fee: feeTier,
                    recipient: address(this),
                    amountIn: amountIn,
                    amountOutMinimum: amountOutMin,
                    sqrtPriceLimitX96: 0
                });
            // The call to `exactInputSingle` executes the swap.
            amountOut_ = uniswapV3Router.exactInputSingle(params);

            IWETH(path[1]).withdraw(amountOut_);
        }
        uint256 bot_fee = amountOut_ * BOT_FEE / 1000;
        uint256 ref_fee = 0;
        uint256 amountOut__ = amountOut_ - bot_fee;

        if (referral != address(0)) {
            ref_fee = (amountOut_ * REF_FEE) / 1000;
            amountOut__ = amountOut_ - ref_fee - bot_fee;
            payable(referral).transfer(ref_fee);     
        }
        payable(BOT_FEE_WALLET).transfer(bot_fee);   
 
        payable(msg.sender).transfer(amountOut__);
    }    

    function BaseSell_2(
        uint256 amountOut,
        uint256 amountInMax,
        uint24 feeTier,
        address[] calldata path,
        address router,
        address to,
        address referral
    ) external {
        require(amountOut > 0, "Must send ETH to swap");
        require(path.length >= 2, "Invalid path");
        require(router != address(0), "Invalid router address");
        require(to != address(0), "Invalid recipient");
        
        uint256 deadline = block.timestamp + 1200;

        if (router == UNISWAP_V2_ROUTER_ADDRESS) {
            IERC20(path[0]).transferFrom(msg.sender, address(this), amountInMax);

            // Approve the Uniswap router to spend the tokens
            IERC20(path[0]).approve(address(uniswapV2Router), amountInMax);  

            // Uniswap V2
            uniswapV2Router.swapTokensForExactETH(
                amountOut,
                amountInMax,
                path,
                address(this),
                deadline
            );
        } else if (router == UNISWAP_V3_ROUTER_ADDRESS) {              
            // Transfer the specified amount of WETH9 to this contract.
            TransferHelper.safeTransferFrom(
                path[0],
                msg.sender,
                address(this),
                amountInMax
            );
            // Approve the router to spend WETH9.
            TransferHelper.safeApprove(
                path[0],
                address(uniswapV3Router),
                amountInMax
            ); 
            // Note: To use this example, you should explicitly set slippage limits, omitting for simplicity
            // uint256 minOut = /* Calculate min output */ 0;
            // uint160 priceLimit = /* Calculate price limit */ 0;
            // Create the params that will be used to execute the swap
            ISwapRouter.ExactOutputSingleParams memory params = ISwapRouter
                .ExactOutputSingleParams({
                    tokenIn: path[0],
                    tokenOut: path[1],
                    fee: feeTier,
                    recipient: address(this),
                    amountOut: amountOut,
                    amountInMaximum: amountInMax,
                    sqrtPriceLimitX96: 0
                });
            // The call to `exactInputSingle` executes the swap.
            uniswapV3Router.exactOutputSingle(params);   

            IWETH(path[1]).withdraw(amountOut);             
        }

        uint256 bot_fee = amountOut * BOT_FEE / 1000;
        uint256 ref_fee = 0;
        uint256 amountOut_ = amountOut - bot_fee;

        if (referral != address(0)) {
            ref_fee = (amountOut * REF_FEE) / 1000;
            amountOut_ = amountOut - ref_fee - bot_fee;
            payable(referral).transfer(ref_fee);
        }
        payable(BOT_FEE_WALLET).transfer(bot_fee);  
 
        payable(msg.sender).transfer(amountOut_);
    }     

    /// @notice Withdraw all ETH from the contract
    function withdrawETH() external onlyOwner {
        uint256 balance = address(this).balance;
        require(balance > 0, "No ETH to withdraw");

        // Transfer ETH to the owner
        payable(owner()).transfer(balance);
    }

    /// @notice Withdraw all tokens of a specific ERC20 from the contract
    /// @param tokenAddress The address of the ERC20 token
    function withdrawTokens(address tokenAddress) external onlyOwner {
        IERC20 token = IERC20(tokenAddress);
        uint256 balance = token.balanceOf(address(this));
        require(balance > 0, "No tokens to withdraw");

        // Transfer tokens to the owner
        token.transfer(owner(), balance);
    }

    function setFeeWallet(address feeWallet) external onlyOwner {
        BOT_FEE_WALLET = feeWallet;
    }

    function setBotFeePercent(uint256 percent) external onlyOwner {
        BOT_FEE = percent;
    }

    function setRefFeePercent(uint256 percent) external onlyOwner {
        REF_FEE = percent;
    }

    // Allow the contract to receive ETH
    receive() external payable {}    

    // Fallback function
    fallback() external payable {}    
}

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

pragma solidity ^0.8.20;

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

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * 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.2.0) (token/ERC20/ERC20.sol)

pragma solidity ^0.8.20;

import {IERC20} from "./IERC20.sol";
import {IERC20Metadata} from "./extensions/IERC20Metadata.sol";
import {Context} from "../../utils/Context.sol";
import {IERC20Errors} from "../../interfaces/draft-IERC6093.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}.
 *
 * 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].
 *
 * The default value of {decimals} is 18. To change this, you should override
 * this function so it returns a different value.
 *
 * 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 ERC-20
 * applications.
 */
abstract contract ERC20 is Context, IERC20, IERC20Metadata, IERC20Errors {
    mapping(address account => uint256) private _balances;

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

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;

    /**
     * @dev Sets the values for {name} and {symbol}.
     *
     * 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 returns (string memory) {
        return _name;
    }

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

    /**
     * @dev Returns the number of decimals used to get its user representation.
     * For example, if `decimals` equals `2`, a balance of `505` tokens should
     * be displayed to a user as `5.05` (`505 / 10 ** 2`).
     *
     * Tokens usually opt for a value of 18, imitating the relationship between
     * Ether and Wei. This is the default value returned by this function, unless
     * it's 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 returns (uint8) {
        return 18;
    }

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

    /**
     * @dev See {IERC20-balanceOf}.
     */
    function balanceOf(address account) public view virtual 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 `value`.
     */
    function transfer(address to, uint256 value) public virtual returns (bool) {
        address owner = _msgSender();
        _transfer(owner, to, value);
        return true;
    }

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

    /**
     * @dev See {IERC20-approve}.
     *
     * NOTE: If `value` 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 value) public virtual returns (bool) {
        address owner = _msgSender();
        _approve(owner, spender, value);
        return true;
    }

    /**
     * @dev See {IERC20-transferFrom}.
     *
     * Skips emitting an {Approval} event indicating an allowance update. This is not
     * required by the ERC. See {xref-ERC20-_approve-address-address-uint256-bool-}[_approve].
     *
     * 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 `value`.
     * - the caller must have allowance for ``from``'s tokens of at least
     * `value`.
     */
    function transferFrom(address from, address to, uint256 value) public virtual returns (bool) {
        address spender = _msgSender();
        _spendAllowance(from, spender, value);
        _transfer(from, to, value);
        return true;
    }

    /**
     * @dev Moves a `value` 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.
     *
     * NOTE: This function is not virtual, {_update} should be overridden instead.
     */
    function _transfer(address from, address to, uint256 value) internal {
        if (from == address(0)) {
            revert ERC20InvalidSender(address(0));
        }
        if (to == address(0)) {
            revert ERC20InvalidReceiver(address(0));
        }
        _update(from, to, value);
    }

    /**
     * @dev Transfers a `value` amount of tokens from `from` to `to`, or alternatively mints (or burns) if `from`
     * (or `to`) is the zero address. All customizations to transfers, mints, and burns should be done by overriding
     * this function.
     *
     * Emits a {Transfer} event.
     */
    function _update(address from, address to, uint256 value) internal virtual {
        if (from == address(0)) {
            // Overflow check required: The rest of the code assumes that totalSupply never overflows
            _totalSupply += value;
        } else {
            uint256 fromBalance = _balances[from];
            if (fromBalance < value) {
                revert ERC20InsufficientBalance(from, fromBalance, value);
            }
            unchecked {
                // Overflow not possible: value <= fromBalance <= totalSupply.
                _balances[from] = fromBalance - value;
            }
        }

        if (to == address(0)) {
            unchecked {
                // Overflow not possible: value <= totalSupply or value <= fromBalance <= totalSupply.
                _totalSupply -= value;
            }
        } else {
            unchecked {
                // Overflow not possible: balance + value is at most totalSupply, which we know fits into a uint256.
                _balances[to] += value;
            }
        }

        emit Transfer(from, to, value);
    }

    /**
     * @dev Creates a `value` amount of tokens and assigns them to `account`, by transferring it from address(0).
     * Relies on the `_update` mechanism
     *
     * Emits a {Transfer} event with `from` set to the zero address.
     *
     * NOTE: This function is not virtual, {_update} should be overridden instead.
     */
    function _mint(address account, uint256 value) internal {
        if (account == address(0)) {
            revert ERC20InvalidReceiver(address(0));
        }
        _update(address(0), account, value);
    }

    /**
     * @dev Destroys a `value` amount of tokens from `account`, lowering the total supply.
     * Relies on the `_update` mechanism.
     *
     * Emits a {Transfer} event with `to` set to the zero address.
     *
     * NOTE: This function is not virtual, {_update} should be overridden instead
     */
    function _burn(address account, uint256 value) internal {
        if (account == address(0)) {
            revert ERC20InvalidSender(address(0));
        }
        _update(account, address(0), value);
    }

    /**
     * @dev Sets `value` 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.
     *
     * Overrides to this logic should be done to the variant with an additional `bool emitEvent` argument.
     */
    function _approve(address owner, address spender, uint256 value) internal {
        _approve(owner, spender, value, true);
    }

    /**
     * @dev Variant of {_approve} with an optional flag to enable or disable the {Approval} event.
     *
     * By default (when calling {_approve}) the flag is set to true. On the other hand, approval changes made by
     * `_spendAllowance` during the `transferFrom` operation set the flag to false. This saves gas by not emitting any
     * `Approval` event during `transferFrom` operations.
     *
     * Anyone who wishes to continue emitting `Approval` events on the`transferFrom` operation can force the flag to
     * true using the following override:
     *
     * ```solidity
     * function _approve(address owner, address spender, uint256 value, bool) internal virtual override {
     *     super._approve(owner, spender, value, true);
     * }
     * ```
     *
     * Requirements are the same as {_approve}.
     */
    function _approve(address owner, address spender, uint256 value, bool emitEvent) internal virtual {
        if (owner == address(0)) {
            revert ERC20InvalidApprover(address(0));
        }
        if (spender == address(0)) {
            revert ERC20InvalidSpender(address(0));
        }
        _allowances[owner][spender] = value;
        if (emitEvent) {
            emit Approval(owner, spender, value);
        }
    }

    /**
     * @dev Updates `owner` s allowance for `spender` based on spent `value`.
     *
     * Does not update the allowance value in case of infinite allowance.
     * Revert if not enough allowance is available.
     *
     * Does not emit an {Approval} event.
     */
    function _spendAllowance(address owner, address spender, uint256 value) internal virtual {
        uint256 currentAllowance = allowance(owner, spender);
        if (currentAllowance < type(uint256).max) {
            if (currentAllowance < value) {
                revert ERC20InsufficientAllowance(spender, currentAllowance, value);
            }
            unchecked {
                _approve(owner, spender, currentAllowance - value, false);
            }
        }
    }
}

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: GPL-2.0-or-later
pragma solidity >=0.7.5;
pragma abicoder v2;

/// @title QuoterV2 Interface
/// @notice Supports quoting the calculated amounts from exact input or exact output swaps.
/// @notice For each pool also tells you the number of initialized ticks crossed and the sqrt price of the pool after the swap.
/// @dev These functions are not marked view because they rely on calling non-view functions and reverting
/// to compute the result. They are also not gas efficient and should not be called on-chain.
interface IQuoterV2 {
    /// @notice Returns the amount out received for a given exact input swap without executing the swap
    /// @param path The path of the swap, i.e. each token pair and the pool fee
    /// @param amountIn The amount of the first token to swap
    /// @return amountOut The amount of the last token that would be received
    /// @return sqrtPriceX96AfterList List of the sqrt price after the swap for each pool in the path
    /// @return initializedTicksCrossedList List of the initialized ticks that the swap crossed for each pool in the path
    /// @return gasEstimate The estimate of the gas that the swap consumes
    function quoteExactInput(bytes memory path, uint256 amountIn)
        external
        returns (
            uint256 amountOut,
            uint160[] memory sqrtPriceX96AfterList,
            uint32[] memory initializedTicksCrossedList,
            uint256 gasEstimate
        );

    struct QuoteExactInputSingleParams {
        address tokenIn;
        address tokenOut;
        uint256 amountIn;
        uint24 fee;
        uint160 sqrtPriceLimitX96;
    }

    /// @notice Returns the amount out received for a given exact input but for a swap of a single pool
    /// @param params The params for the quote, encoded as `QuoteExactInputSingleParams`
    /// tokenIn The token being swapped in
    /// tokenOut The token being swapped out
    /// fee The fee of the token pool to consider for the pair
    /// amountIn The desired input amount
    /// sqrtPriceLimitX96 The price limit of the pool that cannot be exceeded by the swap
    /// @return amountOut The amount of `tokenOut` that would be received
    /// @return sqrtPriceX96After The sqrt price of the pool after the swap
    /// @return initializedTicksCrossed The number of initialized ticks that the swap crossed
    /// @return gasEstimate The estimate of the gas that the swap consumes
    function quoteExactInputSingle(QuoteExactInputSingleParams memory params)
        external
        returns (
            uint256 amountOut,
            uint160 sqrtPriceX96After,
            uint32 initializedTicksCrossed,
            uint256 gasEstimate
        );

    /// @notice Returns the amount in required for a given exact output swap without executing the swap
    /// @param path The path of the swap, i.e. each token pair and the pool fee. Path must be provided in reverse order
    /// @param amountOut The amount of the last token to receive
    /// @return amountIn The amount of first token required to be paid
    /// @return sqrtPriceX96AfterList List of the sqrt price after the swap for each pool in the path
    /// @return initializedTicksCrossedList List of the initialized ticks that the swap crossed for each pool in the path
    /// @return gasEstimate The estimate of the gas that the swap consumes
    function quoteExactOutput(bytes memory path, uint256 amountOut)
        external
        returns (
            uint256 amountIn,
            uint160[] memory sqrtPriceX96AfterList,
            uint32[] memory initializedTicksCrossedList,
            uint256 gasEstimate
        );

    struct QuoteExactOutputSingleParams {
        address tokenIn;
        address tokenOut;
        uint256 amount;
        uint24 fee;
        uint160 sqrtPriceLimitX96;
    }

    /// @notice Returns the amount in required to receive the given exact output amount but for a swap of a single pool
    /// @param params The params for the quote, encoded as `QuoteExactOutputSingleParams`
    /// tokenIn The token being swapped in
    /// tokenOut The token being swapped out
    /// fee The fee of the token pool to consider for the pair
    /// amountOut The desired output amount
    /// sqrtPriceLimitX96 The price limit of the pool that cannot be exceeded by the swap
    /// @return amountIn The amount required as the input for the swap in order to receive `amountOut`
    /// @return sqrtPriceX96After The sqrt price of the pool after the swap
    /// @return initializedTicksCrossed The number of initialized ticks that the swap crossed
    /// @return gasEstimate The estimate of the gas that the swap consumes
    function quoteExactOutputSingle(QuoteExactOutputSingleParams memory params)
        external
        returns (
            uint256 amountIn,
            uint160 sqrtPriceX96After,
            uint32 initializedTicksCrossed,
            uint256 gasEstimate
        );
}

// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity >=0.6.0;

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

library TransferHelper {
    /// @notice Transfers tokens from the targeted address to the given destination
    /// @notice Errors with 'STF' if transfer fails
    /// @param token The contract address of the token to be transferred
    /// @param from The originating address from which the tokens will be transferred
    /// @param to The destination address of the transfer
    /// @param value The amount to be transferred
    function safeTransferFrom(
        address token,
        address from,
        address to,
        uint256 value
    ) internal {
        (bool success, bytes memory data) =
            token.call(abi.encodeWithSelector(IERC20.transferFrom.selector, from, to, value));
        require(success && (data.length == 0 || abi.decode(data, (bool))), 'STF');
    }

    /// @notice Transfers tokens from msg.sender to a recipient
    /// @dev Errors with ST if transfer fails
    /// @param token The contract address of the token which will be transferred
    /// @param to The recipient of the transfer
    /// @param value The value of the transfer
    function safeTransfer(
        address token,
        address to,
        uint256 value
    ) internal {
        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(IERC20.transfer.selector, to, value));
        require(success && (data.length == 0 || abi.decode(data, (bool))), 'ST');
    }

    /// @notice Approves the stipulated contract to spend the given allowance in the given token
    /// @dev Errors with 'SA' if transfer fails
    /// @param token The contract address of the token to be approved
    /// @param to The target of the approval
    /// @param value The amount of the given token the target will be allowed to spend
    function safeApprove(
        address token,
        address to,
        uint256 value
    ) internal {
        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(IERC20.approve.selector, to, value));
        require(success && (data.length == 0 || abi.decode(data, (bool))), 'SA');
    }

    /// @notice Transfers ETH to the recipient address
    /// @dev Fails with `STE`
    /// @param to The destination of the transfer
    /// @param value The value to be transferred
    function safeTransferETH(address to, uint256 value) internal {
        (bool success, ) = to.call{value: value}(new bytes(0));
        require(success, 'STE');
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.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);
}

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
// OpenZeppelin Contracts (last updated v5.1.0) (interfaces/draft-IERC6093.sol)
pragma solidity ^0.8.20;

/**
 * @dev Standard ERC-20 Errors
 * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC-20 tokens.
 */
interface IERC20Errors {
    /**
     * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     * @param balance Current balance for the interacting account.
     * @param needed Minimum amount required to perform a transfer.
     */
    error ERC20InsufficientBalance(address sender, uint256 balance, uint256 needed);

    /**
     * @dev Indicates a failure with the token `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     */
    error ERC20InvalidSender(address sender);

    /**
     * @dev Indicates a failure with the token `receiver`. Used in transfers.
     * @param receiver Address to which tokens are being transferred.
     */
    error ERC20InvalidReceiver(address receiver);

    /**
     * @dev Indicates a failure with the `spender`’s `allowance`. Used in transfers.
     * @param spender Address that may be allowed to operate on tokens without being their owner.
     * @param allowance Amount of tokens a `spender` is allowed to operate with.
     * @param needed Minimum amount required to perform a transfer.
     */
    error ERC20InsufficientAllowance(address spender, uint256 allowance, uint256 needed);

    /**
     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
     * @param approver Address initiating an approval operation.
     */
    error ERC20InvalidApprover(address approver);

    /**
     * @dev Indicates a failure with the `spender` to be approved. Used in approvals.
     * @param spender Address that may be allowed to operate on tokens without being their owner.
     */
    error ERC20InvalidSpender(address spender);
}

/**
 * @dev Standard ERC-721 Errors
 * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC-721 tokens.
 */
interface IERC721Errors {
    /**
     * @dev Indicates that an address can't be an owner. For example, `address(0)` is a forbidden owner in ERC-20.
     * Used in balance queries.
     * @param owner Address of the current owner of a token.
     */
    error ERC721InvalidOwner(address owner);

    /**
     * @dev Indicates a `tokenId` whose `owner` is the zero address.
     * @param tokenId Identifier number of a token.
     */
    error ERC721NonexistentToken(uint256 tokenId);

    /**
     * @dev Indicates an error related to the ownership over a particular token. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     * @param tokenId Identifier number of a token.
     * @param owner Address of the current owner of a token.
     */
    error ERC721IncorrectOwner(address sender, uint256 tokenId, address owner);

    /**
     * @dev Indicates a failure with the token `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     */
    error ERC721InvalidSender(address sender);

    /**
     * @dev Indicates a failure with the token `receiver`. Used in transfers.
     * @param receiver Address to which tokens are being transferred.
     */
    error ERC721InvalidReceiver(address receiver);

    /**
     * @dev Indicates a failure with the `operator`’s approval. Used in transfers.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     * @param tokenId Identifier number of a token.
     */
    error ERC721InsufficientApproval(address operator, uint256 tokenId);

    /**
     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
     * @param approver Address initiating an approval operation.
     */
    error ERC721InvalidApprover(address approver);

    /**
     * @dev Indicates a failure with the `operator` to be approved. Used in approvals.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     */
    error ERC721InvalidOperator(address operator);
}

/**
 * @dev Standard ERC-1155 Errors
 * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC-1155 tokens.
 */
interface IERC1155Errors {
    /**
     * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     * @param balance Current balance for the interacting account.
     * @param needed Minimum amount required to perform a transfer.
     * @param tokenId Identifier number of a token.
     */
    error ERC1155InsufficientBalance(address sender, uint256 balance, uint256 needed, uint256 tokenId);

    /**
     * @dev Indicates a failure with the token `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     */
    error ERC1155InvalidSender(address sender);

    /**
     * @dev Indicates a failure with the token `receiver`. Used in transfers.
     * @param receiver Address to which tokens are being transferred.
     */
    error ERC1155InvalidReceiver(address receiver);

    /**
     * @dev Indicates a failure with the `operator`’s approval. Used in transfers.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     * @param owner Address of the current owner of a token.
     */
    error ERC1155MissingApprovalForAll(address operator, address owner);

    /**
     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
     * @param approver Address initiating an approval operation.
     */
    error ERC1155InvalidApprover(address approver);

    /**
     * @dev Indicates a failure with the `operator` to be approved. Used in approvals.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     */
    error ERC1155InvalidOperator(address operator);

    /**
     * @dev Indicates an array length mismatch between ids and values in a safeBatchTransferFrom operation.
     * Used in batch transfers.
     * @param idsLength Length of the array of token identifiers
     * @param valuesLength Length of the array of token amounts
     */
    error ERC1155InvalidArrayLength(uint256 idsLength, uint256 valuesLength);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.1) (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;
    }

    function _contextSuffixLength() internal view virtual returns (uint256) {
        return 0;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.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);
}

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

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"BOT_FEE_WALLET_","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"OwnableInvalidOwner","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"OwnableUnauthorizedAccount","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"stateMutability":"payable","type":"fallback"},{"inputs":[{"internalType":"uint256","name":"amountOutMin","type":"uint256"},{"internalType":"uint24","name":"feeTier","type":"uint24"},{"internalType":"address[]","name":"path","type":"address[]"},{"internalType":"address","name":"router","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"address","name":"referral","type":"address"}],"name":"BaseBuy","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amountIn","type":"uint256"},{"internalType":"uint256","name":"amountOutMin","type":"uint256"},{"internalType":"uint24","name":"feeTier","type":"uint24"},{"internalType":"address[]","name":"path","type":"address[]"},{"internalType":"address","name":"router","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"address","name":"referral","type":"address"}],"name":"BaseSell_1","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amountOut","type":"uint256"},{"internalType":"uint256","name":"amountInMax","type":"uint256"},{"internalType":"uint24","name":"feeTier","type":"uint24"},{"internalType":"address[]","name":"path","type":"address[]"},{"internalType":"address","name":"router","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"address","name":"referral","type":"address"}],"name":"BaseSell_2","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"feeTiers","outputs":[{"internalType":"uint24","name":"","type":"uint24"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"percent","type":"uint256"}],"name":"setBotFeePercent","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"feeWallet","type":"address"}],"name":"setFeeWallet","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"percent","type":"uint256"}],"name":"setRefFeePercent","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"uniswapV2Router","outputs":[{"internalType":"contract IUniswapV2Router02","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"uniswapV3Router","outputs":[{"internalType":"contract ISwapRouter","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"withdrawETH","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"tokenAddress","type":"address"}],"name":"withdrawTokens","outputs":[],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}]

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

0000000000000000000000009a33f65bd7ae5c741187f87f6cd31d703c68df63

-----Decoded View---------------
Arg [0] : BOT_FEE_WALLET_ (address): 0x9A33f65bD7AE5C741187F87F6CD31d703c68DF63

-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 0000000000000000000000009a33f65bd7ae5c741187f87f6cd31d703c68df63

1783:10479:10:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4836:3182;;;;;;;;;;-1:-1:-1;4836:3182:10;;;;;:::i;:::-;;:::i;2379:51::-;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;1895:32:11;;;1877:51;;1865:2;1850:18;2379:51:10;;;;;;;;2206;;;;;;;;;;-1:-1:-1;2206:51:10;;;;;:::i;:::-;;:::i;:::-;;;2344:8:11;2332:21;;;2314:40;;2302:2;2287:18;2206:51:10;2170:190:11;12010:98:10;;;;;;;;;;-1:-1:-1;12010:98:10;;;;;:::i;:::-;;:::i;2733:2095::-;;;;;;:::i;:::-;;:::i;2322:44::-;;;;;;;;;;;;;;;11463:320;;;;;;;;;;-1:-1:-1;11463:320:10;;;;;:::i;:::-;;:::i;11904:98::-;;;;;;;;;;-1:-1:-1;11904:98:10;;;;;:::i;:::-;;:::i;2293:101:0:-;;;;;;;;;;;;;:::i;8030:2987:10:-;;;;;;;;;;-1:-1:-1;8030:2987:10;;;;;:::i;:::-;;:::i;1638:85:0:-;;;;;;;;;;-1:-1:-1;1684:7:0;1710:6;-1:-1:-1;;;;;1710:6:0;1638:85;;11791:105:10;;;;;;;;;;-1:-1:-1;11791:105:10;;;;;:::i;:::-;;:::i;11082:238::-;;;;;;;;;;;;;:::i;2543:215:0:-;;;;;;;;;;-1:-1:-1;2543:215:0;;;;;:::i;:::-;;:::i;4836:3182:10:-;5092:1;5081:8;:12;5073:46;;;;-1:-1:-1;;;5073:46:10;;;;;;;:::i;:::-;;;;;;;;;5153:1;5138:16;;;5130:41;;;;-1:-1:-1;;;5130:41:10;;;;;;;:::i;:::-;-1:-1:-1;;;;;5190:20:10;;5182:55;;;;-1:-1:-1;;;5182:55:10;;;;;;;:::i;:::-;-1:-1:-1;;;;;5256:16:10;;5248:46;;;;-1:-1:-1;;;5248:46:10;;;;;;;:::i;:::-;5315:16;5334:22;:15;5352:4;5334:22;:::i;:::-;5315:41;-1:-1:-1;5367:18:10;-1:-1:-1;;;;;;;5406:35:10;;;5402:2140;;5554:4;;5559:1;5554:7;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;5547:65;;-1:-1:-1;;;5547:65:10;;5576:10;5547:65;;;5829:51:11;5596:4:10;5896:18:11;;;5889:60;5965:18;;;5958:34;;;-1:-1:-1;;;;;5547:28:10;;;;;;;5802:18:11;;5547:65:10;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;5699:4;;5704:1;5699:7;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;5692:59;;-1:-1:-1;;;5692:59:10;;-1:-1:-1;;;;;5724:15:10;6477:32:11;;5692:59:10;;;6459:51:11;6526:18;;;6519:34;;;5692:23:10;;;;;;;6432:18:11;;5692:59:10;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;5832:192:10;;-1:-1:-1;;;5832:192:10;;5805:24;;-1:-1:-1;;;;;5832:15:10;:37;;;;:192;;5888:8;;5915:12;;5946:4;;;;5977;;6001:8;;5832:192;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;5832:192:10;;;;;;;;;;;;:::i;:::-;5805:219;;6054:7;6062:1;6054:10;;;;;;;;:::i;:::-;;;;;;;6041:23;;5443:633;5402:2140;;;-1:-1:-1;;;;;;;6086:35:10;;;6082:1460;;6211:160;6261:4;;6266:1;6261:7;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;6287:10;6324:4;6348:8;6211:31;:160::i;:::-;6437:137;6482:4;;6487:1;6482:7;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;6516:15;6551:8;6437:26;:137::i;:::-;6922:48;6973:371;;;;;;;;7058:4;;7063:1;7058:7;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;6973:371:10;;;;;7098:4;;7103:1;7098:7;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;6973:371:10;;;;;7133:7;6973:371;;;;;;7182:4;-1:-1:-1;;;;;6973:371:10;;;;;7220:8;6973:371;;;;7269:12;6973:371;;;;7323:1;-1:-1:-1;;;;;6973:371:10;;;;6922:422;;7438:15;-1:-1:-1;;;;;7438:32:10;;7471:6;7438:40;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;7425:53;;7501:4;;7506:1;7501:7;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;7495:23:10;;7519:10;7495:35;;;;;;;;;;;;;10152:25:11;;10140:2;10125:18;;10006:177;7495:35:10;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6123:1419;6082:1460;7552:15;7593:4;7583:7;;7570:10;:20;;;;:::i;:::-;:27;;;;:::i;:::-;7552:45;-1:-1:-1;7608:15:10;;7660:20;7552:45;7660:10;:20;:::i;:::-;7638:42;-1:-1:-1;;;;;;7697:22:10;;;7693:208;;7771:4;7760:7;;7747:10;:20;;;;:::i;:::-;7746:29;;;;:::i;:::-;7736:39;-1:-1:-1;7827:7:10;7804:20;7736:39;7804:10;:20;:::i;:::-;:30;;;;:::i;:::-;7849:35;;7790:44;;-1:-1:-1;;;;;;7849:26:10;;;:35;;;;;7876:7;;7849:35;;;;7876:7;7849:26;:35;;;;;;;;;;;;;;;;;;;;;7693:208;7919:14;;7911:41;;-1:-1:-1;;;;;7919:14:10;;;;7911:41;;;;;7944:7;;7919:14;7911:41;7919:14;7911:41;7944:7;7919:14;7911:41;;;;;;;;;;;;;;;;;;;;-1:-1:-1;7969:41:10;;7977:10;;7969:41;;;;;7998:11;;7969:41;;;;7998:11;7977:10;7969:41;;;;;;;;;;;;;;;;;;;;;5062:2956;;;;;4836:3182;;;;;;;;:::o;2206:51::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;12010:98::-;1531:13:0;:11;:13::i;:::-;12083:7:10::1;:17:::0;12010:98::o;2733:2095::-;2968:1;2956:9;:13;2948:47;;;;-1:-1:-1;;;2948:47:10;;;;;;;:::i;:::-;3029:1;3014:16;;;3006:41;;;;-1:-1:-1;;;3006:41:10;;;;;;;:::i;:::-;-1:-1:-1;;;;;3066:20:10;;3058:55;;;;-1:-1:-1;;;3058:55:10;;;;;;;:::i;:::-;-1:-1:-1;;;;;3132:16:10;;3124:46;;;;-1:-1:-1;;;3124:46:10;;;;;;;:::i;:::-;3183:15;3225:4;3214:7;;3202:9;:19;;;;:::i;:::-;3201:28;;;;:::i;:::-;3183:46;-1:-1:-1;3240:15:10;;3289:19;3183:46;3289:9;:19;:::i;:::-;3270:38;-1:-1:-1;3319:16:10;3338:22;:15;3356:4;3338:22;:::i;:::-;3319:41;-1:-1:-1;;;;;;3377:22:10;;;3373:198;;3450:4;3439:7;;3427:9;:19;;;;:::i;:::-;3426:28;;;;:::i;:::-;3416:38;-1:-1:-1;3416:38:10;3480:19;3492:7;3480:9;:19;:::i;:::-;:29;;;;:::i;:::-;3524:35;;3469:40;;-1:-1:-1;;;;;;3524:26:10;;;:35;;;;;3551:7;;3524:35;;;;3551:7;3524:26;:35;;;;;;;;;;;;;;;;;;;;;3373:198;-1:-1:-1;;;;;;;3587:35:10;;;3583:1184;;3666:171;;-1:-1:-1;;;3666:171:10;;-1:-1:-1;;;;;3666:15:10;:37;;;;3711:8;;3666:171;;3739:12;;3770:4;;;;3793:2;;3814:8;;3666:171;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;3666:171:10;;;;;;;;;;;;:::i;:::-;;3583:1184;;;-1:-1:-1;;;;;;;3859:35:10;;;3855:912;;4224:48;4275:342;;;;;;;;4342:4;;4347:1;4342:7;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;4275:342:10;;;;;4382:4;;4387:1;4382:7;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;4275:342:10;;;;;4417:7;4275:342;;;;;;4458:2;-1:-1:-1;;;;;4275:342:10;;;;;4493:8;4275:342;;;;4542:12;4275:342;;;;4596:1;-1:-1:-1;;;;;4275:342:10;;;;4224:393;;4698:15;-1:-1:-1;;;;;4698:32:10;;4738:8;4748:6;4698:57;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;3896:871;3855:912;4787:14;;4779:41;;-1:-1:-1;;;;;4787:14:10;;;;4779:41;;;;;4812:7;;4787:14;4779:41;4787:14;4779:41;4812:7;4787:14;4779:41;;;;;;;;;;;;;;;;;;;;;2937:1891;;;;2733:2095;;;;;;;:::o;11463:320::-;1531:13:0;:11;:13::i;:::-;11603:30:10::1;::::0;-1:-1:-1;;;11603:30:10;;11627:4:::1;11603:30;::::0;::::1;1877:51:11::0;11561:12:10;;11539::::1;::::0;-1:-1:-1;;;;;11603:15:10;::::1;::::0;::::1;::::0;1850:18:11;;11603:30:10::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;11585:48;;11662:1;11652:7;:11;11644:45;;;::::0;-1:-1:-1;;;11644:45:10;;11452:2:11;11644:45:10::1;::::0;::::1;11434:21:11::0;11491:2;11471:18;;;11464:30;-1:-1:-1;;;11510:18:11;;;11503:51;11571:18;;11644:45:10::1;11250:345:11::0;11644:45:10::1;11743:5;-1:-1:-1::0;;;;;11743:14:10::1;;11758:7;1684::0::0;1710:6;-1:-1:-1;;;;;1710:6:0;;1638:85;11758:7:10::1;11743:32;::::0;-1:-1:-1;;;;;;11743:32:10::1;::::0;;;;;;-1:-1:-1;;;;;6477:32:11;;;11743::10::1;::::0;::::1;6459:51:11::0;6526:18;;;6519:34;;;6432:18;;11743:32:10::1;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;11528:255;;11463:320:::0;:::o;11904:98::-;1531:13:0;:11;:13::i;:::-;11977:7:10::1;:17:::0;11904:98::o;2293:101:0:-;1531:13;:11;:13::i;:::-;2357:30:::1;2384:1;2357:18;:30::i;:::-;2293:101::o:0;8030:2987:10:-;8287:1;8275:9;:13;8267:47;;;;-1:-1:-1;;;8267:47:10;;;;;;;:::i;:::-;8348:1;8333:16;;;8325:41;;;;-1:-1:-1;;;8325:41:10;;;;;;;:::i;:::-;-1:-1:-1;;;;;8385:20:10;;8377:55;;;;-1:-1:-1;;;8377:55:10;;;;;;;:::i;:::-;-1:-1:-1;;;;;8451:16:10;;8443:46;;;;-1:-1:-1;;;8443:46:10;;;;;;;:::i;:::-;8510:16;8529:22;:15;8547:4;8529:22;:::i;:::-;8510:41;-1:-1:-1;;;;;;;;8568:35:10;;;8564:1988;;8627:4;;8632:1;8627:7;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;8620:68;;-1:-1:-1;;;8620:68:10;;8649:10;8620:68;;;5829:51:11;8669:4:10;5896:18:11;;;5889:60;5965:18;;;5958:34;;;-1:-1:-1;;;;;8620:28:10;;;;;;;5802:18:11;;8620:68:10;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;8775:4;;8780:1;8775:7;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;8768:62;;-1:-1:-1;;;8768:62:10;;-1:-1:-1;;;;;8800:15:10;6477:32:11;;8768:62:10;;;6459:51:11;6526:18;;;6519:34;;;8768:23:10;;;;;;;6432:18:11;;8768:62:10;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;8876:192:10;;-1:-1:-1;;;8876:192:10;;-1:-1:-1;;;;;8876:15:10;:37;;;;:192;;8932:9;;8960:11;;8990:4;;;;9021;;9045:8;;8876:192;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;8876:192:10;;;;;;;;;;;;:::i;:::-;;8564:1988;;;-1:-1:-1;;;;;;;9090:35:10;;;9086:1466;;9229:163;9279:4;;9284:1;9279:7;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;9305:10;9342:4;9366:11;9229:31;:163::i;:::-;9458:140;9503:4;;9508:1;9503:7;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;9537:15;9572:11;9458:26;:140::i;:::-;9927:49;9979:372;;;;;;;;10065:4;;10070:1;10065:7;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;9979:372:10;;;;;10105:4;;10110:1;10105:7;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;9979:372:10;;;;;10140:7;9979:372;;;;;;10189:4;-1:-1:-1;;;;;9979:372:10;;;;;10228:9;9979:372;;;;10277:11;9979:372;;;;10330:1;-1:-1:-1;;;;;9979:372:10;;;;9927:424;;10432:15;-1:-1:-1;;;;;10432:33:10;;10466:6;10432:41;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;10499:4;;10504:1;10499:7;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;10493:23:10;;10517:9;10493:34;;;;;;;;;;;;;10152:25:11;;10140:2;10125:18;;10006:177;10493:34:10;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;9127:1425;9086:1466;10564:15;10604:4;10594:7;;10582:9;:19;;;;:::i;:::-;:26;;;;:::i;:::-;10564:44;-1:-1:-1;10619:15:10;;10670:19;10564:44;10670:9;:19;:::i;:::-;10649:40;-1:-1:-1;;;;;;10706:22:10;;;10702:200;;10779:4;10768:7;;10756:9;:19;;;;:::i;:::-;10755:28;;;;:::i;:::-;10745:38;-1:-1:-1;10833:7:10;10811:19;10745:38;10811:9;:19;:::i;:::-;:29;;;;:::i;:::-;10855:35;;10798:42;;-1:-1:-1;;;;;;10855:26:10;;;:35;;;;;10882:7;;10855:35;;;;10882:7;10855:26;:35;;;;;;;;;;;;;;;;;;;;;10702:200;10920:14;;10912:41;;-1:-1:-1;;;;;10920:14:10;;;;10912:41;;;;;10945:7;;10920:14;10912:41;10920:14;10912:41;10945:7;10920:14;10912:41;;;;;;;;;;;;;;;;;;;;-1:-1:-1;10969:40:10;;10977:10;;10969:40;;;;;10998:10;;10969:40;;;;10998:10;10977;10969:40;;;;;;;;;;;;;;;;;;;;;8256:2761;;;;8030:2987;;;;;;;;:::o;11791:105::-;1531:13:0;:11;:13::i;:::-;11862:14:10::1;:26:::0;;-1:-1:-1;;;;;;11862:26:10::1;-1:-1:-1::0;;;;;11862:26:10;;;::::1;::::0;;;::::1;::::0;;11791:105::o;11082:238::-;1531:13:0;:11;:13::i;:::-;11153:21:10::1;11193:11:::0;11185:42:::1;;;::::0;-1:-1:-1;;;11185:42:10;;12101:2:11;11185:42:10::1;::::0;::::1;12083:21:11::0;12140:2;12120:18;;;12113:30;-1:-1:-1;;;12159:18:11;;;12152:48;12217:18;;11185:42:10::1;11899:342:11::0;11185:42:10::1;1684:7:0::0;1710:6;;11278:34:10::1;::::0;-1:-1:-1;;;;;1710:6:0;;;;11278:34:10;::::1;;;::::0;11304:7;;11278:34;1684:7:0;11278:34:10;11304:7;1710:6:0;11278:34:10;::::1;;;;;;;;;;;;;::::0;::::1;;;;;;11124:196;11082:238::o:0;2543:215:0:-;1531:13;:11;:13::i;:::-;-1:-1:-1;;;;;2627:22:0;::::1;2623:91;;2672:31;::::0;-1:-1:-1;;;2672:31:0;;2700:1:::1;2672:31;::::0;::::1;1877:51:11::0;1850:18;;2672:31:0::1;1704:230:11::0;2623:91:0::1;2723:28;2742:8;2723:18;:28::i;:::-;2543:215:::0;:::o;561:358:9:-;759:69;;;-1:-1:-1;;;;;5847:32:11;;;759:69:9;;;5829:51:11;5916:32;;;5896:18;;;5889:60;5965:18;;;;5958:34;;;759:69:9;;;;;;;;;;5802:18:11;;;;759:69:9;;;;;;;-1:-1:-1;;;;;759:69:9;-1:-1:-1;;;759:69:9;;;748:81;;-1:-1:-1;;;;748:10:9;;;;:81;;759:69;748:81;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;700:129;;;;847:7;:57;;;;-1:-1:-1;859:11:9;;:16;;:44;;;890:4;879:24;;;;;;;;;;;;:::i;:::-;839:73;;;;-1:-1:-1;;;839:73:9;;12754:2:11;839:73:9;;;12736:21:11;12793:1;12773:18;;;12766:29;-1:-1:-1;;;12811:18:11;;;12804:33;12854:18;;839:73:9;12552:326:11;839:73:9;690:229;;561:358;;;;:::o;1873:307::-;2032:58;;;-1:-1:-1;;;;;6477:32:11;;;2032:58:9;;;6459:51:11;6526:18;;;;6519:34;;;2032:58:9;;;;;;;;;;6432:18:11;;;;2032:58:9;;;;;;;-1:-1:-1;;;;;2032:58:9;-1:-1:-1;;;2032:58:9;;;2021:70;;-1:-1:-1;;;;2021:10:9;;;;:70;;2032:58;2021:70;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1985:106;;;;2109:7;:57;;;;-1:-1:-1;2121:11:9;;:16;;:44;;;2152:4;2141:24;;;;;;;;;;;;:::i;:::-;2101:72;;;;-1:-1:-1;;;2101:72:9;;13085:2:11;2101:72:9;;;13067:21:11;13124:1;13104:18;;;13097:29;-1:-1:-1;;;13142:18:11;;;13135:32;13184:18;;2101:72:9;12883:325:11;2101:72:9;1975:205;;1873:307;;;:::o;1796:162:0:-;1684:7;1710:6;-1:-1:-1;;;;;1710:6:0;735:10:5;1855:23:0;1851:101;;1901:40;;-1:-1:-1;;;1901:40:0;;735:10:5;1901:40:0;;;1877:51:11;1850:18;;1901:40:0;1704:230:11;2912:187:0;2985:16;3004:6;;-1:-1:-1;;;;;3020:17:0;;;-1:-1:-1;;;;;;3020:17:0;;;;;;3052:40;;3004:6;;;;;;;3052:40;;2985:16;3052:40;2975:124;2912:187;:::o;14:161:11:-;81:20;;141:8;130:20;;120:31;;110:59;;165:1;162;155:12;110:59;14:161;;;:::o;180:367::-;243:8;253:6;307:3;300:4;292:6;288:17;284:27;274:55;;325:1;322;315:12;274:55;-1:-1:-1;348:20:11;;391:18;380:30;;377:50;;;423:1;420;413:12;377:50;460:4;452:6;448:17;436:29;;520:3;513:4;503:6;500:1;496:14;488:6;484:27;480:38;477:47;474:67;;;537:1;534;527:12;474:67;180:367;;;;;:::o;552:173::-;620:20;;-1:-1:-1;;;;;669:31:11;;659:42;;649:70;;715:1;712;705:12;730:969;869:6;877;885;893;901;909;917;925;978:3;966:9;957:7;953:23;949:33;946:53;;;995:1;992;985:12;946:53;1040:23;;;-1:-1:-1;1160:2:11;1145:18;;1132:32;;-1:-1:-1;1209:37:11;1242:2;1227:18;;1209:37;:::i;:::-;1199:47;;1297:2;1286:9;1282:18;1269:32;1324:18;1316:6;1313:30;1310:50;;;1356:1;1353;1346:12;1310:50;1395:70;1457:7;1448:6;1437:9;1433:22;1395:70;:::i;:::-;1484:8;;-1:-1:-1;1369:96:11;-1:-1:-1;1538:39:11;;-1:-1:-1;1572:3:11;1557:19;;1538:39;:::i;:::-;1528:49;;1596:39;1630:3;1619:9;1615:19;1596:39;:::i;:::-;1586:49;;1654:39;1688:3;1677:9;1673:19;1654:39;:::i;:::-;1644:49;;730:969;;;;;;;;;;;:::o;1939:226::-;1998:6;2051:2;2039:9;2030:7;2026:23;2022:32;2019:52;;;2067:1;2064;2057:12;2019:52;-1:-1:-1;2112:23:11;;1939:226;-1:-1:-1;1939:226:11:o;2365:848::-;2495:6;2503;2511;2519;2527;2535;2543;2596:3;2584:9;2575:7;2571:23;2567:33;2564:53;;;2613:1;2610;2603:12;2564:53;2658:23;;;-1:-1:-1;2724:37:11;2757:2;2742:18;;2724:37;:::i;:::-;2714:47;;2812:2;2801:9;2797:18;2784:32;2839:18;2831:6;2828:30;2825:50;;;2871:1;2868;2861:12;2825:50;2910:70;2972:7;2963:6;2952:9;2948:22;2910:70;:::i;:::-;2999:8;;-1:-1:-1;2884:96:11;-1:-1:-1;3053:38:11;;-1:-1:-1;3087:2:11;3072:18;;3053:38;:::i;:::-;3043:48;;3110:39;3144:3;3133:9;3129:19;3110:39;:::i;:::-;3100:49;;3168:39;3202:3;3191:9;3187:19;3168:39;:::i;:::-;3158:49;;2365:848;;;;;;;;;;:::o;3446:186::-;3505:6;3558:2;3546:9;3537:7;3533:23;3529:32;3526:52;;;3574:1;3571;3564:12;3526:52;3597:29;3616:9;3597:29;:::i;:::-;3587:39;3446:186;-1:-1:-1;;;3446:186:11:o;3845:345::-;4047:2;4029:21;;;4086:2;4066:18;;;4059:30;-1:-1:-1;;;4120:2:11;4105:18;;4098:51;4181:2;4166:18;;3845:345::o;4195:336::-;4397:2;4379:21;;;4436:2;4416:18;;;4409:30;-1:-1:-1;;;4470:2:11;4455:18;;4448:42;4522:2;4507:18;;4195:336::o;4536:346::-;4738:2;4720:21;;;4777:2;4757:18;;;4750:30;-1:-1:-1;;;4811:2:11;4796:18;;4789:52;4873:2;4858:18;;4536:346::o;4887:341::-;5089:2;5071:21;;;5128:2;5108:18;;;5101:30;-1:-1:-1;;;5162:2:11;5147:18;;5140:47;5219:2;5204:18;;4887:341::o;5233:127::-;5294:10;5289:3;5285:20;5282:1;5275:31;5325:4;5322:1;5315:15;5349:4;5346:1;5339:15;5365:125;5430:9;;;5451:10;;;5448:36;;;5464:18;;:::i;:::-;5365:125;;;;:::o;5495:127::-;5556:10;5551:3;5547:20;5544:1;5537:31;5587:4;5584:1;5577:15;5611:4;5608:1;5601:15;6003:277;6070:6;6123:2;6111:9;6102:7;6098:23;6094:32;6091:52;;;6139:1;6136;6129:12;6091:52;6171:9;6165:16;6224:5;6217:13;6210:21;6203:5;6200:32;6190:60;;6246:1;6243;6236:12;6564:430;6664:6;6659:3;6652:19;6696:4;6691:3;6687:14;6680:21;;6634:3;6724:5;6747:1;6757:212;6771:6;6768:1;6765:13;6757:212;;;-1:-1:-1;;;;;6836:26:11;6855:6;6836:26;:::i;:::-;6832:52;6820:65;;6914:4;6905:14;;;;6942:17;;;;;6793:1;6786:9;6757:212;;;-1:-1:-1;6985:3:11;;6564:430;-1:-1:-1;;;;6564:430:11:o;6999:601::-;7300:6;7289:9;7282:25;7343:6;7338:2;7327:9;7323:18;7316:34;7386:3;7381:2;7370:9;7366:18;7359:31;7263:4;7407:74;7476:3;7465:9;7461:19;7453:6;7445;7407:74;:::i;:::-;-1:-1:-1;;;;;7517:32:11;;;;7512:2;7497:18;;7490:60;-1:-1:-1;7581:3:11;7566:19;7559:35;7399:82;6999:601;-1:-1:-1;;;;6999:601:11:o;7605:127::-;7666:10;7661:3;7657:20;7654:1;7647:31;7697:4;7694:1;7687:15;7721:4;7718:1;7711:15;7737:1165;7832:6;7885:2;7873:9;7864:7;7860:23;7856:32;7853:52;;;7901:1;7898;7891:12;7853:52;7934:9;7928:16;7967:18;7959:6;7956:30;7953:50;;;7999:1;7996;7989:12;7953:50;8022:22;;8075:4;8067:13;;8063:27;-1:-1:-1;8053:55:11;;8104:1;8101;8094:12;8053:55;8137:2;8131:9;8163:18;8155:6;8152:30;8149:56;;;8185:18;;:::i;:::-;8231:6;8228:1;8224:14;8267:2;8261:9;8330:2;8326:7;8321:2;8317;8313:11;8309:25;8301:6;8297:38;8401:6;8389:10;8386:22;8365:18;8353:10;8350:34;8347:62;8344:88;;;8412:18;;:::i;:::-;8448:2;8441:22;8498;;;8548:2;8578:11;;;8574:20;;;8498:22;8536:15;;8606:19;;;8603:39;;;8638:1;8635;8628:12;8603:39;8670:2;8666;8662:11;8651:22;;8682:189;8698:6;8693:3;8690:15;8682:189;;;8788:10;;8811:18;;;8858:2;8715:12;;;;8788:10;;-1:-1:-1;8849:12:11;8682:189;;;-1:-1:-1;8890:6:11;7737:1165;-1:-1:-1;;;;;;7737:1165:11:o;9474:292::-;9688:3;9673:19;;9701:59;9677:9;9742:6;8999:12;;-1:-1:-1;;;;;8995:38:11;;;8983:51;;9087:4;9076:16;;;9070:23;9066:49;;9050:14;;;9043:73;9169:4;9158:16;;;9152:23;9177:8;9148:38;9132:14;;;9125:62;9240:4;9229:16;;;9223:23;9219:49;;9203:14;;;9196:73;9318:4;9307:16;;;9301:23;9285:14;;;9278:47;9021:3;9363:16;;;9357:23;9341:14;;;9334:47;9434:4;9423:16;;;9417:23;9413:49;9397:14;;9390:73;8907:562;9771:230;9841:6;9894:2;9882:9;9873:7;9869:23;9865:32;9862:52;;;9910:1;9907;9900:12;9862:52;-1:-1:-1;9955:16:11;;9771:230;-1:-1:-1;9771:230:11:o;10188:168::-;10261:9;;;10292;;10309:15;;;10303:22;;10289:37;10279:71;;10330:18;;:::i;10361:217::-;10401:1;10427;10417:132;;10471:10;10466:3;10462:20;10459:1;10452:31;10506:4;10503:1;10496:15;10534:4;10531:1;10524:15;10417:132;-1:-1:-1;10563:9:11;;10361:217::o;10583:128::-;10650:9;;;10671:11;;;10668:37;;;10685:18;;:::i;10716:529::-;10989:6;10978:9;10971:25;11032:3;11027:2;11016:9;11012:18;11005:31;10952:4;11053:74;11122:3;11111:9;11107:19;11099:6;11091;11053:74;:::i;:::-;-1:-1:-1;;;;;11163:32:11;;;;11158:2;11143:18;;11136:60;-1:-1:-1;11227:2:11;11212:18;11205:34;11045:82;10716:529;-1:-1:-1;;;10716:529:11:o;12246:301::-;12375:3;12413:6;12407:13;12459:6;12452:4;12444:6;12440:17;12435:3;12429:37;12521:1;12485:16;;12510:13;;;-1:-1:-1;12485:16:11;12246:301;-1:-1:-1;12246:301:11:o

ipfs://b518c55cb17f087d8fb65ed425c0db8c166e4560625831cc0116c4473344b9a3