Contract Source Code (Solidity Multiple files format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

import "./Ownable.sol";
import "./SafeERC20.sol";
import "./FourERC20.sol";
import "./IPancakeFactory.sol";
import "./IPancakePair.sol";
import "./IPancakeRouter02.sol";
import "./ITokenCreator5.sol";

/**
 * @title ITokenHelper
 * @notice Interface for helper contract handling token liquidity addition and swaps
 */
interface ITokenHelper {
    /**
     * @notice Add liquidity
     * @param amountToken Token amount
     */
    function addLiquidity(uint256 amountToken) external;
    
    /**
     * @notice Swap token for quote token
     * @param to Address to receive quote token
     * @param amountToken Token amount
     * @return amountQuote Amount of quote token received
     */
    function swapForQuote(address to, uint256 amountToken) external returns (uint256 amountQuote);
    
    /**
     * @notice Swap token for ETH
     * @param to Address to receive ETH
     * @param amountToken Token amount
     * @return amountETH Amount of ETH received
     */
    function swapForETH(address to, uint256 amountToken) external returns (uint256 amountETH);
}

/**
 * @title IShareHolderManager
 * @notice Interface for shareholder management contract, used to check if an address is blacklisted
 */
interface IShareHolderManager {
    /**
     * @notice Check if an address is blacklisted
     * @param account Address to check
     * @return Returns true if the address is blacklisted, false otherwise
     */
    function isBlacklisted(address account) external returns (bool);
}

/**
 * @title Token
 * @notice Token contract - Advanced ERC20 token supporting transaction fees, reward distribution, and multiple allocation modes
 * 
 * Key Features:
 * - Transaction fee mechanism: Charges a certain percentage of fees on buy/sell transactions
 * - Reward distribution mechanism: Token holders receive reward distributions based on their holdings
 * - Multiple allocation modes: Fees can be allocated to founder, holders, burn, and liquidity
 * - Anti-sniper protection: Prevents malicious addresses from participating in rewards through blacklist mechanism
 */
contract Token is FourERC20, Ownable {
    /// @notice Wrapped ETH address
    address public constant WETH = 0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c;
    
    /// @notice Burn address
    address public constant DEAD = address(0xdEaD);
    
    /// @notice PancakeSwap Factory contract address
    address public constant PANCAKE_FACTORY = 0xcA143Ce32Fe78f1f7019d7d551a6402fC5350c73;
    
    /// @notice PancakeSwap Router contract address
    address public constant PANCAKE_ROUTER = 0x10ED43C718714eb63d5aA57B78B54704E256024E;
    
    /// @notice Token Manager 2 contract address
    address public constant TOKEN_MANAGER_2 = 0x5c952063c7fc8610FFDB798152D69F0B9550762b;
    
    /// @notice Token Helper 5 contract address, used for handling swaps and liquidity operations
    address public constant TOKEN_HELPER_5 = 0x1d09D9979CB6f7A1c80D4B1604e3F4cE2130e41b;
    
    /// @notice Shareholder management contract address, used for blacklist checks
    address public constant SHARE_HOLDER_MANAGER = 0x19563730740D8d43CaB449D0F880548128FacFe7;

    /// @notice Normal transfer mode - allows all transfers
    uint public constant MODE_NORMAL = 0;
    
    /// @notice Restricted transfer mode
    uint public constant MODE_TRANSFER_RESTRICTED = 1;
    
    /// @notice Controlled transfer mode
    uint public constant MODE_TRANSFER_CONTROLLED = 2;
    
    /// @notice Current transfer mode
    uint public _mode;

    /// @notice Whether the contract has been initialized
    bool private _initialized;
    
    /// @notice Whether a swap operation is in progress (used to prevent reentrancy)
    bool private _swapping;

    /// @notice Quote token address
    address public quote;
    
    /// @notice PancakeSwap pair address 
    address public pair;
    
    /// @notice Founder address, receives founder rewards
    address public founder;
    
    /// @notice Transaction fee rate (basis points, 10000 = 100%)
    uint256 public feeRate;
    
    /// @notice Founder allocation rate
    uint256 public rateFounder;
    
    /// @notice Holder allocation rate
    uint256 public rateHolder;
    
    /// @notice Burn allocation rate
    uint256 public rateBurn;
    
    /// @notice Liquidity allocation rate
    uint256 public rateLiquidity;
    
    /// @notice Minimum dispatch threshold, fees are only dispatched when accumulated fees reach this value
    uint256 public minDispatch;
    
    /// @notice Minimum holding amount, addresses below this value do not participate in rewards
    uint256 public minShare;

    /**
     * @notice User reward information structure
     * @param share User token holding share (0 if balance is below minShare)
     * @param rewardDebt Calculated reward debt, used to track already accounted rewards
     * @param claimable Claimable reward amount (in quote tokens)
     * @param claimed Claimed reward amount (in quote tokens)
     */
    struct UserInfo {
        uint256 share;        // User token holding share (0 if balance < minShare)
        uint256 rewardDebt;   // Calculated reward debt, used to track already accounted rewards
        uint256 claimable;    // Claimable reward amount (in quote tokens)
        uint256 claimed;      // Claimed reward amount (in quote tokens)
    }

    /// @notice Magnitude multiplier, used for calculating feePerShare (2^128)
    uint256 internal constant MAGNITUDE = 2 ** 128;
    
    /// @notice User reward information mapping
    mapping(address => UserInfo) public userInfo;
    
    /// @notice Total token holding shares (sum of all user shares, excluding addresses below minShare)
    uint256 public totalShares;
    
    /// @notice Cumulative reward amount per share (using MAGNITUDE precision, accumulates with each dispatch)
    uint256 public feePerShare;

    /// @notice Total accumulated fees (not yet dispatched).
    uint256 public feeAccumulated;
    
    /// @notice Total dispatched fees
    uint256 public feeDispatched;
    
    /// @notice Total fees allocated to founder
    uint256 public feeFounder;
    
    /// @notice Total fees allocated to holders
    uint256 public feeHolder;
    
    /// @notice Total fees burned
    uint256 public feeBurn;
    
    /// @notice Total fees added to liquidity
    uint256 public feeLiquidity;

    /// @notice Total quote tokens allocated to founder
    uint256 public quoteFounder;
    
    /// @notice Total quote tokens allocated to holders
    uint256 public quoteHolder;
    
    /// @notice Total quote tokens claimed
    uint256 public quoteClaimed;

    /**
     * @notice Fee dispatch event
     * @param amountFounder Token amount allocated to founder
     * @param amountHolder Token amount allocated to holders
     * @param amountBurn Token amount burned
     * @param amountLiquidity Token amount added to liquidity
     * @param quoteFounder Quote token amount allocated to founder in this dispatch
     * @param quoteHolder Quote token amount allocated to holders in this dispatch
     */
    event FeeDispatched(
        uint256 amountFounder,
        uint256 amountHolder,
        uint256 amountBurn,
        uint256 amountLiquidity,
        uint256 quoteFounder,
        uint256 quoteHolder);

    /**
     * @notice Reward claim event
     * @param account Address claiming rewards
     * @param amount Amount of quote tokens claimed
     */
    event FeeClaimed(
        address account,
        uint256 amount);

    /**
     * @notice Initialize the token contract
     * @param a Initialization parameters structure, containing:
     *   - quote: Quote token address
     *   - founder: Founder address
     *   - feeRate: Transaction fee rate (basis points)
     *   - rateFounder: Founder allocation rate (percentage)
     *   - rateHolder: Holder allocation rate (percentage)
     *   - rateBurn: Burn allocation rate (percentage)
     *   - rateLiquidity: Liquidity allocation rate (percentage)
     *   - minDispatch: Minimum dispatch threshold
     *   - minShare: Minimum holding amount
     *   - name: Token name
     *   - symbol: Token symbol
     *   - totalSupply: Total supply
     */
    function init(ITokenCreator5.InitParams memory a) public onlyOwner {
        require(!_initialized, "Token: initialized");
        require(a.feeRate < 10000, "Token: invalid feeRate");
        require((a.founder == address(0)) == (a.rateFounder == 0), "Token: invalid rateFounder");
        require(a.rateFounder + a.rateHolder + a.rateBurn + a.rateLiquidity == 100, "Token: invalid total rates");
        _initialized = true;
        quote = a.quote;
        founder = a.founder;
        feeRate = a.feeRate;
        rateFounder = a.rateFounder;
        rateHolder = a.rateHolder;
        rateBurn = a.rateBurn;
        rateLiquidity = a.rateLiquidity;
        minDispatch = a.minDispatch;
        minShare = a.minShare;
        _init(a.name, a.symbol);
        _mint(owner(), a.totalSupply);
        _mode = MODE_TRANSFER_RESTRICTED;
        _updateShare(owner());
    }

    function _beforeTokenTransfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual override {
        super._beforeTokenTransfer(from, to, amount);
        if (_mode == MODE_TRANSFER_RESTRICTED) {
            revert("Token: Transfer is restricted");
        }
        if (_mode == MODE_TRANSFER_CONTROLLED) {
            require(from == owner() || to == owner(), "Token: Invalid transfer");
        }
    }

    function setMode(uint256 v) public onlyOwner {
        if (_mode != MODE_NORMAL) {
            _mode = v;
        }
    }

    function _pair() internal returns (address) {
        if (pair == address(0) && _mode == MODE_NORMAL) {
            pair = IPancakeFactory(PANCAKE_FACTORY).getPair(address(this), quote);
        }
        return pair;
    }

    function _transfer(
        address from,
        address to,
        uint256 amount
    ) internal override {
        require(to != address(this), "Token: invalid recipient");
        _pair();

        if (_mode == MODE_NORMAL && !_swapping) {
            if (to == pair) {
                _dispatchFee();
            }
            if ((from == pair && to != TOKEN_MANAGER_2) ||
                (to == pair && from != TOKEN_MANAGER_2)) {
                uint256 fee = amount * feeRate / 10000;
                if (fee > 0) {
                    amount -= fee;
                    super._transfer(from, address(this), fee);
                    feeAccumulated += fee;
                }
            }
        }

        super._transfer(from, to, amount);

        _updateShare(from);
        if (from != to) {
            _updateShare(to);
        }

        if (_mode == MODE_NORMAL && !_swapping) {
            if (msg.sender != pair && from != pair && to != pair) {
                _dispatchFee();
                _claimFee(from);
            }
        }
    }

    function _isShareHolder(address account) internal returns (bool) {
        return account != _pair() &&
               account != TOKEN_MANAGER_2 &&
               account != address(this) &&
               account != address(0) &&
               account != DEAD;
    }

    function _updateShare(address account) internal {
        if (rateHolder == 0 || !_isShareHolder(account)) {
            return;
        }

        uint256 newShare = balanceOf(account);
        if (newShare < minShare) {
            newShare = 0;
        }

        UserInfo storage info = userInfo[account];
        uint256 curShare = info.share;
        if (newShare == curShare) {
            return;
        }

        if (curShare > 0) {
            uint256 accFee = curShare * feePerShare / MAGNITUDE;
            if (accFee > info.rewardDebt) {
                info.claimable += accFee - info.rewardDebt;
            }
        }

        info.share = newShare;
        info.rewardDebt = newShare * feePerShare / MAGNITUDE;

        if (newShare > curShare) {
            totalShares = totalShares + (newShare - curShare);
        } else {
            totalShares = totalShares - (curShare - newShare);
        }
    }

    function _dispatchFee() internal {
        uint256 amountTotal = feeAccumulated;
        if (amountTotal < minDispatch) {
            return;
        }

        feeAccumulated = 0;
        uint256 rateTotal = rateFounder + rateBurn + rateLiquidity;
        uint256 amountFounder;
        uint256 amountHolder;
        uint256 amountBurn;
        uint256 amountLiquidity;

        uint256 _quoteFounder;
        uint256 _quoteHolder;

        if (rateHolder > 0 && totalShares > 0) {
            rateTotal += rateHolder;
            amountHolder = amountTotal * rateHolder / rateTotal;
            feeHolder += amountHolder;
            _quoteHolder = _swapForQuote(address(this), amountHolder);
            feePerShare += (_quoteHolder * MAGNITUDE / totalShares);
            quoteHolder += _quoteHolder;
        }
        if (rateFounder > 0) {
            amountFounder = amountTotal * rateFounder / rateTotal;
            feeFounder += amountFounder;
            if (quote == WETH) {
                quoteFounder += (_quoteFounder = _swapForETH(founder, amountFounder));
            } else {
                quoteFounder += (_quoteFounder = _swapForQuote(founder, amountFounder));
            }
        }
        if (rateBurn > 0) {
            amountBurn = amountTotal * rateBurn / rateTotal;
            feeBurn += amountBurn;
            super._transfer(address(this), DEAD, amountBurn);
        }
        if (rateLiquidity > 0) {
            amountLiquidity = amountTotal * rateLiquidity / rateTotal;
            feeLiquidity += amountLiquidity;
            _addLiquidity(amountLiquidity);
        }

        uint256 amountDispatched = amountFounder + amountHolder + amountBurn + amountLiquidity;
        feeAccumulated = amountTotal - amountDispatched;
        feeDispatched += amountDispatched;

        emit FeeDispatched(amountFounder, amountHolder, amountBurn, amountLiquidity, _quoteFounder, _quoteHolder);
    }

    /**
     * @notice Query the claimable reward amount for an account
     * @param account Account address
     * @return Claimable quote token amount
     */
    function claimableFee(address account) view public returns (uint256) {
        UserInfo storage info = userInfo[account];
        uint256 amount = info.claimable;

        uint256 accFee = info.share * feePerShare / MAGNITUDE;
        if (accFee > info.rewardDebt) {
            amount += accFee - info.rewardDebt;
        }

        return amount;
    }

    /**
     * @notice Query the claimed reward amount for an account
     * @param account Account address
     * @return Claimed quote token amount
     */
    function claimedFee(address account) view public returns (uint256) {
        return userInfo[account].claimed;
    }

    /**
     * @notice Claim rewards
     */
    function claimFee() external {
        _updateShare(msg.sender);
        _claimFee(msg.sender);
    }

    function _claimFee(address account) internal {
        if (IShareHolderManager(SHARE_HOLDER_MANAGER).isBlacklisted(account)) {
            return;
        }

        uint256 amountQuote = claimableFee(account);
        if (amountQuote > 0) {
            UserInfo storage info = userInfo[account];
            info.rewardDebt = info.share * feePerShare / MAGNITUDE;
            info.claimable = 0;

            SafeERC20.safeTransfer(IERC20(quote), account, amountQuote);
            info.claimed += amountQuote;
            quoteClaimed += amountQuote;

            emit FeeClaimed(account, amountQuote);
        }
    }

    function _swapForETH(address to, uint256 amountToken) private returns (uint256) {
        _swapping = true;
        _approve(address(this), TOKEN_HELPER_5, amountToken);
        uint256 amountQuote = ITokenHelper(TOKEN_HELPER_5).swapForETH(to, amountToken);
        _swapping = false;
        return amountQuote;
    }

    function _swapForQuote(address to, uint256 amountToken) private returns (uint256) {
        _swapping = true;
        _approve(address(this), TOKEN_HELPER_5, amountToken);
        uint256 amountQuote = ITokenHelper(TOKEN_HELPER_5).swapForQuote(to, amountToken);
        _swapping = false;
        return amountQuote;
    }

    function _addLiquidity(uint256 amountToken) internal {
        _swapping = true;
        _approve(address(this), TOKEN_HELPER_5, amountToken);
        ITokenHelper(TOKEN_HELPER_5).addLiquidity(amountToken);
        _swapping = false;
    }
}

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

pragma solidity ^0.8.1;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     *
     * Furthermore, `isContract` will also return true if the target contract within
     * the same transaction is already scheduled for destruction by `SELFDESTRUCT`,
     * which only has an effect at the end of a transaction.
     * ====
     *
     * [IMPORTANT]
     * ====
     * You shouldn't rely on `isContract` to protect against flash loan attacks!
     *
     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
     * constructor.
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize/address.code.length, which returns 0
        // for contracts in construction, since the code is only stored at the end
        // of the constructor execution.

        return account.code.length > 0;
    }

    /**
     * @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.0/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "Address: insufficient balance");

        (bool success, ) = recipient.call{value: amount}("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }

    /**
     * @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, it is bubbled up by this
     * function (like regular Solidity function calls).
     *
     * 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.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, "Address: low-level call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
     * `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, errorMessage);
    }

    /**
     * @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`.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
        return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
    }

    /**
     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
     * with `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value,
        string memory errorMessage
    ) internal returns (bytes memory) {
        require(address(this).balance >= value, "Address: insufficient balance for call");
        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
        return functionStaticCall(target, data, "Address: low-level static call failed");
    }

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

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionDelegateCall(target, data, "Address: low-level delegate call failed");
    }

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

    /**
     * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling
     * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.
     *
     * _Available since v4.8._
     */
    function verifyCallResultFromTarget(
        address target,
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        if (success) {
            if (returndata.length == 0) {
                // only check isContract if the call was successful and the return data is empty
                // otherwise we already know that it was a contract
                require(isContract(target), "Address: call to non-contract");
            }
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    /**
     * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason or using the provided one.
     *
     * _Available since v4.3._
     */
    function verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal pure returns (bytes memory) {
        if (success) {
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    function _revert(bytes memory returndata, string memory errorMessage) 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(errorMessage);
        }
    }
}

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

pragma solidity ^0.8.0;

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

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

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

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

import "./IERC20.sol";
import "./IERC20Metadata.sol";
import "./Context.sol";

/**
 * @dev Implementation of the {IERC20} interface.
 *
 * This implementation is agnostic to the way tokens are created. This means
 * that a supply mechanism has to be added in a derived contract using {_mint}.
 * For a generic mechanism see {ERC20PresetMinterPauser}.
 *
 * TIP: For a detailed writeup see our guide
 * https://forum.openzeppelin.com/t/how-to-implement-erc20-supply-mechanisms/226[How
 * to implement supply mechanisms].
 *
 * 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 ERC20
 * applications.
 *
 * Additionally, an {Approval} event is emitted on calls to {transferFrom}.
 * This allows applications to reconstruct the allowance for all accounts just
 * by listening to said events. Other implementations of the EIP may not emit
 * these events, as it isn't required by the specification.
 *
 * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}
 * functions have been added to mitigate the well-known issues around setting
 * allowances. See {IERC20-approve}.
 */
contract FourERC20 is Context, IERC20, IERC20Metadata {
    mapping(address => uint256) private _balances;

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

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;

    /**
     * @dev Sets the values for {name} and {symbol}.
     *
     * All two of these values are immutable: they can only be set once during
     * construction.
     */
    function _init(string memory name_, string memory symbol_) internal {
        _name = name_;
        _symbol = symbol_;
    }

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

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

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

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

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

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

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

    /**
     * @dev See {IERC20-approve}.
     *
     * NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on
     * `transferFrom`. This is semantically equivalent to an infinite approval.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function approve(address spender, uint256 amount) public virtual override returns (bool) {
        address owner = _msgSender();
        _approve(owner, spender, amount);
        return true;
    }

    /**
     * @dev See {IERC20-transferFrom}.
     *
     * Emits an {Approval} event indicating the updated allowance. This is not
     * required by the EIP. See the note at the beginning of {ERC20}.
     *
     * NOTE: Does not update the allowance if the current allowance
     * is the maximum `uint256`.
     *
     * Requirements:
     *
     * - `from` and `to` cannot be the zero address.
     * - `from` must have a balance of at least `amount`.
     * - the caller must have allowance for ``from``'s tokens of at least
     * `amount`.
     */
    function transferFrom(address from, address to, uint256 amount) public virtual override returns (bool) {
        address spender = _msgSender();
        _spendAllowance(from, spender, amount);
        _transfer(from, to, amount);
        return true;
    }

    /**
     * @dev Atomically increases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
        address owner = _msgSender();
        _approve(owner, spender, allowance(owner, spender) + addedValue);
        return true;
    }

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

        return true;
    }

    /**
     * @dev Moves `amount` of tokens from `from` to `to`.
     *
     * This internal function is equivalent to {transfer}, and can be used to
     * e.g. implement automatic token fees, slashing mechanisms, etc.
     *
     * Emits a {Transfer} event.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `from` must have a balance of at least `amount`.
     */
    function _transfer(address from, address to, uint256 amount) internal virtual {
        require(from != address(0), "ERC20: transfer from the zero address");
        require(to != address(0), "ERC20: transfer to the zero address");

        _beforeTokenTransfer(from, to, amount);

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

        emit Transfer(from, to, amount);

        _afterTokenTransfer(from, to, amount);
    }

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

        _beforeTokenTransfer(address(0), account, amount);

        _totalSupply += amount;
        unchecked {
            // Overflow not possible: balance + amount is at most totalSupply + amount, which is checked above.
            _balances[account] += amount;
        }
        emit Transfer(address(0), account, amount);

        _afterTokenTransfer(address(0), account, amount);
    }

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

        _beforeTokenTransfer(account, address(0), amount);

        uint256 accountBalance = _balances[account];
        require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
        unchecked {
            _balances[account] = accountBalance - amount;
            // Overflow not possible: amount <= accountBalance <= totalSupply.
            _totalSupply -= amount;
        }

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

        _afterTokenTransfer(account, address(0), amount);
    }

    /**
     * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
     *
     * This internal function is equivalent to `approve`, and can be used to
     * e.g. set automatic allowances for certain subsystems, etc.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `owner` cannot be the zero address.
     * - `spender` cannot be the zero address.
     */
    function _approve(address owner, address spender, uint256 amount) internal virtual {
        require(owner != address(0), "ERC20: approve from the zero address");
        require(spender != address(0), "ERC20: approve to the zero address");

        _allowances[owner][spender] = amount;
        emit Approval(owner, spender, amount);
    }

    /**
     * @dev Updates `owner` s allowance for `spender` based on spent `amount`.
     *
     * Does not update the allowance amount in case of infinite allowance.
     * Revert if not enough allowance is available.
     *
     * Might emit an {Approval} event.
     */
    function _spendAllowance(address owner, address spender, uint256 amount) internal virtual {
        uint256 currentAllowance = allowance(owner, spender);
        if (currentAllowance != type(uint256).max) {
            require(currentAllowance >= amount, "ERC20: insufficient allowance");
            unchecked {
                _approve(owner, spender, currentAllowance - amount);
            }
        }
    }

    /**
     * @dev Hook that is called before any transfer of tokens. This includes
     * minting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
     * will be transferred to `to`.
     * - when `from` is zero, `amount` tokens will be minted for `to`.
     * - when `to` is zero, `amount` of ``from``'s tokens will be burned.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual {}

    /**
     * @dev Hook that is called after any transfer of tokens. This includes
     * minting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
     * has been transferred to `to`.
     * - when `from` is zero, `amount` tokens have been minted for `to`.
     * - when `to` is zero, `amount` of ``from``'s tokens have been burned.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _afterTokenTransfer(address from, address to, uint256 amount) internal virtual {}
}

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

pragma solidity ^0.8.0;

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

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

    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

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

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

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

    /**
     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 amount) external returns (bool);

    /**
     * @dev Moves `amount` tokens from `from` to `to` using the
     * allowance mechanism. `amount` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address from, address to, uint256 amount) external returns (bool);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol)

pragma solidity ^0.8.0;

import "./IERC20.sol";

/**
 * @dev Interface for the optional metadata functions from the ERC20 standard.
 *
 * _Available since v4.1._
 */
interface IERC20Metadata is IERC20 {
    /**
     * @dev Returns the name of the token.
     */
    function name() external view returns (string memory);

    /**
     * @dev Returns the symbol of the token.
     */
    function symbol() external view returns (string memory);

    /**
     * @dev Returns the decimals places of the token.
     */
    function decimals() external view returns (uint8);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.4) (token/ERC20/extensions/IERC20Permit.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in
 * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].
 *
 * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by
 * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't
 * need to send a transaction, and thus is not required to hold Ether at all.
 *
 * ==== Security Considerations
 *
 * There are two important considerations concerning the use of `permit`. The first is that a valid permit signature
 * expresses an allowance, and it should not be assumed to convey additional meaning. In particular, it should not be
 * considered as an intention to spend the allowance in any specific way. The second is that because permits have
 * built-in replay protection and can be submitted by anyone, they can be frontrun. A protocol that uses permits should
 * take this into consideration and allow a `permit` call to fail. Combining these two aspects, a pattern that may be
 * generally recommended is:
 *
 * ```solidity
 * function doThingWithPermit(..., uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) public {
 *     try token.permit(msg.sender, address(this), value, deadline, v, r, s) {} catch {}
 *     doThing(..., value);
 * }
 *
 * function doThing(..., uint256 value) public {
 *     token.safeTransferFrom(msg.sender, address(this), value);
 *     ...
 * }
 * ```
 *
 * Observe that: 1) `msg.sender` is used as the owner, leaving no ambiguity as to the signer intent, and 2) the use of
 * `try/catch` allows the permit to fail and makes the code tolerant to frontrunning. (See also
 * {SafeERC20-safeTransferFrom}).
 *
 * Additionally, note that smart contract wallets (such as Argent or Safe) are not able to produce permit signatures, so
 * contracts should have entry points that don't rely on permit.
 */
interface IERC20Permit {
    /**
     * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,
     * given ``owner``'s signed approval.
     *
     * IMPORTANT: The same issues {IERC20-approve} has related to transaction
     * ordering also apply here.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `deadline` must be a timestamp in the future.
     * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`
     * over the EIP712-formatted function arguments.
     * - the signature must use ``owner``'s current nonce (see {nonces}).
     *
     * For more information on the signature format, see the
     * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP
     * section].
     *
     * CAUTION: See Security Considerations above.
     */
    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external;

    /**
     * @dev Returns the current nonce for `owner`. This value must be
     * included whenever a signature is generated for {permit}.
     *
     * Every successful call to {permit} increases ``owner``'s nonce by one. This
     * prevents a signature from being used multiple times.
     */
    function nonces(address owner) external view returns (uint256);

    /**
     * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.
     */
    // solhint-disable-next-line func-name-mixedcase
    function DOMAIN_SEPARATOR() external view returns (bytes32);
}

// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.5.0;

interface IPancakeFactory {
    event PairCreated(address indexed token0, address indexed token1, address pair, uint256);

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

    function allPairsLength() external view returns (uint256);

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

    function setFeeTo(address) external;

    function setFeeToSetter(address) external;

    function INIT_CODE_PAIR_HASH() external view returns (bytes32);
}

// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.5.0;

interface IPancakePair {
    event Approval(address indexed owner, address indexed spender, uint256 value);
    event Transfer(address indexed from, address indexed to, uint256 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 (uint256);

    function balanceOf(address owner) external view returns (uint256);

    function allowance(address owner, address spender) external view returns (uint256);

    function approve(address spender, uint256 value) external returns (bool);

    function transfer(address to, uint256 value) external returns (bool);

    function transferFrom(
        address from,
        address to,
        uint256 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 (uint256);

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

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

    function MINIMUM_LIQUIDITY() external pure returns (uint256);

    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 (uint256);

    function price1CumulativeLast() external view returns (uint256);

    function kLast() external view returns (uint256);

    function mint(address to) external returns (uint256 liquidity);

    function burn(address to) external returns (uint256 amount0, uint256 amount1);

    function swap(
        uint256 amount0Out,
        uint256 amount1Out,
        address to,
        bytes calldata data
    ) external;

    function skim(address to) external;

    function sync() external;

    function initialize(address, address) external;
}

// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.6.2;

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

    function WETH() external pure returns (address);

    function addLiquidity(
        address tokenA,
        address tokenB,
        uint256 amountADesired,
        uint256 amountBDesired,
        uint256 amountAMin,
        uint256 amountBMin,
        address to,
        uint256 deadline
    )
        external
        returns (
            uint256 amountA,
            uint256 amountB,
            uint256 liquidity
        );

    function addLiquidityETH(
        address token,
        uint256 amountTokenDesired,
        uint256 amountTokenMin,
        uint256 amountETHMin,
        address to,
        uint256 deadline
    )
        external
        payable
        returns (
            uint256 amountToken,
            uint256 amountETH,
            uint256 liquidity
        );

    function removeLiquidity(
        address tokenA,
        address tokenB,
        uint256 liquidity,
        uint256 amountAMin,
        uint256 amountBMin,
        address to,
        uint256 deadline
    ) external returns (uint256 amountA, uint256 amountB);

    function removeLiquidityETH(
        address token,
        uint256 liquidity,
        uint256 amountTokenMin,
        uint256 amountETHMin,
        address to,
        uint256 deadline
    ) external returns (uint256 amountToken, uint256 amountETH);

    function removeLiquidityWithPermit(
        address tokenA,
        address tokenB,
        uint256 liquidity,
        uint256 amountAMin,
        uint256 amountBMin,
        address to,
        uint256 deadline,
        bool approveMax,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external returns (uint256 amountA, uint256 amountB);

    function removeLiquidityETHWithPermit(
        address token,
        uint256 liquidity,
        uint256 amountTokenMin,
        uint256 amountETHMin,
        address to,
        uint256 deadline,
        bool approveMax,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external returns (uint256 amountToken, uint256 amountETH);

    function swapExactTokensForTokens(
        uint256 amountIn,
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external returns (uint256[] memory amounts);

    function swapTokensForExactTokens(
        uint256 amountOut,
        uint256 amountInMax,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external returns (uint256[] memory amounts);

    function swapExactETHForTokens(
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external payable returns (uint256[] memory amounts);

    function swapTokensForExactETH(
        uint256 amountOut,
        uint256 amountInMax,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external returns (uint256[] memory amounts);

    function swapExactTokensForETH(
        uint256 amountIn,
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external returns (uint256[] memory amounts);

    function swapETHForExactTokens(
        uint256 amountOut,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external payable returns (uint256[] memory amounts);

    function quote(
        uint256 amountA,
        uint256 reserveA,
        uint256 reserveB
    ) external pure returns (uint256 amountB);

    function getAmountOut(
        uint256 amountIn,
        uint256 reserveIn,
        uint256 reserveOut
    ) external pure returns (uint256 amountOut);

    function getAmountIn(
        uint256 amountOut,
        uint256 reserveIn,
        uint256 reserveOut
    ) external pure returns (uint256 amountIn);

    function getAmountsOut(uint256 amountIn, address[] calldata path) external view returns (uint256[] memory amounts);

    function getAmountsIn(uint256 amountOut, address[] calldata path) external view returns (uint256[] memory amounts);
}

// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.6.2;

import "./IPancakeRouter01.sol";

interface IPancakeRouter02 is IPancakeRouter01 {
    function removeLiquidityETHSupportingFeeOnTransferTokens(
        address token,
        uint256 liquidity,
        uint256 amountTokenMin,
        uint256 amountETHMin,
        address to,
        uint256 deadline
    ) external returns (uint256 amountETH);

    function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
        address token,
        uint256 liquidity,
        uint256 amountTokenMin,
        uint256 amountETHMin,
        address to,
        uint256 deadline,
        bool approveMax,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external returns (uint256 amountETH);

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

    function swapExactETHForTokensSupportingFeeOnTransferTokens(
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external payable;

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

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.10;

interface ITokenCreator5 {
    struct InitParams {
        address quote;
        string name;
        string symbol;
        uint256 totalSupply;
        address founder;
        uint256 feeRate;
        uint256 rateFounder;
        uint256 rateHolder;
        uint256 rateBurn;
        uint256 rateLiquidity;
        uint256 minDispatch;
        uint256 minShare;
    }

    function createToken(uint256 salt, InitParams memory) external returns (address);
}

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

pragma solidity ^0.8.0;

import "./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.
 *
 * By default, the owner account will be the one that deploys the contract. This
 * can later be changed with {transferOwnership}.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
abstract contract Ownable is Context {
    address private _owner;

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

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor() {
        _transferOwnership(_msgSender());
    }

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

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

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view virtual {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions. 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 {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        _transferOwnership(newOwner);
    }

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.3) (token/ERC20/utils/SafeERC20.sol)

pragma solidity ^0.8.0;

import "./IERC20.sol";
import "./IERC20Permit.sol";
import "./Address.sol";

/**
 * @title SafeERC20
 * @dev Wrappers around ERC20 operations that throw on failure (when the token
 * contract returns false). Tokens that return no value (and instead revert or
 * throw on failure) are also supported, non-reverting calls are assumed to be
 * successful.
 * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
 * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
 */
library SafeERC20 {
    using Address for address;

    /**
     * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,
     * non-reverting calls are assumed to be successful.
     */
    function safeTransfer(IERC20 token, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
    }

    /**
     * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the
     * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.
     */
    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
    }

    /**
     * @dev Deprecated. This function has issues similar to the ones found in
     * {IERC20-approve}, and its usage is discouraged.
     *
     * Whenever possible, use {safeIncreaseAllowance} and
     * {safeDecreaseAllowance} instead.
     */
    function safeApprove(IERC20 token, address spender, uint256 value) internal {
        // safeApprove should only be called when setting an initial allowance,
        // or when resetting it to zero. To increase and decrease it, use
        // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
        require(
            (value == 0) || (token.allowance(address(this), spender) == 0),
            "SafeERC20: approve from non-zero to non-zero allowance"
        );
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
    }

    /**
     * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,
     * non-reverting calls are assumed to be successful.
     */
    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        uint256 oldAllowance = token.allowance(address(this), spender);
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, oldAllowance + value));
    }

    /**
     * @dev Decrease the calling contract's allowance toward `spender` by `value`. If `token` returns no value,
     * non-reverting calls are assumed to be successful.
     */
    function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        unchecked {
            uint256 oldAllowance = token.allowance(address(this), spender);
            require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
            _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, oldAllowance - value));
        }
    }

    /**
     * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,
     * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval
     * to be set to zero before setting it to a non-zero value, such as USDT.
     */
    function forceApprove(IERC20 token, address spender, uint256 value) internal {
        bytes memory approvalCall = abi.encodeWithSelector(token.approve.selector, spender, value);

        if (!_callOptionalReturnBool(token, approvalCall)) {
            _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, 0));
            _callOptionalReturn(token, approvalCall);
        }
    }

    /**
     * @dev Use a ERC-2612 signature to set the `owner` approval toward `spender` on `token`.
     * Revert on invalid signature.
     */
    function safePermit(
        IERC20Permit token,
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal {
        uint256 nonceBefore = token.nonces(owner);
        token.permit(owner, spender, value, deadline, v, r, s);
        uint256 nonceAfter = token.nonces(owner);
        require(nonceAfter == nonceBefore + 1, "SafeERC20: permit did not succeed");
    }

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     */
    function _callOptionalReturn(IERC20 token, bytes memory data) private {
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
        // we're implementing it ourselves. We use {Address-functionCall} to perform this call, which verifies that
        // the target address contains contract code and also asserts for success in the low-level call.

        bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
        require(returndata.length == 0 || abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
    }

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     *
     * This is a variant of {_callOptionalReturn} that silents catches all reverts and returns a bool instead.
     */
    function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
        // we're implementing it ourselves. We cannot use {Address-functionCall} here since this should return false
        // and not revert is the subcall reverts.

        (bool success, bytes memory returndata) = address(token).call(data);
        return
            success && (returndata.length == 0 || abi.decode(returndata, (bool))) && Address.isContract(address(token));
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"FeeClaimed","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"amountFounder","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amountHolder","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amountBurn","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amountLiquidity","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"quoteFounder","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"quoteHolder","type":"uint256"}],"name":"FeeDispatched","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"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":"DEAD","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MODE_NORMAL","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MODE_TRANSFER_CONTROLLED","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MODE_TRANSFER_RESTRICTED","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"PANCAKE_FACTORY","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"PANCAKE_ROUTER","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"SHARE_HOLDER_MANAGER","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"TOKEN_HELPER_5","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"TOKEN_MANAGER_2","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"WETH","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_mode","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"claimFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"claimableFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"claimedFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"subtractedValue","type":"uint256"}],"name":"decreaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"feeAccumulated","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"feeBurn","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"feeDispatched","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"feeFounder","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"feeHolder","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"feeLiquidity","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"feePerShare","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"feeRate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"founder","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"addedValue","type":"uint256"}],"name":"increaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"quote","type":"address"},{"internalType":"string","name":"name","type":"string"},{"internalType":"string","name":"symbol","type":"string"},{"internalType":"uint256","name":"totalSupply","type":"uint256"},{"internalType":"address","name":"founder","type":"address"},{"internalType":"uint256","name":"feeRate","type":"uint256"},{"internalType":"uint256","name":"rateFounder","type":"uint256"},{"internalType":"uint256","name":"rateHolder","type":"uint256"},{"internalType":"uint256","name":"rateBurn","type":"uint256"},{"internalType":"uint256","name":"rateLiquidity","type":"uint256"},{"internalType":"uint256","name":"minDispatch","type":"uint256"},{"internalType":"uint256","name":"minShare","type":"uint256"}],"internalType":"struct ITokenCreator5.InitParams","name":"a","type":"tuple"}],"name":"init","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"minDispatch","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"minShare","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pair","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"quote","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"quoteClaimed","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"quoteFounder","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"quoteHolder","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rateBurn","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rateFounder","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rateHolder","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rateLiquidity","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"v","type":"uint256"}],"name":"setMode","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalShares","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"userInfo","outputs":[{"internalType":"uint256","name":"share","type":"uint256"},{"internalType":"uint256","name":"rewardDebt","type":"uint256"},{"internalType":"uint256","name":"claimable","type":"uint256"},{"internalType":"uint256","name":"claimed","type":"uint256"}],"stateMutability":"view","type":"function"}]

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

2133:14464:13:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2325:46;;2364:6;2325:46;;;;;-1:-1:-1;;;;;178:32:14;;;160:51;;148:2;133:18;2325:46:13;;;;;;;;2139:100:2;;;:::i;:::-;;;;;;;:::i;4499:201::-;;;;;;:::i;:::-;;:::i;:::-;;;1638:14:14;;1631:22;1613:41;;1601:2;1586:18;4499:201:2;1473:187:14;4511:26:13;;;;;;;;;1811:25:14;;;1799:2;1784:18;4511:26:13;1665:177:14;3268:108:2;3356:12;;3268:108;;4288:23:13;;;;;;5577:44;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2330:25:14;;;2386:2;2371:18;;2364:34;;;;2414:18;;;2407:34;2472:2;2457:18;;2450:34;2317:3;2302:19;5577:44:13;2099:391:14;3339:49:13;;3387:1;3339:49;;5280:261:2;;;;;;:::i;:::-;;:::i;3110:93::-;;;3193:2;3098:36:14;;3086:2;3071:18;3110:93:2;2956:184:14;3440:49:13;;3488:1;3440:49;;5950:238:2;;;;;;:::i;:::-;;:::i;5736:26:13:-;;;;;;3251:36;;3286:1;3251:36;;3967:22;;;;;-1:-1:-1;;;;;3967:22:13;;;6639:27;;;;;;6296:22;;;;;;4215:25;;;;;;8238:872;;;;;;:::i;:::-;;:::i;:::-;;5978:29;;;;;;4139:26;;;;;;5884;;;;;;3439:127:2;;;;;;:::i;:::-;-1:-1:-1;;;;;3540:18:2;3513:7;3540:18;;;;;;;;;;;;3439:127;1877:103:11;;;:::i;14804:116:13:-;;;;;;:::i;:::-;-1:-1:-1;;;;;14888:17:13;14862:7;14888:17;;;:8;:17;;;;;:25;;;;14804:116;2435:84;;2477:42;2435:84;;4645:23;;;;;;1236:87:11;1309:6;;-1:-1:-1;;;;;1309:6:11;1236:87;;3095:89:13;;3142:42;3095:89;;2918:83;;2959:42;2918:83;;2358:104:2;;;:::i;4066:22:13:-;;;;;;3806:20;;;;;;;;-1:-1:-1;;;;;3806:20:13;;;14971:101;;;:::i;14286:354::-;;;;;;:::i;:::-;;:::i;6691:436:2:-;;;;;;:::i;:::-;;:::i;3879:19:13:-;;;;;-1:-1:-1;;;;;3879:19:13;;;3772:193:2;;;;;;:::i;:::-;;:::i;2212:73:13:-;;2243:42;2212:73;;6375:27;;;;;;3538:17;;;;;;6227:24;;;;;;6559:26;;;;;;6056:28;;;;;;6465:27;;;;;;9564:121;;;;;;:::i;:::-;;:::i;6143:25::-;;;;;;4028:151:2;;;;;;:::i;:::-;;:::i;2582:83:13:-;;2623:42;2582:83;;2725:84;;2767:42;2725:84;;4364:28;;;;;;2135:201:11;;;;;;:::i;:::-;;:::i;2139:100:2:-;2193:13;2226:5;2219:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2139:100;:::o;4499:201::-;4582:4;751:10:1;4638:32:2;751:10:1;4654:7:2;4663:6;4638:8;:32::i;:::-;4688:4;4681:11;;;4499:201;;;;;:::o;5280:261::-;5377:4;751:10:1;5435:38:2;5451:4;751:10:1;5466:6:2;5435:15;:38::i;:::-;5484:27;5494:4;5500:2;5504:6;5484:9;:27::i;:::-;-1:-1:-1;5529:4:2;;5280:261;-1:-1:-1;;;;5280:261:2:o;5950:238::-;6038:4;751:10:1;6094:64:2;751:10:1;6110:7:2;6147:10;6119:25;751:10:1;6110:7:2;6119:9;:25::i;:::-;:38;;;;:::i;:::-;6094:8;:64::i;8238:872:13:-;1122:13:11;:11;:13::i;:::-;8324:12:13::1;::::0;::::1;;8323:13;8315:44;;;::::0;-1:-1:-1;;;8315:44:13;;7158:2:14;8315:44:13::1;::::0;::::1;7140:21:14::0;7197:2;7177:18;;;7170:30;-1:-1:-1;;;7216:18:14;;;7209:48;7274:18;;8315:44:13::1;;;;;;;;;8389:5;8377:1;:9;;;:17;8369:52;;;::::0;-1:-1:-1;;;8369:52:13;;7505:2:14;8369:52:13::1;::::0;::::1;7487:21:14::0;7544:2;7524:18;;;7517:30;-1:-1:-1;;;7563:18:14;;;7556:52;7625:18;;8369:52:13::1;7303:346:14::0;8369:52:13::1;8469:13;::::0;::::1;::::0;8440:9:::1;::::0;::::1;::::0;-1:-1:-1;;;;;8440:23:13::1;::::0;8469:18;;8439:49:::1;8431:88;;;::::0;-1:-1:-1;;;8431:88:13;;7856:2:14;8431:88:13::1;::::0;::::1;7838:21:14::0;7895:2;7875:18;;;7868:30;7934:28;7914:18;;;7907:56;7980:18;;8431:88:13::1;7654:350:14::0;8431:88:13::1;8581:1;:15;;;8568:1;:10;;;8553:1;:12;;;8537:1;:13;;;:28;;;;:::i;:::-;:41;;;;:::i;:::-;:59;;;;:::i;:::-;8600:3;8537:66;8529:105;;;::::0;-1:-1:-1;;;8529:105:13;;8211:2:14;8529:105:13::1;::::0;::::1;8193:21:14::0;8250:2;8230:18;;;8223:30;8289:28;8269:18;;;8262:56;8335:18;;8529:105:13::1;8009:350:14::0;8529:105:13::1;8644:12;:19:::0;;8681:7;;8659:4:::1;-1:-1:-1::0;;;;;;8673:15:13;;;;-1:-1:-1;;;;;8673:15:13;;::::1;;::::0;;;;;;;;8708:9:::1;::::0;::::1;::::0;8698:7:::1;:19:::0;;-1:-1:-1;;;;;;8698:19:13::1;::::0;;;::::1;;::::0;;8737:9:::1;::::0;::::1;::::0;8727:7:::1;:19:::0;8770:13:::1;::::0;::::1;::::0;8756:11:::1;:27:::0;8806:12:::1;::::0;::::1;::::0;8793:10:::1;:25:::0;8644:19:::1;8839:10:::0;::::1;::::0;8828:8:::1;:21:::0;8875:15:::1;::::0;::::1;::::0;8859:13:::1;:31:::0;8914:13:::1;::::0;::::1;::::0;8900:11:::1;:27:::0;8948:10:::1;::::0;::::1;::::0;8937:8:::1;:21:::0;8974:6:::1;::::0;::::1;::::0;8982:8:::1;::::0;::::1;::::0;8968:23:::1;::::0;8974:6;8968:5:::1;:23::i;:::-;9001:29;9007:7;1309:6:11::0;;-1:-1:-1;;;;;1309:6:11;;1236:87;9007:7:13::1;9016:1;:13;;;9001:5;:29::i;:::-;3387:1;9040:5;:32:::0;9082:21:::1;9095:7;1309:6:11::0;;-1:-1:-1;;;;;1309:6:11;;1236:87;9095:7:13::1;9082:12;:21::i;:::-;8238:872:::0;:::o;1877:103:11:-;1122:13;:11;:13::i;:::-;1942:30:::1;1969:1;1942:18;:30::i;:::-;1877:103::o:0;2358:104:2:-;2414:13;2447:7;2440:14;;;;;:::i;14971:101:13:-;15010:24;15023:10;15010:12;:24::i;:::-;15044:21;15054:10;15044:9;:21::i;14286:354::-;-1:-1:-1;;;;;14389:17:13;;14346:7;14389:17;;;:8;:17;;;;;14433:14;;;;14488:11;;14475:10;;14346:7;;-1:-1:-1;;;5510:8:13;14475:24;;14488:11;14475:24;:::i;:::-;:36;;;;:::i;:::-;14458:53;;14534:4;:15;;;14525:6;:24;14521:89;;;14584:15;;;;14575:24;;:6;:24;:::i;:::-;14565:34;;;;:::i;:::-;;;14521:89;-1:-1:-1;14627:6:13;14286:354;-1:-1:-1;;;14286:354:13:o;6691:436:2:-;6784:4;751:10:1;6784:4:2;6867:25;751:10:1;6884:7:2;6867:9;:25::i;:::-;6840:52;;6931:15;6911:16;:35;;6903:85;;;;-1:-1:-1;;;6903:85:2;;9094:2:14;6903:85:2;;;9076:21:14;9133:2;9113:18;;;9106:30;9172:34;9152:18;;;9145:62;-1:-1:-1;;;9223:18:14;;;9216:35;9268:19;;6903:85:2;8892:401:14;6903:85:2;7024:60;7033:5;7040:7;7068:15;7049:16;:34;7024:8;:60::i;3772:193::-;3851:4;751:10:1;3907:28:2;751:10:1;3924:2:2;3928:6;3907:9;:28::i;9564:121:13:-;1122:13:11;:11;:13::i;:::-;9623:5:13::1;::::0;:20;9619:60:::1;;9659:5;:9:::0;9564:121::o;4028:151:2:-;-1:-1:-1;;;;;4144:18:2;;;4117:7;4144:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;4028:151::o;2135:201:11:-;1122:13;:11;:13::i;:::-;-1:-1:-1;;;;;2224:22:11;::::1;2216:73;;;::::0;-1:-1:-1;;;2216:73:11;;9500:2:14;2216:73:11::1;::::0;::::1;9482:21:14::0;9539:2;9519:18;;;9512:30;9578:34;9558:18;;;9551:62;-1:-1:-1;;;9629:18:14;;;9622:36;9675:19;;2216:73:11::1;9298:402:14::0;2216:73:11::1;2300:28;2319:8;2300:18;:28::i;10684:346:2:-:0;-1:-1:-1;;;;;10786:19:2;;10778:68;;;;-1:-1:-1;;;10778:68:2;;9907:2:14;10778:68:2;;;9889:21:14;9946:2;9926:18;;;9919:30;9985:34;9965:18;;;9958:62;-1:-1:-1;;;10036:18:14;;;10029:34;10080:19;;10778:68:2;9705:400:14;10778:68:2;-1:-1:-1;;;;;10865:21:2;;10857:68;;;;-1:-1:-1;;;10857:68:2;;10312:2:14;10857:68:2;;;10294:21:14;10351:2;10331:18;;;10324:30;10390:34;10370:18;;;10363:62;-1:-1:-1;;;10441:18:14;;;10434:32;10483:19;;10857:68:2;10110:398:14;10857:68:2;-1:-1:-1;;;;;10938:18:2;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;:36;;;10990:32;;1811:25:14;;;10990:32:2;;1784:18:14;10990:32:2;;;;;;;10684:346;;;:::o;11321:419::-;11422:24;11449:25;11459:5;11466:7;11449:9;:25::i;:::-;11422:52;;-1:-1:-1;;11489:16:2;:37;11485:248;;11571:6;11551:16;:26;;11543:68;;;;-1:-1:-1;;;11543:68:2;;10715:2:14;11543:68:2;;;10697:21:14;10754:2;10734:18;;;10727:30;10793:31;10773:18;;;10766:59;10842:18;;11543:68:2;10513:353:14;11543:68:2;11655:51;11664:5;11671:7;11699:6;11680:16;:25;11655:8;:51::i;:::-;11411:329;11321:419;;;:::o;9920:1061:13:-;10061:4;-1:-1:-1;;;;;10047:19:13;;;10039:56;;;;-1:-1:-1;;;10039:56:13;;11073:2:14;10039:56:13;;;11055:21:14;11112:2;11092:18;;;11085:30;11151:26;11131:18;;;11124:54;11195:18;;10039:56:13;10871:348:14;10039:56:13;10105:7;:5;:7::i;:::-;-1:-1:-1;10127:5:13;;:20;:34;;;;-1:-1:-1;10152:9:13;;;;;;;10151:10;10127:34;10123:505;;;10187:4;;-1:-1:-1;;;;;10187:4:13;;;10181:10;;;;10177:63;;10211:14;:12;:14::i;:::-;10266:4;;-1:-1:-1;;;;;10258:12:13;;;10266:4;;10258:12;:37;;;;-1:-1:-1;;;;;;10274:21:13;;2767:42;10274:21;;10258:37;10257:98;;;-1:-1:-1;10323:4:13;;-1:-1:-1;;;;;10317:10:13;;;10323:4;;10317:10;:37;;;;-1:-1:-1;;;;;;10331:23:13;;2767:42;10331:23;;10317:37;10253:365;;;10375:11;10408:5;10398:7;;10389:6;:16;;;;:::i;:::-;:24;;;;:::i;:::-;10375:38;-1:-1:-1;10435:7:13;;10431:173;;10466:13;10476:3;10466:13;;:::i;:::-;;;10501:41;10517:4;10531;10538:3;10501:15;:41::i;:::-;10582:3;10564:14;;:21;;;;;;;:::i;:::-;;;;-1:-1:-1;;10431:173:13;10357:261;10253:365;10638:33;10654:4;10660:2;10664:6;10638:15;:33::i;:::-;10682:18;10695:4;10682:12;:18::i;:::-;10722:2;-1:-1:-1;;;;;10714:10:13;:4;-1:-1:-1;;;;;10714:10:13;;10710:57;;10740:16;10753:2;10740:12;:16::i;:::-;10781:5;;:20;:34;;;;-1:-1:-1;10806:9:13;;;;;;;10805:10;10781:34;10777:198;;;10849:4;;-1:-1:-1;;;;;10849:4:13;10835:10;:18;;;;:34;;-1:-1:-1;10865:4:13;;-1:-1:-1;;;;;10857:12:13;;;10865:4;;10857:12;;10835:34;:48;;;;-1:-1:-1;10879:4:13;;-1:-1:-1;;;;;10873:10:13;;;10879:4;;10873:10;;10835:48;10831:134;;;10903:14;:12;:14::i;:::-;10935:15;10945:4;10935:9;:15::i;:::-;9920:1061;;;:::o;1401:132:11:-;1309:6;;-1:-1:-1;;;;;1309:6:11;751:10:1;1465:23:11;1457:68;;;;-1:-1:-1;;;1457:68:11;;11426:2:14;1457:68:11;;;11408:21:14;;;11445:18;;;11438:30;11504:34;11484:18;;;11477:62;11556:18;;1457:68:11;11224:356:14;1941:128:2;2020:5;:13;2028:5;2020;:13;:::i;:::-;-1:-1:-1;2044:7:2;:17;2054:7;2044;:17;:::i;8690:548::-;-1:-1:-1;;;;;8774:21:2;;8766:65;;;;-1:-1:-1;;;8766:65:2;;13991:2:14;8766:65:2;;;13973:21:14;14030:2;14010:18;;;14003:30;14069:33;14049:18;;;14042:61;14120:18;;8766:65:2;13789:355:14;8766:65:2;8844:49;8873:1;8877:7;8886:6;8844:20;:49::i;:::-;8922:6;8906:12;;:22;;;;;;;:::i;:::-;;;;-1:-1:-1;;;;;;;9077:18:2;;:9;:18;;;;;;;;;;;:28;;;;;;9132:37;1811:25:14;;;9132:37:2;;1784:18:14;9132:37:2;;;;;;;9182:48;8690:548;;:::o;11262:925:13:-;11324:10;;:15;;:43;;;11344:23;11359:7;11344:14;:23::i;:::-;11343:24;11324:43;11320:80;;;11262:925;:::o;11320:80::-;-1:-1:-1;;;;;3540:18:2;;11410:16:13;3540:18:2;;;;;;;;;;;11472:8:13;;11461:19;;11457:62;;;-1:-1:-1;11507:1:13;11457:62;-1:-1:-1;;;;;11553:17:13;;11529:21;11553:17;;;:8;:17;;;;;11599:10;;11623:20;;;11619:57;;11659:7;;;11262:925;:::o;11619:57::-;11690:12;;11686:212;;11718:14;-1:-1:-1;;;11746:11:13;;11735:8;:22;;;;:::i;:::-;:34;;;;:::i;:::-;11718:51;;11796:4;:15;;;11787:6;:24;11783:105;;;11858:15;;;;11849:24;;:6;:24;:::i;:::-;11831:4;:14;;;:42;;;;;;;:::i;:::-;;;;-1:-1:-1;;11783:105:13;11704:194;11686:212;11908:21;;;11968:11;;-1:-1:-1;;;5510:8:13;11957:22;;11921:8;11957:22;:::i;:::-;:34;;;;:::i;:::-;11939:15;;;:52;12006:19;;;12002:179;;;12070:19;12081:8;12070;:19;:::i;:::-;12055:11;;:35;;;;:::i;:::-;12041:11;:49;12002:179;;;12150:19;12161:8;12150;:19;:::i;:::-;12135:11;;:35;;;;:::i;:::-;12121:11;:49;11310:877;;;11262:925;:::o;2496:191:11:-;2589:6;;;-1:-1:-1;;;;;2606:17:11;;;-1:-1:-1;;;;;;2606:17:11;;;;;;;2639:40;;2589:6;;;2606:17;2589:6;;2639:40;;2570:16;;2639:40;2559:128;2496:191;:::o;15078:620:13:-;15137:64;;-1:-1:-1;;;15137:64:13;;-1:-1:-1;;;;;178:32:14;;15137:64:13;;;160:51:14;3142:42:13;;15137:55;;133:18:14;;15137:64:13;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;15133:101;;;15078:620;:::o;15133:101::-;15244:19;15266:21;15279:7;15266:12;:21::i;:::-;15244:43;-1:-1:-1;15301:15:13;;15297:395;;-1:-1:-1;;;;;15356:17:13;;15332:21;15356:17;;;:8;:17;;;;;15418:11;;15405:10;;-1:-1:-1;;;5510:8:13;15405:24;;;:::i;:::-;:36;;;;:::i;:::-;15387:15;;;:54;15472:1;15455:14;;;:18;15518:5;;15488:59;;15518:5;;;-1:-1:-1;;;;;15518:5:13;15526:7;15535:11;15488:22;:59::i;:::-;15577:11;15561:4;:12;;;:27;;;;;;;:::i;:::-;;;;;;;;15618:11;15602:12;;:27;;;;;;;:::i;:::-;;;;-1:-1:-1;;15649:32:13;;;-1:-1:-1;;;;;14623:32:14;;14605:51;;14687:2;14672:18;;14665:34;;;15649:32:13;;14578:18:14;15649:32:13;;;;;;;15318:374;15123:575;15078:620;:::o;9691:223::-;9749:4;;9726:7;;-1:-1:-1;;;;;9749:4:13;:18;:42;;;;-1:-1:-1;9771:5:13;;:20;9749:42;9745:142;;;9870:5;;9814:62;;-1:-1:-1;;;9814:62:13;;9863:4;9814:62;;;14922:34:14;9870:5:13;;;;-1:-1:-1;;;;;9870:5:13;14972:18:14;;;14965:43;2477:42:13;;9814:40;;14857:18:14;;9814:62:13;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;9807:4;:69;;-1:-1:-1;;;;;;9807:69:13;-1:-1:-1;;;;;9807:69:13;;;;;;;;;;9745:142;-1:-1:-1;9903:4:13;;-1:-1:-1;;;;;9903:4:13;;9691:223::o;12193:1925::-;12258:14;;12300:11;;12286:25;;12282:62;;;12327:7;12193:1925::o;12282:62::-;12371:1;12354:14;:18;;;12427:13;;12416:8;;12402:11;;:22;;12416:8;12402:22;:::i;:::-;:38;;;;:::i;:::-;12382:58;;12450:21;12481:20;12511:18;12539:23;12573:21;12604:20;12652:1;12639:10;;:14;:33;;;;;12671:1;12657:11;;:15;12639:33;12635:372;;;12701:10;;12688:23;;;;:::i;:::-;;;12767:9;12754:10;;12740:11;:24;;;;:::i;:::-;:36;;;;:::i;:::-;12725:51;;12803:12;12790:9;;:25;;;;;;;:::i;:::-;;;;-1:-1:-1;12844:42:13;;-1:-1:-1;12866:4:13;12873:12;12844:13;:42::i;:::-;12943:11;;12829:57;;-1:-1:-1;12916:24:13;-1:-1:-1;;;12829:57:13;12916:24;:::i;:::-;:38;;;;:::i;:::-;12900:11;;:55;;;;;;;:::i;:::-;;;;;;;;12984:12;12969:11;;:27;;;;;;;:::i;:::-;;;;-1:-1:-1;;12635:372:13;13020:11;;:15;13016:384;;13095:9;13081:11;;13067;:25;;;;:::i;:::-;:37;;;;:::i;:::-;13051:53;;13132:13;13118:10;;:27;;;;;;;:::i;:::-;;;;-1:-1:-1;;13163:5:13;;-1:-1:-1;;13163:5:13;;;;-1:-1:-1;;;;;13163:5:13;:13;13159:231;;13241:7;;13229:35;;-1:-1:-1;;;;;13241:7:13;13250:13;13229:11;:35::i;:::-;13213:51;;;13196:12;;:69;;;;;;;:::i;:::-;;;;-1:-1:-1;13159:231:13;;-1:-1:-1;13159:231:13;;13351:7;;13337:37;;-1:-1:-1;;;;;13351:7:13;13360:13;13337;:37::i;:::-;13321:53;;;13304:12;;:71;;;;;;;:::i;:::-;;;;-1:-1:-1;;13159:231:13;13413:8;;:12;13409:187;;13479:9;13468:8;;13454:11;:22;;;;:::i;:::-;:34;;;;:::i;:::-;13441:47;;13513:10;13502:7;;:21;;;;;;;:::i;:::-;;;;-1:-1:-1;13537:48:13;;-1:-1:-1;13561:4:13;2364:6;13574:10;13537:15;:48::i;:::-;13609:13;;:17;13605:194;;13690:9;13674:13;;13660:11;:27;;;;:::i;:::-;:39;;;;:::i;:::-;13642:57;;13729:15;13713:12;;:31;;;;;;;:::i;:::-;;;;-1:-1:-1;13758:30:13;;-1:-1:-1;13772:15:13;13758:13;:30::i;:::-;13809:24;13880:15;13867:10;13836:28;13852:12;13836:13;:28;:::i;:::-;:41;;;;:::i;:::-;:59;;;;:::i;:::-;13809:86;-1:-1:-1;13922:30:13;13809:86;13922:11;:30;:::i;:::-;13905:14;:47;;;;13979:16;13962:13;;:33;;;;;;;:::i;:::-;;;;-1:-1:-1;;14011:100:13;;;15562:25:14;;;15618:2;15603:18;;15596:34;;;15646:18;;;15639:34;;;15704:2;15689:18;;15682:34;;;15747:3;15732:19;;15725:35;;;15791:3;15776:19;;15769:35;;;14011:100:13;;15549:3:14;15534:19;14011:100:13;;;;;;;12226:1892;;;;;;;;;12193:1925::o;7597:806:2:-;-1:-1:-1;;;;;7694:18:2;;7686:68;;;;-1:-1:-1;;;7686:68:2;;16017:2:14;7686:68:2;;;15999:21:14;16056:2;16036:18;;;16029:30;16095:34;16075:18;;;16068:62;-1:-1:-1;;;16146:18:14;;;16139:35;16191:19;;7686:68:2;15815:401:14;7686:68:2;-1:-1:-1;;;;;7773:16:2;;7765:64;;;;-1:-1:-1;;;7765:64:2;;16423:2:14;7765:64:2;;;16405:21:14;16462:2;16442:18;;;16435:30;16501:34;16481:18;;;16474:62;-1:-1:-1;;;16552:18:14;;;16545:33;16595:19;;7765:64:2;16221:399:14;7765:64:2;7842:38;7863:4;7869:2;7873:6;7842:20;:38::i;:::-;-1:-1:-1;;;;;7915:15:2;;7893:19;7915:15;;;;;;;;;;;7949:21;;;;7941:72;;;;-1:-1:-1;;;7941:72:2;;16827:2:14;7941:72:2;;;16809:21:14;16866:2;16846:18;;;16839:30;16905:34;16885:18;;;16878:62;-1:-1:-1;;;16956:18:14;;;16949:36;17002:19;;7941:72:2;16625:402:14;7941:72:2;-1:-1:-1;;;;;8049:15:2;;;:9;:15;;;;;;;;;;;8067:20;;;8049:38;;8267:13;;;;;;;;;;:23;;;;;;8319:26;;1811:25:14;;;8267:13:2;;8319:26;;1784:18:14;8319:26:2;;;;;;;8358:37;9920:1061:13;9116:442;3387:1;9312:5;;:33;9308:103;;9361:39;;-1:-1:-1;;;9361:39:13;;17234:2:14;9361:39:13;;;17216:21:14;17273:2;17253:18;;;17246:30;17312:31;17292:18;;;17285:59;17361:18;;9361:39:13;17032:353:14;9308:103:13;3488:1;9424:5;;:33;9420:132;;1309:6:11;;-1:-1:-1;;;;;9481:15:13;;;1309:6:11;;9481:15:13;;:32;;-1:-1:-1;1309:6:11;;-1:-1:-1;;;;;9500:13:13;;;1309:6:11;;9500:13:13;9481:32;9473:68;;;;-1:-1:-1;;;9473:68:13;;17592:2:14;9473:68:13;;;17574:21:14;17631:2;17611:18;;;17604:30;17670:25;17650:18;;;17643:53;17713:18;;9473:68:13;17390:347:14;10987:269:13;11046:4;11080:7;:5;:7::i;:::-;-1:-1:-1;;;;;11069:18:13;:7;-1:-1:-1;;;;;11069:18:13;;;:63;;;;-1:-1:-1;;;;;;11106:26:13;;2767:42;11106:26;;11069:63;:106;;;;-1:-1:-1;;;;;;11151:24:13;;11170:4;11151:24;;11069:106;:146;;;;-1:-1:-1;;;;;;11194:21:13;;;;11069:146;:180;;;;-1:-1:-1;;;;;;11234:15:13;;2364:6;11234:15;;11062:187;10987:269;-1:-1:-1;;10987:269:13:o;915:175:12:-;1024:58;;;-1:-1:-1;;;;;14623:32:14;;1024:58:12;;;14605:51:14;14672:18;;;;14665:34;;;1024:58:12;;;;;;;;;;14578:18:14;;;;1024:58:12;;;;;;;;-1:-1:-1;;;;;1024:58:12;-1:-1:-1;;;1024:58:12;;;997:86;;1017:5;;997:19;:86::i;16028:322:13:-;16120:9;:16;;-1:-1:-1;;16120:16:13;;;;;16101:7;16146:52;16163:4;2959:42;16186:11;16146:8;:52::i;:::-;16230:58;;-1:-1:-1;;;16230:58:13;;-1:-1:-1;;;;;14623:32:14;;16230:58:13;;;14605:51:14;14672:18;;;14665:34;;;16208:19:13;;2959:42;;16230:41;;14578:18:14;;16230:58:13;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;16298:9;:17;;-1:-1:-1;;16298:17:13;;;16208:80;16028:322;-1:-1:-1;;;;16028:322:13:o;15704:318::-;15794:9;:16;;-1:-1:-1;;15794:16:13;;;;;15775:7;15820:52;15837:4;2959:42;15860:11;15820:8;:52::i;:::-;15904:56;;-1:-1:-1;;;15904:56:13;;-1:-1:-1;;;;;14623:32:14;;15904:56:13;;;14605:51:14;14672:18;;;14665:34;;;15882:19:13;;2959:42;;15904:39;;14578:18:14;;15904:56:13;14431:274:14;16356:239:13;16419:9;:16;;-1:-1:-1;;16419:16:13;;;;;16445:52;16462:4;2959:42;16485:11;16445:8;:52::i;:::-;16507:54;;-1:-1:-1;;;16507:54:13;;;;;1811:25:14;;;2959:42:13;;16507:41;;1784:18:14;;16507:54:13;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;16571:9:13;:17;;-1:-1:-1;;16571:17:13;;;-1:-1:-1;;;16356:239:13:o;5170:642:12:-;5589:23;5615:69;5643:4;5615:69;;;;;;;;;;;;;;;;;5623:5;-1:-1:-1;;;;;5615:27:12;;;:69;;;;;:::i;:::-;5589:95;;5702:10;:17;5723:1;5702:22;:56;;;;5739:10;5728:30;;;;;;;;;;;;:::i;:::-;5694:111;;;;-1:-1:-1;;;5694:111:12;;18133:2:14;5694:111:12;;;18115:21:14;18172:2;18152:18;;;18145:30;18211:34;18191:18;;;18184:62;-1:-1:-1;;;18262:18:14;;;18255:40;18312:19;;5694:111:12;17931:406:14;4108:223:0;4241:12;4272:52;4294:6;4302:4;4308:1;4311:12;4272:21;:52::i;:::-;4265:59;4108:223;-1:-1:-1;;;;4108:223:0:o;5165:446::-;5330:12;5387:5;5362:21;:30;;5354:81;;;;-1:-1:-1;;;5354:81:0;;18544:2:14;5354:81:0;;;18526:21:14;18583:2;18563:18;;;18556:30;18622:34;18602:18;;;18595:62;-1:-1:-1;;;18673:18:14;;;18666:36;18719:19;;5354:81:0;18342:402:14;5354:81:0;5446:12;5460:23;5487:6;-1:-1:-1;;;;;5487:11:0;5506:5;5513:4;5487:31;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5445:73;;;;5535:69;5562:6;5570:7;5579:10;5591:12;5535:26;:69::i;:::-;5528:76;5165:446;-1:-1:-1;;;;;;;5165:446:0:o;7671:628::-;7851:12;7879:7;7875:418;;;7906:10;:17;7927:1;7906:22;7902:286;;-1:-1:-1;;;;;1702:19:0;;;8113:60;;;;-1:-1:-1;;;8113:60:0;;19243:2:14;8113:60:0;;;19225:21:14;19282:2;19262:18;;;19255:30;19321:31;19301:18;;;19294:59;19370:18;;8113:60:0;19041:353:14;8113:60:0;-1:-1:-1;8208:10:0;8201:17;;7875:418;8249:33;8257:10;8269:12;8980:17;;:21;8976:379;;9208:10;9202:17;9264:15;9251:10;9247:2;9243:19;9236:44;8976:379;9331:12;9324:20;;-1:-1:-1;;;9324:20:0;;;;;;;;:::i;222:250:14:-;307:1;317:113;331:6;328:1;325:13;317:113;;;407:11;;;401:18;388:11;;;381:39;353:2;346:10;317:113;;;-1:-1:-1;;464:1:14;446:16;;439:27;222:250::o;477:396::-;626:2;615:9;608:21;589:4;658:6;652:13;701:6;696:2;685:9;681:18;674:34;717:79;789:6;784:2;773:9;769:18;764:2;756:6;752:15;717:79;:::i;:::-;857:2;836:15;-1:-1:-1;;832:29:14;817:45;;;;864:2;813:54;;477:396;-1:-1:-1;;477:396:14:o;878:131::-;-1:-1:-1;;;;;953:31:14;;943:42;;933:70;;999:1;996;989:12;1014:134;1082:20;;1111:31;1082:20;1111:31;:::i;:::-;1014:134;;;:::o;1153:315::-;1221:6;1229;1282:2;1270:9;1261:7;1257:23;1253:32;1250:52;;;1298:1;1295;1288:12;1250:52;1337:9;1324:23;1356:31;1381:5;1356:31;:::i;:::-;1406:5;1458:2;1443:18;;;;1430:32;;-1:-1:-1;;;1153:315:14:o;1847:247::-;1906:6;1959:2;1947:9;1938:7;1934:23;1930:32;1927:52;;;1975:1;1972;1965:12;1927:52;2014:9;2001:23;2033:31;2058:5;2033:31;:::i;:::-;2083:5;1847:247;-1:-1:-1;;;1847:247:14:o;2495:456::-;2572:6;2580;2588;2641:2;2629:9;2620:7;2616:23;2612:32;2609:52;;;2657:1;2654;2647:12;2609:52;2696:9;2683:23;2715:31;2740:5;2715:31;:::i;:::-;2765:5;-1:-1:-1;2822:2:14;2807:18;;2794:32;2835:33;2794:32;2835:33;:::i;:::-;2495:456;;2887:7;;-1:-1:-1;;;2941:2:14;2926:18;;;;2913:32;;2495:456::o;3145:127::-;3206:10;3201:3;3197:20;3194:1;3187:31;3237:4;3234:1;3227:15;3261:4;3258:1;3251:15;3277:250;3344:2;3338:9;3386:6;3374:19;;3423:18;3408:34;;3444:22;;;3405:62;3402:88;;;3470:18;;:::i;:::-;3506:2;3499:22;3277:250;:::o;3532:719::-;3575:5;3628:3;3621:4;3613:6;3609:17;3605:27;3595:55;;3646:1;3643;3636:12;3595:55;3682:6;3669:20;3708:18;3745:2;3741;3738:10;3735:36;;;3751:18;;:::i;:::-;3826:2;3820:9;3794:2;3880:13;;-1:-1:-1;;3876:22:14;;;3900:2;3872:31;3868:40;3856:53;;;3924:18;;;3944:22;;;3921:46;3918:72;;;3970:18;;:::i;:::-;4010:10;4006:2;3999:22;4045:2;4037:6;4030:18;4091:3;4084:4;4079:2;4071:6;4067:15;4063:26;4060:35;4057:55;;;4108:1;4105;4098:12;4057:55;4172:2;4165:4;4157:6;4153:17;4146:4;4138:6;4134:17;4121:54;4219:1;4212:4;4207:2;4199:6;4195:15;4191:26;4184:37;4239:6;4230:15;;;;;;3532:719;;;;:::o;4256:1470::-;4343:6;4396:2;4384:9;4375:7;4371:23;4367:32;4364:52;;;4412:1;4409;4402:12;4364:52;4452:9;4439:23;4481:18;4522:2;4514:6;4511:14;4508:34;;;4538:1;4535;4528:12;4508:34;4561:22;;;;4617:6;4599:16;;;4595:29;4592:49;;;4637:1;4634;4627:12;4592:49;4663:17;;:::i;:::-;4703:22;4722:2;4703:22;:::i;:::-;4696:5;4689:37;4772:2;4768;4764:11;4751:25;4801:2;4791:8;4788:16;4785:36;;;4817:1;4814;4807:12;4785:36;4853:45;4890:7;4879:8;4875:2;4871:17;4853:45;:::i;:::-;4848:2;4841:5;4837:14;4830:69;;4945:2;4941;4937:11;4924:25;4974:2;4964:8;4961:16;4958:36;;;4990:1;4987;4980:12;4958:36;5026:45;5063:7;5052:8;5048:2;5044:17;5026:45;:::i;:::-;5021:2;5014:5;5010:14;5003:69;;5125:2;5121;5117:11;5104:25;5099:2;5092:5;5088:14;5081:49;5163:32;5190:3;5186:2;5182:12;5163:32;:::i;:::-;5157:3;5146:15;;5139:57;5250:3;5242:12;;;5229:26;5212:15;;;5205:51;5310:3;5302:12;;;5289:26;5272:15;;;5265:51;5370:3;5362:12;;;5349:26;5332:15;;;5325:51;5395:3;5443:11;;;5430:25;5414:14;;;5407:49;5475:3;5523:11;;;5510:25;5494:14;;;5487:49;5555:3;5603:11;;;5590:25;5574:14;;;5567:49;5635:3;5683:11;;;5670:25;5654:14;;;5647:49;;;;-1:-1:-1;5150:5:14;4256:1470;-1:-1:-1;;;4256:1470:14:o;5731:180::-;5790:6;5843:2;5831:9;5822:7;5818:23;5814:32;5811:52;;;5859:1;5856;5849:12;5811:52;-1:-1:-1;5882:23:14;;5731:180;-1:-1:-1;5731:180:14:o;5916:388::-;5984:6;5992;6045:2;6033:9;6024:7;6020:23;6016:32;6013:52;;;6061:1;6058;6051:12;6013:52;6100:9;6087:23;6119:31;6144:5;6119:31;:::i;:::-;6169:5;-1:-1:-1;6226:2:14;6211:18;;6198:32;6239:33;6198:32;6239:33;:::i;:::-;6291:7;6281:17;;;5916:388;;;;;:::o;6309:380::-;6388:1;6384:12;;;;6431;;;6452:61;;6506:4;6498:6;6494:17;6484:27;;6452:61;6559:2;6551:6;6548:14;6528:18;6525:38;6522:161;;6605:10;6600:3;6596:20;6593:1;6586:31;6640:4;6637:1;6630:15;6668:4;6665:1;6658:15;6522:161;;6309:380;;;:::o;6694:127::-;6755:10;6750:3;6746:20;6743:1;6736:31;6786:4;6783:1;6776:15;6810:4;6807:1;6800:15;6826:125;6891:9;;;6912:10;;;6909:36;;;6925:18;;:::i;8364:168::-;8437:9;;;8468;;8485:15;;;8479:22;;8465:37;8455:71;;8506:18;;:::i;8537:217::-;8577:1;8603;8593:132;;8647:10;8642:3;8638:20;8635:1;8628:31;8682:4;8679:1;8672:15;8710:4;8707:1;8700:15;8593:132;-1:-1:-1;8739:9:14;;8537:217::o;8759:128::-;8826:9;;;8847:11;;;8844:37;;;8861:18;;:::i;11711:545::-;11813:2;11808:3;11805:11;11802:448;;;11849:1;11874:5;11870:2;11863:17;11919:4;11915:2;11905:19;11989:2;11977:10;11973:19;11970:1;11966:27;11960:4;11956:38;12025:4;12013:10;12010:20;12007:47;;;-1:-1:-1;12048:4:14;12007:47;12103:2;12098:3;12094:12;12091:1;12087:20;12081:4;12077:31;12067:41;;12158:82;12176:2;12169:5;12166:13;12158:82;;;12221:17;;;12202:1;12191:13;12158:82;;;12162:3;;;11711:545;;;:::o;12432:1352::-;12558:3;12552:10;12585:18;12577:6;12574:30;12571:56;;;12607:18;;:::i;:::-;12636:97;12726:6;12686:38;12718:4;12712:11;12686:38;:::i;:::-;12680:4;12636:97;:::i;:::-;12788:4;;12852:2;12841:14;;12869:1;12864:663;;;;13571:1;13588:6;13585:89;;;-1:-1:-1;13640:19:14;;;13634:26;13585:89;-1:-1:-1;;12389:1:14;12385:11;;;12381:24;12377:29;12367:40;12413:1;12409:11;;;12364:57;13687:81;;12834:944;;12864:663;11658:1;11651:14;;;11695:4;11682:18;;-1:-1:-1;;12900:20:14;;;13018:236;13032:7;13029:1;13026:14;13018:236;;;13121:19;;;13115:26;13100:42;;13213:27;;;;13181:1;13169:14;;;;13048:19;;13018:236;;;13022:3;13282:6;13273:7;13270:19;13267:201;;;13343:19;;;13337:26;-1:-1:-1;;13426:1:14;13422:14;;;13438:3;13418:24;13414:37;13410:42;13395:58;13380:74;;13267:201;-1:-1:-1;;;;;13514:1:14;13498:14;;;13494:22;13481:36;;-1:-1:-1;12432:1352:14:o;14149:277::-;14216:6;14269:2;14257:9;14248:7;14244:23;14240:32;14237:52;;;14285:1;14282;14275:12;14237:52;14317:9;14311:16;14370:5;14363:13;14356:21;14349:5;14346:32;14336:60;;14392:1;14389;14382:12;15019:251;15089:6;15142:2;15130:9;15121:7;15117:23;15113:32;15110:52;;;15158:1;15155;15148:12;15110:52;15190:9;15184:16;15209:31;15234:5;15209:31;:::i;17742:184::-;17812:6;17865:2;17853:9;17844:7;17840:23;17836:32;17833:52;;;17881:1;17878;17871:12;17833:52;-1:-1:-1;17904:16:14;;17742:184;-1:-1:-1;17742:184:14:o;18749:287::-;18878:3;18916:6;18910:13;18932:66;18991:6;18986:3;18979:4;18971:6;18967:17;18932:66;:::i;:::-;19014:16;;;;;18749:287;-1:-1:-1;;18749:287:14:o

ipfs://564c1491be1695d1a63efe5ca85807f26a0ca8acf165b9af8dd95f8f1e3401d4