"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},
		},
		{

	"internal/abi"
	"sync"
	"sync/atomic"
)

// An Addr is an argument to an instruction.
// The general forms and their encodings are:
//
//	sym±offset(symkind)(reg)(index*scale)
//		Memory reference at address &sym(symkind) + offset + reg + index*scale.
//		Any of sym(symkind), ±offset, (reg), (index*scale), and *scale can be omitted.
//		If (reg) and *scale are both omitted, the resulting expression (index) is parsed as (reg).

// by conversion to uintptr, addition of an offset, and conversion back to Pointer.
//
//	p = unsafe.Pointer(uintptr(p) + offset)
//
// The most common use of this pattern is to access fields in a struct
// or elements of an array:
//
//	// equivalent to f := unsafe.Pointer(&s.f)
//	f := unsafe.Pointer(uintptr(unsafe.Pointer(&s)) + unsafe.Offsetof(s.f))
//
//	// equivalent to e := unsafe.Pointer(&x[i])

			// 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 '+':

	// on and then pick up on the frame offsets of specific
	// variables.
	//
	// Stack slot merging is a greedy algorithm, and there can
	// be many possible ways to overlap a given set of candidate
	// variables, all of them legal. Rather than locking down
	// a specific set of overlappings or frame offsets, this
	// tests just verifies that there is a decent-sized clump of 4+ vars that

  }

  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;

	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},