"SELECT * FROM `users` LIMIT ?",
			[]interface{}{limit10},
		},
		{
			[]clause.Interface{clause.Select{}, clause.From{}, clause.Limit{Limit: &limit10, Offset: 20}, clause.Limit{Offset: 30}, clause.Limit{Limit: &limitNeg10}},
			"SELECT * FROM `users` OFFSET ?",
			[]interface{}{30},
		},
		{

			// as some people do write offsets of 24 hours
			// or 60 minutes or 60 seconds.
			if hr > 24 {
				rangeErrString = "time zone offset hour"
			}
			if mm > 60 {
				rangeErrString = "time zone offset minute"
			}
			if ss > 60 {
				rangeErrString = "time zone offset second"
			}

			zoneOffset = (hr*60+mm)*60 + ss // offset is in seconds
			switch sign[0] {
			case '+':

	switch p.As {
	case ASUB:
		if p.From.Type == obj.TYPE_CONST {
			p.From.Offset = -p.From.Offset
			p.As = AADD
		}

	case ASUBU:
		if p.From.Type == obj.TYPE_CONST {
			p.From.Offset = -p.From.Offset
			p.As = AADDU
		}

	case ASUBV:
		if p.From.Type == obj.TYPE_CONST {
			p.From.Offset = -p.From.Offset
			p.As = AADDV
		}

	case ASUBVU:
		if p.From.Type == obj.TYPE_CONST {

	if t.Location() == UTC {
		offsetMin = -1
	} else {
		_, offset := t.Zone()
		if offset%60 != 0 {
			version = timeBinaryVersionV2
			offsetSec = int8(offset % 60)
		}

		offset /= 60
		if offset < -32768 || offset == -1 || offset > 32767 {
			return nil, errors.New("Time.MarshalBinary: unexpected zone offset")
		}
		offsetMin = int16(offset)
	}

	sec := t.sec()
	nsec := t.nsec()

	}

	// Read package offsets for good measure
	r.pkgOffsets = make([]uint64, r.hdr.Entries)
	for i := uint64(0); i < r.hdr.Entries; i++ {
		if r.pkgOffsets[i], err = r.rdUint64(); err != nil {
			return err
		}
		if r.pkgOffsets[i] > r.hdr.TotalLength {
			return fmt.Errorf("insane pkg offset %d: %d > totlen %d",
				i, r.pkgOffsets[i], r.hdr.TotalLength)
		}
	}

	MOVV	R26, ((offset)+(4*8))(R3)	\
	MOVV	R27, ((offset)+(5*8))(R3)	\
	MOVV	R28, ((offset)+(6*8))(R3)	\
	MOVV	R29, ((offset)+(7*8))(R3)	\
	MOVV	R30, ((offset)+(8*8))(R3)	\
	MOVV	R31, ((offset)+(9*8))(R3)

#define SAVE_F24_TO_F31(offset)	\
	MOVD	F24, ((offset)+(0*8))(R3)	\
	MOVD	F25, ((offset)+(1*8))(R3)	\
	MOVD	F26, ((offset)+(2*8))(R3)	\
	MOVD	F27, ((offset)+(3*8))(R3)	\
	MOVD	F28, ((offset)+(4*8))(R3)	\
	MOVD	F29, ((offset)+(5*8))(R3)	\

	// Block 0x91, offset 0x39c
	{value: 0x0010, lo: 0x80, hi: 0xb1},
	{value: 0x0004, lo: 0xb2, hi: 0xbf},
	// Block 0x92, offset 0x39e
	{value: 0x0004, lo: 0x80, hi: 0x81},
	{value: 0x0010, lo: 0x93, hi: 0xbf},
	// Block 0x93, offset 0x3a0
	{value: 0x0010, lo: 0x80, hi: 0xbd},
	// Block 0x94, offset 0x3a1
	{value: 0x0010, lo: 0x90, hi: 0xbf},
	// Block 0x95, offset 0x3a2
	{value: 0x0010, lo: 0x80, hi: 0x8f},

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}