docs: private void readPatchedBaseValues(int firstByte)
              throws IOException
      {
          // extract the number of fixed bits
          int fb = LongDecode.decodeBitWidth((firstByte >>> 1) & 0b1_1111);
  
          // extract the run length of data blob
          int length = (firstByte & 0b1) << 8;
          length |= input.read();
          // runs are always one off
          length += 1;
  
          // extract the number of bytes occupied by base
          int thirdByte = input.read();
          int baseWidth = (thirdByte >>> 5) & 0b0111;
          // base width is one off
          baseWidth += 1;
  
          // extract patch width
          int patchWidth = LongDecode.decodeBitWidth(thirdByte & 0b1_1111);
  
          // read fourth byte and extract patch gap width
          int fourthByte = input.read();
          int patchGapWidth = (fourthByte >>> 5) & 0b0111;
          // patch gap width is one off
          patchGapWidth += 1;
  
          // extract the length of the patch list
          int patchListLength = fourthByte & 0b1_1111;
  
          // read the next base width number of bytes to extract base value
          long base = bytesToLongBE(input, baseWidth);
          long mask = (1L << ((baseWidth * 8) - 1));
          // if MSB of base value is 1 then base is negative value else positive
          if ((base & mask) != 0) {
              base = base & ~mask;
              base = -base;
          }
  
          // unpack the data blob
          long[] unpacked = new long[length];
          packer.unpack(unpacked, 0, length, fb, input);
  
          // unpack the patch blob
          long[] unpackedPatch = new long[patchListLength];
  
          if ((patchWidth + patchGapWidth) > 64 && !skipCorrupt) {
              throw new OrcCorruptionException(input.getOrcDataSourceId(), "Invalid RLEv2 encoded stream");
          }
  
          int bitSize = LongDecode.getClosestFixedBits(patchWidth + patchGapWidth);
          packer.unpack(unpackedPatch, 0, patchListLength, bitSize, input);
  
          // apply the patch directly when decoding the packed data
          int patchIndex = 0;
          long currentGap;
          long currentPatch;
          long patchMask = ((1L << patchWidth) - 1);
          currentGap = unpackedPatch[patchIndex] >>> patchWidth;
          currentPatch = unpackedPatch[patchIndex] & patchMask;
          long actualGap = 0;
  
          // special case: gap is >255 then patch value will be 0.
          // if gap is <=255 then patch value cannot be 0
          while (currentGap == 255 && currentPatch == 0) {
              actualGap += 255;
              patchIndex++;
              currentGap = unpackedPatch[patchIndex] >>> patchWidth;
              currentPatch = unpackedPatch[patchIndex] & patchMask;
          }
          // add the left over gap
          actualGap += currentGap;
  
          // unpack data blob, patch it (if required), add base to get final result
          for (int i = 0; i < unpacked.length; i++) {
              if (i == actualGap) {
                  // extract the patch value
                  long patchedValue = unpacked[i] | (currentPatch << fb);
  
                  // add base to patched value
                  literals[numLiterals++] = base + patchedValue;
  
                  // increment the patch to point to next entry in patch list
                  patchIndex++;
  
                  if (patchIndex < patchListLength) {
                      // read the next gap and patch
                      currentGap = unpackedPatch[patchIndex] >>> patchWidth;
                      currentPatch = unpackedPatch[patchIndex] & patchMask;
                      actualGap = 0;
  
                      // special case: gap is >255 then patch will be 0. if gap is
                      // <=255 then patch cannot be 0
                      while (currentGap == 255 && currentPatch == 0) {
                          actualGap += 255;
                          patchIndex++;
                          currentGap = unpackedPatch[patchIndex] >>> patchWidth;
                          currentPatch = unpackedPatch[patchIndex] & patchMask;
                      }
                      // add the left over gap
                      actualGap += currentGap;
  
                      // next gap is relative to the current gap
                      actualGap += i;
                  }
              }
              else {
                  // no patching required. add base to unpacked value to get final value
                  literals[numLiterals++] = base + unpacked[i];
              }
          }
      }