-- input --
[math] is a package but this is not a doc link.

[io] is a doc link.

[math]: https://example.com
-- gofmt --
[math] is a package but this is not a doc link.

[io] is a doc link.

[math]: https://example.com
-- text --
math is a package but this is not a doc link.

io is a doc link.

[math]: https://example.com
-- markdown --
[math](https://example.com) is a package but this is not a doc link.

		},
		{
			input:  "2147483647", // math.MaxInt32
			output: IntOrString{Type: Int, IntVal: 2147483647},
		},
		{
			input:  "-2147483648", // math.MinInt32
			output: IntOrString{Type: Int, IntVal: -2147483648},
		},
		{
			input:  "2147483648", // math.MaxInt32+1
			output: IntOrString{Type: String, StrVal: "2147483648"},
		},
		{
			input:  "-2147483649", // math.MinInt32-1

	z.v = v
	z.q = s
	z.oneminusQ = 1.0 - z.q
	z.oneminusQinv = 1.0 / z.oneminusQ
	z.hxm = z.h(z.imax + 0.5)
	z.hx0minusHxm = z.h(0.5) - math.Exp(math.Log(z.v)*(-z.q)) - z.hxm
	z.s = 1 - z.hinv(z.h(1.5)-math.Exp(-z.q*math.Log(z.v+1.0)))
	return z
}

// Uint64 returns a value drawn from the Zipf distribution described
// by the Zipf object.
func (z *Zipf) Uint64() uint64 {
	if z == nil {
		panic("rand: nil Zipf")
	}

package strconv_test

import (
	"math"
	"math/cmplx"
	"reflect"
	. "strconv"
	"testing"
)

var (
	infp0 = complex(math.Inf(+1), 0)
	infm0 = complex(math.Inf(-1), 0)
	inf0p = complex(0, math.Inf(+1))
	inf0m = complex(0, math.Inf(-1))

	infpp = complex(math.Inf(+1), math.Inf(+1))
	infpm = complex(math.Inf(+1), math.Inf(-1))
	infmp = complex(math.Inf(-1), math.Inf(+1))

		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;

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

package strconv_test

import (
	"math"
	. "strconv"
	"testing"
)

func TestMulByLog2Log10(t *testing.T) {
	for x := -1600; x <= +1600; x++ {
		iMath := MulByLog2Log10(x)
		fMath := int(math.Floor(float64(x) * math.Ln2 / math.Ln10))
		if iMath != fMath {
			t.Errorf("mulByLog2Log10(%d) failed: %d vs %d\n", x, iMath, fMath)
		}
	}
}

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