// These two fields are swapped on MIPS platforms.
		ofErrno, ofCode = ofCode, ofErrno
	}
	ofPid := 12
	if host64bit {
		ofPid = 16
	}
	ofUid := ofPid + 4
	ofStatus := ofPid + 8

	offsets := []struct {
		name string
		got  uintptr
		want int
	}{
		{"Signo", unsafe.Offsetof(si.Signo), ofSigno},
		{"Errno", unsafe.Offsetof(si.Errno), ofErrno},
		{"Code", unsafe.Offsetof(si.Code), ofCode},

/**
 * Checks the data in the content of the documents for equality structurally, ignoring:
 * * the [DeclarativeDocument] implementations,
 * * the differences in the source information, like source identifiers or the offsets in the source data,
 * * the source representations of the literal values (thus taking into account only the values),
 * * the error causes, thus considering all error nodes equal to each other but not to any other node.
 */

// an in-memory suffix array.
//
// Example use:
//
//	// create index for some data
//	index := suffixarray.New(data)
//
//	// lookup byte slice s
//	offsets1 := index.Lookup(s, -1) // the list of all indices where s occurs in data
//	offsets2 := index.Lookup(s, 3)  // the list of at most 3 indices where s occurs in data
package suffixarray

import (
	"bytes"
	"encoding/binary"
	"errors"
	"io"
	"math"

// that are known to the runtime.
//
// The first local is a bool called retValid with a whole pointer-word reserved
// for it on the stack. The purpose of this word is so that the runtime knows
// whether the stack-allocated return space contains valid values for stack
// scanning.
//
// The second local is an abi.RegArgs value whose offset is also known to the

	if err := binary.Write(ws, binary.LittleEndian, cfw.csh); err != nil {
		return err
	}
	hdrsz := uint32(len(ws.BytesWritten()))

	// Write string table and args to a byte slice (since we need
	// to capture offsets at various points), then emit the slice
	// once we are done.
	cfw.stab.Freeze()
	if err := cfw.stab.Write(ws); err != nil {
		return err
	}
	cfw.csh.StrTabLen = uint32(len(ws.BytesWritten())) - hdrsz