doDelete(entity, null);
    }

    public int queryDelete(CBCall<DuplicateHostCB> cbLambda) {
        return doQueryDelete(createCB(cbLambda), null);
    }

    public int[] batchInsert(List<DuplicateHost> list) {
        return batchInsert(list, null, null);
    }

    public int[] batchInsert(List<DuplicateHost> list, RequestOptionCall<BulkRequestBuilder> call) {

        doDelete(entity, null);
    }

    public int queryDelete(CBCall<JobLogCB> cbLambda) {
        return doQueryDelete(createCB(cbLambda), null);
    }

    public int[] batchInsert(List<JobLog> list) {
        return batchInsert(list, null, null);
    }

    public int[] batchInsert(List<JobLog> list, RequestOptionCall<BulkRequestBuilder> call) {

      int[] quotients = new int[indexes.length];
      int[] remainders = new int[indexes.length];
      // The indexes to select. In the worst case, we'll need one each side of each quantile.
      int[] requiredSelections = new int[indexes.length * 2];
      int requiredSelectionsCount = 0;
      for (int i = 0; i < indexes.length; i++) {

 */
public class Name implements NetbiosName {

    private static final int TYPE_OFFSET = 31;
    private static final int SCOPE_OFFSET = 33;

    /**
     * Name
     */
    public String name;
    /**
     * Scope id
     */
    public String scope;
    /**
     * Type
     */
    public int hexCode;
    int srcHashCode; /*
                      * srcHashCode must be set by name resolution

 * #lock(int) strong} and {@linkplain #lazyWeakLock(int) weak} {@code Striped<Lock>}, {@linkplain
 * #semaphore(int, int) strong} and {@linkplain #lazyWeakSemaphore(int, int) weak} {@code
 * Striped<Semaphore>}, and {@linkplain #readWriteLock(int) strong} and {@linkplain
 * #lazyWeakReadWriteLock(int) weak} {@code Striped<ReadWriteLock>}. <i>Strong</i> means that all

    int tmp = 0;
    for (int i = 0; i < reps; i++) {
      int j = i & ARRAY_MASK;
      tmp += LongMath.mod(longs[j], positive[j]);
    }
    return tmp;
  }

  @Benchmark
  int gCD(int reps) {
    int tmp = 0;
    for (int i = 0; i < reps; i++) {
      int j = i & ARRAY_MASK;
      tmp += LongMath.mod(nonnegative[j], positive[j]);
    }
    return tmp;
  }

  @Benchmark

        protected int writeDataWireFormat(byte[] dst, int dstIndex) {
            return dataWireFormatReturn;
        }

        @Override
        protected int readSetupWireFormat(byte[] buffer, int bufferIndex, int len) {
            return 0;
        }

        @Override
        protected int readParametersWireFormat(byte[] buffer, int bufferIndex, int len) throws SMBProtocolDecodingException {

        @Override
        public int decode(byte[] buffer, int bufferIndex) throws SMBProtocolDecodingException {
            return 0;
        }

        @Override
        public int encode(byte[] dst, int dstIndex) {
            return 0;
        }

        @Override
        public void setDigest(SMBSigningDigest digest) {
            this.digest = digest;
        }

    int NT_STATUS_UNSUCCESSFUL = 0xC0000001;
    /** The requested operation is not implemented */
    int NT_STATUS_NOT_IMPLEMENTED = 0xC0000002;
    /** The specified information class is invalid */
    int NT_STATUS_INVALID_INFO_CLASS = 0xC0000003;
    /** Invalid access to memory location */
    int NT_STATUS_ACCESS_VIOLATION = 0xC0000005;
    /** The handle is invalid */
    int NT_STATUS_INVALID_HANDLE = 0xC0000008;

        // When
        int bytesRead = response.readBytesWireFormat(buffer, 0);

        // Then
        assertEquals(4, bytesRead);
    }

    @DisplayName("Should handle structure with different reserved values")
    @ParameterizedTest
    @CsvSource({ "0, 0", "255, 255", "0, 65535", "100, 200" })
    void testReadWithDifferentReservedValues(int byte2, int byte3) throws SMBProtocolDecodingException {