}
	return z

  // CHECK: %[[ARG_TRANSPOSE:[0-9]*]] = "tf.Transpose"(%arg0, %[[ARG_PERM]])
  // CHECK: %[[TANH:[0-9]*]] = "tf.Tanh"(%[[ARG_TRANSPOSE]]) {{.*}} tensor<1x8x4x4xf32>
  // CHECK: %[[ADD:[0-9]*]] = "tf.AddV2"(%[[TANH]], %[[TANH]]) {{.*}} tensor<1x8x4x4xf32>
  // CHECK: return %[[ADD]]

  %0 = "tf.Tanh"(%arg0) : (tensor<1x4x4x8xf32>) -> tensor<1x4x4x8xf32>

  elif act == 'TANH':
    return tf.raw_ops.Tanh(x=res)
  else:
    return res


@tf.RegisterGradient('NewConv2D')
def _conv_add_relu_grad(op: ops.Operation, grad):
  act = op.get_attr('act')
  y = op.outputs[0]
  if act == 'RELU':
    grad = gen_nn_ops.relu_grad(grad, y)
  elif act == 'RELU6':
    grad = gen_nn_ops.relu6_grad(grad, y)
  elif act == 'TANH':
    y = math_ops.conj(y)

 Const 7
 GreaterEqual 2
 MatMul 1
 Mul 5
 Select 2
 Sigmoid 3
 Snapshot 1
 Split 1
 Tanh 2
cluster 22 size 28
 Add 3
 BiasAdd 1
 Cast 1
 ConcatV2 1
 Const 5
 GreaterEqual 1
 MatMul 1
 Mul 5
 Select 3
 Sigmoid 3
 Snapshot 1
 Split 1
 Tanh 2
cluster 23 size 423
 Add 12
 AddN 28
 BiasAddGrad 6
 BroadcastGradientArgs 12
 Cast 12

  // CHECK: %[[RES_PERM:.*]] = "tf.Const"() <{value = dense<[0, 3, 1, 2]> : tensor<4xi32>}>
  // CHECK: %[[TANH:[0-9]*]] = "tf.Tanh"(%arg0) {{.*}} tensor<1x4x4x8xf32>
  // CHECK: %[[RES_TRANSPOSE:[0-9]*]] = "tf.Transpose"(%[[TANH]], %[[RES_PERM]]) {{.*}} tensor<1x8x4x4xf32>
  // CHECK: return %[[RES_TRANSPOSE]]

  %0 = "tf.Const"() {value = dense<[0, 3, 1, 2]> : tensor<4xi32>} : () -> tensor<4xi32>

			t.Errorf("Tan(%g) = %g, want %g", -v.in, f, -v.want)
		}
	}
}
func TestTanh(t *testing.T) {
	for i := 0; i < len(vc); i++ {
		if f := Tanh(vc[i]); !cSoclose(tanh[i], f, 2e-15) {
			t.Errorf("Tanh(%g) = %g, want %g", vc[i], f, tanh[i])
		}
	}
	for _, v := range tanhSC {
		if f := Tanh(v.in); !cAlike(v.want, f) {
			t.Errorf("Tanh(%g) = %g, want %g", v.in, f, v.want)
		}

DATA tanhtab<>+112(SB)/8, $-.218623539150173528E-01
DATA tanhtab<>+120(SB)/8, $-.115062908917949451E-01
GLOBL tanhtab<>+0(SB), RODATA, $128

// Tanh returns the hyperbolic tangent of the argument.
//
// Special cases are:
//      Tanh(±0) = ±0
//      Tanh(±Inf) = ±1
//      Tanh(NaN) = NaN
// The algorithm used is minimax polynomial approximation using a table of
// polynomial coefficients determined with a Remez exchange algorithm.

// CHECK-NEXT:         builtin_options_type: SequenceRNNOptions,
// CHECK-NEXT:         builtin_options: {
// CHECK-NEXT:           time_major: true,
// CHECK-NEXT:           fused_activation_function: TANH
// CHECK-NEXT:         }
// CHECK-NEXT:       } ],
// CHECK-NEXT:       name: "main"
// CHECK-NEXT:     } ],
// CHECK-NEXT:     description: "MLIR Converted.",
// CHECK-NEXT:     buffers: [ {
// CHECK-EMPTY:

                               tf.function(gen_mnist_ops.new_conv2d),
                               ops_defs._composite_conv_add_relu, kwargs)

  def test_new_conv2d_tanh(self):
    self.skipTest('Fix tanh gradients')
    input_ = tf.random.uniform([1, 4, 4, 1])
    filter_ = tf.random.uniform([2, 2, 1, 8])
    bias = tf.zeros([8])
    kwargs = {
        'input_': input_,
        'filter_': filter_,
        'bias': bias,

    %5, %6, %7, %8,
    %9, %9, %9,
    %10, %11,
    %10, %10,
    %9, %9,
    %recurrent_input, %cell_input,
    %9, %9, %9, %9) {
      cell_clip = 1.000000e+01 : f32,
      fused_activation_function = "TANH",
      proj_clip = 0.000000e+00 : f32,
      time_major = false} : (
        tensor<1x2x3xf32>,
        tensor<1x1xf32>, tensor<1x1xf32>, tensor<1x1xf32>, tensor<1x1xf32>,