OpBuilder builder(fn.getContext());
  // The control tokens generated by the last ControlNodeOp wrapping.  Will be
  // empty until the first ControlNodeOp was generated, then have constant size
  // 1.
  llvm::SmallVector<Value, 1> control_tokens;
  for (auto *op : ops_with_side_effects) {
    // Wrap all side-effect producing/dependent operations in a ControlNodeOp.
    builder.setInsertionPoint(op);
    Location loc = op->getLoc();

#include "tensorflow/compiler/mlir/lite/transforms/passes.h.inc"

bool IsFlexDelegate(Operation *op) {
  // Unwrap from any ControlNodeOps or CustomTfOp.
  if (auto control_node = dyn_cast<mlir::TFL::ControlNodeOp>(*op)) {
    return IsFlexDelegate(&control_node.getBody().front().front());
  }
  if (auto custom_tf_op = dyn_cast<mlir::TFL::CustomTfOp>(*op)) {
    return IsFlexDelegate(&custom_tf_op.getBody().front().front());
  }

    if (const auto& outgoing = (*control_nodes)[incoming].outgoing; outgoing) {
      control_tokens.push_back(*outgoing);
    }
  }

  // Create the ControlNodeOp.
  auto ctrl_op = op_builder.create<mlir::TFL::ControlNodeOp>(
      op_loc, cloned_op->getResultTypes(),
      mlir::TFL::ControlType::get(op->getContext()), control_tokens);
  ctrl_op.getBody().takeBody(region);

  return value.isa<UnitAttr>() && type.isa<NoneType>();
}

YieldOp ControlNodeOp::GetYield() {
  return llvm::cast<YieldOp>(GetBody().back());
}

// Checks if a TFL.control_node wraps a single operation and the single
// operation results are perfectly forwarded to the wrapper's yield.
bool ControlNodeOp::WrapsSinglePerfectlyForwardedOp() {
  auto body = GetBody().without_terminator();

  let summary = "Pin operators with side effects";
  let description = [{
      This transformation pass wraps operations that have or depend on side effects in
      TFL::ControlNodeOp, which depend on the control token generated by the most recent
      preceding such operation, if any. This copies the logic that is currently executed

  for (const auto& item : llvm::enumerate(*block)) {
    if (llvm::isa<mlir::TFL::ControlNodeOp>(item.value())) {
      control_nodes.push_back(&item.value());
      control_nodes_at.try_emplace(&item.value(), item.index());
    }
  }

  for (auto outer_op : control_nodes) {
    auto control_node_op = dyn_cast<mlir::TFL::ControlNodeOp>(outer_op);
    auto* inner_op = &control_node_op.getBody().front().front();

  let summary = "Yield operation";
  let description = [{
    The "yield" operation represents a return operation within the conditional
    and body of structured control flow (e.g., while), and a terminator for ControlNodeOp.
    The operation takes a variable number of operands and produces no results.
    The operand number and types must match the signature of the region that contains the operation.
  }];