options.insert(arg);
            }
          }
        } else {
          op->emitOpError("Predecessor op doesn't implement BranchOpInterface");
          return failure();
        }
      }
    }
    if (!options.empty()) {
      if (options.size() != 1) {
        op->emitOpError("Incompatible code paths.");
        return failure();
      } else {
        *out = *options.begin();

    } else if (result.wasSkipped()) {
      continue;
    }

    result = f.walk([&](Operation* op) {
      const auto uses = SymbolTable::getSymbolUses(op);
      if (!uses.has_value()) {
        op->emitOpError() << "contains a potentially unknown symbol table";
        return WalkResult::interrupt();
      }

      for (const SymbolTable::SymbolUse& use : *uses) {
        func::FuncOp called_func =

      op->removeAttr(tensorflow::kMustCompileAttr);
      if (!must_compile_attr_val) {
        if (op->hasAttr(tensorflow::kCompileDeviceTypeAttr)) {
          op->emitOpError()
              << "has both '" << tensorflow::kMustCompileAttr
              << " = false' and '" << tensorflow::kCompileDeviceTypeAttr
              << "' attribute which contradicts each other";

    if (!backend_config) {
      op->emitOpError() << "is missing attribute '" << kTfBackendConfigAttrName
                        << "'";
      return WalkResult::interrupt();
    }
    auto called_func = mlir::dyn_cast_or_null<SymbolRefAttr>(
        backend_config.get(kCalledFuncAttrName));
    if (!called_func) {
      op->emitOpError() << "is missing attribute '" << kCalledFuncAttrName

                                            TypeRangeWithDesc range0,
                                            TypeRangeWithDesc range1) {
  if (range0.first.size() != range1.first.size()) {
    return op->emitOpError()
           << range0.second << "s (size = " << range0.first.size() << ")"
           << " should have the same number of values as " << range1.second
           << "s (size = " << range1.first.size() << ")";
  }

    auto key_value = mlir::dyn_cast<mlir::ArrayAttr>(op_attr);
    if (!key_value || key_value.getValue().size() != 2 ||
        !mlir::isa<mlir::StringAttr>(key_value.getValue()[0]))
      return op.emitOpError() << "each op_attr should be a key-value pair, "
                                 "where the key is a string";
  }
  return mlir::success();
}

template <typename OpTy>

  auto embedding_attr = op->getAttrOfType<StringAttr>(kTPUEmbeddingAttr);
  if (!embedding_attr) return mlir::success();

  if (!embedding_op_map->insert({embedding_attr.getValue(), op}).second)
    return op->emitOpError(
        "found duplicate TPU embedding ops potentially from multiple "
        "TPUEmbedding layers");

  op->removeAttr(kTPUEmbeddingAttr);
  return success();
}

LogicalResult FindTPUEmbeddingOps(

      } else if (device_str_attr.getValue() != launch.getDevice()) {
        return launch.emitOpError()
               << "inner op has conflicting 'device' attribute, "
                  "got '"
               << device_str_attr.getValue() << "' but expected '"
               << launch.getDevice() << "'";
      }
    } else {
      return launch.emitOpError()
             << "inner op has bad 'device' attribute, got " << device_attr;
    }

  Block* parent_block = graph.getOperation()->getBlock();
  for (Operation& op : graph.GetBody().without_terminator()) {
    auto island_op = llvm::dyn_cast<tf_executor::IslandOp>(op);
    if (!island_op)
      return op.emitOpError()
             << "is not supported for lifting out of tf_executor.graph, "
                "expected tf_executor.island";

    // Move inner ops in island to before the outer graph.

  if (!device_type_.hasValue()) return;
  auto func_op = getOperation();

  auto walk_result = func_op->walk([&](TF::StatelessRandomGetAlgOp op) {
    if (failed(ConvertGetAlgOp(op))) {
      op->emitOpError(
          "Could not convert and remove Device specific information");
      return WalkResult::interrupt();
    }

    return WalkResult::advance();
  });