int data1 = (int) (mostSig >>> 32); // first 4 bytes
        short data2 = (short) (mostSig >>> 16); // next 2 bytes
        short data3 = (short) mostSig; // next 2 bytes

        // Write in little-endian format as specified by MS-SMB2
        bb.putInt(data1); // data1 (4 bytes, little-endian)
        bb.putShort(data2); // data2 (2 bytes, little-endian)
        bb.putShort(data3); // data3 (2 bytes, little-endian)

app = FastAPI()

# =====================================================================================
# Without aliases


@app.post("/optional-bytes", operation_id="optional_bytes")
async def read_optional_bytes(p: Annotated[bytes | None, File()] = None):
    return {"file_size": len(p) if p else None}


@app.post("/optional-uploadfile", operation_id="optional_uploadfile")

    private byte[] bytes;

    AppendableByteSource(byte[] initialBytes) {
      this.bytes = initialBytes.clone();
    }

    @Override
    public InputStream openStream() {
      return new In();
    }

    void append(byte[] b) {
      byte[] newBytes = Arrays.copyOf(bytes, bytes.length + b.length);
      System.arraycopy(b, 0, newBytes, bytes.length, b.length);
      bytes = newBytes;

app = FastAPI()

# =====================================================================================
# Without aliases


@app.post("/list-bytes", operation_id="list_bytes")
async def read_list_bytes(p: Annotated[list[bytes], File()]):
    return {"file_size": [len(file) for file in p]}


@app.post("/list-uploadfile", operation_id="list_uploadfile")

package cmd

import (
	"bytes"
	"testing"

	"github.com/tinylib/msgp/msgp"
)

func TestMarshalUnmarshalallTierStats(t *testing.T) {
	v := allTierStats{}
	bts, err := v.MarshalMsg(nil)
	if err != nil {
		t.Fatal(err)
	}
	left, err := v.UnmarshalMsg(bts)
	if err != nil {
		t.Fatal(err)
	}
	if len(left) > 0 {
		t.Errorf("%d bytes left over after UnmarshalMsg(): %q", len(left), left)
	}

  }

  @Override
  @CanIgnoreReturnValue
  public Hasher putBytes(byte[] bytes) {
    checkNotNull(bytes);
    update(bytes);
    return this;
  }

  @Override
  @CanIgnoreReturnValue
  public Hasher putBytes(byte[] bytes, int off, int len) {
    checkPositionIndexes(off, off + len, bytes.length);
    update(bytes, off, len);
    return this;
  }

  @Override
  @CanIgnoreReturnValue

        // Version (2 bytes)
        SMBUtil.writeInt2(3, buffer, 8);

        // Size (2 bytes) - the size of this referral entry
        SMBUtil.writeInt2(20, buffer, 10);

        // Server type (2 bytes)
        SMBUtil.writeInt2(1, buffer, 12);

        // Referral flags (2 bytes)
        SMBUtil.writeInt2(0, buffer, 14);

        // Proximity (2 bytes for v3)
        SMBUtil.writeInt2(0, buffer, 16);

	v := BatchJobReplicateCredentials{}
	var buf bytes.Buffer
	msgp.Encode(&buf, &v)
	b.SetBytes(int64(buf.Len()))
	en := msgp.NewWriter(msgp.Nowhere)
	b.ReportAllocs()
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		v.EncodeMsg(en)
	}
	en.Flush()
}

func BenchmarkDecodeBatchJobReplicateCredentials(b *testing.B) {
	v := BatchJobReplicateCredentials{}
	var buf bytes.Buffer
	msgp.Encode(&buf, &v)

   * well-formed.
   *
   * <p>This method returns {@code true} if and only if {@code Arrays.equals(bytes, new
   * String(bytes, UTF_8).getBytes(UTF_8))} does, but is more efficient in both time and space.
   */
  public static boolean isWellFormed(byte[] bytes) {
    return isWellFormed(bytes, 0, bytes.length);
  }

  /**

   * well-formed.
   *
   * <p>This method returns {@code true} if and only if {@code Arrays.equals(bytes, new
   * String(bytes, UTF_8).getBytes(UTF_8))} does, but is more efficient in both time and space.
   */
  public static boolean isWellFormed(byte[] bytes) {
    return isWellFormed(bytes, 0, bytes.length);
  }

  /**