(TF_MulOp:$alpha
        $lr,
        (TF_DivOp
          (TF_SqrtOp (TF_SubOp $one, $beta2_power)),
          (TF_SubOp $one, $beta1_power)
        )
      ),
      (TF_AddV2Op:$new_m
        (TF_MulOp $beta1, (CreateTFReadVariableOp $src_op, $grad, $m_resource)),
        (TF_MulOp (TF_SubOp $one, $beta1), $grad)
      ),
      (TF_AddV2Op:$new_v

def LowerSquaredDifferenceOpOnRealTensors : Pat<
  (TF_SquaredDifferenceOp RealTensor: $lhs, RealTensor:$rhs),
  (TF_SquareOp (TF_SubOp $lhs, $rhs))>;

def LowerSquaredDifferenceOpOneComplexTensors : Pat<
  (TF_SquaredDifferenceOp ComplexTensor: $lhs, ComplexTensor:$rhs),
  (TF_MulOp (TF_SubOp:$diff $lhs, $rhs), (TF_ConjOp $diff))>;

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

    (TF_SubOp $beta, (TF_MulOp $m, $rsqrt)))>;
def ConvertBatchNormWithGlobalNormalization_2 : Pat<
  (TF_BatchNormWithGlobalNormalizationOp
    $t, $m, $v, $beta, $gamma, F32Attr:$variance_epsilon, ConstBoolAttrTrue:$scale_after_normalization),
  (TF_AddOp
    (TF_MulOp $t, (TF_MulOp:$mul (TF_RsqrtOp (TF_AddOp $v, (TF_ConstOp $variance_epsilon))), $gamma)),
    (TF_SubOp $beta, (TF_MulOp $m, $mul)))>;

            $x,
            (TF_MulOp:$multiplier
                $scale,
                (TF_RsqrtOp
                    (TF_AddV2Op $variance,
                              (TF_ConstOp $epsilon))))),
        (TF_SubOp $offset, (TF_MulOp $mean, $multiplier))),
     // We already guaranteed that the last five results have no use so it does
     // not matter what value we provide here for replacement.
     /*batch_mean=*/(replaceWithValue $x),

                         [TF_PolygammaOp, CHLO_BroadcastPolygammaOp],
                         [TF_PowOp, CHLO_BroadcastPowOp],
                         [TF_RealDivOp, CHLO_BroadcastDivOp],
                         [TF_SubOp, CHLO_BroadcastSubOp],
                         [TF_ZetaOp, CHLO_BroadcastZetaOp]] in
  def : DirectBinaryPat<fromToBinPair[0], fromToBinPair[1]>;

def LowerRightShiftSigned :

                         [MHLO_MulOp, CHLO_BroadcastMulOp, TF_MulOp],
                         [MHLO_PowOp, CHLO_BroadcastPowOp, TF_PowOp],
                         [MHLO_SubtractOp, CHLO_BroadcastSubOp, TF_SubOp],
                         [MHLO_Atan2Op, CHLO_BroadcastAtan2Op, TF_Atan2Op]] in {
  def : Pat<(fromToBinPair[0]:$result $l, $r),
            (fromToBinPair[2] $l, $r),
            [(IsNotWithinScatterRegion $result)]>;

                        (TFL_AddOp $lhs, $rhs, TFL_AF_None)>;
def LegalizeBiasAdd : Pat<
  (TF_BiasAddOp F32Tensor:$l, F32Tensor:$r, IsDataFormatNHWC:$data_format),
  (TF_AddV2Op $l, $r)>;
def LegalizeSub : Pat<(TF_SubOp $lhs, $rhs),
                      (TFL_SubOp $lhs, $rhs, TFL_AF_None)>;
def LegalizeMul : Pat<(TF_MulOp $lhs, $rhs),
                      (TFL_MulOp $lhs, $rhs, TFL_AF_None)>;

//             (TF_MulOp:$multiplier
//                 $scale,
//                 (TF_RsqrtOp
//                     (TF_AddOp $variance,
//                               (TF_ConstOp $epsilon))))),
//         (TF_SubOp $offset, (TF_MulOp $mean, $multiplier))),
//    // We already guaranteed that the last five results have no use so it does
//    // not matter what value we provide here for replacement.

  );

  let results = (outs
    Res<TF_Int64Tensor, [{A Tensor of the same shape as the input `string_tensor`.}]>:$output
  );
}

def TF_SubOp : TF_Op<"Sub", [Pure, ResultsBroadcastableShape, TF_CwiseBinary, TF_SameOperandsAndResultElementTypeResolveRef]>,
               WithBroadcastableBinOpBuilder {
  let summary = "Returns x - y element-wise.";