secondaryParameterOffset = NTT_SECONDARY_PARAMETER_OFFSET;
    }

    @Override
    int writeParameterWordsWireFormat(final byte[] dst, int dstIndex) {
        final int start = dstIndex;

        if (command != SMB_COM_NT_TRANSACT_SECONDARY) {
            dst[dstIndex++] = maxSetupCount;
        } else {
            dst[dstIndex++] = (byte) 0x00; // Reserved
        }

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

    @Override
    int readParameterWordsWireFormat(final byte[] buffer, int bufferIndex) {
        final int start = bufferIndex;

        fid = readInt2(buffer, bufferIndex);
        bufferIndex += 2;
        fileAttributes = readInt2(buffer, bufferIndex);
        bufferIndex += 2;

        final int start = dstIndex;

        writeInt2(fid, dst, dstIndex);
        dstIndex += 2;
        dst[dstIndex] = (byte) 0x00; // Reserved
        dstIndex++;
        dst[dstIndex++] = (byte) 0x00; // Reserved
        writeInt4(securityInformation, dst, dstIndex);
        dstIndex += 4;

        return dstIndex - start;
    }

    @Override

    @Override
    protected void haveResponse(final byte[] buffer, final int start, final int len) throws SMBProtocolDecodingException {
        if (isRetainPayload()) {
            final byte[] payload = new byte[len];
            System.arraycopy(buffer, start, payload, 0, len);
            setRawPayload(payload);
        }

        if (!verifySignature(buffer, start, len)) {

     *            the queryFlags to set
     */
    public void setQueryFlags(final byte queryFlags) {
        this.queryFlags = queryFlags;
    }

    /**
     * Sets the file index from which to start the directory enumeration
     *
     * @param fileIndex
     *            the fileIndex to set
     */
    public void setFileIndex(final int fileIndex) {
        this.fileIndex = fileIndex;
    }

	}
	return nil
}

// UnmarshalXML - decodes XML data.
func (d *DeleteReplication) UnmarshalXML(dec *xml.Decoder, start xml.StartElement) (err error) {
	// Make subtype to avoid recursive UnmarshalXML().
	type deleteReplication DeleteReplication
	drep := deleteReplication{}

	if err := dec.DecodeElement(&drep, &start); err != nil {
		return err
	}
	if len(drep.Status) == 0 {
		drep.Status = Disabled
	}
	d.Status = drep.Status

    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.Encodable#encode(byte[], int)
     */
    @Override
    public int encode(final byte[] dst, int dstIndex) {
        final int start = dstIndex;
        SMBUtil.writeInt8(this.timeout, dst, dstIndex);
        dstIndex += 8;
        SMBUtil.writeInt4(this.nameBytes.length, dst, dstIndex);
        dstIndex += 4;

    }

    @Override
    public Appendable append(char c) {
      result.append(c);
      return this;
    }

    @Override
    public Appendable append(CharSequence csq, int start, int end) {
      result.append(csq, start, end);
      return this;
    }

    @Override
    public void flush() {
      flushed = true;
    }

    @Override
    public void close() {
      closed = true;
    }

                } catch (Exception e) {
                    exceptions.add(e);
                } finally {
                    endLatch.countDown();
                }
            });
        }

        // Start all threads simultaneously
        startLatch.countDown();

        // Wait for completion
        assertTrue(endLatch.await(30, TimeUnit.SECONDS), "All threads should complete within timeout");
        executor.shutdown();

                    }
                    ncpos += padding;
                }
            }
            this.negotiateContexts = contexts;
            return Math.max(bufferIndex, ncpos) - start;
        }

        return bufferIndex - start;
    }

    /**
     * Creates a negotiate context response based on the context type.
     *
     * @param type the negotiate context type