func.func @main(%arg0: tensor<2xf32>) -> tensor<2xf32> {
      %0 = "tf.Const"() {value = dense<1.42> : tensor<2xf32>} : () -> tensor<2xf32>
      %1 = "tf.Atan2"(%arg0, %0) : (tensor<2xf32>, tensor<2xf32>) -> tensor<2xf32>
      func.return %0 : tensor<2xf32>
    }
  })";

  TF_ASSERT_OK(LegalizeModule(kModuleWithConstParam));
}

  RANDOM_UNIFORM = 148,
  MULTINOMIAL = 149,
  GELU = 150,
  DYNAMIC_UPDATE_SLICE = 151,
  RELU_0_TO_1 = 152,
  UNSORTED_SEGMENT_PROD = 153,
  UNSORTED_SEGMENT_MAX = 154,
  UNSORTED_SEGMENT_SUM = 155,
  ATAN2 = 156,
  UNSORTED_SEGMENT_MIN = 157,
  SIGN = 158,
  BITCAST = 159,
  BITWISE_XOR = 160,
  RIGHT_SHIFT = 161,
  // All Operators start with STABLEHLO_ prefixes are subject to change

// CHECK:  return %[[RES0]] : tensor<1xi64>
}

func.func @atan2(%arg0: tensor<8xf32>, %arg1: tensor<8xf32>) -> tensor<8xf32> {
  %0 = "tf.Atan2"(%arg0, %arg1) : (tensor<8xf32>, tensor<8xf32>) -> tensor<8xf32>
  func.return %0 : tensor<8xf32>

// CHECK-LABEL: atan2
// CHECK: %[[RES0:.*]] = "tfl.atan2"(%arg0, %arg1) : (tensor<8xf32>, tensor<8xf32>) -> tensor<8xf32>

  );

  let results = (outs TFL_TensorOf<[F32, I32]>:$output);
}

def TFL_Atan2Op: TFL_Op<"atan2", [
  Pure,
  SameOperandsAndResultShape,
  SameOperandsAndResultElementType]> {

  let summary = "Atan2 operation";
  let description = [{
    The "atan2" operation computes the arctangent of y/x element-wise,
    respecting signs of the arguments.
  }];

// CHECK-DAG.       %cst = arith.constant dense<[4]> : tensor<1xi64>
// CHECK:           %[[VAL_2:.*]] = "tf.Atan2"(%[[VAL_0]], %[[VAL_1]]) : (tensor<1xf32>, tensor<4xf32>) -> tensor<4xf32>
// CHECK:           %[[VAL_3:.*]] = "tf.Atan2"(%[[VAL_1]], %[[VAL_0]]) : (tensor<4xf32>, tensor<1xf32>) -> tensor<4xf32>
// CHECK:           return %[[VAL_2]], %[[VAL_3]] : tensor<4xf32>, tensor<4xf32>

func.func @angle_c64(%arg0: tensor<complex<f32>>) -> tensor<f32> {
// CHECK: [[IMAG:%.*]] = mhlo.imag [[ARG0]]
// CHECK: [[REAL:%.*]] = mhlo.real [[ARG0]]
// CHECK: [[ATAN2:%.*]] = mhlo.atan2 [[IMAG]], [[REAL]]
  %0 = "tf.Angle"(%arg0): (tensor<complex<f32>>) -> tensor<f32>
  func.return %0 : tensor<f32>
}

//===----------------------------------------------------------------------===//

  func.return %0#0 : tensor<? x i32>
}

// CHECK-LABEL: testAtan2
func.func @testAtan2(%arg0: tensor<?xf32>, %arg1: tensor<?xf32>) -> tensor<?xf32> {
  // CHECK: "tfl.atan2"(%arg0, %arg1)
  %0 = "tfl.atan2"(%arg0, %arg1): (tensor<?xf32>, tensor<?xf32>) -> tensor<?xf32>
  func.return %0 : tensor<?xf32>
}

// -----

// CHECK-LABEL: testConv2D

    base class.

## Major Features and Improvements

*   `tf.lite`:

    *   New operations supported:
          * tf.unsortedsegmentmin op is supported.
          * tf.atan2 op is supported.
          * tf.sign op is supported.
    *   Updates to existing operations:
          * tfl.mul now supports complex32 inputs.

*   `tf.experimental.StructuredTensor`

`input` must be complex numbers of the form \\(a + bj\\), where *a*
is the real part and *b* is the imaginary part.

The argument returned by this operation is of the form \\(atan2(b, a)\\).

For example:

```
# tensor 'input' is [-2.25 + 4.75j, 3.25 + 5.75j]
tf.math.angle(input) ==> [2.0132, 1.056]
```

@compatibility(numpy)
Equivalent to np.angle.
@end_compatibility

of <code>F</code>.
A method invocation is similar but the method itself
is specified as a selector upon a value of the receiver type for
the method.
</p>

<pre>
math.Atan2(x, y)  // function call
var pt *Point
pt.Scale(3.5)     // method call with receiver pt
</pre>

<p>
If <code>f</code> denotes a generic function, it must be