}

        if ( this.dataCount > 0 ) {
            System.arraycopy(this.txn_buf, this.bufDataOffset, dst, this.headerStart + this.dataOffset, this.dataCount);
            this.bufDataOffset += this.dataCount;
            end = Math.max(end, this.headerStart + this.dataOffset + this.dataCount);
        }

        return end - start;
    }


    @Override

            bufferIndex += parameterCount;
        }
        if( dataCount > 0 ) {
            bufferIndex += pad1 = dataOffset - ( bufferIndex - headerStart );
            System.arraycopy( buffer, bufferIndex, txn_buf,
                            bufDataStart + dataDisplacement, dataCount );
            bufferIndex += dataCount;
        }

        /* Check to see if the entire transaction has been

        if (command == SMB_COM_NT_TRANSACT_SECONDARY) {
            writeInt4( parameterDisplacement, dst, dstIndex );
            dstIndex += 4;
        }
        writeInt4( dataCount, dst, dstIndex );
        dstIndex += 4;
        writeInt4(( dataCount == 0 ? 0 : dataOffset ), dst, dstIndex );
        dstIndex += 4;
        if (command == SMB_COM_NT_TRANSACT_SECONDARY) {
            writeInt4( dataDisplacement, dst, dstIndex );

    }


    /**
     * @return the dataCount
     */
    protected final int getDataCount () {
        return this.dataCount;
    }


    /**
     * @param dataCount
     *            the dataCount to set
     */
    public final void setDataCount ( int dataCount ) {
        this.dataCount = dataCount;
    }


    /**
     * @param buffer
     */

            dstIndex += parameterCount;
        }

        if( dataCount > 0 ) {
            p = pad1;
            while( p-- > 0 ) {
                dst[dstIndex++] = (byte)0x00;       // Pad1
            }
            System.arraycopy( txn_buf, bufDataOffset, dst, dstIndex, dataCount );
            bufDataOffset += dataCount;
            dstIndex += dataCount;
        }

        return dstIndex - start;
    }

	return nil
}

// defaultWQuorum write quorum based on setDriveCount and defaultParityCount
func (er erasureObjects) defaultWQuorum() int {
	dataCount := er.setDriveCount - er.defaultParityCount
	if dataCount == er.defaultParityCount {
		return dataCount + 1
	}
	return dataCount
}

func diskErrToDriveState(err error) (state string) {
	switch {
	case errors.Is(err, errDiskNotFound) || errors.Is(err, context.DeadlineExceeded):

            bufferIndex += e.nextEntryOffset;
        }

        /* last nextEntryOffset for NT 4(but not 98) is 0 so we must
         * use dataCount or our accounting will report an error for NT :~(
         */

        //return bufferIndex - start;

        return dataCount;
    }
    public String toString() {
        String c;
        if( subCommand == SmbComTransaction.TRANS2_FIND_FIRST2 ) {

            SMBUtil.writeInt4(this.parameterDisplacement, dst, dstIndex);
            dstIndex += 4;
        }
        SMBUtil.writeInt4(this.dataCount, dst, dstIndex);
        dstIndex += 4;
        SMBUtil.writeInt4( ( this.dataCount == 0 ? 0 : this.dataOffset ), dst, dstIndex);
        dstIndex += 4;
        if ( this.getCommand() == SMB_COM_NT_TRANSACT_SECONDARY ) {

            bufferIndex += e.getNextEntryOffset();
        }

        setResults(results);

        /*
         * last nextEntryOffset for NT 4(but not 98) is 0 so we must
         * use dataCount or our accounting will report an error for NT :~(
         */
        return getDataCount();
    }


    @Override
    public String toString () {
        String c;

        bufferIndex += 4;
        parameterOffset = readInt4( buffer, bufferIndex );
        bufferIndex += 4;
        parameterDisplacement = readInt4( buffer, bufferIndex );
        bufferIndex += 4;
        dataCount = readInt4( buffer, bufferIndex );
        bufferIndex += 4;
        dataOffset = readInt4( buffer, bufferIndex );
        bufferIndex += 4;
        dataDisplacement = readInt4( buffer, bufferIndex );