// Test valid TID
            response.setTid(100);
            assertTrue(response.isValidTid(), "TID 100 should be valid");

            // Test invalid TID (0xFFFF)
            response.setTid(0xFFFF);
            assertFalse(response.isValidTid(), "TID 0xFFFF should be invalid");
        }

        @Test
        @DisplayName("Should decode parameter words correctly")

    }
    return tmp;
  }

  @Benchmark
  int binomial(int reps) {
    int tmp = 0;
    for (int i = 0; i < reps; i++) {
      int j = i & 0xffff;
      tmp += BigIntegerMath.binomial(factorials[j], binomials[j]).intValue();
    }
    return tmp;
  }

        this.name = pipeName;
        this.pipeData = data;
        this.pipeDataOff = off;
        this.pipeDataLen = len;
        this.timeout = 0xFFFFFFFF;
        this.maxParameterCount = 0;
        this.maxDataCount = 0xFFFF;
        this.maxSetupCount = (byte) 0x00;
        this.setupCount = 2;
    }

    @Override
    protected int writeSetupWireFormat(final byte[] dst, int dstIndex) {
        dst[dstIndex] = this.getSubCommand();

        this.pipeFid = fid;
        this.pipeData = data;
        this.pipeDataOff = off;
        this.pipeDataLen = len;
        this.maxParameterCount = 0;
        this.maxDataCount = 0xFFFF;
        this.maxSetupCount = (byte) 0x00;
        this.setupCount = 2;
        this.name = "\\PIPE\\";
    }

    @Override
    protected int writeSetupWireFormat(final byte[] dst, int dstIndex) {

     */
    int DEFAULT_SO_TIMEOUT = 35000;
    /**
     * Default receive buffer size for SMB transport.
     */
    int DEFAULT_RCV_BUF_SIZE = 0xFFFF;
    /**
     * Default send buffer size for SMB transport.
     */
    int DEFAULT_SND_BUF_SIZE = 0xFFFF;
    /**
     * Default buffer size for change notification responses.
     */
    int DEFAULT_NOTIFY_BUF_SIZE = 1024;

    /**

            e.type = SMBUtil.readInt2(buffer, bufferIndex);
            bufferIndex += 2;
            int off = SMBUtil.readInt4(buffer, bufferIndex);
            bufferIndex += 4;
            off = (off & 0xFFFF) - this.converter;
            off = start + off;
            e.remark = readString(buffer, off, 128, false);

            if (log.isTraceEnabled()) {
                log.trace(e.toString());
            }

	t.Run("uint16max-1_NoZip64", func(t *testing.T) {
		t.Parallel()
		if generatesZip64(t, gen(0xfffe)) {
			t.Error("unexpected zip64")
		}
	})
	// 16k records should make a zip64:
	t.Run("uint16max_Zip64", func(t *testing.T) {
		t.Parallel()
		if !generatesZip64(t, gen(0xffff)) {
			t.Error("expected zip64")
		}
	})
}

    }
    return tmp;
  }

  @Benchmark
  int binomial(int reps) {
    int tmp = 0;
    for (int i = 0; i < reps; i++) {
      int j = i & 0xffff;
      tmp += BigIntegerMath.binomial(factorials[j], binomials[j]).intValue();
    }
    return tmp;
  }

            bufferIndex += 16;
            e.versionMajor = buffer[bufferIndex] & 0xFF;
            bufferIndex++;
            e.versionMinor = buffer[bufferIndex++] & 0xFF;
            e.type = readInt4(buffer, bufferIndex);
            bufferIndex += 4;
            int off = readInt4(buffer, bufferIndex);
            bufferIndex += 4;
            off = (off & 0xFFFF) - converter;
            off = start + off;

 *
 * @author Louis Wasserman
 */
@NullUnmarked
final class MathBenchmarking {
  static final int ARRAY_SIZE = 0x10000;
  static final int ARRAY_MASK = 0x0ffff;
  static final Random RANDOM_SOURCE = new Random(314159265358979L);
  static final int MAX_EXPONENT = 100;

  /*
   * Duplicated from LongMath.
   * binomial(biggestBinomials[k], k) fits in a long, but not