const offset = 3<<29 + 10
	if i > offset {
		return *ss[i-offset]
	}
	return ""
}
func f9(ss []*string, i int) string {
	const offset = 3<<29 - 10
	if i > offset {
		return *ss[i-offset]
	}
	return ""

func (sws *WriteSeeker) Seek(offset int64, whence int) (int64, error) {
	switch whence {
	case io.SeekStart:
		if sws.off != offset && (offset < 0 || offset > int64(len(sws.payload))) {
			return 0, fmt.Errorf("invalid seek: new offset %d (out of range [0 %d]", offset, len(sws.payload))
		}
		sws.off = offset
		return offset, nil
	case io.SeekCurrent:
		newoff := sws.off + offset

	atyp := typ.ArrayType()
	etyp := atyp.Elem
	offset := baseOffset
	for range atyp.Len {
		switch etyp.Kind() {
		case abi.String:
			seq.stringOffsets = append(seq.stringOffsets, offset)
		case abi.Struct:
			buildStructCloneSeq(etyp, seq, offset)
		case abi.Array:
			buildArrayCloneSeq(etyp, seq, offset)
		}
		offset += etyp.Size()
		align := uintptr(etyp.FieldAlign())
		offset = (offset + align - 1) &^ (align - 1)
	}

	// the abbreviation.
	// Hence, we construct the name from the offset.
	z.name = "UTC"
	if offset < 0 {
		z.name += "-"
		offset *= -1
	} else {
		z.name += "+"
	}
	z.name += itoa.Itoa(offset / 60)
	min := offset % 60
	if min != 0 {
		z.name += ":" + itoa.Itoa(min)
	}
	localLoc.zone = []zone{z}

    /**
     * 
     * @param config
     * @param fid
     * @param offset
     * @param maxCount
     * @param andx
     */
    public SmbComReadAndX ( Configuration config, int fid, long offset, int maxCount, ServerMessageBlock andx ) {
        super(config, SMB_COM_READ_ANDX, andx);
        this.fid = fid;
        this.offset = offset;
        this.maxCount = this.minCount = maxCount;
        this.openTimeout = 0xFFFFFFFF;

     *
     * @param data The data.
     * @param offset The starting offset at which the SMB header begins.
     * @param length The length of the SMB data starting at offset. 
     */
    boolean verify(byte[] data, int offset, ServerMessageBlock response) {
        update(macSigningKey, 0, macSigningKey.length);
        int index = offset;
        update(data, index, ServerMessageBlock.SIGNATURE_OFFSET); 

	MOVD	R26, (offset+8*12)(R1) \
	MOVD	R27, (offset+8*13)(R1) \
	MOVD	R28, (offset+8*14)(R1) \
	MOVD	R29, (offset+8*15)(R1) \
	MOVD	g,   (offset+8*16)(R1) \
	MOVD	R31, (offset+8*17)(R1)

#define RESTORE_GPR(offset)            \
	MOVD	(offset+8*0)(R1), R14  \
	MOVD	(offset+8*1)(R1), R15  \
	MOVD	(offset+8*2)(R1), R16  \
	MOVD	(offset+8*3)(R1), R17  \
	MOVD	(offset+8*4)(R1), R18  \
	MOVD	(offset+8*5)(R1), R19  \
	MOVD	(offset+8*6)(R1), R20  \

      @Override
      public long getLongLittleEndian(byte[] source, int offset) {
        return Longs.fromBytes(
            source[offset + 7],
            source[offset + 6],
            source[offset + 5],
            source[offset + 4],
            source[offset + 3],
            source[offset + 2],
            source[offset + 1],
            source[offset]);
      }

      @Override

  }

  private static long hashLength33To64(byte[] bytes, int offset, int length) {
    long z = load64(bytes, offset + 24);
    long a = load64(bytes, offset) + (length + load64(bytes, offset + length - 16)) * K0;
    long b = rotateRight(a + z, 52);
    long c = rotateRight(a, 37);
    a += load64(bytes, offset + 8);
    c += rotateRight(a, 7);
    a += load64(bytes, offset + 16);
    long vf = a + z;

	STP	(R25, R26), ((offset)+6*8)(RSP) \
	STP	(R27, g), ((offset)+8*8)(RSP)

#define RESTORE_R19_TO_R28(offset) \
	LDP	((offset)+0*8)(RSP), (R19, R20) \
	LDP	((offset)+2*8)(RSP), (R21, R22) \
	LDP	((offset)+4*8)(RSP), (R23, R24) \
	LDP	((offset)+6*8)(RSP), (R25, R26) \
	LDP	((offset)+8*8)(RSP), (R27, g) /* R28 */

#define SAVE_F8_TO_F15(offset) \
	FSTPD	(F8, F9), ((offset)+0*8)(RSP) \