{
    {
        let _1 := 64
        mstore(_1, 128)
        if iszero(lt(calldatasize(), 4))
        {
            let _2 := 0
            switch shr(224, calldataload(_2))
            case 0x37fe974a {
                if callvalue() { revert(_2, _2) }
                let ret := fun_computeLiquidity(abi_decode_tuple_address(calldatasize()))
                let memPos := mload(_1)
                return(memPos, sub(abi_encode_tuple_struct_LiquidityStatus(memPos, ret), memPos))
            }
            case 0x41976e09 {
                if callvalue() { revert(_2, _2) }
                let ret_1, ret_2 := fun_getPrice(abi_decode_tuple_address(calldatasize()))
                let memPos_1 := mload(_1)
                return(memPos_1, sub(abi_encode_uint256_uint256(memPos_1, ret_1, ret_2), memPos_1))
            }
            case 0x69a92ea3 {
                if callvalue() { revert(_2, _2) }
                abi_decode_12552(calldatasize())
                let memPos_2 := mload(_1)
                return(memPos_2, sub(abi_encode_bytes32(memPos_2, loadimmutable("3064")), memPos_2))
            }
            case 0x8eddcd92 {
                if callvalue() { revert(_2, _2) }
                let ret_3 := fun_getNewMarketParameters(abi_decode_tuple_address(calldatasize()))
                let memPos_3 := mload(_1)
                return(memPos_3, sub(abi_encode_struct_NewMarketParameters(memPos_3, ret_3), memPos_3))
            }
            case 0x9693fa6b {
                if callvalue() { revert(_2, _2) }
                let ret_4, ret_5, ret_6 := fun_getPriceFull(abi_decode_tuple_address(calldatasize()))
                let memPos_4 := mload(_1)
                return(memPos_4, sub(abi_encode_uint256_uint256_uint256(memPos_4, ret_4, ret_5, ret_6), memPos_4))
            }
            case 0xa1308f27 {
                if callvalue() { revert(_2, _2) }
                abi_decode_12552(calldatasize())
                let memPos_5 := mload(_1)
                return(memPos_5, sub(abi_encode_bytes32(memPos_5, loadimmutable("3062")), memPos_5))
            }
            case 0xc39b543a {
                if callvalue() { revert(_2, _2) }
                fun_requireLiquidity(abi_decode_tuple_address(calldatasize()))
                return(mload(_1), _2)
            }
            case 0xebd7ba19 {
                if callvalue() { revert(_2, _2) }
                let ret_7 := fun_computeAssetLiquidities(abi_decode_tuple_address(calldatasize()))
                let memPos_6 := mload(_1)
                return(memPos_6, sub(abi_encode_array_struct_AssetLiquidity_dyn(memPos_6, ret_7), memPos_6))
            }
            case 0xf70c2fde {
                if callvalue() { revert(_2, _2) }
                let param, param_1 := abi_decode_struct_AssetCachet_struct_AssetConfig(calldatasize())
                let var_twap, var_twapPeriod := modifier_FREEMEM(param, param_1)
                let memPos_7 := mload(_1)
                return(memPos_7, sub(abi_encode_uint256_uint256(memPos_7, var_twap, var_twapPeriod), memPos_7))
            }
        }
        revert(0, 0)
    }
    function cleanup_address(value) -> cleaned
    {
        cleaned := and(value, sub(shl(160, 1), 1))
    }
    function validator_revert_address(value)
    {
        if iszero(eq(value, and(value, sub(shl(160, 1), 1)))) { revert(0, 0) }
    }
    function abi_decode_address() -> value
    {
        value := calldataload(4)
        validator_revert_address(value)
    }
    function abi_decode_tuple_address(dataEnd) -> value0
    {
        if slt(add(dataEnd, not(3)), 32) { revert(0, 0) }
        let value := calldataload(4)
        validator_revert_address(value)
        value0 := value
    }
    function cleanup_bool(value) -> cleaned
    {
        cleaned := iszero(iszero(value))
    }
    function abi_encode_struct_LiquidityStatus(value, pos)
    {
        mstore(pos, mload(value))
        mstore(add(pos, 0x20), mload(add(value, 0x20)))
        mstore(add(pos, 0x40), mload(add(value, 0x40)))
        mstore(add(pos, 0x60), iszero(iszero(mload(add(value, 0x60)))))
    }
    function abi_encode_tuple_struct_LiquidityStatus(headStart, value0) -> tail
    {
        tail := add(headStart, 128)
        abi_encode_struct_LiquidityStatus(value0, headStart)
    }
    function abi_encode_uint256_uint256(headStart, value0, value1) -> tail
    {
        tail := add(headStart, 64)
        mstore(headStart, value0)
        mstore(add(headStart, 32), value1)
    }
    function abi_decode_12552(dataEnd)
    {
        if slt(add(dataEnd, not(3)), 0) { revert(0, 0) }
    }
    function abi_decode(headStart, dataEnd)
    {
        if slt(sub(dataEnd, headStart), 0) { revert(0, 0) }
    }
    function abi_encode_bytes32(headStart, value0) -> tail
    {
        tail := add(headStart, 32)
        mstore(headStart, value0)
    }
    function cleanup_uint32(value) -> cleaned
    {
        cleaned := and(value, 0xffffffff)
    }
    function cleanup_uint24(value) -> cleaned
    {
        cleaned := and(value, 0xffffff)
    }
    function abi_encode_struct_NewMarketParameters(headStart, value0) -> tail
    {
        tail := add(headStart, 224)
        mstore(headStart, and(mload(value0), 0xffff))
        let _1 := 0xffffffff
        mstore(add(headStart, 0x20), and(mload(add(value0, 0x20)), _1))
        let memberValue0 := mload(add(value0, 0x40))
        mstore(add(headStart, 0x40), and(mload(memberValue0), sub(shl(160, 1), 1)))
        mstore(add(headStart, 96), iszero(iszero(mload(add(memberValue0, 0x20)))))
        mstore(add(headStart, 128), and(mload(add(memberValue0, 0x40)), _1))
        mstore(add(headStart, 160), and(mload(add(memberValue0, 96)), _1))
        mstore(add(headStart, 192), and(mload(add(memberValue0, 128)), 0xffffff))
    }
    function abi_encode_uint256_uint256_uint256(headStart, value0, value1, value2) -> tail
    {
        tail := add(headStart, 96)
        mstore(headStart, value0)
        mstore(add(headStart, 32), value1)
        mstore(add(headStart, 64), value2)
    }
    function abi_encode_array_struct_AssetLiquidity_dyn(headStart, value0) -> tail
    {
        let _1 := 32
        let tail_1 := add(headStart, _1)
        mstore(headStart, _1)
        let pos := tail_1
        let length := mload(value0)
        mstore(tail_1, length)
        pos := add(headStart, 64)
        let srcPtr := add(value0, _1)
        let i := 0
        for { } lt(i, length) { i := add(i, 1) }
        {
            let _2 := mload(srcPtr)
            mstore(pos, and(mload(_2), sub(shl(160, 1), 1)))
            let memberValue0 := mload(add(_2, _1))
            abi_encode_struct_LiquidityStatus(memberValue0, add(pos, _1))
            pos := add(pos, 160)
            srcPtr := add(srcPtr, _1)
        }
        tail := pos
    }
    function panic_error_0x41()
    {
        mstore(0, shl(224, 0x4e487b71))
        mstore(4, 0x41)
        revert(0, 0x24)
    }
    function finalize_allocation_12563(memPtr)
    {
        let newFreePtr := add(memPtr, 160)
        if or(gt(newFreePtr, 0xffffffffffffffff), lt(newFreePtr, memPtr)) { panic_error_0x41() }
        mstore(64, newFreePtr)
    }
    function finalize_allocation_12670(memPtr)
    {
        let newFreePtr := add(memPtr, 64)
        if or(gt(newFreePtr, 0xffffffffffffffff), lt(newFreePtr, memPtr)) { panic_error_0x41() }
        mstore(64, newFreePtr)
    }
    function finalize_allocation_22851(memPtr)
    {
        let newFreePtr := add(memPtr, 128)
        if or(gt(newFreePtr, 0xffffffffffffffff), lt(newFreePtr, memPtr)) { panic_error_0x41() }
        mstore(64, newFreePtr)
    }
    function finalize_allocation_22852(memPtr)
    {
        let newFreePtr := add(memPtr, 96)
        if or(gt(newFreePtr, 0xffffffffffffffff), lt(newFreePtr, memPtr)) { panic_error_0x41() }
        mstore(64, newFreePtr)
    }
    function finalize_allocation(memPtr, size)
    {
        let newFreePtr := add(memPtr, and(add(size, 31), not(31)))
        if or(gt(newFreePtr, 0xffffffffffffffff), lt(newFreePtr, memPtr)) { panic_error_0x41() }
        mstore(64, newFreePtr)
    }
    function allocate_memory_12562() -> memPtr
    {
        memPtr := mload(64)
        let newFreePtr := add(memPtr, 0x01e0)
        if or(gt(newFreePtr, 0xffffffffffffffff), lt(newFreePtr, memPtr)) { panic_error_0x41() }
        mstore(64, newFreePtr)
    }
    function allocate_memory() -> memPtr
    {
        memPtr := mload(64)
        finalize_allocation_22851(memPtr)
    }
    function cleanup_uint112(value) -> cleaned
    {
        cleaned := and(value, 0xffffffffffffffffffffffffffff)
    }
    function abi_decode_uint112() -> value
    {
        value := calldataload(36)
        if iszero(eq(value, and(value, 0xffffffffffffffffffffffffffff))) { revert(0, 0) }
    }
    function cleanup_uint144(value) -> cleaned
    {
        cleaned := and(value, 0xffffffffffffffffffffffffffffffffffff)
    }
    function abi_decode_uint144() -> value
    {
        value := calldataload(68)
        if iszero(eq(value, and(value, 0xffffffffffffffffffffffffffffffffffff))) { revert(0, 0) }
    }
    function cleanup_uint96(value) -> cleaned
    {
        cleaned := and(value, 0xffffffffffffffffffffffff)
    }
    function abi_decode_uint96() -> value
    {
        value := calldataload(100)
        if iszero(eq(value, and(value, 0xffffffffffffffffffffffff))) { revert(0, 0) }
    }
    function cleanup_uint40(value) -> cleaned
    {
        cleaned := and(value, 0xffffffffff)
    }
    function abi_decode_uint40() -> value
    {
        value := calldataload(164)
        if iszero(eq(value, and(value, 0xffffffffff))) { revert(0, 0) }
    }
    function validator_revert_uint8(value)
    {
        if iszero(eq(value, and(value, 0xff))) { revert(0, 0) }
    }
    function abi_decode_uint8() -> value
    {
        value := calldataload(196)
        validator_revert_uint8(value)
    }
    function validator_revert_uint32(value)
    {
        if iszero(eq(value, and(value, 0xffffffff))) { revert(0, 0) }
    }
    function abi_decode_uint32_22844() -> value
    {
        value := calldataload(228)
        validator_revert_uint32(value)
    }
    function abi_decode_uint32_22846() -> value
    {
        value := calldataload(292)
        validator_revert_uint32(value)
    }
    function abi_decode_uint32() -> value
    {
        value := calldataload(356)
        validator_revert_uint32(value)
    }
    function cleanup_int96(value) -> cleaned
    {
        cleaned := signextend(11, value)
    }
    function abi_decode_int96() -> value
    {
        value := calldataload(260)
        if iszero(eq(value, signextend(11, value))) { revert(0, 0) }
    }
    function validator_revert_uint16(value)
    {
        if iszero(eq(value, and(value, 0xffff))) { revert(0, 0) }
    }
    function abi_decode_uint16() -> value
    {
        value := calldataload(324)
        validator_revert_uint16(value)
    }
    function validator_revert_bool(value)
    {
        if iszero(eq(value, iszero(iszero(value)))) { revert(0, 0) }
    }
    function abi_decode_struct_AssetConfig(end) -> value
    {
        if slt(add(end, not(483)), 0xa0) { revert(0, 0) }
        let memPtr := mload(64)
        let newFreePtr := add(memPtr, 0xa0)
        if or(gt(newFreePtr, 0xffffffffffffffff), lt(newFreePtr, memPtr)) { panic_error_0x41() }
        mstore(64, newFreePtr)
        value := memPtr
        let value_1 := calldataload(484)
        validator_revert_address(value_1)
        mstore(memPtr, value_1)
        let value_2 := calldataload(516)
        validator_revert_bool(value_2)
        mstore(add(memPtr, 32), value_2)
        let value_3 := calldataload(548)
        validator_revert_uint32(value_3)
        mstore(add(memPtr, 64), value_3)
        let value_4 := calldataload(580)
        validator_revert_uint32(value_4)
        mstore(add(memPtr, 96), value_4)
        let value_5 := calldataload(612)
        if iszero(eq(value_5, and(value_5, 0xffffff))) { revert(0, 0) }
        mstore(add(memPtr, 128), value_5)
    }
    function abi_decode_struct_AssetCachet_struct_AssetConfig(dataEnd) -> value0, value1
    {
        let _1 := add(dataEnd, not(3))
        if slt(_1, 640) { revert(0, 0) }
        if slt(_1, 0x01e0) { revert(0, 0) }
        let value := allocate_memory_12562()
        mstore(value, abi_decode_address())
        mstore(add(value, 32), abi_decode_uint112())
        mstore(add(value, 64), abi_decode_uint144())
        mstore(add(value, 96), abi_decode_uint96())
        mstore(add(value, 128), calldataload(132))
        mstore(add(value, 160), abi_decode_uint40())
        mstore(add(value, 192), abi_decode_uint8())
        mstore(add(value, 224), abi_decode_uint32_22844())
        mstore(add(value, 256), abi_decode_int96())
        mstore(add(value, 288), abi_decode_uint32_22846())
        mstore(add(value, 320), abi_decode_uint16())
        mstore(add(value, 352), abi_decode_uint32())
        mstore(add(value, 384), calldataload(388))
        mstore(add(value, 416), calldataload(420))
        mstore(add(value, 448), calldataload(452))
        value0 := value
        value1 := abi_decode_struct_AssetConfig(dataEnd)
    }
    function allocate_and_zero_memory_struct_struct_AssetConfig() -> memPtr
    {
        let memPtr_1 := mload(64)
        finalize_allocation_12563(memPtr_1)
        memPtr := memPtr_1
        mstore(memPtr_1, 0)
        mstore(add(memPtr_1, 32), 0)
        mstore(add(memPtr_1, 64), 0)
        mstore(add(memPtr_1, 96), 0)
        mstore(add(memPtr_1, 128), 0)
    }
    function allocate_and_zero_memory_struct_struct_NewMarketParameters() -> memPtr
    {
        let memPtr_1 := mload(64)
        let newFreePtr := add(memPtr_1, 96)
        if or(gt(newFreePtr, 0xffffffffffffffff), lt(newFreePtr, memPtr_1)) { panic_error_0x41() }
        mstore(64, newFreePtr)
        memPtr := memPtr_1
        mstore(memPtr_1, 0)
        mstore(add(memPtr_1, 32), 0)
        mstore(add(memPtr_1, 64), allocate_and_zero_memory_struct_struct_AssetConfig())
    }
    function write_to_memory_bool(memPtr)
    { mstore(memPtr, 0x01) }
    function write_to_memory_uint32_12567(memPtr)
    { mstore(memPtr, 0xffffffff) }
    function write_to_memory_uint32_12631(memPtr)
    { mstore(memPtr, 0x42c1d800) }
    function write_to_memory_uint32(memPtr, value)
    {
        mstore(memPtr, and(value, 0xffffffff))
    }
    function write_to_memory_uint24_12568(memPtr)
    { mstore(memPtr, 16777215) }
    function write_to_memory_uint24_12571(memPtr)
    { mstore(memPtr, 3000) }
    function write_to_memory_uint24_12572(memPtr)
    { mstore(memPtr, 10000) }
    function write_to_memory_uint24_12573(memPtr)
    { mstore(memPtr, 500) }
    function write_to_memory_uint24_12574(memPtr)
    { mstore(memPtr, 100) }
    function write_to_memory_uint24(memPtr)
    { mstore(memPtr, 1800) }
    function mapping_index_access_mapping_address_address_of_address_12569(key) -> dataSlot
    {
        mstore(0, and(key, sub(shl(160, 1), 1)))
        mstore(0x20, 0x0b)
        dataSlot := keccak256(0, 0x40)
    }
    function mapping_index_access_mapping_address_address_of_address_12580(key) -> dataSlot
    {
        mstore(0, and(key, sub(shl(160, 1), 1)))
        mstore(0x20, 0x08)
        dataSlot := keccak256(0, 0x40)
    }
    function mapping_index_access_mapping_address_address_of_address_12628(key) -> dataSlot
    {
        mstore(0, and(key, sub(shl(160, 1), 1)))
        mstore(0x20, 0x09)
        dataSlot := keccak256(0, 0x40)
    }
    function mapping_index_access_mapping_address_address_of_address_12656(key) -> dataSlot
    {
        mstore(0, and(key, sub(shl(160, 1), 1)))
        mstore(0x20, 0x07)
        dataSlot := keccak256(0, 0x40)
    }
    function mapping_index_access_mapping_address_address_of_address(slot, key) -> dataSlot
    {
        mstore(0, and(key, sub(shl(160, 1), 1)))
        mstore(0x20, slot)
        dataSlot := keccak256(0, 0x40)
    }
    function read_from_storage_split_offset_address(slot) -> value
    {
        value := and(sload(slot), sub(shl(160, 1), 1))
    }
    function panic_error_0x11()
    {
        mstore(0, shl(224, 0x4e487b71))
        mstore(4, 0x11)
        revert(0, 0x24)
    }
    function increment_uint256(value) -> ret
    {
        if eq(value, not(0)) { panic_error_0x11() }
        ret := add(value, 1)
    }
    function panic_error_0x32()
    {
        mstore(0, shl(224, 0x4e487b71))
        mstore(4, 0x32)
        revert(0, 0x24)
    }
    function memory_array_index_access_uint24(baseRef, index) -> addr
    {
        if iszero(lt(index, 0x04)) { panic_error_0x32() }
        addr := add(baseRef, shl(5, index))
    }
    function read_from_memoryt_uint24(ptr) -> returnValue
    {
        returnValue := and(mload(ptr), 0xffffff)
    }
    function abi_decode_address_fromMemory(headStart, dataEnd) -> value0
    {
        if slt(sub(dataEnd, headStart), 32) { revert(0, 0) }
        let value := mload(headStart)
        validator_revert_address(value)
        value0 := value
    }
    function abi_encode_address_address_uint24(headStart, value0, value1, value2) -> tail
    {
        tail := add(headStart, 96)
        let _1 := sub(shl(160, 1), 1)
        mstore(headStart, and(value0, _1))
        mstore(add(headStart, 32), and(value1, _1))
        mstore(add(headStart, 64), and(value2, 0xffffff))
    }
    function revert_forward()
    {
        let pos := mload(64)
        returndatacopy(pos, 0, returndatasize())
        revert(pos, returndatasize())
    }
    function abi_decode_uint128_fromMemory(headStart, dataEnd) -> value0
    {
        if slt(sub(dataEnd, headStart), 32) { revert(0, 0) }
        let value := mload(headStart)
        if iszero(eq(value, and(value, 0xffffffffffffffffffffffffffffffff))) { revert(0, 0) }
        value0 := value
    }
    function require_helper_stringliteral_15dc(condition)
    {
        if iszero(condition)
        {
            let memPtr := mload(64)
            mstore(memPtr, shl(229, 4594637))
            mstore(add(memPtr, 4), 32)
            mstore(add(memPtr, 36), 23)
            mstore(add(memPtr, 68), "e/no-uniswap-pool-avail")
            revert(memPtr, 100)
        }
    }
    function require_helper_stringliteral_cad5(condition)
    {
        if iszero(condition)
        {
            let memPtr := mload(64)
            mstore(memPtr, shl(229, 4594637))
            mstore(add(memPtr, 4), 32)
            mstore(add(memPtr, 36), 23)
            mstore(add(memPtr, 68), "e/bad-uniswap-pool-addr")
            revert(memPtr, 100)
        }
    }
    function write_to_memory_uint16_12575(memPtr)
    { mstore(memPtr, 2) }
    function write_to_memory_uint16_12577(memPtr)
    { mstore(memPtr, 3) }
    function write_to_memory_uint16_12581(memPtr)
    { mstore(memPtr, 1) }
    function write_to_memory_uint16(memPtr, value)
    {
        mstore(memPtr, and(value, 0xffff))
    }
    function abi_encode_uint16_to_uint16(headStart) -> tail
    {
        tail := add(headStart, 32)
        mstore(headStart, 10)
    }
    function abi_encode_uint16(headStart, value0) -> tail
    {
        tail := add(headStart, 32)
        mstore(headStart, and(value0, 0xffff))
    }
    function return_data_selector() -> sig
    {
        if gt(returndatasize(), 3)
        {
            returndatacopy(0, 0, 4)
            sig := shr(224, mload(0))
        }
    }
    function try_decode_error_message() -> ret
    {
        if lt(returndatasize(), 0x44) { leave }
        let data := mload(64)
        let _1 := not(3)
        returndatacopy(data, 4, add(returndatasize(), _1))
        let offset := mload(data)
        let _2 := returndatasize()
        let _3 := 0xffffffffffffffff
        if or(gt(offset, _3), gt(add(offset, 0x24), _2)) { leave }
        let msg := add(data, offset)
        let length := mload(msg)
        if gt(length, _3) { leave }
        if gt(add(add(msg, length), 0x20), add(add(data, returndatasize()), _1)) { leave }
        finalize_allocation(data, add(add(offset, length), 0x20))
        ret := msg
    }
    function abi_encode_stringliteral(headStart) -> tail
    {
        mstore(headStart, 32)
        mstore(add(headStart, 32), 30)
        mstore(add(headStart, 64), "e/risk/uniswap-pool-not-inited")
        tail := add(headStart, 96)
    }
    function abi_encode_stringliteral_92b3(pos) -> end
    {
        mstore(pos, "e/risk/uniswap/")
        end := add(pos, 15)
    }
    function copy_memory_to_memory(src, dst, length)
    {
        let i := 0
        for { } lt(i, length) { i := add(i, 32) }
        {
            mstore(add(dst, i), mload(add(src, i)))
        }
        if gt(i, length) { mstore(add(dst, length), 0) }
    }
    function abi_encode_string_memory_ptr(value, pos) -> end
    {
        let length := mload(value)
        copy_memory_to_memory(add(value, 0x20), pos, length)
        end := add(pos, length)
    }
    function abi_encode_string(headStart, value0) -> tail
    {
        mstore(headStart, 32)
        let length := mload(value0)
        mstore(add(headStart, 32), length)
        copy_memory_to_memory(add(value0, 32), add(headStart, 64), length)
        tail := add(add(headStart, and(add(length, 31), not(31))), 64)
    }
    function extract_returndata() -> data
    {
        switch returndatasize()
        case 0 { data := 96 }
        default {
            let _1 := returndatasize()
            if gt(_1, 0xffffffffffffffff) { panic_error_0x41() }
            let memPtr := mload(64)
            finalize_allocation(memPtr, add(and(add(_1, 31), not(31)), 0x20))
            mstore(memPtr, _1)
            data := memPtr
            returndatacopy(add(memPtr, 0x20), 0, returndatasize())
        }
    }
    function read_from_storage_split_offset_uint32(slot) -> value
    {
        value := and(shr(168, sload(slot)), 0xffffffff)
    }
    /// @ast-id 10602
    function fun_getNewMarketParameters(var_underlying) -> var_p_mpos
    {
        var_p_mpos := allocate_and_zero_memory_struct_struct_NewMarketParameters()
        let _1 := 64
        let _2 := add(var_p_mpos, _1)
        let _3 := 32
        write_to_memory_bool(add(mload(_2), _3))
        let _4 := 0
        mstore(add(mload(_2), _1), _4)
        write_to_memory_uint32_12567(add(mload(_2), 96))
        write_to_memory_uint24_12568(add(mload(_2), 128))
        let _5 := loadimmutable("10268")
        let _6 := sub(shl(160, 1), 1)
        switch eq(and(var_underlying, _6), and(_5, _6))
        case 0 {
            switch iszero(iszero(and(read_from_storage_split_offset_address(mapping_index_access_mapping_address_address_of_address_12569(var_underlying)), _6)))
            case 0 {
                let var_pool := _4
                let var_fee := _4
                let expr_10439_mpos := allocate_memory()
                write_to_memory_uint24_12571(expr_10439_mpos)
                write_to_memory_uint24_12572(add(expr_10439_mpos, _3))
                write_to_memory_uint24_12573(add(expr_10439_mpos, _1))
                write_to_memory_uint24_12574(add(expr_10439_mpos, 96))
                let var_bestLiquidity := _4
                let var_i := _4
                let _7 := and(loadimmutable("10270"), _6)
                for { }
                1
                {
                    var_i := increment_uint256(var_i)
                }
                {
                    let _8 := 4
                    if iszero(lt(var_i, _8)) { break }
                    let _9 := read_from_memoryt_uint24(memory_array_index_access_uint24(expr_10439_mpos, var_i))
                    let _10 := mload(_1)
                    mstore(_10, shl(225, 0x0b4c7741))
                    let _11 := staticcall(gas(), _7, _10, sub(abi_encode_address_address_uint24(add(_10, _8), var_underlying, _5, _9), _10), _10, _3)
                    if iszero(_11) { revert_forward() }
                    let expr := _4
                    if _11
                    {
                        finalize_allocation(_10, returndatasize())
                        expr := abi_decode_address_fromMemory(_10, add(_10, returndatasize()))
                    }
                    let _12 := and(expr, _6)
                    if iszero(_12) { continue }
                    let _13 := mload(_1)
                    mstore(_13, shl(225, 0x0d343281))
                    let _14 := staticcall(gas(), _12, _13, _8, _13, _3)
                    if iszero(_14) { revert_forward() }
                    let expr_1 := _4
                    if _14
                    {
                        finalize_allocation(_13, returndatasize())
                        expr_1 := abi_decode_uint128_fromMemory(_13, add(_13, returndatasize()))
                    }
                    let expr_2 := iszero(and(var_pool, _6))
                    if iszero(expr_2)
                    {
                        let _15 := 0xffffffffffffffffffffffffffffffff
                        expr_2 := gt(and(expr_1, _15), and(var_bestLiquidity, _15))
                    }
                    if expr_2
                    {
                        var_pool := expr
                        var_fee := read_from_memoryt_uint24(memory_array_index_access_uint24(expr_10439_mpos, var_i))
                        var_bestLiquidity := expr_1
                    }
                }
                let _16 := and(var_pool, _6)
                require_helper_stringliteral_15dc(iszero(iszero(_16)))
                require_helper_stringliteral_cad5(eq(cleanup_address(fun_computeUniswapPoolAddress(var_underlying, var_fee)), _16))
                write_to_memory_uint16_12575(var_p_mpos)
                write_to_memory_uint32(add(var_p_mpos, _3), and(var_fee, 16777215))
                if iszero(extcodesize(_16)) { revert(_4, _4) }
                let _17 := mload(_1)
                mstore(_17, shl(224, 0x32148f67))
                let trySuccessCondition := call(gas(), _16, _4, _17, sub(abi_encode_uint16_to_uint16(add(_17, 4)), _17), _17, _4)
                if trySuccessCondition
                {
                    finalize_allocation(_17, returndatasize())
                    abi_decode(_17, add(_17, returndatasize()))
                }
                switch iszero(trySuccessCondition)
                case 0 { }
                default {
                    let _18 := 1
                    if eq(147028384, return_data_selector())
                    {
                        let _19 := try_decode_error_message()
                        if _19
                        {
                            _18 := _4
                            if eq(keccak256(add(_19, _3), mload(_19)), 0xe01ebc6b01bbf458b3d355b6e649efe64599751670c5d19175619893ecf97529)
                            {
                                let _20 := mload(_1)
                                mstore(_20, shl(229, 4594637))
                                revert(_20, sub(abi_encode_stringliteral(add(_20, 4)), _20))
                            }
                            let expr_10582_mpos := mload(_1)
                            let _21 := sub(abi_encode_string_memory_ptr(_19, abi_encode_stringliteral_92b3(add(expr_10582_mpos, _3))), expr_10582_mpos)
                            mstore(expr_10582_mpos, add(_21, not(31)))
                            finalize_allocation(expr_10582_mpos, _21)
                            let _22 := mload(_1)
                            mstore(_22, shl(229, 4594637))
                            revert(_22, sub(abi_encode_string(add(_22, 4), expr_10582_mpos), _22))
                        }
                    }
                    if _18
                    {
                        fun_revertBytes(extract_returndata())
                    }
                }
            }
            default {
                write_to_memory_uint16_12577(var_p_mpos)
                mstore(add(var_p_mpos, _3), _4)
                write_to_memory_uint32(add(mload(_2), _1), read_from_storage_split_offset_uint32(mapping_index_access_mapping_address_address_of_address_12580(read_from_storage_split_offset_address(mapping_index_access_mapping_address_address_of_address_12569(var_underlying)))))
            }
        }
        default {
            write_to_memory_uint16_12581(var_p_mpos)
            mstore(add(var_p_mpos, _3), _4)
        }
    }
    /// @ast-id 164
    function fun_revertBytes(var_errMsg_mpos)
    {
        let expr := mload(var_errMsg_mpos)
        if iszero(iszero(expr))
        {
            revert(add(32, var_errMsg_mpos), expr)
        }
        let _1 := mload(64)
        mstore(_1, shl(229, 4594637))
        mstore(add(_1, 4), 32)
        mstore(add(_1, 36), 13)
        mstore(add(_1, 68), "e/empty-error")
        revert(_1, 100)
    }
    /// @ast-id 10658
    function fun_computeUniswapPoolAddress(var_underlying, var_fee) -> var
    {
        let var_tokenA := var_underlying
        let var_tokenB := loadimmutable("10268")
        let var_tokenB_1 := var_tokenB
        let _1 := sub(shl(160, 1), 1)
        if gt(and(var_underlying, _1), and(var_tokenB, _1))
        {
            var_tokenB := var_underlying
            var_tokenA := var_tokenB_1
        }
        let expr_10648_mpos := mload(64)
        let _2 := add(expr_10648_mpos, 0x20)
        let _3 := sub(abi_encode_address_address_uint24(_2, var_tokenA, var_tokenB, var_fee), expr_10648_mpos)
        mstore(expr_10648_mpos, add(_3, not(31)))
        finalize_allocation(expr_10648_mpos, _3)
        let expr := keccak256(_2, mload(expr_10648_mpos))
        let expr_10651_mpos := mload(64)
        let _4 := add(expr_10651_mpos, 0x20)
        mstore(_4, shl(248, 255))
        mstore(add(expr_10651_mpos, 33), and(shl(96, loadimmutable("10270")), not(0xffffffffffffffffffffffff)))
        mstore(add(expr_10651_mpos, 53), expr)
        mstore(add(expr_10651_mpos, 85), loadimmutable("10272"))
        mstore(expr_10651_mpos, 85)
        finalize_allocation_22851(expr_10651_mpos)
        var := cleanup_address(cleanup_address(keccak256(_4, mload(expr_10651_mpos))))
    }
    /// @ast-id 147
    function modifier_FREEMEM(var_assetCache_mpos, var_config_mpos) -> _1, _2
    {
        let _3 := 0x40
        let var_origFreeMemPtr := mload(_3)
        let var_twap := 0
        let var_twapPeriod := var_twap
        var_twap := var_twap
        var_twapPeriod := 0
        let expr_component, expr_component_1, expr_component_2, expr_component_3 := fun_resolvePricingConfig(var_assetCache_mpos, var_config_mpos)
        let _4 := 0xffff
        let _5 := and(expr_component_1, _4)
        switch eq(_5, 0x01)
        case 0 {
            switch eq(_5, 0x02)
            case 0 {
                let _6 := mload(_3)
                mstore(_6, shl(229, 4594637))
                revert(_6, sub(abi_encode_stringliteral_ee51(add(_6, 4)), _6))
            }
            default {
                let _7 := 0xffffff
                let expr := fun_computeUniswapPoolAddress(expr_component, and(expr_component_2, _7))
                let var_ago := and(expr_component_3, _7)
                let expr_mpos := allocate_and_zero_memory_array_array_uint32_dyn()
                write_to_memory_uint32(memory_array_index_access_uint32_dyn_12584(expr_mpos), var_ago)
                mstore(memory_array_index_access_uint32_dyn_12585(expr_mpos), var_twapPeriod)
                let expr_mpos_1 := mload(_3)
                let _8 := add(expr_mpos_1, 0x20)
                let _9 := shl(224, 0x883bdbfd)
                mstore(_8, _9)
                let _10 := sub(abi_encode_array_uint32_dyn(add(expr_mpos_1, 36), expr_mpos), expr_mpos_1)
                let _11 := not(31)
                mstore(expr_mpos_1, add(_10, _11))
                finalize_allocation(expr_mpos_1, _10)
                let expr_component_4 := staticcall(gas(), expr, _8, mload(expr_mpos_1), var_twapPeriod, var_twapPeriod)
                let var_data_mpos := extract_returndata()
                if iszero(expr_component_4)
                {
                    let expr_1 := keccak256(add(var_data_mpos, 0x20), mload(var_data_mpos))
                    let expr_mpos_2 := mload(_3)
                    let _12 := add(expr_mpos_2, 0x20)
                    mstore(_12, shl(229, 4594637))
                    let _13 := sub(abi_encode_stringliteral_d30c(add(expr_mpos_2, 36)), expr_mpos_2)
                    mstore(expr_mpos_2, add(_13, _11))
                    finalize_allocation(expr_mpos_2, _13)
                    if iszero(eq(expr_1, keccak256(_12, mload(expr_mpos_2))))
                    {
                        fun_revertBytes(var_data_mpos)
                    }
                    let _14 := and(expr, sub(shl(160, 1), 1))
                    let _15 := mload(_3)
                    mstore(_15, shl(224, 0x3850c7bd))
                    let _16 := staticcall(gas(), _14, _15, 4, _15, 224)
                    if iszero(_16) { revert_forward() }
                    let expr_component_5 := var_twapPeriod
                    let expr_component_6 := var_twapPeriod
                    let expr_component_7 := var_twapPeriod
                    if _16
                    {
                        finalize_allocation(_15, returndatasize())
                        let expr_component_8, expr_component_9, expr_component_10, expr_component_11, expr_component_12, expr_component_13, expr_component_14 := abi_decode_uint160t_int24t_uint16t_uint16t_uint16t_uint8t_bool_fromMemory(_15, add(_15, returndatasize()))
                        expr_component_5 := expr_component_10
                        expr_component_6 := expr_component_11
                        expr_component_7 := expr_component_12
                    }
                    let expr_2 := mod_uint16(checked_add_uint16(expr_component_5), expr_component_6)
                    let _17 := mload(_3)
                    let _18 := shl(224, 0x252c09d7)
                    mstore(_17, _18)
                    let _19 := staticcall(gas(), _14, _17, sub(abi_encode_uint16(add(_17, 4), expr_2), _17), _17, 128)
                    if iszero(_19) { revert_forward() }
                    let expr_component_15 := var_twapPeriod
                    let expr_component_16 := var_twapPeriod
                    if _19
                    {
                        finalize_allocation(_17, returndatasize())
                        let expr_component_17, expr_component_18, expr_component_19, expr_component_20 := abi_decode_uint32t_int56t_uint160t_bool_fromMemory(_17, add(_17, returndatasize()))
                        expr_component_15 := expr_component_17
                        expr_component_16 := expr_component_20
                    }
                    let var_oldestAvailableAge := expr_component_15
                    if iszero(expr_component_16)
                    {
                        let _20 := mload(_3)
                        mstore(_20, _18)
                        let _21 := staticcall(gas(), _14, _20, sub(abi_encode_rational_by(add(_20, 4)), _20), _20, 128)
                        if iszero(_21) { revert_forward() }
                        let expr_component_21 := var_twapPeriod
                        if _21
                        {
                            finalize_allocation(_20, returndatasize())
                            let expr_component_22, expr_component_23, expr_component_24, expr_component_25 := abi_decode_uint32t_int56t_uint160t_bool_fromMemory(_20, add(_20, returndatasize()))
                            expr_component_21 := expr_component_22
                        }
                        var_oldestAvailableAge := expr_component_21
                    }
                    let _22 := and(expr_component_6, _4)
                    let expr_3 := eq(_22, and(expr_component_7, _4))
                    if expr_3 { expr_3 := lt(_22, _4) }
                    if expr_3
                    {
                        let expr_4 := checked_add_uint16(expr_component_6)
                        if iszero(extcodesize(_14))
                        {
                            revert(var_twapPeriod, var_twapPeriod)
                        }
                        let _23 := mload(_3)
                        mstore(_23, shl(224, 0x32148f67))
                        let _24 := call(gas(), _14, var_twapPeriod, _23, sub(abi_encode_uint16(add(_23, 4), expr_4), _23), _23, var_twapPeriod)
                        if iszero(_24) { revert_forward() }
                        if _24
                        {
                            finalize_allocation(_23, returndatasize())
                            abi_decode(_23, add(_23, returndatasize()))
                        }
                    }
                    let _25 := 0xffffffff
                    var_ago := checked_sub_uint256(timestamp(), and(var_oldestAvailableAge, _25))
                    write_to_memory_uint32(memory_array_index_access_uint32_dyn_12584(expr_mpos), and(var_ago, _25))
                    let expr_mpos_3 := mload(_3)
                    let _26 := add(expr_mpos_3, 0x20)
                    mstore(_26, _9)
                    let _27 := sub(abi_encode_array_uint32_dyn(add(expr_mpos_3, 36), expr_mpos), expr_mpos_3)
                    mstore(expr_mpos_3, add(_27, _11))
                    finalize_allocation(expr_mpos_3, _27)
                    let expr_component_26 := staticcall(gas(), expr, _26, mload(expr_mpos_3), var_twapPeriod, var_twapPeriod)
                    var_data_mpos := extract_returndata()
                    if iszero(expr_component_26)
                    {
                        fun_revertBytes(var_data_mpos)
                    }
                }
                let expr_mpos_4 := abi_decode_array_int56_dyn_fromMemory(add(var_data_mpos, 0x20), add(add(var_data_mpos, mload(var_data_mpos)), 0x20))
                let _28 := read_from_memoryt_int56(memory_array_index_access_uint32_dyn_12585(expr_mpos_4))
                let expr_5 := checked_sub_int56(_28, read_from_memoryt_int56(memory_array_index_access_uint32_dyn_12584(expr_mpos_4)))
                let var := fun_decodeSqrtPriceX96(var_assetCache_mpos, cleanup_address(fun_getSqrtRatioAtTick(convert_int56_to_int24(checked_div_int56(expr_5, signextend(6, var_ago))))))
                var_twapPeriod := var_ago
                var_twap := var
            }
        }
        default {
            var_twap := 0x0de0b6b3a7640000
            var_twapPeriod := and(expr_component_3, 0xffffff)
        }
        _1 := var_twap
        _2 := var_twapPeriod
        mstore(_3, var_origFreeMemPtr)
    }
    /// @ast-id 147
    function modifier_FREEMEM_12660(var_assetCache_mpos, var_config_mpos) -> _1, _2
    {
        let _3 := 0x40
        let var_origFreeMemPtr := mload(_3)
        let var_twap := 0x00
        let var_twapPeriod := var_twap
        var_twap := var_twap
        var_twapPeriod := 0x00
        let expr_component, expr_component_1, expr_component_2, expr_component_3 := fun_resolvePricingConfig(var_assetCache_mpos, var_config_mpos)
        let _4 := 0xffff
        let _5 := and(expr_component_1, _4)
        switch eq(_5, 0x01)
        case 0 {
            switch eq(_5, 0x02)
            case 0 {
                let _6 := mload(_3)
                mstore(_6, shl(229, 4594637))
                revert(_6, sub(abi_encode_stringliteral_ee51(add(_6, 4)), _6))
            }
            default {
                let _7 := 0xffffff
                let expr := fun_computeUniswapPoolAddress(expr_component, and(expr_component_2, _7))
                let var_ago := and(expr_component_3, _7)
                let expr_mpos := allocate_and_zero_memory_array_array_uint32_dyn()
                write_to_memory_uint32(memory_array_index_access_uint32_dyn_12584(expr_mpos), var_ago)
                mstore(memory_array_index_access_uint32_dyn_12585(expr_mpos), var_twapPeriod)
                let expr_mpos_1 := mload(_3)
                let _8 := add(expr_mpos_1, 0x20)
                let _9 := shl(224, 0x883bdbfd)
                mstore(_8, _9)
                let _10 := sub(abi_encode_array_uint32_dyn(add(expr_mpos_1, 36), expr_mpos), expr_mpos_1)
                let _11 := not(31)
                mstore(expr_mpos_1, add(_10, _11))
                finalize_allocation(expr_mpos_1, _10)
                let expr_component_4 := staticcall(gas(), expr, _8, mload(expr_mpos_1), var_twapPeriod, var_twapPeriod)
                let var_data_mpos := extract_returndata()
                if iszero(expr_component_4)
                {
                    let expr_1 := keccak256(add(var_data_mpos, 0x20), mload(var_data_mpos))
                    let expr_mpos_2 := mload(_3)
                    let _12 := add(expr_mpos_2, 0x20)
                    mstore(_12, shl(229, 4594637))
                    let _13 := sub(abi_encode_stringliteral_d30c(add(expr_mpos_2, 36)), expr_mpos_2)
                    mstore(expr_mpos_2, add(_13, _11))
                    finalize_allocation(expr_mpos_2, _13)
                    if iszero(eq(expr_1, keccak256(_12, mload(expr_mpos_2))))
                    {
                        fun_revertBytes(var_data_mpos)
                    }
                    let _14 := and(expr, sub(shl(160, 1), 1))
                    let _15 := mload(_3)
                    mstore(_15, shl(224, 0x3850c7bd))
                    let _16 := staticcall(gas(), _14, _15, 4, _15, 224)
                    if iszero(_16) { revert_forward() }
                    let expr_component_5 := var_twapPeriod
                    let expr_component_6 := var_twapPeriod
                    let expr_component_7 := var_twapPeriod
                    if _16
                    {
                        finalize_allocation(_15, returndatasize())
                        let expr_component_8, expr_component_9, expr_component_10, expr_component_11, expr_component_12, expr_component_13, expr_component_14 := abi_decode_uint160t_int24t_uint16t_uint16t_uint16t_uint8t_bool_fromMemory(_15, add(_15, returndatasize()))
                        expr_component_5 := expr_component_10
                        expr_component_6 := expr_component_11
                        expr_component_7 := expr_component_12
                    }
                    let expr_2 := mod_uint16(checked_add_uint16(expr_component_5), expr_component_6)
                    let _17 := mload(_3)
                    let _18 := shl(224, 0x252c09d7)
                    mstore(_17, _18)
                    let _19 := staticcall(gas(), _14, _17, sub(abi_encode_uint16(add(_17, 4), expr_2), _17), _17, 128)
                    if iszero(_19) { revert_forward() }
                    let expr_component_15 := var_twapPeriod
                    let expr_component_16 := var_twapPeriod
                    if _19
                    {
                        finalize_allocation(_17, returndatasize())
                        let expr_component_17, expr_component_18, expr_component_19, expr_component_20 := abi_decode_uint32t_int56t_uint160t_bool_fromMemory(_17, add(_17, returndatasize()))
                        expr_component_15 := expr_component_17
                        expr_component_16 := expr_component_20
                    }
                    let var_oldestAvailableAge := expr_component_15
                    if iszero(expr_component_16)
                    {
                        let _20 := mload(_3)
                        mstore(_20, _18)
                        let _21 := staticcall(gas(), _14, _20, sub(abi_encode_rational_by(add(_20, 4)), _20), _20, 128)
                        if iszero(_21) { revert_forward() }
                        let expr_component_21 := var_twapPeriod
                        if _21
                        {
                            finalize_allocation(_20, returndatasize())
                            let expr_component_22, expr_component_23, expr_component_24, expr_component_25 := abi_decode_uint32t_int56t_uint160t_bool_fromMemory(_20, add(_20, returndatasize()))
                            expr_component_21 := expr_component_22
                        }
                        var_oldestAvailableAge := expr_component_21
                    }
                    let _22 := and(expr_component_6, _4)
                    let expr_3 := eq(_22, and(expr_component_7, _4))
                    if expr_3 { expr_3 := lt(_22, _4) }
                    if expr_3
                    {
                        let expr_4 := checked_add_uint16(expr_component_6)
                        if iszero(extcodesize(_14))
                        {
                            revert(var_twapPeriod, var_twapPeriod)
                        }
                        let _23 := mload(_3)
                        mstore(_23, shl(224, 0x32148f67))
                        let _24 := call(gas(), _14, var_twapPeriod, _23, sub(abi_encode_uint16(add(_23, 4), expr_4), _23), _23, var_twapPeriod)
                        if iszero(_24) { revert_forward() }
                        if _24
                        {
                            finalize_allocation(_23, returndatasize())
                            abi_decode(_23, add(_23, returndatasize()))
                        }
                    }
                    let _25 := 0xffffffff
                    var_ago := checked_sub_uint256(timestamp(), and(var_oldestAvailableAge, _25))
                    write_to_memory_uint32(memory_array_index_access_uint32_dyn_12584(expr_mpos), and(var_ago, _25))
                    let expr_mpos_3 := mload(_3)
                    let _26 := add(expr_mpos_3, 0x20)
                    mstore(_26, _9)
                    let _27 := sub(abi_encode_array_uint32_dyn(add(expr_mpos_3, 36), expr_mpos), expr_mpos_3)
                    mstore(expr_mpos_3, add(_27, _11))
                    finalize_allocation(expr_mpos_3, _27)
                    let expr_component_26 := staticcall(gas(), expr, _26, mload(expr_mpos_3), var_twapPeriod, var_twapPeriod)
                    var_data_mpos := extract_returndata()
                    if iszero(expr_component_26)
                    {
                        fun_revertBytes(var_data_mpos)
                    }
                }
                let expr_mpos_4 := abi_decode_array_int56_dyn_fromMemory(add(var_data_mpos, 0x20), add(add(var_data_mpos, mload(var_data_mpos)), 0x20))
                let _28 := read_from_memoryt_int56(memory_array_index_access_uint32_dyn_12585(expr_mpos_4))
                let expr_5 := checked_sub_int56(_28, read_from_memoryt_int56(memory_array_index_access_uint32_dyn_12584(expr_mpos_4)))
                let var := fun_decodeSqrtPriceX96(var_assetCache_mpos, cleanup_address(fun_getSqrtRatioAtTick(convert_int56_to_int24(checked_div_int56(expr_5, signextend(6, var_ago))))))
                var_twapPeriod := var_ago
                var_twap := var
            }
        }
        default {
            var_twap := 0x0de0b6b3a7640000
            var_twapPeriod := and(expr_component_3, 0xffffff)
        }
        _1 := var_twap
        _2 := var_twapPeriod
        mstore(_3, var_origFreeMemPtr)
    }
    function abi_encode_stringliteral_ee51(headStart) -> tail
    {
        mstore(headStart, 32)
        mstore(add(headStart, 32), 22)
        mstore(add(headStart, 64), "e/unknown-pricing-type")
        tail := add(headStart, 96)
    }
    function array_allocation_size_array_uint32_dyn(length) -> size
    {
        if gt(length, 0xffffffffffffffff) { panic_error_0x41() }
        size := add(shl(5, length), 0x20)
    }
    function allocate_and_zero_memory_array_array_uint32_dyn() -> memPtr
    {
        let memPtr_1 := mload(64)
        finalize_allocation_22852(memPtr_1)
        mstore(memPtr_1, 0x02)
        memPtr := memPtr_1
        calldatacopy(add(memPtr_1, 0x20), calldatasize(), 64)
    }
    function memory_array_index_access_uint32_dyn_12584(baseRef) -> addr
    {
        if iszero(mload(baseRef)) { panic_error_0x32() }
        addr := add(baseRef, 32)
    }
    function memory_array_index_access_uint32_dyn_12585(baseRef) -> addr
    {
        if iszero(lt(0x01, mload(baseRef))) { panic_error_0x32() }
        addr := add(baseRef, 64)
    }
    function memory_array_index_access_uint32_dyn(baseRef, index) -> addr
    {
        if iszero(lt(index, mload(baseRef))) { panic_error_0x32() }
        addr := add(add(baseRef, shl(5, index)), 32)
    }
    function abi_encode_array_uint32_dyn(headStart, value0) -> tail
    {
        let _1 := 32
        let tail_1 := add(headStart, _1)
        mstore(headStart, _1)
        let pos := tail_1
        let length := mload(value0)
        mstore(tail_1, length)
        pos := add(headStart, 64)
        let srcPtr := add(value0, _1)
        let i := 0
        for { } lt(i, length) { i := add(i, 1) }
        {
            mstore(pos, and(mload(srcPtr), 0xffffffff))
            pos := add(pos, _1)
            srcPtr := add(srcPtr, _1)
        }
        tail := pos
    }
    function abi_encode_stringliteral_d30c(headStart) -> tail
    {
        mstore(headStart, 32)
        mstore(add(headStart, 32), 3)
        mstore(add(headStart, 64), "OLD")
        tail := add(headStart, 96)
    }
    function abi_decode_uint160t_int24t_uint16t_uint16t_uint16t_uint8t_bool_fromMemory(headStart, dataEnd) -> value0, value1, value2, value3, value4, value5, value6
    {
        if slt(sub(dataEnd, headStart), 224) { revert(0, 0) }
        let value := mload(headStart)
        validator_revert_address(value)
        value0 := value
        let value_1 := mload(add(headStart, 32))
        if iszero(eq(value_1, signextend(2, value_1))) { revert(0, 0) }
        value1 := value_1
        let value_2 := mload(add(headStart, 64))
        validator_revert_uint16(value_2)
        value2 := value_2
        let value_3 := mload(add(headStart, 96))
        validator_revert_uint16(value_3)
        value3 := value_3
        let value_4 := mload(add(headStart, 128))
        validator_revert_uint16(value_4)
        value4 := value_4
        let value_5 := mload(add(headStart, 160))
        validator_revert_uint8(value_5)
        value5 := value_5
        let value_6 := mload(add(headStart, 192))
        validator_revert_bool(value_6)
        value6 := value_6
    }
    function checked_add_uint16(x) -> sum
    {
        let x_1 := and(x, 0xffff)
        if gt(x_1, 65534) { panic_error_0x11() }
        sum := add(x_1, 1)
    }
    function panic_error_0x12()
    {
        mstore(0, shl(224, 0x4e487b71))
        mstore(4, 0x12)
        revert(0, 0x24)
    }
    function mod_uint16(x, y) -> r
    {
        let _1 := 0xffff
        let y_1 := and(y, _1)
        if iszero(y_1) { panic_error_0x12() }
        r := mod(and(x, _1), y_1)
    }
    function abi_decode_int56_fromMemory(offset) -> value
    {
        value := mload(offset)
        if iszero(eq(value, signextend(6, value))) { revert(0, 0) }
    }
    function abi_decode_uint32t_int56t_uint160t_bool_fromMemory(headStart, dataEnd) -> value0, value1, value2, value3
    {
        if slt(sub(dataEnd, headStart), 128) { revert(0, 0) }
        let value := mload(headStart)
        validator_revert_uint32(value)
        value0 := value
        value1 := abi_decode_int56_fromMemory(add(headStart, 32))
        let value_1 := mload(add(headStart, 64))
        validator_revert_address(value_1)
        value2 := value_1
        let value_2 := mload(add(headStart, 96))
        validator_revert_bool(value_2)
        value3 := value_2
    }
    function abi_encode_rational_by(headStart) -> tail
    {
        tail := add(headStart, 32)
        mstore(headStart, 0)
    }
    function checked_sub_uint256(x, y) -> diff
    {
        if lt(x, y) { panic_error_0x11() }
        diff := sub(x, y)
    }
    function abi_decode_array_int56_dyn_fromMemory(headStart, dataEnd) -> value0
    {
        let _1 := 32
        if slt(sub(dataEnd, headStart), _1) { revert(0, 0) }
        let offset := mload(headStart)
        if gt(offset, 0xffffffffffffffff) { revert(0, 0) }
        let _2 := add(headStart, offset)
        if iszero(slt(add(_2, 0x1f), dataEnd)) { revert(0, 0) }
        let _3 := mload(_2)
        let _4 := array_allocation_size_array_uint32_dyn(_3)
        let memPtr := mload(64)
        finalize_allocation(memPtr, _4)
        let dst := memPtr
        mstore(memPtr, _3)
        dst := add(memPtr, _1)
        let srcEnd := add(add(_2, shl(5, _3)), _1)
        if gt(srcEnd, dataEnd) { revert(0, 0) }
        let src := add(_2, _1)
        for { } lt(src, srcEnd) { src := add(src, _1) }
        {
            mstore(dst, abi_decode_int56_fromMemory(src))
            dst := add(dst, _1)
        }
        value0 := memPtr
    }
    function read_from_memoryt_int56(ptr) -> returnValue
    {
        returnValue := signextend(6, mload(ptr))
    }
    function checked_sub_int56(x, y) -> diff
    {
        let x_1 := signextend(6, x)
        let y_1 := signextend(6, y)
        let _1 := slt(y_1, 0)
        if and(iszero(_1), slt(x_1, add(not(0x7fffffffffffff), y_1))) { panic_error_0x11() }
        if and(_1, sgt(x_1, add(0x7fffffffffffff, y_1))) { panic_error_0x11() }
        diff := sub(x_1, y_1)
    }
    function checked_div_int56(x, y) -> r
    {
        let x_1 := signextend(6, x)
        let y_1 := signextend(6, y)
        if iszero(y_1) { panic_error_0x12() }
        if and(eq(x_1, not(0x7fffffffffffff)), eq(y_1, not(0))) { panic_error_0x11() }
        r := sdiv(x_1, y_1)
    }
    function convert_int56_to_int24(value) -> converted
    {
        converted := signextend(2, value)
    }
    function read_from_memoryt_address(ptr) -> returnValue
    {
        returnValue := and(mload(ptr), sub(shl(160, 1), 1))
    }
    function checked_mul_uint256_12666(x) -> product
    {
        let _1 := 0xee6b2800
        if and(iszero(iszero(x)), gt(_1, div(not(0), x))) { panic_error_0x11() }
        product := mul(x, _1)
    }
    function checked_mul_uint256(x, y) -> product
    {
        if and(iszero(iszero(x)), gt(y, div(not(0), x))) { panic_error_0x11() }
        product := mul(x, y)
    }
    function checked_div_uint256_12624(y) -> r
    {
        if iszero(y) { panic_error_0x12() }
        r := div(shl(192, 1), y)
    }
    function checked_div_uint256_12625(y) -> r
    {
        if iszero(y) { panic_error_0x12() }
        r := div(0xc097ce7bc90715b34b9f1000000000, y)
    }
    function checked_div_uint256_12645(y) -> r
    {
        if iszero(y) { panic_error_0x12() }
        r := div(0xffffffffffffffffffffffffffff, y)
    }
    function checked_div_uint256_12649(x) -> r
    {
        r := div(x, 0x033b2e3c9fd0803ce8000000)
    }
    function checked_div_uint256_12661(x) -> r
    {
        r := div(x, 0x0de0b6b3a7640000)
    }
    function checked_div_uint256_12662(x) -> r
    { r := div(x, 0xee6b2800) }
    function checked_div_uint256_12692(y) -> r
    {
        if iszero(y) { panic_error_0x12() }
        r := div(not(0), y)
    }
    function checked_div_uint256_22855(x) -> r
    {
        r := div(x, 0x3782dace9d900000)
    }
    function checked_div_uint256(x, y) -> r
    {
        if iszero(y) { panic_error_0x12() }
        r := div(x, y)
    }
    /// @ast-id 10755
    function fun_decodeSqrtPriceX96(var_assetCache_10661_mpos, var_sqrtPriceX96) -> var_price
    {
        let _1 := sub(shl(160, 1), 1)
        let _2 := and(mload(var_assetCache_10661_mpos), _1)
        switch lt(_2, and(loadimmutable("10268"), _1))
        case 0 {
            let _3 := mload(add(var_assetCache_10661_mpos, 416))
            if and(1, gt(_3, 0x12725dd1d243aba0e75fe645cc4873f9e65afe688c928e1f21)) { panic_error_0x11() }
            var_price := fun_mulDiv(var_sqrtPriceX96, var_sqrtPriceX96, checked_div_uint256_12624(mul(0x0de0b6b3a7640000, _3)))
            if iszero(var_price)
            {
                var_price := 0xc097ce7bc90715b34b9f1000000000
                leave
            }
            var_price := checked_div_uint256_12625(var_price)
        }
        default {
            let expr := fun_mulDiv_22854(var_sqrtPriceX96, var_sqrtPriceX96)
            var_price := checked_div_uint256(expr, mload(add(var_assetCache_10661_mpos, 416)))
        }
        let _4 := 0xc097ce7bc90715b34b9f1000000000
        switch gt(var_price, _4)
        case 0 {
            if iszero(var_price) { var_price := 1 }
        }
        default { var_price := _4 }
    }
    function require_helper_stringliteral_e566(condition)
    {
        if iszero(condition)
        {
            let memPtr := mload(64)
            mstore(memPtr, shl(229, 4594637))
            mstore(add(memPtr, 4), 32)
            mstore(add(memPtr, 36), 25)
            mstore(add(memPtr, 68), "e/nested-price-forwarding")
            revert(memPtr, 100)
        }
    }
    /// @ast-id 11067
    function fun_resolvePricingConfig(var_assetCache_10981_mpos, var_config_10984_mpos) -> var_underlying, var_pricingType, var_pricingParameters, var_twapWindow
    {
        let _1 := 0xffff
        let cleaned := and(mload(add(var_assetCache_10981_mpos, 320)), _1)
        switch eq(cleaned, 0x03)
        case 0 {
            var_underlying := and(mload(var_assetCache_10981_mpos), sub(shl(160, 1), 1))
            var_pricingType := cleaned
            var_pricingParameters := and(mload(add(var_assetCache_10981_mpos, 352)), 0xffffffff)
            var_twapWindow := and(mload(add(var_config_10984_mpos, 128)), 0xffffff)
        }
        default {
            var_underlying := read_from_storage_split_offset_address(mapping_index_access_mapping_address_address_of_address_12569(cleanup_address(mload(var_assetCache_10981_mpos))))
            let expr_11011_mpos := fun_resolveAssetConfig(var_underlying)
            var_twapWindow := cleanup_uint24(mload(add(expr_11011_mpos, 128)))
            let _2 := sload(mapping_index_access_mapping_address_address_of_address_12628(cleanup_address(mload(expr_11011_mpos))))
            var_pricingType := and(shr(208, _2), _1)
            var_pricingParameters := shr(224, _2)
            require_helper_stringliteral_e566(iszero(eq(var_pricingType, 0x03)))
        }
    }
    function write_to_memory_address(memPtr, value)
    {
        mstore(memPtr, and(value, sub(shl(160, 1), 1)))
    }
    function require_helper_stringliteral(condition)
    {
        if iszero(condition)
        {
            let memPtr := mload(64)
            mstore(memPtr, shl(229, 4594637))
            mstore(add(memPtr, 4), 32)
            mstore(add(memPtr, 36), 22)
            mstore(add(memPtr, 68), "e/market-not-activated")
            revert(memPtr, 100)
        }
    }
    /// @ast-id 878
    function fun_resolveAssetConfig(var_underlying) -> var_825_mpos
    {
        pop(allocate_and_zero_memory_struct_struct_AssetConfig())
        let _1 := sub(shl(160, 1), 1)
        mstore(0, and(var_underlying, _1))
        mstore(0x20, 0x08)
        let _2 := keccak256(0, 0x40)
        let memPtr := mload(0x40)
        finalize_allocation_12563(memPtr)
        let _3 := sload(_2)
        let _4 := and(_3, _1)
        mstore(memPtr, _4)
        mstore(add(memPtr, 0x20), iszero(iszero(and(shr(160, _3), 0xff))))
        let _5 := 0xffffffff
        mstore(add(memPtr, 0x40), and(shr(168, _3), _5))
        let _6 := add(memPtr, 96)
        mstore(_6, and(shr(200, _3), _5))
        let _7 := add(memPtr, 128)
        mstore(_7, shr(232, _3))
        require_helper_stringliteral(iszero(iszero(_4)))
        if eq(and(cleanup_uint32(mload(_6)), _5), _5)
        {
            write_to_memory_uint32_12631(_6)
        }
        let _8 := 0xffffff
        if eq(and(cleanup_uint24(mload(_7)), _8), _8) { write_to_memory_uint24(_7) }
        var_825_mpos := memPtr
    }
    /// @ast-id 11182
    function fun_getPrice(var_underlying) -> var_twap, var_twapPeriod
    {
        let expr_11154_mpos := fun_resolveAssetConfig(var_underlying)
        let _1 := sub(shl(160, 1), 1)
        let _2 := and(mload(expr_11154_mpos), _1)
        let _3 := 0
        mstore(_3, _2)
        let _4 := 0x20
        mstore(_4, 0x09)
        let _5 := 0x40
        let _6 := fun_loadAssetCache(var_underlying, keccak256(_3, _5))
        let var_origFreeMemPtr := mload(_5)
        let var_twap_1 := _3
        let var_twapPeriod_1 := _3
        var_twap_1 := _3
        var_twapPeriod_1 := _3
        let expr_component, expr_component_1, expr_component_2, expr_component_3 := fun_resolvePricingConfig(_6, expr_11154_mpos)
        let _7 := 0xffff
        let _8 := and(expr_component_1, _7)
        switch eq(_8, 1)
        case 0 {
            switch eq(_8, 0x02)
            case 0 {
                let _9 := mload(_5)
                mstore(_9, shl(229, 4594637))
                revert(_9, sub(abi_encode_stringliteral_ee51(add(_9, 4)), _9))
            }
            default {
                let _10 := 0xffffff
                let expr := fun_computeUniswapPoolAddress(expr_component, and(expr_component_2, _10))
                let var_ago := and(expr_component_3, _10)
                let expr_mpos := allocate_and_zero_memory_array_array_uint32_dyn()
                write_to_memory_uint32(memory_array_index_access_uint32_dyn_12584(expr_mpos), var_ago)
                mstore(memory_array_index_access_uint32_dyn_12585(expr_mpos), _3)
                let expr_mpos_1 := mload(_5)
                let _11 := add(expr_mpos_1, _4)
                let _12 := shl(224, 0x883bdbfd)
                mstore(_11, _12)
                let _13 := sub(abi_encode_array_uint32_dyn(add(expr_mpos_1, 36), expr_mpos), expr_mpos_1)
                let _14 := not(31)
                mstore(expr_mpos_1, add(_13, _14))
                finalize_allocation(expr_mpos_1, _13)
                let expr_component_4 := staticcall(gas(), expr, _11, mload(expr_mpos_1), _3, _3)
                let var_data_mpos := extract_returndata()
                if iszero(expr_component_4)
                {
                    let expr_1 := keccak256(add(var_data_mpos, _4), mload(var_data_mpos))
                    let expr_mpos_2 := mload(_5)
                    let _15 := add(expr_mpos_2, _4)
                    mstore(_15, shl(229, 4594637))
                    let _16 := sub(abi_encode_stringliteral_d30c(add(expr_mpos_2, 36)), expr_mpos_2)
                    mstore(expr_mpos_2, add(_16, _14))
                    finalize_allocation(expr_mpos_2, _16)
                    if iszero(eq(expr_1, keccak256(_15, mload(expr_mpos_2))))
                    {
                        fun_revertBytes(var_data_mpos)
                    }
                    let _17 := and(expr, _1)
                    let _18 := mload(_5)
                    mstore(_18, shl(224, 0x3850c7bd))
                    let _19 := staticcall(gas(), _17, _18, 4, _18, 224)
                    if iszero(_19) { revert_forward() }
                    let expr_component_5 := _3
                    let expr_component_6 := _3
                    let expr_component_7 := _3
                    if _19
                    {
                        finalize_allocation(_18, returndatasize())
                        let expr_component_8, expr_component_9, expr_component_10, expr_component_11, expr_component_12, expr_component_13, expr_component_14 := abi_decode_uint160t_int24t_uint16t_uint16t_uint16t_uint8t_bool_fromMemory(_18, add(_18, returndatasize()))
                        expr_component_5 := expr_component_10
                        expr_component_6 := expr_component_11
                        expr_component_7 := expr_component_12
                    }
                    let expr_2 := mod_uint16(checked_add_uint16(expr_component_5), expr_component_6)
                    let _20 := mload(_5)
                    let _21 := shl(224, 0x252c09d7)
                    mstore(_20, _21)
                    let _22 := staticcall(gas(), _17, _20, sub(abi_encode_uint16(add(_20, 4), expr_2), _20), _20, 128)
                    if iszero(_22) { revert_forward() }
                    let expr_component_15 := _3
                    let expr_component_16 := _3
                    if _22
                    {
                        finalize_allocation(_20, returndatasize())
                        let expr_component_17, expr_component_18, expr_component_19, expr_component_20 := abi_decode_uint32t_int56t_uint160t_bool_fromMemory(_20, add(_20, returndatasize()))
                        expr_component_15 := expr_component_17
                        expr_component_16 := expr_component_20
                    }
                    let var_oldestAvailableAge := expr_component_15
                    if iszero(expr_component_16)
                    {
                        let _23 := mload(_5)
                        mstore(_23, _21)
                        let _24 := staticcall(gas(), _17, _23, sub(abi_encode_rational_by(add(_23, 4)), _23), _23, 128)
                        if iszero(_24) { revert_forward() }
                        let expr_component_21 := _3
                        if _24
                        {
                            finalize_allocation(_23, returndatasize())
                            let expr_component_22, expr_component_23, expr_component_24, expr_component_25 := abi_decode_uint32t_int56t_uint160t_bool_fromMemory(_23, add(_23, returndatasize()))
                            expr_component_21 := expr_component_22
                        }
                        var_oldestAvailableAge := expr_component_21
                    }
                    let _25 := and(expr_component_6, _7)
                    let expr_3 := eq(_25, and(expr_component_7, _7))
                    if expr_3 { expr_3 := lt(_25, _7) }
                    if expr_3
                    {
                        let expr_4 := checked_add_uint16(expr_component_6)
                        if iszero(extcodesize(_17)) { revert(_3, _3) }
                        let _26 := mload(_5)
                        mstore(_26, shl(224, 0x32148f67))
                        let _27 := call(gas(), _17, _3, _26, sub(abi_encode_uint16(add(_26, 4), expr_4), _26), _26, _3)
                        if iszero(_27) { revert_forward() }
                        if _27
                        {
                            finalize_allocation(_26, returndatasize())
                            abi_decode(_26, add(_26, returndatasize()))
                        }
                    }
                    let _28 := 0xffffffff
                    var_ago := checked_sub_uint256(timestamp(), and(var_oldestAvailableAge, _28))
                    write_to_memory_uint32(memory_array_index_access_uint32_dyn_12584(expr_mpos), and(var_ago, _28))
                    let expr_mpos_3 := mload(_5)
                    let _29 := add(expr_mpos_3, _4)
                    mstore(_29, _12)
                    let _30 := sub(abi_encode_array_uint32_dyn(add(expr_mpos_3, 36), expr_mpos), expr_mpos_3)
                    mstore(expr_mpos_3, add(_30, _14))
                    finalize_allocation(expr_mpos_3, _30)
                    let expr_component_26 := staticcall(gas(), expr, _29, mload(expr_mpos_3), _3, _3)
                    var_data_mpos := extract_returndata()
                    if iszero(expr_component_26)
                    {
                        fun_revertBytes(var_data_mpos)
                    }
                }
                let expr_mpos_4 := abi_decode_array_int56_dyn_fromMemory(add(var_data_mpos, _4), add(add(var_data_mpos, mload(var_data_mpos)), _4))
                let _31 := read_from_memoryt_int56(memory_array_index_access_uint32_dyn_12585(expr_mpos_4))
                let expr_5 := checked_sub_int56(_31, read_from_memoryt_int56(memory_array_index_access_uint32_dyn_12584(expr_mpos_4)))
                let var := fun_decodeSqrtPriceX96(_6, cleanup_address(fun_getSqrtRatioAtTick(convert_int56_to_int24(checked_div_int56(expr_5, signextend(6, var_ago))))))
                var_twapPeriod_1 := var_ago
                var_twap_1 := var
            }
        }
        default {
            var_twap_1 := 0x0de0b6b3a7640000
            var_twapPeriod_1 := and(expr_component_3, 0xffffff)
        }
        mstore(_5, var_origFreeMemPtr)
        var_twapPeriod := var_twapPeriod_1
        var_twap := var_twap_1
    }
    function allocate_and_zero_memory_struct_struct_AssetCache() -> memPtr
    {
        let memPtr_1 := mload(64)
        let newFreePtr := add(memPtr_1, 480)
        if or(gt(newFreePtr, 0xffffffffffffffff), lt(newFreePtr, memPtr_1)) { panic_error_0x41() }
        mstore(64, newFreePtr)
        memPtr := memPtr_1
        let _1 := 0
        mstore(memPtr_1, _1)
        mstore(add(memPtr_1, 32), _1)
        mstore(add(memPtr_1, 64), _1)
        mstore(add(memPtr_1, 96), _1)
        mstore(add(memPtr_1, 128), _1)
        mstore(add(memPtr_1, 160), _1)
        mstore(add(memPtr_1, 192), _1)
        mstore(add(memPtr_1, 224), _1)
        mstore(add(memPtr_1, 256), _1)
        mstore(add(memPtr_1, 288), _1)
        mstore(add(memPtr_1, 320), _1)
        mstore(add(memPtr_1, 352), _1)
        mstore(add(memPtr_1, 384), _1)
        mstore(add(memPtr_1, 416), _1)
        mstore(add(memPtr_1, 448), _1)
    }
    function update_storage_value_offsett_uint96_to_uint96(slot, value)
    {
        let _1 := sload(slot)
        sstore(slot, or(and(_1, sub(shl(160, 1), 1)), and(shl(160, value), shl(160, 0xffffffffffffffffffffffff))))
    }
    function update_storage_value_offsett_uint112_to_uint112(slot, value)
    {
        sstore(slot, or(and(sload(slot), not(0xffffffffffffffffffffffffffff)), and(value, 0xffffffffffffffffffffffffffff)))
    }
    function update_storage_value_offsett_uint144_to_uint144(slot, value)
    {
        let _1 := sload(slot)
        sstore(slot, or(and(_1, 0xffffffffffffffffffffffffffff), and(shl(112, value), not(0xffffffffffffffffffffffffffff))))
    }
    /// @ast-id 1304
    function fun_loadAssetCache(var_underlying, var_assetStorage_1248_slot) -> var_assetCache_1252_mpos
    {
        var_assetCache_1252_mpos := allocate_and_zero_memory_struct_struct_AssetCache()
        if fun_initAssetCache(var_underlying, var_assetStorage_1248_slot, var_assetCache_1252_mpos)
        {
            sstore(var_assetStorage_1248_slot, or(and(sload(var_assetStorage_1248_slot), not(0xffffffffff)), and(mload(add(var_assetCache_1252_mpos, 160)), 0xffffffffff)))
            let cleaned := and(mload(var_assetCache_1252_mpos), sub(shl(160, 1), 1))
            let _1 := add(var_assetStorage_1248_slot, 1)
            sstore(_1, or(and(sload(_1), shl(160, 0xffffffffffffffffffffffff)), cleaned))
            update_storage_value_offsett_uint96_to_uint96(_1, cleanup_uint96(mload(add(var_assetCache_1252_mpos, 96))))
            let _2 := cleanup_uint112(mload(add(var_assetCache_1252_mpos, 32)))
            let _3 := add(var_assetStorage_1248_slot, 3)
            update_storage_value_offsett_uint112_to_uint112(_3, _2)
            update_storage_value_offsett_uint144_to_uint144(_3, cleanup_uint144(mload(add(var_assetCache_1252_mpos, 64))))
            sstore(add(var_assetStorage_1248_slot, 4), mload(add(var_assetCache_1252_mpos, 128)))
        }
    }
    function write_to_memory_uint40(memPtr, value)
    {
        mstore(memPtr, and(value, 0xffffffffff))
    }
    function write_to_memory_uint8(memPtr, value)
    {
        mstore(memPtr, and(value, 0xff))
    }
    function write_to_memory_int96(memPtr, value)
    {
        mstore(memPtr, signextend(11, value))
    }
    function extract_from_storage_value_offsett_uint96(slot_value) -> value
    { value := shr(160, slot_value) }
    function write_to_memory_uint96(memPtr, value)
    {
        mstore(memPtr, and(value, 0xffffffffffffffffffffffff))
    }
    function read_from_storage_split_offset_uint112(slot) -> value
    {
        value := and(sload(slot), 0xffffffffffffffffffffffffffff)
    }
    function write_to_memory_uint112(memPtr, value)
    {
        mstore(memPtr, and(value, 0xffffffffffffffffffffffffffff))
    }
    function read_from_storage_split_offset_uint144(slot) -> value
    {
        value := shr(112, sload(slot))
    }
    function write_to_memory_uint144(memPtr, value)
    {
        mstore(memPtr, and(value, 0xffffffffffffffffffffffffffffffffffff))
    }
    function checked_add_int256(x) -> sum
    {
        let _1 := slt(x, 0)
        let _2 := 0x033b2e3c9fd0803ce8000000
        if and(iszero(_1), sgt(_2, sub(sub(shl(255, 1), 1), x))) { panic_error_0x11() }
        if and(_1, slt(_2, sub(shl(255, 1), x))) { panic_error_0x11() }
        sum := add(x, _2)
    }
    function checked_add_uint256(x, y) -> sum
    {
        if gt(x, not(y)) { panic_error_0x11() }
        sum := add(x, y)
    }
    /// @ast-id 1243
    function fun_initAssetCache(var_underlying, var_assetStorage_slot, var_assetCache_917_mpos) -> var_dirty
    {
        var_dirty := 0x00
        write_to_memory_address(var_assetCache_917_mpos, var_underlying)
        let _1 := sload(var_assetStorage_slot)
        let _2 := add(var_assetCache_917_mpos, 160)
        let _3 := 0xffffffffff
        write_to_memory_uint40(_2, and(_1, _3))
        let _4 := and(shr(40, _1), 0xff)
        write_to_memory_uint8(add(var_assetCache_917_mpos, 192), _4)
        let _5 := 0xffffffff
        write_to_memory_uint32(add(var_assetCache_917_mpos, 224), and(shr(48, _1), _5))
        let _6 := add(var_assetCache_917_mpos, 256)
        write_to_memory_int96(_6, signextend(11, shr(80, _1)))
        let _7 := add(var_assetCache_917_mpos, 288)
        write_to_memory_uint32(_7, and(shr(176, _1), _5))
        write_to_memory_uint16(add(var_assetCache_917_mpos, 320), and(shr(208, _1), 0xffff))
        write_to_memory_uint32(add(var_assetCache_917_mpos, 352), shr(224, _1))
        let _8 := extract_from_storage_value_offsett_uint96(sload(add(var_assetStorage_slot, 1)))
        let _9 := add(var_assetCache_917_mpos, 96)
        write_to_memory_uint96(_9, _8)
        let _10 := sload(add(var_assetStorage_slot, 3))
        let _11 := add(var_assetCache_917_mpos, 32)
        let _12 := 0xffffffffffffffffffffffffffff
        write_to_memory_uint112(_11, and(_10, _12))
        let _13 := add(var_assetCache_917_mpos, 64)
        write_to_memory_uint144(_13, shr(112, _10))
        let _14 := sload(add(var_assetStorage_slot, 4))
        let _15 := add(var_assetCache_917_mpos, 128)
        mstore(_15, _14)
        let expr := exp(0x0a, and(sub(0x12, _4), 0xff))
        let _16 := add(var_assetCache_917_mpos, 416)
        mstore(_16, expr)
        let expr_1 := checked_div_uint256_12645(expr)
        let _17 := add(var_assetCache_917_mpos, 448)
        mstore(_17, expr_1)
        let expr_2 := modifier_FREEMEM_12646(var_assetCache_917_mpos, address())
        switch iszero(gt(expr_2, mload(_17)))
        case 0 {
            mstore(add(var_assetCache_917_mpos, 384), 0x00)
        }
        default {
            mstore(add(var_assetCache_917_mpos, 384), mul(expr_2, mload(_16)))
        }
        let _18 := cleanup_uint40(cleanup_uint40(mload(_2)))
        if iszero(eq(timestamp(), _18))
        {
            var_dirty := 1
            let expr_3 := fun_rpow(checked_add_int256(cleanup_int96(cleanup_int96(mload(_6)))), checked_sub_uint256(timestamp(), _18))
            let expr_4 := checked_div_uint256_12649(checked_mul_uint256(expr_3, mload(_15)))
            let expr_5 := checked_mul_uint256(cleanup_uint144(cleanup_uint144(mload(_13))), expr_4)
            let expr_6 := checked_div_uint256(expr_5, mload(_15))
            let var_newReserveBalance := cleanup_uint96(cleanup_uint96(mload(_9)))
            let var_newTotalBalances := cleanup_uint112(cleanup_uint112(mload(_11)))
            let expr_7 := checked_sub_uint256(expr_6, cleanup_uint144(cleanup_uint144(mload(_13))))
            let _19 := cleanup_uint32(mload(_7))
            let expr_8 := 0x00
            switch eq(and(_19, _5), _5)
            case 0 { expr_8 := _19 }
            default { expr_8 := 0x36d61600 }
            let expr_9 := checked_div_uint256_22855(checked_mul_uint256(expr_7, and(expr_8, _5)))
            if iszero(iszero(expr_9))
            {
                let _20 := mload(add(var_assetCache_917_mpos, 384))
                let expr_10 := checked_add_uint256(_20, div(expr_6, 0x3b9aca00))
                let expr_11 := checked_mul_uint256(expr_10, var_newTotalBalances)
                var_newTotalBalances := checked_div_uint256(expr_11, checked_sub_uint256(expr_10, expr_9))
                var_newReserveBalance := checked_add_uint256(var_newReserveBalance, checked_sub_uint256(var_newTotalBalances, cleanup_uint112(cleanup_uint112(mload(_11)))))
            }
            let expr_12 := iszero(gt(var_newTotalBalances, _12))
            if expr_12
            {
                expr_12 := iszero(gt(expr_6, 0xffffffffffffffffffffffffffffffffffff))
            }
            if expr_12
            {
                write_to_memory_uint144(_13, fun_encodeDebtAmount(expr_6))
                mstore(_15, expr_4)
                write_to_memory_uint40(_2, and(timestamp(), _3))
                if iszero(eq(var_newTotalBalances, cleanup_uint112(cleanup_uint112(mload(_11)))))
                {
                    write_to_memory_uint96(_9, fun_encodeSmallAmount(var_newReserveBalance))
                    write_to_memory_uint112(_11, fun_encodeAmount(var_newTotalBalances))
                }
            }
        }
    }
    /// @ast-id 1369
    function fun_encodeAmount(var_amount) -> var
    {
        let _1 := 0xffffffffffffffffffffffffffff
        if gt(var_amount, _1)
        {
            let memPtr := mload(64)
            mstore(memPtr, shl(229, 4594637))
            mstore(add(memPtr, 4), 32)
            mstore(add(memPtr, 36), 28)
            mstore(add(memPtr, 68), "e/amount-too-large-to-encode")
            revert(memPtr, 100)
        }
        var := and(var_amount, _1)
    }
    /// @ast-id 1389
    function fun_encodeSmallAmount(var_amount) -> var
    {
        let _1 := 0xffffffffffffffffffffffff
        if gt(var_amount, _1)
        {
            let memPtr := mload(64)
            mstore(memPtr, shl(229, 4594637))
            mstore(add(memPtr, 4), 32)
            mstore(add(memPtr, 36), 34)
            mstore(add(memPtr, 68), "e/small-amount-too-large-to-enco")
            mstore(add(memPtr, 100), "de")
            revert(memPtr, 132)
        }
        var := and(var_amount, _1)
    }
    /// @ast-id 1409
    function fun_encodeDebtAmount(var_amount) -> var
    {
        let _1 := 0xffffffffffffffffffffffffffffffffffff
        if gt(var_amount, _1)
        {
            let memPtr := mload(64)
            mstore(memPtr, shl(229, 4594637))
            mstore(add(memPtr, 4), 32)
            mstore(add(memPtr, 36), 33)
            mstore(add(memPtr, 68), "e/debt-amount-too-large-to-encod")
            mstore(add(memPtr, 100), "e")
            revert(memPtr, 132)
        }
        var := and(var_amount, _1)
    }
    /// @ast-id 147
    function modifier_FREEMEM_12646(var_assetCache_mpos, var_account) -> _1
    {
        let var_origFreeMemPtr := mload(0x40)
        _1 := fun_callBalanceOf_inner(var_assetCache_mpos, var_account)
        mstore(0x40, var_origFreeMemPtr)
    }
    function fun_callBalanceOf_inner(var_assetCache_mpos, var_account) -> var
    {
        let _1 := sub(shl(160, 1), 1)
        let cleaned := and(mload(var_assetCache_mpos), _1)
        let expr_1542_mpos := mload(64)
        let _2 := add(expr_1542_mpos, 0x20)
        mstore(_2, shl(224, 0x70a08231))
        mstore(add(expr_1542_mpos, 36), and(var_account, _1))
        mstore(expr_1542_mpos, 36)
        finalize_allocation_22852(expr_1542_mpos)
        let expr_1543_component := staticcall(0x4e20, cleaned, _2, mload(expr_1542_mpos), 0, 0)
        let expr_component_mpos := extract_returndata()
        let expr := iszero(expr_1543_component)
        if iszero(expr)
        {
            expr := lt(mload(expr_component_mpos), 0x20)
        }
        if expr
        {
            var := 0
            leave
        }
        if slt(sub(add(expr_component_mpos, mload(expr_component_mpos)), expr_component_mpos), 0x20) { revert(0, 0) }
        var := mload(add(expr_component_mpos, 0x20))
    }
    /// @ast-id 11294
    function fun_getPriceFull(var_underlying) -> var_twap, var_twapPeriod, var_currPrice
    {
        var_currPrice := 0
        let expr_11199_mpos := fun_resolveAssetConfig(var_underlying)
        let _1 := mapping_index_access_mapping_address_address_of_address_12628(cleanup_address(mload(expr_11199_mpos)))
        let expr_11215_mpos := fun_loadAssetCache(var_underlying, _1)
        let var_twap_1, var_twapPeriod_1 := modifier_FREEMEM(expr_11215_mpos, expr_11199_mpos)
        var_twapPeriod := var_twapPeriod_1
        var_twap := var_twap_1
        let expr_11235_component, expr_component, expr_component_1, expr_component_2 := fun_resolvePricingConfig(expr_11215_mpos, expr_11199_mpos)
        let _2 := and(expr_component, 0xffff)
        switch eq(_2, 0x01)
        case 0 {
            let expr := eq(_2, 0x02)
            if iszero(expr) { expr := eq(_2, 0x03) }
            switch expr
            case 0 {
                let _3 := mload(64)
                mstore(_3, shl(229, 4594637))
                revert(_3, sub(abi_encode_stringliteral_ee51(add(_3, 4)), _3))
            }
            default {
                let expr_11258_mpos := fun_loadAssetCache(expr_11235_component, _1)
                let expr_address := cleanup_address(cleanup_address(fun_computeUniswapPoolAddress(expr_11235_component, and(expr_component_1, 0xffffff))))
                let _4 := mload(64)
                mstore(_4, shl(224, 0x3850c7bd))
                let _5 := staticcall(gas(), expr_address, _4, 4, _4, 224)
                if iszero(_5) { revert_forward() }
                let expr_component_3 := 0
                if _5
                {
                    finalize_allocation(_4, returndatasize())
                    let expr_component_4, expr_component_5, expr_component_6, expr_component_7, expr_component_8, expr_component_9, expr_component_10 := abi_decode_uint160t_int24t_uint16t_uint16t_uint16t_uint8t_bool_fromMemory(_4, add(_4, returndatasize()))
                    expr_component_3 := expr_component_4
                }
                var_currPrice := fun_decodeSqrtPriceX96(expr_11258_mpos, and(expr_component_3, sub(shl(160, 1), 1)))
            }
        }
        default {
            var_currPrice := 0x0de0b6b3a7640000
        }
    }
    function allocate_and_zero_memory_struct_struct_LiquidityStatus() -> memPtr
    {
        let memPtr_1 := mload(64)
        let newFreePtr := add(memPtr_1, 128)
        if or(gt(newFreePtr, 0xffffffffffffffff), lt(newFreePtr, memPtr_1)) { panic_error_0x41() }
        mstore(64, newFreePtr)
        memPtr := memPtr_1
        mstore(memPtr_1, 0)
        mstore(add(memPtr_1, 32), 0)
        mstore(add(memPtr_1, 64), 0)
        mstore(add(memPtr_1, 96), 0)
    }
    /// @ast-id 11550
    function fun_computeLiquidity(var_account) -> var__mpos
    {
        pop(allocate_and_zero_memory_struct_struct_LiquidityStatus())
        var__mpos := fun_computeLiquidityRaw(var_account, fun_getEnteredMarketsArray(var_account))
    }
    function allocate_and_zero_memory_array_array_address_dyn() -> memPtr
    {
        let memPtr_1 := mload(64)
        finalize_allocation_12670(memPtr_1)
        mstore(memPtr_1, 0x01)
        memPtr := memPtr_1
        calldatacopy(add(memPtr_1, 0x20), calldatasize(), 0x20)
    }
    function storage_array_index_access_address_ptr(array, index) -> slot, offset
    {
        if iszero(lt(index, 0x0100000000)) { panic_error_0x32() }
        slot := add(array, index)
        offset := 0
    }
    function extract_from_storage_value_dynamict_address(slot_value, offset) -> value
    {
        value := and(shr(shl(3, offset), slot_value), sub(shl(160, 1), 1))
    }
    /// @ast-id 510
    function fun_getEnteredMarketsArray(var_account) -> var_438_mpos
    {
        let _1 := sub(shl(160, 1), 1)
        mstore(0, and(var_account, _1))
        mstore(0x20, 0x06)
        let value := and(shr(48, sload(keccak256(0, 0x40))), 0xffffffff)
        let value_1 := and(shr(80, sload(keccak256(0, 0x40))), _1)
        let _2 := array_allocation_size_array_uint32_dyn(value)
        let memPtr := mload(0x40)
        finalize_allocation(memPtr, _2)
        mstore(memPtr, value)
        calldatacopy(add(memPtr, 0x20), calldatasize(), add(array_allocation_size_array_uint32_dyn(value), not(31)))
        if iszero(value)
        {
            var_438_mpos := memPtr
            leave
        }
        let _3 := mapping_index_access_mapping_address_address_of_address_12656(var_account)
        write_to_memory_address(memory_array_index_access_uint32_dyn_12584(memPtr), value_1)
        let var_i := 1
        for { }
        lt(var_i, value)
        {
            var_i := increment_uint256(var_i)
        }
        {
            let _4, _5 := storage_array_index_access_address_ptr(_3, var_i)
            write_to_memory_address(memory_array_index_access_uint32_dyn(memPtr, var_i), extract_from_storage_value_dynamict_address(sload(_4), _5))
        }
        var_438_mpos := memPtr
    }
    /// @ast-id 11533
    function fun_computeLiquidityRaw(var_account, var_underlyings_mpos) -> var_status_mpos
    {
        var_status_mpos := allocate_and_zero_memory_struct_struct_LiquidityStatus()
        mstore(var_status_mpos, 0x00)
        let _1 := add(var_status_mpos, 32)
        mstore(_1, 0x00)
        let _2 := add(var_status_mpos, 64)
        mstore(_2, 0x00)
        let _3 := add(var_status_mpos, 96)
        mstore(_3, 0x00)
        pop(allocate_and_zero_memory_struct_struct_AssetConfig())
        let zero_struct_AssetCache_mpos := allocate_and_zero_memory_struct_struct_AssetCache()
        let var_i := 0x00
        for { }
        1
        {
            var_i := increment_uint256(var_i)
        }
        {
            if iszero(lt(var_i, mload(var_underlyings_mpos))) { break }
            let _4 := read_from_memoryt_address(memory_array_index_access_uint32_dyn(var_underlyings_mpos, var_i))
            let var_price := 0x00
            let var_assetCacheAndPriceInited := 0x00
            var_price := 0x00
            let var_config_mpos := fun_resolveAssetConfig(_4)
            let _5 := mapping_index_access_mapping_address_address_of_address_12628(cleanup_address(mload(var_config_mpos)))
            let var_balance := cleanup_uint112(read_from_storage_split_offset_uint112(mapping_index_access_mapping_address_address_of_address(add(_5, 5), var_account)))
            let var_owed := cleanup_uint144(read_from_storage_split_offset_uint144(mapping_index_access_mapping_address_address_of_address(add(_5, 5), var_account)))
            let expr := iszero(iszero(var_balance))
            if expr
            {
                expr := iszero(iszero(and(cleanup_uint32(mload(add(var_config_mpos, 64))), 0xffffffff)))
            }
            if expr
            {
                pop(fun_initAssetCache(_4, _5, zero_struct_AssetCache_mpos))
                let var_twap, var_twapPeriod := modifier_FREEMEM_12660(zero_struct_AssetCache_mpos, var_config_mpos)
                var_price := var_twap
                var_assetCacheAndPriceInited := 0x01
                let expr_1 := checked_div_uint256_12661(checked_mul_uint256(div(checked_mul_uint256(var_balance, fun_computeExchangeRate(zero_struct_AssetCache_mpos)), 0x0de0b6b3a7640000), var_twap))
                mstore(var_status_mpos, checked_add_uint256(mload(var_status_mpos), checked_div_uint256_12662(checked_mul_uint256(expr_1, cleanup_uint32(cleanup_uint32(mload(add(var_config_mpos, 64))))))))
            }
            if iszero(iszero(var_owed))
            {
                if iszero(var_assetCacheAndPriceInited)
                {
                    pop(fun_initAssetCache(_4, _5, zero_struct_AssetCache_mpos))
                    let var_twap_1, var_twapPeriod_1 := modifier_FREEMEM_12660(zero_struct_AssetCache_mpos, var_config_mpos)
                    var_price := var_twap_1
                }
                mstore(_2, increment_uint256(mload(_2)))
                if cleanup_bool(mload(add(var_config_mpos, 32))) { write_to_memory_bool(_3) }
                let expr_2 := checked_div_uint256_12661(checked_mul_uint256(div(fun_roundUpOwed(zero_struct_AssetCache_mpos, fun_getCurrentOwedExact(_5, zero_struct_AssetCache_mpos, var_account, shr(112, sload(mapping_index_access_mapping_address_address_of_address(add(_5, 5), var_account))))), 0x3b9aca00), var_price))
                let _6 := add(var_config_mpos, 96)
                let expr_3 := iszero(iszero(and(cleanup_uint32(mload(_6)), 0xffffffff)))
                let expr_4 := 0x00
                switch expr_3
                case 0 {
                    expr_4 := 0xffffffffffffffffffffffffffffffffffff
                }
                default {
                    let expr_5 := checked_mul_uint256_12666(expr_2)
                    expr_4 := checked_div_uint256(expr_5, cleanup_uint32(cleanup_uint32(mload(_6))))
                }
                mstore(_1, checked_add_uint256(mload(_1), expr_4))
            }
        }
    }
    /// @ast-id 1440
    function fun_computeExchangeRate(var_assetCache_1412_mpos) -> var
    {
        let _1 := add(var_assetCache_1412_mpos, 32)
        let _2 := 0xffffffffffffffffffffffffffff
        if iszero(and(mload(_1), _2))
        {
            var := 0x0de0b6b3a7640000
            leave
        }
        let _3 := mload(add(var_assetCache_1412_mpos, 384))
        let expr := checked_add_uint256(_3, div(and(mload(add(var_assetCache_1412_mpos, 64)), 0xffffffffffffffffffffffffffffffffffff), 0x3b9aca00))
        let _4 := 0x0de0b6b3a7640000
        if and(iszero(iszero(expr)), gt(_4, div(not(0), expr))) { panic_error_0x11() }
        let cleaned := and(mload(_1), _2)
        if iszero(cleaned) { panic_error_0x12() }
        var := div(mul(expr, _4), cleaned)
    }
    /// @ast-id 2027
    function fun_getCurrentOwedExact(var_assetStorage_1997_slot, var_assetCache_mpos, var_account, var_owed) -> var
    {
        if iszero(var_owed)
        {
            var := 0x00
            leave
        }
        let expr := checked_mul_uint256(var_owed, mload(add(var_assetCache_mpos, 128)))
        let _1 := sload(add(mapping_index_access_mapping_address_address_of_address(add(var_assetStorage_1997_slot, 5), var_account), 1))
        if iszero(_1) { panic_error_0x12() }
        var := div(expr, _1)
    }
    /// @ast-id 2063
    function fun_roundUpOwed(var_assetCache_2030_mpos, var_owed) -> var_
    {
        if iszero(var_owed)
        {
            var_ := 0x00
            leave
        }
        let _1 := mload(add(var_assetCache_2030_mpos, 416))
        let _2 := 0x3b9aca00
        let product := mul(_2, _1)
        if iszero(product) { panic_error_0x12() }
        var_ := mul(mul(div(add(add(var_owed, product), not(0)), product), _1), _2)
    }
    /// @ast-id 11632
    function fun_computeAssetLiquidities(var_account) -> var_mpos
    {
        let expr_11567_mpos := fun_getEnteredMarketsArray(var_account)
        let _1 := mload(expr_11567_mpos)
        let _2 := array_allocation_size_array_uint32_dyn(_1)
        let _3 := 64
        let memPtr := mload(_3)
        finalize_allocation(memPtr, _2)
        mstore(memPtr, _1)
        let _4 := add(array_allocation_size_array_uint32_dyn(_1), not(31))
        let i := 0
        let i_1 := i
        for { } lt(i_1, _4) { i_1 := add(i_1, 32) }
        {
            let memPtr_1 := mload(_3)
            finalize_allocation_12670(memPtr_1)
            mstore(memPtr_1, i)
            let _5 := allocate_and_zero_memory_struct_struct_LiquidityStatus()
            let _6 := 32
            mstore(add(memPtr_1, _6), _5)
            mstore(add(add(memPtr, i_1), _6), memPtr_1)
        }
        let expr_mpos := allocate_and_zero_memory_array_array_address_dyn()
        let var_i := i
        for { }
        0x01
        {
            var_i := increment_uint256(var_i)
        }
        {
            if iszero(lt(var_i, mload(expr_11567_mpos))) { break }
            let _7 := read_from_memoryt_address(memory_array_index_access_uint32_dyn(expr_11567_mpos, var_i))
            write_to_memory_address(memory_array_index_access_uint32_dyn_12584(expr_mpos), _7)
            write_to_memory_address(mload(memory_array_index_access_uint32_dyn(memPtr, var_i)), _7)
            mstore(add(mload(memory_array_index_access_uint32_dyn(memPtr, var_i)), 32), fun_computeLiquidityRaw(var_account, expr_mpos))
        }
        var_mpos := memPtr
    }
    /// @ast-id 11667
    function fun_requireLiquidity(var_account)
    {
        pop(allocate_and_zero_memory_struct_struct_LiquidityStatus())
        let var_mpos := fun_computeLiquidityRaw(var_account, fun_getEnteredMarketsArray(var_account))
        let expr := iszero(mload(add(var_mpos, 96)))
        if iszero(expr)
        {
            expr := eq(mload(add(var_mpos, 64)), 0x01)
        }
        if iszero(expr)
        {
            let memPtr := mload(64)
            mstore(memPtr, shl(229, 4594637))
            mstore(add(memPtr, 4), 32)
            mstore(add(memPtr, 36), 28)
            mstore(add(memPtr, 68), "e/borrow-isolation-violation")
            revert(memPtr, 100)
        }
        let _1 := mload(var_mpos)
        if lt(_1, mload(add(var_mpos, 32)))
        {
            let memPtr_1 := mload(64)
            mstore(memPtr_1, shl(229, 4594637))
            mstore(add(memPtr_1, 4), 32)
            mstore(add(memPtr_1, 36), 22)
            mstore(add(memPtr_1, 68), "e/collateral-violation")
            revert(memPtr_1, 100)
        }
    }
    function require_helper(condition)
    {
        if iszero(condition) { revert(0, 0) }
    }
    /// @ast-id 13238
    function fun_mulDiv_22854(var_a, var_b) -> var_result
    {
        let usr$mm := mulmod(var_a, var_b, not(0))
        let var_prod0 := mul(var_a, var_b)
        let _1 := lt(usr$mm, var_prod0)
        let _2 := sub(usr$mm, var_prod0)
        let var_prod1 := sub(_2, _1)
        if eq(_2, _1)
        {
            var_result := div(var_prod0, 0x12725dd1d243aba0e75fe645cc4873f9e6)
            leave
        }
        let _3 := 0x12725dd1d243aba0e75fe645cc4873f9e6
        if iszero(gt(_3, var_prod1)) { revert(0, 0) }
        let var_remainder := mulmod(var_a, var_b, _3)
        var_result := mul(or(shr(0x01, sub(var_prod0, var_remainder)), shl(255, sub(var_prod1, gt(var_remainder, var_prod0)))), 0x80bf433070d530fec992d281993084ea0851f19952bccb6b6d6a90f542af7c3b)
    }
    /// @ast-id 13238
    function fun_mulDiv(var_a, var_b, var_denominator) -> var_result
    {
        let usr$mm := mulmod(var_a, var_b, not(0))
        let var_prod0 := mul(var_a, var_b)
        let _1 := lt(usr$mm, var_prod0)
        let _2 := sub(usr$mm, var_prod0)
        let var_prod1 := sub(_2, _1)
        if eq(_2, _1)
        {
            require_helper(iszero(iszero(var_denominator)))
            var_result := div(var_prod0, var_denominator)
            leave
        }
        require_helper(gt(var_denominator, var_prod1))
        let var_remainder := mulmod(var_a, var_b, var_denominator)
        let expr := and(var_denominator, add(not(var_denominator), 0x01))
        let var_denominator_1 := div(var_denominator, expr)
        let _3 := 0x02
        let expr_1 := xor(mul(0x03, var_denominator_1), _3)
        let expr_2 := mul(expr_1, sub(_3, mul(var_denominator_1, expr_1)))
        let expr_3 := mul(expr_2, sub(_3, mul(var_denominator_1, expr_2)))
        let expr_4 := mul(expr_3, sub(_3, mul(var_denominator_1, expr_3)))
        let expr_5 := mul(expr_4, sub(_3, mul(var_denominator_1, expr_4)))
        let expr_6 := mul(expr_5, sub(_3, mul(var_denominator_1, expr_5)))
        var_result := mul(or(div(sub(var_prod0, var_remainder), expr), mul(sub(var_prod1, gt(var_remainder, var_prod0)), add(div(sub(0, expr), expr), 0x01))), mul(expr_6, sub(_3, mul(var_denominator_1, expr_6))))
    }
    /// @ast-id 13412
    function fun_rpow(var_x, var_n) -> var_z
    {
        switch var_x
        case 0 {
            switch var_n
            case 0 {
                var_z := 0x033b2e3c9fd0803ce8000000
            }
            default { var_z := 0 }
        }
        default {
            let _1 := 1
            switch and(var_n, _1)
            case 0 {
                var_z := 0x033b2e3c9fd0803ce8000000
            }
            default { var_z := var_x }
            var_n := shr(_1, var_n)
            for { } var_n { var_n := shr(_1, var_n) }
            {
                let usr$xx := mul(var_x, var_x)
                if iszero(eq(div(usr$xx, var_x), var_x))
                {
                    let _2 := 0
                    revert(_2, _2)
                }
                let _3 := 0x019d971e4fe8401e74000000
                let usr$xxRound := add(usr$xx, _3)
                if lt(usr$xxRound, usr$xx)
                {
                    let _4 := 0
                    revert(_4, _4)
                }
                let _5 := 0x033b2e3c9fd0803ce8000000
                var_x := div(usr$xxRound, _5)
                if and(var_n, _1)
                {
                    let usr$zx := mul(var_z, var_x)
                    if and(iszero(iszero(var_x)), iszero(eq(div(usr$zx, var_x), var_z)))
                    {
                        let _6 := 0
                        revert(_6, _6)
                    }
                    let usr$zxRound := add(usr$zx, _3)
                    if lt(usr$zxRound, usr$zx)
                    {
                        let _7 := 0
                        revert(_7, _7)
                    }
                    var_z := div(usr$zxRound, _5)
                }
            }
        }
    }
    function require_helper_stringliteral_846b(condition)
    {
        if iszero(condition)
        {
            let memPtr := mload(64)
            mstore(memPtr, shl(229, 4594637))
            mstore(add(memPtr, 4), 32)
            mstore(add(memPtr, 36), 1)
            mstore(add(memPtr, 68), "T")
            revert(memPtr, 100)
        }
    }
    /// @ast-id 13812
    function fun_getSqrtRatioAtTick(var_tick) -> var_sqrtPriceX96
    {
        let _1 := signextend(2, var_tick)
        let expr := 0x00
        switch slt(_1, expr)
        case 0 { expr := _1 }
        default { expr := sub(0x00, _1) }
        require_helper_stringliteral_846b(iszero(gt(expr, 887272)))
        let expr_1 := 0x00
        switch iszero(iszero(and(expr, 0x01)))
        case 0 { expr_1 := shl(128, 1) }
        default {
            expr_1 := 0xfffcb933bd6fad37aa2d162d1a594001
        }
        let var_ratio := and(expr_1, 0xffffffffffffffffffffffffffffffffff)
        if iszero(iszero(and(expr, 2)))
        {
            var_ratio := shr(128, mul(var_ratio, 0xfff97272373d413259a46990580e213a))
        }
        if iszero(iszero(and(expr, 0x04)))
        {
            var_ratio := shr(128, mul(var_ratio, 0xfff2e50f5f656932ef12357cf3c7fdcc))
        }
        if iszero(iszero(and(expr, 0x08)))
        {
            var_ratio := shr(128, mul(var_ratio, 0xffe5caca7e10e4e61c3624eaa0941cd0))
        }
        if iszero(iszero(and(expr, 0x10)))
        {
            var_ratio := shr(128, mul(var_ratio, 0xffcb9843d60f6159c9db58835c926644))
        }
        if iszero(iszero(and(expr, 0x20)))
        {
            var_ratio := shr(128, mul(var_ratio, 0xff973b41fa98c081472e6896dfb254c0))
        }
        if iszero(iszero(and(expr, 0x40)))
        {
            var_ratio := shr(128, mul(var_ratio, 0xff2ea16466c96a3843ec78b326b52861))
        }
        let _2 := 0x80
        if iszero(iszero(and(expr, _2)))
        {
            var_ratio := shr(_2, mul(var_ratio, 0xfe5dee046a99a2a811c461f1969c3053))
        }
        if iszero(iszero(and(expr, 0x0100)))
        {
            var_ratio := shr(_2, mul(var_ratio, 0xfcbe86c7900a88aedcffc83b479aa3a4))
        }
        if iszero(iszero(and(expr, 0x0200)))
        {
            var_ratio := shr(_2, mul(var_ratio, 0xf987a7253ac413176f2b074cf7815e54))
        }
        if iszero(iszero(and(expr, 0x0400)))
        {
            var_ratio := shr(_2, mul(var_ratio, 0xf3392b0822b70005940c7a398e4b70f3))
        }
        if iszero(iszero(and(expr, 0x0800)))
        {
            var_ratio := shr(_2, mul(var_ratio, 0xe7159475a2c29b7443b29c7fa6e889d9))
        }
        if iszero(iszero(and(expr, 0x1000)))
        {
            var_ratio := shr(_2, mul(var_ratio, 0xd097f3bdfd2022b8845ad8f792aa5825))
        }
        if iszero(iszero(and(expr, 0x2000)))
        {
            var_ratio := shr(_2, mul(var_ratio, 0xa9f746462d870fdf8a65dc1f90e061e5))
        }
        if iszero(iszero(and(expr, 0x4000)))
        {
            var_ratio := shr(_2, mul(var_ratio, 0x70d869a156d2a1b890bb3df62baf32f7))
        }
        if iszero(iszero(and(expr, 0x8000)))
        {
            var_ratio := shr(_2, mul(var_ratio, 0x31be135f97d08fd981231505542fcfa6))
        }
        if iszero(iszero(and(expr, 0x010000)))
        {
            var_ratio := shr(_2, mul(var_ratio, 0x09aa508b5b7a84e1c677de54f3e99bc9))
        }
        if iszero(iszero(and(expr, 0x020000)))
        {
            var_ratio := shr(_2, mul(var_ratio, 0x5d6af8dedb81196699c329225ee604))
        }
        if iszero(iszero(and(expr, 0x040000)))
        {
            var_ratio := shr(_2, mul(var_ratio, 0x2216e584f5fa1ea926041bedfe98))
        }
        if iszero(iszero(and(expr, 0x080000)))
        {
            var_ratio := shr(_2, mul(var_ratio, 0x048a170391f7dc42444e8fa2))
        }
        if sgt(_1, 0x00)
        {
            var_ratio := checked_div_uint256_12692(var_ratio)
        }
        let expr_2 := 0x00
        switch iszero(and(var_ratio, 0xffffffff))
        case 0 { expr_2 := 0x01 }
        default { expr_2 := 0x00 }
        var_sqrtPriceX96 := and(add(shr(0x20, var_ratio), and(expr_2, 0xff)), sub(shl(160, 1), 1))
    }
}
// ====
// stackOptimization: true
// ----