is DescriptorWithContainerSource -> {
                        // Deserialized member
                        return getFakeContainingKtModule(containingDeclaration)
                    }
                    is LazyJavaPackageFragment -> {
                        // Deserialized top-level
                        (containingDeclaration.source as KotlinJvmBinarySourceElement).binaryClass.containingLibrary

  if (!object_graph->ParseFromString(*object_graph_string)) {
    return absl::Status(
        absl::StatusCode::kFailedPrecondition,
        "SavedModel checkpoint object graph could not be deserialized.");
  }
  return absl::OkStatus();
}

}  // namespace

absl::Status SavedModelV2Bundle::Load(const std::string& export_dir,
                                      SavedModelV2Bundle* const bundle) {

	if err != nil {
		t.Fatal(err)
	}
	t.Log("serialized size:", buf.Len(), "bytes")
	var got dataUsageCache
	err = got.deserialize(&buf)
	if err != nil {
		t.Fatal(err)
	}
	if got.Info.LastUpdate.IsZero() {
		t.Error("lastupdate not set")
	}

	if !want.Info.LastUpdate.Equal(got.Info.LastUpdate) {
		t.Fatalf("deserialize LastUpdate mismatch\nwant: %+v\ngot:  %+v", want, got)
	}

            selectedVariants >> [v1, v2]
            repositoryName >> 'repoName'
        }

        when:
        def serialized = serialize(component)
        def result = deserialize(serialized)

        then:
        result.id == componentIdentifier
        result.selectionReason == ComponentSelectionReasons.requested()

         */
        public abstract byte getSerializerIndex();

        protected abstract void serialize(Encoder encoder, T value) throws Exception;

        protected abstract T deserialize(Decoder decoder) throws Exception;

        @Override
        public final void write(Encoder encoder, T value) throws Exception {
            encoder.writeByte(getSerializerIndex());

        withValidityAssertion { analysisSession.containingDeclarationProvider.getContainingFileSymbol(this) }

    /**
     * Returns containing JVM class name for [KaCallableSymbol]
     *
     *   even for deserialized callables! (which is useful to look up the containing facade in [PsiElement])
     *   for regular, non-local callables from source, it is a mere conversion of [ClassId] inside [CallableId]
     *

namespace testing {

// Returns a StructuredValue corresponding to the serialized InputSignature of a
// tf.function with 0 inputs
StructuredValue ZeroArgInputSignature();

// Returns a StructuredValue corresponding to the serialized InputSignature of a
// tf.function with 1 input
StructuredValue SingleArgInputSignature();

// Returns a StructuredValue corresponding to the serialized InputSignature of a
// tf.function with 3 inputs

      }
    }
  """
  target = stablehlo.get_current_version()
  artifact = stablehlo.serialize_portable_artifact(assembly, target)
  deserialized = stablehlo.deserialize_portable_artifact(artifact)
  rountrip = stablehlo.serialize_portable_artifact(deserialized, target)
  assert artifact == rountrip


if __name__ == "__main__":

 * limitations under the License.
 */
package com.google.common.collect;


/**
 * GWT emulation of {@link JdkBackedImmutableBiMap}. Never used, but must exist so that the client
 * is willing to deserialize maps that were this type on the server.
 */
@ElementTypesAreNonnullByDefault
class JdkBackedImmutableBiMap<K, V> extends RegularImmutableBiMap<K, V> {

  EXPECT_EQ(tensorflow::unwrap(var_handle0)->DeviceName(&status2), dev0_name);

  // Rename local device
  // This server def has the task index set to 0.
  string serialized = server_def.SerializeAsString();
  TFE_ContextSetServerDef(ctx, 0, serialized.data(), serialized.size(), status);
  EXPECT_EQ(TF_OK, TF_GetCode(status)) << TF_Message(status);

  const string dev1_name =