testServices.expressionMarkerProvider.getElementsOfTypeAtCarets<KtDeclaration>(testServices).single().first

        val restoreAt =
            testServices.expressionMarkerProvider.getElementsOfTypeAtCarets<KtElement>(
                testServices,
                caretTag = "restoreAt"
            ).single().first

        val project = declaration.project

    Arg<TF_StrTensor, [{shape {N}.  The names of the tensors to be restored. This is tensor name in the model.}]>:$tensor_names,
    Arg<TF_StrTensor, [{shape {N}.  The slice specs of the tensors to be restored.
Empty strings indicate that they are non-partitioned tensors.}]>:$shape_and_slices,
    // VarHandles for restored tensors.
    Variadic<TF_Tensor>:$var_handles,
    // Data types for restored tensor.
    TypeArrayAttr: $restored_dtypes,

    %cst_1 = "tf.Const"() <{value = dense<["y", "z"]> : tensor<2x!tf_type.string>}> : () -> tensor<2x!tf_type.string>
    //expected-error@below {{'tf.RestoreV2' op expects 2 valid users, but got 1}}
    %0:2 = "tf.RestoreV2"(%cst, %cst_1, %cst_0): (tensor<!tf_type.string>, tensor<2x!tf_type.string>, tensor<2x!tf_type.string>) -> (tensor<3x1xf32>, tensor<1x3xf32>)

        override fun toTracking(): Tracking {
            throw IllegalStateException("Cannot track state because it was restored")
        }

        override fun toRestoring(): Restoring {
            throw IllegalStateException("Cannot restore state because it was already restored")
        }

        fun loadFrom(storedState: CachedEnvironmentState) {
            if (storedState.cleared) {

  are multiple output tensors from one node). Since Retval nodes are not used in
  SavedModel, this function removes them and restore the names to the actual
  output tensors.

  Args:
    graph_def: the converted GraphDef.

  Returns:
    The GraphDef with Retval nodes removed and output tensor names restored.
  """
  output_renaming_map = {}
  with session.Session(graph=ops.Graph()):
    importer.import_graph_def(graph_def, name='')

        assertTrue(enabledOnOtherThread)
    }

    @Test
    fun `input tracking is restored to the state when it was disabled`() {
        val state = InputTrackingState()
        state.disableForCurrentThread() // <1>
        state.disableForCurrentThread() // <2>

        state.restoreForCurrentThread() // Revert call at <2>, restore to "disabled" state set by call at <1>
        assertFalse(state.isEnabledForCurrentThread())

/**
 * [KaSymbol] is valid only during read action it was created in
 * To pass the symbol from one read action to another the KtSymbolPointer should be used
 *
 * We can restore the symbol
 *  * for symbol which came from Kotlin source it will be restored based on [com.intellij.psi.SmartPsiElementPointer]
 *  * restoring symbols which came from Java source is not supported yet
 *  * for library symbols:

}

// Expiry returns expiry of restored object and true if restore-object has completed.
// Otherwise returns zero value of time.Time and false.
func (r restoreObjStatus) Expiry() (time.Time, bool) {
	if r.Ongoing() {
		return time.Time{}, false
	}
	return r.expiry, true
}

// Ongoing returns true if restore-object is ongoing.
func (r restoreObjStatus) Ongoing() bool {

  let summary = "Restore variable tensors";
  let description = [{
    This is the MLRT version of tf.IfrtRestoreVariableOp.

    This Op is similar to a combination of RestoreV2 and AssignVariable Op, but
    this Op's execution is asynchronous.

    This Op is specific to MLRT runtime and is not a stable interface for
    serialization.

Leonardo Sarra <******@****.***> 1718116194 +0200