auto s_const = builder.create<SparseConstOp>(
              op->getLoc(), cst.getValue(), s_param, new_value);
          value.replaceAllUsesWith(s_const.getResult());
          cst.erase();
        } else if (type.getElementType().isF16()) {
          std::vector<Eigen::half> dense_data;
          dense_data.reserve(type.getNumElements());
          for (const auto& val : attr.getValues<APFloat>())

      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))) {

  // CHECK-NEXT: "tf.AssignVariableOp"(%[[VAR]], %[[IDENTITY]])
}

// -----

// If something other than `tf.VarHandleOp` is being initialized, it is
// not erased.

// CHECK-LABEL: module
module attributes {tf_saved_model.semantics} {
  "tf_saved_model.session_initializer"() {initializers = [@init_func_restore_op]} : () -> ()
  // CHECK: "tf_saved_model.session_initializer"()