return c.with(func(db *DB) *DB {
		return db.Or(query, args...)
	})
}

func (c chainG[T]) Limit(offset int) ChainInterface[T] {
	return c.with(func(db *DB) *DB {
		return db.Limit(offset)
	})
}

func (c chainG[T]) Offset(offset int) ChainInterface[T] {
	return c.with(func(db *DB) *DB {
		return db.Offset(offset)
	})
}

type joinBuilder struct {
	db *DB
}

        bufferIndex += 2;
        final int ownerUOffset = SMBUtil.readInt4(buffer, bufferIndex); // offset to owner sid
        bufferIndex += 4;
        final int ownerGOffset = SMBUtil.readInt4(buffer, bufferIndex); // offset to group sid
        bufferIndex += 4;
        SMBUtil.readInt4(buffer, bufferIndex); // offset to sacl
        bufferIndex += 4;
        final int daclOffset = SMBUtil.readInt4(buffer, bufferIndex);

                    final int pos = text.indexOf(term, offset);
                    if (pos > 0) {
                        final String tmp = text.substring(offset, pos);
                        readingBuf.append(transliterator.transliterate(tmp));
                        offset = pos;
                    } else if (pos == -1) {
                        continue;
                    }

            int offset = 64;
            writeSecurityBuffer(type3, 12, offset, lmResponse);
            offset += lmLength;
            writeSecurityBuffer(type3, 20, offset, ntResponse);
            offset += ntLength;
            writeSecurityBuffer(type3, 28, offset, domain);
            offset += domainLength;
            writeSecurityBuffer(type3, 36, offset, user);
            offset += userLength;

        if (protwordsItemList == null) {
            reload(null);
        }

        if (offset >= protwordsItemList.size() || offset < 0) {
            return new PagingList<>(Collections.<ProtwordsItem> emptyList(), offset, size, protwordsItemList.size());
        }

        int toIndex = offset + size;
        if (toIndex > protwordsItemList.size()) {

        assertEquals(0, SMBUtil.readInt2(buffer, offset + 2));

        // Verify Reserved (4 bytes at offset+4, should be 0)
        assertEquals(0, SMBUtil.readInt4(buffer, offset + 4));

        // Verify file ID is copied correctly (16 bytes starting at offset+8)
        byte[] copiedFileId = new byte[16];
        System.arraycopy(buffer, offset + 8, copiedFileId, 0, 16);
        assertArrayEquals(testFileId, copiedFileId);
    }

        return md5.digest(digest);
    }

    @Override
    protected int engineDigest(final byte[] buf, final int offset, final int len) {
        final byte[] digest = md5.digest();
        md5.update(opad);
        md5.update(digest);
        try {
            return md5.digest(buf, offset, len);
        } catch (final Exception ex) {
            throw new IllegalStateException();
        }
    }

        return this.md5.digest(digest);
    }

    @Override
    protected int engineDigest(final byte[] buf, final int offset, final int len) {
        final byte[] digest = this.md5.digest();
        this.md5.update(this.opad);
        this.md5.update(digest);
        try {
            return this.md5.digest(buf, offset, len);
        } catch (final Exception ex) {
            throw new IllegalStateException();
        }
    }

    return db_hero


@app.get("/heroes/", response_model=list[HeroPublic])
def read_heroes(
    session: Session = Depends(get_session),
    offset: int = 0,
    limit: int = Query(default=100, le=100),
):
    heroes = session.exec(select(Hero).offset(offset).limit(limit)).all()
    return heroes


@app.get("/heroes/{hero_id}", response_model=HeroPublic)

    return ImmutableList.of(element);
  }

  @Override
  boolean isPartialView() {
    return false;
  }

  @Override
  int copyIntoArray(@Nullable Object[] dst, int offset) {
    dst[offset] = element;
    return offset + 1;
  }

  @Override
  public final int hashCode() {
    return element.hashCode();
  }

  @Override
  public String toString() {
    return '[' + element.toString() + ']';