if (op->getDialect()->getNamespace() !=
          TF::TensorFlowDialect::getDialectNamespace()) {
        return WalkResult::advance();
      }

      if (!LegalizeSingleOp(*op).ok()) {
        return WalkResult::interrupt();
      }

      return WalkResult::advance();
    });

    if (walk_result.wasInterrupted()) {
      return tsl::errors::Internal("Could not legalize all ops");
    }

    }

    if (status.has_value()) {
      if (failed(*status) || !op->use_empty()) return WalkResult::interrupt();

      op->erase();
    }

    return WalkResult::advance();
  });

  if (result.wasInterrupted()) {
    signalPassFailure();
    return;
  }
}

}  // namespace

std::unique_ptr<OperationPass<func::FuncOp>>

      LOG(ERROR) << "Found illegal op containing uq/qint type: "
                 << op->getName().getStringRef().str();
      return WalkResult::interrupt();
    }
    return WalkResult::advance();
  });

  if (walk_result.wasInterrupted()) {
    signalPassFailure();
  }
}

}  // namespace

std::unique_ptr<OperationPass<func::FuncOp>>
CreateVerifyQuantLegalizationPass() {

          if (head_outside_compiled_ops.count(operand_op)) continue;

          if (operand_op->getParentRegion() == cluster_region)
            return WalkResult::interrupt();
        }
        return WalkResult::advance();
      });

      if (!walk_result.wasInterrupted())
        head_outside_compiled_ops.insert(&cluster_op);
    }
  }

  for (auto head_outside_compiled_op :

  auto decompose_result = function.walk([&](ReduceDatasetOp reduce_dataset) {
    if (!reduce_dataset->hasAttrOfType<StringAttr>(TF::kCompileDeviceTypeAttr))
      return WalkResult::advance();
    OpBuilder builder(reduce_dataset);
    Location loc = reduce_dataset.getLoc();

    // Get reduce function signature for dataset iteration types.

        const Value cast =
            builder.create<TF::CastOp>(op->getLoc(), original_type, op_result);
        op_result.replaceAllUsesExcept(cast, cast.getDefiningOp());
      }
    }
    return WalkResult::advance();
  });

  if (result.wasInterrupted()) return signalPassFailure();
}

}  // namespace

  ASSERT_TRUE(main);

  bool has_cluster_op = false;
  main.walk([&](mlir::tf_device::ClusterFuncOp cluster_op) {
    has_cluster_op = true;
    return WalkResult::advance();
  });

  EXPECT_TRUE(has_cluster_op);
  EXPECT_EQ(compilation_status.Delta(mlir::TF::kMlirPh1BridgeCounterReplicated,
                                     mlir::TF::kMlirPh1BridgeCounterV2,

      if (llvm::isa<AssertOp>(op)) {
        return WalkResult::advance();
      }
      if (auto if_op = llvm::dyn_cast<IfOp>(op)) {
        if (IsPureFunction(if_op.then_function()) &&
            IsPureFunction(if_op.else_function())) {
          return WalkResult::advance();
        }
      }
      if (IsCallToPureFunction(op)) {
        return WalkResult::advance();
      }

    llvm::SmallVector<ReadVariableOp, 4> reads;
    if (failed(GetReads(func, replicate, reads)))
      return WalkResult::interrupt();
    MoveReads(replicate, reads);
    return WalkResult::advance();
  });

  if (result.wasInterrupted()) return signalPassFailure();
}

}  // namespace

std::unique_ptr<OperationPass<FuncOp>> CreateHoistBroadcastReadPass() {

    }
    if (!IsDefaultConversionLegal(op, default_conversion_target)) {
      has_invalid_ops = true;
      IncrementCounterFor(mlir_failed_legalization_op_count, op);
    }
    return WalkResult::advance();
  });

  if (has_invalid_ops) signalPassFailure();
}

}  // namespace

std::unique_ptr<mlir::OperationPass<mlir::func::FuncOp>>
CreateVerifyTFXLALegalizationPass(bool legalize_chlo) {