/*executor_type=*/builder.getStringAttr(""));
    call_op->setAttr("device", launch->getAttrOfType<StringAttr>("device"));
    launch.replaceAllUsesWith(call_op);
    launch.erase();
  });
}

}  // namespace

std::unique_ptr<OperationPass<ModuleOp>> CreateConvertLaunchFuncToTFCallPass() {
  return std::make_unique<ConvertLaunchFuncToTFCallPass>();
}

}  // namespace TFDevice

        auto new_op = builder.create<TFR::CastOp>(
            returned_op->getLoc(), new_type, returned_op.getArg());
        returned_value.set(new_op.getResult());
        if (returned_op.use_empty()) {
          returned_op.erase();
        }
      } else {
        returned_value.get().getDefiningOp()->emitError(
            "The producer of quantized type result should be a tfr.cast op.");
        return;
      }
    }

      status = ReplacePartitionedOp(num_cores_per_replica, partitioned_output);
    }

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

      op->erase();
    }

    return WalkResult::advance();
  });

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

}  // namespace

		oldSvc: makeSvc("1.1.1.1", "3.3.3.3"),
		fail:   true,
	}, {
		name:   "update: add externalIPs",
		newSvc: makeSvc("1.1.1.1", "2.2.2.2"),
		oldSvc: makeSvc("1.1.1.1"),
		fail:   true,
	}, {
		name:   "update: erase externalIPs",
		newSvc: makeSvc(),
		oldSvc: makeSvc("1.1.1.1", "2.2.2.2"),
	}, {
		name:   "update: reduce externalIPs from back",
		newSvc: makeSvc("1.1.1.1"),
		oldSvc: makeSvc("1.1.1.1", "2.2.2.2"),
	}, {

  for (auto result :
       llvm::zip(graph.getResults(), graph.GetFetch().getFetches()))
    std::get<0>(result).replaceAllUsesWith(std::get<1>(result));

  graph.erase();
  return success();
}

void ExecutorDialectToFunctionalConversion::runOnOperation() {
  auto result = getOperation().walk([](tf_executor::GraphOp graph) {
    if (failed(LiftIslandOpInnerOpsFromGraph(graph)))

	// nil data return and error return keeps the existing data aka createConfigSet
	<-delay
	g.Eventually(func() error {
		c := store.List(gvk.Gateway, "")

		if len(c) != 1 {
			return errors.New("config files erased on Copilot error")
		}

		return nil
	}).Should(Succeed())

func FilterIndex[I any, K comparable](idx *Index[I, K], k K) FetchOption {
	return func(h *dependency) {
		// Index is used to pre-filter on the List, and also to match in Matches. Provide type-erased methods for both
		h.filter.listFromIndex = func() any {
			return idx.Lookup(k)
		}
		h.filter.indexMatches = func(a any) bool {
			return idx.objectHasKey(a.(I), k)
		}
	}
}

            PartialTensorShapeUtils::PartialShapeListString(it->second),
            ", actual: ",
            PartialTensorShapeUtils::PartialShapeListString(shapes));
      }
      expected_shapes.erase(it);
    }
  }
  if (!expected_shapes.empty()) {
    std::vector<string> missing;
    missing.reserve(expected_shapes.size());
    for (const auto& entry : expected_shapes) {
      missing.push_back(entry.first);

      //   }
      // clang-format on
      for (auto attr : session_initializer.getInitializers()) {
        auto sym_attr = mlir::dyn_cast<FlatSymbolRefAttr>(attr);
        if (!sym_attr) break;
        entrypoints.erase(sym_attr.getValue());
      }
    }

    if (entrypoints.empty()) {
      return fail(module, "No entrypoints found");
    }
    if (entrypoints.size() == 1) {
      auto entrypoint = entrypoints.begin()->second;

  // Export the result as a FunctionDef.
  FunctionDef func_def;
  TF_RETURN_IF_ERROR(
      ConvertMlirFunctionToFunctionLibraryDef(func, export_confs_, &func_def));
  module.erase();
  return func_def;
}

Status TFRDecomposeContext::DecomposeGraph(mlir::ModuleOp user_module) {
  // Call the decompose passes by using the external symbol table.
  if (failed(pm_.run(user_module))) {