(FloatValueEquals<"0.797884583"> $Cst_sqrt_2dPi),
   (FloatValueEquals<"0.044715"> $Coeff),
   (HasOneUse $mul_out),
   (HasOneUse $add_out),
   (HasOneUse $tanh_out),
   (HasOneUse $mul_out1),
   (HasOneUse $add_out1),
   (HasOneUse $mul_out2),
   (HasOneUse $pow_out),
  ]>;

// Alternate pattern for GeluApproximate (see different order for mul), replaces

def DefinedByConv2D : Constraint<CPred<"llvm::isa_and_nonnull<mlir::TF::Conv2DOp>($0.getDefiningOp())">>;
// Checks if the value has only one user.
def HasOneUse : Constraint<CPred<"$0.hasOneUse()">>;

// If we see a Conv2D op followed by Mul, then multiply the filter
// with the value in Mul.
def FuseMulAndConv2D :
  Pat<(TF_MulOp:$mul (TF_Conv2DOp:$conv $input,

      $input,
      (MultiplyFakeQuantValue $weight,
        (MakeOneDimValueBroadcastable $mul_rhs, $weight))),
    (MultiplyFakeQuantValue $bias, $mul_rhs), $data_format),
  [(HasOneUse $conv_out),
   (HasOneUse $bias_add),
   (HasRankOf<1> $mul_rhs_value),
   (HasStaticShapeConstraint $weight),
   (CanBeSymmetricallyQuantized $weight),
   (CanBeSymmetricallyQuantized $bias),

    squeeze_op = llvm::cast<TF::SqueezeOp>(consumer_op);
    if (!expand_op.getResult().hasOneUse()) {
      return rewriter.notifyMatchFailure(
          expand_op, "result for current op has more than 1 use");
    }
    if (!squeeze_op.getResult().hasOneUse()) {
      return rewriter.notifyMatchFailure(
          squeeze_op, "result for current op has more than 1 use");
    }

            device_return->getParentRegion()->getRegionNumber());
        if (operand_idx >= execute_results.size()) return nullptr;

        auto result_from_use = execute_results[operand_idx];
        if (!result_from_use.hasOneUse()) return nullptr;

        device_return = result_from_use.use_begin()->getOwner();
        if (!device_return) return nullptr;
      }
    } else {
      LLVM_DEBUG(llvm::dbgs()

// For the second pattern, there is not good way in the framework to handle the
// commutativity of the AddV2: we want the FusedBatchNormV3 on any side.
// Also we need some native calls to handle the "hasOneUse" aspects and the
// optional extra operands for the AddV2 case.
struct ReluToFusedBatchNorm : public OpRewritePattern<ReluOp> {
  using OpRewritePattern<ReluOp>::OpRewritePattern;

      first.getStrides().getSplatValue<IntegerAttr>().getInt() != 1 ||
      first.getStrides() != second.getStrides())
    return rewriter.notifyMatchFailure(concat, "slice ops must have stride=1");
  if (!first->hasOneUse() || !second->hasOneUse())
    return rewriter.notifyMatchFailure(concat, "slice ops are used elsewhere");

  SmallVector<int64_t> new_start;
  SmallVector<int64_t> new_limit;
  SmallVector<int64_t> new_slice_shape;

      return failure();
    }

    // Compute inverse of input transpose.
    llvm::SmallVector<int32_t> inverse_perm_arr = InvertPermutation(perm1_arr);

    if (!(tpose_arg1->hasOneUse() || tpose_arg2->hasOneUse())) {
      return failure();
    }

    auto current_out_type =
        llvm::dyn_cast<RankedTensorType>(op->getResult(0).getType());
    auto new_out_type = RankedTensorType::get(

    RankedTensorType pad_type = pad_op.getType().cast<RankedTensorType>();

    auto transpose_op = pad_input.getDefiningOp<stablehlo::TransposeOp>();
    if (!transpose_op || !transpose_op->hasOneUse()) return failure();
    Value transpose_input = transpose_op.getOperand();

    ArrayRef<int64_t> transpose_perm = transpose_op.getPermutation();
    SmallVector<int64_t> new_padding_low =

    }

    // If the contraction is used in multiple places, fusing it will only create
    // more contraction nodes, which is slower.
    if (!contraction.getResult().hasOneUse())
      return rewriter.notifyMatchFailure(contraction,
                                         "result is used by multiple ops");

    BiasAddOp bias_add = GetBiasAdd(contraction.getResult());
    if (!bias_add) {