// case is useful for float16 quantization. Since all ops have been
    // legalized to tflite ops, so we only care about ConstOp or QConstOp or
    // mlir constant op.
    Operation* input_op = operand.getDefiningOp();
    if (input_op == nullptr) return failure();

    Attribute attr;
    if (matchPattern(input_op, m_Constant(&attr))) {
      // Constant case.
      builder->setInsertionPoint(op);

def EmptyCustomOptions : NativeCodeCall<
  "TFL::ConstBytesAttr::get($_builder.getContext(), \"\")">;

def CustomOptions : NativeCodeCall<
  "CustomOptions($_builder.getContext(), $0.getDefiningOp()).value()">;

class CreateStringAttr<string values> : NativeCodeCall<
  "$_builder.getStringAttr("# values #")">;

def LegalizeTensorListReserve : Pat<(TF_TensorListReserveOp:$tf_op $shape, $num_elements),

                  AttrType &max_value) const {
    Value min = tf_op.getMin(), max = tf_op.getMax();
    if (auto min_id = min.getDefiningOp<TF::IdentityOp>()) {
      min = min_id.getInput();
    }
    if (auto max_id = max.getDefiningOp<TF::IdentityOp>()) {
      max = max_id.getInput();
    }

    if (!matchPattern(min, m_Constant(&min_value))) {
      return false;
    }

#define COMPOSITE_UTILS_TD

include "mlir/IR/PatternBase.td"

// See the function doc in the header file.
def GetNhwcReturnTypeFromNchw: NativeCodeCall<
  "GetNhwcReturnTypeFromNchw((*$0.begin()).getDefiningOp())">;

// When given a DenseIntElementsAttr containing I64 elements, this extracts
// one I32IntegerAttr from the given index.
class GetI32At<int index>: NativeCodeCall<

    auto assign_variable_op =
        dyn_cast_or_null<AssignVariableOp>(var_handle_user);
    if (!assign_variable_op) continue;
    auto value_op = assign_variable_op.getValue().getDefiningOp();
    auto dq_op = dyn_cast_or_null<DequantizeOp>(value_op);
    if (!dq_op || ref_qtype) continue;
    ref_qtype = dq_op.getInput().getType();
  }
  return ref_qtype;
}

class QuantizeVariablesPass

    auto batchInputDataset = op.getInputDataset();

    ParallelMapDatasetOp batchInputOp = dyn_cast_or_null<ParallelMapDatasetOp>(
        batchInputDataset.getDefiningOp());
    if (!batchInputOp) return failure();

    // The type of the `num_parallel_calls` argument in ParallelMapDataset
    // and MapAndBatchDataset is different (int32 and int64 respectively)

  resource_infos_[resource].potentially_written = true;
  auto* operation = resource.getDefiningOp();
  if (operation && isa<TF::VarHandleOp>(operation)) {
    mutable_variables_.insert(GetResourceKey(operation));
  }
}

bool ResourceAnalyzer::IsPotentiallyWritten(Value resource) const {
  assert(IsResource(resource));
  auto* operation = resource.getDefiningOp();
  if (operation && isa<TF::VarHandleOp>(operation))

    Value assigned_value_operand = assign_variable_op.getOperand(1);

    if (auto var_handle_op =
            dyn_cast<TF::VarHandleOp>(resource_operand.getDefiningOp());
        var_handle_op &&
        isa<TF::ConstOp>(assigned_value_operand.getDefiningOp())) {
      var_handle_ops.emplace_back(var_handle_op);
    }
  }

  return var_handle_ops;
}

    Value pad_input = pad_op.getOperand();
    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();

  LogicalResult match(mlir::stablehlo::TransposeOp op) const override {
    Value operand = op.getOperand();
    auto const_op =
        dyn_cast_or_null<mlir::stablehlo::ConstantOp>(operand.getDefiningOp());
    if (!const_op) return failure();

    // Only support float tensors.
    auto tensor_type = mlir::dyn_cast_or_null<TensorType>(const_op.getType());