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

package rand

func GetNormalDistributionParameters() (float64, [128]uint32, [128]float32, [128]float32) {
	return rn, kn, wn, fn
}

func GetExponentialDistributionParameters() (float64, [256]uint32, [256]float32, [256]float32) {
	return re, ke, we, fe

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

// Test that nil checks are removed.
// Optimization is enabled.

package p

func f5(p *float32, q *float64, r *float32, s *float64) float64 {
	x := float64(*p) // ERROR "generated nil check"
	y := *q          // ERROR "generated nil check"
	*r = 7           // ERROR "removed nil check"
	*s = 9           // ERROR "removed nil check"
	return x + y

#include "mlir/IR/Types.h"  // from @llvm-project

namespace mlir::quant::stablehlo {

// Returns true if the type or its element type is a float type with bit_width
// > 16.
bool IsLargeFloatType(Type type);

// Converts large float type to bfloat16. Otherwise returns original type.
Type ToBfloat16Type(Type type);

}  // namespace mlir::quant::stablehlo

// itself, passes the rest on to strconv.ParseFloat.
func myatof32(s string) (f float32, ok bool) {
	if mant, exp, ok := strings.Cut(s, "p"); ok {
		n, err := strconv.Atoi(mant)
		if err != nil {
			println("bad n", mant)
			return 0, false
		}
		e, err1 := strconv.Atoi(exp)
		if err1 != nil {
			println("bad p", exp)
			return 0, false
		}
		return float32(float64(n) * pow2(e)), true
	}
	f64, err1 := strconv.ParseFloat(s, 32)

	BeginFcn()
	c0 := StructF2S0{F0: ArrayF2S1E1{New_3(float64(-0.4418990509835844))}}
	c1 := ArrayF2S2E1{StructF2S1{ /* _: "񊶿(z̽|" */ F1: "􂊇񊶿"}}
	c2 := int16(4162)
	c3 := float32(-7.667096e+37)
	c4 := int64(3202175648847048679)
	var p0 ArrayF2S0E0
	p0 = ArrayF2S0E0{}
	var p1 uint8
	p1 = uint8(57)
	var p2 uint16
	p2 = uint16(10920)
	var p3 float64
	p3 = float64(-1.597256501942112)
	Mode = ""
	// 5 returns 4 params

		if i > 7 {
			dst.gp_regs[i+6] = uint64(src.Ints[i])
		} else {
			dst.gp_regs[i+3] = uint64(src.Ints[i])
		}
	}
	// Fprs F1..F13 are used to pass float arguments in registers on PPC64
	for i := 0; i < 12; i++ {
		dst.fp_regs[i+1] = math.Float64frombits(src.Floats[i])
	}

}

func loadRegArgs(dst *abi.RegArgs, src *sigcontext) {
	// Gprs R3..R10, R14..R17 are used to pass int arguments in registers on PPC64

type I interface{}

const (
	// assume all types behave similarly to int8/uint8
	Int8   int8  = 101
	Minus1 int8  = -1
	Uint8  uint8 = 102
	Const        = 103

	Float32    float32 = 104.5
	Float64    float64 = 105.5
	ConstFloat         = 106.5
	Big        float64 = 1e300

	String = "abc"
	Bool   = true
)

var (
	a1 = Int8 * 100              // ERROR "overflow|cannot convert"
	a2 = Int8 * -1               // OK

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

package main

func f1() (x int, y float64) {
	return
}

func f2(x int, y float64) {
	return
}

func main() {
	f2(f1()) // this should be a legal call
}

/*
bug080.go:12: illegal types for operand: CALL
	(<int32>INT32)
	({<x><int32>INT32;<y><float32>FLOAT32;})

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

// cmd/compile erroneously rejected conversions of constant values
// between int/float and complex types.

package p

const (
	_ = int(complex64(int(0)))
	_ = float64(complex128(float64(0)))

	_ = int8(complex128(1000)) // ERROR "overflow|cannot convert"

		x := float64(j) * float64(wn[i])
		if absInt32(j) < kn[i] {
			// This case should be hit better than 99% of the time.
			return x
		}

		if i == 0 {
			// This extra work is only required for the base strip.
			for {
				x = -math.Log(r.Float64()) * (1.0 / rn)
				y := -math.Log(r.Float64())
				if y+y >= x*x {
					break
				}
			}
			if j > 0 {
				return rn + x
			}
			return -rn - x
		}