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",
		},
		{

//===----------------------------------------------------------------------===//
// 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),

	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())

  "$_builder.getStringAttr("# values #")">;

def LegalizeTensorListReserve : Pat<(TF_TensorListReserveOp:$tf_op $shape, $num_elements),
    (TFL_CustomOp (Size2InputRange $shape, $num_elements),
   (CreateStringAttr<"\"TensorListReserve\"">), (CustomOptions $tf_op))>;

def LegalizeTensorListStack : Pat<(TF_TensorListStackOp $input, $shape, $unused_num_elements),
    (TFL_CustomOp (Size2InputRange $input, $shape),

    @Issue("GRADLE-3418")
    def "doesn't match if pre and suf are the same"() {
        def step = new HasPrefixAndSuffixPatternStep("pat", "pat", CASE_SENSITIVE)

        expect:
        step.matches("patpat")
        step.matches("pat-pat")
        !step.matches("")
        !step.matches("pat")
    }

    [(IsNchwLayoutOp $attrs)]>;

def LegalizeCompositeExactAtenGELU : Pat<
        (MHLO_CompositeOp:$composite
          (variadic $inputs),
          ConstantStrAttr<StrAttr, "aten.gelu.default">, $attrs, $_, $_),
        (TFL_GeluOp $inputs, ConstBoolAttrFalse),
        [(IsStrCompositeAttribute<"approximate", "none"> $attrs)]>;

def LegalizeCompositeApproximateAtenGELU : Pat<
        (MHLO_CompositeOp:$composite
          (variadic $inputs),

def RemoveConstIdentityOp : Pat<
  (TF_IdentityOp (TF_ConstOp $input)),
  (TF_ConstOp $input)>;

// Standardizes the Max and Min ops by moving constant value to rhs. This will
// make it easier to create Relu1 matching patterns.
def SwapMaximumOperands : Pat<
  (TF_MaximumOp (TF_ConstOp:$cst $cst_val), $input),
  (TF_MaximumOp $input, $cst)>;

def SwapMinimumOperands : Pat<

def LiftGather : Pat<
  (TF_GatherV2Op:$res $params, $indices, $axis, $batch_dims),
  (LiftAsTFPartitionedCall<"composite_gather_fn">
    (ArgumentList $params, $indices, $axis),
    (ResultList $res),
    (NamedAttributeList
      (NamedAttr<"batch_dims"> $batch_dims))),
  [(IsNotInLiftedFunc $res), (IsConstTensor $params)], [], (addBenefit 1)>;

def LiftConv3D : Pat<

def ConvertArithConstToTfConst : Pat<
  (Arith_ConstantOp:$res DenseElementsAttr:$value),
  (TF_ConstOp $value),
  [(AnyStaticShapeTensor $res)]>;

// Remove CheckNumerics op
def RemoveCheckNumerics : Pat<
  (TF_CheckNumericsOp $arg, $msg),
  (replaceWithValue $arg)>;

// Remove StopGradient op
def RemoveStopGradient : Pat<
  (TF_StopGradientOp $arg),
  (replaceWithValue $arg)>;

}

func (idx *routingIndex) addPattern(pat *pattern) {
	if pat.lastSegment().multi {
		idx.multis = append(idx.multis, pat)
	} else {
		if idx.segments == nil {
			idx.segments = map[routingIndexKey][]*pattern{}
		}
		for pos, seg := range pat.segments {
			key := routingIndexKey{pos: pos, s: ""}
			if !seg.wild {
				key.s = seg.s
			}
			idx.segments[key] = append(idx.segments[key], pat)
		}
	}
}