type (
	Integer interface{ ~int|~int8|~int16|~int32|~int64 }
	Unsigned interface{ ~uint|~uint8|~uint16|~uint32|~uint64 }
	Floats interface{ ~float32|~float64 }
	Complex interface{ ~complex64|~complex128 }
	Number interface{ Integer|Unsigned|Floats|Complex }
	Ordered interface{ Integer|Unsigned|Floats|~string }

	_ interface{ Number | error /* ERROR "cannot use error in union" */ }

// run

// Copyright 2021 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package main

var p0exp = S1{
	F1: complex(float64(2.3640607624715027), float64(-0.2717825524109192)),
	F2: S2{F1: 9},
	F3: 103050709,
}

type S1 struct {
	F1 complex128
	F2 S2
	F3 uint64
}

type S2 struct {
	F1 uint64
	F2 empty
}

// errorcheck

// Copyright 2016 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package main

		panic("unreachable")
	}
	a := s.Sizeof(T) // may be 0 or negative
	// spec: "For a variable x of any type: unsafe.Alignof(x) is at least 1."
	if a < 1 {
		return 1
	}
	// complex{64,128} are aligned like [2]float{32,64}.
	if isComplex(T) {
		a /= 2
	}
	if a > s.MaxAlign {
		return s.MaxAlign
	}
	return a
}

func (s *gcSizes) Offsetsof(fields []*Var) []int64 {
	offsets := make([]int64, len(fields))

           AbstractTensorHandle* const y, AbstractTensorHandle** z,
           const char* name = nullptr, const char* raw_device_name = nullptr);

// Returns the complex conjugate of a complex number.
Status Conj(AbstractContext* ctx, AbstractTensorHandle* const input,
            AbstractTensorHandle** output, const char* name = nullptr,
            const char* raw_device_name = nullptr);

			return nil, err
		}
		n.IsComplex = true
		n.simplifyComplex()
		return n, nil
	}
	// Imaginary constants can only be complex unless they are zero.
	if len(text) > 0 && text[len(text)-1] == 'i' {
		f, err := strconv.ParseFloat(text[:len(text)-1], 64)
		if err == nil {
			n.IsComplex = true
			n.Complex128 = complex(0, f)
			n.simplifyComplex()
			return n, nil
		}
	}

	return 5, 7
}

func appendArgs() ([]string, string) {
	return []string{"foo"}, "bar"
}

func appendMultiArgs() ([]byte, byte, byte) {
	return []byte{'a', 'b'}, '1', '2'
}

func main() {
	if c := complex(complexArgs()); c != 5+7i {
		panic(c)
	}

	if s := append(appendArgs()); len(s) != 2 || s[0] != "foo" || s[1] != "bar" {
		panic(s)
	}

// Use of this source code is governed by a BSD-style
// 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"

		return cmp.Compare(aVal.String(), bVal.String())
	case reflect.Float32, reflect.Float64:
		return cmp.Compare(aVal.Float(), bVal.Float())
	case reflect.Complex64, reflect.Complex128:
		a, b := aVal.Complex(), bVal.Complex()
		if c := cmp.Compare(real(a), real(b)); c != 0 {
			return c
		}
		return cmp.Compare(imag(a), imag(b))
	case reflect.Bool:
		a, b := aVal.Bool(), bVal.Bool()
		switch {
		case a == b:
			return 0

// Copyright 2022 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package main

// #include <complex.h>
import "C"

//export exportComplex64
func exportComplex64(v complex64) complex64 {
	return v
}

//export exportComplex128
func exportComplex128(v complex128) complex128 {
	return v
}

//export exportComplexfloat