test32(float32(m1100p149), f32(m1100p149))

	test64(float64(m0000p1074), f64(m0000p1074))
	test64(float64(m1000p1074), f64(m1000p1074))
	test64(float64(m1001p1074), f64(m1001p1074))
	test64(float64(m1011p1074), f64(m1011p1074))
	test64(float64(m1100p1074), f64(m1100p1074))
}

func f32(x float64) float32 { return float32(x) }
func f64(x float64) float64 { return float64(x) }

func test32(a, b float32) {

package main

import "fmt"

const (
    F32 = 0.00999999977648258209228515625
    F64 = 0.01000000000000000020816681711721685132943093776702880859375
)

var F = float64(float32(0.01))

func main() {
	// 0.01 rounded to float32 then to float64 is F32.
	// 0.01 represented directly in float64 is F64.
	if F != F32 {
		panic(fmt.Sprintf("F=%.1000g, want %.1000g", F, F32))
	}

  func.return %0 : tensor<4xcomplex<f64>>
}

func.func @f16() -> tensor<4xf16> {
  // CHECK-LABEL: @f16
  // CHECK: value = dense<[1.000000e+00, 2.000000e+00, 3.000000e+00, 4.000000e+00]> : tensor<4xf16>

	_ = complex(f32, f32)
	_ = complex(f32, 1)
	_ = complex(f32, 1.0)
	_ = complex(f32, 'a')
	_ = complex(f64, f64)
	_ = complex(f64, 1)
	_ = complex(f64, 1.0)
	_ = complex(f64, 'a')
	_ = complex(f32 /* ERROR "mismatched types" */ , f64)
	_ = complex(f64 /* ERROR "mismatched types" */ , f32)
	_ = complex(1, 1)
	_ = complex(1, 1.1)
	_ = complex(1, 'a')
	complex /* ERROR "not used" */ (1, 2)

  func.return %0 : tensor<4xcomplex<f64>>
}

func.func @f16() -> tensor<4xf16> {
  // CHECK-LABEL: @f16
  // CHECK: value = dense<[1.000000e+00, 2.000000e+00, 3.000000e+00, 4.000000e+00]> : tensor<4xf16>

// CHECK-SAME: (%[[ARG0:.+]]: tensor<f64>)
func.func @min_with_f64_max_val(%arg0 : tensor<f64>) -> (tensor<f64>, tensor<f64>) {
  %f64_max = arith.constant dense<1.7976931348623157E+308> : tensor<f64>
  %0 = "tfl.minimum"(%arg0, %f64_max) : (tensor<f64>, tensor<f64>) -> tensor<f64>
  %1 = "tfl.minimum"(%f64_max, %arg0) : (tensor<f64>, tensor<f64>) -> tensor<f64>
  func.return %0, %1 : tensor<f64>, tensor<f64>
  // CHECK: return %[[ARG0]], %[[ARG0]]

    func.func @main() -> tensor<?xi32> attributes {tf.entry_function = {control_outputs = "", inputs = "i,j", outputs = "identity_RetVal"}} {
      %0 = mhlo.constant dense<1.000000e+00> : tensor<f64>
      %1 = mhlo.convert %0 : (tensor<f64>) -> tensor<i64>
      %2 = mhlo.reshape %1 : (tensor<i64>) -> tensor<1xi64>
      %3 = "mhlo.dynamic_iota"(%2) {iota_dimension = 0 : i64} : (tensor<1xi64>) -> tensor<?xi32>

    %1:2 = tf_executor.island(%0#1) wraps "tf.Const"() {value = dense<3.000000e+00> : tensor<f32>} : () -> tensor<f32>
    %2:2 =  tf_executor.island(%1#1) wraps "tf.Const"() {value = dense<4.000000e+00> : tensor<f64>} : () -> tensor<f64>
    tf_executor.fetch
  }
  func.return

    }
  }
}
versions {
  producer: 216
}

# CHECK-NO-SUBTYPE: func @main(%arg0: tensor<i32>, %arg1: tensor<!tf_type.variant>, %arg2: tensor<i8>, %arg3: tensor<f64>, %arg4: tensor<!tf_type.resource>) -> (tensor<i32>, tensor<!tf_type.variant>, tensor<i8>, tensor<f64>, tensor<!tf_type.resource>)

	// ppc64x/power9:"FMOVS\t[$]f32\\.42440000\\(SB\\)"
	// ppc64x/power10:"XXSPLTIDP\t[$]1111752704,"
	return 49.0
}

func Float64Constant() float64 {
	// ppc64x/power8:"FMOVD\t[$]f64\\.4048800000000000\\(SB\\)"
	// ppc64x/power9:"FMOVD\t[$]f64\\.4048800000000000\\(SB\\)"
	// ppc64x/power10:"XXSPLTIDP\t[$]1111752704,"
	return 49.0
}

func Float32DenormalConstant() float32 {
	// ppc64x:"FMOVS\t[$]f32\\.00400000\\(SB\\)"