Why nextInitializedTickWithinOneWord() returns the same tick provided when there are other initialized ticks to the right.

[vishwa7dcap786]

ticks intialized 85176,85177,85175
(111000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 ).
when calling NextInitializedTick with values 85176 ,1 . It returns 85176 while the next initialized tick is 85175.

In the low level,
mask = 49039857307708443467467104868809893875799651909875269631 =
11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111 (185 digits)

flipped 85175,85176,85177
bit =85819750288489776068067433520417314282649390842281721856 =
111000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 (186 digits)

masked = bit & mask =36779892980781332600600328651607420406849738932406452224 =
11000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 (185 digits)

when the masked value is passed to the mostSignificantBit(masked) it returns the 184 which is 85176.
i don't understand that we are searching next initialized tick to right side of 184(85176) but it returns the same provided tick back. But returns 85175 when calling nextInitializedTickWithinOneWord( 85176,1 ) without initializing 85176 while 85175 is initialized.

mapping(int16 => uint256) public self;

function position(int24 tick) public  pure returns (int16 wordPos, uint8 bitPos) {
    wordPos = int16(tick >> 8);
    bitPos = uint8(uint24(tick % 256));
}

function flipTick(
int24 tick,
int24 tickSpacing
) public returns(uint256) {
    require(tick % tickSpacing == 0); // ensure that the tick is spaced
    (int16 wordPos, uint8 bitPos) = position(tick / tickSpacing);
    uint256 mask = (1 << bitPos);

    self[wordPos] ^= mask;
    return mask;
}

      function nextInitializedTickWithinOneWord(int24 tick, int24 tickSpacing) public view returns (uint256 bit, uint256 mask, uint256 masked 
                 ,int24 next, bool initialized){
          int24 compressed = tick / tickSpacing;
          if (tick < 0 && tick % tickSpacing != 0) compressed--;
          (int16 wordPos, uint8 bitPos) = position(compressed);
                                           // all the 1s at or to the right of the current bitPos
         mask = (1 << bitPos) - 1 + (1 << bitPos);
         masked = self[wordPos] & mask;
        bit = self[wordPos];
                                          // if there are no initialized ticks to the right of or at the current tick, return rightmost in the word
        initialized = masked != 0;
                                      // overflow/underflow is possible, but prevented externally by limiting both tickSpacing and tick
        next = initialized
                       ? (compressed - int24(uint24(bitPos - mostSignificantBit(masked)))) * tickSpacing
                       : (compressed - int24(uint24(bitPos))) * tickSpacing;
}

[vishwa7dcap786]

it works as expected after making changes in creating mask for selling eth or x 'mask = (1 << bitPos) - 1 + (1 << bitPos); ---> (1 << bitPos)-1'

bit = ^(1<<184) =
24519928653854221733733552434404946937899825954937634816 =
10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 (185 digits)

mask = (1<<184)-1 =
49039857307708443467467104868809893875799651909875269631 =
1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111 (184 digits)

so now we can search the next initialized tick in other 184 digits without including 185th digit (184).
Still I am not sure what we will implement. It depends on.

function nextInitializedTickWithinOneWord(int24 tick, int24 tickSpacing) public view returns (uint256 bit, uint256 mask, uint256 masked ,int24 next, bool initialized){
            int24 compressed = tick / tickSpacing;
            if (tick < 0 && tick % tickSpacing != 0) compressed--;
            (int16 wordPos, uint8 bitPos) = position(compressed);
            // all the 1s at or to the right of the current bitPos
             mask = (1 << bitPos) - 1 ;
             masked = self[wordPos] & mask;
            bit = self[wordPos];
            // if there are no initialized ticks to the right of or at the current tick, return rightmost in the word
            initialized = masked != 0;
            // overflow/underflow is possible, but prevented externally by limiting both tickSpacing and tick
            next = initialized
                ? (compressed - int24(uint24(bitPos - mostSignificantBit(masked)))) * tickSpacing
                : (compressed - int24(uint24(bitPos))) * tickSpacing;
    }