*
     * @param    input    input block
     * @param    offset    start of meaningful bytes in input
     * @param    len        count of bytes in input block to consider
     */
    public void engineUpdate (byte[] input, int offset, int len) {
        // make sure we don't exceed input's allocated size/length
        if (offset < 0 || len < 0 || (long)offset + len > input.length)
            throw new ArrayIndexOutOfBoundsException();

    /**
     * Return the byte or character offset into the input source this location
     * is pointing to. If the input source is a file or a byte stream then
     * this is the byte offset into that stream, but if the input source is
     * a character media then the offset is the character offset.
     * Returns -1 if there is no offset available.
     * @return the current offset
     */
    int getCharacterOffset();

    /**

	// Check offset overflow. Must fit in int32.
	MOVQ 2147483647+1(AX), AX       // ERROR "offset too large"
	MOVQ 3395469782(R10), R8        // ERROR "offset too large"
	LEAQ 3395469782(AX), AX         // ERROR "offset too large"
	ADDQ 3395469782(AX), AX         // ERROR "offset too large"
	ADDL 3395469782(AX), AX         // ERROR "offset too large"

        super(config);
        this.data = b;
        this.offset = off;
    }


    void setParam ( byte[] b, int off ) {
        this.data = b;
        this.offset = off;
    }


    /**
     * 
     * @return the read data
     */
    public final byte[] getData () {
        return this.data;
    }


    /**
     * @return the offset
     */
    public final int getOffset () {

     */
    public void setReadLength ( int readLength ) {
        this.readLength = readLength;
    }


    /**
     * @param offset
     *            the offset to set
     */
    public void setOffset ( long offset ) {
        this.offset = offset;
    }


    /**
     * @param minimumCount
     *            the minimumCount to set
     */

	if offset < 0 || length < 0 {
		return -1, errInvalidArgument
	}
	if offset+length > totalLength {
		return -1, errInvalidArgument
	}

	if length == 0 {
		return 0, nil
	}

	reader := newParallelReader(readers, e, offset, totalLength)
	if len(prefer) == len(readers) {

        int offset = 0;
        if ( domainLength > 0 ) {
            writeUShort(targetInfo, offset, 2);
            offset += 2;
            writeUShort(targetInfo, offset, domainLength);
            offset += 2;
            System.arraycopy(domain, 0, targetInfo, offset, domainLength);
            offset += domainLength;
        }
        if ( serverLength > 0 ) {

        <match value="\nReceived: from " type="string" offset="32:256"/>
        <match value="\nMime-Version: " type="string" offset="32:256"/>

        <match value="\nX-" type="stringignorecase" offset="32:256">
          <match value="\nFrom: " type="string" offset="32:8192"/>
          <match value="\nDate: " type="string" offset="32:8192"/>
          <match value="\nSubject: " type="string" offset="32:8192"/>

}

func (w *writerAt) WriteAt(b []byte, offset int64) (n int, err error) {
	w.m.Lock()
	defer w.m.Unlock()

	if w.nextOffset == offset {
		n, err = w.w.Write(b)
		w.nextOffset += int64(n)
	} else {
		if offset > w.nextOffset+ftpMaxWriteOffset {
			return 0, fmt.Errorf("write offset %d is too far ahead of next offset %d", offset, w.nextOffset)
		}
		w.buffer[offset] = make([]byte, len(b))
		copy(w.buffer[offset], b)

        if (mappingItemList == null) {
            reload(null);
        }

        if (offset >= mappingItemList.size() || offset < 0) {
            return new PagingList<>(Collections.<CharMappingItem> emptyList(), offset, size, mappingItemList.size());
        }

        int toIndex = offset + size;
        if (toIndex > mappingItemList.size()) {