package main

import (
	"fmt"
	"math"
	"log"
	"errors"
	"io"
)

import (
	"fmt"

	"math"

	"log"

	"errors"

	"io"
)

// We reset the line numbering to test that
// the formatting works independent of line directives
//line :19

import (
	"fmt"
	"math"
	"log"
	"errors"
	"io"

	"fmt"

	"math"

	"log"

	"errors"

	"io"
)

	{1.0, 1.1, -1},
	{1.1, 1.1, 0},
	{1.1, 1.0, +1},
	{math.Inf(1), math.Inf(1), 0},
	{math.Inf(-1), math.Inf(-1), 0},
	{math.Inf(-1), 1.0, -1},
	{1.0, math.Inf(-1), +1},
	{math.Inf(1), 1.0, +1},
	{1.0, math.Inf(1), -1},
	{math.NaN(), math.NaN(), 0},
	{0.0, math.NaN(), +1},
	{math.NaN(), 0.0, -1},
	{math.NaN(), math.Inf(-1), -1},
	{math.Inf(-1), math.NaN(), +1},
	{0.0, 0.0, 0},
	{negzero, negzero, 0},

	{NaN(),
		NaN()},
}
var vcIsNaNSC = []complex128{
	complex(math.Inf(-1), math.Inf(-1)),
	complex(math.Inf(-1), math.NaN()),
	complex(math.NaN(), math.Inf(-1)),
	complex(0, math.NaN()),
	complex(math.NaN(), 0),
	complex(math.Inf(1), math.Inf(1)),
	complex(math.Inf(1), math.NaN()),
	complex(math.NaN(), math.Inf(1)),
	complex(math.NaN(), math.NaN()),
}
var isNaNSC = []bool{
	false,
	false,
	false,

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

package main

import "math"

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

	case im == 0 && (math.IsInf(re, 0) || math.IsNaN(re)):
		return complex(math.NaN(), -im*math.Copysign(0, re))
	case math.IsInf(im, 0):
		switch {
		case re == 0:
			return complex(math.Inf(1), -re*math.Copysign(0, im))
		case math.IsInf(re, 0) || math.IsNaN(re):
			return complex(math.Inf(1), math.NaN())
		}
	case re == 0 && math.IsNaN(im):
		return complex(math.NaN(), 0)
	}

package main

import (
	"errors"
	"fmt"
	"io"
	"log"
	"math"
)

import (
	"fmt"

	"math"

	"log"

	"errors"

	"io"
)

// We reset the line numbering to test that
// the formatting works independent of line directives
//line :19

import (
	"errors"
	"fmt"
	"io"
	"log"
	"math"

	"fmt"

	"math"

	"log"

	"errors"

	"io"
)

import (

		}
		if real(x) < 0 {
			return complex(0, math.Copysign(math.Sqrt(-real(x)), imag(x)))
		}
		return complex(math.Sqrt(real(x)), imag(x))
	} else if math.IsInf(imag(x), 0) {
		return complex(math.Inf(1.0), imag(x))
	}
	if real(x) == 0 {
		if imag(x) < 0 {
			r := math.Sqrt(-0.5 * imag(x))
			return complex(r, -r)
		}
		r := math.Sqrt(0.5 * imag(x))
		return complex(r, r)
	}
	a := real(x)

	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")
	}

	switch re, im := real(x), imag(x); {
	case math.IsInf(re, 0):
		switch {
		case re > 0 && im == 0:
			return x
		case math.IsInf(im, 0) || math.IsNaN(im):
			if re < 0 {
				return complex(0, math.Copysign(0, im))
			} else {
				return complex(math.Inf(1.0), math.NaN())
			}
		}
	case math.IsNaN(re):
		if im == 0 {
			return complex(math.NaN(), im)
		}
	}
	r := math.Exp(real(x))
	s, c := math.Sincos(imag(x))

pkg math (linux-amd64-cgo), const MinInt = -9223372036854775808
pkg math (linux-arm), const MaxInt = 2147483647
pkg math (linux-arm), const MaxUint = 4294967295
pkg math (linux-arm), const MinInt = -2147483648
pkg math (linux-arm-cgo), const MaxInt = 2147483647
pkg math (linux-arm-cgo), const MaxUint = 4294967295
pkg math (linux-arm-cgo), const MinInt = -2147483648
pkg math (netbsd-386), const MaxInt = 2147483647