Contract 0xef13e1f0fd09337fd4d12196e0ea23e84663d37d 7

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (security/ReentrancyGuard.sol)

pragma solidity ^0.8.0;

/**
 * @dev Contract module that helps prevent reentrant calls to a function.
 *
 * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
 * available, which can be applied to functions to make sure there are no nested
 * (reentrant) calls to them.
 *
 * Note that because there is a single `nonReentrant` guard, functions marked as
 * `nonReentrant` may not call one another. This can be worked around by making
 * those functions `private`, and then adding `external` `nonReentrant` entry
 * points to them.
 *
 * TIP: If you would like to learn more about reentrancy and alternative ways
 * to protect against it, check out our blog post
 * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
 */
abstract contract ReentrancyGuard {
    // Booleans are more expensive than uint256 or any type that takes up a full
    // word because each write operation emits an extra SLOAD to first read the
    // slot's contents, replace the bits taken up by the boolean, and then write
    // back. This is the compiler's defense against contract upgrades and
    // pointer aliasing, and it cannot be disabled.

    // The values being non-zero value makes deployment a bit more expensive,
    // but in exchange the refund on every call to nonReentrant will be lower in
    // amount. Since refunds are capped to a percentage of the total
    // transaction's gas, it is best to keep them low in cases like this one, to
    // increase the likelihood of the full refund coming into effect.
    uint256 private constant _NOT_ENTERED = 1;
    uint256 private constant _ENTERED = 2;

    uint256 private _status;

    constructor() {
        _status = _NOT_ENTERED;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and making it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        // On the first call to nonReentrant, _notEntered will be true
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

        // Any calls to nonReentrant after this point will fail
        _status = _ENTERED;

        _;

        // By storing the original value once again, a refund is triggered (see
        // https://eips.ethereum.org/EIPS/eip-2200)
        _status = _NOT_ENTERED;
    }
}

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

pragma solidity ^0.8.0;

import "./IERC20.sol";
import "./extensions/IERC20Metadata.sol";
import "../../utils/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.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How
 * to implement supply mechanisms].
 *
 * We have followed general OpenZeppelin Contracts guidelines: functions revert
 * instead returning `false` on failure. This behavior is nonetheless
 * conventional and does not conflict with the expectations of ERC20
 * applications.
 *
 * Additionally, an {Approval} event is emitted on calls to {transferFrom}.
 * This allows applications to reconstruct the allowance for all accounts just
 * by listening to said events. Other implementations of the EIP may not emit
 * these events, as it isn't required by the specification.
 *
 * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}
 * functions have been added to mitigate the well-known issues around setting
 * allowances. See {IERC20-approve}.
 */
contract ERC20 is Context, IERC20, IERC20Metadata {
    mapping(address => uint256) private _balances;

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

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;

    /**
     * @dev Sets the values for {name} and {symbol}.
     *
     * The default value of {decimals} is 18. To select a different value for
     * {decimals} you should overload it.
     *
     * All two of these values are immutable: they can only be set once during
     * construction.
     */
    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
    }

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

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

    /**
     * @dev Returns the number of decimals used to get its user representation.
     * For example, if `decimals` equals `2`, a balance of `505` tokens should
     * be displayed to a user as `5.05` (`505 / 10 ** 2`).
     *
     * Tokens usually opt for a value of 18, imitating the relationship between
     * Ether and Wei. This is the value {ERC20} uses, unless this function is
     * overridden;
     *
     * NOTE: This information is only used for _display_ purposes: it in
     * no way affects any of the arithmetic of the contract, including
     * {IERC20-balanceOf} and {IERC20-transfer}.
     */
    function decimals() public view virtual override returns (uint8) {
        return 18;
    }

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

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

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

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

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

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

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

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

        return true;
    }

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

        _beforeTokenTransfer(from, to, amount);

        uint256 fromBalance = _balances[from];
        require(fromBalance >= amount, "ERC20: transfer amount exceeds balance");
        unchecked {
            _balances[from] = fromBalance - amount;
        }
        _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;
        _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;
        }
        _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.6.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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

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

pragma solidity ^0.8.0;

import "../ERC20.sol";
import "../../../utils/Context.sol";

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

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

// 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 v4.4.1 (token/ERC20/extensions/draft-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.
 */
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].
     */
    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: MIT
// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC20/presets/ERC20PresetFixedSupply.sol)
pragma solidity ^0.8.0;

import "../extensions/ERC20Burnable.sol";

/**
 * @dev {ERC20} token, including:
 *
 *  - Preminted initial supply
 *  - Ability for holders to burn (destroy) their tokens
 *  - No access control mechanism (for minting/pausing) and hence no governance
 *
 * This contract uses {ERC20Burnable} to include burn capabilities - head to
 * its documentation for details.
 *
 * _Available since v3.4._
 *
 * _Deprecated in favor of https://wizard.openzeppelin.com/[Contracts Wizard]._
 */
contract ERC20PresetFixedSupply is ERC20Burnable {
    /**
     * @dev Mints `initialSupply` amount of token and transfers them to `owner`.
     *
     * See {ERC20-constructor}.
     */
    constructor(
        string memory name,
        string memory symbol,
        uint256 initialSupply,
        address owner
    ) ERC20(name, symbol) {
        _mint(owner, initialSupply);
    }
}

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

pragma solidity ^0.8.0;

import "../IERC20.sol";
import "../extensions/draft-IERC20Permit.sol";
import "../../../utils/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;

    function safeTransfer(
        IERC20 token,
        address to,
        uint256 value
    ) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
    }

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

    function safeIncreaseAllowance(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        uint256 newAllowance = token.allowance(address(this), spender) + value;
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
    }

    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");
            uint256 newAllowance = oldAllowance - value;
            _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
        }
    }

    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");
        if (returndata.length > 0) {
            // Return data is optional
            require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.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
     * ====
     *
     * [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://diligence.consensys.net/posts/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.5.11/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 functionCall(target, data, "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");
        require(isContract(target), "Address: call to non-contract");

        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResult(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) {
        require(isContract(target), "Address: static call to non-contract");

        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResult(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) {
        require(isContract(target), "Address: delegate call to non-contract");

        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason 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 {
            // 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 v4.4.1 (utils/Context.sol)

pragma solidity ^0.8.0;

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

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

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

pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.
        // We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have
        // `msb(a) <= a < 2*msb(a)`.
        // We also know that `k`, the position of the most significant bit, is such that `msb(a) = 2**k`.
        // This gives `2**k < a <= 2**(k+1)` → `2**(k/2) <= sqrt(a) < 2 ** (k/2+1)`.
        // Using an algorithm similar to the msb conmputation, we are able to compute `result = 2**(k/2)` which is a
        // good first aproximation of `sqrt(a)` with at least 1 correct bit.
        uint256 result = 1;
        uint256 x = a;
        if (x >> 128 > 0) {
            x >>= 128;
            result <<= 64;
        }
        if (x >> 64 > 0) {
            x >>= 64;
            result <<= 32;
        }
        if (x >> 32 > 0) {
            x >>= 32;
            result <<= 16;
        }
        if (x >> 16 > 0) {
            x >>= 16;
            result <<= 8;
        }
        if (x >> 8 > 0) {
            x >>= 8;
            result <<= 4;
        }
        if (x >> 4 > 0) {
            x >>= 4;
            result <<= 2;
        }
        if (x >> 2 > 0) {
            result <<= 1;
        }

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

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

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

/// @title Minimal ERC20 interface for Uniswap
/// @notice Contains a subset of the full ERC20 interface that is used in Uniswap V3
interface IERC20Minimal {
    /// @notice Returns the balance of a token
    /// @param account The account for which to look up the number of tokens it has, i.e. its balance
    /// @return The number of tokens held by the account
    function balanceOf(address account) external view returns (uint256);

    /// @notice Transfers the amount of token from the `msg.sender` to the recipient
    /// @param recipient The account that will receive the amount transferred
    /// @param amount The number of tokens to send from the sender to the recipient
    /// @return Returns true for a successful transfer, false for an unsuccessful transfer
    function transfer(address recipient, uint256 amount) external returns (bool);

    /// @notice Returns the current allowance given to a spender by an owner
    /// @param owner The account of the token owner
    /// @param spender The account of the token spender
    /// @return The current allowance granted by `owner` to `spender`
    function allowance(address owner, address spender) external view returns (uint256);

    /// @notice Sets the allowance of a spender from the `msg.sender` to the value `amount`
    /// @param spender The account which will be allowed to spend a given amount of the owners tokens
    /// @param amount The amount of tokens allowed to be used by `spender`
    /// @return Returns true for a successful approval, false for unsuccessful
    function approve(address spender, uint256 amount) external returns (bool);

    /// @notice Transfers `amount` tokens from `sender` to `recipient` up to the allowance given to the `msg.sender`
    /// @param sender The account from which the transfer will be initiated
    /// @param recipient The recipient of the transfer
    /// @param amount The amount of the transfer
    /// @return Returns true for a successful transfer, false for unsuccessful
    function transferFrom(
        address sender,
        address recipient,
        uint256 amount
    ) external returns (bool);

    /// @notice Event emitted when tokens are transferred from one address to another, either via `#transfer` or `#transferFrom`.
    /// @param from The account from which the tokens were sent, i.e. the balance decreased
    /// @param to The account to which the tokens were sent, i.e. the balance increased
    /// @param value The amount of tokens that were transferred
    event Transfer(address indexed from, address indexed to, uint256 value);

    /// @notice Event emitted when the approval amount for the spender of a given owner's tokens changes.
    /// @param owner The account that approved spending of its tokens
    /// @param spender The account for which the spending allowance was modified
    /// @param value The new allowance from the owner to the spender
    event Approval(address indexed owner, address indexed spender, uint256 value);
}

// SPDX-License-Identifier: Apache-2.0

pragma solidity 0.8.2;

interface IvFlashSwapCallback {
    function vFlashSwapCallback(
        address tokenIn,
        address tokenOut,
        uint256 requiredBackAmount,
        bytes calldata data
    ) external;
}

// SPDX-License-Identifier: Apache-2.0

pragma solidity 0.8.2;

import '../types.sol';

interface IvPair {
    event Mint(
        address indexed sender,
        uint256 amount0,
        uint256 amount1,
        uint lpTokens,
        uint poolLPTokens
    );

    event Burn(
        address indexed sender,
        uint256 amount0,
        uint256 amount1,
        address indexed to
    );

    event Swap(
        address indexed sender,
        address tokenIn,
        address tokenOut,
        uint256 amountIn,
        uint256 amountOut,
        address indexed to
    );

    event SwapReserve(
        address indexed sender,
        address tokenIn,
        address tokenOut,
        uint256 amountIn,
        uint256 amountOut,
        address ikPool,
        address indexed to
    );

    event AllowListChanged(address[] tokens);

    event Sync(uint256 balance0, uint256 balance1);

    event ReserveSync(address asset, uint256 balance, uint256 rRatio);

    event FeeChanged(uint24 fee, uint24 vFee);

    event ReserveThresholdChanged(uint256 newThreshold);

    event AllowListCountChanged(uint24 _maxAllowListCount);

    function fee() external view returns (uint24);

    function vFee() external view returns (uint24);

    function setFee(uint24 _fee, uint24 _vFee) external;

    function swapNative(
        uint256 amountOut,
        address tokenOut,
        address to,
        bytes calldata data
    ) external returns (uint256 _amountIn);

    function swapReserveToNative(
        uint256 amountOut,
        address ikPair,
        address to,
        bytes calldata data
    ) external returns (uint256 _amountIn);

    function swapNativeToReserve(
        uint256 amountOut,
        address ikPair,
        address to,
        bytes calldata data
    ) external returns (address _token, uint256 _leftovers);

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

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

    function setAllowList(address[] memory _allowList) external;

    function setMaxAllowListCount(uint24 _maxAllowListCount) external;

    function calculateReserveRatio() external view returns (uint256 rRatio);

    function setMaxReserveThreshold(uint256 threshold) external;

    function token0() external view returns (address);

    function token1() external view returns (address);

    function pairBalance0() external view returns (uint256);

    function pairBalance1() external view returns (uint256);

    function maxAllowListCount() external view returns (uint24);

    function getBalances() external view returns (uint256, uint256);

    function getLastBalances()
        external
        view
        returns (
            uint256 _lastBalance0,
            uint256 _lastBalance1,
            uint256 _blockNumber
        );

    function getTokens() external view returns (address, address);

    function reservesBaseValue(
        address reserveAddress
    ) external view returns (uint256);

    function reserves(address reserveAddress) external view returns (uint256);
}

// SPDX-License-Identifier: Apache-2.0

pragma solidity 0.8.2;

interface IvPairFactory {
    event PairCreated(
        address poolAddress,
        address factory,
        address token0,
        address token1,
        uint24 fee,
        uint24 vFee,
        uint256 maxReserveRatio
    );

    event DefaultAllowListChanged(address[] allowList);

    event FactoryNewAdmin(address newAdmin);
    event FactoryNewPendingAdmin(address newPendingAdmin);

    event ExchangeReserveAddressChanged(address newExchangeReserve);

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

    function getPair(
        address tokenA,
        address tokenB
    ) external view returns (address);

    function setDefaultAllowList(address[] calldata _defaultAllowList) external;

    function admin() external view returns (address);

    function pendingAdmin() external view returns (address);

    function setPendingAdmin(address newAdmin) external;

    function acceptAdmin() external;

    function exchangeReserves() external view returns (address);

    function setExchangeReservesAddress(address _exchangeReserves) external;
}

// SPDX-License-Identifier: Apache-2.0

pragma solidity 0.8.2;

/// @title An interface for a contract that is capable of deploying Uniswap V3 Pools
/// @notice A contract that constructs a pool must implement this to pass arguments to the pool
/// @dev This is used to avoid having constructor arguments in the pool contract, which results in the init code hash
/// of the pool being constant allowing the CREATE2 address of the pool to be cheaply computed on-chain
interface IvSwapPoolDeployer {
    /// @notice Get the parameters to be used in constructing the pool, set transiently during pool creation.
    /// @dev Called by the pool constructor to fetch the parameters of the pool
    /// Returns factory The factory address
    /// Returns token0 The first token of the pool by address sort order
    /// Returns token1 The second token of the pool by address sort order
    /// Returns fee The fee collected upon every swap in the pool, denominated in hundredths of a bip
    /// Returns tickSpacing The minimum number of ticks between initialized ticks
    function poolCreationDefaults()
        external
        view
        returns (
            address factory,
            address token0,
            address token1,
            uint24 fee,
            uint24 vFee,
            uint24 maxAllowListCount,
            uint256 maxReserveRatio
        );
}

// SPDX-License-Identifier: Apache-2.0

pragma solidity 0.8.2;

import '@openzeppelin/contracts/utils/math/Math.sol';
import '../types.sol';
import '../interfaces/IvPair.sol';

library vSwapLibrary {
    uint24 internal constant PRICE_FEE_FACTOR = 10 ** 3;

    //find common token and assign to ikToken1 and jkToken1
    function findCommonToken(
        address ikToken0,
        address ikToken1,
        address jkToken0,
        address jkToken1
    ) internal pure returns (VirtualPoolTokens memory vPoolTokens) {
        (
            vPoolTokens.ik0,
            vPoolTokens.ik1,
            vPoolTokens.jk0,
            vPoolTokens.jk1
        ) = (ikToken0 == jkToken0)
            ? (ikToken1, ikToken0, jkToken1, jkToken0)
            : (ikToken0 == jkToken1)
            ? (ikToken1, ikToken0, jkToken0, jkToken1)
            : (ikToken1 == jkToken0)
            ? (ikToken0, ikToken1, jkToken1, jkToken0)
            : (ikToken0, ikToken1, jkToken0, jkToken1); //default
    }

    function calculateVPool(
        uint256 ikTokenABalance,
        uint256 ikTokenBBalance,
        uint256 jkTokenABalance,
        uint256 jkTokenBBalance
    ) internal pure returns (VirtualPoolModel memory vPool) {
        vPool.balance0 =
            (ikTokenABalance * Math.min(ikTokenBBalance, jkTokenBBalance)) /
            Math.max(ikTokenBBalance, 1);

        vPool.balance1 =
            (jkTokenABalance * Math.min(ikTokenBBalance, jkTokenBBalance)) /
            Math.max(jkTokenBBalance, 1);
    }

    function getAmountIn(
        uint256 amountOut,
        uint256 pairBalanceIn,
        uint256 pairBalanceOut,
        uint256 fee
    ) internal pure returns (uint256 amountIn) {
        uint256 numerator = (pairBalanceIn * amountOut) * PRICE_FEE_FACTOR;
        uint256 denominator = (pairBalanceOut - amountOut) * fee;
        amountIn = (numerator / denominator) + 1;
    }

    function getAmountOut(
        uint256 amountIn,
        uint256 pairBalanceIn,
        uint256 pairBalanceOut,
        uint256 fee
    ) internal pure returns (uint256 amountOut) {
        uint256 amountInWithFee = amountIn * fee;
        uint256 numerator = amountInWithFee * pairBalanceOut;
        uint256 denominator = (pairBalanceIn * PRICE_FEE_FACTOR) +
            amountInWithFee;
        amountOut = numerator / denominator;
    }

    function quote(
        uint256 amountA,
        uint256 balanceA,
        uint256 balanceB
    ) internal pure returns (uint256 amountB) {
        require(amountA > 0, 'VSWAP: INSUFFICIENT_AMOUNT');
        require(balanceA > 0 && balanceB > 0, 'VSWAP: INSUFFICIENT_LIQUIDITY');
        amountB = (amountA * balanceB) / balanceA;
    }

    function sortBalances(
        address tokenIn,
        address baseToken,
        uint256 pairBalance0,
        uint256 pairBalance1
    ) internal pure returns (uint256 _balance0, uint256 _balance1) {
        (_balance0, _balance1) = baseToken == tokenIn
            ? (pairBalance0, pairBalance1)
            : (pairBalance1, pairBalance0);
    }

    function getVirtualPoolBase(
        address jkToken0,
        address jkToken1,
        uint256 jkBalance0,
        uint256 jkBalance1,
        uint24 jkvFee,
        address ikPair
    ) internal view returns (VirtualPoolModel memory vPool) {
        (address ik0, address ik1) = IvPair(ikPair).getTokens();
        (address jk0, address jk1) = (jkToken0, jkToken1); //gas saving

        VirtualPoolTokens memory vPoolTokens = findCommonToken(
            ik0,
            ik1,
            jk0,
            jk1
        );

        require(vPoolTokens.ik1 == vPoolTokens.jk1, 'IOP');

        (uint256 ikBalance0, uint256 ikBalance1, ) = IvPair(ikPair)
            .getLastBalances();

        (uint256 _jkBalance0, uint256 _jkBalance1) = (jkBalance0, jkBalance1); //gas saving

        vPool = calculateVPool(
            vPoolTokens.ik0 == ik0 ? ikBalance0 : ikBalance1,
            vPoolTokens.ik0 == ik0 ? ikBalance1 : ikBalance0,
            vPoolTokens.jk0 == jk0 ? _jkBalance0 : _jkBalance1,
            vPoolTokens.jk0 == jk0 ? _jkBalance1 : _jkBalance0
        );

        vPool.token0 = vPoolTokens.ik0;
        vPool.token1 = vPoolTokens.jk0;
        vPool.commonToken = vPoolTokens.ik1;

        vPool.fee = jkvFee;
    }

    function getVirtualPool(
        address jkPair,
        address ikPair
    ) internal view returns (VirtualPoolModel memory vPool) {
        (address jk0, address jk1) = IvPair(jkPair).getTokens();
        (uint256 _balance0, uint256 _balance1, ) = IvPair(jkPair)
            .getLastBalances();
        uint24 vFee = IvPair(jkPair).vFee();

        vPool = getVirtualPoolBase(
            jk0,
            jk1,
            _balance0,
            _balance1,
            vFee,
            ikPair
        );
    }
}

// SPDX-License-Identifier: Apache-2.0

pragma solidity 0.8.2;

struct VirtualPoolModel {
    uint24 fee;
    address token0;
    address token1;
    uint256 balance0;
    uint256 balance1;
    address commonToken;
}

struct VirtualPoolTokens {
    address jk0;
    address jk1;
    address ik0;
    address ik1;
}

struct ExchangeReserveCallbackParams {
    address jkPair1;
    address ikPair1;
    address jkPair2;
    address ikPair2;
    address caller;
    uint256 flashAmountOut;
}

struct SwapCallbackData {
    address caller;
    uint256 tokenInMax;
    uint ETHValue;
    address jkPool;
}

struct PoolCreationDefaults {
    address factory;
    address token0;
    address token1;
    uint24 fee;
    uint24 vFee;
    uint24 maxAllowListCount;
    uint256 maxReserveRatio;
}

// SPDX-License-Identifier: Apache-2.0

pragma solidity 0.8.2;

import '@openzeppelin/contracts/security/ReentrancyGuard.sol';
import '@openzeppelin/contracts/token/ERC20/IERC20.sol';
import '@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol';
import '@openzeppelin/contracts/utils/math/Math.sol';
import '@uniswap/v3-core/contracts/interfaces/IERC20Minimal.sol';

import './interfaces/IvPair.sol';
import './interfaces/IvSwapPoolDeployer.sol';
import './interfaces/IvPairFactory.sol';
import './interfaces/IvFlashSwapCallback.sol';
import './libraries/vSwapLibrary.sol';
import './vSwapERC20.sol';

contract vPair is IvPair, vSwapERC20, ReentrancyGuard {
    uint24 internal constant BASE_FACTOR = 1000;
    uint24 internal constant MINIMUM_LIQUIDITY = BASE_FACTOR;
    uint24 internal constant RESERVE_RATIO_FACTOR = BASE_FACTOR;

    address public factory;

    address public immutable override token0;
    address public immutable override token1;

    uint24 public override fee;
    uint24 public override vFee;

    uint256 public override pairBalance0;
    uint256 public override pairBalance1;

    uint256 private _lastBlockUpdated;
    uint256 private _lastPairBalance0;
    uint256 private _lastPairBalance1;

    uint256 public maxReserveRatio;

    address[] public allowList;
    mapping(address => bool) public allowListMap;
    uint24 public override maxAllowListCount;

    mapping(address => uint256) public override reservesBaseValue;
    mapping(address => uint256) public override reserves;

    function _onlyFactoryAdmin() internal view {
        require(
            msg.sender == IvPairFactory(factory).admin() ||
                msg.sender == factory,
            'OA'
        );
    }

    modifier onlyFactoryAdmin() {
        _onlyFactoryAdmin();
        _;
    }

    modifier onlyForExchangeReserves() {
        require(msg.sender == IvPairFactory(factory).exchangeReserves(), 'OER');
        _;
    }

    /// @dev This function is gas optimized to avoid a redundant extcodesize check in addition to the returndatasize
    function fetchBalance(address token) internal view returns (uint256) {
        (bool success, bytes memory data) = token.staticcall(
            abi.encodeWithSelector(
                IERC20Minimal.balanceOf.selector,
                address(this)
            )
        );
        require(success && data.length >= 32);
        return abi.decode(data, (uint256));
    }

    constructor() {
        (
            factory,
            token0,
            token1,
            fee,
            vFee,
            maxAllowListCount,
            maxReserveRatio
        ) = IvSwapPoolDeployer(msg.sender).poolCreationDefaults();
    }

    function _update(uint256 balance0, uint256 balance1) internal {
        if (block.number > _lastBlockUpdated) {
            (_lastPairBalance0, _lastPairBalance1) = (balance0, balance1);
            _lastBlockUpdated = block.number;
        }

        (pairBalance0, pairBalance1) = (balance0, balance1);

        emit Sync(balance0, balance1);
    }

    function getLastBalances()
        external
        view
        override
        returns (
            uint256 _lastBalance0,
            uint256 _lastBalance1,
            uint256 _blockNumber
        )
    {
        return (_lastPairBalance0, _lastPairBalance1, _lastBlockUpdated);
    }

    function getBalances()
        external
        view
        override
        returns (uint256 _balance0, uint256 _balance1)
    {
        return (pairBalance0, pairBalance1);
    }

    function getTokens()
        external
        view
        override
        returns (address _token0, address _token1)
    {
        return (token0, token1);
    }

    function swapNative(
        uint256 amountOut,
        address tokenOut,
        address to,
        bytes calldata data
    ) external override nonReentrant returns (uint256 _amountIn) {
        require(to > address(0) && to != token0 && to != token1, 'IT');
        require(tokenOut == token0 || tokenOut == token1, 'NNT');
        require(amountOut > 0, 'IAO');

        SafeERC20.safeTransfer(IERC20(tokenOut), to, amountOut);

        address _tokenIn = tokenOut == token0 ? token1 : token0;

        (uint256 _balanceIn, uint256 _balanceOut) = vSwapLibrary.sortBalances(
            _tokenIn,
            token0,
            pairBalance0,
            pairBalance1
        );

        require(amountOut <= _balanceOut, 'AOE');

        uint256 requiredAmountIn = vSwapLibrary.getAmountIn(
            amountOut,
            _balanceIn,
            _balanceOut,
            fee
        );

        if (data.length > 0) {
            IvFlashSwapCallback(msg.sender).vFlashSwapCallback(
                _tokenIn,
                tokenOut,
                requiredAmountIn,
                data
            );
        }

        _amountIn = fetchBalance(_tokenIn) - _balanceIn;

        require(_amountIn > 0 && _amountIn >= requiredAmountIn, 'IIA');

        {
            //avoid stack too deep
            bool _isTokenIn0 = _tokenIn == token0;

            _update(
                _isTokenIn0 ? _balanceIn + _amountIn : _balanceOut - amountOut,
                _isTokenIn0 ? _balanceOut - amountOut : _balanceIn + _amountIn
            );
        }

        emit Swap(
            msg.sender,
            _tokenIn,
            tokenOut,
            requiredAmountIn,
            amountOut,
            to
        );
    }

    function swapNativeToReserve(
        uint256 amountOut,
        address ikPair,
        address to,
        bytes calldata data
    )
        external
        override
        onlyForExchangeReserves
        nonReentrant
        returns (address _leftoverToken, uint256 _leftoverAmount)
    {
        require(amountOut > 0, 'IAO');
        require(to > address(0) && to != token0 && to != token1, 'IT');

        VirtualPoolModel memory vPool = vSwapLibrary.getVirtualPool(
            ikPair,
            address(this)
        );

        // validate ikPair with factory
        require(
            IvPairFactory(factory).getPair(vPool.token1, vPool.commonToken) ==
                ikPair,
            'IIKP'
        );

        require(amountOut <= vPool.balance1, 'AOE');
        require(allowListMap[vPool.token1], 'TNW');
        require(vPool.token0 == token0 || vPool.token0 == token1, 'NNT');

        SafeERC20.safeTransfer(IERC20(vPool.token1), to, amountOut);
        uint256 requiredAmountIn = 0;

        requiredAmountIn = vSwapLibrary.quote(
            amountOut,
            vPool.balance1,
            vPool.balance0
        );

        if (data.length > 0)
            IvFlashSwapCallback(msg.sender).vFlashSwapCallback(
                vPool.token0,
                vPool.token1,
                requiredAmountIn,
                data
            );

        // reverts if overflow occurs since solidity 0.8
        // so if fetchBalance(vPool.token0) - pairBalance - requiredAmountIn < 0
        // then it is reverted (requiredAmountIn always positive)
        (_leftoverAmount, _leftoverToken) = vPool.token0 == token0
            ? (
                fetchBalance(vPool.token0) - pairBalance0 - requiredAmountIn,
                token0
            )
            : (
                fetchBalance(vPool.token0) - pairBalance1 - requiredAmountIn,
                token1
            );

        if (_leftoverAmount > 0) {
            SafeERC20.safeTransfer(
                IERC20(_leftoverToken),
                msg.sender,
                _leftoverAmount
            );
        }

        // //update reserve balance in the equivalent of token0 value

        uint256 _reserveBaseValue = reserves[vPool.token1] - amountOut;
        if (_reserveBaseValue > 0) {
            // //re-calculate price of reserve asset in token0 for the whole pool blance
            _reserveBaseValue = vSwapLibrary.quote(
                _reserveBaseValue,
                vPool.balance1,
                vPool.balance0
            );
        }

        if (_reserveBaseValue > 0 && vPool.token0 == token1) {
            //if tokenOut is not token0 we should quote it to token0 value
            _reserveBaseValue = vSwapLibrary.quote(
                _reserveBaseValue,
                pairBalance1,
                pairBalance0
            );
        }

        reservesBaseValue[vPool.token1] = _reserveBaseValue;

        //update reserve balance
        reserves[vPool.token1] -= amountOut;

        _update(fetchBalance(token0), fetchBalance(token1));

        emit ReserveSync(
            vPool.token1,
            reserves[vPool.token1],
            calculateReserveRatio()
        );

        emit SwapReserve(
            msg.sender,
            vPool.token0,
            vPool.token1,
            requiredAmountIn,
            amountOut,
            ikPair,
            to
        );
    }

    function swapReserveToNative(
        uint256 amountOut,
        address ikPair,
        address to,
        bytes calldata data
    ) external override nonReentrant returns (uint256 amountIn) {
        require(amountOut > 0, 'IAO');
        require(to > address(0) && to != token0 && to != token1, 'IT');

        VirtualPoolModel memory vPool = vSwapLibrary.getVirtualPoolBase(
            token0,
            token1,
            pairBalance0,
            pairBalance1,
            vFee,
            ikPair
        );

        // validate ikPair with factory
        require(
            IvPairFactory(factory).getPair(vPool.token0, vPool.commonToken) ==
                ikPair,
            'IIKP'
        );

        require(amountOut <= vPool.balance1, 'AOE');
        require(allowListMap[vPool.token0], 'TNW');
        require(vPool.token1 == token0 || vPool.token1 == token1, 'NNT');

        SafeERC20.safeTransfer(IERC20(vPool.token1), to, amountOut);

        uint256 requiredAmountIn = vSwapLibrary.getAmountIn(
            amountOut,
            vPool.balance0,
            vPool.balance1,
            vFee
        );

        if (data.length > 0)
            IvFlashSwapCallback(msg.sender).vFlashSwapCallback(
                vPool.token0,
                vPool.token1,
                requiredAmountIn,
                data
            );

        amountIn = fetchBalance(vPool.token0) - reserves[vPool.token0];

        require(amountIn > 0 && amountIn >= requiredAmountIn, 'IIA');

        //update reserve balance in the equivalent of token0 value
        uint256 _reserveBaseValue = reserves[vPool.token0] + amountIn;

        //re-calculate price of reserve asset in token0 for the whole pool blance
        _reserveBaseValue = vSwapLibrary.quote(
            _reserveBaseValue,
            vPool.balance0,
            vPool.balance1
        );

        if (vPool.token1 == token1) {
            //if tokenOut is not token0 we should quote it to token0 value
            _reserveBaseValue = vSwapLibrary.quote(
                _reserveBaseValue,
                pairBalance1,
                pairBalance0
            );
        }

        reservesBaseValue[vPool.token0] = _reserveBaseValue;

        //update reserve balance
        reserves[vPool.token0] += amountIn;

        _update(fetchBalance(token0), fetchBalance(token1));

        uint _reserveRatio = calculateReserveRatio();
        require(_reserveRatio < maxReserveRatio, 'TBPT'); // reserve amount goes beyond pool threshold

        emit ReserveSync(vPool.token0, reserves[vPool.token0], _reserveRatio);
        emit SwapReserve(
            msg.sender,
            vPool.token0,
            vPool.token1,
            requiredAmountIn,
            amountOut,
            ikPair,
            to
        );
    }

    function calculateReserveRatio()
        public
        view
        override
        returns (uint256 rRatio)
    {
        uint256 totalReserves = 0;
        for (uint256 i = 0; i < allowList.length; ++i) {
            totalReserves += reservesBaseValue[allowList[i]];
        }

        rRatio = pairBalance0 > 0
            ? (totalReserves * RESERVE_RATIO_FACTOR) / (2 * pairBalance0)
            : 0;
    }

    function mint(
        address to
    ) external override nonReentrant returns (uint256 liquidity) {
        (uint256 _pairBalance0, uint256 _pairBalance1) = (
            pairBalance0,
            pairBalance1
        );
        uint256 currentBalance0 = fetchBalance(token0);
        uint256 currentBalance1 = fetchBalance(token1);
        uint256 amount0 = currentBalance0 - _pairBalance0;
        uint256 amount1 = currentBalance1 - _pairBalance1;

        uint256 _totalSupply = totalSupply();
        if (_totalSupply == 0) {
            liquidity = Math.sqrt(amount0 * amount1) - MINIMUM_LIQUIDITY;
            _mint(address(0), MINIMUM_LIQUIDITY); // permanently lock the first MINIMUM_LIQUIDITY tokens
        } else {
            liquidity = Math.min(
                (amount0 * _totalSupply) / _pairBalance0,
                (amount1 * _totalSupply) / _pairBalance1
            );
        }

        //substract reserve ratio PCT from minted liquidity tokens amount
        uint256 reserveRatio = calculateReserveRatio();

        liquidity =
            (liquidity * RESERVE_RATIO_FACTOR) /
            (RESERVE_RATIO_FACTOR + reserveRatio);

        require(liquidity > 0, 'ILM');

        _mint(to, liquidity);

        _update(currentBalance0, currentBalance1);
        emit Mint(to, amount0, amount1, liquidity, totalSupply());
    }

    function burn(
        address to
    )
        external
        override
        nonReentrant
        returns (uint256 amount0, uint256 amount1)
    {
        address _token0 = token0; // gas savings
        address _token1 = token1; // gas savings
        uint256 balance0 = fetchBalance(_token0);
        uint256 balance1 = fetchBalance(_token1);
        uint256 liquidity = fetchBalance(address(this));

        uint256 _totalSupply = totalSupply();
        amount0 = (balance0 * liquidity) / _totalSupply;
        amount1 = (balance1 * liquidity) / _totalSupply;

        require(amount0 > 0 && amount1 > 0, 'ILB');

        _burn(address(this), liquidity);
        SafeERC20.safeTransfer(IERC20(_token0), to, amount0);
        SafeERC20.safeTransfer(IERC20(_token1), to, amount1);

        //distribute reserve tokens and update reserve ratios
        uint256 _currentReserveRatio = calculateReserveRatio();
        if (_currentReserveRatio > 0) {
            for (uint256 i = 0; i < allowList.length; ++i) {
                address _wlI = allowList[i];
                uint256 reserveBalance = reserves[_wlI];

                if (reserveBalance > 0) {
                    uint256 reserveAmountOut = (reserveBalance * liquidity) /
                        _totalSupply;

                    SafeERC20.safeTransfer(IERC20(_wlI), to, reserveAmountOut);

                    uint256 reserveBaseValuewlI = reservesBaseValue[_wlI]; //gas saving

                    reservesBaseValue[_wlI] =
                        reserveBaseValuewlI -
                        ((reserveBaseValuewlI * liquidity) / _totalSupply);

                    reserves[_wlI] = reserveBalance - reserveAmountOut;
                }
            }
        }

        balance0 = fetchBalance(_token0);
        balance1 = fetchBalance(_token1);

        _update(balance0, balance1);
        emit Burn(msg.sender, amount0, amount1, to);
    }

    function setAllowList(
        address[] memory _allowList
    ) external override onlyFactoryAdmin {
        require(_allowList.length <= maxAllowListCount, 'MW');

        address[] memory _oldWL = allowList;

        for (uint256 i = 0; i < _oldWL.length; ++i)
            allowListMap[_oldWL[i]] = false;

        //set new allowList
        allowList = _allowList;
        for (uint256 i = 0; i < _allowList.length; ++i)
            allowListMap[_allowList[i]] = true;

        emit AllowListChanged(_allowList);
    }

    function setFee(
        uint24 _fee,
        uint24 _vFee
    ) external override onlyFactoryAdmin {
        require(_fee > 0 && _vFee > 0 && _fee < 1000 && _vFee < 1000, 'IFC');
        fee = _fee;
        vFee = _vFee;

        emit FeeChanged(_fee, _vFee);
    }

    function setMaxReserveThreshold(
        uint256 threshold
    ) external override onlyFactoryAdmin {
        require(threshold > 0, 'IRT');
        maxReserveRatio = threshold;

        emit ReserveThresholdChanged(threshold);
    }

    function setMaxAllowListCount(
        uint24 _maxAllowListCount
    ) external override onlyFactoryAdmin {
        maxAllowListCount = _maxAllowListCount;
        emit AllowListCountChanged(_maxAllowListCount);
    }
}

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

pragma solidity 0.8.2;

import '@openzeppelin/contracts/token/ERC20/IERC20.sol';
import '@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol';
import '@openzeppelin/contracts/utils/Context.sol';

import '@openzeppelin/contracts/token/ERC20/presets/ERC20PresetFixedSupply.sol'; //for test

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

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

    uint256 private _totalSupply;

    string private constant _name = 'Virtuswap-LP';
    string private constant _symbol = 'VSWAPLP';

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

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

    /**
     * @dev Returns the number of decimals used to get its user representation.
     * For example, if `decimals` equals `2`, a balance of `505` tokens should
     * be displayed to a user as `5.05` (`505 / 10 ** 2`).
     *
     * Tokens usually opt for a value of 18, imitating the relationship between
     * Ether and Wei. This is the value {ERC20} uses, unless this function is
     * overridden;
     *
     * NOTE: This information is only used for _display_ purposes: it in
     * no way affects any of the arithmetic of the contract, including
     * {IERC20-balanceOf} and {IERC20-transfer}.
     */
    function decimals() public view virtual override returns (uint8) {
        return 18;
    }

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

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

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

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

    /**
     * @dev See {IERC20-approve}.
     *
     * NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on
     * `transferFrom`. This is semantically equivalent to an infinite approval.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function approve(
        address spender,
        uint256 amount
    ) external 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
    ) external 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
    ) external 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 {
        _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 {}
}

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

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address[]","name":"tokens","type":"address[]"}],"name":"AllowListChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint24","name":"_maxAllowListCount","type":"uint24"}],"name":"AllowListCountChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"sender","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount0","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount1","type":"uint256"},{"indexed":true,"internalType":"address","name":"to","type":"address"}],"name":"Burn","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint24","name":"fee","type":"uint24"},{"indexed":false,"internalType":"uint24","name":"vFee","type":"uint24"}],"name":"FeeChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"sender","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount0","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount1","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"lpTokens","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"poolLPTokens","type":"uint256"}],"name":"Mint","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"asset","type":"address"},{"indexed":false,"internalType":"uint256","name":"balance","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"rRatio","type":"uint256"}],"name":"ReserveSync","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"newThreshold","type":"uint256"}],"name":"ReserveThresholdChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"sender","type":"address"},{"indexed":false,"internalType":"address","name":"tokenIn","type":"address"},{"indexed":false,"internalType":"address","name":"tokenOut","type":"address"},{"indexed":false,"internalType":"uint256","name":"amountIn","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amountOut","type":"uint256"},{"indexed":true,"internalType":"address","name":"to","type":"address"}],"name":"Swap","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"sender","type":"address"},{"indexed":false,"internalType":"address","name":"tokenIn","type":"address"},{"indexed":false,"internalType":"address","name":"tokenOut","type":"address"},{"indexed":false,"internalType":"uint256","name":"amountIn","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amountOut","type":"uint256"},{"indexed":false,"internalType":"address","name":"ikPool","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"}],"name":"SwapReserve","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"balance0","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"balance1","type":"uint256"}],"name":"Sync","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":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"allowList","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"allowListMap","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"}],"name":"burn","outputs":[{"internalType":"uint256","name":"amount0","type":"uint256"},{"internalType":"uint256","name":"amount1","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"calculateReserveRatio","outputs":[{"internalType":"uint256","name":"rRatio","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":"factory","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"fee","outputs":[{"internalType":"uint24","name":"","type":"uint24"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getBalances","outputs":[{"internalType":"uint256","name":"_balance0","type":"uint256"},{"internalType":"uint256","name":"_balance1","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getLastBalances","outputs":[{"internalType":"uint256","name":"_lastBalance0","type":"uint256"},{"internalType":"uint256","name":"_lastBalance1","type":"uint256"},{"internalType":"uint256","name":"_blockNumber","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getTokens","outputs":[{"internalType":"address","name":"_token0","type":"address"},{"internalType":"address","name":"_token1","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":[],"name":"maxAllowListCount","outputs":[{"internalType":"uint24","name":"","type":"uint24"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxReserveRatio","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"}],"name":"mint","outputs":[{"internalType":"uint256","name":"liquidity","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pairBalance0","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pairBalance1","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"reserves","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"reservesBaseValue","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address[]","name":"_allowList","type":"address[]"}],"name":"setAllowList","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint24","name":"_fee","type":"uint24"},{"internalType":"uint24","name":"_vFee","type":"uint24"}],"name":"setFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint24","name":"_maxAllowListCount","type":"uint24"}],"name":"setMaxAllowListCount","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"threshold","type":"uint256"}],"name":"setMaxReserveThreshold","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amountOut","type":"uint256"},{"internalType":"address","name":"tokenOut","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"swapNative","outputs":[{"internalType":"uint256","name":"_amountIn","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amountOut","type":"uint256"},{"internalType":"address","name":"ikPair","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"swapNativeToReserve","outputs":[{"internalType":"address","name":"_leftoverToken","type":"address"},{"internalType":"uint256","name":"_leftoverAmount","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amountOut","type":"uint256"},{"internalType":"address","name":"ikPair","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"swapReserveToNative","outputs":[{"internalType":"uint256","name":"amountIn","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"token0","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"token1","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"vFee","outputs":[{"internalType":"uint24","name":"","type":"uint24"}],"stateMutability":"view","type":"function"}]

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

606:15997:18:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3351:181;3498:12;;3512;;3351:181;;;;22892:25:20;;;22948:2;22933:18;;22926:34;;;;22865:18;3351:181:18;;;;;;;;1962:98:19;2048:5;;;;;;;;;;;;;;;;;1962:98;;;;;;;:::i;4297:221::-;;;;;;:::i;:::-;;:::i;:::-;;;10494:14:20;;10487:22;10469:41;;10457:2;10442:18;4297:221:19;10424:92:20;872:40:18;;;;;;;;-1:-1:-1;;;;;6842:55:20;;;6824:74;;6812:2;6797:18;872:40:18;6779:125:20;3050:106:19;3137:12;;3050:106;;;22682:25:20;;;22670:2;22655:18;3050:106:19;22637:76:20;5441:3405:18;;;;;;:::i;:::-;;:::i;:::-;;;;-1:-1:-1;;;;;9157:55:20;;;9139:74;;9244:2;9229:18;;9222:34;;;;9112:18;5441:3405:18;9094:168:20;15873:266:18;;;;;;:::i;:::-;;:::i;:::-;;5080:286:19;;;;;;:::i;:::-;;:::i;1234:30:18:-;;;;;;8852:2796;;;;;;:::i;:::-;;:::i;2899:91:19:-;;;2981:2;23833:36:20;;23821:2;23806:18;2899:91:19;23788:87:20;5761:258:19;;;;;;:::i;:::-;;:::i;3055:290:18:-;3282:17;;3301;;3320;;3055:290;;;23173:25:20;;;23229:2;23214:18;;23207:34;;;;23257:18;;;23250:34;23161:2;23146:18;3055:290:18;23128:162:20;11654:412:18;;;:::i;997:27::-;;;;;-1:-1:-1;;;997:27:18;;;;;;;;;22221:8:20;22209:21;;;22191:40;;22179:2;22164:18;997:27:18;22146:91:20;1271:26:18;;;;;;:::i;:::-;;:::i;15344:523::-;;;;;;:::i;:::-;;:::i;1073:36::-;;;;;;12072:1349;;;;;;:::i;:::-;;:::i;3214:139:19:-;;;;;;:::i;:::-;;:::i;1400:61:18:-;;;;;;:::i;:::-;;;;;;;;;;;;;;13427:1911;;;;;;:::i;:::-;;:::i;2173:102:19:-;2261:7;;;;;;;;;;;;;;;;;2173:102;;6506:485;;;;;;:::i;:::-;;:::i;16145:233:18:-;;;;;;:::i;:::-;;:::i;3549:211:19:-;;;;;;:::i;:::-;;:::i;3538:163:18:-;;;;-1:-1:-1;;;;;3679:6:18;7162:15:20;;7144:34;;3687:6:18;7214:15:20;7209:2;7194:18;;7187:43;7056:18;3538:163:18;7038:198:20;1353:40:18;;;;;;;;;1303:44;;;;;;:::i;:::-;;;;;;;;;;;;;;;;843:22;;;;;-1:-1:-1;;;;;843:22:18;;;918:40;;;;;1467:52;;;;;;:::i;:::-;;;;;;;;;;;;;;1031:36;;;;;;16384:217;;;;;;:::i;:::-;;:::i;3818:171:19:-;;;;;;:::i;:::-;-1:-1:-1;;;;;3955:18:19;;;3929:7;3955:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;3818:171;965:26:18;;;;;-1:-1:-1;;;965:26:18;;;;;;3707:1728;;;;;;:::i;:::-;;:::i;4297:221:19:-;4404:4;719:10:9;4458:32:19;719:10:9;4474:7:19;4483:6;4458:8;:32::i;:::-;-1:-1:-1;4507:4:19;;4297:221;-1:-1:-1;;;4297:221:19:o;5441:3405:18:-;1888:7;;;1874:41;;;-1:-1:-1;;;1874:41:18;;;;5680:22;;;;-1:-1:-1;;;;;1888:7:18;;1874:39;;:41;;;;;;;;;;;1888:7;1874:41;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;1860:55:18;:10;-1:-1:-1;;;;;1860:55:18;;1852:71;;;;-1:-1:-1;;;1852:71:18;;12936:2:20;1852:71:18;;;12918:21:20;12975:1;12955:18;;;12948:29;-1:-1:-1;;;12993:18:20;;;12986:33;13036:18;;1852:71:18;;;;;;;;;1744:1:0::1;2325:7;;:19;;2317:63;;;::::0;-1:-1:-1;;;2317:63:0;;20794:2:20;2317:63:0::1;::::0;::::1;20776:21:20::0;20833:2;20813:18;;;20806:30;20872:33;20852:18;;;20845:61;20923:18;;2317:63:0::1;20766:181:20::0;2317:63:0::1;1744:1;2455:7;:18:::0;5751:13:18;5743:29:::2;;;::::0;-1:-1:-1;;;5743:29:18;;13670:2:20;5743:29:18::2;::::0;::::2;13652:21:20::0;13709:1;13689:18;;;13682:29;-1:-1:-1;;;13727:18:20;;;13720:33;13770:18;;5743:29:18::2;13642:152:20::0;5743:29:18::2;-1:-1:-1::0;;;;;5790:15:18;::::2;::::0;;;;:31:::2;;;5815:6;-1:-1:-1::0;;;;;5809:12:18::2;:2;-1:-1:-1::0;;;;;5809:12:18::2;;;5790:31;:47;;;;;5831:6;-1:-1:-1::0;;;;;5825:12:18::2;:2;-1:-1:-1::0;;;;;5825:12:18::2;;;5790:47;5782:62;;;::::0;-1:-1:-1;;;5782:62:18;;17637:2:20;5782:62:18::2;::::0;::::2;17619:21:20::0;17676:1;17656:18;;;17649:29;-1:-1:-1;;;17694:18:20;;;17687:32;17736:18;;5782:62:18::2;17609:151:20::0;5782:62:18::2;5855:29;5887:84;5928:6;5956:4;5887:27;:84::i;:::-;6057:7;::::0;;6074:12:::2;::::0;;::::2;::::0;6088:17:::2;::::0;::::2;::::0;6043:63;;-1:-1:-1;;;6043:63:18;;5855:116;;-1:-1:-1;;;;;;6043:89:18;;::::2;::::0;6057:7;::::2;::::0;6043:30:::2;::::0;:63:::2;::::0;6088:17;6043:63:::2;-1:-1:-1::0;;;;;7162:15:20;;;7144:34;;7214:15;;7209:2;7194:18;;7187:43;7071:2;7056:18;;7038:198;6043:63:18::2;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;6043:89:18::2;;6022:140;;;;-1:-1:-1::0;;;6022:140:18::2;;;;;;15428:2:20::0;15410:21;;;15467:1;15447:18;;;15440:29;-1:-1:-1;;;15500:2:20;15485:18;;15478:34;15544:2;15529:18;;15400:153;6022:140:18::2;6194:5;:14;;;6181:9;:27;;6173:43;;;::::0;-1:-1:-1;;;6173:43:18;;19802:2:20;6173:43:18::2;::::0;::::2;19784:21:20::0;19841:1;19821:18;;;19814:29;-1:-1:-1;;;19859:18:20;;;19852:33;19902:18;;6173:43:18::2;19774:152:20::0;6173:43:18::2;6247:12;::::0;;::::2;::::0;-1:-1:-1;;;;;6234:26:18::2;;::::0;;;:12:::2;:26;::::0;;;::::2;;6226:42;;;::::0;-1:-1:-1;;;6226:42:18;;16498:2:20;6226:42:18::2;::::0;::::2;16480:21:20::0;16537:1;16517:18;;;16510:29;-1:-1:-1;;;16555:18:20;;;16548:33;16598:18;;6226:42:18::2;16470:152:20::0;6226:42:18::2;6302:6;-1:-1:-1::0;;;;;6286:22:18::2;:5;:12;;;-1:-1:-1::0;;;;;6286:22:18::2;;:48;;;;6328:6;-1:-1:-1::0;;;;;6312:22:18::2;:5;:12;;;-1:-1:-1::0;;;;;6312:22:18::2;;6286:48;6278:64;;;::::0;-1:-1:-1;;;6278:64:18;;14766:2:20;6278:64:18::2;::::0;::::2;14748:21:20::0;14805:1;14785:18;;;14778:29;-1:-1:-1;;;14823:18:20;;;14816:33;14866:18;;6278:64:18::2;14738:152:20::0;6278:64:18::2;6353:59;6383:5;:12;;;6398:2;6402:9;6353:22;:59::i;:::-;6422:24;6480:107;6512:9;6535:5;:14;;;6563:5;:14;;;6480:18;:107::i;:::-;6461:126:::0;-1:-1:-1;6602:15:18;;6598:213:::2;;6699:12;::::0;::::2;::::0;6729::::2;::::0;;::::2;::::0;6631:180;;-1:-1:-1;;;6631:180:18;;6651:10:::2;::::0;6631:50:::2;::::0;:180:::2;::::0;6759:16;;6793:4;;;;6631:180:::2;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;6598:213;7078:6;-1:-1:-1::0;;;;;7062:22:18::2;:5;:12;;;-1:-1:-1::0;;;;;7062:22:18::2;;:284;;7292:16;7277:12;;7248:26;7261:5;:12;;;7248;:26::i;:::-;:41;;;;:::i;:::-;:60;;;;:::i;:::-;7326:6;7062:284;;;7161:16;7146:12;;7117:26;7130:5;:12;;;7117;:26::i;:::-;:41;;;;:::i;:::-;:60;;;;:::i;:::-;7195:6;7062:284;7026:320:::0;-1:-1:-1;7026:320:18;-1:-1:-1;7361:19:18;;7357:187:::2;;7396:137;7443:14;7476:10;7504:15;7396:22;:137::i;:::-;7662:12;::::0;;::::2;::::0;-1:-1:-1;;;;;7653:22:18::2;7625:25;7653:22:::0;;;:8:::2;:22;::::0;;;;;:34:::2;::::0;7678:9;;7653:34:::2;:::i;:::-;7625:62:::0;-1:-1:-1;7701:21:18;;7697:292:::2;;7847:131;7883:17;7918:5;:14;;;7950:5;:14;;;7847:18;:131::i;:::-;7827:151;;7697:292;8023:1;8003:17;:21;:47;;;;;8044:6;-1:-1:-1::0;;;;;8028:22:18::2;:5;:12;;;-1:-1:-1::0;;;;;8028:22:18::2;;8003:47;7999:300;;;8161:127;8197:17;8232:12;;8262;;8161:18;:127::i;:::-;8141:147;;7999:300;8327:12;::::0;;::::2;::::0;;-1:-1:-1;;;;;8309:31:18;;::::2;;::::0;;;:17:::2;:31;::::0;;;;;;:51;;;8413:12;;8404:22;;::::2;::::0;;:8:::2;:22:::0;;;;;;:35;;8430:9;;8309:31;8404:35:::2;::::0;8430:9;;8404:35:::2;:::i;:::-;::::0;;;-1:-1:-1;8450:51:18::2;::::0;-1:-1:-1;8458:20:18::2;8471:6;8458:12;:20::i;:::-;8480;8493:6;8480:12;:20::i;:::-;8450:7;:51::i;:::-;8542:12;::::0;;::::2;::::0;-1:-1:-1;;;;;8568:22:18;::::2;;::::0;;;:8:::2;:22;::::0;;;;;;8517:120:::2;::::0;8542:12;8604:23:::2;:21;:23::i;:::-;8517:120;::::0;;-1:-1:-1;;;;;9487:55:20;;;9469:74;;9574:2;9559:18;;9552:34;;;;9602:18;;;9595:34;9457:2;9442:18;8517:120:18::2;;;;;;;8702:12;::::0;;::::2;::::0;8728::::2;::::0;;::::2;::::0;8653:186;;-1:-1:-1;;;;;8747:15:20;;;8729:34;;8799:15;;;8779:18;;;8772:43;;;;8831:18;;8824:34;;;8889:2;8874:18;;8867:34;;;8938:15;;;8932:3;8917:19;;8910:44;8653:186:18;::::2;::::0;8678:10:::2;::::0;8653:186:::2;::::0;8655:3:20;8640:19;8653:186:18::2;;;;;;;-1:-1:-1::0;;1701:1:0::1;2628:7;:22:::0;-1:-1:-1;5441:3405:18;;;;-1:-1:-1;5441:3405:18;-1:-1:-1;;;;5441:3405:18:o;15873:266::-;1764:19;:17;:19::i;:::-;15998:1:::1;15991:4;:8;;;:21;;;;;16011:1;16003:5;:9;;;15991:21;:36;;;;;16023:4;16016;:11;;;15991:36;:52;;;;;16039:4;16031:5;:12;;;15991:52;15983:68;;;::::0;-1:-1:-1;;;15983:68:18;;15097:2:20;15983:68:18::1;::::0;::::1;15079:21:20::0;15136:1;15116:18;;;15109:29;-1:-1:-1;;;15154:18:20;;;15147:33;15197:18;;15983:68:18::1;15069:152:20::0;15983:68:18::1;16061:3;:10:::0;;;::::1;-1:-1:-1::0;;;16061:10:18::1;::::0;;::::1;::::0;;::::1;::::0;;;::::1;16081:12:::0;::::1;-1:-1:-1::0;;;16081:12:18;;::::1;::::0;;::::1;;::::0;;;16109:23:::1;::::0;;22439:34:20;;;22504:2;22489:18;;22482:43;;;;16109:23:18::1;::::0;22385:18:20;16109:23:18::1;;;;;;;;15873:266:::0;;:::o;5080:286:19:-;5207:4;719:10:9;5263:38:19;5279:4;719:10:9;5294:6:19;5263:15;:38::i;:::-;5311:27;5321:4;5327:2;5331:6;5311:9;:27::i;:::-;5355:4;5348:11;;;5080:286;;;;;;:::o;8852:2796:18:-;9027:16;1744:1:0;2325:7;;:19;;2317:63;;;;-1:-1:-1;;;2317:63:0;;20794:2:20;2317:63:0;;;20776:21:20;20833:2;20813:18;;;20806:30;20872:33;20852:18;;;20845:61;20923:18;;2317:63:0;20766:181:20;2317:63:0;1744:1;2455:7;:18;9063:13:18;9055:29:::1;;;::::0;-1:-1:-1;;;9055:29:18;;13670:2:20;9055:29:18::1;::::0;::::1;13652:21:20::0;13709:1;13689:18;;;13682:29;-1:-1:-1;;;13727:18:20;;;13720:33;13770:18;;9055:29:18::1;13642:152:20::0;9055:29:18::1;-1:-1:-1::0;;;;;9102:15:18;::::1;::::0;;;;:31:::1;;;9127:6;-1:-1:-1::0;;;;;9121:12:18::1;:2;-1:-1:-1::0;;;;;9121:12:18::1;;;9102:31;:47;;;;;9143:6;-1:-1:-1::0;;;;;9137:12:18::1;:2;-1:-1:-1::0;;;;;9137:12:18::1;;;9102:47;9094:62;;;::::0;-1:-1:-1;;;9094:62:18;;17637:2:20;9094:62:18::1;::::0;::::1;17619:21:20::0;17676:1;17656:18;;;17649:29;-1:-1:-1;;;17694:18:20;;;17687:32;17736:18;;9094:62:18::1;17609:151:20::0;9094:62:18::1;9167:29;9199:171;9244:6;9264;9284:12;;9310;;9336:4;;;;;;;;;;;9354:6;9199:31;:171::i;:::-;9456:7;::::0;;9473:12:::1;::::0;::::1;::::0;9487:17:::1;::::0;::::1;::::0;9442:63:::1;::::0;-1:-1:-1;;;9442:63:18;;-1:-1:-1;;;;;7162:15:20;;;9442:63:18;;::::1;7144:34:20::0;;;;7214:15;;7194:18;;;7187:43;9473:12:18;;-1:-1:-1;9442:89:18;;::::1;::::0;9456:7:::1;::::0;9442:30:::1;::::0;7056:18:20;;9442:63:18::1;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;9442:89:18::1;;9421:140;;;;-1:-1:-1::0;;;9421:140:18::1;;;;;;15428:2:20::0;15410:21;;;15467:1;15447:18;;;15440:29;-1:-1:-1;;;15500:2:20;15485:18;;15478:34;15544:2;15529:18;;15400:153;9421:140:18::1;9593:5;:14;;;9580:9;:27;;9572:43;;;::::0;-1:-1:-1;;;9572:43:18;;19802:2:20;9572:43:18::1;::::0;::::1;19784:21:20::0;19841:1;19821:18;;;19814:29;-1:-1:-1;;;19859:18:20;;;19852:33;19902:18;;9572:43:18::1;19774:152:20::0;9572:43:18::1;9646:12;::::0;;::::1;::::0;-1:-1:-1;;;;;9633:26:18::1;;::::0;;;:12:::1;:26:::0;;;;;;;::::1;;9625:42;;;::::0;-1:-1:-1;;;9625:42:18;;16498:2:20;9625:42:18::1;::::0;::::1;16480:21:20::0;16537:1;16517:18;;;16510:29;-1:-1:-1;;;16555:18:20;;;16548:33;16598:18;;9625:42:18::1;16470:152:20::0;9625:42:18::1;9701:6;-1:-1:-1::0;;;;;9685:22:18::1;:5;:12;;;-1:-1:-1::0;;;;;9685:22:18::1;;:48;;;;9727:6;-1:-1:-1::0;;;;;9711:22:18::1;:5;:12;;;-1:-1:-1::0;;;;;9711:22:18::1;;9685:48;9677:64;;;::::0;-1:-1:-1;;;9677:64:18;;14766:2:20;9677:64:18::1;::::0;::::1;14748:21:20::0;14805:1;14785:18;;;14778:29;-1:-1:-1;;;14823:18:20;;;14816:33;14866:18;;9677:64:18::1;14738:152:20::0;9677:64:18::1;9752:59;9782:5;:12;;;9797:2;9801:9;9752:22;:59::i;:::-;9910:14;::::0;::::1;::::0;9938::::1;::::0;::::1;::::0;9966:4:::1;::::0;9822:24:::1;::::0;9849:131:::1;::::0;9887:9;;-1:-1:-1;;;9966:4:18;::::1;;;9849:24;:131::i;:::-;9822:158:::0;-1:-1:-1;9995:15:18;;9991:213:::1;;10092:12;::::0;::::1;::::0;10122::::1;::::0;;::::1;::::0;10024:180;;-1:-1:-1;;;10024:180:18;;10044:10:::1;::::0;10024:50:::1;::::0;:180:::1;::::0;10152:16;;10186:4;;;;10024:180:::1;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;9991:213;10264:12;::::0;;::::1;::::0;;-1:-1:-1;;;;;10255:22:18::1;;::::0;;;:8:::1;:22:::0;;;;;;;;10239:12;;10226:26:::1;::::0;:12:::1;:26::i;:::-;:51;;;;:::i;:::-;10215:62;;10307:1;10296:8;:12;:44;;;;;10324:16;10312:8;:28;;10296:44;10288:60;;;::::0;-1:-1:-1;;;10288:60:18;;20463:2:20;10288:60:18::1;::::0;::::1;20445:21:20::0;20502:1;20482:18;;;20475:29;-1:-1:-1;;;20520:18:20;;;20513:33;20563:18;;10288:60:18::1;20435:152:20::0;10288:60:18::1;10463:12;::::0;;::::1;::::0;-1:-1:-1;;;;;10454:22:18::1;10426:25;10454:22:::0;;;:8:::1;:22:::0;;;;;;;:33:::1;::::0;10479:8;;10454:33:::1;:::i;:::-;10426:61;;10600:115;10632:17;10663:5;:14;;;10691:5;:14;;;10600:18;:115::i;:::-;10580:135;;10746:6;-1:-1:-1::0;;;;;10730:22:18::1;:5;:12;;;-1:-1:-1::0;;;;;10730:22:18::1;;10726:275;;;10863:127;10899:17;10934:12;;10964;;10863:18;:127::i;:::-;10843:147;;10726:275;11029:12;::::0;;::::1;::::0;;-1:-1:-1;;;;;11011:31:18;;::::1;;::::0;;;:17:::1;:31:::0;;;;;;:51;;;11115:12;;11106:22;;::::1;::::0;;:8:::1;:22:::0;;;;;:34;;11132:8;;11011:31;11106:34:::1;::::0;11132:8;;11106:34:::1;:::i;:::-;::::0;;;-1:-1:-1;11151:51:18::1;::::0;-1:-1:-1;11159:20:18::1;11172:6;11159:12;:20::i;11151:51::-;11213:18;11234:23;:21;:23::i;:::-;11213:44;;11291:15;;11275:13;:31;11267:48;;;;-1:-1:-1::0;;;11267:48:18::1;;;;;;11870:2:20::0;11852:21;;;11909:1;11889:18;;;11882:29;-1:-1:-1;;;11942:2:20;11927:18;;11920:34;11986:2;11971:18;;11842:153;11267:48:18::1;11388:12;::::0;;::::1;::::0;-1:-1:-1;;;;;11402:22:18::1;;::::0;;;:8:::1;:22:::0;;;;;;;;11376:64;;9469:74:20;;;9559:18;;;9552:34;;;;9602:18;;;9595:34;;;11376:64:18::1;::::0;9457:2:20;9442:18;11376:64:18::1;;;;;;;11504:12;::::0;;::::1;::::0;11530::::1;::::0;;::::1;::::0;11455:186;;-1:-1:-1;;;;;8747:15:20;;;8729:34;;8799:15;;;8779:18;;;8772:43;;;;8831:18;;8824:34;;;8889:2;8874:18;;8867:34;;;8938:15;;;8932:3;8917:19;;8910:44;11455:186:18;::::1;::::0;11480:10:::1;::::0;11455:186:::1;::::0;8655:3:20;8640:19;11455:186:18::1;;;;;;;;-1:-1:-1::0;;1701:1:0;2628:7;:22;-1:-1:-1;8852:2796:18;;;-1:-1:-1;;;;;;8852:2796:18:o;5761:258:19:-;719:10:9;5873:4:19;3955:18;;;:11;:18;;;;;;;;-1:-1:-1;;;;;3955:27:19;;;;;;;;;;5873:4;;719:10:9;5927:64:19;;719:10:9;;3955:27:19;;5952:38;;5980:10;;5952:38;:::i;:::-;5927:8;:64::i;11654:412:18:-;11749:14;;;11814:120;11838:9;:16;11834:20;;11814:120;;;11892:17;:31;11910:9;11920:1;11910:12;;;;;;-1:-1:-1;;;11910:12:18;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;11910:12:18;11892:31;;;;;;;;;;;;;11875:48;;;;:::i;:::-;;-1:-1:-1;11856:3:18;;;:::i;:::-;;;11814:120;;;;11968:1;11953:12;;:16;:106;;12058:1;11953:106;;;12030:12;;12026:16;;:1;:16;:::i;:::-;11985:36;705:4;11985:13;:36;:::i;:::-;11984:59;;;;:::i;:::-;11944:115;;11654:412;;:::o;1271:26::-;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;1271:26:18;;-1:-1:-1;1271:26:18;:::o;15344:523::-;1764:19;:17;:19::i;:::-;15483:17:::1;::::0;15462;;15483::::1;::::0;;::::1;-1:-1:-1::0;15462:38:18::1;15454:53;;;::::0;-1:-1:-1;;;15454:53:18;;20133:2:20;15454:53:18::1;::::0;::::1;20115:21:20::0;20172:1;20152:18;;;20145:29;-1:-1:-1;;;20190:18:20;;;20183:32;20232:18;;15454:53:18::1;20105:151:20::0;15454:53:18::1;15518:23;15544:9;15518:35;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;;-1:-1:-1;;;;;15518:35:18::1;::::0;;;;;::::1;::::0;::::1;;::::0;;::::1;;;;;;;;;;;15569:9;15564:87;15588:6;:13;15584:1;:17;15564:87;;;15646:5;15620:12;:23;15633:6;15640:1;15633:9;;;;;;-1:-1:-1::0;;;15633:9:18::1;;;;;;;;;;::::0;;::::1;::::0;;;;;;;-1:-1:-1;;;;;15620:23:18::1;::::0;;;::::1;::::0;;;;;;-1:-1:-1;15620:23:18;:31;;-1:-1:-1;;15620:31:18::1;::::0;::::1;;::::0;;;::::1;::::0;;15603:3:::1;::::0;::::1;:::i;:::-;;;15564:87;;;-1:-1:-1::0;15690:22:18;;::::1;::::0;:9:::1;::::0;:22:::1;::::0;::::1;::::0;::::1;:::i;:::-;;15727:9;15722:94;15746:10;:17;15742:1;:21;15722:94;;;15812:4;15782:12;:27;15795:10;15806:1;15795:13;;;;;;-1:-1:-1::0;;;15795:13:18::1;;;;;;;;;;::::0;;::::1;::::0;;;;;;;-1:-1:-1;;;;;15782:27:18::1;::::0;;;::::1;::::0;;;;;;-1:-1:-1;15782:27:18;:34;;-1:-1:-1;;15782:34:18::1;::::0;::::1;;::::0;;;::::1;::::0;;15765:3:::1;::::0;::::1;:::i;:::-;;;15722:94;;;;15832:28;15849:10;15832:28;;;;;;:::i;12072:1349::-:0;12152:17;1744:1:0;2325:7;;:19;;2317:63;;;;-1:-1:-1;;;2317:63:0;;20794:2:20;2317:63:0;;;20776:21:20;20833:2;20813:18;;;20806:30;20872:33;20852:18;;;20845:61;20923:18;;2317:63:0;20766:181:20;2317:63:0;1744:1;2455:7;:18;12244:12:18::1;::::0;12270::::1;::::0;12182:21:::1;12328:20;12341:6;12328:12;:20::i;:::-;12302:46;;12358:23;12384:20;12397:6;12384:12;:20::i;:::-;12358:46:::0;-1:-1:-1;12414:15:18::1;12432:31;12450:13:::0;12432:15;:31:::1;:::i;:::-;12414:49:::0;-1:-1:-1;12473:15:18::1;12491:31;12509:13:::0;12491:15;:31:::1;:::i;:::-;12473:49;;12533:20;12556:13;3137:12:19::0;;3050:106;;12556:13:18::1;12533:36:::0;-1:-1:-1;12583:17:18;12579:394:::1;;705:4;12628:28;12638:17;12648:7:::0;12638;:17:::1;:::i;:::-;12628:9;:28::i;:::-;:48;;;;:::i;:::-;12616:60:::0;-1:-1:-1;12690:36:18::1;12704:1;705:4;12690:5;:36::i;:::-;12579:394;;;12824:138;12877:13:::0;12851:22:::1;12861:12:::0;12851:7;:22:::1;:::i;:::-;12850:40;;;;:::i;:::-;12935:13:::0;12909:22:::1;12919:12:::0;12909:7;:22:::1;:::i;:::-;12908:40;;;;:::i;:::-;12824:8;:138::i;:::-;12812:150;;12579:394;13057:20;13080:23;:21;:23::i;:::-;13057:46:::0;-1:-1:-1;13188:35:18::1;13057:46:::0;705:4:::1;13188:35;:::i;:::-;13139:32;705:4;13139:9:::0;:32:::1;:::i;:::-;13138:86;;;;:::i;:::-;13114:110;;13255:1;13243:9;:13;13235:29;;;::::0;-1:-1:-1;;;13235:29:18;;21512:2:20;13235:29:18::1;::::0;::::1;21494:21:20::0;21551:1;21531:18;;;21524:29;-1:-1:-1;;;21569:18:20;;;21562:33;21612:18;;13235:29:18::1;21484:152:20::0;13235:29:18::1;13275:20;13281:2;13285:9;13275:5;:20::i;:::-;13306:41;13314:15;13331;13306:7;:41::i;:::-;13367:2;-1:-1:-1::0;;;;;13362:52:18::1;;13371:7;13380;13389:9;13400:13;3137:12:19::0;;3050:106;;13400:13:18::1;13362:52;::::0;;23526:25:20;;;23582:2;23567:18;;23560:34;;;;23610:18;;;23603:34;23668:2;23653:18;;23646:34;23513:3;23498:19;13362:52:18::1;;;;;;;-1:-1:-1::0;;1701:1:0;2628:7;:22;-1:-1:-1;12072:1349:18;;;-1:-1:-1;;;;;;12072:1349:18:o;3214:139:19:-;-1:-1:-1;;;;;3328:18:19;;3302:7;3328:18;;;;;;;;;;;3214:139;;;;:::o;13427:1911:18:-;13539:15;13556;1744:1:0;2325:7;;:19;;2317:63;;;;-1:-1:-1;;;2317:63:0;;20794:2:20;2317:63:0;;;20776:21:20;20833:2;20813:18;;;20806:30;20872:33;20852:18;;;20845:61;20923:18;;2317:63:0;20766:181:20;2317:63:0;1744:1;2455:7;:18;13605:6:18::1;13654;13587:15;13704:21;13605:6:::0;13704:12:::1;:21::i;:::-;13685:40;;13735:16;13754:21;13767:7;13754:12;:21::i;:::-;13735:40;;13785:17;13805:27;13826:4;13805:12;:27::i;:::-;13785:47;;13843:20;13866:13;3137:12:19::0;;3050:106;;13866:13:18::1;13843:36:::0;-1:-1:-1;13843:36:18;13900:20:::1;13911:9:::0;13900:8;:20:::1;:::i;:::-;13899:37;;;;:::i;:::-;13889:47:::0;-1:-1:-1;13981:12:18;13957:20:::1;13968:9:::0;13957:8;:20:::1;:::i;:::-;13956:37;;;;:::i;:::-;13946:47;;14022:1;14012:7;:11;:26;;;;;14037:1;14027:7;:11;14012:26;14004:42;;;::::0;-1:-1:-1;;;14004:42:18;;16167:2:20;14004:42:18::1;::::0;::::1;16149:21:20::0;16206:1;16186:18;;;16179:29;-1:-1:-1;;;16224:18:20;;;16217:33;16267:18;;14004:42:18::1;16139:152:20::0;14004:42:18::1;14057:31;14071:4;14078:9;14057:5;:31::i;:::-;14098:52;14128:7;14138:2;14142:7;14098:22;:52::i;:::-;14160;14190:7;14200:2;14204:7;14160:22;:52::i;:::-;14285:28;14316:23;:21;:23::i;:::-;14285:54:::0;-1:-1:-1;14353:24:18;;14349:807:::1;;14398:9;14393:753;14417:9;:16:::0;14413:20;::::1;14393:753;;;14458:12;14473:9;14483:1;14473:12;;;;;;-1:-1:-1::0;;;14473:12:18::1;;;;;;;;;;::::0;;;::::1;::::0;;;;;::::1;::::0;-1:-1:-1;;;;;14473:12:18::1;14528:14:::0;;;:8:::1;:14:::0;;;;;;;;14473:12;;-1:-1:-1;14565:18:18;;14561:571:::1;;14607:24;14689:12:::0;14635:26:::1;14652:9:::0;14635:14;:26:::1;:::i;:::-;14634:67;;;;:::i;:::-;14607:94;;14724:58;14754:4;14761:2;14765:16;14724:22;:58::i;:::-;-1:-1:-1::0;;;;;14835:23:18;::::1;14805:27;14835:23:::0;;;:17:::1;:23;::::0;;;;;15027:12;14992:31:::1;15014:9:::0;14835:23;14992:31:::1;:::i;:::-;14991:48;;;;:::i;:::-;14944:96;::::0;:19;:96:::1;:::i;:::-;-1:-1:-1::0;;;;;14894:23:18;::::1;;::::0;;;:17:::1;:23;::::0;;;;:146;15080:33:::1;15097:16:::0;15080:14;:33:::1;:::i;:::-;-1:-1:-1::0;;;;;15063:14:18;::::1;;::::0;;;:8:::1;:14;::::0;;;;:50;-1:-1:-1;;14561:571:18::1;14393:753;;14435:3;;;;:::i;:::-;;;14393:753;;;;14349:807;15177:21;15190:7;15177:12;:21::i;:::-;15166:32;;15219:21;15232:7;15219:12;:21::i;:::-;15208:32;;15251:27;15259:8;15269;15251:7;:27::i;:::-;15293:38;::::0;;22892:25:20;;;22948:2;22933:18;;22926:34;;;-1:-1:-1;;;;;15293:38:18;::::1;::::0;15298:10:::1;::::0;15293:38:::1;::::0;22865:18:20;15293:38:18::1;;;;;;;2484:1:0;;;;;;;1701::::0;2628:7;:22;;;;13427:1911:18;;;:::o;6506:485:19:-;719:10:9;6623:4:19;3955:18;;;:11;:18;;;;;;;;-1:-1:-1;;;;;3955:27:19;;;;;;;;;;6623:4;;719:10:9;6760:35:19;;;;6739:119;;;;-1:-1:-1;;;6739:119:19;;21843:2:20;6739:119:19;;;21825:21:20;21882:2;21862:18;;;21855:30;21921:34;21901:18;;;21894:62;21992:7;21972:18;;;21965:35;22017:19;;6739:119:19;21815:227:20;6739:119:19;6892:60;6901:5;6908:7;6936:15;6917:16;:34;6892:8;:60::i;:::-;-1:-1:-1;6980:4:19;;6506:485;-1:-1:-1;;;;6506:485:19:o;16145:233:18:-;1764:19;:17;:19::i;:::-;16275:1:::1;16263:9;:13;16255:29;;;::::0;-1:-1:-1;;;16255:29:18;;12202:2:20;16255:29:18::1;::::0;::::1;12184:21:20::0;12241:1;12221:18;;;12214:29;-1:-1:-1;;;12259:18:20;;;12252:33;12302:18;;16255:29:18::1;12174:152:20::0;16255:29:18::1;16294:15;:27:::0;;;16337:34:::1;::::0;22682:25:20;;;16337:34:18::1;::::0;22670:2:20;22655:18;16337:34:18::1;;;;;;;;16145:233:::0;:::o;3549:211:19:-;3650:4;719:10:9;3704:28:19;719:10:9;3721:2:19;3725:6;3704:9;:28::i;16384:217:18:-;1764:19;:17;:19::i;:::-;16500:17:::1;:38:::0;;-1:-1:-1;;16500:38:18::1;;::::0;::::1;::::0;;::::1;::::0;;;16553:41:::1;::::0;22191:40:20;;;16553:41:18::1;::::0;22179:2:20;22164:18;16553:41:18::1;22146:91:20::0;3707:1728:18;3875:17;1744:1:0;2325:7;;:19;;2317:63;;;;-1:-1:-1;;;2317:63:0;;20794:2:20;2317:63:0;;;20776:21:20;20833:2;20813:18;;;20806:30;20872:33;20852:18;;;20845:61;20923:18;;2317:63:0;20766:181:20;2317:63:0;1744:1;2455:7;:18;-1:-1:-1;;;;;3912:15:18;::::1;::::0;;;;:31:::1;;;3937:6;-1:-1:-1::0;;;;;3931:12:18::1;:2;-1:-1:-1::0;;;;;3931:12:18::1;;;3912:31;:47;;;;;3953:6;-1:-1:-1::0;;;;;3947:12:18::1;:2;-1:-1:-1::0;;;;;3947:12:18::1;;;3912:47;3904:62;;;::::0;-1:-1:-1;;;3904:62:18;;17637:2:20;3904:62:18::1;::::0;::::1;17619:21:20::0;17676:1;17656:18;;;17649:29;-1:-1:-1;;;17694:18:20;;;17687:32;17736:18;;3904:62:18::1;17609:151:20::0;3904:62:18::1;3996:6;-1:-1:-1::0;;;;;3984:18:18::1;:8;-1:-1:-1::0;;;;;3984:18:18::1;;:40;;;;4018:6;-1:-1:-1::0;;;;;4006:18:18::1;:8;-1:-1:-1::0;;;;;4006:18:18::1;;3984:40;3976:56;;;::::0;-1:-1:-1;;;3976:56:18;;14766:2:20;3976:56:18::1;::::0;::::1;14748:21:20::0;14805:1;14785:18;;;14778:29;-1:-1:-1;;;14823:18:20;;;14816:33;14866:18;;3976:56:18::1;14738:152:20::0;3976:56:18::1;4062:1;4050:9;:13;4042:29;;;::::0;-1:-1:-1;;;4042:29:18;;13670:2:20;4042:29:18::1;::::0;::::1;13652:21:20::0;13709:1;13689:18;;;13682:29;-1:-1:-1;;;13727:18:20;;;13720:33;13770:18;;4042:29:18::1;13642:152:20::0;4042:29:18::1;4082:55;4112:8;4123:2;4127:9;4082:22;:55::i;:::-;4148:16;4179:6;-1:-1:-1::0;;;;;4167:18:18::1;:8;-1:-1:-1::0;;;;;4167:18:18::1;;:36;;4197:6;4167:36;;;4188:6;4167:36;4148:55;;4215:18;4235:19:::0;4258:129:::1;4297:8;4319:6;4339:12;;4365;;4258:25;:129::i;:::-;4214:173;;;;4419:11;4406:9;:24;;4398:40;;;::::0;-1:-1:-1;;;4398:40:18;;19802:2:20;4398:40:18::1;::::0;::::1;19784:21:20::0;19841:1;19821:18;;;19814:29;-1:-1:-1;;;19859:18:20;;;19852:33;19902:18;;4398:40:18::1;19774:152:20::0;4398:40:18::1;4449:24;4476:123;4514:9;4537:10;4561:11;4586:3;;;;;;;;;;;4476:123;;:24;:123::i;:::-;4449:150:::0;-1:-1:-1;4614:15:18;;4610:218:::1;;4645:172;::::0;-1:-1:-1;;;4645:172:18;;4665:10:::1;::::0;4645:50:::1;::::0;:172:::1;::::0;4713:8;;4739;;4765:16;;4799:4;;;;4645:172:::1;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;4610:218;4875:10;4850:22;4863:8;4850:12;:22::i;:::-;:35;;;;:::i;:::-;4838:47;;4916:1;4904:9;:13;:46;;;;;4934:16;4921:9;:29;;4904:46;4896:62;;;::::0;-1:-1:-1;;;4896:62:18;;20463:2:20;4896:62:18::1;::::0;::::1;20445:21:20::0;20502:1;20482:18;;;20475:29;-1:-1:-1;;;20520:18:20;;;20513:33;20563:18;;4896:62:18::1;20435:152:20::0;4896:62:18::1;5018:16;5049:6;-1:-1:-1::0;;;;;5037:18:18::1;:8;-1:-1:-1::0;;;;;5037:18:18::1;;5018:37;;5070:181;5095:11;:62;;5134:23;5148:9:::0;5134:11;:23:::1;:::i;:::-;5095:62;;;5109:22;5122:9:::0;5109:10;:22:::1;:::i;:::-;5175:11;:62;;5215:22;5228:9:::0;5215:10;:22:::1;:::i;:::-;5175:62;;;5189:23;5203:9:::0;5189:11;:23:::1;:::i;5070:181::-;-1:-1:-1::0;5277:151:18::1;::::0;;-1:-1:-1;;;;;8244:15:20;;;8226:34;;8296:15;;;8291:2;8276:18;;8269:43;8328:18;;;8321:34;;;8386:2;8371:18;;8364:34;;;5277:151:18;;::::1;::::0;5295:10:::1;::::0;5277:151:::1;::::0;8152:3:20;8137:19;5277:151:18::1;8119:285:20::0;10434:370:19;-1:-1:-1;;;;;10565:19:19;;10557:68;;;;-1:-1:-1;;;10557:68:19;;17967:2:20;10557:68:19;;;17949:21:20;18006:2;17986:18;;;17979:30;18045:34;18025:18;;;18018:62;-1:-1:-1;;;18096:18:20;;;18089:34;18140:19;;10557:68:19;17939:226:20;10557:68:19;-1:-1:-1;;;;;10643:21:19;;10635:68;;;;-1:-1:-1;;;10635:68:19;;13267:2:20;10635:68:19;;;13249:21:20;13306:2;13286:18;;;13279:30;13345:34;13325:18;;;13318:62;-1:-1:-1;;;13396:18:20;;;13389:32;13438:19;;10635:68:19;13239:224:20;10635:68:19;-1:-1:-1;;;;;10714:18:19;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;:36;;;10765:32;;22682:25:20;;;10765:32:19;;22655:18:20;10765:32:19;;;;;;;10434:370;;;:::o;4282:512:16:-;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4425:11:16;4438;4460:6;-1:-1:-1;;;;;4453:24:16;;:26;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;4424:55;;;;4490:17;4509;4539:6;-1:-1:-1;;;;;4532:43:16;;:45;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;4489:88;;;;;4587:11;4608:6;-1:-1:-1;;;;;4601:19:16;;:21;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;4587:35;;4641:146;4673:3;4690;4707:9;4730;4753:4;4771:6;4641:18;:146::i;:::-;4633:154;4282:512;-1:-1:-1;;;;;;;;4282:512:16:o;763:205:7:-;902:58;;;-1:-1:-1;;;;;9157:55:20;;902:58:7;;;9139:74:20;9229:18;;;;9222:34;;;902:58:7;;;;;;;;;;9112:18:20;;;;902:58:7;;;;;;;;;;-1:-1:-1;;;902:58:7;;;875:86;;895:5;;875:19;:86::i;:::-;763:205;;;:::o;2344:336:16:-;2465:15;2510:1;2500:7;:11;2492:50;;;;-1:-1:-1;;;2492:50:16;;11515:2:20;2492:50:16;;;11497:21:20;11554:2;11534:18;;;11527:30;11593:28;11573:18;;;11566:56;11639:18;;2492:50:16;11487:176:20;2492:50:16;2571:1;2560:8;:12;:28;;;;;2587:1;2576:8;:12;2560:28;2552:70;;;;-1:-1:-1;;;2552:70:16;;21154:2:20;2552:70:16;;;21136:21:20;21193:2;21173:18;;;21166:30;21232:31;21212:18;;;21205:59;21281:18;;2552:70:16;21126:179:20;2552:70:16;2665:8;2643:18;2653:8;2643:7;:18;:::i;:::-;2642:31;;;;:::i;:::-;2632:41;2344:336;-1:-1:-1;;;;2344:336:16:o;2064:370:18:-;2209:117;;;2307:4;2209:117;;;;6824:74:20;;;;2209:117:18;;;;;;;;;;6797:18:20;;;;2209:117:18;;;;;;;;;-1:-1:-1;;;2209:117:18;;;2179:157;;2124:7;;;;;;-1:-1:-1;;;;;2179:16:18;;;:157;;2209:117;2179:157;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2143:193;;;;2354:7;:28;;;;;2380:2;2365:4;:11;:17;;2354:28;2346:37;;;;;;2411:4;2400:27;;;;;;;;;;;;:::i;2699:350::-;2790:17;;2775:12;:32;2771:170;;;2843:17;2823:61;;;2824:17;2823:61;;;2918:12;2898:17;:32;2771:170;2966:12;2951:51;;;2952:12;2951:51;;;3018:24;;;22892:25:20;;;22948:2;22933:18;;22926:34;;;3018:24:18;;22865:18:20;3018:24:18;22847:119:20;1526:194:18;1628:7;;;1614:30;;;-1:-1:-1;;;1614:30:18;;;;-1:-1:-1;;;;;1628:7:18;;;;1614:28;;:30;;;;;;;;;;;;1628:7;1614:30;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;1600:44:18;:10;-1:-1:-1;;;;;1600:44:18;;:85;;;-1:-1:-1;1678:7:18;;-1:-1:-1;;;;;1678:7:18;1664:10;:21;1600:85;1579:134;;;;-1:-1:-1;;;1579:134:18;;19472:2:20;1579:134:18;;;19454:21:20;19511:1;19491:18;;;19484:29;-1:-1:-1;;;19529:18:20;;;19522:32;19571:18;;1579:134:18;19444:151:20;1579:134:18;1526:194::o;11085:487:19:-;-1:-1:-1;;;;;3955:18:19;;;11215:24;3955:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;-1:-1:-1;;11281:37:19;;11277:289;;11379:6;11359:16;:26;;11334:114;;;;-1:-1:-1;;;11334:114:19;;14001:2:20;11334:114:19;;;13983:21:20;14040:2;14020:18;;;14013:30;14079:31;14059:18;;;14052:59;14128:18;;11334:114:19;13973:179:20;11334:114:19;11490:51;11499:5;11506:7;11534:6;11515:16;:25;11490:8;:51::i;:::-;11085:487;;;;:::o;7445:852::-;-1:-1:-1;;;;;7571:18:19;;7563:68;;;;-1:-1:-1;;;7563:68:19;;17231:2:20;7563:68:19;;;17213:21:20;17270:2;17250:18;;;17243:30;17309:34;17289:18;;;17282:62;17380:7;17360:18;;;17353:35;17405:19;;7563:68:19;17203:227:20;7563:68:19;-1:-1:-1;;;;;7649:16:19;;7641:64;;;;-1:-1:-1;;;7641:64:19;;11111:2:20;7641:64:19;;;11093:21:20;11150:2;11130:18;;;11123:30;11189:34;11169:18;;;11162:62;-1:-1:-1;;;11240:18:20;;;11233:33;11283:19;;7641:64:19;11083:225:20;7641:64:19;-1:-1:-1;;;;;7787:15:19;;7765:19;7787:15;;;;;;;;;;;7833:21;;;;7812:106;;;;-1:-1:-1;;;7812:106:19;;14359:2:20;7812:106:19;;;14341:21:20;14398:2;14378:18;;;14371:30;14437:34;14417:18;;;14410:62;14508:8;14488:18;;;14481:36;14534:19;;7812:106:19;14331:228:20;7812:106:19;-1:-1:-1;;;;;7952:15:19;;;:9;:15;;;;;;;;;;;7970:20;;;7952:38;;8167:13;;;;;;;;;;:23;;;;;;8216:26;;22682:25:20;;;8167:13:19;;8216:26;;22655:18:20;8216:26:19;;;;;;;8253:37;763:205:7;3041:1235:16;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3295:11:16;3308;3330:6;-1:-1:-1;;;;;3323:24:16;;:26;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;3294:55;;-1:-1:-1;3294:55:16;-1:-1:-1;3389:8:16;3399;3360:11;3471:93;3294:55;;3389:8;3399;3471:15;:93::i;:::-;3432:132;;3602:11;:15;;;-1:-1:-1;;;;;3583:34:16;:11;:15;;;-1:-1:-1;;;;;3583:34:16;;3575:50;;;;-1:-1:-1;;;3575:50:16;;18730:2:20;3575:50:16;;;18712:21:20;18769:1;18749:18;;;18742:29;-1:-1:-1;;;18787:18:20;;;18780:33;18830:18;;3575:50:16;18702:152:20;3575:50:16;3637:18;3657;3688:6;-1:-1:-1;;;;;3681:43:16;;:45;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;3636:90;;;;;3738:19;3759;3783:10;3795;3737:69;;;;3838:276;3885:3;-1:-1:-1;;;;;3866:22:16;:11;:15;;;-1:-1:-1;;;;;3866:22:16;;:48;;3904:10;3866:48;;;3891:10;3866:48;3947:3;-1:-1:-1;;;;;3928:22:16;:11;:15;;;-1:-1:-1;;;;;3928:22:16;;:48;;3966:10;3928:48;;;3953:10;3928:48;4009:3;-1:-1:-1;;;;;3990:22:16;:11;:15;;;-1:-1:-1;;;;;3990:22:16;;:50;;4029:11;3990:50;;;4015:11;3990:50;4073:3;-1:-1:-1;;;;;4054:22:16;:11;:15;;;-1:-1:-1;;;;;4054:22:16;;:50;;4093:11;4054:50;;;4079:11;4054:50;3838:14;:276::i;:::-;4140:15;;;;;-1:-1:-1;;;;;4125:30:16;;;:12;;;:30;4180:15;;4165:30;;:12;;;:30;;;;4225:15;;;;;4205:35;;;:17;;;:35;-1:-1:-1;;;4251:18:16;;;;;;3830:284;3041:1235;-1:-1:-1;;;;;;;;;;;3041:1235:16:o;1514:378::-;1675:16;;248:7;1724:25;1740:9;1724:13;:25;:::i;:::-;1723:46;;;;:::i;:::-;1703:66;-1:-1:-1;1779:19:16;1832:3;1802:26;1819:9;1802:14;:26;:::i;:::-;1801:34;;;;:::i;:::-;1779:56;-1:-1:-1;1857:23:16;1779:56;1857:9;:23;:::i;:::-;1856:29;;1884:1;1856:29;:::i;:::-;1845:40;1514:378;-1:-1:-1;;;;;;;1514:378:16:o;6281:2206:10:-;6329:7;6352:6;6348:45;;-1:-1:-1;6381:1:10;6374:8;;6348:45;7075:1;7098;7118:3;7113:8;;;:12;7109:79;;7175:2;7164:13;;;;;7147:3;7141:9;7109:79;7206:2;7201:7;;;:11;7197:77;;7261:2;7250:13;;;;;7234:2;7228:8;7197:77;7292:2;7287:7;;;:11;7283:77;;7347:2;7336:13;;;;;7320:2;7314:8;7283:77;7378:2;7373:7;;;:11;7369:76;;7433:1;7422:12;;;;;7406:2;7400:8;7369:76;7463:1;7458:6;;;:10;7454:74;;7516:1;7505:12;;;;;7490:1;7484:7;7454:74;7546:1;7541:6;;;:10;7537:74;;7599:1;7588:12;;;;;7573:1;7567:7;7537:74;7629:1;7624:6;;;:10;7620:53;;7661:1;7650:12;;;;;7620:53;8131:1;8120:6;8116:1;:10;;;-1:-1:-1;;;8116:10:10;;;;;;;;;;8107:6;:19;8106:26;;8097:35;;8180:1;8169:6;8165:1;:10;;;-1:-1:-1;;;8165:10:10;;;;;;;;;;8156:6;:19;8155:26;;8146:35;;8229:1;8218:6;8214:1;:10;;;-1:-1:-1;;;8214:10:10;;;;;;;;;;8205:6;:19;8204:26;;8195:35;;8278:1;8267:6;8263:1;:10;;;-1:-1:-1;;;8263:10:10;;;;;;;;;;8254:6;:19;8253:26;;8244:35;;8327:1;8316:6;8312:1;:10;;;-1:-1:-1;;;8312:10:10;;;;;;;;;;8303:6;:19;8302:26;;8293:35;;8376:1;8365:6;8361:1;:10;;;-1:-1:-1;;;8361:10:10;;;;;;;;;;8352:6;:19;8351:26;;8342:35;;8425:1;8414:6;8410:1;:10;;;-1:-1:-1;;;8410:10:10;;;;;;;;;;8401:6;:19;8400:26;;8391:35;;8447:23;8451:6;8463;8459:1;:10;;;-1:-1:-1;;;8459:10:10;;;;;;;;;;8447:3;:23::i;8573:459:19:-;8724:6;8708:12;;:22;;;;;;;:::i;:::-;;;;-1:-1:-1;;;;;;;8876:18:19;;:9;:18;;;;;;;;;;;:28;;;;;;8929:37;22682:25:20;;;8929:37:19;;22655:18:20;8929:37:19;;;;;;;8573:459;;:::o;589:104:10:-;647:7;677:1;673;:5;:13;;685:1;673:13;;;-1:-1:-1;681:1:10;;666:20;-1:-1:-1;589:104:10:o;9352:659:19:-;-1:-1:-1;;;;;9435:21:19;;9427:67;;;;-1:-1:-1;;;9427:67:19;;16829:2:20;9427:67:19;;;16811:21:20;16868:2;16848:18;;;16841:30;16907:34;16887:18;;;16880:62;-1:-1:-1;;;16958:18:20;;;16951:31;16999:19;;9427:67:19;16801:223:20;9427:67:19;-1:-1:-1;;;;;9590:18:19;;9565:22;9590:18;;;;;;;;;;;9626:24;;;;9618:71;;;;-1:-1:-1;;;9618:71:19;;12533:2:20;9618:71:19;;;12515:21:20;12572:2;12552:18;;;12545:30;12611:34;12591:18;;;12584:62;-1:-1:-1;;;12662:18:20;;;12655:32;12704:19;;9618:71:19;12505:224:20;9618:71:19;-1:-1:-1;;;;;9723:18:19;;:9;:18;;;;;;;;;;;9744:23;;;9723:44;;9860:12;:22;;;;;;;9908:37;22682:25:20;;;9723:9:19;;:18;9908:37;;22655:18:20;9908:37:19;;;;;;;9956:48;763:205:7;2686:349:16;2849:17;2868;2935:7;-1:-1:-1;;;;;2922:20:16;:9;-1:-1:-1;;;;;2922:20:16;;:106;;3001:12;3015;2922:106;;;2958:12;2972;2922:106;2897:131;;;;-1:-1:-1;2686:349:16;-1:-1:-1;;;;;2686:349:16:o;3747:706:7:-;4166:23;4192:69;4220:4;4192:69;;;;;;;;;;;;;;;;;4200:5;-1:-1:-1;;;;;4192:27:7;;;:69;;;;;:::i;:::-;4275:17;;4166:95;;-1:-1:-1;4275:21:7;4271:176;;4370:10;4359:30;;;;;;;;;;;;:::i;:::-;4351:85;;;;-1:-1:-1;;;4351:85:7;;19061:2:20;4351:85:7;;;19043:21:20;19100:2;19080:18;;;19073:30;19139:34;19119:18;;;19112:62;19210:12;19190:18;;;19183:40;19240:19;;4351:85:7;19033:232:20;322:668:16;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;670:8:16;-1:-1:-1;;;;;658:20:16;:8;-1:-1:-1;;;;;658:20:16;;657:316;;762:8;-1:-1:-1;;;;;750:20:16;:8;-1:-1:-1;;;;;750:20:16;;749:224;;854:8;-1:-1:-1;;;;;842:20:16;:8;-1:-1:-1;;;;;842:20:16;;841:132;;934:8;944;954;964;841:132;;;879:8;889;899;909;841:132;749:224;;;787:8;797;807;817;749:224;657:316;;;695:8;705;715;725;657:316;-1:-1:-1;;;;;528:445:16;;;629:15;;;528:445;;;;;;;;;571:15;;;528:445;;542:15;;;528:445;542:11;322:668;-1:-1:-1;;;;322:668:16:o;996:512::-;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1328:28:16;1337:15;1354:1;1328:8;:28::i;:::-;1270:42;1279:15;1296;1270:8;:42::i;:::-;1252:60;;:15;:60;:::i;:::-;1251:105;;;;:::i;:::-;1222:14;;;:134;1473:28;1482:15;1499:1;1473:8;:28::i;:::-;1415:42;1424:15;1441;1415:8;:42::i;:::-;1397:60;;:15;:60;:::i;:::-;1396:105;;;;:::i;:::-;1367:14;;;:134;:5;996:512;-1:-1:-1;;;;996:512:16:o;3861:223:8:-;3994:12;4025:52;4047:6;4055:4;4061:1;4064:12;4025:21;:52::i;413:105:10:-;471:7;502:1;497;:6;;:14;;510:1;497:14;;4948:499:8;5113:12;5170:5;5145:21;:30;;5137:81;;;;-1:-1:-1;;;5137:81:8;;15760:2:20;5137:81:8;;;15742:21:20;15799:2;15779:18;;;15772:30;15838:34;15818:18;;;15811:62;15909:8;15889:18;;;15882:36;15935:19;;5137:81:8;15732:228:20;5137:81:8;-1:-1:-1;;;;;1465:19:8;;;5228:60;;;;-1:-1:-1;;;5228:60:8;;18372:2:20;5228:60:8;;;18354:21:20;18411:2;18391:18;;;18384:30;18450:31;18430:18;;;18423:59;18499:18;;5228:60:8;18344:179:20;5228:60:8;5300:12;5314:23;5341:6;-1:-1:-1;;;;;5341:11:8;5360:5;5367:4;5341:31;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5299:73;;;;5389:51;5406:7;5415:10;5427:12;7707;7735:7;7731:566;;;-1:-1:-1;7765:10:8;7758:17;;7731:566;7876:17;;:21;7872:415;;8120:10;8114:17;8180:15;8167:10;8163:2;8159:19;8152:44;8069:145;8259:12;8252:20;;-1:-1:-1;;;8252:20:8;;;;;;;;:::i;-1:-1:-1:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;14:134:20;82:20;;111:31;82:20;111:31;:::i;153:257::-;;265:2;253:9;244:7;240:23;236:32;233:2;;;286:6;278;271:22;233:2;330:9;317:23;349:31;374:5;349:31;:::i;415:261::-;;538:2;526:9;517:7;513:23;509:32;506:2;;;559:6;551;544:22;506:2;596:9;590:16;615:31;640:5;615:31;:::i;681:398::-;;;810:2;798:9;789:7;785:23;781:32;778:2;;;831:6;823;816:22;778:2;875:9;862:23;894:31;919:5;894:31;:::i;:::-;944:5;-1:-1:-1;1001:2:20;986:18;;973:32;1014:33;973:32;1014:33;:::i;:::-;1066:7;1056:17;;;768:311;;;;;:::o;1084:395::-;;;1224:2;1212:9;1203:7;1199:23;1195:32;1192:2;;;1245:6;1237;1230:22;1192:2;1282:9;1276:16;1301:31;1326:5;1301:31;:::i;:::-;1401:2;1386:18;;1380:25;1351:5;;-1:-1:-1;1414:33:20;1380:25;1414:33;:::i;1484:466::-;;;;1630:2;1618:9;1609:7;1605:23;1601:32;1598:2;;;1651:6;1643;1636:22;1598:2;1695:9;1682:23;1714:31;1739:5;1714:31;:::i;:::-;1764:5;-1:-1:-1;1821:2:20;1806:18;;1793:32;1834:33;1793:32;1834:33;:::i;:::-;1588:362;;1886:7;;-1:-1:-1;;;1940:2:20;1925:18;;;;1912:32;;1588:362::o;1955:325::-;;;2084:2;2072:9;2063:7;2059:23;2055:32;2052:2;;;2105:6;2097;2090:22;2052:2;2149:9;2136:23;2168:31;2193:5;2168:31;:::i;:::-;2218:5;2270:2;2255:18;;;;2242:32;;-1:-1:-1;;;2042:238:20:o;2285:1178::-;;2400:2;2443;2431:9;2422:7;2418:23;2414:32;2411:2;;;2464:6;2456;2449:22;2411:2;2509:9;2496:23;2538:18;2579:2;2571:6;2568:14;2565:2;;;2600:6;2592;2585:22;2565:2;2643:6;2632:9;2628:22;2618:32;;2688:7;2681:4;2677:2;2673:13;2669:27;2659:2;;2715:6;2707;2700:22;2659:2;2756;2743:16;2778:2;2774;2771:10;2768:2;;;2784:18;;:::i;:::-;2831:2;2827;2823:11;2863:2;2857:9;2926:2;2922:7;2917:2;2913;2909:11;2905:25;2897:6;2893:38;2981:6;2969:10;2966:22;2961:2;2949:10;2946:18;2943:46;2940:2;;;2992:18;;:::i;:::-;3028:2;3021:22;3078:18;;;3112:15;;;;-1:-1:-1;3147:11:20;;;3177;;;3173:20;;3170:33;-1:-1:-1;3167:2:20;;;3221:6;3213;3206:22;3167:2;3248:6;3239:15;;3263:169;3277:2;3274:1;3271:9;3263:169;;;3334:23;3353:3;3334:23;:::i;:::-;3322:36;;3295:1;3288:9;;;;;3378:12;;;;3410;;3263:169;;;-1:-1:-1;3451:6:20;2380:1083;-1:-1:-1;;;;;;;;2380:1083:20:o;3468:297::-;;3588:2;3576:9;3567:7;3563:23;3559:32;3556:2;;;3609:6;3601;3594:22;3556:2;3646:9;3640:16;3699:5;3692:13;3685:21;3678:5;3675:32;3665:2;;3726:6;3718;3711:22;3770:255;;3881:2;3869:9;3860:7;3856:23;3852:32;3849:2;;;3902:6;3894;3887:22;3849:2;3946:9;3933:23;3965:30;3989:5;3965:30;:::i;4030:259::-;;4152:2;4140:9;4131:7;4127:23;4123:32;4120:2;;;4173:6;4165;4158:22;4120:2;4210:9;4204:16;4229:30;4253:5;4229:30;:::i;4294:394::-;;;4421:2;4409:9;4400:7;4396:23;4392:32;4389:2;;;4442:6;4434;4427:22;4389:2;4486:9;4473:23;4505:30;4529:5;4505:30;:::i;:::-;4554:5;-1:-1:-1;4611:2:20;4596:18;;4583:32;4624;4583;4624;:::i;4693:190::-;;4805:2;4793:9;4784:7;4780:23;4776:32;4773:2;;;4826:6;4818;4811:22;4773:2;-1:-1:-1;4854:23:20;;4763:120;-1:-1:-1;4763:120:20:o;4888:194::-;;5011:2;4999:9;4990:7;4986:23;4982:32;4979:2;;;5032:6;5024;5017:22;4979:2;-1:-1:-1;5060:16:20;;4969:113;-1:-1:-1;4969:113:20:o;5087:986::-;;;;;;5269:3;5257:9;5248:7;5244:23;5240:33;5237:2;;;5291:6;5283;5276:22;5237:2;5332:9;5319:23;5309:33;;5392:2;5381:9;5377:18;5364:32;5405:31;5430:5;5405:31;:::i;:::-;5455:5;-1:-1:-1;5512:2:20;5497:18;;5484:32;5525:33;5484:32;5525:33;:::i;:::-;5577:7;-1:-1:-1;5635:2:20;5620:18;;5607:32;5658:18;5688:14;;;5685:2;;;5720:6;5712;5705:22;5685:2;5763:6;5752:9;5748:22;5738:32;;5808:7;5801:4;5797:2;5793:13;5789:27;5779:2;;5835:6;5827;5820:22;5779:2;5880;5867:16;5906:2;5898:6;5895:14;5892:2;;;5927:6;5919;5912:22;5892:2;5977:7;5972:2;5963:6;5959:2;5955:15;5951:24;5948:37;5945:2;;;6003:6;5995;5988:22;5945:2;5227:846;;;;-1:-1:-1;5227:846:20;;-1:-1:-1;6039:2:20;6031:11;;6061:6;5227:846;-1:-1:-1;;;5227:846:20:o;6078:316::-;;;;6235:2;6223:9;6214:7;6210:23;6206:32;6203:2;;;6256:6;6248;6241:22;6203:2;6290:9;6284:16;6274:26;;6340:2;6329:9;6325:18;6319:25;6309:35;;6384:2;6373:9;6369:18;6363:25;6353:35;;6193:201;;;;;:::o;6399:274::-;;6566:6;6560:13;6582:53;6628:6;6623:3;6616:4;6608:6;6604:17;6582:53;:::i;:::-;6651:16;;;;;6536:137;-1:-1:-1;;6536:137:20:o;7241:688::-;;-1:-1:-1;;;;;7555:2:20;7547:6;7543:15;7532:9;7525:34;7607:2;7599:6;7595:15;7590:2;7579:9;7575:18;7568:43;;7647:6;7642:2;7631:9;7627:18;7620:34;7690:3;7685:2;7674:9;7670:18;7663:31;7731:6;7725:3;7714:9;7710:19;7703:35;7789:6;7781;7775:3;7764:9;7760:19;7747:49;7816:22;;;7840:3;7812:32;;;7805:46;;;;7912:2;7891:15;;;-1:-1:-1;;7887:29:20;7872:45;7868:55;;7454:475;-1:-1:-1;;;;7454:475:20:o;9640:684::-;9811:2;9863:21;;;9933:13;;9836:18;;;9955:22;;;9640:684;;9811:2;10034:15;;;;10008:2;9993:18;;;9640:684;10080:218;10094:6;10091:1;10088:13;10080:218;;;10159:13;;-1:-1:-1;;;;;10155:62:20;10143:75;;10273:15;;;;10238:12;;;;10116:1;10109:9;10080:218;;;-1:-1:-1;10315:3:20;;9791:533;-1:-1:-1;;;;;;9791:533:20:o;10521:383::-;;10670:2;10659:9;10652:21;10702:6;10696:13;10745:6;10740:2;10729:9;10725:18;10718:34;10761:66;10820:6;10815:2;10804:9;10800:18;10795:2;10787:6;10783:15;10761:66;:::i;:::-;10888:2;10867:15;-1:-1:-1;;10863:29:20;10848:45;;;;10895:2;10844:54;;10642:262;-1:-1:-1;;10642:262:20:o;23880:128::-;;23951:1;23947:6;23944:1;23941:13;23938:2;;;23957:18;;:::i;:::-;-1:-1:-1;23993:9:20;;23928:80::o;24013:217::-;;24079:1;24069:2;;-1:-1:-1;;;24104:31:20;;24158:4;24155:1;24148:15;24186:4;24111:1;24176:15;24069:2;-1:-1:-1;24215:9:20;;24059:171::o;24235:168::-;;24341:1;24337;24333:6;24329:14;24326:1;24323:21;24318:1;24311:9;24304:17;24300:45;24297:2;;;24348:18;;:::i;:::-;-1:-1:-1;24388:9:20;;24287:116::o;24408:125::-;;24476:1;24473;24470:8;24467:2;;;24481:18;;:::i;:::-;-1:-1:-1;24518:9:20;;24457:76::o;24538:258::-;24610:1;24620:113;24634:6;24631:1;24628:13;24620:113;;;24710:11;;;24704:18;24691:11;;;24684:39;24656:2;24649:10;24620:113;;;24751:6;24748:1;24745:13;24742:2;;;-1:-1:-1;;24786:1:20;24768:16;;24761:27;24591:205::o;24801:135::-;;-1:-1:-1;;24861:17:20;;24858:2;;;24881:18;;:::i;:::-;-1:-1:-1;24928:1:20;24917:13;;24848:88::o;24941:127::-;25002:10;24997:3;24993:20;24990:1;24983:31;25033:4;25030:1;25023:15;25057:4;25054:1;25047:15;25073:127;25134:10;25129:3;25125:20;25122:1;25115:31;25165:4;25162:1;25155:15;25189:4;25186:1;25179:15;25205:154;-1:-1:-1;;;;;25284:5:20;25280:54;25273:5;25270:65;25260:2;;25349:1;25346;25339:12;25260:2;25250:109;:::o;25364:119::-;25449:8;25442:5;25438:20;25431:5;25428:31;25418:2;;25473:1;25470;25463:12

ipfs://edf7160eccd1c45030138d6c8535b0579e7f04c851e2a8af212270f2da3786d7