MOV	ZERO, (X25)
	ADD	$8, X25
	MOV	ZERO, (X25)
	ADD	$8, X25
	MOV	ZERO, (X25)
	ADD	$8, X25
	MOV	ZERO, (X25)
	ADD	$8, X25
	MOV	ZERO, (X25)
	ADD	$8, X25
	MOV	ZERO, (X25)
	ADD	$8, X25
	MOV	ZERO, (X25)
	ADD	$8, X25
	MOV	ZERO, (X25)
	ADD	$8, X25
	MOV	ZERO, (X25)
	ADD	$8, X25
	MOV	ZERO, (X25)
	ADD	$8, X25
	MOV	ZERO, (X25)
	ADD	$8, X25
	MOV	ZERO, (X25)
	ADD	$8, X25
	MOV	ZERO, (X25)
	ADD	$8, X25

this directory:

Testing basn0g01.png: PASS (524 zero samples)
 Filter 0 was used 32 times
Testing basn0g02.png: PASS (448 zero samples)
 Filter 0 was used 32 times
Testing basn0g04.png: PASS (520 zero samples)
 Filter 0 was used 32 times
Testing basn0g08.png: PASS (3 zero samples)
 Filter 1 was used 9 times
 Filter 4 was used 23 times
Testing basn0g16.png: PASS (1 zero samples)
 Filter 1 was used 1 times

	BLT	X11, X9, zero32
loop64:
	MOV	ZERO, 0(X10)
	MOV	ZERO, 8(X10)
	MOV	ZERO, 16(X10)
	MOV	ZERO, 24(X10)
	MOV	ZERO, 32(X10)
	MOV	ZERO, 40(X10)
	MOV	ZERO, 48(X10)
	MOV	ZERO, 56(X10)
	ADD	$64, X10
	SUB	$64, X11
	BGE	X11, X9, loop64
	BEQZ	X11, done

check32:
	MOV	$32, X9
	BLT	X11, X9, check16
zero32:
	MOV	ZERO, 0(X10)
	MOV	ZERO, 8(X10)
	MOV	ZERO, 16(X10)
	MOV	ZERO, 24(X10)
	ADD	$32, X10
	SUB	$32, X11

go test -list=. ./zero
stdout ExitZero

! go test -bench=. ./zero
stdout 'panic'

# 'go test' with no args streams output without buffering. Ensure that it still
# catches a zero exit with missing output.
cd zero
! go test
stdout 'panic'
cd ../normal
go test
stdout ^ok
cd ..

# If a TestMain exits with a zero status code, 'go test' shouldn't

	for k, v = range map[K]V{zero[K](): zero[V]()} {
	}
	return
}

func RangeMapIface[K interface {
	iface
	comparable
}, V iface]() (k, v iface) {
	for k, v = range map[K]V{zero[K](): zero[V]()} {
	}
	return
}

func RangeSliceAny[V any]() (k, v any) {
	for k, v = range []V{zero[V]()} {
	}
	return
}

func RangeSliceIface[V iface]() (k any, v iface) {
	for k, v = range []V{zero[V]()} {
	}
	return

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

// Test that typed and untyped negative zero floating point constants
// are treated as equivalent to zero constants.

package main

import "math"

const zero = 0.0

func main() {
	x := -zero
	b := math.Float64bits(x)
	if b != 0 {
		panic(b)
	}
	x = -float64(zero)
	b = math.Float64bits(x)
	if b != 0 {
		panic(b)
	}
	v := x

	want complex128
}{
	// Derived from Sin(z) = -i * Sinh(i * z), G.6 #7
	{complex(zero, zero),
		complex(zero, zero)},
	{complex(zero, inf),
		complex(zero, inf)},
	{complex(zero, nan),
		complex(zero, nan)},
	{complex(1.0, inf),
		complex(inf, inf)},
	{complex(1.0, nan),
		NaN()},
	{complex(inf, zero),
		complex(nan, zero)},
	{complex(inf, 1.0),
		NaN()},
	{complex(inf, inf),
		complex(nan, inf)},

func add64(x float64) float64 {
	return x + 0
}

func testAdd64() {
	var zero float64
	inf := 1.0 / zero
	negZero := -1 / inf
	if 1/add64(negZero) != inf {
		panic("negZero+0 != posZero (64 bit)")
	}
}

//go:noinline
func sub64(x float64) float64 {
	return x - 0
}

func testSub64() {
	var zero float64
	inf := 1.0 / zero
	negZero := -1 / inf
	if 1/sub64(negZero) != -inf {

  @MapFeature.Require(ALLOWS_NULL_KEYS)
  @CollectionSize.Require(absent = ZERO)
  public void testCreateWithNullKeySupported() {
    initMapWithNullKey();
    expectContents(createArrayWithNullKey());
  }

  @MapFeature.Require(absent = ALLOWS_NULL_KEYS)
  @CollectionSize.Require(absent = ZERO)
  public void testCreateWithNullKeyUnsupported() {
    try {
      initMapWithNullKey();

// Issue 11674: cmd/compile: does not diagnose constant division by
// zero

package p

const x complex64 = 0
const y complex128 = 0

var _ = x / 1e-20
var _ = x / 1e-50   // GC_ERROR "division by zero"
var _ = x / 1e-1000 // GC_ERROR "division by zero"
var _ = x / 1e-20i
var _ = x / 1e-50i   // GC_ERROR "division by zero"
var _ = x / 1e-1000i // GC_ERROR "division by zero"

var _ = x / 1e-45 // smallest positive float32