auto walk_result = parent_op->walk([](Operation *op) {
    // Cleanup code in attached regions.
    for (Region &region : op->getRegions()) {
      if (!llvm::hasSingleElement(region)) return WalkResult::interrupt();
      RemovePassthroughOp(region.front());
      RemoveDeadLocalVariables(region.front());
    }

    LogicalResult result = success();

      auto& op = outside_compile_ops[i];
      op_info.push_back(tensorflow::OpAsString(*op));
    }

    LOG(WARNING) << outside_compile_ops.size() << " outside compilation "
                 << "regions found while processing "
                 << module->getName().getStringRef().str()
                 << ". This may result in excessively slow model execution. "
                 << "First " << op_info.size()

            // Recursivley call again to raise any non-"CPU" subgraphs contained
            // within nested region of `op`.
            for (auto& region : op.getRegions())
              for (auto& block : region.getBlocks())
                RaiseTargetSubgraphsForBlock(block, builder, module,
                                             /*skip_cpu=*/true, func_count,

              ->has_same_scale_requirement &&
          !IsConnectedWithQuantizedCompsiteFunction(candidate_op)) {
        return failure();
      }

      // Ops with regions will be quantized in a separate pattern.
      if (isa<mlir::stablehlo::ReduceWindowOp>(candidate_op)) {
        return failure();
      }

      const bool weight_only_quantizable =

  }

  // Returns if its legal to inline 'src' region into the 'dest' region
  // attached to a TF operation.
  bool isLegalToInline(Region *dest, Region *src, bool wouldBeCloned,
                       IRMapping &valueMapping) const final {
    // Allow inlining in regions attached to region based control flow
    // operations only if the src region is a single block region

  pm.addPass(mlir::createSymbolDCEPass());

  // Sink constants to regions so that ops requiring constant operands can
  // access the constant and there is no indirection through control flow region
  // arguments. Also, note that this pass is in MHLO but it is generic and sinks
  // constants for all ops with regions.
  pm.addNestedPass<mlir::func::FuncOp>(
      mlir::mhlo::createSinkConstantsToControlFlowPass());

  // Ensure that all ops are in the same region, and have the same replication
  // info.
  // TODO(bfontain): Allow for multiple regions/loops in one module.
  // TODO(patn): move this pass after cluster formation to remove the complexity
  // with replication info and metadata, cluster checking and generalizing to
  // multiple TPU clusters.
  Region* region = (*forward_pass_ops.begin())->getParentRegion();

  let summary = [{
    The `region` operation wraps high-precision ops as a logical low-precision
    quantized kernel.
  }];

  let arguments = (ins Variadic<AnyType>:$inputs,
                    TypeArrayAttr:$input_specs,
                    TypeArrayAttr:$output_specs,
                    StrAttr:$logical_kernel);
  let results = (outs Variadic<AnyType>:$outputs);
  let regions = (region SizedRegion<1>:$body);

  SymbolUserMap symbol_map(table, module);

  // Regions that contains ops requiring token input attributes.
  absl::flat_hash_set<Region*> regions_with_token;
  while (!worklist.empty()) {
    Operation* op = worklist.back();
    worklist.pop_back();

    Region* region = op->getParentRegion();
    regions_with_token.insert(region);

  static LogicalResult inferReturnTypeComponentsFromOperands(
      MLIRContext*, std::optional<Location> location, ValueShapeRange operands,
      DictionaryAttr attributes, OpaqueProperties properties,
      RegionRange regions,
      SmallVectorImpl<ShapedTypeComponents>& inferredReturnShapes) {
    if (operands.empty())
      return emitOptionalError(
          location,