pkg syscall (darwin-arm64), const LOCK_EX = 2
pkg syscall (darwin-arm64), const LOCK_EX ideal-int
pkg syscall (darwin-arm64), const LOCK_NB = 4
pkg syscall (darwin-arm64), const LOCK_NB ideal-int
pkg syscall (darwin-arm64), const LOCK_SH = 1
pkg syscall (darwin-arm64), const LOCK_SH ideal-int
pkg syscall (darwin-arm64), const LOCK_UN = 8
pkg syscall (darwin-arm64), const LOCK_UN ideal-int

// nearest block edge where 0 <= n < blockSize.
func blockPadding(offset int64) (n int64) {
	return -offset & (blockSize - 1)
}

var zeroBlock block

type block [blockSize]byte

// Convert block to any number of formats.
func (b *block) toV7() *headerV7       { return (*headerV7)(b) }
func (b *block) toGNU() *headerGNU     { return (*headerGNU)(b) }

	for i, n := range names {
		fmt.Fprintf(&b, "__typeof__(%s) *__cgo__%d;\n", n.C, i)
		if n.Kind == "iconst" {
			fmt.Fprintf(&b, "enum { __cgo_enum__%d = %s };\n", i, n.C)
		}
	}

	// We create a data block initialized with the values,
	// so we can read them out of the object file.
	fmt.Fprintf(&b, "long long __cgodebug_ints[] = {\n")
	for _, n := range names {
		if n.Kind == "iconst" {
			fmt.Fprintf(&b, "\t%s,\n", n.C)

pkg syscall (freebsd-riscv64), const SYS_CLOCK_GETCPUCLOCKID2 = 247 #53466
pkg syscall (freebsd-riscv64), const SYS_CLOCK_GETCPUCLOCKID2 ideal-int #53466
pkg syscall (freebsd-riscv64), const SYS_CLOCK_GETRES = 234 #53466
pkg syscall (freebsd-riscv64), const SYS_CLOCK_GETRES ideal-int #53466
pkg syscall (freebsd-riscv64), const SYS_CLOCK_GETTIME = 232 #53466
pkg syscall (freebsd-riscv64), const SYS_CLOCK_GETTIME ideal-int #53466

					sa.IsExtended()[0] = 1
				}
				return sp
			}
			sp2 := formatSPD(spd, blk.GNU().Sparse())
			for len(sp2) > 0 {
				var spHdr block
				sp2 = formatSPD(sp2, spHdr.Sparse())
				spb = append(spb, spHdr[:]...)
			}

			// Update size fields in the header block.
			realSize := hdr.Size
			hdr.Size = 0 // Encoded size; does not account for encoded sparse map
			for _, s := range spd {
				hdr.Size += s.Length

</p>

<h2 id="Blocks">Blocks</h2>

<p>
A <i>block</i> is a possibly empty sequence of declarations and statements
within matching brace brackets.
</p>

<pre class="ebnf">
Block = "{" StatementList "}" .
StatementList = { Statement ";" } .
</pre>

<p>
In addition to explicit blocks in the source code, there are implicit blocks:
</p>

<ol>

		if len(extra) < fieldSize {
			break
		}
		fieldBuf := extra.sub(fieldSize)

		switch fieldTag {
		case zip64ExtraID:
			f.zip64 = true

			// update directory values from the zip64 extra block.
			// They should only be consulted if the sizes read earlier
			// are maxed out.
			// See golang.org/issue/13367.
			if needUSize {
				needUSize = false
				if len(fieldBuf) < 8 {
					return ErrFormat

directive declares the symbol <code>runtime·profileloop</code> and the instructions
that follow form the body of the function.
The last instruction in a <code>TEXT</code> block must be some sort of jump, usually a <code>RET</code> (pseudo-)instruction.
(If it's not, the linker will append a jump-to-itself instruction; there is no fallthrough in <code>TEXTs</code>.)

pkg syscall (freebsd-386), const SYS_CHROOT = 61
pkg syscall (freebsd-386), const SYS_CLOCK_GETCPUCLOCKID2 = 247
pkg syscall (freebsd-386), const SYS_CLOCK_GETCPUCLOCKID2 ideal-int
pkg syscall (freebsd-386), const SYS_CLOCK_GETRES = 234
pkg syscall (freebsd-386), const SYS_CLOCK_GETTIME = 232
pkg syscall (freebsd-386), const SYS_CLOCK_SETTIME = 233
pkg syscall (freebsd-386), const SYS_CLOSE = 6

	if _, err := zip.ReadAt(d, zip.Size()-int64(len(d))); err != nil {
		t.Fatalf("ReadAt: %v", err)
	}

	sigOff := findSignatureInBlock(d)
	if sigOff == -1 {
		t.Errorf("failed to find signature in block")
		return false
	}

	dirOff, err := findDirectory64End(zip, zip.Size()-int64(len(d))+int64(sigOff))
	if err != nil {
		t.Fatalf("findDirectory64End: %v", err)
	}
	if dirOff == -1 {
		return false