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

package main

// Test ensures that abi information producer and consumer agree about the
// order of registers for inputs.  T's registers should be I0, F0, I1, F1.

import "fmt"

type P struct {
	a int8
	x float64
}

type T struct {
	d, e P
}

//go:registerparams
//go:noinline
func G(t T) float64 {

		}
	}
	return m
}

func matmult(done chan<- struct{}, A, B, C Matrix, i0, i1, j0, j1, k0, k1, threshold int) {
	di := i1 - i0
	dj := j1 - j0
	dk := k1 - k0
	if di >= dj && di >= dk && di >= threshold {
		// divide in two by y axis
		mi := i0 + di/2
		done1 := make(chan struct{}, 1)
		go matmult(done1, A, B, C, i0, mi, j0, j1, k0, k1, threshold)
		matmult(nil, A, B, C, mi, i1, j0, j1, k0, k1, threshold)

type SZ interface {}

// The I0 interface; no method is exported.
type I0 interface {
	f(x int) int  // unexported method
}

// The I1 interface; some methods are not exported.
type I1 interface {
	I0
	F(x float) float  // exported methods
	g(x int) int  // unexported method
}

// The I2 interface; all methods are exported.
type I2 interface {
	I0
	F(x float) float  // exported method

type SZ interface{}

// The I0 interface; no method is exported.
type I0 interface {
	f(x int) int	// unexported method
}

// The I1 interface; some methods are not exported.
type I1 interface {
	I0
	F(x float) float	// exported methods
	g(x int) int		// unexported method
}

// The I2 interface; all methods are exported.
type I2 interface {
	I0
	F(x float) float	// exported method

//    DEC       -10,+10      7000       8.5e-17     1.9e-17
//    IEEE      -10,+10     30000       5.0e-15     1.1e-16
//
// Larger relative error can be observed for z near 1 +i0.
// In IEEE arithmetic the peak absolute error is 5.2e-16, rms
// absolute error 1.0e-16.

// Log returns the natural logarithm of x.
func Log(x complex128) complex128 {
	return complex(math.Log(Abs(x)), Phase(x))
}

	if b.Kind != BlockIf {
		return false
	}
	// It doesn't matter how much Preds does s0 or s1 have.
	var ss0, ss1 *Block
	s0 := b.Succs[0].b
	i0 := b.Succs[0].i
	if s0.Kind != BlockPlain || !isEmpty(s0) {
		s0, ss0 = b, s0
	} else {
		ss0 = s0.Succs[0].b
		i0 = s0.Succs[0].i
	}
	s1 := b.Succs[1].b
	i1 := b.Succs[1].i
	if s1.Kind != BlockPlain || !isEmpty(s1) {
		s1, ss1 = b, s1
	} else {
		ss1 = s1.Succs[0].b

  %0 = "tfr.cast"(%arg0) : (tensor<3xf32>) -> !tfr.tensor
  %n = arith.constant 3: i32
  %split = tfr.call @tf__risc_split(%0, %n) : (!tfr.tensor, i32) -> !tfr.tensor_list
  %i0 = arith.constant 0: index
  %s0 = tfr.get_element %split[%i0] : (!tfr.tensor_list, index) -> !tfr.tensor
  %4 = "tfr.cast"(%s0) : (!tfr.tensor) -> tensor<f32>
  func.return %4 : tensor<f32>

set0 HelveticaNeue;} {\colortbl;\red255\green255\blue255;} {\*\expandedcolortbl;;} \pard\tx560\tx1120\tx1680\tx2240\tx2800\tx3360\tx3920\tx4480\tx5040\tx5600\tx6160\tx6720\pardirnatural\qc\partightenfactor0 \f0\fs32 \cf0 process \f1\i SourceSet \f0\i0 Resources}AllowLabelDropfalseC{156, 57.500000000000014}{207.5, 57.5}Rotation90StylefillD.0g0.0r0.0space9eaea0911d89d6{{9, 19}, {147, 78}}ClassShapedGraphicID.75g1r0.75spacesrgbshadowDra.0g0.0r0.0space9eaea0911d89d6{\rtf1\ansi\ansicpg1252\cocoartf1561\cocoasubrtf200...

}

// The reassociate rules "x - (z + C) -> (x - z) - C" and
// "(z + C) -x -> C + (z - x)" can optimize the following cases.
func constantFold1(i0, j0, i1, j1, i2, j2, i3, j3 int) (int, int, int, int) {
	// arm64:"SUB","ADD\t[$]2"
	// ppc64x:"SUB","ADD\t[$]2"
	r0 := (i0 + 3) - (j0 + 1)
	// arm64:"SUB","SUB\t[$]4"
	// ppc64x:"SUB","ADD\t[$]-4"
	r1 := (i1 - 3) - (j1 + 1)
	// arm64:"SUB","ADD\t[$]4"

var bx bool
var b0 = false
var b1 = true

var fx float32
var f0 = float32(0)
var f1 = float32(1)

var gx float64
var g0 = float64(0)
var g1 = float64(1)

var ix int
var i0 = 0
var i1 = 1

var jx uint
var j0 = uint(0)
var j1 = uint(1)

var cx complex64
var c0 = complex64(0)
var c1 = complex64(1)

var dx complex128
var d0 = complex128(0)