Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

More Options

• Similar
• Submit Audit
• Compare

/**
 *Submitted for verification at lineascan.build/ on 2025-05-26
*/

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

// contracts/8/interfaces/IAdapter.sol

interface IAdapter {
    function sellBase(
        address to,
        address pool,
        bytes memory data
    ) external;

    function sellQuote(
        address to,
        address pool,
        bytes memory data
    ) external;
}

// contracts/8/interfaces/IERC20.sol

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

    function name() external view returns (string memory);

    function symbol() external view returns (string memory);

    function decimals() external view returns (uint8);

    function totalSupply() external view returns (uint256);

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

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

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

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

    function transferFrom(
        address from,
        address to,
        uint256 value
    ) external returns (bool);
}

// contracts/8/interfaces/IDaiLikePermit.sol

/// @title Interface for DAI-style permits
interface IDaiLikePermit {
    function permit(
        address holder,
        address spender,
        uint256 nonce,
        uint256 expiry,
        bool allowed,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external;
}

// contracts/8/libraries/RevertReasonForwarder.sol

library RevertReasonForwarder {
    function reRevert() internal pure {
        // bubble up revert reason from latest external call
        /// @solidity memory-safe-assembly
        assembly { // solhint-disable-line no-inline-assembly
            let ptr := mload(0x40)
            returndatacopy(ptr, 0, returndatasize())
            revert(ptr, returndatasize())
        }
    }
}

// contracts/8/libraries/SafeERC20.sol

// File @1inch/solidity-utils/contracts/libraries/[email protected]

library SafeERC20 {
    error SafeTransferFailed();
    error SafeTransferFromFailed();
    error ForceApproveFailed();
    error SafeIncreaseAllowanceFailed();
    error SafeDecreaseAllowanceFailed();
    error SafePermitBadLength();

    // Ensures method do not revert or return boolean `true`, admits call to non-smart-contract
    function safeTransferFrom(IERC20 token, address from, address to, uint256 amount) internal {
        bytes4 selector = token.transferFrom.selector;
        bool success;
        /// @solidity memory-safe-assembly
        assembly { // solhint-disable-line no-inline-assembly
            let data := mload(0x40)

            mstore(data, selector)
            mstore(add(data, 0x04), from)
            mstore(add(data, 0x24), to)
            mstore(add(data, 0x44), amount)
            success := call(gas(), token, 0, data, 100, 0x0, 0x20)
            if success {
                switch returndatasize()
                case 0 { success := gt(extcodesize(token), 0) }
                default { success := and(gt(returndatasize(), 31), eq(mload(0), 1)) }
            }
        }
        if (!success) revert SafeTransferFromFailed();
    }

    // Ensures method do not revert or return boolean `true`, admits call to non-smart-contract
    function safeTransfer(IERC20 token, address to, uint256 value) internal {
        if (!_makeCall(token, token.transfer.selector, to, value)) {
            revert SafeTransferFailed();
        }
    }

    function safeApprove(IERC20 token, address spender, uint256 value) internal {
        forceApprove(token, spender, value);
    }

    // If `approve(from, to, amount)` fails, try to `approve(from, to, 0)` before retry
    function forceApprove(IERC20 token, address spender, uint256 value) internal {
        if (!_makeCall(token, token.approve.selector, spender, value)) {
            if (!_makeCall(token, token.approve.selector, spender, 0) ||
                !_makeCall(token, token.approve.selector, spender, value))
            {
                revert ForceApproveFailed();
            }
        }
    }

    

    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        uint256 allowance = token.allowance(address(this), spender);
        if (value > type(uint256).max - allowance) revert SafeIncreaseAllowanceFailed();
        forceApprove(token, spender, allowance + value);
    }

    function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        uint256 allowance = token.allowance(address(this), spender);
        if (value > allowance) revert SafeDecreaseAllowanceFailed();
        forceApprove(token, spender, allowance - value);
    }

    function safePermit(IERC20 token, bytes calldata permit) internal {
        bool success;
        if (permit.length == 32 * 7) {
            success = _makeCalldataCall(token, IERC20Permit.permit.selector, permit);
        } else if (permit.length == 32 * 8) {
            success = _makeCalldataCall(token, IDaiLikePermit.permit.selector, permit);
        } else {
            revert SafePermitBadLength();
        }
        if (!success) RevertReasonForwarder.reRevert();
    }

    function _makeCall(IERC20 token, bytes4 selector, address to, uint256 amount) private returns(bool success) {
        /// @solidity memory-safe-assembly
        assembly { // solhint-disable-line no-inline-assembly
            let data := mload(0x40)

            mstore(data, selector)
            mstore(add(data, 0x04), to)
            mstore(add(data, 0x24), amount)
            success := call(gas(), token, 0, data, 0x44, 0x0, 0x20)
            if success {
                switch returndatasize()
                case 0 { success := gt(extcodesize(token), 0) }
                default { success := and(gt(returndatasize(), 31), eq(mload(0), 1)) }
            }
        }
    }

    function _makeCalldataCall(IERC20 token, bytes4 selector, bytes calldata args) private returns(bool success) {
        /// @solidity memory-safe-assembly
        assembly { // solhint-disable-line no-inline-assembly
            let len := add(4, args.length)
            let data := mload(0x40)

            mstore(data, selector)
            calldatacopy(add(data, 0x04), args.offset, args.length)
            success := call(gas(), token, 0, data, len, 0x0, 0x20)
            if success {
                switch returndatasize()
                case 0 { success := gt(extcodesize(token), 0) }
                default { success := and(gt(returndatasize(), 31), eq(mload(0), 1)) }
            }
        }
    }
}

// contracts/8/interfaces/IWETH.sol

interface IWETH {
    function totalSupply() external view returns (uint256);

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

    function transfer(address recipient, uint256 amount)
        external
        returns (bool);

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

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

    function transferFrom(
        address src,
        address dst,
        uint256 wad
    ) external returns (bool);

    function deposit() external payable;

    function withdraw(uint256 wad) external;
}

// contracts/8/interfaces/IUniV3.sol

interface IUniV3 {
    function swap(
        address recipient,
        bool zeroForOne,
        int256 amountSpecified,
        uint160 sqrtPriceLimitX96,
        bytes calldata data
    ) external returns (int256 amount0, int256 amount1);

    function slot0()
        external
        view
        returns (
            uint160 sqrtPriceX96,
            int24 tick,
            uint16 observationIndex,
            uint16 observationCardinality,
            uint16 observationCardinalityNext,
            uint8 feeProtocol,
            bool unlocked
        );

    function token0() external view returns (address);

    function token1() external view returns (address);

    /// @notice The pool's fee in hundredths of a bip, i.e. 1e-6
    /// @return The fee
    function fee() external view returns (uint24);
}

// contracts/8/interfaces/IERC20Permit.sol

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

// contracts/8/adapter/TemplateAdaptor/BaseUniversalUniswapV3Adaptor.sol

// solhint-disable

/// @dev specific flag for refund logic, "0x3ca20afc" is flexible and also used for commission, "ccc" mean refund
uint256 constant ORIGIN_PAYER = 0x3ca20afc2ccc0000000000000000000000000000000000000000000000000000;
uint256 constant ADDRESS_MASK = 0x000000000000000000000000ffffffffffffffffffffffffffffffffffffffff;

abstract contract BaseUniversalUniswapV3Adaptor is IAdapter {
    address public immutable WETH;
    uint160 public immutable MIN_SQRT_RATIO;
    uint160 public immutable MAX_SQRT_RATIO;

    /// @notice throw error when amount is not positive
    error InvalidAmount();
    /// @notice throw error when payer is not the contract itself or value is not required
    error InvalidPay();

    constructor(address weth, uint160 minSqrtRatio, uint160 maxSqrtRatio) {
        WETH = weth;
        MIN_SQRT_RATIO = minSqrtRatio;
        MAX_SQRT_RATIO = maxSqrtRatio;
    }

    function sellBase(
        address to,
        address pool,
        bytes memory moreInfo
    ) external override {
        _sell(to, pool, moreInfo);
    }

    function sellQuote(
        address to,
        address pool,
        bytes memory moreInfo
    ) external override {
        _sell(to, pool, moreInfo);
    }

    function _sell(address to, address pool, bytes memory moreInfo) internal {
        (uint160 sqrtX96, bytes memory data) = abi.decode(
            moreInfo,
            (uint160, bytes)
        );
        _uniswapV3Swap(to, pool, sqrtX96, data, _getPayerOrigin());
    }

    function _uniswapV3Swap(
        address to,
        address pool,
        uint160 sqrtX96,
        bytes memory data,
        uint256 payerOrigin
    ) internal {
        (address fromToken, address toToken) = abi.decode(
            data,
            (address, address)
        );
        uint256 sellAmount = IERC20(fromToken).balanceOf(address(this));
        bool zeroForOne = fromToken < toToken;
        // Call the pool's swap function
        IUniV3(pool).swap(
            to,
            zeroForOne,
            int256(sellAmount),
            sqrtX96 == 0
                ? (zeroForOne ? MIN_SQRT_RATIO + 1 : MAX_SQRT_RATIO - 1)
                : sqrtX96,
            data
        );
        /// @notice Refund logic: if there is leftover fromToken, refund to payerOrigin
        address _payerOrigin;
        if ((payerOrigin & ORIGIN_PAYER) == ORIGIN_PAYER) {
            _payerOrigin = address(uint160(uint256(payerOrigin) & ADDRESS_MASK));
        }
        uint256 amount = IERC20(fromToken).balanceOf(address(this));
        if (amount > 0 && _payerOrigin != address(0)) {
            SafeERC20.safeTransfer(IERC20(fromToken), _payerOrigin, amount);
        }
    }

    // Common internal callback logic for all V3-like protocols
    function _universalSwapCallback(
        int256 amount0Delta,
        int256 amount1Delta,
        bytes memory data
    ) internal {
        if (amount0Delta <= 0 && amount1Delta <= 0) {
            revert InvalidAmount();
        }
        (address tokenIn, address tokenOut) = abi.decode(
            data,
            (address, address)
        );
        address tokenA = tokenIn;
        address tokenB = tokenOut;
        if (tokenA > tokenB) {
            (tokenA, tokenB) = (tokenB, tokenA);
        }
        (bool isExactInput, uint256 amountToPay) = amount0Delta > 0
            ? (tokenIn < tokenOut, uint256(amount0Delta))
            : (tokenOut < tokenIn, uint256(amount1Delta));
        if (isExactInput) {
            pay(tokenIn, address(this), msg.sender, amountToPay);
        } else {
            pay(tokenOut, address(this), msg.sender, amountToPay);
        }
    }

    /// @notice Internal function to handle token payments during swaps
    /// @dev This function handles two types of payments:
    ///      1. WETH payments: If the token is WETH and contract has enough ETH balance,
    ///         it will wrap ETH to WETH and transfer to recipient
    ///      2. ERC20 payments: If the payer is the contract itself, it will transfer
    ///         the ERC20 tokens directly to the recipient
    /// @param token The token address to pay with (WETH or ERC20)
    /// @param payer The address that should pay the tokens
    /// @param recipient The address that should receive the tokens
    /// @param value The amount of tokens to pay
    /// @custom:error InvalidPay Thrown when payer is not the contract itself
    function pay(
        address token,
        address payer,
        address recipient,
        uint256 value
    ) internal {
        /// @notice pay with WETH
        if (token == WETH && address(this).balance >= value) {
            IWETH(WETH).deposit{value: value}();
            IWETH(WETH).transfer(recipient, value);
            /// @notice pay with ERC20
        } else if (payer == address(this)) {
            SafeERC20.safeTransfer(IERC20(token), recipient, value);
        } else {
            revert InvalidPay();
        }
    }

    function _getPayerOrigin() internal pure returns (uint256 payerOrigin) {
        assembly {
            // Get the total size of the calldata
            let size := calldatasize()
            // Load the last 32 bytes of the calldata, which is assumed to contain the payer origin
            // Assumption: The calldata is structured such that the payer origin is always at the end
            payerOrigin := calldataload(sub(size, 32))
        }
    }

    // Fallback function to handle unexpected V3-like callbacks.
    // It expects calldata matching the (int256 amount0Delta, int256 amount1Delta, bytes memory data) signature
    // after the 4-byte function selector.
    fallback(bytes calldata _calldata) external returns (bytes memory) {
        (int256 amount0Delta, int256 amount1Delta, bytes memory data) = abi.decode(_calldata[4:], (int256, int256, bytes));
        _universalSwapCallback(amount0Delta, amount1Delta, data);

        // Uniswap V3 callbacks typically do not return values.
        // Returning empty bytes is standard for fallbacks that successfully handle a call
        // but don't have a specific return value defined by an interface.
        return bytes("");
    }
}

// contracts/8/adapter/TemplateAdaptor/UniversalUniswapV3Adaptor.sol

// solhint-disable

/**
 * @title UniversalUniswapV3Adaptor
 * @notice Base contract for Universal Uniswap V3 Adapter implementation
 * @dev This contract serves as the foundation for adapting various Uniswap V3-like DEX protocols
 *
 * Supported DEX Protocols:
 * 1. Uniswap V3 Family:
 *    - Uniswap V3
 *    - Sheepdex
 *
 * 2. Algebra Family:
 *    - CamelotV3
 *    - KimV4
 *    - ThenaV2
 *    - Quickswapv3
 *    - HerculesV3
 *    - ZyberV3
 *
 * 3. Other V3-like DEXs:
 *    - Agni
 *    - FusionX
 *    - RamsesV2 (including NileCL)
 *    - Xei
 *    - PancakeV3
 *    - FireflyV3
 *
 * @custom:security-contact [email protected]
 */
contract UniversalUniswapV3Adaptor is BaseUniversalUniswapV3Adaptor {
    constructor(
        address weth,
        uint160 minSqrtRatio,
        uint160 maxSqrtRatio
    ) BaseUniversalUniswapV3Adaptor(weth, minSqrtRatio, maxSqrtRatio) {}

    // Uniswap V3 callback(
    // Sheepdex,
    // etc.)
    function uniswapV3SwapCallback(
        int256 amount0Delta,
        int256 amount1Delta,
        bytes calldata data
    ) external {
        _universalSwapCallback(amount0Delta, amount1Delta, data);
    }

    // Agni callback
    function agniSwapCallback(
        int256 amount0Delta,
        int256 amount1Delta,
        bytes calldata data
    ) external {
        _universalSwapCallback(amount0Delta, amount1Delta, data);
    }

    // Algebra/Algebra-like callback (
    // CamelotV3,
    // KimV4,
    // ThenaV2,
    // Quickswapv3,
    // HerculesV3,
    // ZyberV3,
    // etc.)
    function algebraSwapCallback(
        int256 amount0Delta,
        int256 amount1Delta,
        bytes calldata data
    ) external {
        _universalSwapCallback(amount0Delta, amount1Delta, data);
    }

    // FusionX callback
    function fusionXV3SwapCallback(
        int256 amount0Delta,
        int256 amount1Delta,
        bytes calldata data
    ) external {
        _universalSwapCallback(amount0Delta, amount1Delta, data);
    }

    // RamsesV2 callback(
    // NileCL,
    // etc.)
    function ramsesV2SwapCallback(
        int256 amount0Delta,
        int256 amount1Delta,
        bytes calldata data
    ) external {
        _universalSwapCallback(amount0Delta, amount1Delta, data);
    }

    // Xei callback
    function xeiV3SwapCallback(
        int256 amount0Delta,
        int256 amount1Delta,
        bytes calldata data
    ) external {
        _universalSwapCallback(amount0Delta, amount1Delta, data);
    }

    // PancakeV3 callback
    function pancakeV3SwapCallback(
        int256 amount0Delta,
        int256 amount1Delta,
        bytes calldata data
    ) external {
        _universalSwapCallback(amount0Delta, amount1Delta, data);
    }

    // FireflyV3 callback
    function fireflyV3SwapCallback(
        int256 amount0Delta,
        int256 amount1Delta,
        bytes calldata data
    ) external {
        _universalSwapCallback(amount0Delta, amount1Delta, data);
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"weth","type":"address"},{"internalType":"uint160","name":"minSqrtRatio","type":"uint160"},{"internalType":"uint160","name":"maxSqrtRatio","type":"uint160"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"InvalidAmount","type":"error"},{"inputs":[],"name":"InvalidPay","type":"error"},{"inputs":[],"name":"SafeTransferFailed","type":"error"},{"stateMutability":"nonpayable","type":"fallback"},{"inputs":[],"name":"MAX_SQRT_RATIO","outputs":[{"internalType":"uint160","name":"","type":"uint160"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MIN_SQRT_RATIO","outputs":[{"internalType":"uint160","name":"","type":"uint160"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"WETH","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"int256","name":"amount0Delta","type":"int256"},{"internalType":"int256","name":"amount1Delta","type":"int256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"agniSwapCallback","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"int256","name":"amount0Delta","type":"int256"},{"internalType":"int256","name":"amount1Delta","type":"int256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"algebraSwapCallback","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"int256","name":"amount0Delta","type":"int256"},{"internalType":"int256","name":"amount1Delta","type":"int256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"fireflyV3SwapCallback","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"int256","name":"amount0Delta","type":"int256"},{"internalType":"int256","name":"amount1Delta","type":"int256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"fusionXV3SwapCallback","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"int256","name":"amount0Delta","type":"int256"},{"internalType":"int256","name":"amount1Delta","type":"int256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"pancakeV3SwapCallback","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"int256","name":"amount0Delta","type":"int256"},{"internalType":"int256","name":"amount1Delta","type":"int256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"ramsesV2SwapCallback","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"address","name":"pool","type":"address"},{"internalType":"bytes","name":"moreInfo","type":"bytes"}],"name":"sellBase","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"address","name":"pool","type":"address"},{"internalType":"bytes","name":"moreInfo","type":"bytes"}],"name":"sellQuote","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"int256","name":"amount0Delta","type":"int256"},{"internalType":"int256","name":"amount1Delta","type":"int256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"uniswapV3SwapCallback","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"int256","name":"amount0Delta","type":"int256"},{"internalType":"int256","name":"amount1Delta","type":"int256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"xeiV3SwapCallback","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

000000000000000000000000e5d7c2a44ffddf6b295a15c148167daaaf5cf34f00000000000000000000000000000000000000000000000000000001000276a3000000000000000000000000fffd8963efd1fc6a506488495d951d5263988d26

-----Decoded View---------------
Arg [0] : weth (address): 0xe5D7C2a44FfDDf6b295A15c148167daaAf5Cf34f
Arg [1] : minSqrtRatio (uint160): 4295128739
Arg [2] : maxSqrtRatio (uint160): 1461446703485210103287273052203988822378723970342

-----Encoded View---------------
3 Constructor Arguments found :
Arg [0] : 000000000000000000000000e5d7c2a44ffddf6b295a15c148167daaaf5cf34f
Arg [1] : 00000000000000000000000000000000000000000000000000000001000276a3
Arg [2] : 000000000000000000000000fffd8963efd1fc6a506488495d951d5263988d26

17953:2399:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;16714:12;17953:2399;;;16814:13;17953:2399;16824:1;17953:2399;;16814:13;:::i;:::-;16803:50;;;;;;;:::i;:::-;16739:114;;;;;;16864:56;16887:12;16901;16915:4;16864:22;:56::i;:::-;-1:-1:-1;;17173:9:0;;;;;;;;;-1:-1:-1;17173:9:0;;-1:-1:-1;19890:212:0;;;;;;:::i;:::-;;:::i;:::-;;11803:163;;;;;;:::i;:::-;;:::i;11363:39::-;;;;;;;;-1:-1:-1;;;;;3510:32:1;;;3492:51;;3480:2;3465:18;11363:39:0;;;;;;;11281:29;;;;;11317:39;;;;;13717:914;13884:1;13868:12;:17;;:38;;;;;13905:1;13889:12;:17;;13868:38;13864:93;;;13930:15;;-1:-1:-1;;;13930:15:0;;;;;;;;;;;13864:93;13968:15;13985:16;14030:4;14005:73;;;;;;;;;;;;:::i;:::-;13967:111;;-1:-1:-1;13967:111:0;-1:-1:-1;13967:111:0;;-1:-1:-1;;;;;14164:15:0;;;;;;;14160:83;;;14216:6;14160:83;14254:17;14273:19;14311:1;14296:12;:16;:134;;14399:7;-1:-1:-1;;;;;14388:18:0;:8;-1:-1:-1;;;;;14388:18:0;;14416:12;14296:134;;;14339:8;-1:-1:-1;;;;;14329:18:0;:7;-1:-1:-1;;;;;14329:18:0;;14357:12;14296:134;14253:177;;;;14445:12;14441:183;;;14474:52;14478:7;14495:4;14502:10;14514:11;14474:3;:52::i;:::-;14441:183;;;14559:53;14563:8;14581:4;14588:10;14600:11;14559:3;:53::i;:::-;13853:778;;;;;;13717:914;;;:::o;19890:212::-;20038:56;20061:12;20075;20089:4;;20038:56;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;20038:22:0;;-1:-1:-1;;;20038:56:0:i;:::-;19890:212;;;;:::o;11803:163::-;11933:25;11939:2;11943:4;11949:8;11933:5;:25::i;:::-;11803:163;;;:::o;15403:558::-;15591:4;-1:-1:-1;;;;;15582:13:0;:5;-1:-1:-1;;;;;15582:13:0;;:47;;;;;15624:5;15599:21;:30;;15582:47;15578:376;;;15652:4;-1:-1:-1;;;;;15646:19:0;;15673:5;15646:35;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;15696:38:0;;-1:-1:-1;;;15696:38:0;;-1:-1:-1;;;;;4360:32:1;;;15696:38:0;;;4342:51:1;4409:18;;;4402:34;;;15702:4:0;15696:20;;-1:-1:-1;15696:20:0;;-1:-1:-1;4315:18:1;;;-1:-1:-1;15696:38:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;15578:376;;;15813:4;-1:-1:-1;;;;;15796:22:0;;;15792:162;;15835:55;15865:5;15873:9;15884:5;15835:22;:55::i;:::-;15792:162;;;15930:12;;-1:-1:-1;;;15930:12:0;;;;;;;;;;;12146:275;12231:15;12248:17;12294:8;12269:75;;;;;;;;;;;;:::i;:::-;12230:114;;;;12355:58;12370:2;12374:4;12380:7;12389:4;12395:17;-1:-1:-1;;16138:14:0;16398:13;16385:27;;15969:461;12395:17;12355:14;:58::i;:::-;12219:202;;12146:275;;;:::o;3564:203::-;3652:52;3662:5;-1:-1:-1;;;3694:2:0;3698:5;3652:9;:52::i;:::-;3647:113;;3728:20;;-1:-1:-1;;;3728:20:0;;;;;;;;;;;12429:1215;12609:17;12628:15;12672:4;12647:73;;;;;;;;;;;;:::i;:::-;12752:42;;-1:-1:-1;;;12752:42:0;;12788:4;12752:42;;;3492:51:1;12608:112:0;;-1:-1:-1;12608:112:0;-1:-1:-1;12731:18:0;;-1:-1:-1;;;;;12752:27:0;;;;;3465:18:1;;12752:42:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;12731:63;;12805:15;12835:7;-1:-1:-1;;;;;12823:19:0;:9;-1:-1:-1;;;;;12823:19:0;;12805:37;;12902:4;-1:-1:-1;;;;;12895:17:0;;12927:2;12944:10;12976;13002:7;-1:-1:-1;;;;;13002:12:0;13013:1;13002:12;:113;;13108:7;13002:113;;;13035:10;:52;;13069:18;13086:1;13069:14;:18;:::i;:::-;13035:52;;;13048:18;:14;13065:1;13048:18;:::i;:::-;13130:4;12895:250;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;13245:20;-1:-1:-1;;;11042:66:0;13281:11;:26;13280:44;13276:145;;-1:-1:-1;;;;;;13372:35:0;;13276:145;13448:42;;-1:-1:-1;;;13448:42:0;;13484:4;13448:42;;;3492:51:1;13431:14:0;;-1:-1:-1;;;;;13448:27:0;;;;;3465:18:1;;13448:42:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;13431:59;;13514:1;13505:6;:10;:40;;;;-1:-1:-1;;;;;;13519:26:0;;;;13505:40;13501:136;;;13562:63;13592:9;13604:12;13618:6;13562:22;:63::i;:::-;12597:1047;;;;;;12429:1215;;;;;:::o;5531:698::-;5625:12;5779:4;5773:11;5813:8;5807:4;5800:22;5860:2;5853:4;5847;5843:15;5836:27;5901:6;5894:4;5888;5884:15;5877:31;5972:4;5967:3;5961:4;5955;5952:1;5945:5;5938;5933:44;5922:55;;;5994:7;5991:220;;;6028:16;6062:47;;;;6191:1;6187;6181:8;6178:15;6173:2;6155:16;6152:24;6148:46;6137:57;;6021:175;;6062:47;6105:1;6097:5;6085:18;6082:25;6071:36;;6021:175;;5991:220;5531:698;;;;;;:::o;14:331:1:-;119:9;130;172:8;160:10;157:24;154:44;;;194:1;191;184:12;154:44;223:6;213:8;210:20;207:40;;;243:1;240;233:12;207:40;-1:-1:-1;;269:23:1;;;314:25;;;;;-1:-1:-1;14:331:1:o;350:127::-;411:10;406:3;402:20;399:1;392:31;442:4;439:1;432:15;466:4;463:1;456:15;482:275;553:2;547:9;618:2;599:13;;-1:-1:-1;;595:27:1;583:40;;653:18;638:34;;674:22;;;635:62;632:88;;;700:18;;:::i;:::-;736:2;729:22;482:275;;-1:-1:-1;482:275:1:o;762:186::-;810:4;843:18;835:6;832:30;829:56;;;865:18;;:::i;:::-;-1:-1:-1;931:2:1;910:15;-1:-1:-1;;906:29:1;937:4;902:40;;762:186::o;953:462::-;995:5;1048:3;1041:4;1033:6;1029:17;1025:27;1015:55;;1066:1;1063;1056:12;1015:55;1102:6;1089:20;1133:48;1149:31;1177:2;1149:31;:::i;:::-;1133:48;:::i;:::-;1206:2;1197:7;1190:19;1252:3;1245:4;1240:2;1232:6;1228:15;1224:26;1221:35;1218:55;;;1269:1;1266;1259:12;1218:55;1334:2;1327:4;1319:6;1315:17;1308:4;1299:7;1295:18;1282:55;1382:1;1357:16;;;1375:4;1353:27;1346:38;;;;1361:7;953:462;-1:-1:-1;;;953:462:1:o;1420:454::-;1504:6;1512;1520;1573:2;1561:9;1552:7;1548:23;1544:32;1541:52;;;1589:1;1586;1579:12;1541:52;1625:9;1612:23;1602:33;;1682:2;1671:9;1667:18;1654:32;1644:42;;1737:2;1726:9;1722:18;1709:32;1764:18;1756:6;1753:30;1750:50;;;1796:1;1793;1786:12;1750:50;1819:49;1860:7;1851:6;1840:9;1836:22;1819:49;:::i;:::-;1809:59;;;1420:454;;;;;:::o;1879:725::-;1965:6;1973;1981;1989;2042:2;2030:9;2021:7;2017:23;2013:32;2010:52;;;2058:1;2055;2048:12;2010:52;2094:9;2081:23;2071:33;;2151:2;2140:9;2136:18;2123:32;2113:42;;2206:2;2195:9;2191:18;2178:32;2229:18;2270:2;2262:6;2259:14;2256:34;;;2286:1;2283;2276:12;2256:34;2324:6;2313:9;2309:22;2299:32;;2369:7;2362:4;2358:2;2354:13;2350:27;2340:55;;2391:1;2388;2381:12;2340:55;2431:2;2418:16;2457:2;2449:6;2446:14;2443:34;;;2473:1;2470;2463:12;2443:34;2518:7;2513:2;2504:6;2500:2;2496:15;2492:24;2489:37;2486:57;;;2539:1;2536;2529:12;2486:57;1879:725;;;;-1:-1:-1;;2570:2:1;2562:11;;-1:-1:-1;;;1879:725:1:o;2609:131::-;-1:-1:-1;;;;;2684:31:1;;2674:42;;2664:70;;2730:1;2727;2720:12;2664:70;2609:131;:::o;2745:596::-;2831:6;2839;2847;2900:2;2888:9;2879:7;2875:23;2871:32;2868:52;;;2916:1;2913;2906:12;2868:52;2955:9;2942:23;2974:31;2999:5;2974:31;:::i;:::-;3024:5;-1:-1:-1;3081:2:1;3066:18;;3053:32;3094:33;3053:32;3094:33;:::i;:::-;3146:7;-1:-1:-1;3204:2:1;3189:18;;3176:32;3231:18;3220:30;;3217:50;;;3263:1;3260;3253:12;3762:401;3857:6;3865;3918:2;3906:9;3897:7;3893:23;3889:32;3886:52;;;3934:1;3931;3924:12;3886:52;3966:9;3960:16;3985:31;4010:5;3985:31;:::i;:::-;4085:2;4070:18;;4064:25;4035:5;;-1:-1:-1;4098:33:1;4064:25;4098:33;:::i;:::-;4150:7;4140:17;;;3762:401;;;;;:::o;4447:277::-;4514:6;4567:2;4555:9;4546:7;4542:23;4538:32;4535:52;;;4583:1;4580;4573:12;4535:52;4615:9;4609:16;4668:5;4661:13;4654:21;4647:5;4644:32;4634:60;;4690:1;4687;4680:12;4634:60;4713:5;4447:277;-1:-1:-1;;;4447:277:1:o;4729:250::-;4814:1;4824:113;4838:6;4835:1;4832:13;4824:113;;;4914:11;;;4908:18;4895:11;;;4888:39;4860:2;4853:10;4824:113;;;-1:-1:-1;;4971:1:1;4953:16;;4946:27;4729:250::o;4984:775::-;5072:6;5080;5133:2;5121:9;5112:7;5108:23;5104:32;5101:52;;;5149:1;5146;5139:12;5101:52;5181:9;5175:16;5200:31;5225:5;5200:31;:::i;:::-;5299:2;5284:18;;5278:25;5250:5;;-1:-1:-1;5326:18:1;5315:30;;5312:50;;;5358:1;5355;5348:12;5312:50;5381:22;;5434:4;5426:13;;5422:27;-1:-1:-1;5412:55:1;;5463:1;5460;5453:12;5412:55;5492:2;5486:9;5517:48;5533:31;5561:2;5533:31;:::i;5517:48::-;5588:2;5581:5;5574:17;5628:7;5623:2;5618;5614;5610:11;5606:20;5603:33;5600:53;;;5649:1;5646;5639:12;5600:53;5662:67;5726:2;5721;5714:5;5710:14;5705:2;5701;5697:11;5662:67;:::i;:::-;5748:5;5738:15;;;;;4984:775;;;;;:::o;5764:184::-;5834:6;5887:2;5875:9;5866:7;5862:23;5858:32;5855:52;;;5903:1;5900;5893:12;5855:52;-1:-1:-1;5926:16:1;;5764:184;-1:-1:-1;5764:184:1:o;5953:127::-;6014:10;6009:3;6005:20;6002:1;5995:31;6045:4;6042:1;6035:15;6069:4;6066:1;6059:15;6085:185;-1:-1:-1;;;;;6206:10:1;;;6194;;;6190:27;;6229:12;;;6226:38;;;6244:18;;:::i;:::-;6226:38;6085:185;;;;:::o;6275:182::-;-1:-1:-1;;;;;6382:10:1;;;6394;;;6378:27;;6417:11;;;6414:37;;;6431:18;;:::i;6462:747::-;6676:4;6722:1;6718;6713:3;6709:11;6705:19;6763:2;6755:6;6751:15;6740:9;6733:34;6817:6;6810:14;6803:22;6798:2;6787:9;6783:18;6776:50;6862:6;6857:2;6846:9;6842:18;6835:34;6917:2;6909:6;6905:15;6900:2;6889:9;6885:18;6878:43;;6958:3;6952;6941:9;6937:19;6930:32;6991:6;6985:13;7035:6;7029:3;7018:9;7014:19;7007:35;7051:80;7124:6;7118:3;7107:9;7103:19;7098:2;7090:6;7086:15;7051:80;:::i;:::-;7192:2;7171:15;-1:-1:-1;;7167:29:1;7152:45;;;;7199:3;7148:55;;6462:747;-1:-1:-1;;;;;;6462:747:1:o;7214:243::-;7291:6;7299;7352:2;7340:9;7331:7;7327:23;7323:32;7320:52;;;7368:1;7365;7358:12;7320:52;-1:-1:-1;;7391:16:1;;7447:2;7432:18;;;7426:25;7391:16;;7426:25;;-1:-1:-1;7214:243:1:o

ipfs://6e2fcb6532f4127736ce7de5d33f592bb9d0d70a09d99ce531afcb367b77273d