_ = complex(f64, f32) // ERROR "complex"
	_ = complex(f32, F32) // ERROR "complex"
	_ = complex(F32, f32) // ERROR "complex"
	_ = complex(f64, F64) // ERROR "complex"
	_ = complex(F64, f64) // ERROR "complex"

	_ = complex(F1()) // ERROR "not enough arguments"
	_ = complex(F3()) // ERROR "too many arguments"

	_ = complex() // ERROR "not enough arguments"

	c128 = complex(f32, f32) // ERROR "cannot use"

	VCVT_NE_F64_F32:   "VCVT.NE.F64.F32",
	VCVT_CS_F64_F32:   "VCVT.CS.F64.F32",
	VCVT_CC_F64_F32:   "VCVT.CC.F64.F32",
	VCVT_MI_F64_F32:   "VCVT.MI.F64.F32",
	VCVT_PL_F64_F32:   "VCVT.PL.F64.F32",
	VCVT_VS_F64_F32:   "VCVT.VS.F64.F32",
	VCVT_VC_F64_F32:   "VCVT.VC.F64.F32",
	VCVT_HI_F64_F32:   "VCVT.HI.F64.F32",
	VCVT_LS_F64_F32:   "VCVT.LS.F64.F32",
	VCVT_GE_F64_F32:   "VCVT.GE.F64.F32",

    tf_device.return %arg0, %arg1, %arg2, %arg3, %arg4 : tensor<i1>, tensor<i32>, tensor<i64>, tensor<f32>, tensor<f64>
  // CHECK-NEXT: }, {
  }, {
    // CHECK-NEXT: tf_device.return
    tf_device.return
  // CHECK-NEXT: }) : () -> (tensor<i1>, tensor<i64>, tensor<f64>)
  }) : () -> (tensor<i1>, tensor<i32>, tensor<i64>, tensor<f32>, tensor<f64>)

// RUN: flatbuffer_translate -mlir-to-tflite-flatbuffer %s -emit-select-tf-ops -o - | flatbuffer_to_string - | FileCheck %s

func.func @main(tensor<4xcomplex<f64>>, tensor<4xcomplex<f64>>) -> tensor<4xcomplex<f64>> {
^bb0(%arg0: tensor<4xcomplex<f64>>, %arg1: tensor<4xcomplex<f64>>):
// CHECK:  {
// CHECK-NEXT:  version: 3,
// CHECK-NEXT:  operator_codes: [ {
// CHECK-NEXT:    deprecated_builtin_code: 32,
// CHECK-NEXT:    custom_code: "FlexAdd",

	}
	if u128 != ju128 {
		panic("u128 != ju128")
	}
	if f32 != if32 {
		panic("f32 != if32")
	}
	if f32 != jf32 {
		panic("f32 != jf32")
	}
	if f64 != if64 {
		panic("f64 != if64")
	}
	if f64 != jf64 {
		panic("f64 != jf64")
	}
	if c128 != ic128 {
		panic("c128 != ic128")
	}
	if c128 != jc128 {
		panic("c128 != jc128")
	}
	if s != is {
		panic("s != is")
	}

		case tf64*100 + tu32:
			f64 = float64(v); u32 = uint32(f64); w = big(u32)
		case tf64*100 + ti64:
			f64 = float64(v); i64 = int64(f64); w = big(i64)
		case tf64*100 + tu64:
			f64 = float64(v); u64 = uint64(f64); w = big(u64)
		case tf64*100 + tf32:
			f64 = float64(v); f32 = float32(f64); w = big(f32)
		case tf64*100 + tf64:
			f64 = float64(v); f64 = float64(f64); w = big(f64)
		}

func.func @mirror_pad(%arg0: tensor<2x3xcomplex<f64>>) -> tensor<4x7xcomplex<f64>> {
  %0 = mhlo.constant dense<[[1, 1], [2, 2]]> : tensor<2x2xi32>
  // NO_FALLBACK: tf.MirrorPad
  // SUPPORTED_FALLBACK_DEVICE-NOT: tf.MirrorPad
  // UNSPECIFIED_FALLBACK_DEVICE: tf.MirrorPad
  // UNSUPPORTED_FALLBACK_DEVICE: tf.MirrorPad
  %1 = "tf.MirrorPad"(%arg0, %0) {mode = "SYMMETRIC"} : (tensor<2x3xcomplex<f64>>, tensor<2x2xi32>) -> tensor<4x7xcomplex<f64>>

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

//go:build gc

#include "textflag.h"

// try to run "vmov.f64 d0, d0" instruction
TEXT ·useVFPv1(SB),NOSPLIT,$0
	WORD $0xeeb00b40	// vmov.f64 d0, d0
	RET

// try to run VFPv3-only "vmov.f64 d0, #112" instruction
TEXT ·useVFPv3(SB),NOSPLIT,$0
	WORD $0xeeb70b00	// vmov.f64 d0, #112
	RET

// try to run ARMv6K (or above) "ldrexd" instruction
TEXT ·useARMv6K(SB),NOSPLIT,$32

	//	chki64(int64(f32), 0)
	//	chki64(int64(f64), 0)


	chku8(uint8(i8), ci8&0xff)
	chku8(uint8(i16), ci16&0xff)
	chku8(uint8(i32), ci32&0xff)
	chku8(uint8(i64), ci64&0xff)
	chku8(uint8(u8), cu8&0xff)
	chku8(uint8(u16), cu16&0xff)
	chku8(uint8(u32), cu32&0xff)
	chku8(uint8(u64), cu64&0xff)
	//	chku8(uint8(f32), 0)
	//	chku8(uint8(f64), 0)

	chku16(uint16(i8), ci8&0xffff)

	f32 := types.Types[types.TFLOAT32]
	f64 := types.Types[types.TFLOAT64]
	c64 := types.Types[types.TCOMPLEX64]
	c128 := types.Types[types.TCOMPLEX128]
	ft := mkFuncType(nil,
		[]*types.Type{
			i8, i16, i32, i64,
			f32, f32, f64, f64,
			i8, i16, i32, i64,
			f32, f32, f64, f64,
			c128, c128, c128, c128, c64,
			i8, i16, i32, i64,
			i8, i16, i32, i64},
		[]*types.Type{i32, f64, f64})
	exp := makeExpectedDump(`