TF::TensorListSetItemOp op, OpAdaptor adaptor,
      ConversionPatternRewriter &rewriter) const {
    Location loc = op.getLoc();
    Value input = adaptor.getOperands()[0];
    Value index = adaptor.getOperands()[1];
    Value item = adaptor.getOperands()[2];

    IntegerType shape_dtype = rewriter.getIntegerType(32);
    auto item_rank = rewriter.create<TF::RankOp>(

  llvm::SmallSetVector<Value, 4> new_launch_op_results;

  new_launch_op_results.insert(
      old_launch_op->GetBody().getTerminator()->getOperands().begin(),
      old_launch_op->GetBody().getTerminator()->getOperands().end());

  for (Value operand : tpu_copy_with_dynamic_shape_op->getOperands()) {
    if (GetOpOfValue(operand)->getParentRegion() ==
        tpu_copy_with_dynamic_shape_op->getParentRegion()) {

  Operation* terminator = cluster.GetBody().getTerminator();
  llvm::SmallSetVector<Value, 4> cluster_results_set;
  cluster_results_set.insert(terminator->getOperands().begin(),
                             terminator->getOperands().end());

  auto cluster_ops = llvm::reverse(cluster.GetBody().without_terminator());
  for (Operation& cluster_op : cluster_ops) {

         llvm::enumerate(cluster_func_op.getOperands())) {
      auto device_launch_op = llvm::dyn_cast<tf_device::LaunchOp>(
          GetOpOfValue(cluster_func_operand.value()));
      if (!device_launch_op) continue;
      for (auto result : llvm::zip(
               device_launch_op.getResults(),
               device_launch_op.GetBody().getTerminator()->getOperands())) {

    return CreateListReserveOptions(context, tflite_type);
  }
  return {};
}

bool HasVariantInputOrOutput(Operation* op) {
  const bool has_variant_input = llvm::any_of(op->getOperands(), [](Value val) {
    return val.getType().cast<TensorType>().getElementType().isa<VariantType>();
  });
  const bool has_variant_output =
      llvm::any_of(op->getResultTypes(), [](Type t) {

      }
    }
    if (!newType) {
      return failure();
    }
    rewriter.replaceOpWithNewOp<UnrealizedConversionCastOp>(op, newType,
                                                            op->getOperands());
    return success();
  }
};

class HandleCall : public OpInterfaceRewritePattern<CallOpInterface> {
  // Optional-agnostic pattern that propagates types across the program.

      neighbors.push_back(arg.getArgNumber());
      continue;
    }
    if (!node.getDefiningOp()) continue;
    for (Value operand : node.getDefiningOp()->getOperands()) {
      if (visited.contains(operand)) continue;
      queue.push_back(operand);
      visited.insert(operand);
    }
  }
}

void FindConsumedOp(Operation *start_op,

    StringAttr op_device = op->getAttrOfType<StringAttr>(kDeviceAttr);
    bool should_fold = llvm::all_of(
        op.getOperands(), [&op_device, &should_fold_op_func](const Value &arg) {
          return should_fold_op_func(arg, op_device);
        });
    if (should_fold) {
      op.replaceAllUsesWith(op.getOperands());
      op.erase();
    }
    return WalkResult::advance();
  });
}

}  // namespace

           call_op.getOperands())) {
    arg_mapper.map(func_arg, operand);
  }

  Region& function_body = func_op.getBody();
  IRMapping new_op_mapper;
  for (Operation& op : function_body.getOps()) {
    if (llvm::isa<func::ReturnOp>(op)) {
      for (auto [call_result, return_value] :
           llvm::zip_equal(call_op.getResults(), op.getOperands())) {

  const int operands_size = while_op.getNumOperands() + extra_operands.size();
  SmallVector<Value, 4> operands;
  operands.reserve(operands_size);
  operands.append(while_op.getOperands().begin(), while_op.getOperands().end());
  operands.append(extra_operands.begin(), extra_operands.end());
  SmallVector<Type, 4> new_types;
  new_types.reserve(operands_size);
  new_types.append(while_op.getResultTypes().begin(),