return err
	}

	if vssLimit > 0 && vssLimit < humanize.GiByte {
		logger.Info("WARNING: maximum virtual memory limit (%s) is too small for 'go runtime', please consider setting `ulimit -v` to unlimited",
			humanize.IBytes(vssLimit))
	}

	if ctx.MemLimit > 0 {
		debug.SetMemoryLimit(int64(ctx.MemLimit))
	}

	// Do not use RLIMIT_AS as that is not useful and at times on systems < 4Gi

		if err != nil {
			return err
		}
		if mlimit > memAvailable {
			logger.Info("WARNING: maximum memory available (%s) smaller than specified --memlimit=%s, ignoring --memlimit value",
				humanize.IBytes(memAvailable), memlimit)
		}
		ctxt.MemLimit = mlimit
	} else {
		ctxt.MemLimit = memAvailable
	}

	if memAvailable < ctxt.MemLimit {
		ctxt.MemLimit = memAvailable
	}

	if capacity < capacityNeeded {
		return false, false, fmt.Sprintf("not enough usable space available to perform speedtest - expected %s, got %s",
			humanize.IBytes(capacityNeeded), humanize.IBytes(capacity))
	}

	// Verify if we can employ autotune without running out of capacity,
	// if we do run out of capacity, make sure to turn-off autotuning
	// in such situations.
	if autotune {

pkg syscall (freebsd-386-cgo), type IfData struct, Hdrlen uint8
pkg syscall (freebsd-386-cgo), type IfData struct, Hwassist uint32
pkg syscall (freebsd-386-cgo), type IfData struct, Ibytes uint32
pkg syscall (freebsd-386-cgo), type IfData struct, Ierrors uint32
pkg syscall (freebsd-386-cgo), type IfData struct, Imcasts uint32
pkg syscall (freebsd-386-cgo), type IfData struct, Ipackets uint32

/**
 * Static utility methods pertaining to {@code byte} primitives, that are not already found in
 * either {@link Byte} or {@link Arrays}, <i>and interpret bytes as neither signed nor unsigned</i>.
 * The methods which specifically treat bytes as signed or unsigned are found in {@link SignedBytes}
 * and {@link UnsignedBytes}.
 *
 * <p>See the Guava User Guide article on <a

// Package bytes implements functions for the manipulation of byte slices.
// It is analogous to the facilities of the [strings] package.
package bytes

import (
	"internal/bytealg"
	"math/bits"
	"unicode"
	"unicode/utf8"
	_ "unsafe" // for linkname
)

// Equal reports whether a and b
// are the same length and contain the same bytes.
// A nil argument is equivalent to an empty slice.

	for r := rune(0); r < NRune; r++ {
		size := utf8.EncodeRune(b[n:], r)
		nbytes, err := buf.WriteRune(r)
		if err != nil {
			t.Fatalf("WriteRune(%U) error: %s", r, err)
		}
		if nbytes != size {
			t.Fatalf("WriteRune(%U) expected %d, got %d", r, size, nbytes)
		}
		n += size
	}
	b = b[0:n]

	// Check the resulting bytes
	if !Equal(buf.Bytes(), b) {

pkg syscall (netbsd-arm64-cgo), type IfData struct, Collisions uint64
pkg syscall (netbsd-arm64-cgo), type IfData struct, Hdrlen uint8
pkg syscall (netbsd-arm64-cgo), type IfData struct, Ibytes uint64
pkg syscall (netbsd-arm64-cgo), type IfData struct, Ierrors uint64
pkg syscall (netbsd-arm64-cgo), type IfData struct, Imcasts uint64
pkg syscall (netbsd-arm64-cgo), type IfData struct, Ipackets uint64

    Murmur3_32Hasher(int seed) {
      this.h1 = seed;
      this.length = 0;
      isDone = false;
    }

    private void update(int nBytes, long update) {
      // 1 <= nBytes <= 4
      buffer |= (update & 0xFFFFFFFFL) << shift;
      shift += nBytes * 8;
      length += nBytes;

      if (shift >= 32) {
        h1 = mixH1(h1, mixK1((int) buffer));
        buffer >>>= 32;
        shift -= 32;
      }
    }

pkg bytes, method (*Buffer) Bytes() []uint8
pkg bytes, method (*Buffer) Len() int
pkg bytes, method (*Buffer) Next(int) []uint8
pkg bytes, method (*Buffer) Read([]uint8) (int, error)
pkg bytes, method (*Buffer) ReadByte() (uint8, error)
pkg bytes, method (*Buffer) ReadBytes(uint8) ([]uint8, error)
pkg bytes, method (*Buffer) ReadFrom(io.Reader) (int64, error)
pkg bytes, method (*Buffer) ReadRune() (int32, int, error)