syso/goboringcrypto_linux_arm64.syso is built with:

	GOARCH=arm64 ./build.sh

Both run on an x86 Debian Linux system using Docker.
For the arm64 build to run on an x86 system, you need

	apt-get install qemu-user-static qemu-binfmt-support

to allow the x86 kernel to run arm64 binaries via QEMU.

    classPath: ClassPath,
    srcDir: File,
    binDir: File?,
    packageName: String = kotlinDslPackageName,
    format: AccessorFormat = AccessorFormats.default
) {
    val availableSchema = availableProjectSchemaFor(projectSchema, classPath)
    emitAccessorsFor(
        availableSchema,
        srcDir,
        binDir,
        OutputPackage(packageName),
        format
    )
}

		f.Add([]byte(test.data))
	}
	f.Add(bytes.Repeat([]byte("abcdefghijklmnop"), 256))
	var buf bytes.Buffer
	for i := 0; i < 256; i++ {
		buf.WriteByte(byte(i))
	}
	f.Add(bytes.Repeat(buf.Bytes(), 64))
	f.Add(bigData(f))

	f.Fuzz(func(t *testing.T, b []byte) {
		cmd := exec.Command(xxhsum, "-H64")
		cmd.Stdin = bytes.NewReader(b)
		var hhsumHash bytes.Buffer
		cmd.Stdout = &hhsumHash
		if err := cmd.Run(); err != nil {

	f.Add(bytes.Repeat([]byte("abcdefghijklmnop"), 256))
	var buf bytes.Buffer
	for i := 0; i < 256; i++ {
		buf.WriteByte(byte(i))
	}
	f.Add(bytes.Repeat(buf.Bytes(), 64))
	f.Add(bigData(f))

	f.Fuzz(func(t *testing.T, b []byte) {
		cmd := exec.Command(zstd, "-z")
		cmd.Stdin = bytes.NewReader(b)
		var compressed bytes.Buffer
		cmd.Stdout = &compressed
		cmd.Stderr = os.Stderr

    labels:
      kubernetes.io/bootstrapping: rbac-defaults
    name: system:controller:persistent-volume-binder
  roleRef:
    apiGroup: rbac.authorization.k8s.io
    kind: ClusterRole
    name: system:controller:persistent-volume-binder
  subjects:
  - kind: ServiceAccount
    name: persistent-volume-binder
    namespace: kube-system
- apiVersion: rbac.authorization.k8s.io/v1
  kind: ClusterRoleBinding
  metadata:

			if !extData.ReadUint16LengthPrefixed(&binders) || binders.Empty() {
				return false
			}
			for !binders.Empty() {
				var binder []byte
				if !readUint8LengthPrefixed(&binders, &binder) ||
					len(binder) == 0 {
					return false
				}
				m.pskBinders = append(m.pskBinders, binder)
			}
		default:
			// Ignore unknown extensions.
			continue
		}

		if !extData.Empty() {
			return false
		}

static pthread_cond_t runtime_init_cond = PTHREAD_COND_INITIALIZER;
static pthread_mutex_t runtime_init_mu = PTHREAD_MUTEX_INITIALIZER;
static int runtime_init_done;

// pthread_g is a pthread specific key, for storing the g that binded to the C thread.
// The registered pthread_key_destructor will dropm, when the pthread-specified value g is not NULL,
// while a C thread is exiting.
static pthread_key_t pthread_g;
static void pthread_key_destructor(void* g);

        }
        DefaultNativePlatform targetPlatform = new DefaultNativePlatform("default");
        def visualCpp = vsInstall.visualCpp.forPlatform(targetPlatform)
        vcBin = visualCpp.binDir
        vcPath = visualCpp.path.join(';')
    }

    static @Nullable VisualStudioInstall findVisualStudio() {
        return VisualStudioLocatorTestFixture.visualStudioLocator.locateComponent(null).component
    }

	NodeLifecycleController                      = "node-lifecycle-controller"
	TaintEvictionController                      = "taint-eviction-controller"
	PersistentVolumeBinderController             = "persistentvolume-binder-controller"
	PersistentVolumeAttachDetachController       = "persistentvolume-attach-detach-controller"
	PersistentVolumeExpanderController           = "persistentvolume-expander-controller"

            '/usr/local/include'
        ]
        def mapped = [
            'C:\\cygwin\\usr\\include',
            'C:\\cygwin\\usr\\local\\include'
        ]
        def binDir = tmpDir.createDir('bin')
        def cygpath = binDir.createFile(OperatingSystem.current().getExecutableName('cygpath'))

        expect:
        runsCompiler(gccCygwin64, gccVerboseOutput('7.3', includes))