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

			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 syscall (freebsd-arm64), const LOCK_EX = 2
pkg syscall (freebsd-arm64), const LOCK_EX ideal-int
pkg syscall (freebsd-arm64), const LOCK_NB = 4
pkg syscall (freebsd-arm64), const LOCK_NB ideal-int
pkg syscall (freebsd-arm64), const LOCK_SH = 1
pkg syscall (freebsd-arm64), const LOCK_SH ideal-int
pkg syscall (freebsd-arm64), const LOCK_UN = 8
pkg syscall (freebsd-arm64), const LOCK_UN ideal-int

	fw *flate.Writer
}

func (w *pooledFlateWriter) Write(p []byte) (n int, err error) {
	w.mu.Lock()
	defer w.mu.Unlock()
	if w.fw == nil {
		return 0, errors.New("Write after Close")
	}
	return w.fw.Write(p)
}

func (w *pooledFlateWriter) Close() error {
	w.mu.Lock()
	defer w.mu.Unlock()
	var err error
	if w.fw != nil {
		err = w.fw.Close()
		flateWriterPool.Put(w.fw)
		w.fw = nil

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

		}
		pre = cur
	}
	return true
}

// alignSparseEntries mutates src and returns dst where each fragment's
// starting offset is aligned up to the nearest block edge, and each
// ending offset is aligned down to the nearest block edge.
//
// Even though the Go tar Reader and the BSD tar utility can handle entries
// with arbitrary offsets and lengths, the GNU tar utility can only handle

//
// pthread_t *t = NULL;
// pthread_mutex_t mu;
// int nts = 0;
// int all_done = 0;
//
// static void *aFn(void *vargp) {
//   int done = 0;
//   while (!done) {
//     usleep(100);
//     pthread_mutex_lock(&mu);
//     done = all_done;
//     pthread_mutex_unlock(&mu);
//   }
//   return NULL;
// }
//
// void trial(int argc) {
//   int i;
//   nts = argc;
//   t = calloc(nts, sizeof(pthread_t));

pkg syscall (freebsd-riscv64), const LOCK_EX = 2 #53466
pkg syscall (freebsd-riscv64), const LOCK_EX ideal-int #53466
pkg syscall (freebsd-riscv64), const LOCK_NB = 4 #53466
pkg syscall (freebsd-riscv64), const LOCK_NB ideal-int #53466
pkg syscall (freebsd-riscv64), const LOCK_SH = 1 #53466
pkg syscall (freebsd-riscv64), const LOCK_SH ideal-int #53466
pkg syscall (freebsd-riscv64), const LOCK_UN = 8 #53466

// 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) }