// Partially supported in TFLite, treated as passthrough IdentityOp
def ConvertCheckNumerics : Pat<(TF_CheckNumericsOp $arg, $msg), (TF_IdentityOp $arg)>;
def ConvertSnapshot : Pat<(TF_SnapshotOp $arg), (TF_IdentityOp $arg)>;
def ConvertStopGradient : Pat<(TF_StopGradientOp $arg), (TF_IdentityOp $arg)>;
def ConvertPlaceholderWithDefault : Pat<(TF_PlaceholderWithDefaultOp $arg), (TF_IdentityOp $arg)>;

def LegalizeFill : Pat<(TF_FillOp $arg, $value), (TFL_FillOp $arg, $value)>;

def LegalizeFloor : Pat<(TF_FloorOp $arg), (TFL_FloorOp $arg)>;

def LegalizeLeakyRelu : Pat<(TF_LeakyReluOp $arg, F32Attr:$a),
                            (TFL_LeakyReluOp $arg, $a)>;

def LegalizeLog : Pat<(TF_LogOp $arg), (TFL_LogOp $arg)>;

def LegalizeLog1p : Pat<
  (TF_Log1pOp F32Tensor:$arg),

def LogicalNotOfGreater : Pat<
  (TF_LogicalNotOp:$src (TF_GreaterOp $arg0, $arg1)),
  (TF_LessEqualOp:$dest $arg0, $arg1), [], [(CopyAttrs $src, $dest)]>;

def LogicalNotOfGreaterEqual : Pat<
  (TF_LogicalNotOp:$src (TF_GreaterEqualOp $arg0, $arg1)),
  (TF_LessOp:$dest $arg0, $arg1), [], [(CopyAttrs $src, $dest)]>;

def LogicalNotOfLess : Pat<(
  TF_LogicalNotOp:$src (TF_LessOp $arg0, $arg1)),

  def : Pat<(pair[0] I1Tensor:$l, I1Tensor:$r), (pair[2] $l, $r)>;
  def : Pat<(pair[1] I1Tensor:$l, I1Tensor:$r, $broadcast_dimensions),
            (pair[2] $l, $r),
            [(IsLegalNumpyRankedBroadcast $l, $r, $broadcast_dimensions)]>;
}

def : Pat<(MHLO_ShiftRightArithmeticOp $l, $r), (TF_RightShiftOp $l, $r)>;
def : Pat<(CHLO_BroadcastShiftRightArithmeticOp $l, $r,

			f:   func() { Info("Hello") },
			pat: timePattern + "\tinfo\tHello",
		},
		{
			f:   func() { Infof("Hello") },
			pat: timePattern + "\tinfo\tHello",
		},
		{
			f:   func() { Infof("%s", "Hello") },
			pat: timePattern + "\tinfo\tHello",
		},
		{
			f:   func() { Warn("Hello") },
			pat: timePattern + "\twarn\tHello",
		},
		{
			f:   func() { Warnf("Hello") },
			pat: timePattern + "\twarn\tHello",
		},
		{

                  ] in {
 def : Pat<(Mapping[0] MHLO_AnyTensor:$input),
           (Mapping[1] $input)>;
}

def : Pat<(TF_AngleOp $x), (MHLO_Atan2Op (MHLO_ImagOp $x), (MHLO_RealOp $x))>;

// TODO(bixia): Lower with Truncate=True for floating point value conversions.
def : Pat<(TF_CastOp $arg, ConstBoolAttrFalse), (MHLO_ConvertOp $arg)>;

def LiftBatchMatMul : Pat<
  (TF_BatchMatMulV2Op:$res $x, $y, $adj_x, $adj_y, $grad_x, $grad_y),
  (LiftAsTFPartitionedCall<"composite_batch_matmul_fn">
    (ArgumentList $x, $y),
    (ResultList $res),
    (NamedAttributeList
      (NamedAttr<"adj_x"> $adj_x),
      (NamedAttr<"adj_y"> $adj_y))),
  [(IsNotInLiftedFunc $res)], [], (addBenefit 1)>;

def LiftEinsum : Pat<
  (TF_EinsumOp:$res $input, $equation),

//===----------------------------------------------------------------------===//
// Pattern rules for lifting ops as functions
//===----------------------------------------------------------------------===//

def LiftConv : Pat<
  (StableHLO_ConvolutionOp:$res $lhs, $rhs, $window_strides, $padding,
      $lhs_dilation, $rhs_dilation, $window_reversal, $dimension_numbers,
      $feature_group_count, $batch_group_count, $precision_config),

			pat: timePattern + "\tdebug\ttestScope\tHello",
		},

		{
			f:   func() { s.Info("Hello") },
			pat: timePattern + "\tinfo\ttestScope\tHello",
		},
		{
			f:   func() { s.Infof("Hello") },
			pat: timePattern + "\tinfo\ttestScope\tHello",
		},
		{
			f:   func() { s.Infof("%s", "Hello") },
			pat: timePattern + "\tinfo\ttestScope\tHello",
		},

		{
			f:   func() { s.Warn("Hello") },

	var idx routingIndex
	for i, pat := range patterns {
		got := indexConflicts(pat, &idx)
		want := trueConflicts(pat, patterns[:i])
		if !slices.Equal(got, want) {
			t.Fatalf("%q:\ngot  %q\nwant %q", pat, got, want)
		}
		idx.addPattern(pat)
	}
}

func trueConflicts(pat *pattern, pats []*pattern) []string {
	var s []string
	for _, p := range pats {
		if pat.conflictsWith(p) {
			s = append(s, p.String())