pkg syscall (linux-amd64-cgo), type Flock_t struct, Pad_cgo_0 [4]uint8
pkg syscall (linux-amd64-cgo), type Flock_t struct, Pad_cgo_1 [4]uint8
pkg syscall (linux-amd64-cgo), type Flock_t struct, Pid int32
pkg syscall (linux-amd64-cgo), type Flock_t struct, Start int64
pkg syscall (linux-amd64-cgo), type Flock_t struct, Type int16
pkg syscall (linux-amd64-cgo), type Flock_t struct, Whence int16

	    and ends at the end of the innermost containing block.</li>

	<li>The scope of a type identifier declared inside a function
	    begins at the identifier in the TypeSpec
	    and ends at the end of the innermost containing block.</li>
</ol>

<p>
An identifier declared in a block may be redeclared in an inner block.
While the identifier of the inner declaration is in scope, it denotes

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

			b.Write(buf[:1])
		}
	}
}

func BenchmarkBufferWriteBlock(b *testing.B) {
	block := make([]byte, 1024)
	for _, n := range []int{1 << 12, 1 << 16, 1 << 20} {
		b.Run(fmt.Sprintf("N%d", n), func(b *testing.B) {
			b.ReportAllocs()
			for i := 0; i < b.N; i++ {
				var bb Buffer
				for bb.Len() < n {
					bb.Write(block)
				}
			}
		})
	}
}

func BenchmarkBufferAppendNoCopy(b *testing.B) {

	// callback(x) calls goCallback(x)
	callbackMutex.Lock()
	callbackToken++
	i := callbackToken
	callbackFuncs[i] = f
	callbackMutex.Unlock()

	// Pass the address of i because the C function was written to
	// take a pointer.  We could pass an int if we felt like
	// rewriting the C code.
	C.callback(unsafe.Pointer(&i))

	callbackMutex.Lock()
	delete(callbackFuncs, i)
	callbackMutex.Unlock()
}

pkg crypto, type Decrypter interface, Public() PublicKey
pkg crypto, type DecrypterOpts interface {}
pkg crypto/cipher, func NewGCMWithNonceSize(Block, int) (AEAD, error)
pkg crypto/elliptic, type CurveParams struct, Name string
pkg crypto/rsa, method (*PrivateKey) Decrypt(io.Reader, []uint8, crypto.DecrypterOpts) ([]uint8, error)
pkg crypto/rsa, type OAEPOptions struct

	    and ends at the end of the innermost containing block.</li>

	<li>The scope of a type identifier declared inside a function
	    begins at the identifier in the TypeSpec
	    and ends at the end of the innermost containing block.</li>
</ol>

<p>
An identifier declared in a block may be redeclared in an inner block.
While the identifier of the inner declaration is in scope, it denotes

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

					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

	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