out  string
	}{
		{"int", math.MaxInt64, "9223372036854775807"},
		{"int8", int8(math.MaxInt8), "127"},
		{"int16", int16(math.MaxInt16), "32767"},
		{"int32", int32(math.MaxInt32), "2147483647"},
		{"int64", int64(math.MaxInt64), "9223372036854775807"},
		{"uint", uint(math.MaxUint64), "18446744073709551615"},
		{"uint8", uint8(math.MaxUint8), "255"},
		{"uint16", uint16(math.MaxUint16), "65535"},

// license that can be found in the LICENSE file.

package main

import "math"

func main() {
	f()
	g()
	h()
}
func f() {
	for i := int64(math.MinInt64); i >= math.MinInt64; i-- {
		if i > 0 {
			println("done")
			return
		}
		println(i, i > 0)
	}
}
func g() {
	for i := int64(math.MinInt64) + 1; i >= math.MinInt64; i-- {
		if i > 0 {
			println("done")
			return
		}

		m.Set(sysCPULoadPerc, math.Round(perc*100)/100)
	}

	ts := cpuMetrics.TimesStat
	tot := ts.User + ts.System + ts.Idle + ts.Iowait + ts.Nice + ts.Steal
	cpuUserVal := math.Round(ts.User/tot*100*100) / 100
	m.Set(sysCPUUser, cpuUserVal)
	cpuSystemVal := math.Round(ts.System/tot*100*100) / 100
	m.Set(sysCPUSystem, cpuSystemVal)
	cpuNiceVal := math.Round(ts.Nice/tot*100*100) / 100
	m.Set(sysCPUNice, cpuNiceVal)

	< TIME;

	TIME, io, path, slices
	< io/fs;

	# MATH is RUNTIME plus the basic math packages.
	RUNTIME
	< math
	< MATH;

	unicode !< math;

	MATH
	< math/cmplx;

	MATH
	< math/rand, math/rand/v2;

	MATH
	< runtime/metrics;

	RUNTIME, math/rand/v2
	< internal/concurrent;

	MATH, unicode/utf8
	< strconv;

	unicode !< strconv;

// For details, see the comment at the top of cmplxdivide.c.

package main

import (
	"fmt"
	"math"
)

func calike(a, b complex128) bool {
	if imag(a) != imag(b) && !(math.IsNaN(imag(a)) && math.IsNaN(imag(b))) {
		return false
	}

	if real(a) != real(b) && !(math.IsNaN(real(a)) && math.IsNaN(real(b))) {
		return false
	}

	return true
}

func main() {
	bad := false

import static com.google.common.truth.Truth.assertThat;
import static com.google.common.truth.Truth.assertWithMessage;
import static java.math.BigInteger.ONE;
import static java.math.BigInteger.TEN;
import static java.math.BigInteger.ZERO;
import static java.math.RoundingMode.CEILING;
import static java.math.RoundingMode.DOWN;
import static java.math.RoundingMode.FLOOR;

import "errors"

func inodeForFd(n NetnsFd) (uint64, error) {
	return 0, errors.New("not implemented")
}

func NetnsSet(n NetnsFd) error {
	return errors.New("not implemented")
}

func OpenNetns(nspath string) (NetnsCloser, error) {
	return nil, errors.New("not implemented")
}

// inspired by netns.Do() but with an existing fd.
func NetnsDo(fdable NetnsFd, toRun func() error) error {

			wantOK: true,
		},
		{
			name: "max",
			fields: fields{
				value: []byte(strconv.FormatInt(math.MaxInt64, 10)),
			},
			want:   math.MaxInt64,
			wantOK: true,
		},
		{
			name: "min",
			fields: fields{
				value: []byte(strconv.FormatInt(math.MinInt64, 10)),
			},
			want:   math.MinInt64,
			wantOK: true,
		},
		{
			name: "max-overflow",
			fields: fields{

import static com.google.common.math.MathPreconditions.checkInRangeForRoundingInputs;
import static com.google.common.math.MathPreconditions.checkNonNegative;
import static com.google.common.math.MathPreconditions.checkRoundingUnnecessary;
import static java.lang.Math.abs;
import static java.lang.Math.copySign;
import static java.lang.Math.getExponent;
import static java.lang.Math.log;
import static java.lang.Math.rint;

import static com.google.common.math.MathPreconditions.checkInRangeForRoundingInputs;
import static com.google.common.math.MathPreconditions.checkNonNegative;
import static com.google.common.math.MathPreconditions.checkRoundingUnnecessary;
import static java.lang.Math.abs;
import static java.lang.Math.copySign;
import static java.lang.Math.getExponent;
import static java.lang.Math.log;
import static java.lang.Math.rint;