// which should have died is still running. However, rather than do this with
	// thread IDs, it does this by unsharing state on that thread. This way, it
	// also detects whether new threads were cloned from the dead thread, and not
	// from a clean thread. Cloning from a locked thread is undesirable since
	// cloned threads will inherit potentially unwanted OS state.
	//

  // TODO(b/160906885): Repalce the following code with an non-recursive one.
  llvm::SmallVector<Operation*, 4> erase_list;
  llvm::SmallPtrSet<Operation*, 4> dead_ops;

  // Marks all the variables dead.
  dead_ops.insert(vars.begin(), vars.end());

  // Removes relevant ops in topological order.
  for (auto& op : vars) RecursiveRemove(op, erase_list, dead_ops);

  // Erases the ops.

        //we can try sending something to the daemon and try out if it is really dead or use jps
        //if it's really dead we should deregister it if it is not already deregistered.
        //if the daemon is not dead we might continue receiving from it (and try to find the bug in messaging infrastructure)

// custom op is quantized only for storage and dequantized at runtime.
// 'no_side_effect' is used to determine whether the op can be pruned if
// considered as trivially dead.
struct CustomOpInfo {
  std::vector<std::int32_t> quantizable_input_indices;
  bool is_weight_only = false;
  bool no_side_effect = true;
};

using BuiltinOperatorSet = absl::flat_hash_set<tflite::BuiltinOperator>;

// limitations under the License.

// Package backoff is a wrapper of `github.com/cenkalti/backoff/v4`.
// It is to prevent misuse of `github.com/cenkalti/backoff/v4`,
// thus application could fall into dead loop.
package backoff

import (
	"context"
	"fmt"
	"time"

	"github.com/cenkalti/backoff/v4"
)

// BackOff is a backoff policy for retrying an operation.
type BackOff interface {

  }

  void rewrite(TF::AssignVariableOp assign_op,
               PatternRewriter& rewriter) const override {
    // `TF::ConstOp` and `TF::VarHandleOp` are not manually erased.
    // `applyPatternsAndFoldGreedily` performs dead code elimination and unsed
    // ops will be erased during the optimization.
    rewriter.eraseOp(assign_op);
  }
};

void RemoveVariableInitializationByConstPass::runOnOperation() {
  MLIRContext& ctx = getContext();

  // Running canonicalizer before decomposing resource ops in cluster helps the
  // latter pass to converge faster as it does not have to spend time folding
  // away dead ops.
  pm.addNestedPass<FuncOp>(mlir::createCanonicalizerPass());
  // Place DecomposeResourceOpsPass before TFExecutorConstantSinking pass
  // because DecomposeResourceOpsPass uses pattern rewriter which hoists

// getContainersToDeleteInPod returns the exited containers in a pod whose name matches the name inferred from filterContainerId (if not empty), ordered by the creation time from the latest to the earliest.
// If filterContainerID is empty, all dead containers in the pod are returned.
func getContainersToDeleteInPod(filterContainerID string, podStatus *kubecontainer.PodStatus, containersToKeep int) containerStatusbyCreatedList {

	for state.head != nil {
		x := state.head
		state.head = x.next
		if stackTraceDebug {
			for i := 0; i < x.nobj; i++ {
				obj := &x.obj[i]
				if obj.r == nil { // reachable
					continue
				}
				println("  dead stkobj at", hex(gp.stack.lo+uintptr(obj.off)), "of size", obj.r.size)
				// Note: not necessarily really dead - only reachable-from-ptr dead.
			}
		}
		x.nobj = 0

		if x == v {
			continue
		}
		if x == w {
			continue
		}
		if w != nil {
			return false
		}
		w = x
	}

	if w == nil {
		// v references only itself. It must be in
		// a dead code loop. Don't bother modifying it.
		return false
	}
	v.Op = OpCopy
	v.SetArgs1(w)
	f := v.Block.Func
	if f.pass.debug > 0 {
		f.Warnl(v.Pos, "eliminated phi")
	}
	return true