// op involves a region, the op is only quantizable when the region only
  // consists of ops whose quantization parameters can be propagated from
  // outside.
  bool IsNestedRegionQuantizable(Operation* op) const {
    for (Region& region : op->getRegions()) {
      for (Operation& op : region.getOps()) {
        if (!IsOpQuantizableInNestedRegion(op)) {
          return false;
        }
      }
    }

// conversion, use the first input to get inputs rank. Other inputs need not be
// ranked.
// Defining op for `axis` is TensorFlow constant op in the pattern as during
// the conversion, original Concat op operands still refers to the old ops even
// if HLO constant op is introduced as an replacement for the TensorFlow
// Constant op.
def : Pat<(TF_ConcatV2Op $inputs, (ConstantLikeMatcher OneElementAttr:$axis)),

  block.walk([&](Operation *op) {
    if (op->getName().getStringRef() != "tfg.NextIteration") return;
    mlir::OpBuilder builder(op);

    llvm::SmallVector<Value, 2> new_operands;
    FilterOutBlockArgControlDep(op->getOperands().drop_front(), new_operands);

    auto source_op = builder.create<tf_executor::NextIterationSourceOp>(
        op->getLoc(), op->getOperand(0).getType());

}

bool IsTPUOp(mlir::Operation* op) {
  return op->hasAttr(TF::kReplicationInfoAttr);
}

StringAttr GetReplicationAttr(mlir::Operation* op) {
  return op->getAttrOfType<StringAttr>(TF::kReplicationInfoAttr);
}

StringAttr GetReplicationAttr(TF::TPUCompilationResultOp op) {
  // Special case for getting the replication region for
  // TPUCompilationResultsOp.
  return op->getAttrOfType<StringAttr>(kTpuCompilationStatus);

    Operation *op, const ClusteringPolicySet &policies,
    const std::function<bool(Operation *op)> &filter) {
  // Check that op has no side effects. This guarantees that we will not
  // reorder side-effecting ops during cluster formation.
  if (!isMemoryEffectFree(op)) return std::nullopt;

  // Operation rejected by the custom filter.
  if (filter && !filter(op)) return std::nullopt;

    mlir::Operation *op = use.getOwner();
    if (llvm::isa<TF::TensorListGetItemOp>(op) ||
        llvm::isa<TF::TensorListLengthOp>(op) ||
        llvm::isa<TF::TensorListPushBackOp>(op) ||
        llvm::isa<TF::TensorListReserveOp>(op) ||
        llvm::isa<TF::TensorListSetItemOp>(op) ||
        llvm::isa<TF::TensorListStackOp>(op) ||
        llvm::isa<TF::TensorListResizeOp>(op)) {

    func.walk([&](mlir::TF::ReadVariableOp op) {
      auto sym = lookupGlobalTensor(func, op.getResource(), syms, opToName);
      success &= !!sym;
      if (!success) return;
      OpBuilder builder(op);
      auto load = builder.create<mlir::ml_program::GlobalLoadOp>(
          op.getLoc(), op.getValue().getType(), sym);
      op.getValue().replaceAllUsesWith(load.getResult());
      op.erase();
    });

            assert op.failure instanceof ProjectConfigurationException
            assert op.failure.message == "A problem occurred configuring <project>."
            assert op.failure.cause.is(failureCause)
        } else {
            assert resultType.isInstance(op.result)
            assert op.failure == null
        }
    }

    List<TestBuildOperationRunner.Log.Record> getOperations() {

        notifications.op(LoadBuildBuildOperationType.Details, [buildPath: ":a:buildSrc"]).parentId == notifications.op(BuildBuildSrcBuildOperationType.Details, [buildPath: ':a']).id

        notifications.op(EvaluateSettingsBuildOperationType.Details, [buildPath: ":"]).parentId == notifications.op(LoadBuildBuildOperationType.Details, [buildPath: ":"]).id

      operand = rewriter.create<CastOp>(op.getLoc(), tensor_type_f32, operand);
    }
    Value result = rewriter.create<MatMulOp>(
        op.getLoc(), op.getProduct().getType(), operands[0], operands[1],
        op.getTransposeA(), op.getTransposeB());

    rewriter.replaceOp(op, {result});
    return success();
  }
};

// Lowers _UnaryOpsComposition op as a series of original TensorFlow ops that