}
	}

	if (!globalThis.crypto) {
		throw new Error("globalThis.crypto is not available, polyfill required (crypto.getRandomValues only)");
	}

	if (!globalThis.performance) {
		throw new Error("globalThis.performance is not available, polyfill required (performance.now only)");
	}

	if (!globalThis.TextEncoder) {
		throw new Error("globalThis.TextEncoder is not available, polyfill required");
	}

	if (!globalThis.TextDecoder) {

  - type: textarea
    id: orthogonality
    attributes:
      label: "Orthogonality: How does this change interact or overlap with existing features?"
      description: "Is the goal of this change a performance improvement? If so, what quantifiable improvement should we expect? How would we measure it?"
    validations:
      required: false

  - type: textarea
    id: learning-curve
    attributes:

}

globalThis.require = require;
globalThis.fs = require("fs");
globalThis.TextEncoder = require("util").TextEncoder;
globalThis.TextDecoder = require("util").TextDecoder;

globalThis.performance ??= require("performance");

globalThis.crypto ??= require("crypto");

require("./wasm_exec");

const go = new Go();
go.argv = process.argv.slice(2);
go.env = Object.assign({ TMPDIR: require("os").tmpdir() }, process.env);

package tar

import (
	"io/fs"
	"os/user"
	"runtime"
	"strconv"
	"sync"
	"syscall"
)

func init() {
	sysStat = statUnix
}

// userMap and groupMap caches UID and GID lookups for performance reasons.
// The downside is that renaming uname or gname by the OS never takes effect.
var userMap, groupMap sync.Map // map[int]string

func statUnix(fi fs.FileInfo, h *Header, doNameLookups bool) error {

		if r != utf8.RuneError {
			// r is 2 to 4 bytes
			if len(chars) == width {
				if chars == string(r) {
					return i
				}
				continue
			}
			// Use bytealg.IndexString for performance if available.
			if bytealg.MaxLen >= width {
				if bytealg.IndexString(chars, string(r)) >= 0 {
					return i
				}
				continue
			}
		}
		for _, ch := range chars {
			if r == ch {

			85, 120, 0, 0, // tag 30805 size 0
		},
	}
	testValidHeader(&h, t)
}

// Just benchmarking how fast the Zip64 test above is. Not related to
// our zip performance, since the test above disabled CRC32 and flate.
func BenchmarkZip64Test(b *testing.B) {
	for i := 0; i < b.N; i++ {
		testZip64(b, 1<<26)
	}
}

func BenchmarkZip64TestSizes(b *testing.B) {

pkg syscall (windows-386), const HKEY_CURRENT_USER ideal-int
pkg syscall (windows-386), const HKEY_DYN_DATA ideal-int
pkg syscall (windows-386), const HKEY_LOCAL_MACHINE ideal-int
pkg syscall (windows-386), const HKEY_PERFORMANCE_DATA ideal-int
pkg syscall (windows-386), const HKEY_USERS ideal-int
pkg syscall (windows-386), const IFF_POINTTOPOINT ideal-int
pkg syscall (windows-386), const IGNORE ideal-int

pkg syscall (windows-386), const HKEY_DYN_DATA = 2147483654
pkg syscall (windows-386), const HKEY_LOCAL_MACHINE = 2147483650
pkg syscall (windows-386), const HKEY_PERFORMANCE_DATA = 2147483652
pkg syscall (windows-386), const HKEY_USERS = 2147483651
pkg syscall (windows-386), const IFF_LOOPBACK = 4
pkg syscall (windows-386), const IFF_MULTICAST = 16

</p>

<h2 id="runtime">Runtime</h2>

<p><!-- CL 543255 -->
  The runtime now keeps type-based garbage collection metadata nearer to each
  heap object, improving the CPU performance (latency or throughput) of Go programs
  by 1&ndash;3%.
  This change also reduces the memory overhead of the majority Go programs by
  approximately 1% by deduplicating redundant metadata.

			b.Run(v.label, func(b *testing.B) {
				b.ReportAllocs()
				for i := 0; i < b.N; i++ {
					// Writing to io.Discard because we want to
					// test purely the writer code and not bring in disk performance into this.
					tw := NewWriter(io.Discard)
					for _, file := range v.files {
						if err := tw.WriteHeader(file.hdr); err != nil {
							b.Errorf("unexpected WriteHeader error: %v", err)
						}