// Erase unused ops in the reverse order.
    rewriter.eraseOp(output_uniform_dequantize_call_op);
    rewriter.eraseOp(output_uniform_quantize_call_op);
    rewriter.eraseOp(combined_scale_multiply_op);
    rewriter.eraseOp(subtract_op);
    rewriter.eraseOp(other_conv_op);
    rewriter.eraseOp(op);
    rewriter.eraseOp(input_i8_to_f32_convert_op);

      }

      read_variable_op.erase();
      continue;
    }

    if (auto assign_variable_op = dyn_cast<TF::AssignVariableOp>(&op)) {
      Value resource = assign_variable_op.getResource();
      auto last_store = resource_handle_to_last_store_op[resource];
      // Previous store ops to same resource can be erased.
      if (last_store) last_store.erase();

  // Remove unused message identification ops.
  if (communication_key_index == 0)
    for (auto op : compilation_key_ops) op->erase();
  if (communication_key_index == 0 || core_to_device_ordinal.empty())
    for (auto op : core_to_device_ordinal_op) op->erase();

  for (mlir::tf_device::LaunchOp tmp_host_launch_op : core_to_tmp_launch)
    RemoveOutsideCompilation(tmp_host_launch_op);

		}
	}
	if e.s.f.pass.debug > regDebug {
		fmt.Printf("%s\n", c.LongString())
		fmt.Printf("v%d now available in %s:%s\n", vid, loc, c)
	}
}

// erase removes any user of loc.
func (e *edgeState) erase(loc Location) {
	cr := e.contents[loc]
	if cr.c == nil {
		return
	}
	vid := cr.vid

	if cr.final {
		// Add a destination to move this value back into place.

  // Erase original while op and temporary functions. Note, we use the non_tpu
  // function in the output graph.
  symbol_table.lookup(orig_callers.forward.getF())->erase();
  symbol_table.lookup(orig_callers.core_tpu.getF())->erase();
  symbol_table.lookup(orig_callers.backward.getF())->erase();
  orig_while_op.body_function().erase();
  orig_while_op.erase();

    if (!is_converged) {
      for (Node* n : topo) {
        for (int oid = 0; oid < n->num_outputs(); ++oid) {
          predicate_map_.erase(TensorId(n->name(), oid));
        }
        predicate_map_.erase(TensorId(n->name(), Graph::kControlSlot));
      }
    }

    if (success != nullptr) {
      *success = is_converged;
    }
  }

            cst.getValueAttr());
        full_range_const = new_op.getOutput();
      }
      use.set(full_range_const);
    }
    if (cst.use_empty()) cst.erase();
  });
  return func;
}

// Helper method that returns the index of the tensor with name 'tensor_name'
// in the list of tensor names 'tensors'. It allows excluding some indices.

2. you might want to add generated checksums to the list above
3. when _updating_ dependency verification file with more secure checksums, you don't want to accidentally erase checksums

[[sec:signature-verification]]
== Verifying dependency signatures

In addition to <<sec:checksum-verification,checksums>>, Gradle supports verification of signatures.

// CHECK: "tf.opB"([[REPLICATE]]#0)

// -----

// TF produces Identity ops between TPUReplicatedOutput and
// TPUPartitionedOutputV2 ops. This test ensures that they are erased
// and not considered within the clustered computation. It also ensures that
// the expected interleaving pattern is present in the output.

// Do not convert control outputs to chains in the presence of an op with
// unknown side effects in the while body.
// This test checks that loop signatures are unchanged and no control output is
// erased from while loop body.

// CHECK-LABEL: func @unknown_resource_op_while_body