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}

		}
		if p.From.Offset&0xFFFF == 0 {
			// The constant can be added using ADDIS
			p.As = AADDIS
			p.From.Offset >>= 16
		} else if buildcfg.GOPPC64 >= 10 {
			// Let the assembler generate paddi for large constants.
			break
		} else if (p.From.Offset < -0x8000 && int64(int32(p.From.Offset)) == p.From.Offset) || (p.From.Offset > 0xFFFF && p.From.Offset < 0x7FFF8000) {

	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  \

	}
	su.SetUint32(target.Arch, offset, newinsn)
}

// Rewrite the instruction at offset into a hardware nop instruction. Also, verify the
// existing instruction under mask matches the check value.
func rewritetonop(target *ld.Target, ldr *loader.Loader, su *loader.SymbolBuilder, offset int64, mask, check uint32) {
	rewritetoinsn(target, ldr, su, offset, mask, check, OP_NOP)
}

	// Block 0x38, offset 0xe00
	0xe00: 0x000a,
	// Block 0x39, offset 0xe40
	0xe40: 0x0009,
	0xe5b: 0x007a, 0xe5c: 0x006a,
	// Block 0x3a, offset 0xe80
	0xe92: 0x000c, 0xe93: 0x000c, 0xe94: 0x000c,
	0xeb2: 0x000c, 0xeb3: 0x000c, 0xeb4: 0x000c,
	// Block 0x3b, offset 0xec0
	0xed2: 0x000c, 0xed3: 0x000c,
	0xef2: 0x000c, 0xef3: 0x000c,
	// Block 0x3c, offset 0xf00
	0xf34: 0x000c, 0xf35: 0x000c,

func (p *parser) loadBatch(pid int32, events []Event) ([]Event, error) {
	offsets := p.batchOffsets[pid]
	if len(offsets) == 0 {
		return nil, io.EOF
	}
	n := offsets[0].numEvents
	offset := offsets[0].offset
	offsets = offsets[1:]
	p.batchOffsets[pid] = offsets

	p.off = offset

	if cap(events) < n {
		events = make([]Event, 0, n)
	}

	gotHeader := false