Contract 0x6f9d14cf4a06dd9c70766bd161cf8d4387683e1b 11

//SPDX-License-Identifier: None
pragma solidity =0.7.6;
pragma abicoder v2;

import "./router/SwapRouter.sol";
import "./router/libs/IERC20.sol";

interface UniswapV3Pool {
    function token0() external returns (address);
    function token1() external returns (address);
    function fee() external returns (uint24);
}

contract LlamaZip is SwapRouter {
    address internal immutable owner; // Set to internal to avoid collisions
    uint internal constant MAX_BPS = 10000;

    constructor(address _factory, address _WETH9, address _owner) SwapRouter(_factory, _WETH9) {
        owner = _owner;
    }

    struct Pool {
        address token0;
        address token1;
        uint24 fee;
    }

    mapping(uint => Pool) internal pools;

    function setPool(uint id, address pool) internal {
        require(pools[id].token0 == address(0) && pools[id].token1 == address(0), "already set");

        pools[id] = Pool({
            fee: UniswapV3Pool(pool).fee(),
            token0: UniswapV3Pool(pool).token0(),
            token1: UniswapV3Pool(pool).token1()
        });
    }

    function getPool(uint poolId) view internal returns (Pool memory pool){
        if(poolId == 0){
            return Pool(0x4200000000000000000000000000000000000006, 0x7F5c764cBc14f9669B88837ca1490cCa17c31607, 500); // WETH / USDC 0.05%
        } else if(poolId == (1 << 252)){
            return Pool(0x4200000000000000000000000000000000000006, 0x4200000000000000000000000000000000000042, 3000); // WETH / OP 0.3%
        } else if(poolId == (2 << 252)){
            return Pool(0x4200000000000000000000000000000000000042, 0x7F5c764cBc14f9669B88837ca1490cCa17c31607, 3000); // OP / USDC 0.3%
        } else if(poolId == (3 << 252)){
            return Pool(0x4200000000000000000000000000000000000006, 0x4200000000000000000000000000000000000042, 500); // WETH / OP 0.05%
        } else if(poolId == (4 << 252)){
            return Pool(0x7F5c764cBc14f9669B88837ca1490cCa17c31607, 0xDA10009cBd5D07dd0CeCc66161FC93D7c9000da1, 100); // USDC / DAI 0.01%
        } else if(poolId == (5 << 252)){
            return Pool(0x4200000000000000000000000000000000000006, 0x8700dAec35aF8Ff88c16BdF0418774CB3D7599B4, 3000); // WETH / SNX 0.3%
        } else if(poolId == (6 << 252)){
            return Pool(0x4200000000000000000000000000000000000006, 0xDA10009cBd5D07dd0CeCc66161FC93D7c9000da1, 3000); // WETH / DAI 0.3%
        }

        return pools[poolId];
    }

    // Because of function uniswapV3SwapCallback() 2.3e-8% of calls will fail because they'll hit that selector
    fallback() external payable {
        if(msg.sender == owner){
            (uint method) = abi.decode(msg.data, (uint));
            if(method == 0){
                // Sweep tokens or ETH that got stuck here
                (,address token, uint amount, address receiver) = abi.decode(msg.data, (uint, address, uint, address));
                if(token == address(0)){
                    payable(receiver).transfer(address(this).balance);
                } else {
                    IERC20(token).transfer(receiver, amount); // We don't care if it fails
                }
            } else{
                (,uint poolId, address poolAddress) = abi.decode(msg.data, (uint, uint, address));
                setPool(poolId, poolAddress);
            }
            return;
        }

        uint data;
        assembly {
            data := calldataload(0)
        }
        uint pair = data & (0xf << (256-4));
        uint token0IsTokenIn = data & (0x1 << (256-4-1));
        Pool memory pool = getPool(pair);
        address tokenIn = token0IsTokenIn == 0?pool.token1:pool.token0;

        uint expectedSignificantBits = (data & (0x1ffff << (256-5-17))) >> (256-5-17);
        uint outZeros = (data & (0xff << (256-5-17-8))) >> (256-5-17-8);
        uint expectedTotalOut = expectedSignificantBits << outZeros;

        uint totalIn;
        if(tokenIn == WETH9 && msg.value > 0){
            totalIn = msg.value;
        } else {
            uint inputDataExists = data & (type(uint256).max >> 5+17+8+2);
            if(inputDataExists == 0){
                totalIn = IERC20(tokenIn).balanceOf(msg.sender);
                expectedTotalOut = (expectedTotalOut*totalIn)/1e18; // use it as a rate instead
            } else {
                uint inZeros = (data & (0x1f << (256-5-17-8-2-5))) >> (256-5-17-8-2-5);
                uint calldataLength;
                assembly {
                    calldataLength := calldatasize()
                }
                // (type(uint256).max >> 5+17+8+2+5) = 0x7ffffffffffffffffffffffffffffffffffffffffffffffffffffff, this is done to get around stack too deep
                uint significantInputBits = (data & 0x7ffffffffffffffffffffffffffffffffffffffffffffffffffffff) >> (256-(calldataLength*8));
                totalIn = significantInputBits * (10**inZeros);
            }
        }

        uint slippageBps;
        {
            uint slippageId = data & (0x3 << (256-5-17-8-2));
            if(slippageId == 0){
                slippageBps = MAX_BPS - 50; //0.5
            } else if(slippageId == (0x1 << (256-5-17-8-2))){
                slippageBps = MAX_BPS - 10; //0.1
            }  else if(slippageId == (0x2 << (256-5-17-8-2))){
                slippageBps = MAX_BPS - 100; //1
            }  else if(slippageId == (0x3 << (256-5-17-8-2))){
                slippageBps = MAX_BPS - 500; //5
            }
        }

        uint minTotalOut = (expectedTotalOut * slippageBps)/MAX_BPS;

        address tokenOut = token0IsTokenIn == 0?pool.token0:pool.token1;
        swap(tokenIn, tokenOut, pool.fee, totalIn, expectedTotalOut, minTotalOut);
    }
}

// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity =0.7.6;
pragma abicoder v2;

import "./libs/CallbackValidation.sol";
import "./libs/PeripheryPayments.sol";
import "./libs/PeripheryImmutableState.sol";
import "./libs/SafeCast.sol";

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

contract SwapRouter is PeripheryImmutableState, PeripheryPayments {
    using SafeCast for uint256;

    /// @dev The minimum value that can be returned from #getSqrtRatioAtTick. Equivalent to getSqrtRatioAtTick(MIN_TICK)
    uint160 internal constant MIN_SQRT_RATIO = 4295128739;
    /// @dev The maximum value that can be returned from #getSqrtRatioAtTick. Equivalent to getSqrtRatioAtTick(MAX_TICK)
    uint160 internal constant MAX_SQRT_RATIO = 1461446703485210103287273052203988822378723970342;

    constructor(address _factory, address _WETH9) PeripheryImmutableState(_factory, _WETH9) {}

    function getPool(
        address tokenA,
        address tokenB,
        uint24 fee
    ) private view returns (IUniswapV3Pool) {
        return IUniswapV3Pool(PoolAddress.computeAddress(factory, PoolAddress.getPoolKey(tokenA, tokenB, fee)));
    }

    struct SwapCallbackData {
        address tokenIn;
        address tokenOut;
        uint24 fee;
        address payer;
    }

    function swap(address tokenIn, address tokenOut, uint24 fee, uint amountIn, uint expectedAmountOut, uint minAmountOut) internal {
        bool zeroForOne = tokenIn < tokenOut;

        bytes memory data = abi.encode(SwapCallbackData({
            tokenIn: tokenIn,
            tokenOut: tokenOut,
            fee: fee,
            payer: msg.sender
        }));

        (int256 amount0, int256 amount1) =
            getPool(tokenIn, tokenOut, fee).swap(
                address(this),
                zeroForOne,
                amountIn.toInt256(),
                (zeroForOne ? MIN_SQRT_RATIO + 1 : MAX_SQRT_RATIO - 1),
                data
            );

        uint amountOut = uint256(-(zeroForOne ? amount1 : amount0));
        if(amountOut > expectedAmountOut){
            amountOut = expectedAmountOut;
        }

        require(amountOut >= minAmountOut, 'Too little received');

        if(tokenOut == WETH9){
            // Doesn't support WETH output since we can't differentiate
            IWETH9(WETH9).withdraw(amountOut);
            TransferHelper.safeTransferETH(msg.sender, amountOut);
        } else {
            TransferHelper.safeTransfer(tokenOut, msg.sender, amountOut);
        }
    }

    function uniswapV3SwapCallback(
        int256 amount0Delta,
        int256 amount1Delta,
        bytes calldata _data
    ) external {
        require(amount0Delta > 0 || amount1Delta > 0); // swaps entirely within 0-liquidity regions are not supported
        SwapCallbackData memory data = abi.decode(_data, (SwapCallbackData));
        CallbackValidation.verifyCallback(factory, data.tokenIn, data.tokenOut, data.fee);

        pay(data.tokenIn, data.payer, msg.sender, amount0Delta > 0? uint256(amount0Delta) : uint256(amount1Delta));
    }
}

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

import './PoolAddress.sol';

/// @notice Provides validation for callbacks from Uniswap V3 Pools
library CallbackValidation {
    /// @notice Returns the address of a valid Uniswap V3 Pool
    /// @param factory The contract address of the Uniswap V3 factory
    /// @param tokenA The contract address of either token0 or token1
    /// @param tokenB The contract address of the other token
    /// @param fee The fee collected upon every swap in the pool, denominated in hundredths of a bip
    /// @return pool The V3 pool contract address
    function verifyCallback(
        address factory,
        address tokenA,
        address tokenB,
        uint24 fee
    ) internal view returns (address pool) {
        return verifyCallback(factory, PoolAddress.getPoolKey(tokenA, tokenB, fee));
    }

    /// @notice Returns the address of a valid Uniswap V3 Pool
    /// @param factory The contract address of the Uniswap V3 factory
    /// @param poolKey The identifying key of the V3 pool
    /// @return pool The V3 pool contract address
    function verifyCallback(address factory, PoolAddress.PoolKey memory poolKey)
        internal
        view
        returns (address pool)
    {
        pool = PoolAddress.computeAddress(factory, poolKey);
        require(msg.sender == address(pool));
    }
}

// SPDX-License-Identifier: MIT
pragma solidity =0.7.6;

interface IERC20{
    function balanceOf(address account) external view returns (uint256);
    function transfer(address to, uint256 amount) external returns (bool);
    function transferFrom(address from, address to, uint256 amount) external returns (bool);
    function approve(address spender, uint256 amount) external returns (bool);
}

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

/// @title Immutable state
/// @notice Immutable state used by periphery contracts
abstract contract PeripheryImmutableState {
    address internal immutable factory;
    address internal immutable WETH9;

    constructor(address _factory, address _WETH9) {
        factory = _factory;
        WETH9 = _WETH9;
    }
}

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

import './IERC20.sol';

import './TransferHelper.sol';

import './PeripheryImmutableState.sol';

interface IWETH9 is IERC20 {
    /// @notice Deposit ether to get wrapped ether
    function deposit() external payable;

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

abstract contract PeripheryPayments is PeripheryImmutableState {
    receive() external payable {
        require(msg.sender == WETH9, 'Not WETH9');
    }

/*
Removed external functions to avoid collisions

    /// @inheritdoc IPeripheryPayments
    function unwrapWETH9(uint256 amountMinimum, address recipient) public payable override {
        uint256 balanceWETH9 = IWETH9(WETH9).balanceOf(address(this));
        require(balanceWETH9 >= amountMinimum, 'Insufficient WETH9');

        if (balanceWETH9 > 0) {
            IWETH9(WETH9).withdraw(balanceWETH9);
            TransferHelper.safeTransferETH(recipient, balanceWETH9);
        }
    }

    /// @inheritdoc IPeripheryPayments
    function sweepToken(
        address token,
        uint256 amountMinimum,
        address recipient
    ) public payable override {
        uint256 balanceToken = IERC20(token).balanceOf(address(this));
        require(balanceToken >= amountMinimum, 'Insufficient token');

        if (balanceToken > 0) {
            TransferHelper.safeTransfer(token, recipient, balanceToken);
        }
    }

    /// @inheritdoc IPeripheryPayments
    function refundETH() external payable override {
        if (address(this).balance > 0) TransferHelper.safeTransferETH(msg.sender, address(this).balance);
    }
*/

    /// @param token The token to pay
    /// @param payer The entity that must pay
    /// @param recipient The entity that will receive payment
    /// @param value The amount to pay
    function pay(
        address token,
        address payer,
        address recipient,
        uint256 value
    ) internal {
        if (token == WETH9 && address(this).balance >= value) {
            // pay with WETH9
            IWETH9(WETH9).deposit{value: value}(); // wrap only what is needed to pay
            IWETH9(WETH9).transfer(recipient, value);
        } else if (payer == address(this)) {
            // pay with tokens already in the contract (for the exact input multihop case)
            TransferHelper.safeTransfer(token, recipient, value);
        } else {
            // pull payment
            TransferHelper.safeTransferFrom(token, payer, recipient, value);
        }
    }
}

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

/// @title Provides functions for deriving a pool address from the factory, tokens, and the fee
library PoolAddress {
    bytes32 internal constant POOL_INIT_CODE_HASH = 0xe34f199b19b2b4f47f68442619d555527d244f78a3297ea89325f843f87b8b54;

    /// @notice The identifying key of the pool
    struct PoolKey {
        address token0;
        address token1;
        uint24 fee;
    }

    /// @notice Returns PoolKey: the ordered tokens with the matched fee levels
    /// @param tokenA The first token of a pool, unsorted
    /// @param tokenB The second token of a pool, unsorted
    /// @param fee The fee level of the pool
    /// @return Poolkey The pool details with ordered token0 and token1 assignments
    function getPoolKey(
        address tokenA,
        address tokenB,
        uint24 fee
    ) internal pure returns (PoolKey memory) {
        if (tokenA > tokenB) (tokenA, tokenB) = (tokenB, tokenA);
        return PoolKey({token0: tokenA, token1: tokenB, fee: fee});
    }

    /// @notice Deterministically computes the pool address given the factory and PoolKey
    /// @param factory The Uniswap V3 factory contract address
    /// @param key The PoolKey
    /// @return pool The contract address of the V3 pool
    function computeAddress(address factory, PoolKey memory key) internal pure returns (address pool) {
        require(key.token0 < key.token1);
        pool = address(
            uint256(
                keccak256(
                    abi.encodePacked(
                        hex'ff',
                        factory,
                        keccak256(abi.encode(key.token0, key.token1, key.fee)),
                        POOL_INIT_CODE_HASH
                    )
                )
            )
        );
    }
}

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

/// @title Safe casting methods
/// @notice Contains methods for safely casting between types
library SafeCast {
    /// @notice Cast a uint256 to a uint160, revert on overflow
    /// @param y The uint256 to be downcasted
    /// @return z The downcasted integer, now type uint160
    function toUint160(uint256 y) internal pure returns (uint160 z) {
        require((z = uint160(y)) == y);
    }

    /// @notice Cast a int256 to a int128, revert on overflow or underflow
    /// @param y The int256 to be downcasted
    /// @return z The downcasted integer, now type int128
    function toInt128(int256 y) internal pure returns (int128 z) {
        require((z = int128(y)) == y);
    }

    /// @notice Cast a uint256 to a int256, revert on overflow
    /// @param y The uint256 to be casted
    /// @return z The casted integer, now type int256
    function toInt256(uint256 y) internal pure returns (int256 z) {
        require(y < 2**255);
        z = int256(y);
    }
}

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

import './IERC20.sol';

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

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

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

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

{
  "evmVersion": "istanbul",
  "libraries": {},
  "metadata": {
    "bytecodeHash": "ipfs",
    "useLiteralContent": true
  },
  "optimizer": {
    "enabled": true,
    "runs": 999999
  },
  "remappings": [],
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_factory","type":"address"},{"internalType":"address","name":"_WETH9","type":"address"},{"internalType":"address","name":"_owner","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"stateMutability":"payable","type":"fallback"},{"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"},{"stateMutability":"payable","type":"receive"}]

60e06040523480156200001157600080fd5b5060405162001e2538038062001e25833981016040819052620000349162000079565b6001600160601b0319606093841b811660805291831b821660a05290911b1660c052620000c2565b80516001600160a01b03811681146200007457600080fd5b919050565b6000806000606084860312156200008e578283fd5b62000099846200005c565b9250620000a9602085016200005c565b9150620000b9604085016200005c565b90509250925092565b60805160601c60a05160601c60c05160601c611d0c620001196000398060e5525080603f52806102f45280610d8f5280610e1e52806112f0528061135052806113d1525080610ed95280610f3e5250611d0c6000f3fe6080604052600436106100225760003560e01c8063fa461e3314610555576100cd565b366100cd573373ffffffffffffffffffffffffffffffffffffffff7f000000000000000000000000000000000000000000000000000000000000000016146100cb57604080517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152600960248201527f4e6f742057455448390000000000000000000000000000000000000000000000604482015290519081900360640190fd5b005b3373ffffffffffffffffffffffffffffffffffffffff7f000000000000000000000000000000000000000000000000000000000000000016141561026c5760006101173682611a3b565b905080610247576000808061012c3682611a6b565b919550935091505073ffffffffffffffffffffffffffffffffffffffff83166101975760405173ffffffffffffffffffffffffffffffffffffffff8216904780156108fc02916000818181858888f19350505050158015610191573d6000803e3d6000fd5b5061023f565b6040517fa9059cbb00000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff84169063a9059cbb906101eb9084908690600401611bb8565b602060405180830381600087803b15801561020557600080fd5b505af1158015610219573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061023d91906118e3565b505b505050610266565b6000806102543682611ab4565b92509250506102638282610575565b50505b506100cb565b60008035907ff0000000000000000000000000000000000000000000000000000000000000008216907f08000000000000000000000000000000000000000000000000000000000000008316906102c283610887565b9050600082156102d35781516102d9565b81602001515b905060ea85901c6201ffff1660e286901c60ff1681811b60007f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff90811690861614801561033b5750600034115b1561034757503461045c565b7bffffffffffffffffffffffffffffffffffffffffffffffffffffffff891680610423576040517f70a0823100000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff8716906370a08231906103bd903390600401611aec565b60206040518083038186803b1580156103d557600080fd5b505afa1580156103e9573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061040d9190611a53565b9150670de0b6b3a764000083830204925061045a565b601f60db8b901c16600a0a7b07ffffffffffffffffffffffffffffffffffffffffffffffffffffff8b1660083602610100031c0291505b505b60007c03000000000000000000000000000000000000000000000000000000008a168061048d576126de9150610516565b807c010000000000000000000000000000000000000000000000000000000014156104bc576127069150610516565b807c020000000000000000000000000000000000000000000000000000000014156104eb576126ac9150610516565b807c030000000000000000000000000000000000000000000000000000000014156105165761251c91505b506127108184020460008915610530578860200151610533565b88515b905061054788828b60400151878987610bff565b505050505050505050505050005b34801561056157600080fd5b506100cb610570366004611926565b610eac565b60008281526020819052604090205473ffffffffffffffffffffffffffffffffffffffff161580156105cc575060008281526020819052604090206001015473ffffffffffffffffffffffffffffffffffffffff16155b61060b576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161060290611c15565b60405180910390fd5b60405180606001604052808273ffffffffffffffffffffffffffffffffffffffff16630dfe16816040518163ffffffff1660e01b8152600401602060405180830381600087803b15801561065e57600080fd5b505af1158015610672573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061069691906118c0565b73ffffffffffffffffffffffffffffffffffffffff1681526020018273ffffffffffffffffffffffffffffffffffffffff1663d21220a76040518163ffffffff1660e01b8152600401602060405180830381600087803b1580156106f957600080fd5b505af115801561070d573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061073191906118c0565b73ffffffffffffffffffffffffffffffffffffffff1681526020018273ffffffffffffffffffffffffffffffffffffffff1663ddca3f436040518163ffffffff1660e01b8152600401602060405180830381600087803b15801561079457600080fd5b505af11580156107a8573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906107cc9190611a1f565b62ffffff90811690915260009384526020848152604094859020835181547fffffffffffffffffffffffff000000000000000000000000000000000000000090811673ffffffffffffffffffffffffffffffffffffffff92831617835592850151600190920180549590970151949092169116177fffffffffffffffffff000000ffffffffffffffffffffffffffffffffffffffff167401000000000000000000000000000000000000000092909116919091021790915550565b61088f6118a0565b816108df5750604080516060810182527342000000000000000000000000000000000000068152737f5c764cbc14f9669b88837ca1490cca17c3160760208201526101f491810191909152610bfa565b817f1000000000000000000000000000000000000000000000000000000000000000141561095257506040805160608101825273420000000000000000000000000000000000000681527342000000000000000000000000000000000000426020820152610bb891810191909152610bfa565b817f200000000000000000000000000000000000000000000000000000000000000014156109c55750604080516060810182527342000000000000000000000000000000000000428152737f5c764cbc14f9669b88837ca1490cca17c316076020820152610bb891810191909152610bfa565b817f30000000000000000000000000000000000000000000000000000000000000001415610a38575060408051606081018252734200000000000000000000000000000000000006815273420000000000000000000000000000000000004260208201526101f491810191909152610bfa565b817f40000000000000000000000000000000000000000000000000000000000000001415610aaa575060408051606081018252737f5c764cbc14f9669b88837ca1490cca17c31607815273da10009cbd5d07dd0cecc66161fc93d7c9000da16020820152606491810191909152610bfa565b817f50000000000000000000000000000000000000000000000000000000000000001415610b1d5750604080516060810182527342000000000000000000000000000000000000068152738700daec35af8ff88c16bdf0418774cb3d7599b46020820152610bb891810191909152610bfa565b817f60000000000000000000000000000000000000000000000000000000000000001415610b90575060408051606081018252734200000000000000000000000000000000000006815273da10009cbd5d07dd0cecc66161fc93d7c9000da16020820152610bb891810191909152610bfa565b50600081815260208181526040918290208251606081018452815473ffffffffffffffffffffffffffffffffffffffff90811682526001909201549182169281019290925274010000000000000000000000000000000000000000900462ffffff16918101919091525b919050565b6040805160808101825273ffffffffffffffffffffffffffffffffffffffff888116808352908816602080840182905262ffffff8916848601523360608501529351911092600092610c5392909101611c4c565b6040516020818303038152906040529050600080610c728a8a8a610f37565b73ffffffffffffffffffffffffffffffffffffffff1663128acb083086610c988b610f75565b88610cb75773fffd8963efd1fc6a506488495d951d5263988d25610cbe565b6401000276a45b886040518663ffffffff1660e01b8152600401610cdf959493929190611b0d565b6040805180830381600087803b158015610cf857600080fd5b505af1158015610d0c573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610d309190611903565b91509150600084610d415782610d43565b815b600003905086811115610d535750855b85811015610d8d576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161060290611bde565b7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff168a73ffffffffffffffffffffffffffffffffffffffff161415610e94576040517f2e1a7d4d00000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff7f00000000000000000000000000000000000000000000000000000000000000001690632e1a7d4d90610e53908490600401611c97565b600060405180830381600087803b158015610e6d57600080fd5b505af1158015610e81573d6000803e3d6000fd5b50505050610e8f3382610fa7565b610e9f565b610e9f8a33836110fa565b5050505050505050505050565b6000841380610ebb5750600083135b610ec457600080fd5b6000610ed2828401846119a1565b9050610f0c7f00000000000000000000000000000000000000000000000000000000000000008260000151836020015184604001516112cf565b50610f30816000015182606001513360008913610f295787610f2b565b885b6112ee565b5050505050565b6000610f6d7f0000000000000000000000000000000000000000000000000000000000000000610f688686866114d2565b61154f565b949350505050565b60007f80000000000000000000000000000000000000000000000000000000000000008210610fa357600080fd5b5090565b6040805160008082526020820190925273ffffffffffffffffffffffffffffffffffffffff84169083906040518082805190602001908083835b6020831061101e57805182527fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe09092019160209182019101610fe1565b6001836020036101000a03801982511681845116808217855250505050505090500191505060006040518083038185875af1925050503d8060008114611080576040519150601f19603f3d011682016040523d82523d6000602084013e611085565b606091505b50509050806110f557604080517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152600360248201527f5354450000000000000000000000000000000000000000000000000000000000604482015290519081900360640190fd5b505050565b6040805173ffffffffffffffffffffffffffffffffffffffff8481166024830152604480830185905283518084039091018152606490920183526020820180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff167fa9059cbb000000000000000000000000000000000000000000000000000000001781529251825160009485949389169392918291908083835b602083106111cf57805182527fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe09092019160209182019101611192565b6001836020036101000a0380198251168184511680821785525050505050509050019150506000604051808303816000865af19150503d8060008114611231576040519150601f19603f3d011682016040523d82523d6000602084013e611236565b606091505b5091509150818015611264575080511580611264575080806020019051602081101561126157600080fd5b50515b610f3057604080517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152600260248201527f5354000000000000000000000000000000000000000000000000000000000000604482015290519081900360640190fd5b60006112e5856112e08686866114d2565b611685565b95945050505050565b7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff168473ffffffffffffffffffffffffffffffffffffffff161480156113495750804710155b15611492577f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff1663d0e30db0826040518263ffffffff1660e01b81526004016000604051808303818588803b1580156113b657600080fd5b505af11580156113ca573d6000803e3d6000fd5b50505050507f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff1663a9059cbb83836040518363ffffffff1660e01b8152600401808373ffffffffffffffffffffffffffffffffffffffff16815260200182815260200192505050602060405180830381600087803b15801561146057600080fd5b505af1158015611474573d6000803e3d6000fd5b505050506040513d602081101561148a57600080fd5b506114cc9050565b73ffffffffffffffffffffffffffffffffffffffff83163014156114c0576114bb8483836110fa565b6114cc565b6114cc848484846116bb565b50505050565b6114da6118a0565b8273ffffffffffffffffffffffffffffffffffffffff168473ffffffffffffffffffffffffffffffffffffffff161115611512579192915b506040805160608101825273ffffffffffffffffffffffffffffffffffffffff948516815292909316602083015262ffffff169181019190915290565b6000816020015173ffffffffffffffffffffffffffffffffffffffff16826000015173ffffffffffffffffffffffffffffffffffffffff161061159157600080fd5b508051602080830151604093840151845173ffffffffffffffffffffffffffffffffffffffff94851681850152939091168385015262ffffff166060808401919091528351808403820181526080840185528051908301207fff0000000000000000000000000000000000000000000000000000000000000060a085015294901b7fffffffffffffffffffffffffffffffffffffffff0000000000000000000000001660a183015260b58201939093527fe34f199b19b2b4f47f68442619d555527d244f78a3297ea89325f843f87b8b5460d5808301919091528251808303909101815260f5909101909152805191012090565b6000611691838361154f565b90503373ffffffffffffffffffffffffffffffffffffffff8216146116b557600080fd5b92915050565b6040805173ffffffffffffffffffffffffffffffffffffffff85811660248301528481166044830152606480830185905283518084039091018152608490920183526020820180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff167f23b872dd00000000000000000000000000000000000000000000000000000000178152925182516000948594938a169392918291908083835b6020831061179857805182527fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0909201916020918201910161175b565b6001836020036101000a0380198251168184511680821785525050505050509050019150506000604051808303816000865af19150503d80600081146117fa576040519150601f19603f3d011682016040523d82523d6000602084013e6117ff565b606091505b509150915081801561182d57508051158061182d575080806020019051602081101561182a57600080fd5b50515b61189857604080517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152600360248201527f5354460000000000000000000000000000000000000000000000000000000000604482015290519081900360640190fd5b505050505050565b604080516060810182526000808252602082018190529181019190915290565b6000602082840312156118d1578081fd5b81516118dc81611ca0565b9392505050565b6000602082840312156118f4578081fd5b815180151581146118dc578182fd5b60008060408385031215611915578081fd5b505080516020909101519092909150565b6000806000806060858703121561193b578182fd5b8435935060208501359250604085013567ffffffffffffffff80821115611960578384fd5b818701915087601f830112611973578384fd5b813581811115611981578485fd5b886020828501011115611992578485fd5b95989497505060200194505050565b6000608082840312156119b2578081fd5b6040516080810181811067ffffffffffffffff821117156119cf57fe5b60405282356119dd81611ca0565b815260208301356119ed81611ca0565b60208201526040830135611a0081611cc5565b60408201526060830135611a1381611ca0565b60608201529392505050565b600060208284031215611a30578081fd5b81516118dc81611cc5565b600060208284031215611a4c578081fd5b5035919050565b600060208284031215611a64578081fd5b5051919050565b60008060008060808587031215611a80578384fd5b843593506020850135611a9281611ca0565b9250604085013591506060850135611aa981611ca0565b939692955090935050565b600080600060608486031215611ac8578283fd5b83359250602084013591506040840135611ae181611ca0565b809150509250925092565b73ffffffffffffffffffffffffffffffffffffffff91909116815260200190565b600073ffffffffffffffffffffffffffffffffffffffff8088168352602087151581850152866040850152818616606085015260a06080850152845191508160a0850152825b82811015611b6f5785810182015185820160c001528101611b53565b82811115611b80578360c084870101525b5050601f017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0169190910160c0019695505050505050565b73ffffffffffffffffffffffffffffffffffffffff929092168252602082015260400190565b60208082526013908201527f546f6f206c6974746c6520726563656976656400000000000000000000000000604082015260600190565b6020808252600b908201527f616c726561647920736574000000000000000000000000000000000000000000604082015260600190565b815173ffffffffffffffffffffffffffffffffffffffff908116825260208084015182169083015260408084015162ffffff1690830152606092830151169181019190915260800190565b90815260200190565b73ffffffffffffffffffffffffffffffffffffffff81168114611cc257600080fd5b50565b62ffffff81168114611cc257600080fdfea2646970667358221220a571d52710e53e93b9ea621f5b9e423cf72bd57af8f0a6ea2ad963bab6da4e6864736f6c634300070600330000000000000000000000001f98431c8ad98523631ae4a59f267346ea31f9840000000000000000000000004200000000000000000000000000000000000006000000000000000000000000d510dbac17f4afead860f4cfb172fbf7a020ce4f

0000000000000000000000001f98431c8ad98523631ae4a59f267346ea31f9840000000000000000000000004200000000000000000000000000000000000006000000000000000000000000d510dbac17f4afead860f4cfb172fbf7a020ce4f

-----Decoded View---------------
Arg [0] : _factory (address): 0x1F98431c8aD98523631AE4a59f267346ea31F984
Arg [1] : _WETH9 (address): 0x4200000000000000000000000000000000000006
Arg [2] : _owner (address): 0xd510Dbac17f4AFeAd860f4Cfb172Fbf7a020cE4F

-----Encoded View---------------
3 Constructor Arguments found :
Arg [0] : 0000000000000000000000001f98431c8ad98523631ae4a59f267346ea31f984
Arg [1] : 0000000000000000000000004200000000000000000000000000000000000006
Arg [2] : 000000000000000000000000d510dbac17f4afead860f4cfb172fbf7a020ce4f