return success();
}

LogicalResult ConvertCaseOp(CaseOp case_op) {
  OpBuilder builder(case_op);
  auto case_region = builder.create<TF::CaseRegionOp>(
      case_op.getLoc(), case_op.getResultTypes(), case_op.getBranchIndex(),
      case_op.getIsStateless(), case_op.getBranches().size());
  CopyDeviceAndUnderscoredAttributes(case_op, case_region);

  for (const auto& item : llvm::enumerate(case_region.getBranches())) {

  // functional op.
  OpBuilder builder(case_region);
  auto case_op = builder.create<CaseOp>(
      case_region.getLoc(), case_region.getResultTypes(),
      case_region.getBranchIndex(), extern_values,
      builder.getArrayAttr(branch_symbols), case_region.getIsStateless());
  CopyAndOverrideAttributes(case_region, case_op, &builder);

  // Redirect old results to new results.

};

LogicalResult FoldConstantCaseOp::matchAndRewrite(
    TF::CaseOp op, PatternRewriter& rewriter) const {
  // Extract the constant cond value.
  DenseIntElementsAttr branch;
  if (!matchPattern(op.getBranchIndex(), m_Constant(&branch))) return failure();

  int index = *branch.getValues<int>().begin();
  if (index < 0 || index >= op.num_branches()) index = op.num_branches() - 1;

      // the number of regions as an input along with the operands.
      mhlo_op = rewriter.create<DstOpT>(loc, op.getResultTypes(),
                                        adaptor.getBranchIndex(),
                                        op.getBranches().size());
    } else if constexpr (std::is_same<DstOpT, mhlo::WhileOp>::value) {
      llvm::SmallVector<Type, 4> while_result_types;