}

    void tokenizePartialBlock(final int startOffset, final int endOffset, final boolean afterSynonymProduced) {
        if (startOffset >= endOffset) {
            return;
        }

        int posInc = afterSynonymProduced ? 0 : 1;
        if (endOffset - startOffset < n) {
            queue.add(new MyToken(block.substring(startOffset, endOffset), startOffset, endOffset, posInc));
            return;
        }

            for (String word : words) {
                if (!word.isEmpty()) {
                    int startOffset = text.indexOf(word, offset);
                    int endOffset = startOffset + word.length();

                    // Handle decimal numbers
                    if (word.matches("\\d+") && startOffset > 0 && text.charAt(startOffset - 1) == '.') {
                        continue;
                    }

	for shardsIdx, ok := range shardConfig {
		if ok == 0 {
			copy(splitData[shardsIdx][startOffset:], shards[shardsIdx])
			for i := range shards[shardsIdx] {
				if splitFilled[shardsIdx][startOffset+i] == 1 {
					fmt.Println("Internal error: Found filled data at", startOffset+i)
				}
				splitFilled[shardsIdx][startOffset+i] = 1
			}
			reconstructed += len(shards[shardsIdx])
		} else {

	}
	for i, test := range testCases {
		startOffset, snappyStartOffset, firstPart, _, _ := getCompressedOffsets(test.objInfo, test.offset, nil)
		if startOffset != test.startOffset {
			t.Errorf("Test %d - expected startOffset %d but received %d",
				i, test.startOffset, startOffset)
		}
		if snappyStartOffset != test.snappyStartOffset {
			t.Errorf("Test %d - expected snappyOffset %d but received %d",

      public byte[] getExpected(byte[] bytes) {
        byte[] baseExpected = factory.getExpected(bytes);
        int startOffset = (int) min(off, baseExpected.length);
        int actualLen = (int) min(len, baseExpected.length - startOffset);
        return Arrays.copyOfRange(baseExpected, startOffset, startOffset + actualLen);
      }

      @Override
      public void tearDown() throws IOException {
        factory.tearDown();

        int bytesWritten = transaction.writeParameterWordsWireFormat(dst, startOffset);

        // Verify the bytes written
        assertTrue(bytesWritten > 0);

        // Verify data is written at correct offset
        assertEquals(3, dst[startOffset]);

        // Verify total parameter count at correct offset
        assertEquals(500, SMBUtil.readInt4(dst, startOffset + 3));

        // Verify total data count at correct offset

func GetObject(ctx context.Context, api ObjectLayer, bucket, object string, startOffset int64, length int64, writer io.Writer, etag string, opts ObjectOptions) (err error) {
	var header http.Header
	if etag != "" {
		header.Set("ETag", etag)
	}
	Range := &HTTPRangeSpec{Start: startOffset, End: startOffset + length}

	reader, err := api.GetObjectNInfo(ctx, bucket, object, Range, header, opts)
	if err != nil {

        )
    }

    private
    fun getLineNumber(declaration: KtDeclaration, ktFile: KtFile): Int {
        val startOffset = declaration.startOffsetSkippingComments
        return ktFile.viewProvider.document?.getLineNumber(startOffset)?.plus(1) ?: -1
    }

    private
    fun KtFile.forEachIncubatingDeclaration(block: (KtNamedDeclaration) -> Unit) {

}

// ShardFileOffset - returns the effective offset where erasure reading begins.
func (e *Erasure) ShardFileOffset(startOffset, length, totalLength int64) int64 {
	shardSize := e.ShardSize()
	shardFileSize := e.ShardFileSize(totalLength)
	endShard := (startOffset + length) / e.blockSize
	tillOffset := min(endShard*shardSize+shardSize, shardFileSize)
	return tillOffset
}

	if length < 0 {
		length = fi.Size - startOffset
	}

	// Reply back invalid range if the input offset and length fall out of range.
	if startOffset > fi.Size || startOffset+length > fi.Size {
		return InvalidRange{startOffset, length, fi.Size}
	}

	// Get start part index and offset.
	partIndex, partOffset, err := fi.ObjectToPartOffset(ctx, startOffset)
	if err != nil {