@pendle/core-v2 2.29.1 → 2.29.2

package/contracts/core/StandardizedYield/implementations/Kyber/libraries/SwapMath.sol

@@ -0,0 +1,338 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.0;
+
+import { MathConstants as C } from "./MathConstants.sol";
+import { FullMath } from "./FullMath.sol";
+import { QuadMath } from "./QuadMath.sol";
+import { SafeCast } from "./SafeCast.sol";
+
+
+/**
+ *      ---------      [DIRECT COPIED FROM KYBERSWAP]      ---------
+ */
+
+
+/// @title Contains helper functions for swaps
+library SwapMath {
+    using SafeCast for uint256;
+    using SafeCast for int256;
+
+    /// @dev Computes the actual swap input / output amounts to be deducted or added,
+    /// the swap fee to be collected and the resulting sqrtP.
+    /// @notice nextSqrtP should not exceed targetSqrtP.
+    /// @param liquidity active base liquidity + reinvest liquidity
+    /// @param currentSqrtP current sqrt price
+    /// @param targetSqrtP sqrt price limit the new sqrt price can take
+    /// @param feeInFeeUnits swap fee in basis points
+    /// @param specifiedAmount the amount remaining to be used for the swap
+    /// @param isExactInput true if specifiedAmount refers to input amount, false if specifiedAmount refers to output amount
+    /// @param isToken0 true if specifiedAmount is in token0, false if specifiedAmount is in token1
+    /// @return usedAmount actual amount to be used for the swap
+    /// @return returnedAmount output qty to be accumulated if isExactInput = true, input qty if isExactInput = false
+    /// @return deltaL collected swap fee, to be incremented to reinvest liquidity
+    /// @return nextSqrtP the new sqrt price after the computed swap step
+    function computeSwapStep(
+        uint256 liquidity,
+        uint160 currentSqrtP,
+        uint160 targetSqrtP,
+        uint256 feeInFeeUnits,
+        int256 specifiedAmount,
+        bool isExactInput,
+        bool isToken0
+    )
+        internal
+        pure
+        returns (int256 usedAmount, int256 returnedAmount, uint256 deltaL, uint160 nextSqrtP)
+    {
+        // in the event currentSqrtP == targetSqrtP because of tick movements, return
+        // eg. swapped up tick where specified price limit is on an initialised tick
+        // then swapping down tick will cause next tick to be the same as the current tick
+        if (currentSqrtP == targetSqrtP) return (0, 0, 0, currentSqrtP);
+        usedAmount = calcReachAmount(
+            liquidity,
+            currentSqrtP,
+            targetSqrtP,
+            feeInFeeUnits,
+            isExactInput,
+            isToken0
+        );
+
+        if (
+            (isExactInput && usedAmount > specifiedAmount) ||
+            (!isExactInput && usedAmount <= specifiedAmount)
+        ) {
+            usedAmount = specifiedAmount;
+        } else {
+            nextSqrtP = targetSqrtP;
+        }
+
+        uint256 absDelta = usedAmount >= 0 ? uint256(usedAmount) : usedAmount.revToUint256();
+        if (nextSqrtP == 0) {
+            deltaL = estimateIncrementalLiquidity(
+                absDelta,
+                liquidity,
+                currentSqrtP,
+                feeInFeeUnits,
+                isExactInput,
+                isToken0
+            );
+            nextSqrtP = calcFinalPrice(
+                absDelta,
+                liquidity,
+                deltaL,
+                currentSqrtP,
+                isExactInput,
+                isToken0
+            ).toUint160();
+        } else {
+            deltaL = calcIncrementalLiquidity(
+                absDelta,
+                liquidity,
+                currentSqrtP,
+                nextSqrtP,
+                isExactInput,
+                isToken0
+            );
+        }
+        returnedAmount = calcReturnedAmount(
+            liquidity,
+            currentSqrtP,
+            nextSqrtP,
+            deltaL,
+            isExactInput,
+            isToken0
+        );
+    }
+
+    /// @dev calculates the amount needed to reach targetSqrtP from currentSqrtP
+    /// @dev we cast currentSqrtP and targetSqrtP to uint256 as they are multiplied by TWO_FEE_UNITS or feeInFeeUnits
+    function calcReachAmount(
+        uint256 liquidity,
+        uint256 currentSqrtP,
+        uint256 targetSqrtP,
+        uint256 feeInFeeUnits,
+        bool isExactInput,
+        bool isToken0
+    ) internal pure returns (int256 reachAmount) {
+        uint256 absPriceDiff;
+        unchecked {
+            absPriceDiff = (currentSqrtP >= targetSqrtP)
+                ? (currentSqrtP - targetSqrtP)
+                : (targetSqrtP - currentSqrtP);
+        }
+        if (isExactInput) {
+            // we round down so that we avoid taking giving away too much for the specified input
+            // ie. require less input qty to move ticks
+            if (isToken0) {
+                // numerator = 2 * liquidity * absPriceDiff
+                // denominator = currentSqrtP * (2 * targetSqrtP - currentSqrtP * feeInFeeUnits / FEE_UNITS)
+                // overflow should not happen because the absPriceDiff is capped to ~5%
+                uint256 denominator = C.TWO_FEE_UNITS * targetSqrtP - feeInFeeUnits * currentSqrtP;
+                uint256 numerator = FullMath.mulDivFloor(
+                    liquidity,
+                    C.TWO_FEE_UNITS * absPriceDiff,
+                    denominator
+                );
+                reachAmount = FullMath
+                    .mulDivFloor(numerator, C.TWO_POW_96, currentSqrtP)
+                    .toInt256();
+            } else {
+                // numerator = 2 * liquidity * absPriceDiff * currentSqrtP
+                // denominator = 2 * currentSqrtP - targetSqrtP * feeInFeeUnits / FEE_UNITS
+                // overflow should not happen because the absPriceDiff is capped to ~5%
+                uint256 denominator = C.TWO_FEE_UNITS * currentSqrtP - feeInFeeUnits * targetSqrtP;
+                uint256 numerator = FullMath.mulDivFloor(
+                    liquidity,
+                    C.TWO_FEE_UNITS * absPriceDiff,
+                    denominator
+                );
+                reachAmount = FullMath
+                    .mulDivFloor(numerator, currentSqrtP, C.TWO_POW_96)
+                    .toInt256();
+            }
+        } else {
+            // we will perform negation as the last step
+            // we round down so that we require less output qty to move ticks
+            if (isToken0) {
+                // numerator: (liquidity)(absPriceDiff)(2 * currentSqrtP - deltaL * (currentSqrtP + targetSqrtP))
+                // denominator: (currentSqrtP * targetSqrtP) * (2 * currentSqrtP - deltaL * targetSqrtP)
+                // overflow should not happen because the absPriceDiff is capped to ~5%
+                uint256 denominator = C.TWO_FEE_UNITS * currentSqrtP - feeInFeeUnits * targetSqrtP;
+                uint256 numerator = denominator - feeInFeeUnits * currentSqrtP;
+                numerator = FullMath.mulDivFloor(liquidity << C.RES_96, numerator, denominator);
+                reachAmount = (FullMath.mulDivFloor(numerator, absPriceDiff, currentSqrtP) /
+                    targetSqrtP).revToInt256();
+            } else {
+                // numerator: liquidity * absPriceDiff * (TWO_FEE_UNITS * targetSqrtP - feeInFeeUnits * (targetSqrtP + currentSqrtP))
+                // denominator: (TWO_FEE_UNITS * targetSqrtP - feeInFeeUnits * currentSqrtP)
+                // overflow should not happen because the absPriceDiff is capped to ~5%
+                uint256 denominator = C.TWO_FEE_UNITS * targetSqrtP - feeInFeeUnits * currentSqrtP;
+                uint256 numerator = denominator - feeInFeeUnits * targetSqrtP;
+                numerator = FullMath.mulDivFloor(liquidity, numerator, denominator);
+                reachAmount = FullMath
+                    .mulDivFloor(numerator, absPriceDiff, C.TWO_POW_96)
+                    .revToInt256();
+            }
+        }
+    }
+
+    /// @dev estimates deltaL, the swap fee to be collected based on amount specified
+    /// for the final swap step to be performed,
+    /// where the next (temporary) tick will not be crossed
+    function estimateIncrementalLiquidity(
+        uint256 absDelta,
+        uint256 liquidity,
+        uint160 currentSqrtP,
+        uint256 feeInFeeUnits,
+        bool isExactInput,
+        bool isToken0
+    ) internal pure returns (uint256 deltaL) {
+        if (isExactInput) {
+            if (isToken0) {
+                // deltaL = feeInFeeUnits * absDelta * currentSqrtP / 2
+                deltaL = FullMath.mulDivFloor(
+                    currentSqrtP,
+                    absDelta * feeInFeeUnits,
+                    C.TWO_FEE_UNITS << C.RES_96
+                );
+            } else {
+                // deltaL = feeInFeeUnits * absDelta * / (currentSqrtP * 2)
+                // Because nextSqrtP = (liquidity + absDelta / currentSqrtP) * currentSqrtP / (liquidity + deltaL)
+                // so we round up deltaL, to round down nextSqrtP
+                deltaL = FullMath.mulDivFloor(
+                    C.TWO_POW_96,
+                    absDelta * feeInFeeUnits,
+                    C.TWO_FEE_UNITS * currentSqrtP
+                );
+            }
+        } else {
+            // obtain the smaller root of the quadratic equation
+            // ax^2 - 2bx + c = 0 such that b > 0, and x denotes deltaL
+            uint256 a = feeInFeeUnits;
+            uint256 b = (C.FEE_UNITS - feeInFeeUnits) * liquidity;
+            uint256 c = feeInFeeUnits * liquidity * absDelta;
+            if (isToken0) {
+                // a = feeInFeeUnits
+                // b = (FEE_UNITS - feeInFeeUnits) * liquidity - FEE_UNITS * absDelta * currentSqrtP
+                // c = feeInFeeUnits * liquidity * absDelta * currentSqrtP
+                b -= FullMath.mulDivFloor(C.FEE_UNITS * absDelta, currentSqrtP, C.TWO_POW_96);
+                c = FullMath.mulDivFloor(c, currentSqrtP, C.TWO_POW_96);
+            } else {
+                // a = feeInFeeUnits
+                // b = (FEE_UNITS - feeInFeeUnits) * liquidity - FEE_UNITS * absDelta / currentSqrtP
+                // c = liquidity * feeInFeeUnits * absDelta / currentSqrtP
+                b -= FullMath.mulDivFloor(C.FEE_UNITS * absDelta, C.TWO_POW_96, currentSqrtP);
+                c = FullMath.mulDivFloor(c, C.TWO_POW_96, currentSqrtP);
+            }
+            deltaL = QuadMath.getSmallerRootOfQuadEqn(a, b, c);
+        }
+    }
+
+    /// @dev calculates deltaL, the swap fee to be collected for an intermediate swap step,
+    /// where the next (temporary) tick will be crossed
+    function calcIncrementalLiquidity(
+        uint256 absDelta,
+        uint256 liquidity,
+        uint160 currentSqrtP,
+        uint160 nextSqrtP,
+        bool isExactInput,
+        bool isToken0
+    ) internal pure returns (uint256 deltaL) {
+        if (isToken0) {
+            // deltaL = nextSqrtP * (liquidity / currentSqrtP +/- absDelta)) - liquidity
+            // needs to be minimum
+            uint256 tmp1 = FullMath.mulDivFloor(liquidity, C.TWO_POW_96, currentSqrtP);
+            uint256 tmp2 = isExactInput ? tmp1 + absDelta : tmp1 - absDelta;
+            uint256 tmp3 = FullMath.mulDivFloor(nextSqrtP, tmp2, C.TWO_POW_96);
+            // in edge cases where liquidity or absDelta is small
+            // liquidity might be greater than nextSqrtP * ((liquidity / currentSqrtP) +/- absDelta))
+            // due to rounding
+            deltaL = (tmp3 > liquidity) ? tmp3 - liquidity : 0;
+        } else {
+            // deltaL = (liquidity * currentSqrtP +/- absDelta) / nextSqrtP - liquidity
+            // needs to be minimum
+            uint256 tmp1 = FullMath.mulDivFloor(liquidity, currentSqrtP, C.TWO_POW_96);
+            uint256 tmp2 = isExactInput ? tmp1 + absDelta : tmp1 - absDelta;
+            uint256 tmp3 = FullMath.mulDivFloor(tmp2, C.TWO_POW_96, nextSqrtP);
+            // in edge cases where liquidity or absDelta is small
+            // liquidity might be greater than nextSqrtP * ((liquidity / currentSqrtP) +/- absDelta))
+            // due to rounding
+            deltaL = (tmp3 > liquidity) ? tmp3 - liquidity : 0;
+        }
+    }
+
+    /// @dev calculates the sqrt price of the final swap step
+    /// where the next (temporary) tick will not be crossed
+    function calcFinalPrice(
+        uint256 absDelta,
+        uint256 liquidity,
+        uint256 deltaL,
+        uint160 currentSqrtP,
+        bool isExactInput,
+        bool isToken0
+    ) internal pure returns (uint256) {
+        if (isToken0) {
+            // if isExactInput: swap 0 -> 1, sqrtP decreases, we round up
+            // else swap: 1 -> 0, sqrtP increases, we round down
+            uint256 tmp = FullMath.mulDivFloor(absDelta, currentSqrtP, C.TWO_POW_96);
+            if (isExactInput) {
+                return FullMath.mulDivCeiling(liquidity + deltaL, currentSqrtP, liquidity + tmp);
+            } else {
+                return FullMath.mulDivFloor(liquidity + deltaL, currentSqrtP, liquidity - tmp);
+            }
+        } else {
+            // if isExactInput: swap 1 -> 0, sqrtP increases, we round down
+            // else swap: 0 -> 1, sqrtP decreases, we round up
+            uint256 tmp = FullMath.mulDivFloor(absDelta, C.TWO_POW_96, currentSqrtP);
+            if (isExactInput) {
+                return FullMath.mulDivFloor(liquidity + tmp, currentSqrtP, liquidity + deltaL);
+            } else {
+                return FullMath.mulDivCeiling(liquidity - tmp, currentSqrtP, liquidity + deltaL);
+            }
+        }
+    }
+
+    /// @dev calculates returned output | input tokens in exchange for specified amount
+    /// @dev round down when calculating returned output (isExactInput) so we avoid sending too much
+    /// @dev round up when calculating returned input (!isExactInput) so we get desired output amount
+    function calcReturnedAmount(
+        uint256 liquidity,
+        uint160 currentSqrtP,
+        uint160 nextSqrtP,
+        uint256 deltaL,
+        bool isExactInput,
+        bool isToken0
+    ) internal pure returns (int256 returnedAmount) {
+        if (isToken0) {
+            if (isExactInput) {
+                // minimise actual output (<0, make less negative) so we avoid sending too much
+                // returnedAmount = deltaL * nextSqrtP - liquidity * (currentSqrtP - nextSqrtP)
+                returnedAmount =
+                    FullMath.mulDivCeiling(deltaL, nextSqrtP, C.TWO_POW_96).toInt256() +
+                    FullMath
+                        .mulDivFloor(liquidity, currentSqrtP - nextSqrtP, C.TWO_POW_96)
+                        .revToInt256();
+            } else {
+                // maximise actual input (>0) so we get desired output amount
+                // returnedAmount = deltaL * nextSqrtP + liquidity * (nextSqrtP - currentSqrtP)
+                returnedAmount =
+                    FullMath.mulDivCeiling(deltaL, nextSqrtP, C.TWO_POW_96).toInt256() +
+                    FullMath
+                        .mulDivCeiling(liquidity, nextSqrtP - currentSqrtP, C.TWO_POW_96)
+                        .toInt256();
+            }
+        } else {
+            // returnedAmount = (liquidity + deltaL)/nextSqrtP - (liquidity)/currentSqrtP
+            // if exactInput, minimise actual output (<0, make less negative) so we avoid sending too much
+            // if exactOutput, maximise actual input (>0) so we get desired output amount
+            returnedAmount =
+                FullMath.mulDivCeiling(liquidity + deltaL, C.TWO_POW_96, nextSqrtP).toInt256() +
+                FullMath.mulDivFloor(liquidity, C.TWO_POW_96, currentSqrtP).revToInt256();
+        }
+
+        if (isExactInput && returnedAmount == 1) {
+            // rounding make returnedAmount == 1
+            returnedAmount = 0;
+        }
+    }
+}

package/contracts/core/StandardizedYield/implementations/Kyber/libraries/TickMath.sol

@@ -0,0 +1,224 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity >=0.8.0;
+
+
+/**
+ *      ---------      [DIRECT COPIED FROM KYBERSWAP]      ---------
+ */
+
+/// @title Math library for computing sqrt prices from ticks and vice versa
+/// @notice Computes sqrt price for ticks of size 1.0001, i.e. sqrt(1.0001^tick) as fixed point Q64.96 numbers. Supports
+/// prices between 2**-128 and 2**128
+library TickMath {
+  /// @dev The minimum tick that may be passed to #getSqrtRatioAtTick computed from log base 1.0001 of 2**-128
+  int24 internal constant MIN_TICK = -887272;
+  /// @dev The maximum tick that may be passed to #getSqrtRatioAtTick computed from log base 1.0001 of 2**128
+  int24 internal constant MAX_TICK = -MIN_TICK;
+
+  /// @dev The minimum value that can be returned from #getSqrtRatioAtTick. Equivalent to getSqrtRatioAtTick(MIN_TICK)
+  uint160 internal constant MIN_SQRT_RATIO = 4295128739;
+  /// @dev The maximum value that can be returned from #getSqrtRatioAtTick. Equivalent to getSqrtRatioAtTick(MAX_TICK)
+  uint160 internal constant MAX_SQRT_RATIO = 1461446703485210103287273052203988822378723970342;
+
+  /// @notice Calculates sqrt(1.0001^tick) * 2^96
+  /// @dev Throws if |tick| > max tick
+  /// @param tick The input tick for the above formula
+  /// @return sqrtP A Fixed point Q64.96 number representing the sqrt of the ratio of the two assets (token1/token0)
+  /// at the given tick
+  function getSqrtRatioAtTick(int24 tick) internal pure returns (uint160 sqrtP) {
+    unchecked {
+      uint256 absTick = uint256(tick < 0 ? -int256(tick) : int256(tick));
+      require(absTick <= uint256(int256(MAX_TICK)), 'T');
+
+      // do bitwise comparison, if i-th bit is turned on,
+      // multiply ratio by hardcoded values of sqrt(1.0001^-(2^i)) * 2^128
+      // where 0 <= i <= 19
+      uint256 ratio = (absTick & 0x1 != 0)
+        ? 0xfffcb933bd6fad37aa2d162d1a594001
+        : 0x100000000000000000000000000000000;
+      if (absTick & 0x2 != 0) ratio = (ratio * 0xfff97272373d413259a46990580e213a) >> 128;
+      if (absTick & 0x4 != 0) ratio = (ratio * 0xfff2e50f5f656932ef12357cf3c7fdcc) >> 128;
+      if (absTick & 0x8 != 0) ratio = (ratio * 0xffe5caca7e10e4e61c3624eaa0941cd0) >> 128;
+      if (absTick & 0x10 != 0) ratio = (ratio * 0xffcb9843d60f6159c9db58835c926644) >> 128;
+      if (absTick & 0x20 != 0) ratio = (ratio * 0xff973b41fa98c081472e6896dfb254c0) >> 128;
+      if (absTick & 0x40 != 0) ratio = (ratio * 0xff2ea16466c96a3843ec78b326b52861) >> 128;
+      if (absTick & 0x80 != 0) ratio = (ratio * 0xfe5dee046a99a2a811c461f1969c3053) >> 128;
+      if (absTick & 0x100 != 0) ratio = (ratio * 0xfcbe86c7900a88aedcffc83b479aa3a4) >> 128;
+      if (absTick & 0x200 != 0) ratio = (ratio * 0xf987a7253ac413176f2b074cf7815e54) >> 128;
+      if (absTick & 0x400 != 0) ratio = (ratio * 0xf3392b0822b70005940c7a398e4b70f3) >> 128;
+      if (absTick & 0x800 != 0) ratio = (ratio * 0xe7159475a2c29b7443b29c7fa6e889d9) >> 128;
+      if (absTick & 0x1000 != 0) ratio = (ratio * 0xd097f3bdfd2022b8845ad8f792aa5825) >> 128;
+      if (absTick & 0x2000 != 0) ratio = (ratio * 0xa9f746462d870fdf8a65dc1f90e061e5) >> 128;
+      if (absTick & 0x4000 != 0) ratio = (ratio * 0x70d869a156d2a1b890bb3df62baf32f7) >> 128;
+      if (absTick & 0x8000 != 0) ratio = (ratio * 0x31be135f97d08fd981231505542fcfa6) >> 128;
+      if (absTick & 0x10000 != 0) ratio = (ratio * 0x9aa508b5b7a84e1c677de54f3e99bc9) >> 128;
+      if (absTick & 0x20000 != 0) ratio = (ratio * 0x5d6af8dedb81196699c329225ee604) >> 128;
+      if (absTick & 0x40000 != 0) ratio = (ratio * 0x2216e584f5fa1ea926041bedfe98) >> 128;
+      if (absTick & 0x80000 != 0) ratio = (ratio * 0x48a170391f7dc42444e8fa2) >> 128;
+
+      // take reciprocal for positive tick values
+      if (tick > 0) ratio = type(uint256).max / ratio;
+
+      // this divides by 1<<32 rounding up to go from a Q128.128 to a Q128.96.
+      // we then downcast because we know the result always fits within 160 bits due to our tick input constraint
+      // we round up in the division so getTickAtSqrtRatio of the output price is always consistent
+      sqrtP = uint160((ratio >> 32) + (ratio % (1 << 32) == 0 ? 0 : 1));
+    }
+  }
+
+  /// @notice Calculates the greatest tick value such that getRatioAtTick(tick) <= ratio
+  /// @dev Throws in case sqrtP < MIN_SQRT_RATIO, as MIN_SQRT_RATIO is the lowest value getRatioAtTick may
+  /// ever return.
+  /// @param sqrtP The sqrt ratio for which to compute the tick as a Q64.96
+  /// @return tick The greatest tick for which the ratio is less than or equal to the input ratio
+  function getTickAtSqrtRatio(uint160 sqrtP) internal pure returns (int24 tick) {
+    // second inequality must be < because the price can never reach the price at the max tick
+    require(sqrtP >= MIN_SQRT_RATIO && sqrtP < MAX_SQRT_RATIO, 'R');
+    uint256 ratio = uint256(sqrtP) << 32;
+
+    uint256 r = ratio;
+    uint256 msb = 0;
+
+    unchecked {
+      assembly {
+        let f := shl(7, gt(r, 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF))
+        msb := or(msb, f)
+        r := shr(f, r)
+      }
+      assembly {
+        let f := shl(6, gt(r, 0xFFFFFFFFFFFFFFFF))
+        msb := or(msb, f)
+        r := shr(f, r)
+      }
+      assembly {
+        let f := shl(5, gt(r, 0xFFFFFFFF))
+        msb := or(msb, f)
+        r := shr(f, r)
+      }
+      assembly {
+        let f := shl(4, gt(r, 0xFFFF))
+        msb := or(msb, f)
+        r := shr(f, r)
+      }
+      assembly {
+        let f := shl(3, gt(r, 0xFF))
+        msb := or(msb, f)
+        r := shr(f, r)
+      }
+      assembly {
+        let f := shl(2, gt(r, 0xF))
+        msb := or(msb, f)
+        r := shr(f, r)
+      }
+      assembly {
+        let f := shl(1, gt(r, 0x3))
+        msb := or(msb, f)
+        r := shr(f, r)
+      }
+      assembly {
+        let f := gt(r, 0x1)
+        msb := or(msb, f)
+      }
+
+      if (msb >= 128) r = ratio >> (msb - 127);
+      else r = ratio << (127 - msb);
+
+      int256 log_2 = (int256(msb) - 128) << 64;
+
+      assembly {
+        r := shr(127, mul(r, r))
+        let f := shr(128, r)
+        log_2 := or(log_2, shl(63, f))
+        r := shr(f, r)
+      }
+      assembly {
+        r := shr(127, mul(r, r))
+        let f := shr(128, r)
+        log_2 := or(log_2, shl(62, f))
+        r := shr(f, r)
+      }
+      assembly {
+        r := shr(127, mul(r, r))
+        let f := shr(128, r)
+        log_2 := or(log_2, shl(61, f))
+        r := shr(f, r)
+      }
+      assembly {
+        r := shr(127, mul(r, r))
+        let f := shr(128, r)
+        log_2 := or(log_2, shl(60, f))
+        r := shr(f, r)
+      }
+      assembly {
+        r := shr(127, mul(r, r))
+        let f := shr(128, r)
+        log_2 := or(log_2, shl(59, f))
+        r := shr(f, r)
+      }
+      assembly {
+        r := shr(127, mul(r, r))
+        let f := shr(128, r)
+        log_2 := or(log_2, shl(58, f))
+        r := shr(f, r)
+      }
+      assembly {
+        r := shr(127, mul(r, r))
+        let f := shr(128, r)
+        log_2 := or(log_2, shl(57, f))
+        r := shr(f, r)
+      }
+      assembly {
+        r := shr(127, mul(r, r))
+        let f := shr(128, r)
+        log_2 := or(log_2, shl(56, f))
+        r := shr(f, r)
+      }
+      assembly {
+        r := shr(127, mul(r, r))
+        let f := shr(128, r)
+        log_2 := or(log_2, shl(55, f))
+        r := shr(f, r)
+      }
+      assembly {
+        r := shr(127, mul(r, r))
+        let f := shr(128, r)
+        log_2 := or(log_2, shl(54, f))
+        r := shr(f, r)
+      }
+      assembly {
+        r := shr(127, mul(r, r))
+        let f := shr(128, r)
+        log_2 := or(log_2, shl(53, f))
+        r := shr(f, r)
+      }
+      assembly {
+        r := shr(127, mul(r, r))
+        let f := shr(128, r)
+        log_2 := or(log_2, shl(52, f))
+        r := shr(f, r)
+      }
+      assembly {
+        r := shr(127, mul(r, r))
+        let f := shr(128, r)
+        log_2 := or(log_2, shl(51, f))
+        r := shr(f, r)
+      }
+      assembly {
+        r := shr(127, mul(r, r))
+        let f := shr(128, r)
+        log_2 := or(log_2, shl(50, f))
+      }
+
+      int256 log_sqrt10001 = log_2 * 255738958999603826347141; // 128.128 number
+
+      int24 tickLow = int24((log_sqrt10001 - 3402992956809132418596140100660247210) >> 128);
+      int24 tickHi = int24((log_sqrt10001 + 291339464771989622907027621153398088495) >> 128);
+
+      tick = tickLow == tickHi ? tickLow : getSqrtRatioAtTick(tickHi) <= sqrtP ? tickHi : tickLow;
+    }
+  }
+
+  function getMaxNumberTicks(int24 _tickDistance) internal pure returns (uint24 numTicks) {
+    return uint24(TickMath.MAX_TICK / _tickDistance) * 2;
+  }
+}